A tarefa é retirada de uma palestra do Prof. Devadas, do MIT, chamada Você pode ler mentes . Uma explicação detalhada do truque pode ser encontrada no vídeo vinculado ou neste documento . Vou tentar explicar em termos mais simples.

Acontece que isso foi inventado na década de 1930 e é conhecido como o "truque de cinco cartas da Fitch Cheney" .

O truque é assim:

• Cinco cartas aleatórias são escolhidas de um baralho. A platéia e seu assistente podem vê-los, mas você não.
• Seu assistente (com quem você praticou) selecionará quatro dessas cartas e as mostrará em uma ordem específica. Observe que o cartão oculto não é escolhido aleatoriamente entre os 5 cartões. O assistente escolhe um / o cartão que fará o truque funcionar.
• Você deduzirá, com base nas informações que pode coletar dos quatro cartões, o que é o quinto cartão.

Quão?

Lembre-se dos dois pontos a seguir:

1. Ao escolher 5 cartas aleatórias, você tem a garantia de que pelo menos duas cartas têm o mesmo naipe ¹ .

2. A imagem abaixo mostra um círculo com todas as classificações ² . Como é um círculo, é possível contar: J, Q, K, A, 2, 3 (isto é, contagem modular). Você está garantido que a carta oculta não tem a mesma classificação que a primeira, pois será do mesmo naipe (explicado abaixo). Sempre é possível escolher o primeiro cartão e os cartões ocultos, de modo que o cartão oculto esteja entre 1 e 6 graus mais alto que o primeiro (quando contando em círculos). Se o primeiro cartão for 1 , o cartão oculto será 2,3,4,5,6 ou 7 . Se o primeiro cartão for J , o cartão oculto será Q, K, A, 2,3 ou 4 e assim por diante.

O algoritmo:

A primeira carta: esta carta terá o mesmo naipe da carta oculta. O cartão também será o ponto de referência que você usará ao descobrir a classificação do cartão oculto.

As 2ª, 3ª e 4ª cartas decodificam um valor no intervalo inclusivo 1 ... 6 . Chamaremos os três cartões de S, M, L (cartão menor, cartão do meio, cartão maior). Os valores serão codificados desta forma (ordem lexicográfica):

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

Portanto, se o ranking da primeira carta for 5 e as três cartas restantes tiverem classificação 4 Q 7 (elas são ordenadas SLM ), a última carta terá classificação 5 + 2 = 7 . Você pode escolher se o ás deve ser a carta mais alta ou mais baixa, desde que seja consistente.

Se várias cartas compartilharem o mesmo ranking, o naipe determinará a ordem em que C <D <H <S .

Formato de entrada:

As quatro cartas serão dadas como H3 (três de copas), DK (rei de diamantes) e assim por diante. Você pode optar por considerar a entrada como 3H e KD .

A entrada pode estar em qualquer formato conveniente, mas você não pode combinar a lista de naipes em uma variável e a lista de classificações em outra. 'D5', 'H3' ..e [['D',5],['H',3] ...são ambos OK, mas 'DHCH',[5,3,1,5]não é. Você não pode usar números em vez de letras, com exceção de T .

Resultado

O cartão oculto, no mesmo formato que a entrada.

Exemplo

Vamos fazer uma explicação passo a passo:

Input:
D3 S6 H3 H9

Sabemos que o cartão oculto é um diamante, pois o primeiro cartão é um diamante. Também sabemos que o ranking é 4,5,6,7,8 ou 9, já que o ranking da primeira carta é 3 .

Os cartões restantes são encomendados 6,3,9 ==> M, S, L , que codifica o valor 3 . O cartão oculto é, portanto, 3 + 3 = 6 de diamantes, portanto a saída deve ser D6 .

Casos de teste:

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

Isso é código-golfe , então a solução mais curta em cada idioma vence. As explicações são incentivadas!

¹ Existem quatro naipes ( C Lubs, D iamonds, H earts e S PAdES).

² Existem 13 fileiras, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Você pode optar por usar T em vez de 10 .

JavaScript (ES6), 130 102 bytes

Recebe entrada como uma matriz de seqüências de caracteres em "Rs"formato, onde R é a classificação es é o naipe. Espera "T" por 10 anos. Ases são baixos.

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

Experimente online!

Quão?

Primeiro, convertemos cada cartão em uma matriz [rank, card] onde rank é um valor numérico em [14 ... 26] e card é a string original.

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

A classificação e o naipe da primeira carta são armazenados em R e S, respectivamente. As outras três placas são armazenadas em B , C e D .

Por exemplo, ['3c','6h','6c','2s']torna-se:

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

Em seguida, comparamos cada par em [B, C, D] . Esses elementos são implicitamente coagidos a cadeias de caracteres quando são comparados entre si:

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

Como é garantido que a classificação e a carta consistem em exatamente dois caracteres, é seguro comparar em ordem lexicográfica.

Computamos:

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

Abaixo estão todas as combinações possíveis:

 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, construímos o cartão de saída usando R , S e o resultado acima:

'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

Experimente online!

Ases são altos

Codifica as três cartas localizando sua posição em uma lista ordenada de 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

Isso é convertido em um número inteiro na base 3 e multiplicado por 3 e dividido por 10:

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

As diferentes codificações são:

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

Salvou:

• -2 bytes, graças a ovs

Gelatina , 33 bytes

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

Experimente online!

Explicação

A primeira linha é niládica. Rende uma lista dos 52 cartões

Ø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']

No link principal, ¢chama o resultado do primeiro link, que é a lista de cartões.

¢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) , 49 bytes ^SBCS

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

Experimente online!

Visão geral: 'CDHS'∘.,2↓⎕D,'TJQKA'gera o produto externo, portanto, uma matriz 2D com (C2 C3 C4 ...), (D2 D3 D4 ...), .... Transporemos essa matriz para obter (C2 D2 H2 ...), ...e achatar isso.

Obrigado a @ngn pelo 2-⌊1.8⊥, que pega a ordem dos cartões (SML = 1 2 3) e os classifica (como de 1 a 6 no OP).

Explicação do 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

Experimente online!

Explicação:

[JQK]
1$&
T`AJQK`1123

Substitui Ases, Valetes, Rainhas e Reis por 1, 11, 12 e 13. As duas primeiras linhas precedem a 1antes da letra e o último translitera o segundo dígito.

*' G0`

A *indica que nesta fase não deve modificar a seqüência de trabalho. Isso pode fazer o cenário parecer inútil, mas será útil mais tarde. Ele 'divide a cadeia de trabalho em todos os espaços e G0pega a primeira (para encontrar a primeira carta).

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

As duas primeiras linhas multiplicam os números dos cartões por 5 e depois os tornam unários (por exemplo, 5 é representado como _____), para que possamos adicionar quantias menores para os fatos mais tarde. A linha final se divide em espaços e mantém as três últimas cartas.

T`CD\HS`d
\d
*

Isso converte Clubes, Diamantes, Copas e Espadas em 0, 1, 2 e 3, respectivamente, e transforma o número em unário. Como está agora anexado à parte numérica do cartão, ele fornecerá um valor exclusivo para o cartão, determinando a sua altura.

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

Isso encontra a ordem dos cartões e o valor a ser adicionado ao primeiro cartão. Por exemplo, na primeira linha /^(_+)¶\1_+/(corresponde a pedidos que têm o valor do meio maior que o primeiro valor. Ele cria um loop if-else para o que fazer (pois essa ordem corresponde às permutações 1, 2 e 4). Kmarca uma constante.

\d
$+3-$&

Lembra-se anteriormente, quando costumávamos *indicar que um estágio não afetaria a sequência de trabalho? É aqui que a usamos. Este estágio é um estágio de substituição; ele substitui o número a ser adicionado $+3-$&. $+3acessa o *palco, pega o naipe e o número da primeira carta, -atua como um separador e $&é a partida. Então a cadeia de trabalho está agora{suit}{original number}-{number to add}

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

Isso transforma os dois números em unários e os soma.

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

A linha superior captura o número ou o número - 13 (para que não tenhamos saídas, por exemplo, S16). A linha inferior transforma o número capturado novamente na base 10 e o resultado é impresso implicitamente.

Carvão , 64 62 bytes

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

Experimente online! Link é a versão detalhada do código. Usa Tpara 10 e classifica Aalto. O índice de permutação não foi decodificado com muita facilidade; uma ordem de permutação diferente teria me poupado pelo menos três bytes. Explicação:

⁺⭆⁸⁺²ιTJQKA

Adicione 2 a todos os números inteiros de 0 a 7 e concatente-os e sufixo TJQKApara os cartões de figuras e ás. Isso economiza 2 bytes sobre um literal de cadeia de caracteres, embora aconteça que ter Aalto teria economizado um byte através da compactação de cadeia de qualquer maneira.

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

Mapa sobre as cartas e os naipes, concatentando os dois juntos. Como isso normalmente produziria uma matriz aninhada, os resultados são concatenados em uma única sequência, que é dividida em pares de caracteres novamente.

≔Ｅ⟦ηζε⟧⌕διυ

Encontre as posições do segundo, terceiro e quarto cartões.

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

Calcule o índice de permutação indexado em 1. As duas primeiras permutações têm a menor carta primeiro; isso é testado via ⌕υ⌊υ. Os outros dois pares de permutações são diferenciados quanto à primeira carta maior; isso é testado via ⌕υ⌈υ. As operações lógicas e aritméticas mapeiam esses testes para os valores 0, 2e 4; isso é aumentado 1dependendo da comparação entre a terceira e a quarta placas, testadas via ‹⊟υ⊟υ. Finalmente, o índice é incrementado para fornecer a codificação desejada.

§δ⁺⌕δθ×⁴...

Multiplique isso por 4 representando a distância entre as cartas do mesmo naipe, adicione a posição da primeira carta e indexe ciclicamente e imprima o 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

Experimente online!

Pitão, 42 bytes

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

Realmente feio...

Experimente on-line: Demontration ou Test Suite

J , 68 bytes

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

Experimente online!

Nota: -3 fora de bytes TIO porque o f=.não conta. Tentará jogar mais e adicionar explicações amanhã.

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]

Experimente online!

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]

Experimente online!

T-SQL, 211 bytes

Entrada é uma variável de tabela. Usando T para 10, ases são baixos

Formato para classificação de cartas / naipe 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

Experimente on-line sem limites

Observe como o valor SML (12-17) é calculado:

Logicamente S, M, L (1,2,3) é convertido em um valor numérico

primeiro cartão é avaliado 27 * valor de sequência

o segundo cartão é valorizado 9 * valor de sequência

o terceiro cartão é valorizado 3 * valor de sequência

Ao multiplicar por 3, a raiz quadrada arredondada para baixo se torna um bom número seqüencial.

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*+è

Porto de @dylnan resposta Jelly 's , mas infelizmente 05AB1E não tem o builtin índice de permutação ..

Experimente online ou verifique todos os casos de teste .

Explicação:

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 esta dica 05AB1E (seção Como compactar cadeias de caracteres que não fazem parte do dicionário? ) Para entender por que .•3u§•é "jqka"e .•ôì•é "cdhs".