배경

에서 머뭇 거리는 , 라운드는 각각의 포인트를 추가하여 채점 독특한 (하나 이상의 플레이어가 0 점 가치가 찾은 즉 단어) 선수가 발견 한 단어. 포인트는 다음과 같이 각 단어의 글자 수를 기준으로 계산됩니다.

3 글자 : 1 점

4 글자 : 1 점

5 글자 : 2 점

6 글자 : 3 점

7 글자 : 5 점

8 자 이상 : 11 점

도전

이 도전에서, 각 플레이어의 단어를 나타내는 문자열 목록을 취하고 플레이어의 점수 목록을 출력하는 프로그램 또는 함수를 작성하십시오. 최소 2 명의 플레이어가 있고 모든 단어가 3 자 이상이고 모두 소문자 (또는 원하는 경우 모든 대문자)로 가정 할 수 있습니다. 각 플레이어가 각 단어를 한 번만 사용한다고 가정 할 수도 있습니다. 즉, 플레이어 목록에는 중복이 포함되지 않습니다. 이것은 코드 골프이므로 바이트 단위의 최단 답변이 이깁니다.

규칙

적절한 형식으로 입력 할 수 있습니다. 예를 들어 문자열 목록, 쉼표로 구분 된 문자열 목록, 각 입력 행에서 쉼표로 구분 된 문자열 등이 있습니다. 출력은 정수 목록 (또는 언어와 동등한)의 형식이거나 인쇄 할 수 있습니다. 선택한 구분 기호 (예 : 줄 바꿈)를 사용하여 stdout 할 값

테스트 사례

입력 => 출력

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

껍질 , 21 20 19 바이트

Zgarb 덕분에 -2 바이트

A055228 에서 가져온 아이디어

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

온라인으로 사용해보십시오!

설명 (이전 버전)

            ṠṀ-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 바이트

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

온라인으로 사용해보십시오!

취하고 L문자열 벡터들의리스트로서; 값을 반환합니다.

먼저 unlist단어를 찾고, 중복을 찾은 다음 플레이어의 단어 목록에서 제거합니다. 그런 다음이 고유 한 단어 목록을 pmin가져와 8 개 이상의 단어가 11로 점수가 매겨 지도록 각 점수를 계산합니다 .

자바 스크립트 (ES6), 92 바이트

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의 답변 과 다소 유사 하지만 대부분 독립적으로 작성되었습니다. 나는 다른 합산 방법 ( reduce)과 반복되는 항 ( filter+ includes) 을 확인하기 위해 다른 방법을 사용했습니다 . 그래도 [1]확인하는 대신 항목을 확인하는 아이디어를 인정했습니다 .length>1.

테스트 사례

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>

자바 스크립트 (ES6), 106 93 바이트

[Arnauld, Shaggy 및 JollyJoker 덕분에 13 (!) 바이트 절약되었습니다.]

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

테스트 사례 :

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]

펄 6 , 64 바이트

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

온라인으로 사용해보십시오!

Pyth , 26 바이트

H.PWiz의 공식을 사용합니다 .

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

모든 테스트 사례를 확인하십시오.

초기 버전, 33 바이트 :

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

모든 테스트 사례를 확인하십시오.

설명

m + Fm * h +++ * 6> lk7y> lk6> lk5> glk3q1 / sQ 전체 프로그램.

m 입력을 매핑합니다.
   m 각 하위 목록을 매핑하십시오.
                        > lk3 길이가 2보다 큽니까? True이면 1, False이면 0
      +> lk5 Plus "길이가 5보다 큽니까?"
       + y> lk6 Plus "길이가 6보다 큽니까?", 두 배.
        + * 6> lk7 Plus "길이가 7보다 큽니까?", 6 번
     h 증가.
                            q1 / sQ 납작한 원소의 원소 수를 센다
                                     입력하고 1과 같은지 확인하십시오. False이면 0, True이면 1.
    * 곱셈.
 + F 각 하위 목록을 합칩니다.

하스켈 , 76 75 바이트

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

온라인으로 사용해보십시오!

Japt , 29 25 24 23 21 20 바이트

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

시도 해봐

• 스코어링을 위해 찾은 공식 H.PWiz 를 사용하여 4 바이트를 절약했습니다 .

설명

배열의 암시 적 입력 U.

Ëx@

배열 ( Ë) 위에 매핑 하고 현재 단어가있는 x다음 함수를 통해 요소를 전달한 후 추가 ( ) 하여 각 하위 배열을 줄 X입니다.

èøX

포함 된 è요소의 개수를 세십시오 ( ) .UøX

¥1

그 값이 1인지 확인하십시오.

©

논리 AND ( &&).

3nXÊm8)

n최소값 ( m) 8과 길이 ( Ê) 에서 ( ) 3을 뺍니다 X.

ʬc

계승, 제곱근 및 반올림

파이썬 (2) , 106 (105) 88 84 바이트

^{Jonathan Frech 덕분에 -1 바이트
reffu 덕분에 -1 (17) 바이트}

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]

온라인으로 사용해보십시오!

젤리 , 26 바이트

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

온라인으로 사용해보십시오!

자바 (8) 202 200 198 바이트

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

OR ( 198 바이트 )

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

불행히도 Java에는 여러 개의 존재하는 모든 목록의 모든 항목을 제거 할 수있는 기본 제공 방법이나 간단한 방법이 없습니다.

설명:

여기에서 시도하십시오.

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 바이트

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

테스트 사례 :

> 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

목록에서 한 번만 발생하는 이름을 가져와 주어진 컷오프 포인트를 기준으로 길이를 요인으로 변환 한 다음 합산 한 점수로 변환합니다.

Perl 5 , 104 + 2 (-na) = 106 바이트

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

온라인으로 사용해보십시오!

클로저, 102 바이트

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

nextnil단어가 하나만있는 경우를 반환 합니다. w:)

PHP , 226 바이트

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

나는 이것이 여전히 꽤 잘릴 수 있다고 생각합니다.

언 골프 드 :

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

온라인으로 사용해보십시오!

스칼라 , 242 바이트

이 함수는 매개 변수로 a를 가져와 aa Seq[Set[String]]를 반환합니다 Array[Int]. 변경 가능하도록 배열을 사용합니다 (4 문자 손실).

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

온라인으로 사용해보십시오!

내가 작업하지 않았기 때문에 최적화 할 수 있습니다.

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

부품. 이 도전에 감사드립니다!

스위프트 4 , 164 바이트 *

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

위의 표현은 기술적으로 정확하고 순수한 Swift입니다. 그러나식이 너무 복잡하여 형식 유추 시스템의 기하 급수적 증가로 인해 컴파일러가 임의의 시간 초과 (15 초 등) 후에 포기하기 전에 처리 할 수 ​​없습니다.

이 표현식을 현재 컴파일러에서 컴파일 할 수있게하려면 다음과 같이 분류 할 수 있습니다.

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

세분화 :

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 바이트

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.

다음과 같은 형식의 데이터가 필요합니다.

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

파이썬을 지원하는 clingo 5.2.1이 필요 합니다.

언 골프 드 :

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 함수는 python answer 에서 크게 영감을 받았습니다 .