ฉันจะบอกคุณเกี่ยวกับระบบตัวเลขอย่างง่าย _{^{(ซึ่งฉันทำขึ้นสำหรับความท้าทายนี้)}}

ระบบนี้มีฟังก์ชั่น(), [], และ{}<>

1 ()

เมื่อจะได้รับการขัดแย้งใดก็ประเมิน()0

เมื่อ()ได้รับหนึ่งหรือมากกว่าข้อโต้แย้งมันจะประเมินผลรวมของข้อโต้แย้ง

2 []

เมื่อจะได้รับการขัดแย้งใดก็ประเมิน[]-1

เมื่อ[]ได้รับหนึ่งหรือมากกว่าข้อโต้แย้งมันจะประเมินข้อโต้แย้งแรกด้วยผลรวมของข้อโต้แย้งอื่น ๆ

3 {}

เมื่อจะได้รับการขัดแย้งใดก็ประเมิน{}1

เมื่อ{}ได้รับหนึ่งหรือมากกว่าข้อโต้แย้งมันจะประเมินผลของข้อโต้แย้งเหล่านั้น

4 <>

เมื่อจะได้รับการขัดแย้งใดก็ประเมิน<>1

เมื่อ<>ได้รับหนึ่งหรือมากกว่าข้อโต้แย้งมันจะประเมินเป็นจำนวนเต็มอาร์กิวเมนต์แรกหารด้วยผลิตภัณฑ์ของข้อโต้แย้งอื่น ๆ

งานของคุณ

รับสตริงที่มีตัวเลขที่ถูกต้อง (นั่นหมายถึงวงเล็บเหลี่ยมมีความสมดุลไม่มีการหารด้วย 0s ฯลฯ ) ในระบบตัวเลขอย่างง่ายนี้พิมพ์ค่าของมัน

กรณีทดสอบ

() -> 0
(()()) -> 0
([][]) -> -2
({}<>) -> 2
({}[]) -> 0
[] -> -1
[[][]] -> 0
[()<>] -> -1
{()} -> 0
{([]<>)} -> 0

จำไว้ว่านี่คือcode-golfดังนั้นโค้ดที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

Dyalog APL , 94 ไบต์

o←{(⊂(1⊃⍵),⍺⍺⊃⍵),2↓⍵}⋄u←{(⊃⍵,⍺⍺1)⍺⍺⍵⍵/1↓⍵}⋄⍎⍕'+/o' '-u+o' '×/o' '÷u×o' '(⊂⍬),'[')]}>'⍳⌽⍞],'⊂⍬'

การใช้งาน ⎕IO←0

แทนที่)]}>ด้วยการเรียกฟังก์ชั่นที่ใช้สแต็ค, ใช้การดำเนินการในกรอบด้านบนลบมันและผนวกผลให้กรอบถัดไป (ผู้ประกอบการเอกoจะใช้สำหรับการที่มิประกอบ dyadic uจับกรณีที่มีความซับซ้อนมากขึ้นของ-และ÷)

แทนที่([{<ด้วยรหัสที่เพิ่มเฟรมให้กับสแต็ก ( (⊂⍬),)

รันการแสดงออกที่เกิดขึ้น (กลับรายการเพื่อให้ตรงกับคำสั่งของการดำเนินการ APL) กับสแต็คเริ่มต้นของหนึ่งเฟรมที่ว่างเปล่า ( ⊂⍬)

Haskell, 357 306 277 251 228 224 188 185 180 180 ไบต์

เครื่องมือแยกวิเคราะห์โทเค็นที่มีสแต็กที่ชัดเจน (%)ใช้สแต็คเค็นและตัวอักษรและผลักดันอย่างใดอย่างหนึ่ง (opcode, defaultnumber) หรือ (0 จำนวน) สำหรับ({[<หรือปรากฏตัวเลขสูงสุดและเป็นหนึ่ง opcode )}]>และผลักดันคำตอบสำหรับ Opcodes ถูกเข้ารหัสโดยแฮ็คการแจงนับ

รุ่งโรจน์ถึง @ChristianSievers สำหรับคำตอบที่ยอดเยี่ยมของเขาที่ฉันยืมความคิดบางอย่างจาก

หนึ่งในสายการบิน!

s%c|elem c"([<{",g<-div(fromEnum c)25=(g,[0,0,1,-1,1]!!g):s|(a,(o,n):b)<-span((==0).fst)s=(0,[foldr1(flip$[(+),quot,(-),(*)]!!(o-1))$snd<$>a,n]!!(0^length a)):b
snd.head.foldl(%)[]

ขณะนี้มีการจัดการข้อผิดพลาดน้อยลง! การใช้งาน:

*Main> map (snd.head.foldl(%)[]) ["()","(()())","([][])","({}<>)","({}[])","[]","[[][]]","[()<>]","{()}","{([]<>)}"]
[0,0,-2,2,0,-1,0,-1,0,0]

ขอบคุณ @ChristianSievers สำหรับการบันทึก 14 + 3 ไบต์!

ขอบคุณ @Zgarb สำหรับการบันทึก + 4 ไบต์!

Python 2, 292 265 248 235 223 206 204 ไบต์

r=reduce
s=input()
for n in')]}>':s=s.replace(n,'),')
for a in'(*x:sum(x)','[a=-1,*x:a-sum(x)','{*x:r(int.__mul__,x,1)','<a=1,*x:r(int.__div__,x,a)':s=s.replace(a[0],'(lambda %s)('%a[1:])
print eval(s)[0]

แทนที่วงเล็บทั้งหมดด้วยแลมบ์ดาที่ทำสิ่งที่วงเล็บทำจากนั้นประเมินโค้ด Python ที่ได้ '[<><>([]{})]'ต้องใช้ปัจจัยการผลิตที่ล้อมรอบด้วยคำพูดเช่น

โปรแกรมนี้จัดเก็บประเภทของวงเล็บเหลี่ยมเป็นอักขระตัวแรกในแต่ละสตริงในforและทุกอย่างหลังจากคำหลักlambdaเป็นส่วนที่เหลือ จากนั้นใช้อักขระตัวแรกเพื่อแทนที่ ส่วนที่เหลือจะรวมกันเป็นแลมบ์ดาเหมือน(lambda*x:sum(x))()ส่วนที่เหลือของมันจะรวมกันเป็นแลมบ์ดาเหมือน

ลองใช้กับ Ideone!

PEG.js (ES6) , 132 ไบต์

x=a:[([{<]b:x*[)\]}>]{var x='([<'.indexOf(a)
b.length^1||b.push(0)
return~~eval(b.length?b.join(('+-/'[x]||'*')+' '):~-('10'[x]||2))}

ควรได้รับการแก้ไขแล้ว

คำอธิบาย

อ่านเพิ่มเติมได้:

x=a:[([{<]
  b:x*
  [)\]}>]
{
  var x='([<'.indexOf(a)
  b.length^1||b.push(0)
  return ~~eval(
    b.length?
      b.join(('+-/'[x]||'*')+' ')
    :~-('10'[x]||2))
  )
}

PEG.js เป็น Javascript เวอร์ชันขยายที่สร้างขึ้นเป็นพิเศษสำหรับการวิเคราะห์คำ มันเข้มงวดมากซึ่งเป็นเหตุผลว่าทำไมฉันต้องใช้varมันเป็นที่เข้มงวดมากซึ่งเป็นเหตุผลที่ผมต้องใช้นอกจากนี้ดูเหมือนว่าจะมีข้อผิดพลาดกับวงเล็บภายในสตริงซึ่งป่องรหัสอย่างมีนัยสำคัญ

ในการเริ่มต้นที่เรากำหนดกฎxที่ตรงกับวงเล็บใด ๆที่อาจจะหรืออาจจะไม่ได้มีการแสดงออกหลายตัวที่ตรงกับกฎax

สำหรับการแข่งขันแต่ละครั้งxเราจะเพิ่ม 0 ให้กับอาร์เรย์ของการแข่งขันภายในbถ้าbความยาวคือ 1

ถ้าbความยาวของ> 0 แล้วเราพบว่าดัชนีของaใน([<และได้รับตัวละครจาก+-/ใช้ดัชนีที่ หากผลที่ได้คือไม่ได้กำหนด (ความหมายว่าaเป็น{) *แล้วเราเปิดผลลงใน ในที่สุดเราก็จัดการพื้นที่และเข้าร่วมbกับผลลัพธ์

หากb's ความยาว = 0 แล้วเราพบว่าดัชนีของaใน([<และได้รับตัวละครจาก10ใช้ดัชนีที่ หากผลลัพธ์ไม่ได้ถูกกำหนด (หมายถึงที่aเป็น{หรือ<) เราจะเปลี่ยนผลลัพธ์เป็น 2 ในที่สุดเราก็จะลดลง

ในตอนท้ายเราสามารถประเมินผลการแสดงออกและเพิ่มผลลัพธ์ได้

Perl, 113 + 2 = 115 ไบต์

ทำงานด้วย-lp(โทษ 2 ไบต์)

/\W/,eval"sub $`\{\$#_?(shift)$&&$'1}"for qw'a+a:1- b-a:- c*c: d/c:';y/([{</a-d/;s/\W/0),/g;s/\pL\K/(/g;$_=eval

อ่านได้มากขึ้น (หมายเหตุ: "รุ่นที่อ่านได้ง่ายกว่านี้" จะไม่ทำงานเพราะฉันใส่ความคิดเห็นในสถานที่ที่พวกเขาไม่ได้รับอนุญาตจาก syntactically):

              # -p option: read a line of input into $_ at program start
              # -l option: remove the final newline whenever reading
do {          # for each element of a list, given later:
  /\W/;       # place an initial identifier in $`, the next character in
              # $&, and the rest of the element in $'
  eval qq{    # then evaluate the following template, with substitutions:
    sub $` {  # define a subroutine named $`, that does this:
      \$#_ ?  # if there is more than one argument                   
      (shift) # then return the first argument $&-ed with
      $& &$'  # the result of a recursive call with the tail of the arguments
              # else (the "else" is a colon taken from $', not the template)
      1       # return (the remainder of $' applied to) 1
    }
  }
} for qw'     # specify the list by splitting the following on whitespace:        
  a+a:1-      # a(head,tail) = len(tail>1) ? head+a(tail) : 1-1
  b-a:-       # b(head,tail) = len(tail>1) ? head-a(tail) : -1
  c*c:        # c(head,tail) = len(tail>1) ? head*c(tail) : 1
  d/c:        # d(head,tail) = len(tail>1) ? head/c(tail) : 1
';
y/([{</a-d/;  # replace ( [ { < with a b c d in $_
s/\W/0),/g;   # replace whitespace, punctuation in $_ with the string "0),"
s/\pL\K/(/g;  # place a ( after (\K) each letter (\pL) in $_
$_=eval       # evaluate $_ as a Perl program, storing the result back in $_
              # -p option: print $_ to the user at program end
              # -l option: output a newline whenever printing

แนวคิดพื้นฐานคือเรากำลังแปลงอินพุต[()<>]ให้เป็นโปรแกรม Perl b(a(0),d(0),0),ผ่านการประมวลผลข้อความ Perl ได้ดีกับเครื่องหมายจุลภาคต่อท้าย ก่อนหน้านี้เรากำหนดฟังก์ชั่นa, b, c,dที่จะมีผลกระทบเช่นเดียวกับ(), [], {}, <>สร้างจากภาษาที่เรากำลังดำเนินการ; พวกเขาแต่ละคนไม่สนใจอาร์กิวเมนต์สุดท้ายของพวกเขา (0 ในตอนท้าย) ซึ่งถูกรวมไว้เพื่อให้แน่ใจว่าอินพุตแยกวิเคราะห์ได้อย่างถูกต้องและทำงานโดยใช้การนำไปใช้ที่เห็นโดยทั่วไปในการเขียนโปรแกรมการทำงานที่ประมวลผลส่วนหัวและส่วนท้าย เพราะb(e,f,g,0)หมายความว่าe-f-gคือปฏิบัติต่ออาร์กิวเมนต์แรกเป็นพิเศษในขณะที่aปฏิบัติต่อข้อโต้แย้งของมันสมมาตร ( a(e,f,g,0)หมายถึงe+f+g) เราดำเนินการaซ้ำและbaโทรผ่าน cและdมีความสัมพันธ์ที่คล้ายกัน ฟังก์ชั่นทั้งสี่นี้คล้ายกันมากดังนั้นเราจึงสร้างมันขึ้นมาตอนรันไทม์แทนที่จะใช้มันแยกกัน เราจัดเก็บแม่แบบที่ใช้กับทั้งสี่ฟังก์ชั่นในสตริงจากนั้นสร้างฟังก์ชั่นโดยการแทนที่ตัวละครลงในแม่แบบ

เนื่องจาก Perl /ทำการหารจุดลอยตัวการดำเนินการ{}ก็ทำเช่นกัน ฉันสมมติว่าสิ่งนี้ไม่ใช่ปัญหาในสิทธิ์ของตนเองหรือ-Minteger(การเลือกตัวแปรภาษาที่การดำเนินการทางคณิตศาสตร์ทั้งหมดเป็นการดำเนินการจำนวนเต็ม) ฟรีเพราะมิฉะนั้นฉันต้องใช้ไบต์พิเศษในการเขียนหารจำนวนเต็มใน Perl ซึ่งดูเหมือนจะไม่ได้เป็นสิ่งที่ปัญหาเป็นพื้นฐานเกี่ยวกับ (ฉันคิดว่าคุณจะต้องใช้เวลาสี่ไบต์ในการเปลี่ยน(shift)เป็นint+(shift) ; ฉันไม่ได้ทดสอบสิ่งนี้)

อ็อกเทฟ, 215 206 198 ไบต์

S='sum(x(:))-sum(x(2:end))';Y='(@(x)isempty(x)';c=']) ';[~,~,u]=unique(['()<>[]{}',input('')]);eval([{'sum([',c,[Y,'+fix((',S,')/prod(x(2:end))))(['],c,[Y,'*-1+',S,'*2)(['],c,'prod([',c}{u(9:end)}])

ลองออนไลน์

PHP, 315 300 285 258 250 244 ไบต์

for($s=$argv[1];$r=!$r;)foreach(["(+)1","[-]0","{*}2","</>2]as$p)if(preg_match("#$e$p[0]([-_\d]*)$e$p[2]#",$s,$m)){if(""==$v=strtok($m[1],_))$v=$p[3]-1;while(""<$n=strtok(_))eval("\$v$p[1]=$n;");$s=strtr($s,[$m[$r=0]=>_.$v]);}echo substr($s,1);

แทนที่นิพจน์ย่อยด้วยขีดล่าง + ค่า วนซ้ำเมื่อการวนซ้ำไม่มีการแทนที่

19 ปีตั้งแต่ฉันพบ C ครั้งแรก, 17 ปีทำงานกับ PHP;
นี่เป็นครั้งแรกที่strtokสมเหตุสมผล ... ช่วยประหยัด 24 ไบต์!

ชำรุด

for($s=$argv[1];    // take input from argument
    $r=!$r;)        // toggle $r; loop until no replacement has taken place
    foreach(["(+)1","[-]0","{*}2","</>2]as$p) // loop through operations
        if(preg_match("#$e$p[0]([-_\d]*)$e$p[2]#",$s,$m))   // find a match
        {
            if(""==$v=strtok($m[1],_))  // init $v with first token from sub-match
                $v=$p[3]-1;             // if no token, init with default value
            while(""<$n=strtok(_))      // loop through tokens
                eval("\$v$p[1]=$n;");       // operate
            $s=strtr($s,[$m[$r=0]=>_.$v]);  // reset $r; replace match with underscore+value
        }
echo substr($s,1);  // print result

ES6 (Javascript) 250, 171, 154, 149, 147 ไบต์

รุ่น Javascript แท้ๆ

"Metaprogramming" (เหมือนกับคำตอบอื่น ๆ ส่วนใหญ่ที่นี่) แปลงข้อความโปรแกรมอินพุตเป็นโปรแกรม Javascript ที่สอดคล้องกันโดยใช้การแทนที่ข้อความโดยตรงจำนวนมาก (เช่นการรักษาโครงสร้างของโปรแกรมตามที่เป็นอยู่)

อาจจะสามารถเล่นกอล์ฟต่อไปได้

อัปเดต (v2.1)

• ลบสองไบต์ (ลบวงเล็บในนิพจน์ประกอบไปด้วย)
• เพิ่มขนาดอีก 5 ไบต์โดยใช้ตัวแปรสำหรับการดึงผลลัพธ์และกำจัดส่วนเกิน "[]"

อัปเดต (v2)

เพิ่งรู้ว่าเครื่องหมายจุลภาคที่รออยู่ในอาร์เรย์ ES นั้นถูกต้องทั้งหมดดังนั้นรหัสการทำเครื่องหมายจุลภาคทั้งหมดจึงสามารถลบออกได้ ยังได้ปฏิบัติตามคำแนะนำที่ยอดเยี่ยมโดย @Titus ในการเพิ่มประสิทธิภาพการค้นหาตัวอักษร

อัปเดต (v1)

ลบนามแฝง "replace" ที่ซ้ำออก

อัปเดต (v1)

• ใช้ตัวอักษรที่ดีกว่า: () => 1+ [] => 0 {} => 2 * <> => 2 / (ถ่านแต่ละตัวสามารถนำกลับมาใช้โดยตรงเป็นค่าหรือตัวดำเนินการ)

• แทนที่ลด () พร้อมแทนที่ () (การทำแผนที่ตัวอักษร)

• การผสานการประมวลผลคงที่แบบเปิดและปิดวงเล็บเป็นขั้นตอนเดียว

Golfed (v2.1)

s=>eval("o="+s.replace(/./g,r=>"2+1-3*3/"["()[]{}<>".indexOf(r)]).replace(/\d\D?|\D/g,r=>r[1]?r[0]-2+",":r*1?'([':`].reduce((r,a)=>r${r}a)),`)+"o

Golfed (v1)

(s,A="(2)+[1]-{3}*<3>/")=>eval(s[R="replace"](/./g,r=>A[A.indexOf(r)+1])[R](/\d\D?|\D/g,r=>r[1]?r[0]-2+",":(r[0]*1?'([':`].reduce((r,a)=>r${r}a)),`))[R](/,(\])|,$/g,"$1"))    

Golfed (v0)

([...s],A="(a)b[c]d{e}f<g>h",R="replace")=>eval(s.reduce((r,c)=>r+=A[A.indexOf(c)+1],'')[R](/ab|cd|ef|gh/g,r=>({d:-1,b:'0'}[r[1]]||1) + ',')[R](/[aceg]/g,"([")[R](/[bdfh]/g,r=>`].reduce((r,a)=>r${"+*-/"["bfdh".indexOf(r)]}a)),`)[R](/,(\])|,$/g,"$1"))

อธิบาย (v0)

//BEGIN 

//s - input text, A - alphabet, R - "String.replace()" alias
E=([...s],A="(a)b[c]d{e}f<g>h",R="replace")=>eval(

//Replace input alphabet by a more friendly one, to avoid too much escaping and quoting
// () - ab, [] -cd, {} - ef, <> - gh
s.reduce((r,c)=>r+=A[A.indexOf(c)+1],'')

//Replace no-arg invocations with a corresponding constant value
// () => 0, [] => -1, {} => 1, <> => 1      
[R](/ab|cd|ef|gh/g,r=>({d:-1,b:'0'}[r[1]]||1) + ',')

//Replace opening brackets with "(["
[R](/[aceg]/g,"([")

//Replace closing brackets with "].reduce(...)),"
//An arithmetic operation to apply (+-*/) is chosen based on the bracket type 
//and is substituted into the template 
[R](/[bdfh]/g,r=>`].reduce((r,a)=>r${"+*-/"["bfdh".indexOf(r)]}a)),`)

//Strip excessive commas
[R](/,(\])|,$/g,"$1")
);

//END: eval() the result


Example:
E("{([]<>()<>{})(<><>)}")
=> eval("([([-1,1,0,1,1].reduce((r,a)=>r+a)),([1,1].reduce((r,a)=>r+a))].reduce((r,a)=>r*a))")
=> 4

ทดสอบ

E=([...s],A="(a)b[c]d{e}f<g>h",R="replace")=>eval(s.reduce((r,c)=>r+=A[A.indexOf(c)+1],'')[R](/ab|cd|ef|gh/g,r=>({d:-1,b:'0'}[r[1]]||1) + ',')[R](/[aceg]/g,"([")[R](/[bdfh]/g,r=>`].reduce((r,a)=>r${"+*-/"["bfdh".indexOf(r)]}a)),`)[R](/,(\])|,$/g,"$1"))

T=(s,a)=>{
    console.log(s,r=E(s),r==a?"OK":"NOT OK");
}

T("()",0)
T("(()())",0) 
T("([][])",-2)
T("({}<>)",2) 
T("({}[])",0) 
T("[]",-1)
T("[[][]]",0) 
T("[()<>]",-1) 
T("{()}",0) 
T("{([]<>)}",0)

ทดสอบผลลัพธ์

() 0 OK
(()()) 0 OK
([][]) -2 OK
({}<>) 2 OK
({}[]) 0 OK
[] -1 OK
[[][]] 0 OK
[()<>] -1 OK
{()} 0 OK
{([]<>)} 0 OK

Haskell, 184 179 172 161 160 159 151 148 145 ไบต์

s%(c:i)|elem c")}]>"=([1?(*),sum,1?quot,(-1)?(-)]!!mod(fromEnum c)5$s,i)|(r,j)<-[]%i=(s++[r])%j
[v]%e=(v,e)
(v?_)[]=v
(_?o)s=foldl1 o s
fst.([]%)

Recursive descent ทำเกลียวอินพุตเนื่องจาก Haskell ตามปกติบรรทัดสุดท้ายไม่ใช่คำจำกัดความ แต่ระบุฟังก์ชันที่แก้ปัญหาได้ ดังนั้นในการทดสอบใส่บรรทัดยกเว้นบรรทัดสุดท้ายในไฟล์โหลดและทำสิ่งนี้:

*Main> fst.([]%) $ "{([][][])([][])}"
6

ขอบคุณ @Zgarb สำหรับแรงบันดาลใจและคำแนะนำโดยละเอียดมากมายและสำหรับ @Angs สำหรับแรงบันดาลใจจากคำตอบของเขาและคำแนะนำเพิ่มเติม

ไม่ได้ระบุวิธีการหารควรทำงานกับจำนวนเต็มลบ อย่างไรก็ตามการใช้งานซ้ำ ๆdivดูเหมือนจะผิดเนื่องจากไม่เหมือนกับการใช้divเพียงครั้งเดียวกับผลิตภัณฑ์ที่มีค่าที่เหลืออยู่ ตอนนี้ใช้quotผมให้ได้ผลลัพธ์เดียวกันและ<{}([][])[]><{}{([][])[]}>

สำหรับโค้ดที่ดีเกือบอ่านได้ดูที่รุ่นแรก รุ่นกลางมีรหัสที่ดีและน่ากลัวทุกชนิดและช่วยให้เข้าใจรุ่นนี้

JavaScript (ES6), ไม่eval, 156 ไบต์

f=s=>s==(s=s.replace(/(.) ?([- \d]*)[\]})>]/,(_,c,s)=>` `+(s?s.split` `.reduce((l,r)=>c<`<`?l- -r:c<`[`?l/r|0:c<`{`?l-r:l*r):c==`[`?-1:c==`(`?0:1)))?+s:f(s)

คำอธิบาย: regexp ค้นหาวงเล็บปิดแรกที่ไม่ได้ประมวลผลและจับคู่วงเล็บเปิดที่สอดคล้อง (สันนิษฐาน) และอาร์กิวเมนต์ใด ๆ ในระหว่างนั้น อาร์กิวเมนต์จะถูกแยกและลดขนาดตามการดำเนินการ (น่าเศร้า '(' และ '[' ไม่ใช่คู่ที่ดีที่สุดสำหรับ+และ-) หรือหากไม่มีข้อโต้แย้งค่าที่เหมาะสมจะถูกคำนวณ จากมุมมองของฉัน) ผลลัพธ์จะถูกแทนที่ด้วยช่องว่างนำเพื่อแยกออกจากผลลัพธ์อื่น ๆ จากนั้นฟังก์ชันจะเรียกตัวเองซ้ำ ๆ จนกว่าจะไม่มีการเปลี่ยนแปลงที่จะทำอีกต่อไป ตัวอย่าง:

[()<>]
[ 0<>]
[ 0 1]
 -1