Paciência búlgaro é um jogo single-player popularizado por Martin Gardner em sua coluna matemática na Scientific American .

Você tem Ncartões idênticos, divididos em pilhas. Você pega uma carta de cada pilha e forma uma nova pilha com as cartas removidas. Você repete esse processo até chegar a um estado que já viu e, assim, continuar repetindo o loop.

Por exemplo, digamos que você tenha 8cartas, divida em uma pilha de 5e uma pilha de 3. Nós escrevemos os tamanhos pilha em ordem decrescente: 5 3. Aqui está uma transcrição do jogo:

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

Você primeiro remove um cartão de cada uma das duas pilhas, deixando pilhas de 4e 2, e uma pilha recém-criada de 2doações 4 2 2. Na próxima etapa, elas diminuem para 3 1 1seguidas com uma nova pilha de 3. Finalmente, o último passo esvazia as pilhas de tamanho 1e produz o 4 2 2que já apareceu, então paramos.

Observe que a soma dos tamanhos das pilhas permanece a mesma.

Seu objetivo é imprimir uma transcrição do jogo a partir de uma determinada configuração inicial. Isso é código de golfe, e o menor número de bytes vence.

Entrada

Uma lista de números positivos em ordem decrescente que representa os tamanhos de pilha iniciais. Receber entrada via STDIN ou entrada de função. Você pode usar qualquer estrutura de lista que desejar.

Você não recebe o número total de cartões Ncomo entrada.

Resultado

Imprima a sequência de tamanhos de pilha que o jogo de Paciência Búlgaro passa. Observe que a impressão é necessária, não retornando. Cada etapa deve ter sua própria linha.

Cada linha deve ter uma sequência de números positivos em ordem decrescente, sem números 0. Você pode ter separadores e tokens de início e de término (por exemplo [3, 3, 1, 1]). Os números podem ter vários dígitos, portanto devem ser separados de alguma forma.

Imprima as divisões de tamanho de pilha que você vê até incluir uma repetição. Portanto, a primeira linha deve ser a entrada e a última linha deve ser uma repetição de uma linha anterior. Não deve haver outras repetições.

Casos de teste

>> [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

Isso é bem parecido com a tradução da minha resposta python 2.

Exemplo de execução:

Entrada:

[4,4,3,2,1]

Resultado:

[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]

Como 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}/

Experimente online.

Exemplo de execução

$ 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}}

Explicação

• A entrada é tomada como argumento para uma lambda. Espera um Array.
• Os estados anteriores do jogo são armazenados no Hash g.
• Para criar um novo estado do jogo, use Array#mappara diminuir cada elemento em 1, adicione o comprimento de Arraycomo elemento, classifique-o em ordem decrescente e exclua o elemento 0.
• Para verificar se um estado do jogo já foi visto antes, gbasta verificar se há uma chave para o novo estado do jogo.

CJam, 35 34 33 bytes

(Droga, esse corte de energia que eu não fui o primeiro a postar no CJam)

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

Entrada:

[1 1 1 1 1 1 1]

Resultado:

[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]

Experimente online aqui

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

Semelhante à resposta do Quincunx, mas substitui os anexos pela adição e remove as duas últimas linhas.

Saída de amostra:

[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];

Quase certamente pode ser jogado ainda mais. Experimente aqui.

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;

Teste aqui. Digite a entrada como uma matriz no estilo CJam, como [5 3], no campo STDIN. O formato de saída é semelhante, portanto, colchetes e espaços como delimitadores.

Mesmo se eu jogar mais longe (o que é definitivamente possível), não há como vencer Pyth com isso. Talvez seja a hora de aprender J. Explicação mais tarde.

JavaScript (E6) 113

Pior entrada até agora :(

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)
}

Teste no console do FireFox / FireBug

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

Resultado

[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]

Python 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

Isso simplesmente lembra todas as iterações anteriores e verifica se a nova está nessa lista. Em seguida, imprime.

Exemplo de execução:

Entrada:

[4,4,3,2,1]

Resultado:

[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: reli as especificações para o golfe, além de aplicar muito golfe.

Caracteres Python 3: 89

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

Muito parecido com as soluções Python já postadas, mas com chamadas de função recursivas ao invés de loops. A lista sarmazena as divisões já vistas e provoca um curto-circuito na recursão em caso de repetição.

A função print()(este é Python 3) só precisa ser chamada de alguma forma em cada loop. O difícil é que lambdaapenas permite uma expressão única, então não podemos fazer print(l);.... Além disso, produz resultados Nonedifíceis de trabalhar. Acabo colocando print(l)de um lado uma desigualdade; ==não funciona por algum motivo que eu não entendo.

Uma abordagem alternativa de colocá-lo em uma lista usa igualmente muitos 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])

Usar print(*l)formataria as saídas como 4 2 2e não [4,2,2].