Menerapkan kalkulator skrip operasi operasi integer sederhana.

Konsep

Akumulator dimulai pada 0 dan operasi dilakukan di atasnya. Pada akhir program mengeluarkan nilai akumulator.

Operasi:

• +menambah 1akumulator
• -kurangi 1dari akumulator
• * mengalikan akumulator dengan 2
• / membagi akumulator dengan 2

Contoh skrip

Input ++**--/harus memberikan output 3.

Contoh implementasi

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

Aturan

• Ini adalah kode-golf , jadi jawaban terendah dalam byte menang, tetapi tidak dipilih.
• Implementasi kreatif didorong.
• Celah standar dilarang.
• Anda mendapatkan program melalui stdin atau argumen, dan Anda dapat menampilkan jawabannya melalui nilai balik atau stdout.
• Selamat bersenang-senang.
• Divisi terpotong karena itu adalah divisi integer.
• Program -/kembali -1.

Uji kasus

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

Python 2, 48 byte

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

Apakah +2, -2, *2, atau /2. Dengan melakukan +2dan -2bukannya +1dan -1, kami bekerja dalam unit yang berlipat ganda, sehingga hasil akhir perlu dibelah dua. Kecuali, divisi lantai /sekarang perlu dibulatkan ke kelipatan 2, yang dilakukan dengan &-2.

Haskell, 51 byte

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

Contoh penggunaan: foldl(#)0 $ "++**--/"-> 3.

Jelly , 18 17 byte

‘

’

:2
Ḥ
O0;ṛĿ/

Cobalah online!

Bagaimana itu bekerja

Enam baris pertama mendefinisikan tautan pembantu dengan indeks mulai dari 1 hingga 6 ; mereka menambah, tidak melakukan apa-apa, mengurangi, tidak melakukan apa pun, membagi dua (lantai), dan ganda.

Tautan utama - O0;ṛĿ/- mengonversi karakter input ke titik kode mereka ( O), menambahkan 0 (nilai awal) ke larik poin kode 0;, lalu mengurangi larik yang dihasilkan sebagai berikut.

Nilai awal adalah elemen pertama dari array, yaitu 0 yang diawali . Quicklink ṛĿdipanggil untuk setiap elemen berikut dalam array, dengan nilai pengembalian terakhir sebagai argumen kiri dan elemen saat ini sebagai yang benar. Ia memeriksa argumen yang benar ( ṛ) dan mengevaluasi tautan dengan indeks itu secara monadik ( Ŀ), sehingga menerapkan operasi yang diinginkan.

Python 2, 54 byte

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

Input diambil sebagai string literal. ~ord(c)%5%3memetakan operator ke operan kanan yang sesuai.

Sebelumnya, saya menggunakan hash(c)%55%3yang tidak menghasilkan hasil yang konsisten antara berbagai versi Python. Ini mendorong saya untuk menjelajahi formula lain.

SILOS , 133 211 byte

: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

Mengambil kode operator ASCII.

Cobalah online dengan test case:
-/
++**--/
*///*-*+-+

Mesin Turing - 23 negara (684 bytes)

Coba di sini - 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

Input tidak boleh mengandung '*' karena ini adalah karakter khusus dalam kode mesin Turing. Gunakan 'x' sebagai gantinya. Keluarkan jawabannya dalam biner.

Kode tidak terobosan

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

Penjelasan negara:

Inisialisasi:
Status ini dikunjungi sekali pada awal setiap proses, dimulai dengan init2

• init2: Pindahkan semua jalan ke kanan dan beri tanda '.'. Dengan begitu TM tahu kapan harus berhenti. Ubah ke 'init0'.
• init0: Pindahkan semua bagian belakang ke kiri sampai kepala membaca spasi. Kemudian pindahkan satu sel ke kiri. Ubah ke 'init1'.
• init1: Letakkan nol dan gerakkan satu sel ke kanan dan ubah menjadi 'readop'.

Instruksi membaca:
Status ini akan dikunjungi beberapa kali di seluruh program

• readop: Bergerak terus ke kanan sampai membaca operator atau '.' Jika menyentuh operator, ubah ke status yang sesuai (+, -, x, /). Jika menyentuh '.', Ubah ke status 'sirip'.

• return: Mengembalikan head ke ruang kosong antara total yang berjalan dan operator. Kemudian ubah ke 'readop'.

Operasi: Operasi
ini melakukan pekerjaan kotor yang sebenarnya

• +: Pindah ke kiri sampai kepala membaca karakter non-spasi putih. Jika karakter ini adalah '-', pindah ke kiri dan ubah ke 'dec'. Jika tidak, ubah ke 'inc'.

• -: Mirip dengan '+', kecuali ubah ke 'inc' jika ada '-' dan 'dec' sebaliknya.

• inc: Jika digit di bawah kepala adalah 0 (atau spasi), ubah ke 1 dan ubah ke 'nol'. Jika digit adalah 1, ubah ke 0, lalu ulangi digit berikutnya.

• dec: Mirip dengan inc, kecuali 1 menuju 0, 0 pergi ke 1, dan jika kepala membaca spasi, ubah ke 'neg'.

• x, x0, x1: Bitshift nomor satu ke kiri. Ubah ke 'kembali'.

• /, //, div, div0, div1: Pindahkan semua jalan ke kanan nomor, lalu bithift satu ke kanan. Jika ada '-', ubah ke 'inc'. Ini mensimulasikan pembulatan angka negatif. Kalau tidak, ubah ke 'nol'

• neg: Tempatkan '-' setelah nomor kemudian ubah ke 'readop'

• nol, nol1, nol2: Hapus nol di depan dan ubah ke 'readop'

Pembersihan: Membuat output rapi

• sirip, min: Pindahkan tanda '-' di depan nomor jika perlu. Berhenti.

Perl 6 , 53  52 byte

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

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

Penjelasan:

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

Pemakaian:

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 byte

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

Wandbox

05AB1E , 20 byte

Terima kasih kepada Enigma untuk memperbaiki -/-bug!

Untuk 16 byte jika bukan bilangan bulat divisi: Î"+-*/""><·;"‡.V.

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

Penjelasan:

Î                      # 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

Menggunakan pengkodean CP-1252 . Cobalah online!

JavaScript ES6, 80 68 byte

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

Menyimpan 12 byte kekalahan berkat Neil!

Ruby, 48 44 42 + 1 = 43 byte

+1 byte untuk -nbendera. Mengambil input pada STDIN.

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

Lihat di ideone (digunakan $_karena ideone tidak mengambil bendera baris perintah): http://ideone.com/3udQ3H

PHP 76 Bytes

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

Python 2, 58 56 byte

-2 byte terima kasih kepada @Lynn

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

Ordinals karakter +-*/yang 43,45,42,47modulo 11 ini 10,1,9,3modulo 3 yaitu 1,1,0,0, 2 kurang orang yang 1,1,2,2memberikan sebesar yang kita butuhkan untuk setiap operasi: r=r+1, r=r-1, r=r*2, danr=r/2

Sebelumnya:

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

Mathematica, 83 73 70 byte

^{10 byte disimpan karena @MartinEnder .}

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

Fungsi anonim. Mengambil daftar karakter sebagai input dan mengembalikan nomor sebagai output. Saran bermain golf diterima.

SILOS , 175 164 byte

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

Cobalah online!

Metode input sehat. Divisi integer yang benar (bulat menuju -infinity).

C #, 87 81 byte

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

Tidak Terkumpul:

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

Input dianggap valid. Pembagian dengan dua dilakukan dengan menggeser ke kanan sedikit, karena pembagian teratur selalu membulatkan ke arah nol, dan menggeser ke bawah selalu membulatkan ke bawah. Penambahan dan penurunan memanfaatkan dengan mudah jarak 1 antara kode ASCII untuk +dan -.

Javascript (ES6), 57 byte (array) / 60 byte (integer)

Mengembalikan array dari semua hasil antara:

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

Misalnya, output untuk "++**--/"akan[1, 2, 4, 8, 7, 6, 3] .

Hanya mengembalikan hasil akhir:

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

Bagaimana itu bekerja

Kedua solusi didasarkan pada ide yang sama: menggunakan fungsi hash sempurna eval(2+c+3)&3untuk memetakan berbagai karakter operator cdi [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

Catatan: nilai awal untuk akumulator adalah string program, menggunakan operasi bit (~, >>, <<, |) itu dikonversi ke 0 pada penggunaan pertama.

Sebagai catatan tambahan, jawaban cerdas @xnor akan mencetak 40 porting ke javascript:

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

(jika Anda suka ini, pilih dia)

Uji

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 byte

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

Menggunakan aliran java 8.

GNU sed, 65 59 57 byte

Sunting: 2 byte lebih pendek berkat komentar Toby Speight

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

Menjalankan:

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

Keluaran:

-1

The sedScript mempersiapkan masukan untuk dcpanggilan shell di akhir, yang terakhir menerima masukan dalam notasi Reverse Polandia . Di divisi, jika nomornya negatif ( d0>), [1-]perintah decrement yang disimpan dalam register @dipanggil. Contoh konversi: + - * /-> 1+ 1- 2* d0>@2/.

PHP, 75 byte

Ini menggunakan versi modifikasi dari jawaban Jörg Hülsermann .

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

Ini sangat bergantung pada substitusi string, menggunakan ekspresi reguler sederhana ( ~.~).

Variabel $sditugaskan kembali dengan nilai baru untuk setiap karakter. Pada akhirnya, ini menghasilkan hasilnya.

Coba di sini:

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

Atau coba: http://sandbox.onlinephpfunctions.com/code/7d2adc2a500268c011222d8d953d9b837f2312aa

Perbedaan:

• Dari pada echo$s , saya menggunakan sprintf($s). Keduanya melakukan tindakan yang sama pada angka. Karena ini hanya untuk pengujian, tidak apa-apa.
• Jika tidak ada argumen yang lulus, argumen itu akan berjalan seolah-olah Anda lulus ++*+sebagai argumen pertama, yang akan ditampilkan 5.

Batch, 61 byte

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

Terjemahan dari jawaban xcellent Python @ xnor

Pyke, 24 22 byte

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

Coba di sini!

Atau 12 byte (tidak kompetitif)

~:"ht}e".:0E

Coba di sini!

Tambahkan translatesimpul - pada dasarnya beberapa temukan dan ganti.

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

PHP, 104 102 82 byte

Versi pertama dengan eval:

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

Versi kedua dengan operator ternary:

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

Mengambil string input sebagai argumen pertama dari baris perintah.

Ini "hanya" bekerja untuk string input lebih pendek dari 10.000 karakter - yang seharusnya banyak. Diuji dengan semua kasus uji, sayangnya tidak dapat menghemat inisialisasi di awal.Versi kedua berfungsi dengan string dengan panjang berapa pun dan tanpa inisialisasi. :-)

Elemen utama adalah fungsi eval yang memanipulasi $iberdasarkan peta operasi aritmatika, yang cukup mudah kecuali untuk divisi. PHP mengembalikan float saat menggunakan /dan intdivterlalu banyak byte, jadi kami melakukan pergeseran kanan .

Pembaruan

1. Disimpan 2 byte dengan menyingkat $i=$i>>1menjadi $i>>=1untuk pembagian integer.
2. Membuang eval demi operator ternary.

Python 3, 98 66 60 byte

Terima kasih Tukkax!

Bukan sebagai golf seperti jawaban yang lain, tetapi saya tidak dapat bersaing dengan mereka tanpa plagiarisme.

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

Juga, saya punya solusi lambda rekursif juga

73 67 byte (ditingkatkan!)

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 byte

Golf

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)

Berkomentar

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 

Strategi adalah untuk memperbaiki +, -, %operator. Pisahkan string kemudian parsing string ke dalam daftar fungsi yang panjang, untuk dimasukkan ke dalamReduce()'s akumulator.

Tidak bisa bermain golf lagi. Jika seseorang dapat mulai b=body<-bekerja, mungkin ada beberapa byte penghematan (sempurnakan setiap fungsi dengan bsetelah "-"="+"="/"="*"). Awalnya mencoba untuk mengganti dan mengurai eval, tetapi urutan operasi dan tanda kurung sangat mengerikan.

Lex + C, 78 , 74 , 73 byte

Karakter pertama adalah spasi.

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

Membaca dari stdin, mengembalikan hasil.

Kompilasi dengan lex golfed.l && cc lex.yy.c main.c -lm -lfl, main test:

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

Javascript (ES5), 127 byte

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}

Tidak Terkumpul:

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 byte

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

Program lengkap yang mengambil input sebagai string dan mencetak hasilnya.

Ini adalah port jawaban Python @ xnor .

Cobalah online

Bagaimana itu bekerja

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 byte

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