Exercícios Resolvidos de Python

Prévia do material em texto

Exerćıcios resolvidos de python
Lucas Ambrus
13 de dezembro de 2021
Figure 1: Slava Stalin
1
Funções e Tipos de dados..............................................................................3
Strings, Estrutura Condicional......................................................................4
Variáveis e atribuição, tuplas.........................................................................7
Manipulação de strings, tuplas e listas.........................................................10
Fatiamento e Manipulação de listas..............................................................15
Estruturas de repetição I - While.................................................................19
Estruturas de repetição II - For....................................................................23
Laços aninhados e matrizes...........................................................................29
2
Machine Teaching 2
1. Pedrinho quer comprar o maior número posśıvel de bombons com o dinheiro que tem.
Faça uma função chamada num bombons para calcular quantos bombons ele consegue
comprar, dados o dinheiro e o preço do bombom para realização da compra.
def num_bombons(d, b):
return d//b
2. Um grupo de amigos deseja fazer uma viagem e decidiram ir de carro. Pelas regras
rodoviárias um véıculo convencional tem a capacidade de transportar até 5 passageiros,
porém há véıculos com outras capacidades. Construa uma função em Python chamada
carros para calcular e retornar o número exato de carros necessários para esta viagem,
consderando que seja dado como entrada o número de pessoas. Caso os véıculos con-
siderados sejam de capacidades não convencionais, será dado também como entrada a
capacidade dos véıculos, considerando que todos os véıculos são iguais.
import math
def carros(p, v=5):
return math.ceil(p / v)
3. Questão OBI (Olimṕıada Brasileira de Informática - OBI2012, Fase 2, Nı́vel Júnior)
- (Receita de Bolo) João deseja fazer bolos para seus amigos, usando uma receita que
indica que devem ser usadas 2 x́ıcaras de farinha de trigo, 3 ovos e 5 colheres de sopa de
leite. Em casa ele tem **A** x́ıcaras de farinha de trigo, **B** ovos e **C** colheres de
sopa de leite. João não tem muita prática com a cozinha, e portanto ele só se arriscará
a¡br¿fazer medidas exatas da receita de bolo (por exemplo, se ele tiver material suficiente
para fazer mais do que 2 e menos do que 3 bolos, ele fará somente 2 bolos). Sabendo disto,
ajude João escrevendo uma função chamada **bolos** que determine qual a quantidade
máxima de bolos que ele consegue fazer.
**Entrada:** Os parâmetros de entrada da função são três números inteiros A, B e C,
indicando respectivamente o número de x́ıcaras de farinha de trigo, o número de ovos e o
número de colheres de sopa de leite que João tem em casa. **Sáıda:** Sua função deve
retornar a quantidade máxima de bolos que João consegue fazer.
import math
def bolos(A,B,C):
"""inserir xı́caras, ovos e colheres"""
return math.floor(min((A/2),(B/3),(C/5)))
3
Machine Teaching 3
1. Faça uma função chamada **PosNegZero** que determina se um número inteiro X
passado como parâmetro é positivo, negativo ou zero. O valor de retorno da função deve
ser uma dentre as strings “X e positivo”, “X e negativo” ou “X e zero”.
def PosNegZero(x):
if x > 0:
return str(x) + ’ e positivo’
if x < 0:
return str(x) + ’ e negativo’
elif x == 0:
return str(x) + ’ e zero’
2. Dois times, Cormengo e Flaminthians, participam de um campeonato de futebol,
juntamente com outros times. Cada vitória conta três pontos, cada empate um ponto.
Fica melhor classificado no campeonato um time que tenha mais pontos. Em caso de
empate no número de pontos, fica melhor classificado o time que tiver maior saldo de gols.
Se o número de pontos e o saldo de gols forem os mesmos para os dois times então os dois
times estão empatados no campeonato. Faça uma função definida por classificacao(Cv,
Ce, Cs, Fv, Fe, Fs). Dados os números de vitórias e empates, e os saldos de gols dos
dois times, sua tarefa é determinar qual dos dois está melhor classificado, ou se eles estão
empatados no campeonato.
Entrada: Os parâmetros de entrada da função são seis números inteiros C, Ce, Cs, F v, F e
e F s, que são, respectivamente, o número de vitórias do Cormengo, o número de empates
do Cormengo, o saldo de gols do Cormengo, o número de vitórias do Flaminthians, o
número de empates do Flaminthians e o saldo de gols do Flaminthians. Sáıda: A sua
função deve retornar a string ’Cormengo’, se Cormengo estiver melhor classificado que
Flaminthians ou a string ’Flaminthians’ se Flaminthians estiver melhor classificado que
Cormengo; e se os dois times estiverem empatados a função deve retornar ’Empate’.
Table 1: Exemplos:
Entrada: 10,5,18,11,2,18 Sáıda: ’Empate’
Entrada: 10,5,18,11,1,18 Sáıda: ’Cormengo’
Entrada: 9,5,-1,10,2,10 Sáıda: ’Flaminthians’
4
def classificacao(cv, ce, cs, fv, fe, fs):
"""informar vitorias, empates e gols de cada time"""
#ptc = pontos totais cormengo
#ptf = pontos totais flaminthians
ptc = 3*cv + ce
ptf = 3*fv + fe
if (ptc == ptf):
if (cs > fs):
return ’Cormengo’
elif (cs < fs):
return ’Flaminthians’
else:
return ’Empate’
elif (ptc > ptf):
return ’Cormengo’
else:
return ’Flaminthians’
5
3. Questão OBI (Olimṕıada Brasileira de Informática - 2009, Fase 1, Nı́vel Júnior) -
(Aviões de Papel) Para descontrair os alunos após as provas da OBI, a Diretora da escola
organizou um campeonato de aviões de papel. Cada aluno participante receberá uma
certa quantidade de folhas de um papel especial para fazer os seus modelos de aviões. A
quantidade de folhas que cada aluno deverá receber ainda não foi determinada: ela será
decidida pelos júızes do campeonato. A diretora convidou, para atuarem como júızes,
engenheiros da Embraer, uma das mais bem sucedidas empresas brasileiras, que vende
aviões com tecnologia brasileira no mundo todo. O campeonato está programado para
começar logo após a prova da OBI, mas os júızes ainda não chegaram à escola. A diretora
está aflita, pois comprou uma boa quantidade de folhas de papel especial, mas não sabe
se a quantidade comprada vai ser suficiente. Considere, por exemplo, que a Diretora
comprou 100 folhas de papel especial, e que há 33 competidores. Se os júızes decidirem
que cada competidor tem direito a três folhas de papel, a quantidade comprada pela di-
retora é suficiente. Mas se os júızes decidirem que cada competidor tem direito a quatro
folhas, a quantidade comprada pela diretora não seria suficiente. Você deve escrever uma
função definida por avioes(competidores, papel comprado, papel competidor) que, dados
o número de competidores, o número de folhas de papel especial compradas pela Diretora
e o número de folhas que cada competidor deve receber, determine se o número de folhas
comprado pela Diretora é suficiente.
Table 2: Exemplos:
Entrada: 10,100,10 Sáıda: ’Suficiente’
Entrada: 10,90,10 Sáıda: ’Insuficiente’
Entrada: 5,40,2 Sáıda: ’Suficiente’
def avioes(c, p_compr, p_compet):
"""int, int, int -> string"""
total = p_compr/c
if total >= p_compet:
return ’Suficiente’
else:
return ’Insuficiente’
6
Machine Teaching 4
1. Considere que a e b são duas strings à escolha do usuário. Faça uma função, chamada
concatenação, que retorne a concatenação delas no formato abba.
def concatenacao(a, b):
return str(a) + str(b) + str(b) + str(a)
2. Escreva uma função definida por **substitui(s, x, i)** que receba uma string *s*,
um caractere *x* e um número inteiro *i* entre 0 e o comprimento da string, e retorne
uma string igual a *s*, exceto que o elemento da posição *i* deve ser substitúıdo pelo
caractere *x*.
def substitui(s,x,i):
’’’Substitui letra na posiç~ao escolhida.
Inserir palavra entre aspas.
str--> str’’’parte1 = s[0:i]
parte2 = s[i+1:len(s)]
return parte1 + x + parte2
3. Escreva uma função chamada **hashtag** que receba uma string e insira o carac-
tere ”#” no ińıcio, no meio e no final dela. Por exemplo, se a entrada for ”abcd”, a
sáıda deve ser ”#ab#cd#”. Outro exemplo: se receber ”abcde”, a função deve retornar
”#ab#cde#”.
def hashtag(s):
’’’Inserir palavra entre aspas.
Inserir palavra entre aspas.
str-> str ’’’
j = s[0:math.floor(len(s)/2)]
k = s[math.floor(len(s)/2):len(s)]
return ’#’ + j + ’#’ + k + ’#’
7
4. Faça uma função chamada **filtra pares** que receba uma tupla com quatro elementos
inteiros como parâmetro, e retorne uma nova tupla contendo apenas os elementos pares
da tupla original, na mesma ordem em que se encontravam. Esse tipo de operação onde se
selecionam elementos de um conjunto inicial que satisfazem uma determinada propriedade
é bastante comum em computação, e se chama **filtragem**.
def filtra_pares(elementos):
’’’Inserir elementos entre colchetes.
Retorna tupla só com elementos pares.
touple--> touple’’’
elementos_pares = ()
if elementos[0] % 2 == 0:
elementos_pares = elementos_pares + (elementos[0],)
if elementos[1] % 2 == 0:
elementos_pares = elementos_pares + (elementos[1],)
if elementos[2] % 2 == 0:
elementos_pares = elementos_pares + (elementos[2],)
if elementos[3] % 2 == 0:
elementos_pares = elementos_pares + (elementos[3],)
return elementos_pares
8
5. Questão OBI (Olimṕıada Brasileira de Informática)
Detecção de colisão é uma das operações mais comuns (e importantes) em jogos eletrônicos.
O objetivo, basicamente, é verificar se dois objetos quaisquer colidiram, ou seja, se a in-
terseção entre eles é diferente de vazio. Isso pode ser usado para saber se duas naves
colidiram, se um monstro bateu numa parede, se um personagem pegou um item, etc.
Para facilitar as coisas, muitas vezes os objetos são aproximados por figuras geométricas
simples (esferas, paraleleṕıpedos, triângulos etc). Neste problema, os objetos são aproxi-
mados por retângulos num plano 2D. Escreva uma função chamada **colisao** que, dados
dois retângulos, determine se eles se interceptam ou não. Cada retângulo é determinado
pelas coordenadas x e y de dois de seus vértices diametralmente opostos, representando
a diagonal que vai da esquerda para a direita e de baixo para cima. Os lados de cada
retângulo são sempre paralelos aos eixos x e y. **Entrada:** Os parâmetros de entrada
são duas tuplas com quatro valores inteiros cada uma, representando as coordenadas do
primeiro retângulo e as coordenadas do segundo retângulo. **Sáıda:** A sua função deve
retornar o valor booleano True caso haja interseção ou False, caso não haja.
Table 3: Exemplos:
Entrada: (0,0,1,1), (0,0,1,1) Sáıda: True
Entrada: (0,0,2,2), (1,1,3,3) Sáıda: True
Entrada: (0,0,1,1), (2,2,3,3) Sáıda: False
def colisao(ret1,ret2):
’’’a funcao colisao recebe duas tuplas com quatro valores inteiros
cada uma, representando as coordenadas dos vertices inferior
esquerdo e superior esquerdo do primeiro retângulo e do segundo
retângulo, nessa ordem, e devolve True se ha colisao entre os
2 retangulos e False, caso contrario.
tuple, tuple --> bool’’’
if ret1[2]<ret2[0]:
return False
elif ret2[2]<ret1[0]:
return False
elif ret1[3]<ret2[1]:
return False
elif ret2[3]<ret1[1]:
return False
else:
return True
9
Machine Teaching 5
1. Faça uma função definida por **quant palavras(frase)** que dada uma frase, retorne
o número de palavras da frase. Considere que a frase pode ter espaços no ińıcio e no final.
Dica: veja a função split( )
def quant_palavras(frase):
"""funç~ao que conta palavras de uma frase.
string -> int"""
contagem = frase.split(" ")
return len(contagem)
2. Dado um texto armazenado em uma string, faça a função **conta frases** que conte
o número de frases que aparecem neste texto. Cada frase no texto é terminada com
um ponto final, um ponto de exclamação, um ponto de interrogação ou três pontos
em sequência (reticências). Pontos de exclamação ou de interrogação não aparecerão
repetidos em sequência no texto e esses śımbolos só aparecem no texto terminando uma
frase. No exemplo a seguir, são contadas 4 frases: “Preciso tirar um cochilo. Meus Deus!
Que horas são? Vou perder a minha aula...”
def conta_frases(texto):
cont1 = texto.split(’.’)
cont2 = texto.split(’!’)
cont3 = texto.split(’?’)
cont4 = texto.count(’...’)
return (len(cont1) - 2*cont4) + len(cont2) + len(cont3) - 3
3. Faça uma função chamada definida por **intercala(lista1, lista2)** que dadas duas
listas L1 e L2 de tamanho 3, gera uma lista L3 que é formada intercalando os elementos
de L1 e L2. Exemplo: L1 = [1, 3, 5] e L2 = [2, 4, 6] gera L3 = [1, 2, 3, 4, 5, 6].
def intercala(lis1, lis2):
"""recebe duas listas e gera uma terceira lista com elementos intercalados.
list --> list"""
lista3 = [lis1[0], lis2[0], lis1[1], lis2[1], lis1[2], lis2[2]]
return lista3
10
4. Faça uma função **retira pontuacao** que, dada uma frase, retorne a frase onde todos
os caracteres de pontuação (incluindo travessão, v́ırgula, dois pontos, ponto e v́ırgula,
além da pontuação de encerramento de frase) tenham sido substitúıdos por espaço.
def retira_pontuacao(frase):
if ":" in frase:
frase = frase.replace(":", " ")
if ";" in frase:
frase = frase.replace(";", " ")
if "." in frase:
frase = frase.replace(".", " ")
if "!" in frase:
frase = frase.replace("!", " ")
if "-" in frase:
frase = frase.replace("-", " ")
if "," in frase:
frase = frase.replace(",", " ")
if "?" in frase:
frase = frase.replace("?", " ")
return frase
11
5. Faça uma função chamada **inverte** que dada uma frase retorne uma outra frase que
contenha as mesmas palavras da frase de entrada na ordem inversa, sem letras maiúsculas,
e sem a pontuação.
Exemplo:
frase lida: “Nossa, como eu gosto de chocolate.”
frase alterada: “chocolate de gosto eu como nossa”
DICA: Remova a pontuação da frase, usando a função que você fez pro exerćıcio
anterior. Para reaproveitar uma função feita no Machine Teaching, copie o código com-
pleto da função e cole na caixa de resposta do exerćıcio onde quer utilizá-la. Faça então
a função pedida no exerćıcio, embaixo da que você colou, e dentro dela você irá chamar
a que está reutilizando.
def inverte(frase):
"""Funç~ao recebe frase e retorna frase invertida
e sem pontuaç~oes. Informar frase entre aspas.
str--> str"""
if ":" in frase:
frase = frase.replace(":", "")
if ";" in frase:
frase = frase.replace(";", "")
if "." in frase:
frase = frase.replace(".", "")
if "!" in frase:
frase = frase.replace("!", "")
if "-" in frase:
frase = frase.replace("-", " ")
if "," in frase:
frase = frase.replace(",", "")
if "?" in frase:
frase = frase.replace("?", "")
fraselist = frase.split(" ")
range_list = len(fraselist)+1
fat_inv = fraselist[-1:-(range_list):-1]
inverso = str.join(’ ’,fat_inv)
return str.lower(inverso)
12
6. Faça uma função **piramide num** que construa uma pirâmide de números inteiros,
dados dois números. Uma pirâmide de números é na verdade uma sequência de números
com as seguintes caracteŕısticas:
I. o primeiro valor passado como parâmetro deverá ser o primeiro e o último elemento da
sequência, marcando o ińıcio e fim da sequência
II. cada valor dentro da sequência não pode ter uma diferença absoluta maior que um de
seu vizinho à direita ou à esquerda.
III. o maior número da sequência estará no meio dela, e corresponde ao segundo número
dado como entrada.
IV. todos os números na pirâmide aparecem duas vezes na sequência com exceção daquele
que está no meio.
Sua função receberá como entrada dois números inteiros, e deve retornar uma lista com
a sequência correspondente à pirâmide.
Table 4: Exemplos:
Entrada: piramide(3,6) Sáıda: [3,4,5,6,5,4,3]
Entrada: piramide(9,6)Sáıda: [9,8,7,6,7,8,9]
Entrada: piramide(6,6) Sáıda: [6]
def piramide_num(num1, num2):
"""Insira dois números inteiros. A funç~ao devolve uma lista pirâmide.
int, int --> list"""
lista1 = [num1]
r1 = range(num1, num2, -1)
r2 = range(num2, num1)
r3 = range(num1, num2)
r4 = range(num2, num1, -1)
if num1 > num2:
return list(r1) + list(r2) + lista1
elif num1 < num2:
return list(r3) + list(r4) + lista1
else:
return lista1
13
7. OBI 2012 (Colchão)*
João está comprando móveis novos para sua casa. Agora é a vez de comprar um colchão
novo, de molas, para substituir o colchão velho. As portas de sua casa têm **altura H**
e **largura L** e existe um colchão que está em promoção com dimensões A x B x C.
O colchão tem a forma de um paraleleṕıpedo reto retângulo e João só consegue arrastá-lo
através de uma porta com uma de suas faces paralelas ao chão, mas consegue virar e
rotacionar o colchão antes de passar pela porta. Entretanto, de nada adianta ele comprar
o colchão se ele não passar através das portas de sua casa.
Portanto ele quer saber se consegue passar o colchão pelas portas e para isso precisa de
sua ajuda. Faça uma função definida por **colchao(medidas,H,L)** para resolver esse
problema, onde medidas é uma lista com os tamanhos inteiros A, B e C, e H e L são os
tamanhos inteiros da altura e largura da porta, respectivamente.
- **Entrada:** Os parâmetros de entrada são uma lista com as dimensões do colchão em
cent́ımetros, ordenadas da menor para a maior, e dois inteiros H e L, correspondentes
respectivamente a altura e a largura das portas em cent́ımetros.
- **Sáıda:** A sua função deve retornar True se o colchão passa pelas portas e False caso
contrário.
def colchao(medidas, H, L):
"""Funç~ao define se colch~ao passa pela porta
de acordo com as medidas do colch~ao.
list, float, float--> bool"""
if medidas[1] <= H:
return True
if medidas[1] <= L:
return True
if medidas[2] <= H:
return True
if medidas[2] <= L:
return True
else:
return False
14
Machine Teaching 6
1. Faça uma função chamada **altera frase** que receba uma frase, uma palavra e uma
posição.
- Caso a palavra já exista na frase, transforme a primeira ocorrência da palavra na frase
para maiúscula.
- Caso a palavra não exista, insira a palavra na frase na posição dada. Assuma que a
primeira palavra está na posição 0. Retorne a nova frase.
Exemplo1: - Frase: Meu nome é ana
- Palavra: ana
- Retorno: Meu nome é ANA
Exemplo 2: - Frase: Meu nome é ana
- Palavra: primeiro
- Posição: 1
- Retorno: Meu primeiro nome é ana
def altera_frase(frase, palavra, index):
"""funç~ao substitui palavra na posiç~ao desejada.
Palavra repetida é coloca em maiúscula, palavra n~ao
repetida é inserida na posiç~ao desejada.
str, str, int--> str"""
lista1 = frase.split()
if palavra in lista1:
lista1[lista1.index(palavra)] = str.upper(palavra)
return str.join(’ ’, lista1)
else:
lista1.insert(index, palavra)
return str.join(’ ’, lista1)
15
2. Faça uma função chamada **faltas** que receba uma lista no seguinte formato:
[[Brasil, Italia, [10, 9]], [Brasil, Espanha, [5, 7]], [Italia, Espanha, [7,8]]] Esta lista in-
dica o número de faltas que cada time fez em cada jogo. Na lista acima, no jogo entre
Brasil e Itália, o Brasil fez 10 faltas e a Itália fez 9. Dada essa lista, a função deve retornar
o total de faltas do campeonato.
def faltas(lista):
"""funç~ao recebe uma lista, soma as faltas que as listas informam
e retorna o total de faltas.
list--> int"""
faltas1 = int(lista[0][2][0]) + int(lista[0][2][1]) + int(lista[1][2][0])
faltas2 = int(lista[1][2][1]) + int(lista[2][2][0]) + int(lista[2][2][1])
total_faltas = faltas1 + faltas2
return faltas
3. Faça uma função definida por **insere(lista numero, n)** que dada uma lista ordenada
(crescente) de números inteiros e um número inteiro n, inclua n na posição correta, ou
seja, de tal maneira que a lista continue ordenada.
def insere(lista_numero, n):
"""funç~ao recebe uma lista de números e um número,
adiciona o número à lista, a ordena e retorna lista.
list, int--> list"""
lista_numero.insert(0, n)
list.sort(lista_numero)
return lista_numero
16
4. Faça uma função chamada **maiores** que dada uma lista de números inteiros e um
número inteiro n, retorna outra lista, que contenha todos os números da lista original
maiores que n, ordenados em ordem crescente
def maiores(lista, n):
"""funç~ao recebe lista e número inteiro e retorna
lista com elementos da entrada a partir do número inteiro
list, int--> list"""
if n in lista:
list.sort(lista)
lista1 = lista[list.index(lista, n) + 1:]
return lista1
else:
lista.insert(-1, n)
list.sort(lista)
lista1 = lista[list.index(lista, n) + 1:]
return lista1
5. Faça uma função chamada **acima da media** que dada uma lista com as notas dos
alunos de uma turma, retorne uma lista ordenada com as notas que ficaram acima da
média. **DICA:** Aproveite a função desenvolvida no exerćıcio **maiores**.
#colar aqui a funç~ao "maiores" do exercı́cio anterior
def acima_da_media(lista):
"""funç~ao recebe lista e retorna lista ordenada
list--> list"""
media = int(sum(lista) / len(lista))
return maiores(lista, media)
17
6. Defina uma função chamada **eh ordenada** que dada uma lista não vazia contendo
uma quantidade qualquer de valores numéricos diga se a lista está ordenada em ordem
crescente, decrescente ou não ordenada. A retorno da função deve ser uma tupla cujo
primeiro elemento é **True**, caso a lista esteja ordenada, e **False**, caso contrário
e cujo segundo elemento seja crescente, decrescente ou desordenada, indicando se a lista
está ordenada em ordem crescente, decrescente ou não está ordenada, respectivamente.
**DICA**: Atenção! Lembre-se que algumas operações sobre listas alteram o valor da
lista original ao invés de retornar uma nova lista com as alterações. Esse é o caso da
função list.sort(lista), por exemplo. Então, se você precisar preservar o valor da lista
original, faça uma cópia antes de alterá-la.
def eh_ordenada(lista):
"""funç~ao recebe lista, retorna tupla
com true e o tipo de ordem ou retorna tupla
com false e desordenada
list--> tuple"""
tupla = ()
lista1 = lista[:]
list.sort(lista)
lista_ordenada = lista[:]
list.reverse(lista)
lista_invertida = lista[:]
if lista_ordenada == lista1:
tupla = tupla + (True,’crescente’)
return tupla
elif lista_invertida == lista1:
tupla = tupla + (True,’decrescente’)
return tupla
else:
tupla = tupla + (False,’desordenada’)
return tupla
18
Machine Teaching 7
1. Faça uma função chamada **filtraMultiplos** para filtrar os múltiplos de um número
n. Sua função deve receber como entrada uma lista de números e um número, e retornar
outra lista contendo todos os elementos da lista original que forem diviśıveis por n.
def filtraMultiplos(lista, n):
"""funç~ao que recebe lista e retorna lista
com números múltiplos do número n
list, int--> list"""
multiplos = []
contador = 0
while contador < len(lista):
if lista[contador] % n == 0:
multiplos.insert(contador, lista[contador])
contador = contador + 1
return multiplos
2. Faça uma função chamada **uppCons** que receba como entrada uma frase e retorne
a frase com todas as suas consoantes em maiúsculas (e os demais caracteres exatamente
como estavam na frase original).
def uppCons(texto):
lista_texto = list(texto)
contador = 0
letras = []
while contador < len(lista_texto):
if lista_texto[contador] in ’çbcdfghjklmnpqrstvwxyz’:
letras.insert(contador, lista_texto[contador].upper())
contador = contador + 1
else:
letras.insert(contador, lista_texto[contador])
contador = contador + 1
return ’’.join(letras)
19
3. Faça uma função chamada **posLetra** que recebe como entrada uma string, uma
letra, e um número que indica a ocorrência desejada da letra (1 para primeiraocorrência,
2 para segunda, etc). Sua função deve retornar em que posição da string aquela ocorrência
da letra está. Caso exista menos ocorrências da letra do que a ocorrência pedida, a função
deve retornar -1.
Exemplo:
>>>posLetra(”mariana come banana”, ’a’, 3)
6
(posição da terceira ocorrência da letra ’a’ na string dada)
def posLetra(frase, letra, numero):
’’’funç~ao que retorna posiç~ao da letra na ocorrência desejada
str, str, int--> int’’’
palavras = list(frase)
contador = 0
ocorrencias = 0
while len(palavras) > contador:
if letra in palavras[contador]:
ocorrencias += 1
if ocorrencias == numero:
return contador
contador += 1
if ocorrencias < numero:
return -1
else:
return ocorrencias
20
4. Faça uma função chamada **repetidos** que receba como entrada uma lista de
números, e retorne o número de vezes que um elemento da lista é igual ao elemento
anterior. Exemplo: repetidos([1,4,3,3,2,3,3,3,3,5,4,6,6,7,6,8,8,7]); Resposta: 6.
def repetidos(lista_num):
’’’funç~ao que conta quantas vezes um elemento apareceu repetido
list--> int’’’
contador = 1
vezes = 0
while len(lista_num) > contador:
if lista_num[contador] == lista_num[contador - 1]:
vezes += 1
contador += 1
else:
contador += 1
return vezes
5. Faça uma função chamada **fatorial** que dado um número, calcule o fatorial deste
número. Não use a função factorial do módulo math.
def fatorial(numero):
"""funç~ao calcula o fatorial de um número inteiro
qualquer
int--> int"""
contador = 1
fatorial = numero
while contador < numero:
fatorial = fatorial * contador
contador = contador + 1
return fatorial
21
6. Joãozinho adora quebra-cabeças, essa é sua brincadeira favorita. O grande problema,
porém, é que às vezes o jogo vem com uma peça faltando. Isso irrita bastante o pobre
menino, que tem de descobrir qual peça está faltando e solicitar uma peça de reposição
ao fabricante do jogo. Sabendo que o quebra-cabeças tem N peças, numeradas de 1 a N e
que exatamente uma está faltando, ajude Joãozinho a saber qual peça ele tem de pedir.
Escreva uma função chamada **faltante** que, dada uma lista com N − 1 inteiros nu-
merados de 1 a N, descubra qual número inteiro deste intervalo está faltando.
*Entrada:** O parâmetro de entrada é uma lista L de tamanho N − 1 contendo números
inteiros (não repetidos) de 1 a N.
*Sáıda:** A sua função deve retornar o número inteiro x que pertence ao intervalo [1, N]
mas que não pertence a lista de entrada L.
Table 5: Exemplos:
Entrada: [3,1] Sáıda: 2
Entrada: [1,2,3,5] Sáıda: 4
Entrada: [2,4,3] Sáıda: 1
def faltante(lista):
"""funç~ao recebe lista e retorna elemento que falta
list--> int"""
list.sort(lista)
lista_ordenada = list(range(1, len(lista)+2))
contador = 0
while len(lista_ordenada) > contador+1:
if lista[contador] != lista_ordenada[contador]:
return lista_ordenada[contador]
contador +=1
return lista_ordenada[-1]
22
Machine Teaching 8
1. Construa uma função chamada **freq palavras(frases)** que receba uma string e
retorne um dicionário onde cada palavra dessa string seja uma chave e tenha como valor
o número de vezes que a palavra aparece.
Por exemplo:
>>> freq_palavras(’dinheiro é dinheiro e vice versa’) #entrada de dados
>>> {’dinheiro’:2, ’é’:1, ’e’:1, ’vice’:1, ’versa’:1} #saı́da de dados
def freq_palavras(frase):
’’’funç~ao recebe frase e retorna dicionário com
quantidade de cada palavra da string
str--> dict’’’
palavras = frase.split()
dict1 = {}
counter = 0
for elementos in palavras:
dict1[palavras[counter]] = palavras.count(palavras[counter])
counter += 1
return dict1
23
2. Escreva uma função chamada **total** que recebe uma lista de compras e um di-
cionário contendo o preço de cada produto dispońıvel em uma determinada loja, e retorna
o valor total dos itens da lista que estejam dispońıveis nesta loja.
Por exemplo, para os dados:
lista de compras = [’biscoito’, ’chocolate’, ’farinha’]
produtos = ’amaciante’:4.99, ’arroz’:10.90, ’biscoito’:1.69, ’cafe’:6.98, ’chocolate’:3.79,
’farinha’:2.99
O valor retornado pela função será 8.47.
*Retorne o resultado com 2 casas decimais, utilizando a função round(número, 2).
def total(lista, produtos):
’’’funç~ao calcula total da lista de compras
de acordo com os preços do dicionário
list, dict--> float’’’
contador = 0
total = 0
for elementos in lista:
if lista[contador] in produtos:
total += produtos[lista[contador]]
contador += 1
return round(total, 2)
24
3. Faça uma função chamada **lingua p** que receba como parâmetro uma palavra (em
português) e retorne esta mesma palavra traduzida para a ĺıngua do P. Uma palavra foi
traduzida para a ĺıngua do P quando, após cada vogal da palavra original, é inserida a
sequência de letras mais a vogal original.
A resposta deve ignorar a diferença entre minúsculas e maiúsculas e retornar a palavra
traduzida toda em minúsculas.
Por exemplo:
>>>lingua_p(’exemplo’) #entrada de dados
>>>epexepemplopo #saı́da de dados
>>>lingua_p(’entao’)
>>>epentapaopo
>>>lingua_p(’Caderno’)
>>>capadepernopo
def lingua_p(palavra):
’’’funç~ao que recebe palavra em português e
retorna palavra traduzida em lı́ngua do p.
str--> str’’’
traduzido_p = []
contador = 0
for letra in list(palavra):
if letra in ’aeiouáéı́óú’:
traduzido_p.append(letra + ’p’ + letra)
else:
traduzido_p.append(letra)
return ’’.join(traduzido_p)
25
4. Faça uma função chamada **qtd divisores** que conte quantos divisores um
número tem. Este número será passado como entrada.
Exemplo: Se o número for 10, os divisores são: 1, 2, 5 e 10; total de 4 divisores.
def qtd_divisores(numero):
’’’funç~ao que verifica quantos divisores um
número qualquer tem.
int--> int’’’
contador = 0
for elemento in range(1, numero):
if numero % elemento == 0:
contador += 1
if numero < 0:
return contador
else:
return contador + 1
26
5. Faça uma função chamada **primo** que dado um número inteiro positivo, verifique
se este número é primo ou não. Retorne um valor booleano.
Dica: uma estratégia simples para identificar a primalidade de um número é verificar se
não existe nenhum número menor que ele próprio (e maior ou igual a 2) que o divida.
Dica 2: O número de divisões indicado na dica anterior é maior que o necessário. Você
consegue reduzi-lo?
def primo(numero):
’’’funç~ao que verifica se um número
qualquer é primo.
int--> bool’’’
contador = 0
for elemento in range(2, numero):
if numero % elemento == 0:
contador += 1
if contador > 0:
return False
else:
return True
27
6. Sendo H = 1+ 1
2
+ 1
3
+ 1
4
+ ...+ 1
N
faça uma função chamada **soma h** para calcular
e retornar o valor H com N termos onde N é inteiro e dado com entrada. Retorne seu
resultado somente com 2 casas decimais, utilizando a função round(número, 2).
def soma_h(N):
’’’funç~ao calcula somatório de fraç~oes com
N termos onde cada fraç~ao tem denominador igual
a sua posiç~ao no somatório.
int--> float’’’
lista_soma = [1]
for numero in range(2, N+1):
lista_soma.append((numero)**-1)
somatorio = sum(lista_soma)
return round(somatorio, 2)
28
Machine Teaching 9
1. Faça uma função booleana chamada **eh quadrada** para identificar se uma matriz é
quadrada. Observação: uma matriz vazia (sem nenhuma linha nem coluna) é considerada
quadrada.
def eh_quadrada(matriz):
’’’verifica se a matriz é quadrada
list--> bool’’’
contador = 0
if len(matriz) == 0:
return True
for item in matriz:
if len(item) == len(matriz):
contador += 1
if contador == len(matriz):
return True
else:
return False
2. Faça uma função definida por **conta numero(numero, matriz)** que dado um número
inteiro e uma matriz de inteiros de tamanho qualquer, conta e retorna quantas vezes aquele
número aparece na matriz.
def conta_numero(numero, matriz):
’’’percorre a matriz inteira e verifica se há numero
int,list--> int ’’’
total = 0
for item in matriz:
for item2 in item:
if item2 == numero:
total += 1
return total
29
3. Faça uma função chamada **media matriz** que dada uma matriz de inteiros não
vazia, retorna a média de todos os números da matriz (com exatamente duas casas deci-
mais de precisão).
def media_matriz(matriz):
’’’calcula média de todos os elementos de uma matriz
e retorna resultado com duas casas de precis~ao
list--> float’’’
soma = 0 #inicia contador em zero
contador = 0 #inicia contador em zero
for item in matriz:
for item2 in item:
soma += item2
contador += 1
media = soma/contador
return round(media, 2)
30
4. Uma pista de Kart permite 10 voltas para cada um dos 6 corredores. Faça uma
função chamada **melhor volta** que receba como entrada uma matriz 6 x 10 com
os tempos em segundos dos corredores em cada volta. A função deve retornar uma
**tupla** informando: De quem foi a melhor volta da prova, com qual tempo e em que
volta. Assuma que os corredores tem tempos diferentes. (dica: use a função ‘min‘).
Obs: use números de 1 a 6 para os corredores e de 1 a 10 para as voltas (não esqueça que
em Python os ı́ndices começam de 0)
def melhor_volta(matriz):
’’’funç~ao que recebe matriz de voltas
com tempos e verifica quem fez a melhor volta, com que
tempo e em que volta, e retorna tupla com dados nessa ordem
list--> tuple’’’
lista_tempos = []
lista_voltas = []
for voltas in range(6):
for tempos in range(10):
if matriz[voltas][tempos] == min(matriz[voltas]):
lista_tempos.append(tempos)
for i in range(6):
lista_voltas.append(matriz[i][lista_tempos[i]])
volta = lista_voltas.index(min(lista_voltas))
tempo = min(lista_voltas)
piloto = matriz[volta].index(tempo) + 1
tupla = (volta + 1, tempo, piloto)
return tupla
31
5. Suponha que os dados de funcionários de uma empresa sejam armazenados em uma
matriz como a do exemplo a seguir:
”AdalbertoFerreira” ”566” ”Contabilidade” ”(21)84564 - 5248”
”JulianaVasconcelos” ”465” ”RH” ”(21)3555 - 4552”
”FlaviaAmorim” ”565” ”Contabilidade” ”(21)2134 - 4845”
Cada linha da matriz tem quatro entradas, representando as informações referentes
a nome, registro, setor e telefone de um funcionário, nesta ordem. O número de linhas
depende da quantidade de funcionários. Todas as entradas da matriz estão em formato
de string. Escreva uma função chamada **busca** que receba uma matriz como a do
exemplo e faça uma busca por setor, ou seja, dado um nome de um setor da empresa, a
função retorna os dados de todos os funcionários daquele setor. Por exemplo:
>>>busca("Contabilidade", matriz) #entrada de dados
>>>[[‘Adalberto Ferreira’, ‘566’, ‘(21)84564-5248’],[‘Flavia Amorim’, ‘465’,
‘(21)2134-4845’]] #saı́da de dados
Se nenhum registro for encontrado, a função deverá retornar uma lista vazia.
def busca(setor, matriz):
’’’funç~ao retorna dados de todos os
funcionários de determinado setor
str--> list’’’
dados = []
for i in range(len(matriz)):
if setor in matriz[i]:
dados.append(matriz[i])
for j in range(len(dados)):
if dados[j][2] == setor:
del dados[j][2]
32