<jupyter_start><jupyter_text>Jupyter Notebook  1) O que é o Jupyter Notebook?O Jupyter Notebook é um documento que permite você executar códigos em Python e escrever textos como um word, tudo em um mesmo lugar.Vídeo do FEA.Dev de como utilizar o Jupyter Notebook 2) Como eu faço para rodar o código?Para rodar uma célula basta clicar na célula e pressionar **Shift + Enter**. Você também pode rodar uma célula ou mais de uma pelo menu de opções na aba "Cell". A células são os retângulos, que podem conter um código em Python ou um texto escrito.Caso você clique nos textos e a formatação dele fique estranha basta rodar essa célula para corrigir. 3) Porquê eu posso obter diferentes resultados toda vez que eu rodo a mesma célula?Quando você roda uma célula isso atualiza alguma variável (ex, x = x+1), assim você terá resultados diferentes para x enquanto você rodar várias vezes essa célula. 4) Estou travado em algum exercício, o que eu faço?Nós recomendamos que você busque alguém do FEA.dev ou busque informações no Google ou no Stack Overflow.  5) Como eu salvo o meu progresso?Clique em "File" na barra de opções e por fim clique na opção "Save and Checkpoint" 6) O que devo fazer se o meu Jupyter travar?Caso isso aconteça você pode tentar reiniciar o Kernel clicando em "Kernel" na barra de opções, e por fim selecionando a opção "Restart"Caso queira as informações em vídeo recomendamos o seguinte vídeo: https://www.youtube.com/watch?v=m0FbNlhNyQ8 7) Ainda estou com dúvidas sobre o Jupyter.Caso isso ocorra pode nos chamar ou se preferir pode assistir o seguinte vídeo: https://www.youtube.com/watch?v=HbsnAGFS1qk  Python Case Iniciante Bem vindo(a) ao Case de Iniciante do processo seletivo do FEA.dev. **_O objetivo desse case é que você estude e aprenda o básico de Python_** ao mesmo tempo que resolve a série de exercícios que se encontram nesse arquivo. Para isso **_você está livre para pesquisar sobre Python em qualquer fonte_**: Google, Youtube, FEA.dev, Stack Overflow, etc.O nosso principal objetivo com o case é **_avaliar o progresso do seu conhecimento em programação_** em relação ao que você sabia antes de prestar o processo seletivo, ou seja, **_queremos analisar o quanto você foi capaz de aprender._** Para isso vamos usar como base as respostas dos exercícios e as informações que você nos passou no forms de inscrição. **Material de Estudo Base:** Nós do FEA.dev **_recomendamos o curso de Python do Gustavo Guanabara_** como material de estudo para esse case. Lembre-se de fazer um estudo seletivo dentro do possível: https://www.youtube.com/watch?v=S9uPNppGsGo&list=PLvE-ZAFRgX8hnECDn1v9HNTI71veL3oW0 **Tenho Dúvidas!** Caso tenha dúvidas sobre os exercício ou qualquer outra dúvida **_sinta-se livre para chamar qualquer um dos nossos membros pelo WhatsApp_**.**Nenhum** ponto será descontado por você ter nos chamado, por isso não fique com vergonha. Além disso, outra ótima ferramenta para se tirar dúvidas e fazer pesquisas é o Stack Overflow.Rode a célula abaixo e entre em contato com um de nossos monitores:<jupyter_code>import random
lista_contatos = ["<NAME> - +55 11 94497-2191", "<NAME> - +55 11 94529-9054", "<NAME> - +55 11 97138-1558", "<NAME> - +55 11 99179-8629", "<NAME> - +55 11 99484-1349"]

print(f'Seu monitor: {lista_contatos[random.randint(0, 4)]}')<jupyter_output>Seu monitor: <NAME> - +55 11 99179-8629<jupyter_text>**Instruções para o Case:** - Você deve escrever a resposta de cada exercício no retângulo abaixo de cada questão e depois do *SEU CODIGO COMECA AQUI*.- Nos ordenamos os exercícios de forma que a dificuldade seja crescente, portanto recomendamos que sigam a ordem deles.- Todos os resultados de cada exercício deverão ser printados- O case possui no total 12 exercícios de programação (e 1 bônus). Dos 12 você deve fazer até onde você for capaz. Por isso não se preocupe caso não tenha conseguido fazer todos os 12 exercícios.- O exercício 13 é uma tarefa extra. Ela possui um nível de dificuldade acima dos demais, e não é obrigatório- **No final do jupyter notebook tem uma parte onde você deve você colocar todas as fontes que você usou para estudar e para fazer os exercícios. Lembrando que a quantidade e nem a qualidade das fontes serão avaliadas. Insira os links.** - Todo código que você escrever deverá ser comentado, veja o exemplo abaixo<jupyter_code>"""
Exemplo:
Neste exercicio você deverá criar duas variáveis com os valores de 10 e 12 e soma-las
"""

#####SEU CODIGO COMECA AQUI#####
# VARIAVEL COM O NUMERO 10
x = 10

# VARIAVEL COM O NUMERO 12
y = 10

# SOMA DAS VARIÁVEIS "x" E "y"
total = x + y

# RESPOSTA
print(total)<jupyter_output>20<jupyter_text>Exercícios  1) Numa loja o salário dos vendedores é calculado como uma parte fixa de R$ 2.000,00, somado a um bônus de 15% das vendas totais desse vendedor.Em Agosto, Joaquim realizou vendas que totalizaram R$ 8.000,00, qual o salário total dele nesse mesmo mês?<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Declaração de variáveis (p/ evitar magic numbers)
fixo = 2000
bonus = 0.15
vendas = 8000

# Realiza cálculo do salário
salario = (fixo + bonus * vendas)

# Resposta
print (f'O salário total de Joaquim no mês de agosto é de: R${salario:.2f}')<jupyter_output>O salário total de Joaquim no mês de agosto é de: R$3200.00<jupyter_text>2)  Calcule o consumo de calorias por quilómetro rodado de determinadas pessoas, e printe o nome da pessoa com o gasto calórico/min mais baixo.$\text{Gasto calórico/min} = Velocidade (km/h) * peso (kg) * 0.0175$- <NAME> corre a 8km/h com 65kg - Kiichiro Toyoda corre a 12km/h com 58kg- <NAME> corre a 11km/h com 60kgFonte da fórmula de calorias/min [GE]<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Declaração de variável com o valor da constante da fórmula do gasto calórico
const = 0.0175

# Função para automatizar o cálculo das calorias gastas usando a velocidade e massa de cada pessoa
def cal(speed, weight):
    # Cálculo em si, com base na fórmula do enunciado
    calo = (speed * weight * const)
    # Retorna o valor da resposta a variável que a função for atribuída em seguida
    return calo

# Usando a função com os parâmetros de <NAME> (velocidade, massa), mesma estrutura para os próximos
h = cal(8, 65)
# Define por padrão a variável da caloria final da resposta, a ser testada para as próximas pessoas
cal_final = h
# Define por padrão a variável do nome final da resposta, a ser testada para as próximas pessoas
name = "<NAME>"

# Usando a função com os parâmetros de <NAME>
k = cal(12, 58)
# Testa caso o gasto calórico de Kiichiro for menor que o resultado armazenado anteriormente, se positivo ...
# ...então o mesmo substituirá o valor da caloria final e também o nome, se não a variável final se mantém igual
if k < cal_final:
    cal_final = k
    name = "<NAME>"

# Usando a função com os parâmetros de <NAME>
b = cal(11, 60)
# Testa caso o gasto calórico de Bernd for menor que o resultado armazenado anteriormente, se positivo ...
# ...então o mesmo substituirá o valor da caloria final e também o nome, se não a variável final se mantém igual
if b < cal_final:
    cal_final = b
    name = "<NAME>"

# Resposta
print(f"A pessoa com o menor gasto calórico é {name}, sendo de {cal_final:.2f} cal/min")

# É possível automatizar mais ainda e colocar esses "ifs" dentro da função? Sem sucesso até o momento<jupyter_output>A pessoa com o menor gasto calórico é <NAME>, sendo de 9.10 cal/min<jupyter_text>3) O objetivo desse exercício é criar uma fórmula de juros compostos.  Denomine as variáveis como: "Mont_inicial", "tx_juros", "tempo". Atribua às variáveis  respectivamente os seguintes valores: "R$ 9000", "1,8% a.m", "19 meses "; e calcule o montante final. O montante final deve ser printado na tela.**Obs**: fórmula de Juros Compostos é $M_f = M_o(1 + i)^t$- $M_f$ = montante final ; $M_o$ = montante inicial ; $i$ = taxa de juros ; $t$ = tempo;<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Declaração de variáveis
Mont_inicial = 9000
tx_juros = 0.018
tempo = 19

# Cálculo do montante final
Mf = Mont_inicial * ((1 + tx_juros) ** (tempo))

# Resposta
print(f"o montante final é de: R${Mf:.2f}")<jupyter_output>o montante final é de: R$12631.37<jupyter_text>4) Utilize o código acima para criar dois novos montantes finais, que terão o mesmo montante inicial do exercício anterior: - O mont_final2 com taxa de juros = 2% a.m; tempo = 14 meses;- O mont_final3 com taxa de juros = 0.5% a.m; tempo = 32 mesesApós isso você deverá testar quais dos três montantes finais possui o maior valor, e printar o valor desse montante.**Obs**:Não print os resultados para saber o maior, você deverá fazer esse teste utilizando as condicionais do Python (if-else-elif).<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Declaração de variável
Mont_inicial = 9000

# Função para automatizar a conta usando os parâmetros de cada investimento)
def Mont(tx_juros, tempo):
    # Cálculo em si, usando a fórmula para juros compostos
    Mf = Mont_inicial * ((1 + tx_juros) ** (tempo))
    
    # Retorna o valor do cálculo, sem essa linha o código não funciona
    return Mf

# Usando a função com os parâmetros do investimento 1 (taxa de juros, tempo), mesma estrutura para os próximos
mont_final1 = Mont(0.018, 19)
# Define por padrão o retorno da função como o maior montante final, depois a ser testado
maior = mont_final1
# Define por padrão o número do investimento para ser usado na resposta final, também a ser testado
name = 1

# Calculando o montante final usando a função "Mont" e os parâmetros específicos desse investimento
mont_final2 = Mont(0.02, 14)
# Testa na condição "if" caso esse investimento é maior que o anterior acaba substituindo os valores das variáveis finais
if mont_final2 > maior:
    maior = mont_final2
    name = 2

# Calculando o montante final usando a função "Mont" e os parâmetros específicos desse investimento
mont_final3 = Mont(0.005, 32)
# Testa na condição "if" caso esse investimento é maior que o anterior acaba substituindo os valores das variáveis finais
if mont_final3 > maior:
    maior = mont_final3
    name = 3

# Resposta
print(f"O maior montante final pertence ao investimento {name}, sendo de R${maior:.2f}")


#dá pra fazer um for loop e deixar mais enxuto ainda?
#incluir o if na função assim fica mais exuto<jupyter_output>O maior montante final pertence ao investimento 1, sendo de R$12631.37<jupyter_text>5) Nesse exercício você é um professor(a) de uma matéria da FEA e está se adaptando ao EAD, você quer fazer um programa que calcule a hipotenusa de um triângulo para rapidamente corrigir as provas de seus alunos (a matéria é Triângulos Keynesianos). Haverá três modelos de prova, cada um com a mesma questão de triângulos, mas cada uma das três com números diferentes.Calcule qual será cada uma das hipotenusas para os modelos de prova.$Hipotenusa = \sqrt{CatetoA^2 + CatetoB^2}$| Provas | Cateto A   | Cateto B ||-------|------|------|| Modelo 1 | 3 | 4 || Modelo 2 | 20 | 54.8 || Modelo 3 | 133.4 | 98 |<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Função para automatizar os cálculos e já "printar" as respostas de cada modelo
def hip(CatetoA, CatetoB, modelo):
    # Cálculo genérico da hipotenusa que será usado para cada modelo específico em seguida
    hipo = (CatetoA ** 2 + CatetoB ** 2) ** (1 / 2)
    # Print da resposta final de cada modelo
    print(f"A hipotenusa na prova do modelo {modelo} é: {hipo:6.2f}")

# Usando a função em cada modelo de fato para gerar as respostas
# Formato = (1ºnúmero = catetoA; 2ºnúmero = catetoB; 3ªnúmero = nº do modelo da prova) como descrito na função
modelo1 = hip(3, 4, 1)
modelo2 = hip(20, 54.8, 2)
modelo3 = hip(133.4, 98, 3)<jupyter_output>A hipotenusa na prova do modelo 1 é:   5.00
A hipotenusa na prova do modelo 2 é:  58.34
A hipotenusa na prova do modelo 3 é: 165.53<jupyter_text>6) As tarefas desse exercício são focadas na estrutura de dado complexa\*, lista.\* complexa porque não é, por exemplo, um int ou um float, mas sim um conjunto de elementos variados, que inclusive podem ser de tipos diferentesa) Crie uma lista com 4 notas: 4.75, 6.0, 9.5, 7.0. Mostre cada nota na tela acessando pela lista.<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Criação da lista
notas = [4.75, 6.0, 9.5, 7.0]

# Loop para percorrer cada elemento e printar individualmente em linhas separadas (uso do "enumerate()" para poder...
# ...saber qual a posição dentro da lista, i = posição, n = valor dentro da posição)
for i, n in enumerate(notas):
    print(f'Na posição {i} o valor armazenado é: {n:.2f}')<jupyter_output>Na posição 0 o valor armazenado é: 4.75
Na posição 1 o valor armazenado é: 6.00
Na posição 2 o valor armazenado é: 9.50
Na posição 3 o valor armazenado é: 7.00<jupyter_text>b) Você deve criar uma variável "geo", essa variável será a média **geométrica** dessas notas. Além disso você precisa adicionar essa média no final da lista que você criou. Por fim printe a média geométrica.Fórmula da média geométrica = $\sqrt[\leftroot{2}\uproot{2}n]{x_1x_2...x_n}$<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Criação da lista
notas = [4.75, 6.0, 9.5, 7.0]

# Variável de "controle" do loop iniciciando em 2, pois os 2 primeiros termos (0 e 1) não serão percorridos no loop
i = 2
# Variável para saber de forma dinâmica a quantidade de termos dentro da lista fornecida
size = len(notas)
# Criação da variável geo já incluso a multiplicação dos dois primeiros termos da lista (foi o jeito que deu certo)
geo = notas[0] * notas[1]

# Loop para percorrer a lista a partir do terceito elemento (posição 2) até o último (size) e multiplicar cada termo...
# ... da variável geo pelo próximo termo da lista
while i < size:
    # Variável com o termo atual da iteração
    current = notas[i]
    # Multiplicação do resultado anterior da variável geo pelo termo atual, já armazenando na mesma
    geo *= current
    # Acrescenta +1 na variável de controle do loop para saber até quando chegar o limite da lista e parar a execução
    i += 1

# Calculando a raíz de "size" usando a função "round" pois o resultado ficaria um número quebrado e muito grande
geo = round(geo**(1/size), 2)
# Inclui o resultado da variável geo no final da lista inicial
notas.insert(size, geo)

# Resposta 
print(f"A média geométrica da lista anterior é igual a: {geo},\nsendo acrescida na nova lista, formando: {notas}")<jupyter_output>A média geométrica da lista anterior é igual a: 6.6,
sendo acrescida na nova lista, formando: [4.75, 6.0, 9.5, 7.0, 6.6]<jupyter_text>7) Crie um código que leia a variável N, e print todos os números entre 1 e 1000, que dividido por esse N, tem resto igual a 2. Exemplo: > N=5  >>>> 12/5, tem resto igual a 2, portanto devo printar o número 12<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Declaração da variável com a quantidade máxima a ser testada em seguida
max = 1000
# Variável apenas evitar magic number, usado para saber qual o resto da divisão desejado na função a seguir
base = 2

# Função para cálcular o resto e "printar" os números pedidos
def resto(n):
    # Declação do valor inicial da variável de iteração, para percorrer a partir do número 1
    i = 1
    # loop para percorrer até o valor máximo (1000) e realizar o cálculo a cada iteração
    while i <= max:
        # Como colocar esse "operador ternário" sem a 2ª condição de "else"?
        # print(i if i % n == base else "impar")
        
        # Se o número da iteração dividido por "n" deixar o resto da divisão == 2, então será printado o número do (i)
        if i % n == base:
            # Seria melhor criar uma lista e printar as repostas dessa forma ou manter 1 reposta p linha?
            # Como fazer uma tabela e printar as respostas nesse formato?
            print(i)
        # Acrescenta +1 na variável "i" para seguir com o próximo número a ser testado
        i += 1
    # Print para separar os resultados de cada caso em algumas linhas
    print("\n" * 2)


# Caso N=13
# Print para evidenciar qual caso está sendo rodado
print("-" * 5 + "Caso 13" + "-" * 5)
# Atribui o valor "13" a variável "N" que servirá como denominador no cálculo da função (igual aos próximos casos)
N = 13
# Inicia a função no caso dessa variável sendo igual a 13 (igual aos próximos casos, com seus respectivos valores)
resto(N)

# Caso N=17
# Print para evidenciar qual caso está sendo rodado
print("-" * 5 + "Caso 17" + "-" * 5)
# Atribui o valor "17" a variável "N" que servirá como denominador no cálculo da função
N = 17
# Inicia a função no caso dessa variável sendo igual a 17
resto(N)

# Caso N=23
# Print para evidenciar qual caso está sendo rodado
print("-" * 5 + "Caso 23" + "-" * 5)
# Atribui o valor "23" a variável "N" que servirá como denominador no cálculo da função
N = 23
# Inicia a função no caso dessa variável sendo igual a 23
resto(N)<jupyter_output>-----Caso 13-----
2
15
28
41
54
67
80
93
106
119
132
145
158
171
184
197
210
223
236
249
262
275
288
301
314
327
340
353
366
379
392
405
418
431
444
457
470
483
496
509
522
535
548
561
574
587
600
613
626
639
652
665
678
691
704
717
730
743
756
769
782
795
808
821
834
847
860
873
886
899
912
925
938
951
964
977
990



-----Caso 17-----
2
19
36
53
70
87
104
121
138
155
172
189
206
223
240
257
274
291
308
325
342
359
376
393
410
427
444
461
478
495
512
529
546
563
580
597
614
631
648
665
682
699
716
733
750
767
784
801
818
835
852
869
886
903
920
937
954
971
988



-----Caso 23-----
2
25
48
71
94
117
140
163
186
209
232
255
278
301
324
347
370
393
416
439
462
485
508
531
554
577
600
623
646
669
692
715
738
761
784
807
830
853
876
899
922
945
968
991<jupyter_text>8) **Qual o motivo de aprender inglês?? Crie seu próprio app de tradução!**Nesse exercío você terá um dicionário (de python, ou seria um inglês-português?), onde as chaves são palavras em inglês e os valores são as respectivas traduções em português. Por exemplo:> dicio = {"hello": "olá"}O objetivo dessa tarefa será traduzir a frase em inglês que está na variável (string) chamada "frase_eng". Além disso a você deverá printar a tradução.**Dica: procure sobre métodos de strings**<jupyter_code>"""LISTA DE PALAVRAS EM PORTUGUES"""
frase_eng = "may the force be with you"

dicio = {'the': 'a',
         'may': 'que',
         'ball': 'bola',
         'programming': 'programacao',
         'force': 'forca',
         'you': 'voce',
         'python': 'piton',
         'be': 'esteja',
         'mouse': 'rato',
         'sweet': 'doce',
         'with': 'com',
         'sky': 'ceu'}
#####SEU CODIGO COMECA AQUI#####

# Separando cada termo da frase para poder manipular individualmente a seguir
frase = frase_eng.split()

# Criação da variável final da resposta deixando no formato de uma string vazia 
translate = ''

# For loop para percorrer cada termo da variável frase
for k in frase:
    # Condição para que o termo na iteração atual conste na "chave" do dicionário (o termo a ser traduzido)
    if k in dicio.keys():
        # Constando, então é pego o valor correspondente a essa chave no dicionário e acrescentado na string "translate"
        # e a cada iteração é somado (concatenado) a anterior junto com um "espaço"
        translate = translate + dicio[k] + ' '

# Resposta removendo qualquer espaço adicional no final (feito para corrigir o espaço da última iteração do loop)
print(translate.strip())


# Parece fácil agora, mas demorei p cacete nessas de dicionário<jupyter_output>que a forca esteja com voce<jupyter_text>9) **Parabéns agora você é dono(a) de um food truck!!** Para facilitar seu trabalho você deseja automatizar o calculo do valor total que o cliente deverá te pagar. Para isso você precisará usar a tabela (cardápio) abaixo para escrever um programa que leia um dicionário, "dict_pedido", que possui os códigos dos itens que o seu cliente deseja consumir como as chaves do dicionário e quantidade de cada pedido com o valor do dicionário {código do item: quantidade}. Por fim, calcule o valor total a ser pago pelo cliente. Além disso você deve printar o resultado final. Código | Produto | Preço--- | --- | ---**1** | Cachorro Quente |  10.50**2**| XSalada | 5.50 **3** | XBacon | 7.00**4** | Pão na Chapa | 3.79**5** | Refrigerante | 6.00<jupyter_code># DICINARIO COM O PEDIDO DO CLIENTE
dict_pedido = {3: 2, 1:1, 5:11, 4:5, 2:3}  # {código do item: quantidade do item}

#####SEU CODIGO COMECA AQUI#####

# Lista com 1 dicionário por linha com informações correspondentes a cada produto (fica mais organizado e ...
# ...fácil para linkar todas as informações depois)
cardapio = [{"Código": 1, "Produto":"Cachorro Quente", "Preço": 10.50},
            {"Código": 2, "Produto":"XSalada"        , "Preço":  5.50},
            {"Código": 3, "Produto":"XBacon"         , "Preço":  7.00},
            {"Código": 4, "Produto":"Pão na Chapa"   , "Preço":  3.79},
            {"Código": 5, "Produto":"Refrigerante"   , "Preço":  6.00}]

# Criação da variável p/ resposta final
total = 0

# Prints apenas pela estética
print("Pedido: \n")
print("Produto:" + " " * 12 + "Preço Unitário:" + " " * 5 + "Quantidade:" + " " * 9 + "Subtotal:")

# Loop percorrendo o dicionário com o pedido do cliente (k = key; v = value), necessário usar .items()
for k, v in dict_pedido.items():
    
    # Variável para armazenar o nome do produto correspondente ao código do mesmo
    nome = cardapio[k-1]["Produto"]
    
    # Variável para armazenar o preço corresponde do produto na iteração atual ("k - 1" no código pois acredito que ...
    # ... o índice padrão da lista começa com zero, então sem essa subtração acaba dando um bug)
    p_unitario = float(cardapio[k-1]["Preço"])
    
    # Subtotal é a multiplicação da qt. pelo preço buscado na lista código ("v" é o valor usado no dicionário...
    # fornecido "dict_pedido" para discriminar a quantidade comprada do item)
    subtotal = v * p_unitario
    
    # Print com o nome do produto, preço unitário, quantidade e subtotal de cada iteração, tentanto deixar com uma...
    # ...formatação mais agradável
    print(f"{nome:19} {p_unitario:5.2f} {v:16} unidade(s)       R$ {subtotal:.2f}")
    
    # Soma o subtotal de cada iteração
    total += subtotal


# Resposta final
print("\nTotal " + '-' * 53 + f" R${total}")<jupyter_output>Pedido: 

Produto:            Preço Unitário:     Quantidade:         Subtotal:
XBacon               7.00                2 unidade(s)       R$ 14.00
Cachorro Quente     10.50                1 unidade(s)       R$ 10.50
Refrigerante         6.00               11 unidade(s)       R$ 66.00
Pão na Chapa         3.79                5 unidade(s)       R$ 18.95
XSalada              5.50                3 unidade(s)       R$ 16.50

Total ----------------------------------------------------- R$125.95<jupyter_text>10) Nesta tarefa você deverá criar uma lista de 10 itens (começando pelo 0). Sendo i a posição de um determinado elemento dentro da lista.Se a posição i for par: o elemento nesta posição deverá ser preenchida de acordo com a regra: $x[i] = 3^i + 7*i$Se a posição i for ímpar: o elemento nesta posição deverá ser preenchida de acordo com a regra: $x[i] = 3^i + 7(i - 2) + \frac{i^2}{2}$<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Declaração de variáveis globais
i = 0
max = 10
lista = []

# While loop para determinar se o "i" é par ou impar depois fazer o cálculo e indexar a lista de acordo com essa resposta
while i < max:
    # Testa condição para ser par, ou seja, o resto da divisão 'i' / 2 tem que ser = 0
    if i % 2 == 0:
        # Caso verdadeiro faz o cálculo pré-determinado para números pares e armazena na variável "x" atual
        x = 3**i + 7 * i
        # Acrescenta o valor na lista usando de parâmetros (posição atual, resposta do cálculo de "x" atual)
        lista.insert(i, x)
        
    # Se condição anterior for falsa o valor é impar e entra no "else"
    else:
        # Faz o cálculo pré-determinado para números ímpares e armazena na variável "x" atual
        x = 3**i + 7 * (i - 2) + (i**2)/2
        # Acrescenta o valor na lista usando de parâmetros (posição atual, resposta do cálculo de "x" atual)
        lista.insert(i, x)
    
    # Acrescenta +1 na variável para o loop poder prosseguir até o termo máximo sem virar um loop infinito
    i += 1
    
# Resposta
print(lista)<jupyter_output>[1, -3.5, 23, 38.5, 109, 276.5, 771, 2246.5, 6617, 19772.5]<jupyter_text>11) **Parabéns você foi contratado pelo Papai Noel como Data Scientist!!**A maior companhia do Polo Norte deseja que você preveja o lucro da empresa em 2019 com base no Lucro dos anos de 2010 a 2018 e no número de vendas dos anos de 2010 à 2019. Para isso, você irá criar uma regressão linear simples com base nessas duas informações.> $\hat{y} = a + b.X$> $a = \overline{Y} - b.\overline{X}$> $b = \frac{\sum{X.Y} - \frac{\sum{X}.\sum{Y}}{n}}{\sum{X^2}-\frac{(\sum{X})^2}{n}}$ - onde $\hat{y}$ é a estimativa do lucro da empresa com base no número de vendas $X$ em determinado ano - $b$ o coeficiente angular da reta; $a$ é o ponto de intersecção- $\overline{Y}$ e $\overline{X}$ são respectivamente a média aritmética da variáveis "y" e "x"- $X$ é o número de vendas- $Y$ é o lucro na empresaCaso tenha mais dúvidas recomendamos que assistam esse vídeo ou qualquer material de sua preferência: https://www.youtube.com/watch?v=x42skwrbiek**Obs**:Você deve usar o número de de vendas em 2019 para prever o lucro em 2019, por isso esse valor de vendas não deve entrar no cálculo da regressão linear simples.<jupyter_code># LUCRO DO NOEL DO ANO DE 2010 A 2018
lucro_10_18 = [3200, 1720, 800, 1800, 4750, 8000, 3200, 12789, 12271]

# NUMERO DE VENDAS DO NOEL DO ANO DE 2010 A 2019
vendas_10_19 = [3269, 7000, 7300, 8264, 11345, 12589, 13211, 14467, 16666, 17420]

#####SEU CODIGO COMECA AQUI#####

# Criação da lista para armazenar o quadrado dos termos da lista de vendas
x_sqr = []
# Criação da Lista para armazenar o produto do lucro pelas vendas nos respectivos anos
lucro_x_vendas = []

# Variáveis para armazenar a somatória de todos os termos de suas respectivas listas
total_lucro_x_vendas = 0
total_x_sqr = 0
total_x = 0
total_y = 0

# Variável para saber o nº de termos da lista
size = len(lucro_10_18)

# Variável para armazenar o número de vendas do ano de 2019
v_2019 = vendas_10_19[size]

# Loop para percorrer a lista com os lucros de 2010 a 2018. Foi escolhida essa lista, pois a outra possui um termo...
# a mais e não consegui fazer as contas sem adicionar condições extras
for i, n in enumerate(lucro_10_18):
    # Adiciona na lista "x_sqr" o termo de mesma posição da iteração atual, mas pegando da lista de vendas...
    # e elevando esse termo ao ²
    x_sqr.insert(i, vendas_10_19[i] **2) 
    # Adiciona na lista "lucro_x_vendas" o termo de mesma posição da lista percorrida, mas multiplicando com...
    # o termo também de mesma posição da lista de vendas
    lucro_x_vendas.insert(i, n * vendas_10_19[i])
    
    # A cada iteração soma o termo correspondente a ele mesmo para saber o total na lista de vendas
    total_x += vendas_10_19[i]
    # A cada iteração soma o termo correspondente a ele mesmo para saber o total na lista de vendas ao ² (x_sqr)
    total_x_sqr += x_sqr[i]
    # A cada iteração soma o termo correspondente a ele mesmo para saber o total na lista de lucros
    total_y += n
    # A cada iteração soma o termo correspondente a ele mesmo para saber o total na lista de lucros x vendas
    total_lucro_x_vendas += lucro_x_vendas[i]

# Variáveis para saber a média aritmética dos termos da lista "x" e "y" (somatória dos termos / qt. de termos)
x_mean = total_x / size
y_mean = total_y / size

# Criação das variáveis para o cálculo dos termos da regressão, conforme fórmulas do enunciado e vídeo
b = (total_lucro_x_vendas - ((total_x * total_y)/size)) / (total_x_sqr - (total_x **2)/size)
a = (y_mean - b * x_mean)

# Variável para armazenar a equação final
final = a + b * v_2019

# Resposta final, ufaaaaaaaaa
print(f"A previsão de lucro para a empresa do papai noel no ano de 2019 é de ${final:.2f}")

#print(f"A lista 'x' ao quadrado equivale a {x_sqr}\n")
#print(f"A lista de lucro x vendas equivale a {lucro_x_vendas}\n")
#print(f"A soma de todos os termos da lista'x' equivale a {total_x}\n")
#print(f"A soma de todos os termos da lista'y' equivale a {total_y}\n")
#print(f"A soma de todos os termos da lista de 'x²' equivale a {total_x_sqr}\n")
#print(f"A soma de todos os termos da lista de 'lucro x vendas' equivale a {total_lucro_x_vendas}")
#print(f"A média da lista x é {x_mean}")
#print(f"A média da lista y é {y_mean}")
#print(f"O termo 'a' equivale a {a}")
#print(f"O termo 'b' equivale a {b}")
#print(f"A equação final (no formato y = a + bx) é: y = {a:.4f} + {b:.4f} * {v_2019}")<jupyter_output>A previsão de lucro para a empresa do papai noel no ano de 2019 é de $11220.25<jupyter_text>12)|QUESTÃO ADAPTADA MAC113 - FEA - Professores : <NAME> e <NAME> | Após o período de festas você arruma um emprego em um bar pertencente à *holding* do Papai Noel (ele se aproveita da sazonalidade de seu trabalho e da ausência de leis trabalhistas no Polo Norte para demití-lo de seu emprego como *Data Scientist*). No bar todos os clientes possuem direito a pagar fiado com limite de **R$ 50,00**, ou seja, podem comprar refeições além da quantia em sua carteira no momento desde que não ultrapasse esse limite. Dependendo da situação do cliente e da conta que ele deverá pagar, ele poderá obter uma das seguintes situações:1. ‘PAGAMENTO ACEITO’: se o cliente possui saldo suficiente para efetuar o saque,2. ‘FIADO’: se o saldo do cliente junto com o valor disponível em fiado é suficientepara efetuar o pagamento, ou3. ‘QUANTIA INSUFICIENTE’: se o saldo do cliente junto com o valor disponível em fiado NÃO é suficiente para efetuar o saque.&nbsp;&nbsp;Como você é um *data scientist* nato você não pode fugir de sua natureza e decide fazer uma pequena análise sobre o poder financeiro dos consumidores do bar do Sr. Noel. Você decide criar uma função que receba como argumentos (nesta ordem):- O Nome do Cliente (str)- Dinheiro na carteira do cliente (float)- Valor do pagamentoUsando a função do item anterior, seu programa retornará um print:A-B: COnde:– A – Nome do cliente;– B – ‘PAGAMENTO ACEITO’, ‘FIADO’ ou ‘QUANTIA INSUFICIENTE’;– C – Dinheiro na carteira do cliente após o pagamentoObserve que quando a transação tem o status ‘QUANTIA INSUFICIENTE’, o saldo continua o mesmo já que não poderá ser debitado. No caso do status "FIADO" o dinheiro restante na carteira do cliente será negativa.<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Variáveis para armazenar as mensagens de status final
aceito = "PAGAMENTO ACEITO!"
fiado = "FIADO!"
recusado = "QUANTIA INSUFICIENTE"

# Variável para definir valor limite de fiado
limite = - 50

# Print por estética
print("Nome:" + ' ' * 11 + "Status:" + ' ' * 18 + "Saldo final:")

# Função para checar qual o status e saldo final do cliente
def poder_consumidor (nome, money, pg):
    # Variável p armazenar o saldo que o comprador fica após ter pago
    saldo = float(money - pg)
    
    # Se o saldo restante for maior que 0 então o pagamento foi aceito
    if saldo > 0:
        status = aceito
    # Senão verifica se o saldo que sobrou está entre o limite (-50) e 0, então o pagamento será no fiado
    else:
        if saldo >= limite:
            status = fiado
        # Senão entra na última condição possível, o cliente não tem dinheiro suficiente e a transação não é aprovada
        else:
            status = recusado
            # Como a compra do cliente foi recusada o saldo volta a ser o inicial
            saldo = money
    
    # Print da resposta final de cada cliente
    print(f"{nome:15} {status:24} $ {saldo:.2f}")

#####SEU CODIGO TERMINA AQUI#####
# ESTES TESTES SÃO PARA NOSSA CORREÇÃO, NÃO ALTERE
poder_consumidor("Thomas", 420, 500)
poder_consumidor("Ed", 1240, 1290)
poder_consumidor("Alice", 480, 500)
poder_consumidor("Edu", 500, 320)<jupyter_output>Nome:           Status:                  Saldo final:
Thomas          QUANTIA INSUFICIENTE     $ 420.00
Ed              FIADO!                   $ -50.00
Alice           FIADO!                   $ -20.00
Edu             PAGAMENTO ACEITO!        $ 180.00<jupyter_text>Questão de Programação Bônus!!!não é obrigatória&nbsp;&nbsp;&nbsp;Após o seu período como data scientist (e como bartender) na empresa do Sr. Noel você quer voltar para a Terra da Garoa, já que não conseguiu se adaptar ao verão do Polo Norte. Ao chegar no aeroporto você percebe que esqueceu seu passaporte e acabou trazendo seu documento de identificação polo-nortista (que é muito similar ao seu passaporte), que não é válido para voos internacionais, já que o Polo Norte não é oficialmente um país.Há uma longa fila no aeroporto, porque o sistema de identificação automático de passaportes do aeroporto é muito mal otimizado e não consegue identificar os campos dos documentos eficientemente. Ao perceber essa falha você pensa que pode achar uma solução, tanto para a fila como para a sua situação documental.O sistema tem que identificar os seguintes campos:- [byr] -> Birth Year (ano de nascimento)- [iyr] -> Issue Year (ano de expedição)- [eyr] -> Expiration Year (ano de validade)- [hgt] -> Height (altura)- [hcl] -> Hair Color (cor do cabelo)- [ecl] -> Eye Color (cor do olho)- [pid] -> Passport ID (Id do passaporte)- [cid] -> Country ID (Id do país)O seu input será um arquivo de texto com os campos de cada documento que o sistema identificou, um exemplo do input é o seguinte:note que o formato segue um modelo key\:value```ecl:gry pid:860033327 eyr:2020 hcl:fffffdbyr:1937 iyr:2017 cid:147 hgt:183cmiyr:2013 ecl:amb cid:350 eyr:2023 pid:028048884hcl:cfa07d byr:1929hcl:ae17e1 iyr:2013eyr:2024ecl:brn pid:760753108 byr:1931hgt:179cmhcl:cfa07d eyr:2025 pid:166559648iyr:2011 ecl:brn hgt:59in```Cada documento está **separado por uma linha em branco**, ou seja, o conjunto `ecl:gry pid:860033327 eyr:2020 hcl:fffffd byr:1937 iyr:2017 cid:147 hgt:183cm` é o primeiro documento. O `iyr:2013 ecl:amb cid:350 eyr:2023 pid:028048884 hcl:cfa07d byr:1929` o segundo e etc.Note que o primeiro documento possui todos os campos que caracterizam um passaporte, por isso ele é considerado **válido**. O segundo passaporte é **ínvalido**, pois não possui o campo da altura `hgt`.Note que o terceiro passaporte possui todos os campos, exceto o `cid`, o código do país. Seria interessante se o sistema ignorasse este campo, para que você possa voltar ao país canarinho, não? O quarto passaporte não possui ambos `cid` e `byr`, por isso não seria válido.O seu objetivo é codar um programa que **leia o input.txt e conte** quantos passaportes são válidos (o `cid` seria opcional, para que você possa embarcar).**Importante:** O input.txt está na pasta enviadaLink para o arquivo no drive, caso haja algum problema com o arquivo enviado<jupyter_code>#####SEU CODIGO COMECA AQUI#####

# Estrutura a ser organizada:


'''passaporte = [{byr:   , iyr:    , eyr:    , hgt:    , hcl:    , ecl:    , pid:    , cid:    },
                 {byr:   , iyr:    , eyr:    , hgt:    , hcl:    , ecl:    , pid:    , cid:    },
                 {byr:   , iyr:    , eyr:    , hgt:    , hcl:    , ecl:    , pid:    , cid:    },
                 {byr:   , iyr:    , eyr:    , hgt:    , hcl:    , ecl:    , pid:    , cid:    },
                 {byr:   , iyr:    , eyr:    , hgt:    , hcl:    , ecl:    , pid:    , cid:    }]'''

#passaporte[0] primeiro passaporte
#passaporte[1] segundo passaporte e assim por diante.

# Na estrutura de dicionário não funcinou ;/

# Nova tentativa:
# Lista para comparar os itens que são considerados para validar o passaporte (todos exceto "cid")
lista = ['byr', 'iyr', 'eyr', 'hgt', 'hcl', 'ecl', 'pid']

# Lista que juntará informações de um passaporte que estão espalhadas em linhas diferentes...
# no arquivo .txt
passaporte = []
# Lista p/ poder contar quantos dos campos necessários o passaporte possui
status = []
# Variável p/ contar quantos passaportes são válidos
count = 0
# Variável p/ contar quantos passaportes tem no total
total = 0

# Comando para abrir arquivo .txt
file = open('input.txt')
# Loop para percorrer linha a linha do arquivo
for line, value in enumerate(file):
    
    # Condição: se conter algum valor na linha que não apenas um espaço em branco, (ou seja, até chegar...
    # linha que separa um passaporte do outro)
    if value != '\n':
        # adiciona na lista passaporte o valor daquela linha, e as outras pertencentes ao mesmo passaporte
        passaporte.append(value)
    
    # Quando chegar a linha que separa os passaportes
    else:
        # Inicia um loop percorrendo cada item da lista com os campos a serem verificados
        for i, n in enumerate(lista):
            # Verifica se o campo específico da lista consta no passaporte 
            if lista[i] in str(passaporte):
                # Caso verdadeiro adiciona um "True" a lista de controle "status" (a palavra não importa)
                status.append('TRUE')
        
        # Após percorrer toda lista, verifica se todos os campos constam no passaporte, (é necessário...
        # que a lista "status" tenha 7 posições preenchidas, não importa o que tem dentro)
        if len(status) == 7:
            # Estando de acordo, acrescenta +1 na variável que conta quantos passaportes são válidos
            count +=1
        
        # Zera a lista passaporte para não acumular com o próximo passaporte
        passaporte = []
        # Zera a lista status para não acumular com o próximo passaporte
        status = []
        
    # Se a linha está vazia acrescenta +1 na variável total, que mostra o total de passaportes no arquivo
    if value == '\n':
        total += 1

# Adiciona +1 na variável total para corrigir o índice da lista que começa em zero
total += 1

# Resposta Final!!!
print(f"Dos {total} passaportes analisados, apenas {count} são válidos.")<jupyter_output>Dos 254 passaportes analisados, apenas 190 são válidos.
{'fraction_non_alphanumeric': 0.08542183295520499, 'fraction_numerical': 0.04326491848256213, 'mean_word_length': 3.5947878787878786, 'pattern_counts': {'":': 16, '<': 71, '<?xml version=': 0, '>': 87, 'https://': 4, 'lorem ipsum': 0, 'www.': 4, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '16', 'dir': 'jupyter-structured-clean-dedup', 'id': '19846', 'license': 'MIT', 'n_tokens_mistral': 15087, 'n_tokens_neox': 13656, 'n_words': 5516, 'path': '.ipynb_checkpoints/case_basico-checkpoint.ipynb', 'repo_name': 'k-marcelino/Case-Basico_PS_FEA.dev', 'size': '38073'}