간단한 정수 연산 스크립트 가능 계산기를 구현하십시오.

개념

누산기는 0에서 시작하여 연산이 수행됩니다. 프로그램이 끝나면 누산기의 값이 출력됩니다.

운영 :

• +1누산기에 추가
• -1누산기에서 빼기
• * 누산기에 2
• / 누산기를 다음과 같이 나눕니다. 2

샘플 스크립트

입력 ++**--/은 출력을 제공해야합니다 3.

구현 예

def calc(s)
    i = 0
    s.chars.each do |o|
        case o
            when '+'
                i += 1
            when '-'
                i -= 1
            when '*'
                i *= 2
            when '/'
                i /= 2
        end
    end
    return i
end

규칙

• 이것은 code-golf 이므로 바이트 단위의 최저 응답이이기는하지만 선택되지는 않습니다.
• 창의적인 구현이 권장됩니다.
• 표준 허점은 금지되어 있습니다.
• stdin 또는 arguments를 통해 프로그램을 가져오고 리턴 값 또는 stdout을 통해 응답을 출력 할 수 있습니다.
• 즐기세요
• 정수 나누기이므로 나누기가 잘립니다.
• 프로그램이를 -/반환합니다 -1.

테스트 사례

*///*-*+-+
-1
/*+/*+++/*///*/+-+//*+-+-/----*-*-+++*+**+/*--///+*-/+//*//-+++--++/-**--/+--/*-/+*//*+-*-*/*+*+/+*-
-17 
+++-+--/-*/---++/-+*-//+/++-*--+*+/*/*/++--++-+//++--*/***-*+++--+-*//-*/+*/+-*++**+--*/*//-*--**-/-*+**-/*-**/*+*-*/--+/+/+//-+*/---///+**////-*//+-+-/+--/**///*+//+++/+*++**++//**+**+-*/+/*/*++-/+**+--+*++++/-*-/*+--/++*/-++/-**++++/-/+/--*/-/+---**//*///-//*+-*----+//--/-/+*/-+++-+*-*+*+-/-//*-//+/*-+//+/+/*-/-/+//+**/-****/-**-//+/+-+/*-+*++*/-/++*/-//*--+*--/-+-+/+/**/-***+/-/++-++*+*-+*+*-+-//+/-++*+/*//*-+/+*/-+/-/*/-/-+*+**/*//*+/+---+*+++*+/+-**/-+-/+*---/-*+/-++*//*/-+-*+--**/-////*/--/*--//-**/*++*+/*+/-+/--**/*-+*+/+-*+*+--*///+-++/+//+*/-+/**--//*/+++/*+*////+-*-//--*+/*/-+**/*//+*+-//+--+*-+/-**-*/+//*+---*+//*/+**/*--/--+/*-*+*++--*+//+*+-++--+-*-*-+--**+/+*-/+*+-/---+-*+-+-/++/+*///*/*-+-*//-+-++/++/*/-++/**--+-////-//+/*//+**/*+-+/+/+///*+*///*-/+/*/-//-*-**//-/-+--+/-*--+-++**++//*--/*++--*-/-///-+/+//--+*//-**-/*-*/+*/-*-*//--++*//-*/++//+/-++-+-*/*-+++**-/-*++++**+-+++-+-***-+//+-/**-+/*+****-*+++*/-*-/***/-/*+/*****++*+/-/-**-+-*-*-++**/*+-/*-+*++-/+/-++*-/*-****-*
18773342

파이썬 2, 48 바이트

i=0
for c in input():exec"i=i%s2&-2"%c
print i/2

합니까 +2, -2, *2, 또는 /2. 이렇게함으로써 +2및 -2보다는 +1및 -1최종 출력 요구가 절반으로 할 수 있도록, 우리는 두 배 단위로 노력하고 있습니다. 단, 바닥 구분은 /이제 2로 배수를 내림해야합니다 &-2.

하스켈, 51 바이트

x#'+'=x+1
x#'-'=x-1
x#'*'=x*2
x#_=div x 2 
foldl(#)0

사용 예 : foldl(#)0 $ "++**--/"-> 3.

젤리 , 18 17 바이트

‘

’

:2
Ḥ
O0;ṛĿ/

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

작동 원리

처음 6 줄은 1 에서 6 까지의 인덱스를 가진 도우미 링크를 정의합니다 . 그들은 증가하고, 아무것도하지 않고, 감소하고, 아무것도하지 않으며, 반으로 (바닥), 두 배로합니다.

주 링크 – O0;ṛĿ/– 입력 문자를 코드 포인트 ( O) 로 변환하고 0 (초기 값)을 코드 포인트 배열 앞에 추가 한 0;다음 생성 된 배열을 다음과 같이 줄입니다.

초기 값은 배열의 첫 번째 요소, 즉 앞에 0 이 붙습니다 . 빠른 ṛĿ반환 값은 배열의 모든 다음 요소에 대해 호출되며 마지막 반환 값은 왼쪽 인수이고 현재 요소는 오른쪽입니다. 올바른 인수 ( ṛ)를 검사하고 해당 인덱스와의 링크를 단정적으로 ( Ŀ) 평가 하여 원하는 작업을 적용합니다.

파이썬 2, 54 바이트

i=0
for c in input():exec"i=i"+c+`~ord(c)%5%3`
print i

입력은 문자열 리터럴로 사용됩니다. ~ord(c)%5%3연산자를 해당하는 오른쪽 피연산자에 매핑합니다.

이전에는 hash(c)%55%3다른 버전의 Python간에 일관된 결과를 얻지 못한 것을 사용했습니다 . 이것은 다른 공식을 탐구하도록 장려했습니다.

사일로 , 133 211 바이트

:s
def : lbl G GOTO
readIO
i-46
if i a
i+2
if i b
i+2
if i c
i+1
if i d
G e
:a
G v
:p
a-1
a/2
G o
:v
a+1
if a p
a-1
j=a
j/2
k=j
k*2
k-a
a/2
if k t
G o
:t
a-1
:o
G s
:b
a-1
G s
:c
a+1
G s
:d
a*2
G s
:e
printInt a

연산자의 ASCII 코드를 사용합니다.

테스트 사례와 함께 온라인으로 사용해보십시오 :
-/
++**--/
*///*-*+-+

튜링 머신-23 개 상태 (684 바이트)

여기에서 시도하십시오 -permalink

0 * * r 0
0 _ . l 1
1 * * l 1
1 _ * l 2
2 * 0 r 3
3 _ * r 3
3 + _ l +
3 - _ l -
3 x _ l x
3 / _ l /
+ _ * l +
+ * * * 4
4 - * l 5
4 _ 1 r 6
4 0 1 l 7
4 1 0 l 4
- _ * l -
- * * * 5
5 - * l 4
5 _ * r 8
5 0 1 l 5
5 1 0 l 7
x * * l x
x 1 0 l 9
x 0 0 l a
9 _ 1 r 6
9 1 1 l 9
9 0 1 l a
a _ _ r 6
a 1 0 l 9
a 0 0 l a
/ _ * l /
/ * * l b
b * * l b
b _ * r c
c 0 0 r d
c 1 0 r e
d * * l 7 
d 0 0 r d
d 1 0 r e
e _ * l 7
e - * l 4
e 0 1 r d
e 1 1 r e
8 * * r 8
8 - _ r 3
8 _ - r 3
7 * * l 7
7 _ * r f
f 0 _ r f
f 1 * r 6
f * _ l g
g * 0 r 6
6 * * r 6
6 _ * r 3
3 . _ l h
h _ * l h
h - _ l i
h * * l halt
i * * l i
i _ - r halt

입력은 Turing 기계 코드의 특수 문자이므로 '*'를 포함하지 않아야합니다. 대신 'x'를 사용하십시오. 답을 이진수로 출력합니다.

명확하지 않은 코드

init2 * * r init2
init2 _ . l init0
init0 * * l init0
init0 _ * l init1
init1 * 0 r readop
readop _ * r readop
readop + _ l +
readop - _ l -
readop x _ l x
readop / _ l /
+ _ * l +
+ * * * inc
inc - * l dec
inc _ 1 r return
inc 0 1 l zero
inc 1 0 l inc
- _ * l -
- * * * dec
dec - * l inc
dec _ * r neg
dec 0 1 l dec
dec 1 0 l zero
x * * l x
x 1 0 l x1
x 0 0 l x0
x1 _ 1 r return
x1 1 1 l x1
x1 0 1 l x0
x0 _ _ r return
x0 1 0 l x1
x0 0 0 l x0
/ _ * l /
/ * * l //
// * * l //
// _ * r div
div 0 0 r div0
div 1 0 r div1
div0 * * l zero 
div0 0 0 r div0
div0 1 0 r div1
div1 _ * l zero
div1 - * l inc
div1 0 1 r div0
div1 1 1 r div1
neg * * r neg
neg - _ r readop
neg _ - r readop
zero * * l zero
zero _ * r zero1
zero1 0 _ r zero1
zero1 1 * r return
zero1 * _ l zero2
zero2 * 0 r return
return * * r return
return _ * r readop
readop . _ l fin
fin _ * l fin
fin - _ l min
fin * * l halt
min * * l min
min _ - r halt

상태 설명 :

초기화 :
이 상태는 각 실행이 시작될 때마다 init2부터 시작하여 한 번 방문됩니다.

• init2 : 오른쪽 끝까지 이동하여 '.'를 입력하십시오. 그렇게하면 TM이 언제 중지해야하는지 알 수 있습니다. 'init0'으로 변경하십시오.
• init0 : 헤드가 공백을 읽을 때까지 모든 것을 왼쪽으로 다시 이동하십시오. 그런 다음 하나의 셀을 왼쪽으로 이동하십시오. 'init1'로 변경하십시오.
• init1 : 0을 넣고 하나의 셀을 오른쪽으로 이동하고 'readop'으로 변경하십시오.

읽기 지침 :
이 상태는 프로그램 전체에서 여러 번 방문됩니다.

• readop : 연산자 또는 '.'를 읽을 때까지 오른쪽으로 끝까지 이동합니다. 연산자에 부딪 치면 해당 상태 (+,-, x, /)로 변경하십시오. '.'에 도달하면 'fin'상태로 변경하십시오.

• return : 누적 합계와 연산자 사이의 빈 공간으로 헤드를 반환합니다. 그런 다음 'readop'으로 변경하십시오.

작업 :
이 작업은 실제 더러운 작업을 수행합니다.

• + : 머리가 공백이 아닌 문자를 읽을 때까지 왼쪽으로 이동하십시오. 이 문자가 '-'이면 왼쪽으로 이동하여 'dec'로 변경하십시오. 그렇지 않으면 'inc'로 변경하십시오.

• -: '-'가 있으면 'inc'로 변경하고 그렇지 않으면 'dec'로 변경 한 것을 제외하고는 '+'와 유사합니다.

• inc : 머리 아래의 숫자가 0 (또는 공백)이면 1로 변경하고 '0'으로 변경하십시오. 숫자가 1이면 0으로 변경 한 후 다음 숫자에서 반복하십시오.

• dec : inc와 비슷하지만 1은 0으로, 0은 1로, 헤드가 공백을 읽는 경우 'neg'로 변경합니다.

• x, x0, x1 : 숫자 1을 왼쪽으로 비트 시프트합니다. '반품'으로 변경하십시오.

• /, //, div, div0, div1 : 숫자의 오른쪽 끝까지 이동 한 다음 오른쪽으로 비트 이동합니다. '-'가 있으면 'inc'로 변경하십시오. 음수 반올림을 시뮬레이션합니다. 그렇지 않으면 '0'으로 변경하십시오.

• neg : 숫자 뒤에 '-'를 놓고 'readop'으로 변경하십시오.

• zero, zero1, zero2 : 선행 0을 제거하고 'readop'으로 변경

정리 : 출력을 표시 가능하게 만듭니다.

• 핀, 최소 : 필요한 경우 숫자 앞에 '-'를 이동하십시오. 정지.

펄 6 , 53  52 바이트

{([Ro] %(<+ - * />Z=>*+1,*-1,* *2,*div 2){.comb})(0)}

{[Ro](%(<+ - * />Z=>*+1,*-1,*×2,*div 2){.comb})(0)}

설명:

# bare block lambda that has one implicit parameter ｢$_｣
{
  (
    # reduce the code refs using ring operator ｢∘｣ in reverse ｢R｣
    [R[o]]

      # produce a hash from:
      %(

        # list of pairs of "operator" to code ref
        # ( similar to ｢'+' => { $^a + 1 }｣ )

          # keys
          < + - * / >

        # keys and values joined using infix zip operator ｢Z｣
        # combined with the infix Pair constructor operator ｢=>｣
        Z[=>]

          # values (Whatever lambdas)
          * + 1,
          * - 1,
          * × 2, # same as ｢* * 2｣
          * div 2,

      ){

        # split the block's argument into chars
        # and use them as keys to the hash
        # which will result in a list of code refs
        .comb

      }

  # call composed code ref with 0
  )(0)
}

용법:

my $input = '++**--/'
my $output = {[Ro](%(<+ - * />Z=>*+1,*-1,*×2,*div 2){.comb})(0)}.( $input );
say $output; # 3
say $output.^name; # Int

C, 63 62 57 바이트

s,t;c(char*x){for(;*x;s+=t<4?t?2-t:s:-s>>1)t=*x++%6;s=s;}

완드 박스

05AB1E , 20 바이트

-bug 를 수정 한 Enigma 에게 감사드립니다 -/!

정수 나누기가 아닌 경우 16 바이트의 경우 : Î"+-*/""><·;"‡.V.

Î…+-*"><·"‡'/"2÷":.V

설명:

Î                      # Push 0, which is our starting variable, and input
 …+-*                  # Push the string "+-*"
     "><·"             # Push the string "><·"
          ‡            # Transliterate. The following changes:
                           "+" -> ">"
                           "-" -> "<"
                           "*" -> "·"
           '/"2÷":     # Replace "/" by "2÷"
                  .V   # Evaluate the code as 05AB1E code...
                           '>' is increment by 1
                           '<' is decrement by 1
                           '·' is multiply by 2
                           '2÷' is integer divide by two
                       # Implicitly output the result

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

자바 스크립트 ES6, 80 68 바이트

k=>[...k].reduce((c,o)=>+{"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}‌​[o],0)

Neil 덕분에 무려 12 바이트를 절약했습니다!

루비, 48 44 42 + 1 = 43 바이트

-n플래그의 경우 +1 바이트 STDIN에서 입력을받습니다.

i=0
gsub(/./){i=i.send$&,"+-"[$&]?1:2}
p i

ideone에서 참조하십시오 ( $_ideone은 명령 줄 플래그를 사용 하지 않기 때문에 사용 ) : http://ideone.com/3udQ3H

PHP 76 바이트

for(;$c=$argv[1][$n++];)eval('$s=floor($s'.$c.(2-ord($c)%11%3).');');echo$s;

파이썬 2, 58 56 바이트

@Lynn 덕분에 -2 바이트

r=0
for c in input():exec'r=r'+c+`2-ord(c)%11%3`
print r

문자의 서수는 +-*/있습니다 43,45,42,47이이 모듈 (11) 10,1,9,3모듈로 사람들은 3 1,1,0,0, 2 적은 사람들은되는 1,1,2,2(가) 우리가 각 작업에 필요한 금액을 제공 : r=r+1, r=r-1, r=r*2, 및r=r/2

너무 이른:

r=0
for c in input():exec'r=r'+c+`(ord(c)%5==2)+1`
print r

Mathematica, 83 73 70 바이트

^{@MartinEnder 로 인해 10 바이트가 저장되었습니다 .}

(#/*##2&@@#/.Thread[{"+","-","*","/"}->{#+1&,#-1&,2#&,⌊#/2⌋&}])@0&

익명의 기능. 문자 목록을 입력으로 취하고 숫자를 출력으로 리턴합니다. 골프 제안을 환영합니다.

사일로 , 175 164 바이트

loadLine
a=256
o=get a
lbla
a+1
o-42
p=o
p-1
p/p
p-1
r-p
s=o
s-3
s/s
s-1
r+s
m=o
m/m
m-2
m|
r*m
t=r
t%2
d=o
d-5
d/d
d-1
t*d
d-1
d|
r-t
r/d
o=get a
if o a
printInt r

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

Sane 입력 방법. 올바른 정수 나누기 (-무한 방향으로 반올림)

C #, 87 81 바이트

int f(string s){int i=0;foreach(var c in s)i=c<43?i*2:c<46?i+44-c:i>>1;return i;}

언 골프 드 :

int f(string s)
{
    int i = 0;

    foreach (var c in s)
        i = c < 43 ? i * 2
          : c < 46 ? i + 44 - c
          : i >> 1;

    return i;
}

입력이 유효한 것으로 가정합니다. 정규 분할은 항상 0으로 반올림되고 비트 이동은 항상 반올림하기 때문에 2로 나누기는 1 비트 오른쪽으로 이동하여 수행됩니다. 증가 및 감소를위한 ASCII 코드의 한 거리의 편리한 사용을 +하고 -.

자바 스크립트 (ES6), 57 바이트 (배열) / 60 바이트 (정수)

모든 중간 결과의 배열을 반환합니다.

o=>[...o].map(c=>x=[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],x=0)

예를 들어에 대한 출력 "++**--/"은[1, 2, 4, 8, 7, 6, 3] .

최종 결과 만 반환 :

o=>[...o].reduce((x,c)=>[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],0)

작동 원리

두 솔루션은 동일한 아이디어에 기반을두고있다 : 완벽한 해시 함수를 사용하여 eval(2+c+3)&3다른 운전자 문자 매핑 c에를 [0, 3].

 operator | eval(2+c+3)  | eval(2+c+3)&3
----------+--------------+---------------
    +     |  2+3 = 5     |    5 & 3 = 1
    -     |  2-3 = -1    |   -1 & 3 = 3
    *     |  2*3 = 6     |    6 & 3 = 2
    /     |  2/3 ~= 0.67 | 0.67 & 3 = 0

자바 스크립트 (ES6), 57

a=>[...a].map(c=>a=c<'+'?a<<1:c<'-'?-~a:c<'/'?~-a:a>>1)|a

참고 : 누산기의 초기 값은 프로그램 문자열이며 비트 연산 (~, >>, <<, |)을 사용하여 처음 사용시 0으로 변환됩니다.

참고로 @xnor의 영리한 답변은 40 점을 자바 스크립트로 포팅했습니다.

a=>[...a].map(c=>a=eval(~~a+c+2))&&a>>1

(이것이 마음에 드시면 투표하십시오)

테스트

f=a=>[...a].map(c=>a=c<'+'?a<<1:c<'-'?-~a:c<'/'?~-a:a>>1)|a

function update() {
  O.textContent = f(I.value);
}

update()

<input value='++**--/' id=I oninput='update()'><pre id=O></pre>

자바, 77 바이트

int f(String s){return s.chars().reduce(0,(r,c)->c<43?r*2:c<46?r+44-c:r>>1);}

Java 8 스트림을 사용합니다.

GNU sed, 65 59 57 바이트

편집 : Toby Speight 의 의견 덕분에 2 바이트 단축

s/[+-]/1&/g
s/*/2&/g
s:/:d0>@2&:g
s/.*/dc -e"0[1-]s@&p"/e

운영:

sed -f simple_calculator.sed <<< "*///*-*+-+"

산출:

-1

sed스크립트의 입력 준비 dc후자의 입력 받아, 마지막에 쉘 호출을 역 폴란드어 표기법을 . 나누기에서 숫자가 음수 ( d0>)이면 [1-]레지스터에 저장된 감소 명령 @이 호출됩니다. 변환 예 : + - * /-> 1+ 1- 2* d0>@2/.

PHP, 75 바이트

이것은 수정 된 버전의 Jörg Hülsermann의 답변을 사용합니다.

eval(preg_replace('~.~','$s=($s\0(2-ord("\0")%11%3))|0;',$argv[1]));echo$s;

간단한 정규 표현식 ( ~.~)을 사용하여 문자열 대체에 크게 의존합니다 .

변수 $s는 각 문자에 대한 새로운 값으로 재 할당됩니다. 결국 결과를 출력합니다.

여기에서보십시오 :

if('\0' == "\0")
{
	$argv = Array($s = 0, prompt());
	function preg_replace($pattern, $replacement, $subject)
	{
		$regexp = new RegExp($pattern.replace(new RegExp('~', 'g'), ''), 'g');
		return $subject.replace($regexp, $replacement.split('\0').join('$&'));
	}
	
	function printf($string)
	{
		console.log($string);
	}
	
	function ord($chr)
	{
		return $chr.charCodeAt(0);
	}
}
else
{
    if(!isset($argv))
    {
        $argv = array('', '++*+');
    }
}

eval(preg_replace('~.~','$s=($s\0(2-ord("\0")%11%3))|0;',$argv[1]));printf($s);

또는 http://sandbox.onlinephpfunctions.com/code/7d2adc2a500268c011222d8d953d9b837f2312aa에서 시도 하십시오.

차이점 :

• 대신 echo$s에을 사용하고 sprintf($s)있습니다. 둘 다 숫자에 대해 동일한 동작을 수행합니다. 이것은 단지 테스트를위한 것이므로 괜찮습니다.
• 전달 된 인수가없는 경우 ++*+첫 번째 인수로 전달 된 것처럼 실행됩니다 5.

배치, 61 바이트

@set n=
@for %%a in (%*)do @set/an=n%%a2^&-2
@cmd/cset/an/2

@ xnor의 xcellent Python 답변의 번역.

파이크, 24 22 바이트

\*\}:\/\e:\+\h:\-\t:0E

여기 사용해보십시오!

또는 12 바이트 (비경쟁)

~:"ht}e".:0E

여기 사용해보십시오!

translate노드 추가 -기본적으로 여러 찾기 및 바꾸기

~:           -   "+-*/"
        .:   -  input.translate(^, V)
  "ht}e"     -   "ht}e"
          0E - eval(^, stack=0)

PHP, 104 (102) 82 바이트

eval이 포함 된 첫 번째 버전 :

$i=0;while($c<9999)eval('$i'.['+'=>'++','-'=>'--','*'=>'*=2','/'=>'>>=1'][$argv[1]{$c++}].';');echo$i;

삼항 연산자가있는 두 번째 버전 :

while($o=ord($argv[1]{$c++}))$i=$o<43?$i*2:($o<44?$i+1:($o<46?$i-1:$i>>1));echo$i;

명령 행에서 입력 문자열을 첫 번째 인수로 사용합니다.

이 "만"은 10,000 자보다 짧은 입력 문자열에 효과적입니다. 안타깝게도 모든 테스트 사례로 테스트했지만 처음에는 초기화를 저장할 수 없습니다.두 번째 버전은 모든 길이의 문자열과 초기화없이 작동합니다. :-)

주요 요소는 $i산술 연산 맵을 기반으로 조작하는 eval 함수이며 , 나누기를 제외하고는 매우 간단합니다. 사용하는 경우 PHP는 float를 반환 /하고 intdiv우리가 할 수 있도록, 너무 많은 바이트를하다 오른쪽 변화를 .

업데이트

1. 정수 나누기 로 단축 $i=$i>>1하여 2 바이트를 절약했습니다 $i>>=1.
2. 삼항 연산자에 찬성하여 평가를 계산하십시오.

파이썬 3, 98 66 60 바이트

감사합니다 Tukkax!

다른 답변만큼 골프는 아니지만 표절 없이는 경쟁 할 수 없습니다.

i=0
for c in input():i+=[1,-i//2,-1,i][ord(c)%23%4]
print(i)

또한 재귀 람다 솔루션도 있습니다.

73 67 바이트 (개선!)

s=lambda x,z=0:s(x[1:],z+[1,-z//2,-1,z][ord(x[0])%23%4])if x else z

R, 201 바이트

골프

p=.Primitive;"-"="+"=function(x)p("+")(x,1);body(`-`)[[1]]=p("-");"*"="/"=function(x)p("*")(x,2);body(`/`)[[1]]=p("%/%");Reduce(function(f, ...)f(...),rev(mget(strsplit(scan(stdin(),""),"")[[1]])),0,T)

댓글

p = .Primitive                       # Redefine
"-" = "+" = function(x)p("+")(x,1)   # Define - and +
body(`-`)[[1]] = p("-")              # Change the body, what we do to save a byte
"*" = "/" = function(x)p("*")(x,2)   # Same as above
body(`/`)[[1]] = p("%/%")            # Same as above
Reduce(function(f, ...)f(...),       # Function wrapper to evaluate list of func.  
  rev(mget(strsplit(scan(stdin(),""),"")[[1]])), # Strsplit input into list of functions
  init = 0,                                      # Starting Arg = 1
  right = T)                                     # Right to left = True 

전략은 +, -, %운영자 를 개선하는 것 입니다. 문자열을 분할 한 다음 문자열을 긴 함수 목록으로 구문 분석하여 Reduce()'s누적 기에 공급 합니다.

더 이상 골프를 칠 수 없었습니다. 누군가 b=body<-가 일할 수 있다면 몇 바이트가 절약 될 수 있습니다 (모든 기능을 bafter로 재정의하십시오 "-"="+"="/"="*"). 처음에는 평가를 대체하고 구문 분석하려고 시도했지만 연산 순서와 괄호는 무서웠습니다.

Lex + C, 78 , 74 , 73 바이트

첫 번째 문자는 공백입니다.

 c;F(){yylex(c=0);return c;}
%%
\+ c++;
- c--;
\* c*=2;
\/ c=floor(c/2.);

에서 읽고 stdin결과를 반환합니다.

로 컴파일하고 lex golfed.l && cc lex.yy.c main.c -lm -lfl메인 테스트를 수행하십시오.

int main() { printf("%d\n", F()); }

자바 스크립트 (ES5), 127 바이트

function(b){for(a=c=0;a<b.length;++a)switch(b[a]){case"+":++c;break;case"-":--c;break;case"*":c*=2;break;case"/":c/=2}return c}

언 골프 드 :

function c(a){
  c=0;
  for(var i=0;i<a.length;++i){
    switch(a[i]){
      case "+":++c;break;
      case "-":--c;break;
      case "*":c*=2;break;
      case "/":c/=2;break;
    }
  }
  return c;
}

Pyth, 23 바이트

FNQ=Z.v%".&%sZ2_2"N;/Z2

문자열로 입력을 받아 결과를 인쇄하는 전체 프로그램입니다.

이것은 @xnor의 Python answer 포트입니다 .

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

작동 원리

FNQ=Z.v%".&%sZ2_2"N;/Z2   Program. Input: Q. Z initialised as 0
FNQ                       For. For N in Q:
        ".&%sZ2_2"         String. Literal string ".&%sZ2_2"
       %          N        String format. Replace %s with the current operator N
           %sZ2            Operator. Yield Z*2, Z//2, Z+2, Z-2 as appropriate
         .&    _2          Bitwise and. Result of above & -2
     .v                    Evaluate. Yield the result of the expression
   =Z                      Assignment. Assign result of above to Z
                   ;      End. End for loop
                    /Z2   Integer division. Yield Z//2
                          Print. Print the above implicitly 

PHP, 79 바이트

<?$i=0;switch($_POST['a']){case"+":$i+1;case"-":$i-1;case"/":$i/2;case"*":$i*2}