Herausforderung:

Verwenden Sie eine Zeichenfolge aus Groß- oder Kleinbuchstaben als Eingabe (optional) und berechnen Sie die Punktzahl, die die Zeichenfolge bei einer Partie Scrabble in Englisch erhalten würde.

Regeln:

Die Punktzahl für jeden Buchstaben ist wie folgt (verwenden Sie diese Option, auch wenn es andere Versionen des Spiels gibt):

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

Die Punktzahl eines Strings ist einfach die Summe der Punkte jedes verwendeten Buchstabens. Sie können davon ausgehen, dass Sie viele Kacheln zur Verfügung haben, so dass lange Wörter und Wörter mit vielen gleichen Buchstaben eine gültige Eingabe sind.

Testfälle:

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

Die kürzeste Antwort in jeder Sprache gewinnt! Die Eingabe- und Ausgabeformate sind flexibel. Sie können die Eingabe also als Array von Zeichen (Groß- oder Kleinbuchstaben) verwenden, wenn Sie möchten.

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

Die Ausgabe erfolgt unär .

Reduziert jeden Buchstaben auf eine Kombination von Buchstaben mit niedrigerer Punktzahl, bis alle Buchstaben 1-Punkte sind. Ersetzt dann diese durch 1s, um eine unäre Zählung zu erhalten.

Probieren Sie es 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]

Probieren Sie es online!

Erläuterung

Die meisten Buchstaben geben eine Punktzahl von 1 an, und daher müssen wir diese nicht nachverfolgen. Stattdessen dekrementieren wir einfach jede Punktzahl (spart auch 1 Byte ein 10) und addieren dann die Länge der Zeichenfolge zur resultierenden Punktzahl.

Vielen Dank an @nimi für -2 Bytes (Wörter neu ordnen und [1..]stattdessen verwenden [4,3..])!

Oktave , 50 Bytes

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

Probieren Sie es online!

Herausforderung angenommen. Erläuterung:

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

Da es wirklich getan werden musste, ist es hier. Das Debuggen war wirklich unangenehm und brachte einige Herausforderungen mit sich.

Die Eingabe darf nur in Großbuchstaben erfolgen. Ausgabe ist unär (hoffe das ist 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

Probieren Sie es online!

Allgemeiner Ablauf ist:

• Zeichen aus Eingabe holen
• 65 abziehen
• Überprüfen Sie, ob das Ergebnis 0 ist
  • Wenn 0, springe die angegebene Anzahl von Wörtern.
  • Andernfalls subtrahieren Sie 1 und wiederholen Sie die Prüfung.
• Die Sprungziele sind Push-Druckvorgänge, gefolgt von einer Schleife zurück zum Programmanfang.

Endet mit einem Fehler.

Eine vollständigere Erklärung:

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

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

Probieren Sie es online!

Vielen Dank an @JoKing für das Speichern von 14 Bytes!

Lesbare Version:

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

Probieren Sie es hier aus

Erläuterung

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

Probieren Sie es online!

Kürzere Version, Hafen von DanielIndie Antwort , 71 70 Bytes

^{-1 Byte dank Sunny Patel}

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

Probieren Sie es online!

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

• @ Arnauld genial wie immer 7 Bytes zu reduzieren
• danke an l4m2 für die reduzierung um 1 byte

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

Probieren Sie es online!

Java 8, 75 71 70 Bytes

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

-1 Byte, indem Sie "02210313074020029000033739".charAt(c-65)-47zu unprintables (und zwei \n) ändern , damit das -47entfernt werden kann. Inspiriert von @Sanchises 'Octave-Antwort .

Probieren Sie es online aus.

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

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

Probieren Sie es online!

Jelly , 19 Bytes

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

Ein monadischer Link, der eine Liste von Großbuchstaben akzeptiert und eine Ganzzahl zurückgibt

Probieren Sie es online! Oder sehen Sie sich die Testsuite an .

Wie?

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

Probieren Sie es online!

Übernimmt die Eingabe als Großbuchstaben. R behandelt nicht druckbare und mehrzeilige Zeichenfolgen ohne Probleme, das ist also schön. Jetzt sind wir fast doppelt so groß wie das externe Paket!

Und weil CRAN so viele zufällige Leckereien hat:

R + ScrabbleScore 31 Bytes

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

Probieren Sie es online!

Leider swsüberprüft die Gültigkeit der Standardeinstellung.

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🍉

Probieren Sie es online!

Erläuterung:

Ich habe die Variablennamen von einzelnen Buchstaben in aussagekräftigere Wörter geändert und einige Teile meines Codes erweitert, um ihn hoffentlich für Personen lesbarer zu machen, die mit der Sprache nicht vertraut sind. Sie können das erweiterte Programm testen hier .

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

Übernimmt die Eingabe als Kleinbuchstabenliste.

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

Probieren Sie es online! oder als Testsuite

Oktave , 73 Bytes

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

Probieren Sie es online!

Wird verwendet ismember, um jedes Zeichen im Eingabestream xseinem Index in der Suchzeichenfolge zuzuordnen 'QZJXKFHVWYBCMPDG'. Jedes nicht gefundene Element wird einem Index von 0 zugeordnet (dies schließt die 1-Punkt-Zeichen ein).

Als Nächstes fügen wir 1 zum Index hinzu, damit die Nullen gültige 1-Index-Referenzen werden, und suchen in der Zeichenfolge nach '09977433333222211'. Dies ist ein Element länger als die erste Suchzeichenfolge. Die Ziffern stellen den Punktwert jedes Elements in der ursprünglichen Zeichenfolge minus 1 dar, wobei das zusätzliche Element eine '0' am ist beginning.

Schließlich wird die resultierende Zeichenfolge durch Subtrahieren von 47( '0'-1) in Ganzzahlen umgewandelt , wobei der Punktwert für jeden Buchstaben erhalten wird, und alle Punktwerte werden dann summiert.

C ++, 95 Bytes

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

Probieren Sie es online aus (kein TIO-Link, sorry)

Erläuterung:

• Deklariert mein Array mit den Werten jedes Buchstabens in der angegebenen Reihenfolge, minus 1. Das Minus 1 liegt an Q und Z: Ich konnte dort keine zweistellige Zahl haben
• Durchläuft die Zeichenfolge, pbis das Zeichen null ist, und fügt die Punktzahl der Zahl hinzu ( *pgibt uns den Buchstaben, -65damit wir das Array ordnungsgemäß indizieren können). Da mes sich um ein handelt char*, das in ein konvertiert wird, bringen charwir es mit einem Minus 48auf 0 zurück, aber add 1since mwird als eine Punktzahl weniger für jedes Zeichen deklariert.

_{Ich bin kein begeisterter Poster hier, also hoffe ich, dass ich das richtig gemacht habe. Ich glaube, die Rückgabe nzählt als Ausdruck des Werts, und das Deklarieren einer Funktion ist in Ordnung.}

Haskell , 66 Bytes

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

Probieren Sie es online! Gleicher Ansatz wie die JavaScript-Antwort von DanielIndie .

Haskell , 82 81 Bytes

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

Probieren Sie es online!

PowerShell , 60 Byte

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

Probieren Sie es online!

Japt , 36 Bytes

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Nimmt Eingaben als Kleinbuchstaben und gibt eine Zahl zurück.
Kurze Erklärung:

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

Probieren Sie es online!

Ruby , 60 Bytes

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

Probieren Sie es online!

Ein Lambda, das Eingaben als Array von (Groß-) Zeichen akzeptiert und eine Ganzzahl zurückgibt.

Perl 5 -pF , 50 Bytes

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

Probieren Sie es 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 . ;

Die Eingabe muss in Großbuchstaben erfolgen:
C PPCG 11 OK

Lesbar

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

Probieren Sie es online!

Perl 6 , 52 Bytes

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

Probieren Sie es online!

Ordnet jedes Zeichen einer Ziffer zu und summiert sie. Und addiert 1 für jedes Zeichen, da es keine Ziffer 10 ohne Unicode-Bytes gibt.

Retina 0.8.2 , 41 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung: Wie bei der Haskell-Antwort werden nichttriviale Buchstaben in 1 weniger als ihre Punktzahl übersetzt, und 1 wird später hinzugefügt, wenn die Zeichen in unäre umgewandelt werden. Durch das Setzen des FHVWYLetzten können sie alle auf eine Punktzahl von 3 + 1 abbilden.

C (gcc), 78 72 Bytes

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

Die Zeichenfolge enthält tatsächlich 26 Zeichen. Sehen Sie sich den richtig gerenderten Code an und führen Sie ihn hier aus .

Dank an Gastropner für das Golfspielen von 6 Bytes.

Ungolfed-Version:

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

Erläuterung:

• Die Eingabe erfolgt in Zelle A1
• Die Formel muss als Matrixformel mit Ctrl+ Shift+ eingegeben werden Enter, wodurch die geschweiften Klammern hinzugefügt werden{ } an beiden Enden hinzugefügt werden.
• MID(A1,ROW(A:A),1) Ruft nacheinander alle Zeichen ab (und auch viele leere Werte, da so viele Werte zurückgegeben werden, wie Zeilen im Blatt vorhanden sind).
• CODE(MID(~)&"z")Ruft den ASCII-Wert für jedes Zeichen ab. Das &"z"hängt ein zan das Ende des MID()Ergebnisses an, weil CODE()leere Eingaben nicht gefallen. Der ASCII-Wert fürz ist jedoch höher als jeder Großbuchstabe, sodass er später effektiv ignoriert wird.
• MID("02210313074020029000033739",CODE(~)-64,1) Zieht einen Buchstaben aus der Ergebniszeichenfolge, basierend auf dem um 64 gesenkten ASCII-Wert, sodass die Buchstaben 1-26 statt 65-90 ausführen.
• "0"&MID(~)Dem MID()Ergebnis wird eine Null vorangestellt, da Sie in Excel nicht mit leeren Zeichenfolgen rechnen können , von denen es mehrere gibt.
• 0+("0"&MID(~)) verwandelt all diese Saiten in Zahlen.
• SUM(0+("0"&MID(~))) addiert alle Zeichenketten, die jetzt Zahlen sind.
• LEN(A1)+SUM(~)Fügt die Länge der Eingabe zur Summe hinzu, da alle Werte in der Score-Zeichenfolge ( 02210313074020029000033739) um eins nach unten angepasst wurden, sodass sie alle eine Ziffer lang sind.

Es gibt eine sehr ähnliche Lösung in Google Sheets, aber es kommt mit 97 Bytes, weil ArrayFromula()es länger ist als {}(aber zumindest kann es damit umgehen 0 + "" = 0).

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

Wolfram Language (Mathematica) , 74 Bytes

Natürlich unterstützt Wolfram | Alpha Scrabble Scoring! Dies ist eine anonyme Funktion.

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

Dies funktioniert nicht mit TIO.

Ausführen zu können, gehen Sie hier , nach unten scrollen und klicken Sie auf „ein neues Notebook erstellen»“. Der im Notebook zu verwendende Code befindet sich in diesem TIO-Programm, sodass Sie ihn kopieren können. Fügen Sie jeden Funktionsaufruf in einen eigenen Codeblock ein. Wenn Sie zu viele in einem einzelnen Block ausführen, wird die Ausführung nicht abgeschlossen.

Beachten Sie, dass WolframAlpha eine Anfrage über das Internet gesendet wird. Obwohl es andere Antworten auf PPCG gibt, die es verwenden, dachte ich, dass Sie es wissen sollten.

Dieses Programm verwendet die unten stehende kürzere Funktion, ruft sie jedoch für jedes einzelne Zeichen der Eingabe auf (wobei jedes Mal ein separater Aufruf an Wolfram | Alpha gesendet wird!).

Dies funktioniert nur für Eingaben bis zur Länge 15, der Breite einer Scrabble-Karte. (49 Bytes)

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

Wie oben, zeigt jedoch das Ergebnis in einem Feld zusammen mit der Frage an, ob die Eingabe ein gültiges Scrabble-Wort ist. (45 Bytes)

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

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

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

+18 Bytes für using System.Linq;

Probieren Sie es online!

K (oK) , 60 38 Bytes

Lösung:

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

Probieren Sie es online!

Erläuterung:

Index in die Scores, Ergebnis aufsummieren.

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

Probieren Sie es online!

35-Byte-Lösung:

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

Führen Sie es online aus