Il primo trucco con le carte magiche che abbia mai imparato da bambino era il seguente:

• Avere 1 mazzo di carte in cui il modello sul retro non è simmetrico verticalmente.
• Organizza tutte le carte in modo che siano rivolte in una direzione.
• Chiedi a un individuo di "scegliere una carta, una carta qualsiasi, memorizzarla e restituirla a te".
• Procedere a metterlo nel mazzo (nella direzione sbagliata).
• Mischia energicamente, dando l'illusione di non sapere dove sia la loro carta.
• Produci la loro carta con stupore.

Questo trucco è ovviamente un po 'di lucentezza in natura oggi, ma costituisce una buona sfida. Scrivi un programma che, quando non viene fornito alcun input, genera un mazzo di carte mischiato casualmente con una delle carte, scelta a caso, invertita. Tuttavia, quando l'ingresso è un mazzo di carte con una carta invertita, è necessario produrre la carta invertita (nell'ordine corretto).

Il mazzo di carte

Un mazzo di carte è definito come:

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

Una carta è definita come il suo numero, quindi la prima lettera del suo seme. Il rovescio di una carta è esattamente l'opposto, la prima lettera del suo seme seguita da un numero.

La carta disegnata

Esempio, se la carta che abbiamo scelto casualmente di invertire fosse la 4 of Clubs (4C), finiremmo con (senza mescolare, ovviamente):

[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

Quindi, dopo aver mescolato:

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

Questo è un output valido dato input vuoto.

The Deck Input

Tuttavia, al contrario, quando il nostro programma riceve l'output di cui sopra come input, dovrebbe essere generato 4C. Vale a dire, per un input di:

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

Passi fino a trovare la carta invertita e la restituisci, ripristinata allo stato normale. Quindi qui troveremmo C4, sappiamo che C non è un numero e lo restituire come 4C, che è corretto.

Regole

• Non è possibile caricare il deck da fonti esterne.
• Un input vuoto dovrebbe risultare in un mazzo mischiato casualmente con 1 carta casuale invertita.
• Un mazzo di carte con 1 carta invertita come input dovrebbe provocare la carta invertita.
• Qualsiasi altro input può provocare lama esplosive che guidano in segway attraverso un tubo futuristico.
  • O qualsiasi altra cosa, del resto.
• Sia la carta scelta che l'ordine di mescolamento devono essere uniformemente casuali.
  • Vale a dire che tutte le carte hanno le stesse probabilità di essere selezionate per essere invertite.
  • Vale a dire che tutte le combinazioni di carte hanno le stesse probabilità di apparire.
• Puoi usare SHCDo shcdper i semi, ma sii coerente:
  • Se scegli semi maiuscoli ( SHCD) devi anche usare TJQKA.
  • Se scegli semi minuscoli ( shcd) devi anche usare tjqka.
• Questo è code-golf , il vincitore è il byte più basso.

Retina , 61 60 59 byte

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

Provalo online! Modifica: salvato 1 2 byte grazie a @MartinEnder. Spiegazione:

G`[HCDS].

Elimina tutte le carte non recuperate. Questo dovrebbe lasciare una carta rovesciata o nessuna carta.

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

Se l'input è (ora) vuoto, crea un mazzo di carte.

@V`

Seleziona in modo casuale una carta e invertila (non inverte la singola carta invertita).

O?`

Mescola le carte.

05AB1E , 29 byte

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

Provalo online!

PowerShell v2 o successivo, 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}}

Versione lunga:

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

Uso:

Crea un mazzo mescolato e salvalo in una variabile:

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

Ispeziona la variabile a piacimento, per esempio

$Deck -join ','

Riporta il mazzo nella sceneggiatura:

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

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)

Provalo online! input vuoto è indicato come[]

> <> , 215 193 byte

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/

Provalo online!

Accetta input come card non separate e output uguale (ad es. KCAC5C6S...)

Per semplificare il test, ecco una versione che accetta input come separati da virgola e output come newline separati.

Tutti i x0 s sono solo un tentativo di creare un generatore di numeri casuali semi-uniforme. Più di essi aumenta la gamma di valori possibili e il contrario per meno. 10 di questi è dove l'ho giudicato abbastanza casuale.

Si noti che segue le regole in quanto:

• Tutte le carte hanno le stesse probabilità di essere selezionate per essere invertite.
• Tutte le carte hanno le stesse possibilità di apparire in qualsiasi punto del mazzo mischiato.

Ma non tutte le combinazioni mischiate sono possibili output (e in effetti, la stragrande maggioranza non lo sono).

Gelatina , 26 byte

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

Un collegamento monadico che accetta un elenco di elenchi di personaggi (uno stub di 0 carte o un mazzo completo di 52 carte con una carta invertita) e che restituisce un elenco di elenchi di personaggi (uno stub della 1 carta rovesciata ma in avanti o un intero -deck con una carta casuale invertita).

Provalo online!(piè di pagina per far corrispondere le rappresentazioni di input e output - come un programma completo Codice Jelly Python-elimina l'argomento e spacca i caratteri per l'output)

Come?

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

Rubino , 95 (o 100) byte

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

Dato un array vuoto come input, restituisce il deck come un array di stringhe. Dato un array non vuoto come input, restituisce la scheda capovolta come un array contenente una singola stringa. Se la scheda capovolta è richiesta come stringa anziché come matrice a singolo elemento contenente una stringa, quanto segue aggiunge 5 byte: passare s-na(s-n)[0]

Provalo online!

La prima riga genera un mazzo standard. La seconda riga si suddivide come segue

 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 byte

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'input è una stringa, l'output è una stringa o java.util.Listdipende dall'input.

Spiegazione:

Provalo online.

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 byte

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

Accetta l'elenco vuoto per input vuoto.
Provalo online

Spiegazione

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 byte

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

Provalo online!

Dato un input vuoto, (chiamata fsenza input), per impostazione predefinita l=1, creiamo una permutazione casuale mdel deck. Supponendo che samplesia veramente casuale, c'è una pari probabilità che qualsiasi carta sia la prima in questo elenco. Quindi modifichiamo il primo e poi riordiniamo di nuovo, restituendo l'elenco.

Inversione, cerchiamo una carta che inizia con una delle SDHCe la invertiamo.

Python 2 , 135 byte

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

Provalo online!

Le carte sono tuple di (value,suit)

L'input vuoto è []