Lab05 - Loops for e while, listas e tuplas

Lista de Exercícios: Loops (for e while) e Estruturas de Dados (lista e tupla)¶

Neste notebook, você encontrará exercícios para praticar conceitos relacionados a loops (for e while) e estruturas de dados (lista e tupla).

Dicas Importantes¶

• Não altere os nomes dos arquivos ou funções: Isso pode fazer com que os testes automáticos falhem, mesmo que sua solução esteja correta.
• Leia os erros com atenção: Eles podem fornecer dicas sobre o que está errado em seu código.
• Peça ajuda: Se estiver tendo dificuldades, não hesite em pedir ajuda ao professor ou colegas.

1. Escreva a função primeiros_n_impares que recebe como argumento n e retorna uma lista com os números ímpares usando um loop for.

Exemplo: a função recebe 10 e retorna [1, 3, 5, 7, 9]

In [2]:

## exemplo de resolução 1
def primeiros_n_impares(n):
    return [i for i in range(1, n, 2)]

print(primeiros_n_impares(10))

## exemplo de resolução 1 def primeiros_n_impares(n): return [i for i in range(1, n, 2)] print(primeiros_n_impares(10))

[1, 3, 5, 7, 9]

In [10]:

## exemplo de resolução 2
def primeiros_n_impares(n):
    lista = []
    for i in range(1, n, 2):
        lista.append(i)
    return lista 

print(primeiros_n_impares(10))

## exemplo de resolução 2 def primeiros_n_impares(n): lista = [] for i in range(1, n, 2): lista.append(i) return lista print(primeiros_n_impares(10))

[1, 3, 5, 7, 9]

2. Escreva um programa que encontre o fatorial de um número ( n ) usando um loop while.

Escreva a função fatorial que recebe um parametro n e retorna o valor do fatorial.

In [11]:

'''
Este é um clássico. para praticar lógica.
'''

def fatorial(n):
    resultado = 1
    while n > 1:
        resultado *= n  # é o mesmo que resultado = resultado * n
        n -= 1          # é o mesmo que n = n - 1
    return resultado

print(fatorial(4))

''' Este é um clássico. para praticar lógica. ''' def fatorial(n): resultado = 1 while n > 1: resultado *= n # é o mesmo que resultado = resultado * n n -= 1 # é o mesmo que n = n - 1 return resultado print(fatorial(4))

24

3. FizzBuzz é uma brincadeira matemática e de programação muito comum em entrevistas de emprego para programadores.

A ideia básica do jogo é contar de 1 a 100, e quando um número é múltiplo de 3, em vez de dizer o número, deve-se dizer Fizz. Se um número é múltiplo de 5, deve-se dizer Buzz. Se o número é múltiplo tanto de 3 como de 5, deve-se dizer FizzBuzz.

Por exemplo, os primeiros números da sequência seriam:

1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16, ... 

Você deve escrever a função fizz_buzz que não recebe parametro e que retorna uma lista com o resultado do jogo. Use um laço for.

In [12]:

'''
Este é um clássico. para praticar lógica.
'''

def fizz_buzz():
    resultado = []
    for i in range(1, 101):     # lembrar de fazer até 101
        if i % 3 == 0 and i % 5 == 0:
            resultado.append("FizzBuzz")
        elif i % 3 == 0:
            resultado.append("Fizz")
        elif i % 5 == 0:
            resultado.append("Buzz")
        else:
            resultado.append(i)
    return resultado

print(fizz_buzz())

''' Este é um clássico. para praticar lógica. ''' def fizz_buzz(): resultado = [] for i in range(1, 101): # lembrar de fazer até 101 if i % 3 == 0 and i % 5 == 0: resultado.append("FizzBuzz") elif i % 3 == 0: resultado.append("Fizz") elif i % 5 == 0: resultado.append("Buzz") else: resultado.append(i) return resultado print(fizz_buzz())

[1, 2, 'Fizz', 4, 'Buzz', 'Fizz', 7, 8, 'Fizz', 'Buzz', 11, 'Fizz', 13, 14, 'FizzBuzz', 16, 17, 'Fizz', 19, 'Buzz', 'Fizz', 22, 23, 'Fizz', 'Buzz', 26, 'Fizz', 28, 29, 'FizzBuzz', 31, 32, 'Fizz', 34, 'Buzz', 'Fizz', 37, 38, 'Fizz', 'Buzz', 41, 'Fizz', 43, 44, 'FizzBuzz', 46, 47, 'Fizz', 49, 'Buzz', 'Fizz', 52, 53, 'Fizz', 'Buzz', 56, 'Fizz', 58, 59, 'FizzBuzz', 61, 62, 'Fizz', 64, 'Buzz', 'Fizz', 67, 68, 'Fizz', 'Buzz', 71, 'Fizz', 73, 74, 'FizzBuzz', 76, 77, 'Fizz', 79, 'Buzz', 'Fizz', 82, 83, 'Fizz', 'Buzz', 86, 'Fizz', 88, 89, 'FizzBuzz', 91, 92, 'Fizz', 94, 'Buzz', 'Fizz', 97, 98, 'Fizz', 'Buzz']

4. Crie uma lista contendo os primeiros ( n ) números pares e imprima-a.

A função deve ter o nome dobra_n_eventos recebe um numero n e retorna com o dobro dos numeros pares.

Exemplo:

• se n for 10, retorna uma lista com 2, 4, 6, 8, 10, 12, 14, 16, 18, 20.
• se n for 5, retorna uma lista com 2, 4, 6, 8, 10.

In [24]:

"""
Se é pra retornar com o dobro dos pares temos que fazer 2*n mas para pegar esse valor na lista tem que somar 1.

então fica o range de 2 até 2n+1 com passo de 2

"""

## exemplo de resolução 1
def dobra_n_eventos(n):
    return [i for i in range(2, 2*n+1, 2)]

print(dobra_n_eventos(5))

""" Se é pra retornar com o dobro dos pares temos que fazer 2*n mas para pegar esse valor na lista tem que somar 1. então fica o range de 2 até 2n+1 com passo de 2 """ ## exemplo de resolução 1 def dobra_n_eventos(n): return [i for i in range(2, 2*n+1, 2)] print(dobra_n_eventos(5))

[2, 4, 6, 8, 10]

In [23]:

## exemplo de resolução 2
def dobra_n_eventos(n):
    lista = []
    for i in range(2, 2*n+1, 2): 
        lista.append(i)

    return lista

print(dobra_n_eventos(5))

## exemplo de resolução 2 def dobra_n_eventos(n): lista = [] for i in range(2, 2*n+1, 2): lista.append(i) return lista print(dobra_n_eventos(5))

[2, 4, 6, 8, 10]

5. Dada uma tupla t contendo números, escreva a função soma_e_media para calcular a soma e a média desses números.

A função soma_e_media recebe como argumento uma tupla de numeros e retorna uma tupla com os argumentos (soma, media).

Exemplo:

• se t for (10,2,3,4), retorna a tupla (19,4.75)
• se t for (1,1,1,2,2,2), retorna a tupla (9,1.5)

In [14]:

## exemplo de resolução 1
def soma_e_media(t):
    soma = sum(t)
    media = soma / len(t)
    return soma, media   # o return de uma função com mais multiplos argumentos separados por vigula será uma tupla.

print(soma_e_media((1,1,1,2,2,2)))

## exemplo de resolução 1 def soma_e_media(t): soma = sum(t) media = soma / len(t) return soma, media # o return de uma função com mais multiplos argumentos separados por vigula será uma tupla. print(soma_e_media((1,1,1,2,2,2)))

In [16]:

## exemplo de resolução 2
def soma_e_media(t):
    soma = 0
    for i in t:
        soma += i
    media = soma / len(t)
    return (soma, media)

print(soma_e_media((1,1,1,2,2,2)))

## exemplo de resolução 2 def soma_e_media(t): soma = 0 for i in t: soma += i media = soma / len(t) return (soma, media) print(soma_e_media((1,1,1,2,2,2)))

(9, 1.5)

6. Escreva um programa que remova todos os números ímpares de uma lista dada.

A função remove_impaar recebe uma lista e devolve uma lista.

In [22]:

## exemplo de resolução 1
def remove_impar(lst):
    return [i for i in lst if i % 2 == 0]

print(remove_impar((1,1,1,11,2,2,2,2,3,3,3)))

## exemplo de resolução 1 def remove_impar(lst): return [i for i in lst if i % 2 == 0] print(remove_impar((1,1,1,11,2,2,2,2,3,3,3)))

[2, 2, 2, 2]

In [21]:

## exemplo de resolução 2
def remove_impar(lst):
    par = []
    for i in lst:
        if i%2 == 0:
            par.append(i)
    return par

print(remove_impar((1,1,4,11,2,20,2,2,3,3,3)))

## exemplo de resolução 2 def remove_impar(lst): par = [] for i in lst: if i%2 == 0: par.append(i) return par print(remove_impar((1,1,4,11,2,20,2,2,3,3,3)))

[4, 2, 20, 2, 2]

7. A função fibonacci recebe um numero inteiro e retorna uma lista com os números da sequência Fibonacci até n. Use um loop for.

A sequencia de fibonacci é uma sequencia numérica onde o proximo numero é a soma do atual com o anterior. como no exemplo:

0, 1, 1, 2, 3, 5, 8... o próximo numero será 8+5=13

In [27]:

'''
Este é um clássico. para praticar lógica.
indice =  0 1 2 3 4 5 6
 lista = [2,4,3,5,6,9,8]

i = 5
lista[i]   representa o indice i=5; valor = 9 
lista[i-1] representa o indice anterior, i=4; valor = 6
lista[i-2] representa o indice i=3; valor = 5

isso é importante pois na sequência de fibonacci fazemos indice atual como soma dos anteriores.
'''

def fibonacci(n):
    fib = [0, 1]
    for i in range(2, n):
        fib.append(fib[i-1] + fib[i-2])
    return fib[:n]

print(fibonacci(10))

''' Este é um clássico. para praticar lógica. indice = 0 1 2 3 4 5 6 lista = [2,4,3,5,6,9,8] i = 5 lista[i] representa o indice i=5; valor = 9 lista[i-1] representa o indice anterior, i=4; valor = 6 lista[i-2] representa o indice i=3; valor = 5 isso é importante pois na sequência de fibonacci fazemos indice atual como soma dos anteriores. ''' def fibonacci(n): fib = [0, 1] for i in range(2, n): fib.append(fib[i-1] + fib[i-2]) return fib[:n] print(fibonacci(10))

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

8. Escreva uma função max_e_index que, recebe uma lista de números, encontra o maior número usando um loop while e o armazena em uma tupla junto com seu índice na lista original para retorno da função.

Exemplo:

• se a lista recebida pela função for [3,4,5,2,7,9,4,1,1,1,4,0,], a função retorna a tupla (9,5)

In [29]:

'''
desafio clássico de lógica.

a idéia é varrer o vetor procurando o maior valor e o indice e salvar nas variaveis max_val e max_index

'''
def max_e_index(lst):
    max_val = lst[0]    # assume o maior valor é o primeiro da lista
    max_index = 0       # entao o indice correspondente é 0
    i = 1
    while i < len(lst):     # faz a varredura da lista
        if lst[i] > max_val:    # se o valor atual da lista é maior 
            max_val = lst[i]    # então troca o valor
            max_index = i       # e atualizar o indice
        i += 1
    return max_val, max_index

print(max_e_index([3,4,5,2,7,9,4,1,1,1,4,0,]))

''' desafio clássico de lógica. a idéia é varrer o vetor procurando o maior valor e o indice e salvar nas variaveis max_val e max_index ''' def max_e_index(lst): max_val = lst[0] # assume o maior valor é o primeiro da lista max_index = 0 # entao o indice correspondente é 0 i = 1 while i < len(lst): # faz a varredura da lista if lst[i] > max_val: # se o valor atual da lista é maior max_val = lst[i] # então troca o valor max_index = i # e atualizar o indice i += 1 return max_val, max_index print(max_e_index([3,4,5,2,7,9,4,1,1,1,4,0,]))

(9, 5)

In [30]:

# usando laço for

def max_e_index(lst):
    max_val = lst[0]
    max_index = 0
    for i in lst:
        if lst[i] > max_val:
            max_val = lst[i]
            max_index = i
    return max_val, max_index

print(max_e_index([3,4,5,2,7,9,4,1,1,1,4,0,]))

# usando laço for def max_e_index(lst): max_val = lst[0] max_index = 0 for i in lst: if lst[i] > max_val: max_val = lst[i] max_index = i return max_val, max_index print(max_e_index([3,4,5,2,7,9,4,1,1,1,4,0,]))

(9, 5)

9. Utilizando um loop for para percorrer uma lista de palavras e armazenar em uma nova lista todas as palavras que possuem mais de 5 letras. No final, converta essa lista em uma tupla como retorno da função. a função deve se chamar palavras_grandes

Por exemplo:

se a lista de entrada for ["olha","o","pensamento","computacional","python","oi"] então a saida deve ser ('pensamento', 'computacional', 'python')

In [32]:

## exemplo de resolução 1

def palavras_grandes(lst):
    resultado = []      # cria uma lista para adicionar as palavras grandes
    for palavra in lst:
        if len(palavra) > 5:
            resultado.append(palavra)

    return tuple(resultado) # converte a lista em tuple

print(palavras_grandes(["olha","o","pensamento","computacional","python","oi",]))

## exemplo de resolução 1 def palavras_grandes(lst): resultado = [] # cria uma lista para adicionar as palavras grandes for palavra in lst: if len(palavra) > 5: resultado.append(palavra) return tuple(resultado) # converte a lista em tuple print(palavras_grandes(["olha","o","pensamento","computacional","python","oi",]))

('pensamento', 'computacional', 'python')

In [33]:

## exemplo de resolução 2

def palavras_grandes(lst):
    resultado = [palavra for palavra in lst if len(palavra) > 5]
    return tuple(resultado)

print(palavras_grandes(["olha","o","pensamento","computacional","python","oi",]))

## exemplo de resolução 2 def palavras_grandes(lst): resultado = [palavra for palavra in lst if len(palavra) > 5] return tuple(resultado) print(palavras_grandes(["olha","o","pensamento","computacional","python","oi",]))

('pensamento', 'computacional', 'python')

10. Foram anotadas as idades e alturas de alunos em lista de tuplas com a segunte estrutura [(idade1,altura1),(idade2,altura2),...]. Faça a função estudantes que recebe a lista de estudantes e determina quantos alunos com mais de 13 anos possuem altura inferior à média de altura desses alunos.

Por exemplo:

Se receber [(14, 160), (15, 165), (16, 170)] então retorna 1.

In [40]:

def estudantes(students):
    # Passo 1: Calcular a altura média
    soma_altura = 0
    for idade, altura in students:  # desta forma descompacta a tupla
        soma_altura += altura   # soma todas as alturas
        
    media_altura = soma_altura / len(students)
    
    # Passo 2: Contar estudantes com mais de 13 anos e altura abaixo da média
    count = 0
    for idade, altura in students:
        if idade > 13 and altura < media_altura:
            count += 1
            
    return count


print(estudantes([(14, 160), (15, 165), (16, 170),(15, 190)]))

def estudantes(students): # Passo 1: Calcular a altura média soma_altura = 0 for idade, altura in students: # desta forma descompacta a tupla soma_altura += altura # soma todas as alturas media_altura = soma_altura / len(students) # Passo 2: Contar estudantes com mais de 13 anos e altura abaixo da média count = 0 for idade, altura in students: if idade > 13 and altura < media_altura: count += 1 return count print(estudantes([(14, 160), (15, 165), (16, 170),(15, 190)]))

3

In [39]:

def estudantes(students):
    media_altura = sum([altura for _, altura in students]) / len(students)
    count = sum(1 for idade, altura in students if idade > 13 and altura < media_altura)
    return count

print(estudantes([(14, 160), (15, 165), (16, 170)]))

def estudantes(students): media_altura = sum([altura for _, altura in students]) / len(students) count = sum(1 for idade, altura in students if idade > 13 and altura < media_altura) return count print(estudantes([(14, 160), (15, 165), (16, 170)]))

1

12. Problema de Estatísticas de Consumo de Carro

Escreva uma função chamada estatisticas_carros que será responsável por fornecer informações sobre o consumo de combustível de diferentes modelos de carros.

Entradas:

A função deve receber duas listas de mesmo tamanho:

modelos: Uma lista de strings, onde cada string representa o nome de um modelo de carro. consumo: Uma lista de números (floats ou inteiros) que representam o consumo em km por litro de cada carro. O i-ésimo elemento desta lista corresponde ao i-ésimo elemento da lista modelos.

Saídas:

A função deve retornar uma string representando o modelo do carro mais econômico.

Exemplo:

Suponha que temos os seguintes modelos e consumos:

modelos = ["Fusca", "Gol"]
consumos = [8, 10]

a função retorna Gol

In [34]:

def estatisticas_carros(modelos, consumos):
    index_economico = consumos.index(max(consumos))
    modelo_economico = modelos[index_economico]

    return modelo_economico

print(estatisticas_carros(['Fusca','Gol'],[8,10]))

def estatisticas_carros(modelos, consumos): index_economico = consumos.index(max(consumos)) modelo_economico = modelos[index_economico] return modelo_economico print(estatisticas_carros(['Fusca','Gol'],[8,10]))

Gol

13. Resolva usando for: Faça uma função fracao que calcule e retorne o valor de

$$ S= \frac{1}{1}+\frac{3}{2}+\frac{5}{3}+\frac{7}{4}+\frac{9}{5}+...+\frac{99}{50} $$

In [41]:

def fracao():
    s = 0
    for i in range(1, 51):  # denominador varia de 1 a 50
        numerador = 2 * i - 1  # para obter a sequência de números ímpares
        s += numerador / i
    return s

resultado = fracao()
resultado

def fracao(): s = 0 for i in range(1, 51): # denominador varia de 1 a 50 numerador = 2 * i - 1 # para obter a sequência de números ímpares s += numerador / i return s resultado = fracao() resultado

Out[41]:

95.5007946616706

14. Resolva usando for: Faça uma função fracao2 que calcule e retorne o valor de

$$ S= \frac{1}{1}+\frac{2}{4}+\frac{3}{9}+\frac{4}{16}+...+\frac{10}{100} $$

In [43]:

def fracao2():
    s = 0
    for i in range(1, 11):  
        denominador = i**2  
        s += i / denominador
    return s

resultado = fracao2()
resultado

def fracao2(): s = 0 for i in range(1, 11): denominador = i**2 s += i / denominador return s resultado = fracao2() resultado

Out[43]:

2.9289682539682538

15. Faça uma função fracao3 que calcule a seguinte soma:

$$ S= \frac{10}{1!}-\frac{9}{2!}+\frac{8}{3!}-\frac{7}{4!}+...-\frac{1}{10!} $$

In [46]:

def fracao3():
    s = 0
    sinal = 1  # inicia com sinal positivo
    for i in range(1, 11):  # de 1 a 10
        numerador =  sinal * (11 - i) 
        denominador = fatorial(i)
        s += numerador / denominador
        sinal *= -1  # alterna o sinal
    return s

## o fatoria já está feito no começo da lista vamos usar...
def fatorial(n):
    resultado = 1
    while n > 1:
        resultado *= n  
        n -= 1          
    return resultado


resultado = fracao3()
resultado

def fracao3(): s = 0 sinal = 1 # inicia com sinal positivo for i in range(1, 11): # de 1 a 10 numerador = sinal * (11 - i) denominador = fatorial(i) s += numerador / denominador sinal *= -1 # alterna o sinal return s ## o fatoria já está feito no começo da lista vamos usar... def fatorial(n): resultado = 1 while n > 1: resultado *= n n -= 1 return resultado resultado = fracao3() resultado

Out[46]:

6.58544670414462