Juego de memoria con cartas: algoritmo de mezcla y volteo CSS

Contenido
- Por qué el barajado y el volteo de cartas son tan complicados
- Implementarlo tú mismo con el barajado Fisher-Yates y el volteo de cartas en CSS
- Cantidad de cartas según el tamaño del tablero
- Conclusión
- Mecanismos técnicos esenciales (Technical Mechanism)
- Tabla comparativa de rendimiento de los algoritmos de mezclado
- 5 errores que debes evitar a toda costa al desarrollar un juego de memoria
- Flujo de trabajo en 5 pasos para una arquitectura de juego de cartas perfecta
- 7 consejos para desarrollar juegos de cartas
- Árbol de decisión para elegir la dificultad y el tamaño del tablero
- Glosario de términos técnicos clave (Terminology Cheatsheet)
- Preguntas frecuentes
El juego de memoria de voltear cartas tiene una regla muy sencilla: destapar parejas y acertarlas. Pero cuando te pones a crearlo tú mismo, puede que no sepas por dónde empezar con la lógica que baraja las cartas de forma justa y con la animación de volteo. En este artículo repasamos el algoritmo de barajado Fisher-Yates, que mezcla el orden de las cartas al azar, y el método de volteo con CSS que cambia según el estado de cada carta. Además, te presentamos una herramienta con la que puedes jugar directamente y medir tus registros.
Resumen ① El barajado Fisher-Yates recorre el array desde el final e intercambia cada posición con otra elegida al azar, de modo que las cartas quedan repartidas de forma justa. ② Basta con alternar el valor de transform: rotateY y el contenido visible del mismo elemento según el estado de la carta (isFlipped, isMatched) para conseguir la animación de volteo. ③ Aunque no lo implementes tú mismo, puedes jugar directamente con la herramienta "Juego de memoria: encuentra las parejas" y medir el número de movimientos y el tiempo.
Por qué el barajado y el volteo de cartas son tan complicados
Lo primero con lo que te topas al crear un juego de emparejar cartas es cómo barajarlas de forma justa. Si escribes un código sencillo que reordena el array al azar, aparecen sesgos que acumulan cartas en ciertas posiciones y el juego pierde gracia. Además, tienes que pensar en la animación de volteo, que muestra el anverso y el reverso de forma natural al hacer clic en una carta, y en la gestión de estados que impide pulsar una tercera carta antes de que termine la comprobación de la pareja.
Implementarlo tú mismo con el barajado Fisher-Yates y el volteo de cartas en CSS
1. Barajado Fisher-Yates y comprobación de parejas
El barajado Fisher-Yates empieza en el último índice del array y avanza uno a uno hacia delante: en cada paso, intercambia el valor de la posición actual con el de un índice elegido al azar dentro del rango que llega hasta ese punto.
Recorriendo los índices i del array desde N-1 hasta 1 en orden inverso, se obtiene un entero j entre 0 e i calculando Math.floor(Math.random() × (i + 1)) y se intercambian A[i] y A[j].
Como este proceso se repite una sola vez por cada índice, la complejidad temporal es O(N), y la clave del algoritmo es que todas las distribuciones de las cartas aparecen con la misma probabilidad.
Las condiciones que determinan el estado del juego son las siguientes.
- Comparar las dos cartas seleccionadas: Si el valor emoji de ambas cartas coincide (firstCard.emoji === secondCard.emoji), 0,5 segundos después se fija isMatched = true; si no coincide, 1 segundo después se vuelve a poner isFlipped en false y las cartas se renderizan de nuevo tapadas.
- Evaluar el número de movimientos (Moves) y el tiempo (Timer): Si registras los turnos y el tiempo que tardas en emparejar las cartas, puedes usar esos datos como indicador para comparar el nivel de memoria a corto plazo de cada jugador.
2. Renderizar el transform del volteo según el estado de la carta
A continuación tienes el código que muestra el emoji cuando la carta está volteada (isFlipped) o emparejada (isMatched), y el signo de interrogación cuando no lo está. No separa el anverso y el reverso en elementos distintos: solo alterna el contenido visible y el valor de transform en un único botón y en el span que contiene.
const isRevealed = card.isFlipped || card.isMatched;
<button
onClick={() => handleCardClick(index)}
style={{
transform: isRevealed ? "rotateY(0deg)" : "rotateY(180deg)",
transition: "transform 0.3s ease, background-color 0.3s ease",
backgroundColor: card.isMatched ? "#0f172a" : isRevealed ? "#38bdf8" : "#475569"
}}
>
<span style={{ transform: isRevealed ? "rotateY(0deg)" : "rotateY(180deg)" }}>
{isRevealed ? card.emoji : "❓"}
</span>
</button>
Según el valor de isRevealed, el transform del botón y del span interior pasan juntos a rotateY(0deg) o rotateY(180deg), con una transición ease de 0,3 segundos. Sin necesidad de propiedades de efecto 3D como perspective o backface-visibility, basta con cambiar el contenido visible y el ángulo de rotación a partir de un solo valor de estado para lograr la interacción de volteo.
3. Reglas de gestión de estados para el desarrollo de puzles reales
- Barrera defensiva contra el error del clic doble (Double-click): Después de seleccionar la segunda carta y hasta que se confirme si hay pareja (0,5 segundos si aciertas, 1 segundo si fallas), debes impedir que un tercer clic seguido desordene el estado del juego. Para ello hace falta un bloqueo (Lock): una marca isLocked = true que bloquee temporalmente la entrada de clics hasta que termine la comprobación de la pareja.
- Momento de evaluar la condición de victoria (Win Condition): Dentro del callback de setTimeout debes llamar a every(...) sobre el array matchedCards que acabas de actualizar para comprobar si están todas emparejadas. Así evitas el error de leer un estado anterior de React que todavía no se ha vuelto a renderizar y dejar pasar la condición de victoria.
Nota Aunque no implementes esta lógica tú mismo, puedes jugar ahora mismo con la herramienta "Juego de memoria: encuentra las parejas". Elige la dificultad de 4x4 o 6x6 y pon a prueba tu memoria de trabajo con un registro de movimientos y tiempo en tiempo real.
Si quieres comprobar el algoritmo de barajado y el código de volteo sin escribirlos tú mismo, pruébalo con nuestra herramienta.
Pon a prueba tu memoria a corto plazo emparejando cartas de emojis ocultas en tableros de 4x4 y 6x6, y compara tus récords de turnos.

Cantidad de cartas según el tamaño del tablero
| Tamaño del tablero | Total de cartas | Número de parejas |
|---|---|---|
| 4x4 | 16 cartas | 8 parejas |
| 6x6 | 36 cartas | 18 parejas |
Conclusión
- El barajado Fisher-Yates recorre el array desde el final e intercambia cada posición con otra elegida al azar, de modo que mezcla las cartas de forma justa.
- Basta con alternar el contenido visible y el valor de transform: rotateY según el estado de la carta (isFlipped, isMatched) para conseguir la animación de volteo.
- Si no aplicas un bloqueo (Lock) que impida clics adicionales antes de que termine la comprobación de la pareja, el estado del juego puede desordenarse.
- En lugar de implementarlo tú mismo, con la herramienta "Juego de memoria: encuentra las parejas" puedes medir el número de movimientos y el tiempo directamente en tableros de 4x4 y 6x6.
Pon a prueba tu memoria a corto plazo emparejando cartas de emojis ocultas en tableros de 4x4 y 6x6, y compara tus récords de turnos.
Mecanismos técnicos esenciales (Technical Mechanism)
Para crear un juego de cartas perfecto no basta con programar: hace falta entender a fondo los algoritmos, el motor de renderizado y la psicología cognitiva.
1. La demostración matemática del mezclado Fisher-Yates
La clave de un mezclado aleatorio es que las N! permutaciones posibles (factorial) aparezcan exactamente con la misma probabilidad de 1/N!. En un arreglo de tamaño N, el algoritmo de Fisher-Yates recorre los índices de atrás hacia adelante y, en cada paso, elige uno al azar dentro del rango restante y lo intercambia.
Si calculamos matemáticamente la probabilidad de que una carta concreta acabe en una posición concreta, veremos que la probabilidad de que la primera carta vaya a un sitio determinado es 1/N, y la de la siguiente es 1/(N−1). Al multiplicarlas todas se obtiene de forma natural 1/N × (N−1) × ... × 1 = 1/N!, lo que garantiza una distribución perfectamente uniforme (Uniform Distribution).
En cambio, el método <pre>sort(() => Math.random() - 0.5)</pre> depende en gran medida de cómo funciona internamente el algoritmo de ordenación del motor (como Timsort en V8), así que la distribución no es uniforme y aparece un sesgo impredecible.
2. Arquitectura de transformaciones 3D con CSS
Para que las cartas parezcan girar de verdad en un espacio tridimensional hay que controlar la tubería de renderizado del navegador.
: aporta profundidad al espacio 3D y crea la sensación de perspectiva al girar.perspective
: hace que los elementos hijos compartan el espacio 3D del padre.transform-style: preserve-3d
: oculta el reverso de la carta cuando mira hacia delante, de modo que al superponer anverso y reverso la transición resulte natural.backface-visibility: hidden
: gira la carta 180 grados sobre el eje Y para darle la vuelta. Estas propiedades se benefician de la aceleración por hardware de la GPU y garantizan una animación fluida a 60 fotogramas por segundo (60 FPS) incluso en dispositivos móviles.rotateY(180deg)
3. Diseño de una máquina de estados (State Machine) en React
En un juego donde se mezclan animaciones asíncronas e interacción del usuario, una máquina de estados finitos (FSM) estricta es imprescindible.
- IDLE: estado de espera en el que no hay ninguna carta seleccionada.
- ONE_SELECTED: estado en el que se ha hecho clic en la primera carta y ya está girada.
- TWO_SELECTED (LOCKED): estado inmediatamente posterior al clic en la segunda carta, en el que se bloquea por completo cualquier clic adicional (isLocked).
- CHECK_MATCH: estado de cálculo en el que se comparan los valores de las dos cartas.
- RESET / MATCHED: estado en el que, si coinciden, las cartas se fijan, y si no, vuelven a girarse boca abajo.
- CHECK_WIN: estado en el que se comprueba si todas las cartas están emparejadas y se activa el disparador de victoria.
4. Psicología cognitiva: memoria de trabajo y memoria visoespacial
Este juego va más allá del simple entretenimiento: esconde principios de neurociencia. Según el modelo del psicólogo cognitivo Nelson Cowan, la capacidad de la memoria de trabajo (Working Memory) humana está limitada a unos 4 ± 1 chunks, frente al límite de 7 ± 2 de la teoría clásica de George Miller. El juego de cartas estimula al máximo la agenda visoespacial (Visuospatial Sketchpad) del modelo de memoria de trabajo de Baddeley y, con ello, ofrece un efecto de entrenamiento de las redes neuronales que vinculan la posición espacial y la imagen visual (el emoji) dentro de la memoria a corto plazo.
Tabla comparativa de rendimiento de los algoritmos de mezclado
Hemos comparado el rendimiento y la eficiencia de distintas formas de mezclar un arreglo desde un punto de vista matemático y de ingeniería.
| Algoritmo | Complejidad temporal | Complejidad espacial | Uniformidad de la distribución (Bias Score) | Dificultad de implementación | Idoneidad en producción |
|---|---|---|---|---|---|
| Fisher-Yates (Knuth) Shuffle | O(N) | O(1) (In-place) | Perfecta (1/N!) | Intermedia | Máxima (recomendado) |
| Naive Random Sort | O(N log N) | O(N) (memoria adicional) | Muy mala (sesgo grave) | Básica | Mínima (no usar) |
| Random Index Extraction | O(N2) (con splice) | O(N) | Aceptable | Intermedia | Baja (pierde rendimiento) |
| Sattolo's Algorithm | O(N) | O(1) | Exclusiva de permutaciones cíclicas | Intermedia | Media (no apta para juegos) |
Como se ve claramente en la tabla, en un juego de cartas donde todo debe quedar perfectamente mezclado al azar, el algoritmo de Fisher-Yates es la única respuesta: ofrece una velocidad de procesamiento O(N), eficiencia de memoria y una equidad demostrada matemáticamente.
5 errores que debes evitar a toda costa al desarrollar un juego de memoria
- Abusar de la ordenación con Math.random() - 0.5: según el motor del navegador, la aleatoriedad se degrada gravemente y, a partir de arreglos de 10 elementos o más, la propia ordenación puede no realizarse bien.
- No bloquear los clics durante la animación: si no ignoras los clics adicionales que se producen entre los 0,5 y 1 segundo que la carta tarda en girarse y mostrar el resultado, las variables de estado se contaminan y la partida se vuelve injugable.
- Dejar que setTimeout provoque fugas de memoria: si no limpias los temporizadores cuando el componente de React se desmonta (Unmount), el callback se ejecuta en segundo plano e intenta actualizar un estado que ya no existe, lo que provoca un fallo (crash).
- Codificar a mano las coordenadas de la cuadrícula (Grid): aunque la proporción de pantalla de móvil y escritorio es distinta, usar píxeles fijos como 800px hace que el diseño adaptable se derrumbe por completo.
- Usar imágenes pesadas de alta calidad: si representas las parejas con PNG/JPG sin optimizar, la carga se ralentiza y aparece un parpadeo (FOUC) porque el anverso de la carta tarda en mostrarse. Recomendamos encarecidamente usar SVG ligeros o emojis nativos (Emoji).
Flujo de trabajo en 5 pasos para una arquitectura de juego de cartas perfecta
- Paso 1: diseñar el modelo de datos y generar los pares de emojis Define objetos de carta con un ID único y un valor que determine su pareja. Por ejemplo, prepara 8 emojis y duplica cada uno para formar un arreglo de 16 elementos.
- Paso 2: aplicar el algoritmo de Fisher-Yates Pasa el arreglo de 16 cartas ya preparado por la lógica de mezclado de Fisher-Yates para construir un mazo perfectamente aleatorio.
- Paso 3: crear el componente de carta con volteo 3D
Combina CSS <pre>
perspective</pre> con <pre>transform: rotateY()</pre> para diseñar un componente de interfaz con textura física que gira suavemente entre el anverso y el reverso. - Paso 4: conectar la máquina de estados con la protección de bloqueo (Lock)
Define un flag global <pre>
isLocked</pre> que controle el evento de clic y enlaza la lógica asíncrona que, cuando haya dos cartas abiertas, determine tras 1 segundo de espera si forman pareja. - Paso 5: añadir cronómetro, número de movimientos y diálogo de victoria Pon en marcha un temporizador que empiece a contar en segundos al iniciar la partida y suma uno al contador cada vez que se gira una carta para construir la pantalla de puntuación final.
7 consejos para desarrollar juegos de cartas
- Optimiza la aceleración por hardware: si añades la propiedad <pre>
will-change: transform</pre> a los elementos de carta que se animan, el navegador reserva recursos de GPU de antemano y evitas los tirones. - Pausa el temporizador al cambiar de pestaña con la Page Visibility API: para que el cronómetro no siga corriendo cuando el usuario se va a otra pestaña del navegador, detecta la propiedad <pre>
document.hidden</pre> y detén el reloj. - Sonido limpio con la Web Audio API: si en lugar de la etiqueta de audio de HTML5 usas osciladores o buffers de la Web Audio API, consigues efectos de sonido sin latencia que coinciden exactamente con el momento del clic.
- Aprovecha la cuadrícula inteligente: con la función <pre>
repeat(auto-fit, minmax(...))</pre> de CSS Grid, las columnas y filas de cartas se recolocan solas de forma flexible según el tamaño de la pantalla, sin necesidad de media queries. - Conserva los récords para siempre con LocalStorage: guarda en el almacenamiento del navegador, en formato JSON, el mínimo de movimientos y el menor tiempo del jugador; así, en la siguiente visita seguirá teniendo un objetivo que superar.
- Accesibilidad (A11y) y teclado con ARIA: para que también puedan jugar las personas con discapacidad visual, coloca bien <pre>
aria-label</pre> y <pre>tabindex</pre> y asigna los eventos de las teclas Enter/Espacio, de modo que se pueda jugar cómodamente sin ratón. - Prueba ya la herramienta web terminada: más vale verlo una vez que oírlo cien veces. Antes de ponerte a programar, juega ahora mismo con la herramienta que hay al final de esta página para inspirarte en el diseño.
Árbol de decisión para elegir la dificultad y el tamaño del tablero
El equilibrio óptimo del juego depende del público objetivo y del dispositivo que use.
- Tablero 4x4 (16 cartas, 8 parejas)
- Dirigido a: niños pequeños, personas mayores y usuarios ocasionales que solo quieren matar el rato.
- Dispositivo ideal: móviles antiguos con pantalla pequeña.
- Características: partidas cortas de 1 a 2 minutos de media y poca carga cognitiva.
- Tablero 6x6 (36 cartas, 18 parejas)
- Dirigido a: adultos que quieren entrenar el cerebro y aficionados a los puzles.
- Dispositivo ideal: tabletas y monitores de escritorio.
- Características: exige una memoria espacial más compleja y genera una implicación alta, con partidas de 5 minutos o más de media.
- Modo contrarreloj (Timed Challenge)
- Dirigido a: jugadores hardcore a los que les gusta competir.
- Condiciones: completar el tablero dentro de un tiempo límite o aplicar un modo infinito en el que el tablero se va ampliando de forma continua despierta una gran dosis de dopamina.
Glosario de términos técnicos clave (Terminology Cheatsheet)
- Mezcla de Fisher-Yates (Fisher-Yates Shuffle): algoritmo estándar de permutación aleatoria que mezcla por completo los elementos de un array sin sesgo matemático y dentro de una complejidad temporal determinada.
- Memoria de trabajo (Working Memory): función cerebral a corto plazo que retiene información temporalmente en la mente y la usa para operaciones cognitivas.
- Máquina de estados (State Machine): arquitectura de software que define los estados finitos que puede tener un sistema y que hace que las transiciones entre estados sean inequívocas en función de los eventos.
- backface-visibility: propiedad clave de CSS que decide si la cara posterior se renderiza en pantalla al aplicar una rotación 3D.
- transform: rotateY: propiedad que rota un elemento HTML del plano 2D sobre el eje Y y crea una sensación de volumen.
- Complejidad temporal O(N): medida de un algoritmo eficiente cuyo tiempo de operación crece de forma lineal en proporción al tamaño N de los datos de entrada.
Preguntas frecuentes
P1. ¿Cómo puedo demostrar que mi lógica de mezcla es matemáticamente justa (Provably Fair)?
R1. Ejecuta unas 100.000 simulaciones y mide la frecuencia de cada elemento del array. Si al mezclar 100.000 veces un array de tamaño 3, [A, B, C], la probabilidad de que A quede en la primera posición converge exactamente en el 33,333%, tu algoritmo es justo. Fisher-Yates supera esta prueba a la perfección, mientras que con un orden aleatorio basado en una simple resta comprobarás enseguida que una carta concreta se queda en una posición determinada con una frecuencia superior al 60%.
P2. ¿Qué hago para que el temporizador no se descontrole cuando el usuario sale a mirar otra app en el móvil?
R2. Los temporizadores asíncronos de JavaScript sufren throttling cuando la pestaña del navegador está inactiva, así que se ralentizan o se detienen. Para evitarlo, debes recordar la marca de tiempo del inicio y, mediante <pre>document.addEventListener('visibilitychange')</pre>, guardar el tiempo acumulado y pausar el temporizador en cuanto la pantalla deja de estar visible. Esa lógica de pausa es imprescindible.
P3. ¿De verdad mejora mi cerebro si juego todos los días a dar la vuelta a cartas?
R3. Según la investigación en neurociencia cognitiva, este tipo de entrenamiento de la memoria espacial (Spatial Memory) favorece la activación de la corteza prefrontal (Prefrontal Cortex). Más que subir el cociente intelectual, lo que mejora es la eficiencia de las redes de conexiones sinápticas que mantienen la información visual momentánea en el espacio de la memoria de trabajo y la recuperan con rapidez, lo que puede ayudar de forma real a la memoria a corto plazo en el día a día.
Este artículo está adaptado de nuestro original en coreano. Leer el original en coreano