La tâche est extraite d’une conférence du professeur MIT Devadas intitulée « Vous pouvez lire dans les pensées» . Une explication détaillée de l'astuce peut être trouvée dans la vidéo liée, ou dans ce document . Je vais essayer de l'expliquer en termes plus simples.

Il s’avère que cette invention a été inventée dans les années 1930 et qu’elle est connue sous le nom de "tour de cinq cartes de Fitch Cheney" .

Le truc va comme ça:

• Cinq cartes au hasard sont choisies parmi un jeu de cartes. Le public et votre assistant peuvent les voir, mais vous ne les voyez pas.
• Votre assistant (avec qui vous avez pratiqué) sélectionnera quatre de ces cartes et vous les montrera dans un ordre spécifique. Notez que la carte cachée n'est pas choisie au hasard parmi les 5 cartes. L'assistant choisit une / la carte qui fera fonctionner l'astuce.
• Vous en déduirez, en fonction des informations que vous pouvez collecter sur les quatre cartes, en quoi consiste la cinquième carte.

Comment?

Gardez les deux points suivants à l’esprit:

1. Lorsque vous choisissez 5 cartes au hasard, vous avez la garantie qu'au moins deux cartes ont la même couleur ¹ .

2. L'image ci-dessous montre un cercle avec tous les rangs ² . Comme il s’agit d’un cercle, il est possible de compter: J, Q, K, A, 2, 3 (comptage modulaire). Vous avez la garantie que la carte cachée n'a pas le même rang que la première, puisqu'elles auront la même couleur (expliqué ci-dessous). Il est toujours possible de choisir la première carte et les cartes cachées de telle sorte que la carte cachée soit entre 1 et 6 rangs plus élevé que la première (en comptant dans les cercles). Si la première carte est 1 , la carte cachée sera 2,3,4,5,6 ou 7 . Si la première carte est J , alors la carte cachée sera Q, K, A, 2,3 ou 4 et ainsi de suite.

L'algorithme:

La première carte: Cette carte aura la même couleur que la carte cachée. La carte sera également le point de référence que vous utiliserez pour déterminer le rang de la carte cachée.

Les 2ème, 3ème et 4ème cartes décodent une valeur comprise entre 1 et 6 . Nous appellerons les trois cartes S, M, L (la plus petite carte, la carte du milieu, la plus grande). Les valeurs seront codées comme ceci (ordre lexicographique):

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

Donc, si le rang de la première carte est 5 et que les trois cartes restantes ont le rang 4 Q 7 (elles sont commandées SLM ), alors la dernière carte a le rang 5 + 2 = 7 . Vous pouvez choisir si l'as doit être la carte la plus haute ou la plus basse, tant que c'est cohérent.

Si plusieurs cartes partagent le rang, la couleur déterminera l'ordre dans lequel C <D <H <S .

Format d'entrée:

Les quatre cartes seront données sous la forme H3 (trois de cœur), DK (roi des diamants), etc. Vous pouvez choisir de prendre l’inverse à l’inverse sous la forme 3H et KD .

L'entrée peut être sur n'importe quel format pratique, mais vous ne pouvez pas combiner la liste des couleurs dans une variable et la liste des rangs dans une autre. 'D5', 'H3' ..et [['D',5],['H',3] ...sont tous les deux OK, mais 'DHCH',[5,3,1,5]n'est pas. Vous ne pouvez pas utiliser des numéros au lieu de lettres, à l' exception des T .

Sortie

La carte cachée, au même format que l’entrée.

Exemple

Faisons un pas à pas:

Input:
D3 S6 H3 H9

Nous savons que la carte cachée est un diamant, puisque la première carte est un diamant. Nous savons aussi que le rang est de 4,5,6,7,8 ou 9 puisque le rang de la première carte est de 3 .

Les cartes restantes sont commandées 6,3,9 ==> M, S, L , qui code la valeur 3 . La carte cachée est donc 3 + 3 = 6 de diamants, donc la sortie devrait être D6 .

Cas de test:

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

C'est du code-golf , donc la solution la plus courte dans chaque langue est gagnante. Les explications sont les bienvenues!

¹ Il y a quatre couleurs ( C lubs, D iamonds, H earts et S pades).

² Il y a 13 rangs, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Vous pouvez choisir d’utiliser T au lieu de 10 .

JavaScript (ES6), 130 102 octets

Prend l'entrée sous la forme d'un tableau de chaînes au "Rs"format, où R est le rang et s le costume. S'attend à "T" pour 10. Les as sont faibles.

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

Essayez-le en ligne!

Comment?

Nous convertissons d'abord chaque carte en un tableau [rank, card] où rang est une valeur numérique dans [14 ... 26] et card est la chaîne d'origine.

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

Le rang et la couleur de la première carte sont stockés dans R et S respectivement. Les trois autres cartes sont stockées dans B , C et D .

Par exemple, ['3c','6h','6c','2s']devient:

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

Nous comparons ensuite chaque paire dans [B, C, D] . Ces éléments sont implicitement contraints aux chaînes lorsqu'ils sont comparés les uns aux autres:

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

Etant donné que le rang et la carte sont assurés de contenir exactement deux caractères, la comparaison dans l'ordre lexicographique est sûre.

Nous calculons:

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

Vous trouverez ci-dessous toutes les combinaisons possibles:

 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

Enfin, nous construisons la carte de sortie en utilisant R , S et le résultat ci-dessus:

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

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

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

Essayez-le en ligne!

Les as sont élevés

Encode les trois cartes en trouvant leur position dans une liste triée des cartes ( 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

Ceci est converti en un entier en base 3 et multiplié par 3, puis divisé par 10:

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

Les différents encodages sont:

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

Enregistré:

• -2 octets, grâce aux ovs

Gelée , 33 octets

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

Essayez-le en ligne!

Explication

La première ligne est niladique. Il donne une liste des 52 cartes

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

Dans le lien principal, ¢appelle le résultat du premier lien qui est la liste des cartes.

¢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 49 octets

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

Essayez-le en ligne!

Vue d'ensemble: 'CDHS'∘.,2↓⎕D,'TJQKA'génère le produit externe, donc une matrice 2D avec (C2 C3 C4 ...), (D2 D3 D4 ...), .... Nous transposons ensuite cette matrice pour l’obtenir (C2 D2 H2 ...), ...puis l’aplatissons.

Merci à @ ngn pour le 2-⌊1.8⊥, qui prend la commande de cartes (SML = 1 2 3) et les note (comme les 1 à 6 dans le PO).

Explication du code:

⊃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

Rétine , 218 208 octets

[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

Essayez-le en ligne!

Explication:

[JQK]
1$&
T`AJQK`1123

Remplace les As, les Valets, les Reines et les Rois par 1, 11, 12 et 13. Les deux premières lignes sont précédées de a 1avant de la lettre et la dernière translittère du deuxième chiffre.

*' G0`

Le *indique que cette étape ne doit pas modifier la chaîne de travail. Cela peut rendre la scène inutile, mais cela vous sera utile plus tard. La 'chaîne divise la chaîne de travail à chaque espace et G0prend la première (pour trouver la première carte).

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

Les deux premières lignes multiplient les nombres sur les cartes par 5, puis transformez-les en unaires (par exemple, 5 est représenté par _____), afin que nous puissions ajouter des montants plus petits pour les suites ultérieurement. La dernière ligne se divise en espaces et conserve les trois dernières cartes.

T`CD\HS`d
\d
*

Ceci convertit les clubs, les diamants, les cœurs et les piques en 0, 1, 2 et 3 respectivement et transforme le nombre en unaire. Puisqu'il se trouve maintenant sur la partie numérotée de la carte, cela donnera une valeur unique à la carte, en déterminant à quelle hauteur.

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

Ceci trouve l'ordre des cartes et la valeur à ajouter à la première carte. Par exemple, sur la première ligne /^(_+)¶\1_+/(, les commandes dont la valeur médiane est supérieure à la première valeur sont comparées. Il crée une boucle if-else pour ce qu'il faut faire (car cet ordre correspond aux permutations 1, 2 et 4). Kmarque une constante.

\d
$+3-$&

Rappelez-vous plus tôt lorsque nous avions l'habitude *d'indiquer qu'une étape n'affecterait pas la chaîne de travail? C'est ici que nous l'utilisons. Cette étape est une étape de remplacement; il remplace le nombre à ajouter $+3-$&. $+3accède à la *scène et obtient le costume et le numéro de la première carte, -agit en tant que séparateur et $&constitue le match. Donc, la chaîne de travail est maintenant{suit}{original number}-{number to add}

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

Cela transforme les deux nombres en unaires et les additionne.

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

La ligne du haut indique soit le nombre, soit le nombre - 13 (afin que nous n'obtenions pas les sorties de S16, par exemple). La ligne du bas ramène le nombre capturé en base 10 et le résultat est imprimé implicitement.

Charbon de bois , 64 62 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Utilise Tpour 10 et trie Ahaut. L'indice de permutation n'a pas été très facilement décodé; un ordre de permutation différent m'aurait économisé au moins trois octets. Explication:

⁺⭆⁸⁺²ιTJQKA

Ajoutez 2 à tous les entiers de 0 à 7, puis concatentez-les et ajoutez un suffixe TJQKAaux cartes illustrées et à l'as. Cela permet d'économiser 2 octets sur un littéral de chaîne, même s'il s'avère que le fait d'avoir Aélevé aurait de toute façon enregistré un octet par compression de chaîne.

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

Carte sur les cartes et les costumes, concatentant les deux ensemble. Dans la mesure où cela produirait normalement un tableau imbriqué, les résultats sont concaténés en une seule chaîne qui est ensuite divisée en paires de caractères.

≔Ｅ⟦ηζε⟧⌕διυ

Trouvez les positions des deuxième, troisième et quatrième cartes.

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

Calcule l'indice de permutation indexé 1. Les deux premières permutations ont la plus petite carte en premier; Ceci est testé via ⌕υ⌊υ. Les deux autres paires de permutations sont différenciées selon que la carte la plus grande est en premier; Ceci est testé via ⌕υ⌈υ. Les opérations logiques et arithmétiques mappent ensuite ces tests sur les valeurs 0, 2et 4; ceci est ensuite augmenté en 1fonction de la comparaison entre la troisième et la quatrième carte, testée via ‹⊟υ⊟υ. Enfin, l'index est incrémenté pour donner le codage souhaité.

§δ⁺⌕δθ×⁴...

Multipliez par 4 la distance entre les cartes de la même couleur, ajoutez la position de la première carte, indexez et imprimez le résultat cycliquement.

Python 2 , 147 octets

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

Essayez-le en ligne!

Pyth, 42 octets

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

Vraiment moche...

Essayez-le en ligne: Demontration ou Test Suite

J , 68 octets

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

Essayez-le en ligne!

Remarque: -3 sur les octets TIO car ils f=.ne comptent pas. Je vais essayer de jouer plus au golf et ajouter une explication demain.

JavaScript (Node.js) , 124 octets

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]

Essayez-le en ligne!

JavaScript (Node.js) , 125 octets

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]

Essayez-le en ligne!

T-SQL, 211 octets

L'entrée est une variable de table. En utilisant T pour 10, les as sont faibles

Format pour le classement / la correspondance des cartes 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

Essayez - le en ligne ungolfed

Notez comment la valeur SML (12-17) est calculée:

Logiquement, S, M, L (1,2,3) est converti en une valeur numérique

la première carte a une valeur de 27 * valeur de séquence

la deuxième carte a la valeur 9 * valeur de séquence

la troisième carte a la valeur 3 * valeur de séquence

En multipliant par 3, la racine carrée arrondie devient un joli nombre séquentiel.

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 octets

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

La réponse de Port of @dylnan 's Jelly , mais malheureusement, 05AB1E ne possède pas l'indice de permutation intégré ..

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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)

Voir ce conseil 05AB1E (section Comment compresser des chaînes ne faisant pas partie du dictionnaire? ) Pour comprendre pourquoi .•3u§•est "jqka"et .•ôì•est "cdhs".