सोमवार मिनी गोल्फ: शॉर्ट कोड-गोल्फ चुनौतियों की एक श्रृंखला , हर सोमवार (उम्मीद!) पोस्ट की गई।

एक फाइबोनैचि जैसा अनुक्रम प्रसिद्ध फाइबोनैचि अनुक्रम के समान विधि का उपयोग करके प्राप्त किया जाता है ; वह है, प्रत्येक संख्या F (n) अनुक्रम में पिछले दो संख्याओं को जोड़कर ( F (n) = F (n-1) + F (n-2) ), या अगली दो संख्याओं को घटाकर ( F (n) = F (n + 2) - F (n + 1) )। मुख्य अंतर यह है कि ये अनुक्रम किसी भी दो संख्याओं से शुरू हो सकते हैं। इन अनुक्रमों का शून्य-अनुक्रमण विवादित है, लेकिन अभी के लिए, हम इस नियम का उपयोग करने जा रहे हैं:

एक फिबोनाची-क्रम में 0 नंबर अंतिम संख्या है जो पूर्ववर्ती संख्या से छोटी है।

एक उदाहरण के रूप में, फिबोनाची अनुक्रम के रूप में लिखा जा सकता है 1, 0, 1, 1, 2, 3, 5..., इसलिए अनुक्रम में 0 वां नंबर अकेला है 0।

चुनौती

चुनौती का लक्ष्य किसी भी प्रारूप में एक प्रोग्राम या फ़ंक्शन लिखना है जो तीन पूर्णांकों में होता है:

ए और बी , दो नंबर जिसके साथ एक अनुक्रम उत्पन्न करना शुरू करना है।
एन , आउटपुट के लिए परिणामी अनुक्रम की लंबाई।

और 0 वें से शुरू होने वाले अनुक्रम के पहले एन नंबर को आउटपुट करता है ।

विवरण

ए , बी और एन को किसी भी क्रम और प्रारूप में लिया जा सकता है, जब तक कि वे नेत्रहीन अलग हो जाते हैं। यदि आप एक अलग ऑर्डर / प्रारूप का उपयोग करते हैं, तो कृपया बताएं कि यह क्या है।
आप मान सकते हैं कि ए , बी और एन हमेशा सकारात्मक पूर्णांक हैं।
आप मान सकते हैं कि N 100 से अधिक नहीं है, और परिणामी अनुक्रम में नहीं होगा x >= 2^31।
यदि A , B से बड़ा है , तो B अनुक्रम में 0 वां नंबर है।
आउटपुट को रिक्त स्थान, अल्पविराम, और / या newlines द्वारा अलग किया जाना चाहिए।
एक अनुगामी अंतरिक्ष या न्यू लाइन की अनुमति दी है, लेकिन है नहीं पीछे अल्पविराम।

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

उदाहरण 1:

8 13 10

पिछड़े से काम करते हुए 8 13जब तक हम पिछले से एक नंबर बड़ा नहीं पाते हैं, तब तक हम प्राप्त करते हैं 13 8 5 3 2 1 1 0 1। इस प्रकार, 0इस क्रम में 0 वां नंबर है। इससे आगे काम करते हुए, हम 0अगले 9 सदस्यों का प्रिंट आउट लेते हैं:

0 1 1 2 3 5 8 13 21 34

उदाहरण 2:

23 37 5

0 वें नंबर को खोजने के लिए फिर से काम करते हुए, हम पाते हैं 37 23 14 9 5 4 1 3। इस समय 0 नंबर है 1, इसलिए हम इसे अगले 4 सदस्यों के साथ प्रिंट करते हैं:

1 4 5 9 14

उदाहरण 3:

4 3 8

इस एक के साथ, हमें 0 वें नंबर को खोजने के लिए पिछड़े काम नहीं करना है, क्योंकि इससे 3छोटा है 4:

3 7 10 17 27 44 71 115

उदाहरण 4:

29 47 11

परिणाम:

1 3 4 7 11 18 29 47 76 123 199

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे कम वैध कोड है। टाईब्रेकर पहले पोस्ट किए गए सबमिशन में जाता है। ~~विजेता को अगले सोमवार, 28 सितंबर को चुना जाएगा। शुभकामनाएँ!~~

संपादित करें: एक अद्भुत 23 बाइट्स के लिए पायथ का उपयोग करते हुए, अपने विजेता, @ जाकुब को बधाई !

— ETHproductions
स्रोत

10

मैंने आपके द्वारा बनाया गया [सोमवार-मिनी-गोल्फ] टैग हटा दिया है। मुझे नहीं लगता कि हमें चुनौतियों के अधिक या कम मनमाने समूहों के लिए टैग बनाने चाहिए। टैग वास्तव में आपको चुनौती के बारे में कुछ भी नहीं बताता है, और यदि आप इन सभी को ढूंढना चाहते हैं, तो कोई खोज बार में वाक्यांश खोज सकता है। वैकल्पिक रूप से, यदि आप भविष्य की हर किश्त में इस पहली चुनौती का लिंक शामिल करते हैं, तो वे सभी साइडबार में "लिंक किए गए प्रश्नों" के तहत जुड़े होंगे।

— मार्टिन एंडर

@ मार्टिनबटनर ठीक है, धन्यवाद; में इसे याद रखूंगा।

— ETHproductions

क्या मैं इनपुट ले सकता हूं कि मैं इसे कैसे चाहता हूं (ए पायथन लिस्ट शाब्दिक [8, 13, 10])?

— ब्लू '

3

वर्तमान में चुनौती कहती है कि एक कार्यक्रम लिखो । क्या इसका मतलब है कि कार्यों की अनुमति नहीं है? (CC @LuisMendo)

— डेनिस

3

@ डेनिस सॉरी, मेरा दिमाग खिसक गया। कार्य करने की भी अनुमति है। यह बात बताने के लिए धन्यवाद!

— ETHproductions

12

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

AQWgHGA,-HGG)VvwHA,H+GH

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

पायथ प्रोग्रामिंग की काफी असामान्य शैली। कभी-कभी फंक्शनल प्रोग्रामिंग की अपनी डाउनसाइड होती है।

स्पष्टीकरण:

AQWgHGA,-HGG)VvwHA,H+GH  Q = input list of the two starting numbers
AQ                       G, H = Q (unpacking Q)
  WgHG                   while H >= G:
      A,-HGG                G, H = [H - G, G]
            )            end while
              vw         read a number from input
             V           for N in range(^):
                H           print H
                 A,H+GH     G, H = [H, G + H]

— Jakube
स्रोत

12

रेटिना , 65 54 बाइट्स

+`(1*),\1(1*)
$2,$1
+`(1*)(,1*);1\B
$1$2$2$1;
^1*,|;1
<empty>

यहाँ, <empty>एक खाली अनुरेखण रेखा का प्रतिनिधित्व करता है। -sध्वज के साथ कोड को एकल फ़ाइल के रूप में चलाएँ ।

इनपुट प्रारूप है

A,B;N

जहाँ संख्याओं को एकात्मकता में दर्शाया जाता है । आउटपुट एक अल्पविराम से अलग की गई सूची है, जो एकात्मक में भी है। उदाहरण के लिए:

8 13 10

होने वाला

11111111,1111111111111;1111111111

और उपज

,1,1,11,111,11111,11111111,1111111111111,111111111111111111111,1111111111111111111111111111111111

व्याख्या

+`(1*),\1(1*)
$2,$1

सबसे पहले, हम कम करने Aऔर B0 और -1st तत्व करने के लिए। +रेटिना बताता है जब तक या तो रेगुलर एक्सप्रेशन मिलान का बंद हो जाता है या प्रतिस्थापन स्ट्रिंग संशोधित नहीं करता है इस regex प्रतिस्थापन दोहरा रखने के लिए। Regex कैप्चर Aके साथ समूह 1 में (1*), और उसके बाद यह सुनिश्चित करें कि बनाता है Bबड़ा के रूप में कम से कम है के रूप में A, जबकि पर कब्जा करने B-Aके साथ \1(1*)यह सुनिश्चित करता है समूह 2. में है कि इस पाश समाप्त एक बार A>B।

प्रतिस्थापन केवल मैच को सेट करके बदल A,Bजाता B-A,Aहै $2,$1।

+`(1*)(,1*);1\B
$1$2$2$1;

अब हम पहले से ही स्ट्रिंग में आवश्यक आउटपुट की पहली संख्या प्राप्त कर चुके हैं (साथ ही इससे पहले वाला, जिसे हमें बाद में हटाने की आवश्यकता होगी)। यह प्रतिस्थापन अब 1से लेते समय अंतिम दो संख्याओं के योग के रूप में एक और संख्या जोड़ता है N। क्योंकि हमारे पास पहले से ही एक संख्या है हम चाहते हैं कि यह केवल हो N-1। हम यह सुनिश्चित करके करते हैं \Bकि ;11स्ट्रिंग के अंत में अभी भी कम से कम है । यदि हम अनुक्रम के अंतिम दो मूल्यों को कहते हैं Cऔर D, तो रेगेक्स Cसमूह 1 और ,Dसमूह दो में कब्जा कर लेता है । हम वापस उन के साथ लिखते हैं $1$2। फिर हम भी लिखते हैं $2$1कि कौन सा अनुवाद करता है ,D+C। ध्यान दें कि हम अपने द्वारा1 मिलान किए गए एकल को वापस नहीं लिखते हैंN, जिससे इसे घटाया जा रहा है।

^1*,|;1
<empty>

अंत में, हमें अनुक्रम के -1 वें तत्व से छुटकारा पाने की आवश्यकता है, साथ ही साथ बचे हुए ;1से N, जिसे हम बस उन दोनों में से मिलान करके और खाली स्ट्रिंग के साथ प्रतिस्थापित करते हैं।

— मार्टिन एंडर
स्रोत

7

पायथन 2, 93 87 67 61 60 बाइट्स

i,j,l=input()
while j/i:i,j=j-i,i
exec"i,j=j,i+j;print i;"*l

इनपुट मिलता है (शाब्दिक अजगर सूची के रूप में [8,10,13])

0 वें कार्यकाल में काम करता है

फिर जोड़ के अनुक्रम को प्रिंट करता है जब तक कि लंबाई तक नहीं पहुंच गया हो

— नीला
स्रोत

1

अच्छी विधि है। इंडेक्स-कम लूप के लिए for _ in[1]*l:, यह करना थोड़ा कम हैexec"stuff;"*l

— xnor

@ xnor: यह मेरे लिए काफी लंबा दिखाई देता है।

— पुनरावर्ती

से तुलना for _ in[1]*l:stuffकरें exec"stuff;"*l। @xnor ने लूप के लिए सामान भाग में नहीं डाला। या for _ in[1]*l:करने के लिएexec";"*l

— ब्लू

2

आप बदल सकते हैं j>=iके साथ j/i। बस यही पता चला! (क्योंकि आप मान सकते हैं कि A, B, और N हमेशा सकारात्मक पूर्णांक हैं )

— mbomb007

6

CJam, 26 23 बाइट्स

3 बाइट्स बचाने के लिए डेनिस के लिए धन्यवाद।

q~{_@\-_g)}g\@{_@+_p}*t

ऑर्डर में इनपुट लेता है N B A(किसी भी तरह की सफेद जगह से अलग)। परिणाम को एक नई-पृथक सूची के रूप में प्रिंट करता है और एक त्रुटि के साथ समाप्त होता है ।

इसका परीक्षण यहां करें।

व्याख्या

0 तत्व को खोजने पर यह एक कदम और आगे बढ़ जाता है। अर्थात, मानों में से एक नकारात्मक होने के बाद समाप्त हो जाता है।

q~      e# Read and evaluate input, pushing N, B and A on the stack.
{       e# do while...
  _@\-  e#   B, A = A, B-A
  _W>   e#   Check if A is still non-negative.
}g
\@      e# Reorder N B A into A B N.
{       e# Run the following N times...
  _@+   e#   A, B = B, A+B
  _p    e#   Print B.
}*
t       e# The last A, B are still on the stack. We remove them by trying to
        e# execute a ternary operator: it pops the first two values but then
        e# terminates the program with an error, because there is no third value.

— मार्टिन एंडर
स्रोत

q~{_@\-_g)}g\@{_@+_p}*t( N B A) तीन बाइट्स बचाता है।

— डेनिस

जब मैं CJam में इसे हल करने की कोशिश कर रहा था, तो मुझे उदाहरण 1 से इनपुट में परेशानी हुई। अब मैं देखता हूं कि यह समाधान अपेक्षित आउटपुट नहीं देता है। यहाँ दोष कहाँ है? मुझे लगता है कि इसके लिए जाँच करने के बजाय B>Aइसे B not smaller than Aया कुछ और के लिए जाँच करना होगा, लेकिन मैं यह नहीं समझ सकता कि सीजेएम में ऐसा कैसे करें। संपादित करें: डेनिस समाधान सही आउटपुट प्रिंट करता है।

— कैबी 4040

खैर, मैंने इसे अपने समाधान में हल किया।

— कैबी 407

@ Cabbie407 आप सही हैं, मुझे <!इसके बजाय उपयोग करना चाहिए था >।

— मार्टिन एंडर

आह ठीक है। मैं सोच रहा था कि !इस में कहाँ रखूँ । मैंने इसे काम करने के लिए बस एक जोड़ा;)

— काबी ४० Sep० '

5

भूलभुलैया , 58 54 49 46 44 बाइट्स

बिटवाइज़ नकार के उपयोग का सुझाव देने के लिए Sp3000 के लिए धन्यवाद, जिसने दो बाइट्स को बचाया।

??#"{=
  ;  -
@"~~:}
~""
?
"}}:=
(   +
{{\!:

इनपुट प्रारूप है B A N। आउटपुट एक नई पंक्तिबद्ध सूची है।

व्याख्या

(थोड़ा पुराना है। मूल विचार अभी भी वही है, लेकिन कोड का लेआउट अब अलग है।)

यह मेरे CJam उत्तर के रूप में एक ही विचार का उपयोग करता है (इसलिए क्रेडिट अभी भी डेनिस जाते हैं): जब हम अनुक्रम को रोकते हैं तो हम तब तक रोकते नहीं हैं जब तक कि हम एक नकारात्मक मूल्य प्राप्त नहीं करते हैं (जो हमें अनुक्रम के -1 और -2 वें तत्व के साथ छोड़ देता है)। फिर, हम पहले मूल्य को प्रिंट करने से पहले उन्हें जोड़ना शुरू करते हैं ।

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

?"
}

IP ?सही (जो पढ़ता है A) पर शुरू होता है । फिर "(एक नो-ऑप) यह एक मृत अंत को हिट करता है, इसलिए यह ?फिर से घूमता है, फिर से निष्पादित करता है (पढ़ना B)। अन्त में, }चाल Bसहायक ढेर के लिए खत्म हो। मृत अंत भोले पर एक बाइट बचाता है

?
?
}

अब लूप जो अनुक्रम की शुरुआत पाता है:

)(:{
"  -
" "`?...
=}""

)((वेतन वृद्धि-घटती) नो-सेशन है, लेकिन यह सुनिश्चित करना है कि ढेर के शीर्ष जंक्शन पर सकारात्मक है (जैसे कि आईपी पूर्व बदल जाता है) आवश्यक है। :डुप्लिकेट A, मुख्य स्टैक पर वापस {जाता है B, -गणना करता है A-B। B-Aहालांकि हम वास्तव में जो चाहते हैं , `वह मूल्य को नकारता है।

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

                v
                "
               """>negative
non-negative <"""

कम से कम मैं अभी तक इस मामले के लिए एक अधिक कॉम्पैक्ट / उपयोगी लेआउट नहीं ढूंढ सका हूं।

वैसे भी, Aगैर-नकारात्मक होने के बावजूद, लूप जारी }रहता Aहै, सहायक स्टैक और =स्वैप पर जाता है Aऔर B।

एक बार Aनकारात्मक होने पर, ?पढ़ता है Nऔर हम दूसरे लूप में चले जाते हैं:

 }:=+:
 }   !
?"({{\

हम जानते हैं कि Nयह सकारात्मक है, इसलिए हम आईपी को एक बाएं-मोड़ (उत्तर) पर भरोसा कर सकते हैं। लूप बॉडी अब बस है:

}}:=+:!\{{(

शब्दों में: दोनों Nऔर Aसहायक स्टैक पर चलते हैं। डुप्लिकेट करें B, कॉपी को स्वैप करें Aऔर Aदूसरी कॉपी में जोड़ें B। के वर्तमान मूल्य को प्रिंट करने के लिए इसे फिर से डुप्लिकेट करें B। एक नई लाइन प्रिंट करें। हटो Bऔर Nवापस मुख्य स्टैक और डेक्रमेंट पर जाएं N।

जबकि Nसकारात्मक है, आईपी एक सही बारी (उत्तर) के पाश जारी ले जाएगा। एक बार Nशून्य तक पहुँचने के बाद , कोड एक फैंसी तरीके से समाप्त हो जाता है:

आईपी सीधे (पश्चिम) आगे बढ़ता रहता है। ?एक और पूर्णांक पढ़ने की कोशिश करता है, लेकिन हम पहले ही ईओएफ तक पहुंच चुके हैं, इसलिए यह वास्तव में 0इसके बजाय धक्का देता है । `यह नकारने की कोशिश करता है, लेकिन यह अभी भी शून्य है। तो आईपी अभी भी पश्चिम की ओर बढ़ता है, कोने में एक मोड़ लेता है, और फिर नीचे की ओर बढ़ता रहता है, @जिससे प्रोग्राम समाप्त हो जाता है।

मुझे आश्चर्य है कि अगर मैं बन सकता था @एक और भी सस्ता स्थिति में (यह वर्तमान में 3 खाली स्थान के पात्रों की लागत) तीन बदल कर "चारों ओर `कोई-ऑप्स (जैसे यौगिक में )(), लेकिन मैं अभी तक कि काम करने के लिए नहीं कर पाए हैं।

— मार्टिन एंडर
स्रोत

5

सी, 105 102 100 बाइट्स

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

2 बाइट बंद करने के लिए @ C0deH4cker को धन्यवाद!

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

— डेनिस
स्रोत

4

मतलाब / ऑक्टेव, 115 125 बाइट्स

function x=f(x,n)
while x(2)>=x(1)
x=[abs(x(1)-x(2)) x];end
x=x([2 1]);for k=1:n-1
x=[x(1)+x(2) x];end
x=x(n:-1:1);

फ़ंक्शन को बुलाया जाना चाहिए f([8 13],10)।

उदाहरण (मतलाब):

>> f([8 13],10)
ans =
     0     1     1     2     3     5     8    13    21    34

या इसे ऑनलाइन (ऑक्टेव) आज़माएं ।

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

नियमों के अनुसार, आप इनपुट को संशोधित कर सकते हैं, इसलिए f([a b],n)अनुमति दी जानी चाहिए।

— बीकर

@ बीकर धन्यवाद! मैं ऐसा करने जा रहा था ... लेकिन फिर मैंने नियम "इनपुट और आउटपुट को रिक्त स्थान, अल्पविराम, या नईलाइन्स द्वारा अलग किया जा सकता है" पढ़ा और भ्रमित हो गया। मैं स्पष्टीकरण के लिए पूछूंगा

— लुइस मेंडो

हाँ, मुझे नहीं पता कि क्या x=f(x,n)फंक्शन हेडर मायने रखता है ...

— बीकर

@AlexA। मैं लुइस की टिप्पणी के नियम के बारे में जवाब दे रहा था "इनपुट और आउटपुट को रिक्त स्थान, अल्पविराम, या न्यूलाइन्स द्वारा अलग किया जा सकता है" और ओपी के "ए, बी, और एन को किसी भी क्रम और प्रारूप में लिया जा सकता है, जब तक वे हैं नेत्रहीन अलग हो गए। " क्योंकि A और B अब फ़ंक्शन हेडर में अलग-अलग दिखाई नहीं देंगे, मैं सवाल कर रहा था कि क्या केवल 2 फ़ंक्शन तर्क होने की अनुमति होगी।

— बीकर

3

हास्केल, 67 65 56 बाइट्स

a#b|a>b=b:scanl(+)(a+b)(a#b)|1>0=(b-a)#a
n%a=take n.(a#)

सुझाव के लिए @nimi को धन्यवाद

यह एक टर्नरी इन्फ़िक्स फ़ंक्शन को परिभाषित करता है %, जिसे प्रारूप में लागू किया जाता है (n%a)b, उदाहरण के लिए:

> (10%8)13
[0,1,1,2,3,5,8,13,21,34]

व्याख्या

द्विआधारी इन्फ़िक्स समारोह #, पहली पंक्ति पर परिभाषित, दो पूर्णांकों में ले जाता है aऔर bऔर अनंत रिटर्न फाइबोनैचि की तरह अनुक्रम जहां aऔर bलगातार तत्व के रूप में पाए जाते हैं।

a#b                                       -- Define a#b:
   |a>b=                                  -- if a>b, then a#b is
        b:                                -- the sequence that starts with b and
          scanl(+)     (a#b)              -- continues with the sums of prefixes of a#b
                  (a+b)                   -- plus the additional term a+b;
                            |1>0=(b-a)#a  -- otherwise, it's (b-a)#a.

फ़ंक्शन %केवल पहले nतत्वों को लेता है a#b।

— Zgarb
स्रोत

आप के साथ फाइबोनैचि अनुक्रम बना सकते हैं let f=a:scanl(+)(a+b)f in f> पूर्ण - ( #: a#b|a>b=let f=a:scanl(+)(a+b)f in f|1>0=(b-a)#aऔर सेव दो बाइट्स।

— nimi

@ निम्मी धन्यवाद; मैंने आपके विचार को चलाया और कुल 9 बाइट्स बचाए।

— ज़गारब

3

> <>, 33 31 + 1 के लिए -v = 32 बाइट्स

&:{:@(?v:}-$&
-1;!?:&<$+{oan::$&

इनपुट का उपयोग स्टैक पर -v से किया जाना चाहिए क्योंकि पार्सिंग दशमलव संख्या> <> में गैर-तुच्छ है।

स्पष्टीकरण:

मैं प्रत्येक (समूह) ऑपरेशन के बाद स्टैक का प्रतिनिधित्व करूंगा। इसकी शुरुआत [F (n), F (n + 1), N] से होती है

पहली पंक्तियाँ सीरी को उसके 0 वें पद पर ले जाती हैं:

& removes N from the stack to put it into a register. [F(n), F(n+1)]
:{:@ move the stack and duplicate items to get [F(n+1), F(n), F(n+1), F(n)]
(?v compares the two top items of the stack and branch to the second line if F(n+1) < F(n) [F(n+1), F(n)]
:} move the stack and duplicate its top to get [F(n), F(n+1), F(n)]
- substracts the two top items and put the result on top of the stack [F(n), F(n+1) - F(n)]
$ switchs the top two values of the stack. [F(n+1) - F(n), F(n)]
& retrieve the value from the register. iteration complete, since [F(n+1) - F(n), F(n), N] can also be read as [F(n-1), F(n), N]

दूसरी पंक्ति सीरी तक जाती है जब तक कि उसने एन शब्दों को नहीं छापा है:

< changes the code pointer direction to the left [F(0), F(-1)]
& retrieves the stored value back from the stack [F(0), F(-1), N]
:?!; copies N to compare it to 0, stops if it is [F(0), F(-1), N]
1- decreases it [F(0), F(-1), N-1]
& stores it back [F(0), F(-1)]
$:: makes the stack [F(-1), F(0), F(0), F(0)]
n{ prints the top of the stack then left shifts it [F(0), F(0), F(-1)]
ao displays a line feed (ascii character 0x0a) [F(0), F(0), F(-1)]
+ adds the two top values [F(0), F(-1) + F(0)]
$ switch the two top values. iteration complete since [F(-1) + F(0), F(0)] which can be read as [F(1), F(0)]

— हारून
स्रोत

आपको 00.पहली पंक्ति में बदलकर अपनी बाइट की गिनती को 2 से कम करने में सक्षम होना चाहिए &। सैद्धांतिक रूप से, !काम करना चाहिए लेकिन मुझे लगता है कि> <> सबसे लंबी एक की चौड़ाई से मेल खाने के लिए लाइनों की चौड़ाई (संपादित करें: यही कारण है कि मैं आपको 00.पहले स्थान पर है)।

— कोल

हाँ, मैं इस बारे में निश्चित नहीं हूँ, मैंने यहाँ लोगों को उपयोग करते देखा है! एक तरह से जिसने अंतरिक्ष को नजरअंदाज कर दिया। मुझे पता है कि fishlanguage.com पर ऑनलाइन दुभाषिया उस तरह से काम नहीं करता है, लेकिन शायद अजगर दुभाषिया करता है। और वैसे भी चाल अच्छी तरह से करता है, धन्यवाद!

— एरोन

ऑनलाइन दुभाषिया के साथ काम करता !या ?(पंक्ति के अंत में) अगर यह सबसे लंबे समय तक लाइन पर है। आप इसे किसी चीज़ के साथ आज़मा सकते हैं 1n!और यह त्रुटि करेगा, लेकिन अगर इसके नीचे कोई रेखा है, तो इससे कुछ अधिक, जैसे lorumipsum, यह नहीं होगा।

— कोल

"आउटपुट को रिक्त स्थान, अल्पविराम और / या newlines द्वारा अलग किया जाना चाहिए।" क्षमा करें, लेकिन आपको दूसरे संस्करण का उपयोग करना होगा। अच्छी नौकरी, हालांकि!

— ETHproductions 19

इसे ठीक किया, मैंने 2 बाइट्स बचाने के लिए रिक्त स्थान के बजाय \ n का उपयोग किया

— एरॉन

2

जावा, 113 78 76 बाइट्स

इस उत्तर में उपयोग किए गए एल्गोरिथ्म को प्रदान करने के लिए क्रेडिट ETHproduction को जाता है ।

(a,b,n)->{for(;a<=b;b-=a)a=b-a;for(;n-->0;b+=a,a=b-a)System.out.println(b);}

यहाँ कोशिश करो ।

स्पष्टीकरण:

(a,b,n)->{
    for (;a<=b;b=b-a)a=b-a;  //Compute previous terms while a <= b
    for (;n-->0;b=a+b,a=b-a) //Compute and print next terms while n > 0
    System.out.println(b);   //Print term
}

मूल दृष्टिकोण, 113 93 बाइट्स

अधिक गोल्फ लगता है;)

String a(int a,int b,int n){return n<0?a+" "+a(b,a+b,n+1):n>0?a>b?a(b,a+b,-n):a(b-a,a,n):"";}

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

स्पष्टीकरण:

String a(int a, int b, int n){
    return 
    n < 0 ?                           //If n < 0
        a + " " + a(b, a + b, n + 1)  //Return a + next terms and increment n.
    :                                 //Else
        n > 0 ?                       //If n > 0
            a > b ?                   //If a > b
                a(b, a + b, -n)       //Negate n and return terms.
            :                         //If a <= b
                a(b - a, a, n)        //Generate previous term.
        :                             //If n == 0
            ""                        //Return nothing.
    ;
}

— नंबर एक
स्रोत

3

क्या? Java JS से छोटा है?! वहाँ कुछ मैं गलत कर रहा हूँ होना चाहिए ....

— 23

@ETHproductions मैंने वास्तव में आपके एल्गोरिथ्म की नकल की (और फिर इसे गोल्फ किया): P

— TheNumberOne

यह मेरे साथ ठीक है, मैंने आपके कुछ सुधार किए;) मैं प्रत्येक आइटम को अलग से छापना भूल गया था जो जेएस में मान्य था।

— ETHproductions

आप छोटा कर सकते हैं b=b-aकरने के लिए b-=a, और के साथ एक ही a=b+a। यह 2 बाइट बचाएगी

— जेवियर डियाज़

एक क्रिया भाषा प्रस्तुत करने के लिए +1 इतना छोटा। आमतौर पर जावा सबमिशन सबसे लंबे होते हैं!

— डंकेमेसेस

2

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

यह अधिकतम करने के लिए गोल्फ हो सकता है। हम देखेंगे।

(a,b,n)=>{while(a<=b)b-=a=b-a;for(;n--;console.log(a=b-a))b+=a}

Ungolfed:

function f(a,b,n) {
  // repeat until we find the 0th item...
  while (a <= b) {  // if a = 5, b = 8:
    a = b - a;      // a = (8 - 5) = 3
    b = b - a;      // b = (8 - 3) = 5
  }
  // repeat n times...
  while (n-- > 0) { // if a = 5, b = 8:
    b += a;         // b = (8 + 5) = 13
    a = b - a;      // a = (13 - 5) = 8
    console.log(a); // print out each item
  }
}

— ETHproductions
स्रोत

1

गणितज्ञ 112

यह अंततः गोल्फ जाएगा

z[a_, b_, n_] := (
  f[0] := Min[a, b];
  f[1] := Max[a, b];
  f[x_] := f[x - 1] + f[x - 2];
  f /@ Range[n]
  )

— WizardOfMenlo
स्रोत

1

सीजेएम, 40 बाइट्स

l~:A;{_@_@)<}{_@\-\}w\{A(:A0>}{_p_@+}w\;

बच्चे के कदम। यह मेरा अब तक का पहला सीजेएम कार्यक्रम है, इसलिए मुझे गर्व है कि यह बिल्कुल काम करता है।

यह उदाहरण के रूप में उसी रूप में इनपुट लेता है।

अब मैंने देखा है कि मैं { ... }*निर्माण का उपयोग करके इसे 33 बाइट्स तक कम कर सकता हूं ।

l~:A;{_@_@)<}{_@-z\}w\A{_p_@+}*;;

और मैं स्टैक को साफ करने और त्रुटि पैदा करने के लिए टर्नरी ऑपरेटर का उपयोग करके इसे एक और कम कर सकता था।

— Cabbie407
स्रोत

1

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

def u a,b,n,z=""
n<1 ? z.chop : u(b,a+b,n-1,z+"#{a} ")
end 
def d a,b,z=0
a.abs>b ? z : d(b-a,a,[a,b]) 
end 
def f a,b,n
x,y=d a,b 
u x,y,n
end

क्रियान्वयन

f फ़ंक्शन वांछित आउटपुट उत्पन्न करता है, तर्क नाम प्रश्न से चर नामों से मेल खाते हैं

f(8,13,10) # returns => "0 1 1 2 3 5 8 13 21 34"

कुछ भी चालाक नहीं है:

u ( अप ) फ़ंक्शन पुनरावर्तन का उपयोग करते हुए, बी के साथ शुरू होने वाले रिट्रेसमेंट अनुक्रम में एन तत्वों की गणना करता है
d ( डाउन ) फ़ंक्शन को पुनरावृत्ति का उपयोग करके दो अंत तत्वों को दिए गए 0 और 1 तत्व का पता चलता है
f ( फिबोनैकी ) फ़ंक्शन दो को एक साथ रखता है

— alexanderbird
स्रोत

1

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

If[#>#2,LinearRecurrence[{1,1},#2+{0,#},#3],#0[#2-#,#,#3]]&

— alephalpha
स्रोत

0

रूबी, 81 75 73

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{b=c+a;c,a=a,b;p b}

6 बाइट्स द्वारा छोटा किया गया जब रेंज.मैप के साथ लूप की जगह

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{p b=c+a;c,a=a,b}

प्रिंट स्टेटमेंट को स्थानांतरित करके एक और 2 बाइट्स को सहेजा गया

— यूरी कज़कोव
स्रोत

0

पाइके, 24 बाइट्स (गैर-प्रतिस्पर्धात्मक)

DA/IDA-],X_r)QVDsRe
R]);

यहाँ यह कोशिश करो!

— नीला
स्रोत

0

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

Ḋ;_/Ɗ>/¿+⁹Ð¡/Ṗ

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

— आउटग्रॉफर को एरिक करें
स्रोत

0

आम लिस्प, 91 बाइट्स

(lambda(a b n)(do((x a(- y x))(y b x))((> x y)(dotimes(k n)(print y)(psetf y(+ y x)x y)))))

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

— रेंज़ो
स्रोत

सोमवार मिनी-गोल्फ # 1: रिवर्स फाइबोनैचि सॉल्वर

चुनौती

विवरण

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

उदाहरण 1:

उदाहरण 2:

उदाहरण 3:

उदाहरण 4:

स्कोरिंग

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

स्पष्टीकरण:

रेटिना , 65 54 बाइट्स

व्याख्या

पायथन 2, 93 87 67 61 60 बाइट्स

CJam, 26 23 बाइट्स

व्याख्या

भूलभुलैया , 58 54 49 46 44 बाइट्स

व्याख्या

सी, 105 102 100 बाइट्स

मतलाब / ऑक्टेव, 115 125 बाइट्स

हास्केल, 67 65 56 बाइट्स

व्याख्या

> <>, 33 31 + 1 के लिए -v = 32 बाइट्स

स्पष्टीकरण:

जावा, 113 78 76 बाइट्स

मूल दृष्टिकोण, 113 93 बाइट्स

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

Ungolfed:

गणितज्ञ 112

सीजेएम, 40 बाइट्स

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

क्रियान्वयन

कुछ भी चालाक नहीं है:

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

रूबी, 81 75 73

पाइके, 24 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

आम लिस्प, 91 बाइट्स