O primeiro truque de cartas mágicas que aprendi quando criança foi o seguinte:

• Tenha 1 baralho de cartas em que o padrão na parte de trás não seja verticalmente simétrico.
• Organize todos os cartões voltados para uma direção.
• Peça a alguém que "escolha um cartão, qualquer cartão, memorize e devolva para você".
• Prossiga para colocá-lo no convés (na direção errada).
• Embaralhe vigorosamente, dando a ilusão de que você não saberá onde está o cartão deles.
• Produza seu cartão para sua surpresa.

Esse truque é obviamente um pouco sem brilho na natureza hoje em dia, no entanto, é um bom desafio. Escreva um programa que, quando não recebe nenhuma entrada, produz um baralho aleatoriamente aleatório com um dos cartões, escolhido aleatoriamente, invertido. No entanto, quando a entrada é um baralho de cartas com uma carta invertida, você deve imprimir a carta invertida (na ordem correta).

O baralho de cartas

Um baralho de cartas é definido como:

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

Um cartão é definido como seu número e, em seguida, a primeira letra do naipe. O verso de uma carta é exatamente o oposto, a primeira letra de seu naipe seguida de um número.

O cartão desenhado

Por exemplo, se a carta escolhida aleatoriamente para reverter fosse a 4 of Clubs (4C), teríamos (sem embaralhar, obviamente):

[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

Depois de embaralhar:

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

Esta é uma saída válida, dada a entrada vazia.

The Deck Input

No entanto, inversamente, quando o nosso programa recebe a saída acima como entrada, deve produzir 4C. Ou seja, para uma entrada 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]

Você percorre até encontrar o cartão invertido e o devolve, invertido de volta ao estado normal. Então, aqui encontraríamos C4, saberíamos que C não é um número e devolveríamos como 4C, o que está correto.

Regras

• Você não pode carregar o deck de nenhuma fonte externa.
• Uma entrada vazia deve resultar em um baralho aleatoriamente embaralhado com 1 cartão aleatório invertido.
• Um baralho de cartas com 1 carta invertida como entrada deve resultar na carta invertida.
• Quaisquer outras entradas podem resultar em lhamas explosivos montando segways através de um tubo futurista.
  • Ou qualquer outra coisa, para esse assunto.
• A carta escolhida e a ordem de embaralhamento devem ser uniformemente aleatórias.
  • Ou seja, todas as cartas têm chances iguais de serem selecionadas para serem revertidas.
  • Ou seja, todas as combinações de cartas têm a mesma chance de aparecer.
• Você pode usar SHCDou shcdpara os fatos, mas seja consistente:
  • Se você escolher maiúsculas ( SHCD), também deverá usar TJQKA.
  • Se você escolher ternos minúsculos ( shcd), também deverá usar tjqka.
• Isso é código-golfe , o vencedor é o menor bytes.

Retina , 61 60 59 bytes

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

Experimente online! Edit: Salvo 1 2 bytes graças a @MartinEnder. Explicação:

G`[HCDS].

Exclua todos os cartões não revertidos. Isso deve deixar um cartão invertido ou nenhum cartão.

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

Se a entrada estiver (agora) vazia, crie um baralho de cartas.

@V`

Selecione um cartão aleatoriamente e inverta-o (inverte o único cartão invertido).

O?`

Embaralhe os cartões.

05AB1E , 29 bytes

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

Experimente online!

PowerShell v2 ou posterior, 175 bytes

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

Versão longa:

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:

Crie um baralho embaralhado e armazene-o em uma variável:

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

Inspecione a variável à vontade, por exemplo

$Deck -join ','

Coloque o baralho de volta no 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 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)

Experimente online! entrada vazia é denotada como[]

> <> , 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/

Experimente online!

Recebe entrada como cartões não separados e sai como o mesmo (por exemplo KCAC5C6S...)

Para facilitar o teste, eis uma versão que recebe entrada como separada por vírgula e sai como nova linha separada.

Todos os x0s são apenas uma tentativa de criar um gerador de números aleatórios semi-uniforme. Mais deles aumenta a faixa de valores possíveis, e o oposto por menos. 10 deles é onde eu julguei ser aleatório o suficiente.

Observe que segue as regras em que:

• Todas as cartas têm a mesma chance de serem selecionadas para serem revertidas.
• Todas as cartas têm a mesma chance de aparecer em qualquer lugar do baralho embaralhado.

Mas nem todas as combinações embaralhadas são saídas possíveis (e, de fato, a grande maioria não é).

Geléia , 26 bytes

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

Um link monádico que aceita uma lista de listas de caracteres (um esboço de 0 cartas ou um baralho completo de 52 cartas com uma carta invertida) e retorna uma lista de listas de caracteres (um esboço da 1 carta invertida, mas para a frente ou uma -deck com uma carta aleatória invertida).

Experimente online! (rodapé para fazer corresponder as representações de entrada e saída - como um programa completo, o código Jelly Python avalia o argumento e esmaga os caracteres juntos para a saída)

Quão?

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

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

Dada uma matriz vazia como entrada, retorna o baralho como uma matriz de seqüências de caracteres. Dada uma matriz não vazia como entrada, retorna o cartão invertido como uma matriz contendo uma única sequência. Se o cartão invertido for necessário como uma sequência em vez de uma matriz de elemento único que contenha uma sequência, o seguinte adicionará 5 bytes: altere s-npara(s-n)[0]

Experimente online!

A primeira linha gera um baralho padrão. A segunda linha se divide da seguinte maneira

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

Input é uma String, a saída é uma String ou java.util.Listdepende da entrada.

Explicação:

Experimente 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

Pitão, 45 bytes

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

Leva a lista vazia para entrada vazia.
Experimente online

Explicação

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

Experimente online!

Dada entrada vazia (chamada fsem entrada), assumimos o padrão l=1e, assim, criamos uma permutação aleatória mdo baralho. Assumindosample seja verdadeiramente aleatório, existe uma probabilidade igual de qualquer carta ser a primeira desta lista. Então, modificamos o primeiro e, em seguida, embaralhamos novamente, retornando a lista.

Invertendo-o, procuramos um cartão que comece com um de SDHCe o inverta.

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

Experimente online!

Os cartões são tuplas de (value,suit)

Entrada vazia é []