├── desafio5 ├── Done │ ├── destinos │ │ ├── __init__.py │ │ ├── interface │ │ │ ├── __init__.py │ │ │ └── destinos.py │ │ ├── niterio.py │ │ ├── fortaliza.py │ │ └── belo_horizonte.py │ ├── planejador_de_viajem.py │ └── run.py ├── toDo │ └── run.py └── descritivo.txt ├── desafio8 ├── Done │ ├── template │ │ ├── __init__.py │ │ └── calculator_template.py │ ├── run.py │ └── calculators.py ├── toDo │ └── run.py └── descritivo.txt ├── desafio3 ├── Done │ ├── model │ │ ├── __init__.py │ │ └── jogador.py │ ├── controller │ │ ├── __init__.py │ │ └── gerenciador_de_jogo.py │ └── run.py ├── toDo │ └── run.py └── descritivo.txt ├── desafio4 ├── Done │ ├── model │ │ ├── entity │ │ │ ├── __init__.py │ │ │ └── livro.py │ │ ├── __init__.py │ │ └── repositorio_de_livros.py │ └── run.py ├── toDo │ └── run.py └── descritivo.txt ├── desafio7 ├── toDo │ └── run.py ├── Done │ ├── run.py │ └── calculator.py └── descritivo.txt ├── desafio2 ├── Done │ ├── model │ │ ├── __init__.py │ │ └── elevador.py │ ├── controller │ │ ├── __init__.py │ │ └── gerenciador_de_elevadores.py │ └── run.py ├── toDo │ └── run.py └── descritivo.txt ├── desafio1 ├── Done │ ├── components │ │ ├── __init__.py │ │ └── elevador.py │ └── run.py ├── toDo │ └── run.py └── descritivo.txt ├── desafio6 ├── toDo │ └── run.py ├── Done │ ├── destinatario.py │ ├── run.py │ └── gerenciador_de_email.py └── descritivo.txt └── desafio9 ├── Done ├── texto_secreto.py ├── run.py ├── gerenciador_de_login.py └── login.py ├── toDo └── run.py └── descritivo.txt /desafio5/Done/destinos/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /desafio8/Done/template/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /desafio5/Done/destinos/interface/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /desafio3/Done/model/__init__.py: -------------------------------------------------------------------------------- 1 | from .jogador import Jogador -------------------------------------------------------------------------------- /desafio4/Done/model/entity/__init__.py: -------------------------------------------------------------------------------- 1 | from .livro import Livro -------------------------------------------------------------------------------- /desafio7/toDo/run.py: -------------------------------------------------------------------------------- 1 | resultado = None 2 | print(resultado) 3 | -------------------------------------------------------------------------------- /desafio8/toDo/run.py: -------------------------------------------------------------------------------- 1 | resultado = None 2 | print(resultado) 3 | -------------------------------------------------------------------------------- /desafio2/Done/model/__init__.py: -------------------------------------------------------------------------------- 1 | from .elevador import Elevador 2 | -------------------------------------------------------------------------------- /desafio1/Done/components/__init__.py: -------------------------------------------------------------------------------- 1 | from .elevador import Elevador 2 | -------------------------------------------------------------------------------- /desafio3/toDo/run.py: -------------------------------------------------------------------------------- 1 | while (True): 2 | input() 3 | print() 4 | -------------------------------------------------------------------------------- /desafio4/Done/model/__init__.py: -------------------------------------------------------------------------------- 1 | from .repositorio_de_livros import RepositorioDeLivros -------------------------------------------------------------------------------- /desafio3/Done/controller/__init__.py: -------------------------------------------------------------------------------- 1 | from .gerenciador_de_jogo import GerenciadorDeJogo 2 | -------------------------------------------------------------------------------- /desafio2/Done/controller/__init__.py: -------------------------------------------------------------------------------- 1 | from .gerenciador_de_elevadores import GerenciadorDeElevadores -------------------------------------------------------------------------------- /desafio1/toDo/run.py: -------------------------------------------------------------------------------- 1 | while (True): 2 | andar = int(input('Defina um andar: ')) 3 | print() 4 | -------------------------------------------------------------------------------- /desafio7/Done/run.py: -------------------------------------------------------------------------------- 1 | from calculator import Calculator 2 | 3 | calc = Calculator() 4 | response = calc.calculate(1, 1) 5 | print(response) 6 | -------------------------------------------------------------------------------- /desafio6/toDo/run.py: -------------------------------------------------------------------------------- 1 | while True: 2 | assunto = input('Defina o Titulo do Email: ') 3 | mensagem = input('Defina o assunto: ') 4 | print() 5 | -------------------------------------------------------------------------------- /desafio5/toDo/run.py: -------------------------------------------------------------------------------- 1 | while (True): 2 | destino = None 3 | 4 | destino_da_viajem = input('Selecione o destino da viajem: ') 5 | 6 | print() 7 | -------------------------------------------------------------------------------- /desafio2/toDo/run.py: -------------------------------------------------------------------------------- 1 | while (True): 2 | elevadorId = int(input('Defina o elevador: ')) 3 | andar = int(input('Defina um andar: ')) 4 | 5 | print() 6 | -------------------------------------------------------------------------------- /desafio6/Done/destinatario.py: -------------------------------------------------------------------------------- 1 | class Destinatario: 2 | def __init__(self, nome, email) -> None: 3 | self.nome = nome 4 | self.email = email 5 | -------------------------------------------------------------------------------- /desafio9/Done/texto_secreto.py: -------------------------------------------------------------------------------- 1 | class TextoSecreto: 2 | def apresentar_texto(self): 3 | print('Ola, esse é meu texto secreto!') 4 | 5 | texto_secreto = TextoSecreto() 6 | -------------------------------------------------------------------------------- /desafio5/Done/destinos/niterio.py: -------------------------------------------------------------------------------- 1 | from .interface.destinos import DestinoInterface 2 | 3 | class Niteroi(DestinoInterface): 4 | 5 | def atividade(self): 6 | return 'Ir para praia' -------------------------------------------------------------------------------- /desafio5/Done/destinos/interface/destinos.py: -------------------------------------------------------------------------------- 1 | from abc import ABC, abstractmethod 2 | 3 | class DestinoInterface (ABC): 4 | 5 | @abstractmethod 6 | def atividade(self): 7 | pass 8 | -------------------------------------------------------------------------------- /desafio5/Done/destinos/fortaliza.py: -------------------------------------------------------------------------------- 1 | from .interface.destinos import DestinoInterface 2 | 3 | class Fortaleza(DestinoInterface): 4 | 5 | def atividade(self): 6 | return 'Ir para o Beach Park' -------------------------------------------------------------------------------- /desafio5/Done/destinos/belo_horizonte.py: -------------------------------------------------------------------------------- 1 | from .interface.destinos import DestinoInterface 2 | 3 | class BeloHorizonte(DestinoInterface): 4 | 5 | def atividade(self): 6 | return 'Visitar Inhotim' -------------------------------------------------------------------------------- /desafio9/toDo/run.py: -------------------------------------------------------------------------------- 1 | class TextoSecreto: 2 | def apresentar_texto(self): 3 | print('Ola, esse é meu texto secreto!') 4 | 5 | texto_secreto = TextoSecreto() 6 | texto_secreto.apresentar_texto 7 | -------------------------------------------------------------------------------- /desafio4/toDo/run.py: -------------------------------------------------------------------------------- 1 | while (True): 2 | escolha = input('1 - Cadastrar livro / 2 - listar livros: ') 3 | if (escolha == '1'): 4 | pass 5 | 6 | if (escolha == '2'): 7 | pass 8 | 9 | -------------------------------------------------------------------------------- /desafio1/Done/run.py: -------------------------------------------------------------------------------- 1 | from components import Elevador 2 | 3 | elevador = Elevador() 4 | 5 | while (True): 6 | andar = int(input('Defina um andar: ')) 7 | response = elevador.locomover(andar) 8 | print(response) 9 | print() 10 | -------------------------------------------------------------------------------- /desafio2/descritivo.txt: -------------------------------------------------------------------------------- 1 | Considerando o descritivo do desafio anterior, o edificio 2 | decidiu por implementar 2 elevadores e, desse modo, transportar 3 | mais moradores de forma mais independente. 4 | 5 | Descreva um programa para esse novo cenario 6 | -------------------------------------------------------------------------------- /desafio8/Done/run.py: -------------------------------------------------------------------------------- 1 | from calculators import Calculator1, Calculator2 2 | 3 | calc1 = Calculator1() 4 | response1 = calc1.calculate(1, 1) 5 | print(response1) 6 | 7 | calc2 = Calculator2() 8 | response2 = calc2.calculate(1, 1) 9 | print(response2) 10 | -------------------------------------------------------------------------------- /desafio4/Done/model/entity/livro.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | class Livro: 4 | def __init__(self, titulo, autor, ano) -> None: 5 | self.titulo = titulo 6 | self.autor = autor 7 | self.ano = ano 8 | self.id = random.randint(0, 1000000) -------------------------------------------------------------------------------- /desafio5/Done/planejador_de_viajem.py: -------------------------------------------------------------------------------- 1 | from typing import Type 2 | from destinos.interface.destinos import DestinoInterface 3 | 4 | class PlanejadorDeViajem: 5 | 6 | def viajar(self, destino: Type[DestinoInterface]): 7 | return destino.atividade() 8 | -------------------------------------------------------------------------------- /desafio9/descritivo.txt: -------------------------------------------------------------------------------- 1 | Uma classe TextoSecreto possui um texto que somente deve ser apresentado 2 | para usuarios cadastrados em certo sistema. Portanto, devemos ter um sistema 3 | de armazenamento de usuarios e que, de acordo com o login correto, possa apresentar 4 | a devida mensagem. 5 | 6 | Implemente tal sistema de login 7 | -------------------------------------------------------------------------------- /desafio3/Done/run.py: -------------------------------------------------------------------------------- 1 | from model import Jogador 2 | from controller import GerenciadorDeJogo 3 | 4 | jogador1 = Jogador('Joaozinho') 5 | jogador2 = Jogador('Pedrinho') 6 | gerenciadorDeJogo = GerenciadorDeJogo(jogador1, jogador2) 7 | 8 | while (True): 9 | input() 10 | resultado = gerenciadorDeJogo.apostarRodada() 11 | print(resultado) 12 | -------------------------------------------------------------------------------- /desafio4/descritivo.txt: -------------------------------------------------------------------------------- 1 | Uma Biblioteca deseja registrar todos os seus livros em um sistema. 2 | Cada livro deve ter os seguintes descritivos: 3 | - Titulo 4 | - Autor 5 | - Ano 6 | - Numero de identificação 7 | 8 | O sistem deve ser capaz apenas de inserir registros de livros 9 | e também lista-los quando desejado. 10 | 11 | Implemente tal sistema. 12 | -------------------------------------------------------------------------------- /desafio9/Done/run.py: -------------------------------------------------------------------------------- 1 | from login import login 2 | from texto_secreto import texto_secreto 3 | from gerenciador_de_login import GerenciadorDeLogin 4 | 5 | gerenciador_de_login = GerenciadorDeLogin(login, texto_secreto) 6 | usuario = 'rafael' 7 | senha = 'minhaSenha' 8 | 9 | login.adicionar_usuario(usuario, senha) 10 | 11 | gerenciador_de_login.logar_usuario(usuario, senha) 12 | 13 | -------------------------------------------------------------------------------- /desafio6/descritivo.txt: -------------------------------------------------------------------------------- 1 | Desejamos criar um novo sistema proprio para envio de emails de uma empresa 2 | Tal sistema tem, por padrão, o nome e o email da empresa já registrados. 3 | 4 | Tal sistema deve, através de interações com o usuario, definir um titulo do email e seu texto. 5 | Alem disso, deve ser possivel inserir vários destinatários para o envio de certo email. 6 | 7 | Desenvolva tal sistema 8 | -------------------------------------------------------------------------------- /desafio1/descritivo.txt: -------------------------------------------------------------------------------- 1 | Um edificio possui 15 andares, sendo 14 andares de moradia 2 | e o primeiro andar reservado para o térreo (descrito apenas como "1"). 3 | 4 | Para que os moradores transitem entre os andares, o edificio dispõe 5 | de um elevador instalado. O elevador não possui restrição de andar e 6 | pode transitar por qualquer andar a qualquer hora. 7 | 8 | Descreva um programa para utilização do elevador no edificio. -------------------------------------------------------------------------------- /desafio2/Done/model/elevador.py: -------------------------------------------------------------------------------- 1 | class Elevador: 2 | def __init__(self, id) -> None: 3 | self.__id = id 4 | self.__andar = 1 5 | 6 | def set_andar(self, andar): 7 | self.__andar = andar 8 | 9 | def get_andar(self): 10 | return self.__andar 11 | 12 | def check_id(self, id): 13 | return (self.__id == id) 14 | 15 | def get_id(self): 16 | return self.__id -------------------------------------------------------------------------------- /desafio3/descritivo.txt: -------------------------------------------------------------------------------- 1 | Dois amigos brincam de pedra, papel ou tesoura. 2 | 3 | Descreva um programa que simule algumas rodadas desse esse jogo. Alem disso, 4 | ao fim de cada rodada, apresente a contagem do placar de vitórias! 5 | 6 | obs: utilize a seguinte função abaixo para se executar uma escolha aleatória 7 | 8 | import random 9 | foo = ['a', 'b', 'c', 'd', 'e'] 10 | print(random.choice(foo)) // Algum valor aleatorio da lista foo -------------------------------------------------------------------------------- /desafio2/Done/run.py: -------------------------------------------------------------------------------- 1 | from model import Elevador 2 | from controller import GerenciadorDeElevadores 3 | 4 | gerenciadorDeElevadores = GerenciadorDeElevadores( 5 | Elevador(1), Elevador(2) 6 | ) 7 | 8 | while (True): 9 | elevadorId = int(input('Defina o elevador: ')) 10 | andar = int(input('Defina um andar: ')) 11 | 12 | response = gerenciadorDeElevadores.locomover(andar, elevadorId) 13 | print(response) 14 | print() 15 | -------------------------------------------------------------------------------- /desafio5/descritivo.txt: -------------------------------------------------------------------------------- 1 | Uma familia deseja realizar uma viajem mas está com certas duvidas sobre o destino. 2 | Para cada destino esperado, tem-se uma atividade para ser feita. 3 | A lista de desejo é apresentada abaixo: 4 | 5 | - Niteroi -> ir para a praia 6 | - Belo Horizonte -> Visitar Inhotim 7 | - Fortaliza -> Ir para o Beach Park 8 | 9 | Implemente um sistema para gerenciar essa viajem, ou seja: 10 | De acordo com a escolha do destino, realize a atividade desejada 11 | -------------------------------------------------------------------------------- /desafio3/Done/model/jogador.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | class Jogador: 4 | def __init__(self, name) -> None: 5 | self.__name = name 6 | self.__vitorias = 0 7 | self.__jogadas = ['pedra', 'papel', 'tesoura'] 8 | 9 | def fazer_jogada(self): 10 | return random.choice(self.__jogadas) 11 | 12 | def incrementar_vitorias(self): 13 | self.__vitorias += 1 14 | 15 | def apresentar_vitorias(self): 16 | return '{} : {} vitorias'.format(self.__name, self.__vitorias) 17 | -------------------------------------------------------------------------------- /desafio4/Done/run.py: -------------------------------------------------------------------------------- 1 | from model import RepositorioDeLivros 2 | 3 | repositorioDeLivros = RepositorioDeLivros() 4 | 5 | while (True): 6 | escolha = input('1 - Cadastrar livro / 2 - listar livros: ') 7 | if (escolha == '1'): 8 | titulo = input('Defina Titulo do Livro: ') 9 | autor = input('Defina Autor do Livro: ') 10 | ano = input('Defina Ano do Livro: ') 11 | repositorioDeLivros.registrar_livro(titulo, autor, ano) 12 | 13 | if (escolha == '2'): 14 | repositorioDeLivros.listar_livros() 15 | 16 | -------------------------------------------------------------------------------- /desafio7/descritivo.txt: -------------------------------------------------------------------------------- 1 | Uma calculadora recebe dois numeros para fazer seu calculo. 2 | 3 | O primeiro numero é multiplicado por 5 e dividido por 8. 4 | Em seguida, é retirada a raiz quadrada do resultado anterior e 5 | elevado ao cubo. 6 | 7 | O segundo numero é elevado ao quadrado e somado ao valor inicial. 8 | o resultado anterior é multiplicado por 2, dividido por 5 e somado a uma constante 9 | de 5.7 10 | 11 | Por fim, os resultados anteriores são somados e a soma é multiplicada por uma constante 12 | de 4.2 13 | 14 | Implemente essa calculadora 15 | -------------------------------------------------------------------------------- /desafio9/Done/gerenciador_de_login.py: -------------------------------------------------------------------------------- 1 | class GerenciadorDeLogin: 2 | def __init__(self, login, texto_secreto) -> None: 3 | self.__login = login 4 | self.__texto_secreto = texto_secreto 5 | 6 | def logar_usuario(self, usuario, senha): 7 | self.__checar_cadastro_de_usuario(usuario, senha) 8 | self.__texto_secreto.apresentar_texto() 9 | pass 10 | 11 | def __checar_cadastro_de_usuario(self, usuario, senha): 12 | cadastro = self.__login.logar_usuario(usuario, senha) 13 | if not cadastro: raise Exception() 14 | 15 | -------------------------------------------------------------------------------- /desafio9/Done/login.py: -------------------------------------------------------------------------------- 1 | class Login: 2 | def __init__(self) -> None: 3 | self.__usuarios = [] 4 | 5 | def adicionar_usuario(self, usuario, senha): 6 | cadastro = { "usuario": usuario, "senha": senha } 7 | self.__usuarios.append(cadastro) 8 | 9 | def logar_usuario(self, usuario, senha): 10 | cadastro = None 11 | 12 | for registro in self.__usuarios: 13 | if (registro["usuario"] == usuario and registro["senha"] == senha): 14 | cadastro = registro 15 | break 16 | 17 | return cadastro 18 | 19 | login = Login() 20 | -------------------------------------------------------------------------------- /desafio5/Done/run.py: -------------------------------------------------------------------------------- 1 | from planejador_de_viajem import PlanejadorDeViajem 2 | from destinos.belo_horizonte import BeloHorizonte 3 | from destinos.fortaliza import Fortaleza 4 | from destinos.niterio import Niteroi 5 | 6 | planejadorDeViajem = PlanejadorDeViajem() 7 | 8 | while (True): 9 | destino = None 10 | 11 | destino_da_viajem = input('Selecione o destino da viajem: ') 12 | if (destino_da_viajem == '1'): destino = Niteroi() 13 | elif (destino_da_viajem == '2'): destino = BeloHorizonte() 14 | elif (destino_da_viajem == '3'): destino = Fortaleza() 15 | 16 | atividade = planejadorDeViajem.viajar(destino) 17 | print(atividade) 18 | print() 19 | -------------------------------------------------------------------------------- /desafio8/descritivo.txt: -------------------------------------------------------------------------------- 1 | Considerando o resultado do desafio anterior, temos o seguinte caso: 2 | 3 | Agora, é de desejo termos 2 calculadoras. Ambas possuindo calculos similares entretanto a segunda calculadora 4 | se diferencia da primeira pelo calculo do segundo numero: 5 | 6 | O segundo numero é elevado ao cubo. Após isso, o resultado obtido é subtraido pelo valor inicial do segundo numero 7 | e multiplicado por dois. Por fim, o resultado é somado a outra constante de proporcionalidade de valor 1.2 8 | 9 | Vale ressaltar que os calculos da primeira calculadora se mantem os mesmos. 10 | 11 | Implemente essas duas calculadoras, entretanto tente utilizar o conceito de Herança de Classes e Métodos Abstratos 12 | -------------------------------------------------------------------------------- /desafio8/Done/calculators.py: -------------------------------------------------------------------------------- 1 | from template.calculator_template import CalculatorTemplate 2 | 3 | class Calculator1(CalculatorTemplate): 4 | def calculate_second_factor(self, arg2: int) -> float: 5 | num_1 = arg2 ** 2 6 | num_2 = (num_1 + arg2) * 2 7 | num_3 = num_2 / 5 8 | second_factor = num_3 + self._constant_1 9 | return second_factor 10 | 11 | class Calculator2(CalculatorTemplate): 12 | def __init__(self): 13 | super().__init__() 14 | self.__constant_3 = 1.2 15 | 16 | def calculate_second_factor(self, arg2: int) -> float: 17 | num_1 = arg2 ** 3 18 | num_2 = (num_1 - arg2) * 2 19 | second_factor = num_2 + self.__constant_3 20 | return second_factor -------------------------------------------------------------------------------- /desafio4/Done/model/repositorio_de_livros.py: -------------------------------------------------------------------------------- 1 | from .entity import Livro 2 | 3 | class RepositorioDeLivros: 4 | def __init__(self) -> None: 5 | self.__livros = [] 6 | 7 | def registrar_livro(self, titulo, autor, ano): 8 | livro = Livro(titulo, autor, ano) 9 | self.__livros.append(livro) 10 | print('Livro cadastrado!') 11 | print() 12 | 13 | def listar_livros(self): 14 | for livro in self.__livros: 15 | print( 16 | ''' 17 | id: {} 18 | Livro: {} 19 | Autor: {} 20 | Ano: {} 21 | ''' 22 | .format( 23 | livro.id, 24 | livro.titulo, 25 | livro.autor, 26 | livro.id 27 | ) 28 | ) 29 | print() -------------------------------------------------------------------------------- /desafio6/Done/run.py: -------------------------------------------------------------------------------- 1 | from gerenciador_de_email import GerenciadorDeEmail 2 | from destinatario import Destinatario 3 | 4 | gerenciadorDeEmail = GerenciadorDeEmail('Rafa Ferreira', 'rafa@email.com') 5 | 6 | while True: 7 | assunto = input('Defina o Titulo do Email: ') 8 | mensagem = input('Defina o assunto: ') 9 | print() 10 | 11 | gerenciadorDeEmail.criar_email(assunto, mensagem) 12 | 13 | command = 's' 14 | while command == 's': 15 | nome = input('Defina o nome do Destinatario: ') 16 | email = input('Defina o email do Destinatario: ') 17 | destinatario = Destinatario(nome, email) 18 | gerenciadorDeEmail.adicionar_destinatario(destinatario) 19 | print() 20 | 21 | command = input('Deseja adicionar outro destinatario ?: ') 22 | 23 | gerenciadorDeEmail.enviar_email() 24 | print() 25 | -------------------------------------------------------------------------------- /desafio1/Done/components/elevador.py: -------------------------------------------------------------------------------- 1 | class Elevador: 2 | def __init__(self) -> None: 3 | self.__andar = 1 4 | 5 | def locomover(self, andar): 6 | if (andar < 1 or andar > 15): return self.__mensagem_de_erro() 7 | else: return self.__alterar_andar_e_retornar_informacao(andar) 8 | 9 | def __alterar_andar_e_retornar_informacao(self, andar): 10 | self.__andar = andar 11 | if (andar == 1): return self.__mensagem_de_alteracao_para_terreo() 12 | return self.__mensagem_de_alteracao_de_andar() 13 | 14 | def __mensagem_de_erro(self): 15 | return 'Andar incorreto! Elevador no {}° andar'.format(self.__andar) 16 | 17 | def __mensagem_de_alteracao_de_andar(self): 18 | return 'Elevador indo para o {}° andar'.format(self.__andar) 19 | 20 | def __mensagem_de_alteracao_para_terreo(self): 21 | return 'Elevador indo para o terreo' 22 | -------------------------------------------------------------------------------- /desafio8/Done/template/calculator_template.py: -------------------------------------------------------------------------------- 1 | import math 2 | from abc import ABC, abstractmethod 3 | 4 | class CalculatorTemplate(ABC): 5 | 6 | def __init__(self) -> None: 7 | self._constant_1 = 5.7 8 | self._constant_2 = 4.2 9 | 10 | def calculate(self, arg1: int, arg2: int) -> float: 11 | first_factor = self.__calculate_first_factor(arg1) 12 | second_factor = self.calculate_second_factor(arg2) 13 | final_value = self.__calculate_final_value(first_factor, second_factor) 14 | return final_value 15 | 16 | def __calculate_first_factor(self, arg1: int) -> float: 17 | num_1 = (arg1 * 5)/8 18 | num_2 = math.sqrt(num_1) 19 | first_factor = num_2 ** 3 20 | return first_factor 21 | 22 | @abstractmethod 23 | def calculate_second_factor(self, arg2: int) -> float: 24 | pass 25 | 26 | def __calculate_final_value(self, first_factor: int, second_factor: int) -> float: 27 | final_value = (first_factor + second_factor) * self._constant_2 28 | return final_value 29 | -------------------------------------------------------------------------------- /desafio7/Done/calculator.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | class Calculator: 4 | 5 | def __init__(self) -> None: 6 | self.__constant_1 = 5.7 7 | self.__constant_2 = 4.2 8 | 9 | def calculate(self, arg1: int, arg2: int) -> float: 10 | first_factor = self.__calculate_first_factor(arg1) 11 | second_factor = self.__calculate_second_factor(arg2) 12 | final_value = self.__calculate_final_value(first_factor, second_factor) 13 | return final_value 14 | 15 | def __calculate_first_factor(self, arg1: int) -> float: 16 | num_1 = (arg1 * 5)/8 17 | num_2 = math.sqrt(num_1) 18 | first_factor = num_2 ** 3 19 | return first_factor 20 | 21 | def __calculate_second_factor(self, arg2: int) -> float: 22 | num_1 = arg2 ** 2 23 | num_2 = (num_1 + arg2) 24 | num_3 = (num_2 * 2) / 5 25 | second_factor = num_3 + self.__constant_1 26 | return second_factor 27 | 28 | def __calculate_final_value(self, first_factor: int, second_factor: int) -> float: 29 | final_value = (first_factor + second_factor) * self.__constant_2 30 | return final_value 31 | -------------------------------------------------------------------------------- /desafio6/Done/gerenciador_de_email.py: -------------------------------------------------------------------------------- 1 | class GerenciadorDeEmail: 2 | def __init__(self, nome_remetente, email_remetente) -> None: 3 | self.__nome_remetente = nome_remetente 4 | self.__email_remetente = email_remetente 5 | self.__assunto = None 6 | self.__mensagem = None 7 | self.__lista_destinatarios = [] 8 | 9 | def criar_email (self, assunto, mensagem): 10 | self.__assunto = assunto 11 | self.__mensagem = mensagem 12 | 13 | def adicionar_destinatario (self, destinatario): 14 | self.__lista_destinatarios.append(destinatario) 15 | 16 | def enviar_email (self): 17 | print( 18 | ''' 19 | Enviando mensagem: 20 | Remetente: {} 21 | Email: {} 22 | - {} 23 | : {} 24 | '''.format( 25 | self.__nome_remetente, 26 | self.__email_remetente, 27 | self.__assunto, 28 | self.__mensagem 29 | ) 30 | ) 31 | 32 | print('Destinatarios:') 33 | for destinatario in self.__lista_destinatarios: 34 | print(' {} - {}'.format(destinatario.nome, destinatario.email)) 35 | 36 | 37 | -------------------------------------------------------------------------------- /desafio3/Done/controller/gerenciador_de_jogo.py: -------------------------------------------------------------------------------- 1 | class GerenciadorDeJogo: 2 | def __init__(self, jogador1, jogador2) -> None: 3 | self.__jogador1 = jogador1 4 | self.__jogador2 = jogador2 5 | 6 | def apostarRodada(self): 7 | jogador1_jogada = self.__jogador1.fazer_jogada() 8 | jogador2_jogada = self.__jogador2.fazer_jogada() 9 | 10 | resultado_da_rodada = self.__verificar_jogadas(jogador1_jogada, jogador2_jogada) 11 | 12 | if (resultado_da_rodada == 1): self.__jogador1.incrementar_vitorias() 13 | if (resultado_da_rodada == 2): self.__jogador2.incrementar_vitorias() 14 | 15 | return self.__apresentar_resultados() 16 | 17 | def __verificar_jogadas(self, jogador1_jogada, jogador2_jogada): 18 | if (jogador1_jogada == jogador2_jogada): return 0 19 | if ( 20 | (jogador1_jogada == 'pedra' and jogador2_jogada == 'tesoura') 21 | or (jogador1_jogada == 'papel' and jogador2_jogada == 'pedra') 22 | or (jogador1_jogada == 'tesoura' and jogador2_jogada == 'papel') 23 | ): return 1 24 | else: return 2 25 | 26 | def __apresentar_resultados(self): 27 | return '{} --- {}'.format( 28 | self.__jogador1.apresentar_vitorias(), 29 | self.__jogador2.apresentar_vitorias() 30 | ) -------------------------------------------------------------------------------- /desafio2/Done/controller/gerenciador_de_elevadores.py: -------------------------------------------------------------------------------- 1 | class GerenciadorDeElevadores: 2 | def __init__(self, elevador1, elevador2) -> None: 3 | self.__elevadores = [elevador1, elevador2] 4 | 5 | def locomover(self, andar, id): 6 | if (andar < 1 or andar > 15): return self.__mensagem_de_erro() 7 | else: return self.__filtrar_elevador_e_alterar_andar(andar, id) 8 | 9 | def __filtrar_elevador_e_alterar_andar(self, andar, id): 10 | for elevador in self.__elevadores: 11 | if elevador.check_id(id): 12 | return self.__alterar_andar_e_retornar_informacao(andar, elevador) 13 | 14 | return self.__mensagem_de_erro_de_elevador() 15 | 16 | def __alterar_andar_e_retornar_informacao(self, andar, elevador): 17 | elevador.set_andar(andar) 18 | if (andar == 1): return self.__mensagem_de_alteracao_para_terreo(elevador) 19 | return self.__mensagem_de_alteracao_de_andar(elevador) 20 | 21 | def __mensagem_de_erro(self): 22 | return 'Andar incorreto!' 23 | 24 | def __mensagem_de_alteracao_de_andar(self, elevador): 25 | return 'Elevador {} indo para o {}° andar'.format(elevador.get_id(), elevador.get_andar()) 26 | 27 | def __mensagem_de_alteracao_para_terreo(self, elevador): 28 | return 'Elevador {} indo para o terreo'.format(elevador.get_id()) 29 | 30 | def __mensagem_de_erro_de_elevador(self): 31 | return 'Elevador nao existe' 32 | --------------------------------------------------------------------------------