Bulgarian Solitaire adalah permainan pemain tunggal yang dipopulerkan oleh Martin Gardner dalam kolom matematika di Scientific American .

Anda memiliki Nkartu yang identik, dibagi menjadi beberapa tumpukan. Anda mengambil kartu dari setiap tumpukan dan membentuk tumpukan baru dengan kartu yang dilepaskan. Anda mengulangi proses ini sampai Anda mencapai keadaan yang sudah Anda lihat dan melanjutkan akan mengulangi loop.

Misalnya, Anda memiliki 8kartu, terbagi menjadi tumpukan 5dan tumpukan 3. Kami menulis ukuran tumpukan di urutan menurun: 5 3. Berikut transkrip permainan:

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

Pertama-tama Anda mengeluarkan kartu dari masing-masing tumpukan, meninggalkan tumpukan 4dan 2, dan tumpukan 2pemberian yang baru dibuat 4 2 2. Pada langkah berikutnya, penurunan ini 3 1 1diikuti dengan tumpukan baru 3. Akhirnya, langkah terakhir mengosongkan tumpukan ukuran 1dan menghasilkan 4 2 2yang sudah muncul, jadi kami berhenti.

Perhatikan bahwa jumlah ukuran tumpukan tetap sama.

Tujuan Anda adalah mencetak transkrip permainan dari konfigurasi awal yang diberikan. Ini adalah kode golf, byte paling sedikit menang.

Memasukkan

Daftar angka positif dalam urutan menurun mewakili ukuran tumpukan awal. Ambil input melalui STDIN atau input fungsi. Anda dapat menggunakan struktur seperti daftar yang Anda inginkan.

Anda tidak mendapatkan jumlah kartu Nsebagai input.

Keluaran

Cetak urutan ukuran tumpukan yang dilalui permainan Solitaire Bulgaria. Perhatikan bahwa pencetakan diperlukan, bukan kembali. Setiap langkah harus menjadi garisnya sendiri.

Setiap baris harus memiliki urutan angka positif dalam urutan menurun tanpa 0's. Anda mungkin memiliki pemisah dan token awal dan akhir (misalnya, [3, 3, 1, 1]). Angka-angka mungkin memiliki beberapa digit, sehingga harus dipisahkan entah bagaimana.

Cetak pemisahan tumpukan yang Anda lihat sampai dan termasuk mencapai pengulangan. Jadi, baris pertama harus menjadi input, dan baris terakhir harus merupakan pengulangan dari baris sebelumnya. Seharusnya tidak ada pengulangan lainnya.

Uji kasus

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

Ini cukup dekat dengan terjemahan jawaban python 2 saya.

Contoh dijalankan:

Memasukkan:

[4,4,3,2,1]

Keluaran:

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

Bagaimana itu bekerja:

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 byte

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

Cobalah online.

Contoh dijalankan

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

Penjelasan

• Masukan diambil sebagai argumen untuk lambda. Diharapkan Array.
• Status gim sebelumnya disimpan di Hash g.
• Untuk membuat status permainan baru, gunakan Array#mapuntuk mengurangi setiap elemen sebanyak 1, tambahkan panjang Arrayelemen, mengurutkannya dalam urutan menurun dan menghapus elemen 0.
• Untuk memeriksa apakah keadaan permainan telah terlihat sebelumnya, memeriksa apakah gmemiliki kunci untuk keadaan permainan baru sudah cukup.

CJam, 35 34 33 byte

(Sial, pemadaman listrik ini bahwa saya bukan orang pertama yang memposting di CJam)

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

Memasukkan:

[1 1 1 1 1 1 1]

Keluaran:

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

Cobalah online di sini

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

Mirip dengan jawaban Quincunx, tetapi mengganti menambahkan dengan penambahan, dan menghapus dua baris terakhir.

Output sampel:

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

Hampir bisa dipastikan golf lebih lanjut. Cobalah di sini.

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 byte

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

Uji di sini. Masukkan input sebagai larik gaya CJam, seperti [5 3], ke dalam bidang STDIN. Format output mirip, jadi kurung dan spasi persegi sebagai pembatas.

Bahkan jika saya memainkan ini lebih jauh (yang pasti mungkin), tidak ada cara untuk mengalahkan Pyth dengan ini. Mungkin sudah waktunya untuk belajar J. Penjelasan datang nanti.

JavaScript (E6) 113

Entri terburuk sejauh ini :(

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

Uji di konsol FireFox / FireBug

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

Keluaran

[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

Ini hanya mengingat semua iterasi sebelumnya, dan memeriksa apakah yang baru ada dalam daftar itu. Kemudian, ia mencetaknya.

Contoh dijalankan:

Memasukkan:

[4,4,3,2,1]

Keluaran:

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

Sunting: Saya membaca ulang spesifikasi untuk golf, plus menerapkan banyak golf.

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

Sama seperti solusi Python yang sudah diposting, tetapi dengan panggilan fungsi rekursif daripada loop. Daftar smenyimpan perpecahan yang sudah terlihat, dan hubung singkat rekursi jika terjadi pengulangan.

Fungsi print()(ini adalah Python 3) hanya perlu dipanggil entah bagaimana di setiap loop. Yang sulit adalah bahwa lambdahanya memungkinkan satu ekspresi, jadi kita tidak bisa melakukannya print(l);.... Juga, ini menghasilkan None, yang sulit untuk dikerjakan. Saya akhirnya menempatkan print(l)di satu sisi ketidaksetaraan; ==tidak bekerja karena alasan yang tidak saya mengerti.

Pendekatan alternatif menempelkannya dalam daftar menggunakan banyak karakter.

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

Menggunakan print(*l)akan memformat output seperti 4 2 2daripada [4,2,2].