Operadores

#include <iostream>

int main() {
    constexpr int meta = 20;  // pontos que o time quer fazer no quarto
    int pontos = 0;
    int jogadas = 0;

    pontos += 2;  // cesta de dois
    ++jogadas;
    pontos += 3;  // cesta de três
    ++jogadas;
    pontos += 1;  // primeiro lance livre
    ++jogadas;
    pontos += 1;  // segundo lance livre
    ++jogadas;
    pontos += 2;  // outra cesta de dois
    ++jogadas;

    std::cout << "Pontos: " << pontos << '\n';
    std::cout << "Jogadas: " << jogadas << '\n';
    std::cout << "Faltam para " << meta << ": " << meta - pontos << '\n';

    return 0;
}

Passo a passo

1. constexpr int meta = 20; guarda a meta do quarto como constante, para que o número 20 apareça num lugar só.
2. pontos e jogadas começam em zero: os operadores compostos leem o valor atual antes de alterar, então a variável precisa ter um valor inicial.
3. Cada pontos += 2; (ou += 3, += 1) soma o valor da jogada ao placar; é o mesmo que pontos = pontos + 2;, só que mais curto.
4. ++jogadas; soma 1 ao contador a cada jogada que pontuou. Como o valor não é usado na mesma linha, tanto faz o pré ou o pós-fixado.
5. Depois das cinco jogadas, o placar vale 2 + 3 + 1 + 1 + 2 = 9 e o contador vale 5.
6. meta - pontos é calculado direto na saída; como - tem precedência maior que <<, não precisa de parênteses.

Por que funciona

A atribuição composta lê a variável, aplica a operação e guarda o resultado de volta, numa instrução só. O incremento é o caso particular de somar 1. Assim, o placar e o contador acompanham o jogo linha a linha, e o total nunca precisa ser digitado: ele é consequência das jogadas.

Erros comuns

• Inverter o operador: pontos =+ 2; compila, mas é lido como pontos = +2; e apaga o placar a cada jogada. O sinal da operação vem antes do =.
• Não inicializar: int pontos; seguido de pontos += 2; soma 2 a um valor indefinido, e o resultado muda a cada execução. Comece com int pontos = 0;.
• Esquecer um ++jogadas: o contador fica em 4 e a saída não bate. Uma forma de evitar é escrever a jogada e o contador sempre em par, como na solução.

Outra forma de resolver

Daria para escrever int pontos = 2 + 3 + 1 + 1 + 2; numa linha. Funciona para um placar fixo, mas a forma com += é a que acompanha um jogo de verdade, em que cada jogada chega em um momento diferente e precisa atualizar o total.

Saída esperada

Pontos: 9
Jogadas: 5
Faltam para 20: 11

#include <iostream>

int main() {
    int preparo = 25;     // minutos para preparar a massa
    int descanso = 90;    // massa descansando
    int fornadas = 2;
    int porFornada = 35;  // minutos de forno por fornada
    int preaquecer = 10;

    // Sem parênteses: * vem antes de +, então só as fornadas são multiplicadas
    int total = preparo + descanso + fornadas * porFornada + preaquecer;

    // / dá as horas cheias e % os minutos que sobram
    int horas = total / 60;
    int minutos = total % 60;

    // Jantar às 19:00, convertido para minutos desde a meia-noite
    int jantar = 19 * 60;
    int inicio = jantar - total;

    std::cout << "Tempo total: " << total << " min\n";
    std::cout << "Duração: " << horas << " h " << minutos << " min\n";
    std::cout << "Começar às " << inicio / 60 << ':' << inicio % 60 << '\n';

    return 0;
}

Passo a passo

1. Cada etapa da receita fica numa variável int, sempre em minutos, para que todas as contas usem a mesma unidade.
2. Na expressão do total, a multiplicação fornadas * porFornada é feita primeiro (70) e só depois as somas: 25 + 90 + 70 + 10 = 195.
3. total / 60 divide dois int, então dá as horas cheias (3) e descarta o resto.
4. total % 60 devolve exatamente o que a divisão descartou: os 15 minutos.
5. 19 * 60 converte o horário do jantar para 1140 minutos desde a meia-noite; subtraindo o total, o início fica em 945.
6. Na última linha, inicio / 60 (15) e inicio % 60 (45) voltam a ser horas e minutos; como / e % têm precedência maior que <<, não precisam de parênteses.

Por que funciona

A precedência resolve a ordem das contas sem parênteses: multiplicação antes da soma, exatamente como na matemática. Já o par / e % é a ferramenta clássica para quebrar uma quantidade em unidades maiores e menores: o quociente diz quantas horas cheias cabem e o resto diz o que sobrou. Trabalhar tudo em minutos e só converter no fim evita somar horas com minutos por engano.

Erros comuns

• Parênteses no lugar errado: (preparo + descanso + fornadas) * porFornada + preaquecer multiplica tudo por 35 e dá 4.105 minutos. Os parênteses só são necessários quando você quer mudar a ordem natural.
• Somar as fornadas como uma só: preparo + descanso + porFornada + preaquecer esquece a segunda fornada e mostra 160 minutos.
• Usar double sem precisar: com double total, total / 60 vale 3.25 e % nem compila, porque o operador resto só existe para inteiros.
• Subtrair horas de minutos: 19 - total mistura unidades e dá -176. Converta o horário para minutos antes da conta.

Outra forma de resolver

Dá para guardar o início já separado, com int horaInicio = (jantar - total) / 60; e int minutoInicio = (jantar - total) % 60;. Aqui os parênteses são obrigatórios, porque a subtração precisa acontecer antes da divisão. Essa forma vale a pena quando os valores serão reaproveitados em outras contas.

Saída esperada

Tempo total: 195 min
Duração: 3 h 15 min
Começar às 15:45

#include <bit>  // std::popcount (C++20)
#include <iostream>

int main() {
    // Cada conquista ocupa um bit
    constexpr unsigned int PRIMEIRA_VITORIA = 1u << 0;  // 1
    constexpr unsigned int COLECIONADOR = 1u << 1;      // 2
    constexpr unsigned int EXPLORADOR = 1u << 2;        // 4
    constexpr unsigned int INVICTO = 1u << 3;           // 8
    constexpr unsigned int MESTRE = 1u << 4;            // 16
    // Máscara: as três conquistas do pacote básico juntas
    constexpr unsigned int BASICO = PRIMEIRA_VITORIA | COLECIONADOR | EXPLORADOR;

    std::cout << std::boolalpha;

    unsigned int conquistas = PRIMEIRA_VITORIA | EXPLORADOR;
    std::cout << "Conquistas iniciais: " << conquistas << '\n';

    conquistas |= COLECIONADOR;  // liga um bit
    std::cout << "Após colecionador: " << conquistas << '\n';

    // Parênteses: sem eles, != seria avaliado antes do &
    std::cout << "Tem mestre: " << ((conquistas & MESTRE) != 0) << '\n';

    conquistas |= INVICTO;
    std::cout << "Após invicto: " << conquistas << '\n';

    conquistas &= ~INVICTO;  // a derrota desliga só o bit do invicto
    std::cout << "Após a derrota: " << conquistas << '\n';

    int total = std::popcount(conquistas);  // quantos bits estão ligados
    std::cout << "Total de conquistas: " << total << '\n';

    // Todos os bits da máscara precisam estar ligados
    std::cout << "Pacote básico completo: " << ((conquistas & BASICO) == BASICO) << '\n';

    // Cada conquista dobra o bônus: 10 deslocado 3 bits = 10 * 2 * 2 * 2
    int moedas = 10 << total;
    std::cout << "Moedas de bônus: " << moedas << '\n';

    return 0;
}

Passo a passo

1. 1u << n desloca o bit 1 para a posição n, gerando 1, 2, 4, 8 e 16: cada conquista tem um bit só dela. O u deixa o valor sem sinal, o tipo indicado para bits.
2. BASICO junta três conquistas com | numa máscara de valor 7 (bits 0, 1 e 2 ligados).
3. O jogador começa com PRIMEIRA_VITORIA | EXPLORADOR, ou seja, 1 + 4 = 5. Com |, bits iguais nunca somam duas vezes.
4. conquistas |= COLECIONADOR liga o bit 2 e o valor passa a 7; os bits que já estavam ligados continuam como estavam.
5. (conquistas & MESTRE) != 0 isola o bit 16: como ele está desligado, o & dá 0 e a comparação dá false.
6. |= INVICTO leva o valor a 15; em seguida, &= ~INVICTO usa o complemento (todos os bits ligados, menos o 8) para desligar só esse bit, e o valor volta a 7.
7. std::popcount conta os bits ligados de um inteiro sem sinal: 3. Já (conquistas & BASICO) == BASICO só é verdadeiro se todos os bits da máscara estiverem ligados.
8. 10 << total desloca 10 três bits para a esquerda, o que equivale a multiplicar por 2 três vezes: 80 moedas.

Por que funciona

Um único unsigned int guarda até 32 conquistas, uma por bit. Os operadores bit a bit agem posição por posição: | liga, & com ~ desliga, & com uma máscara testa e << desloca. Como cada conquista tem um bit exclusivo, ligar ou desligar uma nunca afeta as outras, e o estado inteiro do jogador cabe num número que pode ser salvo ou comparado de uma vez.

O teste com máscara generaliza o teste de um bit: comparar com != 0 responde "tem alguma destas?", e comparar com == BASICO responde "tem todas estas?".

Erros comuns

• Esquecer os parênteses no teste: conquistas & MESTRE != 0 é lido como conquistas & (MESTRE != 0), ou seja, conquistas & 1, que testa a primeira vitória. Envolva o & em parênteses.
• Confundir && com &: conquistas && MESTRE só pergunta se os dois valores são diferentes de zero e dá true aqui. Para bits, use &.
• Desligar com ^: conquistas ^= INVICTO inverte o bit; se o jogador ainda não fosse invicto, ganharia a conquista na derrota. Para desligar sempre, use &= ~INVICTO.
• Somar em vez de |: conquistas += COLECIONADOR funciona na primeira vez, mas, se o bit já estiver ligado, a soma vira 9 e liga o bit do invicto. O |= é seguro para repetir.

Outra forma de resolver

A biblioteca padrão tem std::bitset<5> (cabeçalho <bitset>), com set, reset, test, count e all, que dão nomes às operações e imprimem os bits como 00111. É preferível quando a legibilidade importa mais do que guardar o estado num inteiro, por exemplo para salvar ou enviar pela rede.

Saída esperada

Conquistas iniciais: 5
Após colecionador: 7
Tem mestre: false
Após invicto: 15
Após a derrota: 7
Total de conquistas: 3
Pacote básico completo: true
Moedas de bônus: 80