Problemas clássicos de lógica resolvidos com JavaScript

Então, ajeite-se na cadeira, pegue um café e… bora codar!

A lógica é a alma do código

Conceitos básicos de JavaScript

• Controle de fluxo: estruturas como if/else, for e while são essenciais para controlar o comportamento do seu código.

• Manipulação de arrays: métodos como map, filter e reduce tornam o trabalho com listas de dados mais eficiente.

• Funções e closures: você encontrará muito uso para funções anônimas e arrow functions na construção de soluções limpas.

• Programação assíncrona: promises e async/await são indispensáveis para lidar com tarefas que exigem operações não bloqueantes.

• Objetos, Propriedades e Métodos

• Estruturas Condicionais em JavaScript

• Como criar funções no JavaScript

🚀

Agora, se você quer uma revisão rápida e eficiente para garantir que todos esses fundamentos estão fresquinhos na memória, é só dar o play no vídeo abaixo! Em menos de 30 minutos, você terá um panorama geral dos conceitos mais importantes:

Pronto? Agora sim, bora resolver alguns desafios juntos!

Par ou ímpar?

const ePar = (n) => n % 2 === 0;

console.log(ePar(4)); // true
console.log(ePar(7)); // false

Esse código utiliza o operador % (módulo) para verificar se um número é divisível por 2. Se o resto da divisão for 0, o número é par; caso contrário, é ímpar. Esse tipo de lógica é muito útil para determinar comportamento alternado em loops ou validações específicas, como verificar em qual rodada um jogador deve atuar em um jogo.

Curtiu esse código sobre números pares e ímpares? Então vamos testar ele clicando aqui!

Número primo

const ePrimo = (n) => {
  if (n < 2) return false;
  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (n % i === 0) return false;
  }
  return true;
};

console.log(ePrimo(7)); // true
console.log(ePrimo(10)); // false

Este código usa um loop otimizado, verificando até a raiz quadrada do número para economizar processamento. Números primos são fundamentais em criptografia e algoritmos de segurança, como em sistemas de chaves públicas.

Quer se aprofundar mais no mundo dos números primos? Então bora testar este código aqui!

Soma dos dígitos

const somaDigitos = (n) => {
  return n
    .toString()
    .split('')
    .reduce((acc, digito) => acc + parseInt(digito), 0);
};

console.log(somaDigitos(123)); // 6

Este código converte o número para string, divide em dígitos e os soma utilizando reduce. A soma dos dígitos é frequentemente usada em validações, como o cálculo de checksums em códigos de barras e cartões de crédito.

Ficou curioso para explorar mais sobre soma de dígitos? Teste o código aqui!

Anagrama

const eAnagrama = (str1, str2) => {
  const ordenar = (str) => str.toLowerCase().split('').sort().join('');
  return ordenar(str1) === ordenar(str2);
};

console.log(eAnagrama('amor', 'roma')); // true
console.log(eAnagrama('carro', 'barco')); // false

Aqui, ordenamos as letras das duas palavras e comparamos se são iguais. Esse tipo de lógica é aplicado em análise textual, como detecção de plágio e jogos de palavras.

Gostou desse desafio sobre anagramas? Teste você mesmo aqui!

Sequência de collatz

const collatz = (n) => {
  let sequencia = [n];
  while (n !== 1) {
    n = n % 2 === 0 ? n / 2 : n * 3 + 1;
    sequencia.push(n);
  }
  return sequencia;
};

console.log(collatz(6)); // [6, 3, 10, 5, 16, 8, 4, 2, 1]

A sequência de Collatz é um enigma matemático fascinante que até hoje não foi resolvido para todos os números. Esse código é uma ótima forma de praticar manipulação de loops e listas.

Acha que consegue dominar a sequência de Collatz? Experimente aqui!

Encontrar o maior elemento em um array

const maiorElemento = (arr) => Math.max(...arr);

console.log(maiorElemento([10, 20, 30, 50, 40])); // 50

Esse código usa o operador spread (...) para aplicar o método Math.max em todos os elementos do array. Isso é muito útil em algoritmos que precisam determinar pontuações máximas ou encontrar picos em séries temporais.

Teste o código e descubra o maior elemento agora clicando aqui!

Soma dos N primeiros números naturais

const somaNaturais = (n) => (n * (n + 1)) / 2;

console.log(somaNaturais(10)); // 55

Essa fórmula é uma forma eficiente de somar números consecutivos. É muito útil em situações como cálculos de progressão aritmética e otimizações matemáticas.

Está pronto para dominar as somas naturais? Teste o código acessando aqui!

Busca binária

const buscaBinaria = (arr, alvo) => {
  let inicio = 0, fim = arr.length - 1;

  while (inicio <= fim) {
    let meio = Math.floor((inicio + fim) / 2);
    if (arr[meio] === alvo) return meio;
    else if (arr[meio] < alvo) inicio = meio + 1;
    else fim = meio - 1;
  }
  return -1;
};

console.log(buscaBinaria([1, 3, 5, 7, 9], 7)); // 3

A busca binária reduz pela metade o espaço de busca a cada iteração, sendo extremamente eficiente em listas grandes. Ela é amplamente usada em algoritmos de busca e otimização.

Explore o poder da busca binária e teste o código aqui!

Ordenação por inserção

const insertionSort = (arr) => {
  for (let i = 1; i < arr.length; i++) {
    let atual = arr[i];
    let j = i - 1;
    while (j >= 0 && arr[j] > atual) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = atual;
  }
  return arr;
};

console.log(insertionSort([5, 3, 8, 6, 2])); // [2, 3, 5, 6, 8]

O Insertion Sort é um algoritmo simples, mas eficiente para pequenos conjuntos de dados. É frequentemente usado como parte de algoritmos híbridos, como o Timsort.

Vamos ordenar e testar esse Insertion Sort? Experimente aqui!

Dicas para mandar bem em lógica de programação

• Divida o problema em partes menores: resolver o problema passo a passo facilita não só a compreensão, mas também evita sobrecarga mental. Cada pequena vitória conta!

• Depure o código: use o console do navegador e ferramentas como breakpoints para encontrar erros rapidamente e entender o comportamento do seu código em tempo real.

• Escreva pseudocódigos: antes de partir para a implementação, rascunhe a lógica no papel ou em um editor de texto. Isso ajuda a visualizar o problema sem a pressão da sintaxe correta.

• Pratique diariamente: a prática constante melhora sua lógica e desenvolve uma forma estruturada de pensar. Comece com pequenos desafios e vá aumentando a complexidade aos poucos.

• Faça parte de comunidades: aprender junto torna o processo mais divertido e eficiente. A Rocketseat tem uma comunidade incrível para trocar ideias, tirar dúvidas e celebrar conquistas!

• Compreenda diferentes abordagens: existem várias maneiras de resolver o mesmo problema. Explore métodos alternativos e veja o que funciona melhor em diferentes contextos.

• Use recursos visuais: diagramas e fluxogramas ajudam a visualizar a lógica do código. Ferramentas como o Draw.io são ótimas para esboçar o fluxo do programa.

• Teste com diferentes entradas: tente explorar os "cantos" do problema. Use inputs que você não pensaria inicialmente, como números negativos ou valores muito grandes.

Venha fazer parte da comunidade Rocketseat!

Conclusão

O céu não é o limite, é só o começo!