From 4929ec251f7fe76e2b9ed767a4cd3795f62fe153 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 15 Jan 2026 18:23:25 -0300 Subject: [PATCH 01/24] =?UTF-8?q?Adici=C3=B3n=20de=20.clang-format=20(y=20?= =?UTF-8?q?un=20script)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit .clang-format es un archivo de configuración para clang-format, un formateador de código para C y C++ (así como para un par más de lenguajes). clang-format.py es un script que revisa todo el repositorio para encontrar y formatear los archivos de C y C++ presentes. Hago esto porque clang-format debe ejecutarse en un directorio donde ya haya archivos formateables, y no realiza búsquedas recursivas. --- .clang-format | 9 +++++++++ clang-format.py | 9 +++++++++ 2 files changed, 18 insertions(+) create mode 100644 .clang-format create mode 100644 clang-format.py 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/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}"]) From b397102f6c26ab0de94383d13cf333fdd6c2507d Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 15 Jan 2026 18:38:42 -0300 Subject: [PATCH 02/24] =?UTF-8?q?Adici=C3=B3n=20de=20.editorconfig?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Archivo que puede ser interpretado por muchos editores de texto para obtener las preferencias del usuario. Justamente, yo defino algunas acá. --- .editorconfig | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 .editorconfig diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..f3d6084 --- /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 = false \ No newline at end of file From af213dc198a87536938761c5cab38e07fc98e079 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 15 Jan 2026 18:41:29 -0300 Subject: [PATCH 03/24] [algoritmos] Formateo de ejercicios de C Formateados con clang-format. --- .../(X.2.2) Ejercicios de C/Extra/binario.c" | 4 ++-- .../(X.2.2) Ejercicios de C/Extra/binario2.c" | 20 ++++++++++++++----- .../(X.2.2) Ejercicios de C/Extra/binario3.c" | 2 +- .../(X.2.2) Ejercicios de C/Extra/num_perf.c" | 2 +- .../(X.2.2) Ejercicios de C/Extra/prom_rec.c" | 19 ++++++++++-------- .../(X.2.2) Ejercicios de C/G1/1-12a.c" | 2 +- .../(X.2.2) Ejercicios de C/G1/1-12b.c" | 7 ++++--- .../(X.2.2) Ejercicios de C/G1/1-13.c" | 7 +++++-- .../(X.2.2) Ejercicios de C/G1/1-3.c" | 2 +- .../(X.2.2) Ejercicios de C/G1/1-4b.c" | 3 ++- .../(X.2.2) Ejercicios de C/G1/1-9.c" | 6 +++--- 11 files changed, 46 insertions(+), 28 deletions(-) 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 From ffd87c4e99a454fe3e114575315e6e50074a18cb Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 15 Jan 2026 18:45:39 -0300 Subject: [PATCH 04/24] =?UTF-8?q?Actualizaci=C3=B3n=20de=20.editorconfig?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .editorconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.editorconfig b/.editorconfig index f3d6084..ae99edb 100644 --- a/.editorconfig +++ b/.editorconfig @@ -11,4 +11,4 @@ indent_size = 4 # desea insertar una línea vacía al final de un archivo. [*] end_of_line = lf -insert_final_newline = false \ No newline at end of file +insert_final_newline = true \ No newline at end of file From 5e50e39599fd7f4d960d35db14910eb277ebe417 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Mon, 19 Jan 2026 15:24:51 -0300 Subject: [PATCH 05/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=20l?= =?UTF-8?q?os=20ejercicios=20de=20C=20de=20la=20carpeta=20G2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A pesar de que el método no es del todo ortodoxo, creé una librería/cabecera con definiciones de funciones a compartir entre varios ejercicios. También cambié la manera de definir arreglos y funciones para trabajar con arreglos, utilizando técnicas que me parecen más correctas para trabajar, como definir el tamaño en una constante de tipo "size_t" que se puede utilizar luego como parámetro de una función para evitar el uso de números mágicos al llamar funciones. --- .../(X.2.2) Ejercicios de C/G2/2-1.c" | 12 +++--- .../(X.2.2) Ejercicios de C/G2/2-2.c" | 22 +++++----- .../(X.2.2) Ejercicios de C/G2/2-3.c" | 42 +++++-------------- .../(X.2.2) Ejercicios de C/G2/2-4.c" | 32 +++++++------- .../(X.2.2) Ejercicios de C/G2/2-5.c" | 36 ++++++---------- .../(X.2.2) Ejercicios de C/functions.h" | 39 +++++++++++++++++ 6 files changed, 97 insertions(+), 86 deletions(-) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/functions.h" 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-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..a831c19 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,19 @@ /* 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; + const int 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..84d92bc 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,29 @@ 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; + const int 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..9cce976 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,27 @@ /* 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; + const int 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/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..ca00785 --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/functions.h" @@ -0,0 +1,39 @@ +// 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 + +#ifndef FUNCTIONS_H +#define FUNCTIONS_H + +#include +#include +#include +#include + +void cargar_arreglo_enteros(int* arr, size_t arr_size, int low_lim, + int upp_lim) { + assert(low_lim != upp_lim); + + // Preparación (seeding) del generador de números aleatorios. + srand(time(NULL)); + + 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. rand() % (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] = (rand() % (upp_lim - low_lim + 1)) + low_lim; + } +} + +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 From 1590c9ae0a3a2a689c9f69705bbdd3cf10ad0436 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Wed, 21 Jan 2026 14:33:04 -0300 Subject: [PATCH 06/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-6.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Y también adición a functions.h de una función utilizada para ordenar arreglos de números enteros. --- .../(X.2.2) Ejercicios de C/G2/2-6.c" | 49 +++++++++++++++++++ .../(X.2.2) Ejercicios de C/functions.h" | 20 ++++++++ 2 files changed, 69 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-6.c" 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..7904c94 --- /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,49 @@ +/* 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; + const int 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/functions.h" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/functions.h" index ca00785..61ccc54 100644 --- "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" @@ -30,6 +30,26 @@ void cargar_arreglo_enteros(int* arr, size_t arr_size, int 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]); From fd98f1a5b60be2858b2f35e7190874649a0e1752 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 22 Jan 2026 20:31:50 -0300 Subject: [PATCH 07/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-7.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-7.c" | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-7.c" 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..7600d5f --- /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,59 @@ +/* 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; + const int prim_arr_upp_lim = 150; + const int seg_arr_upp_lim = 200; + int prim_arr[arr_size], seg_arr[arr_size], result; + + cargar_arreglo_enteros(prim_arr, arr_size, low_lim, prim_arr_upp_lim); + cargar_arreglo_enteros(seg_arr, arr_size, low_lim, seg_arr_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; +} From b9eb638bc3b19361963df557a7b21ce00c9b22b2 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 22 Jan 2026 20:37:49 -0300 Subject: [PATCH 08/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=202?= =?UTF-8?q?-7.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-7.c" | 6 ++++++ 1 file changed, 6 insertions(+) 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" index 7600d5f..d78a8b1 100644 --- "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" @@ -28,6 +28,12 @@ void evaluar_resultado(int result) { int main(void) { const size_t arr_size = 10; const int low_lim = 0; + // Uso rangos distintos para generar los contenidos de los arreglos porque + // si utilizo el mismo rango para ambos obtengo exactamente los mismos + // valores. + // Probablemente tenga que ver con la manera en la que está implementada la + // función cargar_arreglo_enteros(), específicamente con el seeding o + // preparación del generador, algo que no es fácil de cambiar. const int prim_arr_upp_lim = 150; const int seg_arr_upp_lim = 200; int prim_arr[arr_size], seg_arr[arr_size], result; From 1f361c9d463f0fdead9b81deb616147dce5d6725 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Wed, 11 Feb 2026 15:46:43 -0300 Subject: [PATCH 09/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=202?= =?UTF-8?q?-7.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Modifiqué la función cargar_arreglo_enteros() para usar métodos más especializados y correctos para generar números al azar en Windows y Linux, dejando el método del tiempo como fallback para otras plataformas. Esto podría generar un problema con el ejercicio 2-7, debido a que antes ambos arreglos en el ejercicio se cargaban con exactamente los mismos valores, y entiendo que era justamente por la manera tan genérica de obtener los números al azar. --- .../(X.2.2) Ejercicios de C/G2/2-7.c" | 17 ++++------ .../(X.2.2) Ejercicios de C/functions.h" | 32 +++++++++++++++---- 2 files changed, 32 insertions(+), 17 deletions(-) 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" index d78a8b1..7f5b8f6 100644 --- "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" @@ -28,18 +28,15 @@ void evaluar_resultado(int result) { int main(void) { const size_t arr_size = 10; const int low_lim = 0; - // Uso rangos distintos para generar los contenidos de los arreglos porque - // si utilizo el mismo rango para ambos obtengo exactamente los mismos - // valores. - // Probablemente tenga que ver con la manera en la que está implementada la - // función cargar_arreglo_enteros(), específicamente con el seeding o - // preparación del generador, algo que no es fácil de cambiar. - const int prim_arr_upp_lim = 150; - const int seg_arr_upp_lim = 200; + const int upp_lim = 100; int prim_arr[arr_size], seg_arr[arr_size], result; - cargar_arreglo_enteros(prim_arr, arr_size, low_lim, prim_arr_upp_lim); - cargar_arreglo_enteros(seg_arr, arr_size, low_lim, seg_arr_upp_lim); + // 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); 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" index 61ccc54..4c96ca1 100644 --- "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" @@ -2,6 +2,8 @@ // 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 @@ -9,24 +11,40 @@ #include #include #include -#include + +int get_random_number() { + int num; + + // clang-format off + #ifdef _WIN32 + #define _CRT_RAND_S + rand_s(&num); + #elif __linux__ + #include + getrandom(&num, sizeof(num), 0); + #else + #include + srand(time(NULL)); + num = rand(); + #endif + // clang-format on + + return num; +} void cargar_arreglo_enteros(int* arr, size_t arr_size, int low_lim, int upp_lim) { assert(low_lim != upp_lim); - // Preparación (seeding) del generador de números aleatorios. - srand(time(NULL)); - 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. rand() % (cant. posibles números) permite obtener un número - // entre 0 y la cantidad de posibles números a 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] = (rand() % (upp_lim - low_lim + 1)) + low_lim; + arr[i] = (get_random_number() % (upp_lim - low_lim + 1)) + low_lim; } } From a3dbf176455daf772b68be098d2a9cc822dedc8f Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 5 Jul 2026 20:18:43 -0300 Subject: [PATCH 10/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-8.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-8.c" | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-8.c" 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..e96b22d --- /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,71 @@ +/* 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; + int arrA[arrA_size], arrB[arrB_size]; + + cargar_arreglo_secuencial(arrA, arrA_size, 0); + cargar_arreglo_secuencial(arrB, arrB_size, 9); + + 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; +} From 8f157bf9f1c1a54bfb18bf17f967df581500881d Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 5 Jul 2026 21:51:49 -0300 Subject: [PATCH 11/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=202?= =?UTF-8?q?-8.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Me había olvidado de definir algunos valores numéricos como constantes. Corregido ahora, para que no haya números mágicos. --- .../(X.2.2) Ejercicios de C/G2/2-8.c" | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) 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" index e96b22d..83c7369 100644 --- "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" @@ -45,10 +45,11 @@ int controlar_presencia_arreglo(int* large_arr, size_t large_arr_size, 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, 0); - cargar_arreglo_secuencial(arrB, arrB_size, 9); + 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); From a219c346586c015ac1c21c9cbe9ff492289d50ee Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 5 Jul 2026 22:07:30 -0300 Subject: [PATCH 12/24] =?UTF-8?q?[algoritmos]=20Correcciones=20est=C3=A9ti?= =?UTF-8?q?cas=20a=20varios=20ejercicios=20de=20C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-3.c" | 5 ++--- .../(X.2.2) Ejercicios de C/G2/2-4.c" | 3 +-- .../(X.2.2) Ejercicios de C/G2/2-5.c" | 3 +-- .../(X.2.2) Ejercicios de C/G2/2-6.c" | 3 +-- .../(X.2.2) Ejercicios de C/G2/2-7.c" | 3 +-- 5 files changed, 6 insertions(+), 11 deletions(-) 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 a831c19..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" @@ -9,10 +9,9 @@ arreglo de forma aleatoria, con números que vayan del 1 al 100. */ int main(void) { const size_t arr_size = 10; - const int low_lim = 1; - const int upp_lim = 100; - + 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 84d92bc..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" @@ -14,8 +14,7 @@ void copiar_arreglo(int* empty_array, int* array_with_contents, int main(void) { const size_t arr_size = 10; - const int low_lim = 0; - const int upp_lim = 10; + const int low_lim = 0, upp_lim = 10; int arr_a[arr_size], arr_b[arr_size]; cargar_arreglo_enteros(arr_a, arr_size, low_lim, upp_lim); 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 9cce976..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" @@ -16,8 +16,7 @@ int sumar_elementos(int* arr, size_t arr_size) { int main(void) { const size_t arr_size = 10; - const int low_lim = 0; - const int upp_lim = 100; + 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); 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" index 7904c94..424959a 100644 --- "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" @@ -25,8 +25,7 @@ void evaluar_resultado(int result) { int main(void) { const size_t arr_size = 10; - const int low_lim = 0; - const int upp_lim = 100; + 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); 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" index 7f5b8f6..f75defe 100644 --- "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" @@ -27,8 +27,7 @@ void evaluar_resultado(int result) { int main(void) { const size_t arr_size = 10; - const int low_lim = 0; - const int upp_lim = 100; + 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 From 6188e364d8c667dac47b40308b6551c6c56401ee Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 19 Jul 2026 01:26:51 -0300 Subject: [PATCH 13/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=20f?= =?UTF-8?q?unctions.h?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Se reacomodaron algunas importaciones de librerías y definiciones condicionales de variables para que estén en el lugar correcto. También se modificó la lógica de obtención de números al azar en get_random_number() para que la función no devuelva números negativos si no está permitido. Esto también requirió modificar cargar_arreglo_enteros() para respetar la nueva definición de get_random_number(). --- .../(X.2.2) Ejercicios de C/functions.h" | 57 +++++++++++++++++-- 1 file changed, 52 insertions(+), 5 deletions(-) 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" index 4c96ca1..31904f2 100644 --- "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" @@ -8,33 +8,74 @@ #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 -int get_random_number() { +#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 - #define _CRT_RAND_S rand_s(&num); #elif __linux__ - #include getrandom(&num, sizeof(num), 0); #else - #include 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); + bool allow_negative_values = false; for (size_t i = 0; i < arr_size; i++) { // Explicación de la fórmula utilizada: @@ -44,7 +85,13 @@ void cargar_arreglo_enteros(int* arr, size_t arr_size, int low_lim, // 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() % (upp_lim - low_lim + 1)) + low_lim; + if (low_lim < 0) { + allow_negative_values = true; + } + + arr[i] = (get_random_number(allow_negative_values) % + (upp_lim - low_lim + 1)) + + low_lim; } } From 73dc00a50789c776649b3fdca875ade3ae6ceca8 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 19 Jul 2026 01:47:34 -0300 Subject: [PATCH 14/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-9.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-9.c" | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" new file mode 100644 index 0000000..008b9bb --- /dev/null +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" @@ -0,0 +1,38 @@ +/* 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: %f\n", prom); + return 0; +} From f615692e5d7eecd52e79908fbf8a968c62525f32 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 19 Jul 2026 01:48:20 -0300 Subject: [PATCH 15/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=202?= =?UTF-8?q?-9.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Correcciones de clang-format. --- .../(X.2.2) Ejercicios de C/G2/2-9.c" | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" index 008b9bb..7d6b49e 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" @@ -1,8 +1,9 @@ /* 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. */ +por pantalla cual es el mayor número, cual es el menor y cual es el promedio. +*/ -#include #include +#include #include "../functions.h" @@ -26,7 +27,7 @@ int main(void) { if (arr[i] < men_num) { men_num = arr[i]; - } + } } prom = prom / 10.0; From 93c1d018a11b6e865195ee2df3c03a41870ba9e8 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 19 Jul 2026 02:13:28 -0300 Subject: [PATCH 16/24] [algoritmos] Traslado de 2-9.c a 2-9a.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Había una consigna adicional en el ítem 9 para hacer por separado en la guía. --- .../(X.2.2) Ejercicios de C/G2/2-9a.c" | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) rename "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" => "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9a.c" (92%) diff --git "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9a.c" similarity index 92% rename from "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" rename to "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9a.c" index 7d6b49e..36c6091 100644 --- "a/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9.c" +++ "b/algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9a.c" @@ -31,9 +31,9 @@ int main(void) { } 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: %f\n", prom); + printf("El promedio de los números en el arreglo es: %.2f\n", prom); + return 0; } From 0aa0367eed14b32a2a3aa048881cce87d08030fa Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sun, 19 Jul 2026 02:13:41 -0300 Subject: [PATCH 17/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-9b.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-9b.c" | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-9b.c" 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..bab31fa --- /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; +} From 4d2add10807d4aca0d45ddfa60356056a5425d4c Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 23 Jul 2026 19:29:17 -0300 Subject: [PATCH 18/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=202?= =?UTF-8?q?-9b.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-9b.c" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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" index bab31fa..e5f3472 100644 --- "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" @@ -48,6 +48,6 @@ int main(void) { "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; } From 2065782b818d4aba59b3976144c7176551db2e76 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 23 Jul 2026 19:30:55 -0300 Subject: [PATCH 19/24] =?UTF-8?q?[algoritmos]=20Modificaci=C3=B3n=20de=20f?= =?UTF-8?q?unctions.h?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ahora se arregla definitivamente la carga de números negativos en arreglos con una solución un tanto fea, si se quiere, pero que permite que get_random_number() igual permita obtener un número negativo al azar. Está explicado en el comentario que añadí a la librería junto con el cambio. --- .../(X.2.2) Ejercicios de C/functions.h" | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) 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" index 31904f2..8dd36d7 100644 --- "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" @@ -75,6 +75,15 @@ int get_random_number(bool get_negative_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++) { @@ -85,10 +94,6 @@ void cargar_arreglo_enteros(int* arr, size_t arr_size, int low_lim, // 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. - if (low_lim < 0) { - allow_negative_values = true; - } - arr[i] = (get_random_number(allow_negative_values) % (upp_lim - low_lim + 1)) + low_lim; From 37c28e52153c0b9f7a2eb0f28bf013852b837946 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Thu, 23 Jul 2026 19:31:10 -0300 Subject: [PATCH 20/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-10.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-10.c" | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-10.c" 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; +} From 2e4711ad5367e3e57ef0f1a1c55a03e811970951 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Mon, 24 Aug 2026 22:47:40 -0300 Subject: [PATCH 21/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-11.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-11.c" | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-11.c" 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..5b0c02f --- /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 finalida 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; +} From 88b310955494aab70c72f51273522ffe6b1704ca Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sat, 29 Aug 2026 19:16:29 -0300 Subject: [PATCH 22/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-12.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-12.c" | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-12.c" 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; +} From 5238095e7e4b65a0f6851587782228023341266d Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Sat, 29 Aug 2026 19:17:40 -0300 Subject: [PATCH 23/24] =?UTF-8?q?[algoritmos]=20Correcci=C3=B3n=20ortogr?= =?UTF-8?q?=C3=A1fica=20en=202-11.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-11.c" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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" index 5b0c02f..bbdb40d 100644 --- "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" @@ -2,7 +2,7 @@ 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 finalida de no hacer "trampa". */ +ordenar arreglos con la finalidad de no hacer "trampa". */ #include From 109aa1f6f9d40b45450e41d31c9aa78205dcb001 Mon Sep 17 00:00:00 2001 From: Lucas Ivan Benchat Parra Date: Fri, 4 Sep 2026 18:35:30 -0300 Subject: [PATCH 24/24] =?UTF-8?q?[algoritmos]=20Adici=C3=B3n=20de=202-13.c?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../(X.2.2) Ejercicios de C/G2/2-13.c" | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 "algoritmos/(X) Adicionales/(X.2) Pr\303\241ctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-13.c" 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; +}