Basit bir tamsayı işlemi komut dosyası hesap makinesi uygulayın.

kavram

Akümülatör 0'da başlar ve üzerinde gerçekleştirilen işlemlere sahiptir. Programın sonunda akümülatörün değeri çıktı.

Operasyonlar:

• +1akümülatöre ekler
• -1akümülatörden çıkarır
• * akümülatörü çarparak 2
• / akümülatörü böler 2

Örnek komut dosyası

Giriş ++**--/, çıkışı vermelidir 3.

Örnek uygulama

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

kurallar

• Bu kod golf , yani bayt cinsinden en düşük cevap kazanır, ancak seçilmez.
• Yaratıcı uygulamalar teşvik edilir.
• Standart boşluklar yasaktır.
• Programı stdin veya argümanlarla alırsınız ve cevabı return değeri veya stdout ile çıkartabilirsiniz.
• İyi eğlenceler.
• Bölme tamsayı bölmeli olduğu için kısalır.
• Program -/geri döner -1.

Test durumları

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

Python 2,48 bayt

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

Mu +2, -2, *2, veya /2. Yaparak +2ve -2yerine +1ve -1iki kat birim halinde çalışıyoruz, bu yüzden son çıktının yarıya inmesi gerekiyor. Bunun dışında, kat bölümünün /şimdi yapılan 2 katına inmesi gerekiyor &-2.

Haskell, 51 bayt

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

Kullanım örneği: foldl(#)0 $ "++**--/"-> 3.

Jöle , 18 17 bayt

‘

’

:2
Ḥ
O0;ṛĿ/

Çevrimiçi deneyin!

Nasıl çalışır

İlk altı satır, 1 ile 6 arasında değişen endekslere sahip yardımcı bağlantıları tanımlar ; arttırırlar, hiçbir şey yapmazlar, azaltırlar, hiçbir şey yapmazlar, yarıya indirirler (döşeme) ve çiftler.

Ana link - O0;ṛĿ/- giriş karakterlerini kod noktalarına dönüştürür ( O), kod noktaları dizisine bir 0 (başlangıç ​​değeri) hazırlar 0;, ardından üretilen diziyi aşağıdaki gibi azaltır.

İlk değer, dizinin ilk öğesidir, yani önceden hazırlanmış 0'dır . Quicklink ṛĿ, dizideki her bir sonraki eleman için, son argüman olarak sol argüman ve mevcut eleman sağ olan olarak çağrılır. Doğru argümanını ( ṛ) inceler ve bu endeks ile bağlantıyı monadik olarak ( Ŀ) değerlendirir, böylece istenen işlemi uygular.

Python 2, 54 bayt

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

Girdi, değişmez bir dize olarak alındı. ~ord(c)%5%3İşleçleri ilgili sağ işleçlerle eşleştirir.

Daha önce, hash(c)%55%3farklı Python sürümleri arasında tutarlı sonuçlar vermeyen bir ürün kullandım . Bu beni diğer formülleri keşfetmeye teşvik etti.

SILOS , 133 211 bayt

: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 operatör kodlarını alır.

Test durumlarıyla çevrimiçi olarak deneyin:
-/
++**--/
*///*-*+-+

Turing Makinesi - 23 eyalet (684 bayt)

Burada deneyin - kalıcı

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 makine kodunda özel bir karakter olduğundan, giriş '*' içermemelidir. Bunun yerine 'x' kullanın. Yanıtı ikili olarak çıkarır.

Bağlantısız Kod

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

Devletlerin açıklaması:

Başlatma:
Bu durumlar, init2 ile başlayan, her koşunun başında bir kez ziyaret edilir.

• init2: Tamamen sağa hareket et ve bir '.' koy. Bu şekilde TM ne zaman duracağını bilir. 'İnit0' olarak değiştirin.
• init0: Kafa bir boşluk okuyana kadar arkaya doğru sola hareket ettirin. Sonra bir hücre sola taşıyın. 'İnit1' olarak değiştirin.
• init1: Bir sıfır koyun ve bir hücreyi sağa hareket ettirin ve 'readop' olarak değiştirin.

Talimatları okuma:
Bu durumlar program boyunca birçok kez ziyaret edilecektir.

• readop: Bir operatör veya '.' okuyana kadar sağa doğru hareket eder. Bir operatöre çarparsa, ilgili duruma geçin (+, -, x, /). Bir '.' İsabet ederse, 'fin' durumuna geçin.

• return: Başı çalışan toplam ile operatörler arasındaki boş alana döndürür. Sonra 'readop' olarak değişir.

İşlemler:
Bu işlemler gerçek kirli işleri yapıyor

• +: Kafa boşluksuz bir karakter okuyana kadar sola hareket et. Bu karakter '-' ise, sola git ve 'dec' olarak değiştir. Aksi takdirde, 'inc' olarak değiştirin.

• -: '+' ile benzer şekilde, '-' ve 'dec' varsa, 'inc' olarak değiştirilmedikçe.

• inc: Başlığın altındaki rakam 0 (veya boşluk) ise, 1 olarak değiştirin ve 'sıfır' olarak değiştirin. Rakam 1 ise, 0 olarak değiştirin, ardından bir sonraki rakama tekrarlayın.

• dec: Inc'e benzer şekilde, 1, 0'a giderken, 0, 1'e gider ve kafa bir boşluk bırakırsa, 'neg' olarak değiştirin.

• x, x0, x1: Bir numara sola kaydırın. 'Return' olarak değiştirin.

• /, //, div, div0, div1: Numaranın sağına sonuna kadar kaydırın, sonra bir sağa doğru bit. '-' varsa, 'inc' olarak değiştirin. Bu, negatif sayıları yuvarlamayı simüle eder. Aksi takdirde 'sıfır' olarak değiştirin

• neg: Rakamdan sonra '-' koyun ve 'readop' olarak değiştirin

• zero, zero1, zero2: Baştaki sıfırları kaldırın ve 'readop' olarak değiştirin

Temizleme: Çıktıyı hassas hale getirir

• fin, min: Gerekirse '-' i sayının önüne getirin. Dur.

Perl 6 , 53  52 bayt

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

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

Açıklama:

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

Kullanımı:

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 bayt

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

Wandbox

05AB1E , 20 bayt

-Bug'u tamir ettiği için Enigma'ya teşekkürler -/!

O bölünme tamsayı değilse 16 için bayt: Î"+-*/""><·;"‡.V.

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

Açıklama:

Î                      # 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 kodlamasını kullanır . Çevrimiçi deneyin!

JavaScript ES6, 80 68 bayt

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

Neil sayesinde bir kuyruklu 12 bayt kurtardı!

Ruby, 48 44 42 + 1 = 43 bayt

-nBayrak için +1 bayt . STDIN'de girişi ele alır.

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

Bunu ideone üzerinde görün ( $_ideone komut satırı bayraklarını almadığından kullanır ): http://ideone.com/3udQ3H

PHP 76 Bayt

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

Python 2, 58 56 bayt

@Lynn sayesinde -2 bayt

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

Karakter sıra sayıları +-*/olan 43,45,42,47bunlar modülo 11 10,1,9,3modülo olanlardır 3 1,1,0,0, 2 daha az olanlar vardır 1,1,2,2her operasyon için ihtiyaç miktarları vererek: r=r+1, r=r-1, r=r*2, ver=r/2

Önceki:

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

Mathematica, 83 73 70 bayt

^{@MartinEnder nedeniyle 10 bayt kaydedildi .}

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

Anonim işlev Girdi olarak bir karakter listesi alır ve çıktı olarak bir sayı döndürür. Golf önerileri kabul edilir.

SILOS , 175 164 bayt

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

Çevrimiçi deneyin!

Sane giriş yöntemi. Doğru tamsayı bölümü (sonsuzluğa doğru yuvarlak).

C #, 87 81 bayt

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

Ungolfed:

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

Girişin geçerli olduğu kabul edilir. İkiye bölme bir bit sağa kaydırılarak yapılır, çünkü düzenli bölme her zaman sıfıra doğru yuvarlanır ve bit kayma her zaman aşağı yuvarlanır. Artırma ve eksiltme için ASCII kodları arasında 1 mesafenin kullanışlı faydalanmak +ve -.

Javascript (ES6), 57 bayt (dizi) / 60 bayt (tam sayı)

Tüm ara sonuçların bir dizisini döndürmek:

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

Örneğin, çıktı "++**--/"olacaktır [1, 2, 4, 8, 7, 6, 3].

Sadece nihai sonucu döndürerek:

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

Nasıl çalışır

Her iki çözüm de aynı fikre dayanır: Mükemmel karma işlevi kullanılarak eval(2+c+3)&3farklı operatör karakterleri eşleştirmek için cde [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

Not: akümülatörün başlangıç ​​değeri, bit işlemlerini kullanan program dizesidir (~, >>, <<, |) ilk kullanımda 0'a dönüştürülür.

Bir not olarak, @xnor'ın zekice cevabı javascript ile gösterilen 40 puanı alacaktır:

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

(Eğer böyle olursa, ona oy verin)

Ölçek

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 bayt

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

Java 8 akışını kullanır.

GNU sed, 65 59 57 bayt

Düzenleme: Toby Speight sayesinde 2 bayt daha kısa yorumları

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

Koşmak:

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

Çıktı:

-1

sedKomut için girdi hazırlar dcikincisi de giriş kabul edilebilir, sonunda kabuk çağrısı Ters Polonya gösterimde . Bölme işleminde, sayı negatif ( d0>) ise, [1-]kayıt defterinde saklanan azaltma komutu @çağrılır. Dönüşüm örneği: + - * /-> 1+ 1- 2* d0>@2/.

PHP, 75 bayt

Bu Jörg Hülsermann'ın cevabının değiştirilmiş bir versiyonunu kullanır .

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

Basit bir düzenli ifade ( ~.~) kullanarak dize yerine çok güvenir .

Değişken $s, her karakter için yeni bir değerle tekrar atanır. Sonunda sonucu verir.

Burada dene:

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

Veya deneyin: http://sandbox.onlinephpfunctions.com/code/7d2adc2a500268c011222d8d953d9b837f2312aa

farklılıklar:

• Yerine echo$s kullanıyorum sprintf($s). Her ikisi de rakamlar üzerinde aynı işlemi yapar. Bu sadece test amaçlı olduğu için sorun değil.
• Başarılı bir argüman yoksa ++*+, göstermesi gereken ilk argüman olarak geçtiniz gibi çalışır 5.

Batch, 61 bytes

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

Translation of @xnor's xcellent Python answer.

Pyke, 24 22 bytes

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

Try it here!

Or 12 bytes (noncompetitive)

~:"ht}e".:0E

Try it here!

Add translate node - basically multiple find and replace.

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

PHP, 104 102 82 bytes

First version with eval:

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

Second version with ternary operators:

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

Takes the input string as first argument from the command line.

This "only" works for input strings shorter than 10,000 characters - which should be plenty. Tested with all the test cases, unfortunately can't save on the initialization in the beginning. Second version works with strings of any length and without initialization. :-)

The main element is the eval function which manipulates $i based on a map of arithmetic operations, which are pretty straightforward except for the division. PHP returns a float when using / and intdiv is too many bytes, so we do a right-shift.

Updates

1. Saved 2 bytes by shortening $i=$i>>1 to $i>>=1 for integer division.
2. Threw out eval in favor of ternary operators.

Python 3, 98 66 60 bytes

Thanks Tukkax!

Not as golfy as the other answer, but I can't compete with them without plagiarism.

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

Also, I have a recursive lambda solution as well

73 67 bytes (improved!)

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 bytes

Golfed

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)

Commented

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 

Strategy is to refine the +, -, % operators. Split the string then parse the string into a long list of functions, to be fed into Reduce()'s accumulator.

Couldn't golf it anymore. If someone can get b=body<- to work, there could be a few bytes of savings (refine every function with b after "-"="+"="/"="*"). Initially tried to substitute and parse eval, but the order of operations and parentheses were terrifying.

Lex + C, 78, 74, 73 bytes

The first character is a space.

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

Reads from stdin, returns result.

Compile with lex golfed.l && cc lex.yy.c main.c -lm -lfl, test main:

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

Javascript (ES5), 127 bytes

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}

Ungolfed:

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 bytes

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

A full program that takes input as a string and prints the result.

This is a port of @xnor's Python answer.

Try it online

How it works

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 bytes

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