do Lógica de Programação – Superior
Plano de aulas da disciplina de Lógica de Programação (INF027), em linguagem C. São 36 encontros em três blocos; cada bloco termina com uma avaliação no formato das provas anteriores, e o último encontro é a reavaliação.
Como é cada aula
- Slides: o conceito do dia, o padrão em C, os erros que mais custam pontos e um teste de mesa.
- Resolvida em sala: uma questão de prova anterior, resolvida passo a passo, com o código comentado.
- Para você: outra questão de prova anterior, para resolver. A solução comentada fica disponível para conferir depois.
stdio.h, stdlib.h e stdbool.h. Para compilar: gcc -Wall arquivo.c -o programa, ou no navegador em OnlineGDB.
Bloco 1 Sequência, aritmética e decisão
Entrada e saída, tipos, / e %, dígitos, bases, if/else, switch e bits. Termina com a Avaliação I.
1 Primeiro programa: entrada, fórmula e saída Avaliação 1 – 2014.2
Escrever um programa completo que lê dados, aplica uma fórmula da prova e imprime o resultado formatado.
Conceitos
- Esqueleto de todo programa:
#include <stdio.h>,int main(void) { ... return 0; } intguarda inteiros;doubleguarda reais. Na dúvida numa fórmula, usedouble- Leitura:
%dparaint,%lfparadouble. Impressão:%de%f(%.2f= 2 casas) scanfprecisa do&antes da variável: ele recebe o endereço onde guardar- Cada fórmula do enunciado vira uma linha
variavel = expressão;
Resolvida em sala: Probabilidade de dois eventos independentes
Avaliação 1 – 2014.2, Questão I avaliacao_1_ano_2014_2.pdf
Solução comentada
// A1-2014.2 – Questão I: Probabilidade de dois eventos independentes
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
double pa, pb; // probabilidades lidas (entre 0 e 1)
printf("P(A) e P(B): "); // pede as duas probabilidades
scanf("%lf %lf", &pa, &pb); // %lf lê um double
double ambos = pa * pb; // P(A e B) = P(A) x P(B)
double algum = pa + pb - ambos; // P(A ou B) = P(A) + P(B) - P(A e B)
printf("P(A e B) = %.4f\n", ambos); // os dois eventos acontecem
printf("P(A ou B) = %.4f\n", algum); // pelo menos um acontece
return 0; // fim sem erro
}Para você: Área sombreada entre o quadrado e o círculo inscrito
Avaliação 1 – 2024.2, Questão I avaliacao_1_ano_2024_2.pdf
Solução comentada (tente antes!)
// A1-2024.2 – Questão I: Área sombreada entre o quadrado e o círculo inscrito
#include <stdio.h> // printf e scanf
#define PI 3.14 // o enunciado manda usar 3.14
int main(void) { // início do programa
double r; // raio do círculo
printf("r: "); // pede o raio
scanf("%lf", &r); // lê o raio
double lado = 2 * r; // o círculo inscrito toca os 4 lados: lado = diâmetro
double quadrado = lado * lado; // área do quadrado = lado²
double circulo = PI * r * r; // área do círculo = π r²
printf("Área sombreada: %.2f\n", quadrado - circulo); // o que sobra do quadrado
return 0; // fim sem erro
}2 Aritmética em C: divisão inteira, resto e conversões Avaliação 1 – 2014.2
Usar /, % e a conversão para double para transformar unidades sem erros de truncamento.
Conceitos
7 / 2vale3(divisão inteira);7 % 2vale1(resto)- Basta um operando real para a conta ser real:
7 / 2.0vale3.5 - Conversão de unidades: total = maior × fator + menor (ex.: minutos = h × 60 + min)
- Volta:
h = total / 60emin = total % 60 - Cast explícito:
(double)soma / n
Resolvida em sala: Graus, minutos e segundos para graus decimais
Avaliação 1 – 2014.2, Questão II avaliacao_1_ano_2014_2.pdf
Solução comentada
// A1-2014.2 – Questão II: Graus, minutos e segundos para graus decimais
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int graus, minutos, segundos; // coordenada lida
printf("Graus minutos segundos: "); // pede os três valores
scanf("%d %d %d", &graus, &minutos, &segundos); // lê os três inteiros
double decimal = graus + minutos / 60.0 + segundos / 3600.0; // 60.0 e 3600.0: divisão real, não inteira
printf("%.5f graus decimais\n", decimal); // 5 casas, como no exemplo da prova
return 0; // fim sem erro
}Para você: Duração de uma aula (hora:minuto)
Avaliação 1 – 2012.2, Questão II avaliacao_1_ano_2012_2.pdf
Solução comentada (tente antes!)
// A1-2012.2 – Questão II: Duração de uma aula (hora:minuto)
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int h1, m1, h2, m2; // entrada (h1:m1) e saída (h2:m2)
printf("Entrada (h m) e saída (h m): "); // pede os dois horários
scanf("%d %d %d %d", &h1, &m1, &h2, &m2); // lê os quatro inteiros
int inicio = h1 * 60 + m1; // tudo em minutos desde 00:00
int fim = h2 * 60 + m2; // idem para a saída
if (fim < inicio) fim = fim + 24 * 60; // saiu depois da meia-noite: soma um dia
int duracao = fim - inicio; // duração em minutos
printf("Duração: %d:%02d\n", duracao / 60, duracao % 60); // / dá as horas, % os minutos restantes
return 0; // fim sem erro
}3 Extraindo dígitos com / e % Avaliação 1 – 2015.2
Separar os dígitos de um número com divisões por 10 e usar o resto para contas circulares.
Conceitos
n % 10é o último dígito;n / 10remove o último dígito- Dígito da posição k (da direita, começando em 0):
(n / 10^k) % 10 - O resto também serve para “dar a volta”: posição circular =
(inicio + passos) % tamanho - Teste com um número em que todos os dígitos são diferentes, ex.: 1234
Resolvida em sala: Soma dos dígitos centrais de um número de 4 dígitos
Avaliação 1 – 2015.2, Questão I avaliacao_1_ano_2015_2.pdf
Solução comentada
// A1-2015.2 – Questão I: Soma dos dígitos centrais de um número de 4 dígitos
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // número menor que 9999
printf("Número: "); // pede o número
scanf("%d", &n); // lê o número
int segundo = (n / 100) % 10; // 4326 / 100 = 43; 43 % 10 = 3
int terceiro = (n / 10) % 10; // 4326 / 10 = 432; 432 % 10 = 2
printf("Soma dos dígitos centrais: %d\n", segundo + terceiro); // 3 + 2 = 5
return 0; // fim sem erro
}Para você: Ponto de término na pista circular
Avaliação 1 – 2026.2, Questão I avaliacao_1_ano_2026_2.pdf
Solução comentada (tente antes!)
// A1-2026.2 – Questão I: Ponto de término na pista circular
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
long c, n; // distância do treino e comprimento da pista (metros)
printf("C (metros do treino) e N (comprimento da pista): "); // pede os dados
scanf("%ld %ld", &c, &n); // %ld lê long (treinos longos cabem)
printf("Deixe a garrafa a %ld metros da partida\n", c % n); // voltas completas não importam: só o resto
return 0; // fim sem erro
}4 Bases numéricas: octal e binário Avaliação 1 – 2012.2
Converter entre bases usando dígitos e potências, validando a entrada.
Conceitos
- Na base b, o número d₂d₁d₀ vale
d2*b*b + d1*b + d0 - Octal só tem dígitos de 0 a 7: valide cada dígito antes de converter
- Para obter os dígitos binários de n:
n % 2, depoisn = n / 2, e repita - Os dígitos saem do menos significativo para o mais significativo
Resolvida em sala: Octal (até 3 dígitos) para decimal
Avaliação 1 – 2012.2, Questão I avaliacao_1_ano_2012_2.pdf
Solução comentada
// A1-2012.2 – Questão I: Octal (até 3 dígitos) para decimal
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // número octal digitado como inteiro (ex.: 435)
printf("Número octal: "); // pede o número
scanf("%d", &n); // lê o número
int d2 = n / 100; // dígito das centenas (4)
int d1 = (n / 10) % 10; // dígito das dezenas (3)
int d0 = n % 10; // dígito das unidades (5)
if (n < 0 || n > 777 || d2 > 7 || d1 > 7 || d0 > 7) { // em octal só existem os dígitos 0 a 7
printf("Número octal inválido\n"); // avisa e termina
return 1; // fim com erro
}
int decimal = d2 * 64 + d1 * 8 + d0; // 4*8² + 3*8¹ + 5*8⁰
printf("(%d)8 = (%d)10\n", n, decimal); // mostra a conversão
return 0; // fim sem erro
}Para você: Quantos dígitos 1 tem o binário de um número entre 0 e 32
Avaliação 1 – 2018.2, Questão I avaliacao_1_ano_2018_2.pdf
Solução comentada (tente antes!)
// A1-2018.2 – Questão I: Quantos dígitos 1 tem o binário de um número entre 0 e 32
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // número entre 0 e 32 (cabe em 6 bits)
printf("Número (0 a 32): "); // pede o número
scanf("%d", &n); // lê o número
int uns = n % 2 // bit de peso 1
+ (n / 2) % 2 // bit de peso 2
+ (n / 4) % 2 // bit de peso 4
+ (n / 8) % 2 // bit de peso 8
+ (n / 16) % 2 // bit de peso 16
+ (n / 32) % 2; // bit de peso 32
printf("%d dígito(s) 1\n", uns); // cada bit vale 0 ou 1: somar conta os uns
return 0; // fim sem erro
}5 Decisão: if/else e operadores lógicos Avaliação 1 – 2014.2
Traduzir condições do enunciado em expressões com &&, || e !.
Conceitos
- Comparação:
==(igual),!=,<,<=,>,>= &&(e): todas verdadeiras;||(ou): basta uma;!nega- Faixas de valores:
if ... else if ... elseem ordem, do menor para o maior - Sempre use chaves
{ }quando o bloco tiver mais de uma linha
Resolvida em sala: Três valores formam um triângulo?
Avaliação 1 – 2014.2, Questão III avaliacao_1_ano_2014_2.pdf
Solução comentada
// A1-2014.2 – Questão III: Três valores formam um triângulo?
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
double a, b, c; // os três comprimentos
printf("Três lados: "); // pede os lados
scanf("%lf %lf %lf", &a, &b, &c); // lê os três valores
if (a < b + c && b < a + c && c < a + b) { // cada lado menor que a soma dos outros dois
printf("Os valores podem ser lados de um triângulo\n"); // desigualdade triangular satisfeita
} else { // basta uma condição falhar
printf("Os valores não podem ser lados de um triângulo\n"); // algum lado é grande demais
}
return 0; // fim sem erro
}Para você: Desconto previdenciário com teto
Avaliação 1 – 2015.2 (versão B), Questão I avaliacao_1_ano_2015_2_B.pdf
Solução comentada (tente antes!)
// A1-2015.2 (B) – Questão I: Desconto previdenciário com teto
#include <stdio.h> // printf e scanf
#define TETO 570.88 // desconto máximo
int main(void) { // início do programa
double salario; // salário lido
printf("Salário: "); // pede o salário
scanf("%lf", &salario); // lê o salário
double desconto = salario * 0.11; // 11% do salário
if (desconto > TETO) desconto = TETO; // passou do teto: fica no teto
printf("Desconto: R$ %.2f\n", desconto); // valor final do desconto
return 0; // fim sem erro
}6 Decisões encadeadas e arredondamento para cima Avaliação 1 – 2015.2 (versão B)
Escolher um valor por faixa ou categoria e arredondar para cima só com aritmética.
Conceitos
- Categoria → valor:
if (c == 1) v = ...; else if (c == 2) ... - Converter para
inttrunca:(int)2.9vale 2 - Arredondar para cima sem biblioteca: trunca e, se sobrou, soma 1
- Com inteiros positivos:
(a + b - 1) / bé a divisão arredondada para cima - Trate a categoria inválida no
elsefinal
Resolvida em sala: Número de lâmpadas de 60 W para um cômodo
Avaliação 1 – 2015.2 (versão B), Questão III avaliacao_1_ano_2015_2_B.pdf
Solução comentada
// A1-2015.2 (B) – Questão III: Número de lâmpadas de 60 W para um cômodo
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int classe; // 1 (I), 2 (II) ou 3 (III)
double largura, comprimento; // dimensões do cômodo em metros
printf("Classe (1, 2 ou 3), largura e comprimento: "); // pede os dados
scanf("%d %lf %lf", &classe, &largura, &comprimento); // lê os três valores
int watts_m2; // potência mínima por m² da classe
if (classe == 1) watts_m2 = 12; // quarto, sala de TV
else if (classe == 2) watts_m2 = 15; // sala, cozinha, varanda
else if (classe == 3) watts_m2 = 20; // banheiro, escritório
else { printf("Classe inválida\n"); return 1; } // qualquer outro valor é erro
double potencia = largura * comprimento * watts_m2; // potência total exigida
int lampadas = (int)(potencia / 60); // parte inteira: 2,4 lâmpadas viram 2...
if (lampadas * 60 < potencia) lampadas++; // ...e se sobrou potência, mais uma: arredonda para cima
printf("%d lâmpada(s) de 60 W\n", lampadas); // resultado
return 0; // fim sem erro
}Para você: Zip – quem ganhou a partida?
Avaliação 1 – 2026.2, Questão I avaliacao_1_ano_2026_2.pdf
Solução comentada (tente antes!)
// A1-2026.2 – Questão I: Zip – quem ganhou a partida?
#include <stdio.h> // printf e scanf
#include <stdlib.h> // abs
int main(void) { // início do programa
int a, b, c, d; // cartas de Lia (a, b) e de Mia (c, d)
printf("Cartas de Lia e de Mia: "); // pede as quatro cartas
scanf("%d %d %d %d", &a, &b, &c, &d); // lê as quatro cartas
int lia = a + b; // pontuação básica: a soma
if (a == b) lia = lia * 2; // cartas iguais: dobra
else if (abs(a - b) == 1) lia = lia * 3; // consecutivas (diferença 1): triplica
int mia = c + d; // a mesma regra para Mia
if (c == d) mia = mia * 2; // cartas iguais
else if (abs(c - d) == 1) mia = mia * 3; // consecutivas
if (lia > mia) printf("Lia\n"); // maior pontuação vence
else if (mia > lia) printf("Mia\n"); // idem
else printf("empate\n"); // iguais: aposta acumula
return 0; // fim sem erro
}7 Comparações em vários níveis Avaliação 1 – 2015.2
Decidir comparando critérios em ordem de prioridade (anos, depois meses, depois dias).
Conceitos
- Compare o critério mais importante; só se empatar, passe ao próximo
- Truque: guardar a diferença e trocar de critério se ela for 0
- Três saídas possíveis: maior, menor, igual. Teste as três
- Alternativa: converter tudo para uma unidade (dias) e comparar uma vez
Resolvida em sala: Quem é mais velho? (anos, meses e dias)
Avaliação 1 – 2015.2, Questão IV avaliacao_1_ano_2015_2.pdf
Solução comentada
// A1-2015.2 – Questão IV: Quem é mais velho? (anos, meses e dias)
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int a1, m1, d1, a2, m2, d2; // idade de cada pessoa: anos, meses, dias
printf("Idade da 1ª pessoa (anos meses dias): "); // pede a primeira idade
scanf("%d %d %d", &a1, &m1, &d1); // lê os três valores
printf("Idade da 2ª pessoa (anos meses dias): "); // pede a segunda idade
scanf("%d %d %d", &a2, &m2, &d2); // lê os três valores
int dif = a1 - a2; // compara primeiro os anos
if (dif == 0) dif = m1 - m2; // anos iguais: desempata pelos meses
if (dif == 0) dif = d1 - d2; // meses iguais: desempata pelos dias
if (dif > 0) printf("A primeira pessoa é mais velha\n"); // mais tempo de vida = mais velha
else if (dif < 0) printf("A segunda pessoa é mais velha\n"); // idem para a segunda
else printf("As duas pessoas têm a mesma idade\n"); // tudo igual
return 0; // fim sem erro
}Para você: Gangorra – equilibrada ou pende para qual lado?
Avaliação 1 – 2017.1, Questão III avaliacao_1_ano_2017_1.pdf
Solução comentada (tente antes!)
// A1-2017.1 – Questão III: Gangorra – equilibrada ou pende para qual lado?
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int p1, c1, p2, c2; // pesos e comprimentos dos lados 1 e 2
printf("P1 C1 P2 C2: "); // pede os quatro valores
scanf("%d %d %d %d", &p1, &c1, &p2, &c2); // lê os quatro valores
int lado1 = p1 * c1; // momento do lado 1
int lado2 = p2 * c2; // momento do lado 2
if (lado1 == lado2) printf("A gangorra fica equilibrada\n"); // P1 x C1 = P2 x C2
else if (lado1 > lado2) printf("A gangorra pende para o lado 1\n"); // lado 1 mais "pesado"
else printf("A gangorra pende para o lado 2\n"); // senão, pende para o lado 2
return 0; // fim sem erro
}8 switch: escolha entre muitos casos Avaliação 1 – 2012.2
Usar switch para mapear valores a textos e combinar com / e %.
Conceitos
switch (x) { case 1: ...; break; default: ...; }comparaxcom constantes- Sem
break, a execução “cai” no próximocase defaulttrata todos os valores não listados- Combine:
dia / 10dá a dezena,dia % 10a unidade
Resolvida em sala: Data por extenso
Avaliação 1 – 2012.2, Questão IV avaliacao_1_ano_2012_2.pdf
Solução comentada
// A1-2012.2 – Questão IV: Data por extenso
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int dia, mes; // data lida
printf("Dia e mês: "); // pede a data
scanf("%d %d", &dia, &mes); // lê os dois inteiros
if (dia < 1 || dia > 31 || mes < 1 || mes > 12) { // validação básica
printf("Data inválida\n"); // avisa
return 1; // fim com erro
}
if (dia == 1) printf("primeiro"); // o dia 1 tem nome próprio
else if (dia >= 10 && dia <= 19) { // 10 a 19: nomes especiais
switch (dia) { // escolhe pelo valor exato
case 10: printf("dez"); break; // cada caso imprime e sai do switch
case 11: printf("onze"); break;
case 12: printf("doze"); break;
case 13: printf("treze"); break;
case 14: printf("quatorze"); break;
case 15: printf("quinze"); break;
case 16: printf("dezesseis"); break;
case 17: printf("dezessete"); break;
case 18: printf("dezoito"); break;
default: printf("dezenove"); break; // sobrou o 19
}
} else { // demais: dezena + "e" + unidade
if (dia / 10 == 2) printf("vinte"); // 20 a 29
if (dia / 10 == 3) printf("trinta"); // 30 e 31
if (dia >= 20 && dia % 10 != 0) printf(" e "); // 21, 22...: "vinte e ..."
switch (dia % 10) { // a unidade
case 1: printf("um"); break;
case 2: printf("dois"); break;
case 3: printf("três"); break;
case 4: printf("quatro"); break;
case 5: printf("cinco"); break;
case 6: printf("seis"); break;
case 7: printf("sete"); break;
case 8: printf("oito"); break;
case 9: printf("nove"); break;
} // unidade 0 (20, 30): nada a imprimir
}
printf(" de "); // ligação entre dia e mês
switch (mes) { // nome do mês
case 1: printf("janeiro"); break;
case 2: printf("fevereiro"); break;
case 3: printf("março"); break;
case 4: printf("abril"); break;
case 5: printf("maio"); break;
case 6: printf("junho"); break;
case 7: printf("julho"); break;
case 8: printf("agosto"); break;
case 9: printf("setembro"); break;
case 10: printf("outubro"); break;
case 11: printf("novembro"); break;
default: printf("dezembro"); break; // sobrou o 12
}
printf("\n"); // termina a linha
return 0; // fim sem erro
}Para você: Jogo do bicho – valor do prêmio
Avaliação 1 – 2017.1, Questão II avaliacao_1_ano_2017_1.pdf
Solução comentada (tente antes!)
// A1-2017.1 – Questão II: Jogo do bicho – valor do prêmio
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
double v; // valor apostado
int n, m; // número apostado e número sorteado
printf("Valor, número apostado e número sorteado: "); // pede os dados
scanf("%lf %d %d", &v, &n, &m); // lê os três valores
int dn = n % 100, dm = m % 100; // dois últimos dígitos (dezena e unidade)
if (dn == 0) dn = 100; // 00 pertence ao último grupo (97, 98, 99, 00)
if (dm == 0) dm = 100; // idem
double premio; // valor a receber
if (n % 10000 == m % 10000) premio = v * 3000; // milhar: quatro últimos dígitos iguais
else if (n % 1000 == m % 1000) premio = v * 500; // centena: três últimos
else if (n % 100 == m % 100) premio = v * 50; // dezena: dois últimos
else if ((dn - 1) / 4 == (dm - 1) / 4) premio = v * 16; // mesmo grupo: 01-04 → 0, 05-08 → 1...
else premio = 0; // nenhum critério
printf("Prêmio: R$ %.2f\n", premio); // o else if garante só o maior prêmio
return 0; // fim sem erro
}9 Geometria com condições: pontos e regiões Avaliação 1 – 2025.2
Decidir se pontos estão dentro de regiões e calcular sobreposições com max/min.
Conceitos
- Ponto dentro de um retângulo:
x >= xmin && x <= xmax && y >= ymin && y <= ymax - Faça o desenho com eixos e teste os pontos da borda
- Sobreposição de intervalos [a1, b1] e [a2, b2]: de
max(a1, a2)atémin(b1, b2) - Se
max(a1, a2) >= min(b1, b2), não há sobreposição
Resolvida em sala: Beach tennis – a bola caiu dentro ou fora?
Avaliação 1 – 2025.2, Questão I avaliacao_1_ano_2025_2.pdf
Solução comentada
// A1-2025.2 – Questão I: Beach tennis – a bola caiu dentro ou fora?
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int k, x, y; // tamanho da quadra e coordenada da bola
printf("k, x e y: "); // pede os dados
scanf("%d %d %d", &k, &x, &y); // lê os três inteiros
// a quadra 2k x k tem o juiz no meio da linha de base: x vai de -k a k e y de 0 a k
if (x >= -k && x <= k && y >= 0 && y <= k) { // em cima da linha conta como dentro (>= e <=)
printf("dentro\n"); // bola válida
} else { // qualquer coordenada fora dos limites
printf("fora\n"); // bola fora
}
return 0; // fim sem erro
}Para você: Área de reserva (sobreposição de dois terrenos)
Avaliação 1 – 2023.1, Questão I avaliacao_1_ano_2023_1.pdf
Solução comentada (tente antes!)
// A1-2023.1 – Questão I: Área de reserva (sobreposição de dois terrenos)
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int x1, y1, v1, h1, x2, y2, v2, h2; // canto superior esquerdo, dimensão vertical e horizontal
printf("Terreno 1 (x y vertical horizontal) e terreno 2: "); // pede os oito valores
scanf("%d %d %d %d %d %d %d %d", &x1, &y1, &v1, &h1, &x2, &y2, &v2, &h2); // posição, velocidade e direção de cada carro
// no mapa o y cresce para baixo: o terreno 1 ocupa x de x1 a x1+h1 e y de y1 a y1+v1
int esq = x1 > x2 ? x1 : x2; // borda esquerda da sobreposição: o maior dos x
int dir = (x1 + h1) < (x2 + h2) ? (x1 + h1) : (x2 + h2); // borda direita: a menor das direitas
int topo = y1 > y2 ? y1 : y2; // borda de cima: o maior dos y
int base = (y1 + v1) < (y2 + v2) ? (y1 + v1) : (y2 + v2); // borda de baixo: a menor das bases
if (esq < dir && topo < base) { // largura e altura positivas: existe área
printf("%d %d %d %d\n", esq, topo, dir - esq, base - topo); // x, y, horizontal, vertical
} else { // só encostam ou nem se tocam
printf("NÃO EXISTE ÁREA SUGERIDA\n"); // mensagem pedida
}
return 0; // fim sem erro
}10 Modelagem: do enunciado à conta Avaliação 1 – 2025.2
Transformar uma situação do dia a dia em contas com / e % e decisões simples.
Conceitos
- Leia o enunciado duas vezes e liste: dados, o que imprimir, restrições
- Faça 2 exemplos à mão antes de programar
- Pontos igualmente espaçados: ponto anterior =
d / p, distância até ele =d % p - Escolher o mais próximo: comparar
restocomp - resto
Resolvida em sala: Luiza – em que ponto descer e quanto andar
Avaliação 1 – 2025.2, Questão II avaliacao_1_ano_2025_2.pdf
Solução comentada
// A1-2025.2 – Questão II: Luiza – em que ponto descer e quanto andar
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int m, p, d; // tamanho da avenida, distância entre pontos, distância da escola
printf("M, P e D (metros): "); // pede os dados
scanf("%d %d %d", &m, &p, &d); // lê os três inteiros
if (d < 0 || d > m || p <= 0 || m % p != 0) { // dados fora do que o enunciado garante
printf("Dados inválidos\n"); // avisa
return 1; // fim com erro
}
int antes = d / p; // índice do ponto anterior à escola (0 = primeiro)
int resto = d % p; // metros entre esse ponto e a escola
if (resto * 2 <= p) { // a escola está mais perto do ponto anterior
printf("Descer no ponto %d e andar %d metros em direção ao Fim da Avenida\n", antes + 1, resto); // mais perto do ponto anterior: anda para a frente
} else { // mais perto do ponto seguinte
printf("Descer no ponto %d e andar %d metros em direção ao Início da Avenida\n", antes + 2, p - resto); // mais perto do próximo ponto: anda de volta
}
return 0; // fim sem erro
}Para você: Acelerador de partículas – qual sensor foi atingido?
Avaliação 1 – 2024.1, Questão I avaliacao_1_ano_2024_1.pdf
Solução comentada (tente antes!)
// A1-2024.1 – Questão I: Acelerador de partículas – qual sensor foi atingido?
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int d; // distância total percorrida (km)
printf("Distância total (km): "); // pede a distância
scanf("%d", &d); // lê a distância
// pela figura: os trechos fixos do emissor ao acelerador e da saída ao sensor somam 5 km,
// e cada volta completa tem 8 km; o que sobra das voltas indica a saída (1, 2 ou 3)
int sensor = (d - 5) % 8; // resto depois de tirar os trechos fixos e as voltas
if (sensor >= 1 && sensor <= 3) printf("A partícula atinge o sensor %d\n", sensor); // só existem os sensores 1, 2 e 3
else printf("Distância incompatível com o acelerador\n"); // não corresponde a nenhuma saída
return 0; // fim sem erro
}11 Bits: XOR, AND e deslocamento Avaliação 1 – 2026.1
Manipular os bits de um inteiro com ^, & e >>.
Conceitos
a ^ b(XOR): bit 1 ondeaebdiferemx & 1é o último bit;x >> kdesloca k casas para a direita- Bit k de x:
(x >> k) & 1 - Inverter o bit k:
x ^ (1 << k) - Equivalente sem bits:
% 2e/ 2
Resolvida em sala: Números n-binariamente distintos
Avaliação 1 – 2026.1, Questão II avaliacao_1_ano_2026_1.pdf
Solução comentada
// A1-2026.1 – Questão II: Números n-binariamente distintos
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n, a, b; // limiar n e os dois números (menores que 16)
printf("n, a e b: "); // pede os dados
scanf("%d %d %d", &n, &a, &b); // lê os três inteiros
int x = a ^ b; // OU exclusivo: bit 1 onde a e b diferem
int diferentes = (x & 1) + ((x >> 1) & 1) + ((x >> 2) & 1) + ((x >> 3) & 1); // conta os 4 bits
if (diferentes >= n) printf("%d e %d são %d-binariamente distintos\n", a, b, n); // bits diferentes suficientes
else printf("%d e %d não são %d-binariamente distintos\n", a, b, n); // menos bits diferentes que n
return 0; // fim sem erro
}Para você: Mutação por swap (inverter um bit)
Avaliação 1 – 2023.2, Questão II avaliacao_1_ano_2023_2.pdf
Solução comentada (tente antes!)
// A1-2023.2 – Questão II: Mutação por swap (inverter um bit)
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int individuo, bit; // número entre 0 e 35 e bit entre 0 e 4
printf("Indivíduo (0 a 35) e bit (0 a 4): "); // pede os dados
scanf("%d %d", &individuo, &bit); // lê os dois inteiros
if (individuo < 0 || individuo > 35 || bit < 0 || bit > 4) { // fora dos limites do enunciado
printf("Valores inválidos\n"); // avisa
return 1; // fim com erro
}
int mascara = 1 << bit; // 1 deslocado: só o bit escolhido ligado (bit 3 → 01000)
int mutante = individuo ^ mascara; // XOR inverte exatamente esse bit
printf("Novo indivíduo: %d\n", mutante); // 28 (11100) → 20 (10100)
return 0; // fim sem erro
}12 Avaliação I Avaliação
Prova do Bloco 1, no formato das avaliações anteriores. Abaixo, uma prova-modelo com duas questões de provas passadas.
Prova-modelo
Questão 1: Cadeado de três rodas – menor número de movimentos
Avaliação 1 – 2024.1, Questão II avaliacao_1_ano_2024_1.pdf
Solução comentada
// A1-2024.1 – Questão II: Cadeado de três rodas – menor número de movimentos
#include <stdio.h> // printf e scanf
#include <stdlib.h> // abs
int main(void) { // início do programa
int atual, segredo; // números de 3 dígitos
printf("Número atual e segredo: "); // pede os dois números
scanf("%d %d", &atual, &segredo); // lê os dois inteiros
int total = 0; // acumula os movimentos
int d; // diferença em uma roda
d = abs(atual / 100 - segredo / 100); // roda das centenas
total += d < 10 - d ? d : 10 - d; // o menor caminho: para cima (d) ou para baixo (10 - d)
d = abs((atual / 10) % 10 - (segredo / 10) % 10); // roda das dezenas
total += d < 10 - d ? d : 10 - d; // mesma regra
d = abs(atual % 10 - segredo % 10); // roda das unidades
total += d < 10 - d ? d : 10 - d; // mesma regra
printf("Movimentos: %d\n", total); // 2 + 2 + 1 = 5 no exemplo
return 0; // fim sem erro
}Questão 2: Teleférico – número mínimo de viagens
Avaliação 1 – 2026.1, Questão I avaliacao_1_ano_2026_1.pdf
Solução comentada
// A1-2026.1 – Questão I: Teleférico – número mínimo de viagens
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int capacidade, alunos; // pessoas por viagem (>= 2) e total de alunos
printf("Capacidade da cabine e número de alunos: "); // pede os dados
scanf("%d %d", &capacidade, &alunos); // lê os dois inteiros
int por_viagem = capacidade - 1; // uma vaga é sempre do monitor
int viagens = (alunos + por_viagem - 1) / por_viagem; // divisão arredondada para cima, só com inteiros
printf("Mínimo de viagens: %d\n", viagens); // 20 alunos, 9 por viagem → 3
return 0; // fim sem erro
}Banco de questões do Bloco 112 questões
Outras questões de provas anteriores com o conteúdo do bloco, para treinar.
- Avaliação 1 – 2012.2, Questão III avaliacao_1_ano_2012_2.pdf
- Avaliação 1 – 2015.2, Questão II avaliacao_1_ano_2015_2.pdf
- Avaliação 1 – 2015.2, Questão III avaliacao_1_ano_2015_2.pdf
- Avaliação 1 – 2015.2 (versão B), Questão II avaliacao_1_ano_2015_2_B.pdf
- Avaliação 1 – 2017.1, Questão I avaliacao_1_ano_2017_1.pdf
- Avaliação 1 – 2022.1, Questão I avaliacao_1_ano_2022_1.pdf
- Avaliação 1 – 2022.1 (versão B), Questão I avaliacao_1_ano_2022_1_B.pdf
- Avaliação 1 – 2023.1, Questão II avaliacao_1_ano_2023_1.pdf
- Avaliação 1 – 2023.2, Questão I avaliacao_1_ano_2023_2.pdf
- Avaliação 1 – 2024.1 (versão B), Questão II avaliacao_1_ano_2024_1_B.pdf
- Avaliação 1 – 2024.2, Questão II avaliacao_1_ano_2024_2.pdf
- Avaliação 1 – 2024.2 (versão C), Questão I avaliacao_1_ano_2024_2_C.pdf
Bloco 2 Repetição, funções e vetores
while e for, acumuladores, laços aninhados, funções, vetores, janelas e simulação. Termina com a Avaliação II.
13 while: repetir até uma condição Avaliação 2 – 2016.1
Repetir enquanto a condição for verdadeira e contar quantas vezes repetiu.
Conceitos
while (condição) { ... }testa antes de cada repetição- Algo dentro do laço precisa mudar a condição, senão é laço infinito
- Contador:
anos = 0antes,anos++dentro - A condição do
whileé o contrário da condição de parada
Resolvida em sala: Em quantos anos Zé fica maior que Chico?
Avaliação 2 – 2016.1, Questão I avaliacao_2_ano_2016_1.pdf
Solução comentada
// A2-2016.1 – Questão I: Em quantos anos Zé fica maior que Chico?
#include <stdio.h> // printf
int main(void) { // início do programa
int chico = 150, ze = 110; // alturas em centímetros (inteiros evitam erro de arredondamento)
int anos = 0; // contador de anos
while (ze <= chico) { // repete ENQUANTO Zé ainda não passou Chico
chico += 2; // Chico cresce 2 cm por ano
ze += 3; // Zé cresce 3 cm por ano
anos++; // passou mais um ano
}
printf("Zé fica maior que Chico em %d anos (%d cm x %d cm)\n", anos, ze, chico); // resultado
return 0; // fim sem erro
}Para você: Tempo para o material radioativo chegar à massa final
Avaliação 2 – 2024.2, Questão I avaliacao_2_ano_2024_2.pdf
Solução comentada (tente antes!)
// A2-2024.2 – Questão I: Tempo para o material radioativo chegar à massa final
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
double massa, final; // massa inicial e massa final desejada
printf("Massa inicial e massa final: "); // pede os dados
scanf("%lf %lf", &massa, &final); // lê os dois valores
int minutos = 0; // contador de minutos
while (massa > final) { // ainda acima da massa desejada
massa = massa * 0.9; // perde 10% por minuto: sobra 90%
minutos++; // passou um minuto
}
printf("Tempo necessário: %d minutos (massa = %.2f)\n", minutos, massa); // resultado
return 0; // fim sem erro
}14 for e acumuladores: somatórios Avaliação 2 – 2014.2
Calcular somas de séries com for e um acumulador.
Conceitos
for (int k = 1; k <= n; k++): início, condição, passo- Acumulador:
soma = 0antes;soma += termodentro - Um termo que depende do anterior: guarde-o numa variável (ex.: triangular += k)
- Frações:
1.0 / t, nunca1 / t
Resolvida em sala: Soma dos recíprocos dos números triangulares
Avaliação 2 – 2014.2, Questão III avaliacao_2_ano_2014_2.pdf
Solução comentada
// A2-2014.2 – Questão III: Soma dos recíprocos dos números triangulares
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // quantidade de termos
printf("N: "); // pede N
scanf("%d", &n); // lê N
long triangular = 0; // número triangular atual
double soma = 0; // acumulador da série (começa em zero)
for (int k = 1; k <= n; k++) { // k-ésimo termo
triangular += k; // o próximo triangular é o anterior + k
soma += 1.0 / triangular; // 1.0: divisão real (1 / 3 inteiro daria 0)
}
printf("S = %.6f\n", soma); // 1 + 1/3 + 1/6 + ...
return 0; // fim sem erro
}Para você: Raiz quadrada subtraindo ímpares consecutivos
Avaliação 2 – 2014.2, Questão I avaliacao_2_ano_2014_2.pdf
Solução comentada (tente antes!)
// A2-2014.2 – Questão I: Raiz quadrada subtraindo ímpares consecutivos
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // número positivo
printf("Número: "); // pede o número
scanf("%d", &n); // lê o número
int resto = n; // vai sendo reduzido pelos ímpares
int vezes = 0; // quantas subtrações foram feitas
for (int impar = 1; resto > 0; impar += 2) { // 1, 3, 5, ... enquanto o resultado for positivo
resto -= impar; // subtrai o próximo ímpar
vezes++; // conta a subtração
}
if (resto == 0) printf("A raiz exata de %d é %d\n", n, vezes); // terminou em zero: exata
else printf("A raiz aproximada de %d é %d\n", n, vezes); // passou de zero: aproximada
return 0; // fim sem erro
}15 Laço sobre os dígitos Avaliação 1 – 2014.2
Percorrer os dígitos de um número de tamanho qualquer com while (n > 0).
Conceitos
while (n > 0) { d = n % 10; ...; n = n / 10; }visita todos os dígitos- A ordem é da direita para a esquerda (unidade primeiro)
- Posição do dígito: um contador que começa em 1
- Em outra base b: troque 10 por b
Resolvida em sala: Validação pelo algoritmo de Luhn (até 4 dígitos)
Avaliação 1 – 2014.2, Questão IV avaliacao_1_ano_2014_2.pdf
Solução comentada
// A1-2014.2 – Questão IV: Validação pelo algoritmo de Luhn (até 4 dígitos)
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // número de até 4 dígitos
printf("Número: "); // pede o número
scanf("%d", &n); // lê o número
int soma = 0; // somatório de Luhn
int posicao = 1; // 1 = unidade (o primeiro após inverter)
while (n > 0) { // percorre os dígitos da direita para a esquerda
int d = n % 10; // dígito atual
if (posicao % 2 == 0) { // posições pares: dobra
d = d * 2; // multiplica por 2
if (d > 9) d = d - 9; // "noves fora": 12 → 3, 16 → 7
}
soma += d; // acumula
n = n / 10; // descarta o dígito já tratado
posicao++; // próxima posição
}
if (soma % 10 == 0) printf("Número Válido\n"); // somatório múltiplo de 10
else printf("Número Inválido\n"); // senão, inválido
return 0; // fim sem erro
}Para você: Dígito verificador da Setelândia (base 7)
Avaliação 1 – 2018.2, Questão II avaliacao_1_ano_2018_2.pdf
Solução comentada (tente antes!)
// A1-2018.2 – Questão II: Dígito verificador da Setelândia (base 7)
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // número de 0 a 999
printf("Número (0 a 999): "); // pede o número
scanf("%d", &n); // lê o número
int soma = 0; // soma dos algarismos na base 7
int resto = n; // cópia que será dividida
while (resto > 0) { // conversão para base 7, dígito a dígito
soma += resto % 7; // o resto da divisão por 7 é o próximo dígito
resto = resto / 7; // passa para a próxima posição
}
int dv = soma % 7; // dígito verificador
printf("%d%d\n", n, dv); // o DV vai à direita do número original
return 0; // fim sem erro
}16 Laços com condição de parada incerta Avaliação 1 – 2024.1 (versão B)
Simular processos que param em um número desconhecido de passos.
Conceitos
- Quando não se sabe quantas repetições, use
while - Cada repetição aplica a regra uma vez
- Conte os passos ou os termos (inclua o primeiro, se o enunciado pedir)
- Valores que crescem muito:
long
Resolvida em sala: Collatz – quantos números até chegar a 1
Avaliação 1 – 2024.1 (versão B), Questão I avaliacao_1_ano_2024_1_B.pdf
Solução comentada
// A1-2024.1 (B) – Questão I: Collatz – quantos números até chegar a 1
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
long n; // long: a sequência sobe bastante antes de descer
printf("Número: "); // pede o número
scanf("%ld", &n); // lê o número
int termos = 1; // o próprio número já conta
while (n != 1) { // até chegar a 1
if (n % 2 == 0) n = n / 2; // par: divide por 2
else n = 3 * n + 1; // ímpar: 3n + 1
termos++; // mais um número na sequência
}
printf("%d números na sequência\n", termos); // 5: 5, 16, 8, 4, 2, 1 → 6
return 0; // fim sem erro
}Para você: Meia-vida – quando o paciente fica intoxicado tomando de 6 em 6 horas
Avaliação 2 – 2026.1, Questão I avaliacao_2_ano_2026_1.pdf
Solução comentada (tente antes!)
// A2-2026.1 – Questão I: Meia-vida – quando o paciente fica intoxicado tomando de 6 em 6 horas
#include <stdio.h> // printf
#define DOSE 800.0 // mg por comprimido
#define LIMITE 1520.0 // acima disso: superdosagem
int main(void) { // início do programa
double teor = DOSE; // primeira dose na hora 0
int horas = 0; // relógio do tratamento
while (teor <= LIMITE) { // ainda não intoxicou
horas += 6; // passam 6 horas (uma meia-vida)
teor = teor / 2 + DOSE; // metade foi metabolizada e entra nova dose
printf("Hora %2d: %.0f mg\n", horas, teor); // mostra a evolução: 1200, 1400, 1500, 1550
}
printf("Intoxicado em %d horas\n", horas); // primeira vez acima de 1520 mg
return 0; // fim sem erro
}17 Laços aninhados: primos e divisores Avaliação 2 – 2014.2
Usar um laço dentro de outro para testar divisibilidade.
Conceitos
- n é primo se nenhum d de 2 até √n divide n
- Condição
d * d <= nevitasqrt - Laço externo escolhe candidatos; interno testa cada um
- Bandeira (flag):
primo = 1antes,primo = 0ao achar divisor
Resolvida em sala: Os N primeiros pares de primos gêmeos
Avaliação 2 – 2014.2, Questão II avaliacao_2_ano_2014_2.pdf
Solução comentada
// A2-2014.2 – Questão II: Os N primeiros pares de primos gêmeos
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // quantos pares mostrar
printf("N: "); // pede N
scanf("%d", &n); // lê N
int achados = 0; // pares já mostrados
for (int p = 3; achados < n; p += 2) { // candidatos ímpares 3, 5, 7...
int p_primo = 1, q_primo = 1; // supõe que p e p + 2 são primos
for (int d = 3; d * d <= p + 2; d += 2) { // testa divisores ímpares até a raiz
if (p % d == 0 && d < p) p_primo = 0; // d divide p (e não é o próprio p)
if ((p + 2) % d == 0 && d < p + 2) q_primo = 0; // d divide p + 2
}
if (p_primo && q_primo) { // os dois primos: é um par de gêmeos
printf("(%d, %d)\n", p, p + 2); // mostra o par
achados++; // conta o par
}
}
return 0; // fim sem erro
}Para você: sigma(n), a soma dos divisores, para n de 1 a N
Avaliação 2 – 2019.2, Questão III avaliacao_2_ano_2019_2.pdf
Solução comentada (tente antes!)
// A2-2019.2 – Questão III: sigma(n), a soma dos divisores, para n de 1 a N
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // limite N
printf("N: "); // pede N
scanf("%d", &n); // lê N
for (int k = 1; k <= n; k++) { // laço de fora: cada k da lista
int sigma = 0; // soma dos divisores de k
for (int d = 1; d <= k; d++) { // laço de dentro: candidatos a divisor
if (k % d == 0) sigma += d; // d divide k: soma
}
printf("%d%s", sigma, k < n ? ", " : "\n"); // vírgula entre os termos, quebra no fim
}
return 0; // fim sem erro
}18 Funções: dividir para conquistar Avaliação 2 – 2016.2
Escrever funções com parâmetros e retorno e reutilizá-las.
Conceitos
int nome(int x) { ... return valor; }- Declare a função antes do
main(ou o protótipo) - Uma função = uma pergunta:
e_primo(n)responde 1 ou 0 - Variáveis dentro da função são locais
Resolvida em sala: Primo de Chen (com funções)
Avaliação 2 – 2016.2, Questão I avaliacao_2_ano_2016_2.pdf
Solução comentada
// A2-2016.2 – Questão I: Primo de Chen (com funções)
#include <stdio.h> // printf e scanf
int e_primo(int n) { // devolve 1 se n for primo, 0 se não
if (n < 2) return 0; // 0 e 1 não são primos
for (int d = 2; d * d <= n; d++) // basta testar até a raiz
if (n % d == 0) return 0; // achou divisor: não é primo
return 1; // nenhum divisor: primo
}
int e_semiprimo(int n) { // 1 se n for o produto de dois primos
for (int d = 2; d * d <= n; d++) // menor fator possível
if (n % d == 0) return e_primo(d) && e_primo(n / d); // primeiro divisor: os dois fatores são primos?
return 0; // sem divisores: é primo, não semiprimo
}
int main(void) { // início do programa
int p; // número lido
printf("Número: "); // pede o número
scanf("%d", &p); // lê o número
if (!e_primo(p)) printf("%d não é primo\n", p); // primo de Chen precisa ser primo
else if (e_primo(p + 2) || e_semiprimo(p + 2)) printf("%d é primo de Chen\n", p); // p + 2 primo ou semiprimo: definição de Chen
else printf("%d não é primo de Chen\n", p); // p + 2 tem 3 ou mais fatores primos
return 0; // fim sem erro
}Para você: Números brasileiros
Avaliação 2 – 2016.1, Questão II avaliacao_2_ano_2016_1.pdf
Solução comentada (tente antes!)
// A2-2016.1 – Questão II: Números brasileiros
#include <stdio.h> // printf e scanf
int digitos_iguais(int n, int base) { // 1 se n escrito na base tiver todos os dígitos iguais
int ultimo = n % base; // dígito menos significativo
while (n > 0) { // percorre os dígitos na base
if (n % base != ultimo) return 0; // achou um dígito diferente
n = n / base; // próximo dígito
}
return 1; // todos iguais
}
int main(void) { // início do programa
int n; // número lido
printf("Número: "); // pede o número
scanf("%d", &n); // lê o número
for (int b = 2; b < n - 1; b++) { // bases possíveis: 1 < b < n - 1
if (digitos_iguais(n, b)) { // achou uma base que funciona
printf("%d é brasileiro (base %d)\n", n, b); // ex.: 7 = (111) na base 2
return 0; // basta uma base
}
}
printf("%d não é brasileiro\n", n); // nenhuma base serviu
return 0; // fim sem erro
}19 Vetores: guardar para comparar Avaliação 2 – 2025.2
Ler valores em um vetor e comparar cada elemento com o anterior.
Conceitos
int v[N];reserva N inteiros:v[0]av[N-1]- Ler:
for (i = 0; i < N; i++) scanf("%d", &v[i]); - Comparar com o anterior: comece o laço em 1 e use
v[i - 1] - Vetor de contagem:
cont[d]++conta quantas vezes d aparece
Resolvida em sala: Maior sequência de valores consecutivos iguais
Avaliação 2 – 2025.2, Questão II avaliacao_2_ano_2025_2.pdf
Solução comentada
// A2-2025.2 – Questão II: Maior sequência de valores consecutivos iguais
#include <stdio.h> // printf e scanf
#define N 11 // quantidade de números sorteados
int main(void) { // início do programa
int v[N]; // vetor com os 11 números
for (int i = 0; i < N; i++) scanf("%d", &v[i]); // lê os 11 valores
int atual = 1, maior = 1; // tamanho da sequência atual e da maior até agora
for (int i = 1; i < N; i++) { // compara cada valor com o anterior
if (v[i] == v[i - 1]) atual++; // igual ao anterior: a sequência cresce
else atual = 1; // diferente: começa uma nova sequência
if (atual > maior) maior = atual; // guarda o recorde
}
printf("%d pontos\n", maior); // tamanho da maior sequência
return 0; // fim sem erro
}Para você: Quantas vezes cada dígito aparece de A até B
Avaliação 1 – 2022.1 (versão B), Questão II avaliacao_1_ano_2022_1_B.pdf
Solução comentada (tente antes!)
// A1-2022.1 (B) – Questão II: Quantas vezes cada dígito aparece de A até B
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int a, b; // intervalo [A, B]
printf("A e B: "); // pede o intervalo
scanf("%d %d", &a, &b); // lê os dois limites
int conta[10] = {0}; // conta[d] = quantas vezes o dígito d apareceu (tudo zero)
for (int n = a; n <= b; n++) { // cada número do intervalo
int x = n; // cópia para desmontar em dígitos
while (x > 0) { // percorre os dígitos (sem zeros à esquerda)
conta[x % 10]++; // o dígito vira o índice do vetor
x /= 10; // próximo dígito
}
}
for (int d = 0; d < 10; d++) printf("%d%s", conta[d], d < 9 ? " " : "\n"); // as 10 contagens
return 0; // fim sem erro
}20 Janelas deslizantes Avaliação 2 – 2025.2
Calcular algo (soma, média, máximo) em todos os blocos de tamanho fixo de um vetor.
Conceitos
- Janela de tamanho J começando em
ini: posiçõesiniaini + J - 1 - Inícios válidos:
ini + J <= N - Laço externo: início; interno: percorre a janela
- Maior/menor: inicialize com um valor impossível ou com a primeira janela
Resolvida em sala: Maior e menor média de temperatura em janelas de tamanho dado
Avaliação 2 – 2025.2, Questão I avaliacao_2_ano_2025_2.pdf
Solução comentada
// A2-2025.2 – Questão I: Maior e menor média de temperatura em janelas de tamanho dado
#include <stdio.h> // printf e scanf
#define N 12 // quantidade de temperaturas
int main(void) { // início do programa
int t[N]; // temperaturas medidas
int janela; // tamanho do intervalo
for (int i = 0; i < N; i++) scanf("%d", &t[i]); // lê as 12 temperaturas
scanf("%d", &janela); // lê o tamanho do intervalo
double maior = -500, menor = 500; // o enunciado garante valores entre -500 e 500
for (int ini = 0; ini + janela <= N; ini++) { // cada janela começa em ini
int soma = 0; // soma da janela atual
for (int k = ini; k < ini + janela; k++) soma += t[k]; // soma os 'janela' valores
double media = (double)soma / janela; // (double): divisão real
if (media > maior) maior = media; // nova maior média
if (media < menor) menor = media; // nova menor média
}
printf("Maior média: %.2f\n", maior); // 28.00 no exemplo
printf("Menor média: %.2f\n", menor); // -5.83 no exemplo
return 0; // fim sem erro
}Para você: Liga do Reizinho – pontos somando min + max de cada janela
Avaliação 1 – 2024.2 (versão D), Questão II avaliacao_1_ano_2024_2_D.pdf
Solução comentada (tente antes!)
// A1-2024.2 (D) – Questão II: Liga do Reizinho – pontos somando min + max de cada janela
#include <stdio.h> // printf e scanf
#define P 5 // partidas do campeonato atual
#define J 3 // tamanho da janela
int main(void) { // início do programa
int gols[P]; // gols em cada partida
for (int i = 0; i < P; i++) scanf("%d", &gols[i]); // lê os gols
int total = 0; // pontuação acumulada
for (int ini = 0; ini <= P - J; ini++) { // P - J + 1 janelas
int min = gols[ini], max = gols[ini]; // começa com o primeiro jogo da janela
for (int k = ini + 1; k < ini + J; k++) { // demais jogos da janela
if (gols[k] < min) min = gols[k]; // menor da janela
if (gols[k] > max) max = gols[k]; // maior da janela
}
total += min + max; // pontos desta janela
}
printf("%d pontos\n", total); // (1+3) + (1+3) + (1+4) = 13 no exemplo
return 0; // fim sem erro
}21 Subsequências: dois índices Avaliação 2 – 2019.2
Examinar todos os pares (início, fim) de um vetor de forma eficiente.
Conceitos
- Subsequência consecutiva = trecho
v[ini..fim] - Fixe
ini; ao avançarfim, a soma só ganhav[fim](não recalcule tudo) - São N(N+1)/2 trechos: para N = 1000, 500 mil, tranquilo
- Com valores não negativos, pode-se parar quando a soma passar do alvo
Resolvida em sala: Quantas subsequências consecutivas somam exatamente X
Avaliação 2 – 2019.2, Questão I avaliacao_2_ano_2019_2.pdf
Solução comentada
// A2-2019.2 – Questão I: Quantas subsequências consecutivas somam exatamente X
#include <stdio.h> // printf e scanf
#define MAX 1000 // tamanho máximo da sequência
int main(void) { // início do programa
int n, x; // tamanho da sequência e soma procurada
int v[MAX]; // a sequência
scanf("%d", &n); // lê N
for (int i = 0; i < n; i++) scanf("%d", &v[i]); // lê os N números
scanf("%d", &x); // lê X
int quantas = 0; // contador de subsequências
for (int ini = 0; ini < n; ini++) { // cada ponto de partida
int soma = 0; // soma de v[ini..fim]
for (int fim = ini; fim < n; fim++) { // estende a subsequência um elemento por vez
soma += v[fim]; // aproveita a soma anterior
if (soma == x) quantas++; // achou uma
}
}
printf("%d subsequências\n", quantas); // 5 no exemplo
return 0; // fim sem erro
}Para você: Corredor de salas – máximo de vidas
Avaliação 2 – 2016.1, Questão III avaliacao_2_ano_2016_1.pdf
Solução comentada (tente antes!)
// A2-2016.1 – Questão III: Corredor de salas – máximo de vidas
#include <stdio.h> // printf e scanf
#define N 10 // salas do corredor
int main(void) { // início do programa
int v[N]; // vidas ganhas em cada sala
for (int i = 0; i < N; i++) scanf("%d", &v[i]); // lê as 10 salas
int melhor = v[0]; // melhor soma encontrada
for (int ini = 0; ini < N; ini++) { // sala de entrada
int soma = 0; // vidas de ini até fim
for (int fim = ini; fim < N; fim++) { // sala de saída
soma += v[fim]; // entra em mais uma sala
if (soma > melhor) melhor = soma; // guarda o recorde
}
}
printf("Máximo: %d vidas\n", melhor); // 5 - 1 + 8 = 12 no exemplo
return 0; // fim sem erro
}22 Vetor como memória: detectar repetição Avaliação 1 – 2024.2 (versão D)
Usar um vetor de marcação para saber se um valor já apareceu.
Conceitos
int visto[MAX] = {0};evisto[x] = 1ao encontrar xif (visto[x])responde em um passo se x já apareceu- Guarde a sequência num segundo vetor para imprimir depois
- O tamanho do vetor tem que cobrir o maior valor possível
Resolvida em sala: Sequência da soma dos quadrados dos dígitos até repetir
Avaliação 1 – 2024.2 (versão D), Questão I avaliacao_1_ano_2024_2_D.pdf
Solução comentada
// A1-2024.2 (D) – Questão I: Sequência da soma dos quadrados dos dígitos até repetir
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // primeiro número (0 a 99)
printf("Número (0 a 99): "); // pede o número
scanf("%d", &n); // lê o número
int visto[200] = {0}; // visto[x] = 1 se x já apareceu (vetor como memória)
int seq[200], tam = 0; // a sequência gerada, para imprimir no fim
while (!visto[n]) { // para quando o número se repetir (ciclo)
visto[n] = 1; // marca como visto
seq[tam++] = n; // guarda na sequência
int soma = 0; // soma dos quadrados dos dígitos
for (int x = n; x > 0; x /= 10) soma += (x % 10) * (x % 10); // dígito a dígito
if (soma >= 100) soma /= 2; // regra: 100 ou mais é dividido por 2
n = soma; // próximo termo
}
printf("Sequência: "); // imprime o resultado
for (int i = 0; i < tam; i++) printf("%d%s", seq[i], i < tam - 1 ? ", " : "\n"); // vírgula entre os termos, quebra de linha no último
return 0; // fim sem erro
}Para você: Os 20 primeiros termos da sequência de Recamán
Avaliação 2 – 2016.2, Questão II avaliacao_2_ano_2016_2.pdf
Solução comentada (tente antes!)
// A2-2016.2 – Questão II: Os 20 primeiros termos da sequência de Recamán
#include <stdio.h> // printf
#define TAM 20 // trocar aqui muda o tamanho do vetor (mínimo impacto)
int main(void) { // início do programa
int a[TAM]; // os termos da sequência
a[0] = 0; // A0 = 0
for (int n = 1; n < TAM; n++) { // calcula A1, A2, ...
int candidato = a[n - 1] - n; // tenta voltar n posições
int repetido = 0; // o candidato já está na sequência?
for (int k = 0; k < n; k++) // procura entre os termos anteriores
if (a[k] == candidato) repetido = 1; // achou: não pode usar
if (candidato > 0 && !repetido) a[n] = candidato; // positivo e novo: usa a subtração
else a[n] = a[n - 1] + n; // senão, avança n posições
}
for (int n = 0; n < TAM; n++) printf("%d%s", a[n], n < TAM - 1 ? ", " : "\n"); // mostra o vetor
return 0; // fim sem erro
}23 Simulação: posições circulares e pilha Avaliação 2 – 2025.1
Simular movimentos numa pista circular e operações de empilhar/desempilhar.
Conceitos
- Posições 1..N circulares:
pos = (pos - 1 + passo + N) % N + 1 - O
+ Nevita resto negativo quando o passo é negativo - Pilha num vetor:
v[topo++] = xempilha;topo--desempilha - Simule exatamente os comandos, um por vez
Resolvida em sala: Robô-espantalho – quantas vezes parou na estação devastada
Avaliação 2 – 2025.1, Questão II avaliacao_2_ano_2025_1.pdf
Solução comentada
// A2-2025.1 – Questão II: Robô-espantalho – quantas vezes parou na estação devastada
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n, c, alvo; // estações, comandos, estação mais próxima da área devastada
scanf("%d %d %d", &n, &c, &alvo); // lê os três inteiros
int estacao = 1; // o robô começa o dia na estação 1
int vezes = (estacao == alvo); // conta a estação inicial, se for o alvo
for (int i = 0; i < c; i++) { // executa os c comandos
int cmd; // 1 = horário, -1 = anti-horário
scanf("%d", &cmd); // lê o comando
estacao = (estacao - 1 + cmd + n) % n + 1; // anda no círculo 1..n (o + n evita resto negativo)
if (estacao == alvo) vezes++; // parou no alvo
}
printf("%d\n", vezes); // 2 no exemplo
return 0; // fim sem erro
}Para você: O chefe ao telefone – "zero" apaga o último número
Avaliação 2 – 2023.2, Questão I avaliacao_2_ano_2023_2.pdf
Solução comentada (tente antes!)
// A2-2023.2 – Questão I: O chefe ao telefone – "zero" apaga o último número
#include <stdio.h> // printf e scanf
#define MAX 1000 // vendas que cabem na "pilha"
int main(void) { // início do programa
int pilha[MAX]; // números ainda válidos
int topo = 0; // quantos números estão na pilha
int x; // número falado
scanf("%d", &x); // primeira leitura
while (x >= 0) { // negativo encerra a lista
if (x == 0) { // "zero": apaga o último número
if (topo > 0) topo--; // só se houver algum
} else { // número de venda
pilha[topo++] = x; // empilha
}
scanf("%d", &x); // próxima leitura
}
int soma = 0; // total das vendas
for (int i = 0; i < topo; i++) soma += pilha[i]; // soma o que sobrou na pilha
printf("%d\n", soma); // 1 + 6 = 7 no exemplo
return 0; // fim sem erro
}24 Avaliação II Avaliação
Prova do Bloco 2, no formato das avaliações anteriores. Abaixo, uma prova-modelo com duas questões de provas passadas.
Prova-modelo
Questão 1: Cofre – quantas vezes cada dígito passa pelo controle
Avaliação 2 – 2025.1, Questão I avaliacao_2_ano_2025_1.pdf
Solução comentada
// A2-2025.1 – Questão I: Cofre – quantas vezes cada dígito passa pelo controle
#include <stdio.h> // printf e scanf
#define T 14 // tamanho da barra: troque aqui (e os valores) para outra barra
int main(void) { // início do programa
int barra[T] = {9, 4, 3, 9, 1, 2, 4, 5, 1, 1, 9, 7, 0, 5}; // números da figura da prova
int conta[10] = {0}; // conta[d]: vezes que o dígito d apareceu no controle
int atual; // posição atual (de 1 a T)
scanf("%d", &atual); // a primeira é sempre 1
conta[barra[atual - 1]]++; // o número da posição inicial conta
int prox; // próxima parada
scanf("%d", &prox); // lê a próxima posição
while (prox > 0) { // zero ou negativo encerra
int passo = prox > atual ? 1 : -1; // para a direita (+1) ou para a esquerda (-1)
for (int p = atual + passo; p != prox + passo; p += passo) // cada posição percorrida, sem repetir a atual
conta[barra[p - 1]]++; // posição p da barra é o índice p - 1 do vetor
atual = prox; // agora o controle está na nova parada
scanf("%d", &prox); // próxima parada
}
for (int d = 0; d < 10; d++) printf("%d%s", conta[d], d < 9 ? " " : "\n"); // as 10 contagens
return 0; // fim sem erro
}Questão 2: Rotina de Kaprekar até 6174
Avaliação 2 – 2026.1, Questão II avaliacao_2_ano_2026_1.pdf
Solução comentada
// A2-2026.1 – Questão II: Rotina de Kaprekar até 6174
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int n; // número de 4 dígitos (com dígitos distintos)
printf("Número de 4 dígitos: "); // pede o número
scanf("%d", &n); // lê o número
do { // pelo menos uma vez (6174 → 7641 - 1467 = 6174)
int d[4]; // os quatro dígitos
for (int i = 0, x = n; i < 4; i++, x /= 10) d[i] = x % 10; // separa (com zeros à esquerda)
for (int p = 0; p < 3; p++) // ordena crescente (bubble sort)
for (int i = 0; i < 3 - p; i++) // bubble sort: a cada passada, o maior vai para o fim
if (d[i] > d[i + 1]) { int aux = d[i]; d[i] = d[i + 1]; d[i + 1] = aux; } // fora de ordem: troca os vizinhos
int menor = d[0] * 1000 + d[1] * 100 + d[2] * 10 + d[3]; // dígitos em ordem crescente
int maior = d[3] * 1000 + d[2] * 100 + d[1] * 10 + d[0]; // em ordem decrescente
n = maior - menor; // próximo número da rotina
printf("%d - %d = %d\n", maior, menor, n); // mostra a transição
} while (n != 6174); // até atingir a constante
return 0; // fim sem erro
}Banco de questões do Bloco 26 questões
Outras questões de provas anteriores com o conteúdo do bloco, para treinar.
- Avaliação 2 – 2016.2, Questão III avaliacao_2_ano_2016_2.pdf
- Avaliação 2 – 2019.2, Questão II avaliacao_2_ano_2019_2.pdf
- Avaliação 2 – 2021.1, Questão I avaliacao_2_ano_2021_1.pdf
- Avaliação 2 – 2021.1, Questão II avaliacao_2_ano_2021_1.pdf
- Avaliação 2 – 2023.2, Questão II avaliacao_2_ano_2023_2.pdf
- Avaliação 2 – 2024.2, Questão II avaliacao_2_ano_2024_2.pdf
Bloco 3 Strings, matrizes e tabelas
Strings e a tabela ASCII, vetores de contagem, matrizes, simulação em grade e tabelas de dados. Termina com a Avaliação III e a Reavaliação.
25 Strings: vetor de char terminado em \0 Avaliação 3 – 2023.2
Ler, percorrer e comparar caracteres de uma string sem bibliotecas extras.
Conceitos
char s[100];guarda até 99 letras + o'\0'final- Uma palavra:
scanf("%99s", s); uma linha:fgets(s, sizeof s, stdin) - Percorrer:
for (i = 0; s[i] != '\0'; i++) - Caracteres são números (ASCII): letras são consecutivas,
'a' < 'b' - Minúscula de uma maiúscula:
c - 'A' + 'a'(escreva sua função)
Resolvida em sala: Palavra ordenada (letras em ordem alfabética, sem diferenciar maiúsculas)
Avaliação 3 – 2023.2, Questão II avaliacao_3_ano_2023_2.pdf
Solução comentada
// A3-2023.2 – Questão II: Palavra ordenada (letras em ordem alfabética, sem diferenciar maiúsculas)
#include <stdio.h> // printf e scanf
int minuscula(char c) { // 'A'..'Z' vira 'a'..'z'; o resto fica igual
if (c >= 'A' && c <= 'Z') return c - 'A' + 'a'; // na tabela ASCII, as letras são consecutivas
return c; // já é minúscula (ou não é letra)
}
int main(void) { // início do programa
char p[100]; // a palavra (até 99 letras + '\0')
printf("Palavra: "); // pede a palavra
scanf("%99s", p); // %99s: lê uma palavra sem estourar o vetor
int ordenada = 1; // supõe ordenada até provar o contrário
for (int i = 1; p[i] != '\0'; i++) { // compara cada letra com a anterior
if (minuscula(p[i - 1]) > minuscula(p[i])) ordenada = 0; // 'r' > 'o' em "Flro": fora de ordem
}
if (ordenada) printf("%s é ordenada\n", p); // resultado
else printf("%s não é ordenada\n", p); // resultado
return 0; // fim sem erro
}Para você: Encontros consonantais numa frase
Avaliação 3 – 2014.2, Questão II avaliacao_3_ano_2014_2.pdf
Solução comentada (tente antes!)
// A3-2014.2 – Questão II: Encontros consonantais numa frase
#include <stdio.h> // printf e fgets
int minuscula(char c) { // 'A'..'Z' vira 'a'..'z'; o resto fica igual
if (c >= 'A' && c <= 'Z') return c - 'A' + 'a'; // na tabela ASCII, as letras são consecutivas
return c; // já é minúscula (ou não é letra)
}
int e_letra(char c) { // 1 se c for uma letra sem acento
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); // letras são consecutivas na tabela ASCII
}
int consoante(char c) { // 1 se c for uma letra sem acento que não é vogal
char m = minuscula(c); // compara sem diferenciar maiúsculas
return e_letra(c) && m != 'a' && m != 'e' && m != 'i' && m != 'o' && m != 'u';// letra que não é vogal
}
int main(void) { // início do programa
char s[257]; // até 256 caracteres + '\0'
printf("Frase: "); // pede a frase
fgets(s, sizeof s, stdin); // lê a linha inteira (com espaços)
int encontros = 0, seguidas = 0; // total de encontros e consoantes seguidas agora
for (int i = 0; s[i] != '\0'; i++) { // percorre a frase
if (consoante(s[i])) { // mais uma consoante no grupo atual
seguidas++; // conta
if (seguidas == 2) encontros++; // a 2ª consoante seguida forma um encontro (conta uma vez)
} else { // vogal, espaço, acento ou pontuação
seguidas = 0; // quebra o grupo
}
}
printf("%d encontros consonantais\n", encontros); // istmo (stm), Stradun (Str), Brasil (Br)
return 0; // fim sem erro
}26 Vetor de contagem por letra Avaliação 3 – 2024.2
Indexar um vetor de 26 posições pela letra (c - 'A').
Conceitos
- Índice da letra:
c - 'A'(maiúscula) ouc - 'a'(minúscula), de 0 a 25 - Volta:
'A' + ké a letra de índice k - Contagem:
cont[k]++; primeira posição: guardar só se ainda for −1 - Inicialize com um laço quando o valor inicial não for 0
Resolvida em sala: Posição da primeira ocorrência de cada letra
Avaliação 3 – 2024.2, Questão II avaliacao_3_ano_2024_2.pdf
Solução comentada
// A3-2024.2 – Questão II: Posição da primeira ocorrência de cada letra
#include <stdio.h> // printf e fgets
int main(void) { // início do programa
char s[1001]; // a string lida
printf("Texto: "); // pede o texto
fgets(s, sizeof s, stdin); // lê a linha inteira
int primeira[26]; // primeira[k]: posição da 1ª ocorrência da letra 'A' + k
for (int k = 0; k < 26; k++) primeira[k] = -1; // -1 = ainda não apareceu
for (int i = 0; s[i] != '\0'; i++) { // percorre o texto
int k = -1; // índice da letra (−1: não é letra)
if (s[i] >= 'A' && s[i] <= 'Z') k = s[i] - 'A'; // maiúscula: 'O' - 'A' = 14
if (s[i] >= 'a' && s[i] <= 'z') k = s[i] - 'a'; // minúscula: 'o' - 'a' = 14
if (k != -1) { // só letras (sem acento)
if (primeira[k] == -1) primeira[k] = i; // guarda só a primeira vez
}
}
for (int k = 0; k < 26; k++) // de A a Z, em ordem
if (primeira[k] != -1) printf("%c(%d) ", 'A' + k, primeira[k]); // só as letras que apareceram
printf("\n"); // termina a linha
return 0; // fim sem erro
}Para você: Assinatura de frequência (2N3A1B aceita BANANA)
Avaliação 3 – 2026.1, Questão II avaliacao_3_ano_2026_1.pdf
Solução comentada (tente antes!)
// A3-2026.1 – Questão II: Assinatura de frequência (2N3A1B aceita BANANA)
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
char formula[60], palavra[33]; // fórmula (ex.: 2N3A1B) e palavra-passe (até 32 letras)
printf("Fórmula e palavra: "); // pede as duas strings
scanf("%59s %32s", formula, palavra); // lê as duas palavras
int exigido[26] = {0}, contado[26] = {0}; // quantidade exigida e encontrada de cada letra
for (int i = 0; formula[i] != '\0'; i += 2) // a fórmula vem em pares: dígito + letra
exigido[formula[i + 1] - 'A'] = formula[i] - '0'; // '3' - '0' = 3; 'A' - 'A' = 0
for (int i = 0; palavra[i] != '\0'; i++) // conta as letras da palavra
contado[palavra[i] - 'A']++; // a letra vira índice
int aceita = 1; // supõe aceita
for (int k = 0; k < 26; k++) // compara letra por letra
if (exigido[k] != contado[k]) aceita = 0; // letra a mais, a menos ou fora da fórmula
printf(aceita ? "ACEITO\n" : "RECUSADO\n"); // resultado
return 0; // fim sem erro
}27 Validação de strings Avaliação 3 – 2025.2
Verificar se uma string obedece a regras, escrevendo as próprias funções de busca.
Conceitos
- Buscar um caractere: laço até o
'\0'; achou, devolve 1 fgetsguarda o'\n': troque-o por'\0'- Validação: começa válido; qualquer violação torna inválido
- Uma função por pergunta:
contem(s, c),tira_enter(s)
Resolvida em sala: A mensagem pode ter sido escrita por alienígenas?
Avaliação 3 – 2025.2, Questão I avaliacao_3_ano_2025_2.pdf
Solução comentada
// A3-2025.2 – Questão I: A mensagem pode ter sido escrita por alienígenas?
#include <stdio.h> // printf e fgets
void tira_enter(char s[]) { // troca o '\n' que o fgets guarda por '\0'
for (int i = 0; s[i] != '\0'; i++) // procura o Enter
if (s[i] == '\n') s[i] = '\0'; // achou: a string termina aqui
}
int contem(char s[], char c) { // 1 se o caractere c aparece em s
for (int i = 0; s[i] != '\0'; i++) // percorre s
if (s[i] == c) return 1; // achou
return 0; // chegou ao fim sem achar
}
int main(void) { // início do programa
char alfabeto[100], msg[1001]; // símbolos alienígenas e mensagem interceptada
printf("Alfabeto: "); // pede o alfabeto
fgets(alfabeto, sizeof alfabeto, stdin); // lê a linha
tira_enter(alfabeto); // remove o Enter do fim
printf("Mensagem: "); // pede a mensagem
fgets(msg, sizeof msg, stdin); // lê a linha
tira_enter(msg); // remove o Enter
int pode = 1; // supõe que sim
for (int i = 0; msg[i] != '\0'; i++) // cada símbolo da mensagem
if (!contem(alfabeto, msg[i])) pode = 0; // símbolo fora do alfabeto
if (pode) printf("A mensagem pode ter sido escrita por alienígenas\n"); // nenhuma regra foi violada
else printf("A mensagem não pode ter sido escrita por alienígenas\n"); // alguma regra foi violada
return 0; // fim sem erro
}Para você: Faixas de letras
Avaliação 3 – 2019.1, Questão I avaliacao_3_ano_2019_1.pdf
Solução comentada (tente antes!)
// A3-2019.1 – Questão I: Faixas de letras
#include <stdio.h> // printf e fgets
int main(void) { // início do programa
char s[1001]; // texto com letras minúsculas e espaços
printf("Texto: "); // pede o texto
fgets(s, sizeof s, stdin); // lê a linha
int tem[26] = {0}; // tem[k] = 1 se a letra 'a' + k aparece
for (int i = 0; s[i] != '\0'; i++) // marca as letras presentes
if (s[i] >= 'a' && s[i] <= 'z') tem[s[i] - 'a'] = 1; // ignora espaços e duplicadas
for (int k = 0; k < 26; k++) { // percorre o alfabeto
if (tem[k] && (k == 0 || !tem[k - 1])) { // começo de faixa: tem a letra, mas não a anterior
int fim = k; // estende enquanto as próximas letras existirem
while (fim + 1 < 26 && tem[fim + 1]) fim++; // anda até o fim da faixa
printf("%c:%c ", 'a' + k, 'a' + fim); // imprime a faixa
}
}
printf("\n"); // termina a linha
return 0; // fim sem erro
}28 Mapear caracteres: tabelas e conversões Avaliação 3 – 2019.1
Converter caracteres usando uma tabela indexada e a aritmética de char.
Conceitos
- Tabela como string:
"22233344455566677778889999"[c - 'A'] - Dígito → número:
c - '0'(sec >= '0' && c <= '9') - Letra hexadecimal → valor:
c - 'A' + 10 - Conversão de base com string:
valor = valor * base + digito(da esquerda para a direita)
Resolvida em sala: Expressão em letras para número de telefone
Avaliação 3 – 2019.1, Questão II avaliacao_3_ano_2019_1.pdf
Solução comentada
// A3-2019.1 – Questão II: Expressão em letras para número de telefone
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
char s[101]; // expressão (A-Z, hífens, 1 e 0)
printf("Expressão: "); // pede a expressão
scanf("%100s", s); // lê sem espaços
// ABCDEFGHIJKLMNOPQRSTUVWXYZ
const char *tabela = "22233344455566677778889999"; // tabela[letra - 'A'] dá o dígito da tecla
for (int i = 0; s[i] != '\0'; i++) { // percorre a expressão
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = tabela[s[i] - 'A']; // letra vira dígito
} // hífen, 1 e 0 ficam como estão
printf("%s\n", s); // 1-527-3623-527
return 0; // fim sem erro
}Para você: Hexadecimal (string) para decimal
Avaliação Final – 2024.2, Questão I avaliacao_4_ano_2024_2.pdf
Solução comentada (tente antes!)
// A4-2024.2 – Questão I: Hexadecimal (string) para decimal
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
char hex[256]; // até 255 caracteres
printf("Hexadecimal: "); // pede o número
scanf("%255s", hex); // lê a string
unsigned long long valor = 0; // maior inteiro sem sinal do C
for (int i = 0; hex[i] != '\0'; i++) { // da esquerda para a direita (método de Horner)
int d; // valor do dígito atual
if (hex[i] >= '0' && hex[i] <= '9') d = hex[i] - '0'; // '7' - '0' = 7
else if (hex[i] >= 'A' && hex[i] <= 'F') d = hex[i] - 'A' + 10; // 'B' - 'A' + 10 = 11
else { printf("Dígito inválido: %c\n", hex[i]); return 1; } // qualquer outro caractere
valor = valor * 16 + d; // desloca uma casa hexadecimal e soma o dígito
}
printf("%llu\n", valor); // %llu imprime unsigned long long
return 0; // fim sem erro
}29 Palavras numa frase Avaliação Final – 2026.1
Separar as palavras de uma frase com uma variável de estado (dentro/fora de palavra).
Conceitos
- Estado
dentro: 1 quando o caractere anterior era letra - Começo de palavra: letra com
dentro == 0 - Fim de palavra: não-letra (ou
'\0') comdentro == 1 - É letra:
(c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
Resolvida em sala: Porcentagem de palavras que contêm uma letra
Avaliação Final – 2026.1, Questão I avaliacao_4_ano_2026_1.pdf
Solução comentada
// A4-2026.1 – Questão I: Porcentagem de palavras que contêm uma letra
#include <stdio.h> // printf e fgets
int minuscula(char c) { // 'A'..'Z' vira 'a'..'z'; o resto fica igual
if (c >= 'A' && c <= 'Z') return c - 'A' + 'a'; // na tabela ASCII, as letras são consecutivas
return c; // já é minúscula (ou não é letra)
}
int e_letra(char c) { // 1 se c for uma letra sem acento
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); // letras são consecutivas na tabela ASCII
}
int main(void) { // início do programa
char letra; // letra procurada
char texto[257]; // até 256 caracteres
printf("Letra: "); // pede a letra
scanf(" %c", &letra); // o espaço antes de %c pula espaços e Enters
getchar(); // consome o Enter que sobrou
printf("Texto: "); // pede o texto
fgets(texto, sizeof texto, stdin); // lê a linha inteira
letra = minuscula(letra); // compara sem diferenciar maiúsculas
int palavras = 0, com_letra = 0; // contadores
int dentro = 0, achou = 0; // estou dentro de uma palavra? ela já tem a letra?
for (int i = 0; ; i++) { // percorre até o '\0' (tratado no fim)
if (e_letra(texto[i])) { // letra: faz parte de uma palavra
if (!dentro) { dentro = 1; achou = 0; } // começou uma palavra nova
if (minuscula(texto[i]) == letra) achou = 1; // a palavra contém a letra
} else { // espaço, Enter ou fim: termina a palavra
if (dentro) { // havia uma palavra aberta
palavras++; // conta a palavra
if (achou) com_letra++; // e se ela tinha a letra
dentro = 0; // fecha a palavra
}
if (texto[i] == '\0') break; // fim do texto
}
}
printf("%d/%d = %.2f\n", com_letra, palavras, palavras ? (double)com_letra / palavras : 0.0); // proporção (evita divisão por zero)
return 0; // fim sem erro
}Para você: Grace Hopper – COBOL ou BUG?
Avaliação 3 – 2025.1, Questão I avaliacao_3_ano_2025_1.pdf
Solução comentada (tente antes!)
// A3-2025.1 – Questão I: Grace Hopper – COBOL ou BUG?
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
char s[200]; // cinco palavras separadas por hífen
printf("Texto: "); // pede o texto
scanf("%199s", s); // lê sem espaços
const char *alvo = "cobol"; // a i-ésima palavra deve começar ou terminar com alvo[i]
int palavra = 0, ok = 1; // índice da palavra atual e resultado
int ini = 0; // posição do início da palavra atual
for (int i = 0; ; i++) { // percorre até o '\0'
if (s[i] == '-' || s[i] == '\0') { // terminou uma palavra: s[ini .. i-1]
if (palavra >= 5 || (s[ini] != alvo[palavra] && s[i - 1] != alvo[palavra])) ok = 0; // letra fora do início e do fim da palavra
palavra++; // próxima palavra
ini = i + 1; // ela começa depois do hífen
if (s[i] == '\0') break; // fim do texto
}
}
if (palavra != 5) ok = 0; // precisam ser exatamente cinco palavras
printf(ok ? "COBOL\n" : "BUG\n"); // resultado
return 0; // fim sem erro
}30 Matrizes: linhas, colunas e percursos Avaliação 3 – 2014.2
Declarar, ler e percorrer matrizes; trocar o papel de linha e coluna.
Conceitos
int m[L][C];e acessom[i][j](linha i, coluna j)- Dois laços: externo nas linhas, interno nas colunas
m[i][j]percorre a linha i;m[j][i]percorre a coluna i- Rotação horária:
nova[i][j] = m[n - 1 - j][i]
Resolvida em sala: A matriz é de permutação? (na prova, N = 10)
Avaliação 3 – 2014.2, Questão I avaliacao_3_ano_2014_2.pdf
Solução comentada
// A3-2014.2 – Questão I: A matriz é de permutação? (na prova, N = 10)
#include <stdio.h> // printf e scanf
#define MAX 100 // maior dimensão aceita
int main(void) { // início do programa
int n, m[MAX][MAX]; // dimensão e matriz
scanf("%d", &n); // lê N (10 na prova; ler N deixa testar com matrizes pequenas)
for (int i = 0; i < n; i++) // cada linha
for (int j = 0; j < n; j++) scanf("%d", &m[i][j]); // cada coluna
int ok = 1; // supõe que é de permutação
for (int i = 0; i < n; i++) { // para cada índice i: linha i e coluna i
int uns_linha = 0, uns_coluna = 0; // quantos 1 na linha i e na coluna i
for (int j = 0; j < n; j++) { // percorre a linha e a coluna ao mesmo tempo
if (m[i][j] != 0 && m[i][j] != 1) ok = 0; // só pode ter 0 e 1
uns_linha += m[i][j]; // m[i][j]: linha i
uns_coluna += m[j][i]; // m[j][i]: coluna i
}
if (uns_linha != 1 || uns_coluna != 1) ok = 0; // exatamente um 1 por linha e por coluna
}
printf(ok ? "É uma matriz de permutação\n" : "Não é uma matriz de permutação\n"); // operador ternário escolhe a mensagem
return 0; // fim sem erro
}Para você: Rotação de 90 graus no sentido horário (na prova, N = 50)
Avaliação 3 – 2026.1, Questão I avaliacao_3_ano_2026_1.pdf
Solução comentada (tente antes!)
// A3-2026.1 – Questão I: Rotação de 90 graus no sentido horário (na prova, N = 50)
#include <stdio.h> // printf e scanf
#define MAX 50 // dimensão da prova
int main(void) { // início do programa
int n, img[MAX][MAX]; // dimensão e imagem em tons de cinza
scanf("%d", &n); // lê N
for (int i = 0; i < n; i++) // lê a imagem linha a linha
for (int j = 0; j < n; j++) scanf("%d", &img[i][j]); // cada coluna
for (int i = 0; i < n; i++) { // linha i da imagem girada
for (int j = 0; j < n; j++) // coluna j da imagem girada
printf("%d ", img[n - 1 - j][i]); // vem da coluna i, lida de baixo para cima
printf("\n"); // fim da linha
}
return 0; // fim sem erro
}31 Matrizes em blocos e em 3 dimensões Avaliação 3 – 2024.2
Percorrer sub-blocos de uma matriz e trabalhar com uma terceira dimensão (canais).
Conceitos
- Bloco F × F começando em (bi, bj):
idebiabi + F - 1 - Inícios de bloco andam de F em F:
bi += F - Quatro laços: dois para os blocos, dois dentro do bloco
- Imagem colorida:
img[i][j][c], c = 0 (R), 1 (G), 2 (B)
Resolvida em sala: Max pooling com filtro F x F e passo F
Avaliação 3 – 2024.2, Questão I avaliacao_3_ano_2024_2.pdf
Solução comentada
// A3-2024.2 – Questão I: Max pooling com filtro F x F e passo F
#include <stdio.h> // printf e scanf
#define MAX 100 // maior imagem aceita
int main(void) { // início do programa
int n, f, img[MAX][MAX]; // dimensão da imagem, do filtro e a imagem
scanf("%d %d", &n, &f); // lê N e F (N múltiplo de F)
for (int i = 0; i < n; i++) // lê a imagem
for (int j = 0; j < n; j++) scanf("%d", &img[i][j]); // cada coluna
for (int bi = 0; bi < n; bi += f) { // linha de início de cada bloco (passo F)
for (int bj = 0; bj < n; bj += f) { // coluna de início de cada bloco
int maior = img[bi][bj]; // começa com o canto do bloco
for (int i = bi; i < bi + f; i++) // percorre o bloco F x F
for (int j = bj; j < bj + f; j++) // colunas do bloco
if (img[i][j] > maior) maior = img[i][j]; // guarda o máximo
printf("%d ", maior); // um valor por bloco
}
printf("\n"); // fim de uma linha de blocos
}
return 0; // fim sem erro
}Para você: Imagem RGB para tons de cinza (na prova, 100 x 100 x 3)
Avaliação 3 – 2025.1, Questão II avaliacao_3_ano_2025_1.pdf
Solução comentada (tente antes!)
// A3-2025.1 – Questão II: Imagem RGB para tons de cinza (na prova, 100 x 100 x 3)
#include <stdio.h> // printf e scanf
#define MAX 100 // dimensão da prova
int img[MAX][MAX][3]; // global: 100 x 100 x 3 inteiros não cabem bem na pilha
int main(void) { // início do programa
int linhas, colunas; // dimensões (100 e 100 na prova)
scanf("%d %d", &linhas, &colunas); // lê as dimensões
for (int i = 0; i < linhas; i++) // cada pixel
for (int j = 0; j < colunas; j++) // cada coluna
for (int c = 0; c < 3; c++) scanf("%d", &img[i][j][c]); // canais R, G e B
for (int i = 0; i < linhas; i++) { // imprime a imagem cinza
for (int j = 0; j < colunas; j++) { // cada coluna
double cinza = 0.299 * img[i][j][0] + 0.587 * img[i][j][1] + 0.114 * img[i][j][2]; // luminância
printf("%d ", (int)(cinza + 0.5)); // + 0.5 e truncar = arredondar
}
printf("\n"); // fim da linha
}
return 0; // fim sem erro
}32 Simulação em grade Avaliação 3 – 2025.2
Simular movimentos ou propagação numa matriz de caracteres.
Conceitos
- Cada linha da grade é uma string:
char g[N][M + 1] - Andar: N → linha−1, S → linha+1, L → coluna+1, O → coluna−1
- Antes de acessar, teste os limites:
0 <= l < Ne0 <= c < M - Ciclo: matriz
visitado; voltar a uma casa visitada = laço infinito
Resolvida em sala: Areia movediça – tempo até o tesouro ou tipo de derrota
Avaliação 3 – 2025.2, Questão II avaliacao_3_ano_2025_2.pdf
Solução comentada
// A3-2025.2 – Questão II: Areia movediça – tempo até o tesouro ou tipo de derrota
#include <stdio.h> // printf e scanf
#define MAX 100 // maior arena aceita
int main(void) { // início do programa
int m; // dimensão da arena
char mapa[MAX][MAX + 1]; // cada linha é uma string (+1 para o '\0')
int visitado[MAX][MAX] = {{0}}; // marca as quadrículas já percorridas
scanf("%d", &m); // lê M
for (int i = 0; i < m; i++) scanf("%s", mapa[i]); // lê as M linhas (ex.: SSOS)
int l, c; // posição inicial (linha, coluna)
scanf("%d %d", &l, &c); // lê a posição do pouso
int minutos = 0; // tempo decorrido
while (1) { // anda até um dos três desfechos
if (l < 0 || l >= m || c < 0 || c >= m) { printf("Fora dos Limites\n"); break; } // saiu da arena
if (mapa[l][c] == 'X') { printf("Tesouro em %d minutos\n", minutos); break; } // vitória
if (visitado[l][c]) { printf("Preso na Areia\n"); break; } // voltou a uma casa: ciclo para sempre
visitado[l][c] = 1; // marca a casa atual
char d = mapa[l][c]; // direção do fluxo aqui
if (d == 'N') l--; // norte: sobe uma linha
else if (d == 'S') l++; // sul: desce
else if (d == 'L') c++; // leste: direita
else c--; // oeste: esquerda
minutos++; // uma quadrícula por minuto
}
return 0; // fim sem erro
}Para você: Gotejamento na parede com prateleiras
Avaliação 3 – 2023.2, Questão I avaliacao_3_ano_2023_2.pdf
Solução comentada (tente antes!)
// A3-2023.2 – Questão I: Gotejamento na parede com prateleiras
#include <stdio.h> // printf e scanf
#define MAX 100 // maior parede aceita
int main(void) { // início do programa
int n, m; // linhas e colunas
char p[MAX][MAX + 1]; // a parede: '.', '#' e 'o'
scanf("%d %d", &n, &m); // lê as dimensões
for (int i = 0; i < n; i++) scanf("%s", p[i]); // lê cada linha
int mudou = 1; // repete enquanto alguma casa virar 'o'
while (mudou) { // aplica as regras até estabilizar
mudou = 0; // nesta passada, ainda nada mudou
for (int i = 0; i < n; i++) { // cada linha
for (int j = 0; j < m; j++) { // cada coluna
if (p[i][j] != '.') continue; // só a parede vazia pode molhar
int cai = i > 0 && p[i - 1][j] == 'o'; // água logo acima
int esq = j > 0 && i + 1 < n && p[i][j - 1] == 'o' && p[i + 1][j - 1] == '#'; // escorre da esquerda sobre prateleira
int dir = j + 1 < m && i + 1 < n && p[i][j + 1] == 'o' && p[i + 1][j + 1] == '#'; // escorre da direita
if (cai || esq || dir) { p[i][j] = 'o'; mudou = 1; } // molhou: talvez molhe vizinhos na próxima passada
}
}
}
for (int i = 0; i < n; i++) printf("%s\n", p[i]); // padrão final
return 0; // fim sem erro
}33 Busca em grade de caracteres Avaliação 3 – 2023.1
Procurar padrões em linhas e colunas de uma grade.
Conceitos
- Para cada posição inicial, compare a palavra letra a letra
- Horizontal:
g[i][j + k]; vertical:g[i + k][j] - Cheque antes se a palavra cabe:
j + t <= nei + t <= m - Por colunas: percorra
knas linhas fixando a coluna
Resolvida em sala: Caça-palavras (horizontal e vertical) – pontuação
Avaliação 3 – 2023.1, Questão I avaliacao_3_ano_2023_1.pdf
Solução comentada
// A3-2023.1 – Questão I: Caça-palavras (horizontal e vertical) – pontuação
#include <stdio.h> // printf e scanf
#define MAX 100 // maior grade aceita
int main(void) { // início do programa
int m, n; // linhas e colunas da grade
char g[MAX][MAX + 1], palavra[MAX + 1]; // grade e palavra procurada
scanf("%d %d", &m, &n); // lê as dimensões
for (int i = 0; i < m; i++) scanf("%s", g[i]); // lê as linhas da grade
scanf("%s", palavra); // lê a palavra
int t = 0, achou = 0; // tamanho da palavra e resultado
while (palavra[t] != '\0') t++; // conta as letras até o '\0'
for (int i = 0; i < m && !achou; i++) { // cada posição inicial
for (int j = 0; j < n && !achou; j++) { // (para assim que achar)
int h = j + t <= n, v = i + t <= m; // cabe na horizontal? na vertical?
for (int k = 0; k < t; k++) { // compara letra a letra
if (h && g[i][j + k] != palavra[k]) h = 0; // falhou na horizontal (anda pela coluna)
if (v && g[i + k][j] != palavra[k]) v = 0; // falhou na vertical (anda pela linha)
}
if (h || v) achou = 1; // encontrou em alguma direção
}
}
printf("%d pontos\n", achou ? t : -5); // tamanho da palavra ou -5
return 0; // fim sem erro
}Para você: Consenso de cinco fitas de DNA
Avaliação 3 – 2023.1, Questão II avaliacao_3_ano_2023_1.pdf
Solução comentada (tente antes!)
// A3-2023.1 – Questão II: Consenso de cinco fitas de DNA
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
char f[5][9]; // 5 fitas de até 8 caracteres
for (int k = 0; k < 5; k++) scanf("%8s", f[k]); // lê as fitas
const char *bases = "ACGT"; // as quatro enzimas
int t = 0; // tamanho das fitas (todas iguais)
while (f[0][t] != '\0') t++; // conta até o '\0'
for (int i = 0; i < t; i++) { // cada posição da fita
int conta[4] = {0}; // frequência de A, C, G, T nesta posição
for (int k = 0; k < 5; k++) // olha a posição i nas 5 fitas
for (int b = 0; b < 4; b++) // compara com cada uma das 4 bases
if (f[k][i] == bases[b]) conta[b]++; // conta a enzima encontrada
int melhor = 0, empate = 0; // índice da mais frequente e se há empate
for (int b = 1; b < 4; b++) { // procura a maior contagem
if (conta[b] > conta[melhor]) { melhor = b; empate = 0; } // nova maior: desfaz empate
else if (conta[b] == conta[melhor]) empate = 1; // igual à maior: empate
}
printf("%c", empate ? '?' : bases[melhor]); // '?' quando não há consenso
}
printf("\n"); // fim da fita
return 0; // fim sem erro
}34 Tabelas de dados: linhas de matriz e vetores paralelos Avaliação Final – 2026.1
Guardar registros (vários dados de um mesmo item) em linhas de matriz ou em vetores paralelos.
Conceitos
- Registro: cada item é uma linha e cada dado, uma coluna:
tab[i][0],tab[i][1] - Vetores paralelos:
pressao[i],glicemia[i]erisco[i]falam do mesmo paciente i - Varrer a tabela: um laço nas linhas, comparando com o item novo
- Lista sem repetição: procure antes de inserir em
v[total++] abs(valor absoluto) vem de<stdlib.h>
Resolvida em sala: Classificador por vizinhança (distância de Manhattan)
Avaliação Final – 2026.1, Questão II avaliacao_4_ano_2026_1.pdf
Solução comentada
// A4-2026.1 – Questão II: Classificador por vizinhança (distância de Manhattan)
#include <stdio.h> // printf e scanf
#include <stdlib.h> // abs
#define MAX 100 // a prova usa M = 10
int main(void) { // início do programa
int m, tab[MAX][3]; // pacientes: pressão, glicemia, risco (+1 ou -1)
scanf("%d", &m); // lê M (10 na prova)
for (int i = 0; i < m; i++) // lê a tabela M x 3
scanf("%d %d %d", &tab[i][0], &tab[i][1], &tab[i][2]); // pressão, glicemia e risco do paciente i
int limiar, pressao, glicemia; // parâmetro e dados do novo paciente
scanf("%d %d %d", &limiar, &pressao, &glicemia); // lê os três valores
int votos = 0; // soma dos riscos dos vizinhos (+1 alto, -1 baixo)
for (int i = 0; i < m; i++) { // cada paciente anterior
int d = abs(pressao - tab[i][0]) + abs(glicemia - tab[i][1]); // distância de Manhattan
if (d < limiar) votos += tab[i][2]; // vizinho (estritamente menor): vota
}
if (votos > 0) printf("ALTO RISCO\n"); // mais vizinhos de alto risco
else if (votos < 0) printf("BAIXO RISCO\n"); // mais vizinhos de baixo risco
else printf("INCONCLUSIVO\n"); // empate (inclusive 0 a 0)
return 0; // fim sem erro
}Para você: Lista de presença com números repetidos (na prova, 50 números)
Avaliação 2 – 2014.2, Questão IV avaliacao_2_ano_2014_2.pdf
Solução comentada (tente antes!)
// A2-2014.2 – Questão IV: Lista de presença com números repetidos (na prova, 50 números)
#include <stdio.h> // printf e scanf
#define MAX 50 // tamanho da lista na prova
int main(void) { // início do programa
int n, lista[MAX]; // quantos números e a lista lida
int presentes[MAX], total = 0; // números sem repetição e quantos são
scanf("%d", &n); // lê N (50 na prova; ler N deixa testar com o exemplo)
for (int i = 0; i < n; i++) scanf("%d", &lista[i]); // lê a lista de presença
for (int i = 0; i < n; i++) { // cada número da lista
int repetido = 0; // já está entre os presentes?
for (int j = 0; j < total; j++) // procura nos que já foram guardados
if (presentes[j] == lista[i]) repetido = 1; // achou: é repetição
if (!repetido) presentes[total++] = lista[i]; // primeira vez: guarda na próxima posição livre
}
printf("%d Alunos\n", total); // quantos receberam presença
for (int j = 0; j < total; j++) // na ordem em que apareceram
printf("%d - %d\n", j + 1, presentes[j]); // posição e número de registro
return 0; // fim sem erro
}35 Avaliação III Avaliação
Prova do Bloco 3, no formato das avaliações anteriores. Abaixo, uma prova-modelo com duas questões de provas passadas.
Prova-modelo
Questão 1: Alcance da lava do vulcão (mapa 8 x 8)
Avaliação Final – 2025.1, Questão I avaliacao_4_ano_2025_1.pdf
Solução comentada
// A4-2025.1 – Questão I: Alcance da lava do vulcão (mapa 8 x 8)
#include <stdio.h> // printf e scanf
#define N 8 // mapa da prova
int main(void) { // início do programa
char mapa[N][N + 1]; // altitudes '1' a '9' (cada linha é uma string)
int forca; // força da erupção (0 a 9)
for (int i = 0; i < N; i++) scanf("%s", mapa[i]); // lê as 8 linhas
scanf("%d", &forca); // lê a força
if (mapa[0][0] - '0' <= forca) mapa[0][0] = '*'; // a erupção começa no canto superior esquerdo
int mudou = 1; // repete enquanto a lava avançar
while (mudou) { // propagação até estabilizar
mudou = 0; // nada mudou nesta passada (ainda)
for (int i = 0; i < N; i++) { // cada posição
for (int j = 0; j < N; j++) { // cada coluna
if (mapa[i][j] == '*' || mapa[i][j] - '0' > forca) continue; // já invadida ou alta demais
int vizinho = (i > 0 && mapa[i - 1][j] == '*') || (i < N - 1 && mapa[i + 1][j] == '*') || // vizinho invadido acima ou abaixo...
(j > 0 && mapa[i][j - 1] == '*') || (j < N - 1 && mapa[i][j + 1] == '*'); // acima, abaixo, esquerda, direita
if (vizinho) { mapa[i][j] = '*'; mudou = 1; } // invadida a partir de um vizinho
}
}
}
for (int i = 0; i < N; i++) printf("%s\n", mapa[i]); // mapa final
return 0; // fim sem erro
}Questão 2: Plano de construção da pirâmide
Avaliação Final – 2024.2, Questão II avaliacao_4_ano_2024_2.pdf
Solução comentada
// A4-2024.2 – Questão II: Plano de construção da pirâmide
#include <stdio.h> // printf e scanf
#define MAX 100 // dimensão máxima
int main(void) { // início do programa
int n, plano[MAX][MAX]; // dimensão e plano de construção
scanf("%d", &n); // lê a dimensão
for (int i = 0; i < n; i++) { // cada posição da base
for (int j = 0; j < n; j++) { // cada coluna
int borda = i; // distância até a borda mais próxima
if (j < borda) borda = j; // borda esquerda
if (n - 1 - i < borda) borda = n - 1 - i; // borda de baixo
if (n - 1 - j < borda) borda = n - 1 - j; // borda direita
plano[i][j] = borda + 1; // cada camada recua uma casa: altura = distância + 1
}
}
for (int i = 0; i < n; i++) { // imprime o plano
for (int j = 0; j < n; j++) printf("%d ", plano[i][j]); // valores separados por espaço
printf("\n"); // fim da linha
}
return 0; // fim sem erro
}36 Reavaliação Reavaliação
Reavaliação: substitui a menor nota. Abaixo, uma prova-modelo com duas questões de provas passadas.
Prova-modelo
Questão 1: Relógio de Chronos – hora a partir dos ângulos dos ponteiros
Avaliação 1 – 2022.1, Questão II avaliacao_1_ano_2022_1.pdf
Solução comentada
// A1-2022.1 – Questão II: Relógio de Chronos – hora a partir dos ângulos dos ponteiros
#include <stdio.h> // printf e scanf
int main(void) { // início do programa
int ang_hora, ang_min; // ângulos dos ponteiros de hora e de minutos (graus)
printf("Ângulos (hora minuto): "); // pede os ângulos
scanf("%d %d", &ang_hora, &ang_min); // lê os dois inteiros
int horas = ang_hora / 30; // 360 graus / 12 horas = 30 graus por hora
int minutos = ang_min / 6; // 360 graus / 60 minutos = 6 graus por minuto
printf("%02d:%02d\n", horas, minutos); // %02d completa com zero à esquerda
return 0; // fim sem erro
}Questão 2: Quantos retângulos (blocos consecutivos) somam exatamente K
Avaliação Final – 2025.1, Questão II avaliacao_4_ano_2025_1.pdf
Solução comentada
// A4-2025.1 – Questão II: Quantos retângulos (blocos consecutivos) somam exatamente K
#include <stdio.h> // printf e scanf
#define N 10 // quadrados na prova
int main(void) { // início do programa
int v[N], k; // números dos quadrados e soma procurada
for (int i = 0; i < N; i++) scanf("%d", &v[i]); // lê os N números
scanf("%d", &k); // lê K
int quantos = 0; // contador de retângulos
for (int ini = 0; ini < N; ini++) { // primeiro quadrado do retângulo
int soma = 0; // soma de v[ini..fim]
for (int fim = ini; fim < N; fim++) { // último quadrado
soma += v[fim]; // inclui mais um quadrado
if (soma == k) quantos++; // achou um retângulo
if (soma > k) break; // naturais: a soma só cresce, pode parar
}
}
printf("%d retângulos\n", quantos); // resultado
return 0; // fim sem erro
}