บัลแกเรีย Solitaireเป็นเกมที่เล่นคนเดียวทำให้เป็นที่นิยมโดยมาร์ตินการ์ดเนอร์ของเขาในคอลัมน์ทางคณิตศาสตร์วิทยาศาสตร์อเมริกัน

คุณมี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เป็นอินพุต

เอาท์พุต

พิมพ์ลำดับของขนาดของกองเกมบัลแกเรียโซลิแทร์ โปรดทราบว่าจำเป็นต้องมีการพิมพ์ไม่ใช่ส่งคืน แต่ละขั้นตอนควรเป็นของตัวเอง

แต่ละบรรทัดควรจะมีลำดับของตัวเลขในเชิงบวกในลำดับถัดลงมาที่ไม่มี0's คุณอาจมีตัวคั่นและโทเค็นเริ่มต้นและจุดสิ้นสุด (ตัวอย่างเช่น[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

Pyth, 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}}

คำอธิบาย

• อินพุตถูกใช้เป็นอาร์กิวเมนต์สำหรับแลมบ์ดา Arrayมันคาดว่า
• Hash gเกมก่อนหน้านี้รัฐจะเก็บไว้ใน
• จะสร้างรัฐเกมใหม่ใช้Array#mapจะลดลงทุกองค์ประกอบโดยที่ 1 เพิ่มความยาวของที่เป็นองค์ประกอบการจัดเรียงไว้ในลำดับที่ลดลงและลบองค์ประกอบArray0
• หากต้องการตรวจสอบสถานะเกมก่อนหน้านี้ให้ตรวจสอบว่า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]

GolfScript, 50 46

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

สามารถเล่นกอล์ฟต่อไปได้อย่างแน่นอน ลองที่นี่

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 ไบต์

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

ทดสอบที่นี่ ป้อนอินพุตเป็นอาเรย์สไตล์ CJam เช่นเดียวกับ[5 3]ในฟิลด์ STDIN รูปแบบผลลัพธ์คล้ายกันดังนั้นวงเล็บเหลี่ยมและช่องว่างเป็นตัวคั่น

แม้ว่าฉันจะลงสนามนี้ต่อไป (ซึ่งเป็นไปได้แน่นอน) ไม่มีทางที่จะเอาชนะ Pyth ได้ อาจถึงเวลาที่จะเรียนรู้คำอธิบายเจมาในภายหลัง

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) เพียงแค่ต้องการเรียกอย่างใดอย่างหนึ่งในแต่ละวง สิ่งที่ยุ่งยากก็คือช่วยให้เพียงการแสดงออกเดียวดังนั้นเราจึงไม่สามารถทำได้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]