Ваша задача состоит в том, чтобы определить, имеет ли данная строка надлежащую длину и может ли она быть представлена ​​плитками скрэббла, и, если это так, вывести сумму баллов каждой буквы.

Если вы не знаете, как играть в 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
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
Я 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 [дикий] 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

Testcases

Ввод, вывод
------------------------
СКРАБЛ 14
JAZZ 19
STACKEXCHANGE 32
XYWFHQYVZVJKHFW 81
PIZZAZZ Invalid
KIXOKEJAJAX Неверно
Неверное недопустимое

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

Запустите с Perl -E.

Golfed:

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

В этом решении используются некоторые непечатаемые символы, поэтому ниже предоставлен hexdump:

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

С, Rev 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), поэтому использование программы немного неудобно, потому что вы должны набрать затем нажмите клавишу возврата, чтобы компьютер прочитал буфер. Для строк, заканчивающихся символом новой строки, я мог бы соответствовать, но не бить так, как это делает bebe.

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

Изменить - изменил способ, которым я кодировал количества / баллы, чтобы уменьшить размер и удалить не-переменные переменные

Редактировать 2 - изменил количество / счет кодировки на целые числа вместо строк

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

Протестировано в консоли Firefox.

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

Ungolfed:

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

BEFUNGE 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"

Python 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"

Хаскелл, 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 65, 65 является 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)])

Давайте используем bignums: 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

Я давно не делал clojure, так что я уверен, что есть несколько способов улучшить мое решение .ie списки qty и 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))))))

Кое-что раскошелилось

(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 баллов.