सरल पूर्णांक ऑपरेशन कैलकुलेटर

28

एक साधारण पूर्णांक ऑपरेशन स्क्रिप्ट योग्य कैलकुलेटर को लागू करें।

संकल्पना

संचायक 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

नियम

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे कम उत्तर है, लेकिन चयनित नहीं है।
  • रचनात्मक कार्यान्वयन को प्रोत्साहित किया जाता है।
  • मानक कमियां निषिद्ध हैं।
  • आप स्टड या तर्कों के माध्यम से कार्यक्रम प्राप्त करते हैं, और आप रिटर्न वैल्यू या स्टडआउट के माध्यम से उत्तर का उत्पादन कर सकते हैं।
  • मज़े करो।
  • विभाजन कम हो जाता है क्योंकि यह पूर्णांक विभाजन है।
  • कार्यक्रम -/लौटता है -1।

परीक्षण के मामलों

*///*-*+-+
-1
/*+/*+++/*///*/+-+//*+-+-/----*-*-+++*+**+/*--///+*-/+//*//-+++--++/-**--/+--/*-/+*//*+-*-*/*+*+/+*-
-17 
+++-+--/-*/---++/-+*-//+/++-*--+*+/*/*/++--++-+//++--*/***-*+++--+-*//-*/+*/+-*++**+--*/*//-*--**-/-*+**-/*-**/*+*-*/--+/+/+//-+*/---///+**////-*//+-+-/+--/**///*+//+++/+*++**++//**+**+-*/+/*/*++-/+**+--+*++++/-*-/*+--/++*/-++/-**++++/-/+/--*/-/+---**//*///-//*+-*----+//--/-/+*/-+++-+*-*+*+-/-//*-//+/*-+//+/+/*-/-/+//+**/-****/-**-//+/+-+/*-+*++*/-/++*/-//*--+*--/-+-+/+/**/-***+/-/++-++*+*-+*+*-+-//+/-++*+/*//*-+/+*/-+/-/*/-/-+*+**/*//*+/+---+*+++*+/+-**/-+-/+*---/-*+/-++*//*/-+-*+--**/-////*/--/*--//-**/*++*+/*+/-+/--**/*-+*+/+-*+*+--*///+-++/+//+*/-+/**--//*/+++/*+*////+-*-//--*+/*/-+**/*//+*+-//+--+*-+/-**-*/+//*+---*+//*/+**/*--/--+/*-*+*++--*+//+*+-++--+-*-*-+--**+/+*-/+*+-/---+-*+-+-/++/+*///*/*-+-*//-+-++/++/*/-++/**--+-////-//+/*//+**/*+-+/+/+///*+*///*-/+/*/-//-*-**//-/-+--+/-*--+-++**++//*--/*++--*-/-///-+/+//--+*//-**-/*-*/+*/-*-*//--++*//-*/++//+/-++-+-*/*-+++**-/-*++++**+-+++-+-***-+//+-/**-+/*+****-*+++*/-*-/***/-/*+/*****++*+/-/-**-+-*-*-++**/*+-/*-+*++-/+/-++*-/*-****-*
18773342
code-golf  math  number  arithmetic 
— dkudriavtsev
स्रोत
2
इसलिए ... यह पूर्ण रूप से पूर्णांक नहीं है, क्योंकि /गैर-पूर्णांक प्राप्त कर सकते हैं।
— कॉनर ओ'ब्रायन
2
फिर आपको इसे स्पष्ट रूप से निर्दिष्ट करना चाहिए।
— कॉनर ओ'ब्रायन
5
क्या -/लौटना चाहिए ?
— डेनिस
4
मैं मदद नहीं कर सकता, लेकिन ध्यान दें कि जंग-लैंग के मुख पृष्ठ पर दिखाए गए कोड का स्निपेट इस चुनौती को हल करता है।
— ज़ेवि
4
कृपया अधिक परीक्षण मामले जोड़ें।
— मार्टिन एंडर

जवाबों:

28

पायथन 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।

— XNOR
स्रोत
ये जबरदस्त है! आप इसे अपने आप को पोस्ट करना चाहते हैं इस का एक CJam बंदरगाह वर्तमान में प्रमुख चुनौती होगा: 0q{2\~-2&}/2/( 2\~evals दूसरे संकार्य के साथ ऑपरेटर 2, -2&बिटवाइज़, है और 2/है अंतिम विभाजन दो से। q{...}/इनपुट पर एक foreach है और 0सिर्फ प्रारंभिक है मूल्य।)
— मार्टिन एंडर
आप इसे पोस्ट कर सकते हैं, मैं सीजाम को नहीं जानता।
— xnor
वास्तव में चतुर! ES6 में
— पोर्ट किया गया
अजगर का शानदार उपयोग इससे कुछ नया सीखा।
— याकूब 365
12

हास्केल, 51 बाइट्स

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

प्रयोग उदाहरण: foldl(#)0 $ "++**--/"-> 3।

— nimi
स्रोत
12

जेली , 18 17 बाइट्स

‘

’

:2
Ḥ
O0;ṛĿ/

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

पहली छह लाइनें 1 से 6 तक के सूचकांकों के साथ सहायक लिंक को परिभाषित करती हैं ; वे वेतन वृद्धि करते हैं, कुछ नहीं करते हैं, वेतन वृद्धि करते हैं, कुछ नहीं करते हैं, आधा (फर्श), और डबल करते हैं।

मुख्य लिंक - O0;ṛĿ/- इनपुट वर्णों को उनके कोड पॉइंट्स ( O) में परिवर्तित करता है, कोड पॉइंट्स की सरणी के लिए एक 0 (प्रारंभिक मूल्य) प्रीपेन्ड करता है 0;, फिर उत्पन्न सरणी को निम्न प्रकार से घटाता है।

प्रारंभिक मान सरणी का पहला तत्व है, अर्थात, पूर्वनिर्मित 0 । क्विकलिंक ṛĿको सरणी में हर निम्नलिखित तत्व के लिए कहा जाता है, अंतिम रिटर्न मान के रूप में बाएं तर्क और वर्तमान तत्व को सही के रूप में। यह अपने सही तर्क ( ṛ) का निरीक्षण करता है और उस सूचकांक के साथ लिंक का मूल्यांकन करता है Ŀ।

— डेनिस
स्रोत
10
यह सबसे नई कहानियों के साथ जेली उत्तर की तरह दिखता है
— कॉनर ओ'ब्रायन
10

पायथन 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किया था जो पायथन के विभिन्न संस्करणों के बीच लगातार परिणाम नहीं देता था। इससे मुझे अन्य सूत्रों का पता लगाने के लिए प्रोत्साहित किया गया।

— xsot
स्रोत
काम करने के लिए प्रतीत नहीं होता है ...
— विनाशकारी नींबू
५५,३ और ६५,४, अजगर के डबल मॉड के लिए दो सबसे छोटे हैं २
— जोनाथन एलन
@DestructibleWatermelon मेरे लिए करता है: ideone
— जोनाथन एलन
मुझे लगता hashहै कि पायथन संस्करण विशिष्ट है - ideone 2.7.10 का उपयोग करता है जो [1, 1, 2, 2]चार मैपिंग के रूप में देता है , जबकि स्थानीय रूप से 2.7.12 पर मुझे मिलता है[2, 0, 1, 0]
— Sp3000
1
यह ideone पर काम करता है, लेकिन मेरे कंप्यूटर अजगर पर नहीं। संभवतः संस्करण निर्भर है, जिस स्थिति में संस्करण EDIT नोट किया जाना चाहिए: Ninja'd: /
— विनाशकारी नींबू
10

एसआईओएस , 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 कोड लेता है।

परीक्षण मामलों के साथ इसे ऑनलाइन आज़माएँ:
-/
++**--/
*///*-*+-+

— betseg
स्रोत
लोडलाइन गोल्फर है
— रोहन झुनझुनवाला
ओपी ने स्पष्ट किया; -1-/ लौटना चाहिए , न कि 0 ।
— डेनिस
@ डेनिस तय। हालांकि बहुत सारे बाइट्स जोड़े गए: /
— betseg
9

ट्यूरिंग मशीन - 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: सभी तरह से दाईं ओर ले जाएँ और 'डाल'। इस तरह टीएम को पता है कि कब रुकना है। 'Init0' में बदलें।
  • init0: जब तक सिर एक जगह नहीं पढ़ता, सभी को बाईं ओर ले जाएँ। फिर एक सेल को बाईं ओर ले जाएं। 'Init1' में बदलें।
  • init1: एक शून्य लगाएं और एक सेल को दाईं ओर ले जाएं और 'रीडॉप' में बदलें।

पढ़ने के निर्देश:
इन राज्यों में पूरे कार्यक्रम में कई बार जाया जाएगा

  • readop: किसी ऑपरेटर या '' को पढ़ने तक सभी तरह से दाईं ओर ले जाता है। यदि यह किसी ऑपरेटर से टकराता है, तो संबंधित स्थिति (+, -, x, /) में बदलें। यदि यह एक '' हिट करता है, तो राज्य को 'फिन' में बदलें।

  • वापसी: चल रहे कुल और ऑपरेटरों के बीच खाली जगह पर सिर लौटाता है। फिर op रीडॉप ’में बदल जाता है।

ऑपरेशन्स:
ये ऑपरेशन वास्तविक गंदे काम करते हैं

  • +: जब तक सिर किसी भी गैर-व्हाट्सएप चरित्र को नहीं पढ़ता, तब तक बाईं ओर ले जाएं। यदि यह वर्ण एक '-' है, तो बाएं घूमें और 'dec' में बदलें। अन्यथा, 'inc' में बदलें।

  • -: '+' के समान, अगर '' - 'और' डिक 'है, तो अन्यथा परिवर्तन के अलावा।

  • inc: यदि सिर के नीचे का अंक 0 (या व्हाट्सएप) है, तो इसे 1 में बदल दें और 'शून्य' में बदल दें। यदि अंक 1 है, तो इसे 0 में बदलें, फिर अगले अंक पर दोहराएं।

  • dec: inc के समान, सिवाय 1 को 0 में जाने के, 0 1 में जाता है, और यदि सिर एक व्हाट्सएप को पढ़ता है, तो 'नेगेटिव' में बदल जाता है।

  • x, x0, X1: नंबर एक को बाईं ओर Bitshift करें। 'वापसी' में बदलें।

  • /, //, div, div0, div1: सभी तरह से संख्या के दाईं ओर ले जाएं, फिर दाईं ओर एक बिट करें। यदि कोई '-' है, तो 'inc' में बदलें। यह नकारात्मक संख्याओं को कम करने में मदद करता है। अन्यथा, 'शून्य' में बदलें

  • नेग: नंबर के बाद '-' लगाएं और फिर 'रीडॉप' में बदल दें।

  • शून्य, शून्य 1, शून्य 2: अग्रणी शून्य निकालें और 'रीडॉप' में बदलें

क्लीनअप: आउटपुट प्रेजेंटेबल बनाता है

  • फिन, मिन: यदि आवश्यक हो तो संख्या के सामने '-' ले जाएं। हॉल्ट।
— KoreanwGlasses
स्रोत
1
सोचा इस कोड को पढ़कर बहुत अच्छा लगा। तो मेरे दिन को रोशन करने के लिए धन्यवाद।
— जैकब 365
8

पर्ल 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
— ब्रैड गिल्बर्ट b2gills
स्रोत
6

05AB1E , 20 बाइट्स

को ठीक करने के लिए पहेली के लिए धन्यवाद-/-बग !

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत
ओपी ने स्पष्ट किया; -1-/ लौटना चाहिए , न कि 0 ।
— डेनिस
Î…+-*"><·"‡'/"2÷":.Vएक ही बाइट की गिनती के लिए ऋणात्मक संख्या विभाजन मुद्दा तय किया जा सकता है ।
— एमिगा
@ डेनिस ने समस्या का समाधान किया।
— अदनान
@ ईमिगं थैंक्स :)
— अदनान
5

जावास्क्रिप्ट ईएस 6, 80 68 बाइट्स

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

नील को धन्यवाद देकर 12 बाइट्स बचाए!

— कोनोर ओ ब्रायन
स्रोत
दूसरा उत्तर अधिक पठनीय होगा यदि आप इसे "c"+"c+1 c-1 c*2 c/2|0".split
— नील
पहले उत्तर के लिए, क्यों नहीं लिखा है o=>c=[c+1,c-1,c*2,c/2|0]["+-*/".indexOf(o)], या मुझे लगता है कि आप आगे बाइट का उपयोग करके सहेज सकते हैं o=>c={"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}[o]।
— नील
k=>[...k].reduce((c,o)=>+{"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}[o],0)अभी भी कम काम कर सकते हैं, लेकिन मैं गिनती खो दिया है ...
— नील
@ नील आह, हां, मैं इस बारे में भूल गया
— कॉनर ओ'ब्रायन
1
आपको किसी तरह शून्य-चौड़ाई वाले अक्षरों के बीच में मिला }और [o]इसलिए, यह वास्तव में केवल 66 बाइट्स लंबा है। इसके अलावा, ओपी ने स्पष्ट किया; -1-/ लौटना चाहिए , न कि 0 ।
— डेनिस
5

रूबी, 48 44 42 + 1 = 43 बाइट्स

-nझंडे के लिए +1 बाइट । STDIN पर इनपुट लेता है।

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

इसे आइडोन पर देखें ( $_चूंकि आइडॉन कमांड लाइन के झंडे नहीं लेता है): http://ideone.com/3udQ3H

— जॉर्डन
स्रोत
4

पायथन 2, 58 56 बाइट्स

-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
— जोनाथन एलन
स्रोत
कैसे के बारे में 2-ord(c)%11%3?
— लिन
@ ठीक है, मैं इसे ले जाऊंगा अगर यह आपके साथ ठीक है? (लेकिन वास्तव में लगता है कि यह एक बदलाव है जिसे आप इसे पोस्ट कर सकते हैं)
— जोनाथन एलन
2
आगे बढ़ो :) ----
— लिन
4

मैथेमेटिका, 83 73 70 बाइट्स

@MartinEnder की वजह से 10 बाइट बच गईं ।

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

अनाम फ़ंक्शन। इनपुट के रूप में वर्णों की एक सूची लेता है और आउटपुट के रूप में एक नंबर देता है। गोल्फ सुझाव का स्वागत करते हैं।

— LegionMammal978
स्रोत
4

सी #, 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;
}

इनपुट मान्य माना जाता है। डिवीजन टू को राइट वन बिट में शिफ्ट करके किया जाता है, क्योंकि रेगुलर डिवीजन हमेशा जीरो की ओर राउंड करता है, और बिट शिफ्टिंग हमेशा राउंड डाउन होता है। वेतन वृद्धि और अवनति ASCII कोड +और के बीच की 1 दूरी का उपयोग करते हैं -।

— Scepheo
स्रोत
नई सी # 6 के लिए कुछ प्यार और Linq के कुल विधि? int f(string s)=>s.Aggregate(0,(i,c)=>c<43?i*2:c<46?i+44-c:i>>1);(६५ बाइट्स)
— सिरिल गैंडन
@CyrilGandon जहाँ तक मुझे पता है कि इसमें "System.Linq का उपयोग करना" शामिल होगा, इसे 19 लंबा बनाते हुए इसे 84 बाइट पर रखना होगा। यही वजह है कि मैंने ऐसा नहीं किया।
— Scepheo
4

जावास्क्रिप्ट (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
— Arnauld
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 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>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

जावा, 77 बाइट्स

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

जावा 8 धाराओं का उपयोग करता है।

— primodemus
स्रोत
1
अच्छा जवाब, और साइट पर आपका स्वागत है! मैं जावा के बारे में कुछ नहीं जानता, लेकिन क्या आप 2 बाइट्स r >> 1को बदल सकते हैं r>>1और बचा सकते हैं ?
— DJMcMayhem
आप बिल्कुल सही हैं, धन्यवाद @DJMcMayhem
— primodemus
1
बहुत बढ़िया, खुशी है कि मैं मदद कर सकता हूँ! एक और ध्यान दें, मैं 77 बाइट्स गिन रहा हूं। क्या आपने अपने बाइट की गिनती में न्यूलाइन शामिल करने के लिए ऐसा किया था? आप एक और बाइट ले सकते हैं क्योंकि यह आवश्यक नहीं है।
— DJMcMayhem
फिर से सही @DJMcMayhem, aparently wc null-termantinging बाइट या कुछ और ...
— primodemus
1
जैसा कि आप java8 का उपयोग कर रहे हैं, क्यों लंबोदा का उपयोग करके फ़ंक्शन को परिभाषित नहीं करते हैं, s->s.chars().reduce(0,(r,c)->c<43?r*2:c<46?r+44-c:r>>1);जो आपको 56 बाइट देगा
— user902383
3

GNU sed, 65 59 57 बाइट्स

संपादित करें: 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/।

— seshoumara
स्रोत
यदि कोई स्थान नहीं है, और [1-]पैटर्न से मेल खाने वाली कोई फ़ाइल नहीं है, तो आपको डीसी के तर्क के आसपास उद्धरणों की आवश्यकता नहीं है ...
— Toby Speight
@TobySpeight मेरे दिमाग में मैं के sसाथ अर्थ बदल गया S। मैं भूल गया कि यह रजिस्ट्री के स्टैक को प्रतिस्थापित नहीं करता है, यह उस पर धकेलता है, जो मैं चाहता था उसके विपरीत प्रभाव रहा (क्योंकि मैंने इसे हर के लिए इस्तेमाल किया था /)। उद्धरण अभी भी आवश्यक हैं क्योंकि आपके पास इसमें /प्रतीक हैं जो स्ट्रिंग को एक फ़ाइल पथ के रूप में व्याख्या करते हैं :) मैंने 1 बाइट को मुंडा किया उसके बाद के स्थान को हटाकर -e।
— शीशमारा ३०'१६
1
dc -eएक फ़ाइल नाम के रूप में तर्क को अचेत नहीं करेगा , इसलिए आपको इसके लिए उद्धरण की आवश्यकता नहीं है /- इसे आज़माएं! मुझे लगता है कि यह एक उचित है एक कोड गोल्फ की आवश्यकता के लिए के लिए है कि वर्तमान कार्यशील निर्देशिका के साथ शुरुआत किसी भी फाइल को शामिल नहीं 01s@या 0-s@।
— स्पाइट
@TobySpeight आप के बारे -eमें सही थे /, हालांकि उद्धरण अभी भी आवश्यक हैं जैसा कि मैंने अभी देखा। >:, एक रीडायरेक्ट ऑपरेटर मुझे लगता है कि के रूप में खोल द्वारा सीधे व्याख्या की है के बाद से मैं यह त्रुटि आईcannot create @2/d0: Directory nonexistent
— seshoumara
आह, हाँ, मैंने विचार नहीं किया >। आपको उद्धरण की आवश्यकता है, आखिर। के लिए क्षमा याचना (गुमराह करने का प्रयास)! और, हालांकि एक बैकस्लैश को जोड़ने से एक चरित्र की तरह दिखता है, इसे एक s///प्रतिस्थापन में दोगुना करने की आवश्यकता होती है , इसलिए वहां कोई लाभ नहीं ...
— Toby Speight
3

PHP, 75 बाइट्स

यह Jörg Hülsermann के उत्तर के संशोधित संस्करण का उपयोग करता है ।

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

यह एक सरल नियमित अभिव्यक्ति का उपयोग करके स्ट्रिंग प्रतिस्थापन पर बहुत निर्भर करता है (~.~ ) ।

चर $sको प्रत्येक वर्ण के लिए नए मान के साथ पुन: असाइन किया गया है। अंत में, यह परिणाम को आउटपुट करता है।

नोट : इसका अर्थ -rध्वज का उपयोग करके निष्पादित किया जाना है ।

इसे यहाँ आज़माएँ:

कोड स्निपेट दिखाएं

या पर प्रयास करें: http://sandbox.onlinephpfunctions.com/code/7d2adc2a500268c011222d8d953d9b837f2312aa

अंतर:

  • के बजाय echo$s , मैं उपयोग कर रहा हूं sprintf($s)। दोनों संख्याओं पर समान क्रिया करते हैं। चूंकि यह सिर्फ परीक्षण के लिए है, यह ठीक है।
  • यदि कोई तर्क वितर्क नहीं है, तो यह चलेगा जैसे कि आप ++*+पहले तर्क के रूप में उत्तीर्ण हुए हैं, जिसे दिखाना चाहिए 5।
— इस्माइल मिगुएल
स्रोत
वाह! eसंशोधक वापस आ गया है! : डी
— टाइटस
@ मुझे यह नहीं मिलता है। क्या आप थोड़ा विस्तार कर सकते हैं?
— इस्माईल मिगुएल
संस्करण 7 से पहले PHP में एक पैटर्न संशोधकe था, जिसे बदल दिया गया था preg_replace_callbackऔर इसका दुरुपयोग किया जा सकता था ... लेकिन यह काफी नहीं है।
— टाइटस
@ टिट्स उस पैटर मॉडिफायर का उपयोग यह बताने के लिए किया गया था कि आउटपुट वास्तविक PHP कोड होगा, और वाक्यविन्यास को सही रखने की कोशिश की जाएगी। यहाँ, इसका उपयोग नहीं करता है, लेकिन हर एक वर्ण को निष्पादित करने के लिए कोड के एक टुकड़े के साथ प्रतिस्थापित किया जाता है, चाहे वह वाक्य रचना ही क्यों न हो। खराब इनपुट सुरक्षा के गंभीर मुद्दों का कारण बनेंगे।
— इस्माइल मिगुएल
मुझे पता है। लेकिन यह जैसा दिखता है।
— टाइटस
2

बैच, 61 बाइट्स

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

@ Xnor के xcellent पायथन के उत्तर का अनुवाद।

— नील
स्रोत
2

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 बहुत सारे बाइट्स होते हैं, इसलिए हम एक राइट-शिफ्ट करते हैं ।

अपडेट

  1. छोटा करके 2 बाइट्स बचाए $i=$i>>1 को $i>>=1पूर्णांक विभाजन के लिए।
  2. टर्नरी ऑपरेटरों के पक्ष में निष्कासन फेंक दिया।
— YetiCGN
स्रोत
2

पायथन 3, 98 66 60 बाइट्स

धन्यवाद तुक्काक्स!

अन्य उत्तर के रूप में गोल्फ के रूप में नहीं है, लेकिन मैं साहित्यिक चोरी के बिना उनके साथ प्रतिस्पर्धा नहीं कर सकता।

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
— विनाशकारी नींबू
स्रोत
प्रक्रियात्मक संस्करण में अपने पुनरावर्ती समाधान के भाग को लागू करने से: 60 बाइट्स i=0 for c in input():i+=[1,-i//2,-1,i][ord(c)%23%4] print(i):। (निश्चित रूप से स्वरूपित नहीं)। इसके अलावा, मुझे लगता है कि आपको उल्लेख करना चाहिए कि आप पायथन 3 का उपयोग कर रहे हैं। Python2 में, input()का मूल्यांकन करेगा int(raw_input())।
— यति
@TuukkaX z = 0 ( +-1 करता है) के लिए काम नहीं करता
— विनाशकारी नींबू
अरे हां, मेरी गलती है।
— यति
1
कृपया Python3 शीर्षक जोड़ें।
— यति
2

आर, 201 बाइट्स

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)

टिप्पणी की गई

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बाद में हर फ़ंक्शन को परिष्कृत करें "-"="+"="/"="*")। प्रारंभ में स्थानापन्न और पार्स करने का प्रयास किया गया था, लेकिन संचालन और कोष्ठक का क्रम भयानक था।

— VLO
स्रोत
यह एक साल बाद है, लेकिन मैं 10 बाइट्स को अपने दृष्टिकोण को थोड़ा स्वैप करके नीचे लाने में कामयाब रहा - आप f, ...परिभाषा के बीच की जगह को हटाकर 8 बाइट्स छोड़ सकते हैंReduce फ़ंक्शन और छुटकारा पा सकते हैं stdin(), scanलेकिन मैंने सिर्फ एक भोले की कोशिश की दृष्टिकोण जो दो अलग-अलग बाइट को गिराकर कार्यों को थोड़ा अलग तरीके से परिभाषित करता है। tio.run/##XcvLCsMgEAXQrwnO6Gge29B/…
— Giuseppe
1

लेक्स + सी, 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()); }
— स्टेफानो सैनफिलिपो
स्रोत
1

जावास्क्रिप्ट (ईएस 5), 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;
}
— पॉल शमित्ज़
स्रोत
1

पायथ, 23 बाइट्स

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

एक पूर्ण कार्यक्रम जो एक स्ट्रिंग के रूप में इनपुट लेता है और परिणाम को प्रिंट करता है।

यह @ 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
— TheBikingViking
स्रोत
1
अजगर को अजगर में परिवर्तित करना ज्यादातर एक बुरा विचार है। u@[yGhG0tG0/G2)CHQ019 बाइट्स
— जेक्यूब
@ जाकुब धन्यवाद - मैं पायथ के लिए बहुत नया हूं, इसलिए किसी भी सलाह की सराहना की जाती है। एक अलग जवाब के रूप में पोस्ट करने के लिए स्वतंत्र महसूस करें, क्योंकि यह एक अलग दृष्टिकोण है।
— TheBikingViking
1

PHP, 79 बाइट्स

<?$i=0;switch($_POST['a']){case"+":$i+1;case"-":$i-1;case"/":$i/2;case"*":$i*2}
— विनी द पूह
स्रोत
2
अपने हेडर में बायटेकाउंट को शामिल करें, अनचाही जगहों को हटा दें और 1-अक्षर चर नामों का उपयोग करें।
— TuxCrafting
यह भी गोल्फ है ?! :-D
— यतिसीजीएन
@ T @xCräftîñg मैंने इसे किया।
— विन्नी द पूह
आप विभाजित करते हैं और गुणा करते हैं 1; आपको विभाजित करने और गुणा करने की आवश्यकता है2
— TuxCrafting
@ T @xCräftîñg मैंने इसे किया।
— विनी द पूह
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.