diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index 6220a9500..000000000
--- a/.gitignore
+++ /dev/null
@@ -1,55 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-env/
-bin/
-build/
-develop-eggs/
-dist/
-eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.coverage
-.cache
-nosetests.xml
-coverage.xml
-
-# Translations
-*.mo
-
-# Mr Developer
-.mr.developer.cfg
-.project
-.pydevproject
-.idea
-
-# Rope
-.ropeproject
-
-# Django stuff:
-*.log
-*.pot
-
-# Sphinx documentation
-docs/_build/
-
diff --git a/atores.py b/atores.py
index cfc2ef5ea..300e3e248 100644
--- a/atores.py
+++ b/atores.py
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 
 from __future__ import unicode_literals
-
 import math
 
 DESTRUIDO = 'Destruido'
@@ -46,22 +45,30 @@ def colidir(self, outro_ator, intervalo=1):
         Só deve haver colisão se os dois atores tiverem seus status ativos.
         Para colisão, é considerado um quadrado, com lado igual ao parâmetro intervalo, em volta do ponto onde se
         encontra o ator. Se os atores estiverem dentro desse mesmo quadrado, seus status devem ser alterados para
-        destruido, seus caracteres para destruido também.
+        DESTRUIDO, seus caracteres para destruido (' ') também.
 
         :param outro_ator: Ator a ser considerado na colisão
         :param intervalo: Intervalo a ser considerado
         :return:
         """
-        pass
+        if self.status == DESTRUIDO or outro_ator.status == DESTRUIDO:
+            return
 
+        condicoes = [
+            abs(self.x - outro_ator.x) <= intervalo,
+            abs(self.y - outro_ator.y) <= intervalo,
+        ]
+
+        if all(condicoes):
+            self.status = outro_ator.status = DESTRUIDO
 
 
 class Obstaculo(Ator):
-    pass
+    _caracter_ativo = 'O'
 
 
 class Porco(Ator):
-    pass
+    _caracter_ativo = '@'
 
 
 class DuploLancamentoExcecao(Exception):
@@ -122,7 +129,7 @@ def calcular_posicao(self, tempo):
 
     def lancar(self, angulo, tempo_de_lancamento):
         """
-        Lógica que lança o pássaro. Deve armazenar o ângulo e o tempo de lançamento para posteriores cálculo.
+        Lógica que lança o pássaro. Deve armazenar o ângulo e o tempo de lançamento para posterior cálculo.
         O ângulo é passado em graus e deve ser transformado em radianos
 
         :param angulo:
@@ -133,8 +140,8 @@ def lancar(self, angulo, tempo_de_lancamento):
 
 
 class PassaroAmarelo(Passaro):
-    pass
+    _caracter_ativo = 'A'
 
 
 class PassaroVermelho(Passaro):
-    pass
\ No newline at end of file
+    _caracter_ativo = 'V'
diff --git a/exercicios/__init__.py b/exercicios/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/exercicios/contagem_caracteres_dict.py b/exercicios/contagem_caracteres_dict.py
new file mode 100644
index 000000000..f068cd5da
--- /dev/null
+++ b/exercicios/contagem_caracteres_dict.py
@@ -0,0 +1,23 @@
+def contar_caracteres(s):
+    """Funcao que conta os caracteres de uma string.
+
+    Ex:
+
+    >>> contar_caracteres('adao')
+    {'a': 2, 'd': 1, 'o': 1}
+    >>> contar_caracteres('banana')
+    {'a': 3, 'b': 1, 'n': 2}
+
+    :param s: string a ser contada
+    """
+    resultado = {}
+    for caracter in s:
+        resultado[caracter] = resultado.get(caracter, 0) + 1
+
+    return resultado
+
+
+if __name__ == '__main__':
+    print(contar_caracteres('adao'))
+    print()
+    print(contar_caracteres('banana'))
\ No newline at end of file
diff --git a/exercicios/contagem_caracteres_lista.py b/exercicios/contagem_caracteres_lista.py
new file mode 100644
index 000000000..8733b3fde
--- /dev/null
+++ b/exercicios/contagem_caracteres_lista.py
@@ -0,0 +1,35 @@
+def contar_caracteres(s):
+    """Funcao que conta os caracteres de uma string.
+
+    Ex:
+
+    >>> contar_caracteres('adao')
+    a: 2
+    d: 1
+    o: 1
+    >>> contar_caracteres('banana')
+    a: 3
+    b: 1
+    n: 2
+
+    :param s: string a ser contada
+    """
+    caracteres_ordenados = sorted(s)
+
+    caracter_anterior = caracteres_ordenados[0]
+    contagem = 1
+
+    for caracter in caracteres_ordenados[1:]:
+        if caracter == caracter_anterior:
+            contagem += 1
+        else:
+            print(f"{caracter_anterior}: {contagem}")
+            caracter_anterior = caracter
+            contagem = 1
+    print(f"{caracter_anterior}: {contagem}")
+
+
+if __name__ == '__main__':
+    contar_caracteres('adao')
+    print()
+    contar_caracteres('banana')
\ No newline at end of file
diff --git a/fase.py b/fase.py
index 3385175c6..76ec120e9 100644
--- a/fase.py
+++ b/fase.py
@@ -43,7 +43,7 @@ def adicionar_obstaculo(self, *obstaculos):
 
         :param obstaculos:
         """
-        pass
+        self._obstaculos.extend(obstaculos)
 
     def adicionar_porco(self, *porcos):
         """
@@ -51,7 +51,7 @@ def adicionar_porco(self, *porcos):
 
         :param porcos:
         """
-        pass
+        self._porcos.extend(porcos)
 
     def adicionar_passaro(self, *passaros):
         """
@@ -59,7 +59,7 @@ def adicionar_passaro(self, *passaros):
 
         :param passaros:
         """
-        pass
+        self._passaros.extend(passaros)
 
     def status(self):
         """
@@ -73,7 +73,13 @@ def status(self):
 
         :return:
         """
-        return EM_ANDAMENTO
+        if not self._possui_porco_ativo():
+            return VITORIA
+        elif self._possui_passaro_ativo():
+            return EM_ANDAMENTO
+        else:
+            return DERROTA
+
 
     def lancar(self, angulo, tempo):
         """
@@ -105,3 +111,14 @@ def calcular_pontos(self, tempo):
     def _transformar_em_ponto(self, ator):
         return Ponto(ator.x, ator.y, ator.caracter())
 
+    def _possui_porco_ativo(self):
+        for porco in self._porcos:
+            if porco.status == ATIVO:
+                return True
+        return False
+
+    def _possui_passaro_ativo(self):
+        for passaro in self._passaros:
+            if passaro.status == ATIVO:
+                return True
+        return False
diff --git a/oo/__init__.py b/oo/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/oo/carro.py b/oo/carro.py
new file mode 100644
index 000000000..d2259645e
--- /dev/null
+++ b/oo/carro.py
@@ -0,0 +1,161 @@
+"""
+Voce deve criar uma classe carro que vai possuir dois
+atributos compostos por outras duas classes:
+  1) Motor
+  2) Direção
+
+O Motor terá a responsabilidade de controlar a velocidade.
+Ele oferece os seguintes atributos:
+  * Atributo de dado velocidade
+  * Método acelerar, aumenta a velocidade de uma unidade
+  * Método frear, decrementa a velocidade de duas unidades
+
+A Direção terá a responsabilidade de controlar a direção. Ela oferece
+os seguintes atributos:
+  * Valores possíveis: Norte / Sul / Leste / Oeste
+  * Método girar à direita
+  * Método girar à esquerda
+
+           N
+        O     L
+           S
+
+  Exemplo:
+  >>> # Testando Motor
+  >>> motor = Motor()
+  >>> motor.velocidade
+  0
+  >>> motor.acelerar()
+  >>> motor.velocidade
+  1
+  >>> motor.acelerar()
+  >>> motor.velocidade
+  2
+ >>> motor.acelerar()
+  >>> motor.velocidade
+  3
+  >>> motor.frear()
+  >>> motor.velocidade
+  1
+  >>> motor.frear()
+  >>> motor.velocidade
+  0
+  >>> # Testando Direção
+  >>> direcao = Direcao()
+  >>> direcao.valor
+  'Norte'
+  >>> direcao.girar_a_direita()
+  >>> direcao.valor
+  'Leste'
+  >>> direcao.girar_a_direita()
+  >>> direcao.valor
+  'Sul'
+  >>> direcao.girar_a_direita()
+  >>> direcao.valor
+  'Oeste'
+  >>> direcao.girar_a_direita()
+  >>> direcao.valor
+  'Norte'
+  >>> direcao.girar_a_esquerda()
+  >>> direcao.valor
+  'Oeste'
+  >>> direcao.girar_a_esquerda()
+  >>> direcao.valor
+  'Sul'
+  >>> direcao.girar_a_esquerda()
+  >>> direcao.valor
+  'Leste'
+  >>> direcao.girar_a_esquerda()
+  >>> direcao.valor
+  'Norte'
+  >>> # Testando Carro
+  >>> carro = Carro(motor, direcao)
+  >>> carro.calcular_velocidade()
+  0
+  >>> carro.acelerar()
+  >>> carro.calcular_velocidade()
+  1
+  >>> carro.acelerar()
+  >>> carro.calcular_velocidade()
+  2
+  >>> carro.frear()
+  >>> carro.calcular_velocidade()
+  0
+  >>> carro.calcular_direcao()
+  'Norte'
+  >>> carro.girar_a_direita()
+  >>> carro.calcular_direcao()
+  'Leste'
+  >>> carro.girar_a_esquerda()
+  >>> carro.calcular_direcao()
+  'Norte'
+  >>> carro.girar_a_esquerda()
+  >>> carro.calcular_direcao()
+  'Oeste'
+"""
+
+
+# ------------------------------------------------------------------
+class Motor:
+    def __init__(self):
+        self.velocidade = 0
+
+    @property
+    def velocidade(self):
+        return self._velocidade
+
+    @velocidade.setter
+    def velocidade(self, vel):
+        # Se velocidade for negativa, velocidade recebe 0
+        self._velocidade = max(0, vel)
+
+    def acelerar(self):
+        self.velocidade += 1
+
+    def frear(self):
+        self.velocidade -= 2
+
+
+# ------------------------------------------------------------------
+class Direcao:
+    _valores = ('Norte', 'Leste', 'Sul', 'Oeste')
+
+    def __init__(self):
+        self._cursor = 0
+
+    @property
+    def valor(self):
+        return self._valores[self._cursor]
+
+    def girar_a_direita(self):
+        self._cursor = (self._cursor + 1) % len(self._valores)
+
+    def girar_a_esquerda(self):
+        self._cursor = (self._cursor - 1) % len(self._valores)
+
+
+# ------------------------------------------------------------------
+
+class Carro:
+    """Implementacao da classe Carro, e suas classe agregadas Motor e Direcao"""
+    def __init__(self, motor, direcao):
+        self._motor = motor
+        self._direcao = direcao
+
+    def calcular_velocidade(self):
+        return self._motor.velocidade
+
+    def acelerar(self):
+        self._motor.acelerar()
+
+    def frear(self):
+        self._motor.frear()
+
+    def calcular_direcao(self):
+        return self._direcao.valor
+
+    def girar_a_direita(self):
+        self._direcao.girar_a_direita()
+
+    def girar_a_esquerda(self):
+        self._direcao.girar_a_esquerda()
diff --git a/oo/pessoa.py b/oo/pessoa.py
new file mode 100644
index 000000000..e34f3ccdd
--- /dev/null
+++ b/oo/pessoa.py
@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+class Pessoa:
+    """Implementação de uma classe que modela uma pessoa"""
+
+    temDeficiencia = False    # atributo de classe
+
+    def __init__(self, *filhos, nome=None, idade=0):
+        self.nome = nome
+        self.idade = idade
+        self.filhos = list(filhos)
+
+    def cumprimentar(self):
+        return f"Ola, meu nome é {self.nome}"
+
+    def __repr__(self):
+        txtSaida = f"Meu nome é {self.nome} e tenho {self.idade} anos"
+
+        if self.filhos:
+            txtSaida = txtSaida + f"\nTenho {len(self.filhos)} filhos:"
+            for filho in self.filhos:
+                txtSaida = txtSaida + f"\n==> {filho}"
+
+        return txtSaida
+
+
+class Homem(Pessoa):
+    def cumprimentar(self):
+        return f"{super().cumprimentar()}. Aperto de mão"
+
+
+if __name__ == '__main__':
+    filhos = [('Arthur', 7), ('Alice', 0)]
+
+    pai = Homem(nome='Adao Oliveira', idade=41)
+    mae = Pessoa(nome='Poliana Carlos', idade=39)
+
+    for filho in filhos:
+        pai.filhos.append(Pessoa(nome=filho[0], idade=filho[1]))
+
+    print(pai)
+
+    # O atributo __dict__ lista todos os atributos de instancia de um objeto.
+
+    # Imprimindo o objeto ANTES da criacao de um atributo de instancia
+    print(pai.__dict__)
+
+    # Criando um atributo booleano 'casado' no objeto 'pai'
+    # (esse atributo nao existe em outros objetos da classe Pessoa
+    pai.casado = True
+
+    # Imprimindo novamente os atributos de instancia
+    print(pai.__dict__)
+
+    mae.filhos = pai.filhos.copy()
+    mae.temDeficiencia = True
+    print(mae)
+
+    print(pai.__dict__)
+    print(mae.__dict__)
+
+    # teste
+    print(pai.temDeficiencia)
+    print(mae.temDeficiencia)
+
+    print(pai.cumprimentar())
+    print(mae.cumprimentar())
+
+
diff --git a/oo/test_carro.py b/oo/test_carro.py
new file mode 100644
index 000000000..0900663b1
--- /dev/null
+++ b/oo/test_carro.py
@@ -0,0 +1,12 @@
+from unittest import TestCase
+from carro import Motor
+
+class CarroTestCase(TestCase):
+    def test_velocidade_inicial(self):
+        motor = Motor()
+        self.assertEqual(0, motor.velocidade)
+
+    def test_acelerar(self):
+        motor = Motor()
+        motor.acelerar()
+        self.assertEqual(1, motor.velocidade)
\ No newline at end of file
diff --git a/oo/test_direcao.py b/oo/test_direcao.py
new file mode 100644
index 000000000..a354a51fd
--- /dev/null
+++ b/oo/test_direcao.py
@@ -0,0 +1,28 @@
+from unittest import TestCase
+from carro import Direcao
+
+class DirecaoTestCase(TestCase):
+    def test_direcao(self):
+        direcao = Direcao()
+        direcao.valor
+
+        # Testando girar_a_direita
+        self.assertEqual('Norte', direcao.valor)
+        direcao.girar_a_direita()
+        self.assertEqual('Leste', direcao.valor)
+        direcao.girar_a_direita()
+        self.assertEqual('Sul', direcao.valor)
+        direcao.girar_a_direita()
+        self.assertEqual('Oeste', direcao.valor)
+        direcao.girar_a_direita()
+        self.assertEqual('Norte', direcao.valor)
+
+        # Testando girar_a_esquerda
+        direcao.girar_a_esquerda()
+        self.assertEqual('Oeste', direcao.valor)
+        direcao.girar_a_esquerda()
+        self.assertEqual('Sul', direcao.valor)
+        direcao.girar_a_esquerda()
+        self.assertEqual('Leste', direcao.valor)
+        direcao.girar_a_esquerda()
+        self.assertEqual('Norte', direcao.valor)
diff --git a/oo/test_motor.py b/oo/test_motor.py
new file mode 100644
index 000000000..4c925681a
--- /dev/null
+++ b/oo/test_motor.py
@@ -0,0 +1,17 @@
+from unittest import TestCase
+from carro import Motor
+
+class MotorTestCase(TestCase):
+    def test_velocidade(self):
+        motor = Motor()
+        self.assertEqual(0, motor.velocidade)
+        motor.acelerar()
+        self.assertEqual(1, motor.velocidade)
+        motor.acelerar()
+        self.assertEqual(2, motor.velocidade)
+        motor.acelerar()
+        self.assertEqual(3, motor.velocidade)
+        motor.frear()
+        self.assertEqual(1, motor.velocidade)
+        motor.frear()
+        self.assertEqual(0, motor.velocidade)
diff --git a/teste.py b/teste.py
new file mode 100644
index 000000000..8dd175890
--- /dev/null
+++ b/teste.py
@@ -0,0 +1 @@
+from tkinter import *
\ No newline at end of file
diff --git a/testes/atores_testes.py b/testes/test_atores.py
similarity index 99%
rename from testes/atores_testes.py
rename to testes/test_atores.py
index f4254f29e..4565dcbdf 100644
--- a/testes/atores_testes.py
+++ b/testes/test_atores.py
@@ -34,14 +34,14 @@ def teste_ator_posicao(self):
         'Teste que verifica que o ator comum não deve se mover independente do tempo do jogo'
         ator = Ator()
         x, y = ator.calcular_posicao(0)
-        self.assertEqual(0, x)
-        self.assertEqual(0, y)
+        # O método 'calcular_posicao()' de Ator é criado com retorno padrão de (1, 1)
+        self.assertEqual(1, x)
+        self.assertEqual(1, y)
 
         ator = Ator(0.3, 0.5)
         x, y = ator.calcular_posicao(10)
-        self.assertEqual(0.3, x)
-        self.assertEqual(0.5, y)
-
+        self.assertEqual(1, x)
+        self.assertEqual(1, y)
 
     def teste_colisao_entre_atores_ativos(self):
         """
@@ -113,7 +113,7 @@ def test_caracter(self):
     def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1):
         """
         Se certifica que há colisão entre atores ativos
-        Atenção: Esse não é método de teste porque nao se inicia com prefixo "text".
+        Atenção: Esse não é método de teste porque nao se inicia com prefixo "teste_".
         Ele serve apenas para encapsular toda lógica de teste de colisão entre dois atores ativos
         """
         # Conferindo status dos dois atores antes da colisão
@@ -126,10 +126,10 @@ def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1):
 
     def assert_nao_colisao(self, ator, ator2):
         """
-        Se certifica que não colisão entre dois atores
-        Atenção: Esse não é método de teste porque nao se inicia com prefixo "text".
+        Se certifica que não há colisão entre dois atores
+        Atenção: Esse não é método de teste porque nao se inicia com prefixo "teste_".
         Ele apenas encapsula a lógica de não colisão entre dois atores.
-        So seja, eles deve manter seus respectivos status mesmo depois da chamada do metodo colidir
+        Ou seja, eles devem manter seus respectivos status, mesmo depois da chamada do metodo colidir()
         """
         # Armazenando status antes da colisão
         status_inicial_ator = ator.status
diff --git a/testes/fase_testes.py b/testes/test_fase.py
similarity index 100%
rename from testes/fase_testes.py
rename to testes/test_fase.py
diff --git a/testes/integracao.py b/testes/test_integracao.py
similarity index 100%
rename from testes/integracao.py
rename to testes/test_integracao.py
diff --git a/testes/testes_placa_grafica.py b/testes/test_placa_grafica.py
similarity index 100%
rename from testes/testes_placa_grafica.py
rename to testes/test_placa_grafica.py