Bulgarian Solitaire è un gioco per giocatore singolo reso popolare da Martin Gardner nella sua rubrica matematica in Scientific American .

Hai Ncarte identiche, divise in pile. Prendi una carta da ogni pila e formi una nuova pila con le carte rimosse. Ripeti questo processo fino a raggiungere uno stato che hai già visto e quindi continuare ripetendo il ciclo.

Ad esempio, supponi di avere 8carte, divise in una pila di 5e una pila di 3. Scriviamo le dimensioni pila in ordine decrescente: 5 3. Ecco una trascrizione del gioco:

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

Per prima cosa rimuovi una carta da ciascuna delle due pile, lasciando pile di 4e 2, e una pila appena creata di 2, dare 4 2 2. Nel passaggio successivo, questi diminuiscono a 3 1 1seguito con una nuova pila di 3. Infine, l'ultimo passaggio svuota le pile di dimensioni 1e produce ciò 4 2 2che è già apparso, quindi ci fermiamo.

Si noti che la somma delle dimensioni della pila rimane invariata.

Il tuo obiettivo è stampare una tale trascrizione del gioco da una determinata configurazione iniziale. Questo è il golf del codice, quindi vince meno byte.

Ingresso

Un elenco di numeri positivi in ​​ordine decrescente che rappresentano le dimensioni iniziali della pila. Accetta input tramite STDIN o input funzione. Puoi usare qualsiasi struttura simile a una lista che desideri.

Non ottieni il numero totale di carte Ncome input.

Produzione

Stampa la sequenza delle dimensioni delle pile che attraversa il gioco del solitario bulgaro. Si noti che è richiesta la stampa, non di ritorno. Ogni passaggio dovrebbe essere la sua linea.

Ogni riga dovrebbe avere una sequenza di numeri positivi in ​​ordine decrescente senza numeri 0. Potresti avere separatori e token di inizio e fine (ad esempio, [3, 3, 1, 1]). I numeri potrebbero avere più cifre, quindi dovrebbero essere separati in qualche modo.

Stampa le spaccature di dimensioni della pila che vedi fino a e compreso il raggiungimento di una ripetizione. Quindi, la prima riga dovrebbe essere l'input e l'ultima riga dovrebbe essere una ripetizione di una riga precedente. Non dovrebbero esserci altre ripetizioni.

Casi test

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

Questo è abbastanza vicino a una traduzione della mia risposta a Python 2.

Esecuzione di esempio:

Ingresso:

[4,4,3,2,1]

Produzione:

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

Come funziona:

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

Provalo online.

Esempio di esecuzione

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

Spiegazione

• L'input viene preso come argomento per un lambda. Si aspetta un Array.
• Gli stati di gioco precedenti sono memorizzati in Hash g.
• Per creare un nuovo stato di gioco, utilizzare Array#mapper ridurre ogni elemento di 1, aggiungere la lunghezza di Arraycome elemento, ordinarlo in ordine decrescente ed eliminare l'elemento0 .
• Per verificare se uno stato del gioco è stato visto prima, gè sufficiente controllare se ha una chiave per il nuovo stato del gioco.

CJam, 35 34 33 byte

(Accidenti, questa interruzione di corrente che non sono stato il primo a pubblicare in CJam)

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

Ingresso:

[1 1 1 1 1 1 1]

Produzione:

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

Provalo online qui

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

Simile alla risposta di Quincunx, ma sostituisce gli allegati con l'aggiunta e rimuove le ultime due righe.

Uscita campione:

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

Quasi sicuramente si può giocare a golf. Provalo qui.

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;

Provalo qui. Immettere input come un array in stile CJam, come [5 3], nel campo STDIN. Il formato di output è simile, quindi parentesi quadre e spazi come delimitatori.

Anche se lo golfò ulteriormente (il che è sicuramente possibile), non c'è modo di battere Pyth con questo. Forse è tempo di imparare J. Spiegazione che verrà dopo.

JavaScript (E6) 113

La peggiore voce finora :(

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

Test nella console FireFox / FireBug

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

Produzione

[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

Questo semplicemente ricorda tutte le iterazioni precedenti e controlla se quella nuova è in quella lista. Quindi lo stampa.

Esecuzione di esempio:

Ingresso:

[4,4,3,2,1]

Produzione:

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

Modifica: rileggo le specifiche al golf, oltre ad applicare molto golf.

Python 3: 89 caratteri

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

Proprio come le soluzioni Python già pubblicate, ma con chiamate di funzione ricorsive piuttosto che loop. L'elenco smemorizza le divisioni già viste e cortocircuita la ricorsione in caso di ripetizione.

La funzione print()(questo è Python 3) deve essere chiamata in qualche modo in ogni ciclo. La cosa difficile è che lambdaconsente solo una singola espressione, quindi non possiamo farlo print(l);.... Inoltre, produce output None, con cui è difficile lavorare. Finisco col mettere print(l)da parte una disuguaglianza;==non funziona per qualche motivo che non capisco.

Un approccio alternativo per inserirlo in un elenco utilizza ugualmente molti caratteri.

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

L'utilizzo print(*l)formattarebbe gli output come 4 2 2piuttosto che come [4,2,2].