Tarea 1: Conversión de Puntuación a Calificación

Función que transforma una puntuación numérica en la calificación de letras A, B, C, D, E según rangos establecidos.

Tipo de parámetro: entero

Tipo de retorno: carácter

#include <stdio.h>

char asignar_calificacion(int puntos);

int main() {
    int valor;
    char calif;
    
    while (scanf("%d", &valor) != EOF) {
        calif = asignar_calificacion(valor);
        printf("Puntos: %d, Calificación: %c\n\n", valor, calif);
    }
    
    return 0;
}

char asignar_calificacion(int puntos) {
    int division = puntos / 10;
    char salida;
    
    if (division == 10) {
        salida = 'A';
    } else if (division == 9) {
        salida = 'B';
    } else if (division == 8) {
        salida = 'C';
    } else if (division == 7) {
        salida = 'D';
    } else if (division == 6) {
        salida = 'E';
    } else {
        salida = 'F'; // Para puntuaciones fuera del rango 60-100
    }
    
    return salida;
}

Tarea 2: Suma de Dígitos de un Entero

Calcula la suma de todos los dígitos de un número entero utilizando un enfoque recursivo en lugar del iterativo original.

Tipo de parámetro: entero

Tipo de retorno: entero

#include <stdio.h>

int sumar_digitos(int num);

int main() {
    int numero;
    int total;
    
    while (printf("Ingrese número: "), scanf("%d", &numero) != EOF) {
        total = sumar_digitos(numero);
        printf("Suma de dígitos: %d\n\n", total);
    }
    
    return 0;
}

int sumar_digitos(int num) {
    if (num == 0) {
        return 0;
    } else {
        return (num % 10) + sumar_digitos(num / 10);
    }
}

Tarea 3: Cálculo de Potencia con Recursión

Implementa una función recursiva para calcular la potencia de un número base elevado a un exponente, optimizada con exponenciación rápida.

Tipo de parámetros: enteros base y exponente

Tipo de retorno: entero

#include <stdio.h>

int calcular_potencia(int base, int expo);

int main() {
    int x, n;
    int resultado;
    
    while (printf("Ingrese base y exponente: "), scanf("%d%d", &x, &n) != EOF) {
        resultado = calcular_potencia(x, n);
        printf("Exponente: %d, Resultado: %d\n\n", n, resultado);
    }
    
    return 0;
}

int calcular_potencia(int base, int expo) {
    int temporal;
    
    if (expo == 0) {
        return 1;
    } else if (expo % 2 != 0) {
        return base * calcular_potencia(base, expo - 1);
    } else {
        temporal = calcular_potencia(base, expo / 2);
        return temporal * temporal;
    }
}

Tarea 4: Búsqueda de Números Primos Gemelos

Detecta todos los pares de números primos gemelos dentro del rango de 1 a 100, mostrando su conteo total.

#include <stdio.h>

int es_primo(int num);

int main() {
    int num;
    int contador = 0;
    
    printf("Primos gemelos hasta 100:\n");
    for (num = 2; num <= 98; num++) {
        if (es_primo(num) && es_primo(num + 2)) {
            printf("%d y %d\n", num, num + 2);
            contador++;
        }
    }
    printf("Total de pares encontrados: %d\n", contador);
    
    return 0;
}

int es_primo(int num) {
    int divisor;
    
    if (num <= 1) {
        return 0;
    }
    if (num == 2) {
        return 1;
    }
    for (divisor = 2; divisor * divisor <= num; divisor++) {
        if (num % divisor == 0) {
            return 0;
        }
    }
    return 1;
}

Tarea 5: Cálculo de Combinaciones

Ofrece dos implementaciones para calcular el coeficiente binomial C(n, m): una iterativa basada en factoriales y otra recursiva basada en la identidad de Pascal.

Implementación Iterativa

#include <stdio.h>

int combinatoria_iterativa(int n, int m);

int main() {
    int n, m;
    int resultado;
    
    while (scanf("%d%d", &n, &m) != EOF) {
        resultado = combinatoria_iterativa(n, m);
        printf("C(%d, %d) = %d\n\n", n, m, resultado);
    }
    
    return 0;
}

int combinatoria_iterativa(int n, int m) {
    int factorial_n = 1, factorial_m = 1, factorial_dif = 1;
    int i;
    
    for (i = 1; i <= n; i++) {
        factorial_n *= i;
    }
    for (i = 1; i <= m; i++) {
        factorial_m *= i;
    }
    for (i = 1; i <= n - m; i++) {
        factorial_dif *= i;
    }
    
    return factorial_n / (factorial_m * factorial_dif);
}

Implementación Recursiva

#include <stdio.h>

int combinatoria_recursiva(int n, int m);

int main() {
    int n, m;
    int valor;
    
    while (scanf("%d%d", &n, &m) != EOF) {
        valor = combinatoria_recursiva(n, m);
        printf("C(%d, %d) = %d\n\n", n, m, valor);
    }
    
    return 0;
}

int combinatoria_recursiva(int n, int m) {
    if (m < 0 || m > n) {
        return 0;
    }
    if (m == 0 || m == n) {
        return 1;
    }
    return combinatoria_recursiva(n - 1, m) + combinatoria_recursiva(n - 1, m - 1);
}

Tarea 6: Máximo Común Divisor para Tres Números

Encuentra el máximo común divisor (MCD) de tres enteros mediante un método de búsqueda descendente.

#include <stdio.h>

int mcd_tres(int a, int b, int c);

int main() {
    int num1, num2, num3;
    int mcd;
    
    scanf("%d %d %d", &num1, &num2, &num3);
    mcd = mcd_tres(num1, num2, num3);
    printf("MCD: %d\n", mcd);
    
    return 0;
}

int mcd_tres(int a, int b, int c) {
    int minimo = a;
    int candidato;
    
    if (b < minimo) {
        minimo = b;
    }
    if (c < minimo) {
        minimo = c;
    }
    
    for (candidato = minimo; candidato >= 1; candidato--) {
        if (a % candidato == 0 && b % candidato == 0 && c % candidato == 0) {
            return candidato;
        }
    }
    
    return 1;
}

Tarea 7: Impresión de Patrón de Caracteres

Genera una figura simétrica con caracteres 'O', '' e 'I I' en forma de pirámide invertida basada en un número de líneas dado.

#include <stdio.h>

void dibujar_figura(int lineas);

int main() {
    int cantidad;
    
    printf("Ingrese número de líneas: ");
    scanf("%d", &cantidad);
    dibujar_figura(cantidad);
    
    return 0;
}

void dibujar_figura(int lineas) {
    int fila, espacio, simbolo;
    
    for (fila = 0; fila < lineas; fila++) {
        for (espacio = 0; espacio < fila; espacio++) {
            printf(" \t");
        }
        for (simbolo = 0; simbolo < lineas * 2 - 1 - 2 * fila; simbolo++) {
            printf(" O\t");
        }
        printf("\n");
        
        for (espacio = 0; espacio < fila; espacio++) {
            printf(" \t");
        }
        for (simbolo = 0; simbolo < lineas * 2 - 1 - 2 * fila; simbolo++) {
            printf("<h>\t");
        }
        printf("\n");
        
        for (espacio = 0; espacio < fila; espacio++) {
            printf(" \t");
        }
        for (simbolo = 0; simbolo < lineas * 2 - 1 - 2 * fila; simbolo++) {
            printf("I I\t");
        }
        printf("\n");
    }
}
</h>