Lý lịch

Trong Boggle , một vòng được ghi bằng cách cộng điểm cho mỗi từ duy nhất mà người chơi đã tìm thấy (nghĩa là bất kỳ từ nào có nhiều hơn một người chơi đã tìm thấy đều có giá trị 0 điểm). Các điểm được tính dựa trên số lượng chữ cái trong mỗi từ, như sau:

3 chữ cái: 1 điểm

4 chữ cái: 1 điểm

5 chữ cái: 2 điểm

6 chữ cái: 3 điểm

7 chữ cái: 5 điểm

8 chữ cái trở lên: 11 điểm

Thử thách

Trong thử thách này, hãy viết chương trình hoặc chức năng lấy danh sách các chuỗi đại diện cho từng từ của người chơi và đưa ra danh sách điểm số của người chơi. Bạn có thể giả sử rằng sẽ có ít nhất 2 người chơi và tất cả các từ sẽ có 3 chữ cái trở lên và tất cả sẽ là chữ thường (hoặc tất cả chữ hoa nếu bạn muốn). Bạn cũng có thể cho rằng mỗi người chơi sẽ chỉ sử dụng mỗi từ một lần; nghĩa là, không có danh sách người chơi nào sẽ chứa các bản sao. Đây là mã golf, vì vậy câu trả lời ngắn nhất trong byte thắng.

Quy tắc

Đầu vào có thể được thực hiện trong bất kỳ định dạng hợp lý. Ví dụ bao gồm danh sách các chuỗi, danh sách các chuỗi được phân tách bằng dấu phẩy, chuỗi được phân tách bằng dấu phẩy trên mỗi dòng đầu vào, v.v. Đầu ra có thể ở dạng danh sách các số nguyên (hoặc tương đương với ngôn ngữ của bạn) hoặc bạn có thể in các giá trị cho thiết bị xuất chuẩn bằng cách sử dụng dấu phân cách bạn chọn (chẳng hạn như dòng mới).

Các trường hợp thử nghiệm

Đầu vào => Đầu ra

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

-2 byte nhờ Zgarb

Ý tưởng lấy từ A055228

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

Hãy thử trực tuyến!

Giải thích (Của phiên bản cũ hơn)

            ṠṀ-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 byte

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)]))

Hãy thử trực tuyến!

Lấy Lnhư một danh sách các vectơ của chuỗi; trả về các giá trị.

Đầu tiên, đó unlistlà các từ, tìm các bản sao, sau đó xóa chúng khỏi danh sách từ của người chơi. Sau đó, nó lấy các danh sách từ duy nhất này và tính điểm của từng từ, sử dụng pminđể đảm bảo rằng các từ dài hơn 8 được ghi là 11.

JavaScript (ES6), 92 byte

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

Khá giống với câu trả lời của Rick Hitchcock nhưng được tạo ra chủ yếu độc lập; Tôi đã sử dụng một phương pháp tổng hợp ( reduce) và phương pháp khác nhau để kiểm tra các thuật ngữ lặp lại ( filter+ includes). Tín dụng cho anh ấy cho ý tưởng kiểm tra cho mục [1]thay vì kiểm tra .length>1, mặc dù.

Các trường hợp thử nghiệm

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 byte

[Đã lưu 13 (!) Byte, nhờ Arnauld, Shaggy và 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)

Các trường hợp thử nghiệm:

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 byte

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

Hãy thử trực tuyến!

Bình thường , 26 byte

Sử dụng công thức của H.PWiz .

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

Xác nhận tất cả các trường hợp thử nghiệm.

Phiên bản ban đầu, 33 byte :

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

Xác nhận tất cả các trường hợp thử nghiệm.

Giải trình

m + Fm * h +++ * 6> lk7y> lk6> lk5> glk3q1 / sQ Chương trình đầy đủ.

m Bản đồ qua đầu vào.
   m Bản đồ trên mỗi danh sách con.
                        > lk3 Chiều dài có lớn hơn 2 không? 1 nếu đúng và 0 nếu sai.
      +> lk5 Plus "có độ dài cao hơn 5?".
       + y> lk6 Plus "có chiều dài cao hơn 6?", tăng gấp đôi.
        + * 6> lk7 Plus "có độ dài cao hơn 7?", Lần 6.
     h Tăng.
                            q1 / sQ Đếm số lần xuất hiện của phần tử trong phần dẹt
                                     nhập và kiểm tra xem nó có bằng 1. 0 nếu Sai, 1 nếu Đúng.
    * Phép nhân.
 + F Sum mỗi danh sách con.

Haskell , 76 75 byte

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

Hãy thử trực tuyến!

Japt , 29 25 24 23 21 20 byte

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

Thử nó

• Đã lưu 4 byte bằng cách sử dụng công thức H.PWiz tìm thấy để tính điểm.

Giải trình

Đầu vào ngầm định của mảng U.

Ëx@

Ánh xạ qua mảng ( Ë) và giảm từng mảng con bằng phép cộng ( x) sau khi chuyển các phần tử của nó qua hàm sau, trong đó Xlà từ hiện tại.

èøX

Đếm ( è) các phần tử Ucó chứa ( ø) X.

¥1

Kiểm tra nếu nó bằng 1.

©

Logic VÀ ( &&).

3nXÊm8)

Trừ ( n) 3 từ mức tối thiểu của ( m) 8 và độ dài ( Ê) của X.

ʬc

Yếu tố, căn bậc hai và làm tròn lên, tương ứng.

Python 2 , 106 105 88 84 byte

^{-1 byte nhờ Jonathan Frech
-1 (17) byte nhờ 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]

Hãy thử trực tuyến!

Thạch , 26 byte

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

Hãy thử trực tuyến!

Java 8, 202 200 198 byte

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

HOẶC (cũng 198 byte )

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

Chắc chắn có thể bị đánh gôn .. Thật không may, Java không có các phương thức xây dựng hoặc phương pháp ngắn để loại bỏ tất cả các mục của tất cả các danh sách có trong nhiều ..

Giải trình:

Hãy thử nó ở đây.

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 byte

Một cách tiếp cận hoàn toàn khác với câu trả lời R khác :

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))]))

Các trường hợp thử nghiệm:

> 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

Lấy tên chỉ xảy ra một lần trong danh sách, chuyển đổi độ dài của chúng thành một yếu tố dựa trên các điểm giới hạn đã cho và chuyển nó thành điểm số sau đó được tính tổng.

Perl 5 , 104 + 2 (-na) = 106 byte

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

Hãy thử trực tuyến!

Clojure, 102 byte

#(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)))))

nexttrả về nilnếu chỉ có một từ w:)

PHP , 226 byte

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

Tôi nghĩ rằng điều này vẫn có thể được cắt giảm khá nhiều.

Ung dung:

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

Hãy thử trực tuyến!

Scala , 242 byte

Hàm lấy, làm tham số a, a Seq[Set[String]]và trả về một Array[Int]. Tôi sử dụng một Array cho nó để có thể thay đổi (mất 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

Hãy thử trực tuyến!

Có thể tối ưu hóa, vì tôi thậm chí không làm việc trên

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

phần. Cảm ơn vì thử thách này!

Swift 4 , 164 byte *

{$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,+)}}

Các biểu hiện trên là đúng kỹ thuật, Swift thuần túy. Tuy nhiên, biểu thức phức tạp đến mức, do sự thổi theo hàm mũ trong hệ thống suy luận kiểu, không thể được xử lý trước khi trình biên dịch bỏ cuộc sau một khoảng thời gian chờ tùy ý (như 15 giây hoặc một cái gì đó).

Để làm cho biểu thức này có thể biên dịch được với trình biên dịch hiện tại, nó có thể được chia nhỏ như thế này:

{
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,+)}
}

Các trường hợp thử nghiệm:

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!")
}

Hỏng:

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 byte

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.

Dự kiến ​​dữ liệu được định dạng là:

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

Cần clingo 5.2.1 với sự hỗ trợ của python.

Ung dung:

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.

Hàm python được lấy cảm hứng rất nhiều từ câu trả lời của python .