保加利亚纸牌是马丁·加德纳（Martin Gardner）在《科学美国人》的数学专栏中最受欢迎的单人游戏。

您有N相同的卡片，分成几堆。您从每堆纸牌中取出一张纸牌，并与移除的纸牌形成新纸堆。您重复此过程，直到达到已经看到的状态，因此继续操作将重复该循环。

例如，假设您有8几张纸牌，分成一堆5和一堆3。我们在写从大到小的顺序堆大小：5 3。这是游戏的文字记录：

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

首先，您从两堆纸叠中各取出一张卡片，留下堆4和2，以及新堆成的2给予4 2 2。下一步，将这些减小到3 1 1一堆新的3。最终，最后一步清空了已经出现的一堆堆大小1和产量4 2 2，因此我们停止了。

请注意，桩大小的总和保持不变。

您的目标是从给定的起始配置中打印游戏的副本。这是代码高尔夫，所以最少的字节获胜。

输入项

代表初始堆大小的降序正数列表。通过STDIN或功能输入进行输入。您可以使用所需的任何类似列表的结构。

您没有得到总卡数N作为输入。

输出量

打印保加利亚纸牌游戏所经历的桩号顺序。请注意，需要打印，不能返回。每个步骤应该是自己的一行。

每行应有一个正数序列，其降序为no 0。您可能有分隔符以及开始标记和结束标记（例如[3, 3, 1, 1]）。这些数字可能有多个数字，因此应以某种方式将它们分开。

打印您看到的绒头大小的裂缝，直到达到并包括重复为止。因此，第一行应该是输入，最后一行应该是前一行的重复。不应有其他重复。

测试用例

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

佩斯40 25

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

这与我的python 2答案的翻译非常接近。

样品运行：

输入：

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

怎么运行的：

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个字节

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

在线尝试。

运行示例

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

露比（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}}

说明

• 输入作为lambda的参数。它期望Array。
• 以前的游戏状态存储在 Hash g。
• 要创建新的游戏状态，请使用Array#map将每个元素减少1的方式，将元素的长度添加Array为元素，以降序对其进行排序，然后删除该元素0。
• 要检查以前是否已看到游戏状态，g只需检查是否具有用于新游戏状态的键就足够了。

CJam，35 34 33字节

（该死的断电使我不是第一个在CJam发表的人）

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

输入：

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

在这里在线尝试

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

与Quincunx的答案类似，但是用加法替换追加，并删除最后两行。

样本输出：

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

高尔夫脚本，50 46

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

几乎可以肯定会进一步打高尔夫球。在这里尝试。

哈斯克尔（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字节

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

在这里测试。[5 3]在STDIN字段中输入input作为CJam样式的数组，例如。输出格式相似，因此方括号和空格作为定界符。

即使我进一步打高尔夫球（这绝对是可能的），也没有办法击败Pyth。也许是时候学习J.稍后再进行解释。

JavaScript（E6）113

到目前为止最差的条目:(

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

在FireFox / FireBug控制台中测试

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

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

这样就可以记住所有先前的迭代，并检查新的迭代是否在该列表中。然后，将其打印出来。

样品运行：

输入：

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

编辑：我重新阅读了高尔夫的规格，并且应用了很多高尔夫。

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

类似于已经发布的Python解决方案，但是具有递归函数调用而不是循环。该列表s存储已经看到的拆分，并在重复的情况下缩短递归。

该函数print()（这是Python 3）仅需要在每个循环中以某种方式调用。棘手的事情是，a lambda只允许一个表达式，所以我们不能这样做print(l);...。此外，它输出None，很难使用。我结束了print(l)不平等的一面。==由于某些我不了解的原因而无法正常工作。

将其粘贴在列表中的另一种方法是使用相同数量的字符。

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

使用print(*l)将格式化输出，4 2 2而不是[4,2,2]。