10 Exercícios de Lógica de Programação em JavaScript

A programação é como um quebra-cabeças fascinante, onde você combina lógica e criatividade para criar soluções únicas.

Quando se trata de linguagens de programação, o JavaScript se destaca por sua versatilidade e ampla aplicação.

Vamos mergulhar em alguns exercícios práticos de lógica de programação em JavaScript.

Vamos explorar a lógica por trás de cada código, passo a passo, para que você possa desenvolver uma compreensão sólida e aplicável.

A lógica de programação é a espinha dorsal do desenvolvimento de software.

Ela nos permite resolver problemas de maneira estruturada e eficiente.

Ao dominar a lógica de programação em JavaScript, você estará equipado para enfrentar desafios complexos de codificação.

Portanto estar em constante melhora na lógica de programação é fundamental.

Nossos exercícios práticos vão aprimorar suas habilidades e expandir sua compreensão.

Exercício 1: Calculando a Soma dos Números Pares

Objetivo: Escrever um programa que calcule a soma dos números pares em um intervalo dado.

somaNumerosPares(inicio, fim) {
    let soma = 0;
    for (let i = inicio; i <= fim; i++) {
        if (i % 2 === 0) {
            soma += i;
        }
    }
    return soma;
}

Desvendando a Lógica por Trás do Exercício 1

Neste exercício, criamos uma função chamada somaNumerosPares que recebe dois parâmetros: inicio e fim.

Utilizamos um loop for para iterar sobre os números no intervalo dado.

A condição if verifica se o número é par e, se for, adiciona-o à variável soma. Ao final, retornamos o valor total da soma.

Exercício 2: Verificando Números Primos

Objetivo: Criar uma função que verifique se um número é primo ou não.

ehPrimo(numero) {
    if (numero <= 1) {
        return false;
    }
    for (let i = 2; i <= Math.sqrt(numero); i++) {
        if (numero % i === 0) {
            return false;
        }
    }
    return true;
}

Aprofundando no Raciocínio do Exercício 2

A função ehPrimo verifica se um número é primo ou não. Primeiro, tratamos os casos especiais em que o número é menor ou igual a 1, retornando false.

Em seguida, utilizamos um loop for para verificar se o número é divisível por algum outro número entre 2 e a raiz quadrada do número em questão.

Se for divisível, retornamos false; caso contrário, retornamos true.

Exercício 3: Revertendo uma String

Objetivo: Escrever um programa que reverta uma string.

reverterString(str) {
    return str.split('').reverse().join('');
}

Desmistificando a Abordagem do Exercício 3

Neste exercício, usamos a função reverterString para inverter uma string.

Primeiro, utilizamos o método split('') para dividir a string em um array de caracteres.

Em seguida, usamos reverse() para inverter a ordem dos elementos no array e, por fim, join('') para transformar o array de caracteres de volta em uma string invertida.

Exercício 4: Contando Palavras em uma Frase

Objetivo: Criar um programa que conte o número de palavras em uma frase.

contarPalavras(frase) {
    return frase.split(' ').filter(palavra => palavra !== '').length;
}

Passo a Passo na Resolução do Exercício 4

A função contarPalavras recebe uma frase como entrada.

Utilizamos split(' ') para dividir a frase em um array de palavras, usando um espaço como separador.

Em seguida, aplicamos o método filter para remover espaços em branco e elementos vazios do array.

Por fim, retornamos o comprimento do array resultante, que representa o número de palavras na frase.

Exercício 5: Encontrando o Maior Elemento em uma Matriz

Objetivo: Escrever um programa que encontre o maior elemento em uma matriz.

encontrarMaiorElemento(matriz) {
    let maior = matriz[0][0];
    for (let i = 0; i < matriz.length; i++) {
        for (let j = 0; j < matriz[i].length; j++) {
            if (matriz[i][j] > maior) {
                maior = matriz[i][j];
            }
        }
    }
    return maior;
}

Explorando a Lógica por Trás do Exercício 5

Neste exercício, a função encontrarMaiorElemento busca o maior valor em uma matriz bidimensional.

Inicializamos a variável maior com o primeiro elemento da matriz e, em seguida, usamos dois loops for aninhados para percorrer todos os elementos da matriz.

Se encontrarmos um elemento maior que o valor atual de maior, atualizamos a variável.

Ao final, retornamos o maior valor encontrado.

Exercício 6: Validando um Palíndromo

Objetivo: Criar um programa que valide se uma palavra é um palíndromo.

ehPalindromo(palavra) {
    const palavraRevertida = palavra.split('').reverse().join('');
    return palavra === palavraRevertida;
}

Analisando a Lógica Utilizada no Exercício 6

A função ehPalindromo verifica se uma palavra é um palíndromo.

Primeiro, usamos split('') para dividir a palavra em um array de caracteres.

Em seguida, utilizamos reverse() para inverter a ordem dos caracteres e join('') para criar a palavra revertida.

Por fim, comparamos a palavra original com a palavra revertida para determinar se é um palíndromo.

Exercício 7: Ordenação de Números em Ordem Crescente

Objetivo: Escrever um programa que ordene um array de números em ordem crescente.

ordenarCrescente(numeros) {
    return numeros.slice().sort((a, b) => a - b);
}

Desvendando o Processo no Exercício 7

Neste exercício, a função ordenarCrescente recebe um array de números como entrada.

Usamos slice() para criar uma cópia do array original e, em seguida, aplicamos sort() com uma função de comparação que ordena os números em ordem crescente.

O resultado é um novo array ordenado.

Exercício 8: Cálculo de Fatorial

Objetivo: Criar um programa que calcule o fatorial de um número.

calcularFatorial(numero) {
    if (numero === 0 || numero === 1) {
        return 1;
    }
    let resultado = 1;
    for (let i = 2; i <= numero; i++) {
        resultado *= i;
    }
    return resultado;
}

Desmistificando o Método no Exercício 8

A função calcularFatorial calcula o fatorial de um número dado.

Tratamos os casos especiais em que o número é 0 ou 1, retornando 1.

Para outros números, usamos um loop for para multiplicar os números de 2 até o número dado, acumulando o resultado na variável resultado.

Exercício 9: Verificando Ano Bissexto

Objetivo: Escrever um programa que verifique se um ano é bissexto.

ehAnoBissexto(ano) {
    return (ano % 4 === 0 && ano % 100 !== 0) || (ano % 400 === 0);
}

Explorando a Lógica do Exercício 9

A função ehAnoBissexto verifica se um ano é bissexto.

Um ano é bissexto se for divisível por 4 e não for divisível por 100, ou se for divisível por 400.

Usamos operadores lógicos para combinar essas condições e determinar se o ano é bissexto.

Exercício 10: Busca Linear em uma Matriz

Objetivo: Criar um programa que realize uma busca linear por um elemento em uma matriz.

buscarElemento(matriz, elemento) {
    for (let i = 0; i < matriz.length; i++) {
        for (let j = 0; j < matriz[i].length; j++) {
            if (matriz[i][j] === elemento) {
                return true;
            }
        }
    }
    return false;
}

Passo a Passo na Abordagem do Exercício 10

A função buscarElemento realiza uma busca linear por um elemento em uma matriz.

Utilizamos dois loops for aninhados para percorrer todos os elementos da matriz.

Se encontrarmos o elemento, retornamos true; caso contrário, retornamos false.

Conclusão: Reforçando as Fundamentes da Programação em JavaScript

Neste artigo, mergulhamos em uma série de exercícios práticos de lógica de programação em JavaScript.

Você também pode conferir alguns projetos em Javascript para melhorar os seus códigos.

Exploramos cada exercício passo a passo, desvendando a lógica por trás de cada código.

Dominar esses conceitos é fundamental para se tornar um programador habilidoso e confiante.

Ao praticar esses exercícios, você está construindo uma base sólida para suas aventuras de codificação futuras.

Perguntas frequentes (FAQs)