Sfida:

Prendi una stringa di lettere maiuscole o minuscole come input (opzionale) e calcola il punteggio che quella stringa otterrebbe in una partita di Scrabble in inglese.

Regole:

Il punteggio di ogni lettera è il seguente (usalo anche se ci sono altre versioni del gioco):

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

Il punteggio di una stringa è semplicemente la somma dei punteggi di ciascuna delle lettere utilizzate. Puoi presumere che tu abbia molte tessere disponibili, quindi parole lunghe e parole con molte delle stesse lettere sono input validi.

Casi test:

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

Vince la risposta più breve in ogni lingua! I formati di input e output sono flessibili, quindi puoi prendere l'input come una matrice di caratteri (maiuscolo o minuscolo) se lo desideri.

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

L'output è in unario .

Riduce ciascuna lettera a una combinazione di lettere con punteggio più basso fino a quando tutte le lettere sono a 1 marcatore. Quindi sostituisce quelli con 1s per dare un conteggio unario.

Provalo online!

Haskell , 86 84 byte

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

Provalo online!

Spiegazione

La maggior parte delle lettere dà un punteggio di 1 e quindi non abbiamo bisogno di tenerne traccia, ma semplicemente diminuiamo ogni punteggio (salva anche 1 byte 10) e quindi aggiungiamo la lunghezza della stringa al punteggio risultante.

Grazie @nimi per -2 byte (riordinando le parole e usando [1..]invece di [4,3..])!

Ottava , 50 byte

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

Provalo online!

Sfida accettata. Spiegazione:

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

Dal momento che doveva davvero essere fatto, eccolo qui. È stato davvero un brutto debug e ha fornito alcune sfide.

L'input deve essere solo in lettere maiuscole. L'output è unario (spero che sia OK?)

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

Provalo online!

Il processo generale è:

• ottenere carattere dall'input
• sottrarre 65
• controlla se il risultato è 0
  • se 0 salta la quantità specificata di parole.
  • altrimenti sottrarre 1 e ripetere il controllo.
• i target di salto sono operazioni di stampa push seguite da un loop back all'inizio del programma.

Termina con un errore.

Una spiegazione più 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 byte

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

Provalo online!

Grazie a @JoKing per aver salvato 14 byte!

Versione leggibile:

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

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

Provalo qui

Spiegazione

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 byte

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

Provalo online!

Versione più breve, porta della risposta di DanielIndie , 71 70 byte

^{-1 byte grazie a Sunny Patel}

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

Provalo online!

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

• @Arnauld fantastico come sempre riducendo 7 byte
• grazie a l4m2 per rducing di 1 byte

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

Provalo online!

Java 8, 75 71 70 byte

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

-1 byte passando "02210313074020029000033739".charAt(c-65)-47a non stampabili (e due \n) in modo che -47possano essere rimossi. Ispirato dalla risposta Octave di @Sanchises .

Provalo 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

Octave / MATLAB, 85 byte

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

Provalo online!

Gelatina , 19 byte

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

Un collegamento monadico che accetta un elenco di caratteri maiuscoli che restituisce un numero intero

Provalo online! Oppure vedi la suite di test .

Come?

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 byte

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

')[u(W)-64])

Provalo online!

Accetta l'input come una stringa maiuscola. R gestisce senza problemi le stringhe non stampabili e multilinea, quindi è carino. Ora siamo quasi il doppio del pacchetto esterno!

E poiché CRAN ha tante chicche casuali:

R + ScrabbleScore 31 byte

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

Provalo online!

Purtroppo, swsverifica la validità per impostazione predefinita.

Emojicode , 358 byte

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

Provalo online!

Spiegazione:

Ho cambiato i nomi delle variabili da singole lettere a parole più significative e ho ampliato alcune parti del mio codice per renderlo più leggibile per le persone che non hanno familiarità con la lingua. Puoi testare il programma esteso qui .

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

Accetta input come un elenco di caratteri minuscoli.

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

Provalo online! o come una suite di test

Ottava , 73 byte

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

Provalo online!

Utilizza ismemberper mappare ogni carattere nel flusso di input xsul suo indice nella stringa di ricerca 'QZJXKFHVWYBCMPDG'. Qualsiasi elemento non trovato verrà mappato su un indice di 0 (questo includerà i caratteri a 1 punto).

Quindi aggiungiamo 1 all'indice per fare in modo che gli 0 diventino riferimenti a 1 indice validi e cerchiamo nella stringa '09977433333222211'. Questo è un elemento più lungo della prima stringa di ricerca. Le cifre rappresentano il valore in punti di ciascun elemento nella stringa originale, meno 1, con l'elemento aggiuntivo che è uno "0" in corrispondenza di beginning.

Alla fine la stringa risultante viene convertita in numeri interi sottraendo 47( '0'-1), ottenendo il valore in punti per ogni lettera e tutti i valori in punti vengono quindi sommati.

C ++, 95 byte

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

Provalo online (non mi dispiace un link TIO)

Spiegazione:

• Dichiara m, una matrice dei valori di ogni lettera in ordine, meno 1. Il meno 1 è dovuto a Q e Z: non potevo avere un numero a due cifre lì dentro
• Scorre la stringa pfino a quando non arriviamo al carattere null e aggiunge il punteggio del numero ( *pci fornisce la lettera e -65quindi possiamo indicizzare correttamente l'array). Since mis a char*si converte in a, charquindi abbiamo meno, 48quindi riportalo a 0, ma aggiungi 1da mè dichiarato come un punteggio in meno per ogni personaggio.

_{Non sono un avido poster qui quindi spero di averlo fatto correttamente. Credo che tornino ncontino come stampare il valore e che dichiarare una funzione vada bene.}

Haskell , 66 byte

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

Provalo online! Stesso approccio della risposta JavaScript di DanielIndie .

Haskell , 82 81 byte

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

Provalo online!

PowerShell , 60 byte

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

Provalo online!

Japt , 36 byte

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Accetta l'input come stringa minuscola, restituisce un numero.
Breve spiegazione:

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

Provalo online!

Rubino , 60 byte

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

Provalo online!

Un lambda, che accetta l'input come una matrice di caratteri (maiuscoli) e restituisce un numero intero.

Perl 5 -pF , 50 byte

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

Provalo online!

Gforth , 109 byte

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

L'input deve essere in maiuscolo:
C PPCG 11 OK

Leggibile

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

Provalo online!

Perl 6 , 52 byte

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

Provalo online!

Mappa ogni personaggio su una cifra e li somma. E aggiunge 1 per ogni personaggio perché non c'è una cifra 10 senza incorrere in byte unicode.

Retina 0.8.2 , 41 byte

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

Provalo online! Il link include casi di test. Spiegazione: Come per la risposta di Haskell, le lettere non banali vengono tradotte in 1 in meno del loro punteggio e 1 viene aggiunto in seguito quando i caratteri vengono convertiti in unari. Mettere l' FHVWYultimo consente a tutti di mappare su un punteggio di 3 + 1.

C (gcc), 78 72 byte

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

Ci sono in realtà 26 caratteri in quella stringa. Vedi il codice reso correttamente ed eseguilo qui .

Grazie a Gastropner per il golf 6 byte.

Versione non golfata:

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 byte

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

Spiegazione:

• L'input è nella cella A1
• La formula deve essere immessa come formula di matrice con Ctrl+ Shift+ Enter, che aggiunge le parentesi graffe { }ad entrambe le estremità.
• MID(A1,ROW(A:A),1) estrae ogni personaggio a turno (e anche molti valori vuoti, poiché restituirà tanti valori quante sono le righe nel foglio)
• CODE(MID(~)&"z")estrae il valore ASCII per ciascun carattere. Il &"z"aggiunge un zalla fine del MID()risultato perché CODE()non funziona come ingressi vuoti. Il valore ASCII perz è maggiore di ogni lettera maiuscola, quindi viene effettivamente ignorato in seguito.
• MID("02210313074020029000033739",CODE(~)-64,1) estrae una lettera dalla stringa del punteggio in base al suo valore ASCII regolato verso il basso di 64, quindi le lettere vanno 1-26 anziché 65-90.
• "0"&MID(~)antepone uno zero al MID()risultato perché Excel non ti consente di fare matematica con stringhe vuote, di cui ce ne saranno diverse.
• 0+("0"&MID(~)) trasforma tutte quelle stringhe in numeri.
• SUM(0+("0"&MID(~))) somma tutte quelle stringhe che ora sono numeri.
• LEN(A1)+SUM(~)aggiunge la lunghezza dell'input alla somma perché tutti i valori nella stringa del punteggio ( 02210313074020029000033739) sono stati regolati verso il basso di uno in modo che siano tutti lunghi una cifra.

C'è una soluzione molto simile in Fogli Google, ma arriva a 97 byte perché ArrayFromula()è più lunga di {}(ma almeno può gestire 0 + "" = 0).

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

Wolfram Language (Mathematica) , 74 byte

Ovviamente Wolfram | Alpha supporta il punteggio Scrabble! Questa è una funzione anonima.

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

Questo non funziona su TIO.

Per eseguire, vai qui , scorri verso il basso e fai clic su "Crea un nuovo blocco note» ". Il codice da utilizzare nel notebook è in questo programma TIO quindi è possibile copiarlo. Incolla ogni chiamata di funzione nel proprio blocco di codice. Se ne esegui troppi in un singolo blocco, l'esecuzione non verrà completata.

Si noti che WolframAlphainvia una richiesta tramite Internet. Sebbene ci siano altre risposte su PPCG che lo utilizzano, ho pensato che dovresti saperlo.

Questo programma utilizza la funzione più breve di seguito, ma la chiama su ogni singolo carattere dell'input (inviando una chiamata separata a Wolfram | Alpha ogni volta!)

Funziona solo con input fino a 15, la larghezza di una scheda Scrabble. (49 byte)

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

Come sopra, ma visualizzerà il risultato in una casella, insieme al fatto che l'input sia una parola Scrabble valida. (45 byte)

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

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

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

+18 byte per using System.Linq;

Provalo online!

K (oK) , 60 38 byte

Soluzione:

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

Provalo online!

Spiegazione:

Indicizza nei punteggi, riassumi il risultato.

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

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

Provalo online!

Soluzione a 35 byte:

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

Eseguilo online