Introdução a Programação com Python: Strings, Formatação e Contratos I/O

▲

BASE

Como usar esta página de Python II

Objetivo: resolver cada exercício com método, validação e explicação técnica.

Roteiro de estudo

Leia o contrato I/O antes de programar: entrada, processamento e saída.
Onde houver input(), forneça as entradas na ordem pedida (uma por linha), como no Deepnote.
Implemente o caso principal e valide com um caso de borda na sequência.
Feche cada exercício explicando por que o formato de saída está correto.

Foco técnico do roteiro

Strings: concatenação, repetição, transformação e contagem.
Aritmética: subtração, porcentagem, juros simples e fórmulas compostas.
Precisão de formato: espaços, separadores, maiúsculas/minúsculas e pontuação fixa.

▼

EX.01

Cabeçalho multilinha (string com quebras de linha)

Objetivo: texto multilinha pode ser escrito com aspas triplas (mais simples) ou com '\n' entre linhas.

O que a questão pede

você precisa armazenar 3 linhas “exatamente” em uma única variável string (com quebras de linha preservadas).

Conceito cobrado

texto multilinha pode ser escrito com aspas triplas (mais simples) ou com '\n' entre linhas.

Estrutura dos dados

Entrada: nenhuma.
Saída: 3 linhas (o cabeçalho impresso).

Como pensar

O enunciado quer uma única string contendo 3 linhas. Armazene o texto inteiro primeiro; só depois imprima. Se você usar 3 print() separados, resolve a saída, mas não a exigência de manter tudo em uma variável.

Como validar

Ao imprimir, o console deve mostrar exatamente 3 linhas: Nome do módulo..., Data de criação... e Descrição.... Se tudo sair em uma linha só ou se você depender de 3 strings independentes, o contrato falhou.

Tabela de Evidência

Leitura: nenhuma.
Decisão no código: texto multilinha pode ser escrito com aspas triplas (mais simples) ou com '\n' entre linhas.
Evidência: saída final no formato exato (3 linhas (o cabeçalho impresso).).

Variáveis-chave

cabecalho

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Fazer 3 prints separados (vira 3 strings soltas, não “uma única string armazenada”). / Perder a quebra de linha (colocar tudo em uma linha só).

cabecalho = """Nome do módulo: Módulo de Vendas Diretas
Data de criação: 15/03/2024
Descrição: Responsável pelo registro e acompanhamento das vendas da equipe externa."""

print(cabecalho)

▼

EX.02

Montar SKU (prefixo + número de série)

Objetivo: concatenação de strings usa o operador +.

O que a questão pede

combinar duas strings para formar um identificador.

Conceito cobrado

concatenação de strings usa o operador +.

Estrutura dos dados

Entrada: nenhuma (dados definidos em variáveis).
Saída: 1 linha (SKU completo).

Como pensar

Há duas partes fixas e nenhuma regra extra de separador. O caminho é juntar prefixo e número exatamente nessa ordem e guardar o resultado em sku.

Como validar

Com ELT e 12345, o programa deve imprimir ELT12345. Qualquer espaço, hífen ou barra extra quebra o formato.

Tabela de Evidência

Leitura: nenhuma (dados definidos em variáveis).
Decisão no código: concatenação de strings usa o operador +.
Evidência: saída final no formato exato (1 linha (SKU completo).).

Variáveis-chave

prefixo
numero_serie
sku

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

prefixo = "ELT"
numero_serie = "12345"

sku = prefixo + numero_serie
print(sku)

▼

EX.03

Linha separadora (repetição de caractere)

Objetivo: em Python, string * inteiro repete a string.

O que a questão pede

repetir um caractere N vezes para gerar uma linha.

Conceito cobrado

em Python, string * inteiro repete a string.

Estrutura dos dados

Entrada: 2 linhas: (1) um caractere, (2) um inteiro positivo (comprimento).
Saída: 1 linha: o caractere repetido exatamente “comprimento” vezes.

Como pensar

Converta o comprimento para inteiro antes da repetição. Depois use o caractere como unidade e repita exatamente N vezes com *.

Como validar

Entrada - e 5 gera -----. Teste também * e 1; a saída deve ser *.

Tabela de Evidência

Leitura: 2 linhas: (1) um caractere, (2) um inteiro positivo (comprimento).
Decisão no código: em Python, string * inteiro repete a string.
Evidência: saída final no formato exato (1 linha: o caractere repetido exatamente “comprimento” vezes.).

Variáveis-chave

caractere
comprimento
linha

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Não converter para int: sem int(), não dá para repetir corretamente. / Digitar mais de um caractere (o programa repete “o texto todo”).

caractere = input()
comprimento = int(input())

linha = caractere * comprimento
print(linha)

▼

EX.04

Confirmar mensagem e inverter capitalização

Objetivo: swapcase() troca maiúscula ↔ minúscula em cada letra.

O que a questão pede

imprimir a mensagem original com confirmação e depois imprimir a versão com maiúsculas/minúsculas invertidas.

Conceito cobrado

swapcase() troca maiúscula ↔ minúscula em cada letra.

Estrutura dos dados

Entrada: 1 linha (mensagem do usuário).
Saída: 2 linhas:

Como pensar

Há duas saídas relacionadas ao mesmo texto. Leia a mensagem uma vez, reaproveite-a na confirmação literal e só depois aplique swapcase() para gerar a segunda linha.

Como validar

Se a entrada for PyThOn, a 1ª linha deve ser Mensagem recebida com sucesso: PyThOn e a 2ª pYtHoN.

Tabela de Evidência

Leitura: 1 linha (mensagem do usuário).
Decisão no código: swapcase() troca maiúscula ↔ minúscula em cada letra.
Evidência: saída final no formato exato (2 linhas:).

Variáveis-chave

mensagem

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Usar upper() ou lower() achando que “inverte” (na verdade força tudo para um lado só).

mensagem = input()

print("Mensagem recebida com sucesso: " + mensagem)
print(mensagem.swapcase())

▼

EX.05

Padronizar nomes (upper/capitalize) e gerar ID de segurança

Objetivo: - upper(): tudo maiúsculo

O que a questão pede

aplicar transformações em strings e depois concatenar no formato exigido.

Conceito cobrado

- upper(): tudo maiúsculo

Estrutura dos dados

Entrada: nenhuma obrigatória (pode usar variáveis como no exemplo do enunciado).
Saída: 3 linhas:

Como pensar

Faça cada transformação separadamente: upper() no nome completo, capitalize() no crachá e só então monte o ID com ---. Separar as etapas ajuda a enxergar se o erro está na transformação ou na concatenação.

Como validar

Com joão silva pereira e joão, as 3 saídas esperadas são JOÃO SILVA PEREIRA, João e João---JOÃO SILVA PEREIRA.

Tabela de Evidência

Leitura: nenhuma obrigatória (pode usar variáveis como no exemplo do enunciado).
Decisão no código: - upper(): tudo maiúsculo
Evidência: saída final no formato exato (3 linhas:).

Variáveis-chave

nome_completo
nome_cracha
nome_completo_formatado
nome_cracha_formatado
id_seguranca

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

nome_completo = "joão silva pereira"
nome_cracha = "joão"

nome_completo_formatado = nome_completo.upper()
nome_cracha_formatado = nome_cracha.capitalize()

id_seguranca = nome_cracha_formatado + "---" + nome_completo_formatado

print(nome_completo_formatado)
print(nome_cracha_formatado)
print(id_seguranca)

▼

EX.06

Verificar critérios de senha (caracteres especiais e letras)

Objetivo: - "x" in senha verifica presença do caractere

O que a questão pede

criar variáveis booleanas para cada critério e exibir claramente.

Conceito cobrado

- "x" in senha verifica presença do caractere

Estrutura dos dados

Entrada: 1 linha (senha do usuário).
Saída: várias linhas (cada uma indicando True/False para um critério).

Como pensar

Quebre a verificação em perguntas pequenas: tem @? tem !? tem #? é só letra minúscula? é só letra maiúscula? Cada pergunta vira uma variável booleana.

Como validar

Teste abc@123: a linha de @ deve sair True e as verificações de "apenas letras" devem sair False. Teste também senha; sem símbolos e com Apenas letras minúsculas? True.

Tabela de Evidência

Leitura: 1 linha (senha do usuário).
Decisão no código: - "x" in senha verifica presença do caractere
Evidência: saída final no formato exato (várias linhas (cada uma indicando True/False para um critério).).

Variáveis-chave

senha
tem_arroba
tem_exclamacao
tem_cerquilha
apenas_minusculas
apenas_maiusculas

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

senha = input()

tem_arroba = "@" in senha
tem_exclamacao = "!" in senha
tem_cerquilha = "#" in senha

apenas_minusculas = senha.isalpha() and senha.islower()
apenas_maiusculas = senha.isalpha() and senha.isupper()

print("Tem '@'?", tem_arroba)
print("Tem '!'?", tem_exclamacao)
print("Tem '#'?", tem_cerquilha)
print("Apenas letras minúsculas?", apenas_minusculas)
print("Apenas letras maiúsculas?", apenas_maiusculas)

▼

EX.07

Tamanho de SMS (len) e diferença para o limite 160

Objetivo: - len(texto) conta caracteres

O que a questão pede

medir o tamanho total (prefixo + mensagem + sufixo) e comparar com 160.

Conceito cobrado

- len(texto) conta caracteres

Estrutura dos dados

Entrada: nenhuma (mensagens em variáveis).
Saída: 2 linhas (tamanho total e diferença para 160).

Como pensar

Some os comprimentos do prefixo, da mensagem e do sufixo antes de comparar com 160. Depois interprete o sinal da diferença: positivo ainda cabe, negativo já excedeu.

Como validar

Se a diferença final for 12, ainda cabem 12 caracteres. Se sair -12, a mensagem passou do limite em 12.

Tabela de Evidência

Leitura: nenhuma (mensagens em variáveis).
Decisão no código: - len(texto) conta caracteres
Evidência: saída final no formato exato (2 linhas (tamanho total e diferença para 160).).

Variáveis-chave

mensagem_candidata
prefixo_padrao
sufixo_padrao
tamanho_total
diferenca_limite

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

mensagem_candidata = "Desconto exclusivo para você! Válido por tempo limitado."
prefixo_padrao = "Voz Digital: "
sufixo_padrao = " Acesse nosso site para detalhes."

tamanho_total = len(prefixo_padrao) + len(mensagem_candidata) + len(sufixo_padrao)
diferenca_limite = 160 - tamanho_total

print("Tamanho total:", tamanho_total)
print("Diferença para o limite (160):", diferenca_limite)

▼

EX.08

Cartão ASCII com bordas (repetição + \n)

Objetivo: - topo/fundo: "=" repetido

O que a questão pede

montar um “desenho” com bordas usando repetição e quebras de linha.

Conceito cobrado

- topo/fundo: "=" repetido

Estrutura dos dados

Entrada: nenhuma.
Saída: múltiplas linhas (o cartão desenhado).

Como pensar

Monte o cartão por partes: topo, linha interna e, por fim, o bloco completo com \n. Pensar em peças evita errar a quantidade de espaços do miolo.

Como validar

O resultado precisa formar um bloco visual como este:
================================== = = = = ==================================

Tabela de Evidência

Leitura: nenhuma.
Decisão no código: - topo/fundo: "=" repetido
Evidência: saída final no formato exato (múltiplas linhas (o cartão desenhado).).

Variáveis-chave

car
largura
topo
meio
cartao

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

car = "="
largura = 34

topo = car * largura
meio = car + (" " * (largura - 2)) + car

cartao = topo + "\n" + meio + "\n" + meio + "\n" + topo
print(cartao)

▼

EX.09

Montar URL por concatenação (passo a passo com '/')

Objetivo: construir em etapas reduz erro (e casa com o texto do enunciado).

O que a questão pede

concatenar partes com barras exatamente como o enunciado descreve.

Conceito cobrado

construir em etapas reduz erro (e casa com o texto do enunciado).

Estrutura dos dados

Entrada: nenhuma (dados em variáveis).
Saída: 1 linha (URL completa).

Como pensar

A regra do enunciado é montar em etapas. Acrescente cada segmento e a barra na ordem pedida para não gerar barra dupla nem esquecer o último trecho.

Como validar

Ao final deve sair api.linkmanager.com/clientes/123/detalhes, sem barra dupla e sem barra sobrando no fim.

Tabela de Evidência

Leitura: nenhuma (dados em variáveis).
Decisão no código: construir em etapas reduz erro (e casa com o texto do enunciado).
Evidência: saída final no formato exato (1 linha (URL completa).).

Variáveis-chave

dominio_base
caminho
identificador
acao
url

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

dominio_base = "api.linkmanager.com"
caminho = "clientes"
identificador = "123"
acao = "detalhes"

url = dominio_base + "/"
url = url + caminho + "/"
url = url + identificador + "/"
url = url + acao

print(url)

▼

EX.10

Contar hashtags com capitalização exata (count)

Objetivo: count() é sensível a capitalização.

O que a questão pede

contar ocorrências exatas, respeitando maiúsculas/minúsculas.

Conceito cobrado

count() é sensível a capitalização.

Estrutura dos dados

Entrada: nenhuma (texto em variável).
Saída: 2 linhas (contagem exata e contagem da versão minúscula).

Como pensar

São duas buscas diferentes no mesmo texto: uma para #PythonChallenge e outra para #pythonchallenge. Como count() respeita maiúsculas e minúsculas, cada contagem mede uma forma exata.

Como validar

No texto do exemplo, a saída esperada é 1 na primeira linha e 1 na segunda. Isso mostra que cada hashtag foi contada separadamente.

Tabela de Evidência

Leitura: nenhuma (texto em variável).
Decisão no código: count() é sensível a capitalização.
Evidência: saída final no formato exato (2 linhas (contagem exata e contagem da versão minúscula).).

Variáveis-chave

texto
qtd_exata
qtd_minuscula

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

texto = "Participe do nosso #PythonChallenge e conquiste prêmios! #pythonchallenge agora mesmo!"

qtd_exata = texto.count("#PythonChallenge")
qtd_minuscula = texto.count("#pythonchallenge")

print(qtd_exata)
print(qtd_minuscula)

▼

EX.11

Saldo de inventário (subtração) + frase final

Objetivo: aplicar as operações de string e/ou aritmética adequadas ao tipo de dado.

O que a questão pede

ler dois inteiros, subtrair e imprimir no formato pedido.

Conceito cobrado

Aplicar as operações de string e/ou aritmética adequadas ao tipo de dado.

Estrutura dos dados

Entrada: 2 linhas (inteiros): quantidade_inicial, quantidade_retirada.
Saída: 1 linha (frase exatamente como a especificação).

Como pensar

Leia os dois inteiros, calcule a diferença e só então monte a frase completa. O ponto crítico é converter os números de volta para texto na concatenação.

Como validar

Entrada 50 e 7 deve produzir exatamente Após a retirada de 7 itens, o saldo atual é de 43 unidades.

Tabela de Evidência

Leitura: 2 linhas (inteiros): quantidade_inicial, quantidade_retirada.
Decisão no código: Aplicar as operações de string e/ou aritmética adequadas ao tipo de dado.
Evidência: saída final no formato exato (1 linha (frase exatamente como a especificação).).

Variáveis-chave

quantidade_inicial
quantidade_retirada
quantidade_restante

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Esquecer int() e tentar subtrair strings.

quantidade_inicial = int(input())
quantidade_retirada = int(input())

quantidade_restante = quantidade_inicial - quantidade_retirada

print("Após a retirada de " + str(quantidade_retirada) + " itens, o saldo atual é de " + str(quantidade_restante) + " unidades.")

▼

EX.12

Juros simples + taxa administrativa + valor da parcela (2 linhas, 2 casas)

Objetivo: - juros simples: valor_com_juros = preco * (1 + taxa_juros * meses)

O que a questão pede

aplicar juros simples primeiro e só depois a taxa administrativa; dividir pelo número de meses.

Conceito cobrado

- juros simples: valor_com_juros = preco * (1 + taxa_juros * meses)

Estrutura dos dados

Entrada: Conforme enunciado.
Saída: 2 linhas:

Como pensar

A ordem importa: primeiro calcule os juros simples sobre o preço, depois aplique a taxa administrativa sobre o montante com juros e, só no fim, divida pelo número de meses.

Como validar

Caso de sanidade: entradas 1000, 0.02, 10 e 0.05 geram 1260.00 na 1ª linha e 126.00 na 2ª. Se inverter a ordem das taxas, os valores mudam.

Tabela de Evidência

Leitura: Conforme enunciado.
Decisão no código: - juros simples: valor_com_juros = preco * (1 + taxa_juros * meses)
Evidência: saída final no formato exato (2 linhas:).

Variáveis-chave

preco
taxa_juros
meses
taxa_admin
valor_com_juros
valor_total

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

preco = float(input())
taxa_juros = float(input())
meses = int(input())
taxa_admin = float(input())

valor_com_juros = preco * (1 + taxa_juros * meses)
valor_total = valor_com_juros * (1 + taxa_admin)
parcela = valor_total / meses

print(f"{valor_total:.2f}")
print(f"{parcela:.2f}")

▼

EX.13

Arcana Quest (// e % na fórmula)

Objetivo: - // = divisão inteira (corta decimais)

O que a questão pede

traduzir a fórmula do enunciado em variáveis intermediárias.

Conceito cobrado

- // = divisão inteira (corta decimais)

Estrutura dos dados

Entrada: 3 linhas (inteiros): exploracao, combate, estrategia.
Saída: 1 linha: "Pontuação Final em Arcana Quest: X pontos."

Como pensar

Separe a fórmula em blocos: base, bônus, dedução e fator. Isso reduz erro de precedência e deixa claro onde entram // e %.

Como validar

Teste 20, 19 e 8: como 19 % 10 vale 9, a dedução não pode ser zero. Esse caso confirma que o módulo entrou de fato na conta.

Tabela de Evidência

Leitura: 3 linhas (inteiros): exploracao, combate, estrategia.
Decisão no código: - // = divisão inteira (corta decimais)
Evidência: saída final no formato exato (1 linha: "Pontuação Final em Arcana Quest: X pontos.").

Variáveis-chave

exploracao
combate
estrategia
base
bonus
deducao

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

exploracao = int(input())
combate = int(input())
estrategia = int(input())

base = exploracao + combate + estrategia
bonus = 2 * estrategia + (exploracao // 2)
deducao = 3 * (combate % 10)
fator = (exploracao // 5) + 1

pontuacao_final = (base + bonus - deducao) * fator

print(f"Pontuação Final em Arcana Quest: {pontuacao_final} pontos.")

▼

EX.14

Celsius → Fahrenheit e IET; saída “F; IET”

Objetivo: - F = (C * 9/5) + 32

O que a questão pede

calcular duas métricas e concatenar como string com '; ' entre elas.

Conceito cobrado

- F = (C * 9/5) + 32

Estrutura dos dados

Entrada: 1 linha (float): temperatura em Celsius.
Saída: 1 linha: "<Fahrenheit>; <IET>" (ambos convertidos para string).

Como pensar

Calcule Fahrenheit e IET separadamente. Depois converta ambos para string e una com ; , porque aqui o formato final vale tanto quanto as fórmulas.

Como validar

Com entrada 10, a saída deve ficar no formato 50.0; 3.2. Se faltar o ; ou surgir vírgula no lugar do ponto, o formato saiu errado.

Tabela de Evidência

Leitura: 1 linha (float): temperatura em Celsius.
Decisão no código: - F = (C * 9/5) + 32
Evidência: saída final no formato exato (1 linha: "<Fahrenheit>; <IET>" (ambos convertidos para string).).

Variáveis-chave

c
f
iet
saida

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Detalhes de tipo, pontuação e espaços na saída.

c = float(input())

f = (c * 9 / 5) + 32
iet = (c / 4.0) - (c * 0.08) + 1.5

saida = str(f) + "; " + str(iet)
print(saida)

▼

EX.15

Porcentagem de vogais (com comentários)

Objetivo: usar contador + loop (forma mais “intro” e transparente).

O que a questão pede

contar vogais (A/E/I/O/U em qualquer caso) e dividir pelo total de caracteres.

Conceito cobrado

usar contador + loop (forma mais “intro” e transparente).

Estrutura dos dados

Entrada: 1 linha (string): mensagem.
Saída: 1 linha: porcentagem de vogais em relação ao total de caracteres.

Como pensar

Conte vogais em um laço, use len() para obter o total e trate o caso total == 0 antes da divisão. A lógica só fecha quando o denominador está seguro.

Como validar

Entrada vazia deve resultar em 0.0. Com AEIOU, o percentual esperado é 100.0, porque todos os 5 caracteres são vogais.

Tabela de Evidência

Leitura: 1 linha (string): mensagem.
Decisão no código: usar contador + loop (forma mais “intro” e transparente).
Evidência: saída final no formato exato (1 linha: porcentagem de vogais em relação ao total de caracteres.).

Variáveis-chave

mensagem
total
vogais
qtd_vogais
percentual

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Contar só letras e ignorar o “total de caracteres” (o enunciado pede total da string). / Esquecer de tratar string vazia (total = 0).

mensagem = input()

# Total de caracteres (inclui espaços e pontuação)
total = len(mensagem)

# Conjunto de vogais em ambos os casos
vogais = "aeiouAEIOU"

# Conta quantos caracteres da mensagem são vogais
qtd_vogais = 0
for ch in mensagem:
    if ch in vogais:
        qtd_vogais += 1

# Evita divisão por zero se a mensagem vier vazia
if total > 0:
    percentual = (qtd_vogais / total) * 100
else:
    percentual = 0.0

print(percentual)

▼

EX.16

Log estruturado por concatenação precisa (7 entradas)

Objetivo: aqui a habilidade é “montar texto com contrato rígido”. Construa com + e str, sem inventar espaços.

O que a questão pede

montar uma única linha com tokens fixos, espaços e pontuação exatamente como especificado.

Conceito cobrado

aqui a habilidade é “montar texto com contrato rígido”. Construa com + e str, sem inventar espaços.

Estrutura dos dados

Entrada: 7 linhas (strings): id, data, hora, tipo, origem, destino, valor.
Saída: 1 linha: log completo com o formato exigido (termina com ';').

Como pensar

Leia as 7 entradas na ordem do enunciado e monte a linha com os blocos fixos exatamente nas mesmas posições. O trabalho aqui é precisão de espaços, setas, chaves e ponto e vírgula final.

Como validar

Com entradas 123, 2024-03-15, 10:30, PIX, 001, 002 e 150.00, a saída final deve ser [LOG:123] - DATA: 2024-03-15 10:30 | TIPO: PIX {ORIGEM:001 -> DESTINO:002} VALOR: R$150.00;

Tabela de Evidência

Leitura: 7 linhas (strings): id, data, hora, tipo, origem, destino, valor.
Decisão no código: aqui a habilidade é “montar texto com contrato rígido”. Construa com + e str, sem inventar espaços.
Evidência: saída final no formato exato (1 linha: log completo com o formato exigido (termina com ';').).

Variáveis-chave

id_transacao
data
hora
tipo
conta_origem
conta_destino

Como explicar

Descreva em voz alta: entrada -> processamento -> saída. Se você consegue justificar cada etapa sem ler o código, o exercício está dominado.

Erro comum

Errar um espaço (especialmente antes/depois do |). / Esquecer o ';' final.

id_transacao = input()
data = input()
hora = input()
tipo = input()
conta_origem = input()
conta_destino = input()
valor = input()

log = "[LOG:" + id_transacao + "] - DATA: " + data + " " + hora + " | TIPO: " + tipo + " {ORIGEM:" + conta_origem + " -> DESTINO:" + conta_destino + "} VALOR: R$" + valor + ";"
print(log)

▼

CHECK

Checklist técnico de domínio

Objetivo: comprovar entendimento além da execução pontual.

Perguntas para validação final

Você sabe justificar quando usar int(), float() e string pura na entrada?
Você consegue explicar a diferença entre formatar saída e “só imprimir um valor”?
Você valida bordas (string vazia, caixa, separadores e limites numéricos) sem depender de tentativa aleatória?
Você consegue reescrever um exercício usando o mesmo contrato I/O com nomes de variáveis melhores?