में मानक पर संख्या योग

32

प्रति पंक्ति एक पूर्णांक के साथ एक धारा / फ़ाइल पर विचार करें। उदाहरण के लिए:

123
5
99

आपके कोड को इन नंबरों के योग को आउटपुट करना चाहिए, जो कि है 227।

इनपुट प्रारूप सख्ती से प्रति पंक्ति एक पूर्णांक है। उदाहरण के लिए, आप यह मान सकते हैं कि इनपुट पूर्णांक के एक सरणी के रूप में एक पंक्ति में है।

आप फ़ाइल नाम, या अपनी पसंद के नाम वाली फ़ाइल के रूप में एसटीडीआईएन से इनपुट ले सकते हैं; आप कौन सा चुन सकते हैं। इनपुट प्राप्त करने के अन्य तरीकों की अनुमति नहीं है।

इनपुट में कम से कम एक पूर्णांक होगा। आप मान सकते हैं कि सभी पूर्णांक गैर-नकारात्मक हैं और उनकी कुल राशि से कम है ।232

code-golf  string  arithmetic 
— डेनिस
स्रोत
2
वहाँ एक अनुगामी newline है? क्या वह न्यूलाइन वैकल्पिक है?
— कृपया
9
नमस्ते! मैंने इस चुनौती को अस्वीकार कर दिया क्योंकि यह एक प्रतिबंधात्मक इनपुट प्रारूप होने के द्वारा स्वीकार्य इनपुट / आउटपुट प्रारूपों के लिए हमारे सामुदायिक मानकों के खिलाफ जाता है ।
— AdmBorkBork
1
@AdmBorkBork और मैंने चैट रूम में इसकी चर्चा की। हम सहमत नहीं हुए हैं :)
22
बोझिल I / O से बचने की चीजों के लेखक के रूप में और मनमाने ढंग से चूक से बचने के लिए , मैं उन आधारों पर इस चुनौती का बचाव करना चाहता हूं। यहां, प्रसंस्करण इनपुट चुनौती का मांस है, न कि अतिरिक्त कार्य जो मुख्य चुनौती से विचलित होता है। यह अजीब I / O आवश्यकताओं के साथ "संख्याएं जोड़ें" नहीं है, यह एक कदम के रूप में जोड़ने के साथ "I / O" यह है। मुख्य कार्य में शॉर्टकट नहीं करने के उत्तरों के लिए मानक I / O को ओवररेल करना आवश्यक है।
— xnor
2
फ़ंक्शन इनपुट का उपयोग क्यों नहीं किया जा सकता है?
— कैलक्यूलेटरफैनलाइन

जवाबों:

15

05AB1E , 2 बाइट्स

|O

स्पष्टीकरण:

|   Get input as array
 O  Sum

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

— Okx
स्रोत
7
यह हास्यास्पद है :)
क्या यह मानक से पढ़ता है?
1
@ लेम्बिक यह करता है।
— ओकेक्स
मेरा मानना ​​है कि आपका 2 बाइट उत्तर पहले था। आप विजेता हैं! (जब तक किसी को 1 बाइट का जवाब नहीं मिलता है।)
4
@ लिम्बिक या 0 बाइट का जवाब ....
— कॉमरेड स्पार्कलपनी
21

बैश + कोरुटिल्स, 16 बाइट्स

xargs|tr \  +|bc

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

के बाद दो रिक्त स्थान हैं \। यह नकारात्मक संख्याओं के लिए भी काम करता है।

स्पष्टीकरण:

xargs             # known trick to turn newlines into spaces, while adding a
                  #trailing newline when printing the result (needed for bc)
|tr \  +          # turn spaces into '+'s
|bc               # calculates the sum

आप आश्चर्यचकित हो सकते हैं कि tr \\n +|bcबेहतर क्यों नहीं है, क्योंकि यह सीधे नई + कहानियों को '+' में बदल देता है। खैर, इसमें 2 अप्रत्याशित त्रुटियां हैं:

  • यदि इनपुट में एक अनुगामी न्यूलाइन है, तो इसे अनुगामी '+' में बदल दिया जाता है, इसलिए इसके अतिरिक्त करने के लिए कोई संख्या नहीं है
  • और सबसे विचित्र मुद्दा यह है कि इनपुट के बाद bc को एक अनुगामी न्यूलाइन की आवश्यकता होती है, लेकिन आपने अभी सभी इनपुट न्यूलाइन्स को '+' के साथ बदल दिया है।
— seshoumara
स्रोत
1
यह मुझे पंसद है। यह अच्छा और चालाक है।
क्या आप xargs के बजाय tr \\ n + का उपयोग कर सकते हैं?
1
@Lembik क्या आपका मतलब है tr \\n +|bc? यदि ऐसा है, तो कृपया अद्यतन विवरण देखें। अच्छा प्रश्न।
— शेषमारा
paste -s -d+|bc15 बाइट्स है
— डेविड कॉनराड
1
@ लिम्बिक ने उस मामले पर विचार नहीं किया, लेकिन सौभाग्य से स्क्रिप्ट अभी भी काम करती है। xargs|tr \ +इस मामले में कुछ नहीं करता है, और बीसी संख्या प्राप्त करता है और इसे वापस प्रिंट करता है।
— शीशमारा
14

MATL , 2 बाइट्स

Us

यह नामक पाठ फ़ाइल में इनपुट की अपेक्षा करता है defin।

Gif या ऐसा नहीं हुआ :

यहाँ छवि विवरण दर्ज करें

या इसे ऑनलाइन आज़माएं! ( सेट-अप के लिए डेनिस के लिए धन्यवाद! )

व्याख्या

जब MATL प्रोग्राम चलाया जाता definहै , यदि कोई फ़ाइल पाई जाती है (नाम "डिफ़ॉल्ट इनपुट" को संदर्भित करता है), तो इसकी सामग्री स्वचालित रूप से पाठ के रूप में लोड हो जाती है और कोड को निष्पादित करने से पहले एक स्ट्रिंग के रूप में स्टैक पर धकेल दिया जाता है।

फ़ंक्शन U, स्ट्रिंग को संख्याओं के कॉलम वेक्टर में बदलने के लिए मूल्यांकन sकरता है , और योग की गणना करता है, जिसे स्पष्ट रूप से प्रदर्शित किया जाता है।

— लुइस मेंडो
स्रोत
12

पेस्ट + बीसी, १३ बाइट्स

paste -sd+|bc

स्पष्टीकरण:

paste -s        Take one line at a time from input
        d+      Joining by '+'
          |bc   Pass as expression to bc

एक और खोल जवाब!

— Okx
स्रोत
1
बहुत साफ सुथरा।
ओह, मेरे पास था paste -s -d+|bcऔर मुझे एहसास नहीं था कि मैं स्विचेस को मजबूत कर सकता हूं। साफ!
— डेविड कॉनराड
12

पर्ल 6 , 13 बाइट्स

say sum lines

कोशिश करो

व्याख्या

  • lines()से लाइनों की सूची देता है $*INया $*ARGFILESएक "जादू" कमांड लाइन इनपुट संभाल।
  • sum(…)[+] Listस्थिति 6 के लिए अनुकूलित होने की अनुमति देने के लिए पर्ल 6 में जोड़ा गया था, जो कि उनके सभी मूल्यों को उत्पन्न किए बिना उनकी राशि की गणना कर सकता है 1..100000
    (जैसे कि मैंने अभी सोचा sumथा कि मैं यहां [+]सामान्य रूप से उपयोग करने के लिए बहुत प्यारा था )
  • say(…).gistइसके इनपुट पर विधि को कॉल करें , और इसे एक अतिरिक्त नई रेखा के साथ प्रिंट करता है।
— ब्रैड गिल्बर्ट b2gills
स्रोत
यह 5 पर्ल क्या है?
15
यह लॉकोड की तरह पढ़ता है
— ब्रायन
@ लेम्बिक को स्पष्ट रूप से पर्ल 6 के रूप में लेबल किया गया है , जो पर्ल 5 की एक बहन भाषा है ।
— ब्रैड गिल्बर्ट
एक टाइपो था। मेरा मतलब था कि यह पर्ल 5 में क्या है?
1
वैसे $a+=$_ for <>;print $aपर्ल 5 में काम करता है, लेकिन इसका एक छोटा तरीका हो सकता है।
— ब्रैड गिल्बर्ट
10

सी, 53 बाइट्स

r;main(i){for(;~scanf("%d",&i);r+=i);printf("%d",r);}
— orlp
स्रोत
C अपनी साख फिर दिखाते हुए :)
2
मुझे लगता है कि एक छोटा रास्ता होना चाहिए, लेकिन मैं इसे नहीं देखता हूं :)
— डिजिटल ट्रॉमा
9

रेटिना , 11 7 बाइट्स

-4 मार्टिन एंडर को धन्यवाद

.*
$*
1

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

यूनीरी में बदलें:

.*
$*

1एस की संख्या की गणना करें :

1
— रिले
स्रोत
1
दिलचस्प है कि रेटिना आधारित भाषा के रूप में रेटिना, अब तक पोस्ट किए गए सबसे छोटे बैश उत्तर की तुलना में कम बाइट्स में योग कर सकती है। +1
— शीशमारा
क्या यह मानक में से पढ़ना है?
2
@Lembik हाँ यह है।
— रिले
यदि यूनिटी में इनपुट की अनुमति थी, तो यह केवल एक बाइट होगी।
— mbomb007
@ mbomb007 मैंने पहले ही सेड में कोशिश की।
— रिले
8

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

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

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

व्याख्या

यह रिले में चैट द्वारा किए गए समाधान का एक गोल्फ बंद है । उनका समाधान था:

([])({<{}>{}<([])>}{})

यदि आपका ब्रेन-फ्लैक से परिचित यह बहुत आत्म-व्याख्यात्मक है। यह स्टैक की ऊँचाई को धक्का देता है और एक मान को पॉप करता है क्योंकि यह नीचे गिना जाता है, अंत में यह सभी रनों के योग को धक्का देता है।

यह एक बहुत अच्छा गोल्फ है लेकिन वह दोनों को शून्य करता है {}और ([])हालांकि इनमें एक मूल्य होगा जो केवल एक से भिन्न होता है यदि इसके बजाय हम मास्क हटाते हैं और दो नकारात्मक में से एक बनाते हैं तो उन्हें लगभग रद्द करना चाहिए।

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

चूंकि वे हमेशा एक-दूसरे से भिन्न होते हैं, हमारे पास दुर्भाग्यपूर्ण परिस्थिति होती है, जहां हमारा उत्तर हमेशा स्टैक की ऊंचाई से बंद होता है। इसे मापने के लिए हम पहले स्टैक की ऊँचाई को घेरने के लिए पुश की शुरुआत करते हैं।

(([]){[{}]{}([])}{})
— गेहूं का जादूगर
स्रोत
1
मैंने इसे नकारात्मक पॉप के रूप में सोचा, पिछली ऊंचाई को लूप से पहले (या पाश के माध्यम से समाप्त होने से पहले) से रद्द कर दिया, और अंतिम ऊंचाई 0 है, इसलिए इसे अनदेखा किया जा सकता है।
— रिले
8

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

import sys;print sum(map(int,sys.stdin))
— orlp
स्रोत
7

आर, 11 बाइट्स

sum(scan())

scanइनपुट लेता है, प्रति पंक्ति एक नंबर। और sum, ठीक है, रकम।

— फ़्रेडरिक
स्रोत
7

पर्ल 5 , 9 बाइट्स

कोड + -pध्वज के 8 बाइट्स ।

$\+=$_}{

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

इसके साथ -p, इनपुट को एक बार में एक पंक्ति में पढ़ा जाता है, $_प्रत्येक समय में संग्रहीत किया जाता है। हम $\संचायक के रूप में उपयोग करते हैं , क्योंकि -pध्वज के लिए धन्यवाद , यह अंत में स्पष्ट रूप से मुद्रित होता है। बेजोड़ }{का उपयोग किया जाता है ताकि -pध्वज केवल $\छपाई के बजाय एक बार प्रिंट हो $_और $\प्रत्येक पंक्ति में यह पढ़े जैसे कि यह सामान्य रूप से होता है।

— बापू
स्रोत
मैं इसे पार्स भी नहीं कर सकता! :) कृपया स्पष्टीकरण दें।
@Lembik यहाँ आप जाओ।
— दादा
बेमिसाल कोष्ठक हिस्सा बहुत अस्पष्ट है!
@ लेम्बिक वो कोष्ठक नहीं हैं ... वे या तो फ्रेंच हैं या घुंघराले ब्रेसिज़ इस पर निर्भर करते हैं कि आप किससे पूछते हैं, लेकिन वे निश्चित रूप से नहीं हैं)(
— CraigR8806
1
@ लिम्बिक accolades, जाहिरा तौर पर।
— माइकल व्हीलर
7

शुद्ध बैश, 37 36 बाइट्स

एक बाइट के लिए @ केविनक्रूजसेन को धन्यवाद!

while read a;do((b+=a));done;echo $b

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

— betseg
स्रोत
3
बहुत अच्छा और साफ।
मैं कभी भी बैश में कार्यक्रम नहीं करता , लेकिन क्या इसके बीच के स्थान को हटाना संभव नहीं है do ((? TIO काम करने लगता है।
— केविन क्रूज़सेन
@ केविनक्रूजसेन हाँ, ऐसा लगता है कि यह काम करता है। मैं अपने दैनिक शेल के रूप में zsh का उपयोग करता हूं और यह बिना किसी स्थान के zsh में काम नहीं करता है, मैंने बस यह मान लिया था कि यह बैश में काम नहीं करेगा, लेकिन जाहिर तौर पर मैं ऐसा नहीं करता।
— betseg
6

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

interact$show.sum.map read.lines

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

interactस्टड से पूरा इनपुट एकत्र करता है, इसे उसके तर्क के रूप में दिए गए फ़ंक्शन में भेजता है और इस फ़ंक्शन से वापस आने वाली स्ट्रिंग को प्रिंट करता है। समारोह है:

            lines   -- split input into list of lines at nl
      map read      -- convert every line to a number (read is polymorphic,
                    -- but as want to sum it later, the type checker knows
                    -- it has to be numbers)
    sum             -- sum the list of numbers
show                -- convert back to string
— nimi
स्रोत
1
यह मुझे वास्तव में हास्केल की तरह बनाता है। स्काला में, मुझे करना है lines.map(_.toInt) क्योंकि राशि स्ट्रिंग से या इस मामले में एक स्पष्ट एक के रूप में संख्यात्मक निहितार्थ रूपांतरण के कुछ प्रकार की उम्मीद है।
— स्टेफेन अलेक्सिएक
6

PHP, 22 बाइट्स

<?=array_sum(file(t));

यह मानता है कि पूर्णांकों की सूची के साथ "t" नामक एक फ़ाइल है।

file()एक फ़ाइल खोलता है और सरणी में एक अलग तत्व संग्रहीत प्रत्येक पंक्ति के साथ एक सरणी देता है। array_sum()एक सरणी में सभी तत्वों को sums।

— कोडोस जॉनसन
स्रोत
5

अवाक, 19 बाइट्स

{s+=$1}END{print s}

स्पष्टीकरण:

{s+=$1}                For all lines in the input, add to s
        END             End loop
           {print s}    Print s
— Okx
स्रोत
1
"स्पष्टीकरण जल्द ही ™" अगर यह ट्रेडमार्क नहीं किया गया था तो यह मेरा नया कैचफ्रेज़ होगा ...
— ETHproductions
2
जाग की भाषा में, आपका उत्तर वास्तव में केवल 19 बाइट्स है: {s+=$1}END{print s}:)
— डिजिटल ट्रॉमा
5

डीसी , 14 बाइट्स

0[+?z2=a]dsaxp

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

स्पष्टीकरण:

 [      ] sa   # recursive macro stored in register a, does the following:
  +            # - sum both numbers on stack
               #   (prints to stderr 1st time since there's only 1)
   ?           # - read next line, push to stack as number
    z          # - push size of stack
     2         # - push 2
      =a       # - if stack size = 2, ? yielded something, so recurse
               # - otherwise end macro (implicit)
0              # push 0 (accumulator)
         d     # duplicate macro before storing it
            x  # Call macro
             p # The sum should be on the stack now, so print it
— ब्रायन मैककिनटन
स्रोत
4

सीजाम , 5 बाइट्स

q~]1b

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

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

q     e# Read all input from STDIN.
 ~    e# Evaluate that input, pushing several integers.
  ]   e# Wrap the entire stack in an array.
   1b e# Convert from base 1 to integer.
      e# :+ (reduce by sum) would work as well, but 1b handles empty arrays.
— डेनिस
स्रोत
1bअंक कैसे बनता है?
— फल तोड़
CJam को अंक-से-पूर्णांक रूपांतरण के लिए एक कैनोनिकल प्रतिनिधित्व की आवश्यकता नहीं होती है; [<x> <y> <z> <w>]<b>bबस b +x + b²y + bz + w की गणना करता है । जब b = 1 , यह x + y + z + w देता है ।
— डेनिस
4

पायथन, 38 30 बाइट्स

lambda n:sum(map(int,open(n)))

अजगर में, फाइलें open('filename')(जाहिर है) द्वारा खोली जाती हैं । वे, हालांकि, पुनरावृत्तियाँ हैं। हर बार जब आप फ़ाइल के माध्यम से पुनरावृत्ति करते हैं, तो आपको अगली पंक्ति मिलती है। इसलिए मैप प्रत्येक सूची पर पुनरावृत्ति intकरता है, उस पर कॉल करता है, और फिर परिणामी सूची पर हस्ताक्षर करता है।

इनपुट के रूप में फ़ाइल नाम के साथ कॉल करें। (यानी f('numbers.txt'))

8 बाइट्स map(int, open(n))एक सूची समझ के बजाय का उपयोग करके बचाया । मूल कोड:

lambda n:sum([int(i)for i in open(n)])
— Rɪᴋᴇʀ
स्रोत
1
मेरा मानना ​​है कि आप 'ओपन (0)' कहकर भी मानक इनपुट के साथ ऐसा कर सकते हैं। निश्चित नहीं है कि इसका उपयोग आपके उत्तर को छोटा करने के लिए किया जा सकता है।
— कोल
@Cole डेनिस के पास पहले से ही वह समाधान है, इसलिए मैं अपना जवाब इस तरह छोड़ दूंगा।
— R
मेरी गलती, इस बारे में खेद है; मैंने आपके उत्तर पर आने से पहले सभी तरह से नहीं पढ़ा।
— कोल
@ यह ठीक है, मुझे कोई आपत्ति नहीं है।
— आर
4

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

गणित के नोटबुक वातावरण को मानता है।

Tr[#&@@@Import@"a"]

किसी फ़ाइल में इनपुट की अपेक्षा करता है a।

— मार्टिन एंडर
स्रोत
यह एक पागल भाषा है :)
4
@Lembik सामान्य लोगों के लिए यह बहुत readably के रूप में लिखते थे Total @ Flatten @ Import @ "a"या यहां तक कि "a" // Import // Flatten // Total। ;)
— मार्टिन एंडर
Tr[#&@@@Import@#]&भी अनुमति नहीं दी जाएगी?
— ngenisis
4

जेली , ९ by बाइट्स

ƈFпFỴVS

वास्तव में जेली की बात नहीं है ...

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

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

ƈFпFỴVS  Main link. No arguments. Implicit argument: 0

  п      While loop; while the condition returns a truthy value, execute the body
          and set the return value to the result. Collect all results (including 0,
          the initial return value) in an array and return that array.
ƈ           Body: Yield a character from STDIN or [] if the input is exhausted.
 F          Condition: Flatten, mapping 0 to [], '0' to "0", and [] to [] (falsy).
    F     Flatten the result.
     Ỵ    Split at newlines.
      V   Evaluate the resulting strings.
       S  Take the sum.
— डेनिस
स्रोत
1
स्पष्टता के लिए दूसरा भी Fहो सकता है Ṗ।
— आउटगोल्फर
4

शुद्ध बैश, ३०

read -d_ b
echo $[${b//'
'/+}]

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

  • readइनपुट फ़ाइल को एक चर में जाना b। -d_बताता है readकि _इसके बजाय लाइन सीमांकक हैnewline
  • ${b//'newline'/+}में नई-पंक्तियों की जगह bके साथ+
  • echo $[ ... ] अंकगणित परिणामी अभिव्यक्ति का मूल्यांकन करता है और इसे आउटपुट करता है।
— डिजिटल आघात
स्रोत
+1 बहुत अच्छा। क्या इनपुट फ़ाइल की अनुगामी न्यूलाइन भी पढ़ी जाती है? मैं पूछता हूं क्योंकि यदि इसे '+' से बदल दिया जाता है, तो $[]अनुभाग 'ट्रेलिंग' + के कारण त्रुटि करेगा।
— शीशमारा
@ शीशमौरा ऐसा प्रतीत होता है कि readअंतिम अनुगामी नईलाइन्स को छोड़ता है, भले ही लाइन सीमांकक को ओवरराइड किया गया हो _। यह शायद एक चेतावनी है read, लेकिन यह इस स्थिति के लिए अच्छी तरह से काम करता है।
— डिजिटल ट्रॉमा
शुद्ध बैश समाधान देखकर मैं हमेशा खुश हूं।
3

विम, 16 बाइट्स / कीस्ट्रोक्स

:%s/\n/+
C<C-r>=<C-r>"<C-h>

चूंकि V पीछे की ओर संगत है, आप इसे ऑनलाइन आज़मा सकते हैं !

— DJMcMayhem
स्रोत
यह या तो मानक से या एक फ़ाइल से पढ़ रहा है?
हाँ, विम की अनुमति नहीं दी जा सकती ... :(
— कैलक्यूलेटरफलीन
3

jq , 5 बाइट्स

add, प्लस कमांड लाइन फ्लैग -s।

उदाहरण के लिए:

% echo "1\n2\n3\n4\n5" | jq -s add
15
— लिन
स्रोत
6 बाइट्स । चूंकि -saddकाम नहीं करेगा, अंतरिक्ष की गणना करें।
— एजीसी
@agc मुझे ठीक करें यदि मैं गलत हूं लेकिन कोड स्वयं add(3 बाइट्स) है और आपको ध्वज के लिए 2 बाइट्स जोड़ना होगा-s । अंतरिक्ष कोड या ध्वज के रूप में नहीं गिनता है: यह भाषा द्वारा उपयोग की जाने वाली कमांड लाइन विभाजक है।
— caird coinheringaahing
1
@ThisGuy, वैसे -sध्वज " --slurp " के लिए छोटा है , (पूरे इनपुट स्ट्रीम को एक बड़े सरणी में पढ़ें और फ़िल्टर को केवल एक बार चलाएं), जो दोनों को बदलता jqहै इनपुट डेटा की व्याख्या, और यह कैसे कोड चलाता है। ऐसा लगता है कि नहीं है -eमें sedजो केवल बताता है sedकि बाद में स्ट्रिंग कोड है। यह भाषा के -sएक हिस्से की तरह ही अधिक jqहै, और इसलिए कि 6 वां बाइट स्थान भी होगा।
— अगस्त
3

डीसी, २२

[pq]sq0[?z2>q+lmx]dsmx

ऐसा होने के बजाय यह अधिक लंबा लगता है, लेकिन यह तय करना मुश्किल है कि फ़ाइल का अंत कब तक होता है। जिस तरह से मैं ऐसा करने के लिए सोच सकता हूं वह केवल ?कमांड के बाद स्टैक की लंबाई की जांच करना है ।

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

[pq]                    # macro to `p`rint top-of-stack, then `q`uit the program
    sq                  # save the above macro in the `q` register
      0                 # push `0` to the stack.  Each input number is added to this (stack accumulator)
       [         ]      # macro to:
        ?               # - read line of input
         z              # - push stack length to stack
          2             # - push 2 to the stack
           >q           # - if 2 > stack length then invoke macro stored in `q` register
             +          # - add input to stack accumulator
              lmx       # - load macro stored in `m` register and execute it
                  d     # duplicate macro
                   sm   # store in register `m`
                     x  # execute macro

नोट मैक्रो mको पुनरावर्ती कहा जाता है। dcइस तरह की चीज के लिए आधुनिक उपकरण पूंछ पुनरावृत्ति करते हैं, इसलिए स्टैक को बहने के बारे में कोई चिंता नहीं होनी चाहिए।

— डिजिटल आघात
स्रोत
PPCG में आपका स्वागत है! कृपया ध्यान दें कि यदि पर्याप्त स्पष्टीकरण नहीं है, तो यह निम्न गुणवत्ता वाले पोस्ट फ़िल्टर के माध्यम से जाएगा ।
— मैथ्यू रो
@SIGSEGV जरूरी नहीं कि आपका स्वागत हो - मैं यहां कुछ समय से हूं; ;-) हां, आपने टिप्पणी करते समय मैं अपना स्पष्टीकरण लिख रहा था। संपादित देखें।
— डिजिटल ट्रॉमा
1
मैं आपको स्टोर करने से पहले मैक्रो को डुप्लिकेट करने की चाल के लिए एक बाइट देना चाहता हूं ।
— बजे ब्रायन मैककियॉन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.