Reto:

Tome una cadena de letras mayúsculas o minúsculas como entrada (opcional) y calcule la puntuación que esa cadena obtendría en un juego de Scrabble en inglés.

Reglas:

El puntaje de cada letra es el siguiente (use esto incluso si hay otras versiones del juego):

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

La puntuación de una cadena es simplemente la suma de las puntuaciones de cada una de las letras utilizadas. Puede suponer que tiene muchos mosaicos disponibles, por lo que las palabras largas y las palabras con muchas de las mismas letras son entradas válidas.

Casos de prueba:

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

¡La respuesta más corta en cada idioma gana! Los formatos de entrada y salida son flexibles, por lo que puede tomar la entrada como una matriz de caracteres (mayúsculas o minúsculas) si lo desea.

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

La salida es en unario .

Reduce cada letra a una combinación de letras de menor puntaje hasta que todas las letras sean de 1 puntaje. Luego reemplaza aquellos con 1s para dar un recuento unario.

Pruébalo en línea!

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]

Pruébalo en línea!

Explicación

La mayoría de las letras dan un puntaje de 1 y, por lo tanto, no necesitamos hacer un seguimiento de estas, en lugar de eso solo disminuimos cada puntaje (también guardamos 1 byte 10) y luego agregamos la longitud de la cadena al puntaje resultante.

¡Gracias @nimi por -2 bytes (reorganizando las palabras y usando en [1..]lugar de [4,3..])!

Octava , 50 bytes

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

Pruébalo en línea!

Desafío aceptado. Explicación:

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

Como realmente tenía que hacerse, aquí está. Fue realmente desagradable depurar y proporcionó algunos desafíos.

La entrada debe ser solo letras mayúsculas. La salida es unaria (¿espero que esté bien?)

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

Pruébalo en línea!

El proceso general es:

• obtener carácter de entrada
• restar 65
• verificar si el resultado es 0
  • si 0 salta la cantidad especificada de palabras.
  • de lo contrario, reste 1 y repita la verificación.
• Los objetivos de salto son operaciones de impresión push seguidas de un bucle de regreso al comienzo del programa.

Termina con un error.

Una explicación más 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

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

Pruébalo en línea!

¡Gracias a @JoKing por guardar 14 bytes!

Versión legible:

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

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

Pruébalo aquí

Explicación

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))

Pruébalo en línea!

Versión más corta, puerto de la respuesta de Daniel Indie , 71 70 bytes

^{-1 byte gracias a Sunny Patel}

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

Pruébalo en línea!

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

• @Arnauld impresionante como siempre reduciendo 7 bytes
• gracias a l4m2 por reducir 1 byte

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

Pruébalo en línea!

Java 8, 75 71 70 bytes

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

-1 byte cambiando "02210313074020029000033739".charAt(c-65)-47a no imprimibles (y dos \n) para que -47se pueda eliminar. Inspirado por la respuesta Octave de @Sanchises .

Pruébalo en línea.

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

Octava / 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)

Pruébalo en línea!

Jalea , 19 bytes

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

Un enlace monádico que acepta una lista de caracteres en mayúscula que devuelve un entero

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

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 bytes

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

')[u(W)-64])

Pruébalo en línea!

Toma la entrada como una cadena en mayúscula. R maneja cadenas no imprimibles y multilíneas sin problemas, así que eso es bueno. ¡Ahora somos casi el doble del paquete externo!

Y porque CRAN tiene tantas cosas al azar:

R + ScrabbleScore 31 bytes

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

Pruébalo en línea!

Lamentablemente, swsverifica la validez por defecto.

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🍉

Pruébalo en línea!

Explicación:

Cambié los nombres de las variables de letras simples a palabras más significativas, y expandí algunas partes de mi código para que sea más legible para las personas que no están familiarizadas con el idioma. Puede probar el programa ampliado aquí .

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

Toma la entrada como una lista de caracteres en minúscula.

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

Pruébalo en línea! o como un conjunto de pruebas

Octava , 73 bytes

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

Pruébalo en línea!

Se utiliza ismemberpara asignar cada carácter en la secuencia de entrada xen su índice en la cadena de búsqueda 'QZJXKFHVWYBCMPDG'. Cualquier elemento no encontrado se asignará a un índice de 0 (esto incluirá los caracteres de 1 punto).

A continuación, agregamos 1 al índice para que los 0 se conviertan en referencias válidas de 1 índice y busquemos en la cadena '09977433333222211'. Este es un elemento más largo que la primera cadena de búsqueda. Los dígitos representan el valor en puntos de cada elemento en la cadena original, menos 1, con el elemento extra como un '0' en el beginning.

Finalmente, la cadena resultante se convierte en enteros restando 47( '0'-1), produciendo el valor de punto para cada letra, y todos los valores de punto se suman.

C ++, 95 bytes

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

Pruébelo en línea (no es un enlace TIO lo siento)

Explicación:

• Declara m, una matriz de los valores de cada letra en orden, menos 1. El menos 1 se debe a Q y Z: no podría tener un número de dos dígitos allí
• Itera a través de la cadena phasta llegar al carácter nulo, y agrega la puntuación del número ( *pnos da la letra, y -65así podemos indexar correctamente la matriz). Dado que mes a, char*se convierte en a, charpor lo tanto, menos, 48así que devuélvelo a 0, pero suma 1ya que mse declara como un puntaje menos para cada personaje.

_{No soy un aficionado ávido aquí, así que espero haberlo hecho correctamente. Creo que devolverlos ncuenta como imprimir el valor, y que declarar una función está bien.}

Haskell , 66 bytes

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

Pruébalo en línea! El mismo enfoque que la respuesta JavaScript de DanielIndie .

Haskell , 82 81 bytes

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

Pruébalo en línea!

PowerShell , 60 bytes

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

Pruébalo en línea!

Japt , 36 bytes

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Toma la entrada como una cadena en minúscula, devuelve un número.
Breve explicación:

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

Pruébalo en línea!

Rubí , 60 bytes.

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

Pruébalo en línea!

Una lambda, que acepta la entrada como una matriz de caracteres (mayúsculas) y devuelve un entero.

Perl 5 -pF , 50 bytes

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

Pruébalo en línea!

Gforth , 109 bytes

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

La entrada debe ser mayúscula:
C PPCG 11 OK

Legible

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

Pruébalo en línea!

Perl 6 , 52 bytes

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

Pruébalo en línea!

Asigna cada carácter a un dígito y los suma. Y agrega 1 para cada carácter porque no hay un dígito 10 sin incurrir en bytes unicode.

Retina 0.8.2 , 41 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación: Al igual que la respuesta de Haskell, las letras no triviales se traducen a 1 menos que su puntaje, y 1 se agrega más tarde cuando los caracteres se convierten en unarios. Poner el FHVWYúltimo les permite a todos mapear a una puntuación de 3 + 1.

C (gcc), 78 72 bytes

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

En realidad hay 26 caracteres en esa cadena. Vea el código representado correctamente y ejecútelo aquí .

Gracias a gastropner por jugar al golf 6 bytes.

Versión sin golf:

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)))}

Explicación:

• La entrada está en la celda A1
• La fórmula debe ingresarse como una fórmula de matriz con Ctrl+ Shift+ Enter, que agrega los corchetes { }a ambos extremos.
• MID(A1,ROW(A:A),1) extrae cada carácter por turno (y también muchos valores vacíos, ya que devolverá tantos valores como filas en la hoja)
• CODE(MID(~)&"z")extrae el valor ASCII para cada carácter. El &"z"anexa una zal final del MID()resultado porque CODE()no le gusta entradas vacías. Sin zembargo, el valor ASCII para es más alto que cada letra mayúscula, por lo que se ignora efectivamente más adelante.
• MID("02210313074020029000033739",CODE(~)-64,1) extrae una letra de la cadena de puntuación en función de su valor ASCII ajustado por 64 para que las letras corran 1-26 en lugar de 65-90.
• "0"&MID(~)antepone un cero al MID()resultado porque Excel no le permitirá hacer cálculos matemáticos con cadenas vacías, de las cuales habrá varias.
• 0+("0"&MID(~)) convierte todas esas cadenas en números.
• SUM(0+("0"&MID(~))) suma todas esas cadenas que ahora son números.
• LEN(A1)+SUM(~)agrega la longitud de la entrada a la suma porque todos los valores en la cadena de puntuación ( 02210313074020029000033739) se ajustaron en uno para que todos tengan un dígito de longitud.

Hay una solución muy similar en Google Sheets, pero viene en 97 bytes porque ArrayFromula()es más larga que {}(pero al menos puede manejar 0 + "" = 0).

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

Wolfram Language (Mathematica) , 74 bytes

¡Por supuesto, Wolfram | Alpha admite la puntuación Scrabble! Esta es una función anónima.

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

Esto no funciona en TIO.

Para ejecutar, vaya aquí , desplácese hacia abajo y haga clic en "Crear un cuaderno nuevo» ". El código para usar en la computadora portátil está en este programa TIO para que pueda copiarlo. Pegue cada llamada de función en su propio bloque de código. Si ejecuta demasiados en un solo bloque, la ejecución no se completará.

Tenga en cuenta que WolframAlphaenvía una solicitud a través de Internet. Aunque hay otras respuestas sobre PPCG que lo usan, pensé que debería saberlo.

Este programa utiliza la siguiente función más corta, pero la invoca en cada carácter individual de la entrada (¡envía una llamada por separado a Wolfram | Alpha cada vez!)

Esto solo funciona para entradas de hasta 15 de longitud, el ancho de una placa Scrabble. (49 bytes)

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

Igual que el anterior, pero mostrará el resultado en un cuadro, junto con si la entrada es una palabra 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;

Pruébalo en línea!

K (oK) , 60 38 bytes

Solución:

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

Pruébalo en línea!

Explicación:

Indice los puntajes, resuma el 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

Pruébalo en línea!

Solución de 35 bytes:

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

Ejecútalo en línea