From 764066a5a94f40eba680b50cf53772e5252a7ba7 Mon Sep 17 00:00:00 2001 From: JNmeca Date: Wed, 16 Nov 2022 18:28:01 -0400 Subject: [PATCH] 16/11/2022 ; 6:30 PM --- .../Programas/Programa 5.1/Programa 5.1.c | 27 +++++ .../Programas/Programa 5.10/Programa 5.10.c | 64 +++++++++++ .../Programas/Programa 5.11/Programa 5.11.c | 63 +++++++++++ .../Programas/Programa 5.12/Programa 5.12.c | 62 +++++++++++ .../Programas/Programa 5.13/Programa 5.13.c | 66 ++++++++++++ .../Programas/Programa 5.14/Programa 5.14.c | 102 ++++++++++++++++++ .../Programas/Programa 5.15/Programa 5.15.c | 21 ++++ .../Programas/Programa 5.16/Programa 5.16.c | 21 ++++ .../Programas/Programa 5.17/Programa 5.17.c | 28 +++++ .../Programas/Programa 5.2/Programa 5.2.c | 25 +++++ .../Programas/Programa 5.3/Programa 5.3.c | 56 ++++++++++ .../Programas/Programa 5.4/Programa 5.4.c | 53 +++++++++ .../Programas/Programa 5.5/Programa 5.5.c | 65 +++++++++++ .../Programas/Programa 5.6/Programa 5.6.c | 43 ++++++++ .../Programas/Programa 5.7/Programa 5.7.c | 76 +++++++++++++ .../Programas/Programa 5.8/Programa 5.8.c | 46 ++++++++ .../Programas/Programa 5.9/Programa 5.9.c | 60 +++++++++++ 17 files changed, 878 insertions(+) create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.1/Programa 5.1.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.10/Programa 5.10.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.11/Programa 5.11.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.12/Programa 5.12.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.13/Programa 5.13.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.14/Programa 5.14.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.15/Programa 5.15.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.16/Programa 5.16.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.17/Programa 5.17.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.2/Programa 5.2.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.3/Programa 5.3.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.4/Programa 5.4.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.5/Programa 5.5.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.6/Programa 5.6.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.7/Programa 5.7.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.8/Programa 5.8.c create mode 100644 5. Arreglos unidimensionales/Programas/Programa 5.9/Programa 5.9.c diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.1/Programa 5.1.c b/5. Arreglos unidimensionales/Programas/Programa 5.1/Programa 5.1.c new file mode 100644 index 0000000..f70c2ad --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.1/Programa 5.1.c @@ -0,0 +1,27 @@ +#include + +/* Cuenta-números. +El programa, al recibir como datos un arreglo unidimensional de tipo +➥entero y un número entero, determina cuántas veces se encuentra el +➥número en el arreglo. */ + +void main(void) +{ + int I = 0, NUM = 0, CUE = 0; + int ARRE[100]; /* Declaración del arreglo */ + + for (I = 0; I < 100; I++) + { + printf("Ingrese el elemento %i del arreglo: ", I + 1); + scanf("%i", &ARRE[I]); /* Lectura -asignación— del arreglo */ + } + + printf("\n\nIngrese el numero que se va a buscar en el arreglo: "); + scanf("%i", &NUM); + + for (I = 0; I < 100; I++) + if (ARRE[I] == NUM) /* Comparación del número con los elementos del arreglo */ + CUE++; + + printf("\n\nEl %d se encuentra %i veces en el arreglo", NUM, CUE); +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.10/Programa 5.10.c b/5. Arreglos unidimensionales/Programas/Programa 5.10/Programa 5.10.c new file mode 100644 index 0000000..997e518 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.10/Programa 5.10.c @@ -0,0 +1,64 @@ +#include + +/* Búsqueda secuencial en arreglos ordenados en forma creciente. */ + +#define MAX 100 + +void Lectura(int, int); /* Prototipos de funciones. */ +int Busca(int*, int, int); + +void main(void) +{ + int RES, ELE, TAM, VEC[MAX]; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + } while (TAM > MAX || TAM < 1); + /* Se verifica que el tamaño del arreglo sea correcto. */ + Lectura(VEC, TAM); + + printf("\nIngrese el elemento a buscar: "); + scanf("%d", &ELE); + + RES = Busca(VEC, TAM, ELE); /* Se llama a la función que busca en el arreglo. */ + + if (RES) + /* Si RES tiene un valor verdadero —diferente de 0—, se escribe la + ➥posición en la que se encontró al elemento. */ + printf("\nEl elemento se encuentra en la posicion: %d", RES); + else + printf("\nEl elemento no se encuentra en el arreglo"); +} + +void Lectura(int A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%d", &A[I]); + } +} + +int Busca(int A[], int T, int E) +/* Esta función se utiliza para localizar el elemento E en el arreglo unidimensional A. +Si se encuentra, la función regresa la posición correspondiente. En caso contrario regresa 0. */ +{ + int RES, I = 0, BAN = 0; + while ((I < T) && (E >= A[I]) && !BAN) + /* Observa que se incorpora una nueva condición. */ + if (A[I] == E) + BAN++; + else + I++; + if (BAN) + RES = I + 1; + /* Se asigna I+1 dado que las posiciones en el arreglo comienzan des + de cero. */ + else + RES = BAN; + return (RES); +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.11/Programa 5.11.c b/5. Arreglos unidimensionales/Programas/Programa 5.11/Programa 5.11.c new file mode 100644 index 0000000..0eb05b1 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.11/Programa 5.11.c @@ -0,0 +1,63 @@ +#include + +/* Búsqueda binaria. */ + +#define MAX 100 + +void Lectura(int, int); /* Prototipos de funciones. */ +int Binaria(int*, int, int); + +void main(void) +{ + int RES, ELE, TAM, VEC[MAX]; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%i", &TAM); + } while (TAM > MAX || TAM < 1); /* Se verifica que el tamaño del arreglo sea + ➥correcto. */ + Lectura(VEC, TAM); + + printf("\nIngrese el elemento a buscar: "); + scanf("%d", &ELE); + + RES = Binaria(VEC, TAM, ELE); /* Se llama a la función que busca en el + ➥arreglo. */ + if (RES) + /* Si RES tiene un valor verdadero —diferente de 0—, se escribe la + ➥posición en la que se encontró el elemento. */ + printf("\nEl elemento se encuentra en la posicion: %d", RES); + else + printf("\nEl elemento no se encuentra en el arreglo"); +} + +void Lectura(int A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%d", &A[I]); + } +} + +int Binaria(int A[], int T, int E) +/* Esta función se utiliza para realizar una búsqueda binaria del elemento E en el arreglo unidimensional A de T elementos. Si se +➥encuentra el elemento, la función regresa la posición correspondiente. +➥En caso contrario, regresa 0. */ { + int ELE, IZQ = 0, CEN, DER = T - 1, BAN = 0; + while ((IZQ <= DER) && (!BAN)) + { + CEN = (IZQ + DER) / 2; + if (E == A[CEN]) + BAN = CEN; + else + if (E > A[CEN]) + IZQ = CEN + 1; + else + DER = CEN - 1; + } + return (BAN); +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.12/Programa 5.12.c b/5. Arreglos unidimensionales/Programas/Programa 5.12/Programa 5.12.c new file mode 100644 index 0000000..31b35c4 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.12/Programa 5.12.c @@ -0,0 +1,62 @@ +#include + +/* Ordenación por inserción directa. */ + +#define MAX 100 + +void Lectura(int*, int); +void Ordena(int*, int); /* Prototipos de funciones. */ +void Imprime(int*, int); + +void main(void) +{ + int TAM, VEC[MAX]; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + + } while (TAM > MAX || TAM < 1); /* Se verifica que el tamaño del arreglo sea + ➥correcto. */ + + Lectura(VEC, TAM); + Ordena(VEC, TAM); + Imprime(VEC, TAM); +} + +void Lectura(int A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%d", &A[I]); + } +} + +void Imprime(int A[], int T) +/* Esta función se utiliza para escribir un arreglo unidimensional +➥ordenado de T elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + printf("\nA[%d]: %d", I, A[I]); +} void Ordena(int A[], int T) +/* La función Ordena utiliza el método de inserción directa para ordenar +➥los elementos del arreglo unidimensional A. */ +{ + int AUX, L, I; + for (I = 1; I < T; I++) + { + AUX = A[I]; + L = I - 1; + while ((L >= 0) && (AUX < A[L])) + { + A[L + 1] = A[L]; + L--; + } + A[L + 1] = AUX; + } +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.13/Programa 5.13.c b/5. Arreglos unidimensionales/Programas/Programa 5.13/Programa 5.13.c new file mode 100644 index 0000000..7c97294 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.13/Programa 5.13.c @@ -0,0 +1,66 @@ +#include + +/* Ordenación por selección directa. */ + +#define MAX 100 + +void Lectura(int*, int); +void Ordena(int*, int); /* Prototipos de funciones. */ +void Imprime(int*, int); + +void main(void) +{ + int TAM, VEC[MAX]; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + } while (TAM > MAX || TAM < 1); /* Se verifica que el tamaño del arreglo sea + ➥correcto. */ + + Lectura(VEC, TAM); + Ordena(VEC, TAM); + Imprime(VEC, TAM); +} + +void Lectura(int A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%d", &A[I]); + } +} + +void Imprime(int A[], int T) +/* Esta función se utiliza para escribir un arreglo unidimensional +➥ordenado de T elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + printf("\nA[%d]: %d", I, A[I]); +} + +void Ordena(int A[], int T) +/* La función Ordena utiliza el método de selección directa para ordenar +➥los elementos del arreglo unidimensional A. */ +{ + int I, J, MEN, L; + for (I = 0; I < (T - 1); I++) + { + MEN = A[I]; + L = I; + for (J = (I + 1); J < T; J++) + if (A[J] < MEN) + { + MEN = A[J]; + L = J; + } + A[L] = A[I]; + A[I] = MEN; + } +} + diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.14/Programa 5.14.c b/5. Arreglos unidimensionales/Programas/Programa 5.14/Programa 5.14.c new file mode 100644 index 0000000..3444675 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.14/Programa 5.14.c @@ -0,0 +1,102 @@ +#include +#include + +/* Estadístico. +El programa, al recibir como dato un arreglo unidimensional de enteros +➥que contiene calificaciones, calcula la media, la varianza, la +➥desviación estándar y la moda. */ #define MAX 100 + +void Lectura(int*, int); +void Frecuencia(int*, int, int*); + +float Media(int*, int); +float Varianza(int*, int, float); /* Prototipos de funciones. */ +float Desviacion(float); + +int Moda(int*, int); + +void main(void) +{ + int TAM, MOD, ALU[MAX], FRE[11] = { 0 }; + float MED, VAR, DES; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + + } while (TAM > MAX || TAM < 1); + /* Se verifica que el tamaño del arreglo sea correcto. */ + + Lectura(ALU, TAM); + MED = Media(ALU, TAM); + VAR = Varianza(ALU, TAM, MED); + DES = Desviacion(VAR); + + Frecuencia(ALU, TAM, FRE); + MOD = Moda(FRE, 11); + + printf("\nMedia: %.2f", MED); + printf("\nVarianza: %.2f", VAR); + printf("\nDesviacion: %.2f", DES); + printf("\nModa: %d", MOD); +} + +void Lectura(int A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%d", &A[I]); + } +} + +float Media(int A[], int T) +/* Esta función se utiliza para calcular la media. */ +{ + int I; + float SUM = 0.0; + for (I = 0; I < T; I++) + SUM += A[I]; + return (SUM / T); +} + +float Varianza(int A[], int T, float M) +/* Esta función se utiliza para calcular la varianza. */ +{ + int I; + float SUM = 0.0; + for (I = 0; I < T; I++) + SUM += pow((A[I] - M), 2); + return (SUM / T); +} + +float Desviacion(float V) +/* Esta función se utiliza para calcular la desviación estándar. */ +{ + return (sqrt(V)); +} + +void Frecuencia(int A[], int P, int B[]) +/* Esta función se utiliza para calcular la frecuencia de calificaciones. +*/ +{ + int I; + for (I = 0; I < P; I++) + B[A[I]]++; +} + +int Moda(int A[], int T) +/* Esta función se utiliza para calcular la moda. */ +{ + int I, MOD = 0, VAL = A[0]; + for (I = 1; I < T; I++) + if (MOD < A[I]) + { + MOD = I; + VAL = A[I]; + } + return (MOD); +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.15/Programa 5.15.c b/5. Arreglos unidimensionales/Programas/Programa 5.15/Programa 5.15.c new file mode 100644 index 0000000..f699c45 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.15/Programa 5.15.c @@ -0,0 +1,21 @@ +#include + +/* Apuntadores y arreglos */ + +void main(void) +{ + int X = 5, Y = 8, V[5] = { 1, 3, 5, 7, 9 }; + int* AY, * AX; + AY = &Y; + X = *AY; + *AY = V[3] + V[2]; + + printf("\nX = %d Y = %d V[0] = %d V[1] = %d V[2] = %d V[3] = %d V[4] = %d", X, Y, V[0], V[1], V[2], V[3], V[4]); + + AX = &V[V[0] * V[1]]; + X = *AX; + Y = *AX * V[1]; + *AX = *AY - 3; + + printf("\nX = %d Y = %d V[0] = %d V[1] = %d V[2] = %d V[3] = %d V[4] = %d", X, Y, V[0], V[1], V[2], V[3], V[4]); +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.16/Programa 5.16.c b/5. Arreglos unidimensionales/Programas/Programa 5.16/Programa 5.16.c new file mode 100644 index 0000000..6b3003f --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.16/Programa 5.16.c @@ -0,0 +1,21 @@ +#include + +/* Apuntadores y arreglos */ + +void main(void) +{ + int V1[4] = { 2, 3, 4, 7 }, V2[4] = { 6 }; + int* AX, * AY; + + AX = &V1[3]; + AY = &V2[2]; + V1[V2[0] - V1[2]] = *AY; + *AY = *AX - V1[0]; + + printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]); + V2[1] = ++ * AX; + V2[3] = (*AY)++; + *AX += 2; + + printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]); +} diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.17/Programa 5.17.c b/5. Arreglos unidimensionales/Programas/Programa 5.17/Programa 5.17.c new file mode 100644 index 0000000..621bcfc --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.17/Programa 5.17.c @@ -0,0 +1,28 @@ +#include + +/* Apuntadores y arreglos */ + +void main(void) +{ + int V1[4] = { 1, 3, 5, 7 }, V2[4] = { 2,4 }; + int* AX, * AY; + + AX = &V1[2]; + AY = &V2[2]; + + V2[2] = *(AX + 1); + V2[3] = *AX; + + AX = AX + 1; + V1[0] = *AX; + + printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]); + + V1[2] = *AY; + V1[1] = --*AY; + + AX = AX + 1; + V1[3] = *AX; + + printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]); +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.2/Programa 5.2.c b/5. Arreglos unidimensionales/Programas/Programa 5.2/Programa 5.2.c new file mode 100644 index 0000000..22a346e --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.2/Programa 5.2.c @@ -0,0 +1,25 @@ +#include + +/* Elección. +El programa almacena los votos emitidos en una elección en la que hubo cinco +➥candidatos e imprime el total de votos que obtuvo cada uno de ellos. */ + +void main(void) +{ + int ELE[5] = { 0 }; /* Declaración del arreglo entero ELE de cinco elementos. Todos sus elementos se inicializan en 0. */ + int I = 0, VOT = 0; + printf("Ingresa el primer voto(0 - Para terminar): "); + scanf("%i", &VOT); + while (VOT) + { + if ((VOT > 0) && (VOT < 6)) /* Se verifica que el voto sea correcto. */ + ELE[VOT - 1]++; /* Los votos se almacenan en el arreglo. Recuerda que la primera posición del arreglo es 0, por esa razón a la variable VOT se le descuenta 1. Los votos del primer candidato se almacenan en la posición 0. */ + else + printf("\nEl voto ingresado es incorrecto.\n"); + printf("Ingresa el siguiente voto(0 - Para terminar) : "); + scanf("%i", &VOT); + } + printf("\n\nResultados de la Eleccion\n"); + for (I = 0; I <= 4; I++) + printf("\nCandidato %d: %d", I + 1, ELE[I]); +} \ No newline at end of file diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.3/Programa 5.3.c b/5. Arreglos unidimensionales/Programas/Programa 5.3/Programa 5.3.c new file mode 100644 index 0000000..48da5f7 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.3/Programa 5.3.c @@ -0,0 +1,56 @@ +#include + +/* Apuntadores, variables y valores. */ + +void main(void) +{ + int X = 3, Y = 7, Z[5] = { 2, 4, 6, 8, 10 }; + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + int* IX; /* IX representa un apuntador a un entero. */ + IX = &X; /* IX apunta a X. IX tiene la dirección de X. */ + Y = *IX; /* Y toma el valor de X, ahora vale 3. */ + *IX = 1; /* X se modifica, ahora vale 1. */ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + IX = &Z[2]; /* IX apunta al tercer elemento del arreglo Z. */ + Y = *IX; /* Y toma el valor de Z[2], ahora vale 6. */ + *IX = 15; /* Z[2] se modifica, ahora vale 15. */ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + X = *IX + 5; /* X se modifica, ahora vale Z[2] + 5 = 20. Recuerda que *IX contiene el valor de Z[2]. */ + *IX = *IX - 5; /* Z[2] se modifica, ahora vale 10. */ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + ++* IX; /* Z[2] se modifica, se incrementa en 1. Z[2] ahora vale 11. */ + *IX += 1; /* Z[2] se vuelve a modificar, ahora vale 12. */ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + X = *(IX + 1); /* X se modifica. El apuntador IX accede temporalmente a Z[3], por lo tanto X toma este valor (8). Observa que IX no se reasigna */ + Y = *IX; /* Y se modifica, toma el valor de Z[2] (12). */ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + IX = IX + 1; /* IX se modifica. Observa la forma de mover el apuntador. + Ahora IX apunta al cuarto elemento de Z (Z[3]). */ + Y = *IX; /* Y se modifica, ahora vale Z[3] (8). */ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] =% d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + IX = IX + 4; /* IX se modifica. Observa que el apuntador se mueve +➥4 posiciones y cae en una dirección afuera del arreglo. Esto ocasionará un +➥error. */ Y = *IX; /* Y se modifica, toma el valor (basura) de una celda +➥incorrecta. Es un error que no señala el compilador del lenguaje C. */ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); + + IX = &X; /* IX apunta a la variable entera X. */ + IX = IX + 1; /* IX se mueve una posición y cae en una celda incorrecta. */ + X = *IX; /* X toma el valor (basura) de la celda a la que apunta IX.*/ + + printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]); +} diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.4/Programa 5.4.c b/5. Arreglos unidimensionales/Programas/Programa 5.4/Programa 5.4.c new file mode 100644 index 0000000..deb1ea7 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.4/Programa 5.4.c @@ -0,0 +1,53 @@ +#include + +/* Producto de vectores. +* +El programa calcula el producto de dos vectores y almacena el resultado en otro arreglo unidimensional. */ + +#define MAX 10 /* Se define una constante para el tamaño de los arreglos. */ + +void Lectura(int VEC[], int T); +void Imprime(int VEC[], int T); /* Prototipos de funciones. */ +void Producto(int* X, int* Y, int* Z, int T); /* Observa que en los parámetros, para indicar que lo que se recibe es un arreglo, se puede escribir VEC[] o *VEC. */ + +void main(void) +{ + int VE1[MAX], VE2[MAX], VE3[MAX]; + /* Se declaran tres arreglos de tipo entero de 10 elementos. */ + Lectura(VE1, MAX); + /* Se llama a la función Lectura. Observa que el paso del arreglo a la función + ➥es por referencia. Sólo se debe incluir el nombre del arreglo. */ + Lectura(VE2, MAX); + Producto(VE1, VE2, VE3, MAX); + /* Se llama a la función Producto. Se pasan los nombres de los tres arreglos. */ + printf("\nProducto de los Vectores"); + Imprime(VE3, MAX); +} +void Lectura(int VEC[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + int I; + printf("\n"); + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%d", &VEC[I]); + } +} +void Imprime(int VEC[], int T) +/* La función Imprime se utiliza para imprimir un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + printf("\nVEC[%d]: %d", I + 1, VEC[I]); +} +void Producto(int* X, int* Y, int* Z, int T) +/* Esta función se utiliza para calcular el producto de dos arreglos +➥unidimensionales de T elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + Z[I] = X[I] * Y[I]; +} diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.5/Programa 5.5.c b/5. Arreglos unidimensionales/Programas/Programa 5.5/Programa 5.5.c new file mode 100644 index 0000000..28ba7c3 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.5/Programa 5.5.c @@ -0,0 +1,65 @@ +#include + +/* Frecuencia de calificaciones. +El programa, al recibir como datos las calificaciones de un grupo de 50 +➥alumnos, obtiene la frecuencia de cada una de las calificaciones y además +➥escribe cuál es la frecuencia más alta. */ + +#define TAM 50 + +void Lectura(int*, int); +void Frecuencia(int, int, int, int); /* Prototipos de funciones. */ +void Impresion(int*, int); +void Mayor(int*, int); + +void main(void) +{ + int CAL[TAM], FRE[6] = { 0 }; /* Declaración de los arreglos. */ + + Lectura(CAL, TAM); /* Se llama a la función Lectura. */ + Frecuencia(CAL, TAM, FRE, 6); + /* Se llama a la función Frecuencia, se pasan ambos arreglos. */ + + printf("\nFrecuencia de Calificaciones\n"); + + Impresion(FRE, 6); + Mayor(FRE, 6); +} +void Lectura(int VEC[], int T) +/* La función Lectura se utiliza para leer el arreglo de calificaciones. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese la calificacion - 0:5 - del alumno %d: ", I + 1); + scanf("%d", &VEC[I]); + } + +} +void Impresion(int VEC[], int T) +/* La función Impresión se utiliza para imprimir el arreglo de frecuencias. */ +{ + int I; + for (I = 0; I < T; I++) + printf("\nVEC[%d]: %d", I, VEC[I]); +} +void Frecuencia(int A[], int P, int B[], int T) +/* Esta función calcula la frecuencia de calificaciones. */ +{ + int I; + for (I = 0; I < P; I++) + if ((A[I] >= 0) && (A[I] < 6)) /* Se valida que la calificación sea correcta. */ + B[A[I]]++; /* Observa la forma de almacenar e incrementar las frecuencias. */ +} +void Mayor(int* X, int T) +/* Esta función obtiene la primera ocurrencia de la frecuencia más alta. */ +{ + int I, MFRE = 0, MVAL = X[0]; + for (I = 1; I < T; I++) + if (MVAL < X[I]) + { + MFRE = I; + MVAL = X[I]; + } + printf("\n\nMayor frecuencia de calificaciones: %d \tValor: %d", MFRE, MVAL); +} diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.6/Programa 5.6.c b/5. Arreglos unidimensionales/Programas/Programa 5.6/Programa 5.6.c new file mode 100644 index 0000000..3bf397a --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.6/Programa 5.6.c @@ -0,0 +1,43 @@ +#include +#include + +/* Suma-cuadrados. +El programa calcula la suma del cuadrado de los elementos de un arreglounidimensional de 100 elementos de tipo real. */ + +#define MAX 100 +/* MAX se utiliza para reservar el espacio máximo que podrá ocupar el arreglo. */ + +void Lectura(float*, int); /* Prototipos de funciones. */ +double Suma(float*, int); + +void main(void) +{ + float VEC[MAX]; + double RES; + Lectura(VEC, MAX); + RES = Suma(VEC, MAX); + /* Se llama a la función Suma y se almacena el resultado en la variable RES. */ + + printf("\n\nSuma del arreglo: %.2lf", RES); +} +void Lectura(float A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo real. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%f", &A[I]); + } +} +double Suma(float A[], int T) +/* La función Suma se utiliza para calcular la suma del cuadrado de los +➥componentes de un arreglo unidimensional de T elementos de tipo real. */ +{ + int I; + double AUX = 0.0; + for (I = 0; I < T; I++) + AUX += pow(A[I], 2); + return(AUX); +} diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.7/Programa 5.7.c b/5. Arreglos unidimensionales/Programas/Programa 5.7/Programa 5.7.c new file mode 100644 index 0000000..5a4d935 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.7/Programa 5.7.c @@ -0,0 +1,76 @@ +#include + +/* Arreglo sin elementos repetidos. +El programa, al recibir como dato un arreglo unidimensional desordenado de N +➥elementos, obtiene como salida ese mismo arreglo pero sin los elementos +➥repetidos. */ + +void Lectura(int*, int); /* Prototipos de funciones. */ +void Imprime(int*, int); +void Elimina(int*, int*); + +/* Observa que en el prototipo de Elimina, el segundo parámetro es por +➥referencia. Esto, porque el tamaño del arreglo puede disminuir. */ + +void main(void) +{ + int TAM, ARRE[100]; + + /* Se escribe un do-while para verificar que el tamaño del arreglo que se + ➥ingresa sea correcto. */ + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + } while (TAM > 100 || TAM < 1); + + Lectura(ARRE, TAM); + Elimina(ARRE, &TAM); + /* Observa que el tamaño del arreglo se pasa por referencia.*/ + Imprime(ARRE, TAM); +} + +void Lectura(int A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T +➥elementos de tipo entero. */ +{ + printf("\n"); + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%i", &A[I]); + } +} + +void Imprime(int A[], int T) +/* La función Imprime se utiliza para escribir un arreglo unidimensional, sin +➥repeticiones, de T elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + printf("\nA[%d]: %d", I, A[I]); +} + +void Elimina(int A[], int* T) +/* Esta función se utiliza para eliminar los elementos repetidos de un arreglo +➥unidimensional de T elementos de tipo entero. */ +{ + int I = 0, K, L; + while (I < (*T - 1)) + { + K = I + 1; + while (K <= (*T - 1)) + { + if (A[I] == A[K]) + { + for (L = K; L < (*T - 1); L++) + A[L] = A[L + 1]; + *T = *T - 1; + } + else + K++; + } + I++; + } +} diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.8/Programa 5.8.c b/5. Arreglos unidimensionales/Programas/Programa 5.8/Programa 5.8.c new file mode 100644 index 0000000..d026b2b --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.8/Programa 5.8.c @@ -0,0 +1,46 @@ +#include +/* Primos. +El programa almacena en un arreglo unidimensional los primeros 100 números primos. */ + +#define TAM 100 + +void Imprime(int, int); /* Prototipos de funciones. */ +void Primo(int, int*); + +void main(void) +{ + int P[TAM] = { 1,2 }; + int FLA, J = 2, PRI = 3; + while (J <= TAM) + { + FLA = 1; + Primo(PRI, &FLA); /* Se llama a la función que determina si PRI es primo. */ + if (FLA) /* Si FLA es 1, entonces PRI es primo. */ + { + P[J] = PRI; + J++; + } + PRI += 2; + } + Imprime(P, TAM); +} + +void Primo(int A, int* B) +/* Esta función determina si A es primo, en cuyo caso el valor de *B no se altera. */ +{ + int DI = 3; + while (*B && (DI < (A / 2))) + { + if ((A % DI) == 0) + *B = 0; + DI++; + } +} + +void Imprime(int Primos[], int T) +/* Esta función imprime el arreglo unidimensional de números primos. */ +{ + int I; + for (I = 0; I < T; I++) + printf("\nPrimos[%i]: %d", I, Primos[I]); +} diff --git a/5. Arreglos unidimensionales/Programas/Programa 5.9/Programa 5.9.c b/5. Arreglos unidimensionales/Programas/Programa 5.9/Programa 5.9.c new file mode 100644 index 0000000..a2fd1b4 --- /dev/null +++ b/5. Arreglos unidimensionales/Programas/Programa 5.9/Programa 5.9.c @@ -0,0 +1,60 @@ +#include + +/* Búsqueda secuencial en arreglos desordenados. */ + +#define MAX 100 + +void Lectura(int, int); /* Prototipos de funciones. */ +int Busca(int*, int, int); + +void main(void) +{ + int RES, ELE, TAM, VEC[MAX]; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &TAM); + + } while (TAM > MAX || TAM < 1); /* Se verifica que el tamaño del arreglo sea correcto. */ + + Lectura(VEC, TAM); + + printf("\nIngrese el elemento a buscar: "); + scanf("%d", &ELE); + + RES = Busca(VEC, TAM, ELE); /* Se llama a la función que busca en el arreglo. */ + if (RES) + /* Si RES tiene un valor verdadero —diferente de 0—, se escribe la posición en la que se encontró el elemento. */ + printf("\nEl elemento se encuentra en la posicion %d", RES); + else + printf("\nEl elemento no se encuentra en el arreglo"); +} + +void Lectura(int A[], int T) +/* La función Lectura se utiliza para leer un arreglo unidimensional de T elementos de tipo entero. */ +{ + int I; + for (I = 0; I < T; I++) + { + printf("Ingrese el elemento %d: ", I + 1); + scanf("%d", &A[I]); + } +} + +int Busca(int A[], int T, int K) +/* Esta función localiza en el arreglo un elemento determinado. Si el elemento es encontrado, regresa la posición correspondiente. En caso contrario, regresa 0. */ +{ + int I = 0, BAN = 0, RES; + while (I < T && !BAN) + if (A[I] == K) + BAN++; + else + I++; + if (BAN) + RES = I + 1; + /* Se asigna I+1 dado que las posiciones en el arreglo comienzan desde cero. */ + else + RES = BAN; + return (RES); +} +