Der 5-Karten-Zaubertrick beinhaltet einen Magier, dessen Assistent ihnen 4 gezeigte und eine versteckte Karte in dieser Reihenfolge gibt, und der Magier muss die versteckte Karte erraten.

WARNUNG: Lösung unten! Geh jetzt oder lass dich damit verwöhnen.

Die Lösung

Der Trick dabei ist, dass die fünf Karten in einer bestimmten Reihenfolge vergeben werden !

$c_1,...,c_5$ sind die 5 Karten in der angegebenen Reihenfolge.

$x_n$ ist die Kartennummer von$c_n$ in$NO=[\text{A,2,3,4,5,6,7,8,9,T,J,Q,K}]$ (Zahlenreihenfolge).

$a+b$ , wobei$a$ eine Kartennummer und$b$ eine ganze Zahl ist, ist gleich der Kartennummer$b$ , die rechts von$a$ in$NO$ , und wird bei Bedarf an den Anfang umgebrochen.

$s_n$ ist die Farbe von$c_n$ in$SO=[\clubsuit,\diamondsuit,\heartsuit,\spadesuit]$ (Farbenreihenfolge).

$a\circ b$ , wobei$a$ eine Kartennummer und$b$ eine Farbe ist, bezeichnet die Karte mit Kartennummer$a$ und Farbe$b$ .

$a<b$ , wo$a$ und$b$ - Karten sind, ist wahrwenn$a$ ‚s Anzug auf den von links ist$b$ s Anzug in‘$SO$ oder ihre Anzüge gleich sind und$a$ ‚s Kartennummer ist links von$b$ ‘ s Kartennummer in$NO$ .

$a>b$ , wobei$a$ und$b$ Karten sind, ist wahr, wenn$a<b$ falsch ist.

$PI(a,b,c)$ , wobei$a$ ,$b$ und$c$ Karten sind, ist der Permutationsindex dieser Reihenfolge von ihnen, spezifiziert durch die folgende Tabelle:
$\begin{array}{|c|c|}\hline\text{Comparison}&PI(a,b,c)\\\hline a<b<c&1\\\hline a<b>c>a&2\\\hline a>b<c>a&3\\\hline a<b>c<a&4\\\hline a>b<c<a&5\\\hline a>b>c&6\\\hline\end{array}$

Die Lösung für den 5-Karten-Zaubertrick lautet:

Die Herausforderung

So weit, ist es gut. Jedoch angegeben , die Berechnung zu tun oben bereits gefragt hier . Stattdessen besteht Ihre Herausforderung darin, die 5 Karten in keiner bestimmten Reihenfolge richtig zu bestellen. Dies bedeutet, dass die ersten vier Karten in der Ausgabe die fünfte darstellen. Mit anderen Worten, sei der Assistent. Bedarf:

• $s_5=s_1$ .
• $x_5=x_1+PI(c_2,c_3,c_4)$ (das muss also möglich sein).

Beispiel

Betrachten wir die Menge 7H,2D,6D,5C,6C. Zunächst nehmen wir die 25 Paare:

7H,7H 7H,2D 7H,6D 7H,5C 7H,6C
2D,7H 2D,2D 2D,6D 2D,5C 2D,6C
6D,7H 6D,2D 6D,6D 6D,5C 6D,6C
5C,7H 5C,2D 5C,6D 5C,5C 5C,6C
6C,7H 6C,2D 6C,6D 6C,5C 6C,6C

Dann entfernen wir offensichtlich die 5 Paare, die dieselbe Karte zweimal enthalten, sie existieren nicht in einem einzigen Deck:

      7H,2D 7H,6D 7H,5C 7H,6C
2D,7H       2D,6D 2D,5C 2D,6C
6D,7H 6D,2D       6D,5C 6D,6C
5C,7H 5C,2D 5C,6D       5C,6C
6C,7H 6C,2D 6C,6D 6C,5C      

Danach, da die Anzüge gleich sein müssen, sind verschiedene Anzüge in einem Paar ein Nein-Nein:

                             
            2D, 6D            
      6D, 2D                  
                        5C, 6C
                  6C, 5C      

Schließlich prüfen wir, ob es möglich ist, von der ersten zur zweiten Karte zu gelangen, indem wir höchstens 6 addieren und die Hälfte der verbleibenden Paare entfernen:

                             
            2D, 6D            

                        5C, 6C
                             

Jetzt haben wir die gültigen Paare: 2D,6Dund 5C,6C. Die erste Karte jedes Paares ist Karte 1, die letzte Karte ist Karte 5.

Wir werden 5C,6Chier der Einfachheit halber mitgehen . Der ganze Satz besteht 7H,2D,6D,5C,6Calso darin, die 2 Karten in dem von uns gewählten Paar zu entfernen 7H,2D,6D. Diese Karten stellen dar 6 - 5 = 1, also müssen wir sie wie "min, mid, max" bestellen. 7H > 2D < 6D < 7Hoder einfach 2D < 6D < 7H, so haben wir es jetzt 2D,6D,7H.

Der letzte Schritt ist, all dies zusammenzufügen, so dass unser Ergebnis sein wird 5C,2D,6D,7H,6C.

Klarstellungen

• Sie können 10anstelle von verwenden T.
• Sie können eine von verwenden ♠♥♦♣, ♤♡♢♧oder ♠♡♢♣statt CDHS, respectively.
• Dies ist Code-Golf , der kürzeste Code gewinnt.

Testfälle

Sie können für jeden Testfall eine oder mehrere der gültigen Lösungen ausgeben.

8S,TD,5C,QS,TS -> 8S,5C,QS,TD,TS
              ... 8S,TD,TS,5C,QS
              ... TS,5C,8S,TD,QS

JD,KH,4S,9D,8S -> 9D,KH,8S,4S,JD
              ... 4S,JD,KH,9D,8S

4H,4D,TH,KH,2C -> 4H,KH,4D,2C,TH
              ... TH,4D,2C,4H,KH
              ... KH,4D,TH,2C,4H

3S,KS,8S,KH,9H -> 9H,8S,KS,3S,KH
              ... 3S,KS,9H,KH,8S
              ... 8S,3S,9H,KH,KS
              ... KS,KH,9H,8S,3S

KH,TS,3C,7H,JD -> 7H,TS,JD,3C,KH

4C,KC,TD,JD,QS -> KC,JD,QS,TD,4C
              ... TD,4C,KC,QS,JD

AC,5H,8D,6D,8S -> 6D,AC,8S,5H,8D

AS,TC,3S,2H,9C -> 9C,2H,AS,3S,TC
              ... AS,9C,2H,TC,3S

4C,JS,AS,8H,JC -> JC,JS,AS,8H,4C
              ... JS,JC,4C,8H,AS

4H,QS,TH,QC,AC -> QC,4H,QS,TH,AC
              ... 4H,QS,QC,AC,TH

Node.js , 190 186 180 Bytes

f=(a,p,g=c=>"A23456789TJQK".search(c[0])+10,[A,B,C,D,E]=a.sort(_=>p>>i++&1,i=0))=>A[k=1]!=E[1]|[B,C,D].sort((a,b)=>k=k*2|a[1]+g(a)>b[1]+g(b))|(k^4)%6+1-(g(E)-g(A)+13)%13?f(a,-~p):a

Probieren Sie es online!

Wie?

Kartennummern identifizieren und vergleichen

Die Hilfsfunktion $g$ gibt einen Index zurück, der die Nummer einer gegebenen Karte darstellt.

g = c => "A23456789TJQK".search(c[0]) + 10

$10$$10$$22$

$a$$b$"NS"

a[1] + g(a) > b[1] + g(b)

Generieren der Permutationen der Eingabe

$120$$a$$p$$A$$B$$C$$D$$E$

[A, B, C, D, E] = a.sort(_ => p >> i++ & 1, i = 0)

$699$

Die Anzüge testen

Der erste offensichtliche Test besteht darin, sicherzustellen, dass die erste und die letzte Karte dieselbe Farbe haben. Wir lehnen die Permutation ab, wenn sie nicht gleich sind.

A[k = 1] != E[1] // we also initialize k, which is used right after that

Den Abstand prüfen

Wir berechnen den Abstand zwischen der ersten Kartennummer und der letzten Kartennummer mit:

(g(E) - g(A) + 13) % 13

$B$$C$$D$

Dieser Test basiert auf der Funktionsweise des sort()Algorithmus von Node.js.

sort()$[A,B,C]$

1. $A$$B$
2. $A$$C$
3. $B$$C$

Betrachten wir den folgenden Code:

[1, 2, 3].sort((a, b) => k = k * 2 | (a > b), k = 1)

$A<B$$1<2$$A<C$$1<3$$B<C$$2<3$$k$$2^3$$k=8$

Nun, wenn wir das tun:

[3, 2, 1].sort((a, b) => k = k * 2 | (a > b), k = 1)

$k=15$

Jede Permutation generiert eine eindeutige Bitmaske, die auf eine eindeutige Entfernung abgebildet wird:

 A, B, C | A>B | A>C | B>C | k  | distance
---------+-----+-----+-----+----+----------
 1, 2, 3 |  0  |  0  |  0  |  8 |    1
 1, 3, 2 |  0  |  0  |  1  |  9 |    2
 2, 1, 3 |  1  |  0  |  0  | 12 |    3
 2, 3, 1 |  0  |  1  |  1  | 11 |    4
 3, 1, 2 |  1  |  1  |  0  | 14 |    5
 3, 2, 1 |  1  |  1  |  1  | 15 |    6

Gegeben $k$können wir es in die Distanz umrechnen, indem wir tun:

  k | xor 4 | mod 6 | +1
----+-------+-------+----
  8 |   12  |   0   |  1
  9 |   13  |   1   |  2
 12 |    8  |   2   |  3
 11 |   15  |   3   |  4
 14 |   10  |   4   |  5
 15 |   11  |   5   |  6

Wenn wir alles zusammenfügen, haben wir folgenden Test:

[B, C, D]
.sort((a, b) =>
  k = k * 2 | a[1] + g(a) > b[1] + g(b)
)
| (k ^ 4) % 6 + 1
- (g(E) - g(A) + 13) % 13

Python 3 , 260 248 232 Bytes

N="A23456789TJQK".find
D=lambda x,y="KC":(N(y[0])+~N(x[0]))%13+15*abs(ord(x[1])-ord(y[1]))
def f(l):a,e,b,c,d=[[x,y]+sorted({*l}-{x,y},key=D)for x in l for y in l if D(x,y)<6][0];print(a,*map(eval,"bbccddcdbdbcdcdbcb"[D(a,e)::6]),e)

Probieren Sie es online!

-12 Bytes dank Eric the Outgolfer
-14 Bytes durch Entfernen eines Listenverständnisses

Sauber , 225 220 209 Bytes

import StdEnv,Data.List
n=['A23456789TJQK':n]

filter(\[[x,s],b,c,d,e]#[p,q,r:_]=map snd(sort(zip2[(elemIndices a n,b)\\[a,b]<-[b,c,d]][1..]))
=[snd(span((<>)x)n)!!(p+if(p>q)0if(q<r)(q+r)q),s]==e)o permutations

Probieren Sie es online!

Als komponierte Funktion :: [[Char]] -> [[Char]], mit einigen Helfern.

Erweitert:

n = ['A23456789TJQK': n] // infinitely repeating card number list

filter (...) o permutations // filter the permutations of the argument by ...
  \[[x, s], b, c, d, e] // deconstruct each permutation via pattern matching
    #[p, q, r: _] = ... // define p, q, r as ...
      map snd (...) // the second component of every element in ...
      sort (...) // the sorted list of ...
      zip2 ... [1..] // pairs of ... and the numbers 1, 2, 3, ..
      [... \\ [a, b] <- [b, c, d]] // ... for every pair of number a and house b in [b, c, d]
      (elemIndices a n, b) // pair of the value of that card number and the house
    = ... == e // check ... for equality against the last card
      [..., s] // ..., paired with house s
      snd (span ((<>) x) n) !! (...) // the card number ... places from x
      p + ... // this is kinda obvious
      if(p > q) 0 ... // if p is greater than q, zero, else ...
      if(q < r) (q + r) q // if q is less than r, q + r, else q

Ruby , 175 Bytes

->a{g=->j{j.tr('ATJQKCHS','1:;<=)_z').sum}
e=b=a.sort_by{|i|g[i]}
4.times{|i|(d=g[b[i+1]]-g[b[i]])<13&&(a=b[i,2];e=d)}
[a[e/7],*(b-a).permutation.to_a[e<7?e-1:12-e],a[e/7-1]]}

Probieren Sie es online!

Eine Lambda-Funktion, die eine Reihe von Karten als Zeichenfolgen verwendet

Kommentiert

->a{g=->j{j.tr('ATJQKCHS','1:;<=)_z').sum}
#helper function converts card to integer, ATJQK to 1:;<= and CHS to )_z then sum ascii values 

e=b=a.sort_by{|i|g[i]}  
#sort according to g. we declare 2 variables here in order to avoid undefined variable error at pre-interpretation check stage.

4.times{|i|(d=g[b[i+1]]-g[b[i]])<13&&(a=b[i,2];e=d)}
#compare each pair of values. if in same suit, store the pair of cards to a
#and the value difference to e. Loop exits with the last suitable pair stored

[a[e/7],*(b-a).permutation.to_a[e<7?e-1:12-e],a[e/7-1]]}
#return array containing the two cards of the same suit in the correct order
#with the correct permutation of the remaining cards (b-a) in the middle

Jelly , 41 Bytes

ØD;“TJQK”¤io2)1¦€µUḊỤ3R¤œ¿+""Om4%13E
Œ!ÇƇ

Ein monadischer Link, der eine Liste von Zeichenlisten akzeptiert und eine Liste aller gültigen Arrangements im selben Format zurückgibt.

Probieren Sie es online! (Die Fußzeile formatiert das Ergebnis als Raster, um das implizite Zertrümmern des Ausdrucks durch den Code des Links bei Ausführung als vollständiges Programm zu vermeiden.)

Oder sehen Sie sich eine Testsuite an .

Ich habe den Verdacht, dass ein anderer Ansatz viel knapper sein wird. Ich werde diese Herausforderung später noch einmal wiederholen müssen!

... hmm, ich hatte noch ein bisschen Geduld und bekam noch 41 Bytes ( Test ):

O¹*@<74$?€€29%⁽:0%⁴UµṪ_Ḣ%13Ḍ⁼Ụ3R¤œ¿Ɗ
Œ!ÇƇ