이 과제는 Devadas 교수의 MIT 강의에서 발췌 한 것 입니다. 트릭에 대한 자세한 설명은 링크 된 비디오 또는 이 문서 에서 찾을 수 있습니다 . 간단한 용어로 설명하려고합니다.

이것은 1930 년대에 발명되었으며 "피치 체니의 5 장의 카드 트릭"으로 알려져 있습니다.

트릭은 다음과 같습니다.

• 한 벌의 카드에서 5 개의 무작위 카드가 선택됩니다. 청중과 조수가 그들을 볼 수는 있지만 그렇지 않습니다.
• 당신의 조수 (당신이 연습 한 사람)는 그 카드 중 4 장을 선택하여 특정한 순서로 당신에게 보여줄 것입니다. 숨겨진 카드는 5 개의 카드에서 무작위로 선택되지 않습니다. 어시스턴트는 트릭을 작동시킬 카드를 선택합니다.
• 네 번째 카드가 무엇인지 네 카드에서 수집 할 수있는 정보를 바탕으로 추론합니다.

어떻게?

다음 두 가지 사항을 명심하십시오.

1. 5 개의 무작위 카드를 선택할 때, 최소 2 개의 카드가 동일한 수트 ^1을 보장합니다 .

2. 아래 이미지는 모든 순위가 ^{2 인} 원을 보여줍니다 . 원이기 때문에 J, Q, K, A, 2, 3을 계산할 수 있습니다 (예 : 모듈 식 계산). 숨겨진 카드는 첫 번째 카드와 같은 순위를 가지지 않습니다. 아래에 설명 된 것과 같은 카드입니다. 숨겨진 카드가 첫 번째 카드보다 1에서 6 사이의 순위 (원으로 계산할 때)가되도록 첫 번째 카드와 숨겨진 카드를 선택할 수 있습니다. 첫 번째 카드가 1 이면 숨겨진 카드는 2,3,4,5,6 또는 7 입니다. 첫 번째 카드가 J 이면 숨겨진 카드는 Q, K, A, 2,3 또는 4 입니다.

알고리즘 :

첫 번째 카드 : 이 카드는 숨겨진 카드와 같은 형태입니다. 이 카드는 숨겨진 카드의 순위를 알아낼 때 사용할 기준점이기도합니다.

두 번째, 세 번째 및 네 번째 카드 는 1 ... 6 범위의 값을 디코딩합니다 . 우리는 세 개의 카드 S, M, L (가장 작은 카드, 중간 카드, 가장 큰 카드)을 부를 것입니다. 값은 다음과 같이 인코딩됩니다 (사전 순서).

S M L   -> 1
S L M   -> 2
M S L   -> 3   
M L S   -> 4
L S M   -> 5
L M S   -> 6 

따라서 첫 번째 카드의 순위가 5 이고 나머지 세 카드의 순위가 4 Q 7 인 경우 ( SLM 주문 ) 마지막 카드의 순위는 5 + 2 = 7 입니다. 에이스가 일관된 한 에이스가 가장 높은 카드인지 가장 낮은 카드인지를 선택할 수 있습니다.

여러 카드가 순위를 공유하면 소송은 C <D <H <S 인 순서를 결정합니다 .

입력 형식 :

4 장의 카드는 H3 (하트 3 개), DK (다이아몬드 킹) 등으로 주어집니다. 대신 입력을 3H 및 KD 와 다르게 선택할 수 있습니다 .

입력은 편리한 형식 일 수 있지만 한 변수의 수트 목록과 다른 변수의 순위 목록을 결합 할 수는 없습니다. 'D5', 'H3' ..그리고 [['D',5],['H',3] ...둘 다 OK이지만 'DHCH',[5,3,1,5]그렇지 않습니다. T를 제외하고 문자 대신 숫자를 사용할 수 없습니다 .

산출

입력과 같은 형식의 숨겨진 카드.

예

연습을 해보자.

Input:
D3 S6 H3 H9

첫 번째 카드는 다이아몬드이기 때문에 숨겨진 카드는 다이아몬드라는 것을 알고 있습니다. 또한 첫 번째 카드의 순위가 3 이므로 순위가 4,5,6,7,8 또는 9 임을 알고 있습니다.

나머지 카드는 6,3,9 ==> M, S, L 로 정렬 되며 값은 3 입니다. 따라서 숨겨진 카드는 다이아몬드의 3 + 3 = 6 이므로 출력은 D6 이어야합니다 .

테스트 사례 :

C3 H6 C6 S2
C9            # The order is LMS (H6 > C6, and 2 < 6). 3+6=9     

SQ S4 S3 ST   # (ST = S10. Format is optional)
S2            # The order is MSL. 12+3=2

HA CA DA SA
H2            # The order is SML. 14+1=2

이것은 code-golf 이므로 각 언어에서 가장 짧은 솔루션이 승리합니다. 설명이 권장됩니다!

¹ 4 가지 슈트 ( C 윤활유, D iamonds, H earts 및 S pad)가 있습니다.

² 13 순위 2,3,4,5,6,7,8,9,10, J, Q, K, A가 있습니다. 10 대신 T 를 사용하도록 선택할 수 있습니다 .

자바 스크립트 (ES6) 130 102 바이트

입력을 "Rs"형식 의 문자열 배열로 취 합니다. 여기서 R 은 순위이고 s 는 적합합니다. 10 초 동안 "T" 를 예상합니다 . 에이스는 낮습니다.

a=>(s='A23456789TJQK')[([[R,[,S]],B,C,D]=a.map(c=>[s.search(c[0])+14,c]),R+=D<C|2*((D<B)+(C<B)))%13]+S

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

어떻게?

먼저 각 카드를 배열 [rank, card] 로 변환합니다 . 여기서 rank 는 [14 ... 26] 의 숫자 값 이고 card 는 원래 문자열입니다.

[[R, [, S]], B, C, D] = a.map(c => ['A23456789TJQK'.search(c[0]) + 14, c])

첫 번째 카드의 순위와 수트는 각각 R 과 S에 저장됩니다 . 다른 세 카드는 B , C 및 D에 저장됩니다 .

예를 들어 다음과 ['3c','6h','6c','2s']같습니다.

[ [ 16, '3c' ], [ 19, '6h' ], [ 19, '6c' ], [ 15, '2s' ] ]
    ^^    ^     <---------->  <---------->  <---------->
    R     S          B             C             D

그런 다음 [B, C, D]의 각 쌍을 비교합니다 . 이 요소들은 서로 비교 될 때 암시 적으로 문자열로 강제됩니다.

[ 19, '6h' ] --> '19,6h'

모두 있기 때문에 순위 와 카드가 정확히 두 개의 문자로 구성 보장됩니다, 사전 편찬 순서로 비교하는 것이 안전합니다.

우리는 다음을 계산합니다.

(D < C) | 2 * ((D < B) + (C < B))

다음은 가능한 모든 조합입니다.

 B, C, D | v0 = D < B  | v1 = C < B  | v2 = D < C  | v2|2*(v0+v1)
---------+-------------+-------------+-------------+--------------
 S, M, L |    false    |    false    |    false    |      0
 S, L, M |    false    |    false    |    true     |      1
 M, S, L |    false    |    true     |    false    |      2
 M, L, S |    true     |    false    |    true     |      3
 L, S, M |    true     |    true     |    false    |      4
 L, M, S |    true     |    true     |    true     |      5

마지막으로 R , S 및 위의 결과를 사용하여 출력 카드를 만듭니다 .

'A23456789TJQK'[(R += D < C | 2 * ((D < B) + (C < B))) % 13] + S

파이썬 (2) , 143 (140) 138 136 127 125 124 123 121 바이트

lambda(S,V),*l:S+N[F(V)+int(`map(sorted(l,key=lambda(s,v):(F(v),s)).index,l)`[1::3],3)*3/10]
N='23456789TJQKA'*2;F=N.find

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

에이스는 높다

정렬 된 카드 목록에서 위치를 찾아서 세 카드를 인코딩합니다 ( 0=smallest, 1=middle, 2=largest).

cards:   [SK, C4, H4]
sorted:  [C4, H4, SK]

ranks:   [ 2            index of SK in sorted
ranks:   [ 2,  0        index of C4 in sorted
ranks:   [ 2,  0,  1    index of H4 in sorted
ranks:   [ 2,  0,  1] = L,S,M

이것은 기수 3의 정수로 변환되고 3을 곱한 다음 10으로 나뉩니다.

int('201',3) = 19 -> 19*3//10 = 5

다른 인코딩은 다음과 같습니다.

cards            base3    *3   /10
[0, 1, 2]  012     5      15     1
[0, 2, 1]  021     7      21     2
[1, 0, 2]  102     11     33     3
[1, 2, 0]  120     15     45     4
[2, 0, 1]  201     19     57     5
[2, 1, 0]  210     21     63     6

저장 됨 :

• ovs 덕분에 -2 바이트

젤리 , 33 바이트

ØDḊḊ;“TJQKA”p“CDHS”
¢iⱮµḊŒ¿×4+Ḣị¢

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

설명

첫 번째 줄은 나쁘다. 52 장의 카드를 얻습니다

ØDḊḊ;“TJQKA”p“CDHS”
ØD                   Digits: '0123456789'
  ḊḊ                 Dequeue twice: '23456789'
    ;                Append with...
     “TJQKA”         ...the string 'TJQKA': '23456789TJQKA'. These are the ranks
            p        Cartesian product with...
             “CDHS”  ...the suits.
                     This yields the list of all cards in lexicographic order:
                                 ['2C', '2D', '2H', '2S',
                                  '3C', ...         'AS']

기본 링크에서 ¢카드 목록 인 첫 번째 링크의 결과를 호출합니다.

¢iⱮµḊŒ¿×4+Ḣị¢
¢              List of cards
 iⱮ            Index of each (Ɱ) of the inputs in the list.
   µ           New monadic link. The list of indices become this links argument.
    Ḋ          Remove the first one.
     Œ¿        Index of the permutation of the last three items. Gives a number 1-6
               as described in the problem statement.
       ×4      Multiply this by 4 so that when we add to the index of the first
               card we end up in the same suit.
         +Ḣ    Add the first index.
           ị   Use this number to index into...
            ¢  ...the list of cards.

APL (Dyalog Unicode) , 49 바이트 ^SBCS

⊃x⌽⍨⊃i-4×2-⌊1.8⊥⍋1↓i←⎕⍳⍨x←,⍉'CDHS'∘.,2↓⎕D,'TJQKA'

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

개요 : 'CDHS'∘.,2↓⎕D,'TJQKA'외부 곱을 생성하므로를 사용하여 2 차원 행렬을 (C2 C3 C4 ...), (D2 D3 D4 ...), ...만듭니다. 그런 다음이 행렬을 전치하여 (C2 D2 H2 ...), ...평탄화합니다.

@ngn 덕분 2-⌊1.8⊥에 카드 순서 (SML = 1 2 3)를 가져 와서 등급을 매 깁니다 (예 : OP의 1 ~ 6).

코드 설명 :

⊃x⌽⍨⊃i-4×2-⌊1.8⊥⍋1↓i←⎕⍳⍨x←,⍉'CDHS'∘.,2↓⎕D,'TJQKA'
                                       ⎕D,'TJQKA' ⍝ Concatenate a list of numbers with TJQKA
                                     2↓           ⍝ Drop 2 (removes "01")
                                  ∘.,             ⍝ Generate the outer product of this prefixed with
                            'CDHS'                ⍝ The suits
                           ⍉                      ⍝ Invert rows/columns
                          ,                       ⍝ Flatten (matrix -> array)
                        x←                        ⍝ Store in x
                      ⍳⍨                          ⍝ Inverted ⍳⍨: find the indices, in our cards,
                     ⎕                            ⍝ of the argument cards
                   i←                             ⍝ Store these indices in i
                 1↓                               ⍝ Remove the first index
                ⍋                                 ⍝ Grade: get ordered indices
         2-⌊1.8⊥                                  ⍝ The magic happens here: get the number from 1 to 6
       4×                                         ⍝ Multiply by 4 to get the same "back" on the card
    ⊃i-                                           ⍝ Substract the result from our first index (which we had discarded)
⊃x⌽⍨                                              ⍝ (Modulated) Index into x (our cards) with this value

레티 나 , 218208 바이트

[JQK]
1$&
T`AJQK`1123
*' G0`
\d+
5**
' G, 1,`
T`CD\HS`d
\d
*
/^(_+)¶\1/(/¶(_+)¶\1/(K`1
/^(_+)¶_+¶\1/(K`2
))K`4
/^(_+)¶_+¶\1/(K`3
/¶(_+)¶\1/(K`5
)))K`6
\d
$+3-$&
(\d+)-(\d+)
$1*_$2*
_{13}(_+)|(_{1,13})
$.($1$2

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

설명:

[JQK]
1$&
T`AJQK`1123

에이스, 잭, 퀸 및 킹을 1, 11, 12 및 13으로 대체합니다. 첫 두 줄 1은 문자 앞에 a 를 추가 하고 마지막 두 줄 은 두 번째 숫자를 음역합니다.

*' G0`

는 *이 단계가 작업 문자열을 수정할 수 없습니다 것을 나타냅니다. 이로 인해 무대가 무의미 해 보이지만 나중에 유용 할 것입니다. 는 '모든 공간에서 작업 문자열을 분할하고, G0(그것이 첫 번째 카드를 발견 있도록) 첫 번째 걸립니다.

\d+
5**
' G, 1,`'

처음 두 줄은 카드의 숫자에 5를 곱한 다음 단항으로 바꿉니다 (예 : 5는 _____로 표시됨). 나중에 정장에 더 적은 양을 추가 할 수 있습니다. 마지막 줄은 공백으로 분할되고 마지막 세 카드를 유지합니다.

T`CD\HS`d
\d
*

클럽, 다이아몬드, 하트 및 스페이드를 각각 0, 1, 2 및 3으로 변환하고 숫자를 단항으로 바꿉니다. 이제 카드의 숫자 부분에 첨부되었으므로 카드의 고유 한 값을 지정하여 카드의 높이를 결정합니다.

/^(_+)¶\1/(/¶(_+)¶\1/(K`1
/^(_+)¶_+¶\1/(K`2
))K`4
/^(_+)¶_+¶\1/(K`3
/¶(_+)¶\1/(K`5
)))K`6

이것은 카드의 순서와 첫 번째 카드에 추가 할 값을 찾습니다. 예를 들어 첫 번째 줄 /^(_+)¶\1_+/(에서 중간 값이 첫 번째 값보다 큰 주문을 찾습니다. 수행 할 작업에 대해 if-else 루프를 만듭니다 (이 순서는 순열 1, 2 및 4와 일치하므로). K상수를 표시합니다.

\d
$+3-$&

*스테이지가 작업 문자열에 영향을 미치지 않음을 나타내는 데 사용했던 것을 기억 하십니까? 이것이 우리가 사용하는 곳입니다. 이 단계는 교체 단계입니다. 추가 할 숫자를로 바꿉니다 $+3-$&. 스테이지에 $+3액세스하고 *첫 번째 카드의 수와 수를 가져 와서 분리 -자로 작동 $&하며 일치합니다. 이제 작업 문자열은{suit}{original number}-{number to add}

(\d+)-(\d+)
$1*_$2*

이것은 두 숫자를 단항으로 바꾸고 함께 더합니다.

_{13}(_+)|(_{1,13})
$.($1$2

맨 위 줄은 숫자 또는 숫자-13을 캡처합니다 (예 : S16의 출력을 얻지 못함). 결론은 캡처 된 숫자를 다시 밑 10으로 바꾸고 결과는 암시 적으로 인쇄됩니다.

숯 , 64 62 바이트

≔⪪⭆⁺⭆⁸⁺²ιTJQKA⭆CDHS⁺λι²δ≔Ｅ⟦ηζε⟧⌕διυ§δ⁺⌕δθ×⁴⊕⁺∧⌕υ⌊υ⊗⊕¬⌕υ⌈υ‹⊟υ⊟υ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. T10을 사용 하고 A높이 정렬 합니다. 순열 인덱스는 매우 쉽게 해독되지 않았습니다. 다른 순열 순서는 적어도 3 바이트를 절약했을 것입니다. 설명:

⁺⭆⁸⁺²ιTJQKA

0에서 7까지의 모든 정수에 2를 더한 다음 TJQKA그림 카드와 에이스의 접미사와 접미사 를 연결 하십시오. 이것은 문자열 리터럴보다 2 바이트를 절약하지만, A높으면 문자열 압축을 통해 바이트를 저장했을 것입니다.

≔⪪⭆...⭆CDHS⁺λι²δ

카드와 슈트를 매핑하고 두 개를 연결하십시오. 이것은 일반적으로 중첩 배열을 생성하기 때문에 결과는 단일 문자열로 연결된 다음 문자 쌍으로 다시 분할됩니다.

≔Ｅ⟦ηζε⟧⌕διυ

두 번째, 세 번째 및 네 번째 카드의 위치를 ​​찾으십시오.

⊕⁺∧⌕υ⌊υ⊗⊕¬⌕υ⌈υ‹⊟υ⊟υ

1 인덱스 순열 인덱스를 계산합니다. 처음 두 순열은 가장 작은 카드를 먼저 갖습니다. 이것은를 통해 테스트됩니다 ⌕υ⌊υ. 다른 두 쌍의 순열은 가장 큰 카드가 첫 번째인지 여부에 따라 구별됩니다. 이것은를 통해 테스트됩니다 ⌕υ⌈υ. 논리 및 산술 연산은 그 값이 테스트 매핑 0, 2및 4; 그런 1다음를 통해 테스트 한 세 번째와 네 번째 카드의 비교 에 따라 증가합니다 ‹⊟υ⊟υ. 마지막으로 인덱스는 원하는 인코딩을 제공하기 위해 증가합니다.

§δ⁺⌕δθ×⁴...

같은 수의 카드 사이의 거리를 반복하여 4 번 곱하고 첫 번째 카드의 위치를 ​​추가 한 다음 주기적으로 결과를 색인화하고 인쇄하십시오.

파이썬 2 , 147 바이트

lambda a:a[0][0]+R[h(map(a[1:].index,sorted(a[1:],key=lambda c:(I(c[1]),c))))+I(a[0][1])]
R='A23456789TJQK'*2;I=R.index
h=lambda(x,y,z):x*2+(y>z)+1

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

Pyth, 42 바이트

+hhQ@J+`M}2Tmk"JQKA"+hhKm,xJtdhdQhx.pStKtK

정말 못생긴 ...

온라인으로 사용해보십시오 : Demontration 또는 Test Suite

J , 68 바이트

r=.'23456789TJQKA'
{:@{.,~0{r|.~1+(r i.0{{.)+(>,{r;'CDHS')A.@/:@i.}.

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

참고 : f=.카운트하지 않으므로 TIO 바이트는 -3 입니다. 더 골프를 치고 내일 설명을 추가합니다.

자바 스크립트 (Node.js) , 124 바이트

s=>(k='23456789TJQKA')[p=t=>k.search(s[t][0])+32+s[t][1],u=p(0),(u[0]+u[1]-2*(p(1)<p(2))-2*(p(1)<p(3))-(p(2)<p(3)))%13]+u[2]

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

자바 스크립트 (Node.js) , 125 바이트

s=>(k='23456789TJQKA')[p=s.map(t=>k.search(t[0])+32+t[1]),u=p[0],(u[0]+u[1]-2*(p[1]<p[2])-2*(p[1]<p[3])-(p[2]<p[3]))%13]+u[2]

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

T-SQL, 211 바이트

입력은 테이블 변수입니다. T를 10으로 사용하면 에이스가 낮습니다.

카드 순위 / 슈트 형식 KH, 6D, TS

DECLARE @ TABLE(c char(2),i int identity(4,-1))
INSERT @
VALUES('2C'),('AH'),('QS'),('KC')

SELECT
substring(max(h+h),max(charindex(q,h)*w)+power(sum(r)*3,.5)-11,1)+max(right(c,w))
FROM(SELECT*,i%4*power(3,rank()over(order by w,charindex(q,h),c))r
FROM(SELECT*,i/4w,left(c,1)q,'A23456789TJQK'h FROM @)d)y

이 온라인 시도 ungolfed

SML (12-17) 값이 어떻게 계산되는지 확인하십시오.

논리적으로 S, M, L (1,2,3)은 숫자 값으로 변환됩니다

첫 번째 카드는 27 * 시퀀스 값입니다

두 번째 카드는 9 * 시퀀스 값입니다

세 번째 카드는 3 * 시퀀스 값입니다

3을 곱하면, 반올림 된 제곱근이 좋은 순차적 숫자가됩니다.

Order    27,9,3*order=r   sum(r)*3    floor sqrt
S M L -> 1*27+2*9+3*3  -> 162      -> 12
S L M -> 1*27+3*9+2*3  -> 180      -> 13
M S L -> 2*27+1*9+3*3  -> 216      -> 14 
M L S -> 2*27+3*9+1*3  -> 252      -> 15
L S M -> 3*27+1*9+2*3  -> 288      -> 16
L M S -> 3*27+2*9+1*3  -> 306      -> 17

05AB1E , 37 바이트

2TŸ.•3u§•S«.•ôì•âíJuDIkćsD{œJsJk>4*+è

@dylnan 의 Jelly 답변 포트 이지만 불행히도 05AB1E에는 순열 색인이 내장되어 있지 않습니다.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

2TŸ                # Push the list [2,3,4,5,6,7,8,9,10]
   .•3u§•S         # Push compressed string "jqka", converted to a list of characters
          «        # Merge the lists together
.•ôì•              # Push compressed string "cdhs"
     â             # Create each possible pair
      í            # Reverse each pair
       Ju          # Join each pair together, and convert to uppercase
D                  # Duplicate the deck
 Ik                # Get the index of the cards of the input-list in the deck
   ć               # Extract head; pop and push remainder and head
    s              # Swap to get the remainder
     D{            # Create a sorted copy
       œ           # Get the permutations of that
        JsJk       # Get the index of the unsorted permutation in this permutations list
            >      # Increase it by 1 (since 05AB1E has 0-based indexing)
             4*    # Multiply it by 4
               +   # Add it to the extracted head
                è  # And index it into the duplicated deck
                   # (after which the result is output implicitly)

이 05AB1E 광산의 팁을 참조하십시오 (섹션 압축 문자열 사전의 일부에 어떻게? ) 이유를 이해하는 .•3u§•것입니다 "jqka"하고 .•ôì•있다 "cdhs".