Tantangan:

Ambil string huruf besar atau kecil sebagai input (opsional), dan hitung skor yang didapat string dalam permainan Scrabble dalam bahasa Inggris.

Aturan:

Skor setiap huruf adalah sebagai berikut (gunakan ini bahkan jika ada versi lain dari permainan):

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

Skor string hanyalah jumlah dari skor setiap huruf yang digunakan. Anda mungkin berasumsi bahwa Anda memiliki banyak ubin yang tersedia, kata-kata yang sangat panjang, dan kata-kata dengan banyak huruf yang sama merupakan input yang valid.

Kasus uji:

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

Jawaban terpendek di setiap bahasa menang! Format input dan output fleksibel, sehingga Anda dapat mengambil input sebagai array karakter (huruf besar atau kecil) jika Anda mau.

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

Keluaran dalam bentuk unary .

Kurangi setiap huruf menjadi kombinasi huruf yang memiliki skor lebih rendah hingga semua huruf memiliki 1-skor. Kemudian gantilah yang dengan 1s untuk memberikan hitungan yang unary.

Cobalah online!

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]

Cobalah online!

Penjelasan

Sebagian besar huruf memberikan skor 1 dan karenanya kita tidak perlu melacaknya, alih-alih kita hanya mengurangi setiap skor (menyimpan 1 byte 10juga) dan kemudian menambahkan panjang string ke skor yang dihasilkan.

Terima kasih @nimi untuk -2 bytes (rearanging kata-kata dan menggunakan [1..]bukan [4,3..])!

Oktaf , 50 byte

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

Cobalah online!

Tantangan diterima. Penjelasan:

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

Karena itu benar-benar harus dilakukan, ini dia. Benar-benar jahat untuk men-debug dan memberikan beberapa tantangan.

Masukan harus huruf besar saja. Outputnya unary (harap tidak apa-apa?)

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

Cobalah online!

Proses umum adalah:

• dapatkan karakter dari input
• kurangi 65
• periksa apakah hasilnya 0
  • jika 0 lompati jumlah kata yang ditentukan.
  • kalau tidak kurangi 1 dan ulangi cek.
• target lompatan adalah operasi cetak dorong diikuti loop kembali ke awal program.

Berakhir dengan kesalahan.

Penjelasan lebih lengkap:

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

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

Cobalah online!

Terima kasih kepada @ JoKing karena telah menghemat 14 byte!

Versi yang dapat dibaca:

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

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

Coba di sini

Penjelasan

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

Cobalah online!

Versi lebih pendek, port jawaban DanielIndie , 71 70 byte

^{-1 byte terima kasih kepada Sunny Patel}

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

Cobalah online!

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

• @Arnauld luar biasa karena selalu mengurangi 7 byte
• terima kasih kepada l4m2 untuk rducing sebesar 1 byte

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

Cobalah online!

Java 8, 75 71 70 byte

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

-1 byte dengan mengubah "02210313074020029000033739".charAt(c-65)-47ke unsintables (dan dua \n) sehingga -47dapat dihapus. Terinspirasi oleh jawaban Octaf @Sanchises .

Cobalah 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

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

Cobalah online!

Jelly , 19 byte

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

Tautan monadik yang menerima daftar karakter huruf besar yang mengembalikan bilangan bulat

Cobalah online! Atau lihat test-suite .

Bagaimana?

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

Cobalah online!

Mengambil input sebagai string huruf besar. R menangani unfintables dan string multiline tanpa masalah, jadi itu bagus. Sekarang kita hampir dua kali lipat dari paket eksternal!

Dan karena CRAN memiliki begitu banyak barang acak:

R + ScrabbleScore 31 byte

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

Cobalah online!

Sayangnya, swsmemeriksa validitas secara default.

Emojicode , 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🍉

Cobalah online!

Penjelasan:

Saya mengubah nama variabel dari satu huruf menjadi kata-kata yang lebih bermakna, dan memperluas beberapa bagian kode saya semoga membuatnya lebih mudah dibaca oleh orang-orang yang tidak terbiasa dengan bahasa tersebut. Anda dapat menguji program yang diperluas di sini .

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

Mengambil input sebagai daftar karakter huruf kecil.

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

Cobalah online! atau sebagai Test suite

Oktaf , 73 byte

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

Cobalah online!

Digunakan ismemberuntuk memetakan setiap karakter dalam aliran input xke indeksnya dalam string pencarian 'QZJXKFHVWYBCMPDG'. Elemen apa pun yang tidak ditemukan akan dipetakan ke indeks 0 (ini akan mencakup karakter 1 poin).

Selanjutnya kita menambahkan 1 ke indeks untuk membuat 0 menjadi referensi 1-indeks yang valid, dan mencari ke dalam string '09977433333222211'. Ini adalah satu elemen lebih panjang dari string pencarian pertama. Digit mewakili nilai titik dari setiap elemen dalam string asli, minus 1, dengan elemen tambahan menjadi '0' di beginning.

Akhirnya string yang dihasilkan dikonversi menjadi bilangan bulat dengan mengurangi 47( '0'-1), menghasilkan nilai poin untuk setiap huruf, dan semua nilai poin kemudian dijumlahkan.

C ++, 95 byte

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

Cobalah online (bukan tautan TIO, maaf)

Penjelasan:

• Deklarasikan m, larik nilai setiap huruf secara berurutan, minus 1. minus 1 adalah karena Q dan Z: Saya tidak dapat memiliki angka dua digit di sana
• Iterasi melalui string psampai kita mendapatkan karakter nol, dan menambahkan skor nomor ( *pmemberi kita surat, dan -65agar kita dapat mengindeks array dengan benar). Sejak madalah char*itu mengkonversi ke charsehingga kita dikurangi 48sehingga membawanya kembali ke 0, tetapi menambahkan 1sejak mdinyatakan sebagai salah satu skor kurang untuk setiap karakter.

_{Saya bukan poster keranjingan di sini jadi saya harap saya telah melakukan ini dengan benar. Saya percaya mereka kembali ndihitung sebagai mencetak nilai, dan menyatakan fungsi itu baik-baik saja.}

Haskell , 66 byte

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

Cobalah online! Pendekatan yang sama dengan jawaban JavaScript DanielIndie .

Haskell , 82 81 byte

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

Cobalah online!

PowerShell , 60 byte

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

Cobalah online!

Japt , 36 byte

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Mengambil input sebagai string huruf kecil, mengembalikan nomor.
Penjelasan singkat:

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

Cobalah online!

Ruby , 60 byte

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

Cobalah online!

Lambda, menerima input sebagai array karakter (huruf besar) dan mengembalikan integer.

Perl 5 -pF , 50 byte

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

Cobalah 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 . ;

Input harus dalam huruf besar:
C PPCG 11 OK

Dapat dibaca

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

Cobalah online!

Perl 6 , 52 byte

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

Cobalah online!

Memetakan setiap karakter ke angka, dan menjumlahkannya. Dan menambahkan 1 untuk setiap karakter karena tidak ada angka 10 tanpa menimbulkan byte unicode.

Retina 0.8.2 , 41 byte

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

Cobalah online! Tautan termasuk kasus uji. Penjelasan: Seperti jawaban Haskell, huruf nontrivial diterjemahkan ke 1 kurang dari skor mereka, dan 1 ditambahkan kemudian ketika karakter dikonversi ke unary. Menempatkan yang FHVWYterakhir memungkinkan mereka semua untuk memetakan ke skor 3 + 1.

C (gcc), 78 72 byte

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

Sebenarnya ada 26 karakter di string itu. Lihat kode yang diberikan dengan benar dan jalankan di sini .

Berkat gastropner untuk bermain golf 6 byte.

Versi tidak disatukan:

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

Penjelasan:

• Input ada di sel A1
• Rumus harus dimasukkan sebagai rumus array dengan Ctrl+ Shift+ Enter, yang menambahkan tanda kurung keriting { }ke kedua ujungnya.
• MID(A1,ROW(A:A),1) menarik setiap karakter secara bergantian (dan banyak nilai kosong juga, karena itu akan mengembalikan nilai sebanyak ada baris di sheet)
• CODE(MID(~)&"z")mengeluarkan nilai ASCII untuk setiap karakter. The &"z"menambahkan sebuah zakhir dari MID()hasil karena CODE()tidak seperti input kosong. Nilai ASCII untuk zlebih tinggi dari setiap huruf kapital, jadi itu diabaikan secara efektif nanti.
• MID("02210313074020029000033739",CODE(~)-64,1) menarik keluar surat dari string skor berdasarkan nilai ASCII-nya yang disesuaikan hingga 64 sehingga huruf-huruf itu berjalan 1-26 bukannya 65-90.
• "0"&MID(~)menambahkan nol ke MID()hasil karena Excel tidak akan membiarkan Anda melakukan matematika dengan string kosong, yang akan ada beberapa.
• 0+("0"&MID(~)) mengubah semua string menjadi angka.
• SUM(0+("0"&MID(~))) menambahkan semua string yang sekarang nomor.
• LEN(A1)+SUM(~)menambahkan panjang input ke penjumlahan karena semua nilai dalam string skor ( 02210313074020029000033739) disesuaikan ke bawah oleh satu sehingga mereka semua akan menjadi satu digit panjangnya.

Ada solusi yang sangat mirip di Google Sheets tetapi ia datang pada 97 byte karena ArrayFromula()lebih panjang dari {}(tetapi setidaknya itu bisa menangani 0 + "" = 0).

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

Bahasa Wolfram (Mathematica) , 74 byte

Tentu saja Wolfram | Alpha mendukung penilaian Scrabble! Ini adalah fungsi anonim.

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

Ini tidak berfungsi pada TIO.

Untuk menjalankan, buka di sini , gulir ke bawah dan klik "Buat Notebook Baru» ". Kode yang digunakan di notebook ada di program TIO ini sehingga Anda dapat menyalinnya. Rekatkan setiap panggilan fungsi dalam blok kode sendiri. Jika Anda menjalankan terlalu banyak dalam satu blok, eksekusi tidak akan selesai.

Catatan yang WolframAlphamengirim permintaan menggunakan Internet. Meskipun ada jawaban lain pada PPCG yang menggunakannya, saya pikir Anda harus tahu.

Program ini menggunakan fungsi yang lebih pendek di bawah ini, tetapi menyebutnya pada setiap karakter individu dari input (mengirim panggilan terpisah ke Wolfram | Alpha setiap kali!)

Ini hanya berfungsi untuk input hingga panjang 15, lebar papan Scrabble. (49 byte)

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

Sama seperti di atas, tetapi akan menampilkan hasilnya dalam kotak, bersama dengan apakah input adalah kata Scrabble yang valid. (45 byte)

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

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

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

+18 byte untuk using System.Linq;

Cobalah online!

K (oK) , 60 38 byte

Larutan:

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

Cobalah online!

Penjelasan:

Indeks ke dalam skor, jumlah hasil.

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

Cobalah online!

Solusi 35 byte:

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

Jalankan secara online