ใช้เครื่องคิดเลขแบบสคริปต์การดำเนินการจำนวนเต็มอย่างง่าย

แนวคิด

ตัวสะสมเริ่มต้นที่ 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 หรืออาร์กิวเมนต์และคุณสามารถส่งออกคำตอบผ่านค่าตอบแทนหรือ stdout
• มีความสุข.
• Division ตัดทอนลงเพราะเป็นส่วนจำนวนเต็ม
• โปรแกรม-/จะกลับ-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 ที่ได้รับการเติม Quicklink ṛĿถูกเรียกใช้สำหรับทุกองค์ประกอบต่อไปนี้ในอาเรย์โดยมีค่าส่งคืนล่าสุดเป็นอาร์กิวเมนต์ซ้ายและองค์ประกอบปัจจุบันเป็นค่าที่ถูกต้อง มันตรวจสอบข้อโต้แย้งที่ถูกต้อง ( ṛ) และประเมินการเชื่อมโยงกับดัชนีนั้น monadically ( Ŀ) จึงใช้การดำเนินการที่ต้องการ

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 เวอร์ชันต่างๆ สิ่งนี้สนับสนุนให้ฉันสำรวจสูตรอื่น

SILOS , 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, /) หากมันกระทบกับ '.' ให้เปลี่ยนเป็น 'ครีบ'

• return: ส่งคืนหัวไปยังพื้นที่ว่างระหว่างผลรวมสะสมและตัวดำเนินการ จากนั้นเปลี่ยนเป็น 'readop'

การดำเนินงาน:
การดำเนินการเหล่านี้ทำงานสกปรกจริง

• +: เลื่อนไปทางซ้ายจนกระทั่งหัวอ่านอักขระที่ไม่ใช่ช่องว่าง หากตัวละครนี้เป็น '-' ให้เลื่อนไปทางซ้ายแล้วเปลี่ยนเป็น 'ธันวาคม' มิฉะนั้นเปลี่ยนเป็น 'inc'

• -: คล้ายกับ '+' ยกเว้นเปลี่ยนเป็น 'inc' หากมี '-' และ 'dec' เป็นอย่างอื่น

• inc: หากตัวเลขที่อยู่ใต้ส่วนหัวเป็น 0 (หรือช่องว่าง) ให้เปลี่ยนเป็น 1 และเปลี่ยนเป็น 'ศูนย์' หากตัวเลขเป็น 1 ให้เปลี่ยนเป็น 0 จากนั้นทำซ้ำกับตัวเลขถัดไป

• dec: คล้ายกับ inc ยกเว้น 1 ไปถึง 0, 0 ไปที่ 1 และถ้าหัวอ่านช่องว่างให้เปลี่ยนเป็น 'neg'

• x, x0, x1: เลื่อนบิตหมายเลขหนึ่งไปทางซ้าย เปลี่ยนเป็น 'return'

• /, //, div, div0, div1: เลื่อนไปจนสุดทางขวาของตัวเลขจากนั้นเลื่อนบิตหนึ่งไปทางขวา หากมี '-' ให้เปลี่ยนเป็น 'inc' นี่เป็นการจำลองการปัดเศษตัวเลขจำนวนลบ มิฉะนั้นเปลี่ยนเป็น 'ศูนย์'

• neg: วาง '-' หลังจำนวนแล้วเปลี่ยนเป็น 'readop'

• ศูนย์, ศูนย์ 1, ศูนย์ 2: ลบศูนย์นำหน้าและเปลี่ยนเป็น 'readop'

การล้างข้อมูล: ทำให้การแสดงผลเป็นไปได้

• ครีบ, นาที: เลื่อนปุ่ม '-' ไปข้างหน้าหมายเลขถ้าจำเป็น หยุด.

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

Wandbox

05AB1E , 20 ไบต์

ขอบคุณปริศนาสำหรับการแก้ไข-/-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 ไบต์ต้องขอบคุณ Neil!

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,02 น้อยเหล่านี้จะ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 ไบต์

^{10 ไบต์บันทึกไว้เนื่องจาก@MartinEnder}

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

ฟังก์ชั่นไม่ระบุชื่อ รับรายการอักขระเป็นอินพุตและส่งคืนตัวเลขเป็นเอาต์พุต ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ

SILOS , 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

ลองออนไลน์!

วิธีการป้อนข้อมูลที่มีสติ การหารจำนวนเต็มที่ถูกต้อง (ปัดไปทาง -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;}

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

การป้อนข้อมูลจะถือว่าถูกต้อง การหารด้วยสองทำได้โดยการเลื่อนไปทางขวาหนึ่งบิตเนื่องจากการหารปกติจะปัดเข้าหาศูนย์เสมอ เพิ่มขึ้นและลดลงทำให้การใช้งานที่มีประโยชน์ของ 1 ระยะห่างระหว่างรหัส ASCII สำหรับและ+-

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 ไบต์

แก้ไข:สั้นลง 2 ไบต์ขอบคุณความคิดเห็นของToby Speight

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ö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

การแปลคำตอบ xcellent Python ของ @ xnor

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;

รับสตริงอินพุตเป็นอาร์กิวเมนต์แรกจากบรรทัดรับคำสั่ง

"only" นี้ทำงานสำหรับสตริงอินพุตที่สั้นกว่า 10,000 ตัวอักษร - ซึ่งควรมีมากมาย ทดสอบกับทุกกรณีการทดสอบ แต่น่าเสียดายที่ไม่สามารถบันทึกในการเริ่มต้นในการเริ่มต้นรุ่นที่สองใช้งานได้กับสตริงที่มีความยาวไม่ จำกัด :-)

องค์ประกอบหลักคือฟังก์ชั่น eval ซึ่งจัดการ$iตามแผนที่ของการดำเนินการทางคณิตศาสตร์ซึ่งค่อนข้างตรงไปตรงมายกเว้นการแบ่ง PHP คืนค่าลอยตัวเมื่อใช้/และintdivมีจำนวนไบต์มากเกินไปดังนั้นเราจึงเปลี่ยนค่าไปทางขวาขวากะ

อัพเดท

1. บันทึก 2 ไบต์โดยย่อ$i=$i>>1เป็น$i>>=1สำหรับการหารจำนวนเต็ม
2. โยนออก eval ในความโปรดปรานของผู้ประกอบการที่ประกอบไปด้วย

Python 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<-ทำงานได้อาจมีการประหยัดสักสองสามไบต์ (ปรับแต่งทุกฟังก์ชั่นbหลังจากนั้น"-"="+"="/"="*") ในขั้นต้นพยายามที่จะทดแทนและแยกวิเคราะห์ eval แต่คำสั่งของการดำเนินงานและวงเล็บเป็นที่น่ากลัว

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

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}

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 ไบต์

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

โปรแกรมเต็มรูปแบบที่รับอินพุตเป็นสตริงและพิมพ์ผลลัพธ์

นี่เป็นพอร์ตของคำตอบ Pythonของ @ xnorคำตอบหลาม

ลองออนไลน์

มันทำงานอย่างไร

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}