5 장의 마술은 그 보조자가 4 장의 보여진 카드와 숨겨진 카드를이 순서대로주는 마술사를 포함하며, 마술사는 숨겨진 카드를 추측해야합니다.

경고 : 아래 해결책! 지금 떠나거나 망쳐 놓으십시오.

해결책

여기서의 요령은 5 장의 카드가 특정 순서 로 주어진다 는 것입니다 !

$c_1,...,c_5$ 주어진 순서대로 5 개 카드입니다.

$x_n$ 은 N O = [ A, 2,3,4,5,6,7,8,9, T, J, Q, K ] 에서$c_n$ 의 카드 번호이다(번호 순서).$NO=[\text{A,2,3,4,5,6,7,8,9,T,J,Q,K}]$

$a+b$ , 카드 번호 및 정수이다 카드 번호와 동일 의 오른쪽 단계 에서 처음에, 포장 필요.$a$$b$$b$$a$$NO$

$s_n$ 의 소송이다 에서 (양복 순서).$c_n$$SO=[\clubsuit,\diamondsuit,\heartsuit,\spadesuit]$

$a\circ b$ (여기서 는 카드 번호이고 는 정장 임)는 카드 번호가 이고 양복이 카드를 나타냅니다 .$a$$b$$a$$b$

$a<b$ , 와 카드가이 경우에 해당하는 의 소송이의 왼쪽에 에 소송의 ' , 또는 정장이 동일하고 의 카드 번호가의 왼쪽에 의'카드 숫자 .$a$$b$$a$$b$$SO$$a$$b$$NO$

$a>b$a b a < b 가 false 인 경우 는 및 가 카드 인 경우 true입니다.$a$$b$$a<b$

$PI(a,b,c)$ a b (여기서 , 및 c 는 카드 임)는이 순서의 순열 인덱스이며 아래 표에 지정되어 있습니다. 비교 P I ( a , b , c ) a < b < c 1 < B > C > 2 > B < C > 3 < B > C < 4 > B <$a$$b$$c$
$\begin{array}{|c|c|}\hline\text{Comparison}&PI(a,b,c)\\\hline a<b<c&1\\\hline a<b>c>a&2\\\hline a>b<c>a&3\\\hline a<b>c<a&4\\\hline a>b<c<a&5\\\hline a>b>c&6\\\hline\end{array}$

5 카드 마술의 해결책은 문제입니다 :

도전

여태까지는 그런대로 잘됐다. 그러나 위에서 지정한 계산을 수행하려면 이미 여기에 요청되어 있습니다 . 대신, 당신의 도전은 5 개의 카드를 특정한 순서로 제공받지 않으면 서 올바르게 주문하는 것입니다. 즉, 출력에서 ​​처음 4 개의 카드는 5 번째 카드를 나타냅니다. 다시 말해서 조수가 되십시오. 요구 사항 :

• $s_5=s_1$ 입니다.
• $x_5=x_1+PI(c_2,c_3,c_4)$ (즉, 가능해야 함).

예

set을 고려해 봅시다 7H,2D,6D,5C,6C. 우선, 우리는 25 쌍을 취합니다 :

7H,7H 7H,2D 7H,6D 7H,5C 7H,6C
2D,7H 2D,2D 2D,6D 2D,5C 2D,6C
6D,7H 6D,2D 6D,6D 6D,5C 6D,6C
5C,7H 5C,2D 5C,6D 5C,5C 5C,6C
6C,7H 6C,2D 6C,6D 6C,5C 6C,6C

그런 다음, 동일한 카드를 두 번 포함하는 5 쌍을 분명히 제거합니다. 단일 카드에는 존재하지 않습니다.

      7H,2D 7H,6D 7H,5C 7H,6C
2D,7H       2D,6D 2D,5C 2D,6C
6D,7H 6D,2D       6D,5C 6D,6C
5C,7H 5C,2D 5C,6D       5C,6C
6C,7H 6C,2D 6C,6D 6C,5C      

그 후에는 수트가 동일해야하므로 한 쌍의 다른 수트는 절대 아닙니다.

                             
            2D, 6D            
      6D, 2D                  
                        5C, 6C
                  6C, 5C      

마지막으로 최대 6 개를 추가하고 나머지 쌍의 절반을 제거하여 첫 번째 카드에서 두 번째 카드로 올 수 있는지 확인합니다.

                             
            2D, 6D            

                        5C, 6C
                             

이제 유효한 쌍이 있습니다 : 2D,6D및 5C,6C. 각 쌍의 첫 번째 카드는 카드 1이고 마지막은 카드 5입니다.

우리는 5C,6C쉬움을 위해 여기에 갈 것 입니다. 전체 세트는 7H,2D,6D,5C,6C이므로 선택한 페어에서 2 장의 카드를 제거하면 7H,2D,6D됩니다. 이 카드는을 나타내 6 - 5 = 1므로 "min, mid, max"와 같이 주문해야합니다. 7H > 2D < 6D < 7H또는 간단하게 2D < 6D < 7H, 이제 우리는 가지고 있습니다 2D,6D,7H.

마지막 단계는이 모든 것을 하나로 묶는 것이므로 결과는 다음과 같습니다 5C,2D,6D,7H,6C.

설명

• 10대신 사용할 수 있습니다 T.
• 당신이 중 하나를 사용할 수 있습니다 ♠♥♦♣, ♤♡♢♧또는 ♠♡♢♣의 대신에 CDHS각각.
• 이것은 가장 짧은 코드가 승리하는 code-golf 입니다.

테스트 사례

각 테스트 사례에 포함 된 하나 이상의 유효한 솔루션을 출력 할 수 있습니다.

8S,TD,5C,QS,TS -> 8S,5C,QS,TD,TS
              ... 8S,TD,TS,5C,QS
              ... TS,5C,8S,TD,QS

JD,KH,4S,9D,8S -> 9D,KH,8S,4S,JD
              ... 4S,JD,KH,9D,8S

4H,4D,TH,KH,2C -> 4H,KH,4D,2C,TH
              ... TH,4D,2C,4H,KH
              ... KH,4D,TH,2C,4H

3S,KS,8S,KH,9H -> 9H,8S,KS,3S,KH
              ... 3S,KS,9H,KH,8S
              ... 8S,3S,9H,KH,KS
              ... KS,KH,9H,8S,3S

KH,TS,3C,7H,JD -> 7H,TS,JD,3C,KH

4C,KC,TD,JD,QS -> KC,JD,QS,TD,4C
              ... TD,4C,KC,QS,JD

AC,5H,8D,6D,8S -> 6D,AC,8S,5H,8D

AS,TC,3S,2H,9C -> 9C,2H,AS,3S,TC
              ... AS,9C,2H,TC,3S

4C,JS,AS,8H,JC -> JC,JS,AS,8H,4C
              ... JS,JC,4C,8H,AS

4H,QS,TH,QC,AC -> QC,4H,QS,TH,AC
              ... 4H,QS,QC,AC,TH

Node.js를 , 190 (186) 180 바이트

f=(a,p,g=c=>"A23456789TJQK".search(c[0])+10,[A,B,C,D,E]=a.sort(_=>p>>i++&1,i=0))=>A[k=1]!=E[1]|[B,C,D].sort((a,b)=>k=k*2|a[1]+g(a)>b[1]+g(b))|(k^4)%6+1-(g(E)-g(A)+13)%13?f(a,-~p):a

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

어떻게?

카드 번호 식별 및 비교

$g$

g = c => "A23456789TJQK".search(c[0]) + 10

$10$$10$$22$

$a$$b$"NS"

a[1] + g(a) > b[1] + g(b)

입력 순열 생성

$120$$a$$p$$A$$B$$C$$D$$E$

[A, B, C, D, E] = a.sort(_ => p >> i++ & 1, i = 0)

$699$

정장 테스트

첫 번째 명백한 테스트는 첫 번째 카드와 마지막 카드가 동일한 지 확인하는 것입니다. 순열이 같지 않으면 순열을 거부합니다.

A[k = 1] != E[1] // we also initialize k, which is used right after that

거리 테스트

첫 번째 카드 번호와 마지막 카드 번호 사이의 거리를 다음과 같이 계산합니다.

(g(E) - g(A) + 13) % 13

$B$$C$$D$

이 테스트 sort()는 Node.js 알고리즘이 작동 하는 방식에 의존합니다 .

sort()$[A,B,C]$ 다음 3 단계를 적용 를 합니다.

1. 비교하다$A$$B$
2. 비교$A$$C$
3. 비교$B$$C$

다음 코드를 고려해 봅시다.

[1, 2, 3].sort((a, b) => k = k * 2 | (a > b), k = 1)

$A<B$$1<2$$A<C$$1<3$$B<C$$2<3$$k$$2^3$$k=8$ .

이제 우리가 할 경우 :

[3, 2, 1].sort((a, b) => k = k * 2 | (a > b), k = 1)

모든 비교가 이제 진실이되어 비트 마스크 를 생성합니다.$k=15$ .

각 순열은 고유 한 거리에 매핑되는 고유 한 비트 마스크를 생성합니다.

 A, B, C | A>B | A>C | B>C | k  | distance
---------+-----+-----+-----+----+----------
 1, 2, 3 |  0  |  0  |  0  |  8 |    1
 1, 3, 2 |  0  |  0  |  1  |  9 |    2
 2, 1, 3 |  1  |  0  |  0  | 12 |    3
 2, 3, 1 |  0  |  1  |  1  | 11 |    4
 3, 1, 2 |  1  |  1  |  0  | 14 |    5
 3, 2, 1 |  1  |  1  |  1  | 15 |    6

$k$ 다음을 수행하여 거리로 변환 할 수 있습니다.

  k | xor 4 | mod 6 | +1
----+-------+-------+----
  8 |   12  |   0   |  1
  9 |   13  |   1   |  2
 12 |    8  |   2   |  3
 11 |   15  |   3   |  4
 14 |   10  |   4   |  5
 15 |   11  |   5   |  6

모든 것을 종합하면 다음과 같은 테스트가 수행됩니다.

[B, C, D]
.sort((a, b) =>
  k = k * 2 | a[1] + g(a) > b[1] + g(b)
)
| (k ^ 4) % 6 + 1
- (g(E) - g(A) + 13) % 13

파이썬 3 , 260248232 바이트

N="A23456789TJQK".find
D=lambda x,y="KC":(N(y[0])+~N(x[0]))%13+15*abs(ord(x[1])-ord(y[1]))
def f(l):a,e,b,c,d=[[x,y]+sorted({*l}-{x,y},key=D)for x in l for y in l if D(x,y)<6][0];print(a,*map(eval,"bbccddcdbdbcdcdbcb"[D(a,e)::6]),e)

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

목록 이해력을 제거 하여 Outgolfer Eric에게 -12 바이트
-14 바이트

면도 , 225 (220) 209 바이트

import StdEnv,Data.List
n=['A23456789TJQK':n]

filter(\[[x,s],b,c,d,e]#[p,q,r:_]=map snd(sort(zip2[(elemIndices a n,b)\\[a,b]<-[b,c,d]][1..]))
=[snd(span((<>)x)n)!!(p+if(p>q)0if(q<r)(q+r)q),s]==e)o permutations

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

구성된 기능으로 :: [[Char]] -> [[Char]]일부 도우미와 함께 .

넓히는:

n = ['A23456789TJQK': n] // infinitely repeating card number list

filter (...) o permutations // filter the permutations of the argument by ...
  \[[x, s], b, c, d, e] // deconstruct each permutation via pattern matching
    #[p, q, r: _] = ... // define p, q, r as ...
      map snd (...) // the second component of every element in ...
      sort (...) // the sorted list of ...
      zip2 ... [1..] // pairs of ... and the numbers 1, 2, 3, ..
      [... \\ [a, b] <- [b, c, d]] // ... for every pair of number a and house b in [b, c, d]
      (elemIndices a n, b) // pair of the value of that card number and the house
    = ... == e // check ... for equality against the last card
      [..., s] // ..., paired with house s
      snd (span ((<>) x) n) !! (...) // the card number ... places from x
      p + ... // this is kinda obvious
      if(p > q) 0 ... // if p is greater than q, zero, else ...
      if(q < r) (q + r) q // if q is less than r, q + r, else q

루비 , 175 바이트

->a{g=->j{j.tr('ATJQKCHS','1:;<=)_z').sum}
e=b=a.sort_by{|i|g[i]}
4.times{|i|(d=g[b[i+1]]-g[b[i]])<13&&(a=b[i,2];e=d)}
[a[e/7],*(b-a).permutation.to_a[e<7?e-1:12-e],a[e/7-1]]}

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

카드 배열을 문자열로 취하는 람다 함수

댓글

->a{g=->j{j.tr('ATJQKCHS','1:;<=)_z').sum}
#helper function converts card to integer, ATJQK to 1:;<= and CHS to )_z then sum ascii values 

e=b=a.sort_by{|i|g[i]}  
#sort according to g. we declare 2 variables here in order to avoid undefined variable error at pre-interpretation check stage.

4.times{|i|(d=g[b[i+1]]-g[b[i]])<13&&(a=b[i,2];e=d)}
#compare each pair of values. if in same suit, store the pair of cards to a
#and the value difference to e. Loop exits with the last suitable pair stored

[a[e/7],*(b-a).permutation.to_a[e<7?e-1:12-e],a[e/7-1]]}
#return array containing the two cards of the same suit in the correct order
#with the correct permutation of the remaining cards (b-a) in the middle

젤리 , 41 바이트

ØD;“TJQK”¤io2)1¦€µUḊỤ3R¤œ¿+""Om4%13E
Œ!ÇƇ

모든 유효한 배열 목록을 동일한 형식으로 반환하는 문자 목록을 허용하는 모나드 링크.

온라인으로 사용해보십시오! (바닥 글은 전체 프로그램으로 실행될 때 링크 코드에 의해 수행되는 암시 적 스매싱 인쇄를 피하기 위해 결과를 격자로 형식화합니다)

또는 테스트 스위트를 참조하십시오 .

나는 다른 접근 방식이 훨씬 더 간결해질 것이라는 몰래 의심을 가지고 있습니다. 나중에이 도전을 다시 방문해야합니다!

... 음, 나는 또 다른 찌를 가지고 있었고 또 다른 41 바이 터 ( test )를 얻었다 .

O¹*@<74$?€€29%⁽:0%⁴UµṪ_Ḣ%13Ḍ⁼Ụ3R¤œ¿Ɗ
Œ!ÇƇ