Fase 1 8 horas Iniciante

# O Terreno Vazio

Palotina, 1983. Antes de construir a pista, o terreno precisava ser limpo. No código: antes de calcular, precisa-se declarar.

Progresso: 0/12 (0%)

## Objetivos da Fase

Nesta primeira fase, você vai limpar o terreno mental e construir os alicerces da programação. Assim como o ábaco romano precisa de todas as contas no chão antes de começar a calcular, o programador precisa entender variáveis antes de escrever qualquer algoritmo.

#### O que você vai aprender:

- Variáveis e tipos de dados em Python
- O sistema bi-quinário do ábaco romano
- Estruturas condicionais (`if` / `elif` / `else`)
- Loops `for` e `while`
- Funções: definir, chamar, retornar
- Listas e dicionários básicos

#### O que você vai criar:

- Seu primeiro programa Python interativo
- Uma calculadora de console
- A classe `RanhuraAbaco` (o coração do ábaco)
- A classe `CircuitoFerradura` completa

## 1.1 — O Ábaco Romano

O ábaco romano (século II–V d.C.) usa o sistema bi-quinário: cada ranhura tem 1 conta superior (vale 5) e 4 contas inferiores (valem 1 cada). Máximo por ranhura: 9. Com 5 ranhuras: 0 a 99.999.

#### 🏁 Metáfora da pista

Cada ranhura é uma curva da pista de Palotina. As contas inferiores são as pedaladas terrestres (esforço do piloto). A conta superior é a rampa — quando você a ativa, o valor salta de 1 para 5, assim como o salto da Paineira multiplica a velocidade instantaneamente.

    # Representação ASCII do ábaco com o número 1993
    ══════════════════════════════════════════════════
       Ranhura │ Celeste │ Terrestres │  Valor
    ══════════════════════════════════════════════════
       Unidades │    ●    │  ● ● ●  ○  │    3
       Dezenas  │    ●    │  ● ● ● ●   │    9
       Centenas │    ●    │  ● ● ● ●   │    9
       Milhares │    ○    │  ●  ○ ○ ○  │    1
    ══════════════════════════════════════════════════
       Total: 1993

## 1.2 — Variáveis e Tipos de Dados

No ábaco, zerar uma ranhura é como declarar uma variável sem valor. Armar um número é atribuir. Ler o total é imprimir.

    # Declarar (terreno vazio)
    >>> abaco = CircuitoFerradura()
    >>> print(abaco.valor_total())
    0

    # Armar o ano de Palotina (atribuir)
    >>> abaco.contornar_paineira(1993)
    >>> print(abaco.valor_total())
    1993

    # Tipos básicos
    >>> ano    = 1993          # int
    >>> cidade = "Palotina"   # str
    >>> pista  = True         # bool
    >>> rampa  = 9.8          # float (gravidade)

## 1.3 — Estruturas Condicionais

No ábaco, a conta superior só ativa quando o dígito atinge 5 ou mais. Isso é uma condicional: "se o valor ≥ 5, ativa a conta celeste".

    # Lógica interna do ábaco: if/elif/else
    def armar_ranhura(valor: int) -> dict:
        if valor < 0 or valor > 9:
            raise ValueError("Ranhura aceita 0–9 apenas")

        superior = valor >= 5
        inferiores = valor - 5 if superior else valor

        return {"superior": superior, "inferiores": inferiores}

    >>> armar_ranhura(7)
    {'superior': True, 'inferiores': 2}

## 1.4 — Loops: Pedaladas na Pista

Para percorrer todas as ranhuras do ábaco, usamos loops. Cada iteração é uma pedalada — você passa por todos os pontos-chave da pista.

    # Percorrer as 5 ranhuras (loop for)
    for nome, estado in abaco.estado_ranhuras().items():
        print(f"  {nome:<22}: valor={estado['valor']}")

      Unidades              : valor=3
      Dezenas               : valor=9
      Centenas              : valor=9
      Milhares              : valor=1
      Dezenas de Milhar     : valor=0

## ✅ Checklist da Fase 1

Marque cada item ao concluir:

Entendi o sistema bi-quinário do ábaco romano
Criei meu primeiro programa Python e imprimi "Palotina 1993"
Declarei variáveis dos 4 tipos básicos (int, float, str, bool)
Escrevi uma estrutura if/elif/else para classificar um dígito
Usei loop for para percorrer as 5 ranhuras do ábaco
Defini e chamei uma função com parâmetros e retorno
Implementei a classe `RanhuraAbaco` com propriedades `valor`
Implementei o método `contornar_paineira(numero)`
Armei o número 1993 no ábaco e conferi todas as ranhuras
Fiz soma (somar) e subtração (subtrair) com overflow controlado
Escrevi testes unitários básicos com `unittest`
Executei o demo `CircuitoFerradura.exe` e entendi cada fase

#### 🏎 Projeto da Fase 1

Implemente a classe `CircuitoFerradura` completa com: `contornar_paineira()`, `somar()`, `subtrair()`, `zerar()`, `estado_ranhuras()` e display ASCII colorido no terminal. Baixe o pacote local do Circuito Ferradura como referência de comportamento esperado.

⬇ Baixar pacote local Avançar para Fase 2 →

🔒 LGPD — Este site usa localStorage para salvar seu progresso. Política de Privacidade.