Contexte

Dans Boggle , un tour est marqué en additionnant les points pour chaque mot unique qu'un joueur a trouvé (c'est-à-dire que tout mot que plus d'un joueur a trouvé vaut 0 point). Les points sont calculés en fonction du nombre de lettres dans chaque mot, comme suit:

3 lettres: 1 point

4 lettres: 1 point

5 lettres: 2 points

6 lettres: 3 points

7 lettres: 5 points

8 lettres ou plus: 11 points

Défi

Dans ce défi, écrivez un programme ou une fonction qui prend une liste de listes de chaînes représentant les mots de chaque joueur et génère une liste des scores des joueurs. Vous pouvez supposer qu'il y aura au moins 2 joueurs et tous les mots seront de 3 lettres ou plus et seront tous en minuscules (ou en majuscules si vous préférez). Vous pouvez également supposer que chaque joueur n'utilisera chaque mot qu'une seule fois; c'est-à-dire qu'aucune liste de joueurs ne contiendra de doublons. C'est le golf de code, donc la réponse la plus courte en octets l'emporte.

Règles

L'entrée peut être prise dans n'importe quel format raisonnable. Les exemples incluent une liste de listes de chaînes, une liste de chaînes séparées par des virgules, une chaîne séparée par des virgules sur chaque ligne d'entrée, etc. La sortie peut être sous la forme d'une liste d'entiers (ou l'équivalent de votre langue) ou vous pouvez imprimer les valeurs à stdout en utilisant un séparateur de votre choix (comme une nouvelle ligne).

Cas de test

Entrée => Sortie

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

-2 octets grâce à Zgarb

Idée tirée de A055228

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

Essayez-le en ligne!

Explication (d'une ancienne 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 121 117 octets

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

Essayez-le en ligne!

Prend Lcomme une liste de vecteurs de chaînes; renvoie les valeurs.

Premièrement, ce unlistsont les mots, trouve les doublons, puis les supprime des listes de mots des joueurs. Ensuite, il prend ces listes de mots uniques et calcule les scores de chacun, en utilisant pminpour s'assurer que les mots de plus de 8 obtiennent un score de 11.

JavaScript (ES6), 92 octets

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

Un peu similaire à la réponse de Rick Hitchcock mais créé principalement indépendamment; J'ai utilisé une méthode différente de sommation ( reduce) et une méthode différente pour vérifier les termes répétés ( filter+ includes). Créditez-lui pour l'idée de vérifier l'article [1]au lieu de vérifier .length>1, cependant.

Cas de test

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 octets

[13 octets (!) Enregistrés grâce à Arnauld, Shaggy et 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)

Cas de test:

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 octets

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

Essayez-le en ligne!

Pyth , 26 octets

Utilise la formule de H.PWiz .

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

Vérifiez tous les cas de test.

La version initiale, 33 octets :

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

Vérifiez tous les cas de test.

Explication

m + Fm * h +++ * 6> lk7y> lk6> lk5> glk3q1 / sQ Programme complet.

m Mappez sur l'entrée.
   m Cartographiez chaque sous-liste.
                        > lk3 La longueur est-elle supérieure à 2? 1 si vrai et 0 si faux.
      +> lk5 Plus "est de longueur supérieure à 5?".
       + y> lk6 Plus "est de longueur supérieure à 6?", doublé.
        + * 6> lk7 Plus "est de longueur supérieure à 7?", Multiplié par 6.
     h Incrément.
                            q1 / sQ Compter les occurrences de l'élément dans l'aplati
                                     et vérifiez si elle est égale à 1. 0 si False, 1 si True.
    * Multiplication.
 + F Additionne chaque sous-liste.

Haskell , 76 75 octets

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

Essayez-le en ligne!

Japt , 29 25 24 23 21 20 octets

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

Essayez-le

• Enregistré 4 octets en utilisant la formule H.PWiz trouvée pour la notation.

Explication

Entrée implicite du tableau U.

Ëx@

Mappez sur le tableau ( Ë) et réduisez chaque sous-tableau par addition ( x) après avoir passé ses éléments à travers la fonction suivante, où Xest le mot courant.

èøX

Count ( è) les éléments Uqui contiennent ( ø) X.

¥1

Vérifiez si cela est égal à 1.

©

ET logique ( &&).

3nXÊm8)

Soustrayez ( n) 3 du minimum de ( m) 8 et de la longueur ( Ê) de X.

ʬc

Factorielle, racine carrée et arrondie, respectivement.

Python 2 , 106 105 105 88 84 octets

^{-1 octet grâce à Jonathan Frech
-1 (17) octets grâce à 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]

Essayez-le en ligne!

Gelée , 26 octets

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

Essayez-le en ligne!

Java 8, 202 200 198 octets

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

OU (également 198 octets )

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

Peut certainement être joué au golf. Malheureusement, Java n'a pas de builds ou de méthodes courtes pour supprimer tous les éléments de toutes les listes qui sont présents dans plusieurs ..

Explication:

Essayez-le ici.

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 octets

Une approche complètement différente de l' autre réponse 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))]))

Cas de test:

> 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

Prend les noms n'apparaissant qu'une seule fois dans la liste, convertit leur longueur en un facteur basé sur les points de coupure donnés et les traduit en scores qui sont ensuite additionnés.

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

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

Essayez-le en ligne!

Clojure, 102 octets

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

nextrenvoie nils'il n'y a qu'un seul mot w:)

PHP , 226 octets

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

Je pense que cela pourrait encore être réduit un peu.

Non golfé:

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

Essayez-le en ligne!

Scala , 242 octets

La fonction prend, comme paramètre a, un Seq[Set[String]]et retourne un Array[Int]. J'utilise un tableau pour qu'il soit mutable (perte de 4 caractères).

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

Essayez-le en ligne!

Pourrait être optimisable, car je n'ai même pas travaillé sur le

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

partie. Merci pour ce défi!

Swift 4 , 164 octets *

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

L'expression ci-dessus est techniquement correcte, Swift pure. Cependant, l'expression est si complexe que, en raison de l'explosion exponentielle dans le système d'inférence de type, ne peut pas être traitée avant que le compilateur n'abandonne après un certain délai arbitraire (comme 15s ou quelque chose).

Pour rendre cette expression compilable avec le compilateur actuel, elle peut être décomposée comme ceci:

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

Cas de test:

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

En panne:

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 octets

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.

Attend des données au format:

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

Besoin de clingo 5.2.1 avec le support python.

Non golfé:

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.

La fonction python est fortement inspirée de la réponse python .