Ad Alice e Bob piace giocare a carte, con un mazzo di carte numerate con numeri interi non negativi consecutivi.

Tuttavia, Alice ha un modo molto particolare di mescolare il mazzo. Per prima cosa, prende la prima carta dal mazzo e la mette in fondo al mazzo. Quindi rimuove la carta successiva e inizia una pila con essa. Quindi, di nuovo, sposta la carta in cima al fondo e mette la nuova carta in cima al mazzo. Ripete questo processo fino a quando non ha svuotato il mazzo, a quel punto il mazzo è il nuovo mazzo.

  deck     |  pile
-----------+-----------
 3 1 4 0 2 | 
 1 4 0 2 3 | 
 4 0 2 3   |         1
 0 2 3 4   |         1
 2 3 4     |       0 1
 3 4 2     |       0 1
 4 2       |     3 0 1
 2 4       |     3 0 1
 4         |   2 3 0 1
           | 4 2 3 0 1
 4 2 3 0 1 | 

^{Figura 1: Alice esegue il suo shuffle sul mazzo da 5 carte "3, 1, 4, 0, 2". Il retro delle carte è rivolto verso sinistra.}

Un giorno Bob annuncia che si sta prendendo una settimana di vacanza. Alice, non avendo nessuno con cui giocare, arruola la sua amica Eva. Ora, Eva è un imbroglione spudorato, quindi quando vede la particolare mescolanza di Alice, si rende conto che può impilare il mazzo in anticipo a suo vantaggio!

Quando Eva torna a casa dopo il primo giorno, fa alcune analisi sul gioco e scopre che le sue migliori probabilità sono quando le carte sono nell'ordine 0, 1, 2, 3, 4, 5, ... cattura quante carte c'erano nel mazzo, quindi, quindi tratteggia uno schema sfrenato per scrivere un codice sul braccio che, quando lanciato, prende le dimensioni del mazzo e mostra l'ordine in cui Eva deve mettere le carte, così che quando Alice mescola il mazzo, il mazzo finale è nell'ordine 0, 1, 2, 3, ...

Non importa davvero in quale lingua sia il codice (lei li conosce tutti), o se il codice è una funzione che prende un argomento intero e restituisce un array, o un programma completo che prende input tramite un argomento della riga di comando o STDIN e scrivendo i risultati su STDOUT. Tuttavia, ha bisogno del codice il più breve possibile, per ridurre al minimo la possibilità che Alice lo veda e la catturi.

Per quanto immorale, ragazzi, potete aiutare Eve?

Ingressi e uscite di esempio:

in  out
 1  0
 2  0 1
 5  2 4 0 3 1
10  2 9 4 8 0 7 3 6 1 5
52  6 51 25 50 12 49 24 48 1 47 23 46 11 45 22 44 5 43 21 42 10 41 20 40 2 39 19
    38 9 37 18 36 4 35 17 34 8 33 16 32 0 31 15 30 7 29 14 28 3 27 13 26

GolfScript, 15 14 13 byte

])~,{\+)\+}/`

Provalo online.

Esempio

$ golfscript alice.gs <<< 10
[2 9 4 8 0 7 3 6 1 5]

Come funziona

])    # Collect the stack into an array and pop. This leaves [] below the input string.
~     # Interpret the input string.
,     # For input “N”, push the array [ 0 … N-1 ] (the pile).
{     # For each card on the pile:
  \+  # Put the card on top of the deck.
  )   # Remove a card from the bottom of the deck.
  \+  # Put the card on top of the deck.
}/    #
`     # Convert the deck into a string.

Julia, 83

u(n)=(a=[n-1:-1:0];l=Int[];[push!(l,shift!(push!(l,pop!(a)))) for i=1:length(a)];l)

L'ultimo elemento nel vettore restituito è la parte superiore del mazzo.

Mathematica, 92 77 46 byte

Prevede l'input in variabile n:

l={};(l=RotateRight[{#-1}~Join~l])&/@Range@n;l

Sta letteralmente giocando il shuffle all'indietro, spostando una carta e poi mettendo in cima la carta in basso.

EDIT: non c'è bisogno di tenere traccia dello stack di output, basta iterare attraverso gli interi.

Python 2.7 - 57

d=[0]
for j in range(1,input()):d=[d.pop()]+[j]+d
print d

Bello e semplice, basta invertire lo shuffle. Abbastanza vicino a come lo fa Golfscript.

J (13 caratteri) e K (9)

A quanto pare, è un semplice processo per annullare la riproduzione casuale e i Mi piace APL hanno il piega avverbio /per aiutarli a renderlo il più breve possibile.

J prende 13 char (_1|.,)/@i.@-, mentre K deve solo 9: |(1!,)/!:. APL sarebbe altrettanto conciso.

Ecco una traccia dettagliata della versione J.

(_1|.,)/@i.@- 4                  NB. recall that J is right-associative
(_1|.,)/@i. - 4                  NB. u@v y  is  u v y
(_1|.,)/@i. _4                   NB. monad - is Negate
(_1|.,)/ i. _4                   NB. @
(_1|.,)/ 3 2 1 0                 NB. monad i. is Integers, negative arg reverses result
3 (_1|.,) 2 (_1|.,) 1 (_1|.,) 0  NB. u/ A,B,C  is  A u B u C
3 (_1|.,) 2 (_1|.,) _1 |. 1 , 0  NB. x (M f g) y  is  M f x g y
3 (_1|.,) 2 (_1|.,) _1 |. 1 0    NB. dyad , is Append
3 (_1|.,) 2 (_1|.,) 0 1          NB. dyad |. is Rotate
3 (_1|.,) _1 |. 2 , 0 1          NB. repeat ad nauseam
3 (_1|.,) _1 |. 2 0 1
3 (_1|.,) 1 2 0
_1 |. 3 , 1 2 0
_1 |. 3 1 2 0
0 3 1 2

Si potrebbe notare che nella J, invertiamo l'array di interi prima, ma nel K lo facciamo in seguito: questo perché la K piega è più simile a un foldl, rispetto al J foldr.