5-कार्ड मैजिक ट्रिक में एक जादूगर शामिल होता है जिसका सहायक उन्हें इस क्रम में 4 दिखाए गए कार्ड और एक छिपा हुआ सामान देता है, और जादूगर को छिपे हुए व्यक्ति का अनुमान लगाना चाहिए।

चेतावनी: नीचे समाधान! अब छोड़ो या इसके साथ खराब हो जाओ।

समाधान

यहाँ चाल यह है कि पाँच कार्ड एक विशिष्ट क्रम में दिए गए हैं !

$c_1,...,c_5$ दिए गए क्रम में 5 कार्ड हैं।

$x_n$ , (संख्या क्रम)में $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$ s' $NO$ में कार्ड नंबर।

$a>b$ है, जहां $a$ और $b$ कार्ड हैं, अगर सही है $a<b$ गलत है।

$PI(a,b,c)$ , जहां $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-कार्ड जादू चाल का हल है समस्या है:

c_{5} = (x_{1} + P I (c_{2}, c_{3}, c_{4})) \circ s_{1}

$c_5=(x_1+PI(c_2,c_3,c_4))\circ s_1$

चुनौती

अब तक सब ठीक है। हालाँकि, ऊपर निर्दिष्ट संगणना करने से पहले से ही यहाँ के लिए कहा गया है । इसके बजाय, आपकी चुनौती यह है कि 5 कार्डों को बिना किसी विशिष्ट क्रम में दिए, उन्हें ठीक से ऑर्डर करने के लिए। इसका मतलब है कि आउटपुट में पहले चार कार्ड पांचवें का प्रतिनिधित्व करेंगे। दूसरे शब्दों में, सहायक बनें। आवश्यकताएँ:

$s_5=s_1$ ।
$x_5=x_1+PI(c_2,c_3,c_4)$ (अर्थात यह संभव होना चाहिए)।

उदाहरण

आइए सेट पर विचार करें 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

बाद में, चूंकि सूट समान होना चाहिए, एक जोड़ी में अलग-अलग सूट एक नहीं है:

अंत में, हम जाँचते हैं कि शेष जोड़े में से आधे को हटाते हुए, पहले कार्ड से दूसरे में अधिकतम 6 जोड़कर प्राप्त करना संभव है:

अब हमारे पास वैध जोड़े हैं: 2D,6Dऔर 5C,6C। प्रत्येक जोड़ी का पहला कार्ड कार्ड 1 है, जबकि अंतिम कार्ड 5 है।

हम 5C,6Cयहां आसानी के साथ जाने वाले हैं। पूरा सेट है 7H,2D,6D,5C,6C, इसलिए, हमारे द्वारा चुनी गई जोड़ी में 2 कार्ड निकालकर, हमारे पास है 7H,2D,6D। ये कार्ड प्रतिनिधित्व करेंगे 6 - 5 = 1, इसलिए हमें उन्हें "न्यूनतम, मध्य, अधिकतम" की तरह ऑर्डर करना होगा। 7H > 2D < 6D < 7H, या बस 2D < 6D < 7H, इसलिए अब हमारे पास है 2D,6D,7H।

अंतिम चरण यह सब एक साथ रखना है, इसलिए हमारा परिणाम होगा 5C,2D,6D,7H,6C।

स्पष्टीकरण

आप उपयोग कर सकते हैं 10के बजाय T।
आप में से एक का उपयोग कर सकते ♠♥♦♣, ♤♡♢♧या ♠♡♢♣के बजाय CDHS, क्रमशः।
यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

आप प्रत्येक परीक्षण मामले के लिए शामिल वैध समाधानों में से एक या अधिक आउटपुट कर सकते हैं।

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

code-golf card-games

— आउटगोल्फ को एरिक करें
स्रोत

उदाहरण कॉलम जोड़कर क्रमपरिवर्तन की कल्पना करना आसान हो सकता है ।

— अरनौल्ड

जादू - एक पाँच कार्ड चाल - यह कैसे काम करता है? - Puzzling Stack Exchange

— user202729

इनपुट कितना उदार है? क्या लंबाई -2 तार के बजाय कार्ड नंबर और घर के टुपल्स स्वीकार्य हैं?

— Οurous

@ @Urous यह चुनौती में निर्दिष्ट नहीं है; जब तक यह उचित है (आपके मामले में, जो उचित लगता है), इसकी अनुमति है।

— आउटगोल्फ

3

नोड.जेएस , 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]$

$A$ $B$
तुलना करें $A$ $C$
$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$

d = ((k xor 4) mod 6) + 1

$d=((k\operatorname{xor}4)\bmod 6)+1$

  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

— Arnauld
स्रोत

1

पायथन 3 , 260 248 232 बाइट्स

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)

इसे ऑनलाइन आज़माएं!

-12 बाइट्स एरिक आउटगॉल्फर -14 बाइट्स के लिए धन्यवाद
एक सूची समझ को हटाकर

— काला उल्लू काई
स्रोत

0

क्लीन , 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

— Οurous
स्रोत

0

रूबी , 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

— स्तर नदी सेंट
स्रोत

0

जेली , 41 बाइट्स

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

एक मोनडिक लिंक एक ही प्रारूप में सभी वैध व्यवस्था की सूची लौटाने वाले पात्रों की सूची की एक सूची को स्वीकार करता है।

इसे ऑनलाइन आज़माएं! (पाद लेख एक पूर्ण प्रोग्राम के रूप में चलाने पर लिंक के कोड द्वारा किए गए निहित स्मैशिंग प्रिंट से बचने के लिए ग्रिड के रूप में परिणाम को प्रारूपित करता है)

या एक परीक्षण-सूट देखें ।

मेरे पास एक डराने वाला संदेह है एक और दृष्टिकोण बहुत अधिक होगा। मुझे इस चुनौती को बाद में फिर से देखना होगा!

... हम्म, मैं चारों ओर एक और प्रहार था और एक और 41 बटर ( परीक्षण ) मिला:

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

— जोनाथन एलन
स्रोत

MIT में प्रोफेसर को AP की जरूरत है!

चेतावनी: नीचे समाधान! अब छोड़ो या इसके साथ खराब हो जाओ।

समाधान

चुनौती

उदाहरण

स्पष्टीकरण

परीक्षण के मामलों

नोड.जेएस , 190 186 180 बाइट्स

कैसे?

कार्ड नंबरों की पहचान करना और उनकी तुलना करना

इनपुट के क्रमपरिवर्तन उत्पन्न करना

सूट का परीक्षण

दूरी का परीक्षण

पायथन 3 , 260 248 232 बाइट्स

क्लीन , 225 220 209 बाइट्स

रूबी , 175 बाइट्स

जेली , 41 बाइट्स