Questa sfida è legata a Flipping Pancakes .

Potresti aver sentito parlare dell'ordinamento dei pancake , in cui una pila di pancake viene ordinata in base alle dimensioni inserendo la spatola nella pila e capovolgendo tutti i pancake sopra la spatola, fino a quando i pancake vengono ordinati dal più piccolo al più grande sul piatto. Il problema del pancake bruciato è leggermente diverso. Tutti i pancake ora hanno un lato bruciato e il lato bruciato di ogni pancake deve essere rivolto verso il piatto una volta completato lo smistamento.

Ad esempio, dato il seguente stack (dimensione del pancake a sinistra. Che 0significa lato bruciato in basso e 1significato lato bruciato in alto a destra):

1 0
3 1
2 1

Puoi capovolgere l'intero stack per ottenere 20 30 11, capovolgere i primi due per ottenere 31 21 11e capovolgere di nuovo l'intero stack per ottenere 10 20 30, una pila ordinata di pancake bruciati. Questa sequenza di mosse, flip 3, flip 2, flip 3, potrebbe essere rappresentata come 3 2 3.

La sfida

• Data una serie di dimensioni di pancake (non necessariamente univoci) e i loro orientamenti, producono una sequenza di ordinamento di pancake bruciata valida, ovvero una sequenza di capriole che porta alla pila di pancake dal più piccolo al più grande con i lati bruciati verso il basso.
• L'input e l'output possono essere di qualsiasi formato sano con i separatori, ma si prega di specificare quali formati si utilizzano e indicare quale estremità del formato di input è la parte superiore dello stack (TOS).
• È consentito lanciare zero frittelle.
• È consentito mescolare separatori nell'ingresso / uscita.

Casi test

Per tutti i seguenti casi di test, l'input è un elenco e l'output è una stringa separata da spazio e TOS è a sinistra.

[[1, 0], [3, 1], [2, 1]]
"3 2 3"

[[5, 1], [3, 0], [4, 1], [2, 1], [1, 0]]
"5 3 4 1 3 2 1"

[[5, 1], [3, 0], [3, 0], [1, 1]]
"4 3 2 3"

Come sempre, se qualcosa non è chiaro o errato, per favore fatemi sapere nei commenti. Buona fortuna e buon golf!

Python 2, 83

Si prevede che l'input sia l'elenco di tuple (dimensioni, orientamento) con la parte superiore della pila alla fine. L'output è un elenco di dimensioni da capovolgere separate da vari tipi di spazi bianchi.

a=input()
while a:i=a.index(max(a));print len(a)-i,a[i][1],len(a),i;a=a[i+1:]+a[:i]

CJam (37 byte)

q~{__$W>#)_p/(W%\M*2,f.^+(1=p_,)pW%}h

L'input è un array in formato CJam su stdin; l'output è un elenco separato da righe di lunghezze di inversione su stdout. La parte superiore dello stack è all'indice 0; 0indica il lato bruciato verso l'alto e 1indica il lato bruciato verso il basso.

Demo online

Dissezione

L'output è sempre 3nlungo, dov'è nil numero di pancake. Per prima cosa capovolgiamo il pancake rimasto più grande verso l'alto; quindi se è bruciato con il lato in giù, lanciamo quell'unico pancake; e poi lo capovolgiamo sul fondo e ripetiamo come se la pila di pancake fosse più corta.

q~         e# Parse input into array
{          e# Loop...
  __$W>#)  e#   Find 1-based index of largest element in array
  _p       e#   Dup and print
  /(       e#   Split into chunks that long, and pull off the first
  W%       e#   Reverse the first chunk. Note that we don't flip the burnt/unburnt bit
  \M*      e#   Merge the remaining chunks into a single array
  2,f.^    e#   Flip *their* burnt/unburnt bits
  +        e#   Concatenate, prepending the first chunk
  (1=p     e#   Pull off the first (largest) element and print its burnt/unburnt bit
  _,)p     e#   Print the number of remaining elements plus 1 (to account for the largest)
  W%       e#   Reverse. Note that the first chunk has now been flipped twice, which is
           e#   why we have left its burnt/unburnt bit alone
}h         e# ... until we get down to an empty array

Rubino, 101 95 93 byte

Non molto da golf, volevo solo fare una variante bogo-sort. È una funzione anonima che prende una serie di array e stampa i capovolgimenti casuali su stdout fino a quando i pancake non vengono ordinati.

->a{(p r=-~rand(a.size)
a[0,r]=a[0,r].reverse.map{|x,b|[x,1-b]})while a!=a.sort||a.rassoc(1)}

Ad esempio, puoi assegnarlo fe diref.call [[1, 0], [3, 1], [2, 1]]

-5 byte da @Jordan con l'uso brillante di rassoc
-2 byte da @ Sherlock9