이 질문의 목적을 위해, 카드 한 벌은 다음과 같은 형식으로 구성됩니다.

[
  "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 ™은 다음 중 하나입니다.

• 같은 수트의 카드 두 장 (조커 제외)이 인접 해 있지 않습니다.
• 동일한 값 중 하나에 인접한 카드 (조커 제외)가 없습니다.
• 카드 (조커 제외)가 인접한 값 중 하나에 인접하지 않습니다 (A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Ace는 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 ™을 수행하십시오.
• Try It Online 과 같은 온라인 통역사 링크 가 선호되지만 선택 사항입니다.

행복한 셔플!

apt, 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)를 건너 뛰면 값이 맞습니다 .

파이썬 3 , 21 바이트

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

온라인으로 사용해보십시오!

설명:

내 루비 답변과 같은 아이디어이지만 파이썬에서는 더 짧습니다 .17 개의 덱을 사용하고 17 번째 카드마다 선택합니다.

자바 스크립트, 35 바이트

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

온라인으로 사용해보십시오!

데크 배열을 입력으로 취하고 각 홀수 값을 데크에서 "20 카드"떨어진 다른 카드로 바꿉니다.

자바 10, 72 65 바이트

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

@GB 의 Ruby answer 와 유사 하지만 바이트를 저장하기 위해 입력 배열 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 bytes

Thanks to Brad Gilbert b2gills for -2 bytes

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

Try it online!

Yet another port of G B's answer. Note that, while the global variable $! is not reset between functions, the value doesn't matter, since any order of the output is valid. However, $ is reset.

Explanation:

{                } #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 @GB's Ruby answer, so make sure to upvote him!

-2 bytes by printing each card with a new-line delimiter instead of wrapping it to a result-list
-2 bytes thanks to @Mr.Xcoder

Try it online.

Explanation:

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

자바 스크립트, 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

내 출력이 "최고"인지 확인할 수 있습니다. 여기에 생성 된 데크가 있습니다.

 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절 을 포함하는 경우 특정 순서 만 보장 ) 입력 테이블 t의 원래 순서를 필드 i 로 포함해야했습니다 . 이것은 또한 다른 사람들이 사용하고있는 동일한 "상대적으로 중요한"요소 / 모드 프로세스를 사용하여 정렬하는 데 사용할 수 있음을 의미합니다. 나는 그것이 뿐만 아니라 효과가 있음을 발견 했습니다.i*7%54i*17%54.

Here are the commands to set up and populate the input table t, based on my solution to this related question:

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'

Jelly,  5  4 bytes

s⁴ZẎ

Try it online!

Turns out the way everyone else everyone else except The random guy is doing it saves a byte :(
Credit to G B for their method.

The way I went...

ṙÐe20

Try it online!

How?

Fix every other card and intersperse it with a rotation of the deck left by 20 places (18 and 22 places also work; furthermore so does either direction of rotation as well as fixing either odd or even cards)

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

That is (using T for 10 and rj & bj for the 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 thanks to Mazzy}
Old code at 30 bytes

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

Another port of G B's method.

Charcoal, 8 bytes

Ｅθ§θ×¹⁷κ

Try it online! Link is to verbose version of code. Another port of @GB's Ruby answer. Explanation:

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

Red, 44 bytes

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

Try it online!

Another interpetation of G B's code. I append 16 copies of the deck to itself and then extract each 17th card.