Escreva um programa que solicita ao usuário um valor de velocidade ( v_{0} ), um valor de aceleração ( a ) e um valor de tempo (t) e o programa imprime na tela a velocidade final e a distância percorrida por um veículo após o intervalo de tempo t, com velocidade inicial igual a v_{0} e aceleração igual a a. Considere as seguintes fórmulas:
  • Velocidade final: v=v_{0}+a \times t
  • Distância percorrida: s=v_{0} \times t+\frac{a \times t^{2}}{2}
Observação: as mensagens exibidas para o usuário deverão ser exatamente como apresentado abaixo (mensagens exibidas com os comandos input() e print()).

Exemplo de execução do programa:

Digite o valor da velocidade: 100.0
Digite o valor da aceleração: 5.0
Digite o valor do tempo: 60.0
Velocidade final: \mathbf{4 0 0 . 0 0}
Distância percorrida: 15000.00

Passo 1

O enunciado pede que seja escrito um programa que:
  • Solicite ao usuário três valores: o valor da velocidade inicial v_{0}, o valor da aceleração a e o valor do tempo t.
  • Calcule a velocidade final v e a distância percorrida s após o intervalo de tempo t, usando as fórmulas fornecidas.
  • Exiba na tela duas linhas com mensagens exatamente iguais às indicadas:
    • Velocidade final: ...
    • Distância percorrida: ...
      As mensagens exibidas devem ter os textos exatamente como no enunciado (mesma ortografia, acentuação e maiúsculas/minúsculas) e os valores numéricos com duas casas decimais (conforme o exemplo).
Informações fornecidas pelo enunciado:
  • Fórmula da velocidade final: v = v_{0} + a \times t
  • Fórmula da distância percorrida: s = v_{0} \times t + \frac{a \times t^{2}}{2}
  • Exemplo de entrada/saída sugerido no enunciado (usado para testar): v_{0}=100{,}0, a=5{,}0, t=60{,}0 com saída esperada
    • Velocidade final: 400{,}00
    • Distância percorrida: 15000{,}00

Passo 2

Entendendo as fórmulas e as variáveis (aula rápida e prática).
  • v_{0} é a velocidade inicial, em unidades de velocidade (por exemplo, km/h ou m/s).
  • a é a aceleração (unidade de velocidade por tempo).
  • t é o tempo decorrido.
  • A velocidade final v é obtida adicionando à velocidade inicial o incremento devido à aceleração ao longo do tempo: v = v_{0} + a \times t.
    • Aqui \times significa multiplicação.
  • A distância percorrida s sob aceleração constante, partindo de velocidade inicial v_{0}, é a soma da distância devido à velocidade inicial (velocidade constante por tempo) mais a contribuição da aceleração (que cresce como t^{2}): s = v_{0} \times t + \frac{a \times t^{2}}{2}.
    • O termo t^{2} é o quadrado do tempo (multiplica-se t por t).
    • O fator \tfrac{1}{2} aparece pela integração da aceleração em relação ao tempo ao calcular a posição.
Exemplinho numérico rápido com os valores do enunciado para fixar a ideia:
  • Calcular v com v_{0}=100{,}0, a=5{,}0, t=60{,}0: v = 100{,}0 + 5{,}0 \times 60{,}0 = 100{,}0 + 300{,}0 = 400{,}0.
  • Calcular s com mesmos valores: s = 100{,}0 \times 60{,}0 + \frac{5{,}0 \times (60{,}0)^{2}}{2} = 6000{,}0 + \frac{5{,}0 \times 3600{,}0}{2} = 6000{,}0 + \frac{18000{,}0}{2} = 6000{,}0 + 9000{,}0 = 15000{,}0.
Observação: nas saídas pedidas no enunciado os valores são mostrados com duas casas decimais, por isso aparecerão como 400{,}00 e 15000{,}00.

Passo 3

Como implementar isso em Python — leitura dos dados.
  • O comando input() em Python exibe um prompt e retorna uma string com o que o usuário digita. Para fazer cálculos, é preciso converter essa string em número (tipo float).
  • Para respeitar exatamente o texto do enunciado, os prompts de entrada devem ser:
    • "Digite o valor da velocidade: " para v_{0},
    • "Digite o valor da aceleração: " para a,
    • "Digite o valor do tempo: " para t.
  • Conversão para número:
    • Em código: v0 = float(input("Digite o valor da velocidade: ")) e análogos para a e t.
  • Explicação do porquê: input(...) pede o valor, retorna texto; float(...) transforma esse texto em número de ponto flutuante apto para multiplicações, somas e potências.

Passo 4

Implementando os cálculos passo a passo no programa.
  • Depois de ler e converter as três variáveis, calcular:
    • v = v0 + a * t para a velocidade final, que implementa a fórmula v = v_{0} + a \times t.
    • s = v0 * t + (a * t**2) / 2 para a distância, que implementa s = v_{0} \times t + \frac{a \times t^{2}}{2}.
  • Atenção sobre t**2: em Python, o operador ** faz potência, então t**2 é t^{2}.
  • Exemplificando no próprio código com os valores do enunciado (o programa fará isso quando o usuário digitar esses números): os cálculos produzirão v == 400.0 e s == 15000.0.

Passo 5

Formatando a saída para ter exatamente duas casas decimais e texto idêntico ao enunciado.
  • O enunciado mostra os valores com duas casas decimais. Para isso em Python pode-se usar:
    • método str.format: "{:.2f}".format(v) ou
    • f-string: f"{v:.2f}"
      Ambos produzem uma string com o número formatado com duas casas decimais (mesmo que seja 400.0, será mostrado como 400.00).
  • As linhas de saída devem ser exatamente:
    • print("Velocidade final: {:.2f}".format(v))
    • print("Distância percorrida: {:.2f}".format(s))
  • Observação sobre acentuação: a string "Distância percorrida: ..." contém acento e deve ser escrita exatamente assim no código (o arquivo .py deve estar em codificação UTF-8, que é o padrão atual).

Passo 6

Programa completo (Python 3). Este é o código final que atende o enunciado — ele lê os valores, calcula e imprime com o texto e formatação pedida.
v0 = float(input("Digite o valor da velocidade: "))
a = float(input("Digite o valor da aceleração: "))
t = float(input("Digite o valor do tempo: "))

v = v0 + a * t
s = v0 * t + (a * t**2) / 2

print("Velocidade final: {:.2f}".format(v))
print("Distância percorrida: {:.2f}".format(s))

Resposta

v0 = float(input("Digite o valor da velocidade: "))
a = float(input("Digite o valor da aceleração: "))
t = float(input("Digite o valor do tempo: "))
v = v0 + a * t
s = v0 * t + (a * t**2) / 2
print(“Velocidade final: {:.2f}”.format(v))
print(“Distância percorrida: {:.2f}”.format(s))

Exercícios relacionados