diff --git a/exercicio_01.md b/exercicio_01.md
deleted file mode 100644
index af1b0fe..0000000
--- a/exercicio_01.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# Exercício 01 - Modelagem Básica de Entidades
-
-## Objetivo
-Praticar a criação de classes simples e inicialização de objetos.
-
-## Descrição do Exercício
-Crie duas classes: **Aluno** e **Disciplina**.
-
-### Requisitos:
-
-1. **Classe Aluno** deve ter atributos para:
-   - nome
-   - matricula
-   - curso
-
-2. **Classe Disciplina** deve ter atributos para:
-   - nome
-   - codigo
-   - carga_horaria
-
-3. Crie o método construtor (`__init__`) para cada classe.
-
-4. Instancie dois objetos de cada classe e imprima seus atributos.
-
-## Entrega
-Crie um arquivo chamado `respExercicio01.py` com a implementação das classes e a criação dos objetos solicitados.
-
-## Exemplo de Saída Esperada
-```
-Aluno: João Silva, Matrícula: 2023001, Curso: Engenharia de Software
-Aluno: Maria Santos, Matrícula: 2023002, Curso: Ciência da Computação
-Disciplina: Programação Orientada a Objetos, Código: POO001, Carga Horária: 60h
-Disciplina: Banco de Dados, Código: BD001, Carga Horária: 80h
-```
\ No newline at end of file
diff --git a/exercicio_01.py b/exercicio_01.py
new file mode 100644
index 0000000..fab04f1
--- /dev/null
+++ b/exercicio_01.py
@@ -0,0 +1,22 @@
+class Aluno:
+    def __init__(self, nome, matricula, curso):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+''
+class Disciplina:
+    def __init__(self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+aluno1 = Aluno("João Silva", "2023001", "Engenharia de Software")
+aluno2 = Aluno("Maria Santos", "2023002", "Ciência da Computação")
+
+disc1 = Disciplina("Programação Orientada a Objetos", "POO001", "60h")
+disc2 = Disciplina("Banco de Dados", "BD001", "80h")
+
+print(f"Aluno: {aluno1.nome}, Matrícula: {aluno1.matricula}, Curso: {aluno1.curso}")
+print(f"Aluno: {aluno2.nome}, Matrícula: {aluno2.matricula}, Curso: {aluno2.curso}")
+print(f"Disciplina: {disc1.nome}, Código: {disc1.codigo}, Carga Horária: {disc1.carga_horaria}")
+print(f"Disciplina: {disc2.nome}, Código: {disc2.codigo}, Carga Horária: {disc2.carga_horaria}")
\ No newline at end of file
diff --git a/exercicio_02.md b/exercicio_02.md
deleted file mode 100644
index 4d7f60b..0000000
--- a/exercicio_02.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# Exercício 02 - Adição de Comportamento (Métodos)
-
-## Objetivo
-Implementar métodos que alteram o estado de um objeto e métodos de consulta.
-
-## Descrição do Exercício
-Adicione à classe **Aluno** do exercício anterior os seguintes elementos:
-
-### Requisitos:
-
-1. Um atributo **notas** (uma lista de floats).
-
-2. Um método `adicionar_nota(nota)` que insere uma nota na lista.
-
-3. Um método `calcular_media()` que retorna a média das notas.
-
-4. Um método `status()` que imprime "Aprovado" se a média for >= 7.0 e "Reprovado" caso contrário.
-
-## Entrega
-Crie um arquivo chamado `respExercicio02.py` com a implementação da classe Aluno aprimorada.
-
-## Exemplo de Uso
-```python
-aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
-aluno.adicionar_nota(8.5)
-aluno.adicionar_nota(7.0)
-aluno.adicionar_nota(9.2)
-print(f"Média: {aluno.calcular_media()}")
-aluno.status()
-```
-
-## Exemplo de Saída Esperada
-```
-Média: 8.23
-Aprovado
-```
\ No newline at end of file
diff --git a/exercicio_02.py b/exercicio_02.py
new file mode 100644
index 0000000..5a7f398
--- /dev/null
+++ b/exercicio_02.py
@@ -0,0 +1,31 @@
+class Aluno:
+    def __init__(self, nome, matricula, curso):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = []
+
+    def adicionar_nota(self, nota):
+        self.notas.append(nota)
+
+    def calcular_media(self):
+        soma = sum(self.notas)
+        quantidade = len(self.notas)
+        if quantidade == 0:
+            return 0
+        return soma / quantidade
+
+    def status(self):
+        media = self.calcular_media()
+        if media >= 7.0:
+            print("Aprovado")
+        else:
+            print("Reprovado")
+
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+aluno.adicionar_nota(8.5)
+aluno.adicionar_nota(7.0)
+aluno.adicionar_nota(9.2)
+
+print(f"Média: {aluno.calcular_media():.2f}")
+aluno.status()
\ No newline at end of file
diff --git a/exercicio_03.md b/exercicio_03.md
deleted file mode 100644
index f9b21c6..0000000
--- a/exercicio_03.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# Exercício 03 - Encapsulamento e Propriedades
-
-## Objetivo
-Aplicar o princípio do Encapsulamento usando getters e setters (ou @property).
-
-## Descrição do Exercício
-Crie a classe **Professor** aplicando conceitos de encapsulamento.
-
-### Requisitos:
-
-1. O atributo **salario** deve ser privado (usando `_salario`).
-
-2. Implemente um método getter para salario (ou use `@property`).
-
-3. Implemente um método setter para salario que só permita a alteração se o novo valor for positivo. Caso contrário, imprima uma mensagem de erro e mantenha o valor anterior.
-
-4. Adicione outros atributos básicos como nome e departamento.
-
-## Entrega
-Crie um arquivo chamado `respExercicio03.py` com a implementação da classe Professor.
-
-## Exemplo de Uso
-```python
-prof = Professor("Dr. Silva", "Computação", 5000.0)
-print(f"Salário atual: R$ {prof.salario}")
-prof.salario = 6000.0  # Deve funcionar
-print(f"Novo salário: R$ {prof.salario}")
-prof.salario = -1000.0  # Deve dar erro
-print(f"Salário após tentativa inválida: R$ {prof.salario}")
-```
-
-## Exemplo de Saída Esperada
-```
-Salário atual: R$ 5000.0
-Novo salário: R$ 6000.0
-Erro: Salário deve ser um valor positivo!
-Salário após tentativa inválida: R$ 6000.0
-```
\ No newline at end of file
diff --git a/exercicio_03.py b/exercicio_03.py
new file mode 100644
index 0000000..a25974b
--- /dev/null
+++ b/exercicio_03.py
@@ -0,0 +1,25 @@
+class Professor:
+    def __init__(self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+
+    @property
+    def salario(self):
+        return self._salario
+
+    @salario.setter
+    def salario(self, valor):
+        if valor > 0:
+            self._salario = valor
+        else:
+            print("Erro: Salário deve ser um valor positivo!")
+
+prof = Professor("Dr. Silva", "Computação", 5000.0)
+print(f"Salário atual: R$ {prof.salario}")
+
+prof.salario = 6000.0
+print(f"Novo salário: R$ {prof.salario}")
+
+prof.salario = -1000.0
+print(f"Salário após tentativa inválida: R$ {prof.salario}")
\ No newline at end of file
diff --git a/exercicio_04.md b/exercicio_04.md
deleted file mode 100644
index 1088b47..0000000
--- a/exercicio_04.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# Exercício 04 - Herança Simples (Especialização)
-
-## Objetivo
-Usar Herança para criar classes especializadas.
-
-## Descrição do Exercício
-Implemente herança criando uma hierarquia de classes.
-
-### Requisitos:
-
-1. Crie uma classe base chamada **Pessoa** com atributos:
-   - nome
-   - cpf
-   - data_nascimento
-
-2. Adicione um método `apresentar()` na classe Pessoa que retorna uma apresentação básica.
-
-3. Crie duas classes filhas que herdam de Pessoa:
-   - **Funcionario**: deve adicionar o atributo `cargo`
-   - **Tutor**: deve adicionar o atributo `area_atuacao`
-
-4. A classe **Tutor** deve sobrescrever o método `apresentar()` para incluir sua área de atuação.
-
-## Entrega
-Crie um arquivo chamado `respExercicio04.py` com a implementação das classes com herança.
-
-## Exemplo de Uso
-```python
-funcionario = Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário")
-tutor = Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação")
-
-print(funcionario.apresentar())
-print(tutor.apresentar())
-```
-
-## Exemplo de Saída Esperada
-```
-Olá, sou João Silva, CPF: 123.456.789-00
-Olá, sou Maria Santos, CPF: 987.654.321-00, atuo na área de Programação
-```
\ No newline at end of file
diff --git a/exercicio_04.py b/exercicio_04.py
new file mode 100644
index 0000000..c5c2c07
--- /dev/null
+++ b/exercicio_04.py
@@ -0,0 +1,27 @@
+class Pessoa:
+    def __init__(self, nome, cpf, data_nascimento):
+        self.nome = nome
+        self.cpf = cpf
+        self.data_nascimento = data_nascimento
+
+    def apresentar(self):
+        return f"Olá, sou {self.nome}, CPF: {self.cpf}"
+
+class Funcionario(Pessoa):
+    def __init__(self, nome, cpf, data_nascimento, cargo):
+        super().__init__(nome, cpf, data_nascimento)
+        self.cargo = cargo
+
+class Tutor(Pessoa):
+    def __init__(self, nome, cpf, data_nascimento, area_atuacao):
+        super().__init__(nome, cpf, data_nascimento)
+        self.area_atuacao = area_atuacao
+
+    def apresentar(self):
+        return f"Olá, sou {self.nome}, CPF: {self.cpf}, atuo na área de {self.area_atuacao}"
+
+funcionario = Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário")
+tutor = Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação")
+
+print(funcionario.apresentar())
+print(tutor.apresentar())
\ No newline at end of file
diff --git a/exercicio_05.md b/exercicio_05.md
deleted file mode 100644
index 9165174..0000000
--- a/exercicio_05.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# Exercício 05 - Herança e o Uso de super()
-
-## Objetivo
-Entender e utilizar a função super() no construtor da classe filha.
-
-## Descrição do Exercício
-Aprimore a classe **Funcionario** do exercício 4 utilizando corretamente a função `super()`.
-
-### Requisitos:
-
-1. No construtor (`__init__`) de **Funcionario**, utilize `super().__init__(...)` para inicializar os atributos herdados de **Pessoa**.
-
-2. Adicione um atributo adicional `salario` à classe Funcionario.
-
-3. Crie um método `exibir_dados()` que mostre todos os dados do funcionário.
-
-4. Crie um objeto Funcionario e garanta que todos os atributos (herdados e próprios) foram inicializados corretamente.
-
-## Entrega
-Crie um arquivo chamado `respExercicio05.py` com a implementação aprimorada usando `super()`.
-
-## Exemplo de Uso
-```python
-funcionario = Funcionario("Ana Costa", "111.222.333-44", "20/03/1988", "Coordenadora", 4500.0)
-funcionario.exibir_dados()
-```
-
-## Exemplo de Saída Esperada
-```
-=== Dados do Funcionário ===
-Nome: Ana Costa
-CPF: 111.222.333-44
-Data de Nascimento: 20/03/1988
-Cargo: Coordenadora
-Salário: R$ 4500.0
-```
\ No newline at end of file
diff --git a/exercicio_05.py b/exercicio_05.py
new file mode 100644
index 0000000..ec7e92d
--- /dev/null
+++ b/exercicio_05.py
@@ -0,0 +1,22 @@
+class Pessoa:
+    def __init__(self, nome, cpf, data_nascimento):
+        self.nome = nome
+        self.cpf = cpf
+        self.data_nascimento = data_nascimento
+
+class Funcionario(Pessoa):
+    def __init__(self, nome, cpf, data_nascimento, cargo, salario):
+        super().__init__(nome, cpf, data_nascimento)
+        self.cargo = cargo
+        self.salario = salario
+
+    def exibir_dados(self):
+        print("=== Dados do Funcionário ===")
+        print(f"Nome: {self.nome}")
+        print(f"CPF: {self.cpf}")
+        print(f"Data de Nascimento: {self.data_nascimento}")
+        print(f"Cargo: {self.cargo}")
+        print(f"Salário: R$ {self.salario}")
+
+funcionario = Funcionario("Ana Costa", "111.222.333-44", "20/03/1988", "Coordenadora", 4500.0)
+funcionario.exibir_dados()
\ No newline at end of file
diff --git a/exercicio_06.md b/exercicio_06.md
deleted file mode 100644
index 4bad163..0000000
--- a/exercicio_06.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Exercício 06 - Composição (Relacionamento "Tem Um")
-
-## Objetivo
-Praticar o princípio da Composição, onde um objeto é feito de outros objetos.
-
-## Descrição do Exercício
-Crie a classe **Curso** que será composta por objetos **Disciplina**.
-
-### Requisitos:
-
-1. Crie a classe **Curso** com atributos:
-   - nome
-   - codigo
-   - disciplinas (lista de objetos Disciplina)
-
-2. Um **Curso** deve ser composto por uma lista de objetos **Disciplina** (do exercício 1).
-
-3. Adicione um método `adicionar_disciplina(disciplina)` à classe Curso.
-
-4. Adicione um método `listar_disciplinas()` que imprima o nome e código de cada disciplina.
-
-5. Adicione um método `carga_horaria_total()` que retorne a soma da carga horária de todas as disciplinas.
-
-## Entrega
-Crie um arquivo chamado `respExercicio06.py` com a implementação das classes e demonstração da composição.
-
-## Exemplo de Uso
-```python
-curso = Curso("Engenharia de Software", "ES001")
-disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60)
-disciplina2 = Disciplina("Banco de Dados", "BD001", 80)
-
-curso.adicionar_disciplina(disciplina1)
-curso.adicionar_disciplina(disciplina2)
-curso.listar_disciplinas()
-print(f"Carga horária total: {curso.carga_horaria_total()}h")
-```
-
-## Exemplo de Saída Esperada
-```
-=== Disciplinas do Curso: Engenharia de Software ===
-- Programação Orientada a Objetos (POO001)
-- Banco de Dados (BD001)
-Carga horária total: 140h
-```
\ No newline at end of file
diff --git a/exercicio_06.py b/exercicio_06.py
new file mode 100644
index 0000000..77b051f
--- /dev/null
+++ b/exercicio_06.py
@@ -0,0 +1,34 @@
+class Disciplina:
+    def __init__(self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+class Curso:
+    def __init__(self, nome, codigo):
+        self.nome = nome
+        self.codigo = codigo
+        self.disciplinas = []
+
+    def adicionar_disciplina(self, disciplina):
+        self.disciplinas.append(disciplina)
+
+    def listar_disciplinas(self):
+        print(f"=== Disciplinas do Curso: {self.nome} ===")
+        for disciplina in self.disciplinas:
+            print(f"- {disciplina.nome} ({disciplina.codigo})")
+
+    def carga_horaria_total(self):
+        total = 0
+        for disciplina in self.disciplinas:
+            total += disciplina.carga_horaria
+        return total
+
+curso = Curso("Engenharia de Software", "ES001")
+disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60)
+disciplina2 = Disciplina("Banco de Dados", "BD001", 80)
+
+curso.adicionar_disciplina(disciplina1)
+curso.adicionar_disciplina(disciplina2)
+curso.listar_disciplinas()
+print(f"Carga horária total: {curso.carga_horaria_total()}h")
\ No newline at end of file
diff --git a/exercicio_07.md b/exercicio_07.md
deleted file mode 100644
index 2a4aef0..0000000
--- a/exercicio_07.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# Exercício 07 - Agregação e Relacionamentos Muitos-Para-Muitos
-
-## Objetivo
-Modelar um relacionamento onde objetos existem independentemente, mas se referenciam mutuamente.
-
-## Descrição do Exercício
-Modifique as classes **Aluno** e **Disciplina** para implementar um relacionamento muitos-para-muitos.
-
-### Requisitos:
-
-1. **Aluno** deve ter um atributo `disciplinas_inscritas` (uma lista de objetos Disciplina).
-
-2. **Disciplina** deve ter um atributo `alunos_matriculados` (uma lista de objetos Aluno).
-
-3. Crie uma classe **Secretaria** com um método estático `inscrever_aluno(aluno, disciplina)` que:
-   - Adicione o aluno na lista de alunos matriculados da disciplina
-   - Adicione a disciplina na lista de disciplinas inscritas do aluno
-
-4. Adicione métodos para listar as disciplinas de um aluno e os alunos de uma disciplina.
-
-## Entrega
-Crie um arquivo chamado `respExercicio07.py` com a implementação do relacionamento muitos-para-muitos.
-
-## Exemplo de Uso
-```python
-aluno1 = Aluno("João Silva", "2023001", "Engenharia de Software")
-aluno2 = Aluno("Maria Santos", "2023002", "Ciência da Computação")
-disciplina1 = Disciplina("POO", "POO001", 60)
-disciplina2 = Disciplina("Banco de Dados", "BD001", 80)
-
-Secretaria.inscrever_aluno(aluno1, disciplina1)
-Secretaria.inscrever_aluno(aluno1, disciplina2)
-Secretaria.inscrever_aluno(aluno2, disciplina1)
-
-aluno1.listar_disciplinas()
-disciplina1.listar_alunos()
-```
\ No newline at end of file
diff --git a/exercicio_07.py b/exercicio_07.py
new file mode 100644
index 0000000..42dd515
--- /dev/null
+++ b/exercicio_07.py
@@ -0,0 +1,41 @@
+class Aluno:
+    def __init__(self, nome, matricula, curso):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.disciplinas_inscritas = []
+
+    def listar_disciplinas(self):
+        print(f"Disciplinas de {self.nome}:")
+        for disciplina in self.disciplinas_inscritas:
+            print(f"- {disciplina.nome}")
+
+class Disciplina:
+    def __init__(self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+        self.alunos_matriculados = []
+
+    def listar_alunos(self):
+        print(f"Alunos em {self.nome}:")
+        for aluno in self.alunos_matriculados:
+            print(f"- {aluno.nome}")
+
+class Secretaria:
+    @staticmethod
+    def inscrever_aluno(aluno, disciplina):
+        aluno.disciplinas_inscritas.append(disciplina)
+        disciplina.alunos_matriculados.append(aluno)
+
+aluno1 = Aluno("João Silva", "2023001", "Engenharia de Software")
+aluno2 = Aluno("Maria Santos", "2023002", "Ciência da Computação")
+disciplina1 = Disciplina("POO", "POO001", 60)
+disciplina2 = Disciplina("Banco de Dados", "BD001", 80)
+
+Secretaria.inscrever_aluno(aluno1, disciplina1)
+Secretaria.inscrever_aluno(aluno1, disciplina2)
+Secretaria.inscrever_aluno(aluno2, disciplina1)
+
+aluno1.listar_disciplinas()
+disciplina1.listar_alunos()
\ No newline at end of file
diff --git a/exercicio_08.md b/exercicio_08.md
deleted file mode 100644
index bbd7d0d..0000000
--- a/exercicio_08.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# Exercício 08 - Método de Classe (@classmethod)
-
-## Objetivo
-Entender o uso de métodos de classe para criar fábricas de objetos.
-
-## Descrição do Exercício
-Crie a classe **Departamento** com métodos de classe para facilitar a criação de objetos.
-
-### Requisitos:
-
-1. Crie a classe **Departamento** com atributos:
-   - nome
-   - sigla
-   - professores (lista de professores)
-
-2. Implemente um método de classe `@classmethod` chamado `criar_departamento_exatas(nome)` que automaticamente atribui a sigla como "EXA".
-
-3. Implemente um método de classe `@classmethod` chamado `criar_departamento_humanas(nome)` que automaticamente atribui a sigla como "HUM".
-
-4. Adicione um método `adicionar_professor(professor)` e `listar_professores()`.
-
-5. Use esses métodos para criar dois departamentos distintos.
-
-## Entrega
-Crie um arquivo chamado `respExercicio08.py` com a implementação dos métodos de classe.
-
-## Exemplo de Uso
-```python
-dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação")
-dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia")
-
-print(f"Departamento: {dept_exatas.nome} - Sigla: {dept_exatas.sigla}")
-print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}")
-```
-
-## Exemplo de Saída Esperada
-```
-Departamento: Matemática e Computação - Sigla: EXA
-Departamento: Letras e Filosofia - Sigla: HUM
-```
\ No newline at end of file
diff --git a/exercicio_08.py b/exercicio_08.py
new file mode 100644
index 0000000..f3de068
--- /dev/null
+++ b/exercicio_08.py
@@ -0,0 +1,26 @@
+class Departamento:
+    def __init__(self, nome, sigla):
+        self.nome = nome
+        self.sigla = sigla
+        self.professores = []
+
+    @classmethod
+    def criar_departamento_exatas(cls, nome):
+        return cls(nome, "EXA")
+
+    @classmethod
+    def criar_departamento_humanas(cls, nome):
+        return cls(nome, "HUM")
+
+    def adicionar_professor(self, professor):
+        self.professores.append(professor)
+
+    def listar_professores(self):
+        for prof in self.professores:
+            print(prof)
+
+dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação")
+dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia")
+
+print(f"Departamento: {dept_exatas.nome} - Sigla: {dept_exatas.sigla}")
+print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}")
\ No newline at end of file
diff --git a/exercicio_09.md b/exercicio_09.md
deleted file mode 100644
index ef76271..0000000
--- a/exercicio_09.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Exercício 09 - Polimorfismo (Diferentes Formas)
-
-## Objetivo
-Demonstrar como diferentes objetos respondem de maneiras únicas ao mesmo método.
-
-## Descrição do Exercício
-Implemente polimorfismo através do método `apresentar()` em diferentes classes.
-
-### Requisitos:
-
-1. Certifique-se de que as classes **Aluno**, **Professor** e **Funcionario** possuem o método `apresentar()`.
-
-2. Cada classe deve implementar o método de forma específica:
-   - **Aluno**: deve dizer "Olá, sou o aluno [nome] e estudo no curso [curso]."
-   - **Professor**: deve dizer "Olá, sou o professor [nome] e leciono no departamento [departamento]."
-   - **Funcionario**: deve dizer "Olá, sou o funcionário [nome] e meu cargo é [cargo]."
-
-3. Crie uma lista contendo objetos de Aluno, Professor e Funcionario.
-
-4. Percorra a lista e chame o método `apresentar()` para cada objeto, demonstrando polimorfismo.
-
-## Entrega
-Crie um arquivo chamado `respExercicio09.py` com a implementação do polimorfismo.
-
-## Exemplo de Uso
-```python
-pessoas = [
-    Aluno("João Silva", "2023001", "Engenharia de Software"),
-    Professor("Dr. Maria", "Computação", 8000.0),
-    Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 3000.0)
-]
-
-for pessoa in pessoas:
-    print(pessoa.apresentar())
-```
-
-## Exemplo de Saída Esperada
-```
-Olá, sou o aluno João Silva e estudo no curso Engenharia de Software.
-Olá, sou o professor Dr. Maria e leciono no departamento Computação.
-Olá, sou o funcionário Carlos Santos e meu cargo é Secretário.
-```
\ No newline at end of file
diff --git a/exercicio_09.py b/exercicio_09.py
new file mode 100644
index 0000000..439bc94
--- /dev/null
+++ b/exercicio_09.py
@@ -0,0 +1,37 @@
+class Aluno:
+    def __init__(self, nome, matricula, curso):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+
+    def apresentar(self):
+        return f"Olá, sou o aluno {self.nome} e estudo no curso {self.curso}."
+
+class Professor:
+    def __init__(self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self.salario = salario
+
+    def apresentar(self):
+        return f"Olá, sou o professor {self.nome} e leciono no departamento {self.departamento}."
+
+class Funcionario:
+    def __init__(self, nome, cpf, data_nascimento, cargo, salario):
+        self.nome = nome
+        self.cpf = cpf
+        self.data_nascimento = data_nascimento
+        self.cargo = cargo
+        self.salario = salario
+
+    def apresentar(self):
+        return f"Olá, sou o funcionário {self.nome} e meu cargo é {self.cargo}."
+
+pessoas = [
+    Aluno("João Silva", "2023001", "Engenharia de Software"),
+    Professor("Dr. Maria", "Computação", 8000.0),
+    Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 3000.0)
+]
+
+for pessoa in pessoas:
+    print(pessoa.apresentar())
\ No newline at end of file
diff --git a/exercicio_10.md b/exercicio_10.md
deleted file mode 100644
index 7ce0e88..0000000
--- a/exercicio_10.md
+++ /dev/null
@@ -1,77 +0,0 @@
-# Exercício 10 - Jogo dos 7 Erros de POO em Python: A Modelagem Quebrada
-
-## Objetivo
-Identificar e corrigir falhas comuns de design e implementação em POO (Encapsulamento, Herança, Construtores).
-
-## Descrição do Exercício
-O código abaixo contém **7 erros** relacionados aos conceitos de Programação Orientada a Objetos. Sua tarefa é identificar todos os erros e corrigi-los.
-
-## Código com Erros
-
-```python
-class pessoa:  # Erro 1
-    def __init__(self, nome, idade):
-        nome = nome  # Erro 2
-        self.idade = idade
-        self.__cpf = None  # Erro 3
-    
-    def apresentar():  # Erro 4
-        return f"Olá, sou {self.nome}"
-
-class Estudante(pessoa):
-    def __init__(self, nome, idade, curso):
-        self.nome = nome  # Erro 5
-        self.idade = idade
-        self.curso = curso
-        self.notas = []
-    
-    def adicionar_nota(self, nota):
-        if nota >= 0 and nota <= 10:
-            self.notas.append(nota)
-    
-    def calcular_media(self):
-        return sum(self.notas) / len(self.notas)  # Erro 6
-
-class Professor(pessoa):
-    def __init__(self, nome, idade, departamento, salario):
-        super().__init__(nome, idade)
-        self.departamento = departamento
-        self.salario = salario
-    
-    def apresentar(self):
-        return f"Olá, sou o professor {self.nome} do departamento {self.departamento}"
-
-# Testando o código
-estudante = Estudante("João", 20, "Engenharia")
-professor = Professor("Dr. Silva", 45, "Computação", 8000)
-
-print(estudante.apresentar())
-print(professor.apresentar())
-print(f"Média do estudante: {estudante.calcular_media()}")  # Erro 7
-```
-
-## Tarefa
-1. **Identifique os 7 erros** no código acima
-2. **Corrija todos os erros** 
-3. **Teste o código corrigido** para garantir que funciona
-
-## Entrega
-Crie dois arquivos:
-1. `Resposta_10.py` - com o código corrigido
-2. `Resposta_10.md` - com um relatório dos erros encontrados e suas respectivas soluções
-
-## Formato do Relatório
-Para cada erro encontrado, descreva:
-- **Erro X**: Descrição do problema
-- **Solução**: Como foi corrigido
-- **Conceito POO**: Qual princípio de POO estava sendo violado
-
-## Dica
-Os erros envolvem:
-- Convenções de nomenclatura
-- Inicialização de atributos
-- Encapsulamento
-- Definição de métodos
-- Herança e uso de super()
-- Tratamento de exceções
-- Lógica de negócio
\ No newline at end of file
diff --git a/exercicio_10.py b/exercicio_10.py
new file mode 100644
index 0000000..aed5fe5
--- /dev/null
+++ b/exercicio_10.py
@@ -0,0 +1,44 @@
+class Pessoa:
+    def __init__(self, nome, idade):
+        self.nome = nome
+        self.idade = idade
+        self.cpf = None
+
+    def apresentar(self):
+        return f"Olá, sou {self.nome}"
+
+class Estudante(Pessoa):
+    def __init__(self, nome, idade, curso):
+        super().__init__(nome, idade)
+        self.curso = curso
+        self.notas = []
+
+    def adicionar_nota(self, nota):
+        if 0 <= nota <= 10:
+            self.notas.append(nota)
+
+    def calcular_media(self):
+        if not self.notas:
+            return 0
+        return sum(self.notas) / len(self.notas)
+
+class Professor(Pessoa):
+    def __init__(self, nome, idade, departamento, salario):
+        super().__init__(nome, idade)
+        self.departamento = departamento
+        self.salario = salario
+
+    def apresentar(self):
+        return f"Olá, sou o professor {self.nome} do departamento {self.departamento}"
+
+# --- Testes ---
+
+estudante = Estudante("João", 20, "Engenharia")
+professor = Professor("Dr. Silva", 45, "Computação", 8000)
+
+estudante.adicionar_nota(8.0)
+estudante.adicionar_nota(9.0)
+
+print(estudante.apresentar())
+print(professor.apresentar())
+print(f"Média do estudante: {estudante.calcular_media()}")
\ No newline at end of file
diff --git a/exercicio_11.md b/exercicio_11.md
deleted file mode 100644
index 0c649e5..0000000
--- a/exercicio_11.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# Exercício 11 - Princípio da Responsabilidade Única (SRP)
-
-## Objetivo
-Aplicar o primeiro princípio SOLID - Single Responsibility Principle (SRP).
-
-## Descrição do Exercício
-Refatore uma classe que viola o SRP, separando suas responsabilidades em classes distintas.
-
-### Código Problemático:
-```python
-class Funcionario:
-    def __init__(self, nome, salario, cargo):
-        self.nome = nome
-        self.salario = salario
-        self.cargo = cargo
-    
-    def calcular_salario_liquido(self, descontos):
-        return self.salario - descontos
-    
-    def gerar_relatorio(self):
-        return f"Relatório: {self.nome} - {self.cargo} - R$ {self.salario}"
-    
-    def salvar_no_banco(self):
-        print(f"Salvando {self.nome} no banco de dados...")
-```
-
-### Requisitos:
-
-1. **Identifique as responsabilidades** da classe Funcionario (dados, cálculos, relatórios, persistência).
-
-2. **Crie classes separadas** para cada responsabilidade:
-   - **Funcionario**: apenas dados do funcionário
-   - **CalculadoraSalario**: cálculos relacionados a salário
-   - **GeradorRelatorio**: geração de relatórios
-   - **RepositorioFuncionario**: persistência de dados
-
-3. **Implemente as classes** seguindo o SRP.
-
-4. **Demonstre o uso** das classes refatoradas.
-
-## Entrega
-Crie um arquivo chamado `respExercicio11.py` com a implementação refatorada seguindo o SRP.
-
-## Exemplo de Uso
-```python
-funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora")
-calculadora = CalculadoraSalario()
-gerador = GeradorRelatorio()
-repositorio = RepositorioFuncionario()
-
-salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0)
-relatorio = gerador.gerar_relatorio(funcionario)
-repositorio.salvar(funcionario)
-```
\ No newline at end of file
diff --git a/exercicio_11.py b/exercicio_11.py
new file mode 100644
index 0000000..74f8eb7
--- /dev/null
+++ b/exercicio_11.py
@@ -0,0 +1,29 @@
+class Funcionario:
+    def __init__(self, nome, salario, cargo):
+        self.nome = nome
+        self.salario = salario
+        self.cargo = cargo
+
+class CalculadoraSalario:
+    def calcular_salario_liquido(self, funcionario, descontos):
+        return funcionario.salario - descontos
+
+class GeradorRelatorio:
+    def gerar_relatorio(self, funcionario):
+        return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario}"
+
+class RepositorioFuncionario:
+    def salvar(self, funcionario):
+        print(f"Salvando {funcionario.nome} no banco de dados...")
+
+funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora")
+calculadora = CalculadoraSalario()
+gerador = GeradorRelatorio()
+repositorio = RepositorioFuncionario()
+
+salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0)
+relatorio = gerador.gerar_relatorio(funcionario)
+
+print(f"Salário Líquido: {salario_liquido}")
+print(relatorio)
+repositorio.salvar(funcionario)
\ No newline at end of file
diff --git a/exercicio_12.md b/exercicio_12.md
deleted file mode 100644
index 458d300..0000000
--- a/exercicio_12.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Exercício 12 - Princípio Aberto/Fechado (OCP)
-
-## Objetivo
-Aplicar o segundo princípio SOLID - Open/Closed Principle (OCP).
-
-## Descrição do Exercício
-Implemente um sistema de cálculo de descontos que seja aberto para extensão mas fechado para modificação.
-
-### Requisitos:
-
-1. **Crie uma classe abstrata** `CalculadorDesconto` com método abstrato `calcular(valor)`.
-
-2. **Implemente diferentes tipos de desconto**:
-   - **DescontoEstudante**: 10% de desconto
-   - **DescontoFuncionario**: 15% de desconto
-   - **DescontoVIP**: 20% de desconto
-
-3. **Crie a classe** `ProcessadorPagamento` que aceita qualquer calculadora de desconto.
-
-4. **Demonstre** como adicionar um novo tipo de desconto sem modificar código existente.
-
-## Entrega
-Crie um arquivo chamado `respExercicio12.py` com a implementação seguindo o OCP.
-
-## Exemplo de Uso
-```python
-from abc import ABC, abstractmethod
-
-# Uso do sistema
-pagamento = ProcessadorPagamento()
-valor_original = 1000.0
-
-# Diferentes tipos de desconto
-desconto_estudante = DescontoEstudante()
-desconto_funcionario = DescontoFuncionario()
-
-valor_final1 = pagamento.processar(valor_original, desconto_estudante)
-valor_final2 = pagamento.processar(valor_original, desconto_funcionario)
-
-print(f"Estudante: R$ {valor_final1}")
-print(f"Funcionário: R$ {valor_final2}")
-```
-
-## Exemplo de Saída Esperada
-```
-Estudante: R$ 900.0
-Funcionário: R$ 850.0
-```
\ No newline at end of file
diff --git a/exercicio_12.py b/exercicio_12.py
new file mode 100644
index 0000000..db70caa
--- /dev/null
+++ b/exercicio_12.py
@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+
+class CalculadorDesconto(ABC):
+    @abstractmethod
+    def calcular(self, valor):
+        pass
+
+class DescontoEstudante(CalculadorDesconto):
+    def calcular(self, valor):
+        return valor * 0.90
+
+class DescontoFuncionario(CalculadorDesconto):
+    def calcular(self, valor):
+        return valor * 0.85
+
+class DescontoVIP(CalculadorDesconto):
+    def calcular(self, valor):
+        return valor * 0.80
+
+class ProcessadorPagamento:
+    def processar(self, valor, calculador_desconto):
+        return calculador_desconto.calcular(valor)
+
+pagamento = ProcessadorPagamento()
+valor_original = 1000.0
+
+desconto_estudante = DescontoEstudante()
+desconto_funcionario = DescontoFuncionario()
+
+valor_final1 = pagamento.processar(valor_original, desconto_estudante)
+valor_final2 = pagamento.processar(valor_original, desconto_funcionario)
+
+print(f"Estudante: R$ {valor_final1}")
+print(f"Funcionário: R$ {valor_final2}")
\ No newline at end of file
diff --git a/exercicio_13.md b/exercicio_13.md
deleted file mode 100644
index e53cf02..0000000
--- a/exercicio_13.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# Exercício 13 - Princípio da Substituição de Liskov (LSP)
-
-## Objetivo
-Aplicar o terceiro princípio SOLID - Liskov Substitution Principle (LSP).
-
-## Descrição do Exercício
-Implemente uma hierarquia de classes que respeite o LSP, onde objetos de classes derivadas possam substituir objetos da classe base sem quebrar a funcionalidade.
-
-### Requisitos:
-
-1. **Crie a classe base** `Veiculo` com métodos:
-   - `acelerar()`: aumenta velocidade
-   - `frear()`: diminui velocidade
-   - `get_velocidade()`: retorna velocidade atual
-
-2. **Implemente classes derivadas**:
-   - **Carro**: velocidade máxima 180 km/h
-   - **Bicicleta**: velocidade máxima 50 km/h
-   - **Aviao**: velocidade máxima 900 km/h
-
-3. **Crie a classe** `ControladorTrafego` que funciona com qualquer veículo.
-
-4. **Garanta** que todas as subclasses mantêm o comportamento esperado da classe base.
-
-## Entrega
-Crie um arquivo chamado `respExercicio13.py` com a implementação seguindo o LSP.
-
-## Exemplo de Uso
-```python
-def testar_veiculo(veiculo):
-    print(f"Testando {type(veiculo).__name__}")
-    veiculo.acelerar()
-    veiculo.acelerar()
-    print(f"Velocidade: {veiculo.get_velocidade()} km/h")
-    veiculo.frear()
-    print(f"Velocidade após frear: {veiculo.get_velocidade()} km/h")
-
-# Todos os veículos devem funcionar da mesma forma
-carro = Carro()
-bicicleta = Bicicleta()
-aviao = Aviao()
-
-testar_veiculo(carro)
-testar_veiculo(bicicleta)
-testar_veiculo(aviao)
-```
-
-## Exemplo de Saída Esperada
-```
-Testando Carro
-Velocidade: 40 km/h
-Velocidade após frear: 20 km/h
-Testando Bicicleta
-Velocidade: 20 km/h
-Velocidade após frear: 10 km/h
-```
\ No newline at end of file
diff --git a/exercicio_13.py b/exercicio_13.py
new file mode 100644
index 0000000..2b02acb
--- /dev/null
+++ b/exercicio_13.py
@@ -0,0 +1,45 @@
+class Veiculo:
+    def __init__(self):
+        self._velocidade = 0
+
+    def acelerar(self):
+        self._velocidade += 10
+
+    def frear(self):
+        self._velocidade -= 10
+        if self._velocidade < 0:
+            self._velocidade = 0
+
+    def get_velocidade(self):
+        return self._velocidade
+
+class Carro(Veiculo):
+    def acelerar(self):
+        if self._velocidade < 180:
+            self._velocidade += 20
+
+class Bicicleta(Veiculo):
+    def acelerar(self):
+        if self._velocidade < 50:
+            self._velocidade += 5
+
+class Aviao(Veiculo):
+    def acelerar(self):
+        if self._velocidade < 900:
+            self._velocidade += 50
+
+def testar_veiculo(veiculo):
+    print(f"Testando {type(veiculo).__name__}")
+    veiculo.acelerar()
+    veiculo.acelerar()
+    print(f"Velocidade: {veiculo.get_velocidade()} km/h")
+    veiculo.frear()
+    print(f"Velocidade após frear: {veiculo.get_velocidade()} km/h")
+
+carro = Carro()
+bicicleta = Bicicleta()
+aviao = Aviao()
+
+testar_veiculo(carro)
+testar_veiculo(bicicleta)
+testar_veiculo(aviao)
\ No newline at end of file
diff --git a/exercicio_14.md b/exercicio_14.md
deleted file mode 100644
index 800cd45..0000000
--- a/exercicio_14.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# Exercício 14 - Princípio da Segregação de Interface (ISP)
-
-## Objetivo
-Aplicar o quarto princípio SOLID - Interface Segregation Principle (ISP).
-
-## Descrição do Exercício
-Refatore interfaces "gordas" em interfaces menores e mais específicas.
-
-### Código Problemático:
-```python
-class Trabalhador:
-    def trabalhar(self):
-        pass
-    
-    def comer(self):
-        pass
-    
-    def dormir(self):
-        pass
-    
-    def programar(self):
-        pass
-```
-
-### Requisitos:
-
-1. **Identifique o problema** da interface atual (nem todos os trabalhadores programam).
-
-2. **Crie interfaces específicas**:
-   - **Trabalhavel**: método `trabalhar()`
-   - **Alimentavel**: método `comer()`
-   - **Descansavel**: método `dormir()`
-   - **Programavel**: método `programar()`
-
-3. **Implemente classes concretas**:
-   - **Desenvolvedor**: implementa todas as interfaces
-   - **Gerente**: implementa Trabalhavel, Alimentavel, Descansavel
-   - **Robo**: implementa apenas Trabalhavel e Programavel
-
-4. **Demonstre** como cada classe implementa apenas as interfaces necessárias.
-
-## Entrega
-Crie um arquivo chamado `respExercicio14.py` com a implementação seguindo o ISP.
-
-## Exemplo de Uso
-```python
-from abc import ABC, abstractmethod
-
-desenvolvedor = Desenvolvedor("Ana")
-gerente = Gerente("Carlos")
-robo = Robo("R2D2")
-
-# Desenvolvedor faz tudo
-desenvolvedor.trabalhar()
-desenvolvedor.comer()
-desenvolvedor.programar()
-
-# Gerente não programa
-gerente.trabalhar()
-gerente.comer()
-
-# Robô não come nem dorme
-robo.trabalhar()
-robo.programar()
-```
\ No newline at end of file
diff --git a/exercicio_14.py b/exercicio_14.py
new file mode 100644
index 0000000..eee0b18
--- /dev/null
+++ b/exercicio_14.py
@@ -0,0 +1,43 @@
+#não sei se está certo
+
+from abc import ABC, abstractmethod
+
+class Trabalhavel(ABC):
+    @abstractmethod
+    def trabalhar(self):
+        pass
+
+class Alimentavel(ABC):
+    @abstractmethod
+    def comer(self):
+        pass
+
+class Descansavel(ABC):
+    @abstractmethod
+    def dormir(self):
+        pass
+
+class Programavel(ABC):
+    @abstractmethod
+    def programar(self):
+        pass
+
+class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel):
+    def trabalhar(self):
+        print("Codando...")
+
+    def comer(self):
+        print("Almoçando...")
+
+    def dormir(self):
+        print("Dormindo...")
+
+    def programar(self):
+        print("Escrevendo testes...")
+
+class Robo(Trabalhavel, Programavel):
+    def trabalhar(self):
+        print("Montando peças...")
+
+    def programar(self):
+        print("Auto-atualizando firmware...")
\ No newline at end of file
diff --git a/exercicio_15.md b/exercicio_15.md
deleted file mode 100644
index 64a688e..0000000
--- a/exercicio_15.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# Exercício 15 - Princípio da Inversão de Dependência (DIP)
-
-## Objetivo
-Aplicar o quinto princípio SOLID - Dependency Inversion Principle (DIP).
-
-## Descrição do Exercício
-Refatore código que depende de implementações concretas para depender de abstrações.
-
-### Código Problemático:
-```python
-class EmailService:
-    def enviar(self, mensagem):
-        print(f"Enviando email: {mensagem}")
-
-class NotificacaoService:
-    def __init__(self):
-        self.email_service = EmailService()  # Dependência concreta
-    
-    def notificar(self, mensagem):
-        self.email_service.enviar(mensagem)
-```
-
-### Requisitos:
-
-1. **Crie uma abstração** `ServicoNotificacao` com método `enviar(mensagem)`.
-
-2. **Implemente diferentes serviços**:
-   - **EmailService**: envia por email
-   - **SMSService**: envia por SMS
-   - **PushService**: envia notificação push
-
-3. **Refatore** `NotificacaoService` para depender da abstração.
-
-4. **Implemente injeção de dependência** no construtor.
-
-5. **Demonstre** como trocar implementações sem modificar o código cliente.
-
-## Entrega
-Crie um arquivo chamado `respExercicio15.py` com a implementação seguindo o DIP.
-
-## Exemplo de Uso
-```python
-# Diferentes implementações podem ser injetadas
-email_service = EmailService()
-sms_service = SMSService()
-push_service = PushService()
-
-# Mesmo código cliente funciona com qualquer implementação
-notificador1 = NotificacaoService(email_service)
-notificador2 = NotificacaoService(sms_service)
-notificador3 = NotificacaoService(push_service)
-
-mensagem = "Bem-vindo ao sistema!"
-notificador1.notificar(mensagem)
-notificador2.notificar(mensagem)
-notificador3.notificar(mensagem)
-```
-
-## Exemplo de Saída Esperada
-```
-Enviando email: Bem-vindo ao sistema!
-Enviando SMS: Bem-vindo ao sistema!
-Enviando push: Bem-vindo ao sistema!
-```
\ No newline at end of file
diff --git a/exercicio_15.py b/exercicio_15.py
new file mode 100644
index 0000000..e0ec6ab
--- /dev/null
+++ b/exercicio_15.py
@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+
+class ServicoNotificacao(ABC):
+    @abstractmethod
+    def enviar(self, mensagem):
+        pass
+
+class EmailService(ServicoNotificacao):
+    def enviar(self, mensagem):
+        print(f"Enviando email: {mensagem}")
+
+class SMSService(ServicoNotificacao):
+    def enviar(self, mensagem):
+        print(f"Enviando SMS: {mensagem}")
+
+class PushService(ServicoNotificacao):
+    def enviar(self, mensagem):
+        print(f"Enviando push: {mensagem}")
+
+class NotificacaoService:
+    def __init__(self, servico: ServicoNotificacao):
+        self.servico = servico
+
+    def notificar(self, mensagem):
+        self.servico.enviar(mensagem)
+
+email_service = EmailService()
+sms_service = SMSService()
+push_service = PushService()
+
+notificador1 = NotificacaoService(email_service)
+notificador2 = NotificacaoService(sms_service)
+notificador3 = NotificacaoService(push_service)
+
+msg = "Bem-vindo ao sistema!"
+notificador1.notificar(msg)
+notificador2.notificar(msg)
+notificador3.notificar(msg)
\ No newline at end of file
diff --git a/exercicio_16.md b/exercicio_16.md
deleted file mode 100644
index cd454b9..0000000
--- a/exercicio_16.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# Exercício 16 - Padrão Adapter (Estrutural)
-
-## Objetivo
-Implementar o padrão de projeto Adapter para integrar interfaces incompatíveis.
-
-## Descrição do Exercício
-Crie um adapter para integrar um sistema de pagamento externo com interface diferente.
-
-### Cenário:
-Você tem um sistema que espera uma interface `ProcessadorPagamento`, mas precisa integrar com um serviço externo `PayPalAPI` que tem interface diferente.
-
-### Requisitos:
-
-1. **Interface esperada pelo sistema**:
-```python
-class ProcessadorPagamento:
-    def processar_pagamento(self, valor, cartao):
-        pass
-```
-
-2. **Serviço externo** (não pode ser modificado):
-```python
-class PayPalAPI:
-    def make_payment(self, amount, credit_card_number):
-        return f"PayPal: Processando ${amount} no cartão {credit_card_number}"
-```
-
-3. **Crie o Adapter** `PayPalAdapter` que implementa `ProcessadorPagamento` e usa `PayPalAPI` internamente.
-
-4. **Implemente a classe** `SistemaPagamento` que usa qualquer `ProcessadorPagamento`.
-
-5. **Demonstre** o uso com diferentes processadores.
-
-## Entrega
-Crie um arquivo chamado `respExercicio16.py` com a implementação do padrão Adapter.
-
-## Exemplo de Uso
-```python
-# Sistema funciona com interface padrão
-processador_interno = ProcessadorPagamentoInterno()
-sistema1 = SistemaPagamento(processador_interno)
-
-# Adapter permite usar PayPal com a mesma interface
-paypal_api = PayPalAPI()
-paypal_adapter = PayPalAdapter(paypal_api)
-sistema2 = SistemaPagamento(paypal_adapter)
-
-# Ambos funcionam da mesma forma
-sistema1.realizar_pagamento(100.0, "1234-5678")
-sistema2.realizar_pagamento(200.0, "8765-4321")
-```
\ No newline at end of file
diff --git a/exercicio_16.py b/exercicio_16.py
new file mode 100644
index 0000000..11b10b2
--- /dev/null
+++ b/exercicio_16.py
@@ -0,0 +1,31 @@
+class ProcessadorPagamento:
+    def processar_pagamento(self, valor, cartao):
+        print(f"Pagamento padrão de ${valor} no cartão {cartao}")
+
+class PayPalAPI:
+    def make_payment(self, amount, credit_card_number):
+        return f"PayPal: Processando ${amount} no cartão {credit_card_number}"
+
+class PayPalAdapter(ProcessadorPagamento):
+    def __init__(self, paypal_api):
+        self.paypal_api = paypal_api
+
+    def processar_pagamento(self, valor, cartao):
+        print(self.paypal_api.make_payment(valor, cartao))
+
+class SistemaPagamento:
+    def __init__(self, processador):
+        self.processador = processador
+
+    def realizar_pagamento(self, valor, cartao):
+        self.processador.processar_pagamento(valor, cartao)
+
+processador_interno = ProcessadorPagamento()
+sistema1 = SistemaPagamento(processador_interno)
+
+paypal_api = PayPalAPI()
+paypal_adapter = PayPalAdapter(paypal_api)
+sistema2 = SistemaPagamento(paypal_adapter)
+
+sistema1.realizar_pagamento(100.0, "1234-5678")
+sistema2.realizar_pagamento(200.0, "8765-4321")
\ No newline at end of file
diff --git a/exercicio_17.md b/exercicio_17.md
deleted file mode 100644
index 7084031..0000000
--- a/exercicio_17.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# Exercício 17 - Padrão Decorator (Estrutural)
-
-## Objetivo
-Implementar o padrão de projeto Decorator para adicionar funcionalidades dinamicamente.
-
-## Descrição do Exercício
-Crie um sistema de bebidas onde você pode adicionar ingredientes extras usando decorators.
-
-### Requisitos:
-
-1. **Interface base** `Bebida` com métodos:
-   - `get_descricao()`: retorna descrição da bebida
-   - `get_preco()`: retorna preço da bebida
-
-2. **Bebidas concretas**:
-   - **Cafe**: "Café" - R$ 5.00
-   - **Cha**: "Chá" - R$ 3.00
-
-3. **Decorator base** `BebidaDecorator` que implementa `Bebida`.
-
-4. **Decorators concretos**:
-   - **LeiteDecorator**: adiciona "com Leite" - +R$ 2.00
-   - **AcucarDecorator**: adiciona "com Açúcar" - +R$ 0.50
-   - **ChantillyDecorator**: adiciona "com Chantilly" - +R$ 3.00
-
-5. **Demonstre** como combinar múltiplos decorators.
-
-## Entrega
-Crie um arquivo chamado `respExercicio17.py` com a implementação do padrão Decorator.
-
-## Exemplo de Uso
-```python
-# Bebida simples
-cafe = Cafe()
-print(f"{cafe.get_descricao()} - R$ {cafe.get_preco()}")
-
-# Bebida com decorators
-cafe_com_leite = LeiteDecorator(cafe)
-print(f"{cafe_com_leite.get_descricao()} - R$ {cafe_com_leite.get_preco()}")
-
-# Múltiplos decorators
-cafe_especial = ChantillyDecorator(AcucarDecorator(LeiteDecorator(Cafe())))
-print(f"{cafe_especial.get_descricao()} - R$ {cafe_especial.get_preco()}")
-```
-
-## Exemplo de Saída Esperada
-```
-Café - R$ 5.0
-Café com Leite - R$ 7.0
-Café com Leite com Açúcar com Chantilly - R$ 10.5
-```
\ No newline at end of file
diff --git a/exercicio_17.py b/exercicio_17.py
new file mode 100644
index 0000000..b408277
--- /dev/null
+++ b/exercicio_17.py
@@ -0,0 +1,64 @@
+from abc import ABC, abstractmethod
+
+class Bebida(ABC):
+    @abstractmethod
+    def get_descricao(self):
+        pass
+
+    @abstractmethod
+    def get_preco(self):
+        pass
+
+class Cafe(Bebida):
+    def get_descricao(self):
+        return "Café"
+    
+    def get_preco(self):
+        return 5.00
+
+class Cha(Bebida):
+    def get_descricao(self):
+        return "Chá"
+    
+    def get_preco(self):
+        return 3.00
+
+class BebidaDecorator(Bebida):
+    def __init__(self, bebida):
+        self.bebida = bebida
+
+    def get_descricao(self):
+        return self.bebida.get_descricao()
+
+    def get_preco(self):
+        return self.bebida.get_preco()
+
+class LeiteDecorator(BebidaDecorator):
+    def get_descricao(self):
+        return f"{self.bebida.get_descricao()} com Leite"
+
+    def get_preco(self):
+        return self.bebida.get_preco() + 2.00
+
+class AcucarDecorator(BebidaDecorator):
+    def get_descricao(self):
+        return f"{self.bebida.get_descricao()} com Açúcar"
+
+    def get_preco(self):
+        return self.bebida.get_preco() + 0.50
+
+class ChantillyDecorator(BebidaDecorator):
+    def get_descricao(self):
+        return f"{self.bebida.get_descricao()} com Chantilly"
+
+    def get_preco(self):
+        return self.bebida.get_preco() + 3.00
+
+cafe = Cafe()
+print(f"{cafe.get_descricao()} - R$ {cafe.get_preco()}")
+
+cafe_com_leite = LeiteDecorator(cafe)
+print(f"{cafe_com_leite.get_descricao()} - R$ {cafe_com_leite.get_preco()}")
+
+cafe_especial = ChantillyDecorator(AcucarDecorator(LeiteDecorator(Cafe())))
+print(f"{cafe_especial.get_descricao()} - R$ {cafe_especial.get_preco()}")
\ No newline at end of file
diff --git a/exercicio_18.md b/exercicio_18.md
deleted file mode 100644
index 832eef9..0000000
--- a/exercicio_18.md
+++ /dev/null
@@ -1,79 +0,0 @@
-# Exercício 18 - Padrão Facade (Estrutural)
-
-## Objetivo
-Implementar o padrão de projeto Facade para simplificar uma interface complexa.
-
-## Descrição do Exercício
-Crie uma facade para simplificar o uso de um sistema complexo de home theater.
-
-### Sistema Complexo Existente:
-```python
-class Amplificador:
-    def ligar(self): pass
-    def definir_volume(self, volume): pass
-
-class DVDPlayer:
-    def ligar(self): pass
-    def reproduzir(self, filme): pass
-
-class Projetor:
-    def ligar(self): pass
-    def modo_widescreen(self): pass
-
-class Luzes:
-    def diminuir(self, nivel): pass
-
-class PipocaPopper:
-    def ligar(self): pass
-    def fazer_pipoca(self): pass
-```
-
-### Requisitos:
-
-1. **Implemente as classes** do sistema complexo com métodos que imprimem suas ações.
-
-2. **Crie a classe** `HomeTheaterFacade` que encapsula a complexidade.
-
-3. **Métodos da facade**:
-   - `assistir_filme(filme)`: configura todo o sistema para assistir
-   - `fim_filme()`: desliga todos os componentes
-
-4. **Demonstre** a diferença entre usar o sistema diretamente vs. usando a facade.
-
-## Entrega
-Crie um arquivo chamado `respExercicio18.py` com a implementação do padrão Facade.
-
-## Exemplo de Uso
-```python
-# Uso complexo (sem facade)
-amplificador = Amplificador()
-dvd = DVDPlayer()
-projetor = Projetor()
-luzes = Luzes()
-pipoca = PipocaPopper()
-
-# Muitas chamadas necessárias...
-amplificador.ligar()
-amplificador.definir_volume(5)
-dvd.ligar()
-# ... etc
-
-# Uso simples (com facade)
-home_theater = HomeTheaterFacade()
-home_theater.assistir_filme("Matrix")
-home_theater.fim_filme()
-```
-
-## Exemplo de Saída Esperada
-```
-Preparando para assistir Matrix...
-Ligando amplificador
-Definindo volume para 5
-Ligando DVD player
-Ligando projetor
-Diminuindo luzes para 10%
-Ligando pipoqueira
-Fazendo pipoca
-Reproduzindo Matrix
-Filme finalizado!
-```
\ No newline at end of file
diff --git a/exercicio_18.py b/exercicio_18.py
new file mode 100644
index 0000000..70fd260
--- /dev/null
+++ b/exercicio_18.py
@@ -0,0 +1,56 @@
+class Amplificador:
+    def ligar(self): print("Ligando amplificador")
+    def definir_volume(self, vol): print(f"Definindo volume para {vol}")
+    def desligar(self): print("Desligando amplificador")
+
+class DVDPlayer:
+    def ligar(self): print("Ligando DVD player")
+    def reproduzir(self, filme): print(f"Reproduzindo {filme}")
+    def desligar(self): print("Desligando DVD player")
+
+class Projetor:
+    def ligar(self): print("Ligando projetor")
+    def modo_widescreen(self): print("Modo widescreen ativado")
+    def desligar(self): print("Desligando projetor")
+
+class Luzes:
+    def diminuir(self, nivel): print(f"Diminuindo luzes para {nivel}%")
+    def ligar(self): print("Luzes ligadas")
+
+class PipocaPopper:
+    def ligar(self): print("Ligando pipoqueira")
+    def fazer_pipoca(self): print("Fazendo pipoca")
+    def desligar(self): print("Desligando pipoqueira")
+
+class HomeTheaterFacade:
+    def __init__(self):
+        self.amp = Amplificador()
+        self.dvd = DVDPlayer()
+        self.projetor = Projetor()
+        self.luzes = Luzes()
+        self.pipoca = PipocaPopper()
+
+    def assistir_filme(self, filme):
+        print(f"Preparando para assistir {filme}...")
+        self.luzes.diminuir(10)
+        self.pipoca.ligar()
+        self.pipoca.fazer_pipoca()
+        self.amp.ligar()
+        self.amp.definir_volume(5)
+        self.projetor.ligar()
+        self.projetor.modo_widescreen()
+        self.dvd.ligar()
+        self.dvd.reproduzir(filme)
+
+    def fim_filme(self):
+        print("Filme finalizado!")
+        self.pipoca.desligar()
+        self.amp.desligar()
+        self.projetor.desligar()
+        self.dvd.desligar()
+        self.luzes.ligar()
+
+home_theater = HomeTheaterFacade()
+home_theater.assistir_filme("Matrix")
+print("-" * 20)
+home_theater.fim_filme()
\ No newline at end of file
diff --git a/exercicio_19.md b/exercicio_19.md
deleted file mode 100644
index 14be2f8..0000000
--- a/exercicio_19.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# Exercício 19 - Padrão Observer (Comportamental)
-
-## Objetivo
-Implementar o padrão de projeto Observer para notificação de mudanças de estado.
-
-## Descrição do Exercício
-Crie um sistema de notificações onde múltiplos observadores são notificados quando o estado de um objeto muda.
-
-### Requisitos:
-
-1. **Interface** `Observer` com método `update(temperatura, umidade, pressao)`.
-
-2. **Classe** `EstacaoMeteorologica` (Subject) que:
-   - Mantém lista de observadores
-   - Permite adicionar/remover observadores
-   - Notifica todos quando dados mudam
-   - Métodos: `adicionar_observer()`, `remover_observer()`, `notificar_observers()`, `definir_medicoes()`
-
-3. **Observadores concretos**:
-   - **DisplayTemperatura**: mostra apenas temperatura
-   - **DisplayUmidade**: mostra apenas umidade
-   - **DisplayCompleto**: mostra todos os dados
-
-4. **Demonstre** como múltiplos displays são atualizados automaticamente.
-
-## Entrega
-Crie um arquivo chamado `respExercicio19.py` com a implementação do padrão Observer.
-
-## Exemplo de Uso
-```python
-estacao = EstacaoMeteorologica()
-
-# Criando displays
-display_temp = DisplayTemperatura()
-display_umidade = DisplayUmidade()
-display_completo = DisplayCompleto()
-
-# Registrando observadores
-estacao.adicionar_observer(display_temp)
-estacao.adicionar_observer(display_umidade)
-estacao.adicionar_observer(display_completo)
-
-# Mudança de estado notifica todos
-estacao.definir_medicoes(25.5, 65.0, 1013.2)
-estacao.definir_medicoes(27.0, 70.0, 1015.1)
-```
-
-## Exemplo de Saída Esperada
-```
-Display Temperatura: 25.5°C
-Display Umidade: 65.0%
-Display Completo: 25.5°C, 65.0%, 1013.2 hPa
-Display Temperatura: 27.0°C
-Display Umidade: 70.0%
-Display Completo: 27.0°C, 70.0%, 1015.1 hPa
-```
\ No newline at end of file
diff --git a/exercicio_19.py b/exercicio_19.py
new file mode 100644
index 0000000..2f21681
--- /dev/null
+++ b/exercicio_19.py
@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+
+class Observer(ABC):
+    @abstractmethod
+    def update(self, temp, umid, pressao): pass
+
+class EstacaoMeteorologica:
+    def __init__(self):
+        self.observers = []
+        self.temp = 0
+        self.umid = 0
+        self.pressao = 0
+
+    def adicionar_observer(self, observer):
+        self.observers.append(observer)
+
+    def remover_observer(self, observer):
+        self.observers.remove(observer)
+
+    def notificar_observers(self):
+        for observer in self.observers:
+            observer.update(self.temp, self.umid, self.pressao)
+
+    def definir_medicoes(self, temp, umid, pressao):
+        self.temp = temp
+        self.umid = umid
+        self.pressao = pressao
+        self.notificar_observers()
+
+class DisplayTemperatura(Observer):
+    def update(self, temp, umid, pressao):
+        print(f"Display Temperatura: {temp}°C")
+
+class DisplayUmidade(Observer):
+    def update(self, temp, umid, pressao):
+        print(f"Display Umidade: {umid}%")
+
+class DisplayCompleto(Observer):
+    def update(self, temp, umid, pressao):
+        print(f"Display Completo: {temp}°C, {umid}%, {pressao} hPa")
+
+estacao = EstacaoMeteorologica()
+display_temp = DisplayTemperatura()
+display_umidade = DisplayUmidade()
+display_completo = DisplayCompleto()
+
+estacao.adicionar_observer(display_temp)
+estacao.adicionar_observer(display_umidade)
+estacao.adicionar_observer(display_completo)
+
+estacao.definir_medicoes(25.5, 65.0, 1013.2)
+estacao.definir_medicoes(27.0, 70.0, 1015.1)
\ No newline at end of file
diff --git a/exercicio_20.md b/exercicio_20.md
deleted file mode 100644
index 7ffb820..0000000
--- a/exercicio_20.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Exercício 20 - Padrão Strategy (Comportamental)
-
-## Objetivo
-Implementar o padrão de projeto Strategy para alternar algoritmos dinamicamente.
-
-## Descrição do Exercício
-Crie um sistema de cálculo de frete que pode usar diferentes estratégias de cálculo.
-
-### Requisitos:
-
-1. **Interface** `EstrategiaFrete` com método `calcular_frete(peso, distancia)`.
-
-2. **Estratégias concretas**:
-   - **FreteNormal**: R$ 5.00 + (peso * 2.0) + (distancia * 0.1)
-   - **FreteExpresso**: R$ 15.00 + (peso * 3.0) + (distancia * 0.2)
-   - **FreteEconomico**: R$ 2.00 + (peso * 1.0) + (distancia * 0.05)
-
-3. **Classe** `CalculadoraFrete` que:
-   - Aceita uma estratégia no construtor
-   - Permite trocar estratégia em tempo de execução
-   - Método `calcular(peso, distancia)` que usa a estratégia atual
-
-4. **Demonstre** como trocar estratégias dinamicamente.
-
-## Entrega
-Crie um arquivo chamado `respExercicio20.py` com a implementação do padrão Strategy.
-
-## Exemplo de Uso
-```python
-peso = 10.0  # kg
-distancia = 100.0  # km
-
-calculadora = CalculadoraFrete(FreteNormal())
-print(f"Frete Normal: R$ {calculadora.calcular(peso, distancia)}")
-
-calculadora.definir_estrategia(FreteExpresso())
-print(f"Frete Expresso: R$ {calculadora.calcular(peso, distancia)}")
-
-calculadora.definir_estrategia(FreteEconomico())
-print(f"Frete Econômico: R$ {calculadora.calcular(peso, distancia)}")
-```
-
-## Exemplo de Saída Esperada
-```
-Frete Normal: R$ 35.0
-Frete Expresso: R$ 65.0
-Frete Econômico: R$ 17.0
-```
\ No newline at end of file
diff --git a/exercicio_20.py b/exercicio_20.py
new file mode 100644
index 0000000..6167363
--- /dev/null
+++ b/exercicio_20.py
@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+class EstrategiaFrete(ABC):
+    @abstractmethod
+    def calcular_frete(self, peso, distancia): pass
+
+class FreteNormal(EstrategiaFrete):
+    def calcular_frete(self, peso, distancia):
+        return 5.00 + (peso * 2.0) + (distancia * 0.1)
+
+class FreteExpresso(EstrategiaFrete):
+    def calcular_frete(self, peso, distancia):
+        return 15.00 + (peso * 3.0) + (distancia * 0.2)
+
+class FreteEconomico(EstrategiaFrete):
+    def calcular_frete(self, peso, distancia):
+        return 2.00 + (peso * 1.0) + (distancia * 0.05)
+
+class CalculadoraFrete:
+    def __init__(self, estrategia: EstrategiaFrete):
+        self.estrategia = estrategia
+
+    def definir_estrategia(self, estrategia: EstrategiaFrete):
+        self.estrategia = estrategia
+
+    def calcular(self, peso, distancia):
+        return self.estrategia.calcular_frete(peso, distancia)
+
+peso = 10.0
+distancia = 100.0
+
+calculadora = CalculadoraFrete(FreteNormal())
+print(f"Frete Normal: R$ {calculadora.calcular(peso, distancia)}")
+
+calculadora.definir_estrategia(FreteExpresso())
+print(f"Frete Expresso: R$ {calculadora.calcular(peso, distancia)}")
+
+calculadora.definir_estrategia(FreteEconomico())
+print(f"Frete Econômico: R$ {calculadora.calcular(peso, distancia)}")
\ No newline at end of file