17

वैकल्पिक फाइबोनैचि अनुक्रम में, आप पहले 1और 1हमेशा की तरह शुरू करते हैं ।

हालाँकि, अगले नंबर को प्राप्त करने के लिए हमेशा अंतिम दो मूल्यों को जोड़ने के बजाय, आप वैकल्पिक रूप से जोड़ने के साथ शुरू करते हैं, और हर बार जब आप इसके बजाय घटाते हैं।

अनुक्रम इस तरह शुरू होता है:

1
1
2    # 1 + 1
-1   # 1 - 2
1    # 2 + -1
-2   # -1 - 1
-1   # 1 + -2
-1   # -2 - -1
-2   # -1 + -1
1    # -1 - -2
-1   # -2 + 1
2    # 1 - -1
1    # -1 + 2
1    # 2 - 1

आदि।

^{सूचना के बाद इस पर शुरू होता है एक बार इसे करने के लिए हो जाता है 1और 1फिर से।}

एक नंबर एन को देखते हुए , वैकल्पिक थ्रेडिंग अनुक्रम के एन वें शब्द को प्रिंट करें ।

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

code-golf number fibonacci

— ओलिवर नी
स्रोत

अनुक्रम 0-अनुक्रमित या 1-अनुक्रमित (या तो एक) है?

— दरवाज़े

@ डॉर्कनोब या तो एक। अपने उत्तर में निर्दिष्ट करें।

— ओलिवर नी

हम लौट सकते हैं trueके लिए 1?

— 23

क्या 1आउटपुट के लिए शुरुआती मूल्यों के रूप में पहले दो मान गिने जाते हैं? या हम सीधे से शुरू करते हैं 2?

— लुइस मेंडो

@LuisMendo पहली दो गिनती।

— ओलिवर नी

17

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

n=>"334130110314"[n%12]-2

0 अनुक्रमित। आप स्ट्रिंग को थोड़ा पुनरावर्ती संस्करण के साथ छोटा कर सकते हैं, हालांकि इसमें 6 बाइट्स शामिल हैं:

f=n=>"3341301"[n]-2||f(13-n%12)

यह अभी भी निश्चित पुनरावर्ती सूत्र से छोटा है:

f=n=>n<2||f(n-2)+f(n-1)*(-n%2|1)

— ETHproductions
स्रोत

8

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

lambda n:2-33107256/5**(n%12)%5

मूल्य की गणना करने की कोशिश कर परेशान नहीं करता है। बस peroidic लंबाई -12 सूची में दिखता है [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], जो आधार 5 में संकुचित है।

1 के लिए एक पुनरावर्ती समाधान (37 बाइट्स) के साथ तुलना करें True:

f=lambda n:n<2or(-1)**n*f(n-1)+f(n-2)

या स्ट्रिंग भंडारण के लिए

lambda n:int('334130110314'[n%12])-2

या एक अंकगणितीय अभिव्यक्ति पर एक प्रयास।

lambda n:4**n%7%3*(-1)**((n+n%2*4)/6)

— XNOR
स्रोत

7

ओएसिस , 10 बाइट्स

कुछ और बिल्ट-इन: पी को लागू करने की याद दिलाता है। इनपुट 0-अनुक्रमित है ।

कोड:

n>2%x<*c+V

अनुवादित संस्करण:

a(n) = (2*((n+1)%2)-1) * a(n-1) + a(n-2)
a(1) = 1
a(0) = 1

और n वें पद की गणना करता है ।

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

— अदनान
स्रोत

5

05AB1E , 10 बाइट्स

•É&Â†º•sèÍ

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

— अदनान
स्रोत

मुझे लगता है कि मुझे जेली के बजाय 05AB1E सीखना शुरू करना चाहिए।

— आउटगोल्फ

4

पायथ - 13 बाइट्स

बेस एक बार चक्र श्रृंखला, मॉड्यूलर अनुक्रमित एन्कोडेड।

@-R2jC"
ûx"5

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

— Maltysen
स्रोत

4

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

“½Ġ⁻S’b5_2⁸ị

TryItOnline!

1-आधारित, पहला और दूसरा मान दिया जाता है 1।

यकीन नहीं होता कि यह अभी तक छोटा है, लेकिन इसके लिए मैंने नोट किया कि श्रृंखला की अवधि 12 है:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

तो, मैंने वह लिया और 2देने के लिए जोड़ा
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
तो आधार 5को आधार नंबर के रूप में परिवर्तित करने के लिए 250, देने के लिए:
[11, 197, 140, 84]
(जो है 184222584)।

“½Ġ⁻S’b5_2⁸ị - Main link: n
“½Ġ⁻S’       - base 250 number      184222584
      b5     - convert to base 5   [3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
        _2   - subtract 2          [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]
          ⁸  - left argument, n
           ị - index into (1-based and modular)

— जोनाथन एलन
स्रोत

4

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

a!b=a:b:(a+b)!(-a)
(1!1!!)

पुनरावर्ती दृष्टिकोण। 0 अनुक्रमित। Ideone पर इसे आज़माएं।
सहेजे गए 7 बाइट्स xnor के लिए धन्यवाद ।

उपयोग:

Prelude> (1!1!!)11
2

— Laikoni
स्रोत

बस करने के लिए कम लग रहा है a!b=a:b:(a+b)!(-a)।

— xnor

3

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

बस एक लुकअप टेबल बनाता है और इसे Cyclically एक्सेस करता है, जैसा कि ETHproductions के जवाब में है। फ़ंक्शन, 1-अनुक्रमित।

Join[s={2,1,1,2,-1,1},-s][[#~Mod~12+1]]&

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

3

MATL , 17 16 15 बाइट्स

'"Bl)e'F5Za2-i)

इनपुट 1-आधारित है।

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

व्याख्या

अनुक्रम की अवधि है [1 1 2 -1 1 -2 -1 -1 -2 1 -1 2]।

'"Bl)e     % Compressed array [1 1 2 -1 1 -2 -1 -1 -2 1 -1 2] with source 
           % alphabet [-2 -1 0 1 2]
F5Za       % Decompress with target alphabet [0 1 2 3 4]
2-         % Subtract 2 to transform alphabet into [-2 -1 0 1 2]
i)         % Input N and use as (modular, 1-based) index into the sequence

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

3

WinDbg, 26 बाइट्स

?(85824331b>>@$t0%c*3&7)-2

इनपुट छद्म रजिस्टर के माध्यम से पारित किया जाता है $t0 । 0 अनुक्रमित। अनुक्रम में प्रत्येक पद का +2 3 बिट्स बनाने में संग्रहीत किया जाता है85824331b ।

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

? (85824331b >> @$t0 % c * 3 & 7) - 2 ;*? Evalutes the expression. Shifts 85824331b to get
                                       *the 3 bits for the @$t0'th term (mod c (12) when
                                       *the sequence repeats). Bitwise AND by 7 to get the
                                       *desired 3 bits, finally subtract 2 since the terms
                                       *where stored as +2.

नमूना उत्पादन, अनुक्रम के पहले 14 मूल्यों को छापने वाला एक लूप:

0:000> .for(r$t0=0;@$t0<e;r$t0=@$t0+1){?(85824331b>>@$t0%c*3&7)-2}
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001
Evaluate expression: 2 = 00000002
Evaluate expression: -1 = ffffffff
Evaluate expression: 1 = 00000001
Evaluate expression: -2 = fffffffe
Evaluate expression: -1 = ffffffff
Evaluate expression: -1 = ffffffff
Evaluate expression: -2 = fffffffe
Evaluate expression: 1 = 00000001
Evaluate expression: -1 = ffffffff
Evaluate expression: 2 = 00000002
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001

— दूध
स्रोत

3

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

n->"334130110314".charAt(n%12)-50

चूंकि यह जावा है, इसलिए उत्तर 0-अनुक्रमित है।

परीक्षण और अपुष्ट:

class Ideone {
  public static void main (String[] args) throws Exception {
    java.util.function.IntFunction f = n->"334130110314".charAt(n%12)-50;
    for (int i = 0; i < 12; i++) {
      System.out.printf("%d -> %d%n", i, f.apply(i));
    }
  }
}

Ideone पर परीक्षण

— ओलिवियर ग्रेजायर
स्रोत

2

गणितज्ञ, ४५ ४१ by बाइट्स

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

±0=±1=1;±n_:=±(n-2)+±(n-1)(1-2n~Mod~2)

0 अनुक्रमित।

प्रयोग

±5

-2

— जंगहवान मिन
स्रोत

2

आप शायद ±एक फ़ंक्शन के बजाय एक अपर ऑपरेटर को परिभाषित करके तीन बाइट्स बचा सकते हैं a।

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

1

पर्ल 6 , 39 35 32 बाइट्स

{(1,1,{|(($/=$^a+$^b),$b-$/)}...*)[$_]}

{(|(334130110314.comb X-2)xx*)[$_]}

{(|334130110314.comb xx*)[$_]-2}

{334130110314.substr($_%12,1)-2}

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

सी #, 117 बाइट्स

golfed:

int A(int n){var f=new List<int>{0,1,1};for(int i=3;i<=n;i++){f.Add(i%2>0?f[i-1]+f[i-2]:f[i-2]-f[i-1]);}return f[n];}

Ungolfed:

public int A(int n)
{
  var f = new List<int> { 0, 1, 1 };

  for (int i = 3; i <= n; i++)
  {
    f.Add(i % 2 > 0 ? f[i - 1] + f[i - 2] : f[i - 2] - f[i - 1]);
  }

  return f[n];
}

परिक्षण:

var alternatingFibonacci = new AlternatingFibonacci();
Console.WriteLine(alternatingFibonacci.B(10));
1

— पीट आर्डेन
स्रोत

एक फंक के संकलन <int, int> तो public int A(int n)अब है n=>, आप 2 बाइट्स सहेजने के लिए ब्रेसिज़ को निकाल सकते हैं , आप iलूप में वेतन वृद्धि कर सकते हैं ++i <= nऔर i = 23 बाइट्स सहेज सकते हैं क्योंकि यह i++कथन के अंत में निकाल देता है

— TheLethalCoder

यदि आप उन सभी की सूची बनाने के बजाय पिछले चर का ट्रैक रखते हैं तो भी मेरा उत्तर देखें। यह बहुत छोटा है

— TheLethalCoder 12

1

आर, 38 बाइट्स

@ETHproductions JS उत्तर से प्रेरित लुकअप टेबल सॉल्यूशन का उपयोग करता है।

c(s<-c(2,1,1,2,-1,1),-s)[scan()%%12+1]

संपादित करें: यह उल्लेख करना भूल गए कि यह 1-अनुक्रमित है।

— Billywob
स्रोत

1

दरअसल , 22 बाइट्स

34*@%"334130110314"E≈¬

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

स्पष्टीकरण:

34*@%"334130110314"E≈¬
34*@%                   input % 12
     "334130110314"E    get that character in the string
                    ≈¬  convert to int, subtract 2

— मै जाऊं
स्रोत

1

जावा 7, 88 82 79 बाइट्स

golfed:

int f(int n){int c,i=0,a=1,b=1;for(;i<n;){c=i++%2>0?a-b:a+b;a=b;b=c;}return b;}

ungolfed:

int f(int n)
{
    int c, i = 0, a = 1, b = 1;
    for (; i < n;)
    {
        c = i++ % 2 > 0 ? a - b : a + b;
        a = b;
        b = c;
    }
    return b;
}

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

— peech
स्रोत

1

जब से आप "तार्किक" तरीके से जाते हैं, तो यहां कुछ संकेत दिए गए हैं: 1. आप intवापसी प्रकार के रूप में घोषित करना भूल गए । 2. यदि आप मैं की घोषणा करने के लिए 0 का काम ले जाकर बाइट्स छोड़ कर सकते हैं: int c,i=0और for(;i<n;){। 3. आप टर्नरी ऑपरेटर की स्थिति के आसपास कोष्ठक को हटा सकते हैं।

— ओलिवियर ग्रेजायर 12

1

@ ओलिवियरग्रेयर धन्यवाद दोस्त :) तय। अच्छा समाधान btw

— पीच

1

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

?sd[ln1+snly[[+2Q]sEln2%1=E-]xlyrsylnld>r]sr1sy0sn1lrxp

0 अनुक्रमित।

?sd                                                     takes input and stores
                                                        it in register d

                                            1sy0sn1     stores 1 in register y
                                                        and 0 in register n and
                                                        appends 1 to the stack

   [ln1+snly                                            adds 1 to register n and
                                                        appends the value of
                                                        register y to the stack

            [[+2Q]sEln2%1=E-]                           adds or subtracts the
                                                        the two values on the
                                                        stack depending on
                                                        parity of n

                             xlyrsylnld>r]              does the rest of the
                                                        stuff required to store
                                                        the new values properly
                                                        and quits if it has
                                                        done enough iterations

                                          sr            stores the main macro
                                                        in register r

                                                   lrxp executes the macro and
                                                        prints the stack

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

बड़े लूप में चल रही व्हाट्सएप की दृश्य व्याख्या (इसके अलावा):

register: y=1     y=1   y=1    y=1   y=1    y=2
stack:     1      1 1    2     2 1   1 2     1
               ly     +     ly     r     sy

यह निर्धारित करने के लिए कि क्या जोड़ने या घटाना काउंटर मॉडुलो दो लेता है और इस चाल का उपयोग करता है यदि एक और निर्माण करता है।

अंत में स्टैक में एक एकल संख्या होती है, वांछित मूल्य, जिसके साथ मुद्रित किया जाता है p।

(मैं नया हूं dc, इसलिए मुझे उम्मीद है कि यहां कुछ स्पष्ट सुधार किए जाएंगे।)

— poi830
स्रोत

0

फोर्सलैंग , 153 बाइट्स

def s set
s a 1
s b 1
s p 1
s k io.readnum()
if k=0
goto b
label a
s c b.mult p
s c a+c
s a b
s b c
s p p.mult -1
s k k+-1
if k
goto a
label b
io.write a

— SuperJedi224
स्रोत

0

टर्टल , 35 बाइट्स

#112-1_--_1-2#?:[*l+].(-r'1)(_"-2")

0 अनुक्रमित

स्पष्टीकरण:

#112-1_--_1-2#                      the 12 values of sequence. - is -1, _ is -2
              ?:                    input a number and move right that many
                [*l+]               move back to the asterisk on start cell, 
                                    increment sting pointer by amount moved
                     .              write pointed char
                      (-r'1)        if it was -, move right, write 1
                            (_"-2") if it was _, write "-2"
      [print grid]

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

— विनाशकारी नींबू
स्रोत

0

ABCR, 43 बाइट्स

)AAB)ABB..A))A..A)AA(ABB.)A+A)))AiB5aAb(Bxo

स्पष्टीकरण: पहला भाग ( )AAB)ABB..A))A..A)AA(ABB.)A+A)))A) कतार ए को सेट करने के लिए [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2] को शामिल करता है, अन्य सभी कतारें खाली रखता है । iBहमारे इच्छित पद को संग्रहीत करता है, और 5aAb(Bxकई बार कतार के माध्यम से लूप चक्र। oकतार के सामने एक संख्या के रूप में छापता है, जो तब हमारा वांछित उत्तर होगा।

— स्टीवन एच।
स्रोत

0

बैच, 49 बाइट्स

@cmd/cset/a"n=%1%%12,~!(n%%3)*(1|-!(n%%5*(n/4)))"

कमांड-लाइन पैरामीटर के रूप में इनपुट लेता है। स्पष्टीकरण: बंद प्रपत्र निम्नलिखित टिप्पणियों का उपयोग करता है:

अनुक्रम 12 अवधि के साथ चक्रीय है
प्रत्येक तीसरा पद third 2 है जबकि अन्य पद ± 1 हैं
5 के गुणकों को छोड़कर तीसरे के बाद की शर्तें नकारात्मक हैं (मॉडुलो 12 को कम करने के बाद)

इसलिए हम modulo 12 (2 बाइट्स को बचाने के लिए) को कम करके शुरू करते हैं। हम फिर मोडुलो तीन को कम करते हैं और परिणाम को उल्टा करते हैं, जो कि 3 या 0 के गुणकों के लिए 1 है अन्यथा। हम तब उस मूल्य को नहीं समझते हैं, जो हमें 3 या -1 के गुणकों के लिए -2 देता है। हम तब modulo 5 को कम करते हैं और 4 से अलग करते हैं, 1, 2, 3, 5, 10 और 12 (0) के लिए शून्य देते हैं। इन्वर्ट करना और नकारना हमें उन मूल्यों के लिए -1 और अन्य मूल्यों के लिए शून्य देता है। हम फिर बिटवाइज़ करते हैं या 1 के साथ और पहले की गणना से गुणा करते हैं।

— नील
स्रोत

0

टीआई-बेसिक, 26 बाइट्स

दुर्भाग्य से, बहुत ही निर्बाध दृष्टिकोण। मुझे कुछ कम नहीं मिला। सूची 1-अनुक्रमित है।

Input :{1,1,2,-1,1,-2:augment(Ans,-Ans:Ans(X

— Timtech
स्रोत

0

सी #, 73 71 बाइट्स

यह n के 0-अनुक्रमित मानों का उपयोग करता है।

n=>{int a=1,b=1,i=0,r;for(;++i<n;){r=i%2>0?a+b:a-b;a=b;b=r;}return b;};

प्रारूपित संस्करण:

Func<int, int> f = n =>
{
    int a = 1, b = 1, i = 0, r;

    for(; ++i < n;)
    {
        r = i % 2 > 0 ? a + b : a - b;
        a = b;
        b = r;
    }

    return b;
};

— TheLethalCoder
स्रोत

वैकल्पिक फिबोनाची

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

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

ओएसिस , 10 बाइट्स

05AB1E , 10 बाइट्स

पायथ - 13 बाइट्स

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

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

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

MATL , 17 16 15 बाइट्स

व्याख्या

WinDbg, 26 बाइट्स

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

परीक्षण और अपुष्ट:

गणितज्ञ, ४५ ४१ by बाइट्स

पर्ल 6 , 39 35 32 बाइट्स

सी #, 117 बाइट्स

आर, 38 बाइट्स

दरअसल , 22 बाइट्स

जावा 7, 88 82 79 बाइट्स

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

फोर्सलैंग , 153 बाइट्स

टर्टल , 35 बाइट्स

स्पष्टीकरण:

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

ABCR, 43 बाइट्स

बैच, 49 बाइट्स

टीआई-बेसिक, 26 बाइट्स

सी #, 73 71 बाइट्स