Latar Belakang

Dalam Boggle , satu ronde dicetak dengan menambahkan poin untuk setiap kata unik yang ditemukan oleh seorang pemain (yaitu setiap kata yang ditemukan lebih dari satu pemain bernilai 0 poin). Poin dihitung berdasarkan jumlah huruf di setiap kata, sebagai berikut:

3 huruf: 1 poin

4 huruf: 1 poin

5 huruf: 2 poin

6 huruf: 3 poin

7 huruf: 5 poin

8 atau lebih huruf: 11 poin

Tantangan

Dalam tantangan ini, tulislah program atau fungsi yang memuat daftar string yang mewakili kata-kata setiap pemain dan menampilkan daftar skor para pemain. Anda dapat mengasumsikan bahwa akan ada setidaknya 2 pemain dan semua kata akan menjadi 3 atau lebih huruf dan semua akan menjadi huruf kecil (atau semua huruf besar jika Anda mau). Anda juga dapat mengasumsikan bahwa setiap pemain hanya akan menggunakan setiap kata sekali; artinya, daftar pemain tidak akan berisi duplikat. Ini kode golf, jadi jawaban tersingkat dalam byte menang.

Aturan

Masukan dapat diambil dalam format apa pun yang masuk akal. Contohnya termasuk daftar daftar string, daftar string yang dipisahkan koma, string yang dipisahkan koma pada setiap baris input, dll. Output dapat berupa daftar bilangan bulat (atau bahasa Anda yang setara) atau Anda dapat mencetak nilai untuk stdout menggunakan pemisah pilihan Anda (seperti baris baru).

Uji Kasus

Input => Output

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

Sekam , 21 20 19 byte

-2 byte terima kasih kepada Zgarb

Ide diambil dari A055228

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

Cobalah online!

Penjelasan (Dari versi yang lebih lama)

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

Cobalah online!

Dibawa Lsebagai daftar vektor string; mengembalikan nilai.

Pertama, ini unlistkata-katanya, menemukan duplikatnya, lalu menghapusnya dari daftar kata para pemain. Kemudian diperlukan daftar kata yang unik ini dan menghitung skor masing-masing, menggunakan pminuntuk memastikan bahwa kata-kata yang lebih lama dari 8 mendapatkan skor sebagai 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))

Agak mirip dengan jawaban Rick Hitchcock tetapi sebagian besar dibuat secara independen; Saya menggunakan metode penjumlahan yang berbeda ( reduce) dan metode yang berbeda untuk memeriksa istilah berulang ( filter+ includes). Namun, kredit kepadanya untuk gagasan memeriksa barang [1]alih-alih memeriksa .length>1.

Uji Kasus

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

[Tersimpan 13 (!) Byte, terima kasih kepada Arnauld, Shaggy, dan 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)

Kasus uji:

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

Cobalah online!

Pyth , 26 byte

Menggunakan formula H.PWiz .

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

Verifikasi semua kasus uji.

Versi awal, 33 byte :

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

Verifikasi semua kasus uji.

Penjelasan

m + Fm * h +++ * 6> lk7y> lk6> lk5> glk3q1 / sQ Program lengkap.

m Peta di atas input.
   m Peta atas setiap sublist.
                        > lk3 Apakah panjangnya lebih dari 2? 1 jika Benar dan 0 jika Salah.
      +> lk5 Plus "panjangnya lebih tinggi dari 5?".
       + y> lk6 Plus "lebih panjang dari 6?", dua kali lipat.
        + * 6> lk7 Plus "panjangnya lebih tinggi dari 7?", Kali 6.
     h Penambahan.
                            q1 / sQ Hitung kemunculan elemen dalam rata
                                     masukan, dan periksa apakah sama dengan 1. 0 jika Salah, 1 jika Benar.
    * Penggandaan.
 + F Jumlahkan setiap sublist.

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]

Cobalah online!

Japt , 29 25 24 23 21 20 byte

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

Cobalah

• Disimpan 4 byte dengan menggunakan rumus H.PWiz yang ditemukan untuk penilaian.

Penjelasan

Input array secara implisit U.

Ëx@

Memetakan di atas array ( Ë) dan mengurangi setiap sub-array dengan penambahan ( x) setelah melewati elemen-elemennya melalui fungsi berikut, di mana Xkata saat ini.

èøX

Hitung ( è) elemen dalam Uyang mengandung ( ø) X.

¥1

Periksa apakah itu sama dengan 1.

©

Logis DAN ( &&).

3nXÊm8)

Kurangi ( n) 3 dari minimum ( m) 8 dan panjang ( Ê) dari X.

ʬc

Secara faktorial, akar kuadrat dan bulat, masing-masing.

Python 2 , 106 105 88 84 byte

^{-1 byte terima kasih kepada Jonathan Frech
-1 (17) byte terima kasih kepada 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]

Cobalah online!

Jeli , 26 byte

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

Cobalah online!

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

ATAU (juga 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;}

Bisa dipastikan golf. Sayangnya Java tidak memiliki build-in atau metode pendek untuk menghapus semua item dari semua daftar yang ada dalam banyak ..

Penjelasan:

Coba di sini.

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

Pendekatan yang sangat berbeda dari jawaban R lainnya :

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

Kasus uji:

> 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

Membawa nama-nama yang muncul hanya sekali dalam daftar, mengonversi panjangnya menjadi faktor berdasarkan poin cut-off yang diberikan dan menerjemahkannya menjadi skor yang kemudian dijumlahkan.

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

Cobalah online!

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

nextkembali niljika hanya ada satu kata 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;}

Saya pikir ini masih bisa dipangkas sedikit.

Tidak Disatukan:

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

Cobalah online!

Scala , 242 byte

Fungsi ini mengambil, sebagai parameter a, Seq[Set[String]]dan mengembalikan sebuah Array[Int]. Saya menggunakan Array agar bisa berubah (kehilangan 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

Cobalah online!

Mungkin dapat dioptimalkan, karena saya bahkan tidak bekerja di Internet

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

bagian. Terima kasih atas tantangan ini!

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

Ungkapan di atas secara teknis benar, Swift murni. Namun, ekspresi ini sangat kompleks sehingga, karena ledakan eksponensial dalam sistem inferensi tipe, tidak dapat diproses sebelum kompiler menyerah setelah beberapa waktu habis-habisnya (seperti 15 atau lebih).

Untuk membuat ekspresi ini dapat dikompilasi dengan kompiler saat ini, dapat dirinci seperti ini:

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

Kasus uji:

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

Rusak:

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.

Diharapkan data diformat sebagai:

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

Membutuhkan clingo 5.2.1 dengan dukungan python.

Tidak Disatukan:

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.

Fungsi python sangat terinspirasi dari jawaban python .