Wyzwanie:

Weź ciąg wielkich lub małych liter jako dane wejściowe (opcjonalnie) i oblicz wynik, który uzyskałby w grze Scrabble w języku angielskim.

Zasady:

Wynik każdej litery jest następujący (użyj tego, nawet jeśli istnieją inne wersje gry):

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

Wynik ciągu jest po prostu sumą wyników każdej z użytych liter. Możesz założyć, że masz dużo kafelków, więc długie słowa i słowa z wieloma takimi samymi literami są prawidłowe.

Przypadki testowe:

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

Najkrótsza odpowiedź w każdym języku wygrywa! Formaty wejściowe i wyjściowe są elastyczne, więc możesz wziąć dane wejściowe jako tablicę znaków (wielkie lub małe litery), jeśli chcesz.

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

Wyjście jest jednoskładnikowa .

Zmniejsza każdą literę do kombinacji liter o niższej punktacji, aż wszystkie litery osiągną 1 punkt. Następnie zamienia te na 1s, aby dać jednoargumentową liczbę.

Wypróbuj online!

Haskell , 86 84 bajtów

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

Wypróbuj online!

Wyjaśnienie

Większość liter daje wynik 1, a zatem nie musimy ich śledzić, zamiast tego po prostu zmniejszamy każdy wynik (zapisujemy również 1 bajt 10), a następnie dodajemy długość ciągu do wynikowego wyniku.

Dzięki @nimi za -2 bajty (zmiana słów i używanie [1..]zamiast [4,3..])!

Oktawa , 50 bajtów

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

Wypróbuj online!

Wyzwanie przyjęte. Wyjaśnienie:

@(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 bajtów

Ponieważ naprawdę trzeba było to zrobić, oto jest. Debiutowanie było naprawdę paskudne i stanowiło kilka wyzwań.

Wprowadzane dane muszą składać się wyłącznie z wielkich liter. Wyjście jest jednoargumentowe (mam nadzieję, że jest w porządku?)

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

Wypróbuj online!

Ogólny proces to:

• uzyskać znak z wejścia
• odejmij 65
• sprawdź, czy wynik to 0
  • jeśli 0 przeskoczy określoną liczbę słów.
  • w przeciwnym razie odejmij 1 i powtórz kontrolę.
• obiektami skoku są operacje wypychania, a następnie powrót do początku programu.

Kończy się błędem.

Pełniejsze wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Dzięki @JoKing za oszczędność 14 bajtów!

Wersja do odczytu:

({              # 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 bajtów

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

Wypróbuj tutaj

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Krótsza wersja, port odpowiedzi DanielIndie , 71 70 bajtów

^{-1 bajt dzięki Sunny Patel}

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

Wypróbuj online!

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

• @Arnauld niesamowite jak zawsze redukuje 7 bajtów
• dzięki l4m2 za zmniejszenie o 1 bajt

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

Wypróbuj online!

Java 8, 75 71 70 bajtów

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

-1 bajt, zmieniając "02210313074020029000033739".charAt(c-65)-47na niedrukowalne (i dwa \n), aby -47można je było usunąć. Zainspirowany odpowiedzią Octave @Sanchises .

Wypróbuj 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 bajtów

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

Wypróbuj online!

Galaretka , 19 bajtów

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

Monadyczny link akceptujący listę wielkich liter, który zwraca liczbę całkowitą

Wypróbuj online! Lub zobacz zestaw testowy .

W jaki sposób?

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 bajtów

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

')[u(W)-64])

Wypróbuj online!

Pobiera dane wejściowe jako ciąg wielkich liter. R bez problemu radzi sobie z niedrukowalnymi i wielowierszowymi ciągami, więc to miłe. Teraz jesteśmy prawie dwa razy większy niż pakiet zewnętrzny!

A ponieważ CRAN ma tak wiele losowych gadżetów:

R + ScrabbleScore 31 bajtów

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

Wypróbuj online!

Niestety swsdomyślnie sprawdza ważność.

Emojicode , 358 bajtów

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

Wypróbuj online!

Wyjaśnienie:

Zmieniłem nazwy zmiennych z pojedynczych liter na bardziej znaczące słowa i rozszerzyłem niektóre części mojego kodu, aby, mam nadzieję, uczynić go bardziej czytelnym dla osób niezaznajomionych z językiem. Rozszerzony program możesz przetestować tutaj .

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

Pobiera dane wejściowe jako małą listę znaków.

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

Wypróbuj online! lub jako pakiet testowy

Oktawa , 73 bajty

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

Wypróbuj online!

Wykorzystuje ismemberdo mapowania każdego znaku w strumieniu wejściowymx na jego indeks w ciągu wyszukiwania'QZJXKFHVWYBCMPDG' . Każdy nie odnaleziony element zostanie zmapowany na indeks 0 (będzie to obejmował znaki 1-punktowe).

Następnie dodajemy 1 do indeksu, aby zera stały się prawidłowymi odwołaniami do 1-indeksu i sprawdzały ciąg znaków '09977433333222211' . Jest to jeden element dłuższy niż pierwszy ciąg wyszukiwania. Cyfry oznaczają wartość punktową każdego elementu w oryginalnym ciągu, minus 1, przy czym dodatkowym elementem jest „0” nabeginning .

Ostatecznie powstały ciąg jest konwertowany na liczby całkowite przez odjęcie 47( '0'-1), co daje wartość punktową dla każdej litery, a następnie wszystkie wartości punktowe są sumowane.

C ++, 95 bajtów

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

Wypróbuj online (nie jest to link do TIO przepraszam)

Wyjaśnienie:

• Deklaruje m , tablica wartości każdej litery w kolejności, minus 1. minus 1 wynika z Q i Z: nie mogłem mieć tam dwucyfrowej liczby
• Iteruje przez ciąg znaków, paż dojdziemy do znaku zerowego, i dodaje wynik liczby ( *pdaje nam literę, -65dzięki czemu możemy poprawnie indeksować tablicę). Ponieważ mjest char*to, konwertuje się na chartak, więc my minus, 48więc przywróć go do 0, ale dodaj, 1ponieważ mjest zadeklarowany jako jeden wynik mniej dla każdej postaci.

_{Nie jestem tutaj zagorzałym plakatem, więc mam nadzieję, że zrobiłem to poprawnie. Uważam, że zwracane nliczą się jako drukowanie wartości, a deklarowanie funkcji jest w porządku.}

Haskell , 66 bajtów

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

Wypróbuj online! Takie samo podejście jak w odpowiedzi DanielIndie na JavaScript .

Haskell , 82 81 bajtów

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

Wypróbuj online!

PowerShell , 60 bajtów

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

Wypróbuj online!

Japt , 36 bajtów

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Pobiera dane wejściowe jako ciąg małych liter, zwraca liczbę.
Krótkie wyjaśnienie:

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

Wypróbuj online!

Rubinowy , 60 bajtów

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

Wypróbuj online!

Lambda, akceptuje dane wejściowe jako tablicę (wielkich liter) znaków i zwraca liczbę całkowitą.

Perl 5 -pF , 50 bajtów

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

Wypróbuj online!

Gforth , 109 bajtów

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

Dane wejściowe muszą być pisane wielkimi literami:
C PPCG 11 OK

Czytelny

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

Wypróbuj online!

Perl 6 , 52 bajtów

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

Wypróbuj online!

Mapuje każdą postać na cyfrę i sumuje je. I dodaje 1 dla każdego znaku, ponieważ nie ma cyfry 10 bez ponoszenia bajtów Unicode.

Retina 0.8.2 , 41 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. Objaśnienie: Podobnie jak odpowiedź Haskella, nietrywialne litery są tłumaczone na 1 mniej niż ich wynik, a 1 dodaje się później, gdy znaki są konwertowane na jednoargumentowe. Umieszczenie FHVWYostatniego pozwala im wszystkim przypisać mapę do wyniku 3 + 1.

C (gcc), 78 72 bajtów

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

W rzeczywistości w ciągu jest 26 znaków. Zobacz poprawnie renderowany kod i uruchom go tutaj .

Dzięki gastropner za grę w golfa 6 bajtów.

Wersja bez golfa:

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 bajtów

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

Wyjaśnienie:

• Dane wejściowe są w komórce A1
• Formułę należy wprowadzić jako formułę tablicową z Ctrl+ Shift+ Enter, która dodaje nawiasy klamrowe{ } na obu końcach.
• MID(A1,ROW(A:A),1) wyciąga po kolei każdy znak (i ​​wiele pustych wartości, ponieważ zwróci tyle wartości, ile jest wierszy w arkuszu)
• CODE(MID(~)&"z")wyciąga wartość ASCII dla każdego znaku. &"z"Dołącza zna końcu MID()wyniku, ponieważ CODE()nie lubi pustych wejść. Jednak wartość ASCII dla zjest wyższa niż każda wielka litera, więc jest później skutecznie ignorowana.
• MID("02210313074020029000033739",CODE(~)-64,1) wyciąga literę z łańcucha wyniku na podstawie wartości ASCII skorygowanej w dół o 64, więc litery biegną 1-26 zamiast 65-90.
• "0"&MID(~) wstawia zero na MID() wyniku, ponieważ Excel nie pozwoli ci wykonywać matematyki z pustymi ciągami, których będzie kilka.
• 0+("0"&MID(~)) zamienia wszystkie te ciągi na liczby.
• SUM(0+("0"&MID(~))) dodaje wszystkie ciągi, które są teraz liczbami.
• LEN(A1)+SUM(~)dodaje długość danych wejściowych do sumy, ponieważ wszystkie wartości w łańcuchu wyników ( 02210313074020029000033739) zostały zmniejszone o jedną, aby wszystkie miały długość jednej cyfry.

Jest bardzo podobne rozwiązanie w Arkuszach Google, ale ma 97 bajtów, ponieważ ArrayFromula()jest dłuższe niż {}(ale przynajmniej może sobie poradzić 0 + "" = 0).

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

Wolfram Language (Mathematica) , 74 bajty

Oczywiście Wolfram | Alpha obsługuje scrabble! To anonimowa funkcja.

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

To nie działa na TIO.

Aby uruchomić, przejdź tutaj , przewiń w dół i kliknij „Utwórz nowy notatnik» ”. Kod do użycia w notebooku znajduje się w tym programie TIO więc możesz go skopiować. Wklej każde wywołanie funkcji do własnego bloku kodu. Jeśli uruchomisz zbyt wiele w jednym bloku, wykonanie się nie zakończy.

Zauważ, że WolframAlpha wysyła żądanie za pośrednictwem Internetu. Chociaż istnieją inne odpowiedzi na PPCG, które go wykorzystują, pomyślałem, że powinieneś wiedzieć.

Ten program używa poniższej krótszej funkcji, ale wywołuje ją dla każdego znaku wejściowego (wysyłając osobne wywołanie do Wolfram | Alpha za każdym razem!)

Działa to tylko w przypadku danych wejściowych o długości do 15, czyli szerokości płyty Scrabble. (49 bajtów)

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

To samo co powyżej, ale wyświetli wynik w polu wraz z informacją, czy dane wejściowe są prawidłowym słowem Scrabble. (45 bajtów)

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

C # (.NET Core) , 50 + 18 = 68 bajtów

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

+18 bajtów dla using System.Linq;

Wypróbuj online!

K (oK) , 60 38 bajtów

Rozwiązanie:

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

Wypróbuj online!

Wyjaśnienie:

Indeks do wyników, podsumowanie wyniku.

+/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 bajtów

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

Wypróbuj online!

Rozwiązanie 35-bajtowe:

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

Uruchom to online