#include <stdio.h>

#define NUM_CAND 3
#define NUM_VOT 6
#define MAX_RODADAS 5

int main() {
    char nomes[NUM_CAND][50];
    int votos[MAX_RODADAS][NUM_VOT];
    int contagem[NUM_CAND];
    int c, v, r;
    int rodadasRealizadas = 0;
    int papaEleito = -1;

    // (a) leitura dos candidatos
    printf("Votacao Conclave:\n");
    for (c = 0; c < NUM_CAND; c++) {
        printf("Cardeal %d: ", c);
        scanf("%s", nomes[c]);
    }

    // (b) simulação das rodadas
    for (r = 0; r < MAX_RODADAS && papaEleito == -1; r++) {
        printf("Digite os votos da rodada %d: ", r + 1);
        for (v = 0; v < NUM_VOT; v++) {
            scanf("%d", &votos[r][v]);
        }
        rodadasRealizadas++;

        // contagem de votos desta rodada
        for (c = 0; c < NUM_CAND; c++) {
            contagem[c] = 0;
        }
        for (v = 0; v < NUM_VOT; v++) {
            contagem[votos[r][v]]++;
        }

        // verifica se algum candidato atingiu 2/3 dos votos
        for (c = 0; c < NUM_CAND; c++) {
            if (contagem[c] * 3 >= NUM_VOT * 2) {
                papaEleito = c;
            }
        }

        if (papaEleito == -1) {
            printf("Fumaca preta!\n");
        }
    }

    // se ninguem atingiu 2/3 apos 5 rodadas, vence quem teve mais votos na ultima rodada
    if (papaEleito == -1) {
        papaEleito = 0;
        for (c = 1; c < NUM_CAND; c++) {
            if (contagem[c] > contagem[papaEleito]) {
                papaEleito = c;
            }
        }
    }

    // (c) resultado final
    printf("Fumaca branca!\n");
    printf("Matriz com todos os votos:\n");
    for (r = 0; r < rodadasRealizadas; r++) {
        for (v = 0; v < NUM_VOT; v++) {
            printf("%d ", votos[r][v]);
        }
        printf("\n");
    }
    printf("Papa eleito: %s\n", nomes[papaEleito]);

    return 0;
}

Pontos-chave: contagem[votos[r][v]]++ usa o próprio voto lido como índice do vetor de contagem — um truque comum quando os valores possíveis já são índices válidos (Aula 4). A comparação contagem[c] * 3 >= NUM_VOT * 2 evita divisão (e a imprecisão de trabalhar com fração), verificando contagem[c] >= (2/3) * NUM_VOT de forma equivalente, apenas multiplicando cruzado.

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

int main() {
    int vida1, vida2;
    int dado, dano;
    int rodada = 1;

    srand(time(NULL));

    printf("Digite a vida do Jogador 1: ");
    scanf("%d", &vida1);
    printf("Digite a vida do Jogador 2: ");
    scanf("%d", &vida2);

    while (vida1 > 0 && vida2 > 0) {
        printf("Rodada %d:\n", rodada);

        // turno do jogador 1, ataca o jogador 2
        dado = 1 + rand() % 6;
        if (dado == 1) {
            dano = 0;
        } else if (dado == 6) {
            dano = 12;
        } else {
            dano = dado;
        }
        printf("Jogador 1: dado %d\n", dado);
        vida2 -= dano;

        // turno do jogador 2, ataca o jogador 1
        dado = 1 + rand() % 6;
        if (dado == 1) {
            dano = 0;
        } else if (dado == 6) {
            dano = 12;
        } else {
            dano = dado;
        }
        printf("Jogador 2: dado %d\n", dado);
        vida1 -= dano;

        printf("\n");
        rodada++;
    }

    printf("Batalha finalizada!\n");
    if (vida1 <= 0 && vida2 <= 0) {
        printf("Empate!\n");
    } else if (vida1 <= 0) {
        printf("Vencedor: Jogador 2\n");
    } else {
        printf("Vencedor: Jogador 1\n");
    }

    return 0;
}

A condição do while (vida1 > 0 && vida2 > 0) garante que a rodada inteira (os dois turnos) sempre é concluída antes de verificar o fim de jogo — exatamente como pede o enunciado ("ao final de uma rodada"), mesmo que um dos jogadores já tenha chegado a zero no meio da rodada.

#include <stdio.h>
#include <string.h>

#define MAX_PRODUTOS 100

int main() {
    char nome[MAX_PRODUTOS][50];
    float preco[MAX_PRODUTOS];
    int estoque[MAX_PRODUTOS];
    int total = 0;
    int opcao, i, encontrado;
    char nomeBusca[50];
    int limiteEstoque;

    do {
        printf("\n1-Cadastrar 2-Remover ultimo 3-Buscar por nome ");
        printf("4-Buscar por estoque 5-Atualizar precos 6-Sair\n");
        printf("Escolha: ");
        scanf("%d", &opcao);

        switch (opcao) {
            case 1: // cadastrar
                if (total >= MAX_PRODUTOS) {
                    printf("Capacidade maxima atingida!\n");
                } else {
                    printf("Nome: ");
                    scanf("%s", nome[total]);
                    printf("Preco: ");
                    scanf("%f", &preco[total]);
                    printf("Estoque: ");
                    scanf("%d", &estoque[total]);
                    total++;
                }
                break;

            case 2: // remover ultimo
                if (total == 0) {
                    printf("Nao ha produtos cadastrados!\n");
                } else {
                    total--;
                    printf("Produto '%s' removido.\n", nome[total]);
                }
                break;

            case 3: // buscar por nome (busca linear)
                printf("Nome a buscar: ");
                scanf("%s", nomeBusca);
                encontrado = -1;
                for (i = 0; i < total && encontrado == -1; i++) {
                    if (strcmp(nome[i], nomeBusca) == 0) {
                        encontrado = i;
                    }
                }
                if (encontrado != -1) {
                    printf("%s - R$ %.2f - %d unidades\n",
                           nome[encontrado], preco[encontrado], estoque[encontrado]);
                } else {
                    printf("Produto nao encontrado.\n");
                }
                break;

            case 4: // buscar por estoque
                printf("Estoque limite: ");
                scanf("%d", &limiteEstoque);
                for (i = 0; i < total; i++) {
                    if (estoque[i] < limiteEstoque) {
                        printf("%s - R$ %.2f - %d unidades\n",
                               nome[i], preco[i], estoque[i]);
                    }
                }
                break;

            case 5: // atualizar precos (+20%)
                for (i = 0; i < total; i++) {
                    preco[i] = preco[i] * 1.2;
                }
                printf("Precos atualizados!\n");
                break;

            case 6:
                printf("Encerrando o programa. Ate mais!\n");
                break;

            default:
                printf("Opcao invalida!\n");
        }
    } while (opcao != 6);

    return 0;
}

Os três vetores (nome, preco, estoque) são paralelos: a posição i de cada um descreve o mesmo produto, ideia já discutida na Aula 5 como alternativa a estruturas com muitas dimensões. A variável total guarda quantas posições estão realmente em uso, e é ela quem controla os limites de todos os laços — "remover" o último produto é tão simples quanto decrementar total, sem precisar apagar fisicamente nenhum dado.

#include <stdio.h>

#define N 3

int main() {
    int m1[N][N], m2[N][N];
    int i, j;
    int soma = 0;
    float threshold;

    // leitura da matriz original
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            printf("Digite o pixel [%d][%d]: ", i, j);
            scanf("%d", &m1[i][j]);
            soma += m1[i][j];
        }
    }

    // threshold = média de todos os valores da matriz
    threshold = soma / (float) (N * N);

    // binarização: gera m2 a partir de m1 e do threshold
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            if (m1[i][j] > threshold) {
                m2[i][j] = 255;
            } else {
                m2[i][j] = 0;
            }
        }
    }

    // m2 já contém o resultado correto (impressão é opcional, conforme o enunciado)
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            printf("%d ", m2[i][j]);
        }
        printf("\n");
    }

    return 0;
}

O threshold é calculado durante a própria leitura da matriz, acumulando a soma de todos os pixels em um único laço duplo, e só depois dividindo pelo número total de elementos (N * N) — o cast (float) é necessário para evitar a divisão inteira (Aula 1) e obter um threshold com casas decimais.

#include <stdio.h>

#define NUM_PRODUTOS 3

int main() {
    char nomes[NUM_PRODUTOS][30] = {"Casquinha", "Picole", "Sundae"};
    float precos[NUM_PRODUTOS] = {3.50, 4.00, 7.90};
    int opcao, codigo, quantidade, i;

    do {
        printf("\n1 - Comprar\n2 - Sair\nEscolha: ");
        scanf("%d", &opcao);

        if (opcao == 1) {
            printf("Produtos disponiveis:\n");
            for (i = 0; i < NUM_PRODUTOS; i++) {
                printf("%d - %s (R$ %.2f)\n", i, nomes[i], precos[i]);
            }

            printf("Codigo do produto: ");
            scanf("%d", &codigo);
            printf("Quantidade: ");
            scanf("%d", &quantidade);

            if (codigo >= 0 && codigo < NUM_PRODUTOS) {
                printf("Total a pagar: R$ %.2f\n", precos[codigo] * quantidade);
            } else {
                printf("Codigo invalido!\n");
            }
        }
    } while (opcao != 2);

    printf("Ate a proxima!\n");
    return 0;
}

Repare que o menu de produtos, na hora de exibir as opções, é impresso com um for percorrendo nomes e precos — nada é "escrito na mão" (como "1 - Casquinha" fixo no código); se os vetores mudassem, o menu se atualizaria sozinho. O mesmo vale para o cálculo do total: precos[codigo] * quantidade usa diretamente o vetor, validando antes que codigo é um índice válido.

#include <stdio.h>

int main() {
    int n, soma, impar;

    printf("Digite um numero inteiro e positivo: ");
    scanf("%d", &n);

    while (n <= 0) { // consistência: insiste até receber um valor válido
        printf("Valor invalido! Digite um numero inteiro e positivo: ");
        scanf("%d", &n);
    }

    soma = 0;
    impar = 1;
    while (soma < n) {
        soma += impar;
        impar += 2; // próximo ímpar: 1, 3, 5, 7, ...
    }

    if (soma == n) {
        printf("%d e quadrado perfeito\n", n);
    } else {
        printf("%d NAO e quadrado perfeito\n", n);
    }

    return 0;
}

Usamos while (soma < n), em vez de um for, porque não sabemos de antemão quantos ímpares serão necessários (Aula 3). Se n for um quadrado perfeito, a soma bate certinho em n ao final de algum passo; caso contrário, a soma ultrapassa n antes de conseguir atingi-lo exatamente (já que os ímpares somados sempre crescem) — por isso a comparação final é soma == n, e não apenas soma >= n.

#include <stdio.h>

#define NUM_PRODUTOS 50
#define NUM_LOJAS 4

int main() {
    int estoque[NUM_PRODUTOS][NUM_LOJAS];
    int estoqueTotal[NUM_PRODUTOS];
    int p, l;

    // (a) preenche a matriz por leitura
    for (p = 0; p < NUM_PRODUTOS; p++) {
        for (l = 0; l < NUM_LOJAS; l++) {
            printf("Estoque do produto %d na loja %d: ", p, l);
            scanf("%d", &estoque[p][l]);
        }
    }

    // (b) calcula o total de cada produto, somando as lojas
    for (p = 0; p < NUM_PRODUTOS; p++) {
        estoqueTotal[p] = 0;
        for (l = 0; l < NUM_LOJAS; l++) {
            estoqueTotal[p] += estoque[p][l];
        }
    }

    // (c) relatorio de produtos com estoque baixo em alguma loja
    printf("Produtos com estoque baixo:\n");
    for (p = 0; p < NUM_PRODUTOS; p++) {
        for (l = 0; l < NUM_LOJAS; l++) {
            if (estoque[p][l] < 10) {
                printf("Produto %d, loja %d: apenas %d unidades\n", p, l, estoque[p][l]);
            }
        }
    }

    return 0;
}

Note que o item (c) percorre a matriz estoque novamente (e não estoqueTotal): o enunciado pede o estoque baixo em qualquer loja individualmente, não no total somado — por isso é a matriz bidimensional, e não o vetor de totais, que precisa ser verificada célula por célula.

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

int main() {
    float n, tolerancia, termo, soma;
    int k;

    printf("Digite n: ");
    scanf("%f", &n);
    printf("Digite a tolerancia: ");
    scanf("%f", &tolerancia);

    soma = 0;
    k = 1;
    do {
        termo = n / ((n + k) * (n + k + 1));
        soma += termo;
        k++;
    } while (fabs(termo) > tolerancia);

    printf("Soma aproximada: %.6f\n", soma);

    return 0;
}

Usamos do-while porque é preciso calcular ao menos um termo antes de poder testar a condição de parada (Aula 3) — não daria para testar fabs(termo) sem primeiro calcular algum termo. A cada volta, um novo termo da série é somado e k avança; o laço para assim que o termo mais recente for pequeno o suficiente (menor ou igual à tolerância).

#include <stdio.h>
#include <string.h>

#define MAXTXT 200
#define MAXPAL 50

int main() {
    char s1[MAXTXT], s2[MAXPAL];
    int tamS1, tamS2, i, j, ocorrencias = 0;
    int igual;

    printf("Digite string s1: ");
    fgets(s1, MAXTXT, stdin);
    s1[strcspn(s1, "\n")] = '\0'; // remove o '\n' do fgets

    printf("Digite string s2: ");
    fgets(s2, MAXPAL, stdin);
    s2[strcspn(s2, "\n")] = '\0';

    tamS1 = strlen(s1);
    tamS2 = strlen(s2);

    // tenta encaixar s2 a partir de cada posição possível de s1
    for (i = 0; i <= tamS1 - tamS2; i++) {
        igual = 1; // flag: assume que bate, até prova em contrário

        for (j = 0; j < tamS2; j++) {
            if (s1[i + j] != s2[j]) {
                igual = 0;
            }
        }

        if (igual) {
            ocorrencias++;
        }
    }

    printf("A string %s ocorre %d vezes\n", s2, ocorrencias);

    return 0;
}

A ideia é "deslizar" s2 por cima de s1, uma posição de cada vez: para cada posição inicial i em s1, comparamos caractere a caractere com s2 (laço interno com a flag igual). O laço externo vai só até tamS1 - tamS2, pois não faz sentido tentar encaixar s2 em uma posição onde ela não caberia inteira dentro de s1.

#include <stdio.h>

#define L 4
#define T 4

int main() {
    char titulos[T][80];
    int vendas[L][T];
    int loja, i, maiorVenda;

    // leitura dos titulos
    for (i = 0; i < T; i++) {
        printf("Titulo do livro %d: ", i);
        scanf("%s", titulos[i]);
    }

    // leitura das vendas de cada livro em cada loja
    for (loja = 0; loja < L; loja++) {
        for (i = 0; i < T; i++) {
            printf("Vendas do livro %d na loja %d: ", i, loja);
            scanf("%d", &vendas[loja][i]);
        }
    }

    // consultas repetidas ate um codigo invalido de loja
    while (1) {
        printf("Digite o codigo da loja (ou invalido para sair): ");
        scanf("%d", &loja);

        if (loja < 0 || loja >= L) {
            printf("Finalizando sistema de consulta\n");
            break;
        }

        // descobre a maior venda dessa loja
        maiorVenda = vendas[loja][0];
        for (i = 1; i < T; i++) {
            if (vendas[loja][i] > maiorVenda) {
                maiorVenda = vendas[loja][i];
            }
        }

        // imprime todos os titulos empatados na maior venda
        printf("Mais vendido(s) (%d unidades):\n", maiorVenda);
        for (i = 0; i < T; i++) {
            if (vendas[loja][i] == maiorVenda) {
                printf("- %s\n", titulos[i]);
            }
        }
    }

    return 0;
}

Usamos while (1) (um laço que só termina através de um break interno) porque o programa deve consultar indefinidamente, sem um número de repetições conhecido de antemão — a única forma de saber quando parar é observar o próprio código de loja digitado. A busca do "mais vendido" segue o mesmo padrão de maior elemento de um vetor (Aula 4); o segundo laço, que imprime todos os empatados, é necessário porque o enunciado exige mostrar mais de um título caso haja empate na venda máxima.

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

#define N 5

int main() {
    float x[N], y[N];
    int i, j;
    float dx, dy, distancia, maiorDistancia = 0;

    for (i = 0; i < N; i++) {
        printf("Ponto %d - x: ", i);
        scanf("%f", &x[i]);
        printf("Ponto %d - y: ", i);
        scanf("%f", &y[i]);
    }

    // compara cada par de pontos (i, j), sem repetir pares
    for (i = 0; i < N; i++) {
        for (j = i + 1; j < N; j++) {
            dx = x[i] - x[j];
            dy = y[i] - y[j];
            distancia = sqrt(dx * dx + dy * dy);

            if (distancia > maiorDistancia) {
                maiorDistancia = distancia;
            }
        }
    }

    printf("Maior distancia entre dois pontos: %.2f\n", maiorDistancia);

    return 0;
}

O laço interno começa em j = i + 1, e não em j = 0, para comparar cada par de pontos exatamente uma vez (o par (2, 4) é o mesmo que (4, 2), então não faz sentido calculá-lo duas vezes) — o mesmo tipo de cuidado que tomamos, por exemplo, ao inverter um vetor sem vetor auxiliar (Aula 4). A cada par comparado, calculamos a distância euclidiana e atualizamos maiorDistancia sempre que encontramos algo maior, no mesmo padrão de "maior elemento" já visto diversas vezes ao longo da disciplina.