Para los propósitos de esta pregunta, una baraja de cartas se formatea de esta manera:

[
  "AS", "2S", "3S", "4S", "5S", "6S", "7S", "8S", "9S", "10S", "JS", "QS", "KS", 
  "AD", "2D", "3D", "4D", "5D", "6D", "7D", "8D", "9D", "10D", "JD", "QD", "KD", 
  "AH", "2H", "3H", "4H", "5H", "6H", "7H", "8H", "9H", "10H", "JH", "QH", "KH", 
  "AC", "2C", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "10C", "JC", "QC", "KC", 
  "J", "J"
]

Las tarjetas siempre se formatean como valor, seguidas de palos. Por ejemplo, ASes el as de espadas. Las dos J's son Jokers. Queremos barajar esta baraja de cartas, pero la baraja debe ser Superb ™.

Un Superb Shuffle ™ es uno en el que:

• No hay dos cartas (excepto Jokers) del mismo palo adyacentes.
• Ninguna carta (excepto Jokers) es adyacente a uno del mismo valor.
• Ninguna carta (excepto Jokers) es adyacente a uno de un valor adyacente (uno más alto o uno más bajo en este orden, A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Observe que Ace no puede ser adyacente a un 2 o un Rey).
• Los comodines pueden estar en cualquier posición.
• La definición de un Superb Shuffle ™ no requiere que las cartas estén en un orden diferente cada vez que se barajan. Lo cual no es muy excelente, pero es Superb ™.

Porque eso es Superb ™.

Un ejemplo podría ser:

[
  "AS", "5D", "9H", "KC", "2D", "6H", "10C", "QS", "3H", "7C", "9S", 
  "KD", "4C", "6S", "10D", "AC", "3S", "7D", "JH", "J", "4D", "8H", 
  "QC", "AD", "5H", "9C", "JS", "2H", "6C", "8S", "QD", "3C", "5S", 
  "9D", "KH", "2S", "6D", "10H", "J", "3D", "7H", "JC", "KS", "4H", 
  "8C", "10S", "AH", "5C", "7S", "JD", "2C", "4S", "8D", "QH"
]

El reto:

• Escribe un código para ejecutar un sorteo excelente
• Usa cualquier idioma.
• La entrada puede ser cualquiera de :
  • una baraja de cartas como se describió anteriormente en el mismo orden , como una matriz u otra estructura de lista.
  • Sin entrada (el código genera una baraja de cartas en ese orden)
• La salida debe ser una baraja completa de cartas en un Superb Shuffle ™ como se describió anteriormente.
• Intente realizar su Superb Shuffle ™ en el menor número de bytes.
• Se prefiere un enlace a un intérprete en línea, como Try It Online , pero opcional.

Feliz barajando!

Japt, 6 5 4 bytes

Divide el conjunto de entrada en subconjuntos de cada elemento 16 y se aplana.

óG c

Intentalo

Ruby , 31 bytes

->x{(0..53).map{|r|x[r*17%54]}}

Pruébalo en línea!

Explicación:

Estoy eligiendo una carta, luego me salto las siguientes 16 y comienzo desde la primera carta cuando llegue a la última carta del mazo. 17 y 54 son primos mutuos, así que estoy seguro de elegir todas las cartas.

Se garantiza que la posición 17 es un palo diferente y la diferencia de valor es al menos 2: la carta 13 (o 15) tiene el mismo valor y un palo diferente, por lo que al saltarse otros 4 (o 2), el valor es correcto .

Python 3 , 21 bytes

lambda x:(x*17)[::17]

Pruébalo en línea!

Explicación:

La misma idea que mi respuesta de Ruby, pero aún más corta en Python: uso 17 mazos y elijo cada 17 carta.

JavaScript, 35 bytes

x=>x.map((a,i)=>i%2?a:x[(i+20)%54])

Pruébalo en línea!

Tomar una matriz de mazo como entrada y reemplazar cada valor impar con otra carta que esté a "20 cartas" de distancia en el mazo.

Java 10, 72 65 bytes

d->{var r=d.clone();for(int i=54;i-->0;r[i*7%54]=d[i]);return r;}

Similar a la respuesta Ruby de @GB , pero al usar i*7%54en la matriz de resultados, en lugar de i*17%54en la matriz de entrada para guardar un byte.

Pruébalo en línea.

Explicación:

d->{              // Method with String-array as both parameter and return-type
  var r=d.clone();//  Result-String, starting as a copy of the input
  for(int i=54;i-->0;
                  //   Loop `i` in the range (54, 0]
    r[            //    Set an item in the result-array at index:
      i*7%54      //     Index `i` multiplied by 7, and then take modulo-54
     ]=d[i]);     //    To the `i`'th item in the input-Deck
  return r;}      //  Return the result-Array

Perl 6 , 21 20 18 bytes

Gracias a Brad Gilbert b2gills por -2 bytes

{.[$++*17%$_]xx$_}

Pruébalo en línea!

Otro puerto de la respuesta de GB . Tenga en cuenta que, si bien la variable global $!no se restablece entre funciones, el valor no importa, ya que cualquier orden de salida es válido. Sin embargo, $ se restablece.

Explicación:

{                } #Anonymous code block
             xx$_  #Repeat size of inputted array (54) times
 .[         ]      #Get from the inputted array, the value at index
    $++*17%$_         #The incremented variable, multiplied by 17, modded by size of the array

05AB1E , 9 7 5 bytes

ā17*è

El puerto de la respuesta de Ruby de @GB , ¡así que asegúrate de votarlo!

-2 bytes imprimiendo cada tarjeta con un delimitador de nueva línea en lugar de envolverla en una lista de resultados
-2 bytes gracias a @ Mr.Xcoder

Pruébalo en línea.

Explicación:

ā        # 1-indexed length range [1 ... length_of_input_list (54)]
 17*     #  `k`: Multiply each index by 17
    è    #  And then replace each item with the 0-indexed `k`'th card of the input-list
         #  (with automatic wrap-around)

JavaScript, 27

Otro basado en la respuesta rubí

d=>d.map((_,i)=>d[i*17%54])

Editado en un obvio acortamiento

T-SQL, 31 bytes

SELECT c FROM t ORDER BY i*7%54

Si no le importa una columna adicional en la salida, puedo reducirla a 29 bytes :

SELECT*FROM t ORDER BY i*7%54

Para que pueda verificar que mi salida es "Excelente", aquí está el mazo que produce:

 J, 5H,  8S, KH, 3D,  8C, JD, AS, 6H,  9S, AC, 4D, 9C, QD, 
2S, 7H, 10S, 2C, 5D, 10C, KD, 3S, 8H,  JS, 3C, 6D, JC, 
AH, 4S,  9H, QS, 4C,  7D, QC, 2H, 5S, 10H, KS, 5C, 8D, 
KC, 3H,  6S, JH, AD,  6C, 9D,  J, 4H,  7S, QH, 2D, 7C, 10D

(Generado usando la nueva adición de SQL 2017 STRING_AGG):

SELECT STRING_AGG(c,', ')WITHIN GROUP(ORDER BY i*7%54)FROM t 

La parte difícil para mí no fue el código de selección, estaba poblando la tabla de entrada (que está permitida para SQL según nuestras reglas de E / S ).

Debido a que SQL está inherentemente desordenado (solo garantiza un cierto orden si incluye una ORDER BYcláusula explícita ), tuve que incluir ese orden original como un campo i en la tabla de entrada t . Esto también significa que puedo usarlo para ordenar, usando el mismo proceso de factor / mod "relativamente primo" que todos los demás están usando. Descubrí que i*7%54funcionaba tan bien como i*17%54.

Estos son los comandos para configurar y completar la tabla de entrada t , según mi solución a esta pregunta relacionada :

CREATE TABLE t (i INT IDENTITY(1,1), c VARCHAR(5))

--Insert 52 suited cards
INSERT t(c)
SELECT v.value+s.a as c
FROM STRING_SPLIT('A-2-3-4-5-6-7-8-9-10-J-Q-K','-')v,
     (VALUES('S',1),('D',2),('H',3),('C',4))s(a,b)
ORDER BY s.b

--Insert Jokers
INSERT t(c) SELECT 'J'
INSERT t(c) SELECT 'J'

Jalea ,  5  4 bytes

s⁴ZẎ

Pruébalo en línea!

Resulta la forma en que todos los demás, excepto el tipo aleatorio lo está haciendo, guarda un byte :(
Crédito a GB por su método .

La forma en que fui ...

ṙÐe20

Pruébalo en línea!

¿Cómo?

Arregle cualquier otra carta e intercale con una rotación de la baraja dejada por 20 lugares (18 y 22 lugares también funcionan; además, lo hace cualquier dirección de rotación, así como la fijación de cartas impares o pares)

ṙÐe20 - Link: list of the card strings (lists of characters)
   20 - place a literal twenty on the right
 Ðe   - apply to even indices:
ṙ     -   rotate left (by 20)

Es decir (usando Tpara 10y rj& bjpara los Js):

input: AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC rj bj
  ṙ20: 8D 9D TD JD QD KD AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC rj bj AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AD 2D 3D 4D 5D 6D 7D
ṙÐe20: AS 9D 3S JD 5S KD 7S 2H 9S 4H JS 6H KS 8H 2D TH 4D QH 6D AC 8D 3C TD 5C QD 7C AH 9C 3H JC 5H KC 7H bj 9H 2S JH 4S KH 6S 2C 8S 4C TS 6C QS 8C AD TC 3D QC 5D rj 7D

PowerShell 3.0, 30 26 bytes

$args[(0..53|%{$_*17%54})]

^{-4 gracias al}
código ^Mazzy Old a 30 bytes

param($d)0..53|%{$d[$_*17%54]}

Otro puerto del método de GB.

Carbón de leña , 8 bytes

Ｅθ§θ×¹⁷κ

Pruébalo en línea! El enlace es a la versión detallada del código. Otro puerto de la respuesta de Ruby de @ GB. Explicación:

 θ          Input array
Ｅ           Map over elements
       κ    Current index
     ¹⁷     Literal 17
    ×       Multiply
   θ        Input array
  §         Cyclically index
            Implicitly print each result on its own line

Rojo , 44 bytes

func[a][append/dup a a 16 prin extract a 17]

Pruébalo en línea!

Otra interpretación del código de GB. Añado 16 copias de la baraja a sí mismo y luego extraigo cada 17 carta.