यह कार्य प्रो। देवदास द्वारा एक एमआईटी व्याख्यान से लिया गया है जिसे आप मन पढ़ सकते हैं । लिंक में, या इस दस्तावेज़ में चाल की एक विस्तृत व्याख्या पाई जा सकती है । मैं इसे सरल शब्दों में समझाने की कोशिश करूँगा।

यह पता चला है कि यह 1930 के दशक में आविष्कार किया गया था, और "फिच चेनी के पांच-कार्ड चाल" के रूप में जाना जाता है ।

चाल इस प्रकार है:

पांच यादृच्छिक कार्ड कार्ड के एक डेक से चुने जाते हैं। दर्शकों और आपके सहायक को उन्हें देखने के लिए मिलता है, लेकिन आप नहीं।
आपके सहायक (जिनके साथ आपने अभ्यास किया है) उन कार्डों में से चार का चयन करेंगे और उन्हें एक विशिष्ट क्रम में आपको दिखाएंगे। ध्यान दें कि छिपे हुए कार्ड को 5 कार्डों से यादृच्छिक रूप से नहीं लिया गया है। सहायक एक / कार्ड लेता है जो चाल को काम करेगा।
आप कटौती करेंगे, जानकारी के आधार पर आप चार कार्डों से इकट्ठा कर सकते हैं कि पांचवा कार्ड क्या है।

कैसे?

निम्नलिखित दो बिंदुओं को ध्यान में रखें:

5 यादृच्छिक कार्ड चुनते समय, आपको गारंटी दी जाती है कि कम से कम दो कार्डों में एक ही सूट ^{1 है} ।
नीचे दी गई छवि सभी रैंकों के साथ एक सर्कल दिखाती है ² । चूंकि यह एक चक्र है, इसलिए इसे गिनना संभव है: जे, क्यू, के, ए, 2, 3 (यानी मॉड्यूलर गिनती)। आपको गारंटी दी जाती है कि छिपे हुए कार्ड में पहले जैसा रैंक नहीं है, क्योंकि वे एक ही सूट के होंगे (नीचे समझाया गया है)। हमेशा पहला कार्ड और छिपे हुए कार्ड का चयन करना संभव होता है, जैसे कि छिपा हुआ कार्ड 1 और 6 रैंक के बीच पहले की तुलना में अधिक होता है (जब मंडलियों में गिनती होती है)। यदि पहला कार्ड 1 है , तो छिपा कार्ड 2,3,4,5,6 या 7 होगा । यदि पहला कार्ड जे है , तो छिपा कार्ड क्यू, के, ए, 2,3 या 4 और इसी तरह होगा।

एल्गोरिथ्म:

पहला कार्ड: इस कार्ड में छिपे कार्ड की तरह ही सूट होगा। कार्ड भी संदर्भ बिंदु होगा जिसका उपयोग आप छिपे हुए कार्ड की रैंक का पता लगाने के लिए करेंगे।

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 क्यू 7 (वे एसएलएम के आदेश दिए गए हैं ) हैं, तो अंतिम कार्ड की रैंक 5 + 2 = 7 है । आप चुन सकते हैं कि इक्का उच्चतम या निम्नतम कार्ड होना चाहिए, जब तक यह सुसंगत हो।

यदि कई कार्ड रैंक साझा करते हैं, तो सूट आदेश का निर्धारण करेगा, जहां सी <डी <एच <एस ।

इनपुट प्रारूप:

चार कार्ड H3 (तीन दिल), डीके (हीरे के राजा) और इतने पर दिए जाएंगे । आप इनपुट को 3H और KD के बजाय दूसरे तरीके से लेने का विकल्प चुन सकते हैं ।

इनपुट किसी भी सुविधाजनक प्रारूप पर हो सकता है, लेकिन आप एक चर में सूट की सूची और दूसरे में रैंक की सूची को जोड़ नहीं सकते। 'D5', 'H3' ..और [['D',5],['H',3] ...दोनों ठीक हैं, लेकिन 'DHCH',[5,3,1,5]नहीं है। T को छोड़कर आप अक्षरों के बजाय संख्याओं का उपयोग नहीं कर सकते ।

उत्पादन

छिपे हुए कार्ड, इनपुट के समान प्रारूप में।

उदाहरण

चलो एक walkthrough करते हैं:

Input:
D3 S6 H3 H9

हम जानते हैं कि छिपा हुआ कार्ड एक हीरा है, क्योंकि पहला कार्ड एक हीरा है। हम यह भी जानते हैं कि रैंक है 4,5,6,7,8 या 9 के बाद से पहली कार्ड के रैंक है 3 ।

शेष कार्ड 6,3,9 ==> एम, एस, एल के आदेश दिए गए हैं , जो मान 3 को एन्कोड करता है । छिपा हुआ कार्ड इसलिए हीरे का 3 + 3 = 6 है, इस प्रकार आउटपुट डी 6 होना चाहिए ।

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

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

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम समाधान जीतता है। स्पष्टीकरण को प्रोत्साहित किया जाता है!

¹ चार सूट हैं ( C lubs, D iamonds, H earts and S pades)।

² 13 रैंक, 2,3,4,5,6,7,8,9,10, J, Q, K, A हैं । आप 10 के बजाय T का उपयोग करना चुन सकते हैं ।

code-golf card-games encode

— स्टीवी ग्रिफिन
स्रोत

17

जावास्क्रिप्ट (ईएस 6), 130 102 बाइट्स

"Rs"प्रारूप में तार के एक सरणी के रूप में इनपुट लेता है , जहां आर रैंक है और एस सूट है। 10 के लिए "टी" की अपेक्षा करता है । इक्के कम हैं।

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

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

कैसे?

हम पहले प्रत्येक कार्ड को एक सरणी [रैंक, कार्ड] में बदल देते हैं, जहां रैंक [14 ... 26] में एक संख्यात्मक मान होता है और कार्ड मूल स्ट्रिंग है।

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

पहले कार्ड का रैंक और सूट क्रमशः आर और एस में संग्रहीत किया जाता है। तीन अन्य कार्ड बी , सी और डी में संग्रहित हैं ।

उदाहरण के लिए, ['3c','6h','6c','2s']बन जाता है:

[ [ 16, '3c' ], [ 19, '6h' ], [ 19, '6c' ], [ 15, '2s' ] ]
    ^^    ^     <---------->  <---------->  <---------->
    R     S          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

— Arnauld
स्रोत

आपका संस्करण बेकार नहीं है, यह सिर्फ आधार और शक्ति का गलत विकल्प है! का प्रयोग करें 92427**3और संशोधित k+7करने के लिए k+8: 1 बाइट को बचाने के लिए

a=>(k='A23456789TJQK'+92427**3)[[[r,s],...x]=a.map((c,i)=>[k.search(c[0])+10,c[1],i]),(r-k[x.sort().map(c=>k=k*2|c[2])|k+8])%13]+s

— asgallant

187**97और k+15यह भी काम करता है, लेकिन मुझे पूरा यकीन है कि वे केवल दो सेट हैं जो इस एल्गोरिथ्म के लिए छोटे हैं।

— asgallant

@asgallant अच्छा लगा!

— अरनौल

@asgallant के 1/34547साथ k+14भी काम करता है।

— अरनौल

15

पायथन 2 , 143 140 138 136 127 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

बचाया:

-2 बाइट्स, ओव्स के लिए धन्यवाद

— TFeld
स्रोत

मैंने सोचा कि जब मैं चुनौती लिखता हूं, तो मैं इसे एक टर्नरी दृष्टिकोण का उपयोग करके कैसे हल कर सकता हूं, लेकिन मैंने इसे करने का एक अच्छा तरीका नहीं निकाला ... गुणा करके 3चतुर था! अच्छा जवाब :)

— स्टीवी ग्रिफिन

@StewieGriffin धन्यवाद :) अब मैं 0अंत में एक जोड़ देता हूं और 10 से विभाजित करता हूं , जो बराबर दिखता है।

— टीफिल्ड

1

@Arnauld। मैंने विवरण को अपडेट किया है उम्मीद है कि यह थोड़ा स्पष्ट कर देगा कि मैं क्या कर रहा हूं।

— TFeld

10

जेली , 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.

— dylnan
स्रोत

1

आप 1इक्का के लिए उपयोग नहीं कर सकते ।

— एग्रीकल्चर से एरिक

@EriktheOutgolfer ने वापस A

— dylnan

आप बाइट बचाने के लिए रजिस्टर का उपयोग कर सकते हैं

— जोनाथन एलन

5

एपीएल (Dyalog यूनिकोड) , 49 बाइट्स ^SBCS

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

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

अवलोकन: 'CDHS'∘.,2↓⎕D,'TJQKA'बाहरी उत्पाद उत्पन्न करता है, इसलिए 2d मैट्रिक्स के साथ (C2 C3 C4 ...), (D2 D3 D4 ...), ...। हम फिर इस मैट्रिक्स को प्राप्त करने के लिए स्थानांतरित करते हैं (C2 D2 H2 ...), ...और फिर उसे समतल करते हैं।

@Ngn के लिए धन्यवाद 2-⌊1.8⊥, जो कार्ड के आदेश (SML = 1 2 3) लेता है और उन्हें ग्रेड देता है (जैसे ओपी में 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

— Ven
स्रोत

4

रेटिना , 218 208 बाइट्स

[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पत्र से पहले प्रीपेंड होती हैं , और अंतिम दूसरे अंक को बदल देती है।

*' 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_+/(आदेशों से मेल खाता है जिनका मध्य मान पहले मान से बड़ा है। यह क्या करना है के लिए एक और लूप बनाता है (जैसा कि यह आदेश क्रमपरिवर्तन 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 में बदल देती है, और परिणाम अंतर्निहित रूप से मुद्रित होता है।

— lolad
स्रोत

फिक्स्ड! मैंने एक रेगेक्स को उलट दिया ताकि यह 13 से अधिक संख्याओं को प्राथमिकता दे

— लोलद

3

चारकोल , 64 62 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। T10 के लिए उपयोग करता है और Aउच्च प्रकार । क्रमचय सूचकांक बहुत आसानी से डिकोड नहीं किया गया था; एक अलग क्रमांकन आदेश ने मुझे कम से कम तीन बाइट्स बचाए। स्पष्टीकरण:

⁺⭆⁸⁺²ιTJQKA

2 से 7 तक सभी पूर्णांकों को जोड़ें, फिर उन्हें समेटें और TJQKAचित्र कार्ड और इक्का के लिए प्रत्यय दें । यह एक स्ट्रिंग शाब्दिक पर 2 बाइट्स बचाता है, हालांकि यह पता चलता है कि Aउच्च होने से वैसे भी स्ट्रिंग संपीड़न के माध्यम से बाइट को बचाया जा सकता है।

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

कार्ड और सूट पर नक्शा, दोनों को एक साथ समेटना। चूंकि यह सामान्य रूप से एक नेस्टेड सरणी का उत्पादन करेगा, इसलिए परिणाम इसके बजाय एक ही स्ट्रिंग में समाप्‍त हो जाते हैं जो बाद में फिर से वर्णों के जोड़े में विभाजित हो जाते हैं।

≔Ｅ⟦ηζε⟧⌕διυ

दूसरे, तीसरे और चौथे कार्ड के पदों का पता लगाएं।

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

1-अनुक्रमित क्रमबद्धता सूचकांक की गणना करें। पहले दो क्रमपरिवर्तन में सबसे छोटा कार्ड है; इसके माध्यम से परीक्षण किया जाता है ⌕υ⌊υ। क्रमपरिवर्तन के अन्य दो जोड़े इस रूप में विभेदित हैं कि क्या सबसे बड़ा कार्ड पहले है; इसके माध्यम से परीक्षण किया जाता है ⌕υ⌈υ। तार्किक और अंकगणितीय संचालन फिर इन परीक्षणों को मूल्यों पर मैप करते हैं 0, 2और 4; इसके बाद इसमें वृद्धि होती है1 तीसरे और चौथे कार्ड के बीच तुलना के आधार पर‹⊟υ⊟υ । अंत में वांछित एन्कोडिंग देने के लिए सूचकांक को बढ़ाया जाता है।

§δ⁺⌕δθ×⁴...

गुणा करें कि 4 एक ही सूट के कार्ड के बीच की दूरी को दोहराते हुए, पहले कार्ड की स्थिति पर जोड़ दें, और चक्रीय रूप से सूचकांक करें और परिणाम प्रिंट करें।

— नील
स्रोत

2

पायथन 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

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

— चास ब्राउन
स्रोत

144 बाइट्स

— ओव

2

पायथ, 42 बाइट्स

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

वास्तव में बदसूरत ...

इसे ऑनलाइन आज़माएँ: डेमोंट्रेशन या टेस्ट सूट

— Jakube
स्रोत

2

जे , 68 बाइट्स

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

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

नोट: TIO बाइट्स -3 बंद क्योंकि f=.गिनती नहीं है। आगे गोल्फ का प्रयास करेंगे और कल स्पष्टीकरण देंगे।

— जोनाह
स्रोत

1

जावास्क्रिप्ट (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]

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

— l4m2
स्रोत

1

टी-एसक्यूएल, 211 बाइट्स

इनपुट एक तालिका चर है। 10 के लिए टी का उपयोग करना, इक्के कम हैं

कार्ड रैंक / सूट केएच, 6 डी, टीएस के लिए प्रारूप

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

इसे ऑनलाइन अनऑर्गलाइज्ड आज़माएं

ध्यान दें कि 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

— t-clausen.dk
स्रोत

1

05AB1E , 37 बाइट्स

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

पोर्ट ऑफ @dylnan के जेली उत्तर , लेकिन दुर्भाग्य से 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"।

— केविन क्रूज़सेन
स्रोत

MIT में प्रोफेसर पढ़ सकते हैं दिमाग!

कैसे?

एल्गोरिथ्म:

इनपुट प्रारूप:

उत्पादन

उदाहरण

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

जावास्क्रिप्ट (ईएस 6), 130 102 बाइट्स

कैसे?

पायथन 2 , 143 140 138 136 127 127 125 124 123 121 बाइट्स

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

एपीएल (Dyalog यूनिकोड) , 49 बाइट्स SBCS

रेटिना , 218 208 बाइट्स

चारकोल , 64 62 बाइट्स

पायथन 2 , 147 बाइट्स

पायथ, 42 बाइट्स

जे , 68 बाइट्स

जावास्क्रिप्ट (Node.js) , 124 बाइट्स

जावास्क्रिप्ट (Node.js) , 125 बाइट्स

टी-एसक्यूएल, 211 बाइट्स

05AB1E , 37 बाइट्स

एपीएल (Dyalog यूनिकोड) , 49 बाइट्स ^SBCS