소개:

표현과 관련하여 이미 몇 년 동안 진행중인 토론에서 영감을 얻었습니다 .$6÷2(1+2)$

식을 사용하면 수학자들은 정답이 임을 빨리 알 수있는 반면 학교에서 간단한 수학 배경을 가진 사람들은 정답이 임을 빠르게 알 수 있습니다. 그렇다면이 논쟁은 어디에서 왔으며 따라서 다른 대답은 어디에서 왔습니까? 작성 방법에는 두 가지 상충되는 규칙이 있습니다 . 하나는 부품 때문이고 다른 하나는 구분 기호 때문 입니다.$6÷2(1+2)$$1$$9$$6÷2(1+2)$2(÷

수학자와 '보통 사람들'이 모두 사용되지만 PEMDAS (- 해설자 - 부문 / 곱셈 - 괄호 추가 / 빼기) 표현식이 아래이 같은 평가 수학자를, 때문에 단지 예를 들어처럼 단항식 일명 " 병치에 의한 암시 적 곱셈으로 인한 단일 용어 "(따라서 in의 일부 )는 (이항 aka 두 용어) 와 다르게 평가됩니다 .$2(3)$$2x^2$PPEMDAS$2×(3)$

$$6÷2(1+2) → \frac{6}{2(3)} → \frac{6}{6} → 1$$

'일반인'의 경우 및 은 동일하므로 in의 일부 이므로 대신 이것을 사용합니다.$2(3)$$2×(3)$MDPEMDAS

$$6÷2(1+2) → 6/2×(1+2) → 6/2×3 → 3×3 → 9$$

그러나 원래 식을 로 작성 했더라도 나누기 기호 사용으로 인해 여전히 논란이있을 수 있습니다 . 현대 수학에서 와 기호는 정확히 같은 의미를가집니다 : 나누기. 일부 규칙은 사전 1918 ^† 분할 기호에 대한 ^†† 가 분할 기호와는 다른 의미를 가지고 있음 상태 . 때문이다 의미 "하는 데 사용 오른쪽에 숫자 / 식을 왼쪽에있는 번호 / 표현을 분할 " ^††† . 그래서 다음 것 또는 지금. 이 경우$6÷2×(1+2)$÷/÷÷/÷$a ÷ b$$(a) / (b)$$\frac{a}{b}$$6÷2×(1+2)$ 1918 년 이전 사람들에 의해 다음과 같이 평가 될 것입니다.

^{† : ÷과거에 사용 된 방법 을 설명하는 여러 출처를 찾았지만 (아래 ††† 참조) 1918 년경 어딘가에 이것이 바뀌 었다는 확실한 증거를 찾을 수 없었습니다. 그러나이 도전을 위해 1918은 포인트를 돌려 곳 ÷과 /그들이 과거에 차이 같은 것을 의미하는 것으로 시작.}

^{†† : 과거 :에도 1633 년 (현재는 네덜란드와 다른 유럽 비영어권 국가에서 초등학교 xD에서 개인적으로 배운 것이기 때문에) 또는 다른 지역과 같은 다른 기호가 나눗셈에 사용 )되었습니다. 1540 년대. 그러나이 도전을 위해 우리는 1918 년 이전의 오벨 루스 기호의 의미에만 초점을 맞 춥니 다 ÷.
††† : 출처 : 이 기사는 일반적으로 . 그리고에 대한 사전 1918 규칙 ÷에 언급되어 이 미국 수학 월간 1917년 2월에서 기사 ; 1659 쪽 9 쪽 과 76 쪽에있는 이 독일어 Teutsche Algebra 서적 ; 이 대수학의 첫 번째 책1895 쪽부터 46 쪽 [48/189] .}

약간의 주제를 벗어난 주제 :이 표현에 대한 실제 논의와 관련하여 : 처음부터 이와 같이 쓰여서는 안됩니다! 질문이 명확하지 않은 경우 정답은 관련이 없습니다. * "요청한 내용이 확실하지 않기 때문에 닫기"버튼을 클릭하십시오 * .
그리고 다른 버전의 Casio 계산기 조차도이 표현을 올바르게 처리하는 방법을 모릅니다.

도전:

두 가지 입력이 제공됩니다.

• 기호로만 구성된 (유효한) 수학적 표현 0123456789+-×/÷()
• 년

그리고 연도 ( y e a r < 1918 일 ÷때 다르게 사용되지만 y e a r ≥ 1918 일 때 와 동일하게 사용됨 )를 기준으로 수학 표현식의 결과를 출력합니다 .$year<1918$/$year\ge1918$

도전 규칙 :

• 수학 표현식이 유효하고 기호 만 사용한다고 가정 할 수 있습니다 0123456789+-×/÷(). 이것은 또한 지수화를 다룰 필요가 없다는 것을 의미합니다. (당신은 또한에 대해 다른 기호를 사용할 수 있습니다 ×또는 ÷(즉, *나 %)는 골프를하는 데 도움이 경우 또는 언어 만 ASCII를 지원하는 경우.)
• 표현식의 (수동) 평가에 도움이되는 경우 공백 표현식을 입력 표현식에 추가 할 수 있습니다.
• I / O는 유연합니다. 입력은 문자열, 문자 배열 등이 될 수 있습니다. 연도는 정수, 날짜 오브젝트, 문자열 등이 될 수 있습니다. 출력은 10 진수입니다.
• 테스트 사례가 0으로 나뉘 지 않는다고 가정 할 수 있습니다.
• input-expression의 숫자가 음수가 아닌 것으로 가정 할 수 있으므로 -음수 기호와 -빼기 기호 를 구별 할 필요가 없습니다 . 그러나 출력은 여전히 ​​음수 일 수 있습니다!
• N(항상 N×(대신 쓰는 것으로 가정 할 수 있습니다 . 우리는 단지 구분 기호의 두 번째 논쟁에 집중할 것 /대 ÷이 도전한다.
• 10 진수 출력값은 최소 3 자리 10 진수의 정밀도를 가져야합니다.
• 입력 표현식 에 y e a r < 1918 인 배수 ÷(예 : $4÷2÷2$ )가 포함 된 경우 다음 과 같이 평가됩니다. 4 ÷ 2 ÷ 2 → 4$year<1918$$4÷2÷2 → \frac{4}{\frac{2}{2}} → \frac{4}{1} → 4$. (또는 낱말 :수$4$식으로 나누어$2 ÷2$, 식$2 ÷2$번호 회전 수단$2$숫자로 분할되어$2$).
• 방법이 있습니다 ÷작동은 암시 적으로는 이상 연산자의 우선 순위가 의미 ×하고 /(이 테스트 케이스 참조 $4÷2×2÷3$ ).
• 입력 연도가 $[0000, 9999]$ 범위 내에 있다고 가정 할 수 있습니다 .

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 I / O 규칙으로 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 반환 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트와 링크를 추가하십시오 (예 : TIO ).
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 사례 :

Input-expression:   Input-year:   Output:      Expression interpretation with parenthesis:

6÷2×(1+2)           2018          9            (6/2)×(1+2)
6÷2×(1+2)           1917          1            6/(2×(1+2))
9+6÷3-3+15/3        2000          13           ((9+(6/3))-3)+(15/3)
9+6÷3-3+15/3        1800          3            (9+6)/((3-3)+(15/3))
4÷2÷2               1918          1            (4/2)/2
4÷2÷2               1900          4            4/(2/2)
(1÷6-3)×5÷2/2       2400          -3.541...    ((((1/6)-3)×5)/2)/2
(1÷6-3)×5÷2/2       1400          1.666...     ((1/(6-3))×5)/(2/2)
1×2÷5×5-15          2015          -13          (((1×2)/5)×5)-15
1×2÷5×5-15          1719          0.2          (1×2)/((5×5)-15)
10/2+3×7            1991          26           (10/2)+(3×7)
10/2+3×7            1911          26           (10/2)+(3×7)
10÷2+3×7            1991          26           (10/2)+(3×7)
10÷2+3×7            1911          0.434...     10/(2+(3×7))
4÷2+2÷2             2000          3            (4/2)+(2/2)
4÷2+2÷2             1900          2            4/((2+2)/2)
4÷2×2÷3             9999          1.333...     ((4/2)×2)/3
4÷2×2÷3             0000          3            4/((2×2)/3)
((10÷2)÷2)+3÷7      2000          2.928...     ((10/2)/2)+(3/7)
((10÷2)÷2)+3÷7      1900          0.785...     (((10/2)/2)+3)/7
(10÷(2÷2))+3×7+(10÷(2÷2))+3×7
                    1920          62           (10/(2/2))+(3×7)+(10/(2/2))+(3×7)
(10÷(2÷2))+3×7+(10÷(2÷2))+3×7
                    1750          62           (10/(2/2))+(3×7)+(10/(2/2))+(3×7)
10÷2/2+4            2000          6.5          ((10/2)/2)+4
10÷2/2+4            0100          2            10/((2/2)+4)
9+6÷3-3+15/3        9630          13           9+(6/3)-3+(15/3)
9+6÷3-3+15/3        0369          3            (9+6)/(3-3+(15/3))

R , 68 66 바이트

function(x,y,`=`=`/`)eval(parse(t=`if`(y<1918,x,gsub('=','/',x))))

온라인으로 사용해보십시오!

=대신 ÷및 *대신에 등호를 예상합니다 ×.

이 코드는 불쾌한 연산자 오버로딩을 사용하여 =우선 순위가 매우 낮은 오른쪽에서 왼쪽으로의 연산자 (-1918 이전에서 원하는 정확한 동작 ÷)를 활용하며 R은 원래의 우선 순위를 유지합니다. 과부하. 나머지는에 의해 자동으로 수행됩니다 eval.

보너스로, 다음은 정확한 구문으로 구현 된 것과 동일한 정확한 접근 방식입니다. 이번에는 특수 구분 연산자가 물결표 ( ~)입니다.

Julia 0.7 , 51 바이트

~=/;f(x,y)=eval(parse(y<1918?x:replace(x,'~','/')))

온라인으로 사용해보십시오!

자바 스크립트 (ES6),  130 (129)  120 바이트

@ScottHamper 덕분에 9 바이트 절약

로 입력을 (year)(expr)받습니다. 예상 %과 *대신 ÷과 ×.

y=>g=e=>(e!=(e=e.replace(/\([^()]*\)/,h=e=>eval(e.split`%`.reduceRight((a,c)=>y<1918?`(${c})/(${a})`:c+'/'+a))))?g:h)(e)

온라인으로 사용해보십시오!

방법?

리프 표현식 처리

$h$$e$%$y$

$y<1918$X%Y(X)/(Y)

예 :

• 8%2해진다 (8)/(2)그 간략한 형태로는,8/2
• 2+3%3+2 된다 (2+3)/(3+2)
• 8%2%2해진다 (8)/((2)/(2))그 간략한 형태로는,8/(2/2)

$y\ge 1918$%/

h = e =>                    // e = input string
  eval(                     // evaluate as JS code:
    e.split`%`              //   split e on '%'
    .reduceRight((a, c) =>  //   for each element 'c', starting from the right and
                            //   using 'a' as the accumulator:
      y < 1918 ?            //     if y is less than 1918:
        `(${c})/(${a})`     //       transform 'X%Y' into '(X)/(Y)'
      :                     //     else:
        c + '/' + a         //       just replace '%' with '/'
    )                       //   end of reduceRight()
  )                         // end of eval()

중첩 식 다루기

$h$

$g$

g = e => (            // e = input
  e !=                // compare the current expression with
    ( e = e.replace(  // the updated expression where:
        /\([^()]*\)/, //   each leaf expression '(A)'
        h             //   is processed with h
      )               // end of replace()
    ) ?               // if the new expression is different from the original one:
      g               //   do a recursive call to g
    :                 // else:
      h               //   invoke h on the final string
)(e)                  // invoke either g(e) or h(e)

파이썬 3.8 (시험판) , 324 (310) 306 바이트

lambda s,y:eval((g(s*(y<1918))or s).replace('%','/'))
def g(s):
 if'%'not in s:return s
 l=r=j=J=i=s.find('%');x=y=0
 while j>-1and(x:=x+~-')('.find(s[j])%3-1)>-1:l=[l,j][x<1];j-=1
 while s[J:]and(y:=y+~-'()'.find(s[J])%3-1)>-1:r=[r,J+1][y<1];J+=1
 return g(s[:l]+'('+g(s[l:i])+')/('+g(s[i+1:r])+')'+s[r:])

온라인으로 사용해보십시오!

소요 %대신 ÷하고 *대신×

Perl 5, 47 97 95 바이트

/ /;$_="($`)";$'<1918?s-%-)/(-g:y-%-/-;$_=eval

$_="($F[0])";1while$F[1]<1918&&s-\([^()]+\)-local$_=$&;s,%,)/((,rg.")"x y,%,,-ee;y-%-/-;$_=eval

TIO

녹 -1066 860 783 755740 바이트

macro_rules! p{($x:expr)=>{$x.pop().unwrap()}}fn t(s:&str,n:i64)->f64{let (mut m,mut o)=(vec![],vec![]);let l=|v:&Vec<char>|*v.last().unwrap();let z=|s:&str|s.chars().nth(0).unwrap();let u=|c:char|->(i64,fn(f64,f64)->f64){match c{'÷'=>(if n<1918{-1}else{6},|x,y|y/x),'×'|'*'=>(4,|x,y|y*x),'-'=>(2,|x,y|y-x),'+'=>(2,|x,y|y+x),'/'=>(5,|x,y|y/x),_=>(0,|_,_|0.),}};macro_rules! c{($o:expr,$m:expr)=>{let x=(u(p!($o)).1)(p!($m),p!($m));$m.push(x);};};for k in s.split(" "){match z(k){'0'..='9'=>m.push(k.parse::<i64>().unwrap() as f64),'('=>o.push('('),')'=>{while l(&o)!='('{c!(o,m);}p!(o);}_=>{let j=u(z(k));while o.len()>0&&(u(l(&o)).0.abs()>=j.0.abs()){if j.0<0&&u(l(&o)).0<0{break;};c!(o,m);}o.push(z(k));}}}while o.len()>0{c!(o,m);}p!(m)}

Rust에는 'eval'과 같은 것이 없으므로 조금 어렵습니다. 기본적으로 이것은 약간 수정 된 늪지대 표준 Djisktra 분로 장 중위 평가 기입니다. ÷는 우선 순위가 가변적 인 연산자입니다. <1918 모드의 다른 모든 것 (그러나 괄호)보다 작고> = 1918 모드의 다른 모든 것보다 높습니다. 또한 <1918이 4 ÷ 2 ÷ 2 사양을 충족하는 것은 '오른쪽 연관'(또는 왼쪽?)이며, ÷ 우선 순위를 음수로하여 연관을 '가짜'로 평가 한 다음 우선 순위 <0을 연관된 것으로 간주합니다. 골프를위한 더 많은 공간이 있지만 이것은 좋은 생각입니다.

play.rust-lang.org에서 ungolfed