La tarea fue tomada de una conferencia del MIT por el Prof. Devadas llamada Puedes leer mentes . Puede encontrar una explicación detallada del truco en el video vinculado o en este documento . Trataré de explicarlo en términos más simples.

Resulta que esto fue inventado en la década de 1930, y se conoce como el "truco de cinco cartas de Fitch Cheney" .

El truco es así:

• Se eligen cinco cartas al azar de una baraja de cartas. El público y su asistente pueden verlos, pero usted no.
• Su asistente (con quien ha practicado) seleccionará cuatro de esas tarjetas y se las mostrará en un orden específico. Tenga en cuenta que la carta oculta no se elige al azar de las 5 cartas. El asistente elige una / la tarjeta que hará que el truco funcione.
• En base a la información que puede obtener de las cuatro cartas, deducirá cuál es la quinta carta.

¿Cómo?

Tenga en cuenta los siguientes dos puntos:

1. Al elegir 5 cartas al azar, tiene la garantía de que al menos dos cartas tienen el mismo palo ¹ .

2. La siguiente imagen muestra un círculo con todos los rangos ² . Como es un círculo, es posible contar: J, Q, K, A, 2, 3 (es decir, conteo modular). Se le garantiza que la carta oculta no tiene el mismo rango que la primera, ya que serán del mismo palo (se explica a continuación). Siempre es posible elegir la primera carta y las cartas ocultas de modo que la carta oculta tenga entre 1 y 6 rangos más altos que la primera (al contar en círculos). Si la primera carta es 1 , la carta oculta será 2,3,4,5,6 o 7 . Si la primera carta es J , la carta oculta será Q, K, A, 2,3 o 4 y así sucesivamente.

El algoritmo:

La primera carta: esta carta tendrá el mismo palo que la carta oculta. La tarjeta también será el punto de referencia que usará al determinar el rango de la tarjeta oculta.

Las tarjetas segunda, tercera y cuarta decodifican un valor en el rango inclusivo 1 ... 6 . Llamaremos a las tres tarjetas S, M, L (tarjeta más pequeña, tarjeta del medio, tarjeta más grande). Los valores se codificarán así (orden lexicográfico):

S M L   -> 1
S L M   -> 2
M S L   -> 3   
M L S   -> 4
L S M   -> 5
L M S   -> 6 

Entonces, si el rango de la primera carta es 5 , y las tres cartas restantes tienen rangos 4 Q 7 (están ordenadas SLM ), entonces la última carta tiene rango 5 + 2 = 7 . Puedes elegir si el as debe ser la carta más alta o más baja, siempre que sea consistente.

Si varias cartas comparten rango, entonces el palo determinará el orden, donde C <D <H <S .

Formato de entrada:

Las cuatro cartas se darán como H3 (tres de corazones), DK (Rey de diamantes) y así sucesivamente. Puede optar por tomar la entrada al revés como 3H y KD .

La entrada puede estar en cualquier formato conveniente, pero no puede combinar la lista de trajes en una variable y la lista de rangos en otra. 'D5', 'H3' ..y [['D',5],['H',3] ...ambos están bien, pero 'DHCH',[5,3,1,5]no lo es. No se pueden utilizar los números en lugar de letras, a excepción de T .

Salida

La tarjeta oculta, en el mismo formato que la entrada.

Ejemplo

Hagamos un tutorial:

Input:
D3 S6 H3 H9

Sabemos que la carta oculta es un diamante, ya que la primera carta es un diamante. También sabemos que el rango es 4,5,6,7,8 o 9 ya que el rango de la primera carta es 3 .

Las cartas restantes se ordenan 6,3,9 ==> M, S, L , que codifica el valor 3 . La carta oculta es, por lo tanto, 3 + 3 = 6 de diamantes, por lo tanto, la salida debe ser D6 .

Casos de prueba:

C3 H6 C6 S2
C9            # The order is LMS (H6 > C6, and 2 < 6). 3+6=9     

SQ S4 S3 ST   # (ST = S10. Format is optional)
S2            # The order is MSL. 12+3=2

HA CA DA SA
H2            # The order is SML. 14+1=2

Este es el código de golf , por lo que gana la solución más corta en cada idioma. ¡Se alientan las explicaciones!

¹ Hay cuatro trajes ( C lubs, D iamonds, H earts y S pades).

² Hay 13 filas, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Puedes elegir usar T en lugar de 10 .

JavaScript (ES6), 130 102 bytes

Toma la entrada como una matriz de cadenas en "Rs"formato, donde R es el rango y s es el palo. Espera "T" por 10's. Los ases son bajos.

a=>(s='A23456789TJQK')[([[R,[,S]],B,C,D]=a.map(c=>[s.search(c[0])+14,c]),R+=D<C|2*((D<B)+(C<B)))%13]+S

Pruébalo en línea!

¿Cómo?

Primero convertimos cada tarjeta en una matriz [rango, tarjeta] donde el rango es un valor numérico en [14 ... 26] y la tarjeta es la cadena original.

[[R, [, S]], B, C, D] = a.map(c => ['A23456789TJQK'.search(c[0]) + 14, c])

El rango y el palo de la primera carta se almacenan en R y S, respectivamente. Las otras tres cartas se almacenan en B , C y D .

Por ejemplo, se ['3c','6h','6c','2s']convierte en:

[ [ 16, '3c' ], [ 19, '6h' ], [ 19, '6c' ], [ 15, '2s' ] ]
    ^^    ^     <---------->  <---------->  <---------->
    R     S          B             C             D

Luego comparamos cada par en [B, C, D] . Estos elementos se coaccionan implícitamente a cadenas cuando se comparan entre sí:

[ 19, '6h' ] --> '19,6h'

Debido a que se garantiza que tanto el rango como la tarjeta constan de exactamente dos caracteres, es seguro comparar en orden lexicográfico.

Calculamos:

(D < C) | 2 * ((D < B) + (C < B))

A continuación se presentan todas las combinaciones posibles:

 B, C, D | v0 = D < B  | v1 = C < B  | v2 = D < C  | v2|2*(v0+v1)
---------+-------------+-------------+-------------+--------------
 S, M, L |    false    |    false    |    false    |      0
 S, L, M |    false    |    false    |    true     |      1
 M, S, L |    false    |    true     |    false    |      2
 M, L, S |    true     |    false    |    true     |      3
 L, S, M |    true     |    true     |    false    |      4
 L, M, S |    true     |    true     |    true     |      5

Finalmente, construimos la tarjeta de salida usando R , S y el resultado anterior:

'A23456789TJQK'[(R += D < C | 2 * ((D < B) + (C < B))) % 13] + S

Python 2 , 143 140 138 136 127 125 124 123 121 bytes

lambda(S,V),*l:S+N[F(V)+int(`map(sorted(l,key=lambda(s,v):(F(v),s)).index,l)`[1::3],3)*3/10]
N='23456789TJQKA'*2;F=N.find

Pruébalo en línea!

Los ases son altos

Codifica las tres cartas al encontrar su posición en una lista ordenada de las cartas ( 0=smallest, 1=middle, 2=largest):

cards:   [SK, C4, H4]
sorted:  [C4, H4, SK]

ranks:   [ 2            index of SK in sorted
ranks:   [ 2,  0        index of C4 in sorted
ranks:   [ 2,  0,  1    index of H4 in sorted
ranks:   [ 2,  0,  1] = L,S,M

Esto se convierte en un número entero en la base 3 y se multiplica por 3, y se divide por 10:

int('201',3) = 19 -> 19*3//10 = 5

Las diferentes codificaciones son:

cards            base3    *3   /10
[0, 1, 2]  012     5      15     1
[0, 2, 1]  021     7      21     2
[1, 0, 2]  102     11     33     3
[1, 2, 0]  120     15     45     4
[2, 0, 1]  201     19     57     5
[2, 1, 0]  210     21     63     6

Salvado:

• -2 bytes, gracias a los ovs

Jalea , 33 bytes

ØDḊḊ;“TJQKA”p“CDHS”
¢iⱮµḊŒ¿×4+Ḣị¢

Pruébalo en línea!

Explicación

La primera línea es niládica. Produce una lista de las 52 cartas.

ØDḊḊ;“TJQKA”p“CDHS”
ØD                   Digits: '0123456789'
  ḊḊ                 Dequeue twice: '23456789'
    ;                Append with...
     “TJQKA”         ...the string 'TJQKA': '23456789TJQKA'. These are the ranks
            p        Cartesian product with...
             “CDHS”  ...the suits.
                     This yields the list of all cards in lexicographic order:
                                 ['2C', '2D', '2H', '2S',
                                  '3C', ...         'AS']

En el enlace principal, ¢llama al resultado del primer enlace, que es la lista de tarjetas.

¢iⱮµḊŒ¿×4+Ḣị¢
¢              List of cards
 iⱮ            Index of each (Ɱ) of the inputs in the list.
   µ           New monadic link. The list of indices become this links argument.
    Ḋ          Remove the first one.
     Œ¿        Index of the permutation of the last three items. Gives a number 1-6
               as described in the problem statement.
       ×4      Multiply this by 4 so that when we add to the index of the first
               card we end up in the same suit.
         +Ḣ    Add the first index.
           ị   Use this number to index into...
            ¢  ...the list of cards.

APL (Dyalog Unicode) , ^{SBCS de} 49 bytes

⊃x⌽⍨⊃i-4×2-⌊1.8⊥⍋1↓i←⎕⍳⍨x←,⍉'CDHS'∘.,2↓⎕D,'TJQKA'

Pruébalo en línea!

Descripción general: 'CDHS'∘.,2↓⎕D,'TJQKA'genera el producto externo, por lo que una matriz 2D con (C2 C3 C4 ...), (D2 D3 D4 ...), .... Luego transponemos esta matriz para obtener (C2 D2 H2 ...), ...y luego aplanar eso.

Gracias a @ngn por el 2-⌊1.8⊥, que toma el orden de las tarjetas (SML = 1 2 3) y las califica (como el 1 al 6 en el OP).

Explicación del código:

⊃x⌽⍨⊃i-4×2-⌊1.8⊥⍋1↓i←⎕⍳⍨x←,⍉'CDHS'∘.,2↓⎕D,'TJQKA'
                                       ⎕D,'TJQKA' ⍝ Concatenate a list of numbers with TJQKA
                                     2↓           ⍝ Drop 2 (removes "01")
                                  ∘.,             ⍝ Generate the outer product of this prefixed with
                            'CDHS'                ⍝ The suits
                           ⍉                      ⍝ Invert rows/columns
                          ,                       ⍝ Flatten (matrix -> array)
                        x←                        ⍝ Store in x
                      ⍳⍨                          ⍝ Inverted ⍳⍨: find the indices, in our cards,
                     ⎕                            ⍝ of the argument cards
                   i←                             ⍝ Store these indices in i
                 1↓                               ⍝ Remove the first index
                ⍋                                 ⍝ Grade: get ordered indices
         2-⌊1.8⊥                                  ⍝ The magic happens here: get the number from 1 to 6
       4×                                         ⍝ Multiply by 4 to get the same "back" on the card
    ⊃i-                                           ⍝ Substract the result from our first index (which we had discarded)
⊃x⌽⍨                                              ⍝ (Modulated) Index into x (our cards) with this value

Retina , 218 208 bytes

[JQK]
1$&
T`AJQK`1123
*' G0`
\d+
5**
' G, 1,`
T`CD\HS`d
\d
*
/^(_+)¶\1/(/¶(_+)¶\1/(K`1
/^(_+)¶_+¶\1/(K`2
))K`4
/^(_+)¶_+¶\1/(K`3
/¶(_+)¶\1/(K`5
)))K`6
\d
$+3-$&
(\d+)-(\d+)
$1*_$2*
_{13}(_+)|(_{1,13})
$.($1$2

Pruébalo en línea!

Explicación:

[JQK]
1$&
T`AJQK`1123

Reemplaza ases, jotas, reinas y reyes con 1, 11, 12 y 13. Las primeras dos líneas anteponen una 1antes de la letra, y la última translitera el segundo dígito.

*' G0`

El *indica que esta etapa no debe modificar la cadena de trabajo. Esto puede hacer que el escenario parezca inútil, pero será útil más adelante. El 'divide la cadena de trabajo en cada espacio, y G0toma el primero (por lo que se encuentra la primera tarjeta).

\d+
5**
' G, 1,`'

Las primeras dos líneas multiplican los números en las tarjetas por 5, luego los convierten en unarios (por ejemplo, 5 se representa como _____), para que podamos agregar cantidades más pequeñas para palos más adelante. La línea final se divide en espacios y mantiene las últimas tres cartas.

T`CD\HS`d
\d
*

Esto convierte clubes, diamantes, corazones y espadas a 0, 1, 2 y 3 respectivamente, y convierte el número en unario. Dado que ahora está en la parte adjunta de la parte del número de la tarjeta, le dará un valor único para la tarjeta, determinando qué tan alto es.

/^(_+)¶\1/(/¶(_+)¶\1/(K`1
/^(_+)¶_+¶\1/(K`2
))K`4
/^(_+)¶_+¶\1/(K`3
/¶(_+)¶\1/(K`5
)))K`6

Esto encuentra el orden de las tarjetas y el valor para agregar a la primera tarjeta. Por ejemplo, en la primera línea /^(_+)¶\1_+/(coincide las órdenes que tienen un valor medio mayor que el primer valor. Crea un bucle if-else para saber qué hacer (ya que este orden coincide con las permutaciones 1, 2 y 4). Kmarca una constante

\d
$+3-$&

¿Recuerdas antes cuando solíamos *indicar que una etapa no afectaría la cadena de trabajo? Aquí es donde lo usamos. Esta etapa es una etapa de reemplazo; reemplaza el número para agregar $+3-$&. $+3accede al *escenario, obtiene el palo y el número de la primera carta, -actúa como separador y $&es el partido. Entonces la cadena de trabajo es ahora{suit}{original number}-{number to add}

(\d+)-(\d+)
$1*_$2*

Esto convierte los dos números en unarios y los suma.

_{13}(_+)|(_{1,13})
$.($1$2

La línea superior captura el número o el número - 13 (para que no obtengamos, por ejemplo, S16). La línea inferior convierte el número capturado nuevamente en la base 10, y el resultado se imprime implícitamente.

Carbón , 64 62 bytes

≔⪪⭆⁺⭆⁸⁺²ιTJQKA⭆CDHS⁺λι²δ≔Ｅ⟦ηζε⟧⌕διυ§δ⁺⌕δθ×⁴⊕⁺∧⌕υ⌊υ⊗⊕¬⌕υ⌈υ‹⊟υ⊟υ

Pruébalo en línea! El enlace es a la versión detallada del código. Usos Tpara 10 y clasifica Aalto. El índice de permutación no se decodificó muy fácilmente; un orden de permutación diferente me habría ahorrado al menos tres bytes. Explicación:

⁺⭆⁸⁺²ιTJQKA

Agregue 2 a todos los enteros de 0 a 7, luego concatente y sufijo TJQKApara las tarjetas con imágenes y as. Esto ahorra 2 bytes sobre un literal de cadena, aunque resulta que tener un valor Aalto habría ahorrado un byte a través de la compresión de cadena de todos modos.

≔⪪⭆...⭆CDHS⁺λι²δ

Mapa sobre las tarjetas y los trajes, concatenando a los dos juntos. Como esto normalmente produciría una matriz anidada, los resultados se concatenan en una sola cadena que luego se divide en pares de caracteres nuevamente.

≔Ｅ⟦ηζε⟧⌕διυ

Encuentra las posiciones de la segunda, tercera y cuarta cartas.

⊕⁺∧⌕υ⌊υ⊗⊕¬⌕υ⌈υ‹⊟υ⊟υ

Calcule el índice de permutación indexado 1. Las dos primeras permutaciones tienen primero la carta más pequeña; Esto se prueba a través de ⌕υ⌊υ. Los otros dos pares de permutaciones se diferencian en cuanto a si la carta más grande es la primera; Esto se prueba a través de ⌕υ⌈υ. Las operaciones lógicas y aritméticas luego asignan estas pruebas a los valores 0, 2y 4; esto se incrementa 1dependiendo de la comparación entre la tercera y la cuarta carta, probada mediante ‹⊟υ⊟υ. Finalmente, el índice se incrementa para dar la codificación deseada.

§δ⁺⌕δθ×⁴...

Multiplique eso por 4 repitiendo la distancia entre cartas del mismo palo, agregue la posición de la primera carta e indexe e imprima cíclicamente el resultado.

Python 2 , 147 bytes

lambda a:a[0][0]+R[h(map(a[1:].index,sorted(a[1:],key=lambda c:(I(c[1]),c))))+I(a[0][1])]
R='A23456789TJQK'*2;I=R.index
h=lambda(x,y,z):x*2+(y>z)+1

Pruébalo en línea!

Pyth, 42 bytes

+hhQ@J+`M}2Tmk"JQKA"+hhKm,xJtdhdQhx.pStKtK

Realmente feo...

Pruébelo en línea: Demontration o Test Suite

J , 68 bytes

r=.'23456789TJQKA'
{:@{.,~0{r|.~1+(r i.0{{.)+(>,{r;'CDHS')A.@/:@i.}.

Pruébalo en línea!

Nota: -3 off TIO bytes porque f=.no cuenta. Intentará jugar más al golf y agregará una explicación mañana.

JavaScript (Node.js) , 124 bytes

s=>(k='23456789TJQKA')[p=t=>k.search(s[t][0])+32+s[t][1],u=p(0),(u[0]+u[1]-2*(p(1)<p(2))-2*(p(1)<p(3))-(p(2)<p(3)))%13]+u[2]

Pruébalo en línea!

JavaScript (Node.js) , 125 bytes

s=>(k='23456789TJQKA')[p=s.map(t=>k.search(t[0])+32+t[1]),u=p[0],(u[0]+u[1]-2*(p[1]<p[2])-2*(p[1]<p[3])-(p[2]<p[3]))%13]+u[2]

Pruébalo en línea!

T-SQL, 211 bytes

La entrada es una variable de tabla. Usando T para 10, los ases son bajos

Formato para tarjetas rango / palo KH, 6D, TS

DECLARE @ TABLE(c char(2),i int identity(4,-1))
INSERT @
VALUES('2C'),('AH'),('QS'),('KC')

SELECT
substring(max(h+h),max(charindex(q,h)*w)+power(sum(r)*3,.5)-11,1)+max(right(c,w))
FROM(SELECT*,i%4*power(3,rank()over(order by w,charindex(q,h),c))r
FROM(SELECT*,i/4w,left(c,1)q,'A23456789TJQK'h FROM @)d)y

Pruébelo en línea sin golf

Observe cómo se calcula el valor SML (12-17):

Lógicamente, S, M, L (1,2,3) se convierte en un valor numérico

la primera tarjeta tiene un valor de secuencia de 27 *

la segunda tarjeta tiene un valor de secuencia de 9 *

la tercera carta tiene un valor de secuencia de 3 *

Al multiplicar por 3, la raíz cuadrada redondeada hacia abajo se convierte en un buen número secuencial.

Order    27,9,3*order=r   sum(r)*3    floor sqrt
S M L -> 1*27+2*9+3*3  -> 162      -> 12
S L M -> 1*27+3*9+2*3  -> 180      -> 13
M S L -> 2*27+1*9+3*3  -> 216      -> 14 
M L S -> 2*27+3*9+1*3  -> 252      -> 15
L S M -> 3*27+1*9+2*3  -> 288      -> 16
L M S -> 3*27+2*9+1*3  -> 306      -> 17

05AB1E , 37 bytes

2TŸ.•3u§•S«.•ôì•âíJuDIkćsD{œJsJk>4*+è

Puerto de la respuesta Jelly de @dylnan , pero desafortunadamente 05AB1E no tiene el índice de permutación incorporado.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

2TŸ                # Push the list [2,3,4,5,6,7,8,9,10]
   .•3u§•S         # Push compressed string "jqka", converted to a list of characters
          «        # Merge the lists together
.•ôì•              # Push compressed string "cdhs"
     â             # Create each possible pair
      í            # Reverse each pair
       Ju          # Join each pair together, and convert to uppercase
D                  # Duplicate the deck
 Ik                # Get the index of the cards of the input-list in the deck
   ć               # Extract head; pop and push remainder and head
    s              # Swap to get the remainder
     D{            # Create a sorted copy
       œ           # Get the permutations of that
        JsJk       # Get the index of the unsorted permutation in this permutations list
            >      # Increase it by 1 (since 05AB1E has 0-based indexing)
             4*    # Multiply it by 4
               +   # Add it to the extracted head
                è  # And index it into the duplicated deck
                   # (after which the result is output implicitly)

Consulte este consejo mío de 05AB1E (sección ¿Cómo comprimir cadenas que no forman parte del diccionario? ) Para comprender por qué .•3u§•es "jqka"y .•ôì•es "cdhs".