Die Aufgabe stammt aus einer MIT-Vorlesung von Prof. Devadas mit dem Titel You can read minds . Eine ausführliche Erklärung des Tricks finden Sie im verlinkten Video oder in diesem Dokument . Ich werde versuchen, es in einfacheren Begriffen zu erklären.

Es stellt sich heraus, dass dies in den 1930er Jahren erfunden wurde und als "Fünf-Karten-Trick von Fitch Cheney" bekannt ist .

Der Trick geht so:

• Aus einem Kartenspiel werden fünf zufällige Karten ausgewählt. Das Publikum und Ihr Assistent können sie sehen, aber Sie tun es nicht.
• Ihr Assistent (mit dem Sie geübt haben) wählt vier dieser Karten aus und zeigt sie Ihnen in einer bestimmten Reihenfolge. Beachten Sie, dass die versteckte Karte nicht zufällig aus den 5 Karten ausgewählt wird. Der Assistent wählt eine / die Karte, mit der der Trick funktioniert.
• Sie werden auf der Grundlage der Informationen, die Sie aus den vier Karten entnehmen können, ableiten, was die fünfte Karte ist.

Wie?

Beachten Sie die folgenden zwei Punkte:

1. Bei der Auswahl von 5 zufälligen Karten wird garantiert, dass mindestens zwei Karten dieselbe Farbe ^{1 haben} .

2. Das Bild unten zeigt einen Kreis mit allen Rängen ² . Da es sich um einen Kreis handelt, kann gezählt werden: J, Q, K, A, 2, 3 (dh modulares Zählen). Es wird garantiert, dass die versteckte Karte nicht den gleichen Rang wie die erste hat, da sie dieselbe Farbe hat (siehe unten). Es ist immer möglich, die erste Karte und die versteckten Karten so zu wählen, dass die versteckte Karte zwischen 1 und 6 Rängen höher ist als die erste (beim Zählen in Kreisen). Wenn die erste Karte 1 ist , ist die versteckte Karte 2,3,4,5,6 oder 7 . Wenn die erste Karte J ist , ist die versteckte Karte Q, K, A, 2,3 oder 4 und so weiter.

Der Algorithmus:

Die erste Karte: Diese Karte hat die gleiche Farbe wie die versteckte Karte. Die Karte ist auch der Bezugspunkt, an dem Sie den Rang der versteckten Karte ermitteln.

Die 2., 3. und 4. Karte dekodiert einen Wert im Inklusivbereich 1 ... 6 . Wir nennen die drei Karten S, M, L (kleinste Karte, mittlere Karte, größte Karte). Die Werte werden wie folgt codiert (lexikografische Reihenfolge):

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

Wenn also der Rang der ersten Karte 5 ist und die verbleibenden drei Karten den Rang 4 Q 7 haben (sie sind SLM- geordnet ), hat die letzte Karte den Rang 5 + 2 = 7 . Sie können wählen, ob das Ass die höchste oder die niedrigste Karte sein soll, solange es konsistent ist.

Wenn mehrere Karten den gleichen Rang haben, bestimmt die Farbe die Reihenfolge, in der C <D <H <S ist .

Eingabeformat:

Die vier Karten werden als H3 (drei Herzen), DK (König der Diamanten) usw. ausgegeben . Sie können die Eingabe auch umgekehrt als 3H und KD verwenden.

Die Eingabe kann in einem beliebigen Format erfolgen, aber Sie können die Liste der Farben in einer Variablen und die Liste der Ränge in einer anderen nicht kombinieren. 'D5', 'H3' ..und [['D',5],['H',3] ...sind beide OK, ist es aber 'DHCH',[5,3,1,5]nicht. Sie können Zahlen nicht anstelle von Buchstaben verwenden, mit Ausnahme von T .

Ausgabe

Die versteckte Karte im selben Format wie die Eingabe.

Beispiel

Machen wir eine Komplettlösung:

Input:
D3 S6 H3 H9

Wir wissen, dass die versteckte Karte ein Diamant ist, da die erste Karte ein Diamant ist. Wir wissen auch, dass der Rang 4,5,6,7,8 oder 9 ist, da der Rang der ersten Karte 3 ist .

Die restlichen Karten sind nach 6,3,9 geordnet ==> M, S, L , was den Wert 3 codiert . Die verborgene Karte ist also 3 + 3 = 6 Diamanten, daher sollte die Ausgabe D6 sein .

Testfälle:

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

Das ist Code-Golf , also gewinnt die kürzeste Lösung in jeder Sprache. Erklärungen sind erwünscht!

¹ Es gibt vier Farben ( C Lubs, D iamonds, H eARTS und S PAdES).

² Es gibt 13 Reihen, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Sie können T anstelle von 10 verwenden .

JavaScript (ES6), 130 102 Byte

Nimmt Eingaben als ein Array von Zeichenfolgen im "Rs"Format, wobei R der Rang und s die Farbe ist. Erwartet "T" für 10er. Asse sind niedrig.

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

Probieren Sie es online!

Wie?

Wir konvertieren zuerst jede Karte in ein Array [Rang, Karte], wobei Rang ein numerischer Wert in [14 ... 26] ist und Karte die ursprüngliche Zeichenfolge ist.

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

Der Rang und die Farbe der ersten Karte werden in R bzw. S gespeichert . Die drei anderen Karten sind in B , C und D gespeichert .

Zum Beispiel ['3c','6h','6c','2s']wird:

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

Wir vergleichen dann jedes Paar in [B, C, D] . Diese Elemente werden implizit zu Zeichenfolgen gezwungen, wenn sie miteinander verglichen werden:

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

Da sowohl Rang als auch Karte garantiert aus genau zwei Zeichen bestehen, ist ein Vergleich in lexikografischer Reihenfolge sicher.

Wir berechnen:

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

Nachfolgend sind alle möglichen Kombinationen aufgeführt:

 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

Schließlich erstellen wir die Ausgabekarte mit R , S und dem obigen Ergebnis:

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

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

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

Probieren Sie es online!

Asse sind hoch

Kodiert die drei Karten, indem sie ihre Position in einer sortierten Liste der Karten finden ( 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

Dies wird in der Basis 3 in eine Ganzzahl umgewandelt und mit 3 multipliziert und durch 10 dividiert:

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

Die verschiedenen Kodierungen sind:

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

Gerettet:

• -2 Bytes dank ovs

Gelee , 33 Bytes

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

Probieren Sie es online!

Erläuterung

Die erste Zeile ist Niladisch. Es ergibt sich eine Liste der 52 Karten

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

Ruft im Hauptlink ¢das Ergebnis des ersten Links auf, bei dem es sich um die Liste der Karten handelt.

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

Probieren Sie es online!

Übersicht: 'CDHS'∘.,2↓⎕D,'TJQKA'Erzeugt das äußere Produkt, also eine 2D-Matrix mit (C2 C3 C4 ...), (D2 D3 D4 ...), .... Wir transponieren dann diese Matrix, um sie zu erhalten (C2 D2 H2 ...), ...und dann zu verflachen.

Vielen Dank an @ngn für das 2-⌊1.8⊥, das die Reihenfolge der Karten (SML = 1 2 3) annimmt und bewertet (wie die 1 bis 6 im OP).

Code Erklärung:

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

[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

Probieren Sie es online!

Erläuterung:

[JQK]
1$&
T`AJQK`1123

Ersetzt Asse, Buben, Damen und Könige durch 1, 11, 12 und 13. Die ersten beiden Zeilen stehen 1vor dem Buchstaben, und die letzte Zeile setzt die zweite Ziffer um.

*' G0`

Das *bedeutet, dass in dieser Phase die Arbeitszeichenfolge nicht geändert werden darf. Dies mag die Bühne sinnlos erscheinen lassen, wird aber später nützlich sein. Der 'teilt die Arbeitszeichenfolge an jeder Stelle auf und G0nimmt die erste (so findet er die erste Karte).

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

Die ersten beiden Zeilen multiplizieren die Zahlen auf den Karten mit 5 und verwandeln sie dann in Unary (Beispiel: 5 wird als _____ dargestellt), sodass wir später kleinere Beträge für Farben hinzufügen können. Die letzte Zeile teilt sich in Felder auf und behält die letzten drei Karten.

T`CD\HS`d
\d
*

Dies wandelt Clubs, Diamonds, Hearts und Spades in 0, 1, 2 und 3 um und verwandelt die Zahl in Unary. Da es sich nun auf dem an der Nummer angehängten Teil der Karte befindet, gibt es einen eindeutigen Wert für die Karte an, der bestimmt, wie hoch sie ist.

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

Dadurch werden die Reihenfolge der Karten und der Wert ermittelt, der der ersten Karte hinzugefügt werden soll. In der ersten Zeile werden beispielsweise /^(_+)¶\1_+/(Aufträge abgeglichen, deren mittlerer Wert größer als der erste Wert ist. Es wird eine if-else-Schleife erstellt, die angibt, was zu tun ist (da diese Reihenfolge den Permutationen 1, 2 und 4 entspricht). Kmarkiert eine Konstante.

\d
$+3-$&

Erinnern Sie sich an früher, als wir *anzeigten, dass eine Bühne die Arbeitssaite nicht beeinträchtigen würde? Hier setzen wir es ein. Diese Stufe ist eine Ersetzungsstufe; Es ersetzt die Zahl, die hinzugefügt werden soll $+3-$&. $+3Er betritt die *Bühne und erhält die -Farbe und die Nummer der ersten Karte, fungiert als Trenner und $&ist das Match. So ist der Arbeitsstring jetzt{suit}{original number}-{number to add}

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

Dies macht die beiden Zahlen unär und addiert sie.

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

Die oberste Zeile fängt entweder die Zahl oder die Zahl - 13 ein (damit wir keine Ausgaben von zB S16 bekommen). In der untersten Zeile wird die erfasste Zahl wieder zur Basis 10, und das Ergebnis wird implizit gedruckt.

Kohle , 64 62 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Verwendet Tfür 10 und sortiert Ahoch. Der Permutationsindex war nicht sehr einfach zu dekodieren. Eine andere Permutationsreihenfolge hätte mir mindestens drei Bytes erspart. Erläuterung:

⁺⭆⁸⁺²ιTJQKA

Addiere 2 zu allen ganzen Zahlen von 0 bis 7, verbinde sie dann und setze TJQKAdas Suffix für die Bildkarten und das Ass. Dies spart 2 Bytes über ein String-Literal, obwohl sich herausstellt, dass Aein Byte durch String-Komprimierung sowieso gespart worden wäre , wenn ein High-Wert vorliegt.

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

Karte über die Karten und die Farben, die die beiden zusammenfassen. Da dies normalerweise ein verschachteltes Array ergeben würde, werden die Ergebnisse stattdessen zu einer einzelnen Zeichenfolge verkettet, die dann wieder in Zeichenpaare aufgeteilt wird.

≔Ｅ⟦ηζε⟧⌕διυ

Finde die Positionen der zweiten, dritten und vierten Karte.

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

Berechnen Sie den 1-indizierten Permutationsindex. Die ersten beiden Permutationen haben die kleinste Karte zuerst; Dies wird über getestet ⌕υ⌊υ. Die beiden anderen Permutationspaare unterscheiden sich darin, ob die größte Karte die erste ist. Dies wird über getestet ⌕υ⌈υ. Logische und arithmetische Operationen ordnen diese Tests dann den Werten zu 0, 2und 4; Dies erhöht sich dann 1abhängig vom Vergleich zwischen der dritten und der vierten Karte, die über getestet wurden ‹⊟υ⊟υ. Schließlich wird der Index erhöht, um die gewünschte Codierung zu erhalten.

§δ⁺⌕δθ×⁴...

Multiplizieren Sie dies mit 4, indem Sie den Abstand zwischen Karten der gleichen Farbe wiedergeben, die Position der ersten Karte addieren und das Ergebnis zyklisch indexieren und drucken.

Python 2 , 147 Bytes

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

Probieren Sie es online!

Pyth, 42 Bytes

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

Echt hässlich...

Probieren Sie es online aus: Demo oder Test Suite

J , 68 Bytes

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

Probieren Sie es online!

Hinweis: -3 aus TIO-Bytes, weil das f=.nicht zählt. Werde versuchen weiter zu golfen und morgen eine Erklärung hinzufügen.

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]

Probieren Sie es 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]

Probieren Sie es online!

T-SQL, 211 Bytes

Die Eingabe ist eine Tabellenvariable. Mit T für 10 sind die Asse niedrig

Format für Kartenrang / Farbe 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

Probieren Sie es online ungolfed

Beachten Sie, wie der SML-Wert (12-17) berechnet wird:

Logischerweise wird S, M, L (1,2,3) in einen numerischen Wert umgewandelt

Die erste Karte hat den Wert 27 * Sequenzwert

Die zweite Karte hat den Wert 9 * Sequenzwert

Die dritte Karte hat den Wert 3 * Sequenzwert

Durch Multiplizieren mit 3 wird die abgerundete Quadratwurzel zu einer schönen fortlaufenden Zahl.

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 Bytes

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

Port von @dylnans Gelee Antwort , aber leider hat 05AB1E nicht den eingebauten Permutationsindex.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Sehen Sie sich meinen Tipp 05AB1E an (Abschnitt So komprimieren Sie Zeichenfolgen, die nicht Teil des Wörterbuchs sind ), um zu verstehen, warum dies so .•3u§•ist "jqka"und .•ôì•ist "cdhs".