Autor
Yo había pensado algo así:
Código
Pero suponiendo que podía haber algo más sencillo (esa cosa la acabo de hacer, no sé si funciona), le pregunté a GPT. Me dijo un método de Fisher o algo así que no entendí. En Wikipedia tampoco. Pero se me ocurrió (o puede ser igual a lo que no entendí) un método que recorra los elementos, hasta el central, intercambiando los de un lado con los de otro, y luego el central con cualquiera, pero tenía dudas de cómo sería exactamente y ahora noto que no sería justo, es decir, el 1er elemento nunca quedaría 2ndo (salvo que fuesen menos de 4), y además:
- Si siempre hay intercambio, nunca podrían quedar en el lugar original, lo cual debería poder suceder.
- Si puede no haber intercambio, la probabilidad de que queden igual varios de ellos es muy alta.
Así que eso no sirve ¿pero cual es entonces un buen método?
Copio la conversación que tuve con GPT:
Citar
En **Macromedia Flash 5**, que utiliza **ActionScript 1.0**, puedes implementar un algoritmo para reordenar un array al azar utilizando un enfoque conocido como el algoritmo de **Fisher-Yates Shuffle**. Aquí tienes el código que puedes usar para reordenar al azar el array `PosiblesColores`:
```actionscript
// Array original
PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos
// Función para reordenar el array al azar
function shuffleArray(array) {
var i, j, temp;
for (i = array.length - 1; i > 0; i--) {
j = Math.floor(Math.random() * (i + 1)); // Genera un índice aleatorio válido
// Intercambia los elementos array y array[j]
temp = array;
array = array[j];
array[j] = temp;
}
}
// Llama a la función para mezclar el array
shuffleArray(PosiblesColores);
// Imprime el array reordenado para verificar
for (var i = 0; i < PosiblesColores.length; i++) {
trace(PosiblesColores);
}
```
### Explicación del código:
1. **Algoritmo Fisher-Yates**:
- Este algoritmo recorre el array desde el último elemento hasta el primero.
- En cada iteración, selecciona un índice aleatorio entre `0` y el índice actual, e intercambia los dos elementos.
- Esto garantiza que cada permutación del array sea igualmente probable.
2. **`Math.random()`**:
- Genera un número decimal aleatorio entre `0` y `1`.
- Multiplicamos este número por el rango necesario (`i + 1`) para obtener un índice aleatorio válido.
3. **Intercambio de elementos**:
- Usamos una variable temporal (`temp`) para almacenar el valor de uno de los elementos mientras realizamos el intercambio.
4. **`trace()`**:
- Esta función imprime los valores en el panel de salida para que puedas verificar el resultado del reordenamiento.
### Ejemplo de salida:
Si el array original es:
```actionscript
PosiblesColores = [0xFFFFFF, 0xFF0000, 0];
```
Después de ejecutar el código, el array podría quedar como:
```actionscript
[0, 0xFFFFFF, 0xFF0000]
```
O cualquier otra permutación aleatoria de los elementos.
Puedes modificar el array `PosiblesColores` para agregar más elementos, y el algoritmo seguirá funcionando correctamente.
```actionscript
// Array original
PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos
// Función para reordenar el array al azar
function shuffleArray(array) {
var i, j, temp;
for (i = array.length - 1; i > 0; i--) {
j = Math.floor(Math.random() * (i + 1)); // Genera un índice aleatorio válido
// Intercambia los elementos array y array[j]
temp = array;
array = array[j];
array[j] = temp;
}
}
// Llama a la función para mezclar el array
shuffleArray(PosiblesColores);
// Imprime el array reordenado para verificar
for (var i = 0; i < PosiblesColores.length; i++) {
trace(PosiblesColores);
}
```
### Explicación del código:
1. **Algoritmo Fisher-Yates**:
- Este algoritmo recorre el array desde el último elemento hasta el primero.
- En cada iteración, selecciona un índice aleatorio entre `0` y el índice actual, e intercambia los dos elementos.
- Esto garantiza que cada permutación del array sea igualmente probable.
2. **`Math.random()`**:
- Genera un número decimal aleatorio entre `0` y `1`.
- Multiplicamos este número por el rango necesario (`i + 1`) para obtener un índice aleatorio válido.
3. **Intercambio de elementos**:
- Usamos una variable temporal (`temp`) para almacenar el valor de uno de los elementos mientras realizamos el intercambio.
4. **`trace()`**:
- Esta función imprime los valores en el panel de salida para que puedas verificar el resultado del reordenamiento.
### Ejemplo de salida:
Si el array original es:
```actionscript
PosiblesColores = [0xFFFFFF, 0xFF0000, 0];
```
Después de ejecutar el código, el array podría quedar como:
```actionscript
[0, 0xFFFFFF, 0xFF0000]
```
O cualquier otra permutación aleatoria de los elementos.
Puedes modificar el array `PosiblesColores` para agregar más elementos, y el algoritmo seguirá funcionando correctamente.
quisiera que el índice vaya subiendo en vez de bajando y que uses while en vez de for
Citar
¡Claro! Aquí está el código modificado para que el índice vaya **subiendo** y se use un bucle `while` en lugar de `for`. El algoritmo sigue siendo equivalente al **Fisher-Yates Shuffle**, pero adaptado a tus especificaciones:
```actionscript
// Array original
PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos
// Función para reordenar el array al azar
function shuffleArray(array) {
var i = 0; // Empieza desde el primer índice
var len = array.length;
while (i < len - 1) {
// Genera un índice aleatorio entre i y el último índice
var j = Math.floor(Math.random() * (len - i)) + i;
// Intercambia los elementos array y array[j]
var temp = array;
array = array[j];
array[j] = temp;
// Incrementa el índice
i++;
}
}
// Llama a la función para mezclar el array
shuffleArray(PosiblesColores);
// Imprime el array reordenado para verificar
var index = 0;
while (index < PosiblesColores.length) {
trace(PosiblesColores[index]);
index++;
}
```
### Cambios realizados:
1. **Uso de `while`**:
- El índice `i` comienza en `0` y se incrementa en cada iteración hasta el penúltimo elemento (`len - 1`).
- El bucle `while` se detiene cuando el índice `i` alcanza el penúltimo elemento.
2. **Generación de índice aleatorio (`j`)**:
- En lugar de seleccionar un índice aleatorio para cualquier posición del array, `j` se selecciona entre `i` (el índice actual) y el final del array.
- Esto asegura que cada elemento solo sea intercambiado con los elementos que aún no han sido procesados.
3. **Intercambio de elementos**:
- Igual que antes, usamos una variable temporal `temp` para realizar el intercambio entre `array` y `array[j]`.
4. **Impresión con `while`**:
- Se utiliza un bucle `while` para imprimir cada elemento del array después de ser mezclado.
### Ejemplo de salida:
Dado el array original:
```actionscript
PosiblesColores = [0xFFFFFF, 0xFF0000, 0];
```
Después de ejecutar el código, podrías obtener una permutación como:
```actionscript
[0xFF0000, 0, 0xFFFFFF]
```
O cualquier otra ordenación aleatoria.
Este código es completamente funcional y cumple con las especificaciones que pediste.
```actionscript
// Array original
PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos
// Función para reordenar el array al azar
function shuffleArray(array) {
var i = 0; // Empieza desde el primer índice
var len = array.length;
while (i < len - 1) {
// Genera un índice aleatorio entre i y el último índice
var j = Math.floor(Math.random() * (len - i)) + i;
// Intercambia los elementos array y array[j]
var temp = array;
array = array[j];
array[j] = temp;
// Incrementa el índice
i++;
}
}
// Llama a la función para mezclar el array
shuffleArray(PosiblesColores);
// Imprime el array reordenado para verificar
var index = 0;
while (index < PosiblesColores.length) {
trace(PosiblesColores[index]);
index++;
}
```
### Cambios realizados:
1. **Uso de `while`**:
- El índice `i` comienza en `0` y se incrementa en cada iteración hasta el penúltimo elemento (`len - 1`).
- El bucle `while` se detiene cuando el índice `i` alcanza el penúltimo elemento.
2. **Generación de índice aleatorio (`j`)**:
- En lugar de seleccionar un índice aleatorio para cualquier posición del array, `j` se selecciona entre `i` (el índice actual) y el final del array.
- Esto asegura que cada elemento solo sea intercambiado con los elementos que aún no han sido procesados.
3. **Intercambio de elementos**:
- Igual que antes, usamos una variable temporal `temp` para realizar el intercambio entre `array` y `array[j]`.
4. **Impresión con `while`**:
- Se utiliza un bucle `while` para imprimir cada elemento del array después de ser mezclado.
### Ejemplo de salida:
Dado el array original:
```actionscript
PosiblesColores = [0xFFFFFF, 0xFF0000, 0];
```
Después de ejecutar el código, podrías obtener una permutación como:
```actionscript
[0xFF0000, 0, 0xFFFFFF]
```
O cualquier otra ordenación aleatoria.
Este código es completamente funcional y cumple con las especificaciones que pediste.
Intenté imitarlo pero como no sé exacto cómo funciona y esos nombres j e i me entreveran, decidí buscar en Wikipedia.
https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
Creo que ahora entiendo, va desde derecha a izquierda y "rolled" significa que eligió intercambiar con ese, el elemento posible de intercambiarse era el 4 y "rolled" un 1, yo interpretaba que había elegido por azar el 1 y no sabía de dónde había sacado el 4.
¿Es así? ¿hay otro mejor?
En línea
