พื้นหลัง

ในBoggleจะมีการทำคะแนนโดยการเพิ่มคะแนนสำหรับคำที่ไม่ซ้ำกันที่ผู้เล่นพบ (เช่นคำใด ๆ ที่พบมากกว่าหนึ่งผู้เล่นที่มีค่า 0 คะแนน) คะแนนจะถูกคำนวณตามจำนวนตัวอักษรในแต่ละคำดังต่อไปนี้:

3 ตัวอักษร: 1 จุด

4 ตัวอักษร: 1 จุด

5 ตัวอักษร: 2 คะแนน

6 ตัวอักษร: 3 คะแนน

7 ตัวอักษร: 5 คะแนน

8 ตัวอักษรหรือมากกว่า: 11 คะแนน

ท้าทาย

ในความท้าทายนี้ให้เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้ในรายการของสตริงที่แสดงถึงคำพูดของผู้เล่นแต่ละคนและแสดงรายการคะแนนของผู้เล่น คุณสามารถสันนิษฐานได้ว่าจะมีผู้เล่นอย่างน้อย 2 คนและทุกคำจะเป็นตัวอักษร 3 ตัวขึ้นไปและจะเป็นตัวพิมพ์เล็ก (หรือตัวพิมพ์ใหญ่ทั้งหมดหากคุณต้องการ) คุณอาจสมมติว่าผู้เล่นแต่ละคนจะใช้แต่ละคำเพียงครั้งเดียว นั่นคือไม่มีรายชื่อผู้เล่นจะมีรายการที่ซ้ำกัน นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ

กฎระเบียบ

สามารถป้อนข้อมูลในรูปแบบที่เหมาะสม ตัวอย่างรวมถึงรายการของรายการของสตริงรายการของสตริงที่คั่นด้วยเครื่องหมายจุลภาค, สตริงที่คั่นด้วยเครื่องหมายจุลภาคในแต่ละบรรทัดของการป้อนข้อมูล ฯลฯ เอาท์พุทสามารถอยู่ในรูปแบบของรายการจำนวนเต็ม (หรือเทียบเท่าภาษาของคุณ) หรือคุณสามารถพิมพ์ ค่าที่จะ stdout โดยใช้ตัวคั่นที่คุณเลือก (เช่นขึ้นบรรทัดใหม่)

กรณีทดสอบ

อินพุต => เอาท์พุท

[["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]

Husk , 21 20 19 ไบต์

-2 ไบต์ขอบคุณZgarb

แนวคิดที่นำมาจาก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

R , 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

JavaScript (ES6), 92 ไบต์

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

ค่อนข้างคล้ายกับคำตอบของ Rick Hitchcockแต่ส่วนใหญ่สร้างขึ้นเอง ฉันใช้วิธีการรวมที่แตกต่างกัน ( 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>

JavaScript (ES6), 106 93 ไบต์

[บันทึก 13 (!) ไบต์ขอบคุณ Arnauld, Shaggy และ JollyJoker.]

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]

Perl 6 , 64 ไบต์

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

ลองออนไลน์!

Pyth , 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 โปรแกรมเต็ม

m แผนที่เหนืออินพุต
   m แผนที่เหนือแต่ละรายการย่อย
                        > lk3 ความยาวมากกว่า 2 หรือไม่ 1 ถ้าเป็นจริงและ 0 ถ้าเป็นเท็จ
      +> lk5 Plus "มีความยาวมากกว่า 5?"
       + y> lk6 Plus "มีความยาวมากกว่า 6?" เป็นสองเท่า
        + * 6> lk7 Plus "มีความยาวมากกว่า 7?" คูณ 6
     ชั่วโมงเพิ่มขึ้น
                            q1 / sQ นับการเกิดขึ้นขององค์ประกอบในแบน
                                     ป้อนข้อมูลและตรวจสอบว่ามันเท่ากับ 1 0 ถ้าเท็จ 1 ถ้าเป็นจริง
    การคูณ *
 + F รวมแต่ละรายการย่อย

Haskell , 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]

ลองออนไลน์!

Japté , 29 25 24 23 21 20 ไบต์

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

ลองมัน

• บันทึก 4 ไบต์โดยใช้สูตร H.PWiz ที่พบสำหรับการให้คะแนน

คำอธิบาย

Uการป้อนข้อมูลโดยปริยายของอาร์เรย์

Ëx@

แม็พกับอาร์เรย์ ( Ë) และลดแต่ละอาเรย์ย่อยด้วยการเพิ่ม ( x) หลังจากผ่านอิลิเมนต์ผ่านฟังก์ชันต่อไปนี้โดยที่Xเป็นคำปัจจุบัน

èøX

count ( è) องค์ประกอบในUที่มี ( )øX

¥1

ตรวจสอบว่าเท่ากับ 1

©

ตรรกะ AND ( &&)

3nXÊm8)

ลบ ( n) 3 จากต่ำ (คนm) 8 และความยาว ( Ê) Xของ

ʬc

แฟกทอเรียลรากที่สองและปัดขึ้นตามลำดับ

Python 2 , 106 105 88 84 ไบต์

^{-1 ไบต์ขอบคุณ Jonathan Frech
-1 (17) ไบต์ขอบคุณ reffu}

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]

ลองออนไลน์!

เยลลี่ 26 ไบต์

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

ลองออนไลน์!

Java 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;}

สามารถเล่นกอล์ฟได้อย่างแน่นอน .. น่าเสียดายที่ Java ไม่มีวิธีการสร้างหรือวิธีสั้น ๆ เพื่อลบรายการทั้งหมดของรายการทั้งหมดที่มีอยู่ในหลาย ๆ

คำอธิบาย:

ลองที่นี่

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

R, 117 ไบต์

แนวทางที่แตกต่างอย่างสิ้นเชิงจากคำตอบ R อื่น ๆ :

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

ใช้ชื่อที่เกิดขึ้นเพียงครั้งเดียวในรายการแปลงความยาวของพวกเขาให้เป็นปัจจัยตามจุดตัดที่กำหนดและแปลว่าเป็นคะแนนที่รวมเข้าด้วยกัน

Perl 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

ลองออนไลน์!

Clojure, 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:)

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;
}

ลองออนไลน์!

สกาลา , 242 ไบต์

ฟังก์ชั่นใช้เวลาเป็นพารามิเตอร์aการและส่งกลับSeq[Set[String]] Array[Int]ฉันใช้ Array เพื่อให้ไม่แน่นอน (การสูญเสีย 4 char)

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

ส่วนหนึ่ง ขอบคุณสำหรับความท้าทายนี้!

สวิฟท์ 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
    }
}

ASP + Pythonขนาด 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")).

ต้องการclingo 5.2.1 พร้อมรองรับ python

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.

ฟังก์ชั่นหลามเป็นแรงบันดาลใจอย่างหนักจากคำตอบหลาม