Nhiệm vụ của bạn là xác định xem một chuỗi đã cho có độ dài phù hợp hay không và có thể được biểu diễn bằng các ô xếp xếp và nếu vậy, hãy xuất tổng của mỗi điểm của mỗi chữ cái.

Nếu bạn không biết cách chơi Scrabble:, bạn có 100 ô với nhiều chữ cái khác nhau được in trên đó, cũng như hai ký tự đại diện có thể đại diện cho bất kỳ chữ cái nào. Mỗi chữ cái có một số điểm nhất định và mỗi ô (nhưng không nhất thiết phải là từ) chỉ có thể được sử dụng một lần. Khi một từ được phát, giá trị điểm của mỗi ô được sử dụng sẽ được cộng lại, trở thành điểm số. Vì có một số lượng chữ cái có hạn, một từ chỉ có thể có một chữ cái nhất định nhiều lần vì chữ cái đó có gạch + bất kỳ ký tự đại diện nào không được sử dụng. Bảng Scrabble có kích thước 15 × 15 ô, vì vậy từ phải dài từ 2 đến 15 ký tự.

Để biết danh sách số lượng và điểm số của từng chữ cái trong phiên bản tiếng Anh, xem bên dưới hoặc http://boardgames.about.com/od/scrabble/a/tile_distribution.htmlm ( lưu trữ ).

Thư Qty Điểm Thư Qty Điểm
------------------- -------------------
A 9 1 O 8 1
B 2 3 P 2 3
C 2 3 Q 1 10
D 4 2 R 6 1
E 12 1 S 4 1
F 2 4 T 6 1
G 3 2 U 4 1
H 2 4 V 2 4
Tôi 9 1 W 2 4
J 1 8 X 1 8
K 1 5 Y 2 4
L 4 1 Z 1 10
M 2 3 [hoang dã] 2 0
N 6 1

Quy tắc khác

• Chương trình sẽ lấy một chuỗi đầu vào từ STDIN hoặc tương tự.
• Đầu vào sẽ luôn chỉ chứa các chữ cái viết hoa.
• Nếu chuỗi chứa nhiều bản sao của một chữ cái hơn các ký tự đại diện hoặc gạch không sử dụng cho chữ cái đó HOẶC độ dài của chuỗi không nằm trong khoảng từ 2 đến 15, chương trình sẽ xuất ra Invalid.
• Mặt khác, điểm số nên được thêm vào bằng cách sử dụng dữ liệu từ biểu đồ trên và đầu ra.
• Không sử dụng ký tự đại diện trừ khi cần thiết.
• Đừng lo lắng về các phần thưởng như điểm số từ gấp đôi hoặc liệu chuỗi đó có phải là một từ thực sự hay không.
• Chương trình sẽ xuất kết quả thông qua STDOUT hoặc tương tự.
• Các lỗ hổng bị cấm theo mặc định không được phép.
• Sử dụng một nguồn bên ngoài, chẳng hạn như một trang web, cũng như bất kỳ thư viện, API, chức năng hoặc tương tự để tính điểm Scrabble hoặc số lượng thích hợp không bị ám chỉ.
• Đây là mã golf , vì vậy ít byte nhất sẽ thắng.

Hướng dẫn

Input: CODEGOLF
C -> 3, O -> 1, D -> 2, E -> 1, G -> 2, O -> 1, L -> 1, F -> 4
3 + 1 + 2 + 1 + 2 + 1 + 1 + 4 = 15
Output: 15

Tủ thử

Đầu ra đầu vào
------------------------
VÒI 14
THÁNG 19
STACKEXCHANGE 32
XYWFHQYVZVJKHFW 81
PIZZAZZ không hợp lệ
KIXOKEJAJAX không hợp lệ
Sai lầm không hợp lệ

Perl 5 228 205 186 184 178 177 153 150 149 142 137 135

Chạy với perl -E.

Chơi gôn

$_=<>;@a=@b=map-ord,'            0 0@0 H        ``'=~/./g;say s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

Giải pháp này sử dụng một số ký tự không in được, do đó, một hexdump được cung cấp dưới đây:

00000000: 245f 3d3c 3e3b 4061 3d40 623d 6d61 702d  $_=<>;@a=@b=map-
00000010: 6f72 642c 2703 0904 0909 2030 2030 030e  ord,'..... 0 0..
00000020: 4030 0e20 0704 4809 1809 601d 0e0e 6027  @0. ..H...`...`'
00000030: 3d7e 2f2e 2f67 3b73 6179 2073 212e 2128  =~/./g;say s!.!(
00000040: 2461 5b24 713d 3634 2d6f 7264 2426 5d2b  $a[$q=64-ord$&]+
00000050: 3d38 293c 383f 242d 2b3d 312d 3239 2f24  =8)<8?$-+=1-29/$
00000060: 625b 2471 5d3a 2b2b 246a 2167 657e 7e5b  b[$q]:++$j!ge~~[
00000070: 322e 2e31 355d 2626 246a 3c33 3f24 2d3a  2..15]&&$j<3?$-:
00000080: 496e 7661 6c69 64                        Invalid

Ngoài ra, sử dụng Ctrl + Key:

$_=<>;@a=@b=map-ord,'^C^I^D^I^I 0 0^C^N@0^N ^G^DH^I^X^I`^]^N^N`'=~/./g;print s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

Ungolfed + bình luận:

# Read in input
$_=<>;
# @a and @b: represents approximately 8x the number of tiles (when rounded up). The 
#   non-multiple-of-8 values distinguish tiles that are given equally, but are worth
#  different values
@b=@a=map-ord,"...."~=/./g;
# above is equivalent to
# @a=@b=(-03,-09,-04,-09,-09,-32,-48,-32,-48,-03,-14,-64,-48,-14,-32,-07,-04,-72,-09,-24,-09,-96,-29,-14,-14,-96);
say
    # for each character
    s!.!
        # $q: A->-1, B->-2, etc.
        # decrement number of $q tiles, add points if needed, otherwise
        #    increment j, which counts number of wilds used
        # truncate(1-29/b[q]): decimal values were chosen specifically
        #    for this to return the point value. b[q] is the number of tiles
        #    of the qth letter after a originally given.
        #  $- contains the score, is initially zero (if in a one line program, 
        #   as the golfed version is), and is always an integer
        ($a[$q=64-ord$&]+=8)<8 ? $- += 1 - 29/$b[$q] : ++$j
    # s returns length, check if between 2 and 15
    !ge ~~ [2..15]
    # make sure less than 3 negative tiles (aka wilds) 
    && $j < 3 ?
        # print score
        $-
    # or invalid
    : Invalid

C, Rev 2, 151 145 138

Lấy cảm hứng từ mã 159 byte trong nhận xét của @ bebe, tôi đã vắt thêm 8 14 21 ký tự:

4 byte được lưu bằng cách sắp xếp lại bộ đếm chiều dài i. Điều này được khởi tạo thành 1 (giả sử chương trình không có đối số) sau đó nhân với 4 mỗi khi một chữ cái được đọc. Nó tràn về 0 khi độ dài từ lớn hơn 15, vì vậy để kiểm tra xem độ dài của từ có tệ không, chúng tôi chỉ cần kiểm tra xem i<5(tôi đặt i<9như vậy nó sẽ vẫn không hợp lệ cho các từ một chữ cái nếu người dùng vô tình thâm nhập ivào 2 bằng cách đặt một đối số trên dòng lệnh.)

4 byte được lưu bằng cách thay đổi kiểm tra điều kiện vòng lặp thành đơn giản &31. Điều này yêu cầu từ kết thúc bằng dấu cách (ASCII 32) hoặc ký tự null (ASCII 0.) Thông thường đầu vào bàn phím bị chấm dứt bởi một dòng mới (ASCII 10) vì vậy chương trình hơi bất tiện khi sử dụng, vì bạn phải nhập không gian sau đó nhấn return cũng để máy tính đọc bộ đệm. Đối với các chuỗi kết thúc dòng mới, tôi có thể khớp nhưng không vượt qua được cách thực hiện.

6 13 byte được lưu bằng cách thay đổi mã hóa thành - (số ô của mỗi chữ cái) - (điểm cho chữ cái đó-1) * 13 . Điều này bây giờ yêu cầu một phạm vi từ -4 cho L, S, U đến -118 cho Q, Z. Lý do sử dụng số âm là để tránh phạm vi ASCII không thể in được từ 0 đến 31. Thay vào đó, phạm vi được sử dụng là phần bù hai của số âm 256-4 = 252 đến 256-118 = 138. Đây là những ký tự ASCII có thể in, mở rộng. Có vấn đề với việc sao chép và dán chúng trong Unicode (cách đơn giản hóa trở lại ASCII tùy thuộc vào trang mã được cài đặt có thể dẫn đến kết quả không thể đoán trước) vì vậy tôi đã đưa mã ASCII chính xác vào nhận xét chương trình.

Ưu điểm của mã hóa này là loại bỏ biến rvì số lượng ô luôn giảm đi 1 (vì nó được lưu dưới dạng số âm, chúng tôi làm t[x]++. Ngoài ra, toán tử postfix có nghĩa là chúng tôi có thể thực hiện gia số này cùng lúc với thêm điểm vào s.

//char t[]={32,247,228,228,239,244,215,240,215,247,164,203,252,228,250,248,228,138,250,252,250,252,215,215,164,215,138,0};
b,s;
main(i,x){
  for(char t[]=" ÷ääïô×ð×÷¤ËüäúøäŠúüúü×פ׊";x=getchar()&31;i*=4)
    t[x]%13?
      s-=t[x]++/13-1:
      b++;
  printf(i<9|b>2?"Invalid":"%d",s);
} 

C, 184 Rev 1 173 (hoặc 172 với tùy chọn trình biên dịch)

Tôi đang sử dụng GCC và với tùy chọn trình biên dịch, -std=c99nó sẽ cho phép tôi chuyển char t[]="...."sang khởi tạo forvòng lặp để tiết kiệm thêm một dấu chấm phẩy. Để dễ đọc, tôi đã hiển thị chương trình mà không có thay đổi này và với khoảng trắng còn lại.

#define T t[x[1][i]-65]
i,b,s;
main(int r,char**x){
  char t[]="Z>>QxS=SZW6(><P>m<(<(SSWSm";
  for(;x[1][i];i++)
    T/10?
      s+=r=T%10+1,T-=r*10:
      b++;
  printf(i<2|i>15|b>2?"Invalid":"%d",s);
}

Các mẹo là trong dữ liệu. Đối với mỗi chữ cái, mã ASCII của biểu mẫu (tổng số điểm của ô cho chữ cái đó) * 10 + (điểm của một ô-1) được lưu trong bảng t[]. Trong thời gian chạy, tổng số điểm này được giảm khi gạch được sử dụng hết.

Tổng số điểm của tất cả các ô cho mỗi chữ cái dao động từ 12 cho E xuống đến 4 cho L, S, U. Hình thức mã hóa này chỉ cho phép sử dụng các ký tự ASCII có thể in được (ASCII 120, xcho E xuống ASCII 40, (cho L, S, U.) Sử dụng số lượng gạch sẽ cần một phạm vi từ 120 đến 10, đó là lý do tại sao tôi tránh nó

Nhờ một #definemacro, một ký hiệu duy nhất Tđược sử dụng trong chương trình chính để lấy chỉ mục chữ cái itừ đối số dòng lệnh đầu tiên, trừ ASCII A= 65 từ nó để đưa ra một chỉ mục và tìm kiếm nó trong bảng T : t[x[1][i]-65].

Các forvòng lặp được sử dụng giống như một whilevòng lặp: vòng lặp kết thúc khi một số không byte (string terminator) gặp phải trong chuỗi đầu vào.

Nếu các ô của chữ cái đó không hết ( T/10là khác không) sđược tăng theo điểm số của ô T%10+1để giữ tổng điểm. Đồng thời, điểm số của ô được lưu trữ r, sao cho giá trị trong khả năng được biểu thị bằng Tcó thể được giảm r*10xuống để chỉ ra rằng một ô đã được sử dụng. Nếu gạch hết, bộ ký tự đại diện / trống bđược tăng lên.

Các printftuyên bố là khá tự giải thích. nếu wordlength nằm ngoài giới hạn hoặc số lượng trống quá cao, hãy in Invalidbằng cách khác in số điểm s.

JavaScript (ES6) - 241 230 199 182

f=s=>{for(i=t=_=0,E=12,A=I=9,B=C=M=P=28,D=17,F=H=V=W=Y=41,G=16,J=X=92,K=53,L=S=U=4,N=R=T=6,O=8,Q=Z=118;c=s[i++];)this[c]%13<1?_++:t+=1+this[c]--/13|0;alert(i<3|i>16|_>2?"Invalid":t)}

Chỉnh sửa - thay đổi cách tôi mã hóa số lượng / điểm số để giảm kích thước và loại bỏ các biến không phải mã ascii

Chỉnh sửa 2 - thay đổi mã hóa số lượng / điểm thành số nguyên thay vì chuỗi

Chỉnh sửa 3 - chuyển sang %13(cảm ơn @ edc65), đảo ngược mã hóa, sửa đổi trực tiếp các giá trị và một vài cải tiến nhỏ khác

Đã thử nghiệm trong bảng điều khiển Firefox.

Trăn 3, 217 201

b=2;i=s=0;w=input()
while i<26:n=w.count(chr(i+65));q=int('9224c232911426821646422121'[i],16);b-=max(0,n-q);s+=min(n,q)*int('1332142418513113a11114484a'[i],16);i+=1
print(["Invalid",s][-b<1<len(w)<16])

Ung dung:

b=2    # number of blanks available
i=s=0  # letter index 0..25, running score tally
w=input()

# Loop through each letter of the alphabet
while i<26:
    # Get number of occurrences in the word
    n=w.count(chr(i+65))
    # Get quantity of the letter from hex encoded string
    q=int('9224c232911426821646422121'[i],16)
    # Remove blanks for each occurrence over that letter's quantity
    b-=max(0,n-q)
    # Score the non-blank tiles, getting scores from hex-encoded string
    s+=min(n,q)*int('1332142418513113a11114484a'[i],16)
    # Increment
    i+=1

# If b > -1 and 1 < len(w) < 16, print the score; otherwise, print "Invalid"
print(["Invalid",s][-b<1<len(w)<16])

Chỉnh sửa: Cảm ơn @BeetDemGuise cho một mẹo mà cuối cùng đã đưa tôi đến nhiều hơn giảm 1 ký tự! Mã gốc bên dưới:

q=[77-ord(x)for x in'DKKIAKJKDLLIKGEKLGIGIKKLKL'];b=2;s=0;w=input()
for c in set(w):n=w.count(c);o=ord(c)-65;b-=max(0,n-q[o]);s+=min(n,q[o])*(1+int('02210313074020029000033739'[o]))
print(["Invalid",s][-b<1<len(w)<16])

BEFUNGE 93 - 210 byte.

Nhưng nó không kiểm tra giới hạn 15 chữ cái.

v1332142418513113:11114484: >01g:"0"-!#v_1-01p1+\v
 9224<232911426821646422121v  "Invalid"<      vp0<
<vp00p10"20"p200p900
>>~:55+-!#v_"@"-::1g:"0"-! #^_1-\1p0g+"0"-02g+>02p
_v#:-1<    #p90+g90-"0"g1:<
     @.g20<        @,,,,,,,<

C, 197

Giả sử chuỗi được cung cấp dưới dạng đối số dòng lệnh, vd ./scrabble STACKEXCHANGE

s;n;m=31;main(int c,char**v){char d[]="BIBBDLBCBIAADBFHBAFDFDBBABA@ACCBADBDAHEACAACJAAAADDHDJ";for(;c=*v[1]++&m;d[c]--,s+=d[c+27]&m)n+=1+m*(!(d[c]&m||d[c=0]&m));printf(n>1&&n<16?"%d":"Invalid",s);}

JavaScript - 232 201

t=[9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1];w=r=0;for(i=y=z.length;i--;){x=z.charCodeAt(i)-65;if(!t[x])w++;else{t[x]--;r+=-~"02210313074020029000033739"[x]}}alert(w>2|y<2|y>15?"Invalid":r)

zlưu trữ từ. Đầu ra như cảnh báo.

Chỉnh sửa: được cải thiện theo khuyến nghị dưới đây.

Haskell - 538

Lưu nó dưới dạng scrabble.hs và sau đó biên dịch nó bằng cách sử dụng

ghc --make scrabble && ./scrabble

Sau đó nhập từ của bạn làm đầu vào và nhấn enter

l=['A'..'Z']
sc=zip l [1,3,3,2,1,4,2,4,1,8,5,1,3,1,1,3,10,1,1,1,1,4,4,8,4,10]
vfs a y =snd $ filter (\x -> fst x == y) a !! 0
q = zip l [9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1]
i s =filter (\x -> (fst x) >=0) [(length [x | x <- s, x == a] - vfs q a,a) | a <- l]
main = do
 s <- getLine
 if length s <= 15 && length s > 2 && sum (map fst (i s)) <= 2 then
  putStrLn $ show (sum [vfs sc x| x <- s] - sum [(vfs sc (snd x)) * (fst x) | x <- (filter (\x -> fst x > 0) (i s))])
 else do
  putStrLn "Invalid"

Con trăn 2.7 - 263

Tôi không thể đến bất cứ nơi nào gần với câu trả lời của DLosc , nhưng điều này coi mỗi chữ cái là một 'túi' mà bạn kéo từ đó, cho đến khi nó trống, sau đó bạn kéo trống và khi đó trống thì nó bị lỗi.

S=input().lower()
X={chr(97+i):[int(y)+1]*(77-ord(x))for i,(x,y)in enumerate(zip('DKKIAKJKDLLIKGEKLGIGIKKLKL','02210313074020029000033739'))}
B=[0,0]
try:
 if len(S)>15:1/0
 print sum(map(lambda x:X[x].pop()if len(X[x])>0 else B.pop(),S))
except:
 print "invalid"

Haskell, 290 283

Theo như tôi có thể làm cho đến bây giờ:

import Data.List
t="CdC8d::Od;D;d41N:dd:6dNdN;;4;6"
s w@(_:_:_)=let d=concat(zipWith(replicate.(`div`11).f 33)t("AEIO"++['A'..]))\\w;y=drop 15w in if length(d++w++y++y++y)>100 then s""else show$187-(sum$map((`mod`11).f 0.(t!!).f 61)d)
s _="Invalid"
f n=(-n+).fromEnum
main=interact s

Mã này tuân thủ các quy tắc rất nghiêm ngặt, vì vậy hãy đảm bảo bạn không vượt qua bất kỳ ký tự phụ nào (chẳng hạn như cuối dòng). Sử dụng như thế này : echo -n "JAZZ" | runghc scrabble.hs.

Giải trình

Mẫu (_:_:_)đảm bảo rằng chỉ các chuỗi có ít nhất hai ký tự được xem xét, mọi thứ khác đều dẫn đến "Invalid"(mẫu dự phòng _). Bảng gạch được mã hóa khi được 11*nTiles+valuechuyển đổi sang ASCII với phần bù cho phép tra cứu modulo 11 hoạt động, trong đó các chữ cái AEIOđược sao chép vì chúng xuất hiện hơn 6 lần mỗi lần. Nhóm gạch sau đó được tạo bằng cách sử dụng replicate, từ đó các ký tự trong từ được loại bỏ khi chúng xuất hiện (danh sách khác biệt,\\). Nhóm chứa 98 ô, vì vậy nếu tổng chiều dài của từ và phần còn lại của nhóm lớn hơn 100, thì chúng ta đã sử dụng quá nhiều ký tự đại diện. Ngoài ra, từ trừ 15 chữ cái đầu tiên được thêm ba lần vào tính toán độ dài để bất kỳ từ nào dài hơn 15 chữ cái tự động xuất hiện để sử dụng hết ba ký tự đại diện và do đó không hợp lệ. Ghi điểm được thực hiện trên nhóm còn lại, ban đầu có 187 điểm, chúng tôi chỉ đơn giản là trừ đi. Lưu ý f 61thay vì f 65, 65 là số ASCII 'A', vì trùng lặp "AEIO"ở đầu nhóm. Phần còn lại chỉ là nồi hơi.

Python3 - 197

s,i,c,r=input(),0x1a24182424416141611a2381612341151891243224c142232391,[],[]; p=len(s)
for w in s:e=8*ord(w)-520;c+=[s.count(w)<=i>>e+4&15];r+=[i>>e&15]
print(['Invalid',sum(r)][all([p>2,p<15]+c)])

Chúng ta hãy đặt các bignums để sử dụng: D (Hiện tại nó không xử lý các ký tự đại diện, tôi đã bỏ qua việc đọc quy tắc đó hoàn toàn, chết tiệt)

Hồng ngọc - 195

b=2
i=s=0
w=$*[0]
(?A..?Z).map{|l|n=w.count(l);q='9224c232911426821646422121'[i].to_i(16);b-=[0,n-q].max;s+=[n,q].min*'1332142418513113a11114484a'[i].to_i(16);i+=1}
p(-b<1&&w.size<16?s:'Invalid')

Tôi giả sử đầu ra "Invalid"là ổn, nếu không tôi sẽ cần phải làm điều $><<(-b<1&&w.size<16?s:'Invalid')đó sẽ tăng đến 198

Clojure - 325

Tôi đã không thực hiện clojure trong một thời gian vì vậy tôi chắc chắn có một số cách để cải thiện giải pháp của tôi. Danh sách qty và pts

(let[w(first *command-line-args*)o(map #(count(filter #{%}(seq w)))(map char(range 65 91)))i(apply +(filter neg?(map #(- % %2)'(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1) o)))](println(if(or(> -2 i)(not(<= 2(count w)15)))"Invalid"(apply +(map #(* % %2)o'(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10))))))

Một số điều không chơi gôn

(let [word    (first *command-line-args*)
      letters (map char(range 65 91))
      occ     (map #(count (filter #{%} (seq word))) letters)
      invalid (apply + (filter neg? (map #(- % %2)
                '(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1)
                occ)))
      score   (apply + (map #(* % %2) occ '(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10)))]
    (println
      (if (or (> -2 invalid)
              (not (<= 2 (count word) 15)))
        "Invalid"
        score)))

ES6: 184 (không nghiêm ngặt)

wđược giả định là đã chứa từ này. rlà chuỗi đầu ra.

i=0,o=[..."291232342c124322491181541236181231a61416141242418241a"].map(c=>parseInt(c,16)),r=!w[16]&&w[2]&&[...w].every(c=>o[c=c.charCodeAt()*2-129]-->0?i+=o[c+1]:o[0]--)?i+"":"Invalid"

Đây là giải thích và ít chơi gôn hơn:

// The sum.
i = 0,

// The data for the letters. It's encoded similar to the Ruby version, with
// the first being the wildcard holder. The rest hold in hex form the
// following: first = quantity left, second = value.
// The .map(c => parseInt(c, 16) simply parses all the hex characters.
o = [..."291232342c124322491181541236181231a61416141242418241a"]
  .map(c => parseInt(c, 16)),

// The result, `r`.
r = !w[16] || // If there is a 16th character in the word or no 2nd character,
    w[2] &&   // then the next section isn't evaluated. It immediately equates
              // to true, thus returning "Invalid".
   [...w] // Convert the string into an array of characters (ES6 equivalent to
          // `.split('')`
    .every(c => // This loop terminates when the callback returns a falsy
                // value.
      // Gets the ASCII value, subtracts 65, doubles it (the lookup table is
      // in pairs within one array), and decrements the counter at that entry.
      // The lookup table also doubles as a data holder.
      o[c = c.charCodeAt() * 2 - 129]--
        > 0 ?  // Test if there is something to take away. This must return
               // false at 0 and -1 so wildcards can be taken.
        i += o[c+1] : // If there was something to take away, then add the
                      // letter value to the sum.
        o[0]--) // Otherwise, take a wildcard. If this is already at 0, then
                // it returns falsy.
      ? "Invalid" : i + "" // This is where the text is returned.

Phi tiêu - 201

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:2}){if((m=a[0].length)>1&&m<16)for(i in a[s=0].codeUnits)x>>(m=i*8-520)&15>0?r+=(x-=1<<m)>>m+4&15:++s;print(s<2?r:"Invalid");}

Điều này đòi hỏi phải có bignums, vì vậy nó sẽ không biên dịch thành JavaScript.
Với nhiều khoảng trắng hơn:

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:3}){
  if((m=a[0].length)>1&&m<16)
    for(i in a[s=0].codeUnits)
      x>>(m=i*8-520)&15>0
      ? r+=(x-=1<<m)>>m+4&15
      : ++s;
  print(s<3?r:"Invalid");
}

PHP, 180 170 168 byte

for($q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);$o=31&ord($argv[1][$i++]);)$s+=$q[$o]++>L?$q[0]++>L?$f=1:0:X02210313074020029000033739[$o]+1;echo$f|$i<3|$i>16?Invalid:$s;

Yay! đánh bại JS!

phá vỡ

for(
    $q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);  // init quantities: L=1,A=12
    $o=31&ord($argv[1][$i++]);                  // loop through characters: map to [1..26]
)
    $s+=                                          // increase score by ...
        $q[$o]++>L?                                 // old quantity below 1?
        $q[0]++>L?$f=1                              // no more wildcards? set error flag
        :0                                          // wildcard: 0 points
        :X02210313074020029000033739[$o]+1;         // else: letter score
echo$f|$i<3|$i>16?Invalid:$s;                   // output

Tôi rất vui vì không có thư nào lớn hơn 10.