您的任务是确定给定的字符串长度是否合适，并可以用Scrabble磁贴表示，如果是，则输出每个字母的分数之和。

如果您不知道如何玩Scrabble :，则有100个磁贴，上面印有字母A–Z，以及两个可代表任何字母的通配符。每个字母都有一定数量的点，每个图块（但不一定是单词）只能使用一次。演奏单词时，将所使用的每个图块的点值相加，即为分数。由于可用的字母数量有限，因此一个单词只能将某个字母的次数与该字母具有图块+任何未使用的通配符的次数相同。拼字游戏板的大小为15×15，因此该单词的长度必须在2到15个字符之间。

有关英文版本中每个字母的数量和分数的列表，请参见下面或http://boardgames.about.com/od/scrabble/a/tile_distribute.htm（存档）。

字母数量积分字母数量积分
------------------- -------------------
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
我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之间（包括2和15），则程序应输出Invalid。
• 否则，应使用上表中的数据将分数相加并输出。
• 除非必要，否则不要使用通配符。
• 不必担心双字得分或字符串是否为真字之类的奖金。
• 程序应通过STDOUT等输出结果。
• 默认情况下不允许存在漏洞。
• 不允许使用外部资源（例如网站）以及计算拼字游戏得分或适当数量的任何库，API，函数等。
• 这是代码高尔夫球，因此最少的字节获胜。

演练

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
PIZZAZZ无效
KIXOKEJAJAX无效
误区无效

Perl 5 228 205 186 184 178 177 153 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

此解决方案使用一些不可打印的字符，因此下面提供了一个十六进制转储：

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时，它溢出为零，因此要检查字长是否不好，我们只需检查是否i<5（我放i<9，如果用户不小心将其设置i为2，它将仍然对一个字母的单词无效。命令行上的单个参数。）

通过将循环条件测试更改为简单字节可节省4个字节&31。这要求单词以空格（ASCII 32）或空字符（ASCII 0）终止。通常，键盘输入以换行符（ASCII 10）终止，因此该程序使用起来有点不方便，因为您必须键入空格，然后也按回车键，使计算机读取缓冲区。对于以换行符结尾的字符串，我可以匹配但不能超越bebe的方式。

通过将编码更改为-（每个字母的图块数）-（该字母的分数-1）* 13来节省6 13个字节。现在，这要求范围从L，S，U的-4到Q，Z的-118。使用负数的原因是为了避免无法打印的ASCII范围0到31。使用的范围是负数256-4 = 252到256-118 = 138的二进制补码。这些是可打印的扩展ASCII字符。用Unicode复制和粘贴存在一些问题（简化回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 1173（或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，x对于E降至ASCII 40，(对于L，S，U。）使用切片数需要从120向下至10的范围。避免了。

多亏了一个#define宏，T在主程序中使用了一个符号才能i从第一个命令行参数中检索字母索引，从中减去ASCII A= 65以得到一个索引，然后在表T：中查找它t[x[1][i]-65]。

该for循环用于更像一个while循环：在循环结束时有一个零字节（串终止子）在输入字符串中遇到。

如果该字母的图块没有用尽（T/10非零）s，则按图块得分递增，T%10+1以保持总分。同时，图块得分存储在中r，因此所代表的的值T可以递减r*10以表示已使用了一个图块。如果磁贴已用尽，通配符/空白计数器b将增加。

该printf声明是不言自明的。如果字长超出范围或空白计数太高，请打印，Invalid否则打印分数s。

JavaScript（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控制台中测试。

Python 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<        @,,,,,,,<

C，197

假设该字符串作为命令行参数提供，例如 ./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);}

JavaScript的- 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"

Python 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。

说明

该模式(_:_:_)可确保仅考虑至少两个字符的字符串，其他所有结果均会产生"Invalid"（后备模式_）。磁贴表被编码为11*nTiles+value具有偏移量的ASCII 编码，该偏移量允许查找模11起作用，其中字母AEIO重复出现是因为每个字母出现6次以上。然后使用来创建图块池replicate，从中删除单词中的字符（列表差异，\\）。该池包含98个图块，因此，如果单词的长度和池的其余部分的总长度大于100，则我们使用了太多的通配符。此外，减去长度前15个字母的单词会被加到长度计算中三次，因此任何大于15个字母的单词都会自动显示用完三个通配符，因此无效。对剩余的池进行计分，该池最初有187分，我们简单地将其减去。请注意，f 61而不是f 65，65是的ASCII码'A'，因为"AEIO"在池的开始处重复。其余的只是样板。

的Python3-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

Clojure-325

我已经有一段时间没有做过Clojure了，所以我确定有几种方法可以改善我的解决方案。即，数量和积分列表

(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");}

这需要bignums，因此它将无法编译为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。