出于这个问题的目的，用这种方式格式化一副纸牌：

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

卡总是格式化为值，后跟西装。例如，AS是黑桃王牌。两个单身的J是小丑。我们要洗牌，但是洗牌必须是Superb™。

Superb Shuffle™是其中一​​种：

• 没有两张相同西装的纸牌（小丑除外）相邻。
• 没有一张纸牌（小丑除外）与相同值的一张纸牌相邻。
• 没有纸牌（小丑除外）与相邻值之一（此顺序为高，低1，A，2、3、4、5、6、7、8、9、10，J，Q，K， A.请注意，A不能与2或King相邻。
• 小丑可以在任何位置。
• Superb Shuffle™的定义不要求每次洗牌时的卡顺序都不同。并不是很好，但是是Superb™。

因为那是Superb™。

一个示例可能是：

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

挑战：

• 编写一些代码以执行出色的混洗
• 使用任何语言。
• 输入可以是任一：
  • 如上所述的一副纸牌，其顺序与数组或其他列表结构相同。
  • 无输入（代码按该顺序生成一副纸牌）
• 如上所述，输出必须是Superb Shuffle™中的一整套纸牌。
• 尝试以最少的字节数执行Superb Shuffle™。
• 首选连接到在线解释器，例如“ 在线试用”，但它是可选的。

快乐的洗牌！

Japt，6 5 4字节

将输入数组拆分为每第16个元素的子数组并展平。

óG c

尝试一下

红宝石，31个字节

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

在线尝试！

说明：

我选择一张卡，然后跳过接下来的16张卡，直到到达牌组的最后一张卡时从第一张卡开始。17和54是互质的，所以我肯定会选择所有卡。

确保第17个位置使用不同的花色，并且值相差至少为2：第13张（或第15张）卡具有相同的值和不同花色，因此跳过其他4个（或2个），该值正确。

Python 3，21个字节

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

在线尝试！

说明：

与我的Ruby答案相同，但在Python中更短：我使用17个牌组，并选择第17张卡。

JavaScript，35个字节

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

在线尝试！

将一个牌组作为输入，并用牌组上距离“ 20​​张牌”的另一张牌替换每个奇数值。

Java 10，72 65字节

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

与@GB的Ruby答案相似，但是通过i*7%54在结果数组上使用而不是i*17%54在输入数组上使用来保存字节。

在线尝试。

说明：

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

感谢-2字节的Brad Gilbert b2gills

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

在线尝试！

GB的另一个答案。请注意，虽然全局变量$!不会在函数之间重置，但该值无关紧要，因为输出的任何顺序都是有效的。但是，$ 被重置。

说明：

{                } #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 字节

ā17*è

@GB的Ruby解答的端口，因此请确保对他进行投票！

通过使用换行分隔符打印每张卡，而不是将其包装到结果列表中，从而得到
-2字节-2字节，这要归功于@ Mr.Xcoder

在线尝试。

说明：

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

另一个基于红宝石答案

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

编辑明显缩短

T-SQL，31个字节

SELECT c FROM t ORDER BY i*7%54

如果您不关心输出中的额外列，则可以将其减少到29个字节：

SELECT*FROM t ORDER BY i*7%54

因此，您可以验证我的输出是否为“ Superb”，这是它产生的甲板：

 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

（使用新的SQL 2017附加项生成STRING_AGG）：

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

对我而言，最困难的部分不是选择代码，而是填充输入表（根据我们的IO规则，SQL允许使用该表）。

由于SQL本质上是无序的（如果您包含显式ORDER BY子句，它只能保证一定的顺序），因此我不得不将该原始顺序作为字段 i包含在输入表t中。这也意味着我可以使用其他人正在使用的相同“相对主要”因子/ mod流程对其进行排序。我发现i*7%54效果和i*17%54。

这是根据我对这个相关问题的解决方案来设置和填充输入表t的命令：

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'

果冻， 5  4 字节

s⁴ZẎ

在线尝试！

原来的方式其他人 其他人，除随机家伙正在做这样可以节省字节:(
感谢GB为他们的方法。

我走的路...

ṙÐe20

在线尝试！

怎么样？

固定其他每张卡，并在其转盘向左旋转20个位置时散布它（也可以使用18和22个位置；此外，旋转的任何方向以及固定奇数或偶数卡都可以）

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

那就是（T用于10和rj＆bj用于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字节

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

^-4感谢
30字节的^Mazzy Old代码

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

GB方法的另一个端口。

木炭，8字节

Ｅθ§θ×¹⁷κ

在线尝试！链接是详细版本的代码。@GB的Ruby答案的另一个端口。说明：

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

红色，44字节

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

在线尝试！

GB的代码的另一个插入。我将卡片组的16个副本附加到其自身，然后提取每张第17张卡片。