挑战：

以一串大写或小写字母作为输入（可选），并计算该字符串在英语拼字游戏中的得分。

规则：

每个字母的得分如下（即使有其他版本的游戏，也要使用该得分）：

1 point: E, A, I, O, N, R, T, L, S, U
2 points: D, G
3 points: B, C, M, P
4 points: F, H, V, W, Y
5 points: K
8 points: J, X
10 points: Q, Z

字符串的分数就是所使用的每个字母的分数之和。您可能会假设您有很多可用的图块，因此，长单词以及带有许多相同字母的单词都是有效的输入。

测试用例：

ABC       ->    7
PPCG      ->   11
STEWIE    ->    9
UGPYKXQ   ->   33
FIZZBUZZ  ->   49
ABCDEFGHIJKLMNOPQRSTUVWXYZ  -> 87

每种语言中最短的答案将获胜！输入和输出格式很灵活，因此您可以根据需要将输入作为字符数组（大写或小写）使用。

sed的4.2.2，81

s/[QZ]/JD/g
s/[JX]/KB/g
s/K/FE/g
s/[FHVWY]/BE/g
s/[BCMP]/DE/g
s/[DG]/EE/g
s/./1/g

输出为一元。

将每个字母缩减为分数较低的字母的组合，直到所有字母均为1分数。然后用1s 替换那些以给出一元计数。

在线尝试！

Haskell，86 84字节

f s=length s+sum[n|x<-s,(n,y)<-zip(9:7:[1..])$words"QZ JX DG BCMP FHVWY K",x`elem`y]

在线尝试！

说明

大多数字母的分数为1，因此我们不需要跟踪这些分数，而是只递减每个分数（也节省1个字节10），然后将字符串的长度添加到结果分数中。

感谢@nimi提供-2个字节（重新排列单词并使用[1..]代替[4,3..]！）！

八度，50字节

@(t)'				'/3*sum(65:90==t')'

在线尝试！

接受挑战。说明：

@(t)             % Define anonymous function taking a single argument t.
    ' ... '/3    % Row vector with letter scores. Corresponds to char([1 3 3 2 ...]*3). 
                 % The factor 3 was necessary to avoid a newline.

*                % Dot product (yes, * is dot product, .* is not. Go figure). Equivalent to sum of element-wise products.
     65:90       % Alphabet
          ==t'   % Broadcast equality with input string.
 sum(         )  % Sum this matrix. Gives the count of each letter in the alphabet
               ' % Transpose into column vector for dot product

Beatnik，733字节

既然确实必须完成，就在这里。调试真的很麻烦，并提出了一些挑战。

输入内容只能为大写字母。输出是一元的（希望可以吗？）

J K ZZZZZZK Z ZD ZB ZZZZZZZZZZZZZZZZZA K A Z ZD ZB ZZZZZZZZZZZZZZZKF K A Z ZD ZB ZZZZZZZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZZZZZZZ K A Z ZD ZB ZZZZZZZZZZZZZZKD K A Z ZD ZB ZZZZZZZZZZZZZD K A Z ZD ZB ZZZZZZZZZZZZZD K A Z ZD ZB ZZZZZZZZZZZZ K A Z ZD ZB ZZZZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZKA K A Z ZD ZB ZZZZZZZZZKF K A Z ZD ZB ZZZZZZZZZZK K A Z ZD ZB ZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZB K A Z ZD ZB ZZZZZZZZKD K A Z ZD ZB ZZZZZZZK K A Z ZD ZB ZZZZKB K A Z ZD ZB ZZZZZZKF K A Z ZD ZB ZZZZZZB K A Z ZD ZB ZZZZZFB K A Z ZD ZB ZZZZZA K A Z ZD ZB ZZZAK K A Z ZD ZB ZZZ K A Z ZD ZB ZD K A Z ZD ZB ZKB K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K A ZKA ZZZZZZZZZZZZZZZZZZY

在线尝试！

一般过程是：

• 从输入中获取字符
• 减65
• 检查结果是否为0
  • 如果为0，则跳到指定字数
  • 否则，减1并重复检查。
• 跳转目标是推式打印操作，然后是循环回到程序开头。

以错误结束。

更完整的解释：

J K ZZZZZZK Z ZD               # Get input and subtract 65
ZB ZZZZZZZZZZZZZZZZZA K A Z ZD # Character A - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZKF K A Z ZD  # Character B - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZB K A Z ZD   # Character C - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZ K A Z ZD    # Character D - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZKD K A Z ZD   # Character E - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZD K A Z ZD     # Character F - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZD K A Z ZD     # Character G - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZ K A Z ZD       # Character H - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZB K A Z ZD      # Character I - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZKA K A Z ZD        # Character J - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZKF K A Z ZD        # Character K - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZK K A Z ZD        # Character L - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZB K A Z ZD         # Character M - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZB K A Z ZD         # Character N - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZKD K A Z ZD         # Character O - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZK K A Z ZD           # Character P - if 0 jump to print, otherwise subtract 1
ZB ZZZZKB K A Z ZD             # Character Q - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZKF K A Z ZD           # Character R - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZB K A Z ZD            # Character S - if 0 jump to print, otherwise subtract 1
ZB ZZZZZFB K A Z ZD            # Character T - if 0 jump to print, otherwise subtract 1
ZB ZZZZZA K A Z ZD             # Character U - if 0 jump to print, otherwise subtract 1
ZB ZZZAK K A Z ZD              # Character V - if 0 jump to print, otherwise subtract 1
ZB ZZZ K A Z ZD                # Character W - if 0 jump to print, otherwise subtract 1
ZB ZD K A Z ZD                 # Character X - if 0 jump to print, otherwise subtract 1
ZB ZKB                         # Character Y - if 0 jump to print, otherwise subtract 1
K ZZZZKF KF                    # Jump Point for print 1111111111
K ZZZZKF KF                    #
K ZZZZKF KF                    # Jump Point for print 11111111
K ZZZZKF KF                    #
K ZZZZKF KF                    #
K ZZZZKF KF                    # Jump Point for print 11111
K ZZZZKF KF                    # Jump Point for print 1111
K ZZZZKF KF                    # Jump Point for print 111
K ZZZZKF KF                    # Jump Point for print 11
K ZZZZKF KF                    # Jump Point for print 1
K A ZKA ZZZZZZZZZZZZZZZZZZAAAA # Jump back to start

脑高射炮，210，204，198，184，170个字节

({<([{}]<>(({}{}))(([][][][][])<((([]())<([][])>))((((()))))>)[](((()()())<((()))>)((())()()()()))((())()()())((()())()())[]((((())())()))(())){({}<{}>())}>{}{}<{{}}><>})

在线尝试！

感谢@JoKing节省了14个字节！

可读版本：

({              # For each character

                # Push array of letter scores
                # Also adjust character to 1-indexing
        <([{}]<>
        (({}{}))    # Push 2 0s
        (([][][][][])   # 10
        <((([]())   # 4
        <([][])>    # 8
        ))      # 4,4
        ((((()))))> # 1,1,1,1
        )       # 10
        []      # Add 12 to difference
        (((()()())  # 3
        <((()))>    # 1,1
        )       # 3
        ((())()()()())) # 1, 5
        ((())()()())    # 1, 4
        ((()())()())    # 2, 4
        []      # Add 22 to difference
        ((((())())()))  # 1,2,3
        (())        # 1
        )   # Push 65-char

        {({}<{}>())} # Index character into score array
        >
        {}{}         # Add score to running total
        <{{}}><>     # Clear the stack

})               # Implicit print of total score

Pyth，40个字节

sm+2x.e}dbc." zØÍ jÙ¹>;%OG5§"\ 1

在这里尝试

说明

sm+2x.e}dbc." zØÍ jÙ¹>;%OG5§"\ 1
 m                              Q  For each character in the (implicit) input...
    x.e  b                     1   ... find the first index in...
          c." zØÍ jÙ¹>;%OG5§"\     ['dg','bcmp','fhvwy','k','','','jx','','qz']
       }d                          ... containing the character...
  +2                               ... 2-indexed.
s                                  Take the sum.

Python 2，78个字节

lambda x:sum(map(('ABCEIKLMNOPRSTU'+'BCDGMPQZ'*2+'FHJJKQQVWXXYZZ'*4).count,x))

在线尝试！

较短的版本，DanielIndie的答案的端口，71 70字节

^{-1个字节，感谢Sunny Patel}

lambda x:sum(int('02210313074020029000033739'[ord(c)-65])+1for c in x)

在线尝试！

JavaScript（Node.js），71 66 63 62字节

• @Arnauld很棒，因为总是减少7个字节
• 多亏了l4m2减少了1个字节

s=>Buffer(s).map(x=>s="02210313074020029000033739"[x-65]-~s)|s

在线尝试！

Java 8，75 71 70字节

s->s.chars().map(c->"\n\n".charAt(c-65)).sum()

-1字节（通过更改"02210313074020029000033739".charAt(c-65)-47为unprintables（和两个\n）），因此-47可以将其删除。受到@Sanchises的Octave答案的启发。

在线尝试。

s->          // Method with String parameter and integer return-type
  s.chars()  //  Loop over the characters as IntStream
   .map(c->"\n\n".charAt(c-65))
             //   Convert the character to its value
   .sum()    //   And sum it all together

八度 / MATLAB，85字节

@(x)sum([1:4 7 9]*any(reshape(char(strsplit('DG BCMP FHVWY K JX QZ')),6,1,5)==x,3)+1)

在线尝试！

果冻，19 字节

Oị“ÆẠḃbṂƬɠF#ṁ²’ḃ⁵¤S

接受大写字符列表的单子链接，该列表返回一个整数

在线尝试！或查看测试套件。

怎么样？

Oị“ÆẠḃbṂƬɠF#ṁ²’ḃ⁵¤S - Link: list of characters
O                   - ordinals ('A'->65, B->66...)
                 ¤  - nilad followed by link(s) as a nilad:
  “ÆẠḃbṂƬɠF#ṁ²’     -   literal 14011114485013321424185131
                ⁵   -   literal 10
               ḃ    -   bijective-base = [1,3,10,1,1,1,1,4,4,8,4,10,1,3,3,2,1,4,2,4,1,8,5,1,3,1]
 ị                  - index into (1-based & modular) (vectorises)
                    -  i.e. mapping from: O P  Q R S T U V W X Y  Z A B C D E F G H I J K L M N)
                  S - sum

R，90 63字节

function(W,u=utf8ToInt)sum(u('

')[u(W)-64])

在线尝试！

将输入作为大写字符串。R可以毫无问题地处理不可打印的内容和多行字符串，所以很好。现在，我们几乎是外部软件包的两倍！

而且由于CRAN具有许多随机的优点：

R + ScrabbleScore 31字节

ScrabbleScore::sws(scan(,""),F)

在线尝试！

可悲的是，sws默认情况下检查有效性。

表情符号，358字节

🐖🔥➡️🔡🍇🍮s 0🔂l🍡🐕🍇🍮s➕s🍺🐽🍯🔤a🔤1🔤e🔤1🔤i🔤1🔤l🔤1🔤n🔤1🔤o🔤1🔤r🔤1🔤s🔤1🔤t🔤1🔤u🔤1🔤d🔤2🔤g🔤2🔤b🔤3🔤c🔤3🔤m🔤3🔤p🔤3🔤f🔤4🔤h🔤4🔤v🔤4🔤w🔤4🔤y🔤4🔤k🔤5🔤j🔤8🔤x🔤8🔤q🔤10🔤z🔤10🍆🔡l🍉🍎🔡s 10🍉

在线尝试！

说明：

我将变量名从单个字母更改为更有意义的词，并扩展了代码的某些部分，以期使不熟悉该语言的人更易读。您可以在此处测试扩展程序。

🐋🔡🍇      👴 define a class that takes a string
 🐖🔥➡️🔡🍇    👴 define a method that returns a string
  🍦values🍯    👴 create int dictionary
   🔤a🔤1 🔤e🔤1 🔤i🔤1 🔤l🔤1 🔤n🔤1 🔤o🔤1 🔤r🔤1 🔤s🔤1 🔤t🔤1 🔤u🔤1 🔤d🔤2 🔤g🔤2
   🔤b🔤3 🔤c🔤3 🔤m🔤3 🔤p🔤3 🔤f🔤4 🔤h🔤4 🔤v🔤4 🔤w🔤4 🔤y🔤4 🔤k🔤5 🔤j🔤8 🔤x🔤8
   🔤q🔤10 🔤z🔤10
  🍆        👴 ^ dictionary contains letters(keys) and their numerical values

  🍮score 0                         👴 declare 'score' variable and set to 0
   🍦iterator🍡🐕                     👴 transform input string to iterator
    🔂letter iterator🍇                👴 iterate over each byte in input string
     🍮score➕score 🍺🐽values 🔡letter   👴 add value of each letter to score
   🍉
  🍎🔡score 10    👴 return the score as a string
 🍉
🍉

🏁🍇          👴 begin the program here
 😀🔥🔤abc🔤    👴 call scoring method and print the score
 😀🔥🔤ppcg🔤    👴 repeat with other test cases
 😀🔥🔤stewie🔤
 😀🔥🔤fizzbuzz🔤
 😀🔥🔤abcdefghijklmnopqrstuvwxyz🔤
🍉

05AB1E，21个字节

将输入作为小写字符列表。

•_JÊ¿ùã$Ƶ½œM•11вAIkèO

在线尝试！ 或作为测试套件

八度，73字节

@(x)sum('09977433333222211'(([~,y]=ismember(x,'QZJXKFHVWYBCMPDG'))+1)-47)

在线尝试！

用于ismember将输入流中的每个字符映射x到查找字符串中的索引'QZJXKFHVWYBCMPDG'。找不到的任何元素都将映射到索引0（这将包含1点字符）。

接下来，我们在索引中添加1，以使0成为有效的1索引引用，并查找字符串'09977433333222211'。这比第一个查询字符串长一个元素。这些数字代表原始字符串中每个元素的点值减去1，而额外的元素在处为'0' beginning。

最后，通过减去47（'0'-1）将结果字符串转换为整数，得出每个字母的点值，然后将所有点值相加。

C ++，95个字节

char*m="02210313074020029000033739";
int f(char*p){int n=0;while(*p)n+=m[*p++-65]-47;return n;}

在线尝试（不提供TIO链接）

说明：

• 声明m，每个字母的值的数组，顺序为负1。负1是因为Q和Z：我在那里不能有两位数字
• 遍历字符串，p直到获得空字符，然后添加数字的分数（*p给我们字母，-65这样我们就可以正确索引数组了）。由于m是a，char*因此它转换为achar，所以我们减去48所以把它带回0，但添加1因为m作为一个得分少的每个字符声明。

_{我在这里不是狂热的海报，所以我希望我做得正确。我相信他们会n在打印值时返回计数，并且声明一个函数很好。}

Haskell，66个字节

sum.map(\c->1+read["02210313074020029000033739"!!(fromEnum c-65)])

在线尝试！与DanielIndie的JavaScript答案相同的方法。

Haskell，82 81字节

sum.map(\c->1+sum(read.pure<$>lookup c(zip"DGBCMPFHVWYKJXQZ""1122223333347799")))

在线尝试！

PowerShell，60字节

$args|% t*y|%{$s+='02210313074020029000033739'[$_-65]-47}
$s

在线尝试！

Japt，36个字节

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

将输入作为小写字符串，返回一个数字。
简短说明：

£2+`dg
¬       // Split the input into chars,
 £      // then map over each char, returning
  2+`dg // 2 plus

qz`·bøX
    bøX // the char's index in
qz`·    // the hardcoded string split by newlines.
x       // And finally sum the whole thing.

在线尝试！

红宝石，60字节

->s{s.sum{|c|"BDDCBECEBIFBDBBDKBBBBEEIEK"[c.ord-65].ord-65}}

在线尝试！

Lambda，接受输入作为（大写）字符数组并返回整数。

Perl 5，50 -pF个字节

_1DG2BCMP3FHVWY4K7JX9QZ=~/\d\D*$_/,$\+=1+$&for@F}{

在线尝试！

Gforth，109个字节

: V s" 1332142418513113:11114484:" ; : C 0 NAME 0 DO DUP C@ 65 - V DROP + C@ 48 - ROT + SWAP 1+ LOOP DROP . ;

输入必须为大写：
C PPCG 11 OK

可读的

\ String used as table with values for each letter in the alphabet
\ : follows 9 in the ASCII-table
: V
   s" 1332142418513113:11114484:"
;

: C
   0                   \ Initialize sum        ( sum               )
   NAME                \ Get the string        ( sum  c-addr count )
   0 DO                \ Start of loop         ( sum  c-addr       )
      DUP C@           \ Get letter            ( sum  c-addr char  )
      65 -             \ Calculate table index ( sum  c-addr index )
      V DROP + C@      \ Get table entry       ( sum  c-addr entry )
      48 -             \ Calculate entry value ( sum  c-addr value )
      ROT + SWAP       \ Update sum            ( sum' c-addr       )
      1+               \ Next character        ( sum' c-addr'      )
   LOOP
   DROP .              \ Drop c-addr and print result
;

在线尝试！

Perl 6，52个字节

{TR/A..Z/02210313074020029000033739/.comb.sum+.ords}

在线尝试！

将每个字符映射到一个数字，并对它们求和。并为每个字符加1，因为在不产生unicode字节的情况下没有数字10。

视网膜0.8.2，41字节

T`BCDGJKMPQXZF\HVWY`221174229793
.
$*..
.

在线尝试！链接包括测试用例。说明：与Haskell答案一样，非平凡的字母被转换为比其分数小1的字母，而当字符转换为一进制时，稍后又添加1。把FHVWY最后让他们都映射到3分+ 1。

C（gcc），78 72字节

i;f(char*s){for(i=0;*s;)i+="\n\n"[*s++-65];s=i;}

该字符串中实际上有26个字符。查看正确呈现的代码，然后在此处运行。

感谢gastropner打高尔夫球6个字节。

非高尔夫版本：

i; // declare a variable to store the score; it is implicitly of type int
f(char* s) { // function taking a string as argument and implicitly returning an int
    for(i = 0; // initialize the score to 0
        *s; ) // iterate over the string until we hit terminating NUL byte
        i += "\n\n"[*s++ - 65]; // this is a 26-char string containing the ASCII equivalent of each numeric scrabble value; 65 is ASCII code for 'A', mapping the alphabet onto the string
    s = i; // implicitly return the score
}

Excel，91字节

{=LEN(A1)+SUM(0+("0"&MID("02210313074020029000033739",CODE(MID(A1,ROW(A:A),1)&"z")-64,1)))}

说明：

• 输入在单元格中 A1
• 必须使用Ctrl+ Shift+ 将公式作为数组公式输入Enter，这会将大括号添加{ }到两端。
• MID(A1,ROW(A:A),1) 依次提取每个字符（还有很多空值，因为它将返回与工作表中的行一样多的值）
• CODE(MID(~)&"z")提取每个字符的ASCII值。该&"z"追加z的结束MID()，因为结果CODE()不是真的喜欢空输入。不过，的ASCII值z高于每个大写字母，因此稍后会被有效忽略。
• MID("02210313074020029000033739",CODE(~)-64,1) 根据分数字符串的ASCII值（向下调整64）从乐谱字符串中取出一个字母，因此字母以1-26代替65-90。
• "0"&MID(~) 在前面加上零 MID()结果前因为Excel不允许您使用空字符串进行数学运算，其中会有多个。
• 0+("0"&MID(~)) 将所有这些字符串转换为数字。
• SUM(0+("0"&MID(~))) 将所有现在都是数字的字符串加起来。
• LEN(A1)+SUM(~)将输入的长度添加到总和中，因为得分字符串（02210313074020029000033739）中的所有值都向下调了一位，因此它们的长度都为一位数。

Google表格中有一个非常相似的解决方案，但它的ArrayFromula()长度为97个字节，因为它比{}（但至少可以处理0 + "" = 0）更长。

=Len(A1)+ArrayFormula(Sum(0+Mid("02210313074020029000033739",Code(Mid(A1,Row(A:A),1)&"z")-64,1)))

Wolfram语言（Mathematica），74字节

Wolfram | Alpha当然支持拼字游戏得分！这是一个匿名函数。

Plus@@(First[WolframAlpha["Scrabble "<>##,"NumberData"]]&/@Characters[#])&

这在TIO上不起作用。

要运行，请转到此处，向下滚动并单击“创建新笔记本»”。笔记本中使用的代码在此TIO程序中，因此您可以复制它。将每个函数调用粘贴到其自己的代码块中。如果您在一个块中运行太多，则执行将无法完成。

注意 WolframAlpha使用Internet发送请求。尽管在PPCG上还有其他使用它的答案，但我认为您应该知道。

该程序使用下面的较短函数，但是在输入的每个单独字符上调用它（每次向Wolfram | Alpha发送单独的调用！）

这仅适用于最大长度为15（拼字板的宽度）的输入。（49个字节）

First[WolframAlpha["Scrabble "<>#,"NumberData"]]&

与上述相同，但将在框中显示结果以及输入是否为有效的拼字游戏单词。（45字节）

First[WolframAlpha["Scrabble "<>#,"Result"]]&

C＃（.NET Core），50 + 18 = 68字节

s=>s.Sum(c=>"02210313074020029000033739"[c-65]-47)

+18个字节 using System.Linq;

在线尝试！

K（oK），60 38字节

解：

+/1+.:'"02210313074020029000033739"65!

在线尝试！

说明：

索引分数，总结结果。

+/1+.:'"02210313074020029000033739"65! / the solution
                                   65! / input modulo 65 to get position in A-Z
       "02210313074020029000033739"    / index into the scores (1 point lower)
    .:'                                / value (.:) each (') to convert to ints
  1+                                   / increase by 1
+/                                     / sum up

Japt -x，43 39 35 30字节

£2+`dglbcÛghvwylk¥ljx¥qz`qÊaøX

在线尝试！

35字节解决方案：

¬£Ò('0+#Ý03#740#È29e4+33739 g65nXc

在线运行