Exercício 1: Geração Aleatória de Identificadores

Este programa demonstra a geração de números pseudoaleatórios em C para criar identificadores sequenciais, como números de matrícula. Ele inicializa o gerador de números aleatórios com base no tempo atual para garantir diferentes sequências a cada execução.

#include <stdio.h>
#include <stdlib.h> // Para srand, rand
#include <time.h>   // Para time

#define TOTAL_IDS 5     // Número de identificadores a serem gerados
#define MAX_SUFIXO_A 80 // Limite superior para o sufixo do Grupo A
#define MAX_SUFIXO_B 35 // Limite superior para o sufixo do Grupo B

int main() {
    int contador_ids;
    int escolha_prefixo; // 0 para Grupo B, 1 para Grupo A
    int numero_sequencial;

    // Inicializa o gerador de números aleatórios com o tempo atual
    srand(time(NULL));

    printf("Gerando %d identificadores aleatórios:\n", TOTAL_IDS);

    for (contador_ids = 0; contador_ids < TOTAL_IDS; contador_ids++) {
        // Escolhe aleatoriamente entre dois prefixos (0 ou 1)
        escolha_prefixo = rand() % 2;

        if (escolha_prefixo == 1) { // Prefixo para o Grupo A
            // Gera um número entre 1 e MAX_SUFIXO_A
            numero_sequencial = rand() % MAX_SUFIXO_A + 1;
            printf("20256343%04d\n", numero_sequencial);
        } else { // Prefixo para o Grupo B
            // Gera um número entre 1 e MAX_SUFIXO_B
            numero_sequencial = rand() % MAX_SUFIXO_B + 1;
            printf("20256136%04d\n", numero_sequencial);
        }
    }

    return 0;
}

Exercício 2: Simulação de Máquina de Vendas

Este programa simula um processo de compra em uma máquina de vendas de bebidas. Ele apresenta um menu, aceita a escolha do usuário e a quantidade, calcula o preço total e o troco. A variável custo_total é redefiinda para zero após cada transação, garantindo que as compras sejam calculadas individualmente.

#include <stdio.h>

// Definindo os preços das bebidas
#define PRECO_REFRIGERANTE 3.0f
#define PRECO_SUCO_LARANJA 5.0f
#define PRECO_AGUA           2.0f

int main() {
    int opcao_bebida, quantidade_item;
    float custo_total_transacao;
    float valor_pago_cliente, troco_final;

    while (1) {
        custo_total_transacao = 0.0f; // Importante: resetar o custo total para cada nova transação

        printf("\n--- Menu da Máquina de Vendas ---\n");
        printf("1. Refrigerante - R$ %.2f\n", PRECO_REFRIGERANTE);
        printf("2. Suco de Laranja - R$ %.2f\n", PRECO_SUCO_LARANJA);
        printf("3. Água Mineral - R$ %.2f\n", PRECO_AGUA);
        printf("0. Sair do processo de compra\n");
        printf("Por favor, digite o número da bebida: ");
        scanf("%d", &opcao_bebida);

        if (opcao_bebida == 0) {
            break; // Sai do loop se a opção for 0
        }

        if (opcao_bebida < 1 || opcao_bebida > 3) { // Ajustado para 3 opções
            printf("Opção de bebida inválida. Por favor, digite novamente.\n");
            continue; // Volta ao início do loop
        }

        printf("Por favor, digite a quantidade desejada: ");
        scanf("%d", &quantidade_item);

        if (quantidade_item <= 0) {
            printf("A quantidade deve ser um número positivo. Por favor, digite novamente.\n");
            continue; // Volta ao início do loop
        }

        // Calcula o custo total com base na opção e quantidade
        switch (opcao_bebida) {
            case 1: // Refrigerante
                custo_total_transacao += PRECO_REFRIGERANTE * quantidade_item;
                break;
            case 2: // Suco de Laranja
                custo_total_transacao += PRECO_SUCO_LARANJA * quantidade_item;
                break;
            case 3: // Água Mineral
                custo_total_transacao += PRECO_AGUA * quantidade_item;
                break;
            default:
                // Este caso não deve ser alcançado devido à validação anterior
                break;
        }

        printf("Total a pagar: R$ %.2f\n", custo_total_transacao);
        printf("Por favor, insira o valor pago: ");
        scanf("%f", &valor_pago_cliente);

        if (valor_pago_cliente < custo_total_transacao) {
            printf("Valor insuficiente. Por favor, insira o valor correto.\n");
            continue; // Permite ao cliente tentar pagar novamente
        }

        troco_final = valor_pago_cliente - custo_total_transacao;
        printf("Troco: R$ %.2f\n", troco_final);
    }

    printf("Obrigado pela sua compra, volte sempre!\n");
    return 0;
}

Exercício 3: Semáforo Simples com Entrada de Caracteres

Este programa simula um sistema de semáforo que responde a caracteres específicos. Ele lê continuamente um caractere da entrada padrão e imprime uma mensagem correspondente, como 'go go go' para 'g'. O programa termina ao receber o caractere de fim de arquivo (EOF).

#include <stdio.h> // Para getchar, printf, EOF
#include <stdlib.h> // Geralmente incluído, mas não estritamente necessário aqui

int main() {
    char caractere_luz;

    printf("Simulador de Semáforo. Digite 'y' (amarelo), 'g' (verde), 'r' (vermelho).\n");
    printf("Pressione Ctrl+D (Unix/Linux) ou Ctrl+Z e Enter (Windows) para sair.\n");

    while (1) {
        printf("\nEntrada: ");
        caractere_luz = getchar(); // Lê um único caractere

        if (caractere_luz == EOF) {
            break; // Sai do loop se EOF for detectado
        }

        // Ignora caracteres de nova linha para não processá-los como comandos
        if (caractere_luz == '\n') {
            continue;
        }

        // Usa switch-case para clareza na verificação de múltiplos casos
        switch (caractere_luz) {
            case 'y':
                printf("Atenção, espere um minuto!\n");
                break;
            case 'g':
                printf("Prossiga, vá em frente!\n");
                break;
            case 'r':
                printf("Pare!\n");
                break;
            default:
                printf("Comando inválido. Algo está errado...\n");
                break;
        }
    }

    printf("Simulador encerrado.\n");
    return 0;
}

Exercício 4: Rastreador de Despesas Diárias

Este programa permite ao usuário inserir despesas diárias e calcula o total acumulado, a despesa máxima e a despesa mínima. A entrada de -1 serve como condição de parada para encerrar o registro das despesas.

#include <stdio.h> // Para printf, scanf
#include <float.h> // Para DBL_MAX, DBL_MIN se necessário, mas não utilizado diretamente aqui

int main() {
    double despesa_atual;
    double maior_despesa = -1.0; // Inicializar com um valor que será facilmente superado
    double menor_despesa = -1.0; // Inicializar com um valor que será facilmente superado
    double total_acumulado = 0.0;
    int primeira_despesa = 1; // Flag para a primeira entrada

    printf("Digite suas despesas diárias (digite -1 para finalizar):\n");

    while (scanf("%lf", &despesa_atual) == 1 && despesa_atual != -1) {
        if (primeira_despesa) {
            maior_despesa = despesa_atual;
            menor_despesa = despesa_atual;
            primeira_despesa = 0; // Desativa a flag após a primeira entrada
        } else {
            if (despesa_atual > maior_despesa) {
                maior_despesa = despesa_atual;
            }
            if (despesa_atual < menor_despesa) {
                menor_despesa = despesa_atual;
            }
        }
        total_acumulado += despesa_atual;
    }

    if (primeira_despesa) { // Se nenhuma despesa válida foi inserida
        printf("Nenhuma despesa foi registrada hoje.\n");
    } else {
        printf("\n--- Resumo das Despesas ---\n");
        printf("Total acumulado: R$ %.2lf\n", total_acumulado);
        printf("Maior despesa: R$ %.2lf\n", maior_despesa);
        printf("Menor despesa: R$ %.2lf\n", menor_despesa);
    }

    return 0;
}

Exercício 5: Classificador de Tipos de Triângulos

Este programa lê três números inteiros que representam os lados de um triângulo e os classifica em Equilátero, Isósceles, Retângulo ou Comum, ou indica se eles não podem formar um triângulo. O programa processa enrtadas continuamente até que um erro de leitura ou EOF seja encontrado.

#include <stdio.h> // Para printf, scanf
#include <stdlib.h> // Para abs, embora não usado no exemplo original, útil para triângulos

int main() {
    int lado_a, lado_b, lado_c;
    int resultado_leitura;

    printf("Digite três números inteiros para os lados do triângulo (separados por espaço).\n");
    printf("Pressione Ctrl+D (Unix/Linux) ou Ctrl+Z e Enter (Windows) para sair.\n");

    while (1) {
        printf("\nEntrada (a b c): ");
        resultado_leitura = scanf("%d %d %d", &lado_a, &lado_b, &lado_c);

        if (resultado_leitura == EOF) {
            break; // Sai do loop se EOF for detectado
        }

        if (resultado_leitura != 3) {
            printf("Entrada inválida. Por favor, digite três números.\n");
            // Limpa o buffer de entrada para evitar loop infinito em caso de entrada não numérica
            while (getchar() != '\n');
            continue;
        }

        // Verifica a condição de existência do triângulo
        if (lado_a <= 0 || lado_b <= 0 || lado_c <= 0 ||
            !(lado_a + lado_b > lado_c &&
              lado_a + lado_c > lado_b &&
              lado_b + lado_c > lado_a)) {
            printf("Não pode formar um triângulo com esses lados (lados devem ser positivos e satisfazer a desigualdade triangular).\n");
        } else if (lado_a == lado_b && lado_b == lado_c) {
            printf("Triângulo Equilátero\n");
        } else if (lado_a == lado_b || lado_b == lado_c || lado_a == lado_c) {
            printf("Triângulo Isósceles\n");
        } else if (lado_a * lado_a + lado_b * lado_b == lado_c * lado_c ||
                   lado_a * lado_a + lado_c * lado_c == lado_b * lado_b ||
                   lado_b * lado_b + lado_c * lado_c == lado_a * lado_a) {
            printf("Triângulo Retângulo\n");
        } else {
            printf("Triângulo Comum (Escaleno)\n");
        }
    }

    printf("Programa de classificação de triângulos encerrado.\n");
    return 0;
}

Exercício 6: Jogo de Adivinhe o Dia da Sorte

Este é um jogo simples onde o jogador tem três tentativas para adivinhar um "dia da sorte" aleatório entre 1 e 30. O programa fornece dicas (maior ou menor) após cada palpite incorreto e revela o dia correto se o jogador ficar sem tentativas.

#include <stdio.h>  // Para printf, scanf
#include <stdlib.h> // Para srand, rand
#include <time.h>   // Para time

int main() {
    int dia_sorteio;
    int palpite_usuario;
    int tentativas_restantes = 3;

    // Inicializa o gerador de números aleatórios
    srand(time(NULL));

    // Gera um dia aleatório entre 1 e 30
    dia_sorteio = rand() % 30 + 1;

    printf("Adivinhe qual dia de novembro de 2025 é o seu dia de sorte!\n");
    printf("Você tem 3 tentativas. O dia está entre 1 e 30.\n");

    while (tentativas_restantes > 0) {
        printf("Tentativas restantes: %d\n", tentativas_restantes);
        printf("Seu palpite (1-30): ");
        scanf("%d", &palpite_usuario);

        if (palpite_usuario < 1 || palpite_usuario > 30) {
            printf("Palpite inválido. Por favor, digite um número entre 1 e 30.\n");
            continue; // Não consome uma tentativa para palpites inválidos
        }

        if (palpite_usuario == dia_sorteio) {
            printf("Parabéns! Você adivinhou o dia de sorte corretamente: %d :)\n", dia_sorteio);
            break; // Sai do loop se o palpite estiver correto
        } else if (palpite_usuario < dia_sorteio) {
            printf("Seu palpite foi muito baixo. O dia da sorte é posterior a %d.\n", palpite_usuario);
        } else { // palpite_usuario > dia_sorteio
            printf("Seu palpite foi muito alto. O dia da sorte é anterior a %d.\n", palpite_usuario);
        }

        tentativas_restantes--; // Decrementa uma tentativa
    }

    if (tentativas_restantes == 0) {
        printf("\nSuas tentativas acabaram.\n");
        printf("Não se preocupe, o dia da sorte de novembro era: %d.\n", dia_sorteio);
    }

    printf("Obrigado por jogar!\n");
    return 0;
}