Hintergrund

In Boggle wird eine Runde durch Addition der Punkte für jedes erzielt einzigartiges Wort ein Spieler (dh jedes Wort , das mehr als ein Spieler wert ist 0 Punkte gefunden hat) gefunden hat. Die Punkte werden basierend auf der Anzahl der Buchstaben in jedem Wort wie folgt berechnet:

3 Buchstaben: 1 Punkt

4 Buchstaben: 1 Punkt

5 Buchstaben: 2 Punkte

6 Buchstaben: 3 Punkte

7 Buchstaben: 5 Punkte

8 oder mehr Buchstaben: 11 Punkte

Herausforderung

Schreiben Sie in dieser Herausforderung ein Programm oder eine Funktion, die eine Liste von Zeichenfolgen aufnimmt, die die Wörter jedes Spielers darstellen, und eine Liste der Punktzahlen der Spieler ausgibt. Sie können davon ausgehen, dass es mindestens 2 Spieler gibt und alle Wörter aus 3 oder mehr Buchstaben bestehen und alle in Kleinbuchstaben (oder ganz in Großbuchstaben, wenn Sie dies vorziehen) geschrieben sind. Sie können auch davon ausgehen, dass jeder Spieler jedes Wort nur einmal verwendet. Das heißt, keine Spielerliste enthält Duplikate. Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes.

Regeln

Die Eingabe kann in jedem vernünftigen Format erfolgen. Beispiele hierfür sind eine Liste mit Listen von Zeichenfolgen, eine Liste mit durch Kommas getrennten Zeichenfolgen, eine durch Kommas getrennte Zeichenfolge in jeder Eingabezeile usw. Die Ausgabe kann in Form einer Liste mit ganzen Zahlen (oder in der entsprechenden Sprache) erfolgen oder Sie können sie drucken Geben Sie die Werte mit einem Trennzeichen Ihrer Wahl (z. B. einem Zeilenvorschub) aus.

Testfälle

Eingabe => Ausgabe

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

Schale , 21 20 19 Bytes

-2 Bytes dank Zgarb

Idee aus A055228 übernommen

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

Probieren Sie es online!

Erklärung (der älteren Version)

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

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

Probieren Sie es online!

Nimmt Lals Liste von Vektoren von Zeichenfolgen; gibt die Werte zurück.

Zuerst werden unlistdie Wörter gesucht, die Duplikate gefunden und dann aus den Wortlisten der Spieler entfernt. Dann nimmt er diese eindeutigen Wortlisten und berechnet die Punktzahlen von jedem, pminum sicherzustellen, dass Wörter, die länger als 8 sind, als 11 gewertet werden.

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

Etwas ähnlich wie Rick Hitchcocks Antwort, aber größtenteils unabhängig erstellt; Ich habe eine andere Methode zum Summieren ( reduce) und eine andere Methode zum Überprüfen auf wiederholte Ausdrücke ( filter+ includes) verwendet. Gutschrift für die Idee, nach Gegenständen [1]zu suchen .length>1, anstatt sie zu überprüfen .

Testfälle

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

[Dank Arnauld, Shaggy und JollyJoker wurden 13 (!) Bytes gespeichert.]

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

Testfälle:

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 Bytes

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

Probieren Sie es online!

Pyth , 26 Bytes

Verwendet die Formel von H.PWiz .

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

Überprüfen Sie alle Testfälle.

Die ursprüngliche Version, 33 Bytes :

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

Überprüfen Sie alle Testfälle.

Erläuterung

m + Fm * h +++ * 6> lk7y> lk6> lk5> glk3q1 / sQ Vollständiges Programm.

m Karte über den Eingang.
   m Mappe über jede Unterliste.
                        > lk3 Ist die Länge größer als 2? 1 wenn wahr und 0 wenn falsch.
      +> lk5 Plus "ist länger als 5?"
       + y> lk6 Plus "ist länger als 6?", verdoppelt.
        + * 6> lk7 Plus "ist länger als 7?", Mal 6.
     h Inkrement.
                            q1 / sQ Zählen Sie die Vorkommen des Elements in der Abgeflachten
                                     Geben Sie ein und überprüfen Sie, ob es gleich 1 ist. 0 wenn False, 1 wenn True.
    * Multiplikation.
 + F Summe jeder Unterliste.

Haskell , 76 75 Bytes

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

Probieren Sie es online!

Japt , 29 25 24 23 21 20 Bytes

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

Versuch es

• 4 Bytes mit der für die Wertung gefundenen Formel H.PWiz gespeichert .

Erläuterung

Implizite Eingabe eines Arrays U.

Ëx@

Ordnen Sie das Array ( Ë) zu und reduzieren Sie jedes Unterarray durch Addition ( x), nachdem Sie seine Elemente durch die folgende Funktion geleitet haben. Dabei Xist das aktuelle Wort.

èøX

Zähle ( è) die Elemente U, die ( ø) enthalten X.

¥1

Überprüfen Sie, ob dies gleich 1 ist.

©

Logisches UND ( &&).

3nXÊm8)

Subtrahieren Sie ( n) 3 vom Minimum von ( m) 8 und der Länge ( Ê) von X.

ʬc

Fakultät, Quadratwurzel bzw. Aufrundung.

Python 2 , 106 105 88 84 Bytes

^{-1 Byte dank Jonathan Frech
-1 (17) Byte dank 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]

Probieren Sie es online!

Gelee , 26 Bytes

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

Probieren Sie es online!

Java 8, 202 200 198 Bytes

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

ODER (auch 198 Bytes )

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

Kann auf jeden Fall Golf gespielt werden. Leider hat Java keine eingebauten oder kurzen Methoden, um alle Elemente aus allen Listen zu entfernen, die in mehreren vorhanden sind.

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

Ein ganz anderer Ansatz als die andere R-Antwort :

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

Testfälle:

> 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

Nimmt die Namen, die nur einmal in der Liste vorkommen, konvertiert ihre Länge in einen Faktor, der auf den angegebenen Grenzwerten basiert, und übersetzt diese in Punktzahlen, die dann summiert werden.

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

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

Probieren Sie es online!

Clojure, 102 Bytes

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

nextGibt zurück, nilwenn es nur ein Wort gibt w:)

PHP , 226 Bytes

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

Ich denke, das könnte noch einiges reduziert werden.

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

Probieren Sie es online!

Scala , 242 Bytes

Die Funktion nimmt als Parameter aa Seq[Set[String]]und gibt ein zurück Array[Int]. Ich benutze ein Array, damit es veränderlich ist (4-Zeichen-Verlust).

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

Probieren Sie es online!

Könnte optimierbar sein, da ich noch nicht mal an dem gearbeitet habe

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

Teil. Danke für diese Herausforderung!

Swift 4 , 164 Bytes *

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

Der obige Ausdruck ist technisch korrekt, reiner Swift. Der Ausdruck ist jedoch so komplex, dass er aufgrund eines exponentiellen Anstiegs im Typinferenzsystem nicht verarbeitet werden kann, bevor der Compiler nach einer willkürlichen Zeitüberschreitung (z. B. 15 Sekunden oder so) aufgibt.

Um diesen Ausdruck mit dem aktuellen Compiler kompilierbar zu machen, kann er folgendermaßen aufgeteilt werden:

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

Testfälle:

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

Heruntergebrochen:

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.

Erwartet Daten, die formatiert sind als:

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

Benötigt Clingo 5.2.1 mit Python-Unterstützung.

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.

Die Python-Funktion ist stark von der Python-Antwort inspiriert .