Meydan okuma:

Giriş olarak büyük veya küçük harflerden oluşan bir dizge alın (isteğe bağlı) ve İngilizce'nin Scrabble oyununda alacağı puanı hesaplayın .

Kurallar:

Her harfin puanı aşağıdaki gibidir (Oyunun diğer versiyonları olsa bile bunu kullanın):

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

Bir dizgenin puanı basitçe kullanılan harflerin her birinin puanlarının toplamıdır. Çok fazla kiremit bulunduğunu varsayalım, o kadar uzun kelimeler ve aynı harflerin birçoğunun bulunduğu kelimeler geçerli girdi.

Test durumları:

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

Her dilde en kısa cevap kazanır! Giriş ve çıkış formatları esnektir, bu nedenle girişi isterseniz karakter dizisi (büyük veya küçük harf) olarak alabilirsiniz.

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

Çıkış birleşik .

Tüm harfleri 1 sayı yapana kadar her harfi daha düşük puanlı harflerin bir kombinasyonuna düşürür. O zaman 1unary sayımı vermek için s ile yer değiştirir .

Çevrimiçi deneyin!

Haskell , 86 84 bayt

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

Çevrimiçi deneyin!

açıklama

Harflerin çoğu 1 puan verir ve böylece bunları takip etmemize gerek kalmaz, bunun yerine her puanı düşürür (1 byte da kaydeder 10) ve sonra dizenin uzunluğunu sonuçtaki puana ekleriz.

Teşekkür @nimi için -2 bayt (sözcükleri rearanging ve kullanma [1..]yerine [4,3..])!

Oktav , 50 bayt

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

Çevrimiçi deneyin!

Meydan okuma kabul edildi. Açıklama:

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

Gerçekten yapılması gerektiğine göre, işte burada. Hata ayıklamak ve birkaç zorluk ortaya koymak gerçekten çok kötüydü.

Giriş yalnızca büyük harfler olmalıdır. Çıktılar tekdüze (umarım iyidir?)

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

Çevrimiçi deneyin!

Genel süreç:

• girişten karakter al
• 65 çıkarma
• sonucun 0 olup olmadığını kontrol et
  • 0 ise belirtilen kelimeden atla.
  • aksi halde 1'i çıkarın ve kontrolü tekrarlayın.
• atlama hedefleri basma işlemlerinin ardından programın başlangıcına bir döngüdür.

Hatayla bitiyor.

Daha eksiksiz bir açıklama:

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 bayt

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

Çevrimiçi deneyin!

14 byte tasarruf için @JoKing'e teşekkürler!

Okunabilir sürüm:

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

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

Burada dene

açıklama

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 bayt

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

Çevrimiçi deneyin!

Kısa versiyon, DanielIndie'nin cevabının limanı , 71 70 byte

^{Sunny Patel sayesinde -1 bayt}

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

Çevrimiçi deneyin!

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

• @Arnauld her zaman 7 bayt azaltan olarak harika
• 1 byte için l4m2 sayesinde

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

Çevrimiçi deneyin!

Java 8, 75 71 70 bayt

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

-1 byte "02210313074020029000033739".charAt(c-65)-47yazdırılamaz (ve iki \n) değiştirerek -47kaldırılabilir. @Sanchises'in Octave cevabı esinlenerek .

Çevrimiçi deneyin.

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 bayt

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

Çevrimiçi deneyin!

Jöle , 19 bayt

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

Bir tamsayı döndüren büyük harfli karakterlerin listesini kabul eden bir monadik bağlantı

Çevrimiçi deneyin! Veya test odasına bakın .

Nasıl?

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 bayt

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

')[u(W)-64])

Çevrimiçi deneyin!

Girişi büyük harfli bir dize olarak alır. R, yazdırılamayan ve çok satırlı dizeleri sorun olmadan kullanır, bu yüzden bu hoş. Şimdi harici paketin neredeyse iki katıyız!

Ve çünkü CRAN çok fazla rastgele güzelliklere sahiptir:

R + ScrabbleScore 31 bayt

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

Çevrimiçi deneyin!

Ne yazık ki, swsvarsayılan olarak geçerliliği denetler.

Emojicode , 358 bayt

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

Çevrimiçi deneyin!

Açıklama:

Değişken isimlerini tekil harflerden daha anlamlı kelimelere değiştirdim ve kodumun bazı bölümlerini, dili bilmeyen insanlar için umarım daha okunaklı hale getirmek için genişlettim. Genişletilmiş programı burada test edebilirsiniz .

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

Girdiyi küçük harf karakter listesi olarak alır.

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

Çevrimiçi deneyin! veya Test paketi olarak

Octave , 73 bayt

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

Çevrimiçi deneyin!

Kullanım Alanları ismembergiriş akışındaki her bir karakteri eşleştirmek için xarama dizesinde 's indeksi üzerine 'QZJXKFHVWYBCMPDG'. Bulunmayan herhangi bir öğe, 0 dizinine eşlenir (bu, 1 punto karakterleri içerir).

Sonra 0'ın geçerli 1-index referansları haline gelmesi için dizine 1 ekler ve dizeye bakarız '09977433333222211'. Bu, ilk arama dizesinden daha uzun bir elementtir. Rakamlar, eksi 1'de '0' olan eksi 1'deki orijinal dizedeki her bir öğenin nokta değerini temsil eder beginning.

Son olarak, sonuçta elde edilen dize, her bir harf için puan değerini veren, 47( '0'-1) çıkarılarak tam sayılara dönüştürülür ve daha sonra tüm puan değerleri toplanır.

C ++, 95 bayt

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

Çevrimiçi deneyin (üzgünüz bir TIO bağlantısı değil)

Açıklama:

• mHer harfin değer sırasını sırasıyla eksi 1 olarak bildirir . Eksi 1, Q ve Z nedeniyle: orada iki basamaklı bir sayıya sahip olamadım
• pBoş karaktere ulaşana kadar dizge boyunca yinelenir ve sayının puanını ekler ( *pbize mektubu verir, -65böylece diziyi uygun şekilde dizine ekleyebiliriz). Çünkü mbir char*a'ya dönüşür, charböylece biz eksi 48yani 0'a geri getiririz, ancak o 1zamandan beri mher karakter için bir puan daha az olarak ilan edilir.

_{Burada hevesli bir poster değilim, umarım bunu doğru yapmışımdır. nDeğerin basılması olarak sayıları döndürdüklerine ve bir işlev bildirmenin iyi olduğuna inanıyorum .}

Haskell , 66 bayt

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

Çevrimiçi deneyin! DanielIndie'nin JavaScript cevabı ile aynı yaklaşım .

Haskell , 82 81 bayt

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

Çevrimiçi deneyin!

PowerShell , 60 bayt

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

Çevrimiçi deneyin!

Japt , 36 bayt

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

Girdiyi küçük harfli dizge olarak alır, sayı döndürür
Kısa açıklama:

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

Çevrimiçi deneyin!

Ruby , 60 bayt

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

Çevrimiçi deneyin!

Girişi (büyük harf) karakter dizisi olarak kabul eden ve bir tamsayı döndüren bir lambda.

Perl 5 -pF , 50 bayt

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

Çevrimiçi deneyin!

Gforth , 109 Bayt

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

Giriş büyük harf olmalıdır:
C PPCG 11 OK

Okunabilir

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

Çevrimiçi deneyin!

Perl 6 , 52 bayt

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

Çevrimiçi deneyin!

Her karakteri bir rakama eşler ve bunları bir araya getirir. Ve her karakter için 1 ekler çünkü unicode baytlar olmadan 10 rakamı yoktur.

Retina 0.8.2 , 41 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama: Haskell cevabında olduğu gibi, önemsiz mektuplar puanlarından 1'in altına çevrilir ve karakterler birliğe dönüştürüldükten sonra 1 eklenir. Sonuncuyu koymak FHVWY, hepsinin 3 + 1 puanla eşlemesini sağlar.

C (gcc), 78 72 bayt

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

Bu dizgede aslında 26 karakter var. Doğru şekilde verilen kodu görün ve burada çalıştırın .

6 byte golf oynadığı için gastropner'e teşekkürler .

Ungolfed versiyonu:

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 bayt

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

Açıklama:

• Giriş hücrede A1
• Formül , her iki uca da küme parantezleri ekleyen Ctrl+ Shift+ Enterişaretli bir dizi formülü olarak girilmelidir { }.
• MID(A1,ROW(A:A),1) sırayla her karakteri dışarı çeker (ve çok sayıda boş değer, çünkü sayfadaki satır sayısı kadar değer döndürür)
• CODE(MID(~)&"z")Her karakter için ASCII değerini çıkarır. &"z"Bir ekler zsonuna MID()çünkü sonucu CODE()boş girişler gibi değil. ASCII değeri zher büyük harften daha yüksektir, ancak daha sonra etkin bir şekilde göz ardı edilir.
• MID("02210313074020029000033739",CODE(~)-64,1) 64 ile ayarlanan ASCII değerine göre puan dizisinden bir harf çıkarır, böylece harfler 65-90 yerine 1-26 olur.
• "0"&MID(~)MID()Excel , sonuçta sıfırı hazırlar çünkü Excel birkaç tane olacak boş dizelerle matematik yapmanıza izin vermez.
• 0+("0"&MID(~)) tüm bu dizeleri sayılara dönüştürür.
• SUM(0+("0"&MID(~))) şimdi sayı olan tüm dizeleri ekler.
• LEN(A1)+SUM(~)girişin uzunluğunu toplama ekler çünkü skor dizesindeki ( 02210313074020029000033739) tüm değerler birer birer aşağı ayarlanmıştır, böylece hepsi bir basamak uzunluğunda olur.

Google E-Tablolar'da çok benzer bir çözüm var, ancak 97 baytta geliyor, çünkü ArrayFromula()daha uzun {}(ancak en azından başa çıkabilir 0 + "" = 0).

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

Wolfram Dili (Mathematica) , 74 bayt

Elbette Wolfram | Alpha, Scrabble puanlamasını destekliyor! Bu anonim bir işlevdir.

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

Bu TIO'da çalışmıyor.

Çalıştırmak için buraya gidin , aşağı kaydırın ve "Yeni Bir Defter Oluştur» "seçeneğini tıklayın. Not defterinde kullanılacak kod bu TIO programındadır, böylece kopyalayabilirsiniz. Her işlev çağrısını kendi kod bloğuna yapıştırın. Tek bir blokta çok fazla çalıştırırsanız, yürütme tamamlanmaz.

Not WolframAlphaInternet'i kullanan bir istek gönderir. PPCG'de onu kullanan başka cevaplar olsa da bilmeniz gerektiğini düşündüm.

Bu program aşağıdaki kısa işlevi kullanır, ancak girişin her bir karakteri üzerine çağırır ( her seferinde Wolfram | Alpha'ya ayrı bir çağrı gönderir !)

Bu sadece 15'lik bir Scrabble tahtasının genişliğine kadar olan girişler için işe yarar. (49 bayt)

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

Yukarıdakiyle aynıdır, ancak sonucu geçerli bir Scrabble sözcüğü olup olmadığıyla birlikte bir kutuda görüntüler. (45 bayt)

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

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

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

İçin +18 bayt using System.Linq;

Çevrimiçi deneyin!

K (oK) , 60 38 bayt

Çözüm:

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

Çevrimiçi deneyin!

Açıklama:

Puanları endeksleyin, sonuçları toplayın.

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

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

Çevrimiçi deneyin!

35 baytlık çözüm:

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

Çevrimiçi çalıştır