Thử thách:

Lấy một chuỗi các chữ cái in hoa hoặc in thường làm đầu vào (tùy chọn) và tính điểm số mà chuỗi đó sẽ nhận được trong trò chơi Scrabble bằng tiếng Anh.

Quy tắc:

Điểm của mỗi chữ cái như sau (sử dụng ngay cả khi có các phiên bản khác của trò chơi):

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

Điểm của một chuỗi chỉ đơn giản là tổng số điểm của từng chữ cái được sử dụng. Bạn có thể cho rằng bạn có sẵn nhiều ô xếp sẵn, vì vậy các từ dài và các từ có nhiều chữ cái giống nhau là đầu vào hợp lệ.

Các trường hợp thử nghiệm:

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

Câu trả lời ngắn nhất trong mỗi ngôn ngữ chiến thắng! Các định dạng đầu vào và đầu ra là linh hoạt, vì vậy bạn có thể lấy đầu vào dưới dạng một mảng các ký tự (chữ hoa hoặc chữ thường) nếu bạn muốn.

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

Đầu ra là trong unary .

Giảm từng chữ cái thành một tổ hợp các chữ cái có điểm thấp hơn cho đến khi tất cả các chữ cái là 1 điểm. Sau đó thay thế những người bằng 1s để đưa ra một số đếm đơn nhất.

Hãy thử trực tuyến!

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]

Hãy thử trực tuyến!

Giải trình

Hầu hết các chữ cái cho điểm 1 và do đó chúng tôi không cần theo dõi những điểm này, thay vào đó chúng tôi chỉ giảm từng điểm (cũng tiết kiệm 1 byte 10) và sau đó thêm độ dài của chuỗi vào điểm kết quả.

Cảm ơn @nimi cho -2 byte (sắp xếp lại các từ và sử dụng [1..]thay vì [4,3..])!

Octave , 50 byte

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

Hãy thử trực tuyến!

Thử thách được chấp nhận. Giải trình:

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

Vì nó thực sự phải được thực hiện, đây là nó. Đó là một thực sự khó chịu để gỡ lỗi và cung cấp một vài thách thức.

Đầu vào phải là chữ in hoa. Đầu ra là đơn nhất (hy vọng là ổn?)

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

Hãy thử trực tuyến!

Quy trình chung là:

• lấy ký tự từ đầu vào
• trừ 65
• kiểm tra nếu kết quả là 0
  • nếu 0 nhảy số lượng từ quy định.
  • mặt khác trừ 1 và kiểm tra lại.
• các mục tiêu nhảy là các hoạt động in ấn theo sau là một vòng lặp trở lại bắt đầu chương trình.

Kết thúc với một lỗi.

Một lời giải thích đầy đủ hơn:

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

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

Hãy thử trực tuyến!

Cảm ơn @JoKing vì đã lưu 14 byte!

Phiên bản dễ đọc:

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

Bình thường, 40 byte

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

Hãy thử nó ở đây

Giải trình

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

Hãy thử trực tuyến!

Phiên bản ngắn hơn, cổng câu trả lời của Daniel. , 71 70 byte

^{-1 byte nhờ Sunny Patel}

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

Hãy thử trực tuyến!

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

• @Arnauld tuyệt vời khi luôn giảm 7 byte
• cảm ơn l4m2 vì đã bắt đầu 1 byte

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

Hãy thử trực tuyến!

Java 8, 75 71 70 byte

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

-1 byte bằng cách thay đổi "02210313074020029000033739".charAt(c-65)-47thành không thể in (và hai \n) để -47có thể loại bỏ. Lấy cảm hứng từ câu trả lời Octave của @Sanchises .

Hãy thử trực tuyến.

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)

Hãy thử trực tuyến!

Thạch , 19 byte

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

Một liên kết đơn âm chấp nhận danh sách các ký tự chữ hoa trả về một số nguyên

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi chữ hoa. R xử lý các chuỗi không thể in và chuỗi nhiều dòng mà không có vấn đề, vì vậy đó là tốt đẹp. Bây giờ chúng tôi gần gấp đôi gói bên ngoài!

Và bởi vì CRAN có rất nhiều tính năng ngẫu nhiên:

R + ScrabbleScore 31 byte

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

Hãy thử trực tuyến!

Đáng buồn thay, swskiểm tra tính hợp lệ theo mặc định.

Biểu tượng cảm xúc , 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🍉

Hãy thử trực tuyến!

Giải trình:

Tôi đã thay đổi tên biến từ các chữ cái đơn thành các từ có ý nghĩa hơn và mở rộng một số phần trong mã của tôi để hy vọng làm cho nó dễ đọc hơn đối với những người không quen thuộc với ngôn ngữ này. Bạn có thể kiểm tra chương trình mở rộng ở đây .

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

Đưa đầu vào dưới dạng danh sách chữ thường.

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Octave , 73 byte

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

Hãy thử trực tuyến!

Sử dụng ismemberđể ánh xạ từng ký tự trong luồng đầu vào xvào chỉ mục của nó trong chuỗi tra cứu 'QZJXKFHVWYBCMPDG'. Bất kỳ yếu tố nào không tìm thấy sẽ được ánh xạ tới chỉ số 0 (điều này sẽ bao gồm các ký tự 1 điểm).

Tiếp theo, chúng ta thêm 1 vào chỉ mục để biến 0 trở thành tham chiếu 1 chỉ mục hợp lệ và tra cứu chuỗi '09977433333222211'. Đây là một yếu tố dài hơn chuỗi tra cứu đầu tiên. Các chữ số biểu thị giá trị điểm của từng phần tử trong chuỗi gốc, trừ 1, với phần tử phụ là '0' tại beginning.

Cuối cùng, chuỗi kết quả được chuyển đổi thành số nguyên bằng cách trừ 47( '0'-1), mang lại giá trị điểm cho mỗi chữ cái và sau đó tất cả các giá trị điểm được tính tổng.

C ++, 95 byte

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

Hãy thử trực tuyến (không phải là một liên kết TIO xin lỗi)

Giải trình:

• Khai báo m, một mảng các giá trị của mỗi chữ cái theo thứ tự, trừ đi 1. Điểm trừ 1 là do Q và Z: Tôi không thể có một số có hai chữ số trong đó
• Lặp lại thông qua chuỗi pcho đến khi chúng ta nhận được ký tự null và thêm số điểm của số ( *pcung cấp cho chúng ta chữ cái, và -65do đó chúng ta có thể lập chỉ mục chính xác cho mảng). Kể từ khi mlà một char*nó chuyển thành một charvì vậy chúng tôi trừ 48để đưa nó trở lại 0, nhưng thêm 1kể từ khi mđược khai báo là một điểm ít hơn cho mỗi nhân vật.

_{Tôi không phải là một người say mê áp phích ở đây vì vậy tôi hy vọng tôi đã làm điều này một cách chính xác. Tôi tin rằng họ trả về nđược tính là in giá trị và việc khai báo hàm là ổn.}

Haskell , 66 byte

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

Hãy thử trực tuyến! Cách tiếp cận tương tự như câu trả lời JavaScript của Daniel .

Haskell , 82 81 byte

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

Hãy thử trực tuyến!

PowerShell , 60 byte

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

Hãy thử trực tuyến!

Japt , 36 byte

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Lấy đầu vào dưới dạng một chuỗi chữ thường, trả về một số.
Giải thích ngắn gọ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.

Hãy thử trực tuyến!

Ruby , 60 byte

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

Hãy thử trực tuyến!

Một lambda, chấp nhận đầu vào dưới dạng một mảng các ký tự (chữ hoa) và trả về một số nguyên.

Perl 5 -pF , 50 byte

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

Hãy thử trực tuyến!

Gforth , 109 byte

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

Đầu vào phải là chữ hoa:
C PPCG 11 OK

Có thể đọc được

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

Hãy thử trực tuyến!

Perl 6 , 52 byte

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

Hãy thử trực tuyến!

Ánh xạ mỗi ký tự thành một chữ số và tính tổng chúng. Và thêm 1 cho mỗi ký tự vì không có chữ số 10 mà không phát sinh các byte unicode.

Võng mạc 0.8.2 , 41 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải thích: Giống như câu trả lời của Haskell, các chữ cái không cần thiết được dịch thành 1 ít hơn số điểm của chúng và 1 được thêm vào sau khi các ký tự được chuyển thành unary. Đặt FHVWYcuối cùng cho phép tất cả họ ánh xạ tới điểm 3 + 1.

C (gcc), 78 72 byte

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

Thực tế có 26 ký tự trong chuỗi đó. Xem mã được kết xuất đúng và chạy nó ở đây .

Cảm ơn gastropner đã chơi golf 6 byte.

Phiên bản bị đánh cắp:

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

Giải trình:

• Đầu vào là trong ô A1
• Công thức phải được nhập dưới dạng công thức mảng có Ctrl+ Shift+ Enter, thêm dấu ngoặc nhọn { }vào cả hai đầu.
• MID(A1,ROW(A:A),1) lần lượt kéo ra từng ký tự (và rất nhiều giá trị trống, vì nó sẽ trả về nhiều giá trị như có các hàng trong trang tính)
• CODE(MID(~)&"z")lấy ra giá trị ASCII cho mỗi ký tự. Việc &"z"nối thêm zvào cuối MID()kết quả vì CODE()không thích các đầu vào trống. Tuy nhiên, giá trị ASCII zcao hơn mọi chữ in hoa, do đó, nó thực sự bị bỏ qua sau này.
• MID("02210313074020029000033739",CODE(~)-64,1) lấy ra một chữ cái từ chuỗi điểm dựa trên giá trị ASCII của nó được điều chỉnh xuống 64 để các chữ cái chạy 1-26 thay vì 65-90.
• "0"&MID(~)trả trước một số không cho MID()kết quả vì Excel sẽ không cho phép bạn làm toán với các chuỗi rỗng, trong đó sẽ có một số.
• 0+("0"&MID(~)) biến tất cả các chuỗi thành số.
• SUM(0+("0"&MID(~))) cộng tất cả các chuỗi mà bây giờ là số.
• LEN(A1)+SUM(~)thêm độ dài của đầu vào vào tổng vì tất cả các giá trị trong chuỗi điểm ( 02210313074020029000033739) được điều chỉnh giảm xuống một vì vậy tất cả chúng sẽ dài một chữ số.

Có một giải pháp rất giống nhau trong Google Sheets nhưng nó có tới 97 byte vì ArrayFromula()dài hơn {}(nhưng ít nhất nó có thể xử lý 0 + "" = 0).

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

Ngôn ngữ Wolfram (Mathicala) , 74 byte

Tất nhiên Wolfram | Alpha hỗ trợ ghi điểm Scrabble! Đây là một chức năng ẩn danh.

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

Điều này không hoạt động trên TIO.

Để chạy, vào đây , cuộn xuống và nhấp vào "Tạo sổ ghi chép mới» ". Mã để sử dụng trong sổ ghi chép nằm trong chương trình TIO này để bạn có thể sao chép nó. Dán mỗi lệnh gọi hàm trong khối mã riêng của nó. Nếu bạn chạy quá nhiều trong một khối, việc thực thi sẽ không hoàn thành.

Lưu ý rằng WolframAlphasẽ gửi yêu cầu bằng Internet. Mặc dù có những câu trả lời khác trên PPCG sử dụng nó, tôi nghĩ bạn nên biết.

Chương trình này sử dụng chức năng ngắn hơn bên dưới, nhưng gọi nó trên từng ký tự riêng lẻ của đầu vào (gửi một cuộc gọi riêng tới Wolfram | Alpha mỗi lần!)

Điều này chỉ hoạt động cho đầu vào lên đến chiều dài 15, chiều rộng của bảng Scrabble. (49 byte)

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

Tương tự như trên, nhưng sẽ hiển thị kết quả trong một hộp, cùng với việc liệu đầu vào có phải là một từ Scrabble hợp lệ hay không. (45 byte)

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

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

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

+18 byte cho using System.Linq;

Hãy thử trực tuyến!

K (oK) , 60 38 byte

Giải pháp:

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

Hãy thử trực tuyến!

Giải trình:

Chỉ số vào điểm số, tổng hợp kết quả.

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

Hãy thử trực tuyến!

Giải pháp 35 byte:

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

Chạy nó trực tuyến