实现一个简单的整数运算可编写脚本的计算器。

概念

累加器从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

规则

• 这是代码高尔夫球，因此以字节为单位的最低答案将获胜，但未选择。
• 鼓励创造性的实施。
• 禁止出现标准漏洞。
• 您可以通过stdin或参数获取程序，并可以通过返回值或stdout输出答案。
• 玩得开心。
• 因为是整数除法，所以除法被截断了。
• 程序-/返回-1。

测试用例

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

Python 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。

Haskell，51个字节

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

用法示例：foldl(#)0 $ "++**--/"-> 3。

果冻，18 17 字节

‘

’

:2
Ḥ
O0;ṛĿ/

在线尝试！

怎么运行的

前六行定义索引范围从1到6的辅助链接；它们增加，不做任何事情，减少，不做任何事情，减半（地板）和加倍。

主链接– O0;ṛĿ/将输入字符转换为它们的代码点（O），在代码点的数组前加上0（初始值）0;，然后按如下所示缩小生成的数组。

初始值是数组的第一个元素，即前置0。在快速链接ṛĿ被称为该数组中的每个元素之后，随着最后返回值作为左参数和当前元素为正确的。它检查其正确的参数（ṛ）并单价（Ŀ）评估与该索引的链接，从而应用所需的操作。

Python 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字节）

在这里尝试- 永久链接

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

输入内容不应包含任何“ *”，因为它是图灵机代码中的特殊字符。请改用“ 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：输入零，然后向右移动一个单元格，然后更改为“ readop”。

阅读说明：
在整个程序中，将多次访问这些状态

• readop：一直向右移动，直到它读取一个运算符或'。'。如果碰到了运算符，请更改为相应的状态（+，-，x，/）。如果命中“。”，则更改为“ fin”状态。

• return：将head返回到运行总计和运算符之间的空白区域。然后更改为“ readop”。

操作：
这些操作实际上是在做肮脏的工作

• +：向左移动，直到头部读取任何非空白字符。如果此字符为“-”，则向左移动并更改为“ dec”。否则，更改为“ inc”。

• -：类似于“ +”，但如果有“-”则更改为“ inc”，否则为“ dec”。

• inc：如果头部下方的数字为0（或空格），则将其更改为1并更改为“零”。如果数字是1，将其更改为0，然后在下一个数字上重复。

• dec：类似于inc，不同之处在于1变为0，0变为1，并且如果磁头读取空白，则更改为'neg'。

• x，x0，x1：将数字左移一位。更改为“返回”。

• /，//，div，div0，div1：一直移到数字的右边，然后再右移一位。如果有“-”，请更改为“ inc”。这模拟舍入负数。否则，请更改为“零”

• 取反：在数字后加上“-”，然后更改为“ readop”

• 零，零1，零2：删除前导零并更改为“ readop”

清理： 使输出可显示

• fin，min：如有必要，将'-'移到数字前面。停止。

Perl 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个字节

感谢Enigma修复-/-bug！

对于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编码。在线尝试！

的JavaScript ES6，80 68个字节

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

感谢尼尔，节省了多达12个字节！

Ruby，48 44 42 +1 = 43字节

+1字节的-n标志。在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;

Python 2，58 56字节

-2个字节，感谢@Lynn

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输入法。正确的整数除法（朝-infinity取整）。

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

假定输入有效。除以2的方法是将右移一位，因为规则除法总是四舍五入，而移位总是四舍五入。增量和减量使方便使用的ASCII码之间的距离1的+和-。

Javascript（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

JavaScript（ES6），57

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

注意：累加器的初始值是程序字符串，使用位操作（〜，>>，<<，| |），在初次使用时将其转换为0。

附带说明一下，@ xnor的聪明回答将得分40移植到javascript：

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>

Java，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在最后为shell调用准备输入，后者接受Reverse Polish表示法的输入。除法时，如果数字为负（d0>），则调用[1-]存储在寄存器中的减量命令@。转换示例：+ - * /-> 1+ 1- 2* d0>@2/。

PHP，75字节

这使用了JörgHü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答案的翻译。

Pyke，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个字符的输入字符串-应该足够了。经过所有测试用例的测试，不幸的是无法在一开始就保存初始化。第二个版本可以处理任何长度的字符串，而无需初始化。:-)

主要元素是eval函数，该函数$i基于算术运算图进行操作，除除运算外，该函数非常简单。PHP在使用时返回浮点数，/并且intdiv字节过多，因此我们进行了right-shift。

更新

1. 通过缩短保存2个字节$i=$i>>1来$i>>=1对整数除法。
2. 放弃评估以支持三元运算符。

Python 3、98 66 60字节

谢谢图卡克斯！

不像其他答案那样打高尔夫球，但如果没有窃，我无法与他们竞争。

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

另外，我也有一个递归的lambda解决方案

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 完善每个功能"-"="+"="/"="*"）。最初尝试替换和解析eval，但是运算和括号的顺序令人恐惧。

莱克斯+ 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()); }

Javascript（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答案的端口。

在线尝试

怎么运行的

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}