Défi:

Prenez une chaîne de lettres majuscules ou minuscules comme entrée (facultatif) et calculez le score que cette chaîne obtiendrait dans un jeu de Scrabble en anglais.

Règles:

Le score de chaque lettre est le suivant (utilisez-le même s'il existe d'autres versions du jeu):

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

Le score d'une chaîne est simplement la somme des scores de chacune des lettres utilisées. Vous pouvez supposer que vous avez beaucoup de tuiles disponibles, donc des mots longs et des mots avec beaucoup des mêmes lettres sont des entrées valides.

Cas de test:

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

La réponse la plus courte dans chaque langue gagne! Les formats d'entrée et de sortie sont flexibles, vous pouvez donc utiliser l'entrée comme un tableau de caractères (majuscules ou minuscules) si vous le souhaitez.

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 sortie est unaire .

Réduit chaque lettre à une combinaison de lettres ayant un score inférieur jusqu'à ce que toutes les lettres soient un marqueur. Puis remplace ceux avec1 s pour donner un compte unaire.

Essayez-le en ligne!

Haskell , 86 84 octets

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

Essayez-le en ligne!

Explication

La plupart des lettres donnent un score de 1 et nous n’avons donc pas besoin de les suivre. Nous décrémentons simplement chaque score (enregistre 1 octet sur 10 ), puis ajoutons la longueur de la chaîne au score obtenu.

Merci @nimi pour -2 octets (en réarrangeant les mots et en utilisant [1..]au lieu de [4,3..])!

Octave , 50 octets

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

Essayez-le en ligne!

Défi accepté. Explication:

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

Puisque cela devait vraiment être fait, le voici. C’était vraiment désagréable de déboguer et fournissait quelques défis.

Les entrées doivent être en majuscules seulement. La sortie est unaire (espérons que c'est 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

Essayez-le en ligne!

Le processus général est:

• obtenir le caractère de l'entrée
• soustraire 65
• vérifier si le résultat est 0
  • si 0 saute le nombre spécifié de mots.
  • sinon soustrayez 1 et recommencez le contrôle.
• les cibles de saut sont des opérations d'impression push suivies d'une boucle de retour au début du programme.

Se termine par une erreur.

Une explication plus complète:

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 octets

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

Essayez-le en ligne!

Merci à @JoKing d'avoir économisé 14 octets!

Version lisible:

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

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

Essayez ici

Explication

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 octets

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

Essayez-le en ligne!

Version abrégée, réponse de DanielIndie , 71 70 octets

^{-1 octet grâce à Sunny Patel}

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

Essayez-le en ligne!

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

• @Arnauld génial, réduisant toujours 7 octets
• merci à l4m2 d'avoir réduit de 1 octet

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

Essayez-le en ligne!

Java 8, 75 71 70 octets

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

-1 octet en changeant "02210313074020029000033739".charAt(c-65)-47en non imprimables (et deux \n) pour -47pouvoir les supprimer. Inspiré par la réponse octave @Sanchises .

Essayez-le en ligne.

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 octets

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

Essayez-le en ligne!

Gelée , 19 octets

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

Un lien monadique acceptant une liste de caractères majuscules qui renvoie un entier

Essayez-le en ligne! Ou voir la suite de tests .

Comment?

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 octets

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

')[u(W)-64])

Essayez-le en ligne!

Prend l'entrée en tant que chaîne majuscule. R gère les chaînes non imprimables et multilignes sans problèmes, ce qui est bien. Maintenant, nous sommes presque deux fois plus nombreux que le paquet externe!

Et parce que CRAN a tellement de goodies aléatoires:

R + ScrabbleScore 31 octets

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

Essayez-le en ligne!

Malheureusement, swsvérifie la validité par défaut.

Emojicode , 358 octets

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

Essayez-le en ligne!

Explication:

J'ai remplacé les noms de variables par des lettres uniques par des mots plus significatifs, et développé certaines parties de mon code afin de le rendre plus lisible pour les personnes non familiarisées avec la langue. Vous pouvez tester le programme étendu ici .

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

Prend les entrées sous forme de liste de caractères minuscules.

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

Essayez-le en ligne! ou en tant que suite de tests

Octave , 73 octets

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

Essayez-le en ligne!

Utilise ismemberpour mapper chaque caractère dans le flux d'entréex sur son index dans la chaîne de recherche 'QZJXKFHVWYBCMPDG'. Tout élément non trouvé sera associé à un index de 0 (ceci inclura les caractères à 1 point).

Ensuite, nous ajoutons 1 à l'index pour que les 0 deviennent des références 1-index valides et recherchent la chaîne '09977433333222211'. C'est un élément plus long que la première chaîne de recherche. Les chiffres représentent la valeur en points de chaque élément de la chaîne d’origine, moins 1, l’élément supplémentaire étant un «0» au début.beginning .

Enfin, la chaîne résultante est convertie en nombres entiers en soustrayant 47( '0'-1), ce qui donne la valeur en points de chaque lettre. Toutes les valeurs en points sont ensuite additionnées.

C ++, 95 octets

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

Essayez-le en ligne (désolé, pas un lien TIO)

Explication:

• Déclare m, un tableau des valeurs de chaque lettre dans l'ordre, moins 1. Le moins 1 est dû à Q et Z: je ne pouvais pas avoir un nombre à deux chiffres
• Parcourt la chaîne pjusqu'à atteindre le caractère nul et ajoute le score du nombre ( *pnous donne la lettre et -65nous pouvons ainsi correctement indexer le tableau). Puisqu'il mest char*converti en un char, nous le renvoyons 48donc à 0, mais add 1puisque mest déclaré avec un score de moins pour chaque personnage.

_{Je ne suis pas un passionné d’affiche ici, alors j’espère que c’est bien passé. Je crois qu'ils retournent ncompte comme impression de la valeur, et que déclarer une fonction est bien.}

Haskell , 66 octets

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

Essayez-le en ligne! Même approche que la réponse JavaScript de DanielIndie .

Haskell , 82 81 octets

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

Essayez-le en ligne!

PowerShell , 60 octets

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

Essayez-le en ligne!

Japt , 36 octets

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Prend l'entrée en tant que chaîne en minuscule, retourne un nombre.
Brève explication:

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

Essayez-le en ligne!

Ruby , 60 octets

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

Essayez-le en ligne!

Un lambda, acceptant les entrées sous forme de tableau de caractères (majuscules) et renvoyant un entier.

Perl 5 -pF , 50 octets

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

Essayez-le en ligne!

Gforth , 109 octets

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

L'entrée doit être en majuscule:
C PPCG 11 OK

Lisible

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

Essayez-le en ligne!

Perl 6 , 52 octets

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

Essayez-le en ligne!

Mappe chaque caractère à un chiffre et les résume. Et ajoute 1 pour chaque caractère car il n'y a pas de chiffre 10 sans encourir d'octets Unicode.

Retina 0.8.2 , 41 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication: comme dans la réponse Haskell, les lettres non triviales sont traduites en 1 moins que leur score, et 1 est ajouté plus tard lorsque les caractères sont convertis en unaires. Mettre en FHVWYdernier leur permet de mapper à 3 + 1.

C (gcc), 78 72 octets

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

Il y a actuellement 26 caractères dans cette chaîne. Voir le code rendu correctement et l'exécuter ici .

Merci à gastropner pour avoir au golf 6 octets.

Version non-golfée:

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 octets

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

Explication:

• L'entrée est dans la cellule A1
• La formule doit être entrée sous forme de formule matricielle avec Ctrl+ Shift+ Enter, ce qui ajoute les accolades { }aux deux extrémités.
• MID(A1,ROW(A:A),1) extrait chaque caractère à son tour (et beaucoup de valeurs vides, aussi, car il retournera autant de valeurs qu'il y a de lignes dans la feuille)
• CODE(MID(~)&"z")extrait la valeur ASCII pour chaque caractère. Le &"z"ajoute un zà la fin du MID()résultat car CODE()n'aime pas les entrées vides. La valeur ASCII zest supérieure à chaque lettre majuscule, donc elle est ignorée ultérieurement.
• MID("02210313074020029000033739",CODE(~)-64,1) extrait une lettre de la chaîne de partition basée sur sa valeur ASCII ajustée de 64 pour que les lettres s'exécutent de 1 à 26 au lieu de 65 à 90.
• "0"&MID(~)ajoute un zéro au MID()résultat car Excel ne vous laissera pas faire de maths avec des chaînes vides, dont il y en aura plusieurs.
• 0+("0"&MID(~)) transforme toutes ces chaînes en nombres.
• SUM(0+("0"&MID(~))) ajoute toutes ces chaînes qui sont maintenant des nombres.
• LEN(A1)+SUM(~)ajoute la longueur de l'entrée à la somme car toutes les valeurs de la chaîne de score ( 02210313074020029000033739) ont été réduites d'un chiffre afin qu'elles aient toutes un chiffre.

Il existe une solution très similaire dans Google Sheets, mais elle compte 97 octets, car elle ArrayFromula()est plus longue que {}(mais au moins, elle peut gérer 0 + "" = 0).

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

Wolfram Language (Mathematica) , 74 octets

Bien sûr, Wolfram | Alpha supporte le scrabble! Ceci est une fonction anonyme.

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

Cela ne fonctionne pas sur TIO.

Pour exécuter, allez ici , faites défiler et cliquez sur "Créer un nouveau cahier» ". Le code à utiliser dans le cahier est dans ce programme TIO afin que vous puissiez le copier. Collez chaque appel de fonction dans son propre bloc de code. Si vous en exécutez trop dans un seul bloc, l'exécution ne sera pas terminée.

Notez que WolframAlpha envoie une demande en utilisant Internet. Bien qu'il existe d'autres réponses sur PPCG qui l'utilisent, j'ai pensé que vous devriez savoir.

Ce programme utilise la fonction plus courte ci-dessous, mais l'appelle sur chaque caractère de l'entrée (en envoyant un appel séparé à Wolfram | Alpha à chaque fois!)

Cela ne fonctionne que pour une longueur maximale de 15, la largeur d'un tableau de Scrabble. (49 octets)

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

Comme ci-dessus, mais affichera le résultat dans une case, en indiquant si le mot saisi est un mot Scrabble valide. (45 octets)

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

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

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

+18 octets pour using System.Linq;

Essayez-le en ligne!

K (oK) , 60 38 octets

Solution:

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

Essayez-le en ligne!

Explication:

Index dans les scores, résume le résultat.

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

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

Essayez-le en ligne!

Solution de 35 octets:

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

Courez en ligne