गोल्फ एक गोल्फ-स्कोरर

Question

एक बच्चे के रूप में, मैं कार्ड गेम " गोल्फ " को बहुत खेलता था । आपकी चुनौती, क्या आपको इसे स्वीकार करना चाहिए, एक गोल्फ हाथ के स्कोर की गणना करना है। चूंकि इस कार्ड गेम ¹ पर 9000 से अधिक विविधताएं हैं , हम उन नियमों के साथ जाएंगे जिन्हें मुझे याद है।

खेल के नियम)

• आप 6 कार्ड के साथ एक राउंड समाप्त करते हैं, और आप यथासंभव कुछ अंक चाहते हैं।

• जोकर का उपयोग नहीं किया जाता है।

• इक्के और 2 क्रमशः -1, और -2 अंक के लायक हैं।

• जैक और किंग्स दोनों 0 अंक के लायक हैं।

• 3 से 10 तक कार्ड अंकित मूल्य के होते हैं। हालाँकि, जब आप उन्हें बंद करते हैं तो ये रद्द हो जाते हैं। उदाहरण के लिए, एक 5 का मूल्य 5 अंक है, लेकिन दो 5 का मूल्य शून्य है। तीन 5s 5 अंक के लायक हैं, (चूंकि पहले 2 जोड़े हैं, लेकिन 3 नहीं है।) और चार 5s 0 के लायक हैं (क्योंकि यह 2 जोड़े बनाता है)।

• क्वींस 15 अंक के लायक हैं। क्वींस को रद्द नहीं किया जा सकता है, उदाहरण के लिए 2 रानियां 30 अंकों के लायक हैं।

नियम (चुनौती के)

इनपुट एक पूर्णांक, या 6 व्यक्तिगत पूर्णांकों की एक सरणी होगी। जिसे भी आप पसंद करते हैं। 1 एक ऐस का प्रतिनिधित्व करता है, 2-10 2-10 का प्रतिनिधित्व करता है, और जैक, क्वीन, और किंग 11, 12 का प्रतिनिधित्व करता है, और 13. आउटपुट उपरोक्त नियमों के अनुसार हाथ का स्कोर है। आप सुरक्षित रूप से मान सकते हैं कि सभी इनपुट मान्य हैं, उदाहरण के लिए कोई संख्या 4 बार से अधिक नहीं दिखाई देती है, और सभी संख्याएं सीमा में हैं [1, 13]। इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं।

परीक्षण IO:

[11, 10, 3, 1, 2, 2]    --> 8
[4, 5, 5, 3, 8, 7]      --> 22
[2, 2, 2, 2, 1, 1]      --> -10 (The lowest score possible)
[12, 12, 12, 12, 10, 9] --> 79 (The highest score possible)
[9, 9, 9, 9, 11, 1]     --> -1
[8, 8, 8, 8, 11, 13]    --> 0
[10, 9, 3, 7, 12, 2]    --> 42
[1, 2, 3, 4, 5, 6]      --> 15
[10, 9, 2, 3, 4, 1]     --> 23
[10, 3, 12, 3, 7, 12]   --> 47

बाइट्स जीत में सबसे छोटा जवाब!

---

¹ वास्तव में नहीं है, लेकिन बहुत भिन्नताएं हैं।

Answer 1

पायथ, 28 27 25 बाइट्स

s+*L%/Qd2}3Tm?<d3_d*15q12

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

व्याख्या

• सबसे पहले, Pyth कुछ वैरिएबल ऑटो करता है। कोड अब है s+*L%/Qd2}3Tm?<d3_d*15q12dQ।
• }3Tसूची बनाता है [3, 4, 5, 6, 7, 8, 9, 10]।
• *Lइनपुट ( /Qd), मोडुलो 2 ( %… 2) में उस संख्या की गिनती द्वारा उस सूची में प्रत्येक संख्या को गुणा करें ( )। परिणाम युग्मित संख्याओं के लिए 0 है और गैर-युग्मित लोगों के लिए संख्या स्वयं है।
• इनपुट नंबरों पर नक्शा ( m… Q):
  • यदि संख्या 3 से कम है ( ?<d3), तो इसे नकारें ( _d)।
  • अन्यथा जांचें कि क्या यह 12 ( q12d) है, और बूलियन को 15 ( *15) से गुणा करें । परिणाम 15 रानियों के लिए और 0 कुछ और के लिए है।
• सूचियों को समेटना ( +)। परिणामी सूची में अब कुछ अतिरिक्त शून्य के साथ गैर-युग्मित संख्याओं (पहले भाग) और विशेष कार्ड A, 2, Q (दूसरा भाग) के स्कोर शामिल हैं।
• अंत में, परिणाम का योग ( s) लें।

वैकल्पिक 25-बाइट समाधान

-+s*L%/Qd2}3T*15/Q12s<#3Q

यह पहले वाले के समान काम करता है, लेकिन क्वीन्स को अलग से गिनता है और फिल्टर के साथ इक्के और टूक को नकारता है।

Answer 2

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

f=lambda x,*T:[x*(-1)**T.count(x),~x%2*15,-x][(x-3)/8]+(T>()and f(*T))

एक बिंदु पर मैंने चाहा कि पायथन ने 0**0 == 0एक बार इलाज किया ताकि मैं कर सकूं (-condition)**num। जैसे बुलाओ f(11, 10, 3, 1, 2, 2)।

पिछला 72-बाइट संस्करण:

f=lambda x,*T:[~x%2*15,x*(-1)**(x<3or T.count(x))][x<11]+(T>()and f(*T))

Answer 3

> <> , 63 57 56 + 2 = 65 59 58 बाइट्स

इनपुट नंबर प्रोग्राम स्टार्ट पर स्टैक पर होने की उम्मीद है, इसलिए -vध्वज के लिए +2 बाइट्स । इसे ऑनलाइन आज़माएं!

</!?lp6$+1g6:
3\0
?\::6g2%*{+}1+:b=
;\~16g-26g2*-c6gf*+n

जैसा कि कोड फ़ील्ड में सभी अप्रयुक्त मानों को आरंभिक किया जाता है 0, इसका उपयोग यह मानने के लिए किया जा सकता है कि स्टैक पर प्रत्येक मान कितने में मौजूद है, इसे बढ़ाकर [value,6]और कोड फ़ील्ड में वापस डाल दिया जाए। कुल गणना तब की जाती है:

T = 0 + {for x in 3 to 10, x*([x,6]%2)} - [1,6] - 2*[2,6] + 15*[12,6]

संपादित करें: इनपुट के पुनर्गठन और गणना चरणों को चारों ओर घुमाकर गोल्फ 6 बाइट्स बंद करें। पुराना वर्जन:

:6g1+$6pl0=?\
/-*2g62-g610/
c ;n$\
6:b=?/>::6g2%*{+}1+!
\gf*+3/

2 संपादित करें: 1 बाइट बचाया, Sp3000 के लिए धन्यवाद

Comments

मैंने देखा है कि आपने 0=?कुछ समय का उपयोग किया है या इसके समान - क्या आप ?!इसके बजाय उपयोग कर सकते हैं ?

— Sp3000

@ Sp3000 Ack, ज़ाहिर है, आप सही हैं। धन्यवाद, मैं इसमें जोड़ दूंगा

— सोक

Answer 4

MATL , 27 26 बाइट्स

3:10=s2\7M*G12=15*Gt3<*_vs

इनपुट एक कॉलम सरणी है, अर्थात, मान अर्धविराम द्वारा अलग किए जाते हैं।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (यह सभी इनपुट लेने के लिए एक लूप जोड़ता है, और नवीनतम इनपुट को आगे बढ़ाने के लिए बदलता Gहै 1$0G)।

व्याख्या

3:10=    % Take input implicitly. Compare with range [3 4 ... 10], with broadcast
s        % Sum of each column: how may threes, fours, ... tens there are
2\       % Modulo 2
7M       % Push [3 4 ... 10] again
*        % Element-wise multiply (the sum of this array is the score of 3...10)
G        % Push input again
12=      % Compare with 12, element-wise
15*      % Multiply by 15 (this is the score of 12)
G        % Push input again
t3<      % Duplicate. True for entries 1 or 2
*_       % Multiply and negate (the sum of this array is the score of 1, 2)
v        % Concatenate all stack concents into a vertical array
s        % Sum of array. Implicitly display

Answer 5

पायथ - 37 36 35

यह बहुत बड़ा तरीका लगता है, लेकिन FGITW।

J<#h;K-QS2++*15/K12sm*d%/Jd2{J_s@S2

टेस्ट सूट ।

Comments

"यह बहुत बड़ा है, लेकिन FGITW लगता है।" तो यह गोल्फ पहले?

— बिल्ली

मैं इस देखा था नहीं जब तक मैं अपने ही समाप्त हो गया है, लेकिन वे का उपयोग कर को छोड़कर लगभग समान हैं Jऔर Kपूरी तरह से अनावश्यक लगता है, और यह भी आप गोल्फ कर सकते हैं +_करने के लिए -:;) मैं 31 मिला+*15/Q12-sm*d%/Qd2{>#2<#11Qs@S2

— FryAmTheEggman

@FryAmTheEggman 24:+*15/Q12-s*R%/Qd2}3Ts@S2

— जेक्यूब

Answer 6

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

a=>a.map(e=>r+=e<3?-e:e>10?e-12?0:15:(m[e]^=1)?e:-e,r=0,m=[])|r

या यदि आप चाहें,

a=>a.map(e=>r-=e<3?e:e>10?e-12?0:-15:(m[e]^=1)?-e:e,r=0,m=[])|r

Answer 7

पर्ल 5 , 74 +1 ( -a) = 75 बाइट्स

map$s+=/12/?15:$_<3?-$_:$_<11?$k{$_}?-delete$k{$_}:($k{$_}=$_):0,@F;say $s

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

Comments

कमांड लाइन के झंडे अब स्वतंत्र हैं!

— बंजर भूमि

Answer 8

पर्ल 5.10.0 + -n, 115 64 60 56 बाइट्स

$p+=$_-12?$_>2?$_<11?++$l[$_]%2?$_:-$_:0:-$_:15}{say$p

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

स्पष्टीकरण:

-nइसके चारों ओर लूप जोड़ना :

# Used variables:
# $_: input (auto)
# $p: points
# $l[n]: number of occurences of n (for 3-10)
while (<>) { # for every input
    $p += $_ - 12 ? # if the input is not 12 (queen) ...
        $_ > 2 ? # then: if it's > 2 (not ace or 2) ...
            $_ < 11 ? # then: if < 11 (3-10) ...
                ++$l[$_] % 2 ? # then: if it's an odd occurence (1st, 3rd, 5th, ...)
                    $_ # add it
                    : -$_ # else subtract it
            : 0 # no points for other stuff (J, K)
        : -$_ # negative points for ace and 2
    : 15 # 15 points for queen
}
{ # after input:
    say $p # output points
}