Introdução à Programação B

1º Teste (Duração 1h30)

Dia 11/11/2020

2020/2021

1. [3 valores] Analise o código com cuidado e mostre o que o seguinte programa escreve no ecrã. Os
comentários foram omitidos de propósito.

def check(n):
return n ** 2 <= n * 2

def processa(value):
if value > 10 or value < 4:
value = value - 2
else:
value = value + 1
return value

def main():
v = 6
while v >= 0:
if check(v) == True:
x = processa(v)
print("if:", x)
else:
x = processa(v * 2)
print("else:", x)
v = v - 2

main()

2. [3 valores] Uma nota redonda é um inteiro entre 0 e 100 que termina no dígito 0, ou no dígito 5. Por
exemplo, 0, 5, 10, 45, 90 e 100 são notas redondas. 12, 57, ou 96, não são notas redondas.
Implemente a função nota_redonda(nota), que devolve True se a nota for redonda, ou False
caso contrário. Se a nota não for um valor entre 0 e 100, a função devolve False.

def round_grade(grade):
"""round_grade(grade): int [nota] -> bool
Exemplos: round_grade(10) -> True
round_grade(57) -> False
round_grade(-12) -> False
round_grade(120) -> False
round_grade(90) -> True
"""
Na sua resposta inclua o cabeçalho da função (a negrito), mas não é necessário perder tempo a
escrever os comentários.

1
3. [4 valores] Defina uma função que recebe a população e a taxa de crescimento populacional anual
de dois países – país A e país B – e determina em quantos anos o país A irá exceder a população do
país B. Por exemplo, se o país A tem uma população de 50 milhões e a sua população cresce 3% por
ano, enquanto o país B tem uma população de 70 milhões e a sua população cresce 2% por ano, a
população do país A irá exceder a população do país B em 35 anos. Pode assumir que tA > tB, ou
seja, a taxa de crescimento do país A é superior à taxa de crescimento do país B. Caso a população
do país A seja superior à população do país B a função deve devolver zero.

def overtake_population(pA, tA, pB, tB):

"""overtake_population: float x float x float x float -> int
Exemplos: overtake_population(50.0, 0.03, 70.0, 0.02) -> 35
overtake_population(51.5, 0.05, 55.0, 0.02) -> 3
overtake_population(50.0, 0.03, 40.4, 0.02) -> 0
"""
Na sua resposta inclua o cabeçalho da função (a negrito), mas não é necessário perder tempo a
escrever os comentários.

4. [4 valores] Escreva uma função que lê do teclado n inteiros e determina o comprimento da maior
sequência de números ímpares contiguamente dispostos. Considere que um número ímpar isolado
é considerado como uma sequência de comprimento unitário. De seguida mostramos exemplos de
execução (a negrito aparecem os inputs do utilizador):

In [1]: value = max_odd_sequence(6) In [1]: value = max_odd_sequence(4)

1 2
3 4
12 0
7 22
11 Out[2]: value
3 0
Out[2]: value
3

In [1]: value = max_odd_sequence(6) In [1]: value = max_odd_sequence(4)

1 1
3 2
12 3
2 6
-7 Out[2]: value
-11 1
Out[2]: value
2

def max_odd_sequence(n):
"""max_odd_sequence: int [número de inteiros a ler] -> int
"""
Na sua resposta inclua o cabeçalho da função (a negrito), mas não é necessário perder tempo a
escrever os comentários.
2
5. [6 valores] Escreva um programa completo que calcule o custo de estacionamento de um cliente.
Consoante o tempo de permanência no parque, assim é a tarifa aplicada, sendo as possíveis tarifas
as seguintes:
• Tarifa A – três primeiras horas: 1.50€/hora
• Tarifa B – da 4ª hora à 7ª hora: 2.00€/hora
• Tarifa C – horas restantes: 2.50€/hora.
O máximo a pagar por dia é de 25.00€. Considera-se também que o tempo de permanência não
excede as 24h. Para simplificar considera-se que o tempo de estacionamento é um inteiro que
representa a duração em minutos. Os valores em euros são números reais. Os valores reais
apresentados devem ser arredondados a uma casa decimal.
De seguida mostramos três exemplos de execução (a negrito aparecem os inputs do utilizador, a
itálico as partes escritas pelo programa).

Duração estacionamento: 65 Duração estacionamento: 230 Duração estacionamento: 535

Horas = 2 Horas = 4 Horas = 9
A pagar = 3.0 euros A pagar = 6.5 euros A pagar = 17.5 euros

Apresentamos também uma breve explicação do valor obtido para cada um dos exemplos:

Explicação Exemplo 1: Explicação Exemplo 2: Explicação Exemplo 3:

Duração = 65
Horas de estacionamento = 2
Custo = 1.5 * 2 (tarifa A)
Duração = 230
Horas de estacionamento = 4
Custo = 1.5 * 3 (tarifa A)
2.0 * 1 (tarifa B)
Duração = 535
Horas de estacionamento = 9
Custo = 1.5 * 3 (tarifa A)
2.0 * 4 (tarifa B)
2.5 * 2 (tarifa C)

Tenha em atenção que o seu programa deve ser estruturado utilizando funções. Sugerimos
estruturar o seu programa usando as funções determine_hours e determine_cost. Caso decida
definir mais funções apresente-as na alínea a).

a) [1 valores] Defina as constantes que achar necessárias e a função main responsável pela
interação com o utilizador.
def main():
"""main: . -> .
Descrição: Interacção com o utilizador
"""
b) [1 valor]
def determine_hours(duration):
"""determine_hours: int [minutos] -> int [horas]
Descrição: Calcula o número de horas a pagar pelo estacionamento.
Exemplos: determine_hours(45) -> 1; determine_hours(245) -> 5
determine_hours(120) -> 2; determine_hours(121) -> 3
"""
c) [4 valores]
def determine_cost(hours):
"""determine_cost: int [horas] -> float [preço]
Descrição: Calcula o preço do estacionamento dado o número de horas.
"""
3