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!

Juego se busca

Hola a todos, aquí estoy intentando revivir este proyecto. Además de terminar de programar lo que falta del minoría, que ya es poquito, ando con ganas de seleccionar un juego nuevo para la próxima competencia, porque el juego Demofobia no resultó ser tan interesante como esperaba.

Así que si alguno conoce un juego simple pero no trivial, ingenioso y no azaroso, que lo comente aquí así vamos preparando el próximo torneo.

Resultados parciales del torneo de Minoría

He dejado pasar demasiado tiempo sin poder terminar de programar el torneo de Minoría, así que he decidido publicar los resultados parciales con los algoritmos que he podido programar hasta ahora.

Mis disculpas a los que han quedado fuera. Eventualmente iré programando los algoritmos que queden y actualizando la tabla de puntajes. Si algún participante se ofrece para terminar los demás algoritmos, será más que bienvenido. Este torneo lo he programado en Python.

La partida fue a 500000 turnos. La tabla de posiciones quedó como sigue:

104922  100.0   J                  (Jorge Alvaro)
104838  99.9    Nash               (Luis Silvestre)
104322  99.4    Salva              (Salvador Cases)
95621   91.1    El Contra          (German Zorba)
93663   89.3    Psicologico        (Ivan Skvarca)
48442   46.2    Segundo Plato      (Guido Bernardo)
24194   23.1    A por el Crater    (Carlos Luna Mota)
24194   23.1    Julian             (Julian Antonacci)

Señales de vida

Este post es sólo para aclarar que estoy vivo, aunque sigo sin poder dedicar todo el tiempo que quisiera a programar.
Eventualmente lograré hacerlo; hasta entonces gracias por la paciencia...

Resurrección

Hola a todos. Ahora que he usado algunos días de mis vacaciones para dormir, estoy mejor capacitado para terminar por fin de escribir lo que falta del código para el torneo de Minoría.

En unas horas, algunos de los participantes recibirán un mensaje pidiendo algunos detalles de sus algoritmos.

Desde ya pido disculpas por mi cuelgue involuntario; mi vida laboral se había extendido un tanto últimamente. No es una excusa, sino una aclaración para tranquilizar a algunas gentes que temían por mi integridad física.