ท้าทาย:

ใช้สตริงของตัวอักษรตัวพิมพ์ใหญ่หรือตัวเล็กเป็นอินพุต (เป็นทางเลือก) และคำนวณคะแนนที่สตริงจะได้รับในเกมScrabble เป็นภาษาอังกฤษ

กฎ:

คะแนนของตัวอักษรแต่ละตัวมีดังนี้ (ใช้สิ่งนี้แม้ว่าจะมีเกมเวอร์ชั่นอื่น):

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

คะแนนของสตริงเป็นเพียงผลรวมของคะแนนของตัวอักษรแต่ละตัวที่ใช้ คุณอาจคิดว่าคุณมีแผ่นกระเบื้องมากมายคำที่ยาวมากและคำที่มีตัวอักษรเดียวกันหลายตัวเป็นอินพุตที่ถูกต้อง

กรณีทดสอบ:

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

คำตอบที่สั้นที่สุดในแต่ละภาษาชนะ! รูปแบบอินพุตและเอาต์พุตมีความยืดหยุ่นดังนั้นคุณอาจใช้อินพุตเป็นอาร์เรย์ของอักขระ (ตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก) หากคุณต้องการ

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

การส่งออกอยู่ในเอก

ลดตัวอักษรแต่ละตัวให้เป็นชุดของตัวอักษรที่ให้คะแนนต่ำกว่าจนกว่าตัวอักษรทั้งหมดจะเป็น 1 ตัวเลือก จากนั้นแทนที่ผู้ที่มี1s เพื่อนับจำนวนนารี

ลองออนไลน์!

Haskell , 86 84 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ตัวอักษรส่วนใหญ่ให้คะแนน 1 และเราไม่จำเป็นต้องติดตามสิ่งเหล่านี้ แต่เราลดระดับคะแนนแต่ละอันลง (ประหยัด 1 ไบต์10ด้วย) จากนั้นเพิ่มความยาวของสตริงลงในคะแนนที่ได้

ขอบคุณ@nimiสำหรับ -2 ไบต์ (จัดเรียงคำและใช้[1..]แทน[4,3..])!

อ็อกเทฟ 50 ไบต์

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

ลองออนไลน์!

รับคำท้า. คำอธิบาย:

@(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 ไบต์

เนื่องจากต้องทำจริงๆนี่คือ เป็นเรื่องที่น่ารังเกียจจริงๆที่จะแก้ไขข้อบกพร่องและให้ความท้าทายเล็กน้อย

ข้อมูลที่ป้อนต้องเป็นตัวอักษรตัวพิมพ์ใหญ่เท่านั้น ผลผลิตไม่พร้อมกัน (หวังว่าจะโอเคไหม)

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

ลองออนไลน์!

กระบวนการทั่วไปคือ:

• รับตัวละครจากอินพุต
• ลบ 65
• ตรวจสอบว่าผลลัพธ์เป็น 0
  • ถ้า 0 ข้ามจำนวนคำที่ระบุ
  • มิฉะนั้นลบ 1 และตรวจสอบซ้ำ
• เป้าหมายการกระโดดคือการดำเนินการพิมพ์แบบกดแล้ววนกลับไปที่จุดเริ่มต้นของโปรแกรม

จบด้วยข้อผิดพลาด

คำอธิบายที่สมบูรณ์มากขึ้น:

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 ไบต์

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

ลองออนไลน์!

ขอบคุณ @JoKing สำหรับการบันทึก 14 ไบต์!

รุ่นที่อ่านได้:

({              # 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 ไบต์

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

ลองที่นี่

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

เวอร์ชั่นที่สั้นกว่าพอร์ตของคำตอบของ DanielIndieขนาด71 70 ไบต์

^{-1 ไบต์ขอบคุณ Sunny Patel}

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

ลองออนไลน์!

JavaScript (Node.js) , 71 66 63 62 ไบต์

• @Arnauld ยอดเยี่ยมเช่นเคยลดลง 7 ไบต์
• ขอบคุณ l4m2 สำหรับการแปลงโดย 1 ไบต์

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

ลองออนไลน์!

Java 8, 75 71 70 ไบต์

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

-1 ไบต์โดยเปลี่ยน"02210313074020029000033739".charAt(c-65)-47เป็น unprintables (และสอง\n) เพื่อให้-47สามารถลบได้ แรงบันดาลใจจาก@Sanchises' คำตอบ

ลองออนไลน์

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

ระดับแปดเสียง / MATLAB, 85 ไบต์

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

ลองออนไลน์!

เยลลี่ขนาด 19 ไบต์

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

ลิงก์ monadic ยอมรับรายการของอักขระตัวพิมพ์ใหญ่ซึ่งส่งคืนจำนวนเต็ม

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

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 ไบต์

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

')[u(W)-64])

ลองออนไลน์!

รับอินพุตเป็นสตริงตัวพิมพ์ใหญ่ R จัดการกับ unprintables และ multiline string โดยไม่มีปัญหาดังนั้นมันดี ตอนนี้เราเกือบสองแพ็คเกจภายนอก!

และเนื่องจาก CRAN มีสินค้าสุ่มมากมาย:

R + ScrabbleScore 31 ไบต์

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

ลองออนไลน์!

น่าเศร้าที่swsตรวจสอบความถูกต้องตามค่าเริ่มต้น

อิโมจิโคด , 358 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

ฉันเปลี่ยนชื่อตัวแปรจากตัวอักษรเดียวเป็นคำที่มีความหมายมากกว่าและขยายบางส่วนของรหัสของฉันเพื่อหวังว่าจะทำให้คนอ่านไม่คุ้นเคยกับภาษามากขึ้น คุณสามารถทดสอบโปรแกรมขยายที่นี่

🐋🔡🍇      👴 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 ไบต์

รับอินพุตเป็นรายการตัวอักษรตัวพิมพ์เล็ก

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

ลองออนไลน์! หรือเป็นชุดทดสอบ

ระดับแปดเสียง 73 ไบต์

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

ลองออนไลน์!

ใช้ismemberเพื่อทำแผนที่ตัวละครในสตรีมใส่แต่ละมันลงของดัชนีในการค้นหาสตริงx 'QZJXKFHVWYBCMPDG'องค์ประกอบใด ๆ ที่ไม่พบจะถูกแมปกับดัชนี 0 (ซึ่งจะรวมถึงอักขระ 1 จุด)

ต่อไปเราจะเพิ่ม 1 ดัชนีที่จะทำให้ 0 กลายเป็นที่ถูกต้องในลำดับที่ 1 '09977433333222211'ดัชนีและค้นหาเข้าไปในสตริง นี่เป็นองค์ประกอบหนึ่งที่ยาวกว่าสตริงการค้นหาแรก ตัวเลขแทนค่าจุดขององค์ประกอบในสายเดิมแต่ละลบ 1 กับองค์ประกอบเสริมเป็น '0' beginningที่

ในที่สุดสตริงผลลัพธ์จะถูกแปลงเป็นจำนวนเต็มโดยการลบ47( '0'-1) ทำให้ได้ค่าจุดสำหรับตัวอักษรแต่ละตัวแล้วรวมค่าจุดทั้งหมด

C ++, 95 ไบต์

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

ลองออนไลน์ (ไม่ใช่ลิงค์ TIO ขออภัย)

คำอธิบาย:

• ประกาศmอาร์เรย์ของค่าของแต่ละตัวอักษรตามลำดับลบ 1 ลบ 1 เป็นเพราะ Q และ Z: ฉันไม่สามารถมีตัวเลขสองหลักในนั้น
• วนซ้ำผ่านสตริงpจนกว่าเราจะได้อักขระว่างและเพิ่มคะแนนของตัวเลข ( *pให้ตัวอักษรกับเราและ-65เราสามารถทำดัชนีอาร์เรย์ได้อย่างถูกต้อง) ตั้งแต่mเป็นchar*จะแปลงไปcharเพื่อให้เราลบ48เพื่อนำมันกลับไปที่ 0 แต่เพิ่ม1ตั้งแต่mมีการประกาศให้เป็นหนึ่งคะแนนน้อยกว่าสำหรับตัวละครแต่ละตัว

_{ฉันไม่ใช่โปสเตอร์ตัวยงที่นี่ดังนั้นฉันหวังว่าฉันจะทำอย่างถูกต้อง ฉันเชื่อว่าพวกเขากลับมาnนับเป็นพิมพ์ค่าและการประกาศฟังก์ชั่นที่ดี}

Haskell , 66 ไบต์

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

ลองออนไลน์! วิธีการเช่นเดียวกับคำตอบของ JavaScript DanielIndie

Haskell , 82 81 ไบต์

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

ลองออนไลน์!

PowerShellขนาด 60 ไบต์

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

ลองออนไลน์!

Japt , 36 ไบต์

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

รับอินพุตเป็นสตริงตัวพิมพ์เล็กส่งคืนตัวเลข
คำอธิบายสั้น ๆ :

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

ลองออนไลน์!

Ruby , 60 ไบต์

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

ลองออนไลน์!

แลมบ์ดาซึ่งรับอินพุตเป็นอาร์เรย์ของอักขระ (ตัวพิมพ์ใหญ่) และส่งคืนจำนวนเต็ม

Perl 5 -pF , 50 ไบต์

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

ลองออนไลน์!

Gforth , 109 ไบต์

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

ข้อมูลที่ป้อนต้องเป็นตัวพิมพ์ใหญ่:
C PPCG 11 OK

อ่านง่าย

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

ลองออนไลน์!

Perl 6 , 52 ไบต์

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

ลองออนไลน์!

แมปตัวละครทุกตัวให้เป็นตัวเลขและสรุป และเพิ่ม 1 สำหรับอักขระแต่ละตัวเนื่องจากไม่มีตัวเลข 10 หลักที่ไม่มีไบต์ unicode เกิดขึ้น

เรติน่า 0.8.2 , 41 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย: เช่นเดียวกับคำตอบของ Haskell ตัวอักษรเล็ก ๆ น้อย ๆ จะถูกแปลเป็น 1 น้อยกว่าคะแนนของพวกเขาและ 1 จะถูกเพิ่มในภายหลังเมื่อตัวละครถูกแปลงเป็น unary การวางFHVWYครั้งสุดท้ายทำให้พวกเขาทั้งหมดสามารถทำแผนที่ด้วยคะแนน 3 + 1

C (gcc), 78 72 ไบต์

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

จริง ๆ แล้วมีอักขระ 26 ตัวในสตริงนั้น ดูรหัสแสดงผลอย่างถูกต้องและทำงานได้ที่นี่

ขอบคุณGastropnerสำหรับการเล่นกอล์ฟขนาด 6 ไบต์

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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 ไบต์

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

คำอธิบาย:

• อินพุตอยู่ในเซลล์ A1
• ต้องป้อนสูตรเป็นสูตรอาร์เรย์ที่มีCtrl+ Shift+ Enterซึ่งเพิ่มวงเล็บปีกกา{ }ให้กับปลายทั้งสอง
• MID(A1,ROW(A:A),1) ดึงตัวละครแต่ละตัวออกมา (และค่าว่างจำนวนมากเช่นกันเนื่องจากมันจะคืนค่ามากเท่าที่มีแถวในแผ่นงาน)
• CODE(MID(~)&"z")ดึงค่า ASCII ออกสำหรับแต่ละอักขระ &"z"ผนวกzไปยังจุดสิ้นสุดของMID()ผลเพราะCODE()ไม่ชอบปัจจัยการผลิตที่ว่างเปล่า แม้ว่าค่า ASCII สำหรับzจะสูงกว่าตัวพิมพ์ใหญ่ทุกตัวดังนั้นจึงไม่สนใจในภายหลัง
• MID("02210313074020029000033739",CODE(~)-64,1) ดึงตัวอักษรออกจากสตริงคะแนนตามค่า ASCII ที่ปรับลดลง 64 เพื่อให้ตัวอักษรวิ่ง 1-26 แทน 65-90
• "0"&MID(~)เพิ่มศูนย์ไปที่MID()ผลลัพธ์เนื่องจาก Excel จะไม่ยอมให้คุณทำคณิตศาสตร์ด้วยสตริงว่างซึ่งจะมีหลายอย่าง
• 0+("0"&MID(~)) เปลี่ยนสตริงทั้งหมดเหล่านั้นให้เป็นตัวเลข
• SUM(0+("0"&MID(~))) รวมสตริงทั้งหมดที่ตอนนี้เป็นตัวเลข
• LEN(A1)+SUM(~)เพิ่มความยาวของอินพุตให้กับผลรวมเนื่องจากค่าทั้งหมดในสตริงคะแนน ( 02210313074020029000033739) ถูกปรับลดลงหนึ่งค่าดังนั้นพวกเขาทั้งหมดจะยาวหนึ่งหลัก

มีโซลูชันที่คล้ายกันมากใน Google ชีต แต่มีขนาด 97 ไบต์เพราะArrayFromula()ยาวกว่า{}(แต่อย่างน้อยก็สามารถจัดการได้0 + "" = 0)

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

ภาษา Wolfram (Mathematica) , 74 ไบต์

แน่นอน Wolfram | Alpha สนับสนุนการทำคะแนนใน Scrabble! นี่คือฟังก์ชั่นที่ไม่ระบุชื่อ

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

สิ่งนี้ใช้ไม่ได้กับ TIO

หากต้องการเรียกใช้ให้ไปที่นี่เลื่อนลงแล้วคลิก "สร้างสมุดบันทึกใหม่»" รหัสที่ใช้ในสมุดบันทึกอยู่ในโปรแกรม TIO นี้เพื่อให้คุณสามารถคัดลอกได้ วางแต่ละการเรียกฟังก์ชันในบล็อกรหัสของตนเอง หากคุณเรียกใช้มากเกินไปในบล็อกเดียวการดำเนินการจะไม่เสร็จสมบูรณ์

โปรดทราบว่าWolframAlphaส่งคำขอโดยใช้อินเทอร์เน็ต แม้ว่าจะมีคำตอบอื่น ๆ เกี่ยวกับ PPCG ที่ใช้มันฉันคิดว่าคุณควรรู้

โปรแกรมนี้ใช้ฟังก์ชั่นที่สั้นกว่าด้านล่าง แต่เรียกใช้กับอักขระแต่ละตัวของอินพุต (ส่งการโทรแยกต่างหากไปยัง Wolfram | Alphaแต่ละครั้ง!)

ใช้งานได้กับอินพุตที่มีความยาวสูงสุด 15 เท่านั้นความกว้างของบอร์ด Scrabble (49 ไบต์)

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

เหมือนด้านบน แต่จะแสดงผลลัพธ์ในกล่องพร้อมกับว่าอินพุตเป็นคำ Scrabble ที่ถูกต้องหรือไม่ (45 ไบต์)

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

C # (. NET Core) , 50 + 18 = 68 ไบต์

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

+18 ไบต์สำหรับ using System.Linq;

ลองออนไลน์!

K (oK) , 60 38 ไบต์

วิธีการแก้:

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

ลองออนไลน์!

คำอธิบาย:

จัดทำดัชนีคะแนนรวมผลสรุป

+/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 ไบต์

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

ลองออนไลน์!

วิธีแก้ปัญหา 35 ไบต์:

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

เปิดใช้งานออนไลน์