당신의 임무는 주어진 문자열이 적절한 길이이고 스크래블 타일로 표현 될 수 있는지 결정하고, 그렇다면 각 문자의 점수의 합을 출력하는 것입니다.

글자 맞추기 게임 방법을 모르는 경우 다양한 글자 A–Z가 인쇄 된 100 개의 타일과 글자를 나타내는 두 개의 와일드 카드가 있습니다. 각 문자에는 특정 개수의 점이 있으며 각 타일 (단, 반드시 단어는 아님)은 한 번만 사용할 수 있습니다. 단어가 재생되면 사용 된 각 타일의 포인트 값이 합산되어 점수가됩니다. 사용 가능한 글자 수가 제한되어 있으므로 단어에는 타일 + 사용되지 않은 와일드 카드가있는 횟수만큼만 특정 글자를 사용할 수 있습니다. 글자 맞추기 보드는 15 × 15 개의 셀이므로 단어의 길이는 2 ~ 15 자 여야합니다.

영어 버전의 각 문자의 수량 및 점수 목록은 아래 또는 http://boardgames.about.com/od/scrabble/a/tile_distribute.htm ( archive )을 참조하십시오 .

문자 수량 포인트 문자 수량 포인트
------------------- -------------------
A 9 1 O 8 1
B 2 3 P 2 3
C 2 3 Q 1 10
D 4 2 R 6 1
E 12 1 S 4 1
F 2 4 T 6 1
G 3 2 U 4 1
H 2 4 V 2 4
I 9 1 W 2 4
J 1 8 X 1 8
K 1 5 Y 2 4
L 4 1 Z 1 10
M 2 3 [야생] 2 0
N 6 1

추가 규칙

• 프로그램은 STDIN 등으로부터 단일 입력 문자열을 가져야합니다.
• 입력은 항상 대문자 만 포함합니다.
• 문자열에 해당 문자에 사용되지 않은 와일드 카드 나 타일보다 많은 문자 사본이 포함되어 있거나 문자열 길이가 2에서 15 사이가 아닌 경우 프로그램에서 출력해야합니다 Invalid.
• 그렇지 않으면 위 차트의 데이터를 사용하여 점수를 합산하여 출력해야합니다.
• 필요한 경우가 아니면 와일드 카드를 사용하지 마십시오.
• 이중 단어 점수 또는 문자열이 실제 단어인지와 같은 보너스에 대해 걱정하지 마십시오.
• 프로그램은 STDOUT 등을 통해 결과를 출력해야합니다.
• 기본적으로 금지 된 허점은 허용되지 않습니다.
• 스크래블 점수 또는 적절한 수량을 계산하는 라이브러리, API, 함수 등뿐만 아니라 웹 사이트와 같은 외부 소스를 사용하는 것도 허용되지 않습니다.
• 이것은 code-golf 이므로 가장 적은 바이트가 이깁니다.

연습

Input: CODEGOLF
C -> 3, O -> 1, D -> 2, E -> 1, G -> 2, O -> 1, L -> 1, F -> 4
3 + 1 + 2 + 1 + 2 + 1 + 1 + 4 = 15
Output: 15

테스트 케이스

입출력
------------------------
문제 14
재즈 19
스택 교환 32
XYWFHQYVZVJKHFW 81
피자
KIXOKEJAJAX가 유효하지 않습니다
잘못된 잘못

펄 5 228 205 186 184 178 177 153 150 149 142 137 135

perl -E로 실행하십시오.

골프 :

$_=<>;@a=@b=map-ord,'            0 0@0 H        ``'=~/./g;say s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

이 솔루션은 인쇄 할 수없는 문자를 사용하므로 다음과 같이 16 진 덤프가 제공됩니다.

00000000: 245f 3d3c 3e3b 4061 3d40 623d 6d61 702d  $_=<>;@a=@b=map-
00000010: 6f72 642c 2703 0904 0909 2030 2030 030e  ord,'..... 0 0..
00000020: 4030 0e20 0704 4809 1809 601d 0e0e 6027  @0. ..H...`...`'
00000030: 3d7e 2f2e 2f67 3b73 6179 2073 212e 2128  =~/./g;say s!.!(
00000040: 2461 5b24 713d 3634 2d6f 7264 2426 5d2b  $a[$q=64-ord$&]+
00000050: 3d38 293c 383f 242d 2b3d 312d 3239 2f24  =8)<8?$-+=1-29/$
00000060: 625b 2471 5d3a 2b2b 246a 2167 657e 7e5b  b[$q]:++$j!ge~~[
00000070: 322e 2e31 355d 2626 246a 3c33 3f24 2d3a  2..15]&&$j<3?$-:
00000080: 496e 7661 6c69 64                        Invalid

또는 Ctrl + Key를 사용하십시오.

$_=<>;@a=@b=map-ord,'^C^I^D^I^I 0 0^C^N@0^N ^G^DH^I^X^I`^]^N^N`'=~/./g;print s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

언 골프 + 댓글 :

# Read in input
$_=<>;
# @a and @b: represents approximately 8x the number of tiles (when rounded up). The 
#   non-multiple-of-8 values distinguish tiles that are given equally, but are worth
#  different values
@b=@a=map-ord,"...."~=/./g;
# above is equivalent to
# @a=@b=(-03,-09,-04,-09,-09,-32,-48,-32,-48,-03,-14,-64,-48,-14,-32,-07,-04,-72,-09,-24,-09,-96,-29,-14,-14,-96);
say
    # for each character
    s!.!
        # $q: A->-1, B->-2, etc.
        # decrement number of $q tiles, add points if needed, otherwise
        #    increment j, which counts number of wilds used
        # truncate(1-29/b[q]): decimal values were chosen specifically
        #    for this to return the point value. b[q] is the number of tiles
        #    of the qth letter after a originally given.
        #  $- contains the score, is initially zero (if in a one line program, 
        #   as the golfed version is), and is always an integer
        ($a[$q=64-ord$&]+=8)<8 ? $- += 1 - 29/$b[$q] : ++$j
    # s returns length, check if between 2 and 15
    !ge ~~ [2..15]
    # make sure less than 3 negative tiles (aka wilds) 
    && $j < 3 ?
        # print score
        $-
    # or invalid
    : Invalid

C, 계 2 151 145 138

@bebe의 의견에서 159 바이트 코드에서 영감을 얻은 다른 8 14 21 문자를 압착 했습니다.

길이 카운터를 재정렬하여 4 바이트를 절약했습니다 i. 이것은 1로 초기화되고 (프로그램이 인수를 취하지 않는다고 가정) 문자를 읽을 때마다 4를 곱합니다. 단어 길이가 15보다 클 때 0으로 오버플로되므로 단어 길이가 나쁜지 확인하기 위해 간단히 확인합니다 i<5( i<9사용자가 실수 i로 2를 입력하여 실수 로 2를 intialis하면 1 문자 단어에 대해서는 유효하지 않습니다) 명령 행의 단일 인수)

루프 조건 테스트를 단순으로 변경하여 4 바이트를 절약했습니다 &31. 이를 위해서는 단어가 공백 (ASCII 32) 또는 널 문자 (ASCII 0)로 끝나야합니다. 일반적으로 키보드 입력은 개행 (ASCII 10)으로 종료되므로 프로그램을 사용하기에 약간 불편합니다. space를 누른 다음 return 키를 눌러 컴퓨터가 버퍼를 읽도록합니다. 줄 바꿈으로 끝나는 문자열의 경우 일치하는 방식을 사용할 수는 있지만 원하는 방식을 이길 수는 없습니다.

6 인코딩을 -(각 문자의 타일 수)-(해당 문자의 점수 -1) * 13 으로 변경하면 13 바이트가 절약됩니다 . 이제 L, S, U의 경우 -4부터 Q, Z의 경우 -118까지의 범위가 필요합니다. 음수를 사용하는 이유는 인쇄 할 수없는 ASCII 범위 0 ~ 31을 피하기위한 것입니다. 대신 사용 된 범위는 음수 256-4 = 252에서 256-118 = 138의 2의 보수입니다. 인쇄 가능한 확장 ASCII 문자입니다. 유니 코드로 복사하여 붙여 넣는 데 문제가 있습니다 (ASCII로 단순화하는 방식은 설치된 코드 페이지에 따라 예기치 않은 결과를 초래할 수 있습니다). 그래서 프로그램 주석에 올바른 ASCII 코드를 포함 시켰습니다.

이 인코딩의 장점은 r타일 ​​수가 항상 1 씩 줄어들 기 때문에 변수가 제거 된다는 것입니다 (음수로 저장되기 때문에 우리는 t[x]++.) 또한 접미사 연산자는 에 점수를 추가합니다 s.

//char t[]={32,247,228,228,239,244,215,240,215,247,164,203,252,228,250,248,228,138,250,252,250,252,215,215,164,215,138,0};
b,s;
main(i,x){
  for(char t[]=" ÷ääïô×ð×÷¤ËüäúøäŠúüúü×פ׊";x=getchar()&31;i*=4)
    t[x]%13?
      s-=t[x]++/13-1:
      b++;
  printf(i<9|b>2?"Invalid":"%d",s);
} 

C, 184 Rev 1 173 (또는 컴파일러 옵션이있는 172)

GCC를 사용하고 있으며 컴파일러 옵션 -std=c99을 사용하면 하나의 추가 세미콜론을 절약하기 위해 루프 char t[]="...."초기화 로 이동할 수 for있습니다. 가독성을 위해이 변경없이 공백이 남아있는 프로그램을 보여주었습니다.

#define T t[x[1][i]-65]
i,b,s;
main(int r,char**x){
  char t[]="Z>>QxS=SZW6(><P>m<(<(SSWSm";
  for(;x[1][i];i++)
    T/10?
      s+=r=T%10+1,T-=r*10:
      b++;
  printf(i<2|i>15|b>2?"Invalid":"%d",s);
}

트릭은 데이터 테이블에 있습니다. 각 문자에 대해 ASCII 문자 (해당 문자의 총 타일 점수) * 10 + (한 타일의 점수 -1) 가 표에 저장됩니다 t[]. 런타임에 타일이 모두 사용됨에 따라 이러한 총 점수가 줄어 듭니다.

각 문자에 대한 모든 타일의 총 점수는 E의 경우 12에서 L, S, U의 경우 4까지입니다. 이 형식의 인코딩을 사용하면 인쇄 가능한 ASCII 문자 만 사용할 수 있습니다 (ASCII 120, xE의 경우 ASCII 40, (L, S, U의 경우). 타일 수 를 사용하려면 120에서 10까지의 범위가 필요합니다. 피했다.

#define매크로 덕분에 T주 프로그램에서 단일 기호 를 사용 i하여 첫 번째 명령 줄 인수에서 문자 색인을 검색하고 ASCII A= 65를 빼서 색인을 제공하고 표 T :에서 찾습니다 t[x[1][i]-65].

for루프는 더 같이 사용되는 while루프 : 루프 단부 0 바이트 (문자열 터미네이터)이 입력 문자열에서 발생할 때.

해당 문자의 타일이 소진되지 않은 경우 ( T/100이 아닌 경우) s타일 ​​점수만큼 증가 T%10+1하여 총 점수를 유지합니다. 동시에 타일 점수가에 저장 r되므로로 표시 T할 수있는의 값이 감소하여 r*10하나의 타일이 사용되었음을 표시 할 수 있습니다 . 타일이 소진되면 와일드 카드 / 빈 카운터 b가 증가합니다.

printf문은 매우 자명하다. 단어 길이가 범위를 벗어 났거나 공백 수가 너무 많으면 인쇄하고 Invalid그렇지 않으면 점수를 인쇄하십시오 s.

자바 스크립트 (ES6)- 241 230 199 182

f=s=>{for(i=t=_=0,E=12,A=I=9,B=C=M=P=28,D=17,F=H=V=W=Y=41,G=16,J=X=92,K=53,L=S=U=4,N=R=T=6,O=8,Q=Z=118;c=s[i++];)this[c]%13<1?_++:t+=1+this[c]--/13|0;alert(i<3|i>16|_>2?"Invalid":t)}

편집 -크기 / 점수를 인코딩하여 크기를 줄이고 ASCII가 아닌 변수를 제거하는 방식이 변경되었습니다.

편집 2- 수량 / 점수 인코딩을 문자열 대신 정수로 변경했습니다.

편집 3 - %13(@ edc65 덕분에)로 전환하고 인코딩을 반전시키고 값을 직접 수정했으며 몇 가지 사소한 개선 사항이 있습니다.

Firefox 콘솔에서 테스트되었습니다.

파이썬 3, 217 201

b=2;i=s=0;w=input()
while i<26:n=w.count(chr(i+65));q=int('9224c232911426821646422121'[i],16);b-=max(0,n-q);s+=min(n,q)*int('1332142418513113a11114484a'[i],16);i+=1
print(["Invalid",s][-b<1<len(w)<16])

언 골프 드 :

b=2    # number of blanks available
i=s=0  # letter index 0..25, running score tally
w=input()

# Loop through each letter of the alphabet
while i<26:
    # Get number of occurrences in the word
    n=w.count(chr(i+65))
    # Get quantity of the letter from hex encoded string
    q=int('9224c232911426821646422121'[i],16)
    # Remove blanks for each occurrence over that letter's quantity
    b-=max(0,n-q)
    # Score the non-blank tiles, getting scores from hex-encoded string
    s+=min(n,q)*int('1332142418513113a11114484a'[i],16)
    # Increment
    i+=1

# If b > -1 and 1 < len(w) < 16, print the score; otherwise, print "Invalid"
print(["Invalid",s][-b<1<len(w)<16])

편집 : @ BeetDemGuise 덕분에 궁극적으로 1 자 이상을 줄였습니다. 아래의 원본 코드 :

q=[77-ord(x)for x in'DKKIAKJKDLLIKGEKLGIGIKKLKL'];b=2;s=0;w=input()
for c in set(w):n=w.count(c);o=ord(c)-65;b-=max(0,n-q[o]);s+=min(n,q[o])*(1+int('02210313074020029000033739'[o]))
print(["Invalid",s][-b<1<len(w)<16])

BEFUNGE 93-210 바이트

그러나 15 글자 제한을 확인하지 않습니다.

v1332142418513113:11114484: >01g:"0"-!#v_1-01p1+\v
 9224<232911426821646422121v  "Invalid"<      vp0<
<vp00p10"20"p200p900
>>~:55+-!#v_"@"-::1g:"0"-! #^_1-\1p0g+"0"-02g+>02p
_v#:-1<    #p90+g90-"0"g1:<
     @.g20<        @,,,,,,,<

197 년 C

문자열이 명령 행 인수로 제공되었다고 가정합니다. 예 : ./scrabble STACKEXCHANGE

s;n;m=31;main(int c,char**v){char d[]="BIBBDLBCBIAADBFHBAFDFDBBABA@ACCBADBDAHEACAACJAAAADDHDJ";for(;c=*v[1]++&m;d[c]--,s+=d[c+27]&m)n+=1+m*(!(d[c]&m||d[c=0]&m));printf(n>1&&n<16?"%d":"Invalid",s);}

자바 스크립트 - 232 (201)

t=[9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1];w=r=0;for(i=y=z.length;i--;){x=z.charCodeAt(i)-65;if(!t[x])w++;else{t[x]--;r+=-~"02210313074020029000033739"[x]}}alert(w>2|y<2|y>15?"Invalid":r)

z단어를 저장합니다. 경고로 출력합니다.

편집 : 아래 권장 사항에 따라 개선되었습니다.

하스켈-538

scrabble.hs로 저장 한 다음 다음을 사용하여 컴파일하십시오.

ghc --make scrabble && ./scrabble

그런 다음 단어를 입력으로 입력하고 Enter 키를 누릅니다

l=['A'..'Z']
sc=zip l [1,3,3,2,1,4,2,4,1,8,5,1,3,1,1,3,10,1,1,1,1,4,4,8,4,10]
vfs a y =snd $ filter (\x -> fst x == y) a !! 0
q = zip l [9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1]
i s =filter (\x -> (fst x) >=0) [(length [x | x <- s, x == a] - vfs q a,a) | a <- l]
main = do
 s <- getLine
 if length s <= 15 && length s > 2 && sum (map fst (i s)) <= 2 then
  putStrLn $ show (sum [vfs sc x| x <- s] - sum [(vfs sc (snd x)) * (fst x) | x <- (filter (\x -> fst x > 0) (i s))])
 else do
  putStrLn "Invalid"

파이썬 2.7-263

DLosc의 답변에 가까운 곳은 올 수 없었지만 , 이것은 각 문자를 당신이 가져 오는 '가방'으로 취급합니다.

S=input().lower()
X={chr(97+i):[int(y)+1]*(77-ord(x))for i,(x,y)in enumerate(zip('DKKIAKJKDLLIKGEKLGIGIKKLKL','02210313074020029000033739'))}
B=[0,0]
try:
 if len(S)>15:1/0
 print sum(map(lambda x:X[x].pop()if len(X[x])>0 else B.pop(),S))
except:
 print "invalid"

하스켈, 290 283

내가 지금까지 할 수있는 한

import Data.List
t="CdC8d::Od;D;d41N:dd:6dNdN;;4;6"
s w@(_:_:_)=let d=concat(zipWith(replicate.(`div`11).f 33)t("AEIO"++['A'..]))\\w;y=drop 15w in if length(d++w++y++y++y)>100 then s""else show$187-(sum$map((`mod`11).f 0.(t!!).f 61)d)
s _="Invalid"
f n=(-n+).fromEnum
main=interact s

이 코드는 규칙을 엄격하게 준수하므로 추가 문자 (예 : 줄 끝)를 전달하지 마십시오. 다음과 같이 사용하십시오 echo -n "JAZZ" | runghc scrabble.hs.

설명

이 패턴을 (_:_:_)사용하면 최소 2 자 이상의 문자열 만 고려하고 나머지는 모두 "Invalid"(대체 패턴 _)이됩니다. 타일 ​​테이블은 11*nTiles+value조회 모듈로 11이 작동 할 수있는 오프셋을 사용하여 ASCII 로 변환 된 것으로 인코딩되며 문자 AEIO가 각각 6 번 이상 발생하기 때문에 문자 가 복제됩니다. 그런 다음을 사용하여 타일 풀을 만들어 replicate단어의 문자가 나타날 때 제거합니다 (차이 목록,\\). 풀에는 98 개의 타일이 포함되어 있으므로 단어의 전체 길이와 풀의 나머지 부분이 100보다 크면 너무 많은 와일드 카드를 사용한 것입니다. 또한 첫 15자를 뺀 단어는 길이 계산에 3 번 더해 지므로 15자를 초과하는 단어는 자동으로 3 개의 와일드 카드를 사용하는 것으로 나타나므로 유효하지 않습니다. 채점은 나머지 웅덩이에서 이루어지며, 처음에는 187 포인트가 있었으며 우리는 단순히 빼버 렸습니다. 풀 시작 부분의 중복으로 인해 , 65가 f 61아닌 f 65ASCII 번호가임을 유의하십시오 . 나머지는 단지 상용구입니다.'A'"AEIO"

파이썬 3-197

s,i,c,r=input(),0x1a24182424416141611a2381612341151891243224c142232391,[],[]; p=len(s)
for w in s:e=8*ord(w)-520;c+=[s.count(w)<=i>>e+4&15];r+=[i>>e&15]
print(['Invalid',sum(r)][all([p>2,p<15]+c)])

bignums를 사용합시다 : D (현재 와일드 카드를 처리하지 않습니다, 나는 그 규칙을 완전히 읽지 않았습니다.)

루비-195

b=2
i=s=0
w=$*[0]
(?A..?Z).map{|l|n=w.count(l);q='9224c232911426821646422121'[i].to_i(16);b-=[0,n-q].max;s+=[n,q].min*'1332142418513113a11114484a'[i].to_i(16);i+=1}
p(-b<1&&w.size<16?s:'Invalid')

나는 출력 "Invalid"이 괜찮다고 가정하고 있습니다. 그렇지 않으면 $><<(-b<1&&w.size<16?s:'Invalid')198까지 범프 할 것입니다.

클로저-325

한동안 clojure를하지 않았으므로 솔루션을 개선하는 여러 가지 방법이 있습니다. 즉 qty 및 pts 목록

(let[w(first *command-line-args*)o(map #(count(filter #{%}(seq w)))(map char(range 65 91)))i(apply +(filter neg?(map #(- % %2)'(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1) o)))](println(if(or(> -2 i)(not(<= 2(count w)15)))"Invalid"(apply +(map #(* % %2)o'(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10))))))

언 골프하는 것

(let [word    (first *command-line-args*)
      letters (map char(range 65 91))
      occ     (map #(count (filter #{%} (seq word))) letters)
      invalid (apply + (filter neg? (map #(- % %2)
                '(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1)
                occ)))
      score   (apply + (map #(* % %2) occ '(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10)))]
    (println
      (if (or (> -2 invalid)
              (not (<= 2 (count word) 15)))
        "Invalid"
        score)))

ES6 : 184 (엄격하지 않음)

w단어를 이미 포함하고 있다고 가정합니다. r출력 문자열입니다.

i=0,o=[..."291232342c124322491181541236181231a61416141242418241a"].map(c=>parseInt(c,16)),r=!w[16]&&w[2]&&[...w].every(c=>o[c=c.charCodeAt()*2-129]-->0?i+=o[c+1]:o[0]--)?i+"":"Invalid"

다음은 설명하고 약간 덜 골프입니다.

// The sum.
i = 0,

// The data for the letters. It's encoded similar to the Ruby version, with
// the first being the wildcard holder. The rest hold in hex form the
// following: first = quantity left, second = value.
// The .map(c => parseInt(c, 16) simply parses all the hex characters.
o = [..."291232342c124322491181541236181231a61416141242418241a"]
  .map(c => parseInt(c, 16)),

// The result, `r`.
r = !w[16] || // If there is a 16th character in the word or no 2nd character,
    w[2] &&   // then the next section isn't evaluated. It immediately equates
              // to true, thus returning "Invalid".
   [...w] // Convert the string into an array of characters (ES6 equivalent to
          // `.split('')`
    .every(c => // This loop terminates when the callback returns a falsy
                // value.
      // Gets the ASCII value, subtracts 65, doubles it (the lookup table is
      // in pairs within one array), and decrements the counter at that entry.
      // The lookup table also doubles as a data holder.
      o[c = c.charCodeAt() * 2 - 129]--
        > 0 ?  // Test if there is something to take away. This must return
               // false at 0 and -1 so wildcards can be taken.
        i += o[c+1] : // If there was something to take away, then add the
                      // letter value to the sum.
        o[0]--) // Otherwise, take a wildcard. If this is already at 0, then
                // it returns falsy.
      ? "Invalid" : i + "" // This is where the text is returned.

다트-201

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:2}){if((m=a[0].length)>1&&m<16)for(i in a[s=0].codeUnits)x>>(m=i*8-520)&15>0?r+=(x-=1<<m)>>m+4&15:++s;print(s<2?r:"Invalid");}

큰 숫자가 필요하므로 JavaScript로 컴파일되지 않습니다.
더 많은 공백으로 :

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:3}){
  if((m=a[0].length)>1&&m<16)
    for(i in a[s=0].codeUnits)
      x>>(m=i*8-520)&15>0
      ? r+=(x-=1<<m)>>m+4&15
      : ++s;
  print(s<3?r:"Invalid");
}

PHP, 180 (170) 168 바이트

for($q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);$o=31&ord($argv[1][$i++]);)$s+=$q[$o]++>L?$q[0]++>L?$f=1:0:X02210313074020029000033739[$o]+1;echo$f|$i<3|$i>16?Invalid:$s;

예이! JS를 때리는!

고장

for(
    $q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);  // init quantities: L=1,A=12
    $o=31&ord($argv[1][$i++]);                  // loop through characters: map to [1..26]
)
    $s+=                                          // increase score by ...
        $q[$o]++>L?                                 // old quantity below 1?
        $q[0]++>L?$f=1                              // no more wildcards? set error flag
        :0                                          // wildcard: 0 points
        :X02210313074020029000033739[$o]+1;         // else: letter score
echo$f|$i<3|$i>16?Invalid:$s;                   // output

나는 10보다 큰 문자 점수가 없다는 것이 기쁘다.