Đối với mục đích của câu hỏi này, một cỗ bài được định dạng theo cách này:

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

Thẻ luôn được định dạng là giá trị, theo sau là bộ quần áo. Ví dụ như ASAce of Spades. Hai J duy nhất là Jokers. Chúng tôi muốn xáo trộn bộ bài này, nhưng việc xáo trộn phải là Super ™.

Một Shuffle ™ tuyệt vời là một trong đó:

• Không có hai thẻ (trừ Jokers) của cùng một bộ đồ liền kề nhau.
• Không có thẻ (trừ Jokers) liền kề với một trong những giá trị tương tự.
• Không có thẻ nào (ngoại trừ Jokers) liền kề với một trong các giá trị liền kề (một cao hơn hoặc thấp hơn theo thứ tự này, A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Lưu ý rằng Ace không thể liền kề với 2 hoặc King).
• The Jokers có thể ở bất kỳ vị trí nào.
• Định nghĩa của Super Shuffle ™ không yêu cầu các thẻ phải theo thứ tự khác nhau mỗi lần chúng được xáo trộn. Điều này không phải là rất tuyệt vời, nhưng đó là Super ™.

Bởi vì đó là Super ™.

Một ví dụ có thể là:

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

Các thách thức:

• Viết một số mã để thực hiện một shuffle tuyệt vời
• Sử dụng bất kỳ ngôn ngữ.
• Đầu vào có thể là :
  • một bộ bài như mô tả ở trên theo cùng một thứ tự , như một mảng hoặc cấu trúc danh sách khác.
  • Không có đầu vào (mã tạo ra một cỗ bài theo thứ tự đó)
• Đầu ra phải là một bộ bài đầy đủ trong Super Shuffle ™ như được mô tả ở trên.
• Cố gắng thực hiện Super Shuffle ™ của bạn với số byte nhỏ nhất.
• Liên kết đến một trình thông dịch trực tuyến như Dùng thử trực tuyến được ưu tiên, nhưng không bắt buộc.

Hạnh phúc xáo trộn!

Japt, 6 5 4 byte

Chia mảng đầu vào thành các mảng con của mọi phần tử thứ 16 và làm phẳng.

óG c

Thử nó

Ruby , 31 byte

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

Hãy thử trực tuyến!

Giải trình:

Tôi đang chọn một thẻ, sau đó bỏ qua 16 thẻ tiếp theo và bắt đầu từ thẻ đầu tiên khi tôi đến thẻ cuối cùng của bộ bài. 17 và 54 là hai số nguyên tố chung, vì vậy tôi chắc chắn chọn tất cả các thẻ.

Vị trí thứ 17 được đảm bảo là một bộ đồ khác nhau và sự khác biệt về giá trị ít nhất là 2: thẻ thứ 13 (hoặc thứ 15) có cùng giá trị và một bộ đồ khác, do đó, bỏ qua 4 (hoặc 2) khác, giá trị là đúng .

Python 3 , 21 byte

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

Hãy thử trực tuyến!

Giải trình:

Ý tưởng tương tự như câu trả lời Ruby của tôi, nhưng thậm chí còn ngắn hơn trong Python: Tôi sử dụng 17 bộ bài và chọn mỗi thẻ thứ 17.

JavaScript, 35 byte

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

Hãy thử trực tuyến!

Lấy một mảng của bộ bài làm đầu vào và thay thế từng giá trị lẻ bằng một thẻ khác cách "20 thẻ" trên bộ bài.

Java 10, 72 65 byte

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

Tương tự như câu trả lời Ruby của @GB , nhưng bằng cách sử dụng i*7%54trên mảng kết quả, thay vì i*17%54trên mảng đầu vào để lưu một byte.

Hãy thử trực tuyến.

Giải trình:

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 byte

Cảm ơn Brad Gilbert b2gills cho -2 byte

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

Hãy thử trực tuyến!

Một cổng khác của câu trả lời của GB . Lưu ý rằng, trong khi biến toàn cục $!không được đặt lại giữa các hàm, giá trị không thành vấn đề, vì bất kỳ thứ tự nào của đầu ra đều hợp lệ. Tuy nhiên, $ được thiết lập lại.

Giải trình:

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

ā17*è

Cổng câu trả lời Ruby của @GB , vì vậy hãy đảm bảo nâng cao anh ấy!

-2 byte bằng cách in mỗi thẻ bằng một dấu phân cách dòng mới thay vì gói nó vào danh sách kết quả
-2 byte nhờ @ Mr.Xcoder

Hãy thử trực tuyến.

Giải trình:

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

Một số khác dựa trên câu trả lời của ruby

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

Chỉnh sửa trong một rút ngắn rõ ràng

T-SQL, 31 byte

SELECT c FROM t ORDER BY i*7%54

Nếu bạn không quan tâm đến một cột thêm trong đầu ra, tôi có thể giảm xuống còn 29 byte :

SELECT*FROM t ORDER BY i*7%54

Vì vậy, bạn có thể xác minh đầu ra của tôi là "Tuyệt vời", đây là bộ bài mà nó tạo ra:

 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

(Được tạo bằng cách sử dụng bổ sung SQL 2017 mới, STRING_AGG):

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

Phần khó đối với tôi không phải là mã được chọn, nó được điền vào bảng đầu vào (được phép cho SQL theo các quy tắc IO của chúng tôi ).

Vì SQL vốn không có thứ tự (nó chỉ đảm bảo một thứ tự nhất định nếu bạn bao gồm một ORDER BYmệnh đề rõ ràng ), tôi phải đưa thứ tự ban đầu đó làm trường i trong bảng đầu vào t . Điều này cũng có nghĩa là tôi có thể sử dụng nó để sắp xếp, sử dụng cùng một quá trình mod / yếu tố "tương đối chính" mà mọi người khác đang sử dụng. Tôi thấy rằngi*7%54 làm việc tốt như là i*17%54.

Dưới đây là các lệnh để thiết lập và điền vào bảng đầu vào t , dựa trên giải pháp của tôi cho câu hỏi liên quan này :

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'

Thạch ,  5  4 byte

s⁴ZẎ

Hãy thử trực tuyến!

Hóa ra cách mọi người khác mọi người khác ngoại trừ Người ngẫu nhiên đang làm điều đó tiết kiệm một byte :(
Tín dụng cho GB cho phương thức của họ .

Con đường tôi đã đi ...

ṙÐe20

Hãy thử trực tuyến!

Làm sao?

Sửa tất cả các thẻ khác và xen kẽ nó với một vòng quay của bộ bài còn lại 20 vị trí (18 và 22 vị trí cũng hoạt động; ngoài ra, cả hai hướng xoay cũng như sửa các thẻ lẻ hoặc chẵn)

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

Đó là (sử dụng Tcho 10và rj& bjcho 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 byte

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

^{-4 nhờ}
mã ^Mazzy Cũ ở 30 byte

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

Một cổng khác của phương thức GB.

Than , 8 byte

Ｅθ§θ×¹⁷κ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Một cổng khác của câu trả lời Ruby của @ GB. Giải trình:

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

Màu đỏ , 44 byte

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

Hãy thử trực tuyến!

Một sự can thiệp khác của mã GB. Tôi nối thêm 16 bản sao của bộ bài vào chính nó và sau đó trích xuất mỗi thẻ thứ 17.