Desafio:

Pegue uma sequência de letras maiúsculas ou minúsculas como entrada (opcional) e calcule a pontuação que essa sequência obteria em um jogo de Scrabble em inglês.

Regras:

A pontuação de cada letra é a seguinte (use isso mesmo se houver outras versões do jogo):

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

A pontuação de uma string é simplesmente a soma da pontuação de cada uma das letras usadas. Você pode assumir que você tem muitos blocos disponíveis; portanto, palavras longas e palavras com muitas das mesmas letras são entradas válidas.

Casos de teste:

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

A resposta mais curta em cada idioma vence! Os formatos de entrada e saída são flexíveis; portanto, você pode usar a entrada como uma matriz de caracteres (maiúscula ou minúscula), se desejar.

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

A saída é unária .

Reduz cada letra a uma combinação de letras com pontuação mais baixa até que todas as letras tenham 1 pontuação. Em seguida, substitui aqueles com 1s para fornecer uma contagem unária.

Experimente online!

Haskell , 86 84 bytes

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

Experimente online!

Explicação

A maioria das letras dá uma pontuação de 1 e, portanto, não precisamos controlá-las. Em vez disso, apenas diminuímos cada pontuação (economiza 1 byte 10também) e adicionamos o comprimento da string à pontuação resultante.

Obrigado @nimi por -2 bytes (reorganizando as palavras e usando em [1..]vez de [4,3..])!

Oitava , 50 bytes

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

Experimente online!

Desafio aceito. Explicação:

@(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 bytes

Já que realmente precisava ser feito, aqui está. Foi realmente desagradável depurar e forneceu alguns desafios.

A entrada deve conter apenas letras maiúsculas. A saída é unária (espero que esteja tudo bem?)

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

Experimente online!

O processo geral é:

• obter caractere da entrada
• subtrair 65
• verifique se o resultado é 0
  • se 0 pular quantidade especificada de palavras.
  • caso contrário, subtraia 1 e repita a verificação.
• os alvos de salto são operações de impressão push seguidas, um retorno ao início do programa.

Termina com um erro.

Uma explicação mais completa:

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 bytes

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

Experimente online!

Obrigado a @JoKing por salvar 14 bytes!

Versão legível:

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

Pitão, 40 bytes

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

Experimente aqui

Explicação

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 bytes

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

Experimente online!

Versão mais curta, porta da resposta de DanielIndie , 71 70 bytes

^{-1 byte graças a Sunny Patel}

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

Experimente online!

JavaScript (Node.js) , 71 66 63 62 bytes

• @Arnauld impressionante como sempre reduzindo 7 bytes
• graças a l4m2 por redução de 1 byte

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

Experimente online!

Java 8, 75 71 70 bytes

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

-1 byte, alterando "02210313074020029000033739".charAt(c-65)-47para não imprimíveis (e dois \n) para que -47possa ser removido. Inspirado pela resposta Octave da @Sanchises .

Experimente online.

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

Oitava / MATLAB, 85 bytes

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

Experimente online!

Geléia , 19 bytes

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

Um link monádico que aceita uma lista de caracteres maiúsculos que retorna um número inteiro

Experimente online! Ou veja a suíte de testes .

Quão?

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 bytes 63

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

')[u(W)-64])

Experimente online!

Recebe a entrada como uma sequência maiúscula. R lida com imprimíveis e seqüências de linhas múltiplas sem problemas, então isso é bom. Agora estamos quase o dobro do pacote externo!

E porque o CRAN tem tantos brindes aleatórios:

R + ScrabbleScore 31 bytes

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

Experimente online!

Infelizmente, swsverifica a validade por padrão.

Emojicode , 358 bytes

🐖🔥➡️🔡🍇🍮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🍉

Experimente online!

Explicação:

Alterei os nomes das variáveis ​​de letras simples para palavras mais significativas e ampliei algumas partes do meu código para torná-lo mais legível para pessoas não familiarizadas com o idioma. Você pode testar o programa expandido aqui .

🐋🔡🍇      👴 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 bytes

Recebe a entrada como uma lista minúscula de caracteres.

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

Experimente online! ou como um conjunto de testes

Oitava , 73 bytes

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

Experimente online!

Usa ismemberpara mapear cada caractere no fluxo de entrada xpara seu índice na cadeia de pesquisa 'QZJXKFHVWYBCMPDG'. Qualquer elemento não encontrado será mapeado para um índice de 0 (isso incluirá os caracteres de 1 ponto).

Em seguida, adicionamos 1 ao índice para fazer com que os 0 se tornem referências de 1 índice válidas e pesquisamos na string '09977433333222211'. Este é um elemento mais longo que a primeira cadeia de pesquisa. Os dígitos representam o valor do ponto de cada elemento na string original, menos 1, com o elemento extra sendo um '0' no beginning.

Finalmente, a sequência resultante é convertida em números inteiros subtraindo 47( '0'-1), produzindo o valor do ponto para cada letra, e todos os valores do ponto são somados.

C ++, 95 bytes

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

Experimente online (não é um link TIO)

Explicação:

• Declara m, uma matriz dos valores de cada letra em ordem, menos 1. O menos 1 é por causa de Q e Z: eu não poderia ter um número de dois dígitos lá
• Repete a cadeia de caracteres paté chegarmos ao caractere nulo e adiciona a pontuação do número ( *pnos fornece a letra e, -65portanto, podemos indexar adequadamente a matriz). Como mé a, char*ele se converte em a, charentão nós menos 48o trazemos de volta para 0, mas adicionamos 1uma vez que mé declarado como uma pontuação a menos para cada personagem.

_{Eu não sou um pôster ávido aqui, então espero ter feito isso corretamente. Eu acredito que eles retornam ncontam como imprimir o valor, e que declarar uma função é bom.}

Haskell , 66 bytes

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

Experimente online! A mesma abordagem da resposta JavaScript de DanielIndie .

Haskell , 82 81 bytes

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

Experimente online!

PowerShell , 60 bytes

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

Experimente online!

Japonês , 36 bytes

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Recebe a entrada como uma sequência minúscula e retorna um número.
Breve explicação:

£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.

Experimente online!

Ruby , 60 bytes

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

Experimente online!

Um lambda, aceitando entrada como uma matriz de caracteres (maiúsculos) e retornando um número inteiro.

Perl 5 -pF , 50 bytes

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

Experimente online!

Gforth , 109 bytes

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

A entrada deve estar em maiúscula:
C PPCG 11 OK

Legível

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

Experimente online!

Perl 6 , 52 bytes

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

Experimente online!

Mapeia todos os caracteres para um dígito e os soma. E adiciona 1 para cada caractere, porque não há um dígito 10 sem incorrer em bytes unicode.

Retina 0.8.2 , 41 bytes

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

Experimente online! O link inclui casos de teste. Explicação: Como a resposta de Haskell, as letras não triviais são traduzidas para 1 a menos que sua pontuação e 1 é adicionado mais tarde quando os caracteres são convertidos em unários. Colocar o FHVWYúltimo permite que todos eles sejam mapeados para uma pontuação de 3 + 1.

C (gcc), 78 72 bytes

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

Na verdade, existem 26 caracteres nessa sequência. Veja o código renderizado corretamente e execute-o aqui .

Agradecimentos a gastropner por jogar 6 bytes.

Versão não destruída:

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 bytes

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

Explicação:

• A entrada está na célula A1
• A fórmula deve ser inserida como uma fórmula de matriz com Ctrl+ Shift+ Enter, que adiciona os colchetes { }às duas extremidades.
• MID(A1,ROW(A:A),1) extrai cada caractere por vez (e muitos valores vazios também, pois ele retornará tantos valores quanto houver linhas na planilha)
• CODE(MID(~)&"z")extrai o valor ASCII para cada caractere. A &"z"anexa um zpara o final do MID()resultado porque CODE()não faz como entradas vazias. O valor ASCII para zé maior que todas as letras maiúsculas, portanto, é efetivamente ignorado mais tarde.
• MID("02210313074020029000033739",CODE(~)-64,1) extrai uma letra da string de pontuação com base em seu valor ASCII ajustado em 64 para que as letras sejam 1-26 em vez de 65-90.
• "0"&MID(~)precede zero ao MID()resultado porque o Excel não permite que você faça contas com seqüências de caracteres vazias, das quais haverá várias.
• 0+("0"&MID(~)) transforma todas essas seqüências em números.
• SUM(0+("0"&MID(~))) adiciona todas as strings que agora são números.
• LEN(A1)+SUM(~)adiciona o comprimento da entrada à soma porque todos os valores na sequência de pontuação ( 02210313074020029000033739) foram ajustados para baixo em um para que todos tivessem um dígito de comprimento.

Existe uma solução muito semelhante no Planilhas Google, mas ela é fornecida com 97 bytes porque ArrayFromula()é maior que {}(mas pelo menos pode suportar 0 + "" = 0).

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

Wolfram Language (Mathematica) , 74 bytes

Claro que o Wolfram | Alpha suporta a pontuação do Scrabble! Esta é uma função anônima.

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

Isso não funciona no TIO.

Para executar, vá aqui , role para baixo e clique em "Criar um novo notebook» ". O código a ser usado no notebook está neste programa TIO para que você possa copiá-lo. Cole cada chamada de função em seu próprio bloco de código. Se você executar muitos em um único bloco, a execução não será concluída.

Observe que WolframAlphaenvia uma solicitação usando a Internet. Embora existam outras respostas no PPCG que o utilizam, achei que você deveria saber.

Este programa usa a função abaixo mais curta, mas chama cada caractere individual da entrada (enviando uma chamada separada para Wolfram | Alpha a cada vez!)

Isso funciona apenas para entradas até o comprimento 15, a largura de uma placa Scrabble. (49 bytes)

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

O mesmo que acima, mas exibirá o resultado em uma caixa, juntamente com a entrada da palavra Scrabble válida. (45 bytes)

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

C # (.NET Core) , 50 + 18 = 68 bytes

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

+18 bytes para using System.Linq;

Experimente online!

K (oK) , 60 38 bytes

Solução:

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

Experimente online!

Explicação:

Índice nas pontuações, resumir o resultado.

+/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 bytes

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

Experimente online!

Solução de 35 bytes:

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

Execute on-line