Il compito è stato preso da una lezione del MIT del Prof. Devadas chiamata Puoi leggere le menti . Una spiegazione dettagliata del trucco può essere trovata nel video collegato o in questo documento . Proverò a spiegarlo in termini più semplici.

Si scopre che questo è stato inventato negli anni '30 ed è noto come "Five-Card Trick of Fitch Cheney" .

Il trucco va così:

• Cinque carte casuali sono scelte da un mazzo di carte. Il pubblico e il tuo assistente possono vederli, ma tu no.
• Il tuo assistente (con il quale ti sei esercitato) selezionerà quattro di quelle carte e te le mostrerà in un ordine specifico. Nota che la carta nascosta non viene scelta casualmente dalle 5 carte. L'assistente prende una / la carta che farà funzionare il trucco.
• Deducerai, in base alle informazioni che puoi raccogliere dalle quattro carte, qual è la quinta carta.

Come?

Tieni a mente i seguenti due punti:

1. Quando si scelgono 5 carte casuali, si garantisce che almeno due carte hanno lo stesso seme ¹ .

2. L'immagine seguente mostra un cerchio con tutti i gradi ² . Poiché è un cerchio, è possibile contare: J, Q, K, A, 2, 3 (ovvero conteggio modulare). Hai la garanzia che la carta nascosta non ha lo stesso valore della prima, poiché saranno dello stesso seme (spiegato di seguito). È sempre possibile scegliere la prima carta e le carte nascoste in modo tale che la carta nascosta sia tra 1 e 6 gradi più alta della prima (quando si conta nei cerchi). Se la prima carta è 1 , la carta nascosta sarà 2,3,4,5,6 o 7 . Se la prima carta è J , la carta nascosta sarà Q, K, A, 2,3 o 4 e così via.

L'algoritmo:

La prima carta: questa carta avrà lo stesso seme della carta nascosta. La carta sarà anche il punto di riferimento che userai per capire il valore della carta nascosta.

Le carte 2a, 3a e 4a decodificano un valore compreso nell'intervallo 1 ... 6 . Chiameremo le tre carte S, M, L (carta più piccola, carta centrale, carta più grande). I valori verranno codificati in questo modo (ordine lessicografico):

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

Quindi, se il rango della prima carta è 5 e le restanti tre carte hanno rango 4 Q 7 (sono ordinate SLM ), allora l'ultima carta ha rango 5 + 2 = 7 . Puoi scegliere se l'asso deve essere la carta più alta o più bassa, purché sia ​​coerente.

Se più carte condividono il valore, allora il seme determinerà l'ordine, dove C <D <H <S .

Formato di input:

Le quattro carte saranno date come H3 (tre di cuori), DK (re di quadri) e così via. Puoi scegliere di prendere l'input viceversa come 3H e KD .

L'input può essere in qualsiasi formato conveniente, ma non è possibile combinare l'elenco dei semi in una variabile e l'elenco dei ranghi in un'altra. 'D5', 'H3' ..e [['D',5],['H',3] ...sono entrambi OK, ma 'DHCH',[5,3,1,5]non lo è. Non è possibile utilizzare i numeri al posto delle lettere, ad eccezione di T .

Produzione

La carta nascosta, nello stesso formato dell'input.

Esempio

Facciamo una procedura dettagliata:

Input:
D3 S6 H3 H9

Sappiamo che la carta nascosta è un diamante, poiché la prima carta è un diamante. Sappiamo anche che il valore è 4,5,6,7,8 o 9 poiché il valore della prima carta è 3 .

Le carte rimanenti sono ordinate 6,3,9 ==> M, S, L , che codifica il valore 3 . La carta nascosta è quindi 3 + 3 = 6 di diamanti, quindi l'output dovrebbe essere D6 .

Casi 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

Questo è code-golf , quindi vince la soluzione più breve in ogni lingua. Le spiegazioni sono incoraggiate!

¹ Ci sono quattro semi ( C lubs, D iamonds, H earts e S pads).

² ci sono 13 gradi, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Puoi scegliere di usare T invece di 10 .

JavaScript (ES6), 130 102 byte

Prende l'input come una matrice di stringhe in "Rs"formato, dove R è il grado e s è il seme. Si aspetta "T" per 10 anni. Gli assi sono bassi.

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

Provalo online!

Come?

Per prima cosa convertiamo ogni carta in un array [rango, carta] dove rango ha un valore numerico in [14 ... 26] e carta è la stringa originale.

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

Il rango e il seme della prima carta sono memorizzati in R e S rispettivamente. Le tre altre carte sono memorizzati in B , C e D .

Ad esempio, ['3c','6h','6c','2s']diventa:

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

Confrontiamo quindi ciascuna coppia in [B, C, D] . Questi elementi sono implicitamente costretti alle stringhe quando vengono confrontati tra loro:

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

Poiché sia ​​il rango che la carta sono garantiti da esattamente due caratteri, è sicuro confrontarli in ordine lessicografico.

Calcoliamo:

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

Di seguito sono elencate tutte le possibili combinazioni:

 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

Infine, costruiamo la scheda di output usando R , S e il risultato sopra:

'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

Provalo online!

Gli assi sono alti

Codifica le tre carte trovandone la posizione in un elenco ordinato delle carte ( 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

Questo viene convertito in un numero intero in base 3 e moltiplicato per 3 e diviso per 10:

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

Le diverse codifiche sono:

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

Salvato:

• -2 byte, grazie agli ovs

Gelatina , 33 byte

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

Provalo online!

Spiegazione

La prima riga è niladica. Produce un elenco delle 52 carte

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

Nel collegamento principale, ¢chiama il risultato del primo collegamento che è l'elenco delle carte.

¢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 da} 49 byte

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

Provalo online!

Panoramica: 'CDHS'∘.,2↓⎕D,'TJQKA'genera il prodotto esterno, quindi una matrice 2d con (C2 C3 C4 ...), (D2 D3 D4 ...), .... Trasponiamo quindi questa matrice per ottenere (C2 D2 H2 ...), ...e quindi appiattirla.

Grazie a @ngn per il 2-⌊1.8⊥, che prende l'ordine delle carte (SML = 1 2 3) e le classifica (come da 1 a 6 nel PO).

Spiegazione del codice:

⊃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

Provalo online!

Spiegazione:

[JQK]
1$&
T`AJQK`1123

Sostituisce Assi, Jack, Regine e Re con 1, 11, 12 e 13. Le prime due righe antepongono una 1prima della lettera e l'ultima traslittera la seconda cifra.

*' G0`

Il *indica che questa fase non deve modificare la stringa di lavoro. Questo può far sembrare inutile il palcoscenico, ma sarà utile in seguito. Il 'suddivide la stringa lavoro a ogni spazio, e G0prende il primo (così trova la prima carta).

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

Le prime due righe moltiplicano i numeri sulle carte per 5, quindi li trasformano in unari (ad esempio, 5 è rappresentato come _____), in modo da poter aggiungere importi più piccoli per semi in seguito. La linea finale si divide in spazi e mantiene le ultime tre carte.

T`CD\HS`d
\d
*

Questo converte Clubs, Diamonds, Hearts e Spades rispettivamente a 0, 1, 2 e 3 e trasforma il numero in unario. Dal momento che ora è sulla parte allegata della parte numerica della carta, darà un valore univoco per la carta, determinando quanto è alta.

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

Questo trova l'ordinamento delle carte e il valore da aggiungere alla prima carta. Ad esempio, sulla prima riga /^(_+)¶\1_+/(corrisponde agli ordini che hanno un valore medio maggiore del primo valore. Crea un ciclo if-else per cosa fare (poiché questo ordine corrisponde alle permutazioni 1, 2 e 4). Ksegna una costante.

\d
$+3-$&

Ricordi prima quando *indicavamo che uno stage non avrebbe influenzato la stringa di lavoro? Questo è dove lo usiamo. Questa fase è una fase di sostituzione; sostituisce il numero da aggiungere $+3-$&. $+3accede allo *stage, ottiene il seme e il numero della prima carta, -funge da separatore ed $&è la partita. Quindi la stringa di lavoro è ora{suit}{original number}-{number to add}

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

Questo trasforma i due numeri in unari e li somma insieme.

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

La riga superiore cattura il numero o il numero - 13 (in modo da non ottenere output di es. S16). La riga inferiore trasforma di nuovo il numero acquisito nella base 10 e il risultato viene stampato implicitamente.

Carbone , 64 62 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Utilizza Tper 10 e specie A. L'indice di permutazione non è stato decodificato molto facilmente; un diverso ordine di permutazione mi avrebbe salvato almeno tre byte. Spiegazione:

⁺⭆⁸⁺²ιTJQKA

Aggiungi 2 a tutti i numeri interi da 0 a 7, quindi concatente e suffisso TJQKAper le carte illustrate e l'asso. Ciò consente di risparmiare 2 byte su una stringa letterale, anche se risulta che avere un valore Aelevato avrebbe comunque salvato un byte tramite la compressione della stringa.

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

Mappa sopra le carte e i semi, concatenando i due insieme. Dal momento che questo normalmente produce un array nidificato, i risultati vengono invece concatenati in una singola stringa che viene quindi suddivisa in coppie di caratteri.

≔Ｅ⟦ηζε⟧⌕διυ

Trova le posizioni della seconda, terza e quarta carta.

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

Calcola l'indice di permutazione 1-indicizzato. Le prime due permutazioni hanno prima la carta più piccola; questo è testato tramite ⌕υ⌊υ. Le altre due coppie di permutazioni sono differenziate sul fatto che sia la prima carta più grande; questo è testato tramite ⌕υ⌈υ. Operazioni logiche e aritmetiche quindi mappare questi test ai valori 0, 2e 4; questo viene quindi aumentato in 1base al confronto tra la terza e la quarta carta, testato tramite ‹⊟υ⊟υ. Infine, l'indice viene incrementato per fornire la codifica desiderata.

§δ⁺⌕δθ×⁴...

Moltiplica quello per 4 ripetendo la distanza tra le carte dello stesso seme, aggiungi la posizione della prima carta e indicizza e stampa ciclicamente il risultato.

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

Provalo online!

Pyth, 42 byte

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

Davvero brutto ...

Provalo online: Demontration o Test Suite

J , 68 byte

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

Provalo online!

Nota: -3 di byte TIO disattivati ​​perché f=.non conta. Tenterà di giocare a golf ulteriormente e aggiungere spiegazioni domani.

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]

Provalo 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]

Provalo online!

T-SQL, 211 byte

L'input è una variabile di tabella. Usando T per 10, gli assi sono bassi

Formato per rango / seme delle carte 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

Provalo online ungolfed

Notare come viene calcolato il valore SML (12-17):

Logicamente S, M, L (1,2,3) viene convertito in un valore numerico

la prima carta ha un valore di sequenza di 27 *

la seconda carta ha un valore di sequenza di 9 *

la terza carta ha un valore di sequenza 3 *

Moltiplicando per 3, la radice quadrata arrotondata per difetto diventa un bel numero sequenziale.

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 of @dylnan 's Jelly risponde , ma sfortunatamente 05AB1E non ha l'indice di permutazione incorporato ..

Provalo online o verifica tutti i casi di test .

Spiegazione:

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)

Vedi questo mio suggerimento 05AB1E (sezione Come comprimere le stringhe che non fanno parte del dizionario? ) Per capire perché .•3u§•è "jqka"ed .•ôì•è "cdhs".