Arka fon

In Boggle , yuvarlak için her puan ekleyerek atılırsa benzersiz (birden fazla oyuncu 0 puan değerinde olduğunu bulmuştur yani herhangi bir kelime) bir oyuncunun bulduğu kelimenin. Puanlar, her kelimedeki harf sayısına göre aşağıdaki şekilde hesaplanır:

3 harf: 1 puan

4 harf: 1 puan

5 harf: 2 puan

6 harf: 3 puan

7 harf: 5 puan

8 veya daha fazla harf: 11 puan

Meydan okuma

Bu mücadelede, her oyuncunun sözlerini temsil eden dizelerin listelerinde yer alan ve oyuncuların skorlarının bir listesini çıkaran bir program veya işlev yazın. En az 2 oyuncu olacağını ve tüm kelimelerin 3 veya daha fazla harf olacağını ve hepsinin küçük harf olacağını (veya isterseniz büyük harf olacağını) kabul edebilirsiniz. Ayrıca her oyuncunun yalnızca bir kelimeyi kullanacağını varsayabilirsiniz; yani, hiçbir oyuncunun listesi kopya içermez. Bu kod golf, bayt cinsinden en kısa cevap kazanıyor.

kurallar

Giriş, herhangi bir makul formatta alınabilir. Örnekler arasında dizelerin listesi, virgülle ayrılmış dizelerin listesi, girişin her satırında virgülle ayrılmış bir dize vb. Sayıları içerir. seçtiğiniz bir ayırıcı kullanarak stdout değerlerini (yeni satır gibi)

Test Kılıfları

Giriş => Çıkış

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

Kabuğu , 21 20 19 bayt

Zgarb sayesinde -2 bayt

A055228 den alınan fikir

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

Çevrimiçi deneyin!

Açıklama (Eski versiyonun)

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

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

Çevrimiçi deneyin!

Alır Ldizeleri vektörlerin listesi gibi; değerleri döndürür.

İlk unlistönce kelimeler, kopyaları bulur, sonra bunları oyuncuların kelime listelerinden çıkarır. Ardından, bu benzersiz kelime listelerini alır ve pmin8'den daha uzun kelimelerin 11 olarak alınmasını sağlamak için her birinin puanlarını hesaplar .

JavaScript (ES6), 92 bayt

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'un cevabına benzeyen ancak çoğunlukla bağımsız olarak oluşturulan; reduceTekrarlanan terimleri ( filter+ includes) kontrol etmek için farklı bir summing ( ) yöntemi ve farklı bir yöntem kullandım . Yine de [1], kontrol etmek yerine, öğeyi kontrol etme fikri için ona kredi verin .length>1.

Test Kılıfları

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 bayt

[Arnauld, Shaggy ve JollyJoker sayesinde 13 (!) Bayt kurtarıldı.]

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

Test durumları:

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 bayt

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

Çevrimiçi deneyin!

Pyth , 26 bayt

H.PWiz'in formülünü kullanır .

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

Tüm test durumlarını doğrulayın.

İlk sürüm, 33 bayt :

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

Tüm test durumlarını doğrulayın.

açıklama

m + Fm * h +++ * 6> lk7y> lk6> lk5> glk3q1 / sQ Tam program.

m Girdi üzerinde harita.
   m Her bir alt listenin haritası.
                        > lk3 Uzunluk 2'den yüksek mi? 1 eğer doğru, 0 ise yanlış.
      +> lk5 Plus "uzunluğu 5'ten yüksek mi?"
       + y> lk6 Plus "uzunluk 6'dan yüksek?", iki katına çıktı.
        + * 6> lk7 Plus "uzunluk 7? Den daha yüksek.", Çarpı 6.
     h Artırma.
                            q1 / sQ Yassılaştırılmış öğedeki öğenin oluşumunu say
                                     girişini yapın ve 1'e eşit olup olmadığını kontrol edin. Yanlış ise 0, Doğru ise 1.
    * Çarpma işlemi.
 + F Her bir alt listeyi toplayın.

Haskell , 76 75 bayt

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

Çevrimiçi deneyin!

Japt , 29 25 24 23 21 20 bayt

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

Dene

• Skorlama için bulunan H.PWiz formülü kullanılarak 4 bayt kaydedildi .

açıklama

Dizinin örtük girişi U.

Ëx@

Dizinin ( Ë) üzerinden eşleyin xve aşağıdaki fonksiyondan elemanlarını geçtikten sonra include ( ) ile her alt diziyi küçültün , şu Xanki kelime.

èøX

(Sayısı è) elemanları Ubu ihtiva eder ( ø) X.

¥1

Bunun 1'e eşit olup olmadığını kontrol edin.

©

Mantıksal VE ( &&).

3nXÊm8)

( n) 3 ifadesini minimum ( m) 8 ve uzunluğu ( Ê) ile çıkarın X.

ʬc

Faktör, karekök ve sırasıyla yuvarlanır.

Python 2 , 106 105 88 84 bayt

^{Jonathan Frech ile
-1 bayt teşekkürler reffu ile -1 (17) bayt teşekkürler}

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]

Çevrimiçi deneyin!

Jöle , 26 bayt

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

Çevrimiçi deneyin!

Java 8, 202 200 198 bayt

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

VEYA (ayrıca 198 bayt )

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

Kesinlikle golf oynayabilir .. Maalesef Java, çoklu listelerde yer alan tüm listelerin tümünü kaldırmak için yerleşik veya kısa yöntemlere sahip değildir.

Açıklama:

Burada dene.

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 bayt

Diğer R cevabından tamamen farklı bir yaklaşım :

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

Test durumları:

> 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

Listede yalnızca bir kez bulunan isimleri alır, uzunluklarını verilen kesme noktalarına göre bir faktöre dönüştürür ve bunları toplanan puanlara çevirir.

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

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

Çevrimiçi deneyin!

Clojure, 102 bayt

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

nextdöner niltek bir kelime varsa w:)

PHP , 226 bayt

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

Bence bu hala biraz kesilmiş olabilir.

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

Çevrimiçi deneyin!

Scala , 242 bayt

Fonksiyonu parametre olarak alır a, bir Seq[Set[String]]ve bir döner Array[Int]. Değişken olması için bir Array kullanıyorum (4-char loss).

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

Çevrimiçi deneyin!

Üzerinde çalışamadığım için optimize edilebilir olabilir.

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

Bölüm. Bu meydan okuma için teşekkürler!

Swift 4 , 164 bayt *

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

Yukarıdaki ifade teknik olarak doğru, saf Swift. Bununla birlikte, ifade o kadar karmaşıktır ki, tür çıkarım sistemindeki üssel patlama nedeniyle, derleyici bazı zaman aşımlarından sonra (15 ya da bir şey gibi) pes etmeden önce işlenemez.

Bu ifadeyi geçerli derleyici ile derlenebilir hale getirmek için, şu şekilde ayrılabilir:

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

Test durumları:

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

Bozuldu:

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 bayt

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.

Aşağıdaki gibi biçimlendirilmiş verileri bekler:

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

Python desteği ile Clingo 5.2.1'e ihtiyaç var .

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.

Python işlevi python yanıtından büyük ölçüde esinlenmiştir .