पृष्ठभूमि

में बौगल , एक दौर से प्रत्येक के लिए अंक को जोड़कर रन बनाता है अद्वितीय शब्द एक खिलाड़ी मिल गया है (यानी किसी भी शब्द एक से अधिक खिलाड़ी पाया गया है कि 0 अंक के लायक है)। प्रत्येक शब्द में अक्षरों की संख्या के आधार पर अंकों की गणना की जाती है:

3 अक्षर: 1 अंक

4 अक्षर: 1 अंक

5 अक्षर: 2 अंक

6 अक्षर: 3 अंक

7 अक्षर: 5 अंक

8 या अधिक अक्षर: 11 अंक

चुनौती

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

नियम

इनपुट किसी भी उचित प्रारूप में लिया जा सकता है। उदाहरणों में तार की सूचियों की एक सूची, अल्पविराम से अलग तार की एक सूची, इनपुट की प्रत्येक पंक्ति पर एक अल्पविराम से अलग तार, आदि आउटपुट पूर्णांकों की सूची (या आपकी भाषा के समकक्ष) के रूप में हो सकते हैं या आप प्रिंट कर सकते हैं अपनी पसंद के विभाजक (जैसे कि एक नई लाइन) का उपयोग करके मूल्यों को रोकना।

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

इनपुट => आउटपुट

[["cat","dog","bird","elephant"],
 ["bird","dog","coyote"],
 ["dog","mouse"]]                 => [12,3,2]

[["abc","def","ghi"],
 ["ghi","def","abc"]]             => [0,0]

[["programming","puzzles"],
 ["code","golf"],
 []]                              => [16,2,0]

code-golf string array-manipulation

— Cowabunghole
स्रोत

6

भूसी , 21 20 19 बाइट्स

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

आइडिया A055228 से लिया गया

ṠṀöṁ(⌈√Π-3▼8L)fε`#Σ

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

स्पष्टीकरण (पुराने संस्करण का)

            ṠṀ-oṠ-uΣ   Remove duplicated words
                   Σ   Concatenate
                  u    Remove duplicates
               oṠ-     Remove those unique elements from the list (give list of elements that appear more than once)
            ṠṀ-        Remove those words from each list in the input
m                      For each list
 ṁ(                    Map then sum
          L)           Length
        ▼8             Min(8,x)
      -3               Minus 3
     Π                 Factorial
    √                  Square root
   ⌈                   Ceiling

— H.PWiz
स्रोत

20 बाइट्स

— जर्बग सेप

अच्छा, मैं स्पष्टीकरण पर बचाने के लिए, हालांकि पुनर्व्यवस्थित नहीं करूंगा।

— एच। वाइज

19f-

— बट्स

धन्यवाद, मैं अपने आप को काम करने के लिए वह तरीका नहीं पा सका।

— एच। वाइज

गाह! सोचा था कि मैं तुम्हें बाँधने में कामयाब हो गया, ध्यान नहीं दिया कि तुम अब 19 वर्ष के हो गए हो।

— झबरा

3

आर , 142 126 121 117 बाइट्स

function(L)sapply(lapply(L,setdiff,(l=unlist(L))[duplicated(l)]),function(x)sum(c(1,1,2,3,5,11)[pmin(6,nchar(x)-2)]))

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

Lतार के वैक्टर की एक सूची के रूप में लेता है ; मान लौटाता है।

सबसे पहले, यह unlistशब्द है, डुप्लिकेट पाता है, फिर उन्हें खिलाड़ियों की शब्द सूची से हटा देता है। फिर यह इन अद्वितीय शब्द सूचियों को लेता है और प्रत्येक के अंकों की गणना करता है, pminयह सुनिश्चित करने के लिए कि 8 से अधिक शब्द 11 के रूप में स्कोर किए जाते हैं।

— ग्यूसेप
स्रोत

आप इसे 108 बाइट्स के लिए छोटा कर सकते हैं यदि आप केवल नकली आंतरिक कार्य में डुप्लिकेट को दूर करते हैं:function(L)sapply(L,function(x)sum(c(1,1,2,3,5,11)[pmin(6,nchar(x[!x%in%(l=unlist(L))[duplicated(l)]])-2)]))

— प्लाननैपस

3

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

a=>a.map(b=>b.reduce((s,v)=>s+(a.filter(b=>b.includes(v))[1]?0:+"11235"[v.length-3]||11),0))

रिक हिचकॉक के जवाब के समान, लेकिन ज्यादातर स्वतंत्र रूप से बनाए गए; मैंने reduceबार-बार ( filter+ includes) बार-बार जाँचने के लिए अलग-अलग तरीके ( ) और अलग- अलग तरीके का इस्तेमाल किया । जाँच के [1]बजाय आइटम के लिए जाँच करने के विचार के लिए उसे श्रेय दिया जाता है .length>1।

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

कोड स्निपेट दिखाएं

let f=
a=>a.map(b=>b.reduce((s,v)=>s+(a.filter(b=>b.includes(v))[1]?0:+"11235"[v.length-3]||11),0))

;[[["cat","dog","bird","elephant"],["bird","dog","coyote"],["dog","mouse"]],[["abc","def","ghi"],["ghi","def","abc"]],[["programming","puzzles"],["code","golf"],[]]]
.forEach(test=>O.innerHTML+=JSON.stringify(test)+" -> "+JSON.stringify(f(test))+"\n")

<pre id=O></pre>

Expand snippet

— जस्टिन मेरिनर
स्रोत

आपको s+=टर्नरीज़ के चारों ओर कोष्ठक का उपयोग करके और हटाकर एक बाइट को बचाने में सक्षम होना चाहिए । और 3 के mapबजाय का उपयोग करके और अधिक reduce: tio.run/##NY/…

— झबरा

बहुत बढ़िया। आपका उपयोग reduceऔर includesमेरा उत्तर मेरे से काफी अलग है।

— रिक हिचकॉक

3

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

[सहेजे गए 13 (!) बाइट्स, धन्यवाद अर्नुलद, झबरा, और जॉली जोकर]।

a=>a.map(b=>b.map(c=>x+=(a+'').split`,`.filter(d=>d==c)[1]?0:+'11235'[c.length-3]||11,x=0)|x)

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

कोड स्निपेट दिखाएं

let f=

a=>a.map(b=>b.map(c=>x+=(a+'').split`,`.filter(d=>d==c)[1]?0:+'11235'[c.length-3]||11,x=0)|x)

console.log(f([["cat","dog","bird","elephant"],
               ["bird","dog","coyote"],
               ["dog","mouse"]
              ])
           )  // [12,3,2]
           
console.log(f([["abc","def","ghi"],
               ["ghi","def","abc"]
              ])
           ) // [0,0]
           
console.log(f([["programming","puzzles"],
               ["code","golf"],
               []
              ])
            ) // [16,2,0]

Expand snippet

— रिक हिचकॉक
स्रोत

2

मुझे लगता है कि आप की जगह ले सकता c[7]?11:c[6]?5:c[5]?3:c[4]?2:1साथ '00011234'[c.length]||11।

— अरनौलद

[15,2,0]इसके बजाय [16,2,0]पिछले परीक्षण के मामले के लिए देता है , लेकिन यह शायद आसानी से तय हो गया है। रात के खाने के बाद कुछ और काम करेंगे, जब तक आप एक जीनियस उत्तर (जैसा कि आप आमतौर पर करते हैं) पोस्ट नहीं करते हैं। धन्यवाद! :)

— रिक हिचकॉक

1

आह हाँ, क्षमा करें, कि होना चाहिए '00011235'।

— अरनौलद

1

मुझे लगता है कि आप @ Arnauld के सुझाव के शीर्ष पर एक और कुछ बाइट्स बचा सकते हैं इसलिए की तरह ।

— शैगी

1

कम से कम 3 अक्षर हैं, है '11235'[c.length-3]||11ना?

— जॉली जोकर

2

पर्ल 6 , 64 बाइट्स

{@^a.map:{sum .map:{@a.Bag{$_}>1??0!!(1,1,2,3,5)[.comb-3]||11}}}

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

— nwellnhof
स्रोत

2

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

H.PWiz के सूत्र का उपयोग करता है ।

m+Fm.E@.!a3hS,8lk2fq1/sQTd

सभी परीक्षण मामलों की जाँच करें।

प्रारंभिक संस्करण, 33 बाइट्स :

m+Fm*h+++*6>lk7y>lk6>lk5glk3q1/sQ

सभी परीक्षण मामलों की जाँच करें।

व्याख्या

m + Fm * h +++ * 6> lk7y> lk6> lk5> glk3q1 / sQ पूर्ण कार्यक्रम।

मी इनपुट पर नक्शा।
   मीटर प्रत्येक सबलिस्ट पर नक्शा।
                        > lk3 लंबाई 2 से अधिक है? 1 अगर सच और 0 अगर गलत।
      +> lk5 प्लस "लंबाई 5 से अधिक है?"।
       + y> lk6 प्लस "लंबाई 6 से अधिक है?", दोगुनी।
        + * 6> lk7 प्लस "लंबाई 7 से अधिक है?", 6 बार।
     h वेतन वृद्धि।
                            q1 / sQ समतल में तत्व की घटनाओं की गणना करें
                                     इनपुट, और जांचें कि क्या यह 1 के बराबर है। 0 यदि गलत है, तो 1 यदि सही है।
    * गुणा।
 + एफ प्रत्येक सबलिस्ट।

— श्री Xcoder
स्रोत

2

हास्केल , 76 75 बाइट्स

f l=[sum[fst.last$zip[0,0,1,1,2,3,5,11]w|w<-p,[w]==(filter(==w)=<<l)]|p<-l]

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

— Laikoni
स्रोत

2

जाप , 29 25 24 23 21 20 बाइट्स

Ëx@èøX ¥1©3nXÊm8)Ê¬c

कोशिश करो

स्कोरिंग के लिए पाया सूत्र H.PWiz सूत्र का उपयोग करके 4 बाइट्स सहेजे गए ।

व्याख्या

सरणी का निहित इनपुट U।

Ëx@

निम्न फ़ंक्शन के माध्यम से अपने तत्वों को पास करने के बाद सरणी ( Ë) पर मैप करें और इसके अलावा प्रत्येक उप-सरणी को कम करें ( xजहां Xवर्तमान शब्द है।

èøX

इसमें ( ) èतत्वों की गणना करें ( ) ।UøX

¥1

जांचें कि क्या यह 1 के बराबर है।

©

तार्किक और ( &&)।

3nXÊm8)

घटाना ( n) 3 न्यूनतम ( m) 8 और लंबाई ( Ê) से X।

Ê¬c

फैक्टरियल, वर्गमूल और गोल, क्रमशः।

— झबरा
स्रोत

2

पायथन 2 , 106 105 88 84 बाइट्स

^{-1 बाइट की}^{बदौलत}^{जोनाथन फ्रीच}
^{-1 (17) बाइट्स रीफू को धन्यवाद}

lambda x:[sum(sum([1,0,1,1,2,6][:len(s)-2])*(`x`.count(`s`)<2)for s in l)for l in x]

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

— छड़ी
स्रोत

105 बाइट्स।

— जोनाथन फ्रेच

104 बाइट्स

— reffu

@reffu धन्यवाद, मैंने आगे भी गोल्फ में कुछ संशोधन किए हैं: 3

— रॉड

@ अच्छा, मैं राशि चाल के दूसरे पैरामीटर के बारे में भूल गया।

— 13

1

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

ðċ@Ị¥ÐfL€«8ị“¡[żÇ’ḃ11¤Sµ€Ẏ

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

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

1

जावा 8, 202 200 198 बाइट्स

a->{int q=a.length,r[]=new int[q],i=0,j,f;for(;i<q;i++)for(String s:a[i]){for(f=j=0;j<q;)f|=a[j].contains(s)&!a[i].equals(a[j++])?1:0;if(f<1)r[i]+=(j=s.length())<5?1:j<6?2:j<7?3:j<8?5:11;}return r;}

या ( 198 बाइट्स )

a->{int q=a.length,r[]=new int[q],i=0,j,f=1,e=0;for(;i<q;r[i++]+=f<1?e<5?1:e<6?2:e<7?3:e<8?5:11:0)for(String s:a[i])for(f=j=0;j<q;e=s.length())f|=a[j].contains(s)&!a[i].equals(a[j++])?1:0;return r;}

निश्चित रूप से गोल्फ हो सकता है .. दुर्भाग्य से जावा के पास सभी सूचियों के सभी आइटमों को हटाने के लिए कोई बिल्ड-इन या छोटा तरीका नहीं है जो कई में मौजूद हैं।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->{                       // Method with ArrayList<String>[] parameter & int[] return-type
  int q=a.length,          //  Length of the input-array
      r[]=new int[q],      //  Result integer-array the size of the input-array
      i=0,j,               //  Index integers
      f;                   //  Flag integer (used as boolean)
  for(;i<q;i++)            //  Loop (1) over the input array
    for(String s:a[i]){    //   Inner loop (2) over the Strings of the current List
      for(j=f=0;           //    Reset the flag `f` and index `j` both to 0
                j<q;)      //    Inner loop (3) over the input list again
        f|=a[j].contains(s)//     If the current list (3) contains the current String (2)
           &!a[i].equals(a[j++])?
                           //     and the current list (3) is not the current list (1)
            1              //      Bitwise-OR the flag with 1 (0->1; 1->1)
           :               //     Else:
            0;             //      Bitwise-OR the flag with 0 (0->0; 1->1)
                           //    End of inner loop (3) (implicit / single-line body)
      if(f<1)              //    If the flag is still 0 (so the current String is unique)
        r[i]+=             //     Increase the current item in the result integer-array by:
              (j=s.length())<5?
                           //      If the length is below 5:
               1           //       By 1
              :j<6?        //      Else-if the length is below 6:
               2           //       By 2
              :j<7?        //      Else-if the length is below 7:
               3           //       By 3
              :j<8?        //      Else-if the length is below 8:
               5           //       By 5
              :            //      Else (above 7):
               11;         //       By 11
    }                      //   End of inner loop (2)
                           //  End of loop (1) (implicit / single-line body)
  return r;                //  Return the resulting integer-array
}                          // End of method

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

मुझे टर्नरीज़ से प्यार है, और स्कैला के बारे में मुझे केवल यही नफरत है कि उन्होंने इस टर्नरी सिंटैक्स को हटा दिया।

— वी। कोर्टोइस

@ V.Courtois हम्म, जिज्ञासा से बाहर, अब स्काला में टेरनेरी सिंटैक्स कैसे है?

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

उह: अगर (बूल 1) एक्सप 1 और एक्सप 2

— वी।

1

आर, 117 बाइट्स

अन्य आर उत्तर से पूरी तरह से अलग दृष्टिकोण :

function(L)sapply(L,function(x)sum(c(0:3,5,11)[cut(nchar(x[x%in%names(which(table(unlist(L))<2))]),c(0,2,4:7,Inf))]))

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

> f=function(L)sapply(L,function(x)sum(c(0:3,5,11)[cut(nchar(x[x%in%names(which(table(unlist(L))<2))]),c(0,2,4:7,Inf))]))
> L=list(c("cat","dog","bird","elephant"),c("bird","dog","coyote"),c("dog","mouse"))
> f(L)
[1] 12  3  2
> L=list(c("abc","def","ghi"),c("ghi","def","abc"))
> f(L)
[1] 0 0
> L=list(c("programming","puzzles"),c("code","golf"),c())
> f(L)
[1] 16  2  0

सूची में केवल एक बार होने वाले नामों को लेता है, दिए गए कट-ऑफ बिंदुओं के आधार पर उनकी लंबाई को एक कारक में परिवर्तित करता है और अनुवाद करता है कि फिर स्कोर में।

— plannapus
स्रोत

कटौती कदम में हमारे दो दृष्टिकोणों को मिलाकर 114 बाइट्स ।

— ग्यूसेप

0

पर्ल 5 , 104 + 2 (-na) = 106 बाइट्स

push@a,[@F];map$k{$_}++,@F}{map{$s=0;map$s+=(($l=y///c)<8?$l<7?$l<5?1:$l-3:5:11)*($k{$_}<2),@$_;say$s}@a

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

— Xcali
स्रोत

0

क्लोजर, 102 बाइट्स

#(for[p %](apply +(for[w p](if(next(filter #{w}(flatten %)))0(get{3 1 4 1 5 2 6 3 7 5}(count w)11)))))

nextरिटर्न nilअगर केवल एक शब्द है w:)

— NikoNyrh
स्रोत

0

PHP , 226 बाइट्स

function x($a){foreach($a as$p){$q=call_user_func_array('array_diff',$a);array_push($a,array_shift($a));$x=0;array_map(function($b)use(&$x){$b=strlen($b);$x+=($b<5?1:($b==5?2:($b==6?3:($b==7?5:11))));},$q);$o[]=$x;}return $o;}

मुझे लगता है कि यह अभी भी काफी नीचे छंटनी की जा सकती है।

Ungolfed:

function x($a) {
    foreach ($a as $p) {
        $q = call_user_func_array('array_diff', $a);
        array_push($a, array_shift($a));
        $x = 0;
        array_map(function($b) use (&$x){
            $b = strlen($b);
            $x += ($b < 5 ? 1 : ($b == 5 ? 2 : ($b == 6 ? 3 : ($b == 7 ? 5 : 11))));
        }, $q);
        $o[] = $x;
    }
    return $o;
}

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

— Samsquanch
स्रोत

0

स्काला , 242 बाइट्स

फ़ंक्शन पैरामीटर के रूप में लेता है, aए Seq[Set[String]]और रिटर्न देता है Array[Int]। मैं इसके लिए एक ऐरे का उपयोग करता हूं जो परस्पर परिवर्तनशील है (4-चार हानि)।

var s=Seq("")
a.foreach(x=>x.foreach(y=>s:+=y))
var u:Array[Int]=Array()
var i= -1
a.foreach(t=>{i+=1
u:+=0
t.map(x=>{val l=x.length
if(s.count(_==x)<2){if(l>7)u(i)+=11
if(l==7)u(i)+=5
if(l==6)u(i)+=3
if(l==5)u(i)+=2
if(l>2&l<5)u(i)+=1}})})
u

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

आशावादी हो सकता है, क्योंकि मैं भी काम नहीं किया था

if(l>7)u(i)+=11
if(l==7)u(i)+=5
if(l==6)u(i)+=3
if(l==5)u(i)+=2
if(l>2&l<5)u(i)+=1

अंश। इस चुनौती के लिए धन्यवाद!

— वी। कोर्टीस
स्रोत

0

स्विफ्ट 4 , 164 बाइट्स *

{$0.map{Set($0).subtracting(Dictionary(grouping:$0.flatMap{$0},by:{$0}).flatMap{$1.count != 1 ?$0:nil}).map{[0,1,1,2,3,5,11][min(max($0.count-2,0),6)]}.reduce(0,+)}}

उपरोक्त अभिव्यक्ति तकनीकी रूप से सही है, शुद्ध स्विफ्ट है। हालाँकि, अभिव्यक्ति इतनी जटिल है कि प्रकार की अनुमान प्रणाली में घातांक झटका के कारण, कंपाइलर को कुछ मनमाने समय (जैसे 15 या कुछ) के बाद छोड़ देने से पहले संसाधित नहीं किया जा सकता है।

वर्तमान संकलक के साथ इस अभिव्यक्ति को संकलित करने के लिए, इसे इस तरह से तोड़ा जा सकता है:

{
let n = Dictionary(grouping:$0.flatMap{$0},by:{$0}).flatMap{$1.count != 1 ?$0:nil}
return $0.map{Set($0).subtracting(n).map{[0,1,1,2,3,5,11][min(max($0.count-2,0),6)]}.reduce(0,+)}
}

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

let f: (_ input: [[String]]) -> [Int] = {
    let n = Dictionary(grouping:$0.flatMap{$0},by:{$0}).flatMap{$1.count != 1 ?$0:nil}
    return $0.map{Set($0).subtracting(n).map{[0,1,1,2,3,5,11][min(max($0.count-2,0),6)]}.reduce(0,+)}
}

let testcases: [(input: [[String]], expected: [Int])] = [
    (input: [
            ["cat","dog","bird","elephant"],
            ["bird","dog","coyote"],
            ["dog","mouse"]
        ],
        expected: [12,3,2]
    ),
    (input: [
            ["abc","def","ghi"],
            ["ghi","def","abc"]
        ],
        expected: [0,0]
    ),
    (input: [
            ["programming","puzzles"],
            ["code","golf"],
            []
        ],
        expected: [16,2,0]
    ),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.input)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \(testcase.input) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}

टूटा:

let verboseF: (_ input: [[String]]) -> [Int] = { playerHands in
    let allWords = playerHands.flatMap{$0}
    // demo data for first test case:
    // allWords: ["cat", "dog", "bird", "elephant", "bird", "dog", "coyote" "dog", "mouse"]

    let allWordsGroupedByThemselves = Dictionary(grouping: allWords, by: {$0})
    /* allWordsGroupedByThemselves:
    [
        "cat": ["cat"],
        "dog": ["dog", "dog", "dog"],
        "bird": ["bird", "bird"],
        "elephant": ["elephant"],
        "coyote": ["coyote"], "mouse": ["mouse"]
    ]*/

    let allWordsUsedMoreThanOnce = allWordsGroupedByThemselves.flatMap{$1.count != 1 ?$0:nil}
    // allWordsUsedMoreThanOnce: ["dog", "bird"]

    return playerHands.map{ hand in
        // demo data for first hand of first test case:
        // hand: ["cat","dog","bird","elephant"]

        let uniqueWordsInHand = Set(hand)
        // uniqueWordsInHand: ["cat","dog","bird","elephant"]

        let uniqueWordsInHandNotUsedByOthers = uniqueWordsInHand.subtracting(allWordsUsedMoreThanOnce)
        // uniqueWordsInHandNotUsedByOthers: ["cat", "elephant"]

        let wordLengths = uniqueWordsInHandNotUsedByOthers.map{$0.count}
        // wordLengths: [3, 8]

        let scores = wordLengths.map{ wordLength in
            return [0,1,1,2,3,5,11][min(max(wordLength-2, 0), 6)] //A look up table that maps word length to word score
        }
        //scores: [1, 11]

        let playerScore = scores.reduce(0,+)
        // playerScore: 12

        return playerScore
    }
}

— अलेक्जेंडर - मोनिका को बहाल करें
स्रोत

0

एएसपी + पायथन , 137 बाइट्स

u(P,W):-1{p(_,W)}1;p(P,W).s(P,S):-S=#sum{@v(W):u(P,W)};p(P,_).#script(python)
def v(w):return[1,1,2,3,5,11][min(len(w.string),8)-3]#end.

इस रूप में स्वरूपित डेटा की उम्मीद है:

p(1,("cat";"dog";"bird";"elephant")).
p(2,("bird";"dog";"coyote")).
p(3,("dog";"mouse")).

अजगर समर्थन के साथ क्लिंगो 5.2.1 की आवश्यकता है ।

Ungolfed:

unique(P,W):- 1 { player(_,W) } 1 ; player(P,W).
score(P,S):- S = #sum{@value(W): unique(P,W)} ; player(P,_).
#script (python)
def value(word):
    return [1,1,2,3,5,11][min(len(word.string),8)-3]
#end.

अजगर समारोह भारी अजगर जवाब से प्रेरित है ।

— aluriak
स्रोत

स्कोर ऑफ़ द गेम ऑफ़ बोगल

पृष्ठभूमि

चुनौती

नियम

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

भूसी , 21 20 19 बाइट्स

स्पष्टीकरण (पुराने संस्करण का)

आर , 142 126 121 117 बाइट्स

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

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

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

पर्ल 6 , 64 बाइट्स

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

व्याख्या

हास्केल , 76 75 बाइट्स

जाप , 29 25 24 23 21 20 बाइट्स

व्याख्या

पायथन 2 , 106 105 88 84 बाइट्स

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

जावा 8, 202 200 198 बाइट्स

आर, 117 बाइट्स

पर्ल 5 , 104 + 2 (-na) = 106 बाइट्स

क्लोजर, 102 बाइट्स

PHP , 226 बाइट्स

स्काला , 242 बाइट्स

स्विफ्ट 4 , 164 बाइट्स *

एएसपी + पायथन , 137 बाइट्स