Der erste Zaubertrick, den ich als Kind gelernt habe, war der folgende:

• Haben Sie 1 Kartenspiel, bei dem das Muster auf der Rückseite nicht vertikal symmetrisch ist.
• Ordne alle Karten so an, dass sie in eine Richtung zeigen.
• Bitten Sie eine Person, "eine Karte auszuwählen, sie auswendig zu lernen und sie Ihnen zurückzugeben".
• Legen Sie es in die falsche Richtung auf das Deck.
• Mische kräftig und gib die Illusion, dass du nicht weißt, wo ihre Karte ist.
• Legen Sie zu ihrem Erstaunen die Karte vor.

Dieser Trick ist in der Natur heutzutage offensichtlich ein bisschen mangelhaft, aber er ist eine gute Herausforderung. Schreiben Sie ein Programm, das, wenn keine Eingabe erfolgt, ein zufällig gemischtes Kartenspiel ausgibt, wobei eine der zufällig ausgewählten Karten umgekehrt wird. Wenn es sich bei der Eingabe jedoch um ein Kartenspiel mit einer umgekehrten Karte handelt, müssen Sie die umgekehrte Karte ausgeben (in der richtigen Reihenfolge).

Das Kartenspiel

Ein Kartenspiel ist definiert als:

[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]

Eine Karte ist definiert als ihre Nummer, dann der erste Buchstabe ihrer Farbe. Die Rückseite einer Karte ist das genaue Gegenteil, der erste Buchstabe der Farbe, gefolgt von einer Zahl.

Die gezogene Karte

Beispiel: Wenn die Karte, die wir zufällig umgedreht haben, die war 4 of Clubs (4C), würden wir am Ende (natürlich ohne zu mischen):

[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]

Das Mischen

Dann nach dem Mischen:

[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]

Dies ist eine gültige Ausgabe bei leerer Eingabe.

Der Deck-Eingang

Wenn jedoch umgekehrt unser Programm die obige Ausgabe als Eingabe empfängt, sollte sie ausgegeben werden 4C. Das heißt für eine Eingabe von:

[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]

Sie iterieren, bis Sie die umgedrehte Karte gefunden haben, und kehren sie in den Normalzustand zurück. Hier finden wir also C4, dass C keine Zahl ist, und geben sie als zurück 4C, was korrekt ist.

Regeln

• Sie dürfen das Deck nicht von externen Quellen laden.
• Eine leere Eingabe sollte zu einem zufällig gemischten Deck mit 1 umgedrehten zufälligen Karte führen.
• Ein Kartenspiel, bei dem 1 Karte als Eingabe umgekehrt ist, sollte die umgekehrte Karte ergeben.
• Alle anderen Eingaben können dazu führen, dass explosive Lamas auf Segways durch eine futuristische Röhre fahren.
  • Oder irgendetwas anderes.
• Sowohl die gewählte Karte als auch die Mischreihenfolge müssen einheitlich zufällig sein.
  • IE alle Karten haben die gleiche Chance, ausgewählt zu werden, umgedreht zu werden.
  • IE haben alle Kartenkombinationen die gleiche Chance zu erscheinen.
• Sie können SHCDoder shcdfür die Anzüge verwenden, aber konsistent sein:
  • Wenn Sie Anzüge in Großbuchstaben ( SHCD) auswählen, müssen Sie auch verwenden TJQKA.
  • Wenn Sie Anzüge in Kleinbuchstaben ( shcd) auswählen, müssen Sie auch verwenden tjqka.
• Dies ist Code-Golf , der Gewinner hat die niedrigsten Bytes.

Netzhaut , 61 60 59 Bytes

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

Probieren Sie es online! Bearbeiten: 1 2 Bytes dank @MartinEnder gespeichert. Erläuterung:

G`[HCDS].

Löschen Sie alle nicht rückgängig gemachten Karten. Dies sollte eine umgedrehte Karte oder keine Karten hinterlassen.

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

Wenn die Eingabe (jetzt) ​​leer ist, erstellen Sie ein Kartenspiel.

@V`

Wähle zufällig eine Karte aus und kehre sie um (hebe die Umkehrung der einzelnen Karte auf).

O?`

Mische die Karte (n).

05AB1E , 29 Bytes

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

Probieren Sie es online!

PowerShell v2 oder höher, 175 Byte

%{$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}}

Lange Version:

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
    }
}

Verwendung:

Erstelle ein gemischtes Deck und speichere es in einer Variablen:

$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}}

Überprüfen Sie beispielsweise die Variable nach Belieben

$Deck -join ','

Pipe das Deck zurück in das Skript:

$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 Bytes

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)

Probieren Sie es online! leere Eingabe wird als bezeichnet[]

> <> , 215 193 Bytes

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/

Probieren Sie es online!

Nimmt Eingaben als nicht getrennte Karten und gibt sie als dieselben aus (zB KCAC5C6S...)

Um das Testen zu vereinfachen, finden Sie hier eine Version , bei der die Eingabe durch Kommas und die Ausgabe durch Zeilenvorschub getrennt ist.

Alle x0s sind nur ein Versuch, einen halbgleichmäßigen Zufallszahlengenerator zu erstellen. Mehr von ihnen erhöht den Bereich möglicher Werte und das Gegenteil für weniger. 10 davon habe ich als zufällig genug eingestuft.

Beachten Sie, dass die folgenden Regeln eingehalten werden:

• Alle Karten haben die gleiche Chance, für die Umkehrung ausgewählt zu werden.
• Alle Karten haben die gleiche Chance, irgendwo im gemischten Deck zu erscheinen.

Aber nicht alle gemischten Kombinationen sind mögliche Ausgaben (und in der Tat ist die überwiegende Mehrheit nicht).

Gelee , 26 Bytes

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

Ein monadischer Link, der eine Liste von Zeichenlisten akzeptiert (ein Stub von 0 Karten oder ein vollständiges Deck von 52 Karten mit einer umgedrehten Karte) und eine Liste von Zeichenlisten zurückgibt (ein Stub der 1 umgedrehten Karte, aber vorwärts oder voll) -deck mit einer zufälligen Karte umgedreht).

Probieren Sie es online! (Fußzeile, damit Eingabe- und Ausgabedarstellungen übereinstimmen)

Wie?

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 (oder 100) Bytes

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

Wenn ein leeres Array als Eingabe angegeben wird, wird das Deck als Array von Strings zurückgegeben. Bei einem nicht leeren Array als Eingabe wird die umgedrehte Karte als Array mit einer einzelnen Zeichenfolge zurückgegeben. Wenn die umgedrehte Karte als Zeichenfolge und nicht als Einzelelement-Array mit einer Zeichenfolge benötigt wird, werden mit den folgenden Schritten 5 Byte hinzugefügt: change s-nto(s-n)[0]

Probieren Sie es online!

Die erste Zeile erzeugt ein Standarddeck. Die zweite Zeile setzt sich wie folgt zusammen

 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 Bytes

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");}

Die Eingabe ist eine Zeichenfolge, die Ausgabe ist java.util.Listabhängig von der Eingabe entweder eine Zeichenfolge oder eine .

Erläuterung:

Probieren Sie es online aus.

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 Bytes

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

Übernimmt die leere Liste für leere Eingaben.
Probieren Sie es online aus

Erläuterung

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 Bytes

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)}

Probieren Sie es online!

Bei leerer Eingabe (Aufruf fohne Eingabe) wird standardmäßig l=1eine zufällige Permutation mdes Decks erstellt. Vorausgesetzt, es sampleist wirklich zufällig, besteht die gleiche Wahrscheinlichkeit, dass eine Karte die erste in dieser Liste ist. Also modifizieren wir die erste und mischen sie dann erneut, um die Liste zurückzugeben.

SDHCUmgekehrt suchen wir eine Karte, die mit einer von ihnen beginnt, und kehren sie um.

Python 2 , 135 Bytes

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

Probieren Sie es online!

Karten sind Tupel von (value,suit)

Leere Eingabe ist []