งานจะนำมาจากการบรรยายโดยศ MIT Devadas เรียกว่าคุณสามารถอ่านใจ คำอธิบายโดยละเอียดของเคล็ดลับสามารถพบได้ในวิดีโอที่เชื่อมโยงหรือในเอกสารนี้ ฉันจะพยายามอธิบายให้ง่ายขึ้น

มันจะเปิดออกนี้ถูกประดิษฐ์ขึ้นในปี 1930 และเป็นที่รู้จักในฐานะ"เคล็ดลับห้าบัตรของฟิทช์เชนีย์"

เคล็ดลับไปเช่นนี้:

• สุ่มเลือกไพ่ห้าใบจากสำรับไพ่ ผู้ชมและผู้ช่วยของคุณจะได้เห็นพวกเขา แต่คุณทำไม่ได้
• ผู้ช่วยของคุณ (ซึ่งคุณฝึกมาแล้ว) จะเลือกไพ่สี่ใบจากนั้นแสดงให้คุณตามลำดับที่เฉพาะเจาะจง โปรดทราบว่าการ์ดที่ซ่อนอยู่จะไม่ถูกสุ่มเลือกจากไพ่ 5 ใบ ผู้ช่วยเลือกการ์ด / ที่จะทำให้การหลอกลวง
• คุณจะอนุมานจากข้อมูลที่คุณสามารถรวบรวมจากไพ่สี่ใบที่ไพ่ใบที่ห้าคืออะไร

อย่างไร?

ระลึกถึงสองประเด็นต่อไปนี้:

1. เมื่อเลือกไพ่ 5 ใบสุ่มคุณจะรับประกันว่าอย่างน้อยสองใบมีชุดเดียวกัน1

2. ภาพด้านล่างแสดงวงกลมที่มีอันดับ²ทั้งหมด เนื่องจากเป็นวงกลมจึงสามารถนับได้: J, Q, K, A, 2, 3 (เช่นการนับแบบแยกส่วน) คุณรับประกันได้ว่าการ์ดที่ซ่อนไม่ได้อยู่ในอันดับเดียวกันกับการ์ดใบแรกเนื่องจากการ์ดจะเป็นชุดเดียวกัน (อธิบายไว้ด้านล่าง) เป็นไปได้เสมอที่จะเลือกไพ่ใบแรกและการ์ดที่ซ่อนอยู่ซึ่งการ์ดที่ซ่อนอยู่ระหว่าง 1 และ 6 อันดับจะสูงกว่าไพ่ใบแรก (เมื่อนับเป็นวงกลม) หากบัตรแรกคือ1แล้วบัตรที่ซ่อนอยู่จะเป็น2,3,4,5,6 หรือ 7 หากไพ่ใบแรกเป็นJการ์ดที่ถูกซ่อนจะเป็นQ, K, A, 2,3 หรือ 4เป็นต้น

อัลกอริทึม:

ไพ่ใบแรก: การ์ดใบนี้จะมีชุดเดียวกันกับการ์ดที่ซ่อนอยู่ การ์ดจะเป็นจุดอ้างอิงที่คุณจะใช้เมื่อค้นหาอันดับของการ์ดที่ซ่อนอยู่

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 คุณสามารถเลือกได้ว่าเอซควรเป็นไพ่สูงสุดหรือต่ำที่สุดตราบใดที่การ์ดยังสอดคล้องกัน

หากลำดับหุ้นหลายบัตรแล้วชุดที่จะตรวจสอบการสั่งซื้อที่C <D <H <S

รูปแบบอินพุต:

ไพ่สี่ใบจะได้รับเป็นH3 (สามดวง), DK (ราชาแห่งเพชร) เป็นต้น คุณอาจเลือกที่จะรับอินพุตด้วยวิธีอื่น ๆ เช่น3HและKDแทน

อินพุตสามารถอยู่ในรูปแบบที่สะดวก แต่คุณไม่สามารถรวมรายการชุดเข้าด้วยกันในตัวแปรหนึ่งและรายการอันดับในอีกชุดได้ 'D5', 'H3' ..และ [['D',5],['H',3] ...ใช้ได้ทั้งคู่ แต่'DHCH',[5,3,1,5]ไม่ใช่ คุณไม่สามารถใช้ตัวเลขแทนตัวอักษรยกเว้นT

เอาท์พุต

การ์ดที่ซ่อนอยู่ในรูปแบบเดียวกับอินพุต

ตัวอย่าง

ลองทำแบบทดสอบ:

Input:
D3 S6 H3 H9

เรารู้ว่าการ์ดที่ซ่อนเป็นเพชรเนื่องจากไพ่ใบแรกเป็นเพชร นอกจากนี้เรายังรู้ว่ายศเป็น4,5,6,7,8 หรือ 9ตั้งแต่ยศบัตรแรกคือ3

บัตรที่เหลือจะได้รับคำสั่ง6,3,9 ==> M, S, Lซึ่ง encodes ค่า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

นี่คือรหัสกอล์ฟดังนั้นทางออกที่สั้นที่สุดในแต่ละภาษาชนะ คำอธิบายได้รับการสนับสนุน!

¹มีสี่ชุด ( C lubs, D iamonds, H earts และS 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 ปี เอซต่ำ

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+Ḣị¢

ลองออนไลน์!

คำอธิบาย

บรรทัดแรกคือ niladic มันให้รายชื่อของ 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) และให้คะแนน (เช่น 1 ถึง 6 ใน OP)

คำอธิบายรหัส:

⊃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

เรติน่า218 208 ไบต์

[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

แทนที่ Aces, Jacks, Queens and Kings ด้วย 1, 11, 12 และ 13 สองบรรทัดแรก1จะเติมก่อนตัวอักษรและตัวสุดท้ายจะเป็นตัวที่สอง

*' G0`

*แสดงให้เห็นว่าขั้นตอนนี้ไม่ควรปรับเปลี่ยนการทำงานสตริง นี่อาจทำให้เวทีดูไม่มีจุดหมาย แต่มันจะมีประโยชน์ในภายหลัง การ'แบ่งสตริงการทำงานในทุกพื้นที่และG0รับสายแรก (ดังนั้นจึงพบการ์ดใบแรก)

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

สองบรรทัดแรกคูณตัวเลขบนการ์ดด้วย 5 จากนั้นเปลี่ยนเป็น unary (ตัวอย่างเช่น 5 แทนด้วย _____) เพื่อให้เราสามารถเพิ่มจำนวนที่น้อยลงสำหรับชุดในภายหลัง บรรทัดสุดท้ายแยกออกจากช่องว่างและเก็บไพ่สามใบสุดท้ายไว้

T`CD\HS`d
\d
*

สิ่งนี้จะแปลง Clubs, Diamonds, Hearts and Spades เป็น 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⁺λι²δ≔Ｅ⟦ηζε⟧⌕διυ§δ⁺⌕δθ×⁴⊕⁺∧⌕υ⌊υ⊗⊕¬⌕υ⌈υ‹⊟υ⊟υ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ใช้Tเวลา 10 และAสูง ดัชนีการเปลี่ยนแปลงไม่ได้ถูกถอดรหัสได้ง่ายนัก ลำดับการเรียงสับเปลี่ยนที่แตกต่างกันจะช่วยฉันอย่างน้อยสามไบต์ คำอธิบาย:

⁺⭆⁸⁺²ιTJQKA

เพิ่ม 2 ให้เป็นจำนวนเต็มทั้งหมด 0 ถึง 7 จากนั้นต่อกันและต่อท้ายTJQKAการ์ดรูปภาพและเอซ สิ่งนี้จะช่วยประหยัด 2 ไบต์บนสตริงตัวอักษรถึงแม้ว่าปรากฎว่าการมีAค่าสูงจะมีการบันทึกไบต์ผ่านการบีบอัดสตริงอย่างไรก็ตาม

≔⪪⭆...⭆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 off ไบต์ 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 เอซอยู่ในระดับต่ำ

รูปแบบสำหรับการ์ดอันดับ / สูท 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

ลองมันออนไลน์ ungolfed

สังเกตการคำนวณค่า 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 's คำตอบวุ้นแต่โชคร้าย 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§•เป็น"jqka"และเป็น.•ôì•"cdhs"