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

चुनौती: स्कोपा के एक दौर में बनाए गए अंकों की संख्या का पता लगाना, कार्ड को राउंड के दौरान कैप्चर किए गए खिलाड़ी को इनपुट के रूप में दिया गया।

एक स्कोपा डेक में 40 कार्ड हैं। यदि आप एक अंतरराष्ट्रीय डेक का उपयोग कर रहे हैं, तो आप प्रत्येक सूट में ए, 2,3,4,5,6,7, क्यू, जे, के को छोड़कर 8, 9 और 10 एस हटाते हैं। ¹ दो खिलाड़ी या साझेदारियां होती हैं और हर दौर के बाद सभी कार्ड एक या दो खिलाड़ियों के कब्जे में होते हैं। स्कोर इस प्रकार गिना जाता है (अधिक जानकारी यहाँ ):

सबसे कार्ड 1 अंक के साथ खिलाड़ी ।
सबसे हीरे (या सिक्के के साथ खिलाड़ी अगर इतालवी डेक का उपयोग करके) स्कोर 1 अंक।
7 हीरे (या सिक्के) के साथ खिलाड़ी , सेटेलो या सुंदर सात के रूप में जाना जाता है , स्कोर 1 अंक।
सर्वोच्च प्राइमेरा स्कोर 1 अंक के साथ खिलाड़ी । किसी खिलाड़ी का प्राइमेरा स्कोर उच्चतम मूल्य वाले कार्ड के अंकों का योग होता है जिसे खिलाड़ी प्रत्येक सूट में कैप्चर करता है (नीचे तालिका देखें)। यदि आपके पास प्रत्येक सूट में कम से कम एक कार्ड नहीं है, तो आप डिफ़ॉल्ट रूप से हार जाते हैं, भले ही आपका स्कोर आपके प्रतिद्वंद्वी के स्कोर से अधिक हो। इस दुर्लभ मामले में कि न तो खिलाड़ी के पास हर सूट में कम से कम एक कार्ड होता है, उच्च प्राइमेरा कुल वाले खिलाड़ी का स्कोर होता है। ²

प्राइमेरा स्कोर की तालिका

| Rank  | Value |
| ----- | ----- |
| 7     | 21    |
| 6     | 18    |
| A     | 16    |
| 5     | 15    |
| 4     | 14    |
| 3     | 13    |
| 2     | 12    |
| Q,J,K | 10    |

इसलिए एक खिलाड़ी एक दौर में अधिकतम 4 अंक हासिल कर सकता है। ³ यदि कोई टाई है, जो कार्ड, हीरे, या प्राइमरी के लिए संभव है , तो कोई भी स्कोर नहीं करता है।

यह महसूस करना महत्वपूर्ण है कि चूंकि प्रत्येक कार्ड को दो खिलाड़ियों में से एक द्वारा कब्जा किया जाना चाहिए, इसलिए आप यह पता लगा सकते हैं कि दूसरे खिलाड़ी ने कौन से कार्ड लिए होंगे, भले ही आपको पता हो कि एक खिलाड़ी ने कौन से कार्ड लिए थे। प्राइमेरा को सही ढंग से स्कोर करने के लिए आपको यह करने की आवश्यकता होगी ।

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

इनपुट

आपके कोड को स्कोपा के एक दौर के दौरान एकल खिलाड़ी द्वारा पकड़े गए कार्ड के इनपुट के रूप में लेना चाहिए।

इनपुट स्ट्रिंग प्रारूप में होना चाहिए, जिसमें एक वर्ण प्रत्येक कार्ड की रैंक और एक वर्ण उसके सूट का प्रतिनिधित्व करता है। यहसीधे इनपुट के रूप में प्राइमेरा स्कोरपास करने के संभावित खामियों को दूरकरता है। कार्यक्रम में कार्ड रैंकों को प्राइमेरा स्कोर में बदलना चाहिए। हालाँकि आप रिक्त स्थान या अल्पविराम, स्ट्रिंग की एक सरणी या किसी अन्य प्रारूप द्वारा अलग किए गए एकल स्ट्रिंग का उपयोग करना चुन सकते हैं। उदाहरण के लिए यदि आप रैंकों को सांकेतिक शब्दों में बदलना76A5432QJKऔर सूटDCHSकरना चाहते हैं जैसे कि आप इनपुट का उपयोग कर सकते हैं जैसे कि['7D', '6H', 'QD', 'JS']या'7D,6H,QD,JS'।

उत्पादन

खिलाड़ी के स्कोर का प्रतिनिधित्व करते हुए 0 से 4 तक का पूर्णांक।

जीतना

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

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

["7D", "6D", "AD", "5D", "4D", "3D", "2D", "QD", "7C", "6C", "4C", "3C", "2C", "7H", "4H", "2H", "5S", "3S", "QS", "JS", "KS"]

स्कोर 4 : 1 पॉइंट> 20 कार्ड, 1 पॉइंट फॉर> 5 डायमंड्स, 7 पॉइंट ऑफ़ डायमंड्स, और 1 पॉइंट फ़ॉर प्राइमेरा 78 (7,7,7,5 जहाँ विरोधी में 7,6,5 है, आदि। 64 के लिए के)

["3D", "7C", "6C", "AC", "5C", "4C", "3C", "2C", "QC", "4H", "7S"]

स्कोर 0 : <= 20 कार्ड, <= 5 हीरे, हीरे का कोई 7 नहीं, और केवल प्राइमेरा में 69 (7,7,4,3 जहां प्रतिद्वंद्वी में 7,7,6, 70 के लिए K है)

[7D", "6D", "AD", "5D", "4D", "3D", "2D", "7C", "6C", "AC", "5C", "4C", "3C", "2C", "7H", "6H", "AH", "5H", "4H", "3H", "2H"]

स्कोर 3 : 1 पॉइंट> 20 कार्ड, 1 पॉइंट फॉर> 5 डायमंड्स, 1 पॉइंट ऑफ़ 7 डायमंड्स। Primiera 63 (7,7,7) होगा और प्रतिद्वंद्वी केवल स्कोर कर सकते हैं 51 (7, क्यू, क्यू, क्यू), लेकिन यह डिफ़ॉल्ट रूप से बिंदु खो देता है के बाद से इस हाथ कोई हुकुम है।

["7D", "6D", "AD", "5D", "4D", "3D", "2D", "QD", "JD", "KD", "QC", "QH", "QS"]

स्कोर 3 : <= 20 कार्ड, 1 अंक के लिए> 5 हीरे, हीरे के 7 के लिए 1 अंक। Primiera केवल स्कोर 51 (7, क्यू, क्यू, क्यू) और प्रतिद्वंद्वी स्कोर कर सकते हैं 63 (7,7,7), लेकिन यह हाथ जीतता है के बाद से प्रतिद्वंद्वी के हाथ कोई हीरे है primiera डिफ़ॉल्ट रूप से बिंदु।

["7D", "6D", "AD", "5D", "4D", "3D", "2D", "QD", "JD", "KD", "7C", "7H"]

स्कोर 3 : <= 20 कार्ड, 1 अंक के लिए> 5 हीरे, हीरे के 7 के लिए 1 अंक। भले ही इस हाथ में कोई हुकुम न हो, फिर भी यह प्राइमेरा को 63 से 57 (7,7,7 बनाम 7,6,6) के स्कोर से जीतता है क्योंकि प्रतिद्वंद्वी के हाथ में कोई हीरा नहीं है।

["7D", "6D", "AD", "5D", "4D", "3D", "2D", "QD", "JD", "KD", "QC", "QH"]

स्कोर 2 : <= 20 कार्ड, 1 अंक> 5 हीरे के लिए, 1 बिंदु 7 हीरे के लिए। इस हाथ में कोई हुकुम नहीं है, और प्रतिद्वंद्वी के हाथ में कोई हीरा नहीं है। प्रतिद्वंद्वी जीतता primiera 41 63 के स्कोर से (बनाम 7,7,7 7, क्यू, क्यू)।

[] (खाली सरणी)

स्कोर 0

^{1: कम से कम हमारे परिवार में, जैक स्कोपा में रानी का अपमान करता है, लेकिन यह स्कोरिंग उद्देश्यों के लिए अप्रासंगिक है।}

^{2: मैं बचपन से इस खेल को खेल रहा हूँ और ऐसा कभी नहीं देखा है, लेकिन आपका कोड उस मामले को संभालने में बेहतर था!}

^{3: राउंड के दौरान बनाए गए "स्वीप्स" के लिए बोनस अंक हैं जिन्हें मैं इस चुनौती के उद्देश्य के लिए अनदेखा कर रहा हूं।}

code-golf card-games

— qdread
स्रोत

1

क्या प्रत्येक रैंक को एक अलग चरित्र द्वारा दर्शाया जाना है?

— दरवाज़े

@ डॉर्कनोब नहीं, जरूरी नहीं, लेकिन कम से कम मैं जिस समाधान पर काम कर रहा हूं, उसमें मुझे यह ज़रूरी लगा कि हर रैंक के लिए एक अनूठा चरित्र होना चाहिए ताकि सभी टेस्ट केस सही हो सकें।

— क़ैद

@ अच्छा पकड़। धन्यवाद

— क्यूप्रेड

6

रूबी, 156 153 बाइट्स

->a{b='';([a[40],a.scan(/.d/)[5],a=~/;d/,'dchs'.gsub(/./){l=a.scan /.(?=#$&)/;l.size<10&&b+=(';865432'.tr(l*'','')+?0)[0];l.max}.sum>b.sum||p]-[p]).size}

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

->a{
b='';                # stores primiera of other player
([                   # this array stores all checks
a[40],               # check if >20 cards (>40 characters)
a.scan(/.d/)[5],     # check if >5 diamonds
a=~/;d/,             # check if 7 of diamonds
'dchs'.gsub(/./){    # for each suit, build a string with...
l=a.scan /.(?=#$&)/; # find all cards with this suit
l.size<10&&          # if there are less than 10, the other person has some, so
b+=                  # append to their score string the following:
(';865432'           #   start with all the cards
.tr(l*'','')         #   remove the ones we have
+?0)                 #   add back the JQK at the end
[0];                 #   take the highest
l.max}               # return the highest card that we have
.sum                 # take the sum of the codepoints
>b.sum               # check if it's greater than the other player's sum
||p                  # if not, evaluate to nil
]-[p])               # remove all nils
.size}               # count how many are left

यह क्रमशः ;865432000प्रतिनिधित्व करने के लिए उपयोग करता है 76A5432QJK, और सूट लोअरकेस में हैं। (वर्णों की पसंद इसलिए है क्योंकि प्रत्येक से 38 घटाना उनके प्राइमेरा मूल्य देता है, लेकिन हम वास्तव में ऐसा कभी नहीं करते हैं क्योंकि केवल रिश्तेदार ही मायने रखते हैं।)

हम यह नहीं जाँचते हैं कि क्या खिलाड़ी एक सूट को याद कर रहा है क्योंकि यह अनावश्यक है - चूंकि सभी कार्डों की संख्या 38 से अधिक है और उनका वास्तविक मूल्य गिना जाता है, अगर कोई सूट याद कर रहा है, तो सबसे अधिक स्कोर जो उन्हें मिल सकता है वह है (21 + 38) * 3 = 177, जो (10 + 38) * 3 + 21 + 38 = 203 से कम है, जो दूसरे खिलाड़ी को मिल सकता है सबसे कम स्कोर है। हमारे पास दो खिलाड़ी एक असमान नॉनज़रो संख्या वाले सूट को याद नहीं कर सकते हैं, क्योंकि एक खिलाड़ी केवल 0, 1, या 2 सूटों को याद कर सकता है, और यदि कोई 2 सूटों को याद कर रहा है, तो उसके पास अन्य 2 सूटों के सभी कार्ड हैं।

— Doorknob
स्रोत

4

आर, 320 298 265 238 229 224 211 209 179 बाइट्स

यह एक फ़ंक्शन के रूप में, ज्यादातर @digEmAll के कारण एक समाधान है।

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

function(h,S=sum,A=apply,l=99+c(11,8,5:2,6,!1:3)%o%!!1:4)S(S(p<-outer(c(7:2,'A','K','J','Q'),c('D','C','H','S'),paste0)%in%h)>20,S(p[1:10])>5,p[1],S(A(l*p,2,max)-A(l*!p,2,max))>0)

नीचे 209 बाइट्स के लिए मेरे पुराने औसत दर्जे के प्रयासों का सर्वश्रेष्ठ है।

संपादित करें: कुछ कार्यों का उपहास करते हुए नीचे गोल्फ, तो सूट की जाँच करने के बजाय स्कोर में एक निरंतर जोड़ने के विचार को लेकर।

अगला संपादन: कुछ अतिरेक से छुटकारा पाया और फिर Giuseppe से कुछ सुधारों को शामिल किया

अगला संपादित करें: digEmAll के लिए -2 बाइट्स धन्यवाद

मैं इस पर भयानक हूं, इसलिए मुझे यकीन है कि अगर वे समय लेने की परवाह करते हैं तो कोई इस पर सुधार कर सकता है। मैं की तरह महसूस sapplyऔर functionसुपर लंबे होते हैं और उनमें से छुटकारा मिल सकता है, लेकिन मैं कैसे को समझ नहीं सकता। इनपुट मानक संकेतन में दो-वर्ण स्ट्रिंग्स हैं।

function(h,s=sum,l=c(11,8,5:2,6,!1:3)+99)s(length(h)>20,s(grepl('D',h))>5,'7D'%in%h,s(sapply(c('D','C','H','S'),function(i,r=c(7:2,'A','K','J','Q')%in%substr(h[grep(i,h)],1,1))s(l[r][1],-l[!r][1],na.rm=T)))>0)

— qdread
स्रोत

1

आप R गोल्फ चैटरूम में सहायता प्राप्त करने में सक्षम हो सकते हैं , digEmAll एक साथी इतालवी भी है!

— ग्यूसेप

1

बस कुछ सलाह लेकिन अगर आप एक अर्ध-उपनिवेश बस एक नई रेखा (जो आर में एक बाइट लगती है) को स्वैप कर सकते हैं, तो यह एक मुफ्त स्वैप है जो आपके उत्तर को अधिक पठनीय बनाता है। इसके अलावा, अगर आपने ऐसा नहीं किया है, तो ऑनलाइन प्रयास करें । आवश्यक नहीं है, लेकिन फिर से, उपयोग करने के लिए अच्छा है। यह CGCC पोस्ट भी उत्पन्न कर सकता है

— Veskah

1

253 बाइट्स - मुझे पूरी तरह से यकीन नहीं है कि यह काम करेगा, क्योंकि मैं ज्यादातर गोल्फ के सामान्य सेट की कोशिश कर रहा था, लेकिन बेझिझक परीक्षण करता हूं और मुझे बता देता हूं।

— ग्यूसेप

1

209

— digEmAll

1

यह 181 के लिए काम करना चाहिए

— digEmAll

2

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 193 बाइट्स

x=>x.Count/21+x.Count(g=>g>48)+x.Sum(g=>g/40)/6+("".Sum(m=>{var r=x.Where(g=>g/10==m);return(r.Any()?r.Max()%10+50:0)-(r.Count()<10?"	".Max(l=>x.Contains(m*10+l)?48:l+50):0);})>0?1:0)

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

— अज्ञान का अवतार
स्रोत

2

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

अपने मानक प्रतिनिधित्व का उपयोग करते हुए, कार्ड के एक सेट के रूप में इनपुट लेता है।

c=>(c.size>20)+((g=o=>[..."CHSD"].map(s=>[..."JQK2345A67"].map((v,i)=>(S=o^c.has(v+s))?m="111345679"[++n,i]||12:0,n=m=0)|(n?0:T=1,t-=m),T=t=4)|t*T)(1)>g``)+S+(n>5)

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

टिप्पणी की गई

c =>                                // c = set of cards
  (c.size > 20) + (                 // +1 point if we have more than 20 cards
    ( g = o =>                      // g is a function taking the flag o (for 'opponent')
      [..."CHSD"].map(s =>          // for each suit s, ending with diamonds:
        [..."JQK2345A67"]           //   for each rank v at position i, sorted from
        .map((v, i) =>              //   lowest to highest primiera score:
          (S = o ^ c.has(v + s)) ?  //     if the player owns this card, set S to 1 and:
            m = "111345679"[++n, i] //       increment n; update m to the score of this
                || 12               //       rank (we use the official score - 9)
          :                         //     else:
            0,                      //       do nothing
          n = m = 0                 //     start with n = m = 0
        ) |                         //   end of inner map()
        ( n ? 0 : T = 1,            //   if n = 0, set T to 1
          t -= m ),                 //   subtract m from t
        T = t = 4                   //   start with T = t = 4
      ) | t * T                     // end of outer map(); yield t * T
    )(1) > g``                      // +1 point if g(1) is greater than g(0)
  ) +                               // (we test this way because the scores are negative)
  S +                               // +1 point if we own the 7 of diamonds
  (n > 5)                           // +1 point if we own more than 5 diamonds

— Arnauld
स्रोत

2

05AB1E , 41 बाइट्स

39ÝsK‚εg9y@Oy0å•Dδ¿m(/d•₆вy.γT÷}è€àO)}`›O

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

सूट DCHSक्रमशः द्वारा प्रतिनिधित्व कर रहे हैं 0123। 7A65432KJQक्रमशः रैंक का प्रतिनिधित्व किया जाता है 0123456789। जिन्हें स्ट्रिंग्स के रूप में लिया जाता है, पूर्णांक नहीं, जैसा कि चुनौती से आवश्यक है (लेकिन फिर 05AB1E उन्हें पूर्णांक में तब भी परिवर्तित कर देता है जब भी)।

अन्य समाधानों की तरह, हम प्रत्येक प्राइमेरा स्कोर में एक बड़ा स्थिरांक (14) जोड़ते हैं ताकि लापता सूट की जाँच अनावश्यक हो सके।

39Ý                      # range 0..39 (the list of all cards in the game)
   sK                    # remove all elements that appear in the input
      ‚                  # pair with the input: [player's hand, opponent's hand]

ε                     }  # map each hand to a list of its 4 subscores:
 g                       #  first subscore: length (number of cards)
 9y@O                    #  second subscore: count elements <= 9 (diamonds)
 y0å                     #  third subscore: is 0 (representing 7D) in the list
            y.γT÷}       #  group the hand by suit
 •Dδ¿m(/d•₆в      è      #  map each rank to its primiera score
                   €à    #  maximum primiera score in each suit
                     O   #  fourth subscore: the sum of those

`›                       # for each subscore: is player's > opponent's?
  O                      # sum
```

— ग्रिमी
स्रोत

2

MS SQL Server 2017 , 525 बाइट्स

CREATE FUNCTION f(@ NVARCHAR(MAX))RETURNS TABLE RETURN
SELECT q/21+IIF(d>6,2,IIF(d=6,1,0))+IIF(m=0,IIF(n=0 AND a>b,1,0),IIF(n=0 OR a>b,1,0))p
FROM(SELECT SUM(q)q,MAX(IIF(s='D',q,0))d,SUM(a)a,MIN(q)m,SUM(b)b,MIN(10-q)n
FROM(SELECT s,COUNT(k)q,MAX(IIF(r=k,v,0))a,MAX(IIF(r=k,0,v))b
FROM(SELECT LEFT(value,1)r,s,ASCII(RIGHT(value,1))-38 v
FROM STRING_SPLIT('7;,68,A6,5,4,3,2,Q0,J0,K0',','),(VALUES('D'),('C'),('H'),('S'))s(s))d
LEFT JOIN(SELECT LEFT(value,1)k,RIGHT(value,1)u FROM STRING_SPLIT(@,','))a
ON r+s=k+u GROUP BY s)t)t

इसे db <> fiddle पर आज़माएं ।

— आंद्रेई ओडेगो
स्रोत

1

रेटिना 0.8.2 , 334 बाइट्स

$
 ¶234567JQKA
r`.\G
$&C $&D $&H $&S 
+`((\w\w).*¶.*)\2 
$1
T`67AJQK`8960
%O$`(\w)(\w)
$2$1
m`^(?=(...)*)(.C )*(.D )*(.H )*(.S )*
$3;$#1 $#2 $#3 $#4 $#5;${2}${3}${4}$5
m`^(?=(9D))?...;
$#1;
(;(?!.*10).* 0.*;).*
$1
\d[C-S] 
1$&
19\w 
21$*@
\d+(\w )?
$*@
(@)?;(@*) @* (@*).*;(@*)¶@?;((?!\2))?@* @* ((?!\3))?.*;((?!\4))?.*
$#1$#5$#6$#7
1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

$
 ¶234567JQKA
r`.\G
$&C $&D $&H $&S

सभी 40 कार्डों की एक सूची बनाएं।

+`((\w\w).*¶.*)\2 
$1

उन कार्ड को निकालें जिन्हें खिलाड़ी रखता है।

T`67AJQK`8960

प्रत्येक रैंक को उसके क्रम क्रम से बदलें, जो 7अन्य कार्डों के लिए उसके मूल्य से 9 और 10 कम है।

%O$`(\w)(\w)
$2$1

सूट और रैंक के आधार पर सॉर्ट करें।

m`^(?=(...)*)(.C )*(.D )*(.H )*(.S )*
$3;$#1 $#2 $#3 $#4 $#5;${2}${3}${4}$5

प्रत्येक सूट में कार्डों की संख्या की गणना करें और प्रत्येक सूट में उच्चतम रैंक वाले कार्ड को कैप्चर करें, उच्चतम हीरे को दो बार कैप्चर करें।

m`^(?=(9D))?...;
$#1;

जाँचें कि क्या उच्चतम हीरा 7 था।

(;(?!.*10).* 0.*;).*
$1

यदि सूट में से कोई भी कार्ड नहीं है, तो सभी उच्चतम कार्ड हटा दें।

\d[C-S] 
1$&
19\w 
21$*@
\d+(\w )?
$*@

उच्चतम कार्डों को उनके यूनिरी स्कोर में परिवर्तित करें और उन्हें एक साथ जोड़ दें। इसके अलावा कार्ड और सूट की लंबाई की कुल संख्या को एकरूपता में बदलें।

(@)?;(@*) @* (@*).*;(@*)¶@?;((?!\2))?@* @* ((?!\3))?.*;((?!\4))?.*
$#1$#5$#6$#7

स्कोर अंक अगर कुल, हीरे, या प्राइमरी, अधिक है।

कुल अंक।

— नील
स्रोत

1

AWK , 235 बाइट्स

{s[9]=35;s[8]=32;s[7]=30;s[6]=29;s[5]=28;s[4]=27;s[3]=26;s[2]=s[1]=s[0]=24;a[$1 $2]=s[$1]}END{while(i++<4){D=0;for(j=0;j<10;j++){if(a[j i]<1){B[i]=s[j];D++}if(A[i]<a[j i])A[i]=a[j i]}x+=A[i];y+=B[i]}print(20<NR)+(D<5)+(1<a[9 4])+(y<x)}

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

1234 का नक्शा (4 हीरे है), मान 0123456789 में मैप करता है। यह कार्यक्रम परीक्षण के मामलों को स्वीकृत प्रारूप में बदल देता है:

BEGIN{RS=", ";FS="";t[7]=9;t[6]=8;t["A"]=7;t[5]=6;t[4]=5;t[3]=4;t[2]=3;t["Q"]=2;t["J"]=1;t["K"]=0;u["D"]=4;u["C"]=1;u["H"]=2;u["S"]=3}{gsub("[\\[\"\\]]","",$0);print t[$1],u[$2]}

मेरा लक्ष्य सिर्फ अग्रणी पायथन कार्यान्वयन को हरा देना था: डी

— डैनियल लाविन
स्रोत

1

पायथन 3 , 249 245 239 238 बाइट्स

-4 बाइट्स @ovs के लिए धन्यवाद

-6 बाइट्स @movatica की बदौलत

lambda C:sum([len(C)>20,'7D'in C,len([c for c in C if'E'>c[1]])>5,p(C)>p({n+s for n in'9876543210'for s in S}-C)])
p=lambda C:[not S.strip(''.join(C)),sum(max([(c[1]==s)*int('9gcdefil99'[int(c[0])],22)for c in C]+[0])for s in S)]
S='DcHS'

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

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

1

2 बाइट्स के साथ कम int('0734569c00'[int(x[0])],13)और के if x[1]<'E'रूप में लिखा जा सकता हैif'E'>x[1]

— ovs

all(s in''.join(C)for s in S)not S.strip(''.join(C))6 बाइट्स को बचाने के लिए छोटा किया जा सकता है

— Movatica

मेरे स्कोपा के हाथ का स्कोर क्या है?

प्राइमेरा स्कोर की तालिका

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

इनपुट

उत्पादन

जीतना

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

रूबी, 156 153 बाइट्स

आर, 320 298 265 238 229 224 211 209 179 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 193 बाइट्स

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

टिप्पणी की गई

05AB1E , 41 बाइट्स

MS SQL Server 2017 , 525 बाइट्स

रेटिना 0.8.2 , 334 बाइट्स

AWK , 235 बाइट्स

पायथन 3 , 249 245 239 238 बाइट्स