Alice et Bob aiment jouer à un jeu de cartes, avec un jeu de cartes numérotées avec des entiers non négatifs consécutifs.

Alice a cependant une façon très particulière de mélanger le jeu. Tout d'abord, elle prend la carte du dessus du paquet et la place au bas du paquet. Elle retire ensuite la carte suivante et commence une pile avec elle. Ensuite, elle fait de nouveau défiler la carte du haut vers le bas et place la nouvelle carte du haut dans la pile. Elle répète ce processus jusqu'à ce qu'elle ait vidé le jeu, auquel cas la pile est le nouveau jeu.

  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 | 

^{Figure 1: Alice effectue son mélange sur le jeu de 5 cartes "3, 1, 4, 0, 2". Les dos des cartes sont tous tournés vers la gauche.}

Un jour, Bob annonce qu'il prend une semaine de vacances. Alice, n'ayant personne avec qui jouer, enrôle son amie Eve. Maintenant, Eve est un tricheur sans vergogne, alors quand elle voit le remaniement particulier d'Alice, elle se rend compte qu'elle peut au préalable empiler le jeu à son avantage!

Quand Eve rentre à la maison après le premier jour, elle fait une analyse du jeu et découvre que ses meilleures chances sont quand les cartes sont dans l'ordre 0, 1, 2, 3, 4, 5, ... Elle n'a pas attrapez le nombre de cartes dans le jeu, cependant, elle élabore un schéma farfelu pour écrire du code sur son bras qui, une fois exécuté, prend la taille du jeu et affiche l'ordre dans lequel Eve doit mettre les cartes, de sorte que lorsque Alice mélange le jeu, le jeu final est dans l'ordre 0, 1, 2, 3, ...

Peu importe Eve dans quelle langue le code est (elle les connaît tous), ou si le code est une fonction prenant un argument entier et renvoyant un tableau, ou un programme complet prenant une entrée via un argument de ligne de commande ou STDIN et écrire les résultats à STDOUT. Elle a cependant besoin du code le plus court possible pour minimiser les chances qu'Alice le voie et la rattrape.

Aussi immoral que cela puisse être, pouvez-vous aider Eve?

Exemples d'entrées et sorties:

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 octets

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

Essayez-le en ligne.

Exemple

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

Comment ça fonctionne

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

Le dernier élément du vecteur renvoyé est le haut du jeu.

Mathematica, 92 77 46 octets

Attend l'entrée en variable n:

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

Il s'agit simplement de jouer le shuffle à l'envers, en passant sur une carte, puis en plaçant la carte du bas sur le dessus.

EDIT: Pas besoin de garder une trace de la pile de sortie, il suffit de parcourir les entiers.

Python 2.7 - 57

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

Agréable et simple, il suffit d'inverser le shuffle. Assez proche de la façon dont Golfscript le fait.

J (13 caractères) et K (9)

En fin de compte, c'est un processus simple pour annuler le mélange, et les goûts APL ont l'adverbe de pli /pour les aider à rendre cela aussi court que possible.

J 13 prend carbonisation avec (_1|.,)/@i.@-, tandis que K a besoin seulement 9: |(1!,)/!:. APL serait également laconique.

Voici une trace étape par étape de la version 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

Vous remarquerez peut - être que dans le J, nous avons inversé le tableau d'entiers en premier lieu , mais dans le K nous le faisons par la suite: cela est parce que le K est un facteur plus comme un foldl, par rapport à la J de foldr.