Bulgarian Solitaire es un juego para un jugador popularizado por Martin Gardner en su columna matemática en Scientific American .

Tienes Ncartas idénticas, divididas en pilas. Toma una carta de cada pila y forma una nueva pila con las cartas retiradas. Repites este proceso hasta que alcances un estado que ya has visto y, por lo tanto, continuar repitiendo el ciclo.

Por ejemplo, supongamos que tiene 8tarjetas, divididas en un montón de 5y un montón de 3. Escribimos los tamaños de pila en orden descendente: 5 3. Aquí hay una transcripción del juego:

5 3
4 2 2
3 3 1 1 
4 2 2

Primero quitas una carta de cada una de las dos pilas, dejando pilas de 4y 2, y una pila de 2donaciones recién creada 4 2 2. En el siguiente paso, estos disminuyen para 3 1 1seguir con un nuevo montón de 3. Finalmente, el último paso vacía las pilas de tamaño 1y produce lo 4 2 2que ya ha aparecido, así que nos detenemos.

Tenga en cuenta que la suma de los tamaños de pila permanece igual.

Su objetivo es imprimir una transcripción del juego desde una configuración inicial dada. Este es el código de golf, por lo que gana menos bytes.

Entrada

Una lista de números positivos en orden descendente que representa los tamaños de pila iniciales. Tomar entrada a través de STDIN o entrada de función. Puede usar cualquier estructura tipo lista que desee.

No obtienes el número total de tarjetas Ncomo entrada.

Salida

Imprime la secuencia de tamaños de pila que atraviesa el juego de Solitario búlgaro. Tenga en cuenta que se requiere imprimir, no regresar. Cada paso debe ser su propia línea.

Cada línea debe tener una secuencia de números positivos en orden descendente sin 0's'. Puede tener separadores y tokens de inicio y fin (por ejemplo, [3, 3, 1, 1]). Los números pueden tener varios dígitos, por lo que deben separarse de alguna manera.

Imprima las divisiones del tamaño de la pila que ve hasta e incluso llegando a repetir. Entonces, la primera línea debe ser la entrada, y la última línea debe ser una repetición de una línea anterior. No debería haber ninguna otra repetición.

Casos de prueba

>> [1]
1
1

>> [2]
2
1 1
2

>> [1, 1, 1, 1, 1, 1, 1]
1 1 1 1 1 1 1
7
6 1
5 2
4 2 1
3 3 1
3 2 2
3 2 1 1
4 2 1

>> [5, 3]
5 3
4 2 2
3 3 1 1
4 2 2

>> [3, 2, 1]
3 2 1
3 2 1

>> [4, 4, 3, 2, 1]
4 4 3 2 1
5 3 3 2 1
5 4 2 2 1
5 4 3 1 1
5 4 3 2
4 4 3 2 1

Pyth, 40 25

QW!}QY~Y]Q=Q_S+fTmtdQ]lQQ

Esto está bastante cerca de una traducción de mi respuesta de Python 2

Ejecución de muestra:

Entrada:

[4,4,3,2,1]

Salida:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

Cómo funciona:

Q                          Q = eval(input()) # automatic
 W!}QY                     while not Q in Y:
      ~Y]Q                     Y += [Q]
               fTmtdQ                     filter(lambda T: T, map(lambda d: d - 1, Q))
            _S+      ]lQ           sorted(                                             + [len(Q)])[::-1]
          =Q_S+fTmtdQ]lQ       Q = sorted(filter(lambda T: T, map(lambda d: d - 1, Q)) + [len(Q)])[::-1]
                        Q      print(Q)
QW!}QY~Y]Q=Q_S+fTmtdQ]lQQ

CJam, 26 bytes

q{~_:(_,+0-$W%]___&=}g{p}/

Pruébalo en línea.

Ejecución de ejemplo

$ cjam <(echo 'q{~_:(_,+0-$W%]___&=}g{p}/') <<< '[5 3]'
[5 3]
[4 2 2]
[3 3 1 1]
[4 2 2]

Ruby, 98

f=->c{g={c=>1}
p *loop{c=(c.map(&:pred)<<c.size).sort.reverse-[0]
g[c]?(break g.keys<<c): g[c]=1}}

Explicación

• La entrada se toma como argumentos para una lambda. Se espera un Array.
• Los estados anteriores del juego se almacenan en el Hash g.
• Para crear un nuevo estado de juego, use Array#mappara disminuir cada elemento en 1, agregue la longitud del Arrayelemento, ordénelo en orden decreciente y elimine el elemento 0.
• Para verificar si se ha visto un estado del juego antes, ges suficiente verificar si tiene una clave para el nuevo estado del juego.

CJam, 35 34 33 bytes

(Maldición, este corte de energía que no fui el primero en publicar en CJam)

l~{_p:(_,+{},$W%_`_S\#0<\S+:S;}g`

Entrada:

[1 1 1 1 1 1 1]

Salida:

[1 1 1 1 1 1 1]
[7]
[6 1]
[5 2]
[4 2 1]
[3 3 1]
[3 2 2]
[3 2 1 1]
[4 2 1]

Pruébalo en línea aquí

Python 2 - 103

p=input()
m=[]
print p
while p not in m:m+=[p];p=sorted([x-1 for x in p if x>1]+[len(p)])[::-1];print p

Similar a la respuesta de Quincunx, pero reemplaza los agregados con la suma y elimina las dos últimas líneas.

Salida de muestra:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

GolfScript, 50 46

~.p$[]{[1$]+\.{(.!";"*~}%\,+$.-1%p\.2$?)!}do];

Es casi seguro que se puede jugar más al golf. Pruébalo aquí.

Haskell, 99

import Data.List
g l=until(nub>>=(/=))(\l->l++[reverse$sort$length(last l):[x-1|x<-last l,x>1]])[l]

CJam, 40 36 34 bytes

]l~{a+_W=_p:(_,+$W%{},1$1$a#0<}gp;

Pruébalo aquí. Ingrese la entrada como una matriz de estilo CJam, como [5 3], en el campo STDIN. El formato de salida es similar, por lo que los corchetes y los espacios son delimitadores.

Incluso si sigo jugando golf más abajo (lo cual es definitivamente posible), no hay forma de vencer a Pyth con esto. Tal vez es hora de aprender J. Explicación más tarde.

JavaScript (E6) 113

La peor entrada hasta ahora :(

F=l=>{
  for(k=[];console.log(l),!k[l];)
    k[l]=l=[...l.map(n=>(p+=n>1,n-1),p=1),l.length].sort((a,b)=>b-a).slice(0,p)
}

Prueba en la consola FireFox / FireBug

F([4,4,3,2,1])

Salida

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

Pitón 2, 148 130 101

l=input()
s=[]
print l
while l not in s:s+=l,;l=sorted([i-1for i in l if 1<i]+[len(l)])[::-1];print l

Esto simplemente recuerda todas las iteraciones anteriores y verifica si la nueva está en esa lista. Luego, lo imprime.

Ejecución de muestra:

Entrada:

[4,4,3,2,1]

Salida:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

Editar: volví a leer las especificaciones de golf, además apliqué mucho golf.

Python 3: 89 caracteres

g=lambda l,s=[]:print(l)!=l in s or g(sorted([x-1for x in l if~-x]+[len(l)])[::-1],s+[l])

Al igual que las soluciones de Python ya publicadas, pero con llamadas a funciones recursivas en lugar de bucles. La lista salmacena las divisiones ya vistas y corta la recursión en caso de repetición.

La función print()(esto es Python 3) solo debe llamarse de alguna manera en cada bucle. Lo complicado es que a lambdasolo permite una sola expresión, por lo que no podemos hacerlo print(l);.... Además, da salida None, con lo que es difícil trabajar. Termino poniendo print(l)a un lado una desigualdad; ==no funciona por alguna razón que no entiendo.

Un enfoque alternativo de pegarlo en una lista utiliza igualmente muchos caracteres.

g=lambda l,s=[]:l in s+[print(l)]or g(sorted([x-1for x in l if~-x]+[len(l)])[::-1],s+[l])

El uso print(*l)formatearía las salidas como en 4 2 2lugar de [4,2,2].