30

हम सभी फाइबोनैचि अनुक्रम से परिचित हैं :

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765

हालाँकि, इसके बजाय, f(n) = f(n-1) + f(n-2)हम पिछली 2 प्रविष्टियों की डिजिटल राशि लेंगे ।

अनुक्रम अभी भी शुरू होना चाहिए 0, 1, इसके बाद मतभेद तेजी से स्पष्ट होते हैं। यह सूची 0-अनुक्रमित है, आप 1-अनुक्रमित के रूप में अच्छी तरह से उपयोग कर सकते हैं, राज्य जो आपने उपयोग किया था।

f(0)  = 0
f(1)  = 1
f(2)  = 1   # 0 + 1
f(3)  = 2   # 1 + 1
f(4)  = 3   # 1 + 2
f(5)  = 5   # 2 + 3
f(6)  = 8   # 3 + 5
f(7)  = 13  # 8 + 5
f(8)  = 12  # 8 + 1 + 3
f(9)  = 7   # 1 + 3 + 1 + 2
f(10) = 10  # 1 + 2 + 7
f(11) = 8   # 7 + 1 + 0
f(12) = 9   # 1 + 0 + 8
f(13) = 17  # 8 + 9
f(14) = 17  # 9 + 1 + 7
f(15) = 16  # 1 + 7 + 1 + 7
f(16) = 15  # 1 + 7 + 1 + 6
f(17) = 13  # 1 + 6 + 1 + 5
f(18) = 10  # 1 + 5 + 1 + 3
f(19) = 5   # 1 + 3 + 1 + 0
f(20) = 6   # 1 + 0 + 5
f(21) = 11  # 5 + 6
f(22) = 8   # 6 + 1 + 1
f(23) = 10  # 1 + 1 + 8
f(24) = 9   # 8 + 1 + 0
f(25) = 10  # 1 + 0 + 9
f(26) = 10  # 9 + 1 + 0
f(27) = 2   # 1 + 0 + 1 + 0
(After this point it repeats at the 3rd term, 0-indexed)

नोट: मैंने पुनरावृत्ति पर ध्यान नहीं दिया, जब तक कि मैंने खुद को चुनौती नहीं दी, और यहाँ मैं सोच रहा था कि एक और उपन्यास फेकलोन चैलेंज लिखना असंभव होगा।

आपका कार्य एक नंबर दिया गया है, nइस क्रम का nth अंक आउटपुट।

सबसे पहले 3 अंक: [0,1,1],

24-अंक दोहराया पैटर्न: [2,3,5,8,13,12,7,10,8,9,17,17,16,15,13,10,5,6,11,8,10,9,10,10]

संकेत: आप अपने लाभ के लिए इस पुनरावृत्ति का फायदा उठाने में सक्षम हो सकते हैं।

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

बोनस: यदि आप अपने उत्तर में पुनरावृत्ति का उपयोग करते हैं, तो मैं सबसे कम बाइट-काउंट का उत्तर दूंगा जो कि अनुक्रम में दोहराव का लाभ उठाता है, जो 100 अंकों का एक इनाम है। इसे आपके मूल उत्तर के भाग के रूप में प्रस्तुत किया जाना चाहिए, आपके मूल उत्तर के बाद। इस पोस्ट को इस उदाहरण के रूप में देखें कि मैं किस बारे में बात कर रहा हूं: https://codegolf.stackexchange.com/a/108972/59376

इस बोनस के लिए अर्हता प्राप्त करने के लिए आपका कोड निरंतर समय ( O(1)) में स्पष्टीकरण के साथ चलना चाहिए ।

बोनस विजेता: डेनिस https://codegolf.stackexchange.com/a/108967/59376 <डेनिस जीता।

सबसे अनोखा कार्यान्वयन: https://codegolf.stackexchange.com/a/108970/59376
(सही उत्तर चुने जाने के बाद भी 100 अंक प्राप्त होंगे,)

code-golf sequence fibonacci code-golf math geometry random code-golf code-golf math decision-problem fractal rational-numbers code-golf number number-theory code-golf combinatorics permutations card-games code-golf math sequence array-manipulation fibonacci code-golf sequence decision-problem graph-theory code-golf ascii-art parsing lisp code-golf string math natural-language logic code-golf math logic code-golf string alphabet code-golf string code-golf string

— जादू ऑक्टोपस Urn
स्रोत

2

क्या हम 1-आधारित इंडेक्सिंग का उपयोग कर सकते हैं या क्या इसे 0-आधारित होना चाहिए?

— बिजनेस कैट

1

@BusinessCat हाँ, यकीन है, यह पेंच।

— मैजिक ऑक्टोपस Urn

1

आप दोहराव का फायदा कैसे उठाते हैं ? क्या इसे हार्डकोड किया जाना है या मैं सिर्फ %24एक "सामान्य" समाधान में जोड़ता हूं ?

— डेनिस

1

@ डेनिस का अर्थ है कि मैं दोहराव का फायदा उठा रहा हूं O(1)। आपका कोड निरंतर समय में चलना चाहिए, अगर यह वास्तव में पुनरावृत्ति का शोषण कर रहा है।

— मैजिक ऑक्टोपस Urn

1

@ डेनिस तकनीकी रूप से इनपुट पर 24% इसे 27 पुनरावृत्तियों में ऊपरी रूप से बांधेगा; जबकि दिलचस्प नहीं है, यह निश्चित रूप से मायने रखता है।

— मैजिक ऑक्टोपस Urn

7

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

कोड:

ScS+T

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

विस्तारित संस्करण:

ScS+10

स्पष्टीकरण:

ScS+   = a(n)
     0 = a(0)
    1  = a(1)
S      # Sum of digits on a(n-1)
 c     # Compute a(n-2)
  S    # Sum of digits
   +   # Add together

— अदनान
स्रोत

ओह यार ... मैं ओएसिस भी सीखना शुरू करने जा रहा हूं।

— मैजिक ऑक्टोपस Urn

28

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

f=(n,x=0,y=1)=>n?f(n-1,y,(x%9||x)+(y%9||y)):x

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

स्निपेट का विस्तार करें

xऔर yदोनों नहीं हो सकते 9, क्योंकि इसके लिए पिछली संख्या की आवश्यकता होगी 0, इसलिए उनकी डिजिटल राशि अधिक नहीं हो सकती 17। इसका मतलब यह है कि संख्या से अधिक के लिए डिजिटल रूट 9शेष modulo के समान है 9।

— नील
स्रोत

6

यह, यह भी दोहराव नेता के बराबर एक इनाम मिलेगा ... यह एक भयानक गणितीय अंतर्दृष्टि है।

— मैजिक ऑक्टोपस Urn

13

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

f=lambda n:n>1and sum(map(int,`f(n-1)`+`f(n-2)`))or n

पुनरावर्ती कार्य। के आधार मामलों n=0और n=1उपज n, बड़ी संख्या में कॉल करके f(n-1)और f(n-2)प्रत्येक स्ट्रिंग को परिवर्तित करके मान की गणना करते हैं, दो तारों को समेटते हुए, प्रत्येक वर्ण को फ़ंक्शन के mapसाथ उपयोग करके पूर्णांक में परिवर्तित करते हैं int, और फिर परिणामी सूची को जोड़ते हैं।

मॉडुलो -24 की जानकारी का उपयोग करके मैं वर्तमान में 56 बाइट गैर-पुनरावर्ती अनाम फ़ंक्शन प्राप्त कर सकता हूं:

lambda n:int(('011'+'2358dc7a89hhgfda56b8a9aa'*n)[n],18)

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

1

हाँ! इतना + क 1! एक पुनरावृत्ति उत्तर :)। मैंने आपके सम्मान में एक बोनस अनुभाग जोड़ा है सर, अब आप 100 अंकों की बाउंटी प्रतियोगिता में अग्रणी हैं!

— मैजिक ऑक्टोपस Urn

11

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

f=n=>n<2?n:~-f(--n)%9+~-f(--n)%9+2

27 या उसके ऊपर के इनपुट के लिए अपने ब्राउज़र को फ्रीज कर सकते हैं, लेकिन यह सभी इनपुट वैल्यू के लिए काम करता है। इसे एक साधारण कैश से सत्यापित किया जा सकता है:

c=[];f=n=>n<2?n:c[n]=c[n]||~-f(--n)%9+~-f(--n)%9+2

<input type=number value=0 min=0 step=1 oninput="O.value=f(this.value)"> <input id=O value=0 disabled>

स्निपेट का विस्तार करें

जैसा कि नील के शानदार जवाब में कहा गया है , आउटपुट कभी भी 17 से अधिक नहीं हो सकता है, इसलिए 9 से ऊपर के किसी भी आउटपुट का डिजिटल योग इसके बराबर है n%9। यह 9 से नीचे के आउटपुट के साथ भी काम करता है; हम इसे 9 के लिए काम कर सकते हैं और साथ ~-ही मापांक से पहले 1 घटाकर , फिर 1 के बाद वापस जोड़ सकते हैं।

हार्डकोडिंग के साथ सबसे अच्छा मैं कर सकता है 50 बाइट्स:

n=>"0x"+"7880136ba5867ffedb834968"[n%24]-(n<3)*9+2

— ETHproductions
स्रोत

6

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

;DFS
ç¡1

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

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

ç¡1   Main link. No arguments. Implicit left argument: 0

  1   Set the right argument to 1.
ç¡    Repeatedly execute the helper link n times – where n is an integer read from
      STDIN – updating the left argument with the return value and the right
      argument with the previous value of the left argument. Yield the last result.


;DFS  Helper link. Arguments: a, b

;     Concatenate; yield [a, b].
 D    Decimal; convert both a and b to their base-10 digit arrays.
  F   Flatten the result.
   S  Compute the sum of the digits.

वैकल्पिक समाधान, 19 बाइट्स, निरंतर समय

;DFS
9⁵ç23Ð¡⁸ịµṠ>?2

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

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

9⁵ç23Ð¡⁸ịµṠ>?2  Main link. Argument: n

9               Set the return value to 9
 ⁵              Yield 10.
  ç23Ð¡         Execute the helper link 23 times, with initial left argument 10
                and initial right argument 9, updating the arguments as before.
                Yield all intermediate results, returning
                [10,10,2,3,5,8,13,12,7,10,8,9,17,17,16,15,13,10,5,6,11,8,10,9].
   ⁸ị           Extract the element at index n. Indexing is 1-based and modular.
     µ          Combine all links to the left into a chain.
       >?2      If n > 2, execute the chain.
      Ṡ         Else, yield the sign if n.

— डेनिस
स्रोत

1

+1 के चुज़े के लिए "चलो लगातार समय में पूरे दोहराया अनुभाग की गणना करें": डी

— फेलिक्स डॉमबेक

4

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

_=$=>$<2?$:eval([..._(--$)+[_(--$)]].join`+`)

प्रयोग

_=$=>$<2?$:eval([..._(--$)+[_(--$)]].join`+`)
_(7)

उत्पादन

व्याख्या

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

...ऑपरेटर वर्ण, जो उसके बाद फिर से एक स्ट्रिंग में बदल जाती है की एक सरणी में इस स्ट्रिंग विभाजन है, लेकिन अब के साथ +मूल्यों के बीच तों। इस स्ट्रिंग को तब कोड के रूप में व्याख्या की जाती है, इसलिए राशि की गणना की जाती है, जिसे बाद में वापस कर दिया जाता है।

यह एक डबल-पुनरावर्ती एल्गोरिथ्म है, जो इसे काफी अक्षम बनाता है। इसे ^n-2इनपुट के लिए 2 फ़ंक्शन कॉल की आवश्यकता है n। जैसे, यहाँ एक लंबा लेकिन तेज समाधान है। इसके साथ आने के लिए ETHproductions का धन्यवाद।

f=($,p=1,c=0)=>$?f($-1,c,eval([...p+[c]].join`+`)):c

— ल्यूक
स्रोत

यह 27 जैसे बड़े मूल्यों के लिए काम नहीं करता है, यह ब्राउज़र को जमा देता है (कम से कम यह मेरे लिए करता है)

— क्रिस्ति लिथोस

इसमें कुछ समय लगता है, लेकिन यह वहां पहुंच जाएगा ... आखिरकार। मैं इसे देखूंगा, लेकिन इस चुनौती के लिए प्रदर्शन महत्वपूर्ण नहीं है ...

— ल्यूक

खैर, जीसस, यह कम्प्यूटेशनल रूप से तीव्र नहीं है, आपके कार्यक्रम को 27 से अधिक मूल्यों के लिए काम करना चाहिए ... लेकिन अगर यह 1-28 के लिए काम करता है, तो तकनीकी रूप से यह साबित होता है कि यह उच्चतर के लिए काम करता है।

— मैजिक ऑक्टोपस Urn

1

@KritiiLithos यह समस्या है कि पुनरावृत्ति है। अनुक्रम में n वें नंबर की गणना के लिए मोटे तौर पर 2 ^ (n-2) फ़ंक्शन कॉल की आवश्यकता होती है, जो बहुत तेज़ी से बनाता है।

— ETHproductions

आप [..._(--$)+[_(--$)]]:-)

— ETHproductions

4

05AB1E , 8 बाइट्स

XÎF‚¤sSO

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

व्याख्या

XÎ        # push 1,0,input
  F       # input_no times do:
   ‚      # pair the top 2 elements of the stack
    ¤     # push a copy of the 2nd element to the stack
     s    # swap the pair to the top of the stack
      S   # convert to list of digits
       O  # sum

— Emigna
स्रोत

3

CJam, 22 20 बाइट्स

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

ri2,{(_(jAb\jAb+:+}j

सीधी पुनरावर्ती एल्गोरिथ्म, कुछ भी नहीं फैंसी। 0 अनुक्रमित।

इसे ऑनलाइन आज़माएं! या 0-50 के लिए परीक्षण (वास्तव में बहुत तेजी से चलता है)।

व्याख्या

ri                    Read an integer from input
  2,                  Push the array [0 1]
    {             }j  Recursive block, let's call it j(n), using the input as n and [0 1] as base cases
     (                 Decrement (n-1)
      _(               Duplicate and decrement again (n-2)
        jAb            Get the list digits of j(n-2)
           \           Swap the top two elements
            jAb        Get the list of digits of j(n-1)
               +       Concatenate the lists of digits
                :+     Sum the digits

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

पुनरावृत्ति का उपयोग कर समाधान। जोनाथन एलन के समाधान के लिए समान एल्गोरिथ्म।

ri_2,1+"[2358DC7A89HHGFDA56B8A9AA]"S*~@*+=

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

— बिजनेस कैट
स्रोत

3

पर्ल 6 , 41 37 बाइट्स

{(0,1,{[+] |$^a.comb,|$^b.comb}...*)[$_]}

कोशिश करो

{(0,1,*.comb.sum+*.comb.sum...*)[$_]}

कोशिश करो

{ # bare block lambda with implicit parameter ｢$_｣
  (

    0, 1,           # first two values

    # WhateverCode lambda with two parameters ( the two ｢*｣ )
    *.comb.sum      # digital sum of first parameter
    +
    *.comb.sum      # digital sum of second parameter

    ...            # keep using that code object to generate new values until:

    *              # never stop

  )[ $_ ]          # index into the sequence
}

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

1

आप भीतर का लंबोदर जैसा लिख सकते हैं *.comb.sum+*.comb.sum।

— SMLS

2

MATL , 15 बाइट्स

lOi:"yyhFYAss]&

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

lO       % Push 1, then 0. So the next generated terms will be 1, 1, 2,... 
i        % Input n
:"       % Repeat that many times
  yy     %   Duplicate top two elements in the stack
  h      %   Concatenate into length-2 horizontal vector
  FYA    %   Convert to decimal digits. Gives a 2-row matrix
  ss     %   Sum of all matrix entries
]        % End
&        % Specify that next function (display) will take only 1 input
         % Implicit display

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

2

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

f=lambda n:n>2and~-f(n-1)%9+~-f(n-2)%9+2or n>0

भारी @ETHproductions 'ES6 जवाब से प्रेरित है ।

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

— डेनिस
स्रोत

2

सी, 96 बाइट्स

या 61 बाइट्स में से प्रत्येक से 1 बाइट के रूप में भागने के कोड गिने जाते हैं

0 अनुक्रमित। कुछ अन्य उत्तरों के समान ही मैं मानों की एक लुकअप तालिका अनुक्रमण कर रहा हूं, लेकिन मैंने इसे 4 बाइट विखंडू में संकुचित कर दिया है। मैंने मॉड 24 संस्करण की जांच करने की जहमत नहीं उठाई क्योंकि मुझे नहीं लगा कि यह उतना दिलचस्प था क्योंकि दूसरों ने पहले ही ऐसा कर लिया है, लेकिन चलो इसका सामना करते हैं, सी वैसे भी जीतने वाला नहीं है।

#define a(n) n<3?!!n:2+(15&"\x1\x36\xba\x58\x67\xff\xed\xb8\x34\x96\x87\x88"[(n-3)/2%12]>>n%2*4)

स्पष्टीकरण:

#define a(n)                                                                                     // using a preprocessor macro is shorter than defining a function
             n<3?!!n:                                                                            // when n is less than 3 !!n will give the series 0,1,1,1..., otherwise..
                                                                             (n-3)/2%12          // condition the input to correctly index the string...
                           "\x1\x36\xba\x58\x67\xff\xed\xb8\x34\x96\x87\x88"                     // which has the repeating part of the series encoded into 4 bits each number
                                                                                                 // these are encoded 2 less than what we want as all numbers in the series after the third are 2 <= a(n>2) <= 17 which conforms to 0 <= a(n>2) - 2 <= 15
                                                                                        >>n%2*4  // ensure the data is in the lower 4 bits by shifting it down, n%2 will give either 0 or 1, which is then multiplied by 4
                        15&                                                                      // mask those bits off
                     2+                                                                          // finally, add 2 to correct the numbers pulled from the string

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

— Ahemone
स्रोत

मैं 1 बाइट के रूप में एस्केप कोड गिनता हूं! महान काम

— अल्बर्ट रेनशॉ

2

जाप , 27 25 बाइट्स

U<2?U:~-ß´U %9+~-ß´U %9+2

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

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

— टॉम
स्रोत

अरे, Japt :-) का उपयोग करने के लिए धन्यवाद, आप दो बाइट्स को बचाने ´के --लिए उपयोग कर सकते हैं ।

— 14

2

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

a!b=sum$read.pure<$>([a,b]>>=show)
g=0:scanl(!)1g
(g!!)

इसे ऑनलाइन आज़माएं! उपयोग:(g!!) 12

— Laikoni
स्रोत

2

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

If[#<2,#,Tr[Join@@IntegerDigits[#0/@{#-1,#-2}]]]&

सीधी पुनरावर्ती परिभाषा। थोड़ी देर के बाद बहुत धीमा हो जाता है।

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

If[#<3,Sign@#,(9@@LetterNumber@"JJBCEHMLGJHIQQPOMJEFKHJ")[[#~Mod~24]]]&

आवधिक पैटर्न को हार्डकोड करना। गणित के लिए तेज़ और संतोषजनक रूप से अपमानजनक अपमानजनक :) 8 बाइट्स बचाने के लिए जंगवान मिन को धन्यवाद!

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

आपके दूसरे कोड के LetterNumber@"JJBCEHMLGJHIQQPOMJEFKHJ"लिए 8 बाइट्स से कम है 43626804920391712116157158790~IntegerDigits~18।

— जुंगह्वान मिन

आप सही हे! इन दिनों में से एक मैं याद करने जा रहा हूँ LetterNumber....

— ग्रेग मार्टिन

1

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

सरल पुनरावृत्त समाधान।

a,b=0,1
exec'a,b=b,(a%9or a)+(b%9or b);'*input()
print a

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

का उपयोग (a%9or a)+(b%9or b)वास्तव में कम से कम निकला sum(map(int(`a`+`b`)))!

— FlipTack
स्रोत

मुझे लगता है कि आप का मतलब है sum(map(int,a+b))(टिप्पणियों में `का उपयोग कैसे कर सकते हैं)

1

पॉवरशेल , 79 बाइट्स

$b,$c=0,1;for($a=$args[0];$a;$a--){$z=[char[]]"$b$c"-join'+'|iex;$b=$c;$c=$z}$b

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

लंबा उबाऊ पुनरावृत्ति समाधान जो प्रत्येक forलूप को प्रत्यक्ष अंकों-राशि की गणना करता है। लूप के अंत में, हम जो नंबर चाहते हैं वह अंदर है $b, इसलिए पाइप लाइन पर छोड़ दिया गया है और आउटपुट निहित है। ध्यान दें कि यदि इनपुट है 0, तो लूप प्रवेश नहीं करेगा क्योंकि सशर्त झूठी है, इसलिए $bबनी हुई है 0।

— AdmBorkBork
स्रोत

1

बैच, 85 बाइट्स

@set/ax=0,y=1
@for /l %%i in (1,1,%1)do @set/az=x-x/10*9+y-y/10*9,x=y,y=z
@echo %x%

मैं सोच रहा था कि मैं बैच के लिए अपने जावास्क्रिप्ट उत्तर को कैसे पोर्ट करने जा रहा हूं लेकिन सुराग @ डेनिस के पायथन समाधान में था।

— नील
स्रोत

1

अजगर, 20 बाइट्स

J,01VQ=+JssjRT>2J)@J

एक प्रोग्राम जो शून्य-अनुक्रमित पूर्णांक का इनपुट लेता है और परिणाम को प्रिंट करता है।

टेस्ट सूट (प्रारूपण के लिए पहला भाग)

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

[स्पष्टीकरण बाद में आ रहा है]

— TheBikingViking
स्रोत

1

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

->n{n<3?n<=>0:"9aa2358dc7a89hhgfda56b8a"[n%24].to_i(18)}

सरल हार्डकोड समाधान।

— जीबी
स्रोत

1

खड़ी , 40 बाइट्स

{!2:>[:$digitsflatmap sum\last\,]n*last}

यह मेमना निम्नलिखित मेमने के बराबर है:

{n : 2:>[:$digitsflatmap sum\last\,]n*last}

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

— कोनोर ओ ब्रायन
स्रोत

1

ऑक्टेव, 148 बाइट्स

function f = fib(n)
  if (n <= 1)
    f = n;
  else
    f = sum(int2str((fib(n - 1)))-48) + sum(int2str((fib(n - 2)))-48);
  endif
endfunction

— Pitagora
स्रोत

Ppcg में आपका स्वागत है! अच्छी पहली पोस्ट!

— R

1

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

import Numeric
import Data.Char
s i=foldr(\c i->i+digitToInt c)0$showInt i""
d a b=a:d b(s a+s b)
f 0=0
f 1=1
f 2=1
f i=d 2 3!!fromIntegral(mod(i-3)24)

f 123456789012345678901234567890123456789012345678उदाहरण के लिए फ़ंक्शन को लागू करें ।

कोड बहुत बड़े सूचकांकों के साथ भी काम करता है। कार्यान्वित मोडुलो 24 कार्यक्षमता के कारण यह बहुत तेज है।

असम्पीडित कोड:

-- FibonacciDigital
-- Gerhard
-- 13 February 2017

module FibonacciDigital () where

import Numeric
import Data.Char

-- sum of digits
digitSum :: Int -> Int 
digitSum i = foldr (\c i -> i + digitToInt c) 0 $ showInt i ""

-- fibonacci digital sequence function with arbitrary starting values
fibonacciDigitals :: Int -> Int -> [Int]
fibonacciDigitals a b = a : fibonacciDigitals b (digitSum a + digitSum b)

-- index -> fibonacci digital value
f :: Integer -> Int 
f 0 = 0 
f 1 = 1 
f 2 = 1 
f i = fibonacciDigitals 2 3 !! fromIntegral (mod (i-3) 24) 

-- End

— गेरहार्ड
स्रोत

0

आर, 90 बाइट्स

एक बहुत लंबा समाधान है, लेकिन मूल रूप से मेरे पास 108 से बेहतर है। मुझे संदेह है कि ऐसा करने का एक बेहतर तरीका है, लेकिन मैं इसे फिलहाल नहीं देख सकता।

function(n,x=0:1){repeat`if`(n,{x=c(x,sum(scan(t=gsub('',' ',x))))[-1];n=n-1},break);x[1]}

यह एक अनाम फ़ंक्शन है जो वेक्टर में संख्याओं को अंकों में विभाजित करने के लिए उपयोग करता है gsubऔर scan(t=विभाजित करता है । इनमें से राशि को वेक्टर में जोड़ा जाता है जबकि पहला आइटम गिराया जाता है। repeatअनुक्रम nसमय के माध्यम से कदम के लिए प्रयोग किया जाता है और परिणाम वेक्टर का पहला आइटम है।

— MickyT
स्रोत

0

PHP, 80 बाइट्स

for($r=[0,1];$i<$argn;)$r[]=array_sum(str_split($r[$i].$r[++$i]));echo$r[$argn];

ऑनलाइन संस्करण

— जार्ग हुल्सरमन
स्रोत

0

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

r=IntegerDigits;f@0=0;f@1=1;f[x_]:=f@x=Tr@r@f[x-1]+Tr@r@f[x-2];f@#&

— J42161217
स्रोत

डिजिटल सम फाइबोनैचि

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

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

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

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

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

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

वैकल्पिक समाधान, 19 बाइट्स, निरंतर समय

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

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

प्रयोग

उत्पादन

व्याख्या

05AB1E , 8 बाइट्स

CJam, 22 20 बाइट्स

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

पर्ल 6 , 41 37 बाइट्स

MATL , 15 बाइट्स

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

सी, 96 बाइट्स

जाप , 27 25 बाइट्स

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

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

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

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

पॉवरशेल , 79 बाइट्स

बैच, 85 बाइट्स

अजगर, 20 बाइट्स

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

खड़ी , 40 बाइट्स

ऑक्टेव, 148 बाइट्स

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

आर, 90 बाइट्स

PHP, 80 बाइट्स

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