सभी पूर्णांक प्रिंट करें

48

एक प्रोग्राम या फ़ंक्शन लिखें, जो कि सभी पूर्णांकों को एक बार अनंत समय और स्मृति दिए जाने के लिए निश्चित रूप से प्रिंट करेगा ।

संभावित आउटपुट हो सकते हैं:

0, 1, -1, 2, -2, 3, -3, 4, -4, …

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -2, -3, -4, -5, -6, -7, -8, -9, 10, 11, …

यह एक मान्य आउटपुट नहीं है, क्योंकि यह कभी भी नकारात्मक संख्याओं की गणना नहीं करेगा:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,…

  • आउटपुट दशमलव में होना चाहिए, जब तक कि आपकी भाषा दशमलव पूर्णांक का समर्थन नहीं करती है (उस स्थिति में पूर्णांक के प्राकृतिक प्रतिनिधित्व का उपयोग करें जो आपकी भाषा का उपयोग करती है)।

  • आपके प्रोग्राम को अपनी भाषा के मानक पूर्णांक प्रकार की सबसे बड़ी परिमाण के साथ संख्याओं तक काम करना पड़ता है।

  • किसी भी विभाजक (एक स्थान, एक अल्पविराम, एक लाइनब्रेक, आदि) का उपयोग करके प्रत्येक पूर्णांक को अगले से अलग किया जाना चाहिए जो कि आपकी भाषा का एक अंक और न ही नकारात्मक संकेत नहीं है।

  • विभाजक को किसी भी बिंदु पर बदलना नहीं चाहिए।

  • विभाजक में कई वर्ण शामिल हो सकते हैं, जब तक कि उनमें से कोई भी एक अंक नहीं है और न ही नकारात्मक चिन्ह (जैसे , कि बस के रूप में मान्य है ,)।

  • किसी भी समर्थित पूर्णांक को अंततः एक सीमित समय के बाद मुद्रित किया जाना चाहिए।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है

लीडरबोर्ड

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

code-golf  number  integer 
— Fatalize
स्रोत
3
यदि हमारी भाषा अनंत सूचियों का समर्थन करती है, तो क्या हम मुद्रण के बजाय किसी फ़ंक्शन से सूची को आउटपुट कर सकते हैं? (ऐसी सूची पर कॉलिंग प्रिंट उसके तत्वों को एक बार में हमेशा के लिए प्रिंट कर देगा।)
— xnor
5
मुझे लगता है कि मनमाने ढंग से आकार के पूर्णांक पर आवश्यकता इस तरह के पूर्णांक के बिना भाषाओं को हतोत्साहित करने के अलावा कुछ नहीं करती है। उन्हें या तो एक आयात करना होगा जिसका वे उपयोग कर सकते हैं या बाकी सभी से पूरी तरह से अलग चुनौती का समाधान कर सकते हैं।
— xnor
2
@xnor बदल गया, हालांकि चुनौती के नाम पर उस तरह के खंडहर हैं।
— घातक
5
@xnor, मनमाने ढंग से सटीक पूर्णांक वाली भाषाओं को अभी भी बाकी सभी से अलग समस्या को हल करना है, इसलिए जो बदलाव किया गया है वह सभी इस समस्या को बहुत सारी भाषाओं में उबाऊ बना देता है।
— पीटर टेलर
2
@PeterTaylor हाँ, यह दुर्भाग्यपूर्ण है। रैपिंग सॉल्यूशंस मुझे ऐसा नहीं लगता, जैसे वे किसी भी नकारात्मक को प्रिंट कर रहे हैं, लेकिन जब यह प्रतिनिधित्व का मामला है, तो मैं अंतर को दृढ़ता से निर्दिष्ट करने का कोई तरीका नहीं देखता हूं।
— xnor

जवाबों:

19

सेसोस , 11 3 3 बाइट्स

0000000: c4ceb9                                            ...

इसे ऑनलाइन आज़माएं! उत्पन्न SBIN कोड देखने के लिए डीबग की जाँच करें ।

सीसोस विधानसभा

उपरोक्त बाइनरी फ़ाइल निम्नलिखित एसएएसएम कोड को इकट्ठा करके बनाई गई है।

set numout

jmp ; implicitly promoted to nop
    put,   fwd 1
    sub 1, put
    rwd 1, add 1
; jnz (implicit)
— डेनिस
स्रोत
यह 3 बाइट्स कैसे है?
— उम्मीद है कि
1
GitHub (हेडर में लिंक) पर रीडमी विस्तार से बताता है कि निर्देश कैसे एन्कोड किए गए हैं।
— डेनिस
1
6 हेक्स अंक / 2 = 3 बाइट @ हेलोफुल हेल्पफुल
— स्टेन
@StanStrum धन्यवाद
— उम्मीद है कि
47

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

do n<-[1..];[1-n,n]

अनंत सूची का निर्माण करता है [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

हास्केल मूल रूप से अनंत सूचियों की अनुमति देता है। ऐसी सूची को प्रिंट करना उसके तत्वों को एक समय के लिए हमेशा के लिए प्रिंट कर देगा।

— XNOR
स्रोत
2
मैं प्यार करता हूँ [n,1-n]!
— दोष
3
IMHO [1-n,n]अच्छे उत्पादन का उत्पादन करेगा।
— नील
@ नील मैं सहमत हूँ, इसे बदल दिया।
— xnor
2
आह, यह concatMap (\n -> [1-n, n]) [1..]ठीक है, के लिए monadese है ? अच्छा!
— कार्स्टन एस
@CarstenS हाँ, बिल्कुल।
— 18
29

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

यह सेल रैपिंग का उपयोग करता है और सभी संभावित मूल्यों को प्रिंट करता है। ब्रेनफक में, मूल पूर्णांक प्रतिनिधित्व बाइट मान द्वारा है ।

.+[.+]

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

— flawr
स्रोत
2
अच्छा, यह सबसे छोटा ब्रेनफक जवाब है जिसे मैंने अब तक PPCG पर देखा है।
— केविन क्रूज़सेन
1
यह अनबाउंड कोशिकाओं के साथ ब्रेनफॉक संस्करणों के लिए काम नहीं करेगा। कृपया ठीक करें (भले ही एक अलग उत्तर के रूप में)
— जॉन ड्वोरक
16
@JDDvorak उत्तर को हर कार्यान्वयन में काम करने की आवश्यकता नहीं है , बस उनमें से किसी एक में।
— मार्टिन एंडर
7
क्या मुझे इस बात का स्पष्टीकरण मिल सकता है कि यह मान्य क्यों है? प्रश्न में उल्लिखित कोई नकारात्मक नहीं है और कोई नकारात्मक नहीं है। इस तथ्य के साथ कि आप ब्रेनफक में 9 से अधिक मानों को आउटपुट कर सकते हैं। कोड गोल्फ में Im अनुभवहीनता और कुछ ऐसा काम करना शुरू कर दिया जो उत्पादन और नकारात्मक को सकारात्मक बनाता है और उच्च अंक देने से पहले।
— gtwebb
5
@ एसक्यूबी असीमित स्मृति के साथ, पूर्णांक का मूल प्रकार अभी भी 8 बिट है। एक जावा में intअचानक कम या ज्यादा बिट्स नहीं होते हैं क्योंकि आपने कुछ रैम जोड़े या हटाए हैं।
— 19
26

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

.(.\OSo;?.>~

इसे ऑनलाइन टेस्ट करें! आप अब गति को समायोजित कर सकते हैं यदि आप इसे तेज या धीमा चलाना चाहते हैं।

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

पहली बात यह है कि दुभाषिया सभी व्हाट्सएप को हटा देता है और कोड को नो-ऑप के साथ .तब तक पैड करता है जब तक कि यह एक घन पर पूरी तरह से फिट न हो जाए। इसका मतलब है कि उपरोक्त कोड भी इस तरह लिखा जा सकता है:

    . (
    . \
O S o ; ? . > ~
. . . . . . . .
    . .
    . .

अब कोड चलाया जाता है। आईपी ​​(इंस्ट्रक्शन पॉइंटर) सुदूर पूर्व की ओर, बाएं ओर के ऊपरी बाएं कोने पर शुरू होता है। यहाँ कार्यक्रम चलाने के दौरान पूरे रास्ते में लगने वाले रास्ते हैं:

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

IP छवि के सबसे बाईं ओर लाल निशान पर शुरू होता है। यह तब चलता है OSo;, जो निम्न कार्य करता है:

  • Oएक पूर्णांक के रूप में टीओएस (टॉप-ऑफ-स्टैक) प्रिंट करें। कार्यक्रम की शुरुआत में, स्टैक में अनंत शून्य होते हैं, इसलिए यह प्रिंट करता है 0।
  • Sपुश 32, अंतरिक्ष चरित्र के लिए चार कोड।
  • oएक चरित्र के रूप में टीओएस प्रिंट करें। यह एक स्पेस प्रिंट करता है।
  • ;टीओएस पॉप। 32स्टैक से निकालता है ।

अब आईपी हिट करता है ?, जो इसे टीओएस के संकेत के आधार पर बाएं, दाएं या सीधे निर्देशित करता है। अभी, टीओएस है 0, इसलिए यह सीधे जाता है। यह नीला रास्ता है; .कुछ भी नहीं करता है, और आईपी तीर को मारता है >, जो इसे पूर्व में फिर से लाल पथ के साथ निर्देशित करता है। ~टीओएस के बिटवाइज़ नॉट को लेता है, इसे बदल देता है -1।

यहां आईपी नेट के दाहिने किनारे तक पहुंचता है, जो इसे वापस बाईं ओर लपेटता है; यह फिर से टीओएस (इस समय -1) और एक स्थान को प्रिंट करता है।

अब आईपी ?फिर से हिट । इस समय, टीओएस है -1; चूंकि यह ऋणात्मक है, इसलिए ग्रीन पथ लेते हुए, IP बाईं ओर मुड़ जाता है। दर्पण \आईपी ​​को डिफ्लेक्ट करता है (, जो टीओएस को घटाता है, इसे बदल देता है -2। यह चारों ओर वापस आता है और तीर मारता है; करने ~के -2लिए बदल, फिर से बिटवाइज़ नहीं लेता है 1।

फिर से टीओएस आउटपुट होता है और एक स्पेस प्रिंट होता है। इस समय जब आईपी हिट करता है ?, तो टीओएस है 1; जब से यह सकारात्मक है, आईपी सही तरीके से बदल जाता है, पीला पथ ले रहा है। पहला ऑपरेटर इसका सामना करता है S, एक अतिरिक्त धक्का 32; ;पॉप इससे पहले कि यह किसी भी मुसीबत पैदा कर सकता है।

अब आईपी वापस तीर के लिए चारों ओर आता है और अपनी दिनचर्या करता है, ~करने के लिए सेवा की शर्तें बदल रहा है -2और Oयह मुद्रण। चूंकि टीओएस फिर से नकारात्मक है, इसलिए आईपी एक बार फिर हरे रंग की राह लेता है। और यह हमेशा की तरह साइकिल चलाता रहता है *: लाल, हरा, लाल, पीला, लाल, हरा, लाल, पीला ..., निम्नलिखित चक्र में मुद्रण:

0 -1 1 -2 2 -3 3 -4 4 -5 5 -6 6 -7 7 -8 8 -9 9 -10 10 ...

टी एल; डॉ

यह कार्यक्रम बार-बार इन 3 आसान चरणों से गुजरता है:

  1. वर्तमान संख्या और एक स्थान आउटपुट।
  2. यदि वर्तमान संख्या ऋणात्मक है, तो इसे 1 से घटाएं।
  3. वर्तमान संख्या का बिटवाइज़ न लें।

गैर-पृथक संस्करण, 6 बाइट्स

nO?~>~

पृथक्करण हटाने से कार्यक्रम इतना सरल हो जाता है कि यह एक इकाई घन पर फिट हो सकता है:

  n
O ? ~ >
  ~

* नोट : न तो कार्यक्रम वास्तव में अनंत है, क्योंकि वे केवल 2 52 तक गिनती करते हैं (जहां जावास्क्रिप्ट पूर्णांक परिशुद्धता को खोना शुरू करता है)।

— ETHproductions
स्रोत
4
अच्छा चित्र! :) क्या आपने इसे हाथ से बनाया है या इसे बनाने के लिए एक उपकरण लिखा है?
— मार्टिन एंडर
5
@MartinEnder धन्यवाद! यह आपके हेक्सागोनी आरेखों से प्रेरित था। मैंने उस एक को हाथ से बनाया; हालाँकि मैं उन्हें ऐसा करने के लिए एक उपकरण लिखना चाहता हूँ जब मेरे पास ऐसा करने के लिए पर्याप्त समय हो।
— ETHproductions
18

MATL , 8 बाइट्स

0`@_@XDT

यह MATL के डिफ़ॉल्ट डेटा प्रकार का उपयोग करता है, जो है double, इसलिए यह 2^53निरपेक्ष मूल्य में काम करता है । आउटपुट है

0
-1
1
-2
2
···

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

व्याख्या

0            % Push 0
  `     T    % Do...while true: infinite loop
   @_        % Push iteration index and negate
     @       % Push iteration index
      XD     % Display the whole stack
— लुइस मेंडो
स्रोत
छपाई शुरू होने से पहले इतनी बड़ी देरी क्यों है?
— घातक
@ मुझे लगता है कि जब भी आप TIO में MATL प्रोग्राम चलाते हैं, तो ऑक्टेव को पुनः आरंभ करने की आवश्यकता होती है, और इसमें कुछ समय लगता है।
— दोष
@ जानिए मुझे यकीन नहीं है यह ऑनलाइन कंपाइलर में होता है, ऑफलाइन नहीं। मुझे लगा कि ऑक्टेव को आउटपुट के साथ करना पड़ सकता है, लेकिन अब मुझे यकीन नहीं है कि इसका कारण क्या है
— लुइस मेंडो
1
स्मार्ट विचार के @_@XDबजाय @_D@Dऐसा करें कि आप पहले रन पर 0 को शामिल कर सकें।
— सेचेज
3
XDस्माइली के लिए +1
— टक्स क्राफ्टिंग
16

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 227 बाइट्स

.
Ajax,.
Puck,.
Act I:
Scene I:
[Enter Ajax,Puck]
Puck:You ox!
Ajax:Be me without myself.Open thy heart.
Scene II:      
Ajax:Be thyself and ash.Open thy heart.Be me times you.Open thy heart.Be me times you.Let us return to scene II.

जाहिर है, यह जवाब जीतने के पास कहीं नहीं है, लेकिन मुझे यह पसंद आया कि यह एक ऐसा उपयोग मामला है जो एसपीएल तुलनात्मक रूप से अच्छी तरह से अनुकूल है।

व्याख्या की:

// Everything before the first dot is the play's title, the parser treats it as a comment.
.

// Dramatis personae. Must be characters from Shakespeare's plays, again with a comment.
Ajax,.
Puck,.

// Acts and scenes serve as labels. Like the whole play, they can have titles too,
// but for the sake of golfing I didn't give them any.
Act I:

// This scene would've been named "You are nothing"
Scene I:

// Characters can talk to each other when on stage
[Enter Ajax,Puck]

// Characters can assign each other values by talking. Nice nouns = 1, ugly nouns = -1.
Puck: You ox!                 // Assignment: $ajax = -1;
Ajax: Be me without myself.   // Arithmetic: $puck = $ajax - $ajax;
      Open thy heart.         // Standard output in numerical form: echo $puck;

// Working title "The circle of life"
Scene II:

// Poor Ajax always doing all the work for us
Ajax: Be thyself and ash.          // $puck = $puck + (-1);
      Open thy heart.              // echo $puck;
      Be me times you.             // $puck *= $ajax;  (remember $ajax==-1 from scene I)
      Open thy heart.              // echo $puck;
      Be me times you.             // negate again
      Let us return to scene II.   // infinite goto loop

जैसा कि आप इस कोड की तुलना करते समय देख सकते हैं मेरे जवाब से संबंधित चुनौती के लिए हमेशा के लिए करने की है (यानी सभी प्राकृतिक संख्याओं को प्रिंट करें), एसपीएल कोड की लंबाई समस्या के आकार में वृद्धि के बजाय बहुत बुरी तरह से बढ़ती है ...

— Christallkeks
स्रोत
1
मुझे यह पसंद हे। यह गोल्फ के लिए भयानक है, लेकिन पढ़ने के लिए अद्भुत है।
— स्वाइनफिश
स्पष्टीकरण की अंतिम पंक्ति पर टाइपो। Let us return to scene II.होना चाहिए scene I।
— ओलिवर नी
अंतर को इंगित करने के लिए धन्यवाद! टाइपो वास्तव में ऊपरी कोड में था: हमें दृश्य I को दोहराना नहीं चाहिए क्योंकि यह $puck0 पर रीसेट हो जाएगा और फिर गिनना अब काम नहीं करेगा। मैंने Iकोड में लापता को जोड़ा और बाइट की लंबाई को सही किया (जो किसी भी तरह से बंद था उफ़)
— क्रिस्टाल्केक्स
14

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

n=0
while 1:print~n,n,;n+=1

प्रिंटों -1 0 -2 1 -3 2 -4 3 ...

— XNOR
स्रोत
10

05AB1E , 9 6 बाइट्स

अदनान की बदौलत 3 बाइट बच गईं

[ND,±,

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

प्रिंटों 0, -1, 1, -2, 2 ...को नई कहानियों से अलग किया।

— Emigna
स्रोत
2
मैं कुछ बिटकॉइक जादू का उपयोग करके इसे 6 बाइट्स तक ले जाने में सक्षम था [N,N±,:।
— अदनान
1
@ अदनान: अच्छा! मैंने पहले भी कुछ ऐसा ही करने की कोशिश की थी, लेकिन इसका उपयोग नहीं किया ±और यह आपकी तुलना में 3 बाइट्स तक समाप्त हो गया।
— एमिगा
मुझे पता है कि यह एक समय हो गया है, लेकिन एक बाइट को बचाने के लिए D,इसे बदला जा सकता है =।
— केविन क्रूज़सेन
10

GNU sed, 189 + 2 (rn झंडे) = 191 बाइट्स

यह सबसे लंबे समय तक समाधान की संभावना है, क्योंकि sed में कोई पूर्णांक प्रकार या अंकगणितीय संचालन नहीं है। जैसे, मुझे एक अनुकरण करना था केवल नियमित अभिव्यक्ति का उपयोग करके मनमाना आकार वृद्धि ऑपरेटर का ।

s/^/0/p
:
:i;s/9(@*)$/@\1/;ti
s/8(@*)$/9\1/
s/7(@*)$/8\1/
s/6(@*)$/7\1/
s/5(@*)$/6\1/
s/4(@*)$/5\1/
s/3(@*)$/4\1/
s/2(@*)$/3\1/
s/1(@*)$/2\1/
s/0(@*)$/1\1/
s/^@+/1&/;y/@/0/
s/^/-/p;s/-//p
t

Daud:

echo | sed -rnf all_integers.sed

आउटपुट:

0
-1
1
-2
2
-3
3
etc.
— seshoumara
स्रोत
10

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

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

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

एक अनंत टेप को देखते हुए सैद्धांतिक रूप से हमेशा के लिए चलेगा।

0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7,8,-8,9,-9,10,-10,11,-11,12,-12,13,-13,14,-14,15,-15,16,-16,17,-17,18,-18,19,-19,20,-20,21,-21,22,-22,23,-23,24,-24,25,-25,26,-26,27,-27,28,-28,29,-29,30,-30,31,-31,32,-32,33,-33,34,-34,35,-35,36,-36,37,-37,38,-38,39,-39,40,-40,41,-41,42,-42,43,-43,44,-44,45,-45,46,-46,47,-47,48,-48,49,-49,50,-50,51,-51,52,-52,53,-53,54,-54,55,-55,56,-56,57,-57,58,-58,59,-59,60,-60,61,-61,62,-62,63,-63,64,-64,65,-65,66,-66,67,-67,68,-68,69,-69,70,-70,71,-71,72,-72,73,-73,74,-74,75,-75,76,-76,77,-77,78,-78,79,-79,80,-80,81,-81,82,-82,83,-83,84,-84,85,-85,86,-86,87,-87,88,-88,89,-89,90,-90,91,-91,92,-92,93,-93,94,-94,95,-95,96,-96,97,-97,98,-98,99,-99,...

असम्पीडित

+[-->+>+[<]>-]>-->+
[
  [.<<<]>>-.>>+<
  [[-]>[->+<]
    ++++++++[-<++++++>>-<]>--
    [++++++++++>->-<<[-<+<+>>]]>+>+<
  ]<<<
  [.<<<]>>.+.>
  [>>>]<<<
]
— Primo
स्रोत
9

ShadyAsFuck , 3 बाइट्स

FVd

स्पष्टीकरण:

F     prints the current cell value (0) and increases it by 1
 V    starts a loop and prints the current value
  d   increases the current value and ends the loop

यह सेल रैपिंग का उपयोग करता है और सभी संभावित मूल्यों को प्रिंट करता है। एसएएफ में, मूल पूर्णांक प्रतिनिधित्व बाइट मान द्वारा है ।

— flawr
स्रोत
5
यह उत्तर है ... छायादार।
— कॉनर ओ'ब्रायन
1
मैं सोच रहा था कि भाषा के नाम के साथ कौन आया है, तो मैंने देखा कि यह किस भाषा से उतरा।
— जॉन ड्वोरक
8

आर, 25 24 बाइट्स

@JDL को एक बाइट के लिए धन्यवाद दिया।

repeat cat(-F,F<-F+1,'')

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

उदाहरण आउटपुट:

0 1 -1 2 -2 3 -3 4 -4 5 -5 6 -6 7 -7 8 -8 9 -9 10
— rturnbull
स्रोत
2
आप बदल सकते हैं while(1)के साथ repeat एक चार को बचाने के लिए।
— JDL
@JDL धन्यवाद! मैं भूल जाता हूं कि निर्माण कभी-कभी होता है।
— rturnbull
7

बैच, 56 बाइट्स

@set n=0
:l
@echo %n%
@set/an+=1
@echo -%n%
@goto l

आउटपुट:

0
-1
1
-2
2
-3

आदि 2147483647 तक काम करता है; 58 बाइट्स यदि आप चाहते हैं (-) आउटपुट में 2147483648:

@set n=0
:l
@echo %n:-=%
@set/an-=1
@echo %n%
@goto l

44 बाइट्स अगर सभी समर्थित पॉजिटिव पूर्णांकों को प्रिंट करते हैं, तो सभी नेगेटिव पूर्णांकों का समर्थन किया है, फिर अंतहीन रूप से दोहराते हुए, स्वीकार्य है:

@set n=0
:l
@echo %n%
@set/an+=1
@goto l
— नील
स्रोत
7

जावा 7, 151 134 122 118 बाइट्स

import java.math.*;void c(){for(BigInteger i=BigInteger.ONE,y=i;;i=i.add(y))System.out.println(y.subtract(i)+"\n"+i);}

12 बाइट्स ने @flawr (और @xnor अप्रत्यक्ष रूप से धन्यवाद) को बचाया

नियम बदलने के बाद .. ( 59 56 63 बाइट्स)

void c(){for(int i=0;i>1<<31;)System.out.println(~--i+"\n"+i);}

जावा में 2147483647 + 1 = -2147483648, हम बस नहीं कर सकते हैं i++और असीम रूप से जारी रख सकते हैं , क्योंकि चुनौती एक बार सभी नंबरों को प्रिंट करने की थी। अतिरिक्त श्रेणी के साथ उपरोक्त कोड के साथ, यह निम्नलिखित क्रम में सभी पूर्णांकों -2147483648को 2147483647एक से एक बार प्रिंट करेगा 0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648। के लिए धन्यवाद @ OlivierGrégoire के बारे में जावा के व्यवहार उनका कहना है के लिए MIN_VALUE-1/ MAX_VALUE+1। इसे यहाँ आज़माएँ।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ - परिणामस्वरूप रनटाइम त्रुटि

import java.math.*;
class M{
  static void c() {
    for(BigInteger i = BigInteger.ONE, y = i; ; i = i.add(y)){
      System.out.println(y.subtract(i) + "\n" + i);
    }
  }

  public static void main(String[] a){
    c();
  }
}

आउटपुट:

0
1
-1
2
-2
3
-3
4
-4
5
-5
...
— केविन क्रूज़सेन
स्रोत
1
मुझे लगता है कि आप एक ही समय में n और 1-n प्रिंट करके कुछ बाइट्स बचा सकते थे, इस तरह से आप कॉम्प्रेशन हटा सकते थे। @xnor ने सबसे पहले इस विचार का यहाँ उपयोग किया था।
— दोष
1
intअनंत समय को देखते हुए, आपका -version कार्यक्रम, हर पूर्णांक को अनंत समय तक प्रिंट करेगा।
— ओलिवियर ग्रेगोइरे
1
@ ओलिवियरग्रैगियर आह, निश्चित रूप से, MAX_VALUE + 1 MIN_VALUE .. आह है। मैंने इसे संपादित किया है, इसे इंगित करने के लिए धन्यवाद।
— केविन क्रूज़सेन
1
यदि आप और अधिक गोल्फ चाहते हैं (यानी छुटकारा पा रहे हैं MAX_VALUE, तो आप मेरे उत्तर की जांच कर सकते हैं (संभवत: अभी भी अंतिम पृष्ठ पर)
— ओलिवियर ग्रेजायर
1
आपका 53 बाइट समाधान एक स्निपेट है, फ़ंक्शन या प्रोग्राम नहीं है, और इस तरह मान्य नहीं है।
— मेगो
6

डीसी (GNU या OpenBSD स्वाद) - 16 बाइट्स

यह संस्करण नीचे दिए गए संस्करण से कम नहीं है, लेकिन आपके पीसी में स्टैक विस्फोट के बिना चलने में सक्षम होना चाहिए। फिर भी अनंत बड़ी संख्या में अनंत मात्रा में स्मृति ले जाएगा ... किसी ...

की वजह से rआदेश की जरूरत है यह जीएनयू-डीसी या OpenBSD-डीसी ।

0[rp1+45Pprdx]dx

परीक्षा:

$ dc -e '0[rp1+45Pprdx]dx' | head
0
-1
1
-2
2
-3
3
-4
4
-5

डीसी - 16 बाइट्स

अब थोड़ा सा मतलब है। ;-)

यह संस्करण स्टैक की लंबाई को रोक रहा है जबकि स्टैक को बढ़ने दे रहा है।

z[pz45Ppllx]dslx

परीक्षा:

$ dc -e 'z[pz45Ppllx]dslx' | head
0
-1
1
-2
2
-3
3
-4
4
-5

डीसी - 17 बाइट्स

बिना गंदे चाल के।

0[p1+45Ppllx]dslx

परीक्षा:

$ dc -e '0[p1+45Ppllx]dslx' | head
0
-1
1
-2
2
-3
3
-4
4
-5
— हिममानव
स्रोत
+? "जितनी जल्दी या बाद में ... उतनी ही जल्दी आप अपेक्षा कर सकते हैं"
— ग्रेग मार्टिन
2
इसके बजाय [-]P, करो 45P। "GNU-Dc या OpenBSD-Dc" - क्या कोई अन्य संस्करण हैं जो आमतौर पर वहाँ जंगली में पाए जाते हैं?
— डिजिटल ट्रॉमा
1
मेरे पास एक और समाधान (या कुछ) है, लेकिन वे वास्तविक नकारात्मक संख्याओं को शामिल करते हैं। क्या मैं उन्हें एक नए उत्तर में पोस्ट कर सकता हूं? मैं पूछ रहा हूँ क्योंकि वे इन के समान दिखते हैं, क्योंकि dcकेवल कुछ ही ऑपरेटर हैं। मैंने इनसे स्वतंत्र रूप से विकास किया।
— जो
@DigitalTrauma ... निश्चित ... मूल डीसी करता है r"स्वैप" के रूप में नहीं है । मैं कभी-कभी डफ़रेंट संस्करणों को देखते समय भ्रमित हो जाता हूं। संभवतः कोई भी प्राचीन डीसी में कोड नहीं करना चाहता है (और rस्टैक को साफ करेगा)। शायद मैं "Dc" को "AT & T dc" में बदल दूंगा? ... और 45Pसंकेत के लिए धन्यवाद ...
— यति
2
@yeti मैंने सिर्फ अपने उत्तरों पर "dc" डाला। मुझे नहीं लगता कि यहां के लोग बहुत चिंतित हैं, खासकर "आधुनिक" डीसी फ्लेवर की सर्वव्यापकता को देखते हुए।
— डिजिटल ट्रॉमा
6

C # 74 बाइट्स

class P{void Main(){for(var x=0m;;System.Console.Write(x+++","+-x+","));}}

class P
{
    void Main()
    {
        for(var x = 0m; ; System.Console.Write(x++ + "," + -x + ","));
    }
}

आउटपुट:

0,-1,1,-2,2,-3,3,-4,4,-5,5,-6,6,-7,7,-8,8,-9,9,-10,10,...

कोशिश करो:

dotnetfiddle.net (1000 तक सीमित)

— एलेक्स
स्रोत
इन स्निपेट्स और फ़ंक्शन / पूर्ण प्रोग्राम नहीं हैं?
— गुलाबीफ्लोक्स 3333
क्षमा करें, पूरा कार्यक्रम जोड़ा गया
— एलेक्स
2
आप publicसंशोधक को छोड़ सकते हैं और 14 बाइट्स बचा सकते हैं । चूक समान रूप से अच्छी तरह से करेगी।
— एलेजांद्रो
@ एलेजैंड्रो धन्यवाद, यह मेरी पहली पोस्ट है :)
— एलेक्स
6

रूबी, 26 22 19 16 बाइट्स

प्रिंटों की संख्याएँ नई सूचियों से अलग हो जाती हैं। -मानटवर्क से -3 बाइट्स। @ M-chrzan से -3 बाइट्स।

0.step{|n|p~n,n}
— मूल्य स्याही
स्रोत
आप यहाँ संख्यात्मक मानों का उत्पादन कर रहे हैं, इसलिए pयह भी करेगा।
— मैनटवर्क
0.step{|n|p n,~n}17 बाइट्स के लिए।
— m-chrzan
1
@ m-chrzan क्योंकि ऑर्डर उतना मायने नहीं रखता है, मैं आपके सुझाव के शीर्ष पर एक अतिरिक्त बाइट बंद करने में सक्षम था!
— वैल्यू इंक
6

जावास्क्रिप्ट, 29 26 बाइट्स

गैर-अनंत संस्करण, 26 बाइट्स

सहेजे गए 3 बाइट्स ETHproductions के लिए धन्यवाद

for(n=1;;)alert([1-n,n++])

-9007199254740991 और 9007199254740992 के बीच सभी पूर्णांक प्रदर्शित करेगा।

अनंत संस्करण (ES6), 114 112 बाइट्स

सहेजे गए 2 बाइट्स ETHproductions के लिए धन्यवाद

for(n=[-1];1;alert(n[a||n.unshift(1),0]?(x=n.join``)+' -'+x:0))for(i=n.length,a=0;i--;a=(n[i]+=1-a)>9?n[i]=0:1);

अनंत समय और स्मृति को देखते हुए सभी पूर्णांक प्रदर्शित करेगा।

— Arnauld
स्रोत
आप फ़ंक्शन बॉयलरप्लेट को छोड़ सकते हैं और इसे पूर्ण प्रोग्राम कह सकते हैं।
— कॉनर ओ'ब्रायन
@ ConorO'Brien - ओह, तुम सही हो। धन्यवाद :)
— अरनुलद
n[a,b,c]रिटर्न n[c], ताकि आप कोष्ठकों को अंदर छोड़ सकें n[(a||n.unshift(1),0)]।
— ETHproductions
आपको 1लूप के लिए या तो ज़रूरत नहीं है ; for(;;)हमेशा के लिए चलता है। आप के साथ दो और बाइट्स बचा सकते हैं for(n=1;;)alert([1-n,n++])। इसके अलावा, यह अब किसी भी ES6 सुविधाओं का उपयोग नहीं करता ;-)
— ETHproductions 15
5

> <> , 19 15 बाइट्स

1::1$-naonao1+!

यह निम्नलिखित प्रिंट करता है:

0
1
-1
2
-2
3
-3

... और इसी तरह। विभाजक एक नई रेखा है।

उस एल्गोरिथ्म के एक संस्करण का उपयोग करने के लिए @ xnor के जवाब को पढ़ने के बाद फिर से लिखा गया। शुरू होने से पहले n=1, प्रोग्राम प्रिंट करता है , 1-nऔर nप्रत्येक एक नई पंक्ति द्वारा, वेतन वृद्धि से पहले n। अधिकतम मान को ओवरफ्लो करने के बाद, प्रोग्राम एक त्रुटि के साथ समाप्त हो जाएगा something smells fishy...। वास्तव में ऐसा होने पर दुभाषिया कार्यान्वयन पर निर्भर करेगा।

पुराना वर्जन:

0:nao0$-:10{0(?$~+!

0 से शुरू होकर, कार्यक्रम अनिश्चित काल तक चलता रहता है। प्रत्येक लूप पर, वर्तमान मान एक नई रेखा के साथ मुद्रित किया जाता है। यह तो नकारात्मक है, और सकारात्मक होने पर वृद्धि हुई है।

— सोक
स्रोत
क्या xnor असंदिग्ध रूप से "वह" है? या हमारे अचेतन पक्षपात दिखा रहे हैं ...?
— ग्रेग मार्टिन
2
@GregMartin यह दिलचस्प है, मुझे नहीं लगता कि मैंने कभी लिंग का उल्लेख किया है।
— xnor
5

बैश + जीएनयू उपयोगिताओं, 26

seq NaN|sed '1i0
p;s/^/-/'
— डिजिटल आघात
स्रोत
मैंने कभी नहीं देखा seq इस तरह से इस्तेमाल किया है, यह एक बग की तरह है? इसके अलावा, क्या यह एक प्रकार के अतिप्रवाह के बाद संख्याओं को दोहराना शुरू कर देगा? मुझे पता है कि $[++i]यह मारपीट में है।
— शेषमारा
एक नई सुविधा की तरह दिखता है - स्रोत कोड देखें । 1 को NaN में जोड़ने से रैपराउंड का कारण नहीं होना चाहिए।
— डिजिटल ट्रॉमा
मैंने seq NaNदौड़ना छोड़ दिया और 999999 के बाद मुद्रण 5 अंक परिशुद्धता के साथ वैज्ञानिक अंकन में किया जाता है। चुनौती के संबंध में, वह मूल्य तब आपके द्वारा छापा गया सबसे बड़ा पूर्णांक है, जो ठीक है क्योंकि बाकी पिछली संख्या को नहीं दोहराएगा। यह भी देखा कि आप के साथ seq चला सकते हैं inf, जैसे के लिए असंवेदनशील मामला nan। +1
— शेषमारा
5

ई.पू., १ by १६ बाइट्स

संपादित करें: डिजिटल ट्रॉमा के लिए 1 बाइट कम धन्यवाद ।

अब तक उपयोग की जाने वाली भाषाओं की विविधता को जोड़ते हुए, मैं एक बीसी समाधान प्रस्तुत करता हूं जो पूर्णांक के साथ काम करता है मनमाने आकार के । कोड के बाद एक नई लाइन की आवश्यकता होती है और इसे बाइट्स में गिना जाता है।

for(;;){i;-++i}

पहले पुनरावृत्ति iको परिभाषित नहीं किया गया है, लेकिन इसे मुद्रित करना मेरे आश्चर्य को 0 देता है।

— seshoumara
स्रोत
1 बाइट छोटी:for(;;){i;-++i}
— डिजिटल ट्रामा
@DigitalTrauma धन्यवाद, मैंने अपना उत्तर अपडेट किया। मजेदार बात यह है कि मैंने अपने अन्य बैश उत्तर में आज उस लूप निर्माण का इस्तेमाल किया , लेकिन bcयह भी भूल गया ।
— शेषमारा
या for(;;){i++;-i}(एक ही लंबाई)।
— sch
5

भूलभुलैया , 9 बाइट्स

!`
\:"
 (

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

यह भी काम करता है और अनिवार्य रूप से समान है:

 "
`:(
\!

व्याख्या

इस कोड में नियंत्रण प्रवाह बल्कि मज़ेदार है। याद रखें कि एक भूलभुलैया कार्यक्रम में इंस्ट्रक्शन पॉइंटर (आईपी) गैर-अंतरिक्ष वर्णों के पथ का अनुसरण करता है और किसी भी जंक्शन पर स्टैक के शीर्ष की जांच करता है कि कौन सा रास्ता लेना है:

  • यदि स्टैक का शीर्ष सकारात्मक है, तो दाएं मुड़ें।
  • यदि स्टैक का शीर्ष शून्य है, तो सीधे आगे बढ़ते रहें।
  • यदि स्टैक का शीर्ष नकारात्मक है, तो बाएं मुड़ें।

जब आईपी एक मृत अंत हिट करता है, तो यह चारों ओर मुड़ता है (केवल एक बार अंत में कमांड को निष्पादित करता है)। और आईपी पूर्व में ऊपर बाएं कोने में शुरू होता है। यह भी ध्यान दें कि स्टैक का अर्थ अनन्त रूप से शून्य की अनंत राशि से शुरू होना है।

कार्यक्रम इस छोटे से बिट से शुरू होता है:

!    Print top of stack (0).
`    Multiply by -1 (still 0).
:    Duplicate.

अब आईपी प्रासंगिक जंक्शन पर है और सीधे आगे बढ़ता है (जिस पर स्टैक के शीर्ष को घटाता है -1। आईपी ​​एक मृत अंत हिट और चारों ओर बदल जाता है। :स्टैक के शीर्ष को एक बार फिर से डुप्लिकेट करता है। अब स्टैक का शीर्ष ऋणात्मक है और आईपी बाईं ओर (पश्चिम) मुड़ता है। अब हम मुख्य लूप की एक और पुनरावृति निष्पादित करते हैं:

\   Print linefeed.
!   Print top of stack (-1).
`   Multiply by -1 (1).
:   Duplicate.

इस बार, स्टैक का शीर्ष सकारात्मक है, इसलिए आईपी सही (पश्चिम) मुड़ता है और तुरंत मुख्य लूप के एक और पुनरावृत्ति को निष्पादित करता है, जो प्रिंट करता है 1। फिर इसे फिर से नकार दिए जाने के बाद, हमने :साथ मारा-1 स्टैक पर इसके ।

इस बार आईपी (पूर्व) बाएँ मुड़ता है। "सिर्फ एक नहीं सेशन है और आईपी मृत अंत में चारों ओर मुड़ता है। :एक और प्रतिलिपि बनाता है और इस बार आईपी दक्षिण में बदल जाता है। (मान को घटाता है -2, IP फिर से घूमता है। स्टैक के शीर्ष अभी भी नकारात्मक होने के साथ, आईपी अब पश्चिम की ओर मुड़ता है: और मुख्य लूप की अगली पुनरावृत्ति करता है।

इस प्रकार, आईपी अब एक तंग लूप पुनरावृत्ति के बीच पुनरावृत्ति करेगा, एक सकारात्मक संख्या को मुद्रित करेगा, और एक पुनरावृति जो दोनों मृतकों के माध्यम से जाती है, ऋणात्मक संख्या को प्रिंट करने से पहले मूल्य में कमी करने के लिए।

आप स्वयं से पूछ सकते हैं कि "दूसरी पंक्ति में ऐसा क्यों है यदि वह वास्तव में कुछ भी नहीं करता है: इसके बिना, जब आईपी :एक नकारात्मक मूल्य पर पहुंचता है , तो यह बाएं (पूर्व) को चालू नहीं कर सकता है , इसलिए यह इसके बजाय दाएं (पश्चिम) में बदल जाएगा। (अंगूठे के एक नियम के रूप में, यदि जंक्शन पर सामान्य दिशा उपलब्ध नहीं है, तो आईपी विपरीत दिशा लेगा)। इसका मतलब है कि आईपी भी (नीचे कभी नहीं पहुंचेगा और हम सकारात्मक पुनरावृत्तियों से सकारात्मक अंतर नहीं कर सकते।

— मार्टिन एंडर
स्रोत
यह वही है जो मैं आपके उत्तर को देखने से पहले आया था: pastebin.com/VHzAvABe
— रॉबर्ट हिकमैन
5

जावास्क्रिप्ट (ईएस 5), 32 31 30 29 बाइट्स

for(i=0;;)[i++,-i].map(alert)

प्रिंटों 0 -1 1 -2 2 -3 3 -4 4 -5 5 ...

पैट्रिक रॉबर्ट्स के लिए 1 बाइट धन्यवाद! कॉनर ओ'ब्रायन को 2 बाइट्स से बचा लिया गया!

— पॉल शमित्ज़
स्रोत
1
कैसे के [i++,-i].map(alert)बजाय के बारे में alert(i++),alert(-i)?
— कॉनर ओ'ब्रायन
for(;;)एक बाइट से छोटा हैwhile(1)
— पैट्रिक रॉबर्ट्स
@ कोनोरो ब्रायन ईएस 6 mapहै
— पॉल
— कॉनर ओ'ब्रायन
आप i=0;बाइट को बचाने के लिए लूप के लिए बिट को अंदर ले जा सकते हैं ।
— कॉनर ओ'ब्रायन
4

जावा, 65 54 बाइट्स

i->{for(;;)System.out.print(i+++" "+(-i<i?-i+" ":""));

अघोषित परीक्षण कोड

public static void main(String[] args) {
    Consumer<Integer> r = i -> {
        for (;;) {
            System.out.print(i++ + " " + (-i < i ? -i + " " : ""));
        }
    };

    r.accept(0);
}
— शॉन वाइल्ड
स्रोत
3
biggest magnitude of the standard integer type of your language int जावा का मानक पूर्णांक प्रकार है।
— शॉन वाइल्ड
1
इसके बारे में क्षमा करें, इस बीच आवश्यकताएं बदल गई हैं ...
— दोष
2
आप इसे ()->{for(int i=0;;)System.out.print(i+" "+(1-i++));};( 53 बाइट्स ) गोल्फ कर सकते हैं
— केविन क्रूज़सेन
@KevinCruijssen कि रिक्ति को चोदता है ...
— शॉन वाइल्ड
1
अनंत समय को देखते हुए, यह प्रत्येक पूर्णांक को प्रत्येक के अनंत बार प्रिंट करेगा।
— ओलिवियर ग्रेगोइरे
4

सी #, 83 बाइट्स

void f(){for(decimal n=0;;n++){Console.Write(n+",");if(n>0)Console.Write(-n+",");}}

Ungolfed:

void f()
{
  for (decimal n=0;;n++)
  {
    Console.Write(n + ",");
    if (n > 0) Console.Write(-n + ",");
   }
}

आउटपुट:

0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6.......
— पीट आर्डेन
स्रोत
काफी कुछ चीजें हैं जो पात्रों को कम करने के लिए की जा सकती हैं। पहले आप कार्यक्रम एक नामस्थान की जरूरत नहीं है। दूसरे वर्ग के नाम को इतने लंबे समय तक रहने की जरूरत नहीं है। इसके अलावा आप दो कॉल कंसोल। राइटलाइन को करते हैं जिसे एक प्रतिनिधि को सरल बनाया जा सकता है। जबकि सच को आ (;) के लिए आ के लिए सरल बनाया जा सकता है और यदि विवरण को प्रतिनिधि के माध्यम से पहले शून्य के मूल्य के आउटपुट के साथ हटाया जा सकता है।
— निको
धन्यवाद। मुझे नहीं पता था कि क्या कोई प्रतिनिधि "धोखा" दे सकता है?
— पीट आर्डेन
नमस्ते, PPCG में आपका स्वागत है! मुझे लगता है कि आपको यह पढ़ने में दिलचस्प लग सकता है: सी # में गोल्फिंग के लिए टिप्स । इसके अलावा, आपको एक पूर्ण कार्यक्रम की आवश्यकता नहीं है, बस एक फ़ंक्शन करेगा (जब तक कि चुनौती अन्यथा न कहे)। तो void f(){code_present_in_main}बाइट-काउंट के लिए पर्याप्त है। कोड के लिए ही, आप इसे कुछ इस तरह से गोल्फ कर सकते हैं: void f(){for(decimal n=1;;)Console.Write((1-n)+","+n+++",");}( 61 बाइट्स )
— केविन क्रूज़सेन
1
ओह महान, यह अब बहुत स्वस्थ है 85, धन्यवाद! मुझे आपके सभी उत्तर का उपयोग करना सही नहीं लगेगा, लेकिन यह निश्चित रूप से एक सुधार है और उन सुझावों से मेरे भविष्य के गोल्फ में मदद मिलेगी!
— पीट आर्डेन
@PeteArden मैं अपने कोड का उपयोग नहीं करने के लिए समझता हूं, क्योंकि यह एक अलग दृष्टिकोण है। हम्म, आप अभी भी अपने खुद के जवाब में decimal n=0और n++;के लिए लूप के अंदर रखकर 2 बाइट्स गोल्फ कर सकते हैं : void f(){for(decimal n=0;;n++){Console.Write(n+",");if(n>0)Console.Write(-n+",");}}:)
— केविन क्रूज़सेन
4

सी # 86 66 बाइट्स

नया उत्तर:

void b(){for(var i=0;;i++)Console.Write(i==0?","+i:","+i+",-"+i);}

स्पष्ट:

void b() 
{
    for(var i=0;;i++)
        Console.Write(i == 0 ? "," + i : "," + i + ",-" + i);
}

पुराना उत्तर (86 बाइट्स):

void a(){Console.Write(String.Join(",",Enumerable.Range(int.MinValue,int.MaxValue)));}

Ungolfed:

void a()
{
    Console.Write(String.Join(",", Enumerable.Range(int.MinValue, int.MaxValue)));
}
— डैनियल लिप्स
स्रोत
1
2 बेकार व्हाट्सएप हैं। एक पहले Enumerable.Rangeऔर एक पहले int.MaxValue।
— यति
1
PPCG में आपका स्वागत है! +1 आपको यह पढ़ने में दिलचस्प लग सकता है: सी # में गोल्फिंग के लिए टिप्स । आपके वर्तमान उत्तर में (for) लूप के लिए ब्रैकेट को हटाया जा सकता है, क्योंकि अंदर केवल एक ही लाइन है। वैकल्पिक रूप से, यह एक छोटा तरीका है: void f(){for(var n=1;;)Console.Write((1-n)+","+n+++",");}( 57 बाइट्स ) ।
— केविन क्रूज़सेन
@ केविनक्रूजसेन धन्यवाद। ब्रैकेट चले गए हैं।
— डैनियल लिप्स
4

पवरशेल, २० 19 18 बाइट्स

टिम्मीड के जवाब से बेशर्मी से चोरी करने में सुधार हुआ 

0;for(){-++$i;$i}

आउटपुट:

0
-1
1
-2
2
-3
3
-4
4

पुराना संस्करण:

for(){-$i;$i++;$i}

यकीन नहीं क्यों tbh, लेकिन - अघोषित चर (या - $ null) 0 के रूप में विकसित किया गया है, जिसने हमें इस संस्करण में 2 बाइट्स बचाए ...

— जो कुछ
स्रोत
1
PPCG में आपका स्वागत है!
— AdmBorkBork
4

ब्रेकीलॉग , 2 बाइट्स

ẉ⊥

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

ẉ     Print with a newline
      the input,
 ⊥    then try again.

चूंकि प्रोग्राम को कोई इनपुट नहीं दिया गया है, इसलिए मुख्य विधेयकों के इनपुट चर को बिना किसी अवरोध के छोड़ दिया जाता है। सबसे पहले, इसे 0 माना जाता है, लेकिन जब निष्पादन हिट होता है ⊥, तो यह विफलता के एकमात्र संभावित बिंदु पर वापस आ जाता है: इनपुट चर के लिए मूल्य का विकल्प। तो फिर यह 1, और -1 की कोशिश करता है, और हर दूसरे पूर्णांक, एक दूसरे को हमेशा के लिए अलग-अलग रूप से मुद्रित करता है क्योंकि ⊥हमेशा पीछे हटने के लिए मजबूर करता है, और इसके प्रभाव को ẉतुरंत निष्पादित किया जाता है।

— असंबंधित स्ट्रिंग
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.