1 से n तक सभी पूर्णांकों का योग


63

मुझे ईमानदारी से आश्चर्य है कि यह पहले से ही नहीं किया गया है। यदि आप एक मौजूदा धागा पा सकते हैं, तो हर तरह से इसे डुप्लिकेट के रूप में चिह्नित करें या मुझे बताएं।

इनपुट

आपका इनपुट 1 से अधिक या उसके बराबर किसी भी सकारात्मक पूर्णांक के रूप में है।

उत्पादन

आपको 1 और संख्या इनपुट के बीच और सभी पूर्णांकों का योग आउटपुट करना होगा।

उदाहरण

 In: 5
     1+2+3+4+5 = 15
Out: 15

OEIS A000217 - त्रिकोणीय संख्या: a (n) = द्विपद (n + 1,2) = n (n + 1) / 2 = 0 + 1 + 2 + ... + n।

लीडरबोर्ड

इस प्रश्न के उत्तर के लिए लीडरबोर्ड देखने के लिए नीचे दिए गए कोड स्निपेट को चलाएँ। (इस सुझाव के लिए programmer5000 और steenbergh के लिए धन्यवाद, और मार्टिन एंडर इसे बनाने के लिए।)



@FryAmTheEggman क्षमा करें - वहाँ एक मस्तिष्क गोज़ का एक सा था। मुझे पता है तुम्हारा क्या मतलब है।
गारेथपॉ जूल 18'17

2
@Aaron आपको निंजासाइड मिल गया हस्क द्वारा, जिसे सिर्फ 1 बाइट समाधान के साथ पोस्ट किया गया था
स्किड्सदेव

7
मैं एक ढेर स्निपेट का सुझाव देता हूं।
प्रोग्रामर

जवाबों:


46

अजगर , 2 बाइट्स

sS

इसे ऑनलाइन आज़माएं! निहित इनपुट। S1-अनुक्रमित सीमा है, और sराशि है।


102
अंत में, Pyth (on) कोड एक सांप की तरह लगता है।
आलिशान

2
यह पायथ के लिए एकदम सही चुनौती है ...
श्री एक्सकोडर

मैं इसका जवाब देने जा रहा था, लेकिन मुझे लगता है कि नहीं
स्टेन स्ट्रम

32

भूसी , 1 बाइट

Σ

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

अंतर्निहित! Σभूसी में आमतौर पर एक सूची के सभी तत्वों का योग प्राप्त करने के लिए उपयोग किया जाता है, लेकिन जब किसी संख्या पर लागू किया जाता है तो यह बिल्कुल वापस आ जाता है n*(n+1)/2


1
जिज्ञासा से बाहर, यह होता है क्योंकि संख्या एक सीमा तक डाली जाती है और फिर सारांशित होती है, या यह वास्तव में हार्डकोड है?
फ्राईमईएग्गमैन

4
@FryAmTheEggman यह वास्तव में हार्डकोड है, और एक अन्य बिलिन, comp के व्यवहार के समान है, जो किसी सूची के सभी तत्वों के उत्पाद या एक ही संख्या के भाज्य की गणना कर सकता है
लियो

4
Σमेरी मशीन पर एक दो बाइट यूनिकोड वर्ण है। मुझे लगता है कि आप कोड पृष्ठ 1253 का उपयोग करते हैं? msdn.microsoft.com/en-us/library/cc195055.aspx
gmatht


21

पीट , 161 बाइट्स / 16 codels

आप इसे इस पीट दुभाषिया के साथ व्याख्या कर सकते हैं या इस वेबसाइट पर छवि अपलोड कर सकते हैं और इसे वहां चला सकते हैं। बाइट गिनती के बारे में निश्चित नहीं है, अगर मैं इसे आकार को कम करने के लिए अलग-अलग सांकेतिक शब्दों में बदल सकता हूं।

स्रोत छवि का स्केल्ड संस्करण:

rapapaing छवि

व्याख्या

highlightedपाठ, वर्तमान ढेर (बाएं से सही करने के लिए बढ़ रहा है) से पता चलता संभालने उपयोगकर्ता इनपुट है 5:

1 संक्रमण एक नंबर इनपुट करें और इसे स्टैक पर धक्का दें

5

2 संक्रमण स्टैक पर इस नंबर को डुप्लिकेट करें

5 5

तीसरा संक्रमण स्टैक पर 1 (गहरे लाल क्षेत्र का आकार) पुश करें

5 5 1

4 संक्रमण शीर्ष दो नंबर जोड़ें

5 6

5 वाँ संक्रमण शीर्ष दो संख्याओं को गुणा करें

30

6 वाँ संक्रमण काला क्षेत्र सुनिश्चित करता है, कि कर्सर हल्के हरे रंग के कोडेल के ठीक नीचे चला जाता है। यह संक्रमण स्टैक पर 2 (गहरे हरे रंग का आकार) को धक्का देता है

30 2

7 वां संक्रमण पहले नंबर पर स्टैक पर दूसरे नंबर को विभाजित करें

15

8 वाँ संक्रमण पॉप और आउटपुट शीर्ष नंबर (संख्या के रूप में व्याख्या की गई)

[empty]

अंतिम जाल एक सफेद क्षेत्र डालने से, संक्रमण एक होता है nop, काला हमारे कर्सर को फंसा देता है। यह कार्यक्रम के निष्पादन को समाप्त करता है।

मूल फ़ाइल (यहाँ के लिए बहुत छोटी है): मूल स्रोत छवि


हमने एक समझदार पाठ (जैसे सी) से अचिंतनीय पाठ (जैसे जेली) को छवियों में बदल दिया ... आगे क्या? : P
frarugi87

+1 मैं वास्तव में एक विवरण के साथ एक पीट जवाब पहले देखा है
MilkyWay90

21

ब्रेन-फ्लैक , 16 बाइट्स

({({}[()])()}{})

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

यह उन कुछ चीजों में से एक है जो ब्रेन-फ्लैक वास्तव में अच्छा है।

चूंकि यह सबसे सरल चीजों में से एक है जिसे आप मस्तिष्क-फ्लैक में कर सकते हैं और इसमें बहुत अधिक दृश्यता है, यहां एक विस्तृत विवरण दिया गया है:

# Push the sum of all of this code. In brain-flak, every snippet also returns a
# value, and all values inside the same brackets are summed
(
    # Loop and accumulate. Initially, this snippet return 0, but each time the
    # loop runs, the value of the code inside the loop is added to the result.
    {
        # Push (and also return)...
        (
            # The value on top of the stack
            {}

            # Plus the negative of...
            [
                # 1
                ()
            ]

        # The previous code pushes n-1 on to the stack and returns the value n-1
        )

        # 1
        # This code has no side effect, it just returns the value 1 each loop.
        # This effectively adds 1 to the accumulator
        ()

    # The loop will end once the value on top of the stack is 0
    }

    # Pop the zero off, which will also add 0 to the current value
    {}

# After the sum is pushed, the entire stack (which only contains the sum)
# will be implicitly printed.
)


18

गणितज्ञ, 9 बाइट्स

#(#+1)/2&

गणितज्ञ, 10 बाइट्स

(#^2+#)/2&

गणितज्ञ, 11 बाइट्स

Tr@Range@#&

गणितज्ञ, 12 बाइट्स

i~Sum~{i,#}&

गणितज्ञ, 14 बाइट्स

(@ user71546 द्वारा)

1/2/Beta[#,2]&

मैथेमेटिका, 15 बाइट्स

Tr[#&~Array~#]&

गणितज्ञ, 16 बाइट्स

Binomial[#+1,2]&

गणितज्ञ, १ Mat बाइट्स

(@ बाय ए ट्री)

⌊(2#+1)^2/8⌋&

गणितज्ञ, 18 बाइट्स

PolygonalNumber@#&

मैथेमेटिका, 19 बाइट्स

#+#2&~Fold~Range@#&

गणितज्ञ, 20 बाइट्स

(@ बाय ए ट्री)

f@0=0;f@i_:=i+f[i-1]

4
यह 13, 14 और 17 को छोड़ना शर्म की बात है ...
पेड़

3
यह अगली चुनौती की तरह लगता है .... या कम से कम मुझे सूची को पूरा करने में मदद करें।
J42161217

2
मेरे पास अभी भी 13 या 14 बाइट्स के लिए कुछ भी नहीं है (सिर्फ अपने छोटे उत्तरों को अन-गोल्फिंग के अलावा), लेकिन यहां बड़े बाइट-काउंट्स के साथ एक और 26 हैं
एक पेड़ नहीं

1
@निशान। 10.4 पर ठीक काम करता है
J42161217

1
: अपनी सूची के लिए @Notatree, यहाँ 35 के लिए एक उम्मीदवार है Array[Boole[#2>=#]और ,{#,#}]~Total~2और
मार्क एस

17

जावास्क्रिप्ट (ईएस 6), 10 बाइट्स

n=>n*++n/2

उदाहरण


2
n*-~n/2यह भी काम करता है, लेकिन केवल के लिएn < 2**31
पैट्रिक रॉबर्ट्स

11

x86_64 मशीन भाषा (लिनक्स), 9 8 बाइट्स

0:   8d 47 01                lea    0x1(%rdi),%eax
3:   f7 ef                   imul   %edi
5:   d1 e8                   shr    %eax
7:   c3                      retq 

इसे ऑनलाइन करने का प्रयास करें! निम्नलिखित C प्रोग्राम संकलित करें और चलाएं।

#include<stdio.h>
const char f[]="\x8d\x47\x01\xf7\xef\xd1\xe8\xc3";
int main(){
  for( int i = 1; i<=10; i++ ) {
    printf( "%d %d\n", i, ((int(*)())f)(i) );
  }
}

@CodyGray और @Peter को -1 के लिए धन्यवाद ।


1
आपको अपने आउटपुट को अहस्ताक्षरित (कोड आकार में कोई परिवर्तन नहीं) के रूप में उपयोग shrकरने के बजाय संभवतः उपयोग करना चाहिए sar। (@CodyGray द्वारा देखा गया और अपने 7-बाइट add+ loopउत्तर में बताया गया है )।
पीटर कॉर्डेस

1
यह बंद-फॉर्मूला के कार्यान्वयन में प्रदर्शन के लिए इष्टतम दिखता है, लेकिन आप 3-बी-ऑपरेंड फॉर्म के बजाय एक-ऑपरेंड फॉर्म mul %ediया imul %edi(प्रत्येक 2 बी) का उपयोग करके एक बाइट बचा सकते हैं । यह उच्च-आधे परिणाम के साथ EDX को देखता है, लेकिन यह ठीक है। मल्टी-ऑपरेंड imulको बाद में वन-ऑपरेंड फॉर्म की तुलना में पेश किया गया था, और इसमें एक बाइट के साथ 2-बाइट ऑपकोड होता है 0F। तीन विकल्पों में से कोई भी हमेशा एक ही परिणाम का उत्पादन करेगा eax, यह केवल उच्च आधा है जो हस्ताक्षरित बनाम अहस्ताक्षरित पर निर्भर करता है।
पीटर कॉर्डेस




10

ऑक्टेव , 22 19 बाइट्स

क्योंकि अंकगणितीय ऑपरेशन उबाऊ हैं ...

@(n)nnz(triu(e(n)))

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

व्याख्या

यह देखते हुए n, यह संख्या ई के बराबर सभी प्रविष्टियों के साथ एक n× nमैट्रिक्स बनाता है ; विकर्ण शून्य के नीचे प्रविष्टियां बनाता है; और नॉनज़रो मानों की संख्या को आउटपुट करता है।


क्या यह वास्तव में संख्यात्मक संस्करण से छोटा है?
फल

@ चैलेंजर 5 नहीं, लेकिन संख्यात्मक संस्करण उबाऊ है:@(n)sum(1:n)
लुइस मेंडो


8

जेली , 2 बाइट्स

RS

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

व्याख्या

RS

    implicit input
 S  sum of the...
R   inclusive range [1..input]
    implicit output

गॉस योग, 3 बाइट्स

‘×H

व्याख्या

‘×H

     implicit input
  H  half of the quantity of...
‘    input + 1...
 ×   times input
     implicit output

यह Anyfix में भी काम करता है: P (TIO पर नहीं)
HyperNeutrino

8

एपीएल, 3 बाइट्स

+/⍳

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

+/- राशि (कम +), - सीमा।


यह अनुक्रमण पर निर्भर करता है। यदि अनुक्रमण 0 पर सेट है, तो आपको 1+
वर्नर

2
@Werner अनुक्रमण डिफ़ॉल्ट है, 1इसलिए मैंने निर्दिष्ट नहीं किया। इसका उपयोग करने पर केवल इसका उल्लेख करना सामान्य है ⎕IO←0(और यह बाइट काउंट में शामिल नहीं है)
उरियल

8

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

यह सबसे छोटा है (मुझे लगता है कि विचार):

f n=sum[1..n]

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

प्रत्यक्ष, 17 13 बाइट्स

f n=n*(n+1)/2

धन्यवाद -4बाइट्स के लिए @WheatWizard !

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

पॉइंटफ्री डायरेक्ट, 15 बाइट्स

(*)=<<(/2).(+1)

विचार के लिए धन्यवाद @nimi!

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

पॉइंटफ्री थ्रू sum, 16 बाइट्स

sum.enumFromTo 1

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

पुनरावर्ती, 22 18 बाइट्स

f 0=0;f n=n+f(n-1)

इस विचार के लिए @maple_shaft और इसे गोल्फ के लिए @Laikoni धन्यवाद!

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

स्टैंडर्ड fold, 19 बाइट्स

f n=foldr(+)0[1..n]

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


7

तारों से , 27 22 बाइट्स

5 बाइट्स @ धन्यवाद के लिए बच गए !

, + +  **       +   *.

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

व्याख्या

,             Read number (n) from STDIN and push it to the stack
 +            Duplicate top of the stack
 +            Duplicate top of the stack
  *           Pop two numbers and push their product (n*n)
*             Pop two numbers and push their sum (n+n*n)
       +      Push 2
   *          Pop two numbers and push their division ((n+n*n)/2)
.             Pop a number and print it to STDOUT


@ मीलों धन्यवाद! बहुत अच्छा विचार!
लुइस मेन्डो

7

05AB1E , 2 बाइट्स

LO

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

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

     #input enters stack implicitly
L    #pop a, push list [1 .. a]
 O   #sum of the list
     #implicit output 

गॉस योग, 4 बाइट्स

>¹*;

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

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

>       #input + 1
 ¹*     #get original input & multiply
   ;    #divide by two 

3
ÝOकाम भी करता है और साधन भी hello
मैजिक ऑक्टोपस Urn

1
L0 और निहारना ..
dylnan

7

जावा (ओपनजेडके 8) , 10 बाइट्स

a->a++*a/2

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

एक पल के लिए नीचे गोल्फ से लिया n->n*(n+1)/2धीमा कारण ।

लेकिन यह असली जावा उत्तर नहीं है। यह निश्चित रूप से पर्याप्त नहीं है।

import java.util.stream.*;
a->IntStream.range(1,a+1).sum()

बुरा नहीं है, लेकिन हम बेहतर कर सकते हैं।

import java.util.stream.*;
(Integer a)->Stream.iterate(1,(Integer b)->Math.incrementExact(b)).limit(a).reduce(0,Integer::sum)

मुझे जावा बहुत पसंद है।


1
यदि आप चाहते हैं कि यह और भी अधिक हो, तो लैंबडा का उपयोग क्यों करें !? : पी
थेथलकोडर

2
मैं वर्बोज़ लैम्बदास के लिए लक्ष्य कर रहा था, मैं एक पूरा कार्यक्रम लिख सकता था अगर मैं विशेष रूप से वाक्पटु होना चाहता था: P
Xanderhall

1
ठीक उसी तरह का समाधान पहले से ही पोस्ट किया गया था
शीतकालीन

2
मैंने इसे याद किया होगा, लेकिन किसी भी मामले में, मैं अन्य उत्तरों की सामग्री को नहीं देखना चाहता हूं। मैं अपना खुद का गोल्फ लिखना पसंद करता हूं।
Xanderhall

7

जाँच करें , 5 बाइट्स

:)*$p

जाँच भी एक गोल्फ भाषा नहीं है, फिर भी यह CJam धड़कता है!

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

स्पष्टीकरण:

इनपुट नंबर को स्टैक पर रखा गया है। :इसे देने के लिए डुप्लिकेट करता है n, n। यह तो )देने के साथ बढ़ा हुआ है n, n+1*दोनों को एक साथ गुणा करता है, और फिर $परिणाम को 2 से विभाजित करता है। परिणाम को pप्रिंट करता है और कार्यक्रम समाप्त हो जाता है।



6

टैक्सी , 687 बाइट्स

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l 2 r.[a]Pickup a passenger going to Addition Alley.Pickup a passenger going to The Underground.Go to Zoom Zoom:n.Go to Addition Alley:w 1 l 1 r.Pickup a passenger going to Addition Alley.Go to The Underground:n 1 r 1 r.Switch to plan "z" if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 3 l 2 l.Switch to plan "a".[z]Go to Addition Alley:n 3 l 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:n 1 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.

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

टिप्पणियों के साथ गैर-गोल्फ:

[ n = STDIN ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left 2nd right.

[ for (i=n;i>1;i--) { T+=i } ]
[a]
Pickup a passenger going to Addition Alley.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north.
Go to Addition Alley: west 1st left 1st right.
Pickup a passenger going to Addition Alley.
Go to The Underground: north 1st right 1st right.
Switch to plan "z" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 3rd left 2nd left.
Switch to plan "a".

[ print(T) ]
[z]
Go to Addition Alley: north 3rd left 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: north 1st right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.

यह लूप की तुलना में 22.6% कम बाइट्स है x*(x+1)/2



5

ब्रेनफक, 24 बाइट्स।

I / O को बाइट्स के रूप में संभाला जाता है।

,[[->+>+<<]>[-<+>]<-]>>.

व्याख्या की

,[[->+>+<<]>[-<+>]<-]>>.
,                           # Read a byte from STDIN
 [                  ]       # Main loop, counting down all values from n to 1
  [->+>+<<]                 # Copy the i value to *i+1 and *i+2
           >[-<+>]          # Move *i+1 back to i
                  <-        # Move back to i, lower it by one. Because *i+2 is never reset, each iteration adds the value of i to it.
                     >>.    # Output the value of *i+2

2
यह बहुत अच्छा है कि ब्रेनफक इस चुनौती में कुछ उच्च-स्तरीय भाषाओं को हरा सकता है।
गारेथपीडब्ल्यू

क्या मेरे लिए अपने कोड का उपयोग करके Lengage (सिर्फ मनोरंजन के लिए) में एक उत्तर जोड़ना वैध है? @ATaco
वी।

मुझे ऐसा नहीं लगता, क्योंकि यह एक ही कोड होगा, बस अलग-अलग एन्कोडेड। @ वी। कर्टोइस
एताको

@ATaco आह तुम सही हो।
वी। कोर्टोइस

5

,,,, 6 बाइट्स

:1+×2÷

व्याख्या

:1+×2÷

:       ### duplicate
 1+     ### add 1
   ×    ### multiply
    2÷  ### divide by 2

अगर मैं जल्द ही किसी भी समय सीमा लागू करता हूं ...


4

रेटिना , 13 बाइट्स

.+
$*
1
$`1
1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: पहला और अंतिम चरण केवल एक ⇔ दशमलव रूपांतरण हैं। मध्य चरण प्रत्येक को उसके बायें से दूसरे 1भाग की संख्या के साथ प्रतिस्थापित करता है, इस प्रकार से गिना जाता है , मानों को संक्षेप में समेटता है।1111n


4

> <> , 7 + 3 = 10 बाइट्स

N (n + 1) / 2 की गणना करता है । -V ध्वज के
लिए 3 बाइट्स जोड़े गए

:1+2,*n

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

या यदि इनपुट को एक वर्ण कोड के रूप में लिया जा सकता है:

> <> , 9 बाइट्स

i:1+2,*n;

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


2
अन्य गणित-दृष्टिकोण ( (n^2+n)/2) का उपयोग करना भी 7 बाइट्स हैं:::*+2,n
स्टेनबर्घ


4

PHP, 19 बाइट्स

<?=$argn*-~$argn/2;
<?=$argn/2*++$argn;
<?=$argn*++$argn/2; # this one fails

बिल्डरों का उपयोग करते हुए, 29 बाइट्स:

<?=array_sum(range(1,$argn));

लूप, 31 बाइट्स:

while($argn)$s+=$argn--;echo$s;

मैं इसके लिए भी अनुमान लगाता हूं:for(;$argn;$s+=$argn--);echo$s;
प्रोग्रॉक

4

क्यूबिक्स , 12 10 बाइट्स

*,)2I://O@

प्रारंभिक संस्करण

....I:)*2,O@

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

व्याख्या

क्यूब पर विस्तारित, कोड इस तरह दिखता है:

    * ,
    ) 2
I : / / O @ . .
. . . . . . . .
    . .
    . .

निर्देश पॉइंटर (आईपी) Iपूर्व की ओर बढ़ते हुए शुरू होता है । यह /दर्पण के पार आने तक पूर्व की ओर बढ़ता रहता है , जो इसे उत्तर की ओर दर्शाता है। जब आईपी कोड के शीर्ष पर पहुंच जाता है, तो यह .दक्षिण की ओर चलते हुए, तीसरी पंक्ति के अंतिम छोर पर घूमता है। फिर यह .उत्तर की ओर बढ़ते हुए अंतिम रेखा पर स्थित है। फिर यह फिर से /दर्पण तक पहुंचता है , जो इसे पूर्व में दर्शाता है, केवल अगले /के लिए इसे फिर से उत्तर में प्रतिबिंबित करता है। इस बार, आईपी .तीसरी पंक्ति पर और फिर .अंतिम पंक्ति पर अंतिम छोर तक जाता है।

निर्देशों को निम्नलिखित क्रम में निष्पादित किया जाता है।

I:)*2,O@ # Explanation
I        # Take input as an integer and push it to the stack
 :       # Duplicate the input
  )      # Increment one of the inputs
   *     # Multiply the input by input+1
    2    # Push 2 to the stack
     ,   # Integer devide the multiplication result by 2
      O  # Output the result
       @ # End program

4

x86-64 मशीन कोड, 7 बाइट्स

31 C0
01 C8
E2 FC
C3  

उपरोक्त बाइट्स एक फ़ंक्शन को परिभाषित करता है जो एकल पैरामीटर को स्वीकार करता है n, और 1 से सभी पूर्णांकों का योग वाला मान लौटाता हैn

यह Microsoft x64 कॉलिंग कन्वेंशन के लिए लिखा गया है , जो ECXरजिस्टर में पैरामीटर पास करता है । रिटर्न मान को EAXसभी x86 / x86-64 कॉलिंग कन्वेंशन की तरह छोड़ दिया जाता है ।

असेंबली असेंबली mnemonics:

       xor  eax, eax    ; zero out EAX
Next:  add  eax, ecx    ; add ECX to EAX
       loop Next        ; decrement ECX by 1, and loop as long as ECX != 0
       ret              ; return, with result in EAX

इसे ऑनलाइन आज़माएं!
(C फ़ंक्शन कॉल में एक विशेषता के साथ एनोटेट किया गया है जो GCC को Microsoft कॉलिंग कन्वेंशन का उपयोग करके कॉल करने का कारण है जो कि एक असेंबली कोड का उपयोग करता है। यदि TIO ने MSVC प्रदान किया था, तो यह आवश्यक नहीं होगा।)


कोड गोल्फ के असामान्य मानकों द्वारा, आप देखते हैं कि यह पुनरावृत्ति लूपिंग दृष्टिकोण उन दृष्टिकोणों के लिए बेहतर है, जो अधिक समझदार गणितीय सूत्र ( n(n+1) / 2) का उपयोग करते हैं , भले ही यह रन-टाइम गति के संदर्भ में स्पष्ट रूप से कम कुशल हो।

संख्या सिद्धांत का उपयोग करते हुए, सीलिंगकैट के कार्यान्वयन को अभी भी एक बाइट द्वारा हराया जा सकता है। इन निर्देशों में से प्रत्येक आवश्यक हैं, लेकिन एक गंतव्य ऑपरेटर के रूप में अंतर्निहितIMUL उपयोग के लिए थोड़ी कम एन्कोडिंग है (वास्तव में, यह उपयोग करता हैEAX EDX:EAX , लेकिन हम परिणाम के ऊपरी 32 बिट्स को अनदेखा कर सकते हैं)। यह केवल 2 बाइट्स को सांकेतिक शब्दों में बदलना है, 3 से नीचे है।

LEAसाथ ही तीन बाइट्स लेता है, लेकिन वास्तव में इसके आसपास कोई रास्ता नहीं है क्योंकि हमें मूल मूल्य को संरक्षित करते हुए वेतन वृद्धि की आवश्यकता है । यदि हमने MOVएक प्रतिलिपि बनाने के लिए किया , तो INC, हम 4 बाइट्स पर होंगे। (X86-32 में, जहां INCकेवल 1 बाइट है, हम उसी 3 बाइट्स पर होंगे LEA।)

अंतिम राइट-शिफ्ट परिणाम को आधे में विभाजित करने के लिए आवश्यक है, और निश्चित रूप से गुणा से अधिक कॉम्पैक्ट (और अधिक कुशल) है। हालाँकि, कोड को वास्तव में shrइसके बजाय उपयोग करना चाहिएsar , क्योंकि यह मान रहा है कि इनपुट मान, nएक अहस्ताक्षरित पूर्णांक है। (यह धारणा नियमानुसार मान्य है, लेकिन यदि आप जानते हैं कि इनपुट निरस्त है, तो आपको एक हस्ताक्षरित अंकगणितीय बदलाव नहीं करना चाहिए, क्योंकि ऊपरी बिट को एक बड़े अहस्ताक्षरित मान में सेट किया जा सकता है) गलत होना।)

8D 41 01                lea    eax, [rcx+1]
F7 E9                   imul   ecx
D1 E8                   shr    eax, 1
C3                      ret

अब केवल 8 बाइट्स (पीटर कॉर्ड्स के लिए धन्यवाद)। फिर भी, 8> 7।


1
वास्तव में, वन-ऑपरेंड imul ecxया mul ecxकाम करेगा और बंद फॉर्म के कार्यान्वयन में एक बाइट को बचाएगा। मुझे वह ठीक नहीं लगा; मैं यह टिप्पणी करने वाला था कि यह अनुमान लगाने से पहले कि प्रदर्शन और कोड-आकार दोनों के लिए यह इष्टतम था कि एक अंतर्निहित eaxऑपरेंड ठीक था।
पीटर कॉर्डेस

मैंने सोचा तो नहीं add अन्य उत्तर को देखते हुए + loopसे छोटा होगा imul। हैंडी एक मानक बुला परंपरा है कि में पहली आर्ग गुजरता है किecx
पीटर Cordes

1
वाह, मैं विश्वास नहीं कर सकता कि मैं एक-ऑपरेंड फॉर्म से चूक गया! मुझे वास्तव में अब तक पता होना चाहिए कि "बीट नहीं किया जा सकता है" जैसी बातें। मैं कब सीखूंगा ?! धन्यवाद, @ पेटर।
कॉडी ग्रे
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.