El truco de magia de 5 cartas involucra a un mago cuyo asistente les da 4 cartas mostradas y una oculta, en este orden, y el mago debe adivinar la oculta.

ADVERTENCIA: ¡Solución a continuación! Vete ahora o déjate mimar con él.

La solución

¡El truco aquí es que las cinco cartas se dan en un orden específico !

$c_1,...,c_5$ son las 5 cartas en el orden dado.

$x_n$ es el número de tarjeta de$c_n$ en(orden de números).$NO=[\text{A,2,3,4,5,6,7,8,9,T,J,Q,K}]$

$a+b$ , donde es un número de tarjeta es un número entero, es igual al número de tarjeta pasos a la derecha de en , ajustando al principio si es necesario.$a$$b$$b$$a$$NO$

$s_n$ es el traje de en (orden del traje).$c_n$$SO=[\clubsuit,\diamondsuit,\heartsuit,\spadesuit]$

$a\circ b$ , donde es un número de tarjeta es un palo, denota la tarjeta con el número de tarjeta y el palo$a$$b$$a$$b$ .

$a<b$ , donde$a$ y$b$ son las tarjetas, es cierto si$a$ 's traje es a la izquierda de$b$ ' s traje en$SO$ , o sus trajes son iguales y$a$ 's número de tarjeta es a la izquierda de$b$ ' s número de tarjeta en$NO$ .

$a>b$ , donde$a$ y$b$ son cartas, es verdadero si$a<b$ es falso.

$PI(a,b,c)$ , donde$a$ ,$b$ y$c$ son las tarjetas, es el índice de permutación de este orden de ellos, especificado por la tabla siguiente:
$\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 solución al truco de magia de 5 cartas es el problema:

El reto

Hasta aquí todo bien. Sin embargo, hacer el cálculo especificado anteriormente ya se solicita aquí . En cambio, su desafío es, dadas las 5 cartas sin un orden específico, ordenarlas correctamente. Esto significa que las primeras cuatro cartas en la salida representarán la quinta. En otras palabras, ser el asistente. Requisitos:

• $s_5=s_1$ .
• $x_5=x_1+PI(c_2,c_3,c_4)$ (es decir, esto debe ser posible).

Ejemplo

Consideremos el conjunto 7H,2D,6D,5C,6C. En primer lugar, tomamos los 25 pares:

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

Luego, obviamente eliminamos los 5 pares que contienen la misma carta dos veces, no existen en un solo mazo:

      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      

Luego, dado que los trajes deben ser iguales, diferentes trajes en un par es un no-no:

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

Finalmente, verificamos si es posible pasar de la primera carta a la segunda agregando como máximo 6, eliminando la mitad de los pares restantes:

                             
            2D, 6D            

                        5C, 6C
                             

Ahora tenemos los pares válidos: 2D,6Dy 5C,6C. La primera carta de cada par es la carta 1, mientras que la última es la carta 5.

Vamos a ir 5C,6Caquí por facilidad. Todo el conjunto es 7H,2D,6D,5C,6C, por lo tanto, eliminar las 2 cartas del par que hemos elegido, tenemos 7H,2D,6D. Estas cartas representarán 6 - 5 = 1, así que tenemos que ordenarlas como "min, mid, max". 7H > 2D < 6D < 7H, o simplemente 2D < 6D < 7H, así que ahora tenemos 2D,6D,7H.

El último paso es poner todo esto junto, para que nuestro resultado sea 5C,2D,6D,7H,6C.

Aclaraciones

• Puede usar en 10lugar de T.
• Puede usar uno de ♠♥♦♣, ♤♡♢♧o en ♠♡♢♣lugar de CDHS, respectivamente.
• Este es el código de golf , el código más corto gana.

Casos de prueba

Puede generar una o más de las soluciones válidas incluidas para cada caso de prueba.

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

Pruébalo en línea!

¿Cómo?

Identificar y comparar los números de tarjeta.

La función auxiliar $g$ devuelve un índice que representa el número de una tarjeta dada.

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

$10$$10$$22$

$a$$b$"NS"

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

Generando las permutaciones de la entrada

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

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

$699$

Probar los trajes

La primera prueba obvia es asegurarse de que la primera y la última carta sean del mismo palo. Rechazamos la permutación si no son iguales.

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

Probar la distancia

Calculamos la distancia entre el primer número de tarjeta y el último número de tarjeta con:

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

$B$$C$$D$

Esta prueba se basa en la forma en que funciona el sort()algoritmo de Node.js.

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

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

Consideremos el siguiente código:

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

Ahora, si lo hacemos:

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

$k=15$

Cada permutación genera una máscara de bits única, que se asigna a una distancia única:

 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

Poniendo todo junto, tenemos la siguiente prueba:

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

Pruébalo en línea!

-12 bytes gracias a Eric the Outgolfer
-14 bytes al eliminar una lista de comprensión

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

Pruébalo en línea!

Como una función compuesta :: [[Char]] -> [[Char]], con algunos ayudantes.

Expandido:

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

Pruébalo en línea!

Una función lambda que toma una serie de tarjetas como cadenas

Comentado

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

Jalea , 41 bytes

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

Un enlace monádico que acepta una lista de listas de caracteres que devuelve una lista de todos los arreglos válidos en el mismo formato.

Pruébalo en línea! (el pie de página formatea el resultado como una cuadrícula para evitar la impresión aplastante implícita que realiza el código del enlace cuando se ejecuta como un programa completo)

O ver un conjunto de pruebas .

Tengo la sospecha de que otro enfoque será mucho más conciso. ¡Tendré que volver a visitar este desafío más tarde!

... hmm, tuve otro golpe y obtuve otro 41 byter ( prueba ):

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