Pequeña corrección

Como bien señaló uno de los participantes del Intervalo, había un error en la tabla detallada, en la parte donde se indican los resultados entre cada par de algoritmos.

Ya pueden ver la versión corregida.

Aclaración: Podrán notar que las cifras de la tabla oficial no son iguales a las que puse antes aquí; esto es porque al correr de nuevo el programa los algoritmos que contenían azar se comportaron distinto. De todas formas, el orden de los resultados oficiales no ha cambiado, cosa que me sorprendió bastante.

Resultados del Intervalo

Tenemos un indiscutible algoritmo ganador: «Fixed». ¡Felicitaciones a su creadora, Cythia Disenfeld!


Detalles

Se jugaron 300 partidas entre cada par de algoritmos.
A modo de control, agregué al plantel dos algoritmos que juegan puramente al azar (aunque con distribuciones diferentes).


Tabla de posiciones

Algoritmo	Autor	partidas ganadas	%
Fixed	Cythia Disenfeld	2896	10.257%
J	Jorge Alvaro	2403	8.5116%
Politicamente Correcto	Juan	2384	8.4443%
AntiLogaritmico	Carlos Luna Mota	2343	8.2990%
Equilibrado	Nicolás Tarazona	2144	7.5942%
Intervazar	Pablo Suárez	2113	7.4844%
Espiral	Carlos Luna Mota	2089	7.3994%
Mediana	Marisa Morales	2005	7.1018%
DobleWin	Leandro Tar	1805	6.3934%
Azar1	BeeR	1482	5.2493%
Pequeritmo07	Markelo	1461	5.1749%
Balanza	Armando Vicente	1398	4.9518%
Azar0	BeeR	1127	3.9919%
Logaritmico	Carlos Luna Mota	989	3.5031%
Midadero	Jean Morales	854	3.0249%
Zigzag	Marcos	739	2.6175%

Una tabla más detallada puede verse aquí.
Agregué extra-oficialmente una variante reality-show (gracias Iván por la idea). Es muy interesante ver cómo van variando las posiciones a medida que se van eliminando algoritmos de la lista.

Para tener una impresión visual del torneo, pueden ver una partida de muestra entre cada par de algoritmos.
¿No son lindos los dibujitos que forman? Se podría idear una forma de arte basada en juegos de tablero...


Código fuente

Todo el sistema y los algoritmos están escritos en Unicon.
Aquí pueden curiosear el código de los jugadores y el código principal.


Comentarios

Me gustó mucho la variedad de ideas que hubo: aunque muchos usaron el concepto «ocupar el centro primero», es notable las muy diversas maneras que hay de implementar la idea.
Entre los algoritmos que no usaban el centro en seguida, está nada menos que el ganador. Quizá se anticipó al pensamiento de los demás...


Conclusiones

Me dan ganas de reeditar este mismo juego, pero en una versión dinámica (es decir, con memoria de las jugadas anteriores), y quizá en dos dimensiones (el juego Frames original). Pero primero jugaremos otros juegos que están esperando. Mañana mismo comentaré el juego y las reglas para la próxima competencia.

¡Muchas gracias a todos por participar!

¡No dejen de enviar comentarios e ideas para nuevas competencias!

Intervalo: plazo final

Ya hay bastantes participantes, así que pongo el plazo definitivo: la recepción de algoritmos para el Intervalo cierra el miércoles 17 a medianoche (hora de Argentina).

Suerte a todos, y mantengan la sintonía.

Va creciendo el plantel

No sé si fue por mi lloriqueo del post anterior, pero estos días me han llegado algunos algoritmos más para el Intervalo.

Presten atención que se viene la gran batalla... ¡Y sigan mandando material!

Falta poco y somos pocos

Hola, les cuento que aún son pocos los algoritmos que me han llegado para el Intervalo, así que cambiaré el plazo de recepción.

Haré esto: cuando tenga siete algoritmos en total, lo anunciaré aquí y esperaré una semana más para los rezagados. ¿Por qué siete? Quizá sea un arrebato místico.

Así que ¡a reclutar gente! No dudo que los que ya me han mandado material conocerán posibles participantes.

Partida de ejemplo de Intervalo

Para aclarar algunas dudas que han surgido, pongo aquí una partida de Intervalo de ejemplo, con una tira de sólo 20 casillas, por brevedad.

Aclaro que la partida es totalmente ficticia, es decir, no usé ningún algoritmo de los que me han presentado hasta ahora para generar las movidas.

Simbología:

x    =    casilla con una ficha del jugador x
w    =    casilla con una ficha del jugador w
.    =    casilla vacía
*    =    casilla con una ficha neutral
()   =    marcan el intervalo formado por las fichas puestas en un turno

Partida:

 . . . . . . . . . . . . . . . . . . . .        (comienzo de la partida)
 . . . . .(*). . . . . . . . . . . . . .        (nadie gana el turno)
 . . . . . * . .(x w). . . . . . . . . .        (nadie gana el turno)
 . . . . . * . . x w(w . . . . . . . x).        (nadie gana el turno)
 . . . .(x * . . x w w . . . w). . . x .        (el jugador w gana el turno)
 . . . . x * . . x w w . . . w . . . x(*)       (nadie gana el turno)
 . .(w . x * . . x w w . . x)w . . . x *        (nadie gana el turno)
 . . w . x *(w . x w w . . x w x). . x *        (el jugador w gana el turno)
 . . w . x * w(*)x w w . . x w x . . x *        (nadie gana el turno)
 .(x w . x * w * x w w w). x w x . . x *        (el jugador w gana el turno)
 . x w . x * w * x w w w . x w x .(*)x *        (nadie gana el turno)
(x x w . x * w * x w w w w)x w x . * x *        (el jugador w gana el turno)
 x x w(x x * w * x w w w w x w x w)* x *        (el jugador w gana el turno)

El jugador w ganó 5 turnos y el jugador x no ganó turno alguno; por lo tanto el jugador w es el ganador de la partida.

Recordemos que, a los fines de este torneo, las partidas ganadas valen 1 punto, y las perdidas o empatadas valen 0 puntos.
El algoritmo que gane más partidas será, pues, el ganador del torneo.
Todos los algoritmos se enfrentarán la misma cantidad de veces con todos sus oponentes.

Progresos del Intervalo

Un breve reporte del progreso del torneo de Intervalo.

Ya me han enviado dos algoritmos jugadores, y tengo uno propio que seguramente es bastante defectuoso, pero no lo tocaré más dado que sería injusto modificarlo a la luz de los que me han presentado.

Algunos participantes me han consultado sobre detalles de interpretación; parece que no quedaron muy claras las reglas del juego. Mañana publicaré todas las aclaraciones necesarias, junto con un ejemplo de partida.

Les recuerdo que hay tiempo de presentar algoritmos hasta el 9 de octubre.

¡No se queden afuera!

Intervalo: detalles para programadores

Para la competencia de Intervalo, los jugadores que quieran escribir su propio código podrán hacerlo.
Obviamente, los que no sepan o no quieran programar pueden enviarme simplemente la idea del algoritmo, y yo la implementaré.

Las reglas para presentar código serán las siguientes:

Se aceptará sólo código fuente, con instrucciones precisas sobre cómo compilarlo/interpretarlo.

El lenguaje que usen deberá disponer de un compilador o intérprete gratuito que corra bajo Linux de 64 bits (mi sistema es un Ubuntu 7.04, versión para amd64).

El programa será llamado con un argumento de 64 caracteres, con el siguiente formato:

. = casilla vacía
n = casilla ocupada por una ficha neutral
p = casilla ocupada por una ficha propia
a = casilla ocupada por una ficha ajena

Ejemplo de la línea de comandos usada:

prog ...na..p...a..p..a.np....a...npn...a.nn.p....p.......a..........

Los caracteres del argumento serán el contenido de la casilla 1 a la 64, respectivamente.

El programa calculará su movida, la imprimirá en la salida estándar como número decimal entre 1 y 64 inclusive, y terminará. La salida deberá ser terminada con un carácter de fin de línea.

Ejemplo en C/C++:
printf("%d\n", casilla_elegida);

Ejemplo en Python:
print casilla_elegida

Los programas que devuelvan el número de una casilla ocupada, o un número fuera del rango, serán descalificados. Por supuesto, antes de hacer la competencia definitiva haré algunas pruebas y avisaré a los autores sobre posibles problemas.

Cuarta competencia: Intervalo

Intervalo es un juego bipersonal de movimientos simultáneos (es la versión unidimensional del Frames, juego que diseñé hace unos años).

Reglas del juego

Intervalo se juega en un tablero con forma de tira de 64 casillas, numeradas del 1 al 64. Al comienzo todas las casillas están vacías.
Cada jugador usa fichas de un color que lo represente. Se usan también algunas fichas de color neutral.
En cada turno, ambos jugadores eligen simultáneamente una de las casillas libres de la tira. (Si los que juegan son personas, pueden escibir en secreto el número de la casilla en un papel y luego mostrarlos al mismo tiempo).
Pueden darse dos casos:

• Que elijan la misma casilla. En este caso, se coloca en la casilla una ficha neutral y termina el turno.
• Que elijan casillas distintas. En este caso, se coloca en cada casilla una ficha del color correspondiente al jugador que la eligió, y se cuentan las fichas de cada jugador que estén entre las dos casillas recién elegidas. El que tenga más fichas propias entre ambas casillas obtiene un punto.

La partida termina cuando ya no hay casillas libres. El que tenga más puntos es el ganador.

Reglas para el torneo

En esta versión de la competencia, los algoritmos deberán ser estáticos. Es decir, deberán calcular su jugada teniendo en cuenta exclusivamente el contenido de la tira de casillas. No tendrán «memoria» del orden de las movidas de la partida.
Dependiendo de las ideas, sugerencias y vicisitudes que surjan en este torneo, decidiremos si hacemos la versión dinámica.

Cada algoritmo se enfrentará N veces con cada uno de sus oponentes. N dependerá de cuestiones técnicas, pero supongo que será al menos 100.

El ránking final se armará usando la cantidad total de partidas ganadas. Las partidas empatadas no se tendrán en cuenta.

El plazo de entrega de algoritmos será de un mes a partir de la fecha de este post.

¡Espero sus algoritmos!