Tugas ini diambil dari kuliah MIT oleh Prof. Devadas bernama You can read mind . Penjelasan terperinci tentang trik ini dapat ditemukan di video yang ditautkan, atau dalam dokumen ini . Saya akan mencoba menjelaskannya secara lebih sederhana.

Ternyata ini diciptakan pada tahun 1930-an, dan dikenal sebagai "Trik Lima Kartu Fitch Cheney" .

Caranya seperti ini:

• Lima kartu acak dipilih dari setumpuk kartu. Penonton dan asisten Anda dapat melihat mereka, tetapi Anda tidak melihatnya.
• Asisten Anda (dengan siapa Anda telah berlatih) akan memilih empat kartu itu dan menunjukkannya kepada Anda dalam urutan tertentu. Perhatikan bahwa kartu yang tersembunyi tidak diambil secara acak dari 5 kartu. Asisten mengambil kartu yang akan membuat trik bekerja.
• Anda akan menyimpulkan, berdasarkan informasi yang Anda dapat kumpulkan dari empat kartu apa kartu kelima itu.

Bagaimana?

Ingatlah dua hal berikut:

1. Saat memilih 5 kartu acak, Anda dijamin bahwa setidaknya dua kartu memiliki jenis kartu yang sama ¹ .

2. Gambar di bawah ini menunjukkan lingkaran dengan semua peringkat ² . Karena itu lingkaran, dimungkinkan untuk menghitung: J, Q, K, A, 2, 3 (yaitu penghitungan modular). Anda dijamin bahwa kartu yang disembunyikan tidak memiliki peringkat yang sama dengan yang pertama, karena mereka akan memiliki kartu yang sama (dijelaskan di bawah). Selalu dimungkinkan untuk memilih kartu pertama dan kartu tersembunyi sedemikian rupa sehingga kartu tersembunyi berada di antara peringkat 1 dan 6 lebih tinggi daripada yang pertama (saat menghitung dalam lingkaran). Jika kartu pertama adalah 1 , maka kartu yang disembunyikan adalah 2,3,4,5,6 atau 7 . Jika kartu pertama adalah J , maka kartu yang disembunyikan adalah Q, K, A, 2,3 atau 4 dan seterusnya.

Algoritma:

Kartu pertama: Kartu ini memiliki jenis yang sama dengan kartu tersembunyi. Kartu tersebut juga akan menjadi titik referensi yang akan Anda gunakan ketika mencari tahu peringkat kartu yang tersembunyi.

Kartu ke-2, ke-3 dan ke-4 menerjemahkan nilai dalam rentang inklusif 1 ... 6 . Kami akan memanggil tiga kartu S, M, L (kartu terkecil, kartu tengah, kartu terbesar). Nilai-nilai akan dikodekan seperti ini (urutan leksikografis):

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

Jadi, jika peringkat kartu pertama adalah 5 , dan tiga kartu sisanya memiliki peringkat 4 Q 7 (mereka memesan SLM ), maka kartu terakhir memiliki peringkat 5 + 2 = 7 . Anda dapat memilih apakah kartu as harus merupakan kartu tertinggi atau terendah, asalkan konsisten.

Jika beberapa kartu berbagi peringkat, maka suit akan menentukan urutan, di mana C <D <H <S .

Masukkan format:

Keempat kartu akan diberikan sebagai H3 (tiga hati), DK (Raja berlian) dan sebagainya. Anda dapat memilih untuk mengambil input sebaliknya sebagai 3H dan KD sebagai gantinya.

Masukan bisa dalam format apa pun yang mudah, tetapi Anda tidak dapat menggabungkan daftar pakaian dalam satu variabel dan daftar peringkat di yang lain. 'D5', 'H3' ..dan [['D',5],['H',3] ...keduanya OK, tetapi 'DHCH',[5,3,1,5]tidak. Anda tidak dapat menggunakan angka alih-alih huruf, kecuali untuk T .

Keluaran

Kartu tersembunyi, dalam format yang sama dengan input.

Contoh

Mari kita lakukan langkah-langkah:

Input:
D3 S6 H3 H9

Kita tahu kartu yang disembunyikan adalah berlian, karena kartu pertama adalah berlian. Kita juga tahu bahwa peringkatnya adalah 4,5,6,7,8 atau 9 karena peringkat kartu pertama adalah 3 .

Kartu yang tersisa dipesan 6,3,9 ==> M, S, L , yang mengkodekan nilai 3 . Karenanya, kartu tersembunyi adalah 3 + 3 = 6 berlian, sehingga hasilnya harus D6 .

Kasus uji:

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

Ini adalah kode-golf , sehingga solusi terpendek dalam setiap bahasa menang. Penjelasan didorong!

¹ Ada empat setelan ( C lubs, D iamonds, H earts dan S pades).

² Ada 13 jajaran, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Anda dapat memilih untuk menggunakan T daripada 10 .

JavaScript (ES6), 130 102 byte

Mengambil input sebagai array string dalam "Rs"format, di mana R adalah peringkat dan s adalah suit. Harapkan "T" untuk 10's. Aces rendah.

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

Cobalah online!

Bagaimana?

Kami pertama-tama mengonversi setiap kartu menjadi array [peringkat, kartu] di mana peringkat adalah nilai numerik dalam [14 ... 26] dan kartu adalah string asli.

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

Pangkat dan jenis kartu pertama disimpan masing-masing dalam R dan S. Tiga kartu lainnya disimpan dalam B , C dan D .

Misalnya, ['3c','6h','6c','2s']menjadi:

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

Kami kemudian membandingkan setiap pasangan dalam [B, C, D] . Elemen-elemen ini secara implisit dipaksa ke string ketika mereka dibandingkan satu sama lain:

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

Karena peringkat dan kartu dijamin terdiri dari tepat dua karakter, aman untuk membandingkan dalam urutan leksikografis.

Kami menghitung:

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

Di bawah ini semua kemungkinan kombinasi:

 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

Akhirnya, kami membuat kartu keluaran menggunakan R , S dan hasil di atas:

'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

Cobalah online!

Aces tinggi

Encode ketiga kartu dengan menemukan posisinya di daftar kartu yang diurutkan ( 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

Ini dikonversi menjadi bilangan bulat di basis 3 dan dikalikan dengan 3, dan dibagi dengan 10:

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

Pengkodean yang berbeda adalah:

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

Disimpan:

• -2 byte, terima kasih atas ovs

Jelly , 33 byte

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

Cobalah online!

Penjelasan

Baris pertama adalah niladik. Ini menghasilkan daftar 52 kartu

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

Di tautan utama, ¢panggil hasil dari tautan pertama yang merupakan daftar kartu.

¢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'

Cobalah online!

Ikhtisar: 'CDHS'∘.,2↓⎕D,'TJQKA'menghasilkan produk luar, jadi matriks 2d dengan (C2 C3 C4 ...), (D2 D3 D4 ...), .... Kami kemudian memindahkan matriks ini untuk mendapatkan (C2 D2 H2 ...), ...dan kemudian meratakannya.

Berkat @ngn untuk 2-⌊1.8⊥, yang mengambil urutan kartu (SML = 1 2 3) dan menilai mereka (seperti 1 hingga 6 di OP).

Penjelasan kode:

⊃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 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

Cobalah online!

Penjelasan:

[JQK]
1$&
T`AJQK`1123

Menggantikan Aces, Jacks, Queens dan Kings dengan 1, 11, 12 dan 13. Dua baris pertama mendahului a 1sebelum huruf, dan yang terakhir mentransliterasikan digit kedua.

*' G0`

The *menunjukkan bahwa tahap ini tidak harus memodifikasi string bekerja. Ini mungkin membuat panggung tampak tidak ada gunanya, tetapi akan bermanfaat nantinya. The 'membagi string bekerja di setiap ruang, dan G0mengambil yang pertama (sehingga menemukan kartu pertama).

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

Dua baris pertama mengalikan angka pada kartu dengan 5, kemudian mengubahnya menjadi unary (misalnya, 5 diwakili sebagai _____), sehingga kita dapat menambahkan jumlah yang lebih kecil untuk jas nanti. Baris terakhir terbagi menjadi spasi dan menyimpan tiga kartu terakhir.

T`CD\HS`d
\d
*

Ini mengkonversi Clubs, Diamonds, Hearts and Spades menjadi 0, 1, 2 dan 3 masing-masing, dan mengubah angka menjadi unary. Karena sekarang terpasang pada bagian nomor kartu, itu akan memberikan nilai unik untuk kartu, menentukan seberapa tinggi kartu itu.

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

Ini menemukan urutan kartu, dan nilai yang ditambahkan ke kartu pertama. Misalnya, pada baris pertama /^(_+)¶\1_+/(cocok dengan pesanan yang memiliki nilai tengah lebih besar dari nilai pertama. Ini membuat loop if-else untuk apa yang harus dilakukan (karena pesanan ini cocok dengan permutasi 1, 2 dan 4). Kmenandai sebuah konstanta.

\d
$+3-$&

Ingat sebelumnya ketika kami *menunjukkan bahwa sebuah panggung tidak akan memengaruhi string yang berfungsi? Di sinilah kita menggunakannya. Tahap ini adalah tahap penggantian; itu menggantikan nomor untuk ditambahkan $+3-$&. $+3mengakses *panggung, dan mendapatkan kartu dan nomor kartu pertama, -bertindak sebagai pemisah, dan $&merupakan pasangan. Jadi string yang bekerja sekarang{suit}{original number}-{number to add}

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

Ini mengubah dua angka menjadi unary dan menambahkannya bersama.

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

Baris teratas menangkap baik angka atau angka - 13 (sehingga kita tidak mendapatkan output misalnya S16). Intinya mengubah nomor yang ditangkap kembali menjadi basis 10, dan hasilnya dicetak secara implisit.

Arang , 64 62 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Gunakan Tuntuk 10 dan jenis Atinggi. Indeks permutasi tidak mudah diterjemahkan; urutan permutasi yang berbeda akan menyelamatkan saya setidaknya tiga byte. Penjelasan:

⁺⭆⁸⁺²ιTJQKA

Tambahkan 2 ke semua bilangan bulat 0 hingga 7, lalu konverente dan sufiks TJQKAuntuk kartu gambar dan kartu as. Ini menghemat 2 byte lebih dari string literal, meskipun ternyata memiliki Atinggi akan menyimpan byte melalui kompresi string.

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

Peta di atas kartu dan jas, menyatukan keduanya. Karena ini biasanya akan menghasilkan array bersarang, hasilnya malah digabungkan menjadi satu string yang kemudian dipisah menjadi pasangan karakter lagi.

≔Ｅ⟦ηζε⟧⌕διυ

Temukan posisi kartu kedua, ketiga dan keempat.

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

Hitung indeks permutasi 1-diindeks. Dua permutasi pertama memiliki kartu terkecil pertama; ini diuji melalui ⌕υ⌊υ. Dua pasang permutasi lainnya dibedakan apakah kartu terbesar adalah yang pertama; ini diuji melalui ⌕υ⌈υ. Operasi logis dan aritmatika kemudian memetakan tes ini ke nilai-nilai 0, 2dan 4; ini kemudian ditingkatkan dengan 1tergantung pada perbandingan antara kartu ketiga dan keempat, diuji melalui ‹⊟υ⊟υ. Akhirnya indeks bertambah untuk memberikan pengkodean yang diinginkan.

§δ⁺⌕δθ×⁴...

Lipatgandakan dengan 4 repesenting jarak antara kartu dengan jenis yang sama, tambahkan pada posisi kartu pertama, dan indeks secara siklis dan cetak hasilnya.

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

Cobalah online!

Pyth, 42 byte

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

Jelek banget...

Cobalah online: Demontration atau Test Suite

J , 68 byte

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

Cobalah online!

Catatan: -3 off byte TIO karena f=.tidak dihitung. Akan berusaha bermain golf lebih lanjut dan menambahkan penjelasan besok.

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]

Cobalah online!

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]

Cobalah online!

T-SQL, 211 byte

Input adalah variabel tabel. Menggunakan T untuk 10, ace rendah

Format untuk peringkat kartu / kartu 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

Cobalah secara online ungolfed

Perhatikan bagaimana nilai SML (12-17) dihitung:

Secara logis S, M, L (1,2,3) dikonversi ke nilai numerik

kartu pertama bernilai 27 * nilai urut

kartu kedua bernilai 9 * nilai urut

kartu ketiga bernilai 3 * nilai urut

Dengan mengalikan dengan 3, akar kuadrat dibulatkan menjadi angka berurutan yang bagus.

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

Port jawaban Jelly @dylnan , tapi sayangnya 05AB1E tidak memiliki indeks permutasi yang dibangun ..

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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)

Lihat tip tambang 05AB1E ini (bagian Bagaimana mengompresi string bukan bagian dari kamus? ) Untuk memahami mengapa .•3u§•ini "jqka"dan .•ôì•itu "cdhs".