Terra-23

🧠 Lógica de Programação & Pensamento Computacional

Reciclagem essencial para profissionais de tecnologia — fundamentos que nunca expiram

⚡ Para devs, analistas, testers e arquitetos

🔍 1. Decomposição

Dividir problemas complexos em partes menores e gerenciáveis. É a base para qualquer solução escalável.

• Exemplo: Construir um e-commerce → separar em: catálogo, carrinho, pagamento, usuário.
• Benefício: Reduz complexidade, facilita testes e manutenção.

💡 Dica: Antes de codar, desenhe blocos funcionais. Use diagramas de fluxo ou mind maps.

📊 2. Reconhecimento de Padrões

Identificar similaridades e regularidades para aplicar soluções conhecidas a novos problemas.

• Exemplo: Validação de formulários → mesmo padrão aplicado em diferentes telas.
• Design Patterns: Singleton, Factory, Observer reutilizam soluções consagradas.

💡 Reutilização de código não é só copiar — é abstrair comportamento comum.

📐 3. Abstração

Focar no essencial, ignorando detalhes irrelevantes. Criar modelos conceituais.

• Exemplo: Uma classe "Veículo" abstrai características comuns (acelerar, frear) sem especificar marca ou cor.
• Interfaces, classes abstratas e APIs são formas de abstração.

💡 "A abstração é a arte de simplificar sem perder significado."

⚙️ 4. Algoritmos

Sequência finita de passos bem definidos para resolver um problema.

// Algoritmo para somar dois números
1. Início
2. Ler valor A
3. Ler valor B
4. Calcular SOMA = A + B
5. Exibir SOMA
6. Fim

Algoritmos eficientes = performance e clareza. Domine estruturas de controle (condicionais, loops).

🔁 Estruturas de Controle

Condicionais (if/else, switch): tomam decisões baseadas em condições.

if (usuarioEstaLogado) { exibirPainel(); } else { redirecionarLogin(); }

Laços de repetição (for, while): executam blocos repetidamente.

for (let i = 0; i < 10; i++) { console.log("iteração " + i); }

📦 Estruturas de Dados

• Arrays/Vetores: coleções ordenadas.
• Listas ligadas: inserção/remoção eficiente.
• Pilhas (LIFO) e Filas (FIFO): controle de fluxo.
• Hash maps / Dicionários: busca por chave em O(1).
• Árvores e Grafos: estruturas hierárquicas e relacionais.

🎯 Escolher a estrutura certa impacta diretamente performance e legibilidade.

🧪 Depuração e Testes

Depurar é arte: identificar, isolar e corrigir falhas no raciocínio lógico.

• Teste de mesa: simular execução manual.
• Breakpoints e logs: rastrear estado das variáveis.
• Testes unitários: garantir que cada parte funcione isoladamente.

// Teste de mesa simples let soma = 0; for (let i=1; i<=3; i++) soma += i; // Resultado esperado: 6

📝 Exercícios para Fixação

1. Sequência de Fibonacci

Escreva um algoritmo que gere os primeiros 10 números da sequência de Fibonacci (0, 1, 1, 2, 3, 5, 8...).

Solução (JavaScript):
let a = 0, b = 1;
for (let i = 0; i < 10; i++) {
  console.log(a);
  [a, b] = [b, a + b];
}

2. Número Primo

Crie uma função que verifica se um número é primo.

Solução:
function isPrime(n) {
  if (n < 2) return false;
  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (n % i === 0) return false;
  }
  return true;
}

3. Inverter String

Implemente uma função que inverte uma string sem usar métodos prontos (ex: "casa" → "asac").

Solução lógica:
function reverseString(str) {
  let reversed = "";
  for (let i = str.length - 1; i >= 0; i--) {
    reversed += str[i];
  }
  return reversed;
}

4. Busca Binária

Implemente busca binária em array ordenado. Descreva a complexidade.

Solução O(log n):
function binarySearch(arr, target) {
  let left = 0, right = arr.length - 1;
  while (left <= right) {
    let mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
  }
  return -1;
}

5. Fatorial com recursão

Escreva uma função recursiva para calcular o fatorial de um número.

Recursão:
function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}

⚡ Complexidade de Algoritmos

Big O Notation: mede eficiência em tempo e espaço.

• O(1) – Constante: acesso a array
• O(log n) – Logarítmica: busca binária
• O(n) – Linear: percorrer lista
• O(n²) – Quadrática: bubble sort

🚀 Revise sempre: código legível + eficiente é o equilíbrio ideal.

🧩 Paradigmas de Programação

• Imperativo: sequência de comandos que alteram estado.
• Funcional: funções puras, imutabilidade (map, filter, reduce).
• Orientação a Objetos: encapsulamento, herança, polimorfismo.
• Declarativo: SQL, HTML — descreve o que quer, não como.

🔧 Boas Práticas

• ✔️ Nomes significativos (variáveis, funções, classes)
• ✔️ Código autoexplicativo (evite comentários desnecessários)
• ✔️ Princípios SOLID, DRY, KISS
• ✔️ Refatoração constante

💡 "Qualquer tolo pode escrever código que um computador entenda. Bons programadores escrevem código que humanos entendam." – Martin Fowler

📚 Referências para Aprofundamento

• "Introduction to Algorithms" – Cormen et al.
• "The Pragmatic Programmer" – Andrew Hunt
• "Clean Code" – Robert C. Martin
• Plataformas: LeetCode, HackerRank, Codewars (prática diária)

🎯 Lógica de programação não é sobre sintaxe — é sobre resolver problemas. Pratique 15 minutos por dia para manter o cérebro afiado.

🧠 Reciclagem para profissionais de tecnologia — Fundamentos que sustentam carreiras sólidas.

Pensamento computacional + lógica = base para qualquer stack, linguagem ou framework.