Bulgarian Solitaire , Martin Gardner tarafından Scientific American'daki matematiksel sütununda popüler hale getirilen tek oyunculu bir oyundur .

NKazıklara bölünmüş özdeş kartlarınız var . Her desteden bir kart alıp, çıkarılan kartlarla yeni bir yığın oluşturuyorsunuz. Daha önce gördüğünüz bir duruma ulaşıncaya kadar bu işlemi tekrar edersiniz, böylece devam etmek döngüyü tekrarlar.

Örneğin, 8bir yığın 5ve bir yığın halinde bölünmüş kartlarınız olduğunu varsayalım 3. Biz azalan sırada kazık boyutları yazın: 5 3. İşte oyunun bir transkripti:

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

Önce iki yığının her birinden bir kart çıkarırsınız ve 4ve 2yeni oluşturulmuş bir yığın yığını 2bırakırsınız 4 2 2. Bir sonraki adımda, bunlar 3 1 1yeni bir yığın ile takip eder 3. Son olarak, son adım daha önce ortaya çıkan boyut 1ve üretim yığınlarını boşaltır 4 2 2, böylece dururuz.

Kazık boyutlarının toplamının aynı kaldığına dikkat edin.

Amacınız, belirli bir başlangıç ​​yapılandırmasından oyunun böyle bir kopyasını yazdırmaktır. Bu kod golf, çok az bayt kazanır.

Giriş

İlk yığın boyutlarını temsil eden azalan sırada pozitif sayıların listesi. Girişi STDIN veya fonksiyon girişi ile alın. İstediğiniz listeye benzer bir yapı kullanabilirsiniz.

Toplam kart sayısını Ngiriş olarak alamazsınız .

Çıktı

Bulgar Solitaire oyununun geçtiği kazık boyutlarının sırasını yazdırın. Yazdırmanın gerekli olduğunu, iade edilmediğini unutmayın. Her adım kendi çizgisi olmalıdır.

Her satırda 0's' ile azalan sırada bir pozitif sayılar dizisi olmalıdır . Ayırıcılarınız ve başlangıç ​​ve bitiş simgeleriniz olabilir (örneğin, [3, 3, 1, 1]). Sayıların birden fazla basamağı olabilir, bu nedenle bir şekilde ayrılmalıdır.

Tekrara ulaşana kadar gördüğünüz yığın boyutu bölünmelerini yazdırın. Bu nedenle, ilk satır giriş olmalı ve son satır önceki satırın tekrarı olmalıdır. Başka tekrar olmamalıdır.

Test senaryoları

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

Bu benim python 2 cevabımın çevirisine oldukça yakın.

Örnek çalışma:

Giriş:

[4,4,3,2,1]

Çıktı:

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

Nasıl çalışır:

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 bayt

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

Çevrimiçi deneyin.

Örnek çalışma

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

açıklama

• Girdi bir lambda'ya argüman olarak alınır. Bekleyen bir Array.
• Önceki oyun durumları Hash g.
• Yeni bir oyun durumu oluşturmak Array#mapiçin tuşlarını kullanarak her öğeyi 1 azaltın , öğenin uzunluğunu Arrayöğe olarak ekleyin, azalan düzende sıralayın ve öğeyi silin 0.
• Bir oyun durumunun daha önce görülüp görülmediğini kontrol etmek giçin, yeni oyun durumu için bir anahtar olup olmadığını kontrol etmek yeterlidir.

CJam, 35 34 33 bayt

(Lanet olsun, CJam'da ilk gönderi yapmadığım bu elektrik kesintisi)

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

Giriş:

[1 1 1 1 1 1 1]

Çıktı:

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

Buradan çevrimiçi deneyin

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'ın cevabına benzer, ancak ekleri yerine ekleme yapar ve son iki satırı kaldırır.

Örnek çıktı:

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

Neredeyse kesinlikle daha da golf edilebilir. Burada deneyin.

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 bayt

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

Burada test edin. [5 3]STDIN alanına girişi CJam tarzı bir dizi gibi girin . Çıktı biçimi benzer, bu nedenle köşeli ayraçlar ve ayırıcılar gibi boşluklar.

Bu daha da aşağı golf olsa bile (ki bu kesinlikle mümkündür), Pyth ile bu yenmek için bir yolu yoktur. Belki de J. Explanation'ı daha sonra öğrenmenin zamanı gelmiştir.

JavaScript (E6) 113

Şimdiye kadarki en kötü giriş :(

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 konsolunda test

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

Çıktı

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

Piton 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

Bu sadece önceki tüm yinelemeleri hatırlar ve yenisinin bu listede olup olmadığını kontrol eder. Sonra yazdırır.

Örnek çalışma:

Giriş:

[4,4,3,2,1]

Çıktı:

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

Düzenleme: Ben golf için özellikleri yeniden okumak, artı golf bir sürü uyguladı.

Python 3: 89 karakter

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

Daha önce yayınlanan Python çözümleri gibi, ancak döngülerden ziyade özyinelemeli işlev çağrıları ile. Liste s, daha önce görülen bölmeleri saklar ve tekrarlama durumunda özyinelemeyi kısa devre yapar.

İşlev print()(bu Python 3'tür) her döngüde bir şekilde çağrılmalıdır. Zor olan şey, lambdasadece tek bir ifadeye izin vermesidir, bu yüzden yapamayız print(l);.... Ayrıca, Noneçalışmak zor olan çıktılar . Ben print(l)bir eşitsizliğin bir tarafına geçiyorum; ==anlamadım nedense çalışmıyor.

Listeye yapıştırmanın alternatif bir yaklaşımı eşit sayıda karakter kullanır.

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

Kullanmak print(*l), çıktıları 4 2 2değil gibi biçimlendirir [4,2,2].