该任务摘自Devadas教授在麻省理工学院的一次演讲，名为“ 您可以读懂思想”。有关此技巧的详细说明，请参见链接的视频或本文档。我将尝试用更简单的术语进行解释。

事实证明，这是1930年代发明的，被称为“惠誉·切尼的五张牌把戏”。

诀窍如下：

• 从一副纸牌中选择五张随机纸牌。观众和您的助手可以看到他们，但您却没有。
• 您的助手（您与之练习过的助手）将选择其中的四张卡片，并按特定顺序显示给您。请注意，隐藏卡不是从5张卡中随机选择的。助手选择一张将使技巧起作用的卡。
• 您将根据从四张卡中收集到的信息推断出第五张卡是什么。

怎么样？

请记住以下两点：

1. 选择5张随机卡片时，可以确保至少有两张卡片具有相同的花色¹。

2. 下图显示了一个等级为²的圆。由于是圆形，因此可以计数：J，Q，K，A，2、3（即模数）。您可以确保隐藏的卡与第一张卡的等级不同，因为它们的西装相同（如下所述）。总是可以选择第一张纸牌和隐藏的纸牌，以使隐藏的纸牌比第一张纸牌高1至6级（按圆圈数时）。如果第一张卡为1，则隐藏的卡将为2、3、4、5、6或7。如果第一张卡是J，那么隐藏的卡将是Q，K，A，2,3或4，依此类推。

算法：

第一张卡：此卡与隐藏卡的西装相同。找出隐藏卡的等级时，该卡也将用作参考点。

第二张，第三张和第四张卡解码范围为1 ... 6的值。我们将这三个卡称为S，M，L（最小卡，中间卡，最大卡）。值将按以下方式编码（字典顺序）：

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

因此，如果第一张牌的等级为5，而其余​​三张牌的等级为4 Q 7（它们被订购SLM），那么最后一张牌的等级为5 + 2 = 7。您可以选择ace是最高牌还是最低牌，只要它是一致的即可。

如果几张牌的排名相同，则西装将确定顺序，其中C <D <H <S。

输入格式：

这四张牌将分别为H3（三颗心），DK（钻石之王）等。您可以选择将输入改为3H和KD。

输入可以采用任何方便的格式，但是您不能将一个变量中的西服列表与另一个变量中的排名列表结合在一起。'D5', 'H3' ..并且 [['D',5],['H',3] ...都是OK的，但'DHCH',[5,3,1,5]并非如此。除了T，您不能使用数字而不是字母。

输出量

隐藏的卡，与输入的格式相同。

例

让我们做一个演练：

Input:
D3 S6 H3 H9

我们知道隐藏的卡是钻石，因为第一张卡是钻石。我们也知道排名是4,5,6,7,8或9，因为第一张牌的排名是3。

其余卡按6,3,9 ==> M，S，L的顺序排序，对值3进行编码。因此，隐藏的卡是3 + 3 = 6的菱形，因此输出应为D6。

测试用例：

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

这是代码高尔夫球，因此每种语言中最短的解决方案将获胜。鼓励解释！

¹有四个套装（Ç鲁布斯，d iamonds，ħ电子艺术和小号的PAdES）。

²共有13个等级，即2,3,4,5,6,7,8,9,10，J，Q，K，A。您可以选择使用T而不是10。

的JavaScript（ES6），130个 102字节

以"Rs"格式的字符串数组形式输入输入，其中R是等级，s是西装。期望“ T”为10。ace低。

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

在线尝试！

怎么样？

我们首先将每张卡转换为数组[rank，card]，其中rank是[14 ... 26]中的数值，而card是原始字符串。

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

第一张卡的等级和花色分别存储在R和S中。其他三张卡分别存储在B，C和D中。

例如，['3c','6h','6c','2s']变为：

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

然后，我们比较[B，C，D]中的每对。将这些元素相互比较时，它们隐式地强制为字符串：

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

由于级别和卡片都保证完全由两个字符组成，因此按字典顺序进行比较是安全的。

我们计算：

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

以下是所有可能的组合：

 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

最后，我们使用R，S和以上结果构建输出卡：

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

Python 2中，143 140 138 136 127 125个 124 123 121字节

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

在线尝试！

王牌高

通过在卡的排序列表（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

将其转换为以3为底的整数并乘以3，再除以10：

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

不同的编码是：

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

已保存：

• -2个字节，多亏了ovs

果冻，33字节

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

在线尝试！

说明

第一行是尼拉地语。它产生了52张卡的列表

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

在主链接中，¢调用第一个链接的结果，即卡列表。

¢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 字节^SBCS

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

在线尝试！

概述：'CDHS'∘.,2↓⎕D,'TJQKA'生成外部乘积，因此使用生成2D矩阵(C2 C3 C4 ...), (D2 D3 D4 ...), ...。然后，我们对该矩阵进行转置以获得(C2 D2 H2 ...), ...并对其进行展平。

感谢@ngn作为2-⌊1.8⊥，它采用卡的顺序（SML = 1 2 3）并对它们进行评分（如OP中的1到6）。

代码说明：

⊃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

视网膜，218208字节

[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

在线尝试！

说明：

[JQK]
1$&
T`AJQK`1123

用1、11、12和13代替A，Jack，Queens和Kings。前两行在1字母前加上a ，最后一行对第二位进行音译。

*' G0`

在*表明这个阶段不应该修改工作字符串。这可能会使阶段显得毫无意义，但稍后将很有用。将'在每一个空间分割工作字符串，G0采取的第一个（所以它找到的第一个卡）。

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

前两行将卡上的数字乘以5，然后将它们转换为一元数（例如5表示为_____），以便稍后我们可以为西装添加较小的数量。最后一行在空格处分割并保留最后三张牌。

T`CD\HS`d
\d
*

这会将“球杆”，“菱形”，“心形”和“锹”分别转换为0、1、2和3，并将数字转换为一元。由于它现在位于卡的数字部分的附件上，因此它将为卡提供唯一的值，从而确定卡的高度。

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

这将查找卡的顺序以及要添加到第一张卡的值。例如，在第一行上/^(_+)¶\1_+/(匹配中间值大于第一值的订单。它为操作创建了一个if-else循环（因为此顺序匹配排列1、2和4）。K标记一个常数。

\d
$+3-$&

还记得前面*提到的阶段不会影响工作字符串的情况吗？这是我们使用它的地方。该阶段是替换阶段；它用代替要添加的数字$+3-$&。$+3进入*舞台，获得第一张牌的西装和编号，-充当分隔符，并且$&是比赛。所以工作字符串现在{suit}{original number}-{number to add}

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

这会将两个数字变成一元并将它们加在一起。

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

第一行捕获数字或数字-13（这样我们就不会得到例如S16的输出）。底线将捕获的数字转回以10为底的数字，结果被隐式打印。

木炭，64 62字节

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

在线尝试！链接是详细版本的代码。使用T10和A高排序。排列索引很难解码。一个不同的排列顺序将为我节省至少三个字节。说明：

⁺⭆⁸⁺²ιTJQKA

将2加到所有0到7的整数中，然后将它们合并起来，并为后缀TJQKA为图片卡和ace。尽管事实证明具有A高电平可以通过字符串压缩节省一个字节，但它在字符串文字上节省了2个字节。

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

映射卡片和西服，将两者结合在一起。由于这通常会产生嵌套的数组，因此将结果串联到单个字符串中，然后再将其拆分为成对的字符。

≔Ｅ⟦ηζε⟧⌕διυ

查找第二张，第三张和第四张卡的位置。

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

计算1索引的置换索引。前两个排列的卡片最小。这是通过测试的⌕υ⌊υ。其他两对排列在最大卡是否在先方面有所区别。这是通过测试的⌕υ⌈υ。然后，逻辑和算术运算将这些测试映射到值0；2和4；然后，1根据通过进行测试的第三张卡与第四张卡之间的比较来增加此值‹⊟υ⊟υ。最后，将索引递增以提供所需的编码。

§δ⁺⌕δθ×⁴...

乘以4代表相同花色的两张纸牌之间的距离，将第一张纸牌的位置相加，并循环索引并打印结果。

Python 2，147字节

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

在线尝试！

Pyth，42个字节

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

真丑

在线尝试：Demontration或Test Suite

J，68字节

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

在线尝试！

注意：-3关闭TIO字节，因为f=.不计数。明天将尝试进一步打高尔夫球并增加解释。

JavaScript（Node.js），124字节

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]

在线尝试！

JavaScript（Node.js），125字节

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]

在线尝试！

T-SQL，211字节

输入是一个表变量。使用T表示10，ace较低

卡等级/套装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

在线试用

注意如何计算SML（12-17）值：

逻辑上将S，M，L（1,2,3）转换为数值

第一张卡的值为27 *序列值

第二张卡的值为9 *序列值

第三张卡的值为3 *序列值

通过乘以3，四舍五入的平方根成为一个不错的序号。

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 个字节

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

@dylnan的Jelly答案端口，但不幸的是05AB1E没有内置的置换索引。

在线尝试或验证所有测试用例。

说明：

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)

请参阅我的05AB1E技巧（如何压缩字符串（不属于字典的一部分？）部分）以了解为什么.•3u§•is "jqka"和.•ôì•is "cdhs"。