काउंटर-फाइबोनैचि अनुक्रम

13

तीन नंबर m , n और p को देखते हुए , आपका कार्य m और n से शुरू होने वाली लंबाई p की सूची / सरणी को प्रिंट करना है और p के बाद प्रत्येक तत्व 2 संख्याओं के अंतर को दर्शाता है, mn (काउंटर- फाइबोनैचि अनुक्रम )

इस चुनौती के लिए आप या तो परिणाम या पूर्ण कार्यक्रम को वापस करने या प्रिंट करने के लिए किसी फ़ंक्शन का उपयोग कर सकते हैं।

इनपुट

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

उत्पादन

काउंटर-फाइबोनैचि अनुक्रम द्वारा दिए गए नंबर, निम्न में से किसी भी प्रारूप में (उदाहरण:) m = 50, n = 40, p = 6:

  • 50,40,10,30,-20,50 (या अल्पविराम के बाद रिक्ति के साथ)
  • [50,40,10,30,-20,50] (या अल्पविराम के बाद रिक्ति के साथ)
  • 50 40 10 30 -20 50(या \nरिक्त स्थान के बजाय)
  • {50,40,10,30,-20,50} (या अल्पविराम के बजाय रिक्त स्थान के साथ)

उदाहरण

Input => Output

50,40,10 => 50,40,10,30,-20,50,-70,120,-190,310
-100,-90,7 => -100,-90,-10,-80,70,-150,220
250,10,8 => 250,10,240,-230,470,-700,1170,-1870

नियम

  • आपको गारंटी दी जाती है कि पी 1 से अधिक है
  • यदि संभव हो तो आपको अपने कार्यक्रम का परीक्षण करने का एक तरीका प्रदान करना चाहिए
  • ध्यान दें कि इस खामियों को मना किया गया है और कोड प्रविष्टि को बंद कर दिया गया है, जैसा कि ऊपर बताया गया है

स्कोरिंग और लीडरबोर्ड

आपका कोड यथासंभव छोटा होना चाहिए, क्योंकि यह कोड-गोल्फ है । कोई उत्तर स्वीकार नहीं किया जाएगा , क्योंकि यह चुनौती भाषा के सबसे छोटे उत्तर को खोजने के लिए है, जो कि गोल्फ भाषाओं के अनुचित लाभ से बचती है।

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

ETHproductions द्वारा संबंधित प्रश्न: सोमवार मिनी-गोल्फ # 1: रिवर्स फाइबोनैचि सॉल्वर

code-golf  math  number  sequence  fibonacci 
— मिस्टर एक्सकोडर
स्रोत
संबंधित, संभव डुप्लिकेट। यह मूल रूप से इस एक के रूप में एक ही चुनौती है, लेकिन अनुक्रम में एक विशिष्ट स्थान से रिवर्स ऑर्डर में आउटपुट करता है।
— ETHproductions
@ETHproductions को एक धोखा माना जा सकता है, लेकिन यह थोड़ा अलग है, प्रत्येक भाषा में सबसे कम समाधान को देखने की कोशिश कर रहा है
— श्री एक्सकोडर
हाँ, भाषा असमानता के बारे में उतनी चिंता नहीं थी, फिर ;-) मुझे नहीं लगता कि इससे कोई बड़ा फर्क पड़ता है। यहाँ मुख्य अंतर यह है कि आप बहुत कुछ उस एल्गोरिथ्म के पहले चरण को छोड़ सकते हैं जिसका उपयोग आपने उस चुनौती को हल करने के लिए किया होगा (शुरुआती बिंदु को खोजने के लिए पीछे की ओर काम करना)
— ETHproductions
@ETHproductions वास्तव में छोटे अंतर हैं। यदि आप चाहते हैं कि यह चुनौती हटा दी जाए, तो मैं इसे पूरी तरह से करूँगा।
— श्री एक्सकोडर
मुझे व्यक्तिगत रूप से लगता है कि यह ठीक है। इसके अलावा, क्या हमें अनुगामी विभाजक रखने की अनुमति है?
— ETHproductions

जवाबों:

9

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

a#b=a:b#(a-b)
(.(#)).(.).take

लंबाई pपहला पैरामीटर है। प्रयोग उदाहरण: ( (.(#)).(.).take ) 10 50 40-> [50,40,10,30,-20,50,-70,120,-190,310]। इसे ऑनलाइन आज़माएं! ।

pतत्वों को सूची को छोटा करना उत्पादन करने से अधिक बाइट्स लेता है।

— nimi
स्रोत
6

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

_@С+Ṗ

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

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

_@С+Ṗ  Main link. Left argument: m. Right argument: n. Third argument: p

    +   Yield (m + n), the term that comes before m.
  С    Execute the link to the left p times, starting with left argument m and
        right argument (m + n). After each execution, replace the right argument
        with the left one and the left argument with the previous return value.
        Yield all intermediate values of the left argument, starting with m.
_@          Subtract the left argument from the right one.
        This yields the first (p + 1) terms of the sequence, starting with m.
    Ṗ   Pop; discard the last term.
— डेनिस
स्रोत
5

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

f=(m,n,p)=>p?m+[,f(n,m-n,p-1)]:[]

स्ट्रिंग्स का 1,2,3,उपयोग किए बिना - प्रारूप की एक स्ट्रिंग लौटाता है !

टेस्ट स्निपेट

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

— ETHproductions
स्रोत
5

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

{($^m,$^n,*-*...*)[^$^p]}

कोशिश करो

विस्तारित:

{  # bare block lambda with placeholder parameters ｢$m｣ ｢$n｣ ｢$p｣
  (
    $^m, $^n,  # declare first two params, and use them

    * - *      # WhateverCode lambda which subtracts two values

    ...        # keep using that to generate values

    *          # never stop (instance of type Whatever)

  )[ ^ $^p ]   # declare last param, and use it to grab the wanted values
               # ｢^ $^p｣ is short form of range op
               # ｢0 ..^ $^p｣ which excludes the ｢$p｣
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
5

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

q~2-{1$1$-}*]S*

1 अतिरिक्त बाइट क्योंकि CJam स्वाभाविक रूप से अनुमति आउटपुट प्रारूप> _ <में से एक का उपयोग नहीं करता है

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

व्याख्या

q~               e# Read and eval the input
  2-             e# Subtract 2 from p (to account for m and n being in the list)
    {            e# Run this block p-2 times:
     1$1$-       e#   Copy the top values and subtract
          }*     e# (end of block)
            ]    e# Wrap the stack in an array
             S*  e# Join with spaces
— बिजनेस कैट
स्रोत
3

रोड़ा , 38 बाइट्स

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}

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

व्याख्या की:

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}
f i,a,b{                             } /* Function declaration */
        seq 1,i                        /* Push numbers 1..i to the stream */
               |{|_|               }_  /* For each number in the stream: */
                    [a];               /*   Push the current value of a */
                        b=a-b;         /*   Set b = the next number */
                              a=a-b    /*   Set a = the previous value of b */
— fergusq
स्रोत
3

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

(m!n)0=[]
(m!n)p=m:(n!(m-n))(p-1)

का उपयोग कर कॉल करें (m!n)p। को परिभाषित करते हुए काम करता है !एक इन्फ़िक्स समारोह है कि में ले जाता है के रूप में mऔर nऔर एक समारोह है कि लेता रिटर्न pऔर वांछित परिणाम देता है।

— जूलियन वुल्फ
स्रोत
अच्छा! मैंने फंक्शन को इनफ़िक्स बनाने के बारे में नहीं सोचा था, इसलिए हैस्केल के साथ मेरी सबसे अच्छी कोशिश 34 थी। BTW आप ;इसे सिंगल-लाइन बनाने के लिए नईलाइन को बदल सकते हैं , इसलिए यह थोड़ा अधिक कोडगॉल्फी लगता है।
— एलेक्सजे 136
2

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

JEKEVEJ=N-JK=JK=KN

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

इनपुट और आउटपुट दोनों को नए सिरे से सीमांकित किया गया है।

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

JEKE                Read two lines of input to J and K
    VE              Read another line and loop that many times:
      J               Print J
       =N-JK          Set N to J - K (Pyth uses prefix notation)
            =JK       Set J to K
               =KN    Set K to N
— draziwfozo
स्रोत
1

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

{-1,1}~LinearRecurrence~##

लविन 'बिलिन। फॉर्म में इनपुट लेता है {{m, n}, p}। LinearRecurrenceनए तत्वों को उत्पन्न करने के लिए पिछले तत्वों के रैखिक संयोजन के गुणांक को जानना चाहता है, जो इस मामले में है {-1,1}।

— ग्रेग मार्टिन
स्रोत
1

QBIC , 35 33 बाइट्स

:::?'a;b;`[c-2|e=a-b?e';`┘a=b┘b=e

पहली बार PRINTएक कोड शाब्दिक में रखकर 2 बाइट्स सहेजे गए ।

स्पष्टीकरण (35 बाइट संस्करण):

:::         Get parameters a, b, c from the cmd-line
  ';`       This suppresses a newline when printing
?a   b';`   PRINT a and b
[c-2|       FOR x=1; x<=(c-2); x++
  e=a-b       calculate the next term of the sequence
  ?e';`       Print it, suppressing newline
  ┘a=b        ┘ denotes a syntactic linebreak; shove the numbers one over
  ┘b=e        dito
            FOR-loop is auto-closed
— steenbergh
स्रोत
यह परीक्षण करने के लिए एक ऑनलाइन दुभाषिया का कोई विचार है?
— मिस्टर एक्सकोडर
@ Mr.Xcoder अभी तक कोई ऑनलाइन दुभाषिया नहीं है, क्षमा करें। मैंने दुभाषिये के लिए एक लिंक जोड़ा है, जो एक DOSBOX प्रोजेक्ट है जो QBasic, QBIC को चला रहा है।
— १
1
व्याख्या दुभाषिया @steenbergh से अधिक मूल्य की है, जवाब देने के लिए धन्यवाद!
— श्री एक्सकोडर
1

सी, 128 बाइट्स

m,n,p,z;main(c,v)char**v;{m=atoi(v[1]);n=atoi(v[2]);p=atoi(v[3])-2;printf("%d,%d",m,n);while(p--)z=m,m=n,n=z-m,printf(",%d",n);}

यह प्रोग्राम तीन तर्कों mको nऔर pकमांड-लाइन से पार्स करता है , और आउटपुट को निर्दिष्ट के रूप में प्रिंट करता है।

आधुनिक सी संकलक आपको मूल आयात को छोड़ने की अनुमति देते हैं, और इस प्रकार हम उपयोग कर सकते हैं printfऔर एस के atoiबिना #include।

intएक प्रकार के बिना घोषित किए जाने पर वैश्विक चर डिफ़ॉल्ट रूप से होते हैं - यह बहुत अधिक स्थान बचाता है।

— AlexJ136
स्रोत
1

जावा, 66 बाइट्स

एक बार के लिए, lambdas की वजह से गोल्फ के लिए अक्षम दृष्टिकोण हैं बहुत उन्हें प्रत्यावर्तन को लागू करने की राउंडअबाउट रास्ता है कि अतिरिक्त बाइट्स का एक बहुत आवश्यकता है।

golfed:

String f(int m,int n,int p){return""+m+(p>1?","+f(n,m-n,p-1):"");}

Ungolfed:

public class CounterFibonacciSequences {

  private static final int[][] INPUTS = new int[][] { //
      { 50, 40, 10 }, //
      { -100, -90, 7 }, //
      { 250, 10, 8 } };

  private static final String[] OUTPUTS = new String[] { //
      "50,40,10,30,-20,50,-70,120,-190,310", //
      "-100,-90,-10,-80,70,-150,220", //
      "250,10,240,-230,470,-700,1170,-1870" };

  public static void main(String[] args) {
    for (int i = 0; i < INPUTS.length; ++i) {
      final int m = INPUTS[i][0];
      final int n = INPUTS[i][1];
      final int p = INPUTS[i][2];
      System.out.println("M: " + m);
      System.out.println("N: " + n);
      System.out.println("P: " + p);
      System.out.println("Expected: " + OUTPUTS[i]);
      System.out.println("Actual:   " + new CounterFibonacciSequences().f(m, n, p));
      System.out.println();
    }
  }

  String f(int m, int n, int p) {
    return "" + m + (p > 1 ? "," + f(n, m - n, p - 1) : "");
  }
}
— समुदाय
स्रोत
1

एएचके, 68 बाइट्स

m=%1%
n=%2%
3-=2
Send %m%`n%n%`n
Loop,%3%
{
n:=m-n
m-=n
Send %n%`n
}

हो रही है 'वास्तव में नहीं जानने के थक कैसे / पारित कर दिया तर्कों का उपयोग करने में सक्षम होने ( %1%, %2%, ...) किसी भी गणित कार्यों में सीधे

— इंजीनियर टोस्ट
स्रोत
1

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

u,t=int,input;m,n,p=u(t()),u(t()),u(t());l=[m,n]
for i in range(p-2):l.append(l[-2]-l[-1])

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

सहेजे गए 3 बाइट्स @ Mr.Xcoder का धन्यवाद

यह संख्याओं को इनपुट के रूप में ले कर काम करता है और उन्हें सही ढंग से प्रारूपित करता है, फिर इनपुट संख्याओं के आधार पर सूची बनाने के लिए लूप का उपयोग करता है।

— कॉमरेड स्पार्कलपनी
स्रोत
आप 1 बाइट बचाने के लिए उस श्रेणी में अल्पविराम के बाद स्थान हटा सकते हैं
— श्री Xcoder
और यदि आप अपने इनपुट को ints और input.sit के साथ मैप करते हैं तो यह छोटा हो सकता है
— श्री Xcoder
@ Mr.Xcoder मैंने विभाजन की कोशिश की, लेकिन यह लंबे समय तक समाप्त हो गया।
— कॉमरेड स्पार्कलेपनी
ठीक है, मैं इसका परीक्षण नहीं कर सका। यह वैसे भी अच्छा है।
— मिस्टर एक्सकोडर
और रेंज को पहले तर्क की आवश्यकता नहीं है
— श्री एक्सकोडर
0

स्विफ्ट - 85 बाइट्स

func y(x:Int,y:Int,z:Int){var m=x,n=y,p=z,c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

उपयोग: y(x:50,y:40,x:6)

स्विफ्ट - 84 बाइट्स

func z(l:[Int]){var m=l[0],n=l[1],p=l[2],c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

उपयोग: z(l: [50,40,6])

आउटपुट:

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