Desafios de Lógica de Programação Resolvidos Passo a Passo

1. FizzBuzz

Enunciado: Escreva um programa que imprima os números de 1 a 100. Para múltiplos de 3, imprima "Fizz". Para múltiplos de 5, imprima "Buzz". Para números que são múltiplos de ambos, imprima "FizzBuzz".

Raciocínio: A chave aqui é usar o operador módulo (%) para verificar divisibilidade. Testamos primeiro a condição mais específica (múltiplo de 3 e 5) antes das condições individuais.

for (let i = 1; i <= 100; i++) {
  let output = '';
  if (i % 3 === 0) output += 'Fizz';
  if (i % 5 === 0) output += 'Buzz';
  console.log(output || i);
}

for i in range(1, 101):
    output = ''
    if i % 3 == 0:
        output += 'Fizz'
    if i % 5 == 0:
        output += 'Buzz'
    print(output or i)

---

2. Sequência de Fibonacci

Enunciado: Gere os primeiros N termos da sequência de Fibonacci, onde cada termo é a soma dos dois anteriores. Começando com 0 e 1.

Raciocínio: Utilizamos uma estrutura de repetição (for/while) para iterar N vezes. A cada iteração, calculamos o próximo termo e atualizamos as variáveis.

function fibonacci(n) {
  let seq = [0, 1];
  for (let i = 2; i < n; i++) {
    seq[i] = seq[i - 1] + seq[i - 2];
  }
  return seq.slice(0, n);
}

console.log(fibonacci(10)); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        print(a, end=' ')
        a, b = b, a + b

fibonacci(10)  # 0 1 1 2 3 5 8 13 21 34

---

3. Número Primo

Enunciado: Escreva uma função que verifique se um número é primo. Um número primo é divisível apenas por 1 e por ele mesmo.

Raciocínio: Números menores que 2 não são primos. Para os demais, verificamos a divisibilidade por todos os números de 2 até a raiz quadrada do número. Se nenhum dividir exatamente, ele é primo.

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

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

import math

def eh_primo(num):
    if num < 2:
        return False
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            return False
    return True

print(eh_primo(7))  # True
print(eh_primo(10)) # False

---

4. Cálculo de Fatorial

Enunciado: Calcule o fatorial de um número N. O fatorial de N (N!) é o produto de todos os inteiros de 1 até N.

Raciocínio: Podemos resolver com um laço de repetição, multiplicando o resultado acumulado pelo número da iteração. Também é um clássico exemplo de recursão.

function fatorialIterativo(n) {
  let resultado = 1;
  for (let i = 2; i <= n; i++) {
    resultado *= i;
  }
  return resultado;
}

function fatorialRecursivo(n) {
  if (n === 0 || n === 1) return 1;
  return n * fatorialRecursivo(n - 1);
}

console.log(fatorialIterativo(5)); // 120
console.log(fatorialRecursivo(5)); // 120

def fatorial_iterativo(n):
    resultado = 1
    for i in range(2, n + 1):
        resultado *= i
    return resultado

def fatorial_recursivo(n):
    if n in (0, 1):
        return 1
    return n * fatorial_recursivo(n - 1)

print(fatorial_iterativo(5))  # 120
print(fatorial_recursivo(5))  # 120

---

5. Inversão de String

Enunciado: Escreva uma função que inverta uma string sem usar funções prontas de reversão.

Raciocínio: Convertemos a string para um array de caracteres, ou iteramos de trás para frente concatenando os caracteres. Em JavaScript, podemos usar um laço decrescente. Em Python, o slicing resolve de forma elegante.

function inverterString(str) {
  let invertida = '';
  for (let i = str.length - 1; i >= 0; i--) {
    invertida += str[i];
  }
  return invertida;
}

console.log(inverterString('C-Hub')); // buH-C

def inverter_string(s):
    invertida = ''
    for char in s[::-1]:
        invertida += char
    return invertida

print(inverter_string('C-Hub'))  # buH-C

---

6. Par ou Ímpar

Enunciado: Dado um número inteiro, determine se ele é par ou ímpar.

Raciocínio: Se o número for divisível por 2 (resto da divisão igual a zero), ele é par. Caso contrário, é ímpar.

function parOuImpar(num) {
  return num % 2 === 0 ? 'Par' : 'Ímpar';
}

console.log(parOuImpar(7));  // Ímpar
console.log(parOuImpar(10)); // Par

def par_ou_impar(num):
    return 'Par' if num % 2 == 0 else 'Ímpar'

print(par_ou_impar(7))   # Ímpar
print(par_ou_impar(10))  # Par

---

7. Maior de Três Números

Enunciado: Dados três números, encontre o maior valor entre eles.

Raciocínio: Podemos usar uma função que compara os números usando uma variável temporária ou a função Math.max.

function maiorDeTres(a, b, c) {
  let maior = a;
  if (b > maior) maior = b;
  if (c > maior) maior = c;
  return maior;
}

console.log(maiorDeTres(10, 25, 7)); // 25

def maior_de_tres(a, b, c):
    return max(a, b, c)

print(maior_de_tres(10, 25, 7))  # 25

---

8. Tabuada

Enunciado: Exiba a tabuada de um número N, de 1 a 10.

Raciocínio: Um laço de repetição de 1 a 10 multiplica o número base pelo contador e exibe o resultado.

function tabuada(n) {
  for (let i = 1; i <= 10; i++) {
    console.log(`${n} x ${i} = ${n * i}`);
  }
}

tabuada(7);

def tabuada(n):
    for i in range(1, 11):
        print(f'{n} x {i} = {n * i}')

tabuada(7)

---

9. Cálculo de Média Ponderada

Enunciado: Calcule a média ponderada de três notas com pesos específicos (ex: 2, 3 e 5).

Raciocínio: A média ponderada é calculada somando o produto de cada nota pelo seu peso e dividindo pela soma dos pesos.

function mediaPonderada(notas, pesos) {
  let somaNotas = 0;
  let somaPesos = 0;
  for (let i = 0; i < notas.length; i++) {
    somaNotas += notas[i] * pesos[i];
    somaPesos += pesos[i];
  }
  return somaNotas / somaPesos;
}

console.log(mediaPonderada([7, 8, 9], [2, 3, 5])); // 8.3

def media_ponderada(notas, pesos):
    soma_notas = sum(n * p for n, p in zip(notas, pesos))
    soma_pesos = sum(pesos)
    return soma_notas / soma_pesos

print(media_ponderada([7, 8, 9], [2, 3, 5]))  # 8.3

---

10. Validação de CPF

Enunciado: Valide um CPF (11 dígitos) verificando seus dois dígitos verificadores.

Raciocínio: O algoritmo oficial soma os 9 primeiros dígitos multiplicados por pesos de 10 a 2. O dígito verificador é 11 menos o resto da divisão por 11 (se maior que 9, dígito = 0). O segundo dígito usa os 10 primeiros números com pesos de 11 a 2.

function validarCPF(cpf) {
  cpf = cpf.replace(/\D/g, '');
  if (cpf.length !== 11 || /^(\d)\1+$/.test(cpf)) return false;

  let soma = 0;
  for (let i = 0; i < 9; i++) soma += parseInt(cpf[i]) * (10 - i);
  let dig1 = 11 - (soma % 11);
  if (dig1 > 9) dig1 = 0;

  soma = 0;
  for (let i = 0; i < 10; i++) soma += parseInt(cpf[i]) * (11 - i);
  let dig2 = 11 - (soma % 11);
  if (dig2 > 9) dig2 = 0;

  return cpf[9] == dig1 && cpf[10] == dig2;
}

console.log(validarCPF('529.982.247-25')); // true ou false dependendo do CPF

def validar_cpf(cpf):
    cpf = ''.join(filter(str.isdigit, cpf))
    if len(cpf) != 11 or cpf == cpf[0] * 11:
        return False

    soma = sum(int(cpf[i]) * (10 - i) for i in range(9))
    dig1 = 11 - (soma % 11)
    dig1 = 0 if dig1 > 9 else dig1

    soma = sum(int(cpf[i]) * (11 - i) for i in range(10))
    dig2 = 11 - (soma % 11)
    dig2 = 0 if dig2 > 9 else dig2

    return int(cpf[9]) == dig1 and int(cpf[10]) == dig2

print(validar_cpf('529.982.247-25'))  # True ou False

Perguntas Frequentes

O que é o desafio FizzBuzz?

FizzBuzz é um clássico desafio de lógica usado em entrevistas. O objetivo é imprimir números de 1 a 100, substituindo múltiplos de 3 por "Fizz", múltiplos de 5 por "Buzz", e múltiplos de ambos por "FizzBuzz". Ele testa condicionais e operador de módulo.

Qual a lógica para validar CPF?

A validação de CPF verifica se os 11 dígitos seguem o algoritmo oficial. O primeiro dígito verificador é calculado com pesos de 10 a 2 sobre os 9 primeiros dígitos. O segundo usa pesos de 11 a 2 sobre os 10 primeiros. Se os dígitos calculados coincidirem com os informados, o CPF é válido.

Qual a diferença entre FizzBuzz e Fibonacci?

FizzBuzz é um exercício de condicionais e laços de repetição para substituir números por palavras. Fibonacci é um algoritmo que gera uma sequência onde cada número é a soma dos dois anteriores, trabalhando conceitos de recursão e iteração.