INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE CÓMPUTO

INGENIERIA EN INTELIGENCIA ARTIFICIAL

FUNDAMENTOS DE PROGRAMACIÓN
PRÁCTICA 5:
ARREGLOS Y CADENAS
DOCENTE:
ANA BELEM JUÁREZ MÉNDEZ

INTEGRANTES:
RAMÍREZ REYES IRENE
VALDEZ GARCÍA PAOLA SARAÍ

GRUPO:
1BV1

JUEVES 1 DE JUNIO DE 2023

Aplicar los conocimientos de arreglos y cadenas en el lenguaje C.

Arreglos
Un arreglo es una colección de posiciones de almacenamiento de datos, donde
cada una tiene el mismo tipo de dato y el mismo nombre. Cada posición de
almacenamiento en un arreglo es llamada un elemento del arreglo.

¿Cómo crear un arreglo?

Para declarar o crear un arreglo utilizaremos la siguiente forma:

• Escribe el tipo de dato que almacenará el arreglo.

• Escribe el nombre del arreglo.
• Entre corchetes, escribe la cantidad de elementos
de ese tipo que se almacenarán.

Hemos declarado también una variable i porque para manejar arreglos

utilizaremos ciclos, y se necesita la variable i como contadora.
 Cadenas
Una cadena de caracteres (también llamada string) es una secuencia ordenada de
símbolos cuya extensión se define de acuerdo con los objetivos de un proyecto.
Una cadena de caracteres en C o en otro lenguaje de programación, se utiliza para
almacenar textos, números o símbolos y mostrarle al usuario un mensaje dentro
de un sistema informático.
Es la manera correcta de atribuirle un sentido a palabras dentro de una frase con
la que una persona podría interactuar a través de una interfaz digital.

¿Cómo hacer una cadena en C?

Para declarar una cadena de caracteres en C, la línea de código debe estar

compuesta por 3 componentes:

1) La variable char.
2) El nombre identificador.
3) La cantidad de caracteres que irán dentro del arreglo.

Por lo tanto, la primera línea del código debe escribirse de la siguiente manera:

• char Nombre [20];

Entradas: longitud(reales)
Salidas: numerosinvertidos(reales)

Función invertir(numeros[], longitud):

Para i de 0 a longitud / 2:
temp = numeros[i]
numeros[i] = numeros[longitud - 1 - i]
numeros[longitud - 1 - i] = temp

Función principal:
longitud = 10
números[longitud]
Para i de 0 a longitud:
números[i] = generar número aleatorio entre 0 y 100

Escribe "El conjunto original de números es:"

Para i de 0 a longitud:
Escribe números[i] con 2 decimales

invertir(numeros, longitud)

Escribe "El conjunto invertido de números es:"

Para i de 0 a longitud:
Escribe números[i] con 2
Fin función principal

Para este ejercicio utilizamos una función en la cual nos invertía los 10
números que generamos previamente al azar, la función utiliza un bucle for
para intercambiar los elementos del arreglo. Comienza desde el primer
elemento y lo intercambia con el último, luego avanza al segundo y lo
intercambia con el penúltimo, y así sucesivamente hasta llegar al centro del
arreglo y para generar los números usamos la formula números[i] = 0 +
((float)rand() / RAND_MAX) * (100 - 0), la cual ya habíamos trabajado en
clase solo modificamos para que funcionara de la manera que
necesitábamos.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void invertir(float numeros[], int longitud) {

int i;
for (i = 0; i < longitud / 2; i++) {
float temp = numeros[i];
numeros[i] = numeros[longitud - 1 - i];
numeros[longitud - 1 - i] = temp;
}
}
int main() {
int longitud = 10;
float numeros[longitud];
int i;
srand(time(NULL));
for (i = 0; i < longitud; i++) {
numeros[i] = 0 + ((float)rand() / RAND_MAX) * (100 - 0);
}
printf("EL conjunto original de numeros es:\n");
for (i = 0; i < longitud; i++) {
printf("%.2f ", numeros[i]);
}
invertir(numeros, longitud);
printf("\nEl conjunto invertido de numeros es:\n");
for (i = 0; i < longitud; i++) {
printf("%.2f ", numeros[i]);
}
return 0;
}
Constantes:
NUM_LANZAMIENTOS = 3000
NUM_CARAS = 6

Arreglo de enteros frecuencia[NUM_CARAS]=0

srand(time(NULL))

Por cada lanzamiento en el rango de 0 a NUM_LANZAMIENTOS:

resultado = generar numero aleatorio entre 0 y NUM_CARAS - 1
Incrementar el valor de frecuencia[resultado] en 1

Imprimir "Cara del dado\tFrecuencia\tPorcentaje"

Por cada cara en el rango de 0 a NUM_CARAS:
porcentaje = (frecuencia[cara] / NUM_LANZAMIENTOS) * 100
Imprimir cara + 1, frecuencia[cara], porcentaje con dos decimales
Para resolver este ejercicio, declaramos un arreglo de tamaño 6 para almacenar
las frecuencias de cada cara del dado, inicializamos todas las posiciones del arreglo
en 0 y establecimos el número de lanzamientos que requerimos y usamos
srand(time(NULL)) para obtener números aleatorios. También usamos el bucle for
para simular los lanzamientos del dado y actualizar las frecuencias y generar un
número aleatorio correspondiente a las caras del dado. Imprimimos los resultados
(cara del dado, frecuencia y porcentaje) recorriendo el arreglo.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NUM_LANZAMIENTOS 3000

#define NUM_CARAS 6

int main() {
int frecuencia[NUM_CARAS] = {0};
srand(time(NULL));
for (int i = 0; i < NUM_LANZAMIENTOS; i++) {
int resultado = rand() % NUM_CARAS;
frecuencia[resultado]++;
}
printf("Cara del dado\tFrecuencia\tPorcentaje\n");
for (int i = 0; i < NUM_CARAS; i++) {
float porcentaje = (float)frecuencia[i] / NUM_LANZAMIENTOS * 100;
printf("%d\t\t%d\t\t%.2f%%\n", i + 1, frecuencia[i], porcentaje);
}
return 0;
}
Entradas: NumeroAleatorio(enteros), NUM_TIENDAS(enteros)
Salidas: promedio(reales),menosVendidos(enteros),
chocolatesVendidos(enteros), TmenosVendidos(enteros)

Función generarNumeroAleatorio(min, max)

Devolver min + rand() % (max - min + 1)
Fin Función
Procedimiento MostrarNumdeChocolates(arreglo[], tamano)
Escribe "Cada tienda vendió:"
Para i = 0 hasta tamano - 1
Escribe "Tienda " + (i + 1) + ": " + arreglo[i] + " chocolates
vendidos"
Fin Para
 Escribe "\n"
Fin Procedimiento
Función calcularPromedio(arreglo[], tamano)
total = 0
Para i = 0 hasta tamano - 1
total = total + arreglo[i]
Fin Para
Devolver total / tamano
Fin Función
Función encontrarTmenosVendidos(arreglo[], tamano)
TmenosVendidos = 0
maxChocolatesNoVendidos = 0
Para i = 0 hasta tamano - 1
chocolatesNoVendidos = CHOCOLATES_POR_TIENDA - arreglo[i]
Si chocolatesNoVendidos > maxChocolatesNoVendidos
TmenosVendidos = i + 1
maxChocolatesNoVendidos = chocolatesNoVendidos
Fin Si
Fin Para
Devolver TmenosVendidos
Fin Función
Procedimiento mostrarMensaje(arreglo[], tamano)
Escribe "Cuándo debes surtir a cada tienda:"
Para i = 0 hasta tamano - 1
chocolatesVendidos = arreglo[i]
Si chocolatesVendidos >= 0 y chocolatesVendidos <= 39
Escribe "Tienda ", (i + 1) ": SURTIR EN DOS SEMANAS"
Sino si chocolatesVendidos >= 40 y chocolatesVendidos <= 100
Escribe "Tienda ", (i + 1)": SURTIR PRONTO"
Sino
Escribe "Tienda ", (i + 1)": Cantidad de chocolates vendidos
inválida"
Fin Si
Fin Para
Escribe "\n"
Fin Procedimiento
Procedimiento principal()
srand(time(NULL))

Definir NUM_TIENDAS como 30

Definir CHOCOLATES_POR_TIENDA como 100
Definir chocolatesVendidos[NUM_TIENDAS]
Para i = 0 hasta NUM_TIENDAS - 1
chocolatesVendidos[i] = generarNumeroAleatorio(0,
CHOCOLATES_POR_TIENDA)
 Fin Para
MostrarNumdeChocolates(chocolatesVendidos, NUM_TIENDAS)
promedio = calcularPromedio(chocolatesVendidos, NUM_TIENDAS)
Escribe "Promedio de chocolates vendidos: ", promedio
TmenosVendidos = encontrarTmenosVendidos(chocolatesVendidos,
NUM_TIENDAS)
maxChocolatesNoVendidos = CHOCOLATES_POR_TIENDA -
chocolatesVendidos[TmenosVendidos - 1]
Escribe "Tienda con menos chocolates vendidos: Tienda ", TmenosVendidos
Escribe "Cantidad de chocolates que no se vendieron: ", maxChocolates
Fin Procedimiento principal

Para este programa nos ayudamos de funciones, la primera función nos ayudó a
generar números aleatorios que representan el número de ventas, la segunda nos
ayudó a imprimir las ventas por tienda, la tercera nos ayudó a calcular el promedio
de ventas de las 30 tiendas y las siguientes nos ayudaron a ver cuál tienda vendió
menos chocolates. Para estas funciones nos ayudamos de arreglos y ciclos, para
mostrar los mensajes de cuando hay que surtir nos ayudamos del comando if el
cual ya habíamos visto previamente. En este programa fue importante fijar muy
bien los parámetros y definir el número de tiendas y el tamaño del arreglo
(CHOCOLATES_POR_TIENDA), ya que estas constantes son la base para que el
programa funcione correctamente.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NUM_TIENDAS 30
#define CHOCOLATES_POR_TIENDA 100

int generarNumeroAleatorio(int min, int max) {

return min + rand() % (max - min + 1);
}
void MostrarNumdeChocolates(int arreglo[], int tamano) {
printf("Cada tienda vendio:\n");
for (int i = 0; i < tamano; i++) {
printf("Tienda %d: %d chocolates vendidos\n", i + 1, arreglo[i]);
}
printf("\n");
}
float calcularPromedio(int arreglo[], int tamano) {
int total = 0;
for (int i = 0; i < tamano; i++) {
total += arreglo[i];
}
return (float)total / tamano;
}
int encontrarTmenosVendidos(int arreglo[], int tamano) {
int TmenosVendidos = 0;
int maxChocolatesNoVendidos = 0;
for (int i = 0; i < tamano; i++) {
int chocolatesNoVendidos = CHOCOLATES_POR_TIENDA - arreglo[i];
if (chocolatesNoVendidos > maxChocolatesNoVendidos) {
TmenosVendidos = i + 1;
maxChocolatesNoVendidos = chocolatesNoVendidos;
}
}
return TmenosVendidos;
}
void mostrarMensaje(int arreglo[], int tamano) {
printf("Cuando debes surtir a cada tienda:\n");
for (int i = 0; i < tamano; i++) {
int chocolatesVendidos = arreglo[i];
if (chocolatesVendidos >= 0 && chocolatesVendidos <= 39) {
printf("Tienda %d: SURTIR EN DOS SEMANAS\n", i + 1);
} else if (chocolatesVendidos >= 40 && chocolatesVendidos <= 100) {
printf("Tienda %d: SURTIR PRONTO\n", i + 1);
} else {
printf("Tienda %d: Cantidad de chocolates vendidos inválida\n",
i + 1);
}
}
printf("\n");
}
int main() {
srand(time(NULL));
int chocolatesVendidos[NUM_TIENDAS];
for (int i = 0; i < NUM_TIENDAS; i++) {
 chocolatesVendidos[i] = generarNumeroAleatorio(0,
CHOCOLATES_POR_TIENDA);
}
MostrarNumdeChocolates(chocolatesVendidos, NUM_TIENDAS);
float promedio = calcularPromedio(chocolatesVendidos, NUM_TIENDAS);
printf("Promedio de chocolates vendidos: %.2f\n\n", promedio);

int TmenosVendidos = encontrarTmenosVendidos(chocolatesVendidos,

NUM_TIENDAS);
int maxChocolatesNoVendidos = CHOCOLATES_POR_TIENDA -
chocolatesVendidos[TmenosVendidos - 1];
printf("Tienda con menos chocolates vendidos: Tienda %d\n",
TmenosVendidos);
printf("Cantidad de chocolates que no se vendieron: %d\n\n",
maxChocolatesNoVendidos);
mostrarMensaje(chocolatesVendidos, NUM_TIENDAS);
return 0;
}
Entradas: palabra(caracteres)
Salidas: tamP(enteros)

Función Palindromo(palabra: arreglo de caracteres) -> entero

tamP = longitud(palabra)
i = 0
j = tamaP - 1
Mientras i < j hacer
Si palabra[i] != palabra[j] entonces
retornar 0
Fin Si
i = i + 1
j = j - 1
Fin Mientras
retornar 1
Fin Función
Función Principal()
palabra: arreglo de caracteres de tamaño 100
Escribe "Introduce una palabra: "
Lee palabra
tamP = longitud(palabra)
Escribe "La palabra tiene %d letras ", convertirAString(tamañoP)
Si Palindromo(palabra) entonces
Escribe "La palabra es un palíndromo."
Sino
Escribe "La palabra no es un palíndromo."
Fin Si

Para este ejercicio utilizamos una función llamada strlen que nos ayudó a contar
el número de letras que contenía la palabra que el usuario introdujo, también
usamos dos contadores para comparar las letras y saber si era una palabra
palíndroma o no, el primer contador (i) lo inicializamos en 0 y el segundo (j) lo
inicializamos con la cantidad de letras menos uno, esto nos permitió ir comparando
a través de un ciclo la primera y última letra sucesivamente hasta acabarlas, si eran
iguales indica que es una palabra palíndroma por lo cual imprimía el mensaje “La
palabra es un palíndromo” de lo contrario imprimía el mensaje “La palabra no es
un palíndromo.”.

#include <stdio.h>
#include <string.h>

int Palindromo(char palabra[]) {

int tamP= strlen(palabra);
int i, j;
for (i = 0, j = tamP - 1; i < j; i++, j--) {
if (palabra[i] != palabra[j]) {
return 0;
}
 }
return 1;
}
int main() {
char palabra[100];

printf("Introduce una palabra: ");

scanf("%s", palabra);

int tamP = strlen(palabra);

printf("La palabra tiene %d letras\n", tamP);
if (Palindromo(palabra)) {
printf("La palabra es un palindromo.\n");
} else {
printf("La palabra no es un palindromo.\n");
}
return 0;
}
Entrada: frase(char[]), i(entero), mayuscula(entero)
Salida: frase(char[])
char frase[200] //arreglo de tamaño 100
Escribe "Introduce una frase:"
fgets(frase, sizeof(frase), stdin) //Lee frase desde la entrada
usando fgets

int i=0
int mayuscula=1

Mientras frase[i] no sea nulo '\0' hacer

Si frase[i] es un espacio en blanco entonces
Asignar 1 a mayuscula
Sino
Si mayuscula es verdadero entonces
Convertir frase[i] a mayuscula usando toupper()
Asignar 0 a mayuscula
Sino
Convertir frase[i] a minuscula usando tolower()
Fin Si
Fin Si
Incrementar i en 1
Fin Mientras
Escribe "",frase
Fin

Declaramos una cadena de caracteres para almacenar la frase introducida por el

usuario de un tamaño máximo de 200 caracteres y posteriormente, le pedimos al
usuario que introduzca una frase. Usamos la función fgets para leer la frase
introducida por el usuario. La función sizeof(frase) la usamos para especificar el
tamaño máximo de caracteres a leer. Para convertir la primera letra de cada
palabra a mayúscula y las demás a minúscula recorrimos la cadena de caracteres
letra por letra. Si la letra actual era la primera letra de la frase o si la letra anterior
es un espacio en blanco, la convertimos a mayúscula utilizando la función toupper.
De lo contrario, la convertimos a minúscula utilizando la función tolower.

#include <stdio.h>
#include <ctype.h>

int main(){
char frase[200];
printf("Introduce una frase:\n\n");
fgets(frase, sizeof(frase), stdin);

int i=0;
int mayuscula=1;

while (frase[i] !='\0') {

if (isspace(frase[i])) {
mayuscula=1;
} else {
if (mayuscula) {
frase[i]=toupper(frase[i]);
mayuscula=0;
} else {
frase[i]=tolower(frase[i]);
}
}
i++;
}
printf("\n%s", frase);

return 0;
}
 • Ramírez Reyes Irene:

Comprendo que la práctica fue más desafiante, y en mi caso me estresé demasiado

debido a la necesidad de prestar atención a los parámetros utilizados en los
arreglos y ciclos, porque se me complican. Recurrí a conocimientos previos,
consulté algunos tutoriales en YouTube y páginas web para asegurarme de cumplir
con los requisitos de cada ejercicio. A pesar de los desafíos que enfrenté, considero
que esta práctica fue una oportunidad valiosa para expandir mis conocimientos y
desarrollar nuevas habilidades en programación. Estoy motivado para seguir
aprendiendo y superar cualquier obstáculo que se presente en el camino.

• Valdez García Paola Saraí:

Esta práctica si estuvo un poco más laboriosa ya que hay que poner mucha
atención en los parámetros que se les da tanto a los arreglos como a los ciclos,
tuve que recurrir a mis practicas pasadas y a algunos tutoriales en YouTube para
poder cumplir con las acciones requeridas en cada ejercicio, me cuesta un poco
de trabajo trabajar con arreglos y cadenas ya que casi no tengo práctica, aunque
creo que practicando un poco más dominaré el tema por completo.

https://drive.google.com/drive/folders/1umCCjW96rI2Y9IT1eJw3TS1oLyGND0Ot?
usp=sharing
 Cadena de caracteres en C: Paso a paso [2021]. (2021, 17 junio).

https://www.crehana.com. https://www.crehana.com/blog/transformacion-

digital/cadena-de-caracteres-c/

Binary Man. (2021, 3 octubre). Programación en C: STRINGS | Como contar las letras de

una palabra [Vídeo]. YouTube.

https://www.youtube.com/watch?v=3kxNNWJSzdQ

Función gets, fgets y puts - Programación en C. (s. f.). Solución ingenieril.

http://solucioningenieril.com/programacion_en_c/funcion_gets_fgets_y_puts

makigas: aprende a programar. (2020, 5 noviembre). Tutorial de C – 24. Archivos (4): leer

con fgets [Vídeo]. YouTube. https://www.youtube.com/watch?v=b-fAFEbZuvI

Naps. (2021, 28 noviembre). Ejemplos explicados de arreglos en lenguaje C -

Programación Básica. Naps Tecnología y educación.

https://naps.com.mx/blog/ejemplos-explicados-de-arreglos-en-c/

UnPuntoycoma. (2017, 30 noviembre). [Lenguaje C #3] Leer cadenas de texto con fgets.

[Vídeo]. YouTube. https://www.youtube.com/watch?v=JWiDnEbpE8E