Operadores aritméticos, relacionais e lógicos

#include <stdio.h>

int main(void)
{
    int acervo = 120;
    int leitores = 0;

    printf("Acervo inicial: %d\n", acervo);

    acervo += 15;            /* doação: soma ao valor atual */
    printf("Após doação: %d\n", acervo);

    acervo -= 8;             /* empréstimos de dois leitores */
    leitores++;
    leitores++;
    printf("Após empréstimos: %d\n", acervo);

    acervo += 3;             /* devolução de um leitor */
    leitores++;
    printf("Após devoluções: %d\n", acervo);

    acervo--;                /* baixa de um livro danificado */
    printf("Após baixa de 1 livro danificado: %d\n", acervo);

    printf("Leitores atendidos: %d\n", leitores);
    return 0;
}

Passo a passo

1. acervo começa em 120 e leitores em 0; o contador precisa de valor inicial, senão o ++ somaria 1 a um lixo de memória.
2. acervo += 15; é a forma curta de acervo = acervo + 15;: lê o valor atual, soma e guarda no mesmo lugar, chegando a 135.
3. acervo -= 8; desconta os empréstimos (127). Logo depois, leitores++ aparece duas vezes, uma por leitor atendido.
4. A devolução volta a usar += (130) e soma mais um leitor, chegando a 3 atendimentos.
5. acervo--; tira exatamente uma unidade (129). Para mudanças de 1, ++ e -- deixam a intenção mais clara que += 1.
6. Cada printf vem logo depois da movimentação, então a saída mostra o acervo passo a passo.

Por que funciona

Os operadores de atribuição composta (+=, -=, *=, /=, %=) combinam uma conta com a atribuição: o lado esquerdo é lido, operado com o lado direito e regravado. Já ++ e -- são o caso particular de somar ou subtrair 1. Como aqui eles aparecem sozinhos na linha, tanto faz a forma pré (++leitores) ou pós (leitores++).

Erros comuns

• Inverter a ordem do operador: acervo =+ 15; compila, mas é lido como acervo = +15; e o acervo passa a valer 15. O operador composto é +=, com o = depois.
• Esquecer o ponto e vírgula entre movimentações: acervo -= 8 leitores++; não compila (expected ';'). Cada atualização é um comando.
• Contador sem valor inicial: int leitores; leitores++; soma 1 a um valor imprevisível. Inicialize com 0.

Outra forma de resolver

As movimentações podem ser escritas por extenso:

acervo = acervo + 15;
leitores = leitores + 1;

O resultado é o mesmo; a forma longa ajuda só quando o lado direito usa outra variável no lugar do próprio acervo.

Saída esperada

Acervo inicial: 120
Após doação: 135
Após empréstimos: 127
Após devoluções: 130
Após baixa de 1 livro danificado: 129
Leitores atendidos: 3

#include <stdio.h>

int main(void)
{
    int qtd_camiseta = 3;
    int preco_camiseta = 40;
    int qtd_bone = 2;
    int preco_bone = 25;
    int cupom = 10;
    int parcelas = 3;

    /* Errado: / vem antes de -, então só o cupom é dividido */
    int sem_parenteses = qtd_camiseta * preco_camiseta
                         + qtd_bone * preco_bone - cupom / parcelas;

    /* Certo: o total (já com o cupom) é fechado antes da divisão */
    int total = qtd_camiseta * preco_camiseta + qtd_bone * preco_bone - cupom;
    int parcela = total / parcelas;
    int primeira = parcela + total % parcelas;  /* absorve a sobra */

    printf("Total do pedido: R$ %d\n", total);
    printf("Expressão sem parênteses: R$ %d\n", sem_parenteses);
    printf("Parcelas: %d\n", parcelas);
    printf("Primeira parcela: R$ %d\n", primeira);
    printf("Demais parcelas: R$ %d\n", parcela);
    /* * vem antes de +, e os parênteses fazem o - primeiro */
    printf("Conferência: R$ %d\n", primeira + parcela * (parcelas - 1));
    return 0;
}

Passo a passo

1. Cada quantidade e preço fica numa variável int com nome, para a expressão se ler como a regra da loja e não como números soltos.
2. Em sem_parenteses, * e / são resolvidos antes de + e -: o C calcula 3 * 40 = 120, 2 * 25 = 50 e 10 / 3 = 3, e só então faz 120 + 50 - 3 = 167. O valor não é parcela de nada.
3. total junta os itens e desconta o cupom: 120 + 50 - 10 = 160. Guardar o total numa variável tem o mesmo efeito de pôr a soma entre parênteses: ela fica pronta antes da divisão.
4. total / parcelas é divisão inteira: 160 / 3 dá 53, e total % parcelas devolve o real que sobrou, 1.
5. A primeira parcela recebe a sobra (53 + 1 = 54), assim nenhum real se perde na divisão.
6. A conferência usa precedência a favor: parcelas - 1 está entre parênteses, * vem antes de +, e 54 + 53 * 2 dá 160 de volta.

Por que funciona

Operadores têm precedência: multiplicativos (*, /, %) antes dos aditivos (+, -), e, entre os de mesmo nível, a avaliação vai da esquerda para a direita. A expressão original estava sintaticamente correta, mas dizia outra coisa. Fechar o total antes de dividir, com parênteses ou com uma variável, faz o código dizer o que a regra pede. O par / e % então reparte o valor inteiro sem perder nenhum real.

Erros comuns

• Confiar na ordem da escrita: a + b - c / n não divide a soma toda; só c é dividido. Agrupe com parênteses: (a + b - c) / n.
• Perder a sobra: imprimir só total / parcelas três vezes soma 159, um real a menos. Some total % parcelas a uma das parcelas.
• Parênteses só no fim: qtd_camiseta * preco_camiseta + (qtd_bone * preco_bone - cupom) / parcelas ainda deixa as camisetas fora da divisão e dá 133. O parêntese precisa envolver todo o total.

Outra forma de resolver

A parcela pode sair numa única expressão, sem a variável total:

int parcela = (qtd_camiseta * preco_camiseta + qtd_bone * preco_bone - cupom) / parcelas;

Serve quando o total não será usado de novo; aqui ele aparece na saída e no resto, então a variável evita repetir a conta.

Saída esperada

Total do pedido: R$ 160
Expressão sem parênteses: R$ 167
Parcelas: 3
Primeira parcela: R$ 54
Demais parcelas: R$ 53
Conferência: R$ 160

#include <stdio.h>

int main(void)
{
    int convidados = 23;
    int cookies_por_pessoa = 3;
    int por_fornada = 12;
    int ovos_por_fornada = 2;
    int ovos_em_casa = 10;
    int max_fornadas = 6;   /* o que dá para assar até a festa */

    int necessarios = convidados * cookies_por_pessoa;

    /* Divisão arredondada para cima só com inteiros */
    int fornadas = (necessarios + por_fornada - 1) / por_fornada;

    int assados = fornadas * por_fornada;
    int sobra = assados - necessarios;
    int ovos_necessarios = fornadas * ovos_por_fornada;

    /* Comparações guardadas direto: valem 1 ou 0 */
    int ovos_ok = ovos_em_casa >= ovos_necessarios;
    int cabe_no_tempo = fornadas <= max_fornadas;
    int faltam = ovos_ok ? 0 : ovos_necessarios - ovos_em_casa;

    printf("Cookies necessários: %d\n", necessarios);
    printf("Fornadas: %d\n", fornadas);
    printf("Cookies assados: %d\n", assados);
    printf("Sobra: %d\n", sobra);
    printf("Ovos necessários: %d\n", ovos_necessarios);
    printf("Ovos suficientes: %s\n", ovos_ok ? "sim" : "não");
    printf("Faltam ovos: %d\n", faltam);
    printf("Cabe no tempo do forno: %s\n", cabe_no_tempo ? "sim" : "não");
    /* && só é verdadeiro se as duas condições forem */
    printf("Festa pronta: %s\n", ovos_ok && cabe_no_tempo ? "sim" : "não");
    return 0;
}

Passo a passo

1. Todos os dados da receita e da festa ficam em variáveis int; nenhuma conta aqui precisa de parte decimal, porque fornadas, cookies e ovos são contados em unidades inteiras.
2. convidados * cookies_por_pessoa dá 69 cookies. Esse é o mínimo; a divisão por fornada é que define quanto será assado de fato.
3. 69 / 12 daria 5 fornadas e faltariam cookies. Somando por_fornada - 1 antes de dividir, (69 + 11) / 12 = 80 / 12 = 6: qualquer sobra empurra o resultado para a fornada seguinte, e uma divisão exata não muda.
4. Com 6 fornadas, saem 72 cookies e sobram 3; os ovos necessários são 6 * 2 = 12.
5. ovos_ok e cabe_no_tempo recebem o resultado das comparações. Como 10 >= 12 é falso, ovos_ok vale 0; 6 <= 6 é verdadeiro e cabe_no_tempo vale 1.
6. O ternário evita um número negativo em faltam: só quando os ovos não bastam ele calcula 12 - 10 = 2.
7. Na última linha, && tem precedência maior que ?:, então ovos_ok && cabe_no_tempo é avaliado primeiro. Como ovos_ok é 0, o curto-circuito nem olha cabe_no_tempo e a festa não está pronta.

Por que funciona

O arredondamento para cima é aritmética de inteiros pura: somar divisor - 1 ao dividendo faz a divisão truncada "passar" para o próximo inteiro sempre que houver resto. Não é preciso ceil, double nem if.

As decisões vêm dos relacionais, que em C produzem um int 1 ou 0. Guardando esse valor numa variável com nome, a condição final se lê como frase (ovos_ok && cabe_no_tempo) e cada parte pode ser impressa e conferida separadamente.

Erros comuns

• Divisão sem arredondar: int fornadas = necessarios / por_fornada; dá 5, e só 60 cookies para os 69 necessários. Use (necessarios + por_fornada - 1) / por_fornada.
• Parênteses esquecidos no arredondamento: necessarios + por_fornada - 1 / por_fornada calcula 1 / 12 = 0 primeiro e resulta em 81. A soma precisa ficar entre parênteses.
• Subtrair sem conferir: int faltam = ovos_necessarios - ovos_em_casa; daria um valor negativo quando sobram ovos. Proteja com a comparação, como no ternário.
• & no lugar de &&: com valores 1 e 0 o resultado coincide, mas & avalia os dois lados sempre e, com outros valores (como 2 & 1), dá 0. Para lógica, use &&.

Outra forma de resolver

O arredondamento também pode somar o resultado de uma comparação:

int fornadas = necessarios / por_fornada + (necessarios % por_fornada != 0);

A comparação vale 1 quando há resto e 0 quando a divisão é exata. É preferível quando necessarios + por_fornada puder estourar o limite do int, já que não soma nada ao dividendo.

Saída esperada

Cookies necessários: 69
Fornadas: 6
Cookies assados: 72
Sobra: 3
Ovos necessários: 12
Ovos suficientes: não
Faltam ovos: 2
Cabe no tempo do forno: sim
Festa pronta: não