Iccanobif अनुक्रम का उत्पादन

22

एक प्रोग्राम या नामांकित फ़ंक्शन लिखें, जो कि nIccanobif अनुक्रम में वें पूर्णांक तक अनुक्रम को आउटपुट करेगा या वापस करेगा , O014 पर A014258 के रूप में प्रलेखित । ध्यान दें कि शून्य में केवल शून्य तत्व ( 0) मुद्रित होगा n।

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

आपके प्रोग्राम का इनपुट पूर्णांक होना चाहिए।

आपके देखने की खुशी के लिए अनुक्रम के पहले 20 नंबर यहां दिए गए हैं:

0, 1, 1, 2, 3, 5, 8, 31, 93, 421, 415, 638, 3501, 9314, 51821, 53116, 739401, 715297, 8964541, 8389769

मानक खामियों को मना किया जाता है।

सबसे छोटा कार्यक्रम जीतता है।

संपादित करें: यह स्पष्ट करने के लिए एक नोट जोड़ा गया कि अनुक्रम शून्य तत्व से शुरू होता है और शून्य होने पर इसे शामिल किया जाना चाहिए n।

उदाहरण IO संभावनाएं:

0    ->    0
1    ->    0 1
6    ->    0 1 1 2 3 5 8
17   ->    [0, 1, 1, 2, 3, 5, 8, 31, 93, 421, 415, 638, 3501, 9314, 51821, 53116, 739401, 715297]

अब जब कई उत्तर हैं, तो पायथन 2 में मेरे कार्यान्वयन नीचे दिए गए हैं, जिन्हें मैंने मार्कअप के साथ छिपाने के लिए कड़ी मेहनत की थी:

Iterative:

# मेरे प्रारंभिक कार्यक्रम के लिए सबसे बेहतर। 73 बाइट्स। यह भी ध्यान दिया जाना चाहिए कि यह कार्यक्रम
 स्टैक ओवरफ्लो तक नहीं पहुंच सकता। यह 10 सेकंड से कम समय में n = 5000 के लिए चलता है।

i,a,b=input(),0,1
print a
while i:print b;i,a,b=i-1,b,int(str(a+b)[::-1])

पुनरावर्ती:

# नोट करें कि यह प्रिंट nनई सुर्खियों में है। 64 बाइट्स।
 N के बड़े मानों के लिए एक स्टैक ओवरफ्लो त्रुटि होगी।

def f(n,i=0,j=1):print i,n and f(n-1,j,int(str(i+j)[::-1]))or'';

code-golf  number  sequence  fibonacci 
— mbomb007
स्रोत
8
+1 फिबोनाची अनुक्रम के साथ करने के लिए कुछ सोचने के लिए जो पहले नहीं किया गया है
— लेवल रिवर सेंट
@steveverrill मैंने तय किया कि मैं एक और चुनौती देना चाहता हूं, फिर मैंने कल्पना करने के बाद यह देखना शुरू कर दिया कि अनुक्रम कैसा दिखेगा। इसलिए मैंने एक कार्यक्रम लिखा। फिर मैंने OEIS को खोजा और चुनौती दी।
— mbomb007
क्या यह इस प्रश्न से प्रेरित था ?
— जॉन जे
@ जॉन नंबर मैंने इसे पहले देखा है, लेकिन यह चुनौती इस साइट पर सबसे सरल चुनौतियों में से एक है। नहीं, मैं केवल अपनी कल्पना से विशुद्ध रूप से एक संख्या अनुक्रम बना रहा था जिसे मैं एक चुनौती के रूप में उपयोग कर सकता था।
— mbomb007
3
मुझे लगता है कि आपको उत्तर स्वीकार करने से पहले थोड़ा इंतजार करना चाहिए। जब तक कि कोई एक उत्तर स्पष्ट रूप से अपराजेय नहीं है (उदाहरण के लिए, 1 बाइट समाधान), तो कम से कम एक सप्ताह इंतजार करना उचित है।
— डेनिस

जवाबों:

3

पायथ, 17 15 14

Pu+Gs_`s>2GQU2

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

बहुत मूल कार्यान्वयन, range(2)इनपुट के बराबर कई तत्वों के साथ शुरू होता है और जुड़ता है, फिर अंतिम तत्व से अतिरिक्त पॉप को स्लाइस करता है ।

@ >उलट बात बताने के लिए @Jakube का धन्यवाद ।

व्याख्या

Pu+Gs_`s>2GQU2    : Q = eval(input) (implicit)
P                 : all but the last element
 u         QU2    : reduce Q times starting with [0, 1]
  +G              : add to the previous result
       s>2G       : sum of the last two elements of G
    s_`           : int(reversed(repr(above value)))
— FryAmTheEggman
स्रोत
4

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

a=0;b=1
exec"print a;a,b=b,int(str(a+b)[::-1]);"*-~input()

strबैकटिक्स के बजाय कन्वर्ट करने के लिए उपयोग करता है क्योंकि पायथन 2 में बड़ी संख्या में अंत में एक एल के साथ लिखा जाता है। मैंने एक पुनरावर्ती कार्य करने की कोशिश की, लेकिन यह अधिक लंबा (61) निकला:

f=lambda n,a=0,b=1:-~n*[0]and[a]+f(n-1,b,int(str(a+b)[::-1]))
— XNOR
स्रोत
3

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

f=n->(t=[0,1];for i=2:n push!(t,t[i]+t[i-1]|>string|>reverse|>int)end;t[1:n+1])

यह एक फ़ंक्शन बनाता है जो एक पूर्णांक को इनपुट के रूप में स्वीकार करता है और एक पूर्णांक सरणी देता है।

असंगठित + स्पष्टीकरण:

function f(n)
    # Start with the usual Fibonacci stuff
    t = [0,1]

    # Looooooooooooooop
    for i = 2:n
        # Compute the Iccanobif number by piping results
        iccanobif = t[i] + t[i-1] |> string |> reverse |> int

        # Jam it into t
        push!(t, iccanobif)
    end

    # Return the first n + 1
    t[1:n+1]
end

उदाहरण:

julia> f(1)
2-element Array{Int64,1}:
 0
 1

julia> f(17)
18-element Array{Int64,1}:
      0
      1
      1
      2
      3
      5
      8
     31
     93
    421
    415
    638
   3501
   9314
  51821
  53116
 739401
 715297
— एलेक्स ए।
स्रोत
3

टी-एसक्यूएल, 149

एक पुनरावर्ती CTE क्वेरी का उपयोग करने वाले बहुत सीधे आगे इनलाइन तालिका फ़ंक्शन। जैसा कि यह INT का उपयोग कर रहा है यह 37 से बाहर हो जाएगा। बड़े निशान के लिए सीएटीएस में जोड़ने से यह आगे 63 तक जाने की अनुमति देगा

create function i(@ int)returns table return with r as(select 0I,1N union all select n,reverse(i+n)+0from r)select 0n union all select top(@)n from r

इसका उपयोग निम्नानुसार किया जाता है

select * from i(0)
n
-----------
0

(1 row(s) affected)

select * from i(1)
n
-----------
0
1

(2 row(s) affected)

select * from i(6)
n
-----------
0
1
1
2
3
5
8

(7 row(s) affected)

select * from i(17)
n
-----------
0
1
1
2
3
5
8
31
93
415
421
638
3501
9314
51821
53116
715297
739401

(18 row(s) affected)
— MickyT
स्रोत
3

के, 25 23 बाइट्स

{-1_ x{x,.|$+/-2#x}/!2}

नो स्टिंकिंग लूप्स में एक उदाहरण का एक सरल संशोधन ।

वाक्यांश .|$एक स्ट्रिंग को एक संख्या देता है, इसे उलट देता है और फिर इसका मूल्यांकन करता है।

संपादित करें:

मेरी ओर से सीमा की स्थिति पर ध्यान देना। अधिक सही अब:

  {-1_ x{x,.|$+/-2#x}/!2}'0 1 6 10
(,0
 0 1
 0 1 1 2 3 5 8
 0 1 1 2 3 5 8 31 93 421 415)

2 संपादित करें:

(x+1)#के साथ प्रतिस्थापित किया जा सकता है -1_, 2 पात्रों की बचत। अंतरिक्ष आवश्यक है क्योंकि अन्यथा _xएक पहचानकर्ता होगा, जब मैं चाहता हूं कि "ड्रॉप" ऑपरेटर नामक एक चर पर लागू हो x।

— JohnE
स्रोत
2
ओपी के अनुसार, उत्पादन शून्य से शुरू होना चाहिए।
— स्ट्रेच
सही- अभी तय होना चाहिए।
— जॉन ईएन
1
केवल एक उत्तर देने के लिए यहां आया था कि आपको वही दिखाई दे। अच्छी तरह से किया।
— tmartin
3

हास्केल, 64 49 बाइट्स

a!b=a:b!(read$reverse$show$a+b)
q n=0:take n(1!1)

प्रयोग उदाहरण: q 15->[0,1,1,2,3,5,8,31,93,421,415,638,3501,9314,51821,53116]

यह कैसे काम करता है: !पुनरावर्ती रूप से यह पहले तर्क के साथ शुरू होने वाले iccanobif संख्याओं की एक अनंत सूची बनाता है (दूसरा तर्क अगले iccanobif संख्या होना चाहिए)। qके nसाथ शुरू होने वाली iccanobif सूची से पहले नंबर लेता है और एक prepends 1, 1है 0।

— nimi
स्रोत
2

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

U1{_2$+sW%i}ri*;]p

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

U1                      e# First two numbers in the series
  {        }ri*         e# Run the loop input numbers times
   _2$+                 e# Get sum of last two numbers in the series
       sW%i             e# Convert to string, inverse and convert back to a number
                ;       e# Remove the last number to get only first n + 1 numbers.
                 ]p     e# Wrap all numbers in an array and print the array

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

— अनुकूलक
स्रोत
2

जावा - 126 124

मैं थोड़ी देर में इस साइट के आसपास जावा नहीं देखा है ...

void f(int b){for(int c=0,d=1,g;b-->=0;d=Integer.valueOf(new StringBuilder(c+(c=d)+"").reverse()+""))System.out.println(c);}

f(5) प्रिंट 0 1 1 2 3 5 8 31 93 421 415 638

— खिंचाव की कमी
स्रोत
मैं भी स्वीकार ...System.out.println(c);
— करूँगा
@ mbomb007 धन्यवाद! मुझे 2 बाइट्स से बचाया।
— स्ट्रेच मणिक
जावा के स्ट्रिंग हेरफेर के बाद से आप नंबर को रिवर्स करने के लिए संख्यात्मक पद्धति का उपयोग करके संभवतः इसे छोटा कर सकते हैं ।
— mbomb007
मुझे पता है कि यह 1.5 साल से अधिक हो गया है, लेकिन आप के Integer.valueOf(साथ बदलकर 6 बाइट्स बचा सकते हैं new Long((और फिर intफॉर-लूप longमें भी बदल सकते हैं)। यदि आप इसके बजाय पूर्णांक के साथ काम करना पसंद करते हैं, new Integer(तो अभी भी कम है Integer.valueOf(।
— केविन क्रूज़सेन
2

SWI- प्रोलॉग, 141 131 121 बाइट्स

a(X,R):-X>1,A is X-1,a(A,B),reverse(B,[K,L|_]),W is K+L,name(W,Z),reverse(Z,Y),name(E,Y),nth0(X,R,E,B);X=1,R=[0,1];R=[0].

रनिंग a(17,X).आउटपुट:

[0, 1, 1, 2, 3, 5, 8, 31, 93, 421, 415, 638, 3501, 9314, 51821, 53116, 739401, 715297]

a(10000,X).मेरे कंप्यूटर पर परिणाम के बारे में 10 सेकंड लेता है ।

संपादित करें: ऊपर 121 बाइट्स संस्करण एक विधेय परिभाषा = एक लाइनर है। पुराना 131 बाइट्स संस्करण निम्नलिखित है (जैसा होना चाहिए p(17,X)):

a(0,[0]).
a(1,[1,0]).
a(X,[E|B]):-A is X-1,a(A,B),B=[K,L|_],W is K+L,name(W,Z),reverse(Z,Y),name(E,Y).
p(X,Y):-a(X,Z),reverse(Z,Y).
— Fatalize
स्रोत
2

> <> (मछली) 592 254 बाइट्स

सुपर गोल्फ नहीं (42/43 ब्लैंक जो कुछ नहीं करते हैं और कुल 30 पुनर्निर्देशन टोकन हैं), लेकिन यह एक दिलचस्प अभ्यास था जो इसे पहले स्थान पर काम कर रहा था।

10!/{:}0=?v/{1-}}:{+:0}!/a,:1%-:0=?!v~{:1!/$:@0=?!v$~}}:&{{&*\
/-$/    ;n/\oo", "n:    \       }+1{/     \$-1$*a /|.!20}}01@/
* :{:}(?v:{!":}-1!/$:@0=?!v$~{:}1!/$:@0=?!v$~}}}:&{{{&*:1%-*&{{&+}}{1+}02.
b .1 +bb   \      \$-1$*a /       \$-1$,a /
\*9{~~~{/

आप इसे यहाँ परीक्षण कर सकते हैं , प्रारंभिक स्टैक में वांछित लंबाई प्रदान ।

EDIT: बाइट काउंट से अधिक

— Fongoid
स्रोत
2

PHP, 114 , 109 बाइट्स

function f($n){if($n==0)return 0;$f=[0,1];for($i=2;$i<=$n;++$i){$f[$i]=strrev($f[$i-1]+$f[$i-2]);}return $f;}

कुछ भी नहीं फैंसी, स्ट्रिंग रिवर्स जादू के साथ सिर्फ एक औसत फिबोनैकी एल्गोरिथ्म।

Ungolfed:

function f($n)
{
    if($n == 0) return 0;
    $f = [0, 1];
    for ($i=2; $i<=$n; ++$i){
        $f[$i] = strrev($f[$i-1] + $f[$i-2]);
    }
    return $f;
}
— अल्वारो अर्रेगुई
स्रोत
1

एक्सेल VBA, 279 बाइट्स

n = InputBox("n")
For i = 0 To n
If i < 2 Then
Cells(i + 1, 1) = i
ElseIf i > 6 Then
x = Cells(i, 1) + Cells(i - 1, 1)
l = Len(x)
v = CStr(x)
For j = 1 To l
r = r + Right(v, 1)
v = Left(v, l - j)
Next j
Cells(i + 1, 1) = r
r = ""
Else
Cells(i + 1, 1) = Cells(i, 1) + Cells(i - 1, 1)
End If
Next i

मैक्रो को चलाने से उपयोगकर्ता को n के लिए मान दर्ज करने के लिए संकेत मिलेगा।

इसके बाद कॉलम A में पंक्ति द्वारा परिणाम मुद्रित किया जाएगा:

उत्पादन

— Wightboy
स्रोत
1
क्या आप इसे कम करने के लिए अपने कोड में रिक्त स्थान निकाल सकते हैं?
— mbomb007
@ mbomb007 जब एक्सेल VBA में लिखते हैं तो स्पेस अपने आप ही आ जाते हैं, इसलिए मैं बस उन्हें अंदर छोड़ देता हूं।
— Wightboy
1

जावास्क्रिप्ट (ES2015), 81 73 बाइट्स

(a,b=0,c=1)=>{for(;a-->-1;c=[...(b+(b=+c)+"")].reverse().join``)alert(b)}

इस फ़ंक्शन को (नाम f) के साथ चलाना 6:

f(6);// alerts: 0, 1, 1, 2, 3, 5, 8
— Downgoat
स्रोत
1

पिप , 13 बाइट्स

मुझे पूरा यकीन है कि इस कार्यक्रम में उपयोग की जाने वाली सभी विशेषताएं पिप में मौजूद थीं, इससे पहले कि यह प्रश्न पूछा जाए।

LaSio:+RVi+oi

कमांड-लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

               a is 1st cmdline arg; i is 0; o is 1 (implicit)
La             Loop (a) times:
       RVi+o   Reverse of i+o
      +        Unary + treats its operand as a number, thus removing leading 0's
    o:         Assign the result to o...
  Si           ... before swapping i and o
            i  After the loop, output i

दो चर के मान इस तरह विकसित होते हैं:

Iter   o   i (output)
   0   1   0
   1   0   1
   2   1   1
   3   1   2
   4   2   3
   5   3   5
   6   5   8
   7   8  31
   8  31  93
   9  93 421
  10 421 415
— DLosc
स्रोत
0

पुष्य , 18 बाइट्स (गैर-प्रतिस्पर्धात्मक)

Z1{:2d+vFs@KjkvF;_

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

यह कार्यक्रमों का सबसे सुरुचिपूर्ण नहीं है, लेकिन यह काम करता है।

Z1     \ Push 0 and 1 to begin the sequence
{:     \ Input times do:
 2d+   \   Add the last two terms
 vF    \   Send to second stack
 s     \   Split into digits
 @Kjk  \   Reverse and join into one number
 vF;    \   Send back to first stack
_      \ At the end of the program, print the whole stack.
— FlipTack
स्रोत
@ mbomb007 हाँ, माफ करना!
— 9
0

आर, 134 बाइट्स

i=function(n){s=c(0,1);for(i in 3:n){s[i]=as.numeric(paste0(rev(strsplit(as.character(s[i-2]+s[i-1]),'')[[1]]),collapse=''))};cat(s)}

उदाहरण:

> i(10)
0 1 1 2 3 5 8 31 93 421

यह देखना पसंद करेंगे कि क्या किसी के पास आपका नंबर लेने से बेहतर R विकल्प था, इसे एक स्ट्रिंग करें, इसे उल्टा करें और इसे फिर से एक नंबर में बदल दें।

— एंड्रयू हेन्स
स्रोत
0

ग्रूवी, 70 बाइट्स

{r={"$it".reverse() as int};f={n->n<3?1:r(f(n-1))+r(f(n-2))};r(f(it))}

{
    r={"$it".reverse() as int};       // Reverse digits, costly using string.
    f={n->n<3?1:r(f(n-1))+r(f(n-2))}; // Recursive Iccanobbif implementation.
    r(f(it))                          // Reverse final output.
}
— जादू ऑक्टोपस Urn
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.