El primer truco de cartas mágicas que aprendí de niño fue el siguiente:

• Tenga 1 mazo de cartas donde el patrón en la parte posterior no sea verticalmente simétrico.
• Organice todas las tarjetas para que estén orientadas en una dirección.
• Pídale a un individuo que, "elija una tarjeta, cualquier tarjeta, memorícela y se la devuelva".
• Proceda a colocarlo en la plataforma (en la dirección incorrecta).
• Baraja vigorosamente, dando la ilusión de que no sabrás dónde está su carta.
• Produzca su tarjeta para su asombro.

Este truco es obviamente un poco lustroso en la naturaleza hoy en día, sin embargo, es un buen desafío. Escriba un programa que, cuando no se le da entrada, emite un mazo de cartas barajado aleatoriamente con una de las cartas, elegida al azar, invertida. Sin embargo, cuando la entrada es un mazo de cartas con una carta invertida, debe sacar la carta invertida (en el orden correcto).

El mazo de cartas

Una baraja de cartas se define 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]

Una tarjeta se define como su número, luego la primera letra de su palo. El reverso de una carta es exactamente lo contrario, la primera letra de su palo seguida de un número.

La carta dibujada

Ejemplo, si la carta que elegimos al azar para revertir era la 4 of Clubs (4C), terminaríamos con (sin barajar, 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]

La barajadura

Luego, después de barajar:

[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 es una salida válida dada entrada vacía.

La entrada de cubierta

Sin embargo, a la inversa, cuando nuestro programa recibe la salida anterior como entrada, debería salir 4C. Es decir, para una 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]

Usted itera hasta encontrar la carta invertida y la devuelve al estado normal. Así que aquí encontraríamos C4, sabríamos que C no es un número, y lo devolveríamos como 4C, lo cual es correcto.

Reglas

• No puede cargar la plataforma desde ninguna fuente externa.
• Una entrada vacía debería dar como resultado un mazo aleatorio con 1 carta aleatoria invertida.
• Una baraja de cartas con 1 carta invertida como entrada debería resultar en la carta invertida.
• Cualquier otra entrada puede dar lugar a llamas explosivas que circulan en segways a través de un tubo futurista.
  • O cualquier otra cosa, para el caso.
• Tanto la carta elegida como el orden aleatorio deben ser uniformemente aleatorios.
  • Es decir, todas las cartas tienen la misma posibilidad de ser seleccionadas para ser revertidas.
  • Es decir, todas las combinaciones de cartas tienen la misma posibilidad de aparecer.
• Puedes usar SHCDoshcd para los trajes, pero sea consistente:
  • Si elige trajes en mayúscula ( SHCD) también debe usarTJQKA .
  • Si elige trajes en minúsculas ( shcd) también debe usar tjqka.
• Este es el código de golf , el ganador tiene los bytes más bajos.

Retina , 61 60 59 bytes

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

Pruébalo en línea! Editar: Guardado 1 2 bytes gracias a @MartinEnder. Explicación:

G`[HCDS].

Eliminar todas las cartas no invertidas. Esto debería dejar una carta invertida o ninguna carta.

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

Si la entrada está (ahora) vacía, cree un paquete de tarjetas.

@V`

Seleccione aleatoriamente una carta y revierta (revierte la carta revertida).

O?`

Baraja las cartas.

05AB1E , 29 bytes

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

Pruébalo en línea!

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

Versión larga:

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 mazo barajado y guárdalo en una 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}}

Inspeccione la variable a voluntad, por ejemplo

$Deck -join ','

Instale nuevamente la cubierta en el guión:

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

Pruébalo en línea! la entrada vacía se denota 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/

Pruébalo en línea!

Toma la entrada como tarjetas no separadas y la salida como la misma (p. Ej. KCAC5C6S... )

Para facilitar la prueba, aquí hay una versión que toma entradas como separadas por comas y salidas como separadas por nueva línea.

Todos x0 s son solo un intento de hacer un generador de números aleatorios semi uniforme. Más de ellos aumenta el rango de valores posibles, y lo contrario por menos. 10 de ellos es donde juzgué que era lo suficientemente aleatorio.

Tenga en cuenta que sigue las reglas en eso:

• Todas las cartas tienen la misma probabilidad de ser seleccionadas para ser revertidas.
• Todas las cartas tienen la misma posibilidad de aparecer en cualquier lugar del mazo barajado.

Pero no todas las combinaciones barajadas son posibles resultados (y, de hecho, la gran mayoría no lo son).

Jalea , 26 bytes

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

Un enlace monádico que acepta una lista de listas de caracteres (un trozo de 0 cartas o un mazo completo de 52 cartas con una carta invertida) y devuelve una lista de listas de caracteres (un trozo de la carta 1 invertida pero hacia adelante o una completa -Cubierta con una carta aleatoria invertida).

Pruébalo en línea! (pie de página para hacer coincidir las representaciones de entrada y salida; como código completo de Jelly, Python evalúa el argumento y junta los caracteres para la salida)

¿Cómo?

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 (o 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 una matriz vacía como entrada, devuelve el mazo como una matriz de cadenas. Dada una matriz no vacía como entrada, devuelve la tarjeta invertida como una matriz que contiene una sola cadena. Si la tarjeta invertida se requiere como una cadena en lugar de una matriz de un solo elemento que contiene una cadena, lo siguiente agrega 5 bytes: cambie s-na(s-n)[0]

Pruébalo en línea!

La primera línea genera un mazo estándar. La segunda línea se desglosa de la siguiente manera.

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

La entrada es una Cadena, la salida es una Cadena o java.util.Listdepende de la entrada.

Explicación:

Pruébalo en línea.

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

Toma la lista vacía para la entrada vacía.
Pruébalo en línea

Explicación

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

Pruébalo en línea!

Dada una entrada vacía (llamada fsin entrada), establecemos por defecto l=1y, por lo tanto, creamos una permutación aleatoriam del mazo. Asumiendo que samplees verdaderamente aleatorio, existe la misma probabilidad de que cualquier carta sea la primera en esta lista. Entonces modificamos el primero, y luego barajamos nuevamente, devolviendo la lista.

Al revertirlo, buscamos una tarjeta que comience con una SDHCy la revertimos.

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

Pruébalo en línea!

Las cartas son tuplas de (value,suit)

La entrada vacía es []