Le premier tour de carte magique que j'ai jamais appris étant enfant était le suivant:

• Avoir 1 jeu de cartes où le motif au dos n'est pas symétrique verticalement.
• Organisez toutes les cartes dans une seule direction.
• Demandez à un individu de "choisir une carte, n'importe quelle carte, de la mémoriser et de vous la rendre".
• Passez-le dans le deck (dans la mauvaise direction).
• Mélangez vigoureusement, donnant l'illusion que vous ne saurez pas où se trouve leur carte.
• Produisez leur carte à leur grand étonnement.

Cette astuce est de toute évidence un peu terne dans la nature de nos jours, mais elle constitue un bon défi. Écrivez un programme qui, sans aucune entrée, génère un jeu de cartes mélangé au hasard avec l'une des cartes, choisie au hasard, inversée. Cependant, lorsque l'entrée est un jeu de cartes avec une carte inversée, vous devez sortir la carte inversée (dans le bon ordre).

Le jeu de cartes

Un jeu de cartes est défini comme:

[2S,3S,4S,5S,6S,7S,8S,9S,TS,JS,QS,KS,AS,
 2D,3D,4D,5D,6D,7D,8D,9D,TD,JD,QD,KD,AD,
 2H,3H,4H,5H,6H,7H,8H,9H,TH,JH,QH,KH,AH,
 2C,3C,4C,5C,6C,7C,8C,9C,TC,JC,QC,KC,AC]

Une carte est définie comme son numéro, puis la première lettre de sa couleur. Le revers d'une carte est exactement le contraire, la première lettre de sa couleur suivie d'un chiffre.

La carte dessinée

Par exemple, si la carte que nous avons choisie au hasard pour inverser était la 4 of Clubs (4C), nous nous retrouverions avec (sans mélange, évidemment):

[2S,3S,4S,5S,6S,7S,8S,9S,TS,JS,QS,KS,AS,
 2D,3D,4D,5D,6D,7D,8D,9D,TD,JD,QD,KD,AD,
 2H,3H,4H,5H,6H,7H,8H,9H,TH,JH,QH,KH,AH,
 2C,3C,C4,5C,6C,7C,8C,9C,TC,JC,QC,KC,AC]

The Shuffling

Ensuite, après avoir mélangé:

[2H,2C,6S,4D,QH,6C,TD,8C,7H,5H,C4,3D,7S,7C,KC,QD,QC,JS,7D,6D,2S,5C,KD,3C,3S,2D,8H,KH,6H,AH,8S,JH,TS,AD,5D,9H,4H,JD,QS,4S,JC,3H,8D,TC,AS,TH,KS,AC,9C,9S,5S,9D]

Il s'agit d'une sortie valide avec une entrée vide.

L'entrée Deck

Cependant, inversement, lorsque notre programme reçoit la sortie ci-dessus en entrée, il devrait sortir 4C. Soit pour une entrée de:

[2H,2C,6S,4D,QH,6C,TD,8C,7H,5H,C4,3D,7S,7C,KC,QD,QC,JS,7D,6D,2S,5C,KD,3C,3S,2D,8H,KH,6H,AH,8S,JH,TS,AD,5D,9H,4H,JD,QS,4S,JC,3H,8D,TC,AS,TH,KS,AC,9C,9S,5S,9D]

Vous parcourez jusqu'à ce que vous trouviez la carte inversée, et la retournez, retournée à l'état normal. Donc, ici, nous trouverions C4, saurions que C n'est pas un nombre, et le renverrions comme 4C, ce qui est correct.

Règles

• Vous ne pouvez pas charger la platine à partir de sources externes.
• Une entrée vide devrait se traduire par un jeu aléatoire au hasard avec 1 carte aléatoire inversée.
• Un jeu de cartes avec 1 carte inversée en entrée devrait donner la carte inversée.
• Toute autre entrée peut entraîner des lamas explosifs sur les segways à travers un tube futuriste.
  • Ou toute autre chose, d'ailleurs.
• La carte choisie et l'ordre de mélange doivent être uniformément aléatoires.
  • IE, toutes les cartes ont la même chance d'être sélectionnées pour être inversées.
  • IE toutes les combinaisons de cartes ont une chance égale d'apparaître.
• Vous pouvez utiliser SHCDou shcdpour les combinaisons, mais soyez cohérent:
  • Si vous choisissez des combinaisons majuscules ( SHCD), vous devez également utiliser TJQKA.
  • Si vous choisissez des combinaisons minuscules ( shcd), vous devez également les utiliser tjqka.
• C'est le code-golf , le gagnant est le nombre d'octets le plus bas.

Rétine , 61 60 59 octets

G`[HCDS].
^$
23456789TJQK
/^2/&L$`.
$&H¶$&D¶$&C¶$&S
@V`
O?`

Essayez-le en ligne! Edit: enregistré 1 2 octets grâce à @MartinEnder. Explication:

G`[HCDS].

Supprimez toutes les cartes non inversées. Cela devrait laisser une carte inversée ou aucune carte.

^$
23456789TJQK
/^2/&L$`.
$&H¶$&D¶$&C¶$&S

Si l'entrée est (maintenant) vide, créez un paquet de cartes.

@V`

Sélectionnez une carte au hasard et inversez-la (annule la seule carte inversée).

O?`

Mélangez la ou les cartes.

05AB1E , 29 octets

Y9ŸJ.•§®т•«.•öB•âsKDgiëDΩÂ:.r

Essayez-le en ligne!

PowerShell v2 ou version ultérieure, 175 octets

%{$s=[char[]]'SDHC';if($_){$_|?{$s-contains$_[0]}|%{$_[1]+$_[0]}}else{$d=$s|%{$e=$_;[char[]]'23456789TJQKA'|%{$_+$e}}|random -c 52;$r=random 52;$d[$r]=$d[$r][1]+$d[$r][0];$d}}

Version longue:

ForEach-Object {
    $s = [char[]]'SDHC'                         # Create a character array with the suits
    if ($_) {                                   # If there's pipeline input ...
        $_ |                                    # ... write it to the output pipeline ...
            Where-Object {$s -contains $_[0]} | # ... but let only those input elements pass where the first letter appears in the suits ...
            ForEach-Object {$_[1] + $_[0]}      # ... and swap the two elements
    } else {
        $d = $s | ForEach-Object {              # Assign $d to the output of the suits, processing each element first.
                $e = $_                         # Store the current suit element for use in the inner loop
                [char[]]'23456789TJQKA' | ForEach-Object {$_ + $e}  # Process each of the numbers, joining it with the current suit, ...
            } | Get-Random -Count 52            # ... and the resulting 2-char-strings goes back into the output to be shuffled
        $r = Get-Random -Maximum 52
        $d[$r] = $d[$r][1] + $d[$r][0]          # Swap the two chars of a random array element in $d
        $d                                      # Write $d to the output pipeline
    }
}

Usage:

Créez un jeu mélangé et stockez-le dans une variable:

$Deck = %{$s=[char[]]'SDHC';if($_){$_|?{$s-contains$_[0]}|%{$_[1]+$_[0]}}else{$d=$s|%{$e=$_;[char[]]'23456789TJQKA'|%{$_+$e}}|random -c 52;$r=random 52;$d[$r]=$d[$r][1]+$d[$r][0];$d}}

Inspectez la variable à volonté, par exemple

$Deck -join ','

Redirigez le jeu dans le script:

$Deck | %{$s=[char[]]'SDHC';if($_){$_|?{$s-contains$_[0]}|%{$_[1]+$_[0]}}else{$d=$s|%{$e=$_;[char[]]'23456789TJQKA'|%{$_+$e}}|random -c 52;$r=random 52;$d[$r]=$d[$r][1]+$d[$r][0];$d}}

Python 2 , 175 octets

from random import*
s='SHCD';c='23456789TJQKA'
d=input()
if d:print[b+a for a,b in d if a in s];q
k=sample
r=k(c,1)+k(s,1)
print k([(a+b,b+a)[r==a+b]for a in c for b in s],52)

Essayez-le en ligne! l'entrée vide est désignée par[]

> <> , 215 193 octets

i:0)?\~"CHSD":"2"$:"3"$:"4"$:"5"$:"6"$:"7"$:"8"$:"9"$:"T"$:"J"$:"Q"$:"K"$:"A"$&105&"S"=?.~~~{c0.
=+i$?\i$:::"B")$"I"(*$"S"
_oo$~/;
x0
x0
x0
x0
x0
x0
x0
x0
x0
x0
\l&>?!<
>&"3"%:?\~$>o<
\  }}&-1/

Essayez-le en ligne!

Prend l'entrée comme des cartes non séparées et la sortie comme la même (par exemple KCAC5C6S...)

Pour faciliter le test, voici une version qui prend les entrées séparées par des virgules et les sorties séparées par des sauts de ligne.

Tous les x0s ne sont qu'une tentative pour créer un générateur de nombres aléatoires semi-uniforme. Plus elles augmentent la plage de valeurs possibles, et l'inverse pour moins. 10 d'entre eux ont été jugés assez aléatoires.

Notez qu'il suit les règles en ce sens:

• Toutes les cartes ont une chance égale d'être sélectionnées pour être inversées.
• Toutes les cartes ont une chance égale d'apparaître n'importe où dans le jeu mélangé.

Mais toutes les combinaisons mélangées ne sont pas des sorties possibles (et en fait, la grande majorité ne le sont pas).

Gelée , 26 octets

9ḊṾ€;“AJKQT”p“CDHS”ḟ⁸ẊU-¦Ẋ

Un lien monadique acceptant une liste de listes de personnages (un talon de 0 cartes ou un jeu complet de 52 cartes avec une carte inversée) et renvoyant une liste de listes de personnages (un talon de la 1 carte inversée mais en avant ou une pleine -deck avec une carte aléatoire inversée).

Essayez-le en ligne! (pied de page pour faire correspondre les représentations d'entrée et de sortie - en tant que programme complet, le code Jelly Python-évalue l'argument et écrase les caractères ensemble pour la sortie)

Comment?

9ḊṾ€;“AJKQT”p“CDHS”ḟ⁸ẊU-¦Ẋ - Link: list of lists of characters, Z
9Ḋ                         - nine dequeued = [2,3,4,5,6,7,8,9]
  Ṿ€                       - unevaluate €ach = ['2','3','4','5','6','7','8','9']
     “AJKQT”               - literal list of characters = ['A','J','K','Q','T']
    ;                      - concatenate = ['2','3','4','5','6','7','8','9','A','J','K','Q','T']
             “CDHS”        - literal list of characters = ['C','D','H','S']
            p              - Cartesian product = [['2','C'],['2','D'],...,['T','S']]
                           -   a full deck of forward cards
                    ⁸      - chain's left argument, Z
                   ḟ       - filter discard
                           -   leaving either that deck or the 1 reversed card in the input
                     Ẋ     - shuffle
                        ¦  - sparse application...
                       -   - ...to index: -1 (which doesn't exist when the length is only 1)
                      U    - ...do: upend (reverses the penultimate card of the deck)
                         Ẋ - shuffle

Ruby , 95 (ou 100) octets

->n{s=(0..51).map{|i|"A23456789TJQK"[i/4]+"HCDS"[i%4]}
n[0]?s-n:s[rand 52].reverse!&&s.shuffle}

Étant donné un tableau vide en entrée, renvoie le jeu sous forme de tableau de chaînes. Étant donné un tableau non vide en entrée, renvoie la carte retournée sous la forme d'un tableau contenant une seule chaîne. Si la carte retournée est requise sous la forme d'une chaîne plutôt que d'un tableau à un seul élément contenant une chaîne, ce qui suit ajoute 5 octets: passez s-nà(s-n)[0]

Essayez-le en ligne!

La première ligne génère un jeu standard. La deuxième ligne se décompose comme suit

 n[0]?                  #If the input array is not empty (contains a truthy first element)
  s-n:                  #Find the contents of s with the contents of n removed. The only card remaining from the standard deck corresponds to the flipped card in the input.
                        #ELSE 
  s[rand 52].reverse!&& #Flip one card in place in the array s. As the result is truthy, whatever is next will be returned.
 s.shuffle              #shuffle the deck and return the shuffled deck with one element flipped
}

Java 8, 275 274 259 octets

import java.util.*;s->{if(s==null){List l=new Stack();char i=52,r=i,x,y;for(r*=Math.random();i-->0;y="23456789TJQKA".charAt(i%13),l.add(i==r?x+""+y:y+""+x))x="HSDC".charAt(i&3);Collections.shuffle(l);return l;}return s.replaceAll(".*,(.)([^HSDC]).*","$2$1");}

L'entrée est une chaîne, la sortie est soit une chaîne, soit une java.util.Listfonction de l'entrée.

Explication:

Essayez-le en ligne.

import java.util.*;          // Required import for List, Stack and Collections
s->{                         // Method with String parameter and Object return-type
  if(s==null){               //  If the input is `null`:
    char i=52,               //   Index-integer
         r=i,                //   Random-integer
         x,y;                //   Temp characters
    List l=new Stack();      //   Create a List
    for(r*=Math.random();    //   Determine the random integer in the range (0;52]
        i-->0                //   Loop `i` 52 times:
        ;                    //     After every iteration:
         y="23456789TJQKA".charAt(i%13)
                             //      Set `y` to one of 23456789TJQKA based on `i` modulo-13
         ,l.add(i==r?        //      If the random integer equals the current `i`
                 x+""+y      //       Add the current card reversed
                :            //      Else:
                 y+""+x))    //       Add the current card as is
      x="HSDC".charAt(i&3);  //    Set `x` to one of HSDC based on `i` bitwise-AND 3
    Collections.shuffle(l);  //   Shuffle the generated Deck
    return l;}               //   And return this Deck as result
                             //  If the input was a Deck instead:
  return s.replaceAll(".*,(.)([^HSDC]).*",
                             //   Get the reversed card from the Deck,
            "$2$1");}        //   and output it non-reversed

Pyth, 45 octets

J"CDHS"KO52=NsM.S*+c"AKQJT"1S9J|f}hTJQXNK_@NK

Prend la liste vide pour une entrée vide.
Essayez-le en ligne

Explication

J"CDHS"KO52=NsM.S*+c"AKQJT"1S9J|f}hTJQXNK_@NK
J"CDHS"                                        Save the suits as J.
       KO52                                    Save a random index as K.
           =NsM.S*+c"AKQJT"1S9J                Save a shuffled deck as N.
                                f}hTJQ         Find all cards with suit first.
                               |      XNK_@NK  If there aren't any, flip a card.

R , 177 171 octets

function(l=1,F="(.)(.)",R="\\2\\1",S=sample)if(l>1)sub(F,R,grep("^[SDHC]",l,v=T))else{m=S(outer(c(2:9,"T","J","Q","K"),c("S","D","H","C"),paste0))
m[1]=sub(F,R,m[1])
S(m)}

Essayez-le en ligne!

Étant donné une entrée vide (appel fsans entrée), nous utilisons par défaut l=1et créons ainsi une permutation aléatoire mdu jeu. En supposant que samplec'est vraiment aléatoire, il y a une probabilité égale qu'une carte soit la première de cette liste. Nous modifions donc le premier, puis mélangons à nouveau, renvoyant la liste.

En l'inversant, nous recherchons une carte commençant par l'une SDHCet l'inversons.

Python 2 , 135 octets

from random import*
s=shuffle
d=zip('A23456789TJQK'*4,'SCDH'*13)
s(d)
D=input()
if D:d=list(set(D)-set(d))
d[0]=d[0][::-1]
s(d)
print d

Essayez-le en ligne!

Les cartes sont des tuples de (value,suit)

L'entrée vide est []