Reunimos 13 exercícios, do iniciante ao avançado, que usam variáveis, operadores aritméticos e printf / scanf. Escreva seu código no navegador e clique em "Corrigir": ele é executado com gcc de verdade em várias entradas e a saída é verificada.
Obs.: Executar e Corrigir enviam seu código ao Wandbox, um serviço externo e gratuito de compilação, que o executa com gcc.
/ e % em C."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
a / b é uma divisão inteira (a parte fracionária é descartada) e a % b é o resto. Você pode mostrar o resultado diretamente, como em printf("Quociente: %d\n", a / b);.#include <stdio.h> int main(void) { int a, b; scanf("%d %d", &a, &b); printf("Soma: %d\n", a + b); printf("Diferença: %d\n", a - b); printf("Produto: %d\n", a * b); printf("Quociente: %d\n", a / b); printf("Resto: %d\n", a % b); return 0; }
a == (a / b) * b + a % b, ou seja, −1 (o resto tem o mesmo sinal de a). No scanf, cuidado também para não esquecer o &, como em &a."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
double. No scanf use %lf; no printf, para duas casas decimais, use %.2f. A área é PI * r * r e o perímetro é 2 * PI * r.#include <stdio.h> int main(void) { const double PI = 3.14159; double r; scanf("%lf", &r); printf("Área: %.2f\n", PI * r * r); printf("Perímetro: %.2f\n", 2 * PI * r); return 0; }
scanf("%f", &r) está errado (%f é para float). Memorize: %lf no scanf e %f no printf. %.2f arredonda a partir da terceira casa decimal e mostra duas casas (o valor da variável em si não muda). Porém, como o double é uma aproximação em binário, às vezes um "5" exatamente nessa posição não arredonda para cima, como 2.675 virando 2.67."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
c * 9 / 5 + 32, como c é double, o cálculo também é feito em double. Cuidado com formas de escrever que calculam 9 / 5 primeiro.#include <stdio.h> int main(void) { double c; scanf("%lf", &c); double f = c * 9 / 5 + 32; printf("Fahrenheit: %.1f\n", f); return 0; }
c * (9 / 5) + 32, 9 / 5 vira 1 por ser uma divisão entre inteiros, e a fórmula fica errada: F = C + 32. Escreva um dos números com casa decimal, como 9.0 / 5, ou multiplique por c primeiro (da esquerda para a direita) para virar double antes de dividir."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
n / 100, as dezenas n / 10 % 10 e as unidades n % 10. O número invertido pode ser montado com unidades * 100 + dezenas * 10 + centenas.#include <stdio.h> int main(void) { int n; scanf("%d", &n); int h = n / 100; int t = n / 10 % 10; int o = n % 10; printf("Centenas: %d\n", h); printf("Dezenas: %d\n", t); printf("Unidades: %d\n", o); printf("Invertido: %d\n", o * 100 + t * 10 + h); return 0; }
/ como "descartar os algarismos de baixo" e em % como "manter só os algarismos de baixo": assim você extrai qualquer posição. Se você mostrar o invertido colocando os três lado a lado com printf("%d%d%d", o, t, h), para 120 aparece 021, que não é o inteiro 21."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
sum / 3, use (double)sum / 3 ou sum / 3.0, para dividir mantendo as casas decimais.#include <stdio.h> int main(void) { int a, b, c; scanf("%d %d %d", &a, &b, &c); int sum = a + b + c; double avg = (double)sum / 3; printf("Total: %d\n", sum); printf("Média: %.2f\n", avg); return 0; }
double avg = sum / 3;, o lado direito é uma divisão entre int, então a parte decimal é descartada antes: 299 / 3 vira 99 → 99.00. O segredo é converter o tipo (cast) com (double) antes de dividir. Escrever (double)(sum / 3), com parênteses, não adianta, pois a conversão acontece depois do truncamento."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
n / 3600, os minutos n % 3600 / 60 e os segundos n % 60. Para mostrar com 2 dígitos preenchidos com zero, use %02d.#include <stdio.h> int main(void) { int n; scanf("%d", &n); int h = n / 3600; int m = n % 3600 / 60; int s = n % 60; printf("%d:%02d:%02d\n", h, m, s); return 0; }
n / 60, 3725 segundos dão 62 minutos, ou seja, incluem também os minutos que já viraram horas. Primeiro use % 3600 para ficar com "o que sobra abaixo de 1 hora" e depois divida por 60. Com %2d o preenchimento é feito com espaços e sai 1: 2: 5; para preencher com zeros, use %02d."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
n / 1000 e atualize o valor restante com n %= 1000;. Continue assim com 500, 100, …#include <stdio.h> int main(void) { int n; scanf("%d", &n); printf("1000 ienes: %d\n", n / 1000); n %= 1000; printf("500 ienes: %d\n", n / 500); n %= 500; printf("100 ienes: %d\n", n / 100); n %= 100; printf("50 ienes: %d\n", n / 50); n %= 50; printf("10 ienes: %d\n", n / 10); n %= 10; printf("5 ienes: %d\n", n / 5); n %= 5; printf("1 iene: %d\n", n); return 0; }
/ e %: "o quociente é a quantidade, o resto é o valor que passa para a próxima". n %= 1000; é a forma abreviada (atribuição composta) de n = n % 1000;. Se você esquecer de atualizar o restante, o resultado fica estranho, como 18 moedas de 100 ienes para 1888 ienes.A a Z) e mostre, no formato do exemplo, o seu código de caractere (código ASCII), a minúscula correspondente e a sua posição no alfabeto (A é a posição 1)."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
%d vira o código do caractere, e com %c vira o caractere. A minúscula pode ser calculada com c - 'A' + 'a' e a posição com c - 'A' + 1.#include <stdio.h> int main(void) { char c; scanf(" %c", &c); printf("Código: %d\n", c); printf("Minúscula: %c\n", c - 'A' + 'a'); printf("Posição: %d\n", c - 'A' + 1); return 0; }
'A' é um inteiro que representa o valor do código do caractere (65 em ASCII). Em ASCII, A a Z e a a z ficam em sequência, então basta somar ou subtrair "quanto a letra está distante de A" para converter. Escrever 'a' - 'A' deixa a intenção mais clara do que escrever diretamente um número como 32."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
(int)x descarta a parte fracionária e dá a parte inteira. A parte fracionária é x - (int)x. Arredondar é "somar 0.5 e depois truncar", ou seja, (int)(x + 0.5).#include <stdio.h> int main(void) { double x; scanf("%lf", &x); int ip = (int)x; double fp = x - ip; int rounded = (int)(x + 0.5); printf("Parte inteira: %d\n", ip); printf("Parte fracionária: %.2f\n", fp); printf("Arredondado: %d\n", rounded); return 0; }
(int)x + 0.5, primeiro trunca e depois soma 0.5, o que não arredonda (atenção à posição dos parênteses). Além disso, somar 0.5 só funciona quando x é 0 ou positivo; com números negativos, −2.7 viraria −2."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
h / 100 vira uma divisão inteira. Use h / 100.0 e guarde o resultado em um double.#include <stdio.h> int main(void) { double w; int h; scanf("%lf %d", &w, &h); double m = h / 100.0; double bmi = w / (m * m); double std = 22 * m * m; printf("IMC: %.1f\n", bmi); printf("Peso ideal: %.1fkg\n", std); return 0; }
double m = h / 100;, 170 / 100 vira 1 pela divisão inteira e só depois é atribuído ao double, então m = 1.0. A armadilha é que, mesmo que a variável de destino seja double, o cálculo do lado direito é feito com os tipos do lado direito. Além disso, w / m * m significa (w / m) * m e volta praticamente a w, por isso os parênteses são necessários.printf("%5d x %2d = %6d\n", preço, quantidade, valor). Em seguida, mostre Subtotal, Imposto (10% do subtotal, descartando frações de iene) e Total, cada um no formato "Subtotal: %d\n"."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
%5d significa "largura mínima de 5 caracteres, alinhado à direita". Se você calcular o imposto em int como sub * 10 / 100, a divisão inteira já descarta as frações de iene.#include <stdio.h> int main(void) { int p1, q1, p2, q2, p3, q3; scanf("%d %d", &p1, &q1); scanf("%d %d", &p2, &q2); scanf("%d %d", &p3, &q3); int s1 = p1 * q1; int s2 = p2 * q2; int s3 = p3 * q3; printf("%5d x %2d = %6d\n", p1, q1, s1); printf("%5d x %2d = %6d\n", p2, q2, s2); printf("%5d x %2d = %6d\n", p3, q3, s3); int sub = s1 + s2 + s3; int tax = sub * 10 / 100; printf("Subtotal: %d\n", sub); printf("Imposto: %d\n", tax); printf("Total: %d\n", sub + tax); return 0; }
sub * 0.1, o tipo não combina com o %d na hora de mostrar. O mais seguro é manter dinheiro em int e multiplicar antes de dividir (na ordem sub / 100 * 10, 1343 ienes dariam 130 ienes de imposto).a / b e a % b em C, o valor de (a / b) * b + a % b como verificação e o resto matemático (o resto que fica entre 0 e b − 1)."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
% devolve um resto negativo quando a é negativo. Somando b e tirando de novo o resto da divisão por b, ou seja, (a % b + b) % b, você obtém sempre um resto maior ou igual a 0.#include <stdio.h> int main(void) { int a, b; scanf("%d %d", &a, &b); int q = a / b; int r = a % b; int m = (r + b) % b; printf("Quociente: %d\n", q); printf("Resto: %d\n", r); printf("Verificação: %d\n", q * b + r); printf("Resto matemático: %d\n", m); return 0; }
(a / b) * b + a % b == a valha, por isso é −1. Ao lidar com valores negativos em cálculos de dia da semana ou de relógio, só r + b não basta, pois dá b quando r = 0; por isso no final se aplica % b mais uma vez.HH:MM (ambos com 2 dígitos e zero à esquerda, formato 24 horas). Na linha seguinte, mostre quantos dias a data avançou, no formato +N dia(s)."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
h * 60 + m + t. A partir daí, os dias são / 1440 e os minutos dentro do dia são % 1440.#include <stdio.h> int main(void) { int h, m, t; scanf("%d %d %d", &h, &m, &t); int total = h * 60 + m + t; int days = total / 1440; int rest = total % 1440; printf("%02d:%02d\n", rest / 60, rest % 60); printf("+%d dia(s)\n", days); return 0; }
/ e % é a técnica padrão para horários e conversões de unidade (1 dia = 24 × 60 = 1440 minutos).