Für die Zwecke dieser Frage wird ein Kartenspiel folgendermaßen formatiert:

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

Karten werden immer als Wert formatiert, gefolgt von Farben. ZB ASist das Pik-As. Die beiden Single J's sind Joker. Wir wollen dieses Kartenspiel mischen, aber das Mischen muss Superb ™ sein.

Ein Superb Shuffle ™ ist eines, bei dem:

• Es liegen keine zwei Karten (außer Joker) derselben Farbe nebeneinander.
• Keine Karte (außer Joker) grenzt an eine Karte mit demselben Wert.
• Keine Karte (außer Joker) grenzt an einen benachbarten Wert (einen höheren oder einen niedrigeren in dieser Reihenfolge). A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Beachten Sie, dass Ace weder an eine 2 noch an einen König angrenzt.
• Die Joker können in jeder Position sein.
• Die Definition eines Superb Shuffle ™ erfordert nicht, dass die Karten bei jedem Mischen in einer anderen Reihenfolge vorliegen. Das ist nicht besonders gut, aber es ist Superb ™.

Denn das ist Superb ™.

Ein Beispiel könnte sein:

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

Die Herausforderung:

• Schreiben Sie Code, um ein hervorragendes Shuffle auszuführen
• Verwenden Sie eine beliebige Sprache.
• Die Eingabe kann entweder sein :
  • ein Kartenspiel wie oben beschrieben in der gleichen Reihenfolge , als Array oder andere Listenstruktur.
  • Keine Eingabe (der Code generiert ein Kartenspiel in dieser Reihenfolge)
• Die Ausgabe muss ein vollständiges Kartenspiel in einem Superb Shuffle ™ sein, wie oben beschrieben.
• Versuchen Sie, Ihren Superb Shuffle ™ in der kleinsten Anzahl von Bytes auszuführen.
• Ein Link zu einem Online-Dolmetscher wie Try It Online ist bevorzugt, aber optional.

Viel Spaß beim Mischen!

Japt, 6 5 4 Bytes

Teilt das Eingabearray in Unterarrays jedes 16. Elements auf und glättet es.

óG c

Versuch es

Ruby , 31 Bytes

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

Probieren Sie es online!

Erläuterung:

Ich wähle eine Karte aus, überspringe dann die nächsten 16 und beginne mit der ersten Karte, wenn ich die letzte Karte des Decks erreicht habe. 17 und 54 sind gegenseitig primitiv, also werde ich sicher alle Karten auswählen.

Die 17. Position ist garantiert eine andere Farbe und die Wertdifferenz beträgt mindestens 2: Die 13. (oder 15.) Karte hat den gleichen Wert und eine andere Farbe. Wenn Sie also andere 4 (oder 2) überspringen, stimmt der Wert .

Python 3 , 21 Bytes

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

Probieren Sie es online!

Erläuterung:

Die gleiche Idee wie meine Ruby-Antwort, aber in Python noch kürzer: Ich benutze 17 Decks und wähle jede 17. Karte aus.

JavaScript, 35 Bytes

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

Probieren Sie es online!

Nehmen Sie eine Reihe von Decks als Eingabe und ersetzen Sie jeden ungeraden Wert durch eine andere Karte, die "20 Karten" auf dem Deck entfernt ist.

Java 10, 72 65 Bytes

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

Ähnlich wie die Ruby-Antwort von @ GB , jedoch mit i*7%54dem Ergebnis-Array anstelle des i*17%54Eingabe-Arrays, um ein Byte zu speichern.

Probieren Sie es online aus.

Erläuterung:

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

Vielen Dank an Brad Gilbert b2gills für -2 Bytes

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

Probieren Sie es online!

Noch eine Portierung der Antwort von GB . Beachten Sie, dass $!der Wert keine Rolle spielt , während die globale Variable zwischen Funktionen nicht zurückgesetzt wird, da jede Reihenfolge der Ausgabe gültig ist. Wird $ jedoch zurückgesetzt.

Erläuterung:

{                } #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*è

Port of @GBs Ruby-Antwort , also stelle sicher, dass du ihn positiv bewertest!

-2 Bytes, indem Sie jede Karte mit einem Trennzeichen für neue Zeilen drucken, anstatt sie
dank @ Mr.Xcoder in eine Ergebnisliste mit -2 Bytes zu packen

Probieren Sie es online aus.

Erläuterung:

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

Eine andere basiert auf der rubinroten Antwort

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

Bearbeitet in einer offensichtlichen Verkürzung

T-SQL, 31 Bytes

SELECT c FROM t ORDER BY i*7%54

Wenn Ihnen eine zusätzliche Spalte in der Ausgabe egal ist, kann ich sie auf 29 Bytes reduzieren :

SELECT*FROM t ORDER BY i*7%54

Sie können also überprüfen, ob meine Ausgabe "Hervorragend" ist. Hier ist das Deck, das sie produziert:

 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

(Mit dem neuen SQL 2017-Zusatz generiert STRING_AGG):

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

Der schwierige Teil für mich war nicht der Auswahlcode, er füllte die Eingabetabelle (die gemäß unseren E / A-Regeln für SQL zulässig ist ).

Da SQL von Natur aus ungeordnet ist (es garantiert nur dann eine bestimmte Reihenfolge, wenn Sie eine explizite ORDER BYKlausel angeben), musste ich diese ursprüngliche Reihenfolge als Feld i in die Eingabetabelle t aufnehmen . Dies bedeutet auch, dass ich damit sortieren kann, wobei derselbe "relativ primäre" Faktor / Mod-Prozess verwendet wird, den alle anderen verwenden. Ich fand, das i*7%54hat genauso gut funktioniert wie i*17%54.

Hier sind die Befehle zum Einrichten und Auffüllen der Eingabetabelle t , basierend auf meiner Lösung für diese verwandte Frage :

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'

Gelee ,  5  4 Bytes

s⁴ZẎ

Probieren Sie es online!

Es stellt sich heraus, wie alle anderen , mit Ausnahme des zufälligen Mannes , ein Byte spart :(
Gutschrift an GB für ihre Methode .

Der Weg, den ich ging ...

ṙÐe20

Probieren Sie es online!

Wie?

Befestigen Sie jede zweite Karte und verteilen Sie sie mit einer Drehung des Kartensatzes um 20 Stellen (18 und 22 Stellen funktionieren ebenfalls; dies gilt auch für die Drehrichtung sowie für das Befestigen von ungeraden oder geraden Karten).

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

Das ist (mit Tfür 10und rj& bjfür die 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 dank Mazzy}
Old Code bei 30 Bytes

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

Ein weiterer Port der GB-Methode.

Kohle , 8 Bytes

Ｅθ§θ×¹⁷κ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ein weiterer Port von @ GBs Ruby-Antwort. Erläuterung:

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

Rot , 44 Bytes

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

Probieren Sie es online!

Eine weitere Interpretation des GB-Codes. Ich hänge 16 Kopien des Decks an sich selbst an und extrahiere dann jede 17. Karte.