Nhiệm vụ được lấy từ một bài giảng của MIT bởi Giáo sư Devadas có tên Bạn có thể đọc được suy nghĩ . Một lời giải thích chi tiết về thủ thuật có thể được tìm thấy trong video được liên kết hoặc trong tài liệu này . Tôi sẽ cố gắng giải thích nó bằng những thuật ngữ đơn giản hơn.

Hóa ra điều này đã được phát minh vào những năm 1930, và được gọi là "Thủ thuật năm lá bài của Fitch Cheney" .

Thủ thuật như thế này:

• Năm thẻ ngẫu nhiên được chọn từ một cỗ bài. Khán giả và trợ lý của bạn có thể nhìn thấy họ, nhưng bạn thì không.
• Trợ lý của bạn (người mà bạn đã thực hành) sẽ chọn bốn trong số những thẻ đó và đưa chúng cho bạn theo một thứ tự cụ thể. Lưu ý rằng thẻ ẩn không được chọn ngẫu nhiên trong số 5 thẻ. Các trợ lý chọn một / thẻ sẽ làm cho thủ thuật hoạt động.
• Bạn sẽ suy luận, dựa trên thông tin bạn có thể thu thập từ bốn thẻ, thẻ thứ năm là gì.

Làm sao?

Hãy ghi nhớ hai điểm sau đây:

1. Khi chọn 5 thẻ ngẫu nhiên, bạn được đảm bảo rằng ít nhất hai thẻ có cùng một bộ ¹ .

2. Hình ảnh dưới đây cho thấy một vòng tròn với tất cả các cấp bậc ² . Vì nó là một hình tròn, nên có thể đếm: J, Q, K, A, 2, 3 (tức là đếm mô-đun). Bạn được đảm bảo rằng thẻ ẩn không có cùng thứ hạng với thẻ đầu tiên, vì chúng sẽ có cùng một bộ (giải thích bên dưới). Bạn luôn có thể chọn thẻ đầu tiên và các thẻ ẩn sao cho thẻ ẩn cao hơn từ 1 đến 6 bậc so với thẻ đầu tiên (khi tính theo vòng tròn). Nếu thẻ đầu tiên là 1 , thì thẻ ẩn sẽ là 2,3,4,5,6 hoặc 7 . Nếu thẻ đầu tiên là J , thì thẻ ẩn sẽ là Q, K, A, 2,3 hoặc 4 , v.v.

Thuật toán:

Thẻ đầu tiên: Thẻ này sẽ có cùng bộ đồ với thẻ ẩn. Thẻ cũng sẽ là điểm tham chiếu bạn sẽ sử dụng khi tìm ra thứ hạng của thẻ ẩn.

Thẻ thứ 2, 3 và 4 giải mã một giá trị trong phạm vi bao gồm 1 ... 6 . Chúng tôi sẽ gọi ba thẻ S, M, L (thẻ nhỏ nhất, thẻ giữa, thẻ lớn nhất). Các giá trị sẽ được mã hóa như thế này (thứ tự từ điển):

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

Vì vậy, nếu thứ hạng của thẻ đầu tiên là 5 và ba thẻ còn lại có thứ hạng 4 Q 7 (chúng được đặt hàng SLM ), thì thẻ cuối cùng có thứ hạng 5 + 2 = 7 . Bạn có thể chọn nếu ace nên là thẻ cao nhất hoặc thấp nhất, miễn là nó phù hợp.

Nếu một vài thẻ chia sẻ thứ hạng, thì bộ đồ sẽ xác định thứ tự, trong đó C <D <H <S .

Định dạng đầu vào:

Bốn thẻ sẽ được trao là H3 (ba trái tim), DK (Vua kim cương), v.v. Thay vào đó, bạn có thể chọn đầu vào theo cách khác là 3H và KD .

Đầu vào có thể ở bất kỳ định dạng thuận tiện nào, nhưng bạn không thể kết hợp danh sách các bộ quần áo trong một biến và danh sách xếp hạng trong một biến khác. 'D5', 'H3' ..và [['D',5],['H',3] ...cả hai đều ổn, nhưng 'DHCH',[5,3,1,5]không phải. Bạn không thể sử dụng số thay vì chữ cái, ngoại trừ T .

Đầu ra

Thẻ ẩn, có cùng định dạng với đầu vào.

Thí dụ

Hãy làm một hướng dẫn:

Input:
D3 S6 H3 H9

Chúng ta biết thẻ ẩn là kim cương, vì thẻ đầu tiên là kim cương. Chúng tôi cũng biết rằng thứ hạng là 4,5,6,7,8 hoặc 9 vì thứ hạng của thẻ đầu tiên là 3 .

Các thẻ còn lại được đặt hàng 6,3,9 ==> M, S, L , mã hóa giá trị 3 . Do đó, thẻ ẩn là 3 + 3 = 6 kim cương, do đó đầu ra phải là D6 .

Các trường hợp thử nghiệm:

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

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất trong mỗi ngôn ngữ sẽ thắng. Giải thích được khuyến khích!

¹ Có bốn bộ quần áo ( C lubs, D iamonds, H earts và S pades).

² Có 13 bậc, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Bạn có thể chọn sử dụng T thay vì 10 .

JavaScript (ES6), 130 102 byte

Lấy đầu vào là một chuỗi các chuỗi có "Rs"định dạng, trong đó R là thứ hạng và s là phù hợp. Yêu cầu "T" trong 10 giây . Ách thấp.

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

Hãy thử trực tuyến!

Làm sao?

Trước tiên, chúng tôi chuyển đổi mỗi thẻ thành một mảng [thứ hạng, thẻ] trong đó thứ hạng là một giá trị số trong [14 ... 26] và thẻ là chuỗi gốc.

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

Thứ hạng và bộ đồ của thẻ đầu tiên được lưu trữ trong R và S tương ứng. Ba thẻ khác được lưu trữ trong B , C và D .

Chẳng hạn, ['3c','6h','6c','2s']trở thành:

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

Sau đó chúng tôi so sánh từng cặp trong [B, C, D] . Các phần tử này được ép buộc ngầm với các chuỗi khi chúng được so sánh với nhau:

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

Bởi vì cả thứ hạng và thẻ được đảm bảo bao gồm chính xác hai ký tự, nên việc so sánh theo thứ tự từ điển là an toàn.

Chúng tôi tính toán:

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

Dưới đây là tất cả các kết hợp có thể:

 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

Cuối cùng, chúng tôi xây dựng thẻ đầu ra bằng R , S và kết quả trên:

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

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

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

Hãy thử trực tuyến!

Ách cao

Mã hóa ba thẻ bằng cách tìm vị trí của chúng trong danh sách sắp xếp của thẻ ( 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

Điều này được chuyển đổi thành một số nguyên trong cơ sở 3 và nhân với 3, và chia cho 10:

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

Các bảng mã khác nhau là:

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

Đã lưu:

• -2 byte, nhờ có lò nướng

Thạch , 33 byte

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

Hãy thử trực tuyến!

Giải trình

Dòng đầu tiên là niladic. Nó mang lại một danh sách 52 thẻ

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

Trong liên kết chính, ¢gọi kết quả của liên kết đầu tiên là danh sách các thẻ.

¢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 byte ^SBCS

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

Hãy thử trực tuyến!

Tổng quan: 'CDHS'∘.,2↓⎕D,'TJQKA'tạo ra sản phẩm bên ngoài, do đó, ma trận 2d với (C2 C3 C4 ...), (D2 D3 D4 ...), .... Sau đó chúng ta hoán chuyển ma trận này để lấy (C2 D2 H2 ...), ...và làm phẳng nó.

Cảm ơn @ngn vì 2-⌊1.8⊥đã lấy thứ tự thẻ (SML = 1 2 3) và xếp loại chúng (như 1 đến 6 trong OP).

Mã giải thích:

⊃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

Võng mạc , 218 208 byte

[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

Hãy thử trực tuyến!

Giải trình:

[JQK]
1$&
T`AJQK`1123

Thay thế Aces, Jacks, Queen và Kings bằng 1, 11, 12 và 13. Hai dòng đầu tiên viết trước một 1chữ cái và cuối cùng phiên âm chữ số thứ hai.

*' G0`

Chỉ *ra rằng giai đoạn này không nên sửa đổi chuỗi làm việc. Điều này có thể làm cho sân khấu dường như vô nghĩa, nhưng nó sẽ hữu ích sau này. Chuỗi 'phân tách chuỗi làm việc ở mọi không gian và G0lấy chuỗi đầu tiên (để nó tìm thấy thẻ đầu tiên).

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

Hai dòng đầu tiên nhân các số trên thẻ với 5, sau đó biến chúng thành đơn vị (ví dụ: 5 được biểu thị dưới dạng _____), để chúng ta có thể thêm số lượng nhỏ hơn cho các bộ quần áo sau này. Dòng cuối cùng phân chia trên các khoảng trắng và giữ ba thẻ cuối cùng.

T`CD\HS`d
\d
*

Điều này chuyển đổi các Câu lạc bộ, Kim cương, Trái tim và Spades thành 0, 1, 2 và 3 tương ứng, và biến số thành số đơn. Vì hiện tại nó được gắn vào phần số của thẻ, nó sẽ cung cấp một giá trị duy nhất cho thẻ, xác định mức độ cao của nó.

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

Điều này tìm thấy thứ tự của các thẻ và giá trị để thêm vào thẻ đầu tiên. Ví dụ: trên dòng đầu tiên /^(_+)¶\1_+/(khớp với các đơn hàng có giá trị trung bình lớn hơn giá trị đầu tiên. Nó tạo ra một vòng lặp if-other để làm gì (vì thứ tự này khớp với các hoán vị 1, 2 và 4). Kđánh dấu một hằng số.

\d
$+3-$&

Nhớ trước đó khi chúng ta thường *chỉ ra rằng một giai đoạn sẽ không ảnh hưởng đến chuỗi làm việc? Đây là nơi chúng tôi sử dụng nó. Giai đoạn này là giai đoạn thay thế; nó thay thế số để thêm bởi $+3-$&. $+3truy cập vào *sân khấu, và nhận được bộ quần áo và số của thẻ đầu tiên, -hoạt động như một người tách biệt, và $&là trận đấu. Vì vậy, chuỗi làm việc bây giờ{suit}{original number}-{number to add}

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

Điều này biến hai số thành đơn nhất và cộng chúng lại với nhau.

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

Dòng trên cùng ghi lại số hoặc số - 13 (để chúng tôi không nhận được kết quả đầu ra, ví dụ S16). Dòng dưới cùng biến số bị bắt trở lại thành cơ sở 10 và kết quả được in hoàn toàn.

Than , 64 62 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng Tcho 10 và sắp xếp Acao. Chỉ số hoán vị không dễ dàng giải mã; một thứ tự hoán vị khác nhau sẽ giúp tôi tiết kiệm ít nhất ba byte. Giải trình:

⁺⭆⁸⁺²ιTJQKA

Thêm 2 vào tất cả các số nguyên từ 0 đến 7, sau đó ghép chúng và hậu tố TJQKAcho các thẻ hình và ace. Điều này tiết kiệm 2 byte trên một chuỗi ký tự, mặc dù hóa ra việc có Amức cao sẽ lưu một byte thông qua nén chuỗi.

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

Bản đồ qua các thẻ và bộ quần áo, kết hợp hai người lại với nhau. Vì điều này thường tạo ra một mảng lồng nhau, kết quả thay vào đó được nối thành một chuỗi duy nhất sau đó được chia thành các cặp ký tự một lần nữa.

≔Ｅ⟦ηζε⟧⌕διυ

Tìm vị trí của thẻ thứ hai, thứ ba và thứ tư.

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

Tính toán chỉ số hoán vị 1 chỉ số. Hai hoán vị đầu tiên có thẻ nhỏ nhất trước; Điều này được thử nghiệm thông qua ⌕υ⌊υ. Hai cặp hoán vị khác được phân biệt là liệu thẻ lớn nhất có phải là đầu tiên hay không; Điều này được thử nghiệm thông qua ⌕υ⌈υ. Phép toán logic và số học sau đó bản đồ những thử nghiệm với các giá trị 0, 2và 4; điều này sau đó được tăng lên 1tùy thuộc vào sự so sánh giữa thẻ thứ ba và thẻ thứ tư, được kiểm tra thông qua ‹⊟υ⊟υ. Cuối cùng, chỉ số được tăng lên để đưa ra mã hóa mong muốn.

§δ⁺⌕δθ×⁴...

Nhân số đó với 4 lần lặp lại khoảng cách giữa các thẻ của cùng một bộ đồ, thêm vào vị trí của thẻ đầu tiên, và lập chỉ mục theo chu kỳ và in kết quả.

Python 2 , 147 byte

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

Hãy thử trực tuyến!

Bình thường, 42 byte

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

Rất xấu...

Dùng thử trực tuyến: Demontration hoặc Test Suite

J , 68 byte

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

Hãy thử trực tuyến!

Lưu ý: -3 tắt byte TIO vì f=.không tính. Sẽ cố gắng để chơi golf hơn nữa và thêm lời giải thích vào ngày mai.

JavaScript (Node.js) , 124 byte

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]

Hãy thử trực tuyến!

JavaScript (Node.js) , 125 byte

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]

Hãy thử trực tuyến!

T-SQL, 211 byte

Đầu vào là một biến bảng. Sử dụng T cho 10, con át rất thấp

Định dạng cho thẻ xếp hạng / bộ đồ 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

Dùng thử trực tuyến ungolfed

Lưu ý cách tính giá trị SML (12-17):

Hợp lý S, M, L (1,2,3) được chuyển đổi thành giá trị số

thẻ đầu tiên có giá trị thứ tự 27 *

thẻ thứ hai có giá trị chuỗi 9 *

thẻ thứ ba có giá trị 3 * giá trị chuỗi

Bằng cách nhân với 3, căn bậc hai được làm tròn trở thành một số tuần tự tốt đẹp.

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 byte

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

Câu trả lời Jelly của @dylnan , nhưng thật không may, 05AB1E không có sẵn chỉ số hoán vị ..

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để chuỗi nén không nằm trong từ điển? ) Để hiểu tại sao .•3u§•là "jqka"và .•ôì•là "cdhs".