[algoritmos] Resto de los ejercicios de práctica de C (y un par de cosas más)

.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

.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

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 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);
         }

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 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;

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 bool cumple_patron(long int entrada, int cant_uno) {
     // Descomentar esto si se quiere ver

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 bool es_perfecto(int num, int divisor, int suma_div) {
     if (divisor != 0) {

algoritmos/(X) Adicionales/(X.2) Práctica 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);

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 int main(void) {
     int num_us;

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 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;
     }
 }

algoritmos/(X) Adicionales/(X.2) Práctica 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);
         }
     }

algoritmos/(X) Adicionales/(X.2) Práctica 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;

algoritmos/(X) Adicionales/(X.2) Práctica 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");
 

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
 

algoritmos/(X) Adicionales/(X.2) Práctica para laboratorios/(X.2.2) Ejercicios de C/G2/2-1.c

@@ -4,19 +4,21 @@ pantalla. */
 #include <stdio.h>
 
 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]);
     }
 
     printf("\n");
     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;

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
+
+#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;
+}

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
+
+#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;
+}

algoritmos/(X) Adicionales/(X.2) Práctica 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 <stdio.h>
+
+#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;
+}