---
name: mescola-array
description: Usare quando l'utente deve mescolare casualmente gli elementi di un array (randomizzare l'ordine).
---

# Mescola Array

Questa skill mescola casualmente gli elementi di un array usando l'algoritmo Fisher-Yates. Utile per randomizzare liste (giochi, quiz), algoritmi che richiedono casualità, test e simulazioni, distribuzione casuale di elementi.

## Procedura

1. **Mescolare l'array**: Usare `mescolaArray(array)`
2. **Passare l'array**: Il parametro deve essere un array
3. **Gestire il risultato**: Restituisce un nuovo array mescolato

## Regole

- `array` deve essere un array (altrimenti restituisce array vuoto)
- Restituisce un nuovo array (non modifica l'originale)
- Crea una **copia** dell'array prima di mescolare
- Ogni elemento ha la stessa probabilità di finire in qualsiasi posizione
- Il risultato è **non deterministico** (diverso ad ogni chiamata)

## Esempi

### Esempio 1: Mescolare un array di numeri

```javascript
const numeri = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const mescolati = mescolaArray(numeri);
console.log(mescolati); // Esempio: [3, 1, 7, 2, 5, 8, 4, 10, 6, 9]
```

### Esempio 2: Mescolare un mazzo di carte

```javascript
const semi = ['♥', '♦', '♣', '♠'];
const valori = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
let mazzo = [];
for (const seme of semi) {
    for (const valore of valori) {
        mazzo.push(valore + seme);
    }
}
const mazzoMescolato = mescolaArray(mazzo);
```

### Esempio 3: Estrazione casuale senza ripetizione

```javascript
const domande = ['D1', 'D2', 'D3', 'D4', 'D5'];
const domandeMescolate = mescolaArray(domande);
// Ora puoi mostrare le domande in ordine casuale
```

### Esempio 4: Mescolare array con un solo elemento

```javascript
const singolo = [42];
const mescolato = mescolaArray(singolo);
console.log(mescolato); // [42] (stesso elemento)
```

### Esempio 5: Mescolare array vuoto

```javascript
const mescolato = mescolaArray([]);
console.log(mescolato); // []
```

## Dettagli Aggiuntivi

- **Algoritmo**: Fisher-Yates (o Knuth shuffle)
- **Implementazione**: 
  ```javascript
  for (let i = array.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [array[i], array[j]] = [array[j], array[i]];
  }
  ```
- **Complessità**: O(n) - tempo lineare
- **Spazio**: O(1) - spazio costante (in-place, ma creiamo una copia)
- **Randomness**: Usa `Math.random()` per generare indici casuali
- **Immutabilità**: Non modifica l'array originale
- **Esempi**:
  - mescolaArray([1, 2, 3, 4]) → [3, 1, 4, 2] (casuale)
  - mescolaArray(['a', 'b', 'c']) → ['b', 'a', 'c'] (casuale)
  - mescolaArray([]) → []
- **Note**: Ogni elemento ha esattamente 1/n probabilità di finire in qualsiasi posizione