Pozwól, że opowiem ci o prostym systemie liczbowym. _{^{(które zrobiłem właśnie dla tego wyzwania)}}

System ten zawiera funkcje (), [], {}, i <>.

1. ()

Gdy ()nie podano żadnych argumentów, ocenia się na 0.

Gdy ()podany jest jeden lub więcej argumentów, następuje ich suma.

2) []

Gdy []nie podano żadnych argumentów, ocenia się na -1.

Gdy []podano jeden lub więcej argumentów, następuje ocena pierwszego argumentu minus suma pozostałych argumentów.

3) {}

Gdy {}nie podano żadnych argumentów, ocenia się na 1.

Gdy {}podano jeden lub więcej argumentów, ocenia się na iloczyn tych argumentów.

4 <>

Gdy <>nie podano żadnych argumentów, ocenia się na 1.

Gdy <>podany jest jeden lub więcej argumentów, następuje ocena liczby całkowitej pierwszego argumentu podzielonej przez iloczyn pozostałych argumentów.

Twoje zadanie

Biorąc pod uwagę ciąg znaków, który zawiera prawidłową liczbę (co oznacza, że ​​nawiasy są zrównoważone, bez dzielenia przez 0 itd.) W tym prostym systemie liczbowym, wypisz jego wartość.

Przypadki testowe

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

Pamiętaj, to jest kodowanie w golfa , więc wygrywa kod z najmniejszą liczbą bajtów.

Dyalog APL , 94 bajty

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

wykorzystuje ⎕IO←0

zastępuje )]}>wywołaniem funkcji, która pobiera stos, stosuje operację na górnej ramce, usuwa ją i dołącza wynik do następnej ramki ( odo tego celu stosuje się operator monadyczny ; operator diadyczny uobsługuje bardziej skomplikowane przypadki -i ÷)

zastępuje ([{<kodem, który dodaje ramkę do stosu ( (⊂⍬),)

wykonuje wynikowe wyrażenie (odwrócone, aby dopasować kolejność wykonywania APL) z początkowym stosem jednej pustej ramki ( ⊂⍬)

Haskell, 357 306 277 251 228 224 188 185 180 bajtów

Parser oparty na tokenach z jawnym stosem. (%)pobiera stos tokenów i znak i albo wypycha (kod operacji, numer domyślny) lub (0, liczba) ({[<, albo wyskakuje z najwyższych liczb i jednego kodu operacji i przesuwa odpowiedź na )}]>. Kody są kodowane przez hack wyliczenia ascii.

Wyrazy uznania dla @ChristianSievers za wspaniałą odpowiedź , od której pożyczyłem kilka pomysłów.

One-liner!

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(%)[]

Teraz z mniejszą obsługą błędów! Stosowanie:

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

Dzięki @ChristianSievers za oszczędność 14 + 3 bajtów!

Dzięki @Zgarb za uratowanie niektórych + 4 bajtów!

Python 2, 292 265 248 235 223 206 204 bajtów

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]

Zamienia wszystkie nawiasy na lambda, które robi to, co robi nawias, a następnie ocenia wynikowy kod Python. Wymaga danych wejściowych otoczonych cudzysłowami, np '[<><>([]{})]'.

Ten program przechowuje typ nawiasu jako pierwszy znak w każdym ciągu w for, a wszystko po słowie kluczowym lambdajako resztę. Następnie używa pierwszego znaku do zastąpienia; reszta jest połączona w lambda (lambda*x:sum(x))().

Wypróbuj na Ideone!

PEG.js (ES6) , 132 bajty

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

Powinien zostać teraz naprawiony.

Wyjaśnienie

Bardziej czytelny:

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 to rozszerzona wersja Javascript stworzona specjalnie do analizy. Jest BARDZO ścisły, dlatego musiałem go użyć var. Ponadto wydaje się, że występuje błąd z nawiasami wewnątrz ciągów, co znacznie rozszerzyło kod.

Na początek definiujemy regułę xpasującą do dowolnego nawiasu, aktóry może zawierać lub nie zawierać wielu wyrażeń pasujących do reguły x.

Dla każdego dopasowania do reguły x, wypychamy 0 do tablicy dopasowania wewnętrznego, bjeśli bdługość wynosi 1.

Jeśli bdługość> 0, to znajdujemy indeks aw ([<i otrzymujemy znak z +-/tego indeksu. Jeśli wynik jest niezdefiniowany (to znaczy, że abył {), to przekształcamy wynik w *. Na koniec zajmujemy się spacją i łączymy się bz wynikiem.

Jeśli bdługość = 0, to znajdujemy indeks aw ([<i otrzymujemy znak z 10tego indeksu. Jeśli wynik jest niezdefiniowany (co oznacza, że abył {lub <), wówczas zamieniamy wynik na 2. Wreszcie, po prostu zmniejszamy.

Na koniec możemy po prostu ocenić wyrażenie i podać wynik.

Perl, 113 + 2 = 115 bajtów

Uruchom z -lp(kara 2 bajty).

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

Bardziej czytelne (uwaga: ta „bardziej czytelna wersja” tak naprawdę nie działa, ponieważ umieszczam komentarze w miejscach, w których nie są dozwolone składniowo):

              # -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

Podstawową ideą jest to, że przekształcamy dane wejściowe podobne [()<>]do programu Perl b(a(0),d(0),0),poprzez przetwarzanie tekstu; Perl jest w porządku z przecinkiem. Wcześniej, mamy zdefiniowane funkcje a, b, c, daby mieć taki sam skutek jak (), [], {}, <>konstrukcje z języka jesteśmy wykonawczego; każdy z nich ignoruje swój ostatni argument (0 na końcu), który jest zawarty w celu zapewnienia, że ​​wszystkie dane wejściowe są poprawnie analizowane, i działa z wykorzystaniem implementacji powszechnie występującej w programowaniu funkcjonalnym, w którym głowa i ogon są przetwarzane osobno. Ponieważ b(e,f,g,0)środki e-f-g, tj. Traktuje swój pierwszy argument specjalnie, podczas gdy ajego argumenty traktuje symetrycznie ( a(e,f,g,0)środki e+f+g), implementujemyarekurencyjnie i bza pośrednictwem połączeń a. ci dmają podobny związek. Wszystkie cztery z tych funkcji są bardzo podobne, więc generujemy je w czasie wykonywania, a nie wdrażamy osobno; przechowujemy szablon, który dotyczy wszystkich czterech funkcji w ciągu, a następnie generujemy funkcje, zastępując znaki w szablonie.

Ponieważ Perl /wykonuje dzielenie zmiennoprzecinkowe, to również implementuje {}. Zakładam, że albo nie jest to problem sam w sobie, albo -Minteger(wybór wariantu językowego, w którym wszystkie operacje arytmetyczne są operacjami liczb całkowitych) jest bezpłatny, ponieważ w przeciwnym razie musiałbym spędzić dodatkowe bajty na pisaniu podziału na liczby całkowite w Perlu, wydaje się, że nie na tym polega problem. (Myślę, że trzeba wydać cztery bajty zmienia (shift)się int+(shift);. Nie testowałem tego)

Oktawa, 215 206 198 bajtów

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

spróbuj online

PHP, 315 300 285 258 250 244 bajtów

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

zamienia podwyrażenia na podkreślenie + wartość; pętla pęka, gdy iteracja nie zastępuje.

19 lat od pierwszego spotkania z C, 17 lat w PHP;
to pierwszy raz, który strtokma sens ... pomaga zaoszczędzić 24 bajty!

awaria

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 bajtów

Czysta wersja Javascript.

„Metaprogramowanie” (jak większość innych odpowiedzi tutaj) konwertuje tekst programu wejściowego na odpowiedni program Javascript, stosując do niego szereg bezpośrednich podstawień tekstu (tj. Zachowując aktualną strukturę programu).

Prawdopodobnie można dalej grać w golfa.

AKTUALIZACJA (v2.1)

• Minus dwa bajty (usunięto nawias w wyrażeniu potrójnym)
• Grał o 5 bajtów więcej, używając zmiennej do ekstrakcji wyników i pozbywając się dodatkowego „[]”

AKTUALIZACJA (v2)

Właśnie zdałem sobie sprawę, że oczekujące przecinki w tablicach ES są całkowicie poprawne, więc cały kod normalizacji przecinków można usunąć. Postępował również zgodnie ze świetną radą @Titus, dotyczącą optymalizacji wyszukiwania alfabetu.

AKTUALIZACJA (v1)

Usunięto zduplikowany alias „zamień”.

AKTUALIZACJA (v1)

• Użyj lepszego alfabetu: () => 1+ [] => 0 {} => 2 * <> => 2 / (każdy znak może być bezpośrednio ponownie użyty jako wartość lub operator)

• Zamienione zmniejsz () na replace () (odwzorowanie alfabetu)

• Scalona stała obróbka nachylenia, otwierania i zamykania zamka w jeden krok

Gra w golfa (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

Gra w golfa (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"))    

Gra w golfa (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"))

Wyjaśnione (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

Test

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)

Wyjście testowe

() 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 bajtów

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.([]%)

Rekurencyjne zejście, nawlekanie danych wejściowych, ponieważ Haskell. Jak zwykle ostatni wiersz nie jest definicją, ale określa funkcję, która rozwiązuje problem. Aby przetestować, umieść wiersze oprócz ostatniego w pliku, załaduj go i zrób coś takiego:

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

Podziękowania dla @Zgarb za inspirację i wiele szczegółowych wskazówek oraz @Angs za inspirację z jego rozwiązania i dalszych wskazówek.

Nie określono, jak powinien zachowywać się podział z ujemnymi liczbami całkowitymi. W każdym razie wielokrotne używanie divwydaje się nieprawidłowe, ponieważ nie jest to to samo, co divjednorazowe użycie z iloczynem pozostałych wartości. Teraz używam quot, otrzymuję te same wyniki dla <{}([][])[]>i <{}{([][])[]}>.

Aby uzyskać ładny, prawie czytelny kod, zobacz pierwszą wersję. Wersje pośrednie zawierają wszelkiego rodzaju ładny i onieśmielający kod i pomagają zrozumieć tę wersję.

JavaScript (ES6), nie eval, 156 bajtów

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)

Objaśnienie: Wyrażenie regularne znajduje pierwszy nieprzetworzony nawias zamykający i dopasowuje (przypuszczalnie) odpowiedni nawias otwierający i wszelkie argumenty pomiędzy nimi. Argumenty są dzielone i redukowane zgodnie z operacją (niestety „(” i „[” nie są optymalną parą dla +i -), lub jeśli nie ma argumentów, wówczas obliczana jest odpowiednia wartość (ponownie dopasowanie znaków do wartości jest nieoptymalne z mojego punktu widzenia). Następnie wynik zastępuje się spacją wiodącą, aby oddzielić go od innych wyników. Następnie funkcja wywołuje się rekurencyjnie, dopóki nie będzie więcej zmian do wprowadzenia, w którym to przypadku zwraca wartość wynikową. Przykład:

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