Ответ 1

Perl в 107 символах

say("Case #$_:"),
$_=eval"''".'.<>'x<>,
s:[a-z]+:*(/ $&\\s/?:g,s/\)\s*\(/):/g,
eval"\$_=<>;say$_;"x<>for 1..<>

Новые строки для удобочитаемости; ни один из них не нужен или не подсчитан.

Он использует функции, найденные только в последних версиях Perl, поэтому запускайте с помощью perl -M5.010 или более поздней версии.

Я тоже был Perl noob, так что это работает почти так же, как рубиновый. Исходная версия 126 символов, оптимизация по peutri.

Обратные:

Word Aligned - Power Programming

Ответ 2

sed в 1554 символах (чистый)/281 (с bc)

Да, серьезно.

Использование: sed -r -f thisfile.sed < input.in > output.out

(работает над GNU sed)

1d
/ /!{x
s/^$/Case #Y:/
:i
s/9Y/Y0/
ti
s/#Y/#0Y/
s/:/:0123456789/
s/(.)Y(.*):[0-9]*\1(.).*/\3\2Y:/
x
G
s/.*\n|Y//gp
z
:p
N
/[()]/s/ |\n//g
y/()/JK/
tp
H
d}
G
s/\n[^J]*/ %/
s/[^JK]*$//
:c
s/J1?([.-9]+)(.*)K/\[email protected]\1/
/%@/by
:b
/J/s/T//
s/J([^JK]*)K/TC\1B/
tb
/ (.+) .*%\1C/{s/%[^C]*/%/
s/T.*B//
by}
s/%.*T/%/
:y
y/CB/JK/
tc
s/.\.0*\b//g
:r
/@.*@/{s/\w*@\w*$/C&B/
s/C(\w)(.*B)/\1C\2~/
s/"[^"]*/&0/g
:t
s/(\w)(C.*)(\w)B(.*~)/\1\2B\3\4\1\3/
T
s/~(10|2[01]|3[0-2]|4[0-3]|5[0-4]|6[0-5]|7[0-6]|8[0-7]|9.)/&Q/
s/(.)(.)Q/\2\1/
s/~0\w/`00/
s/~1\B/`0/
s/~22/`04/
s/~23/`06/
s/~24/`08/
s/~33/`09/
s/~25/`10/
s/~26|~34/`12/
s/~27/`14/
s/~28|~44/`16/
s/~29|~36/`18/
s/~35/`15/
s/~45/`20/
s/~37/`21/
s/~38|~46/`24/
s/~55/`25/
s/~39/`27/
s/~47/`28/
s/~56/`30/
s/~48/`32/
s/~57/`35/
s/~49|~66/`36/
s/~58/`40/
s/~67/`42/
s/~59/`45/
s/~68/`48/
s/~77/`49/
s/~69/`54/
s/~78/`56/
s/~79/`63/
s/~88/`64/
s/~89/`72/
s/~99/`81/
s/`(.)(.)/~\1'\2/
bt
:
s/(~.)'/\1/
s/..'/K&/
/K/bk
:v
s/=(,?.)'/\1/
s/,/1'/
t
s/B(.*)~/\1B"/
tr
s/"(\w*)0/A\1/g
/A.*A/{s/A[^A]*$/J&K/
:k
s/([^A])(J.*)([^A])K/\2K\1\3/
s/K(10|2[01]|3[0-2]|4[0-3]|5[0-4]|6[0-5]|7[0-6]|8[^9]|9.)/&Q/
s/(.)(.)Q/\2\1/
s/K0/=/
s/K11/=2/
s/K12/=3/
s/K13|K22/=4/
s/K14|K23/=5/
s/K15|K24|K33/=6/
s/K16|K25|K34/=7/
s/K(17|26|35|44)/=8/
s/K(18|27|36|45)/=9/
s/K(19|28|37|46|55)/W0/
s/K(29|38|47|56)/W1/
s/K(39|48|57|66)/W2/
s/K49|K58|K67/W3/
s/K59|K68|K77/W4/
s/K69|K78/W5/
s/K79|K88/W6/
s/K89/W7/
s/K99/W8/
s/W/=,/
/'/bv
s/\b=/K:/
tk
s/[:JK]A?//g
s/,/,0123456789GF/
s/(.),.*\1(.).*F/\2/
s/G/,0/
tk}
/A.*A/bv}
s/\w*C.*A//
tr
s/.*@/./

Это решение опускает начальный ноль перед десятичной точкой и не обрабатывает случаи, когда ответ равен 1.00. К счастью, судья GCJ признает отсутствие нуля и не имеет случаев, когда ответ равен 1.00.

Чтобы включить начальный нуль, измените последнюю строку на s/.*@/0./; и обрабатывать случай 1.00, добавьте строку s/^$/1/.

Здесь решение, передающее умножение на bc:

1d
/ /!{x
s/\n.*//
s/.*/echo 0&+1|bc/e
x
g
s/.*/Case #&:/p
:p
N
/[()]/s/ |\n//g
y/()/JK/
tp
H
d}
G
s/\n[^J]*/ %/
s/[^JK]*$//
:c
s/J([.-9]+)(.*)K/\2*\1/
/%\*/s/.*%.(.*)/echo \1|bc -l/e
:b
/J/s/T//
s/J([^JK]*)K/TC\1B/
tb
/ (.+) .*%\1C/{s/%[^C]*/%/
s/T.*B//
b}
s/%.*T/%/
:
y/CB/JK/
tc

Ответ 3

LilyPond: 212 символов

Сумасшествие! Полная смехотворность! LilyPond, со своим встроенным интерпретатором Scheme, умудряется превзойти Scheme больше, чем FIFTY BYTES! Священные акробатические летающие лоси в колготках!!

x=#lambda
w=#read
#(letrec((v(x(a)(map a(iota(w)1))))(c(x(f q)(*(car q)(if(any list? q)(c
f((if(memq(cadr q)f)caddr cadddr)q))1)))))(v(x(i)(w)(set! @(w))(format
#t"Case #~a:
~{~y~}"i(v(x i(w)(c(v(x i(w)))@)))))))

Использование: lilypond thisfile.ly <input.in >output.out 2>/dev/null

Кредит идет cky для написания решения схемы, на котором он основан, хотя эта версия существенно отличается. Серьезно, однако, Схему можно было сыграть в гольф немного дальше...

Ответ 4

PostScript: 170 (обычный)/160 (ASCII85)/121 (двоичный)

Самое короткое (регулярное) решение PostScript при условии, что вы переименуете входной файл в "r" ( 170 символов, включая новые строки); использует специфическую для GhostScript процедуру (=only):

1[/:{repeat}/!{exch token{\ exch known{/<>}if]pop]]3 index mul
!}if}(]){token pop}/?(r)(r)file([){?]}>>begin
1[{(Case #)2{=only}:(:)=[/|[def[{[/\<<[{[/}:>>def |]! =}:}for

Использование: cp input.in r; gs -q -dNOPROMPT -dNODISPLAY -dBATCH thisfile.ps > output.out

Здесь двоичная версия этого в 121 байт (обратные косые черты и непечатаемые символы экранированы):

1[/!{\x92>\x92\xab{\\\x92>\x92`\x92p{]\x92u}if]]3\x92X\x92l!}if}(]){\x92\xab\x92u}/r(r)\x928\x92A([){r]}>>\x92\r1[{(Case #)\x92v=only[/:\x928[\x923=[{[/\\<<[{[/}\x92\x83>>\x923:]! =}\x92\x83}\x92H

Если символы вне диапазона печати ASCII запрещены, PS имеет встроенную кодировку ASCII85 двоичных источников. Поэтому у всех ASCII-печатных символов имеется следующее 160-байтное решение:

1[([){r]}/r(r)<~OuSUj0-P\*5*Dsn>`q:[email protected]$5JU?'9>YBkCXV1Qkk'Ca"[email protected](5.=75YP')1:5*[email protected]>[email protected]<6!&,:Se!4`>4SH!;p_OuQ[/1Herh>;'5D4Bm/:07B"95!G,c3aEmO4aiKGI?I,~>cvx exec

Ответ 5

Ruby in 132

Улучшено леонидом. Новые строки необходимы.

def j
'1
'..gets
end
j.map{|c|s=j.map{gets}*''
puts"Case #%d:"%c,j.map{gets;eval s.gsub(/[a-z]+/,'*(/ \&\b/?').gsub /\)\s*\(/,'):'}}

Ruby in 136

def j;1..gets.to_i;end;j.map{|c|m=j.map{gets}*"";puts"Case ##{c}:";j.map{gets;p eval m.gsub(/[a-z]+/,'*(/ \0\s/?').gsub /\)\s*\(/,'):'}}

Я только что узнал о * ", эквивалентном .join" ". Также поняли, что карта может быть использована в нескольких местах

Ruby in 150

1.upto(gets.to_i){|c|m=eval("gets+"*gets.to_i+"''");puts"Case ##{c}:";1.upto(gets.to_i){gets;p eval m.gsub(/[a-z]+/,'*(/ \0\s/?').gsub /\)\s*\(/,'):'}}

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

Ответ 6

Python в 192

import re;S=re.sub;R=raw_input;I=input;c=0;exec r"c+=1;L=S('\) *\(',')or ',S('([a-z]+)','*(\' \\1 \'in a and',eval(('+R()'*I('Case #%s:\n'%c))[1:])));exec'a=R()+\' \';print eval(L);'*I();"*I()

Ответ 7

Общий Lisp, 199 байт

Обернуто каждые 80 символов:

(defun r()(read))(dotimes(i(r))(format t"~&Case #~D:"(1+ i))(r)(set'z(r))(dotime
s(a(r))(r)(print(do((g(mapcar'read(make-list(r))))(p 1(*(pop c)p))(c z(if(find(p
op c)g)(car c)(cadr c))))((not c)p)))))

Отстут и отступы:

(defun r () (read))
(dotimes (i (r))
  (format t "~&Case #~D:" (1+ i))
  (r)
  (set 'z (r))
  (dotimes (a (r))
    (r)
    (print
      (do ((g (mapcar 'read (make-list (r))))
           (p 1 (* (pop c) p))
           (c z (if (find (pop c) g)
                    (car c)
                    (cadr c))))
          ((not c) p)))))

Ответ 8

C - 346 байт

Скомпилировать с помощью gcc -w

#define N{int n=atoi(gets(A));for(;n--;)
T[999];F[99];char*t,*f,*a,A[99];float p(){float
d,m=1;for(;*t++^40;);sscanf(t,"%f %[^ (]",&d,A);if(*A^41){for(f=F;m**f;){for(;*f&&*f++^32;);for(a=A;*a&&*f==*a;f++,a++);m=*a||*f&64;}d*=!m*p()+m*p();}return
d;}main(I)N{printf("Case #%d:\n",I++);t=T;N
for(gets(t);*++t;);}N gets(F),t=T,printf("%f\n",p());}}}

Ответ 9

JavaScript в 196 байт

r='replace'
q=readline
for(n=0,t=q();t-n++;){for(print('Case #'+n+':'),d='',x=q();x--;d+=q());for(x=q();x--;)print(eval(d[r](/([a-z]+)/g,'*({'+q()[r](/ /g,':1,z')+':1}.z$1?')[r](/\) *\(/g,'):')))}

Использование: $ smjs thisfile.js <input.in

С вкладами от Hyperlisk.

Ответ 10

Дуга, 143 154 символы

Очень похож на CL один, но Arc обязательно имеет краткий идентификатор. Обернуто каждые 40 символов:

(for i 1((= r read))(prn"Case #"i":")(r)
(= z(r))(repeat(r)(r)(loop(= g(n-of(r)(r
))c z p 1)c(= p(*(pop c)p)c(if(pos(pop c
)g)c.0 cadr.c)))prn.p))

Отступ:

(for i 1 ((= r read))
  (prn "Case #" i ":")
  (r)
  (= z (r))
  (repeat (r)
    (r)
    (loop (= g (n-of (r) (r))
             c z
             p 1)
       c
       (= p (* (pop c) p)
          c (if (pos (pop c) g)
                (c 0)
                (cadr c))))
    (prn p)))

Обратная связь: Word Aligned - Power Programming

Ответ 11

PHP в 314

<?php function q(){return trim(fgets(STDIN));}for($n=q($x=0);$x++<$n;){for($s=q($t='');$s--;$t.=q());echo"Case #$x:\n";for($z=q();$z--;){$l=explode(' ',q());$l[0]=0;printf("%f\n",eval('return'.preg_replace(array('/\(/','/(\w+),/','/(\d\)*),\((\d)/','/^./'),array(',(','*(in_array("$1",$l,1)?','$1:$2'),$t).';'));}}

Ответ 12

FORTRAN - 381

Сохранить как a.F95
Скомпилировать с помощью f95 a.F95

#define _ ENDDO
#define A READ(t(k:l-1),*),a
#define Q j=1,n;READ"(A)",s
#define R READ*,n;DO
#define S k+SCAN(t(k:),'()')
CHARACTER(999)s,t,u;R i=1,n;t="";PRINT"('Case #'i0':')",i
R Q;t=TRIM(t)//s;_;R Q;d=1;k=1;DO;k=S;l=S-1
IF(t(l:l)>"(")EXIT;A,u;d=d*a;k=l;m=0
IF(INDEX(s," "//TRIM(u)//" ")>0)CYCLE;DO;IF(')'>t(k:k))m=m+2;m=m-1;k=k+1
IF(1>m)EXIT;k=S-1;_;_;A;d=d*a;PRINT*,d;_;_;END

Используя формат по умолчанию, каждый из результатов начинается с 2 пробелов, но судья Google разрешает это. Спасибо судье google!

РАСШИРЕННАЯ ВЕРСИЯ

CHARACTER(999)s,t,u
READ*,n
DO i=1,n
    t=""
    PRINT"('Case #'I0':')",i
    READ*,n
    DO j=1,n
        READ"(A)",s
        t=TRIM(t)//s
    ENDDO
    READ*,n
    DO j=1,n
        READ"(A)",s
        d=1
        k=1
        DO
            k=k+SCAN(t(k:),'()')
            l=k+SCAN(t(k:),'()')-1
            IF(t(l:l)>"(")THEN
                READ(t(k:l-1),*),a
                d=d*a
                PRINT*,d
                EXIT
            ELSE
                READ(t(k:l-1),*),a,u
                d=d*a
                k=l
                m=0
                IF(INDEX(s," "//TRIM(u)//" ")>0)CYCLE
                DO
                    IF(')'>t(k:k))m=m+2
                    m=m-1
                    k=k+1
                    IF(1>m)EXIT
                    k=k+SCAN(t(k:),'()')-1
                ENDDO
            ENDIF
        ENDDO
    ENDDO
ENDDO
END

Ответ 13

Java в 467 байт

Здесь используется интерпретатор javascript, содержащийся в java 6.

import java.util.*;class D{static{Scanner c=new
Scanner(System.in);int n=c.nextInt(),i=0,l;while(i++<n){l=c.nextInt();String
s="(";while(l-->=0)s+=c.nextLine();System.out.println("Case #"+i+":");l=c.nextInt();while(l-->0)try{c.next();System.out.println(new
javax.script.ScriptEngineManager().getEngineByName("js").eval(s.replace(")","))").replaceAll("\\) *\\(",":(").replaceAll("[a-z]+","*(/ $0 /.test('"+c.nextLine()+" ')?")));}catch(Exception
x){}}System.exit(0);}}

Спасибо Варану, Крису и pfn (косвенно) за то, что помогли мне сократить его.
См. Мой другой (даже более короткий!) Ответ java.

Ответ 14

Haskell, 312 символа

Здесь еще один подход к Haskell. Я оставил грязную работу в Prelude lex. Обертка вокруг него Text.ParserCombinators.ReadP. Импортирование - это 36 символов по-своему!

Синтаксический анализатор - это функция Features -> SExp -> Cuteness, которая избавляет меня от большинства объявлений типа решения /yairchu quibble.

import Text.ParserCombinators.ReadP
main=f(\t->do putStrLn$"Case #"++show t++":";s<-r g;r$print.fst.head.($id=<<s).readP_to_S.d.tail.words=<<g)
d x=do"("<-e;w<-e;c<-do{f<-e;y<-d x;n<-d x;u$if elem f x then y else n}<++u 1.0;e;u$c*read w
f x=do n<-g;mapM x[1..read n]
e=readS_to_P lex
r=f.const
g=getLine
u=return

Он использовал Control.Monad join, forM_ и replicateM, но оказывается, что для их переопределения требуется меньше места, чем для импорта.

Я также отказался от Prelude readParen в пользу просто вызова lex до и после. В текущей версии нет необходимости проверять закрывающую скобку: на действительном входе она всегда будет там. С другой стороны, очень важно проверить открытие: поскольку число преобразуется только после считывания всего подвыражения, для выравнивания правильного синтаксического анализа потребуется много обратного отслеживания.

На теоретической машине с бесконечной памятью и временем, запасной части "("<- можно отбросить (усиление 4 символов, всего 308). Если вызов read не отменяется. На моем, стек просто переполняется довольно быстро.

Ответ 15

m4 с эхом и bc, 339 байт

Это решение является полным и полным взломом, и это дает мне головную боль. Он содержит, помимо прочего, скрытые двойные кавычки, неэкранированные двойные кавычки, неотвратимые обратные кавычки и пары одиночных кавычек (включая вложенную пару с семью кавычками в глубину), неупомянутые регулярные выражения, аутсорсинг десятичного умножения на bc и использование craZy caSE для обхода макроса расширение. Но это должно было быть сделано, я думаю.: p

Это добавляет решение "окончательной макринизации" к предыдущим типам решений (повторяющиеся циклы, рекурсия с lambda mapping, метки и ветки, регулярное выражение и eval и т.д.).

Я думаю, что хороший термин для этого - "код макрониума": D

(для ясности обернуты каждые 60 символов)

define(T,`translit([email protected])')define(Q,`patsubst([email protected])')define(I,0)Q
(T(T(T(Q(Q(Q(Q(Q(Q(T(include(A),(),<>),>\s*>,>>),>\s*<,>;),\
([a-z]+\)\s*<,`*ifElsE<rEgExp<P;``````` \1 ''''''';0>;0;<'),
^<,`defiNe<````I';iNcr<I>>\\"Case `#'I:\\"defiNe<`A'''';'),^
[0-9]*),.+ [0-9]+.*,`dEfiNE<```P';`\& '''>A'),<>;N,`(),n'),E
,e),()),.*,`syscmd(`echo "\&"|bc -l')')

Использование: $ cp input.in A; m4 thisfile.m4 > output.out

Я m4 n00b, хотя, узнав это всего за час до написания этого. Так что, возможно, есть возможности для улучшения.

Ответ 16

Схема (Guile 1.8)

Здесь моя версия в 278 байт (с улучшениями от KirarinSnow, чтобы свести ее до 273), после снятия всех новых строк (кроме строк в строковых литералах, из курс). Он работает только на Guile 1.8 (поскольку в стандартной схеме define является синтаксисом, а не объектом, но Guile представляет его как объект в любом случае).

(define ! define)
(!(c f p w . r)(if(null? r)(* p w)(apply c f(* p w)((if(memq(car r)f)cadr caddr)r))))
(!(d . l)(map display l))
(!(r . x)(read))
(! n(r))
(do((i 1(1+ i)))((> i n))(r)(let((t(r)))(d"Case #"i":
")(do((a(r)(1- a)))((= a 0))(r)(d(apply c(map r(iota(r)))1 t)"
"))))

Ответ 17

С++ в 698 байт
Компиляция с помощью 'g++ -o test source.cpp -include iostream -include vector -include sstream'

#define R(x,f,t) for(int x=f;x<t;x++){
#define S(x) x.size()
#define H string
#define U while
#define I if
#define D cin>>
#define X t.substr(p,S(t))
using namespace std;
int main(){int h,l,n,a,p,Y,W;D h;for(int q=1;q<=h;q++){D l;H s;char c;D c;R(i,0,l)H L;getline(cin,L);R(j,0,S(L))I (L[j]==41||L[j]==40)s+=32;s+=L[j];I(L[j]==40)s+=32;}}D a;printf("Case #%d:\n",q);R(i,0,a)H N;D N;D n;vector<H>f;R(j,0,n)D N;f.push_back(N);}H t=s;float P=1;p=0;U(p<S(t)-1){p=0;U(t[p]!=48&&t[p]!=49)p++;t=X;stringstream T(t);float V;T>>V;H F;T>>F;P*=V;I(F[0]==41)break;Y=0;R(j,0,S(f))if(F==f[j])Y=1;}p=t.find(40)+1;t=X;p=0;I(Y==0){W=1;U (W>0){I(t[p]==40)W++;I(t[p]==41)W--;p++;}t=X;p=0;}}cout<<P<<endl;}}return 0;}

ИЗМЕНИТЬ: Прошу прощения; Я думал, что это нормально для включений (например, C работает даже без учета основных библиотек), в то время как я уверен, что это было бы, если бы я угадал эти определения. Я сейчас не дома, и я не буду на какое-то время: я не смогу его модифицировать. Просто игнорируйте мое представление.

Ответ 18

OCaml в 718 байт

Я OCaml n00b, поэтому это, вероятно, намного дольше, чем нужно.

Использование: ocaml thisfile.ml <input.in >output.out

#load"str.cma";;open List;;open String;;open Str;;let x=length and
y=Printf.printf and e=global_replace and h=float_of_string and b=regexp and
k=index and r=read_line and a=read_int and w s m c=sub s(c+1)(m-c-1);;for i=1to
a()do y"Case #%d:\n"i;let t=let n=a()in let rec g d j=if j>n then d else
g(d^(r()))(j+1)in e(b" ")""(e(b"\\b")"^"(g""1))and n=a()in let rec z j=if j>n
then()else let q=tl(split(b" ")(r()))in let rec g l j s p=let o=k s '('and c=k
s ')'in if j then let f=w s c o in if contains f '('then let m=k s '^'in let
c=index_from s(m+1)'^'in g 0(mem(w s c m)q)(w s(x s)c)(h(w s m o)*.p)else h f*.p
else if o<c then g(l+1)j(w s(x s)o)p else g(l-1)(l=1)(w s(x s)c)p in y"%f\n"(g
0(0=0)t 1.);z(j+1)in z 1done

Ответ 19

Чистая java в 440 байт

Более короткое java-решение, которое не использует никакого трюка. Может быть уменьшено до 425 путем удаления System.exit(0), если вывод stderr игнорируется.

import java.util.*;enum A{_;Scanner c,d;float p(String a){return
d.nextFloat()*(d.hasNext("\\D+")?a.contains(' '+d.next()+' ')?p(a)+0*p(a):0*p(a)+p(a):1);}{c=new
Scanner(System.in);for(int n=c.nextInt(),i=0,l;i++<n;){String
s="";for(l=c.nextInt();l-->=0;)s+=c.nextLine();System.out.println("Case #"+i+":");for(l=c.nextInt();l-->0;){c.next();d=new
Scanner(s.replaceAll("[()]"," "));System.out.println(p(c.nextLine()+' '));}}System.exit(0);}}

Ответ 20

Haskell, 514 байта (я сосать?).

Основываясь на кабриолевом решении:

import Control.Monad
import Text.ParserCombinators.Parsec
data F=N|F String(Float,F)(Float,F)
r=return
f=many1 letter>>= \i->w>>d>>= \t->d>>=r.F i t
d=char '('>>w>>many1(oneOf".0123456789")>>= \g->w>>(f<|>r N)>>= \p->char ')'>>w>>r(read g,p)
w=many$oneOf" \n"
g=getLine
l=readLn
m=replicateM
main=l>>= \n->forM_[1..n]$ \t->putStrLn("Case #"++show t++":")>>l>>=(`m`g)>>=(\(Right q)->l>>=(`m`p q)).parse d"".join
z(p,f)=(p*).y f
y N _=1
y(F n t f)x=z(if n`elem`x then t else f)x
p q=fmap(drop 2.words)g>>=print.z q

Ответ 21

C в 489 байт

Код, заключенный в 80 символов, на самом деле всего 3 строки.

Сохранить в a.c и скомпилировать с помощью: gcc -w a.c -o a

#define S int I,N;scanf("%d\n",&N);for(I=-1;++I<N;)
#define M 1000
char B[M],Z[M],Q[M]={' '},*F[M],*V;float W[M],H;int J,C,L[M],R[M];t(){V=strtok(0
," \n()");}p(){int U=C++;F[U]=0;if(!V)t();sscanf(V,"%f",W+U);t();if(V&&*V>='a')s
trcpy(Q+1,V),V=0,F[U]=strdup(strcat(Q," ")),L[U]=p(),R[U]=p();return U;}main(){S
{printf("Case #%d:\n",I+1);*B=0;{S strcat(B,gets(Z));}V=strtok(B," \n(");C=0,p()
;{S{strcat(gets(B)," ");for(J=0,H=W[0];F[J];J=strstr(B,F[J])?L[J]:R[J],H*=W[J]);
printf("%f\n",H);};}}}

Ответ 22

R в 280 байт

Примечание.. При стандартном распределении R (по версии 2.9.2) эта программа не пропускает большой вход и не работает только на случай 28 (который вложен в 99 уровней), генерируя "переполнение контекста". Чтобы исправить это, измените строку в src/main/gram.c, которая читает

#define CONTEXTSTACK_SIZE 50

и замените 50 на что-то вроде 500. Затем перекомпилируйте. Et voilà!

n=0
g=gsub
eval(parse(text=g('[^
]* [0-9]+( [^
]*|
)','f=c(\\1)
cat(eval(d),"
")
',g('
\\(','
cat("Case #",n<-n+1,":
",sep="")
d=expression(',g('" "','","',g(')\\s*\\(',',',g(' *("[a-z]+")\\s*\\(','*ifelse(\\1%in%f,',g('([a-z]+)','"\\1"',paste(readLines('A'),collapse='
')))))))))

Использование (требуется переименование): cp input.in A; R -q --slave -f thisfile.R >output.out

Ответ 23

F #: 759 важных символов (Вау, я плохо на это;))

Минимизированная версия

open System.Text.RegularExpressions
type t=T of float*(string*t*t)option
let rec e=function x,T(w,Some(s,a,b))->e(x,if Set.contains s x then a else b)*w|x,T(w,_)->w
let rec h x=Regex.Matches(x, @"\(|\)|\d\.\d+|\S+")|>Seq.cast<Match>|>Seq.map (fun x -> x.Value)|> Seq.toList
let rec p=function ")"::y->p y|"("::w::x::y->match x with ")"->T(float w,None),y|n->let a,f=p y in let b,g=p f in T(float w,Some(n,a,b)),g
let solve input =
    Regex.Matches(input,@"(\(((?<s>\()|[^()]|(?<-s>\)))*\)(?(s)(?!)))\s+\d+\s+((\S+\s\d(.+)?\s*)+)")
    |>Seq.cast<Match>
    |>Seq.map(fun m->fst(p(h(m.Groups.[1].Value))), [for a in m.Groups.[3].Value.Trim().Split([|'\n'|])->set(a.Split([|' '|]))])
    |>Seq.iteri(fun i (r,c)->printfn"Case #%i"(i+1);c|>Seq.iter(fun x->printfn"%.7F"(e(x, r))))

Читаемая версия

open System.Text.RegularExpressions

type decisionTree = T of float * (string * decisionTree * decisionTree) option
let rec eval = function 
    | x, T(w, Some(s, a, b)) -> eval(x, if Set.contains s x then a else b) * w
    | x, T(w, _) -> w

// creates a token stream
let rec tokenize tree =
    Regex.Matches(tree, @"\(|\)|\d\.\d+|\S+")
    |> Seq.cast<Match>
    |> Seq.map (fun x -> x.Value)
    |> Seq.toList

// converts token stream into a decisionTree
let rec parse = function
    | ")"::xs -> parse xs
    | "("::weight::x::xs ->
        match x with
        | ")" -> T(float weight, None), xs
        | name ->
            let t1, xs' = parse xs
            let t2, xs'' = parse xs'
            T(float weight, Some(name, t1, t2)), xs''

// uses regex to transform input file into a Seq<decisionTree, list<set<string>>, which each item in our 
// list will be tested against the decisionTree
let solve input =
    Regex.Matches(input, @"(\(((?<s>\()|[^()]|(?<-s>\)))*\)(?(s)(?!)))\s+\d+\s+((\S+\s\d(.+)?\s*)+)")
    |> Seq.cast<Match>
    |> Seq.map (fun m -> fst(parse(tokenize(m.Groups.[1].Value))), [for a in m.Groups.[3].Value.Trim().Split([|'\n'|]) -> set(a.Split([|' '|])) ])
    |> Seq.iteri (fun i (tree, testCases) ->
            printfn "Case #%i" (i+1)
            testCases |> Seq.iter (fun testCase -> printfn "%.7F" (eval (testCase, tree)))
        )