Ejecute un Superb Shuffle ™

15

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!

AJFaraday
fuente
1
Algo relacionado
Shaggy
¿Podemos sustituir en Tlugar de 10?
Jo King
@JoKing No puedes. Al igual que la pregunta de generación de una baraja de cartas, las diferentes longitudes de cuerda son parte de la complejidad.
AJFaraday
¿Se nos permite imprimir cada tarjeta por separado como lo hace la respuesta de Carbón, o necesitamos devolver una matriz / lista?
Kevin Cruijssen
@KevinCruijssen Está bien, siempre y cuando sea notablemente devolver un mazo de cartas en ese formato (valor y palo).
AJFaraday

Respuestas:

5

Japt, 6 5 4 bytes

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

óG c

Intentalo

Lanudo
fuente
¿Necesitas aplanarlo?
Oliver
@ Oliver, espero que no; esperando que AJ confirme.
Shaggy
34

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 .

GB
fuente
66
Bien hecho para encontrar el proceso que utiliza cualquier otra respuesta;)
AJFaraday
3
¿Puedes explicar cómo encontraste el * 17% 54? ¿Solo prueba y error o hay algunas matemáticas obvias que me faltan?
Daniel
@Daniel 17 es la distancia mínima requerida entre dos cartas del mismo palo que no son adyacentes numéricamente (teniendo en cuenta los dos comodines; por ejemplo, 17 pasos te llevan del As de Clubes al 3 de Picas); 54 es el número de cartas en el mazo.
Hellion
11

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.

GB
fuente
5

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.

El chico al azar
fuente
1
Ajá, cuando dije que "todos" en mi publicación eran incorrectos; así es como fui yo también!
Jonathan Allan
4

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
Kevin Cruijssen
fuente
Desafortunadamente, el resultado contiene numerosas cartas adyacentes a cartas del mismo palo. Se inicia con AS, 6S, JS, 3D, 8D, KD,.
AJFaraday
@AJFaraday TIO todavía tenía 11 en lugar de 7. ¿Podría verificarlo nuevamente? Tal vez me perdí algo más, pero creo que debería ser correcto ahora (espero).
Kevin Cruijssen
Eso lo tiene ahora. ¡Buen trabajo!
AJFaraday
3

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
Jo King
fuente
1
Esto funciona igual de bien con una var de estado sin nombre $que con $!o $/. Además, si usó en $_lugar de @_podría comenzarlo en .[…]lugar de @_[…]guardar otro byte.
Brad Gilbert b2gills
2

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)
Kevin Cruijssen
fuente
1
ā17*èdebería ahorrar 2 bytes más
Sr. Xcoder
2

JavaScript, 27

Otro basado en la respuesta rubí

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

Editado en un obvio acortamiento

vityavv
fuente
2

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'
BradC
fuente
¿ iNo se consideraría la entrada adicional aquí?
Shaggy
@Shaggy La pregunta dice que puedo obtener la plataforma de entrada en el orden original (listado). La única forma de garantizar esto en SQL es hacer que el orden sea una parte explícita de la entrada, porque las tablas SQL no tienen un "orden predeterminado" . Entonces, lo veo como un componente necesario de la entrada. Pero no se preocupe, SQL rara vez es competitivo de todos modos :)
BradC
2

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
Jonathan Allan
fuente
2

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.

Veskah
fuente
26 bytes $args[(0..53|%{$_*17%54})].
mazzy
@Mazzy Siento que eso rompe las especificaciones de entrada. Seguro que están reunidos en $ args, pero en realidad no estás pasando uno.
Veskah
citar: The input can be either:... in the same order, as *an array*. $argses una matriz y puedes usar un splatting . por ejemplo $a=@("AS", ..., "J"); &{} @a. Intentalo. :)
mazzy
Además, me parece que no hay necesidad de contar los caracteres &{y }. Puede guardar param($d)0..53|%{$d[$_*17%54]}en un archivo. y llame a este archivo sin&{...}
mazzy
1
@mazzy Sí, siempre he estado un poco inseguro sobre qué partes de control mantener, por lo que generalmente no se ha configurado como un bloque de script. Sin embargo, lo quitaré en el futuro.
Veskah
1

Carbón de leña , 8 bytes

Eθ§θ×¹⁷κ

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
E           Map over elements
       κ    Current index
     ¹⁷     Literal 17
    ×       Multiply
   θ        Input array
  §         Cyclically index
            Implicitly print each result on its own line
Neil
fuente
1

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.

Galen Ivanov
fuente