¿Por qué la mejor posición para LCR no es la última persona?

Question

Para los no iniciados, LCR es un juego en el que cada jugador comienza con tres "fichas" y tira hasta tres dados (como máximo tantos como fichas tenga). Cada dado tiene tres caras que indican que no pasa nada y un punto cada una para la izquierda, el centro y la derecha; la izquierda y la derecha indican que pasan una ficha en esa dirección y el centro indica que una ficha va al "centro", donde se retira del juego. El juego termina cuando sólo un jugador tiene fichas.

Me preguntaba qué posición sería la mejor, así que he creado el siguiente script de Python para que lo haga por mí:

from random import *

def LCRRound(players):
    global playerset
    playerset = [3] * players
    while not GameOver():
        for player in range(len(playerset)):
            for i in range(min(3, playerset[player])):
                Move(player)
            if GameOver():
                break
    return [playerset.index(p) for p in playerset if p!=0][0]
def L(player):
    playerset[player]-=1
    playerset[player-1]+=1
def C(player):
    playerset[player]-=1
def R(player):
    playerset[player]-=1
    playerset[(player+1)%len(playerset)]+=1
def GameOver():
    return playerset.count(0) == len(playerset)-1
def Move(player):
    tmp = randrange(6)
    if tmp==3:
        L(player)
    if tmp==4:
        C(player)
    if tmp==5:
        R(player)

for x in range(2, 11):
    wins = [0] * x
    for y in range(100000 * x):
        wins[LCRRound(x)]+=1
    print(wins)

Que prueba partidas generadas aleatoriamente con 2 a 10 jugadores, jugando 100.000 partidas para cada jugador en cada conjunto (así que 200.000 partidas para las pruebas de dos jugadores, 300.000 para tres, y así sucesivamente hasta 1.000.000 de partidas para diez jugadores). Esto generó la siguiente salida (y una salida similar otras veces que lo ejecuté), con los números siendo el número de veces que el jugador uno (los jugadores están en orden de quien tira):

[76233, 123767]
[91720, 98359, 109921]
[95913, 97396, 101796, 104895]
[96340, 97629, 99926, 103080, 103025]
[96985, 96768, 98607, 101509, 103283, 102848]
[97557, 96211, 97613, 100659, 102562, 103595, 101803]
[97636, 95984, 96652, 99220, 101364, 103619, 104070, 101455]
[98000, 95559, 96338, 97589, 99600, 102966, 104767, 104061, 101120]
[97355, 95754, 95876, 97163, 99303, 101537, 103103, 104583, 103943, 101383]

Para dos y tres jugadores, la posición óptima es la última. Sin embargo, después, el jugador que más gana se convierte en el penúltimo y luego en el antepenúltimo (y presumiblemente continuaría en este movimiento a medida que se añadan más jugadores). Esto es contrario a lo que esperaba, ya que pensaba que la posición óptima sería la del jugador inmediatamente anterior, posterior u opuesto al jugador inicial, pero no es ninguna de ellas. De cara, el segundo jugador parece ser el más desfavorable en lugar de la persona que comienza. Lo que me lleva a mi pregunta:

¿Cuál es la explicación matemática de qué posición es la mejor en LCR?

Answer 1

Intuitivamente, es ventajoso estar sentado al lado de alguien con muchas fichas; es más probable que tenga algunas para darte. Así que la última persona está en desventaja con respecto a la penúltima porque está al lado de la primera, que pierde fichas antes. Del mismo modo, la primera persona está en ventaja con respecto a la segunda porque la última pierde fichas más tarde.

No tengo pruebas de que esto sea lo que ocurre, pero parece explicar tus datos, y efectos similares aparecen definitivamente en otros lugares (por ejemplo, la mayoría de los estadísticos de béisbol afirman que deberías batear a tu mejor jugador en segundo lugar y a tu peor jugador en octavo lugar por aproximadamente estas razones).

Answer 2

Encontré este viejo post y pensé en revivirlo. Tuve exactamente la misma pregunta la primera vez que jugué a este juego hace un par de semanas, y también decidí hacer algunas simulaciones.

Acabé realizando 10.000.000 de simulaciones para partidas de 2, 3 y 4 jugadores, y por otro lado 1.000.000 de simulaciones para partidas de 5 a 10 jugadores. Luego registré el total de victorias de los jugadores / (número de partidas jugadas / número de jugadores). Esto da una estimación de cuánto mejor (o peor) funciona un jugador respecto a la distribución uniforme. Obtuve los siguientes datos (el $i^{th}$ es el índice $i^{th}$ de los jugadores, siendo el jugador cero el que rueda primero, el jugador uno el segundo, etc...):

                               [0.764, 1.235]
                           [0.956, 1.047, 0.997]
                       [0.988, 1.000, 0.985, 1.026] 
                   [0.998, 1.006, 0.982, 1.003, 1.012]
               [1.006, 1.003, 0.985, 0.986, 1.003, 1.017]
            [1.003, 1.010, 0.984, 0.991, 0.995, 1.005, 1.013]
        [1.009, 1.002, 0.993, 0.990, 0.987, 0.995, 1.006, 1.019]
    [1.008, 1.004, 0.992, 0.991, 0.977, 0.990, 0.999, 1.019, 1.020]
[1.010, 1.004, 0.989, 0.981, 0.988, 0.980, 0.996, 1.009, 1.019, 1.023]

Mi observación es que cuanto más lejos del rodillo inicial te encuentres (siendo la distancia el número mínimo de jugadores entre ellos y el rodillo inicial), peor será tu rendimiento, siendo el mejor rendimiento generalmente alcanzado por el jugador directamente a la derecha del rodillo inicial (es decir, la última persona en tirar en un juego jugado en el sentido de las agujas del reloj).

Para los que tengan curiosidad, aquí está mi código:

import random
import numpy

def lrc(num_players, num_games):

    wins = [0 for i in range(0,num_players)]

    # play num_games
    for game in range(0,num_games):
        # money in the center of the table
        center = 0     
        # distribution of money about the table                             
        table = [3 for i in range(0,num_players)]   
        # possible outcomes of a die roll
        outcomes = [0,0,0,1,2,3]               
        # number of players with non-zero number of chips     
        playing = numpy.count_nonzero(table)        

        while playing > 1:
            for i in range(0, num_players):
                if playing == 1:
                    break
                # check if player has money to play
                if table[i] == 0:
                    continue
                # How many dice the player gets to roll
                dice = min(3, table[i])
                # The player rolls the dice
                roll = [random.choice(outcomes) for x in range(0,dice)]

                # move money based on roll
                for j in range(0,len(roll)):
                    if roll[j] == 0:
                        continue
                    elif roll[j] == 1:
                        table[(i-1)%num_players] = table[(i-1)%num_players] + 1
                        table[i] = table[i]-1
                        continue
                    elif roll[j] == 2:
                        table[(i+1)%num_players] = table[(i-1)%num_players]+1
                        table[i] = table[i]-1
                        continue
                    else:
                        center = center + 1
                        table[i] = table[i]-1
                        continue

                # update number of players 'playing' (able to roll)
                playing = numpy.count_nonzero(table)
        winner = numpy.nonzero(table)[0][0]
        wins[winner] = wins[winner]+1
    win_perc = [x/(num_games+0.0) for x in wins]
    print(win_perc)