स्कोरिंग ब्रिसकोला

Question

परिचय

ब्रिसकोला इटली के सबसे लोकप्रिय कार्ड गेम में से एक है। यह ब्रिज की तरह ट्रिक-टेकिंग कार्ड गेम है। ब्रिसकोला अपने विचित्र बिंदु प्रणाली के लिए अच्छी तरह से जाना जाता है। इस चुनौती में, दो कार्ड दिए गए, आप आउटपुट देंगे कि पहले वाला स्कोर अधिक है, कम है, या ब्रिसकोला के पॉइंट सिस्टम में दूसरे के समान अंक हैं।

चुनौती

Briscola इतालवी खेल कार्ड के एक डेक के साथ खेला जाता है। एक डेक में चालीस कार्ड होते हैं, चार में से प्रत्येक सूट में 1-10: कप, तलवार, क्लब और सिक्के। हम इस चुनौती के लिए सूट की अनदेखी करेंगे। कार्ड 2 - 7 संख्यात्मक कार्ड हैं, और कार्ड 8, 9, और 10 फेस कार्ड हैं। कार्ड की रैंकिंग, उच्चतम से निम्नतम तक, इस प्रकार हैं:

 +------------------------+-------------+
 |     Cards, by Rank     | Point Value |
 +------------------------+-------------+
 | Ace (1)                |     11      |
 | Three (3)              |     10      |
 | King (10)              |      4      |
 | Knight (9)             |      3      |
 | Jack (8)               |      2      |
 | Numeric Cards (2, 4-7) |      0      |
 +------------------------+-------------+

अच्छी तालिका के लिए Orphevs का धन्यवाद! :)

आपका कार्य एक पूर्ण कार्यक्रम या फ़ंक्शन बनाना है जो दो नंबर 1-10 कार्ड रैंक का प्रतिनिधित्व करता है, और आउटपुट (या रिटर्न) स्वीकार करता है कि क्या पहले कार्ड का पॉइंट वैल्यू, पॉइंट के मान से अधिक या उससे कम है दूसरा कार्ड। अतिरिक्त नोट्स:

• आपका प्रोग्राम किसी भी तीन मानों को आउटपुट से कम, अधिक से अधिक, और इसके बराबर इंगित करने के लिए आउटपुट कर सकता है, हालांकि, इसे हर बार प्रत्येक स्थिति के लिए समान मूल्य का उत्पादन करना होगा।
• आपका प्रोग्राम किसी भी IO चूक का उपयोग कर सकता है ।
• मानक खामियों को अस्वीकार कर दिया जाता है।
• या तो एक पूर्ण समारोह या एक कार्यक्रम की अनुमति है।

• यह सवाल कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है।

• यहां कुछ नमूना इनपुट और आउटपुट दिए गए हैं:

   1, 4 => अधिक (इक्का स्कोर 11 अंक, 4 अंक 0 अंक, पहले से अधिक दूसरा है।
   8, 3 => से कम (8 स्कोर 2, 3 स्कोर 10, पहले से कम दूसरा है।
   5, 2 => बराबर (5 और 2 दोनों अंक 0)

यदि आपके कोई प्रश्न हैं, तो पूछने में संकोच न करें। सौभाग्य!

Comments

मैंने हमेशा सोचा था कि स्कोपा का प्राइमेरा अधिक विचित्र था;)

— फ्राईमईएगमैन

@FryAmTheEggman तुम सही हो, मैंने इसे बदल दिया है। इसके अलावा, आपके पास प्राइमेरा के बारे में एक बिंदु हो सकता है ...;)

— उभयलिंगी

क्या हम इनपुट के रूप में दो मूल्यों के साथ एक सरणी ले सकते हैं?

— digEmAll

@digEmAll पक्की बात।

— उभयचर जूल

वह विचित्र नहीं। पुर्तगाली सूका और बिस्का कार्ड गेम्स में बहुत समान स्कोरिंग मौजूद है!

— सर्गियोल

Answer 1

जेली , 12 11 बाइट्स

“®µ½¤¢‘iⱮIṠ

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

• लुइस मेंडो की विधि का उपयोग करके -1 बाइट ।

से अधिक और कम से अधिक के 0लिए बराबर के लिए आउटपुट । उस कोड-पेज इंडेक्स का उपयोग करता है जिसका मूल्यांकन करता है ।-11“®µ½¤¢‘[8, 9, 10, 3, 1]

कार्ड की एक जोड़ी के रूप में इनपुट लेता है। 1,2एक उदाहरण के रूप में उपयोग करें ।

“®µ½¤¢‘iⱮIṠ
“®µ½¤¢‘       [8,9,10,3,1]
       i      index of 
        Ɱ     each element in the input -> 5,0
         I    Finds the forward difference: 0-5 = -5.
          Ṡ   Sign -> -1.
                When ranks are equal, Ṡ returns 0 and when the rank of the second
                card is higher, Ṡ returns 1.

Comments

नाराज नहीं है, लेकिन जो कोई भी नीचे क्यों समझा सकता है?

— डायलन

मामले में यह एक आकस्मिक गिरावट थी - और यह मानते हुए कि यह पिछले संपादन के बाद हुआ है - मैं पद के लिए एक डमी अपडेट करने का सुझाव दूंगा ताकि यह डाउनवॉटर को पता चल सके कि कब / अगर डाउनवॉटर को एहसास हुआ कि कुछ गलत हुआ है।

— अरनुलद

Answer 2

MATL , 12 बाइट्स

[DEXIl]&mdZS

इनपुट दो नंबर की एक सरणी है। आउटपुट है -1, 0और 1के लिए क्रमश: एक से अधिक , के बराबर या कम से कम ।

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

व्याख्या

[1 4]उदाहरण के रूप में इनपुट पर विचार करें ।

[DEXIl]    % Push [8 9 10 3 1]
           % STACK: [8 9 10 3 1] 
&m         % Implicit input. Index (1-based) of membership, 0 if not member
           % STACK: [5 0]
d          % Consecutive difference
           % STACK: -5
ZS         % Sign. Implicit display
           % STACK: -1

Answer 3

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

सिंटैक्स में दो रैंक लेता है (a)(b)। 1 से अधिक के लिए रिटर्न , -1 से कम के लिए या 0 के बराबर ।

a=>b=>Math.sign((s="05040000123")[a]-s[b])

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

---

एक सूत्र का उपयोग करते हुए, 48 बाइट्स

यह निश्चित रूप से लुकअप टेबल का उपयोग करने से अधिक लंबा है, लेकिन थोड़ा और दिलचस्प है।

वही I / O प्रारूप।

a=>b=>Math.sign((g=n=>(1<<n&1802)*6%13)(a)-g(b))

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

कैसे?

$0$$n$ , हम गणना करते हैं:

$$p=2^n\text{ and }(2^1+2^3+2^8+2^9+2^{10})$$ $$p=2^n\text{ and }1802$$

  n (card)   | 2**n | AND 1802
-------------+------+----------
  1 (Ace)    |    2 |      2
  2          |    4 |      0
  3 (Three)  |    8 |      8
  4          |   16 |      0
  5          |   32 |      0
  6          |   64 |      0
  7          |  128 |      0
  8 (Jack)   |  256 |    256
  9 (Knight) |  512 |    512
 10 (King)   | 1024 |   1024

अब हम शेष गैर-शून्य मानों को इस तरह बदलना चाहते हैं कि उन्हें सही क्रम में क्रमबद्ध किया जा सके। हम प्रयोग करते हैं:

$$q=6p \bmod 13$$

    p (card)   |   6p | MOD 13
---------------+------+--------
    2 (Ace)    |   12 |   12
    8 (Three)  |   48 |    9
  256 (Jack)   | 1536 |    2     --> Ace > Three > King > Knight > Jack
  512 (Knight) | 3072 |    4
 1024 (King)   | 6144 |    8

Comments

क्या इस दृष्टिकोण के बारे में चर्चा करी गई मापदंडों का उपयोग करके की गई है? तकनीकी रूप से यह इस चुनौती से मेल नहीं खाता है, क्योंकि आपने जो फ़ंक्शन लिखा है, वह फ़ंक्शन देता है, उत्तर नहीं।

— जूल

@Sparr codegolf.meta.stackexchange.com/a/8427/31625

— FryAmTheEggman

Answer 4

जाप , 25 21 16 बाइट्स

• 1 => से अधिक है
• -1 => से कम है
• 0 => बराबर

---

£"78920"bXÉÃr- g

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

Comments

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

— झबरा

मेरे पास एक 13 बाइट समाधान है ( -gयदि आप इसके लिए प्रयास करना चाहते हैं, तो झंडे का उपयोग करना)।

— झबरा

@ शैग्गी मैं यह नहीं कहूंगा कि दो बाइट्स बचा रहा है, फ्लैग किए गए सबमिशन सिर्फ अलग-अलग भाषा समाधान हैं और शुद्ध जप समाधान के रूप में नहीं गिने जाते हैं।

— लीख

यदि आप ध्वज का उपयोग नहीं करना चाहते हैं, तो मैंने ऊपर बताया समाधान 15 बाइट्स हो जाता है। (संकेत: यह [8,9,10,3,1]सरणी और आधार रूपांतरण का उपयोग करता है )

— झबरा

Answer 5

जाप -g , 13 बाइट्स

के -1लिए >, के 1लिए <और के 0लिए आउटपुट ===।

m!b#ù991ìD)rn

इसे आज़माएँ या कई परीक्षण चलाएँ (दूसरी पंक्ति -gध्वज की कार्यक्षमता की पुष्टि करती है कि झंडे को कई इनपुटों को संसाधित करने के लिए इस्तेमाल किया जा सकता है)

---

व्याख्या

                   :Implicit input of 2 integer array
m                  :Map
   #ù991           :  249991
        ìD         :  Convert to array of base-13 digits = [8,9,10,3,1]
 !b                :  Get the index of the current element in that
          )        :End map
           rn      :Reduce by subtraction
                   :Implicitly output the sign of the result

Answer 6

आर , 35 बाइट्स

rank(c(6,0,5,1:4*0,1:3)[scan()])[1]

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

• -6 बाइट्स @JayCe फंक्शन के बजाय फुल प्रोग्राम में स्विच करने के सुझाव के लिए धन्यवाद

कार्यक्रम के 2लिए 'greater than', के 1लिए 'less than', के 1.5लिए देता है'equal'

स्पष्टीकरण:

      c(6,0,5,1:4*0,1:3)[v]          # extract the score of each card in v (got from scan());
                                     # cards in v are used as indexes in the cards rank 
                                     # vector, which is based on briscola scores vector 
                                     # c(11,0,10,0,0,0,0,2,3,4) but divided by 2 and rounded 
                                     # to integer preserving the original order

rank(                      )[1]      # rank returns : c(1,  2)   if v[1] < v[2]
                                     #                c(2,  1)   if v[1] > v[2]
                                     #                c(1.5,1.5) if v[1] == v[2]
                                     # and we select the first value

Comments

rank(c(6,0,5,1:4*0,1:3)[scan()])[1](पूर्ण कार्यक्रम) आपको 6 बाइट्स

— बचाएगा

@ जय: हाँ, मैंने देखा है कि, लेकिन मैं अभी भी बिल्ली () को जोड़ने की आवश्यकता के बारे में उलझन में हूँ जब यह एक पूर्ण कार्यक्रम है ... वैसे भी, मेरे कोड को अपडेट किया;)

— डाइजेक्सिल

Answer 7

जावा 8, 69 66 बाइट्स

a->b->Math.signum("05040000123".charAt(a)-"05040000123".charAt(b))

लैम्ब्डा currying वाक्य रचना में पैरामीटर लेने, के बंदरगाह Arnauld के जावास्क्रिप्ट जवाब ।

रिटर्न 0.0 के बराबर , 1.0के लिए अधिक से अधिक है, और -1.0के लिए की तुलना में कम । इसे यहाँ ऑनलाइन आज़माएँ ।

3 बाइट गोल्फिंग के लिए केविन क्रूजसेन को धन्यवाद ।

Comments

"05040000123".charAt(...)पूर्णांक-सरणी के बजाय दो बार सीधा रिटर्न करके आप 3 बाइट बचा सकते हैं :a->b->Math.signum("05040000123".charAt(a)-"05040000123".charAt(b))

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

Answer 8

मारियोलेन , 578 548 530 बाइट्स

 )                    <
 ====================="
                   >-[!)
                   "==#)
                >-[!)) )
                "==#=) +
         >-----[!))) + +
         "======#==  + +
     >--[!)))   ++++              -(- <
     "===#===================    ====="
  >-[!)))+++++                    >) [!)+:
; "==#=======================     "===#===
>[!                      )))[!((>[!)[!):
"=#==========================#====#==#===
!;((                         <       >)-:
#============================"       "===

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

स्पष्टीकरण:

• पहला, बड़ा महल एक कार्ड नंबर को इनपुट के रूप में पढ़ता है और इसके समकक्ष बिंदु मान की गणना करता है जब तक कि यह नहीं पढ़ता है0 (इनपुट नहीं) । यह मानता है कि इनपुट के रूप में केवल दो सख्ती से सकारात्मक मूल्य होंगे।
• ध्यान दें कि मैंने वास्तव में उचित बिंदु मान सेट नहीं किए हैं क्योंकि वे आवश्यक नहीं हैं, मैं बस बिंदु मान के बीच एक संख्या निर्धारित करता हूं [1-5] कि गणना करने में मदद करने के लिए कि किस कार्ड में सबसे अधिक बिंदु मान हैं।
• दूसरा, छोटा महल सिर्फ दो गणना बिंदु मानों की तुलना करता है।
• यह रिटर्न 1अगर पहला बिंदु मूल्य, दूसरा एक से अधिक है -1, तो दूसरी बात मूल्य पहले एक से अधिक है, और 0अगर अंक मान ही हैं।

Answer 9

अजगर २ , 41 बाइट्स

1 से अधिक के लिए आउटपुट, -1 से कम के लिए, 0 के बराबर।

lambda a,b:cmp(s[a],s[b])
s="05040000123"

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

Answer 10

सी (जीसीसी) , 57 बाइट्स

क्रमशः <, = और> के लिए सामान्य [-1..1] देता है।

char*s="-FAEAAAABCD";f(a,b){a=s[a];b=s[b];b=(a>b)-(a<b);}

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

Comments

के *s=L"...बजाय char*s="...और के a=(s[a]>s[b])-(s[a]<s[b])बजायa=s[a];b=s[b];b=(a>b)-(a<b)

— छत

Answer 11

05AB1E , 14 बाइट्स

ε78920S>sk}`.S

रिटर्न 1, -1या 0से अधिक के लिए; से कम; या बराबर क्रमशः।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ε              # Loop over the input-array
 78920S>       #  Convert 78920 to a list of digits, and increase each by 1,
               #  resulting in [8,9,10,3,1]
        sk     #  Index this list with the input-number (-1 if not found)
               #   i.e. [1,4] → [4,-1]
          }    # Stop the loop
`              # Put all items of the now mapped list separated onto the stack
 .S            # Take the signum (1 if a>b; -1 if a<b; 0 if a==b)
               #  i.e. 4 and -1 → 1

Answer 12

PHP , 51 45 बाइट्स

<?=($m=_5040000123)[$argv[1]]<=>$m[$argv[2]];

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

इसे चलाने के लिए:

php -n <filename> <card1> <card2>

उदाहरण:

php -n briscola_score.php 3 1

नोट: यह कोड PHP 7 के स्पेसशिप ऑपरेटर का उपयोग करता है । तो यह 7 से पहले किसी भी PHP संस्करण पर काम नहीं करेगा।

---

आउटपुट:

• 1 = से अधिक ( card1 > card2)
• 0 = बराबर ( card1 == card2)
• -1 = से कम ( card1 < card2)

---

कैसे?

कई अन्य उत्तरों में प्रयुक्त दृष्टिकोण के समान, लेकिन PHP में। कार्ड के लिए एक मान मानचित्र बनाता है और कार्ड के मूल्यों की तुलना करता है। मानचित्र में मूल्य की स्थिति कार्ड संख्या के समान है।

Answer 13

जावास्क्रिप्ट ES2016 +, 73 वर्ण

सबसे छोटा नहीं है, लेकिन मुझे गणित और अतिप्रवाह के कारण दिलचस्प उम्मीद है :)

(x,y)=>Math.sign((x&8?x:(16-(x**40|0)%7)^16)-(y&8?y:(16-(y**40|0)%7)^16))

और दुर्भाग्यवश 74 वर्णों वाला दूसरा संस्करण:

(x,y)=>eval('(x>y)-(x<y)'.replace(/\w/g,'($&&8?$&:(16-($&**40|0)%7)^16)'))

परीक्षा

चलाने से पहले ब्राउज़र कंसोल खोलें

f=(x,y)=>Math.sign((x&8?x:(16-(x**40|0)%7)^16)-(y&8?y:(16-(y**40|0)%7)^16))
console.table(Array(11).fill().map((x,i)=>Array(11).fill().map((x,j)=>f(i,j))))