Вызов:

Возьмите строку прописных или строчных букв в качестве входных данных (необязательно) и вычислите количество очков, которое эта строка получила бы в игре « Скрэббл» на английском языке.

Правила:

Счет каждой буквы следующий (используйте это, даже если есть другие версии игры):

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

Самый короткий ответ на каждом языке выигрывает! Форматы ввода и вывода являются гибкими, поэтому вы можете использовать ввод как массив символов (верхний или нижний регистр), если хотите.

сед 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

Битник , 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

Brain-Flak , 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 байт благодаря Санни Патель}

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непечатаемые (и два \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*он преобразуется в a, charпоэтому мы минус, 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}}

Попробуйте онлайн!

Лямбда, принимающая ввод в виде массива символов (в верхнем регистре) и возвращающая целое число.

Perl 5 -pF , 50 байт

_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 для каждого символа, потому что нет цифры 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 символов. Посмотрите код, отображаемый правильно, и запустите его здесь .

Спасибо гастропнеру за игру в гольф 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 Sheets очень похожее решение, но оно занимает 97 байт, потому что ArrayFromula()оно длиннее {}(но, по крайней мере, оно может справиться 0 + "" = 0).

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

Wolfram Language (Mathematica) , 74 байта

Конечно, Wolfram | Alpha поддерживает Scrabble! Это анонимная функция.

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

Это не работает на TIO.

Для запуска перейдите сюда , прокрутите вниз и нажмите «Создать новую записную книжку». Код для использования в блокноте находится в этой программе TIO, поэтому вы можете скопировать его. Вставьте каждый вызов функции в отдельный блок кода. Если вы запустите слишком много в одном блоке, выполнение не будет завершено.

Обратите внимание, что WolframAlphaотправляет запрос через Интернет. Хотя есть и другие ответы на PPCG, которые используют его, я подумал, что вы должны знать.

Эта программа использует приведенную ниже укороченную функцию, но вызывает ее для каждого отдельного символа ввода ( каждый раз отправляя отдельный вызов Wolfram | Alpha !)

Это работает только для ввода до длины 15, ширины доски Эрудит. (49 байт)

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

То же, что и выше, но результат будет отображаться в окне вместе с тем, является ли ввод допустимым словом Scrabble. (45 байт)

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

C # (.NET Core) , 50 + 18 = 68 байт

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

+18 байт для using System.Linq;

Попробуйте онлайн!

K (ок) , 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

Запустите его онлайн