diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..da4c2aa --- /dev/null +++ b/.clang-format @@ -0,0 +1,9 @@ +BasedOnStyle: Google + +# Longitud máxima de las líneas. +ColumnLimit: 79 + +# Indentación. +IndentWidth: 4 +ContinuationIndentWidth: 4 +UseTab: Never \ No newline at end of file diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..ae99edb --- /dev/null +++ b/.editorconfig @@ -0,0 +1,14 @@ +# Definir este archivo como el archivo raíz o de nivel superior. +# (Debido a que se podrían crear otros archivos como este en subdirectorios) +root = true + +# Indentación de cuatro espacios. +[*] +indent_style = space +indent_size = 4 + +# Definir el carácter de fin de línea preferido (estilo Unix), así como si se +# desea insertar una línea vacía al final de un archivo. +[*] +end_of_line = lf +insert_final_newline = true \ No newline at end of file diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario.c" index dc97152..111da67 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario.c" @@ -2,8 +2,8 @@ // permite calcular si se cumple el patrón de que el número esté compuesto por // una serie de repeticiones del número 10, como 10101010. -#include #include +#include bool cumple_patron(long int entrada) { // Descomentar esto si se quiere ver @@ -25,7 +25,7 @@ bool cumple_patron(long int entrada) { if (entrada % 100 != entrada) { if (entrada % 100 != 10) { - return false; + return false; } else { cumple_patron(entrada / 100); } diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario2.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario2.c" index d6410fe..e51ac2f 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario2.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario2.c" @@ -2,8 +2,8 @@ // permite calcular si se cumple el patrón de que el número esté compuesto por // una cantidad de 0 que sea múltiplo de 3. -#include #include +#include bool cumple_patron(long int entrada, int cant_cero) { // Descomentar esto si se quiere ver @@ -35,17 +35,27 @@ int main() { long int numero2 = 1011011100; if (cumple_patron(numero, 0)) { - printf("El número %ld tiene una cantidad de 0s que es múltiplo de 3.\n", numero); + printf( + "El número %ld tiene una cantidad de 0s que es múltiplo de 3.\n", + numero); } else { - printf("El número %ld tiene una cantidad de 0s que NO es múltiplo de 3.\n", numero); + printf( + "El número %ld tiene una cantidad de 0s que NO es múltiplo de " + "3.\n", + numero); } printf("--------------------------------------------------\n"); if (cumple_patron(numero2, 0)) { - printf("El número %ld tiene una cantidad de 0s que es múltiplo de 3.\n", numero2); + printf( + "El número %ld tiene una cantidad de 0s que es múltiplo de 3.\n", + numero2); } else { - printf("El número %ld tiene una cantidad de 0s que NO es múltiplo de 3.\n", numero2); + printf( + "El número %ld tiene una cantidad de 0s que NO es múltiplo de " + "3.\n", + numero2); } return 0; diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario3.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario3.c" index 95dac43..071ddfd 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario3.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/binario3.c" @@ -2,8 +2,8 @@ // permite calcular si se cumple el patrón de que el número esté compuesto por // una cantidad impar de 1. -#include #include +#include bool cumple_patron(long int entrada, int cant_uno) { // Descomentar esto si se quiere ver diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/num_perf.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/num_perf.c" index d202729..23c7fe4 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/num_perf.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/num_perf.c" @@ -2,8 +2,8 @@ // número es perfecto. Es decir, si la suma de sus divisores, sin contar a sí // mismo, es igual al número en cuestión. -#include #include +#include bool es_perfecto(int num, int divisor, int suma_div) { if (divisor != 0) { diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/prom_rec.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/prom_rec.c" index c876393..7fb2b5f 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/prom_rec.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/Extra/prom_rec.c" @@ -1,12 +1,15 @@ -// Este algoritmo presenta una función recursiva que permite calcular un promedio -// para un arreglo de 26 elementos. A continuación, adjunto el seudocódigo que -// pensé para plantear la función recursiva: +// Este algoritmo presenta una función recursiva que permite calcular un +// promedio para un arreglo de 26 elementos. A continuación, adjunto el +// seudocódigo que pensé para plantear la función recursiva: /* -Función Promedio(arr: arreglo de [1..26] de entero, num_jug: entero, suma_edades: entero): entero ES +Función Promedio( + arr: arreglo de [1..26] de entero, + num_jug: entero, + suma_edades: entero +): entero ES Si num_jug < 27 Entonces Promedio := Promedio(arr, num_jug + 1, suma_edades + arr[num_jug]) - Contrario Promedio := suma_edades DIV (num_jug - 1) Fin Si @@ -28,14 +31,14 @@ int promedio(int arr[26], int num_jug, int suma_edades) { int main() { int edades[26]; int i, prom, suma_val; - + suma_val = 0; - + for (i = 0; i < 26; i++) { edades[i] = 25; suma_val += edades[i]; } - + prom = promedio(edades, 0, 0); printf("Valor de la variable suma_val: %d\n", suma_val); printf("Valor de la variable prom: %d", prom); diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12a.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12a.c" index 4b967e2..8357251 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12a.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12a.c" @@ -1,7 +1,7 @@ /* Generar un algoritmo que diga si un número es primo. */ -#include #include +#include int main(void) { int num_us; diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12b.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12b.c" index ceb6720..e46bac3 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12b.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-12b.c" @@ -1,7 +1,8 @@ -/* Generar un algoritmo que encuentre los primeros 50 números que sean primos. */ +/* Generar un algoritmo que encuentre los primeros 50 números que sean primos. + */ -#include #include +#include bool verificar_primo(int var_num) { bool es_primo = true; @@ -15,7 +16,7 @@ bool verificar_primo(int var_num) { if (es_primo) { return true; - } else { + } else { return false; } } diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-13.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-13.c" index 282f94c..0b7687b 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-13.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-13.c" @@ -65,10 +65,13 @@ int main(void) { printf("El número más pequeño es: %d\n", mas_peq); printf("Entre ellos se encuentra el número: %d\n", med); } else if (mas_gr == med && med != mas_peq) { - printf("¡El número más grande y el mediano coinciden! Valor: %d\n", mas_gr); + printf("¡El número más grande y el mediano coinciden! Valor: %d\n", + mas_gr); printf("El número más pequeño es: %d\n", mas_peq); } else if (mas_gr != med && med == mas_peq) { - printf("¡El número más pequeño y el mediano coinciden! Valor: %d\n", med); + printf( + "¡El número más pequeño y el mediano coinciden! Valor: %d\n", + med); printf("El número más grande es: %d\n", mas_gr); } } diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-3.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-3.c" index c2cd247..e93908e 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-3.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-3.c" @@ -49,7 +49,7 @@ int main() { scanf("%d", &y); printf("\n"); - switch(eleccion) { + switch (eleccion) { case 1: op_suma(x, y); break; diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-4b.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-4b.c" index 81ffd33..304b58d 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-4b.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-4b.c" @@ -13,7 +13,8 @@ int main(void) { scanf("%d", &num_us); // También se podría acomodar la expresión de la siguiente forma: - // (num_us % 2 == 0) ? printf("El número es par.\n") : printf("El número NO es par.\n"); + // (num_us % 2 == 0) ? printf("El número es par.\n") : printf("El número NO + // es par.\n"); (num_us % 2 == 0) ? printf("El número es par.\n") : printf("El número NO es par.\n"); diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-9.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-9.c" index cdc7fc9..cc92788 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-9.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G1/1-9.c" @@ -1,7 +1,7 @@ /* Generar un programa que determine cuál es el factorial de un número N dado, -utilizando solo las operaciones de multiplicación, suma y resta. El factorial se -compone por la multiplicación de todos los números desde 1 hasta N. Por ejemplo: -el factorial de 5 es 5 * 4 * 3 * 2 * 1. */ +utilizando solo las operaciones de multiplicación, suma y resta. El factorial +se compone por la multiplicación de todos los números desde 1 hasta N. Por +ejemplo: el factorial de 5 es 5 * 4 * 3 * 2 * 1. */ #include diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-1.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-1.c" index 117b36a..cd27f0b 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-1.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-1.c" @@ -4,10 +4,12 @@ pantalla. */ #include int main(void) { - int arr_ent[10], i; + const size_t arr_size = 10; + size_t i; + int arr_ent[arr_size]; - for (i = 0; i <= 9; i++) { - printf("Introduzca un número para la posición %d del arreglo: ", i); + for (i = 0; i < arr_size; i++) { + printf("Introduzca un número para la posición %zu del arreglo: ", i); scanf("%d", &arr_ent[i]); } @@ -15,8 +17,8 @@ int main(void) { printf("Valores cargados\n"); printf("================\n"); - for (i = 0; i <= 9; i++) { - printf("Valor de la posición %d del arreglo: %d\n", i, arr_ent[i]); + for (i = 0; i < arr_size; i++) { + printf("Valor de la posición %zu del arreglo: %d\n", i, arr_ent[i]); } return 0; diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-10.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-10.c" new file mode 100644 index 0000000..cf835d1 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-10.c" @@ -0,0 +1,38 @@ +/* Escribir un algoritmo donde se cargue un arreglo de enteros de diez +posiciones con números aleatorios y se solicite un entero al usuario, +devolviendo todas las posiciones donde se encuentra el valor ingresado +en el arreglo. */ + +#include + +#include "../functions.h" + +int main(void) { + const size_t arr_size = 10; + const int low_lim = -100, upp_lim = 100; + int arr[arr_size], num_us, cant_coincidencias = 0; + + printf("Introduzca un número a buscar en el arreglo: "); + scanf("%d", &num_us); + printf("\n"); + + cargar_arreglo_enteros(arr, arr_size, low_lim, upp_lim); + printf("Valores del arreglo: \n"); + mostrar_arreglo_enteros(arr, arr_size); + printf("\n"); + + for (size_t i = 0; i < arr_size; i++) { + if (arr[i] == num_us) { + printf("Número encontrado en la posición %zu del arreglo.\n", i); + cant_coincidencias += 1; + } + } + + if (cant_coincidencias == 0) { + printf( + "No se encontró el número introducido en el arreglo generado " + "aleatoriamente.\n"); + } + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-11.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-11.c" new file mode 100644 index 0000000..bbdb40d --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-11.c" @@ -0,0 +1,50 @@ +/* Escribir un algoritmo que cargue un arreglo de 100 elementos aleatoriamente, +lo ordene de menor a mayor y muestre por pantalla el arreglo ordenado. */ + +/* NOTA: esta resolución no utiliza la función dispoible en functions.h para +ordenar arreglos con la finalidad de no hacer "trampa". */ + +#include + +#include "../functions.h" + +void ordenar_arreglo_insercion(int* arr, size_t arr_size) { + /* Esto ordena de menor a mayor, como pide la consigna. */ + /* Se utiliza el método de inserción directa, aunque no exactamente + como se lo enseña en AED, ya que en esta resolución la primera parte + de la condición en el "while" es "ind_menor >= 0", mientras que + apegarse al algoritmo mostrando en la materia implicaría que se + escriba "ind_menor > 0", pero así nunca se va a procesar el + primer elemento del arreglo. */ + int resg_arr, ind_menor; + + for (size_t i = 0; i < arr_size; i++) { + resg_arr = arr[i]; + ind_menor = i - 1; + + while (ind_menor >= 0 && resg_arr < arr[ind_menor]) { + arr[ind_menor + 1] = arr[ind_menor]; + ind_menor = ind_menor - 1; + } + + arr[ind_menor + 1] = resg_arr; + } +} + +int main(void) { + const size_t arr_size = 100; + const int low_lim = -100, upp_lim = 100; + int arr[arr_size]; + + cargar_arreglo_enteros(arr, arr_size, low_lim, upp_lim); + printf("Valores del arreglo: \n"); + mostrar_arreglo_enteros(arr, arr_size); + printf("\n"); + + ordenar_arreglo_insercion(arr, arr_size); + printf("Valores del arreglo ordenado: \n"); + mostrar_arreglo_enteros(arr, arr_size); + printf("\n"); + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-12.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-12.c" new file mode 100644 index 0000000..67e7d06 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-12.c" @@ -0,0 +1,51 @@ +/* Escribir un algoritmo que, dado un arreglo ordenado de menor a mayor de +cien enteros, realice una búsqueda binaria para encontrar un valor ingresado +por el usuario. */ + +#include + +#include "../functions.h" + +void busqueda_binaria(int* arr, size_t arr_size, int val_us) { + // No olvidarse de que las posiciones de arreglos empiezan + // con 0 acá, por eso la resta en la asignación inicial de + // "der". + int izq = 0, der = (arr_size - 1), centro = (izq + der) / 2; + + while (izq < der && arr[centro] != val_us) { + if (arr[centro] > val_us) { + der = centro - 1; + } else { + izq = centro + 1; + } + centro = (izq + der) / 2; + } + + if (arr[centro] == val_us) { + printf("Se encontró el elemento buscado en la posición %d.\n", centro); + } else { + printf("No se pudo encontrar el elemento buscado.\n"); + } +} + +int main(void) { + const size_t arr_size = 100; + const int low_lim = -100, upp_lim = 100; + int arr[arr_size], val_us; + + printf("Arreglo original: \n"); + cargar_arreglo_enteros(arr, arr_size, low_lim, upp_lim); + mostrar_arreglo_enteros(arr, arr_size); + printf("\n"); + + printf("Arreglo ordenado: \n"); + ordenar_arreglo_enteros(arr, arr_size); + mostrar_arreglo_enteros(arr, arr_size); + printf("\n"); + + printf("Introduzca el valor que se desea encontrar: "); + scanf("%d", &val_us); + busqueda_binaria(arr, arr_size, val_us); + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-13.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-13.c" new file mode 100644 index 0000000..7922757 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-13.c" @@ -0,0 +1,32 @@ +/* Escribir un algoritmo que ponga en cero todos los elementos de una matriz +5x5 y la muestre por pantalla. */ + +#include + +void cargar_matriz_ceros(size_t hor_size, size_t ver_size, + int arr[hor_size][ver_size]) { + for (size_t i = 0; i < hor_size; i++) { + for (size_t j = 0; j < ver_size; j++) { + arr[i][j] = 0; + } + } +} + +void mostrar_matriz(size_t hor_size, size_t ver_size, + int arr[hor_size][ver_size]) { + for (size_t i = 0; i < hor_size; i++) { + for (size_t j = 0; j < ver_size; j++) { + printf("%d", arr[i][j]); + } + printf("\n"); + } +} + +int main(void) { + const size_t hor_size = 5, ver_size = 5; + int arr[hor_size][ver_size]; + + cargar_matriz_ceros(hor_size, ver_size, arr); + mostrar_matriz(hor_size, ver_size, arr); + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-2.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-2.c" index 506a7f9..3f7db93 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-2.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-2.c" @@ -3,26 +3,28 @@ y otra para mostrarlo por pantalla. */ #include -void cargar_arreglo(int var_arr[10]) { - for (int i = 0; i <= 9; i++) { - printf("Introduzca un número para la posición %d del arreglo: ", i); - scanf("%d", &var_arr[i]); +void cargar_arreglo(int* arr, size_t arr_size) { + for (size_t i = 0; i < arr_size; i++) { + printf("Introduzca un número para la posición %zu del arreglo: ", i); + scanf("%d", &arr[i]); } } -void mostrar_arreglo(int var_arr[10]) { +void mostrar_arreglo(int* arr, size_t arr_size) { printf("\n"); printf("Valores cargados\n"); printf("================\n"); - for (int i = 0; i <= 9; i++) { - printf("Valor de la posición %d del arreglo: %d\n", i, var_arr[i]); + for (size_t i = 0; i < arr_size; i++) { + printf("Valor de la posición %zu del arreglo: %d\n", i, arr[i]); } } int main(void) { - int arr_ent[10]; - cargar_arreglo(arr_ent); - mostrar_arreglo(arr_ent); + const size_t arr_size = 10; + int arr_ent[arr_size]; + + cargar_arreglo(arr_ent, arr_size); + mostrar_arreglo(arr_ent, arr_size); return 0; } diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-3.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-3.c" index a5c6bfd..fd23c09 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-3.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-3.c" @@ -1,39 +1,18 @@ /* Modificar la función de carga creada en el ejercicio anterior para cargar el arreglo de forma aleatoria, con números que vayan del 1 al 100. */ -// Material para este ejercicio: -// https://stackoverflow.com/questions/822323/how-to-generate-a-random-int-in-c -// https://www.cs.yale.edu/homes/aspnes/pinewiki/C(2f)Randomization.html +// NOTA: la función de carga modificada es cargar_arreglo_enteros() y se +// encuentra definida en la librería "functions.h" para que pueda ser utilizada +// por otras funciones también. -#include -#include -#include - -void cargar_arreglo(int var_arr[10]) { - // Preparación (seeding) del generador de números aleatorios. - srand(time(NULL)); - - for (int i = 0; i <= 9; i++) { - // La cota superior del intervalo de números deseados es 101, entonces - // el número 100 queda incluido en dicho intervalo. Se le suma 1 al - // resultado final en caso de que el número generado por rand() sea 0, - // ya que la cota inferior del intervalo de números deseados es 1. - var_arr[i] = (rand() % 101) + 1; - } -} - -void mostrar_arreglo(int var_arr[10]) { - printf("Valores cargados\n"); - printf("================\n"); - - for (int i = 0; i <= 9; i++) { - printf("Valor de la posición %d del arreglo: %d\n", i, var_arr[i]); - } -} +#include "../functions.h" int main(void) { - int arr_ent[10]; - cargar_arreglo(arr_ent); - mostrar_arreglo(arr_ent); + const size_t arr_size = 10; + const int low_lim = 1, upp_lim = 100; + int arr_ent[arr_size]; + + cargar_arreglo_enteros(arr_ent, arr_size, low_lim, upp_lim); + mostrar_arreglo_enteros(arr_ent, arr_size); return 0; } diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-4.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-4.c" index eae11a0..b9fe4e5 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-4.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-4.c" @@ -3,29 +3,28 @@ el otro. */ #include -void copiar_arreglo(int var_a[10], int var_b[10]) { - for (int i = 0; i <= 9; i++) { - var_b[i] = var_a[i]; +#include "../functions.h" + +void copiar_arreglo(int* empty_array, int* array_with_contents, + size_t shared_arr_size) { + for (size_t i = 0; i < shared_arr_size; i++) { + empty_array[i] = array_with_contents[i]; } } int main(void) { - int arr_a[10], arr_b[10], i; - - for (i = 0; i <= 9; i++) { - printf("Introduzca un número para la posición %d del arreglo A: ", i); - scanf("%d", &arr_a[i]); - } + const size_t arr_size = 10; + const int low_lim = 0, upp_lim = 10; + int arr_a[arr_size], arr_b[arr_size]; - copiar_arreglo(arr_a, arr_b); + cargar_arreglo_enteros(arr_a, arr_size, low_lim, upp_lim); + copiar_arreglo(arr_b, arr_a, arr_size); + printf("Valores del arreglo A (cargado por defecto):\n"); + mostrar_arreglo_enteros(arr_a, arr_size); printf("\n"); - printf("Valores del arreglo B\n"); - printf("=====================\n"); - - for (i = 0; i <= 9; i++) { - printf("Valor de la posición %d del arreglo: %d\n", i, arr_b[i]); - } + printf("Valores del arreglo B (rellenado con los valores de A):\n"); + mostrar_arreglo_enteros(arr_b, arr_size); return 0; } diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-5.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-5.c" index e848c24..d153a70 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-5.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-5.c" @@ -1,39 +1,26 @@ /* Crear una función que sume los elementos de un arreglo de enteros de 10 posiciones y devuelva el resultado. */ -// NOTA: para cargar el arreglo opté por reutilizar la mecánica de carga de -// valores al azar que utilicé en el ejercicio 2-3, con una cota superior en el -// número 101, con la diferencia de que esta vez no le sumo nada al número -// entregado por el generador. - #include -#include -#include -void cargar_arreglo(int var_arr[10]) { - // Preparación (seeding) del generador de números aleatorios. - srand(time(NULL)); +#include "../functions.h" - for (int i = 0; i <= 9; i++) { - // La cota superior del intervalo de números deseados es 101, entonces - // el número 100 queda incluido en dicho intervalo. - var_arr[i] = (rand() % 101) + 1; - } -} - -int sumar_elementos(int var_arr[10]) { +int sumar_elementos(int* arr, size_t arr_size) { int suma = 0; - for (int i = 0; i <= 9; i++) { - printf("Posición del arreglo: %d|Número: %d\n", i, var_arr[i]); - suma += var_arr[i]; + for (size_t i = 0; i < arr_size; i++) { + printf("Posición del arreglo: %zu|Número: %d\n", i, arr[i]); + suma += arr[i]; } return suma; } int main(void) { - int arr_ent[10], suma_elem = 0; - cargar_arreglo(arr_ent); - suma_elem = sumar_elementos(arr_ent); + const size_t arr_size = 10; + const int low_lim = 0, upp_lim = 100; + int arr_ent[arr_size], suma_elem; + + cargar_arreglo_enteros(arr_ent, arr_size, low_lim, upp_lim); + suma_elem = sumar_elementos(arr_ent, arr_size); printf("Valor de la suma de los elementos del arreglo: %d\n", suma_elem); return 0; } diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-6.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-6.c" new file mode 100644 index 0000000..424959a --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-6.c" @@ -0,0 +1,48 @@ +/* Crear una función que verifique si un arreglo de 10 posiciones se encuentra +ordenado de forma ascendente o no, la cual debe devolver 1 (verdadero) si el +arreglo está ordenado y 0 (falso) en caso de no estarlo. */ + +#include + +#include "../functions.h" + +int verificar_orden_arreglo(int* arr, size_t arr_size) { + for (size_t i = 1; i < arr_size; i++) { + if (arr[i] < arr[i - 1]) { + return 0; + } + } + return 1; +} + +void evaluar_resultado(int result) { + if (result == 1) { + printf("(el arreglo está ordenado)\n"); + } else { + printf("(el arreglo está desordenado)\n"); + } +} + +int main(void) { + const size_t arr_size = 10; + const int low_lim = 0, upp_lim = 100; + int arr_ent[arr_size], result; + + cargar_arreglo_enteros(arr_ent, arr_size, low_lim, upp_lim); + printf("Arreglo generado por la computadora: \n"); + mostrar_arreglo_enteros(arr_ent, arr_size); + + result = verificar_orden_arreglo(arr_ent, arr_size); + printf("\nEl resultado del análisis es: %d ", result); + evaluar_resultado(result); + + ordenar_arreglo_enteros(arr_ent, arr_size); + result = verificar_orden_arreglo(arr_ent, arr_size); + printf("\n"); + printf("Arreglo reordenado: \n"); + mostrar_arreglo_enteros(arr_ent, arr_size); + printf("\nEl resultado del análisis es: %d ", result); + evaluar_resultado(result); + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-7.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-7.c" new file mode 100644 index 0000000..f75defe --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-7.c" @@ -0,0 +1,61 @@ +/* Crear una función que compare dos arreglos de 10 posiciones y verifique si +ambos son iguales. Al igual que en el caso anterior, la función debe devolver +1 (verdadero) si los arreglos son iguales y 0 (falso) en caso de que no lo +sean. */ + +#include + +#include "../functions.h" + +int verificar_igualdad_arreglos(int* prim_arr, int* seg_arr, + size_t shared_arr_size) { + for (size_t i = 0; i < shared_arr_size; i++) { + if (prim_arr[i] != seg_arr[i]) { + return 0; + } + } + return 1; +} + +void evaluar_resultado(int result) { + if (result == 1) { + printf("(los arreglos son iguales)\n"); + } else { + printf("(los arreglos son distintos)\n"); + } +} + +int main(void) { + const size_t arr_size = 10; + const int low_lim = 0, upp_lim = 100; + int prim_arr[arr_size], seg_arr[arr_size], result; + + // Es posible que en plataformas distintas de Windows y Linux + // los arreglos cargados tengan exactamente los mismos valores, + // debido a que generar números aleatorios cuando se usa el + // tiempo como semilla no es el mejor método para dicho fin. + cargar_arreglo_enteros(prim_arr, arr_size, low_lim, upp_lim); + cargar_arreglo_enteros(seg_arr, arr_size, low_lim, upp_lim); + + printf("Primer arreglo generado por la computadora: \n"); + mostrar_arreglo_enteros(prim_arr, arr_size); + printf("\nSegundo arreglo generado por la computadora: \n"); + mostrar_arreglo_enteros(seg_arr, arr_size); + + result = verificar_igualdad_arreglos(prim_arr, seg_arr, arr_size); + printf("\nEl resultado de la comparación es: %d ", result); + evaluar_resultado(result); + + for (size_t i = 0; i < arr_size; i++) { + seg_arr[i] = prim_arr[i]; + } + + printf("\nRedefinición del segundo arreglo: \n"); + mostrar_arreglo_enteros(seg_arr, arr_size); + + result = verificar_igualdad_arreglos(prim_arr, seg_arr, arr_size); + printf("\nEl resultado de la comparación es: %d ", result); + evaluar_resultado(result); + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-8.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-8.c" new file mode 100644 index 0000000..83c7369 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-8.c" @@ -0,0 +1,72 @@ +/* Crear una función que, dado un arreglo A de enteros de 20 posiciones y otro +arreglo B de enteros de 5 posiciones, devuelva en que posición del arreglo A se +encuentra el arreglo B. En caso de que el arreglo A no se encuentre dentro de B +devolver -1. */ + +#include + +#include "../functions.h" + +void cargar_arreglo_secuencial(int* arr, size_t arr_size, int start_value) { + for (size_t i = 0; i < arr_size; i++) { + arr[i] = start_value + i; + } +} + +int controlar_presencia_arreglo(int* large_arr, size_t large_arr_size, + int* short_arr, size_t short_arr_size) { + size_t j; + + // Únicamente se revisa hasta la posición (A - B), porque si ya + // no coinciden ahí los arreglos, luego no alcanzan los espacios + // para que coincidan por completo. + for (size_t i = 0; i <= (large_arr_size - short_arr_size); i++) { + for (j = 0; j < short_arr_size; j++) { + if (short_arr[j] != large_arr[i + j]) { + break; + } + } + + if (j == short_arr_size) { + // Type cast para ser coherente con los valores que se + // trabajan y devuelven. "size_t" es un "unsigned int" + // utilizado para trabajar con índices, mientras que + // "int" tiene signo. + // + // Si bien el compilador realiza una conversión de + // tipos automática, es preferible ser explícito + // sobre lo que está sucediendo acá. + return (int)i; + } + } + + return -1; +} + +int main(void) { + const size_t arrA_size = 20, arrB_size = 5; + const int start_valueA = 0, start_valueB = 9; + int arrA[arrA_size], arrB[arrB_size]; + + cargar_arreglo_secuencial(arrA, arrA_size, start_valueA); + cargar_arreglo_secuencial(arrB, arrB_size, start_valueB); + + printf("Primer arreglo: \n"); + mostrar_arreglo_enteros(arrA, arrA_size); + printf("\n"); + printf("Segundo arreglo: \n"); + mostrar_arreglo_enteros(arrB, arrB_size); + printf("\n"); + + int result = controlar_presencia_arreglo(arrA, arrA_size, arrB, arrB_size); + if (result == -1) { + printf("El segundo arreglo no se encuentra dentro del primero."); + } else { + printf( + "El segundo arreglo se encuentra dentro del primero a partir de " + "la posición %d.\n", + result); + } + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9a.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9a.c" new file mode 100644 index 0000000..36c6091 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9a.c" @@ -0,0 +1,39 @@ +/* Crear una función que, dado un arreglo de enteros de 10 posiciones, escriba +por pantalla cual es el mayor número, cual es el menor y cual es el promedio. +*/ + +#include +#include + +#include "../functions.h" + +int main(void) { + const size_t arr_size = 10; + const int low_lim = 0, upp_lim = 100; + int arr[arr_size], may_num = INT_MIN, men_num = INT_MAX; + double prom = 0; + + cargar_arreglo_enteros(arr, arr_size, low_lim, upp_lim); + printf("Valores del arreglo: \n"); + mostrar_arreglo_enteros(arr, arr_size); + printf("\n"); + + for (size_t i = 0; i < arr_size; i++) { + prom += arr[i]; + + if (arr[i] > may_num) { + may_num = arr[i]; + } + + if (arr[i] < men_num) { + men_num = arr[i]; + } + } + + prom = prom / 10.0; + printf("El número más grande en el arreglo es: %d\n", may_num); + printf("El número más pequeño en el arreglo es: %d\n", men_num); + printf("El promedio de los números en el arreglo es: %.2f\n", prom); + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9b.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9b.c" new file mode 100644 index 0000000..e5f3472 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9b.c" @@ -0,0 +1,53 @@ +/* Crear una función que, dado un arreglo de enteros de 10 posiciones, escriba +por pantalla cual es el mayor número, cual es el menor y cual es el promedio. + +Obtener además las posiciones donde se encuentran las primeras ocurrencias del +mayor y menor elemento del arreglo. */ + +#include +#include + +#include "../functions.h" + +int main(void) { + const size_t arr_size = 10; + const int low_lim = 0, upp_lim = 100; + int arr[arr_size], may_num = INT_MIN, men_num = INT_MAX; + int prim_pos_may = 0, prim_pos_men = 0; + double prom = 0; + + cargar_arreglo_enteros(arr, arr_size, low_lim, upp_lim); + printf("Valores del arreglo: \n"); + mostrar_arreglo_enteros(arr, arr_size); + printf("\n"); + + for (size_t i = 0; i < arr_size; i++) { + prom += arr[i]; + + if (arr[i] > may_num) { + may_num = arr[i]; + prim_pos_may = i; + } + + if (arr[i] < men_num) { + men_num = arr[i]; + prim_pos_men = i; + } + } + + prom = prom / 10.0; + printf("El número más grande en el arreglo es: %d\n", may_num); + printf("El número más pequeño en el arreglo es: %d\n", men_num); + printf("El promedio de los números en el arreglo es: %.2f\n", prom); + printf("\n"); + printf( + "El número más grande del arreglo se encuentra por primera vez en la " + "posición %d.\n", + prim_pos_may); + printf( + "El número más pequeño del arreglo se encuentra por primera vez en la " + "posición %d.\n", + prim_pos_men); + + return 0; +} diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/functions.h" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/functions.h" new file mode 100644 index 0000000..8dd36d7 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/functions.h" @@ -0,0 +1,129 @@ +// Material para esta librería: +// https://stackoverflow.com/questions/822323/how-to-generate-a-random-int-in-c +// https://www.cs.yale.edu/homes/aspnes/pinewiki/C(2f)Randomization.html +// https://stackoverflow.com/questions/54202670 +// https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/rand-s?view=msvc-170 +// https://man7.org/linux/man-pages/man2/getrandom.2.html + +#ifndef FUNCTIONS_H +#define FUNCTIONS_H + +// clang-format off +#ifdef _WIN32 + // Macro específico de Windows que debe ser definido + // antes de importar la librería "stdlib". + #define _CRT_RAND_S +#endif + +#include +#include +#include +#include + +#ifdef __linux__ + #include +#elif !defined(_WIN32) + #include +#endif +// clang-format on + +int get_random_number(bool get_negative_num) { + int num; + + // clang-format off + #ifdef _WIN32 + rand_s(&num); + #elif __linux__ + getrandom(&num, sizeof(num), 0); + #else + srand(time(NULL)); + num = rand(); + #endif + // clang-format on + + if (!get_negative_num && num < 0) { + // En caso de que se obtenga un número negativo pero + // no se pueda trabajar con números negativos se aplica + // una máscara binaria para obtener el valor absoluto + // del número. + // + // La conversión se realiza de esta manera y no con + // la función abs() de "stdlib.h" porque abs() no es + // capaz de devolver correctamente el valor absoluto + // de INT_MIN (-2.147.483.648), que es uno de los + // valores que se podrían obtener tratando de llenar + // 32 bits de espacio con valores al azar. + // + // Dicha operación resulta exactamente en el mismo + // valor o en conducta indefinida, dependiendo del + // compilador utilizado, porque los 32 bits del + // tipo "int" no alcanzan para representar una + // versión positiva del valor INT_MIN. + // + // Esta máscara es un valor en hexadecimal donde + // todos los bits, salvo el más significativo, + // tienen valor 1, de manera que se conserva el + // valor de todos los bits correspondientes al + // valor de la variable "num", salvo el del bit + // del signo. + num = num & 0x7FFFFFFF; + } + + return num; +} + +void cargar_arreglo_enteros(int* arr, size_t arr_size, int low_lim, + int upp_lim) { + assert(low_lim != upp_lim); + + // Cuando se llame a get_random_number() no se permitirá + // que se generen números negativos porque de lo contrario, + // si el límite inferior es menor a 0, es muy posible que + // los valores negativos finales que se cargan en el + // arreglo de entrada estén por debajo del límite inferior + // debido a la fórmula utilizada para que los números + // devueltos por get_random_number() estén dentro de un + // rango específico. + bool allow_negative_values = false; + + for (size_t i = 0; i < arr_size; i++) { + // Explicación de la fórmula utilizada: + // 1. (upp_lim - low_lim + 1) determina la cantidad de números + // al azar que se pueden obtener. + // 2. get_random_number() % (cant. posibles números) permite obtener + // un número entre 0 y la cantidad de posibles números a obtener. + // 3. Al resultado del módulo se le suma el valor del límite + // inferior para que por lo menos sea igual a dicho número. + arr[i] = (get_random_number(allow_negative_values) % + (upp_lim - low_lim + 1)) + + low_lim; + } +} + +void ordenar_arreglo_enteros(int* arr, size_t arr_size) { + if (arr_size < 2) { + // Los arreglos vacíos o de un elemento no + // necesitan ser ordenados. + return; + } + + for (size_t i = 1; i < arr_size; i++) { + size_t ind_act = i; + int resguardo = arr[ind_act]; + + while (ind_act > 0 && arr[ind_act - 1] > resguardo) { + arr[ind_act] = arr[ind_act - 1]; + ind_act--; + } + + arr[ind_act] = resguardo; + } +} + +void mostrar_arreglo_enteros(int* arr, size_t arr_size) { + for (size_t i = 0; i < arr_size; i++) { + printf("Valor de la posición %zu del arreglo: %d\n", i, arr[i]); + } +} + +#endif diff --git a/clang-format.py b/clang-format.py new file mode 100644 index 0000000..6ca80bc --- /dev/null +++ b/clang-format.py @@ -0,0 +1,9 @@ +import subprocess + +from pathlib import Path + +if __name__ == "__main__": + walk_dir = Path.cwd() + for ext in ["*.c", "*.cpp", "*.h", "*.hpp"]: + for file in walk_dir.rglob(ext): + subprocess.run(["clang-format", "-i", f"{file}"])