Conversão de Pontuação para Classificação

Implementação do Código

#include <stdio.h>

char converter_pontuacao(int pontuacao);

int main() {
    int pontuacao;
    char classificacao;
    
    while (scanf("%d", &pontuacao) != EOF) {
        classificacao = converter_pontuacao(pontuacao);
        printf("Pontuação: %d, Classificação: %c\n\n", pontuacao, classificacao);
    }
    return 0;
}

char converter_pontuacao(int pontuacao) {
    char resultado;
    
    switch (pontuacao / 10) {
        case 10:
        case 9: resultado = 'A'; break;
        case 8: resultado = 'B'; break;
        case 7: resultado = 'C'; break;
        case 6: resultado = 'D'; break;
        default: resultado = 'E';
    }
    return resultado;
}

Análise da Implementação

A função converter_pontuacao analisa a pontuação dividindo por 10 e retorna a classificação correspondente. A utilização de aspas simples é essencial para caracteres individuais, enquanto aspas duplas são reservadas para strings. A estrutura switch com break impede a execução sequencial dos casos.

Soma dos Dígitos de um Número

Implementação do Código

#include <stdio.h>

int somar_digitos(int numero);

int main() {
    int numero;
    int resultado;
    
    while (printf("Digite n: "), scanf("%d", &numero) != EOF) {
        resultado = somar_digitos(numero);
        printf("n=%d, resultado=%d\n\n", numero, resultado);
    }
    return 0;
}

int somar_digitos(int numero) {
    int soma = 0;
    
    while (numero != 0) {
        soma += numero % 10;
        numero /= 10;
    }
    return soma;
}

Análise da Implementação

A função somar_digitos utiliza operações de módulo e divisão para extrair e somar cada dígito do número. Esta aboradgem iterativa processa cada dígito sequencialmente até que o número se torne zero.

Cálculo de Potência com Recursão

Implementação do Código

#include <stdio.h>

int calcular_potencia(int base, int expoente);

int main() {
    int base, expoente;
    int resultado;
    
    while (printf("Digite base e expoente: "), scanf("%d%d", &base, &expoente) != EOF) {
        resultado = calcular_potencia(base, expoente);
        printf("expoente=%d, resultado=%d\n\n", expoente, resultado);
    }
    return 0;
}

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

Análise da Implementação

Esta implementação utiliza recursão para calcular potências, otimizando o processo através da divisão do expoente pela metade quando par. A função lida com casos base e aplica a propriedade matemática de que x^(n/2) * x^(n/2) = x^n.

Identificação de Números Primos Gêmeos

Implementação do Código

#include <stdio.h>
#include <math.h>

int verificar_primo(int numero);

int main() {
    int limite = 100;
    int contador = 0;
    
    printf("Números primos gêmeos até 100:\n");
    for (int i = 2; i < limite - 2; ++i) {
        if(verificar_primo(i) && verificar_primo(i + 2)) {
            printf("%d %d\n", i, i + 2);
            contador++;
        }
    }
    printf("Total de pares de primos gêmeos: %d", contador);
    return 0;
}

int verificar_primo(int numero) {
    if (numero <= 1) return 0;
    if (numero == 2) return 1;
    if (numero % 2 == 0) return 0;
    
    for (int i = 3; i <= sqrt(numero); i += 2) {
        if (numero % i == 0) return 0;
    }
    return 1;
}

Resolução do Problema das Torres de Hanói

Implementação do Código

#include <stdio.h>
#include <stdlib.h>

void resolver_hanoi(unsigned int discos, char origem, char auxiliar, char destino);
void mover_disco(unsigned int disco, char origem, char destino);
int contador_movimentos = 0;

int main() {
    unsigned int discos;
    while (scanf("%u", &discos) != EOF) {
        resolver_hanoi(discos, 'A', 'B', 'C');
        printf("Total de movimentos: %d\n\n", contador_movimentos);
        contador_movimentos = 0;
    }
    return 0;
}

void resolver_hanoi(unsigned int discos, char origem, char auxiliar, char destino) {
    if (discos == 1) {
        mover_disco(discos, origem, destino);
    } else {
        resolver_hanoi(discos - 1, origem, destino, auxiliar);
        mover_disco(discos, origem, destino);
        resolver_hanoi(discos - 1, auxiliar, origem, destino);
    }
}

void mover_disco(unsigned int disco, char origem, char destino) {
    printf("%u: %c -> %c\n", disco, origem, destino);
    contador_movimentos++;
}

Cálculo de Combinações

Abordagem Iterativa

#include <stdio.h>

int calcular_combinacao(int n, int m);

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

int calcular_combinacao(int n, int m) {
    int i, j;
    int numerador = 1, denominador = 1;
    
    for (i = 0; i < m; ++i)
        numerador = numerador * (n - i);
    for (j = 0; j < m; ++j)
        denominador = denominador * (m - j);
    return numerador / denominador;
}

Abordagem Recursiva

#include <stdio.h>

int calcular_combinacao(int n, int m);

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

int calcular_combinacao(int n, int m) {
    if (m == 0) return 1;
    else if (m == n) return 1;
    else if (m > n) return 0;
    else return calcular_combinacao(n - 1, m) + calcular_combinacao(n - 1, m - 1);
}

Cálculo do Máximo Divisor Comum

Implementação do Código

#include <stdio.h>

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

int main() {
    int a, b, c;
    int resultado;
    while (scanf("%d%d%d", &a, &b, &c) != EOF) {
        resultado = calcular_mdc(a, b, c);
        printf("MDC: %d\n\n", resultado);
    }
    return 0;
}

int calcular_mdc(int a, int b, int c) {
    int divisor;
    divisor = a < b ? a : b;
    divisor = divisor < c ? divisor : c;
    
    for (; divisor > 0; --divisor) 
        if (a % divisor == 0 && b % divisor == 0 && c % divisor == 0)
            return divisor;
}