Introdução à Programação B

1º Teste (Duração 1h40)

Dia 02/11/2019
2019/2020

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 processa(vector):
i = 2
while i < len(vector):
vector[i] = vector[i - 1] + vector[i - 2]
i = i + 1
return

def escreve(vector):
for elem in vector:
print(elem)
return

def main():
v = [2] * 7
processa(v)
escreve(v)
return

main()

2. [4 valores] Escreva uma função que determina se um valor n pertence a um dado intervalo.
Considere que o intervalo é aberto. Note que a função deve devolver o resultado correcto mesmo
que os parâmetros start > end.

def is_in_interval(n, start, end):

"""is_in_interval: int [numero n] x int x int -> bool
Exemplos: is_in_interval(1, -2, 0) -> False
is_in_interval(1, -2, 1) -> False
is_in_interval(1, 0, 6) -> True
is_in_interval(1, 6, 0) -> 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. [3 valores] A abundância de um número inteiro positivo n, é dada pela fórmula α(n)= σ(n) – 2n
em que σ(n) é a soma de todos os divisores do número n (recorde que todos os números têm
como divisores eles próprios e 1). Um número abundante é um número cuja abundância é
superior a zero.
Como exemplo considere o número 24. Os seus divisores são 1, 2, 3, 4, 6, 8, 12 e 24, cuja soma é
60. Como 60 é superior a 2 × 24, então 24 é um número abundante. Agora considere o número
10. Os seus divisores são 1, 2, 5, 10, cuja soma é 18. Como 18 é inferior a 2 x 10, então 10 não é
um número abundante.

def is_abundant(n):
"""is_abundant: int [positivo] -> bool
Exemplos: is_abundant(24) -> True; is_abundant(15) -> False;
is_abundant(10) -> False; is_abundant(12) -> 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.

4. [3 valores] Escreva uma função que desenhe um rectângulo de símbolos # de dimensão n por m
(largura por altura). Por exemplo, para n = 6 e m = 4 será apresentado o seguinte rectângulo:
######
######
######
######

def draw_rectangle(n, m):

"""draw_rectangle: int [largura] x int [altura] -> .
"""
Na sua resposta inclua o cabeçalho da função (a negrito), mas não é necessário perder tempo a
escrever os comentários.

5. [3 valores] Alguns números inteiros contêm sequências de dígitos repetidos, por exemplo, o
número 225577750 contém 5 blocos de dígitos (1º bloco – 22, 2º bloco – 55, 3º bloco – 777, 4º
bloco – 5, 5º bloco – 0). O bloco mais longo é o terceiro, de tamanho 3.
Escreva uma função que devolve o tamanho do maior bloco de dígitos repetidos de um número
positivo. Pode assumir que existe uma função int_to_list que converte um número inteiro
positivo numa lista de inteiros, ilustrada na seguinte interação:
In [1]: digits = int_to_list(225577750)
In [2]: digits
Out [2]: [2, 2, 5, 5, 7, 7, 7, 5, 0]

def max_block_size(number):
"""max_block_size: int -> int
Exemplos: max_block_size(225577750) -> 3; max_block_size(1223334444) -> 4
max_block_size(12345678) -> 1; max_block_size(11223344) -> 2
"""
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
6. [4 valores] Uma empresa de transportes precisa que implemente um programa que calcule o custo
de envio de encomendas dos seus clientes. O custo de uma encomenda com peso inferior ou igual a
200 gramas é de 5 euros. Encomendas com peso superior a 200 gramas têm um custo fixo de 5
euros ao qual é adicionado 0.01 euros (1 cêntimo) por cada grama extra. Por exemplo, uma
encomenda com peso de 345 gramas tem um custo de 6.45 euros (5 + 145*0.01).
Os clientes podem ter descontos de acordo o número de encomendas enviadas (ver Tabela 1). O
programa deve começar por ler o número de encomendas, seguido de uma sequência valores de
inteiros com os pesos das encomendas. O programa deve apresentar o custo total e o desconto
atribuído, caso tenha havido desconto. Os resultados devem ser arredondados às centésimas.

Nº de encomendas Desconto
1 0%
2a5 10 %
6 ou mais 15 %
Tabela 1: Desconto por número de encomendas.

De seguida mostramos três exemplos de execução (a negrito aparecem os inputs do utilizador, a

itálico as partes escritas pelo programa). Note que o custo final já inclui o desconto.

No de encomendas: 1 No de encomendas: 4 No de encomendas: 6

Peso: 615 Peso: 1200 Peso: 120
Peso: 319 Peso: 515
Custo final = 9.15 Peso: 705 Peso: 150
Peso: 200 Peso: 201
Peso: 310
Custo final = 32.62 Peso: 190
Desconto = 3.62
Custo final = 29.12
Desconto = 5.14

Tenha em atenção que o seu programa deve ser estruturado utilizando funções. Uma das funções
que aconselhamos a definir é a função custo_encomenda, que calcula o custo de uma encomenda
individual.

def custo_encomenda(peso):
"""custo_encomenda: int [peso] -> float [preco]
Descricao: Determina o custo da encomenda com base no seu peso.
"""

def custo_total(lista_pesos):
"""custo_total: int lista[lista pesos] -> float [preco]
Descricao: Determina o custo total de todas as encomendas.
"""

def desconto_encomenda(num):
"""desconto_encomenda: int [numero de encomendas] -> float [desconto]
Descricao: Calcula o desconto com base no numero de encomendas.
"""
3