1
resposta

Instrução: Como funciona

Então! também acredito que não precisamos reinventar a roda. Não vejo problemas em pesquisar e encontrar e usar uma função pronta.

Porém!!!!

Acredito que não deveríamos nos abstrair da lógica do código encontrado. Especialmente em um código tão pequeno quando esse que foi proposto. Poucas linhas e fáceis de entender... Os instrutores poderiam ter feito uma forcinha e explicado como ele funciona, mesmo que superficialmente.


O algoritmo de Fisher–Yates é a forma clássica de embaralhar um array de forma justa (cada ordem tem a mesma chance de acontecer).

Explicação do que acontece:

  1. Imagine um baralho de cartas. Você pega uma carta qualquer e troca de lugar com outra aleatória.
  2. Depois vai para a próxima carta e faz o mesmo, mas agora só escolhe entre as que ainda não foram fixadas.
  3. No fim, todas mudaram de lugar de maneira aleatória e equilibrada.

No JavaScript:

function embaralhar(array) {
  for (let i = array.length - 1; i > 0; i--) {
    // escolhe índice aleatório entre 0 e i
    const j = Math.floor(Math.random() * (i + 1));

    // troca array[i] com array[j]
    [array[i], array[j]] = [array[j], array[i]];
  }
  return array;
}

// Exemplo de uso:
let numeros = [1, 2, 3, 4, 5];
console.log(embaralhar(numeros));

Resumo do que acontece linha por linha:

* `for (let i = array.length - 1; i > 0; i--)`: começa do último elemento e vai descendo.
* `Math.random() * (i + 1)`: gera número aleatório entre `0` e `i`.
* `[array[i], array[j]] = [array[j], array[i]];`: troca os dois de lugar.

Esse processo garante que cada elemento pode acabar em qualquer posição com probabilidade igual.

1 resposta

Oi Luis! Tudo joia?

É realmente importante não apenas usar soluções prontas, mas também entender como elas funcionam.

O algoritmo de Fisher-Yates é uma maneira eficiente de embaralhar um array de forma que cada permutação possível do array tenha a mesma probabilidade de ocorrer. Vamos dar uma olhada em como ele funciona, passo a passo:

  1. Inicialização: Começamos com o último elemento do array e vamos iterando para trás.

  2. Seleção Aleatória: Para cada elemento, escolhemos um índice aleatório entre 0 e o índice atual.

  3. Troca: Troca-se o elemento atual com o elemento no índice aleatório escolhido.

  4. Repetição: Repetimos esse processo até que todos os elementos tenham sido embaralhados.

No código JavaScript, isso é feito com um loop for que vai do último elemento até o segundo, e dentro desse loop, usamos Math.random() para gerar um índice aleatório. A troca é feita de forma elegante utilizando a atribuição via destructuring, que é uma maneira concisa de trocar os valores de duas variáveis.

Aqui está um exemplo prático de como você pode usar essa função no contexto do seu projeto de sorteio de amigo secreto:

let amigos = [];

function adicionar() {
  let amigo = document.getElementById('nome-amigo');
  amigos.push(amigo.value);
  amigo.value = ''; // Limpa o campo de entrada
}

function sortear() {
  embaralha(amigos);
  // Agora, o array 'amigos' está embaralhado
  // Podemos usar a lógica para definir quem presenteia quem
  for (let i = 0; i < amigos.length; i++) {
    let presenteado = amigos[(i + 1) % amigos.length];
    console.log(`${amigos[i]} vai presentear ${presenteado}`);
  }
}

function embaralha(lista) {
  for (let indice = lista.length; indice; indice--) {
    const indiceAleatorio = Math.floor(Math.random() * indice);
    [lista[indice - 1], lista[indiceAleatorio]] = [lista[indiceAleatorio], lista[indice - 1]];
  }
}

Neste exemplo, após embaralhar o array amigos, usamos um loop para determinar que cada pessoa presenteia a próxima na lista, e a última pessoa presenteia a primeira, criando um ciclo.

Espero ter ajudado e bons estudos!

Caso este post tenha lhe ajudado, por favor, marcar como solucionado ✓.