Le but de ce puzzle est de prendre un jeu de 52 cartes et de le mélanger pour que chaque carte soit dans une position aléatoire.

Donné:

• Un tableau, deckde 52 entiers distincts représentant les cartes. Lorsque vous commencez, deckcontient exactement une de chaque carte dans un ordre inconnu.
• Une fonction int rand(min, max),, qui renvoie un entier aléatoire entre les entiers minet max, inclus. Vous pouvez supposer que cette fonction est vraiment aléatoire.
• Une fonction, void swap(x, y)qui échange deux cartes dans le jeu. Si vous appelez swap(x, y), les cartes aux positions xet ychangeront de place.

Quand:

• Le programme appelle shuffle()(ou shuffle(deck)ou deck.shuffle()ou comme votre implémentation aime s'exécuter),

Alors:

• deck doit contenir exactement une de chaque carte dans un ordre parfaitement aléatoire.

The Catch:

Vous ne pouvez déclarer aucune variable. Appelez swapet randautant que vous le souhaitez, mais vous ne pouvez pas déclarer vos propres variables. Cela inclut les forcompteurs de boucles - même ceux implicites comme dans a foreach.

Clarifications:

• Vous pouvez modifier des détails mineurs en fonction de la langue choisie. Par exemple, vous pouvez écrire swappour commuter deux entiers par référence. Les changements devraient être de faire fonctionner cela avec votre langue, et non de rendre le puzzle plus facile.
• deck peut être une variable globale, ou vous pouvez l'intégrer comme paramètre.
• Vous pouvez faire tout ce que vous voulez sur le contenu deck, mais vous ne pouvez pas changer sa longueur.
• Vos cartes peuvent être numérotées 0-51, 1-52 ou tout ce que vous voulez.
• Vous pouvez écrire ceci dans n'importe quelle langue, mais sans tricher avec la fonction intégrée de votre langue shuffle.
• Oui, vous pouvez écrire la même ligne 52 fois. Personne ne sera impressionné.
• Le temps d'exécution n'a pas d'importance, mais le vrai hasard le fait.
• Ce n'est pas vraiment du golf de code, mais n'hésitez pas à minimiser / obscurcir votre code.

Edit: code de chaudière et visualiseur

Si vous avez utilisé .NET ou JavaScript, voici un code de test qui peut vous être utile:

JavaScript:

• Visualiseur JavaScript rapide et sale, avec source CoffeeScript: https://gist.github.com/JustinMorgan/3989752bdfd579291cca
• Version exécutable (collez simplement votre shuffle()fonction): http://jsfiddle.net/4zxjmy42/

C #:

• Visualiseur ASP.NET avec code C # derrière: https://gist.github.com/JustinMorgan/4b630446a43f28eb5559
• Stub avec uniquement les méthodes swapet randutilitaires: https://gist.github.com/JustinMorgan/3bb4e6b058d70cc07d41

Ce code trie et mélange le paquet plusieurs milliers de fois et effectue des tests d'intégrité de base: pour chaque mélange, il vérifie qu'il y a exactement 52 cartes dans le paquet sans répétition. Ensuite, le visualiseur trace la fréquence de chaque carte se terminant à chaque endroit du jeu, affichant une carte de chaleur en niveaux de gris.

La sortie du visualiseur doit ressembler à de la neige sans motif apparent. Évidemment, cela ne peut pas prouver le vrai hasard, mais c'est un moyen rapide et facile de vérifier par sondage. Je recommande de l'utiliser ou quelque chose comme ça, car certaines erreurs dans l'algorithme de brassage conduisent à des modèles très reconnaissables dans la sortie. Voici un exemple de la sortie de deux implémentations, l'une avec une faille commune:

La version défectueuse mélange partiellement le jeu, donc pourrait bien paraître si vous avez examiné le tableau à la main. Le visualiseur permet de remarquer plus facilement un motif.

Javascript

Je crois que c'est la forme de solution envisagée, j'utilise la carte en position 0 pour suivre les progrès, en mélangeant uniquement les cartes qui ont déjà été utilisées comme compteur, cela atteint la norme 52! permutations avec une distribution égale parfaite. La procédure est compliquée par l'échange XOR qui ne permet pas qu'un élément soit échangé par lui-même.

Edit: J'ai intégré un tri qui trie chaque élément en place juste avant son utilisation, permettant ainsi à cela de fonctionner avec un tableau non trié. J'ai également abandonné les appels récursifs en faveur d'une boucle while.

deck=[]
for(a=0;a<52;a++){
    deck[a]=a
}
function swap(a,b){
    deck[a]=deck[b]^deck[a]
    deck[b]=deck[b]^deck[a]
    deck[a]=deck[b]^deck[a]
}
function rand(a,b){
    return Math.floor(Math.random()*(1+b-a))+a
}
function shuffle(){
    while(deck[0]!=0){ //Sort 0 into element 0
        swap(0,deck[0])
    }
    while(deck[0]<51){ //Run 51 times
        while(deck[deck[0]+1]!=deck[0]+1){ //Sort element deck[0]+1 into position deck[0]+1
            swap(deck[deck[0]+1],deck[0]+1)
        }
        swap(0,deck[0]+1) //Swap element deck[0]+1 into position 0, thus increasing the value of deck[0] by 1
        if(rand(0,deck[0]-1)){ //Swap the element at position deck[0] to a random position in the range 1 to deck[0]
            swap(deck[0],rand(1,deck[0]-1))
        }
    }
    if(rand(0,51)){ //Swap the element at position 0 to a random position
        swap(0,rand(1,51))
    }
}
for(c=0;c<100;c++){
    shuffle()
    document.write(deck+"<br>")
}

Haskell

Voici une implémentation sans point. Aucune variable, paramètre formel ou récursivité explicite. J'ai beaucoup utilisé la fonction de refactorisation de lambdabot@pl ("inutile").

import Data.List
import Control.Applicative
import Control.Monad
import System.Random

shuffle :: [a] -> IO [a]
shuffle = liftM2 (<$>) ((fst .) . foldl' (uncurry ((. flip splitAt) . (.) .
          (`ap` snd) . (. fst) . flip flip tail . (ap .) . flip flip head .
          ((.) .) . (. (++)) . flip . (((.) . (,)) .) . flip (:))) . (,) [])
          (sequence . map (randomRIO . (,) 0 . subtract 1) . reverse .
          enumFromTo 1 . length)

main = print =<< shuffle [1..52]

Voici ma procédure de test pour m'assurer que les nombres ont été uniformément distribués:

main = print . foldl' (zipWith (+)) (replicate 52 0)
       =<< replicateM 1000 (shuffle [1..52])

Voici l'algorithme d'origine:

shuffle :: [a] -> IO [a]
shuffle xs = shuffleWith xs <$>
             sequence [randomRIO (0, i - 1) | i <- reverse [1..length xs]]

shuffleWith :: [a] -> [Int] -> [a]
shuffleWith xs ns = fst $ foldl' f ([], xs) ns where
    f (a,b) n = (x:a, xs++ys) where
        (xs, x:ys) = splitAt n b

J

Ignorer ce deck est une variable, il y a une évidence ...

52 ? 52

Bien sûr, si vous voulez vraiment une fonction, il y a celle-ci, qui fonctionnera même si vous oubliez de supprimer les jokers (ou essayez de mélanger autre chose que des cartes).

{~ (# ? #)

Pour que...

shuffle =: {~ (# ? #)
deck =: i. 52
shuffle deck

Ceci est probablement en dehors de l'intention de la question, qui serait d'implémenter vous-même le shuff de rand ( ?). Je pourrais le faire plus tard quand je ne suis pas censé travailler.

Explication

Explication de 52 ? 52:

• x ? y est x éléments uniques aléatoires de y.

L'explication {~ (# ? #)est plus difficile à cause des fourches et des crochets . Fondamentalement, c'est la même chose queshuffle =: 3 : '((# y) ? (# y)) { y' , qui a un argument implicite ( y).

• # y donne la longueur de y
• Cela donne 52? 52 comme précédemment, qui est une permutation aléatoire de 0..51
• x { y est l'élément de y dans l'index x, ou (dans ce cas) les éléments dans les index de x.
• Cela vous permet de mélanger tout ce qui est passé, pas seulement les entiers.

Voir J Vocabulaire pour plus de détails sur les opérateurs, bien que la syntaxe et la sémantique soient assez délicates à cause de la programmation de rang et tacite.

Python

import random
def rand(x, y):
 return random.randrange(x, y+1)

def swap(deck, x, y):
 deck[x] ^= deck[y]
 deck[y] ^= deck[x]
 deck[x] ^= deck[y]

def shuffle(deck):
 if len(deck)>1:
  deck[1:]=shuffle(deck[1:])
  if rand(0,len(deck)-1)>0:swap(deck, 0, rand(1, len(deck)-1))
 return deck

print shuffle(range(52))

Utilisation de la représentation factorielle

Dans la représentation factorielle d'une permutation, un élément i prend des valeurs de 0 à Ni. Donc, une permutation aléatoire est juste rand(0,i)pour chaque Ni.

En J:

? |.>:i.52
2 39 20 26 ... 2 0 1 0 0 0

où ? xest rand(0,x-1)et |.>:i.52est52 51 ... 1

Ensuite, si ala valeur du ième factoradic, nous faisons l'échange: swap(deck[i], deck[i+a]). La liste des paires à échanger est:

(,. i.52) ,. (,. ((?|.>:i.52)+i.52))
0 33
1 20
2  3
...
49 50
50 50
51 51

L'échange que nous utiliserons fonctionne comme ceci:

deck
24 51 14 18 ...
deck =: 0 1 swap deck
51 24 14 18 ...

Ce n'est pas vraiment "par référence" mais il n'y a pas de fonctions réelles dans J.

Nous utiliserons la longueur du deck ( #deck) pour éviter d'utiliser une constante.

Programme complet en J:

deck =: 52 ? 52                           NB. Initial random deck
swap =: 4 : 'deck =: (x { y) (|.x) } y'   NB. Given swap "function"
f =: 3 : 0                                NB. function that calls the swap for a pair
({.y) swap deck
}.y
)
f^:(#deck) (,.,.[:,.]+[:?[:|.>:) i.#deck

C #

Voici ma propre réponse basée sur l'algorithme de Fisher-Yates . Devrait vous donner un mélange parfait si votre générateur de nombres aléatoires est assez bon.

Version anglaise:

1. Échangez à plusieurs reprises la carte à deck[0]avec celle à deck[v], où vest la valeur nominale de la carte à deck[0]. Répétez jusqu'à ce que v == 0. Cela triera partiellement le jeu, mais cela n'a pas d'importance. Vous savez maintenant que la carte 0 est à l'avant du paquet, ce qui signifie que vous pouvez voler cet espace dans le tableau et l'utiliser comme compteur de boucles. C'est la clé "triche" pour le problème des variables locales.
2. À partir de la position 1 (la deuxième carte du jeu), échangez la carte à iavec celle à rand(i, 51). Notez que vous avez besoin rand(i, 51), pas rand(1, 51) . Cela ne garantit pas que chaque carte est randomisée.
3. Remettez deck[0]à 0. Maintenant, le paquet entier est mélangé à l'exception de la première carte, alors échangez deck[0]avec deck[rand(0, 51)]et vous avez terminé.

Version C #:

public static void shuffle(int[] deck)
{
    while (deck[0] > 0)
        swap(ref deck[0], ref deck[deck[0]]);

    for (deck[0] = 1; deck[0] < 52; deck[0]++)
        swap(ref deck[deck[0]], ref deck[rand(deck[0], 51)]);

    deck[0] = 0;
    swap(ref deck[0], ref deck[rand(0, 51)]);
}

Version Javascript:

while (deck[0] > 0)
    swap(0, deck[0]);

for (deck[0] = 1; deck[0] < 52; deck[0]++)
    swap(deck[0], rand(deck[0], 52));

deck[0] = 0;
swap(0, rand(0, 52));

... où swap(a, b)échange deck[a]avec deck[b].

Ruby, une ligne

Est-ce considéré comme de la triche? Cela devrait être aussi aléatoire que possible.

deck=(0..51).to_a # fill the deck
deck[0..51] = (0..51).map{deck.delete_at(rand deck.length)}

(La randméthode de Ruby ne prend qu'un seul argument, puis génère un nombre n tel que 0 <= nombre <argument.)

De plus - similaire à la solution Perl de sogart, mais pour autant que je sache, elle ne souffre pas du problème:

deck = deck.sort_by{rand}

Sort_by de Ruby est différent de sort - il génère d'abord la liste de valeurs pour trier le tableau, puis seulement le trie par eux. C'est plus rapide quand il est coûteux de trouver la propriété par laquelle nous sommes triés, un peu plus lent dans tous les autres cas. Il est également utile dans le golf de code: P

Javascript

REMARQUE: cette solution n'est techniquement pas correcte car elle utilise un deuxième paramètre i, dans l'appel à shuffle, qui compte comme une variable externe.

function shuffle(deck, i) {
    if (i <= 0)
        return;
    else {
        swap(deck[rand(0,i-1)], deck[i-1]);
        shuffle(deck, i - 1);
    }
}

Appeler avec shuffle(deck,52)

Un exemple de travail complet (a dû être swaplégèrement modifié car il n'y a pas de référence par passage des entiers en JavaScript):

function rand(min, max) { return Math.floor(Math.random()*(max-min+1)+min); }
function swap(deck, i, j) {
    var t=deck[i];
    deck[i] = deck[j];
    deck[j] = t;
}

function shuffle(deck, i) {
    if (i <= 0)
        return;
    else {
        swap(deck, rand(0,i-1), i-1);
        shuffle(deck, i - 1);
    }
}

// create deck
var deck=[];
for(i=0;i<52;i++)deck[i]=i;
document.writeln(deck);
shuffle(deck,52);
document.writeln(deck);

C ++

#include <cstdlib>
#include <ctime>
#include <iostream>

int deck[52];

void swap(int a, int b) {
    deck[a] ^= deck[b];
    deck[b] ^= deck[a];
    deck[a] ^= deck[b];
}

int r(int a, int b) {
    return a + (rand() % (b - a + 1));
}

void s(int *deck) {
    swap(1, r(2, 51));
    deck[0] *= 100;

    for(deck[0] += 2; (deck[0] % 100) < 51; deck[0]++) {
        swap(deck[0] % 100,
          r(0, 1) ? r(1, (deck[0] % 100) - 1) : r((deck[0] % 100) + 1, 51));
    }
    swap(51, r(1, 50)); 

    deck[0] = (deck[0] - 51) / 100;
    swap(r(1, 51), 0);
}

int main(int a, char** c)
{
    srand(time(0));

    for (int i = 0; i < 52; i++)
        deck[i] = i;

    s(deck);
    s(deck);

    for (int i = 0; i < 52; i++)
        std::cout << deck[i] << " ";
}

Évite d'échanger des éléments avec eux-mêmes, donc doit appeler deux fois pour être aléatoire.

ré

shuffle(int[] d){
    while(d.length){
        if([rand(0,d.length-1)!=0)swap(d[0],d[rand(1,d.length-1)]);
        d=d[1..$];
    }
}

Une autre solution Perl, qui produit en fait une sortie uniformément distribuée:

sub shuffle_integers {
    map int, sort {$a-int $a <=> $b-int $b} map $_+rand, @_;
}

say join " ", shuffle_integers 1 .. 52;

Cette solution utilise Perl rand, qui renvoie un nombre aléatoire x dans la plage 0 ≤ x <1. Elle ajoute un tel nombre aléatoire à chaque entier dans l'entrée, trie les nombres en fonction de leurs parties fractionnaires, et finalement supprime à nouveau ces parties fractionnaires .

(Je crois que l'utilisation des variables spéciales $_, $aet $bs'inscrit dans l'esprit du défi, car ce sont la façon dont perl transmet l'entrée à mapet sort, et elles ne sont pas utilisées à d'autres fins dans le code. En tout cas, je crois ils sont en fait les homonymes des valeurs d'entrée, pas de copies indépendantes Ce n'est pas en fait un remaniement en place, bien que,. à la fois mapet de sortcréer des copies de l'entrée sur la pile).

Java

Je suis surpris que personne n'ait déclaré l'évidence: (je suppose que le swap (x, x) ne fait rien.

    static void shuffle(){
        swap(1,rand(0,1));
        swap(2,rand(0,2));
        swap(3,rand(0,3));
        swap(4,rand(0,4));
        swap(5,rand(0,5));
        swap(6,rand(0,6));
        swap(7,rand(0,7));
        swap(8,rand(0,8));
        swap(9,rand(0,9));
        swap(10,rand(0,10));
        swap(11,rand(0,11));
        swap(12,rand(0,12));
        swap(13,rand(0,13));
        swap(14,rand(0,14));
        swap(15,rand(0,15));
        swap(16,rand(0,16));
        swap(17,rand(0,17));
        swap(18,rand(0,18));
        swap(19,rand(0,19));
        swap(20,rand(0,20));
        swap(21,rand(0,21));
        swap(22,rand(0,22));
        swap(23,rand(0,23));
        swap(24,rand(0,24));
        swap(25,rand(0,25));
        swap(26,rand(0,26));
        swap(27,rand(0,27));
        swap(28,rand(0,28));
        swap(29,rand(0,29));
        swap(30,rand(0,30));
        swap(31,rand(0,31));
        swap(32,rand(0,32));
        swap(33,rand(0,33));
        swap(34,rand(0,34));
        swap(35,rand(0,35));
        swap(36,rand(0,36));
        swap(37,rand(0,37));
        swap(38,rand(0,38));
        swap(39,rand(0,39));
        swap(40,rand(0,40));
        swap(41,rand(0,41));
        swap(42,rand(0,42));
        swap(43,rand(0,43));
        swap(44,rand(0,44));
        swap(45,rand(0,45));
        swap(46,rand(0,46));
        swap(47,rand(0,47));
        swap(48,rand(0,48));
        swap(49,rand(0,49));
        swap(50,rand(0,50));
        swap(51,rand(0,51));
    }

OK, ok, ça peut être plus court:

package stackexchange;

import java.util.Arrays;

public class ShuffleDry1
{
    static int[] deck = new int[52];

    static void swap(int i, int j){
        if( deck[i]!=deck[j] ){
            deck[i] ^= deck[j];
            deck[j] ^= deck[i];
            deck[i] ^= deck[j];
        }
    }

    static int rand(int min, int max){
        return (int)Math.floor(Math.random()*(max-min+1))+min;
    }

    static void initialize(){
        for( int i=0 ; i<deck.length ; i++ ){
            deck[i] = i;
            swap(i,rand(0,i));
        }
    }

    static void shuffle(){
        while( deck[0]!=0 ) swap(0,deck[0]);
        for( deck[0]=52; deck[0]-->1 ; ) swap(deck[0],rand(deck[0],51));
        swap(0,rand(0,51));
    }

    public static void main(String[] args) {
        initialize();
        System.out.println("init: " + Arrays.toString(deck));
        shuffle();
        System.out.println("rand: " + Arrays.toString(deck));
    }

}

Burlesque

Ce que vous demandez réellement, c'est une permutation aléatoire d'une liste d'entiers? r@nous donnera toutes les permutations, et nous choisissons simplement une permutation aléatoire.

blsq ) {1 2 3}r@sp
1 2 3
2 1 3
3 2 1
2 3 1
3 1 2
1 3 2
blsq ) {1 2 3}r@3!!BS
2 3 1

Étant donné que nous avons besoin d'un vrai caractère aléatoire, quelque chose que Burlesque n'est pas capable de faire parce que Burlesque n'a pas de fonctionnalité d'E / S dont vous auriez besoin pour fournir une source de caractère aléatoire via STDIN.

C'est probablement quelque chose que je corrigerai dans la version ultérieure (c'est-à-dire générer une graine aléatoire au démarrage et la pousser vers la pile secondaire ou quelque chose comme ça, mais l'interpréteur Burlesque lui-même n'a pas d'E / S).

Javascript

Je ne sais pas si c'est "tricher" mais ma solution utilise le tableau local natif des arguments d'une fonction. J'ai inclus mes propres fonctions de rand() swap()et filldeck(). Fait intéressant, cela devrait fonctionner avec un jeu de n'importe quelle taille.

    var deck = [];

    function shuffle(){
        main(deck.length);
    }

    function main(){
        arguments[0] && swap( arguments[0]-=1, rand(0, deck.length-1) ), main(arguments[0]);
    }

        function rand(min, max){
            return Math.floor( Math.random()*(max-min+1) )+min;
        }

        function swap(x, y){
            var _x = deck[x], _y = deck[y];
            deck[x] = _y, deck[y] = _x;
        }


        function filldeck(dL){
            for(var i=0; i<dL; i++){
                var ran = rand(1,dL);
                while( deck.indexOf(ran) >= 0 ){
                    ran = rand(1,dL);
                }
                deck[i] = ran;
            }
        }

    filldeck(52);
    shuffle();

Tcl , 32 octets

timeFonction abusive qui sert à mesurer le temps passé par un script, mais peut également servir de mécanisme de boucle sans déclarer de variables.

time {lswap $D [rand] [rand]} 52

Essayez-le en ligne!

perl - ce n'est pas un remaniement approprié comme expliqué dans les commentaires!

my @deck = (0..51);
@deck = sort {rand() <=> rand()} @deck;
print join("\n",@deck);

Je pense que je n'ai rien utilisé comme échange, etc. était-ce nécessaire dans le cadre du problème?

JavaScript 4 lignes

function shuffle() {
  while(deck[0]!=0)swap(deck[0],rand(1,51))
  while(deck[0]++!=104)swap(deck[0]%51+1,rand(1,51))
  deck[0]=0
  swap(0,rand(0,51))
}

Réponse originale qui n'était pas assez aléatoire. L'échange n'était pas garanti de toucher chaque élément du jeu.

// shuffle without locals
function shuffle() {
  deck.map(function(){swap(deck[rand(0,51)],deck[rand(0,51)])});
}