Priorytet operatora: jak bardzo mogę się mylić?


65

Powiedz, że mam wyrażenie:

9 * 8 + 1 - 4

To wyrażenie można interpretować na sześć różnych sposobów, w zależności od pierwszeństwa operatora:

(((9 * 8) + 1) - 4) = 69 (* + -)
((9 * 8) + (1 - 4)) = 69 (* - +)
((9 * (8 + 1)) - 4) = 77 (+ * -)
(9 * ((8 + 1) - 4)) = 45 (+ - *)
((9 * 8) + (1 - 4)) = 69 (- * +)
(9 * (8 + (1 - 4))) = 45 (- + *)

Powiedzmy, że jestem programistą i nie chcę zapamiętywać tabel pierwszeństwa itp., Więc po prostu zgadnę.

W tym przypadku największy margines błędu wyniósłby 45-77, co stanowi różnicę 32. Oznacza to, że moje przypuszczenie będzie wyłączone tylko o 32.

Wyzwanie

Biorąc pod uwagę ekspresję składają się z liczb i +, -, *, /(podział całkowitej), a %wyjście układu bezwzględna różnicy największej i najmniejszej możliwej wartości dla tego słowa, na podstawie pierwszeństwa operatorów.

Dane techniczne

  • Wyrażenie wejściowe nie będzie zawierało nawiasów, a każdy operator jest lewostronny.
  • Wyrażenie wejściowe będzie zawierać tylko nieujemne liczby całkowite. Jednak podwyrażenia mogą dawać w wyniku negatywy (np 1 - 4.).
  • Możesz przyjąć wyrażenie w dowolnym rozsądnym formacie. Na przykład:
    • "9 * 8 + 1 - 4"
    • "9*8+1-4"
    • [9, "*", 8, "+", 1, "-", 4]
    • [9, 8, 1, 4], ["*", "+", "-"]
  • Dane wejściowe będą zawierać co najmniej 1, a maksymalnie 10 operatorów.
  • Każde wyrażenie zawierające dzielenie lub modulo przez 0 należy zignorować.
  • Możesz założyć, że modulo nie otrzyma ujemnych argumentów.

Przypadki testowe

9 * 8 + 1 - 4             32
1 + 3 * 4                  3
1 + 1                      0
8 - 6 + 1 * 0              8
60 / 8 % 8 * 6 % 4 * 5    63

1
@AndersKaseorg Wygląda na to, że %w drugim przykładzie traktujesz dwa różne priorytety.
Esolanging Fruit

1
Trzy z „sześciu” są identyczne, podobnie jak kolejne dwa. To pozostawia trzy rzeczywiste przypadki, a nie sześć.
user207421,

3
jak %operator działa na liczbach ujemnych? Sposób jak C lub Python czy coś innego?
tsh

8
Mówiąc wprost, nie musisz dodawać do opisu części „i jestem leniwy”. Wystarczy powiedzieć, że jesteś programistą. :)
Gryphon

1
@tsh Każde zachowanie. Rób co chcesz. Możesz sprawić, że demony wylecą z mojego nosa .
Esolanging Fruit

Odpowiedzi:


27

Python 2 , 171 156 bajtów

lambda a:max(e(a))-min(e(a))
u=')%s('
def e(a,t=u):
 try:b=[eval(a)]
 except:b=[]
 return sum([e('(%s)'%a.replace(o,t%o),u%t)for o in"+-*/%"if' '+o in a],b)

Wypróbuj online!

Jak to działa

Otaczamy każdego operatora inną liczbą skierowanych na zewnątrz par nawiasów, aby symulować różne priorytety (na wszystkie możliwe sposoby), i zawijamy wystarczającą liczbę skierowanych do wewnątrz par nawiasów wokół całego łańcucha, aby uzyskać wyrażenie, które możemy eval. Na przykład za pomocą

+)+(
*))*((
-)))-(((

dostajemy

9 * 8 + 1 - 4(((9 ))*(( 8 )+( 1 )))-((( 4)))= 77.


Możesz zapisać 2 bajty, przesuwając na orzewnątrz, sumaby usunąć warstwę nawiasów kwadratowych: sum([...],[])or[eval(a)]zamiastsum([...]or[[eval(a)]],[])
Strigoides,

@ Strigoides Myślałem, że to nie jest równoważne, ponieważ summoże być pusty bez argumentu pustego - jednak tak naprawdę jest dobrze, ponieważ evalw tym przypadku musi się nie powieść. Dzięki.
Anders Kaseorg,

8

Galaretka , 126 bajtów

„Priorytet operatora? Nawiasy? Pah, kto tego potrzebuje?” - wyzwania związane z użyciem Galaretki jako wyzwania pierwszeństwa operatora.

⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€
ǵḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/
ǵVṾµ1ĿFḟØDḟ”-Lµ?ÐL
5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ
“+_×:%”Œ!Ç€µṾL_L’ỊµÐfV€ṢIS

Wypróbuj online!

Dane wejściowe są traktowane jako ciąg, np. „1 + 2_3 × 4: 5% 6”. Uwaga mnożenie używa „×” zamiast „*”, dzielenie używa „:” zamiast „/”, a odejmowanie używa „_” zamiast „-”.

Jak to działa Program jest podzielony na trzy części: generowanie wszystkich wyrażeń o innym priorytecie operatora, ich ocena i zwracanie różnicy między maksimum a minimum.

Wszystkie wyrażenia są generowane za pomocą kodu:

5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ (4) helper link: returns all outputs given a permutation. Input e.g. "_+:×%"
5Ḷx@€“]“[”           - repeat outer brackets to get ["",""],["]","["],["]]","[["],["]]]","[[["],["]]]]","[[[["]
          ż⁸j/€      - insert the operations in to get "_","]+[","]]:[[","]]]×[[[","]]]]%[[[["
               ,@    - turn this into a mapping equivalent to "_"↦"_","+"↦"]+[",":"↦"]]:[[","×"↦"]]]×[[[","%"↦"]]]]%[[[["
                 y³F - use this mapping to get the right number of outward brackets on each operation. e.g. "1]+[3]]]×[[[4"
ɓ³i@€Ṁ’x@“[“]”j      - add the right number of brackets to the end to get e.g."[[[1]+[3]]]×[[[4]]]"
               Ç     - this calls the link which evaluates the expression
“+_×:%”Œ!Ç€                          (5a) main link. Input e.g. "1+3×4"
“+_×:%”                                 - the string "+_×:%"
       Œ!                               - all permutations
         ǀ                             - apply link (4) to each permutation

Łącza są oceniane za pomocą tego (prawdopodobnie mógłbym ulepszyć z inną strukturą):

⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€      (1) Helper link: Outputs a list of expressions within brackets, e.g. "[[[1]+[3]]]×[[[4]]]"↦"[[1]+[3]]","[[4]]"
⁾[]i$€Ḥæ%3                 - map "[" to 2, "]" to -2, and any other character to 0.
          +\¬              - cumulative sum negated: 1s at characters not in brackets (includes opening brackets), 0s otherwise (includes closing brackets)
             œp¹           - partition the input, not including borders, based on the sum to get "[[[1]+[3]]","[[[4]]"
                Ḋ€         - remove opening brackets
ǵḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/ (2) Return the input to this link with one of the expressions from (1) evaluated
ǵVṾµ1ĿFḟØDḟ”-Lµ?ÐL     (3) link called from part 1: Evaluates expressions
 µ  µ          µ?          - if:
     1ĿFḟØDḟ”-L            - the input contains no operators within brackets:         
  VṾ                         - evaluate this one expression with normal Jelly calculation and return to string
                           - otherwise:
Ç                            - evaluate one subexpression using link (2)
                  ÐL       - repeat this until a single output is determined

Różnica między maksimum a minimum jest obliczana za pomocą kodu w linku (5):

µṾL_L’ỊµÐfV€ṢIS (5b) determine difference between minimum and maximum
µ      µÐf        - filter out outputs involving division or modulo by 0. Determined with:
 ṾL_L’Ị           - actual numbers have their unevaled form Ṿ no more than one byte longer than the non-unevaled form.
          V€      - evaluate each of these valid numbers to get integers from strings
            Ṣ     - sort
             IS   - return the sum of all difference between consecutive elements.

4
Prawdopodobnie najdłuższa odpowiedź Jelly (bez osadzonych danych), jaką kiedykolwiek widziałem. Dobra robota!
Keyu Gan,

@KeyuGan Jeśli chcesz uzyskać dłuższe odpowiedzi żelkowe, spójrz na tę odpowiedź . Nie mogę wymyślić żadnych innych długich odpowiedzi żelków bez kompresji.
fireflame241

6

Python 2 , 235 234 233 226 bajtów

-1 bajt (i poprawka) dzięki Andersowi Kaseorgowi !

-7 bajtów dzięki Step Hen !

from itertools import*
def f(e,a=()):
 for o in permutations("+-*/%"):
	l=e[:]
	for c in o:
	 for i in range(len(l),0,-1):
		if l[i-1]==c:l[i-2:i+1]=["("+l[i-2]+l[i-1]+l[i]+")"]
	try:a+=eval(*l),
	except:0
 print max(a)-min(a)

Wypróbuj online!


1
Przesłania funkcji muszą być wielokrotnego użytku . Możesz rozwiązać ten problem, pozwalając abyć krotką zamiast listy, a nawet zapisać 1 bajt, robiąc to ( a=(), a+=eval(*l),).
Anders Kaseorg,

Huh, TIL. Dzięki za wskazówkę!
notjagan

1
Ponieważ jesteś w Pythonie 2, możesz zapisać niektóre bajty, zmieniając spacje i tabulatory dla wcięcia (w tym przypadku 2 spacje -> tab, trzy spacje -> tab + spacja, cztery spacje -> dwie tabulatory) Wypróbuj online!
Stephen

4

Haskell 582 bajtów

Nie poszło tak dobrze, jak miałem nadzieję, że ...

import Data.List
f x=case x of '+'->(+);'-'->(-);'*'->(*);'/'->div;_->rem
e _ s[]=s
e 1 s(')':x:a)|0<-(read$e 0""a),(x=='%'||x=='/')=""|""<-(e 0""s)=""|""<-(e 0""a)=""|0<3=show$(f x)(read$e 0""s)$read$e 0""a
e 1 s")"=e 0""s
e n s(')':a)=e(n-1)(s++")")a
e 0 s('(':a)=e 1 s a
e n s('(':a)=e(n+1)(s++"(")a
e n s(x:a)=e n(s++[x])a
n?s=take n$cycle s
a!b=e 0""(9?"("++(concat$zipWith(++)a(b++[[]]))++9?")")
c#b|l<-[read x|x<-map(c!)(a b),x/=""]=maximum l-minimum l
a c=transpose$map(\x->map((\(Just q)->q).lookup x)$map(\a->zipWith(\x y->(y,x?")"++y:x?"("))[1..5]a)$permutations"+-*%/")c

Wypróbuj online!

Próba grania w długi program sprawia, że ​​piszę zły kod :(

Próbowałem użyć algorytmu Andersa w Haskell, ale wymknęło mi się to spod kontroli

Funkcja e jest jak szczególny przypadek eval. (#) pobiera listę ciągów znaków reprezentujących liczby całkowite i ciąg operatorów i zwraca różnicę między maksymalną i minimalną możliwą wartością. na przykład

(#) ["9","8","1","4"] "*+-" => 32

1
Jeśli zmienisz nazwę #na ##, możesz zmienić nazwę ena (#):(n#s)(x:a)=...
Esolanging Fruit

Po utworzeniu aliasu trzy następujące najczęściej używane funkcje można zapisać kolejne 6 bajtów. r=read;j=zipWith;o=mapa następnie zamień te funkcje na aliasy literowe.
maple_shaft

Liczę także 594 bajty, a nie 582.
maple_shaft

3

Pyth, 45 bajtów

KS.nm.x.vj\ u.nm+*H/kHckHGd]s.iFQY.p_{eQ-eKhK

Jestem pewien, że można zrobić o wiele więcej optymalizacji, ale do tej pory mi się podobało.

Zajmuje wejście tak: [9, 8, 1, 4], ["*", "+", "-"].

Wypróbuj online!


2
Czy możesz dodać wyjaśnienie?
Jim

2

Mathematica, 186 164 159 bajtów

eMax@#-Min@#&[Fold[#//.{m___,x_,#2[[0]],y_,n___}:>{m,x~Last@#2~y,n}&,e,#]&/@Permutations@{"+"@Plus,"-"[#-#2&],"*"@Times,"/"@Quotient,"%"@Mod}/. 0/0|1/0->{}]

\[Function] zajmuje 3 bajty.

Niektóre alternatywy (zachowuje tę samą liczbę bajtów)

#2-#&@MinMax[...] zamienić Max@#-Min@#&[...]

Head@#2 zamienić #2[[0]]

Wypróbuj online na stronie http://sandbox.open.wolframcloud.com : wpisz ( .... )[{60, "/", 8, "%", 8, "*", 6, "%", 4, "*", 5}]z ....zastąpionym kodem powyżej dla przypadku testowego 60 / 8 % 8 * 6 % 4 * 5. Naciśnij, Shift + enteraby ocenić.


2

JavaScript, 280 bajtów

Uwaga : Dzielenie liczb całkowitych zaokrągla się przy użyciu funkcji floor, co oznacza, że ​​liczby ujemne zaokrąglają się od zera.

To rozwiązanie opiera się na tej odpowiedzi .

b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

Przykładowy fragment kodu:

g=

b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

for(k=0;k<5;k++)
  v=["9*8+1-4","1+3*4","1+1","8-6+1*0","60/8%8*6%4*5"][k],
  console.log(`g(${v}) = ${g(v)}`)


Jak trudno byłoby zapewnić zgodność z normą, zastępując obudowę a / b przez a / b | 0?
trlkly

@trlkly a/b|0zatrzymuje sprawdzanie błędów podziału / modulo 0, ale Math.floor(a/b)zadziałało
Herman L

2

Haskell , 254 bajty

import Data.List.Split
import Data.List
f s=(-)<$>maximum<*>minimum$permutations(zip"+-*/%"[p(+),p(-),p(*),c$div,c$mod])>>=(s!)
p=((pure.).)
c o a b=[o a b|b/=0]
s![]=[read s]
s!((x,o):y)=case splitOn[x]s>>=(!y)of[]->[];l->l?o
[a]?_=[a]
(a:b)?o=b?o>>=o a

Wypróbuj online!

Dane wejściowe to cały ciąg znaków, na przykład 4 + 5 * 2. Generuje wszystkie permutacje operacji, a dla każdej permutacji rozdziela rekurencyjnie ciąg. Filtruje podziały według 0 za pomocą monady listy.


(%)jest operatorem modułu. Jest to pozostałość operacji dzielenia między lewym i prawym argumentem.
maple_shaft

1

Python 2 , 262 256 254 bajtów

from itertools import*
def r(s,o):
 try:
  while o in s:i=s.index(o)-1;s[i:i+3]=[`eval(''.join(s[i:i+3]))`]
  return s
 except:0
def f(s):
 u=[int(v[0])for v in [reduce(r,O,s.split(' '))for O in permutations('*/%+-')]if v!=None];return abs(max(u)-min(u))

Wypróbuj online!


Zaoszczędź niektóre bajty, używając także kart: Wypróbuj online!
Stephen

1
Oszczędź jeden bajt, zmieniając in [na in[(miejsce nie jest potrzebne)
Zacharý

1

PHP , 316 bajtów

<?for(;$t++<54322;)count_chars($t,3)!=12345?:$p[]=$t;foreach($p as$x){for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)while(-1<$k=array_flip($q)[$y]){$n=$k+1;if($b&=$z[$n]||ord($y)%10<6)eval("\$z[$k]=$z[$k]$y$z[$n]^0;");($s=array_splice)($z,$n,1);$s($q,$k,1);}$b?$r[]=$z[0]:0;}echo max($r)-min($r);

Wypróbuj online!

Expanded
for(;$t++<54322;)
  count_chars($t,3)!=12345?:$p[]=$t;
foreach($p as$x){
  for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)
    while(-1<$k=array_flip($q)[$y]){
      $n=$k+1;
      if($b&=$z[$n]||ord($y)%10<6)
        eval("\$z[$k]=$z[$k]$y$z[$n]^0;");
      ($s=array_splice)($z,$n,1);
      $s($q,$k,1);
    }
  $b?$r[]=$z[0]:0;
}
echo max($r)-min($r);

Przypadek lasera to 63. Twój błąd związany z nadaniem temu samemu operatorowi innego pierwszeństwa w różnych częściach jednego wyrażenia
H.PWiz

0

Python 3 , 284 bajtów

Edycja: wydaje się, że coś jest nie tak z oceną ostatniego przykładu. Zajmę się tym jutro.

Kolejna odpowiedź w języku Python. Nie mogłem prześcignąć wszystkich innych, ale spędziłem na tym zbyt długo, aby tego nie postawić.

from itertools import*
def f(n,o):
 z=[]
 for p in permutations("+-*/%"):
  try:
   p,x,a=[*p],n[:],o[:]
   while(p):
    for i,d in enumerate(a):
     if d==p[0]:x[i+1]=str(eval(x[i]+d+x[i+1]));x.pop(i);a.pop(i)
    p.pop(0)
   z+=x
  except:0
 z=[*map(float,z)];return max(z)-min(z)

Wypróbuj online!


1
while(p)może zostać while pzapisany na jeden bajt.
Zacharý

0

Clojure (+ kombinatoryka), 342 377 + 41 = 418 bajtów

+35 bajtów z powodu błędu.

(fn[x y](let[l filter s first z #(l(fn[y]y)%)r(sort(z(for[e(q/permutations[+ - * quot mod])](try(loop[t e m y a x](if(=[]t)(s a)(let[j(s t)i(reverse(keep-indexed #(if(= j %2)%)m))](recur(rest t)(l #(not= j %)m)(loop[d 0 h a](if(=(count i)d)h(let[c(nth i d)f(inc c)](recur(inc d)(vec(z(assoc h c(j(nth h c)(nth h f))f nil)))))))))))(catch Exception _ nil)))))](-(last r)(s r))))

Wypróbuj online!

Aby ta funkcja działa, trzeba usez clojure.math.combinatoricsbiblioteki (41 bajtów):

(use '[clojure.math.combinatorics :as q])

Niuanse:

Ta funkcja jest funkcją anonimową, co oznacza, że ​​musisz to zrobić, aby z niej skorzystać:

((fn[x y]...) numbers operators)

Używam tego słowa quotzamiast /(ponieważ Clojure domyślnie dokonuje podziału ułamkowego) i modzamiast %.

Nieogrodzony program:

(defn precedence [numbers operators]
  (let [results
        (sort
          (for [permute (c/permutations [+ - * / mod])]
            (loop [p-temp permute
                  o-temp operators
                  n-temp numbers]
              (if (empty? o-temp) (first n-temp)
                (let [first-p (first p-temp)
                      indices (reverse (keep-indexed #(when (= first-p %2) %) o-temp))]
                  (recur
                    (rest p-temp)
                    (filter #(not= first-p %) o-temp)
                    (loop [ind 0
                          n-through n-temp]
                      (if (= ind (count indices)) n-through
                        (let [current-ind (nth indices ind)]
                          (recur
                            (inc ind)
                            (vec
                              (filter #(not (nil? %))
                                (assoc n-through
                                  current-ind (first-p (nth n-through current-ind) (nth n-through (inc current-ind)))
                                  (inc current-ind) nil)))))))))))))]
    (- (last results) (first results))))

Myślę, że możesz po prostu powiedzieć „Zamknięcie + kombinatoryka” i nie musisz oceniać tego usestwierdzenia.
Esolanging Fruit

@ Challenger5 Myślę, że lepiej napisz to w opisie, ponieważ domyślnie The characters used to import the library will likely be counted codegolf.meta.stackexchange.com/questions/10225/…
Keyu Gan

@KeyuGan Masz rację - źle zrozumiałem konsensus Meta. Myślę, że requirenależy uwzględnić kod, a jego długość należy dodać do liczby bajtów.
Esolanging Fruit

@ Challenger5 Więc muszę dodać 41 bajtów do mojego bajtu, prawda? DOBRZE.
Qwerp-Derp,

@ Qwerp-Derp Tak, ale import jest częścią twojego kodu i możesz go zagrać w golfa.
Esolanging Fruit 11.07.17

0

JavaScript (ES6), 210 bajtów

Wprowadź jako tablicę liczb i operatorów

k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

Mniej golfa

k=>(
  m = n = NaN,
  r =(o, k, j=0) => {
    // try all operators in o
    for(;q = o[j]; j++)
    {  
      // q : current operator, 
      // look for q inside the expression to evaluate
      for(h = [...k], z = 1; i = h.indexOf(q) + 1;)
      {
        a = h[i - 2]
        b = h[i]
        z *= b // trace if any second operand is zero
        // subst subexpression with its value
        h.splice(i - 2, 3, eval(a + q + b) | 0)
      }
      // now all subexp involving current operator are evaluated
      // the result is ok if current operator is not % or /
      //  OR if no second operand was zero
      (q > '%' & q < '/' || z) && 
        // try again recursively
        // using the remaining operators and the remaining expression
        r(o.slice(0, j) + o.slice(j+1), h) 
    }
    // if no more operators to try, check max and min
    // k is an array with 1 element, can be used like a single number
    o || (
      m = m > k ? m : k, 
      n = n < k ? n : k
    )
  },
  r('+-*/%', k),
  m-n
)

Test

var F=
k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

function update() {
  var input = I.value.match(/\d+|\S/g)
  var result = F(input)
  O.textContent = I.value + ' -> ' + result + ' (max:'+m+' min:'+n+')'
}

update()
<input id=I value="60 / 8 % 8 * 6 % 4 * 5" oninput='update()'>
<pre id=O></pre>

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.