Il trucco magico a 5 carte coinvolge un mago il cui assistente dà loro 4 carte mostrate e una nascosta, in questo ordine, e il mago deve indovinare quella nascosta.

ATTENZIONE: soluzione di seguito! Lascia ora o viziati con esso.

La soluzione

Il trucco qui è che le cinque carte sono date in un ordine specifico !

$c_1,...,c_5$ sono le 5 carte nell'ordine indicato.

$x_n$ è il numero della carta di$c_n$ in$NO=[\text{A,2,3,4,5,6,7,8,9,T,J,Q,K}]$ (ordine numerico).

$a+b$ , dove$a$ è un numero di carta$b$ è un numero intero, è uguale al numero di carta$b$ passi a destra di$a$ in$NO$ , se necessario all'inizio, avvolgendosi all'inizio.

$s_n$ è il seme di$c_n$ in$SO=[\clubsuit,\diamondsuit,\heartsuit,\spadesuit]$ (ordine del seme).

$a\circ b$ , dove$a$ è un numero di carta$b$ è un seme, indica la carta con il numero di carta$a$ e seme$b$ .

$a<b$ , dove$a$ e$b$ sono le carte, è vero se$a$ 's abito è a sinistra di$b$ ' s tuta in$SO$ , o le loro tute sono uguali e$a$ 's numero di carta è a sinistra di$b$ ' s numero di carta in$NO$ .

$a>b$ , dove$a$ e$b$ sono le carte, è vero se$a<b$ è falsa.

$PI(a,b,c)$ , dove$a$ ,$b$ e$c$ sono carte, è l'indice di permutazione di questo loro ordinamento, specificato dalla tabella seguente:
$\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}$

La soluzione al trucco di 5 carte è il problema:

La sfida

Fin qui tutto bene. Tuttavia, fare il calcolo sopra specificato è già richiesto qui . Invece, la tua sfida è, date le 5 carte in nessun ordine specifico, ordinarle correttamente. Ciò significa che le prime quattro carte nell'output rappresenteranno la quinta. In altre parole, sii l'assistente. Requisiti:

• $s_5=s_1$ .
• $x_5=x_1+PI(c_2,c_3,c_4)$ (cioè deve essere possibile).

Esempio

Consideriamo il set 7H,2D,6D,5C,6C . Innanzitutto prendiamo le 25 coppie:

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

Quindi, rimuoviamo ovviamente le 5 coppie che contengono la stessa carta due volte, non esistono in un singolo mazzo:

      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      

Successivamente, poiché i semi devono essere gli stessi, semi diversi in una coppia sono un no-no:

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

Infine, controlliamo se è possibile passare dalla prima carta alla seconda aggiungendo al massimo 6, rimuovendo la metà delle coppie rimanenti:

                             
            2D, 6D            

                        5C, 6C
                             

Ora abbiamo le coppie valide: 2D,6De 5C,6C. La prima carta di ogni coppia è la carta 1, mentre l'ultima è la carta 5.

Andremo con 5C,6Cqui per facilità. L'intero set è 7H,2D,6D,5C,6C, quindi, rimuovere le 2 carte nella coppia che abbiamo scelto, abbiamo 7H,2D,6D. Queste carte rappresenteranno 6 - 5 = 1, quindi dobbiamo ordinarle come "min, mid, max". 7H > 2D < 6D < 7Ho semplicemente 2D < 6D < 7H, quindi ora abbiamo 2D,6D,7H.

L'ultimo passo è mettere tutto insieme, quindi il nostro risultato sarà 5C,2D,6D,7H,6C.

chiarimenti

• È possibile utilizzare 10invece di T.
• È possibile utilizzare uno dei ♠♥♦♣, ♤♡♢♧o ♠♡♢♣al posto di CDHS, rispettivamente.
• Questo è code-golf , vince il codice più corto.

Casi test

È possibile produrre una o più delle soluzioni valide incluse per ciascun caso di test.

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 byte

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

Provalo online!

Come?

Individuare e confrontare i numeri delle carte

$g$

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

Aggiungiamo $10$ per forzare due cifre per tutte le voci, in modo che questi indici possano essere ordinati in modo sicuro in ordine lessicografico. Pertanto un asso è $10$$22$

Dato 2 carte $a$ e$b$"NS"

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

Generazione delle permutazioni dell'input

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

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

Questo codice$699$

Testare i semi

Il primo test ovvio è assicurarsi che la prima e l'ultima carta siano dello stesso seme. Rifiutiamo la permutazione se non sono uguali.

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

Testare la distanza

Calcoliamo la distanza tra il numero della prima carta e l'ultimo numero della carta con:

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

$B$$C$$D$ ) descrive correttamente questa distanza.

Questo test si basa sul funzionamento sort()dell'algoritmo di Node.js.

sort()$[A,B,C]$ applicando questi 3 passaggi:

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

Consideriamo il seguente codice:

[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$ .

Ora, se lo facciamo:

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

$k=15$ .

Ogni permutazione genera una maschera di bit unica, che è mappata a una distanza unica:

 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

$k$

  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

Mettendo tutto insieme, abbiamo il seguente 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 byte

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)

Provalo online!

-12 byte grazie a Eric the Outgolfer
-14 byte rimuovendo la comprensione di un elenco

Pulito , 225 220 209 byte

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

Provalo online!

Come funzione composta, :: [[Char]] -> [[Char]] , con alcuni aiutanti.

Allargato:

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

Rubino , 175 byte

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

Provalo online!

Una funzione lambda che prende una serie di carte come stringhe

Commentate

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

Gelatina , 41 byte

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

Un collegamento monadico che accetta un elenco di elenchi di caratteri che restituiscono un elenco di tutti gli arrangiamenti validi nello stesso formato.

Provalo online! (il piè di pagina formatta il risultato come una griglia per evitare la stampa di smash implicita come eseguita dal codice del collegamento quando eseguita come programma completo)

O vedi una suite di test .

Ho un sospetto furtivo un altro approccio sarà molto più conciso. Dovrò rivisitare questa sfida più tardi!

... hmm, ho fatto un altro giro e ho ottenuto un altro 41 byter ( test ):

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