Le tour de magie de 5 cartes implique un magicien dont l'assistant leur donne 4 cartes montrées et une cachée, dans cet ordre, et le magicien doit deviner la cachée.

AVERTISSEMENT: Solution ci-dessous! Partez maintenant ou gâtez-vous avec.

La solution

L'astuce ici est que les cinq cartes sont données dans un ordre spécifique !

$c_1,...,c_5$ sont les 5 cartes dans l'ordre donné.

$x_n$ est le numéro de carte de$c_n$ dans$NO=[\text{A,2,3,4,5,6,7,8,9,T,J,Q,K}]$ (ordre des nombres).

$a+b$ , où$a$ est un numéro de carte et$b$ est un nombre entier, est égal au nombre de cartes$b$ étapes à droite de$a$ dans$NO$ , encapsulant au début si nécessaire.

$s_n$ est la combinaison de$c_n$ dans$SO=[\clubsuit,\diamondsuit,\heartsuit,\spadesuit]$ (ordre des combinaisons).

$a\circ b$ , où$a$ est un numéro de carte et$b$ est une couleur, désigne la carte avec le numéro de carte$a$ et la couleur$b$ .

$a<b$ , où$a$ et$b$ sontcartes, est vrai si$a$ «de costume est à la gauche de$b$ HABIT en$SO$ , ou leurs combinaisons sont égales et$a$ « numéro de carte de est à gauche de$b$ » s numéro de carte en$NO$ .

$a>b$ , où$a$ et $b$ sont des cartes, est vrai si $a<b$ est faux.

$PI(a,b,c)$ , où$a$ ,$b$ et$c$ sont des cartes, est l'indice de permutation de cet ordre d'entre elles, spécifié par le tableau ci-dessous:
$\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 solution à l'astuce magique à 5 cartes est le problème:

Le défi

Jusqu'ici tout va bien. Cependant, faire le calcul spécifié ci-dessus est déjà demandé ici . Au lieu de cela, votre défi est, étant donné les 5 cartes dans aucun ordre spécifique, de les commander correctement. Cela signifie que les quatre premières cartes de la sortie représenteront la cinquième. En d'autres termes, soyez l'assistant. Exigences:

• $s_5=s_1$ .
• $x_5=x_1+PI(c_2,c_3,c_4)$ (c'est-à-dire que cela doit être possible).

Exemple

Considérons l'ensemble 7H,2D,6D,5C,6C. Tout d'abord, nous prenons les 25 paires:

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

Ensuite, on retire évidemment les 5 paires qui contiennent la même carte deux fois, elles n'existent pas dans un seul 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      

Ensuite, puisque les costumes doivent être les mêmes, différents costumes dans une paire est un non-non:

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

Enfin, nous vérifions s'il est possible de passer de la première carte à la seconde en ajoutant au plus 6, en supprimant la moitié des paires restantes:

                             
            2D, 6D            

                        5C, 6C
                             

Nous avons maintenant les paires valides: 2D,6Det 5C,6C. La première carte de chaque paire est la carte 1, tandis que la dernière est la carte 5.

Nous allons aller 5C,6Cici pour plus de facilité. L'ensemble est 7H,2D,6D,5C,6C, donc, retirer les 2 cartes de la paire que nous avons choisie, nous l'avons 7H,2D,6D. Ces cartes représenteront 6 - 5 = 1, nous devons donc les commander comme "min, mid, max". 7H > 2D < 6D < 7H, ou tout simplement 2D < 6D < 7H, donc nous avons maintenant 2D,6D,7H.

La dernière étape consiste à mettre tout cela ensemble, donc notre résultat sera 5C,2D,6D,7H,6C.

Clarifications

• Vous pouvez utiliser à la 10place de T.
• Vous pouvez utiliser l' un ♠♥♦♣, ♤♡♢♧ou au ♠♡♢♣lieu de CDHS, respectivement.
• C'est le code-golf , le code le plus court l'emporte.

Cas de test

Vous pouvez générer une ou plusieurs des solutions valides incluses pour chaque scénario de 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 octets

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

Essayez-le en ligne!

Comment?

Identifier et comparer les numéros de carte

$g$

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

$10$$10$$22$ .

$a$$b$"NS"

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

Génération des permutations de l'entrée

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

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

$699$ itérations pour les essayer toutes.

Tester les combinaisons

Le premier test évident consiste à s'assurer que la première et la dernière carte sont de la même couleur. Nous rejetons la permutation si elles ne sont pas égales.

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

Tester la distance

Nous calculons la distance entre le premier numéro de carte et le dernier numéro de carte avec:

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

$B$$C$$D$

Ce test repose sur le fonctionnement de l' sort()algorithme de Node.js.

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

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

Prenons le code suivant:

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

Maintenant, si nous le faisons:

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

$k=15$

Chaque permutation génère un masque de bits unique, qui est mappé sur une distance unique:

 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

Pour tout mettre ensemble, nous avons le test suivant:

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

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)

Essayez-le en ligne!

-12 octets grâce à Eric l'Outgolfer
-14 octets en supprimant une liste de compréhension

Propre , 225 220 209 octets

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

Essayez-le en ligne!

En tant que fonction composée :: [[Char]] -> [[Char]], avec quelques assistants.

Étendu:

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

Rubis , 175 octets

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

Essayez-le en ligne!

Une fonction lambda prenant un tableau de cartes comme chaînes

Commenté

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

Gelée , 41 octets

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

Un lien monadique acceptant une liste de listes de caractères renvoyant une liste de tous les arrangements valides dans le même format.

Essayez-le en ligne! (le pied de page formate le résultat sous forme de grille pour éviter l'impression de cassage implicite effectuée par le code du lien lorsqu'il est exécuté en tant que programme complet)

Ou consultez une suite de tests .

Je soupçonne furtivement qu'une autre approche sera beaucoup plus concise. Je devrai revoir ce défi plus tard!

... hmm, j'ai eu un autre coup de fouet et j'ai obtenu un autre 41 octets ( test ):

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