Aux fins de cette question, un jeu de cartes est formaté de la manière suivante:

[
  "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"
]

Les cartes sont toujours formatées en valeur, suivies de combinaisons. Par exemple, ASc'est l'as de pique. Les deux simples J sont des Jokers. Nous voulons mélanger ce jeu de cartes, mais le mélange doit être Superb ™.

Un Superb Shuffle ™ est celui dans lequel:

• Il n'y a pas deux cartes (sauf Jokers) de la même couleur adjacentes.
• Aucune carte (sauf Jokers) n'est adjacente à une de la même valeur.
• Aucune carte (sauf Jokers) n'est adjacente à une valeur adjacente (une supérieure ou une inférieure dans cet ordre, A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Notez que l'as ne peut pas être adjacent à un 2 ou à un roi).
• Les Jokers peuvent être dans n'importe quelle position.
• La définition d'un Superb Shuffle ™ n'exige pas que les cartes soient dans un ordre différent chaque fois qu'elles sont mélangées. Ce qui n'est pas très beau, mais c'est Superb ™.

Parce que c'est Superb ™.

Un exemple pourrait être:

[
  "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"
]

Le défi:

• Écrivez du code pour exécuter un superbe shuffle
• Utilisez n'importe quelle langue.
• L'entrée peut être soit :
  • un jeu de cartes tel que décrit ci-dessus dans le même ordre , comme un tableau ou une autre structure de liste.
  • Aucune entrée (le code génère un jeu de cartes dans cet ordre)
• La sortie doit être un jeu de cartes complet dans un Superb Shuffle ™ comme décrit ci-dessus.
• Essayez d'exécuter votre Superb Shuffle ™ dans le plus petit nombre d'octets.
• Un lien vers un interprète en ligne tel que Try It Online est préférable, mais facultatif.

Mélange heureux!

Japt, 6 5 4 octets

Divise le tableau d'entrée en sous-tableaux de chaque 16e élément et aplatit.

óG c

Essayez-le

Rubis , 31 octets

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

Essayez-le en ligne!

Explication:

Je prends une carte, puis je saute les 16 suivantes et je commence à partir de la première carte lorsque j'atteins la dernière carte du jeu. 17 et 54 sont mutuellement premiers, donc je suis sûr de choisir toutes les cartes.

La 17e position est garantie d'être une couleur différente et la différence de valeur est d'au moins 2: la 13e (ou 15e) carte a la même valeur et une couleur différente, donc en sautant les 4 autres (ou 2), la valeur est correcte .

Python 3 , 21 octets

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

Essayez-le en ligne!

Explication:

La même idée que ma réponse Ruby, mais encore plus courte en Python: j'utilise 17 paquets, et je choisis toutes les 17 cartes.

JavaScript, 35 octets

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

Essayez-le en ligne!

Prendre un tableau de deck en entrée et remplacer chaque valeur impaire par une autre carte distante de "20 cartes" sur le deck.

Java 10, 72 65 octets

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

Similaire à la réponse Ruby de @GB , mais en utilisant i*7%54sur le tableau de résultats, plutôt que i*17%54sur le tableau d'entrée pour enregistrer un octet.

Essayez-le en ligne.

Explication:

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 octets

Merci à Brad Gilbert b2gills pour -2 octets

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

Essayez-le en ligne!

Encore un autre port de la réponse de GB . Notez que, bien que la variable globale ne $!soit pas réinitialisée entre les fonctions, la valeur n'a pas d'importance, car tout ordre de sortie est valide. Cependant, $ est réinitialisé.

Explication:

{                } #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 octets

ā17*è

Port de la réponse Ruby de @GB , alors assurez-vous de lui donner un vote positif!

-2 octets en imprimant chaque carte avec un délimiteur de nouvelle ligne au lieu de l'envelopper dans une liste de résultats
-2 octets grâce à @ Mr.Xcoder

Essayez-le en ligne.

Explication:

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

Un autre basé sur la réponse rubis

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

Édité dans un raccourcissement évident

T-SQL, 31 octets

SELECT c FROM t ORDER BY i*7%54

Si vous ne vous souciez pas d'une colonne supplémentaire dans la sortie, je peux la réduire à 29 octets :

SELECT*FROM t ORDER BY i*7%54

Vous pouvez donc vérifier que ma sortie est "Superbe", voici le deck qu'elle produit:

 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

(Généré à l'aide du nouvel ajout SQL 2017, STRING_AGG):

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

La partie difficile pour moi n'était pas le code de sélection, il remplissait la table d'entrée (ce qui est autorisé pour SQL selon nos règles d'E / S ).

Parce que SQL est intrinsèquement non ordonné (il ne garantit un certain ordre que si vous incluez une ORDER BYclause explicite ), j'ai dû inclure cet ordre d'origine en tant que champ i dans la table d'entrée t . Cela signifie également que je peux l'utiliser pour trier, en utilisant le même processus facteur / mod "relativement premier" que tout le monde utilise. J'ai trouvé que cela i*7%54fonctionnait aussi bien que i*17%54.

Voici les commandes pour configurer et remplir la table d'entrée t , en fonction de ma solution à cette question connexe :

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'

Gelée ,  5  4 octets

s⁴ZẎ

Essayez-le en ligne!

Il s'avère que tout le monde, tout le monde, sauf le gars aléatoire, il enregistre un octet :(
crédit à Go pour leur méthode .

La façon dont je suis allé ...

ṙÐe20

Essayez-le en ligne!

Comment?

Fixez toutes les autres cartes et intercalez-les avec une rotation du jeu de 20 places (18 et 22 places fonctionnent également; en outre, les deux sens de rotation ainsi que la fixation des cartes impaires ou paires)

ṙÐ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)

C'est-à-dire (en utilisant Tpour 10et rj& bjpour les 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 octets

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

^{-4 grâce à Mazzy}
Ancien code à 30 octets

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

Un autre port de la méthode de GB.

Fusain , 8 octets

Ｅθ§θ×¹⁷κ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Un autre port de la réponse Ruby de @ GB. Explication:

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

Rouge , 44 octets

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

Essayez-le en ligne!

Une autre interprétation du code de GB. J'ajoute 16 copies du jeu à lui-même, puis j'extrais chaque 17e carte.