Tipos básicos, operadores e pensamento algorítmico.
Ao encarar as 16 questões a seguir, você não está só “fazendo continhas em Python”. Você está treinando o conjunto
mínimo de competências que transforma alguém que copia código em alguém que constrói código com intenção. O desafio
começa simples (comentários e print()), mas rapidamente vira um treino de raciocínio: organizar dados em
variáveis, aplicar um fluxo claro de Entrada → Processamento → Saída (IPO), escolher tipos corretos
(int, float, bool), operar com segurança em cálculos e, mais adiante, resolver
problemas “de mundo real” que exigem arredondamento para baixo, resto de divisão,
conversão de unidades e respeito à regra de negócio.
Se você conseguir resolver todas, você terá dominado estas skills/qualidades: você saberá ler enunciados como um programador. Isso significa extrair entradas, saídas, restrições (por exemplo: “somente unidades inteiras”, “tributa antes, soma suporte depois”, “parada só no fim do ciclo”) e transformar isso em passos claros. Em vez de “tentar até funcionar”, você passa a raciocinar em cima do que o problema realmente pede.
Você terá controle do básico com precisão: variáveis, atribuição e reatribuição (estado do programa), impressão de
resultados, e principalmente a diferença entre “o código rodou” e “o código está correto”. Ao usar
type() e trabalhar com int, float e bool, você consolida noções de
tipagem prática: contagens não são valores monetários, e estados (ligado/desligado) não são números disfarçados.
Você dominará a aritmética que mais aparece em sistemas reais: soma, subtração, multiplicação, divisão, e o ponto crítico que muita gente tropeça — ordem das operações. Alguns exercícios te obrigam a usar parênteses não por estética, mas para garantir que a regra de negócio seja respeitada.
Você ganhará um “superpoder” de iniciante avançado: saber quando usar divisão comum (/) e quando usar
divisão inteira (//) e resto (%). Isso é o coração de vários
problemas práticos: capacidade máxima sem exceder, decomposição de tempo em horas/minutos, ciclos periódicos, e
qualquer situação em que “não pode quebrar em fração”.
Você aprenderá a pensar em unidades e conversões sem se perder. Minutos para horas decimais, horas para segundos, energia por segundo, margem de segurança — isso é treino de engenharia mental: manter as grandezas consistentes e evitar “erros de unidade” (que são um tipo de bug silencioso e caro).
Você terá uma noção inicial de confiabilidade: calcular com clareza, nomear variáveis com significado, produzir saídas “devidamente sinalizadas” e construir resultados que outra pessoa consegue auditar. Em outras palavras, você começa a programar de um jeito que o time confia.
No fim, quem resolve todas essas questões sai com um núcleo sólido: consegue pegar um problema simples, modelar os
dados, executar os cálculos corretos, justificar as escolhas (especialmente //, % e
parênteses), e apresentar o resultado com clareza. Isso é exatamente a fronteira entre “aprendi comandos” e “aprendi
programação”.
# Programar em Python permite automatizar tarefas repetitivas, reduzir erros humanos,
# padronizar processos e aumentar a eficiência: o computador faz o trabalho chato,
# rápido e reprodutível.Validação: nada aparece na saída (porque comentário não roda).
print("Olá Mundo! Bem-vindo ao Cinema Digital")Validação: o terminal deve mostrar exatamente a frase, sem erros de aspas ou parênteses.
disciplina = "Python"
turma = 101
print(disciplina)
print(turma)Erro comum: esquecer aspas em "Python" (vira “nome de variável” e dá erro de variável não definida).
input() ainda, você já separa mentalmente Entrada, Processamento e Saída.# Entrada
peso_unidade = 80
quantidade = 10
# Processamento
peso_total = peso_unidade * quantidade
# Saída
print(peso_total)Validação: deve imprimir 800. Se o valor não bater, revise as variáveis e a operação.
int para contagem e float para preço monetário.quantidade_macas = 150
preco_maca = 5.99
print(quantidade_macas)
print(preco_maca)Observação: 5.99 é float (decimal). Evite usar inteiros para valores com centavos.
contratos = 12
faturamento = 2500.50
print(type(contratos))
print(type(faturamento))Validação: deve aparecer algo como <class 'int'> e <class 'float'>. Use isso como “raio-X” rápido do seu estado.
sensor_ativo = True
print(sensor_ativo)
sensor_ativo = False
print(sensor_ativo)Erro comum: escrever true/false (minúsculo). Em Python é True/False com inicial maiúscula.
venda_smartphones = 5400.00
venda_acessorios = 1250.50
receita_total = venda_smartphones + venda_acessorios
print(receita_total)Validação: 6650.5 (pode aparecer como 6650.50 dependendo de formatação; se quiser 2 casas, use print(f"{receita_total:.2f}")).
saldo_atual = 10000
valor_fatura = 3500
saldo_final = saldo_atual - valor_fatura
print(saldo_final)Validação: 6500. Se o sinal estiver invertido, revise a ordem das variáveis na subtração.
float e int.preco_fardo = 24.0
unidades = 6
preco_unitario = preco_fardo / unidades
print(preco_unitario)Validação: 4.0. Note que o resultado é float mesmo dividindo por um inteiro.
//). Depois calcula ocupação em porcentagem.capacidade_kg = 550
peso_saca = 65
max_sacas = capacidade_kg // peso_saca
capacidade_real = max_sacas * peso_saca
ocupacao_percent = (capacidade_real / capacidade_kg) * 100
print("Max sacas:", max_sacas)
print("Capacidade real (kg):", capacidade_real)
print("Ocupação (%):", ocupacao_percent)Validação esperada:
max_sacas: 8capacidade_real: 520 kgocupacao_percent: ~94.545...%Erro comum: usar / e obter número quebrado de sacas (o enunciado proíbe).
%). Parada no fim do ciclo → próximo múltiplo de 8.dias_decorridos = 125
periodo = 8
dia_atual_ciclo = dias_decorridos % periodo
dias_ate_parada = (periodo - dia_atual_ciclo) % periodo
total_dias_ate_parada = dias_decorridos + dias_ate_parada
print("Dia atual do ciclo (0 a 7):", dia_atual_ciclo)
print("Total de dias decorridos até a parada:", total_dias_ate_parada)Validação:
5128 (próximo fechamento de ciclo)Armadilha: confundir “fim do ciclo” com “dia 7”. Na prática operacional, o “fim” costuma ser o instante em que completa 8 dias (múltiplo de 8), aqui 128.
custo_base = 2500
aliquota = 0.05
suporte = 150
total_final = (custo_base * (1 + aliquota)) + suporte
print(total_final)Validação: 2775.0. Sem os parênteses, você muda a regra de negócio (por exemplo, pode estar tributando também o suporte).
minutos = 345
horas_decimais = minutos / 60
print(horas_decimais)Validação: 5.75. O enunciado pode citar outro equipamento, mas a tarefa aqui é registrar especificamente os 345 minutos.
voo1_horas = 3.77
voo2_minutos = 214
joules_por_segundo = 2.7
margem = 0.15
voo1_seg = voo1_horas * 3600
voo2_seg = voo2_minutos * 60
total_seg = voo1_seg + voo2_seg
energia = total_seg * joules_por_segundo
energia_com_margem = energia * (1 + margem)
print("Total (s):", total_seg)
print("Energia (J):", energia)
print("Energia com 15% (J):", energia_com_margem)Validação numérica (aprox.):
total_seg ≈ 26412.0energia ≈ 71312.4 Jenergia_com_margem ≈ 82009.26 JErros comuns: esquecer que 1h = 3600s; aplicar 15% antes de somar os voos (aqui a ordem não muda o resultado final, mas em outros problemas muda).
// e % (quociente e resto). Primeiro separam-se horas e minutos; depois calcula-se o valor pago.total_minutos = 1527
valor_por_hora = 60.00
valor_por_minuto = 1.20
horas_trabalhadas = total_minutos // 60
minutos_excedentes = total_minutos % 60
valor_horas = horas_trabalhadas * valor_por_hora
valor_minutos = minutos_excedentes * valor_por_minuto
valor_total = valor_horas + valor_minutos
print("Horas trabalhadas:", horas_trabalhadas)
print("Minutos excedentes:", minutos_excedentes)
print("Valor pago pelas horas: R$", valor_horas)
print("Valor pago pelos minutos: R$", valor_minutos)
print("Valor total a receber: R$", valor_total)Validação:
25271500.032.41532.4Armadilha: usar / em vez de // para horas (gera número quebrado e destrói a lógica de “horas completas”).
// e %) para problemas de “unidades inteiras” e decomposição de tempo.// e %): pegue total_minutos = 999 e decomponha em horas e minutos; depois reconstrua o total (horas*60 + minutos) e mostre que bate com 999. Rubrica: iniciante (funciona), autônomo (testa casos), bom design (nomes claros), excelente (explica o porquê de // e %).