प्लस-माइनस अनुक्रम

Question

प्लस-माइनस अनुक्रम

प्लस-माइनस अनुक्रम वह है जो दो बीजों के साथ शुरू होता है, a(0)और b(0)। इस अनुक्रम का प्रत्येक पुनरावृत्ति अनुक्रम के पिछले दो सदस्यों का जोड़ और घटाव है। वह है, a(N) = a(N-1) + b(N-1)और b(N) = a(N-1) - b(N-1)।

ऑब्जेक्टिव प्लस-माइनस सीक्वेंस को इनफिनिटी में या पहले Kदिए गए स्टेप्स को प्रोड्यूस करता है K। आप एक अनंत आउटपुट प्रोग्राम, एक जनरेटर, या एक फ़ंक्शन / प्रोग्राम का उपयोग करके ऐसा कर सकते हैं जो पहले Kचरण देता है । आउटपुट ऑर्डर मायने नहीं रखता है, इसलिए जब तक यह सुसंगत है। (Ie, b(K) a(K)या a(K) b(K), कुछ गैर-संख्यात्मक, के बीच में गैर न्यू लाइन विभाजक के साथ।) उत्पादन इनपुट के साथ शुरू करनी चाहिए।

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

इनपुट्स के लिए 10 2( a(0) b(0), यह पहले K दृष्टिकोण के लिए एक संभावित आउटपुट है (या अनंत दृष्टिकोण का उपसमूह):

10     2
12     8
20     4
24     16
40     8
48     32
80     16
96     64
160    32
192    128
320    64
384    256
640    128
768    512
1280   256
1536   1024
2560   512
3072   2048
5120   1024
6144   4096
10240  2048
12288  8192
20480  4096
24576  16384
40960  8192
49152  32768
81920  16384
98304  65536

जानकारी के लिए 2 20 10( a(0) b(0) k):

2     20
22   -18
4     40
44   -36
8     80
88   -72
16    160
176  -144
32    320
352  -288

---

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

Comments

मैं एक (2n) = a (0) · 2 b और b (2n) = n (0) · 2 probably नोटिस करता हूं, लेकिन यह शायद यहां उपयोगी नहीं है।

— नील

क्या गैर-न्यूमेरिक विभाजक के बीच aऔर bएक नई रेखा हो सकती है?

— स्वेचर

@ नहीं, यह नहीं हो सकता।

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ स्पष्टीकरण के लिए धन्यवाद!

— स्वेवर

एक अनुक्रम लौटना ठीक है @guifa

— कॉनर ओ'ब्रायन

Answer 1

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

ṄI;Sß

यह एक पुनरावर्ती दृष्टिकोण है। टेल कॉल ऑप्टिमाइज़ेशन के कारण, एकमात्र सीमा दोनों पूर्णांकों को मेमोरी में फिट करने की क्षमता है। आउटपुट प्रति पंक्ति एक सूची है।

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

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

ṄI;Sß  Main link. Argument: [b[n], a[n]] (n = 0 for original input)

Ṅ      Print [b[n], a[n]] to STDOUT.
 I     Compute the increments of the list, i.e., [a[n] - [b[n]].
   S   Compute the sum of the list, i.e., b[n] + a[n].
  ;    Concatenate the results to the left and to the right.
    ß  Recursively call the main link.

Comments

वाह। यह काफी प्रभावशाली है।

— कॉनर ओ'ब्रायन

Main linkवास्तव में क्या मतलब है?

— बिल्ली

@cat यह C के मुख्य कार्य की तरह है। प्रत्येक पंक्ति एक अलग फ़ंक्शन / लिंक को परिभाषित करती है, लेकिन कार्यक्रम निष्पादित होने पर अंतिम स्वचालित रूप से कॉल हो जाती है।

— डेनिस

> जेली कार्यक्रमों में 257 विभिन्न यूनिकोड वर्ण शामिल हैं। वहाँ एक बाइट में 256 बिट्स नहीं है?

— thepiercingarrow

@MarkWright ¶और लाइनफीड को परस्पर उपयोग किया जा सकता है। आप UTF-8 मोड में दोनों का उपयोग कर सकते हैं, लेकिन केवल \x7fजेली के कोड पृष्ठ में उनका प्रतिनिधित्व करने के लिए है।

— डेनिस

Answer 2

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

def f(a,b):print a,b;f(a+b,a-b)

हमेशा के लिए प्रिंट। ठीक है, अंततः आप पुनरावृत्ति सीमा को पार कर जाते हैं, लेकिन यह एक सिस्टम सीमा है।

Comments

आपको लगता है कि किसी त्रुटि की पुनरावृत्ति होने से पहले यह कब तक चल सकता है?

— आर। कप

@ R.Kap यह ~ 1000 है। आप इस सीमा को जो कुछ भी चाहते हैं, उसे सेट कर सकते हैंsys.setrecursionlimit

— Mathias711

@ R.Kap मेरी मशीन पर लगभग 10 सेकंड लगते हैं।

— xnor

पुनरावर्ती त्रुटि बढ़ाने से पहले 10 सेकंड? वाह। पायथन 3 में, मैं 30 मिनट के लिए सीधे जाने देता हूं, और कोई भी त्रुटि नहीं हुई। मैं संख्याओं में से एक के लिए 2000 से अधिक अंक प्रिंट करने में सक्षम था! मुझे लगता whileहै कि आप जो कर रहे हैं, उससे अलग लूप व्यवहार करता है।

— आर। कप

मैंने एक लैम्ब्डा के साथ इसका उपयोग करने की कोशिश की, लेकिन इसे अधिक बाइट्स ( f=lambda a,b:print(a,b)or f(a+b,a-b))

— मिल्कीवेय

Answer 3

MATL , 10 बाइट्स

`tDtswPdhT

यह संस्करण प्लस-माइनस अनुक्रम में तत्वों की एक अनंत संख्या को आउटपुट करेगा।

इसे ऑनलाइन आज़माएं! (अनंत लूप के कारण चलने के बाद इसे रोकें)

व्याख्या

    % Implicitly grab input as a two-element array [a,b]
`   % do...while loop
tD  % Duplicate and display the top of the stack
ts  % Duplicate [a,b] and add them together
w   % Swap the top two elements on the stack
P   % Swap the order of b and a in preparation for diff
d   % Compute the difference between b and a
h   % Horizontally concatenate [a+b, a-b]
T   % Explicit TRUE to make it an infinite loop
    % Implicit end of the do...while loop

Comments

क्या यह स्वचालित रूप से सभी बहुत बड़ी संख्याओं को वैज्ञानिक संकेतन में बदल देता है?

— आर। कप

@ R.Kap ऐसा लगता है कि यह करता है। यह मूल समस्या कथन में स्पष्ट रूप से निषिद्ध प्रतीत नहीं होता है।

— स्वेअर

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

— आर। कप

MATLAB में अच्छी तरह से (जो MATL हुड के तहत उपयोग करता है), आप आउटपुट प्रारूप को बदल सकते हैं जो आप चाहते हैं। MATL का डिफ़ॉल्ट वैज्ञानिक अंकन पर स्विच करने से पहले 15 नंबर तक प्रदर्शित करना है।

— स्वेअर

OOPS मेरा बुरा, क्षमा करें, हटा दिया गया;)

— thepiercingarrow

Answer 4

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

a#b=a:b:(a+b)#(a-b)

संख्याओं का अनंत क्रम उत्पन्न करता है। उपयोग उदाहरण:

Prelude> take 20 $ 2#20

[2,20,22,-18,4,40,44,-36,8,80,88,-72,16,160,176,-144,32,320,352,-288]

Answer 5

अजगर, 10 9 बाइट्स

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

#=Q,s
Q-F

जोड़े का अनंत क्रम प्रिंट करता है।

$ pyth plusminus.p <<< "[10,2]" | head -n 15
[10, 2]
[12, 8]
[20, 4]
[24, 16]
[40, 8]
[48, 32]
[80, 16]
[96, 64]
[160, 32]
[192, 128]
[320, 64]
[384, 256]
[640, 128]
[768, 512]
[1280, 256]

Comments

पहले और आखिरी Qएस को हटाया जा सकता है - पार्थ उन्हें अंतर्निहित रूप से भर देगा।

— isaacg

@ आइसाकग तो लागू हो गया? ठंडा। मैंने पहले वाले को हटाने की कोशिश की, लेकिन वह काम नहीं किया।

— पुरकाकूदरी

यह अजीब है, मेरी मशीन पर काम करने वाले पहले को हटाना।

— isaacg

Answer 6

सी, 81 बाइट्स

a,b;main(c){for(scanf("%d%d%d",&a,&b,&c);c--;a+=b,b=a-b-b)printf("%d %d\n",a,b);}

Answer 7

05AB1E , 7 बाइट्स

पहले-के पद्धति का उपयोग करता है । निम्नलिखित के लिए इनपुट:

k
[a, b]

कोड:

FD=OsƂ

स्पष्टीकरण:

F        # For N in range(0, k).
 D=      # Duplicate top of the stack and print without popping.
   O     # Sum up the array.
    sÆ   # Swap and perform a reduced subtraction.
      ‚  # Pair the top two elements. a, b --> [a, b]

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

कोड अस्पष्ट रूप से भाषा के नाम की याद दिलाता है ...

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ Hahaha, दोनों अपठनीय

— अदनान

Answer 8

के, १२

{(+;-).\:x}\

।

k){(+;-).\:x}\[10;10 2]
10  2
12  8
20  4
24  16
40  8
48  32
80  16
96  64
160 32
192 128
320 64

के रूप में भी बुलाया जा सकता है

k)10{(+;-).\:x}\10 2

Comments

11 बाइट्स

— स्ट्रीटस्टर

Answer 9

एपीएल, 37 वर्ण

{⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z}

के रूप में इस्तेमाल किया जा सकता है

    {⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z} 10 2
10 2
12 8
20 4
24 16
40 8
48 32
80 16
[...]

या

      {⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z} 10 2 6
10 2
12 8
20 4
24 16
40 8
48 32

Answer 10

मैथॉल्फ , 8 बाइट्स

ô`αp‼+-∟

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

इनपुट को रिवर्स ऑर्डर में ले जाता है, लेकिन यह केवल इसलिए है क्योंकि उन्हें स्टैक पर धकेल दिया जाता है। अन्यथा यह 1 बाइट अधिक लंबा होगा। 2-3 बाइट्स आउटपुट से आते हैं। वास्तव में प्रति पंक्ति एक जोड़ी को मुद्रित करने की आवश्यकता के बिना, कार्यक्रम हो सकता है æ`‼+-∟(अनुक्रम के तत्वों के साथ स्टैक को अनिश्चित काल तक भरता है), या É‼+-∟अनुक्रम के सभी तत्वों को प्रिंट करता है (पहले एक डिबग को छोड़कर, जब तक -dझंडा सक्रिय है) ।

व्याख्या

ô      ∟   do-while-true
 `         duplicate the top two items
  αp       wrap last two elements in array and print
    ‼      apply next two operators to the top stack elements
     +     pop a, b : push(a+b)
      -    pop a, b : push(a-b)

Comments

हाय मैक्स। कब से यकीन नहीं है, लेकिन वर्तमान में टीआईओ पर मैथॉल्फ वर्जन, स्ट्रिंग इनपुट को बिल्कुल भी स्वीकार नहीं करता है .. इससे कोई फर्क नहीं पड़ता कि मैं किस बिल्ट का उपयोग करता हूं, यहां तक ​​कि प्रोग्राम के लिए किसी भी कोड के बिना, अगर एक स्ट्रिंग इनपुट के लिए दिया जाता है उदाहरण के लिए ABC, मुझे stdin = StdIn(line)पायथन कोड में लाइन पर एक त्रुटि मिलती है ..

— केविन क्रूज़सेन

@ केविनक्रूजसेन हाय! स्ट्रिंग इनपुट के रूप में 'ABC'या दिया जाना चाहिए "ABC"। आंतरिक रूप से, ast.literal_evalइनपुट पार्स करने के लिए उपयोग किया जाता है। अभी भी कुछ quirks बाहर इस्त्री करने की आवश्यकता है, लेकिन आप ऐसा करने में सक्षम होना चाहिए यह ।

— मैक्स जूल

आह ठीक है, यह समझ में आता है। Btw, क्या एक स्ट्रिंग एक स्ट्रिंग / संख्या को कुछ निश्चित आकार के हिस्सों में विभाजित करने के लिए है या कुछ मात्रा में समान आकार के भागों में है? यानी ABCDEFकरने के लिए [AB, CD, EF]?

— केविन क्रूज़सेन

Nvm, जाहिरा तौर पर वहाँ नहीं है, लेकिन मुझे ऐसा करने का एक तरीका मिल गया है: 2ô_2<\1>](हार्ड-कोडेड इनपुट-लंबाई 6 और आकार 2 के कुछ हिस्सों में विभाजित हो गया, क्योंकि मुझे यही चाहिए था, लेकिन शायद होना चाहिए सामान्य इनपुट-आकार और भाग-आकार के लिए काम करने के लिए परिवर्तनीय)।

— केविन क्रूज़सेन

शायद आपने स्ट्रिंग्स के लिए डिवीजन ऑपरेटर के व्यवहार की अनदेखी की है? /वास्तव में आप क्या कहते हैं, वर्णों के टुकड़ों में विभाजित है । इसे बाहर की जाँच करें$n$

— मैक्स

Answer 11

पायथन 3.5, 55 43 बाइट्स:

def q(a,b):
 while 1:print(a,b);a,b=a+b,a-b

सही अनुक्रम हमेशा के लिए प्रिंट करता है। मैंने इसे बिना किसी त्रुटि के लगभग 30 मिनट तक चलने दिया, और कार्यक्रम ने पहले नंबर के लिए 2301 अंक और दूसरे के लिए 1150 अंक छपवाए थे! इसके आधार पर, मेरा अनुमान है कि, चलाने के लिए पर्याप्त हार्डवेयर उपलब्ध कराया जा रहा है, यह WAY लंबे समय तक चल सकता है और WAY अधिक अंक प्रिंट कर सकता है, और सैद्धांतिक रूप से कोई पुनरावृत्ति सीमा नहीं है, शिष्टाचार while!

Comments

मुझे लगता है कि आप लूप की शुरुआत में वर्तमान मानों को प्रिंट करने वाले हैं, ताकि पहला आउटपुट इनपुट के समान हो। इसके अलावा, जैसा कि यह कोड गोल्फ है, आपको कोष्ठक और मध्यवर्ती चर को अनुकूलित करना चाहिए। अंत में, एक स्टाइल नाइट के रूप में, मुझे लगता है कि आपको चर नामकरण aऔर bप्रश्न का मिलान करने पर विचार करना चाहिए ।

— नील

@Neil सुझावों के लिए धन्यवाद। :)

— आर। कप

मैं उलझन में हूं; अब आपको एक whileऔर एक पुनरावर्ती कॉल मिल गया है ...

— नील

@ नील हां, मैंने उस पर गौर नहीं किया। अब यह तय हो गया है, और बस थोड़ी देर के लिए, सैद्धांतिक रूप से कोई सीमा नहीं है।

— आर। काप

Answer 12

रेंग v.3.2, 9 बाइट्स (स्व-उत्तर, गैर-प्रतिस्पर्धात्मक)

ii¤ææö±2.

दो इनपुट ( a b) और आउटपुट लेता है b a। यहाँ कोशिश करो!

iदो बार इनपुट लेता है, ¤स्टैक को डुप्लिकेट करता है, æएक नंबर और एक स्पेस प्रिंट करता है (और ऐसा दो बार करता है, दो होने के नाते), öएक न्यूलाइन प्रिंट ±करता है , वही करता है जो आप उम्मीद कर सकते हैं, और 2.अगले दो वर्णों को छोड़ देता है, इनपुट प्राप्त वर्णों के चारों ओर लपेटता है।

Comments

हम्म, क्या आप समझेंगे कि उनमें से प्रत्येक चित्रलिपि मेरे जैसे एक नवाब के लिए क्या करती है? :)

— केविन क्रूज़सेन

@ केविनक्रूजसेन मैंने रहस्य समझाया है। :)

— कॉनर ओ'ब्रायन

Answer 13

पायथन 2.7, 56 , 42 बाइट्स:

a,b=input()
while 1:print a,b;a,b=a+b,a-b

सरल लूप जो या तो हमेशा के लिए प्रिंट करता है (ईश)।

Comments

बाइट्स को बचाने के लिए आप इंडेंट स्तर के लिए एकल स्थान का उपयोग कर सकते हैं। साथ ही, आपको दोनों विधियों को करने की आवश्यकता नहीं है, बस एक या दूसरे, ताकि आप डिफ़ॉल्ट पैरामीटर को हटा सकें।

— कॉनर ओ'ब्रायन

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

— सेरडेलिस

यदि आप पहली पंक्ति को बदलकर इसे एक कार्यक्रम बनाते हैं a,b=input(), तो आप इंडेंट को निकाल सकते हैं।

— xnor

@xnor धन्यवाद, केवल 1 बाइट बचाता है, लेकिन यह बदसूरत नहीं है!

— सर्दालिस

Answer 14

बैच, 54 बाइट्स

@echo %1 %2
@set/aa=%1+%2
@set/ab=%1-%2
@%0 %a% %b%

ध्यान दें कि CMD.EXE 32-बिट हस्ताक्षरित पूर्णांकों तक सीमित है, इसलिए यह जल्दी से कचरा और त्रुटि संदेशों को ओवरफ्लो और प्रिंट करेगा।

Comments

हमेशा एक बैच का जवाब इधर-उधर देखना अच्छा लगता है! : डी

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ मैंने इसे विशेष रूप से आपके लिए लिखा है।

— नील

Answer 15

जूलिया, 25 बाइट्स

a<|b=[a b]|>show<a+b<|a-b

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

वैकल्पिक संस्करण, 29 बाइट्स

ध्यान दें कि जब तक आप BigInt<| पर कॉल नहीं करते, आउटपुट अंततः ओवरफ्लो हो जाएगा । दुर्भाग्य से, इस मामले में प्रत्येक सरणी के साथ उपसर्ग करेगा । चार और बाइट्स की कीमत पर, हम सभी संख्यात्मक प्रकारों के लिए व्हॉट्सएप-अलग-अलग आउटपुट उत्पन्न कर सकते हैं।showBigInt

a<|b="$a $b
"|>print<a+b<|a-b

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

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

हम बाइनरी ऑपरेटर <|को उद्देश्यों के लिए परिभाषित करते हैं। यह जूलिया के हाल के संस्करणों में अपरिभाषित है, लेकिन अभी भी पार्सर द्वारा एक ऑपरेटर के रूप में मान्यता प्राप्त है। जबकि \(स्पष्ट रूप से पूर्णांकों के लिए परिभाषित नहीं) एक बाइट कम है, इसकी उच्च पूर्वता की जगह की आवश्यकता होगी a+b<|a-bके साथ (a+b)\(a-b)(+3 बाइट्स) या \(a+b,a-b)(+2 बाइट्स)।

जब a<|bनिष्पादित किया जाता है, तो यह [ab] से STDOUT showतक प्रिंट करने के लिए कॉल करके शुरू होता है । फिर, राशि या अंतर पर पुनरावर्ती कॉल करता है।a+b<|a-b<|

चूंकि रिकर्सन (माना जाता है) अनंत है, तुलना <कभी नहीं की जाती है; यह एकमात्र उद्देश्य कोड के दो भागों का पीछा कर रहा है। यह अधिक सरल विकल्प पर दो बाइट्स बचाता है ([a b]|>show;a+b<|a-b)।

Answer 16

पर्ल 6 , 23 बाइट्स (अनंत)

संपादित करें: जोकिंग के लिए धन्यवाद, अनुक्रम संस्करण अब सबसे छोटा है ( .sayओपी से प्रति स्पष्टीकरण भी हटा दिया गया है :

{@_,{.sum,[-] |$_}...*}

TIO: InfiniteSeq

पुराना कार्यात्मक उत्तर

->\a,\b {(a,b).say;f(a+b,a -b)}

TIO: InfiniteFunc

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

Comments

अनंत के लिए 23 बाइट्स

— जो किंग

@ जॉकिंग: अच्छा लगा! मैं .sum के बारे में नहीं सोच के लिए मूर्खतापूर्ण महसूस करता हूं। मुझे लगता है कि आवश्यकताओं (मैं स्पष्टीकरण के लिए कहा है, लेकिन सबसे ज्यादा दूसरों कि है, उस के साथ 28 देता प्रतीत समारोह में outputing लाचार tio.run/##K0gtyjH7n1upoJamYPu/... )

— user0721090601

Answer 17

फैक्टर, 62 बाइट्स

:: f ( a b -- x ) a b "%s %s" printf a b + a b - f ; recursive

recursive, या फिर कॉलस्टैक बहुत जल्दी खत्म हो जाता है।

Answer 18

रूबी, 25 बाइट्स

Xnor के पायथन समाधान के आधार पर । शायद मैं एक अन्य उत्तर में एक जनरेटर बनाऊंगा, लेकिन यह प्रिंट करेगा a, फिर b, फिर नया a, फिर नया b, विज्ञापन infinitum।

f=->a,b{p a,b;f[a+b,a-b]}

Answer 19

पायथन 3, 42 बाइट्स

मैं इस फ़ंक्शन के लिए एक जनरेटर लिखना चाहता था, और इसलिए मैंने किया।

def f(a,b):
 while 1:yield a,b;a,b=a+b,a-b

पायथन 3 में, इस प्रकार अनुक्रम उत्पन्न होता है:

>>> gen = f(2, 20)
>>> next(gen)
(2, 20)
>>> next(gen)
(22, -18)
>>> next(gen)
(4, 40)
>>> next(gen)
(44, -36)
>>> next(gen)
(8, 80)

Answer 20

आम लिस्प, 57

(lambda(a b)(loop(print`(,a,b))(psetf a(+ a b)b(- a b))))

उपयोग psetf, जो समानांतर में चर और सरल loopवाक्यविन्यास के मूल्यों को प्रभावित करता है ।

Answer 21

बैश + जीएनयू कोरुटिल्स, 75 बाइट्स

a=$1
b=$2
for i in `seq $3`;{ echo -e "$a\t$b";c=$a;a=$((c+b));b=$((c-b));}

मंगलाचरण:

./codegolf.sh 2 10 5

Answer 22

सीपी / एम 8080, 47 बाइट्स

z80 mnemonics लेकिन 8080 के पास कुछ भी नहीं है, स्रोत ने एक बार टिप्पणी की थी कि मैंने इनपुट के बजाय आउटपुट को गिनने का फैसला किया था, लेकिन ट्रिक फ़ंक्शन नाम बनाए रखा, हाथ इकट्ठे हुए इसलिए 'xx का माफ कर दो जहां मुझे बाइट्स की संख्या पता है, लेकिन बाहर नहीं निकली है आउटपुट पते या ऑफ़सेट:

# setup
ld c, 2     0e 02

# loop
.s

# update H (temporarily in B)
ld a, h     7c
add l       85
daa         27
ld b, a     46

# update L
ld a, h     7c
sub l       95
daa         27
ld l, a     6f

# copy B back to H, output H
ld h, b     60
call +o     cd xx xx

# output L
ld b, l     45
call +o     cd xx xx

# repeat
jr -s       18 xx

# output a two-digit BCD value followed by a space
.o

# output high digit
ld a, b     78
rra         1f
rra         1f
rra         1f
rra         1f
call +ob    cd xx xx

# output low digit
ld a, b     78
call +ob    cd xx xx

# output a space
ld e, #$20  1e 20
call 5      cd 00 05

# return
ret         c9

# output a single BCD digit
.ob
and #$f     e6 0f
add #$30    c6 30
ld e, a     5f
call 5      cd 00 05
ret         c9

Answer 23

क्लोजर, 44 बाइट्स

#(iterate(fn[[a b]][(+ a b)(- a b)])[%1 %2])

फंक्शन जो एक अनंत आलसी अनुक्रम पैदा करता है।

Answer 24

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

की आवश्यकता -E(मुक्त)

sub a{say"@_";($c,$d)=@_;a($c+$d,$c-$d)}

या (एक ही लंबाई)

$_=<>;{say;/ /;$_=$`+$'.$".($`-$');redo}

(मैंने बाद के माध्यम से मारा क्योंकि इसमें कुछ पुनरावृत्तियों के लिए गोल त्रुटियां होनी चाहिए।)

टोपी की नोक।

लेकिन मुझे संदेह है कि एक छोटा पर्ल 5 समाधान होना चाहिए।

Comments

यदि कोई छोटा समाधान है, तो टन हास्पेल इसे खोज लेगा। : पी

— कॉनर ओ'ब्रायन

कुछ समय लगा, लेकिन मुझे एक छोटा रास्ता मिल गया:

— Xcali

Answer 25

रिटन , 21 बाइट्स

[¤.' ,$.'
,¤¤+2ª-F]=F

Try it here.

पुनरावर्ती संचालक-लंबोदर। उपयोग:

[¤.' ,$.'
,¤¤+2ª-F]=F10 2F

व्याख्या

[                 ]=F  declare function F for recursion
 ¤.' ,$.'␊,            output top 2 stack items along with trailing newline
           ¤¤+2ª-      get plus and minus of top 2 stack items
                 F     recurse!

Answer 26

> <> , 26 बाइट्स

:?!;1-r:n48*o:@@:nao:@+}-$

इससे कॉल a, b, nढेर पर है, जहां nघुमावों की संख्या या अनंत उत्पादन के लिए एक नकारात्मक मूल्य है। एक स्थान से आउटपुट aऔर bअलग।

एक स्पष्टीकरण के रूप में, यहां बताया गया है कि रनटाइम के दौरान स्टैक कैसे विकसित होता है:

abn
nba
nbaa
naab
naabb
nabab
nab+
+nab
+n-
+-n

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

$ python fish.py -c ':?!;1-r:n48*o:@@:nao:@+}-$' -t 0.01 -v 10 2 -1
10 2
12 8
20 4
24 16
40 8
48 32
80 16
96 64
160 32
192 128
320 64
384 256
640 128
768 512
1280 256
1536 1024
2560 512
3072 2048
5120 1024
6144 4096
10240 2048
12288 8192
20480 4096
24576 16384
40960 8192
49152 32768
81920 16384
98304 65536
163840 32768
196608 131072
327680 65536
393216 262144
655360 131072
786432 524288
1310720 262144
[...]

Answer 27

फजी ऑक्टो गुआकामोल , 17 16 बाइट्स

(गैर-प्रतिस्पर्धात्मक, चुनौती की तुलना में बाद में सुविधाओं का उपयोग करता है)

^^(:C.Zs.aZ.s.-)

क्लाइंट-साइड त्रुटियों के कारण इसे बनाना कठिन था। लेकिन मैं समझ गया!

पूर्वाभ्यास:

^^                # Get input twice, pushes it to the stack.
  (               # Start a infinite loop.
   :              # Prints the stack, and since it has [a,b] is just the output.
    C             # Copy the active stack to the inactive stack.
     .            # Shift the active stack.
      Z           # Reverse the stack.
       s          # Move the top item on the active stack to the top of the inactive.
        .         # Switch stacks again.
         a        # Add the top 2 items, giving the first new item.
          Z       # Reverse the stack, so we keep the 'a' safe and prepare for the 'b'.
           .      # Switch stacks.
            s     # Move the top item on the active stack to the top of the inactive stack.
             .    # Switch stacks.
              -   # Minus the top 2 items, giving 'b'.
               )  # End infinite loop.

Comments

मैं FOG को अच्छी तरह से नहीं जानता, लेकिन क्या आप :लूप की शुरुआत में नहीं जा सकते और दो बार प्रिंटिंग की आवश्यकता को समाप्त कर सकते हैं?

— कॉनर ओ'ब्रायन

oooooh @ CᴏɴᴏʀO'Bʀɪᴇɴ धन्यवाद।

— 16

स्पष्टीकरण को अद्यतन करने के लिए मत भूलना;)

— कोनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ whadda ya मतलब? : P

— R

Answer 28

गंभीरता से, 12 बाइट्स

,,1WX■@│+)-1

आउटपुट एक अनंत धारा है, प्रारूप है b(n) a(n), प्रति पंक्ति आउटपुट का एक जोड़ा है।

कोई ऑनलाइन लिंक नहीं क्योंकि TryItOnline अनंत लूप्स के साथ इतना अच्छा नहीं करता है।

स्पष्टीकरण:

,,1WX■@│+)-1
,,1           push a(0), push b(0), push 1
   W          while loop:
    X           discard the 1 (only used to make sure the while loop always runs)
     ■          print all stack elements, separated by spaces, without popping
      @│        swap, duplicate entire stack
        +)      push a(n) + b(n) (a(n+1)) and move it to the bottom of the stack
          -     push a(n) - b(n) (b(n+1))
           1    push 1 to make sure the loop continues

Answer 29

जे, 16 12 बाइट्स

0&(]+/,-/)~<

दिए गए बीजों के आधार पर अनुक्रम के लिए केवल पहले k मानों का उत्पादन करता है ।

इस टिप्पणी में @randomra द्वारा दिखाए गए ट्रिक (या सिंटैक्टिक शुगर) का उपयोग करके 4 बाइट्स को बचाया ।

प्रयोग

   f =: 0&(]+/,-/)~<
   2 20 f 10
  2   20
 22  _18
  4   40
 44  _36
  8   80
 88  _72
 16  160
176 _144
 32  320
352 _288

Answer 30

सी #, 50 बाइट्स

f=(a,b)=>{Console.WriteLine(a+" "+b);f(a+b,a-b);};

पूर्ण स्रोत, परीक्षण मामले सहित:

using System;
using System.Numerics;

namespace PlusMinusSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<BigInteger,BigInteger>f=null;
            f=(a,b)=>{Console.WriteLine(a+" "+b);f(a+b,a-b);};
            BigInteger x=10, y=2;
            f(x,y);
        }
    }
}

BigInteger डेटा प्रकार का उपयोग किया जाता है, इसलिए नंबर ओवरफ्लो नहीं होते हैं और 0. हो जाते हैं। हालांकि, यह एक पुनरावर्ती समाधान है, एक स्टैक ओवरफ्लो की उम्मीद है।