Ваше завдання - визначити, чи задана рядок належної довжини і чи може бути представлена ​​плитками Scrabble, і, якщо так, вивести суму балів кожної літери.

Якщо ви не знаєте, як грати в Scrabble :, у вас є 100 плиток з різними літерами A – Z, надруковані на них, а також два символи, які можуть представляти будь-яку букву. Кожна літера має певну кількість балів, і кожна плитка (але не обов'язково слово) може бути використана лише один раз. Коли грається слово, додається бальне значення кожної використаної плитки, яка стає бальною. Оскільки в наявності є обмежена кількість букв, слово може мати певну букву стільки разів, скільки на цій букві є плитки + будь-які невикористані символи. Дошка Scrabble має 15 × 15 комірок, тому слово має бути довжиною від 2 до 15 символів.

Перелік кількості та оцінки кожної літери в англійській версії див. Нижче або http://boardgames.about.com/od/scrabble/a/tile_distribute.htm ( архів ).

Письмо Кількість балів Письмо Кількість балів
------------------- -------------------
A 9 1 O 8 1
Б 2 3 Р 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
I 9 1 W 2 4
J 1 8 X 1 8
K 1 5 Y 2 4
L 4 1 Z 1 10
М 2 3 [дикий] 2 0
N 6 1

Подальші правила

• Програма повинна приймати один рядок введення з STDIN або подібного.
• Вхід завжди буде містити лише великі літери.
• Якщо рядок містить більше копій букви, ніж є невикористані символи чи плитки для цього листа АБО довжина рядка не становить від 2 до 15 включно, програма повинна вивести Invalid.
• В іншому випадку бал слід доповнити, використовуючи дані з діаграми вище та вивести.
• Не використовуйте символи, якщо не потрібно.
• Не турбуйтеся про бонуси, такі як подвійні оцінки за слова або про те, що рядок - це справжнє слово.
• Програма виводить результат через STDOUT тощо.
• Пропуски, заборонені за замовчуванням , не допускаються.
• Використання зовнішнього джерела, такого як веб-сайт, а також будь-яких бібліотек, API, функцій тощо, які обчислюють бали Scrabble або належні кількості, не допускаються.
• Це код-гольф , тому виграє найменше байтів.

Покрокова інструкція

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

Тестові шафи

Введення-виведення
------------------------
ЧАСТИНА 14
JAZZ 19
СТЕКС-ОБМІН 32
XYWFHQYVZVJKHFW 81
PIZZAZZ Недійсний
KIXOKEJAJAX Недійсний
НЕЗАБАВЛЕННЯ Неправильне

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

Виконати з perl -E.

Гольф:

$_=<>;@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

У цьому рішенні використовуються деякі символи, що не надруковані, тому нижче розміщено шістнадцятковий набір:

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

Крім того, використовуючи 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 + прокоментував:

# 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

С, Обв. 2, 151 145 138

Надихнувшись 159-байтовим кодом у коментарі @ bebe, я видавив ще 8 14 21 символів:

4 байти збережено шляхом перестановки лічильника довжини i. Це ініціалізується на 1 (якщо програма не бере аргументів), а потім множиться на 4 щоразу, коли лист читається. Він переповнює нуль, коли довжина слова більша за 15, тому, щоб перевірити, чи довжина слова погана, ми просто перевіряємо, чи i<5(я вважаю, що i<9це все ще буде недійсним для однолітерних слів, якщо користувач випадково посилається iна 2, поставивши єдиний аргумент у командному рядку.)

4 байти, збережені зміною тесту стану циклу на простий &31. Це вимагає, щоб слово закінчувалося пробілом (ASCII 32) або нульовим символом (ASCII 0.) Зазвичай введення на клавіатурі закінчується новим рядком (ASCII 10), тому програму трохи незручно використовувати, тому що вам потрібно ввести простір, потім натисніть клавішу return, щоб комп'ютер прочитав буфер. Для рядків, що закінчуються новим рядком, я міг би відповідати, але не перемогти так, як це робить.

6 13 байтів, збережених зміною кодування на - (кількість плиток кожної літери) - (оцінка за цю букву-1) * 13 . Це вимагає діапазону від -4 для L, S, U до -118 для Q, Z. Причиною використання негативних чисел є уникання недрукуваного діапазону ASCII від 0 до 31. Натомість діапазон, що використовується, є доповненням двох від'ємних чисел 256-4 = 252 до 256-118 = 138. Це друковані, розширені символи ASCII. У Unicode є проблеми з їх копіюванням та вставленням (спосіб її спрощення повернення до ASCII залежить від встановленої сторінки коду, що може призвести до непередбачуваних результатів), тому я включив правильні коди ASCII в коментар до програми.

Перевагою цього кодування є усунення змінної, rоскільки кількість плиток завжди зменшується на 1 (оскільки вона зберігається як від’ємне число, ми це робимо t[x]++. Крім того, оператор postfix означає, що ми можемо виконувати цей приріст одночасно з додавання балів до 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 об. 1 173 (або 172 з варіантом компілятора)

Я використовую GCC, і за допомогою параметра компілятора -std=c99це дозволить мені перейти char t[]="...."до ініціалізації forциклу для економії однієї додаткової крапки з комою. Для читабельності я показав програму без цієї зміни та з пробілом, що залишився.

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

Хитрість полягає в даних. Для кожної літери в таблиці зберігається ASCII код форми (загальна оцінка плиток для цієї літери) * 10 + (оцінка однієї плитки-1)t[] . Під час виконання ці загальні бали знижуються в міру використання плитки.

Загальна оцінка всіх плиток для кожної літери коливається від 12 для E до 4 до L, S, U. Ця форма кодування дозволяє використовувати лише друковані символи ASCII (ASCII 120, xдля E аж до ASCII 40, (для L, S, U). Використання кількості плиток потребує діапазону від 120 до 10, саме тому я уникав цього.

Завдяки #defineмакро, один символ Tвикористовується в основній програмі , щоб отримати індекс листи iвід першого аргументу командного рядка, відніміть ASCII A= 65 від нього , щоб дати індекс, і шукати його в таблиці T: t[x[1][i]-65].

forЦикл використовується більше як whileпетлі: кінці петлі , коли нульовий байт (рядок термінатор) зустрічається у вхідному рядку.

Якщо плитки цього листа не вичерпані ( T/10є нульовими) s, збільшуються на рахунок плитки, T%10+1щоб зберегти загальний бал. У той же час оцінка плитки зберігається в r, так що значення в здатності, представленому Tсимволом, можна зменшити, r*10щоб вказати, що одна плитка була використана. Якщо плитка вичерпана, лічильник підстановки / порожній знак bзбільшується.

printfЗатвердження справедливо вимагає пояснень. якщо довжина слова не виходить за межі або кількість пустих є занадто великою, друкуйте результат в Invalidіншому випадку 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)}

Редагувати - змінив спосіб, який я кодував кількість / балів для зменшення розміру та видалення змінних, що не містять ascii

Edit 2 - змінив кодування кількості / балів на цілі числа замість рядків

Edit 3 - перейшов на %13(спасибі @ edc65), перевернув кодування, змінив значення безпосередньо та кілька інших незначних поліпшень

Тестовано на консолі Firefox.

Пітон 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])

Безголівки:

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

Редагувати: Завдяки @BeetDemGuise за підказку, яка в кінцевому підсумку призвела до набагато більше, ніж скорочення на 1 символ! Оригінальний код нижче:

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

БЕФУНГ 93 - 210 байт.

Але це не перевіряє 15 літерну межу.

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

С, 197

Припускає, що рядок надається як аргумент командного рядка, наприклад ./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)

zмагазини слово. Виходи як тривожні.

Редагування: покращено відповідно до рекомендацій, наведених нижче.

Хаскелл - 538

Збережіть його як scrabble.hs, а потім компілюйте за допомогою

ghc --make scrabble && ./scrabble

Потім введіть своє слово як введення та натисніть клавішу 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"

Пітон 2,7 - 263

Я не міг підійти ближче до відповіді DLosc , але це трактує кожну букву як «сумку», яку ви витягуєте, до її порожнього, потім витягуєте заготовки, а коли це порожнє - це помилки.

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

Наскільки я встиг зробити це:

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

Цей код дотримується правил дуже суворо, тому переконайтеся, що ви не передаєте йому зайві символи (наприклад, кінець рядка). Використовуйте як це: echo -n "JAZZ" | runghc scrabble.hs.

Пояснення

Шаблон (_:_:_)гарантує, що враховуються лише рядки щонайменше двох символів, а все інше призводить до "Invalid"(резервний шаблон _). Таблиця плиток кодується як 11*nTiles+valueперетворена в ASCII зі зміщенням, яке дозволяє модулю 11 пошуку, де букви AEIOдублюються, оскільки вони зустрічаються більше ніж у 6 разів кожен. Потім створюється пул плиток, за допомогою replicateякого символи слова видаляються в міру їх виникнення (різниця у списку,\\ ). Басейн містить 98 плиток, тож якщо загальна довжина слова та частина, що залишилася, більша за 100, то ми використали занадто багато підстановок. Крім того, слово мінус перші 15 літер додається тричі до обчислення довжини, тому будь-яке слово, довше 15 літер, автоматично видає три символи, і тому недійсне. Підрахунок балів проводиться в решті пулу, в якому спочатку було 187 балів, з яких ми просто віднімаємо. Зауважте, f 61а не f 6565 - це номер ASCII 'A'через дублікат"AEIO"на початку басейну. Решта - просто котельня.

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

Давайте покладемо бінтуми на використання: D (Наразі це не обробляє макіяж, я повністю пропустив читання цього правила, чорт забирай)

Рубі - 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')

Я припускаю, що вихідний показник "Invalid"чудовий, якщо ні, мені потрібно було б зробити це, $><<(-b<1&&w.size<16?s:'Invalid')що би підняло його до 198

Clojure - 325

Я не робив клоджур протягом певного часу, тому я впевнений, що існує кілька способів покращити моє рішення.

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

Деякі, що Un-golfing

(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 (не суворо)

wпередбачається, що воно вже містить слово. r- це вихідний рядок.

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"

Ось це пояснило і трохи менше гольфу:

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

Дартс - 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");}

Для цього потрібні bignums, тому він не компілюється в JavaScript.
З більшою кількістю пробілів:

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 байт

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;

Так! побиття JS!

зламатися

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

Я так радий, що немає літерного бала більше 10.