लुकास-नेकी नंबर

19

पृष्ठभूमि

ज्यादातर सभी फाइबोनैचि संख्याओं से परिचित हैं F(n):

0, 1, 1, 2, 3, 5, 8, 13, 21 ...

ये और के F(n) = F(n-1) + F(n-2)साथ पुनरावृत्ति फ़ंक्शन द्वारा बनते हैं । A000045F(0)=0F(1)=1

बारीकी से संबंधित अनुक्रम लुकास संख्या है L(m) :

2, 1, 3, 4, 7, 11, 18, 29 ...

ये और के L(m) = L(m-1) + L(m-2)साथ पुनरावृत्ति फ़ंक्शन द्वारा बनते हैं । A000032L(0)=2L(1)=1

हम निर्माण और साथ ही / विषम सूचकांकों के आधार पर दो अनुक्रमों के बीच वैकल्पिक कर सकते हैं,
A(x) = F(x)अगर x mod 2 = 0और A(x) = L(x)अन्यथा। उदाहरण के लिए, के बाद से A(4)बराबर है । हम इस क्रम फोन करता हूँ लुकास-nacci नंबर , :F(4)4 mod 2 = 0A(x)

0, 1, 1, 4, 3, 11, 8, 29, 21, 76 ...

यह प्रत्यावर्तन समारोह द्वारा गठित किया जा सकता A(x) = 3*A(x-2) - A(x-4)के साथ A(0)=0, A(1)=1, A(2)=1, और A(3)=4। A005013

चुनौती

दिए गए इनपुट के अनुसार n, ऊपर बताए अनुसार n+1और सहित संख्याओं का क्रम आउटपुट A(n)। नवीनतम बाइट्स (या बाइट-समकक्ष, जैसे लैब व्यू के लिए , जैसा कि मेटा पर व्यक्तिगत रूप से निर्धारित होता है) जीतता है।

इनपुट

एक एकल गैर-नकारात्मक पूर्णांक n।

उत्पादन

संख्याओं की एक सूची जो लुकास-नेक्सिया संख्याओं के बाद के से मेल खाती A(0)है A(n)। सूची क्रमबद्ध क्रम में होनी चाहिए जैसा कि ऊपर वर्णित है।

नियम

  • मानक कोड-गोल्फ नियम और लूपहोल प्रतिबंध लागू होते हैं।
  • मानक इनपुट / आउटपुट नियम लागू होते हैं।
  • इनपुट नंबर किसी भी उपयुक्त प्रारूप में हो सकता है: एकात्मक या दशमलव, STDIN, फ़ंक्शन या कमांड-लाइन तर्क, आदि से पढ़ा - आपकी पसंद।
  • आउटपुट को STDOUT में प्रिंट किया जा सकता है या फ़ंक्शन कॉल के परिणामस्वरूप वापस किया जा सकता है। यदि मुद्रित किया जाता है, तो संख्याओं को अलग करने के लिए उपयुक्त सीमांकक को शामिल किया जाना चाहिए (अंतरिक्ष-पृथक, अल्पविराम से अलग, आदि)।
  • इसके अतिरिक्त, अगर STDOUT, आसपास के व्हाट्सएप, ट्रेलिंग न्यूलाइन, आदि के लिए आउटपुट सभी वैकल्पिक हैं।
  • यदि इनपुट एक गैर-पूर्णांक या एक नकारात्मक पूर्णांक है, तो प्रोग्राम कुछ भी या कुछ भी नहीं कर सकता है, क्योंकि व्यवहार अपरिभाषित है।

उदाहरण

Input -> Output
0 -> 0
5 -> 0, 1, 1, 4, 3, 11
18 -> 0, 1, 1, 4, 3, 11, 8, 29, 21, 76, 55, 199, 144, 521, 377, 1364, 987, 3571, 2584
code-golf  math  sequence 
— AdmBorkBork
स्रोत
क्या नईलाइन को एक स्वीकृत परिसीमन माना जाता है?
— corsiKa
@corsiKa ज़रूर, यह ठीक है।
— AdmBorkBork

जवाबों:

9

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

;2U+¥Ð¡-,1ZḢ

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

पृष्ठभूमि

हम F (-1) = 1 और L (-1) = -1 को परिभाषित करके एफ और एल -1 को बढ़ा सकते हैं। यह पुनरावर्ती कार्य के अनुरूप है।

हमारे कार्यक्रम के साथ शुरू होता है

-1  1
 0  2

प्रत्येक चरण में, अगली जोड़ी बनाने के लिए, हम अंतिम जोड़ी को उल्टा करते हैं और इसे जोड़े में जोड़ते हैं। उदाहरण के लिए:

[0, 2] U+¥ [-1, 1] -> [2, 0] + [-1, 1] -> [1, 1]

यदि हम कुछ और चरणों के लिए इस प्रक्रिया को जारी रखते हैं, तो हम प्राप्त करते हैं

-1  1
 0  2
 1  1
 1  3
 4  2
 3  7
11  5

लुकास-नेक्सिस अनुक्रम बस बाएं कॉलम है।

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

;2U+¥Ð¡-,1ZḢ  Niladic link. No implicit input.
              Since the link doesn't start with a nilad, the argument 0 is used.

;2            Concatenate the argument with 2, yielding [0, 2].
       -,1    Yield [-1, 1]. This is [L(-1), F(-1)].
    ¥         Create a dyadic chain of the two atoms to the left:
  U             Reverse the left argument.
   +            Add the reversed left argument and the right one, element-wise.
     С       For reasons‡, read a number n from STDIN.
              Repeatedly call the dyadic link U+¥, updating the right argument with
              the value of the left one, and the left one with the return value.
              Collect all intermediate results.
          Z   Zip the list of results, grouping the first and seconds coordinates.
           Ḣ  Head; select the list of first coordinates.

‡ С बाईं ओर दो लिंक पर peeks: 2और U+¥। चूँकि सबसे बाईं ओर एक निलाद है, यह लूप का शरीर नहीं हो सकता है। इसलिए, U+¥शरीर के रूप में उपयोग किया जाता है और इनपुट से एक संख्या पढ़ी जाती है। चूंकि कोई कमांड-लाइन तर्क नहीं हैं, इसलिए उस नंबर को STDIN से पढ़ा जाता है।

— डेनिस
स्रोत
2
मुझे आभास होता है कि आप इस तरह के सामान (जेली में गोल्फ) करते हैं। जिससे मुझे घबराहट होती है।
— Draco18s
24
अगर किसी को जीवित करने के लिए गोल्फ (कोड) कैसे करना है, तो कृपया मुझे चैट में पिंग करें। एक दोस्त के लिए पूछ रहा है ...
— मार्टिन एंडर
2
इसलिए मूल रूप से आप केवल दोनों अनुक्रमों की गणना कर रहे हैं, लेकिन प्रत्येक चरण पर उलट रहे हैं, जो प्रभावी रूप से दृश्यों के बीच स्विच करता है।
— नील
1
@ नील, बिल्कुल। यह बाद में अनुक्रमों को दखल देने से बचता है, जो थोड़ा लंबा है।
— डेनिस
6

सीजाम, 21 20 बाइट्स

1 बाइट बचाने के लिए Sp3000 का धन्यवाद।

TXX4ri{1$3*4$-}*?;]p

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

व्याख्या

बस चुनौती युक्ति में दी गई पुनरावृत्ति का उपयोग करता है।

TXX4 e# Push 0 1 1 4 as base cases.
ri   e# Read input and convert to integer N.
{    e# Run this N times...
  1$ e#   Copy a(n-2).
  3* e#   Multiply by 3.
  4$ e#   Copy a(n-4).
  -  e#   Subtract.
}*
?;   e# Discard the last three values, using a ternary operation and popping the result.
]p   e# Wrap the rest in an array and pretty-print it.
— मार्टिन एंडर
स्रोत
1
कौन (या क्या) Sp3000 है जो आप हर उत्तर पर धन्यवाद देते हैं?
— CJ डेनिस
— मार्टिन
5
@CJDennis कुछ लोग कहते हैं कि वह अब तक का सबसे बड़ा अजगर गोल्फ खिलाड़ी है। कुछ लोग कहते हैं कि वह एक पहाड़ के ऊपर एक एकांत केबिन में रहता है, जिसे न्यूनतम संख्या में लॉग से बनाया गया है। कुछ लोग कहते हैं कि वह हमारे सिर के पीछे की आवाज़ है, जो हमें तब परेशान करती है जब हम समाधान पोस्ट करते हैं जिसे आगे बढ़ाया जा सकता है। लेकिन हम में से ज्यादातर का कहना है कि वह उपयोगकर्ता है जिसका प्रोफ़ाइल मार्टिन जुड़ा हुआ है।
— मेगो
6

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

{(0,1,1,4,{$^b;$^d;3*$^c-$^a}...*)[0..$_]}

प्रयोग

> my &f = {(0,1,1,4,{$^b;$^d;3*$^c-$^a}...*)[0..$_]}
-> ;; $_? is raw { #`(Block|184122176) ... }
> f(0)
(0)
> f(5)
(0 1 1 4 3 11)
> f(18)
(0 1 1 4 3 11 8 29 21 76 55 199 144 521 377 1364 987 3571 2584)
— हॉटकी
स्रोत
1
सबसे स्पष्ट {( (0,1,*+*...*) Z (2,1,*+*...*) ).flat.rotor( 1=>2, 1=>0 )[ 0..$_ ].flat}
— मेमना
यह देखते हुए कि सटीक शब्द "एन" दिया गया है, आप इसके साथ एक बाइट बचा सकते हैं (0,1,1,4,{$^b;$^d;3*$^c-$^a}...*)[^(n+1)]:।
— raiph 3
6

हास्केल, 59 , 57 , 56 , 52 , 51 बाइट्स

l a=2*mod a 2:scanl(+)1(l a)
f n=[l i!!i|i<-[0..n]]

श्रृंखला की परिभाषा इस उत्तर से अनुकूलित है ।

कम गोल्फ वाला: 

fibLike start = start : scanl (+) 1 (fibLike start)
whichStart i = (2*mod i 2)
lucasNacci i = fibLike (whichStart i) !! i
firstN n = [ lucasNacci i | i <- [0..n]]

fibLike startएक अनंत सूची देता है, परिभाषित f(0)=start, f(1)=1, f(n)=f(n-1) + f(n-2):। whichStart iविषम इनपुट (लुकास श्रृंखला) के लिए 2 रिटर्न या यहां तक ​​कि (फाइबोनैचि श्रृंखला) के लिए 0। lucasNacci iith लुकास- nacci नंबर देता है। firstN nसूची पर नक्शे।

बूमरैंग द्वारा बचाए गए एक बाइट।

— माइकल क्लेन
स्रोत
1
मुझे लगता है कि आप को ले जाकर एक और बाइट प्राप्त कर सकते हैं 2*mod i 2में lतो आप कोष्ठक निकाल सकते हैं। इस तरह: l a=2*mod a 2:scanl(+)1(l a)औरf n=[l i!!i|i<-[0..n]]
— बेसाइल-हेनरी
@ बुमरंग युप, वह काम करता है। धन्यवाद
— माइकल क्लेन
5

ईएस 6, 65 बाइट्स

n=>[...Array(n)].map(_=>a.shift(a.push(a[2]*3-a[0])),a=[0,1,1,4])

प्रश्न में दिए गए पुनरावृत्ति संबंध का उपयोग करता है।

— नील
स्रोत
5

रेटिना , 70 62 59 बाइट्स

1
¶$`1
m`^(11)*1$
$&ff
m`$
 f
+`1(f*) (f*)
$2 $2$1
 f*

f
1

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

  • इनपुट unary base, n 1s में है।
  • 1? $`¶- 0 से n तक प्रत्येक संख्या के लिए एक लाइन बनाएं : , 1, 11, 111, 1111, ...
  • m`^(11)*1$ $&ff- ffविषम रेखाओं पर जाएं। यह L (0) = 2 के साथ फ़ंक्शन को बीज देगा।
  • m`$  f-  fसभी लाइनों के लिए आवेदन (अंतरिक्ष ध्यान दें)। यह फाइबोनैचि संख्याओं के लिए 0 और 1 के साथ कार्य करता है, और लुकास संख्या के लिए 2 और 1।
  • +`1(f*) (f*) $2 $2$1 - लूप: गणना करें F (n + 1) = F (n) + F (n-1) जबकि अभी भी 1s हैं।
  •  f*   - प्रत्येक पंक्ति के अंत से F (n + 1) निकालें।
  • f1 s पर वापस बदलें । यदि इसकी आवश्यकता नहीं है और हम fs के साथ रह सकते हैं , तो लंबाई सिर्फ 55 बाइट्स है।
— कोबी
स्रोत
5

Oracle SQL 11.2, 218 216 201 बाइट्स

WITH v(a,b,c,d,i)AS(SELECT 0,1,1,4,3 FROM DUAL UNION ALL SELECT b,c,d,3*c-a,i+1 FROM v WHERE i<:1)SELECT SIGN(LEVEL-1) FROM DUAL WHERE LEVEL-1<=:1 CONNECT BY LEVEL<4UNION ALL SELECT d FROM v WHERE:1>2;

संयुक्त राष्ट्र के golfed

WITH v(a,b,c,d,i) AS 
(
  SELECT 0,1,1,4,3 FROM DUAL 
  UNION ALL 
  SELECT b,c,d,3*c-a,i+1 FROM v WHERE i<:1
)
SELECT SIGN(LEVEL-1) FROM DUAL WHERE LEVEL-1<=:1 CONNECT BY LEVEL<4
UNION ALL SELECT d FROM v WHERE:1>2;

मैं अनुक्रम के पहले 3 तत्वों को उत्पन्न करने के लिए SIGN फ़ंक्शन का उपयोग करके (दुरुपयोग करके) कुछ बाइट्स प्राप्त करने में कामयाब रहा।

— Jeto
स्रोत
3

जाप, 25 22 21 बाइट्स

Uò £MgXf2)+X%2*Mg°X)r

इसे ऑनलाइन टेस्ट करें!

पृष्ठभूमि

जाप में फाइबोनैचि अनुक्रम बनाना कुछ कठिन है, लेकिन हमारे पास Mgइसे बनाने के लिए हमारे पास है। हालांकि, यह केवल हमें फाइबोनैचि अनुक्रम देता है, लुकास अनुक्रम नहीं। हम इस चाल का उपयोग करके लुकास अनुक्रम को आसानी से पूरा कर सकते हैं:

N    F(N-1)  F(N+1)  F(N-1)+F(N+1)
0    1       1       2
1    0       1       1
2    1       2       3
3    1       3       4
4    2       5       7
5    3       8       11
6    5       13      18
7    8       21      29

जैसा कि आप देख सकते हैं, सभी के लिए F(N-1) + F(N+1)समान है । हालाँकि, जब से हमें विषम सूचकांकों पर केवल लुकास संख्या की आवश्यकता होती है, हम दो सूत्रों को एक में जोड़ सकते हैं:L(N)N

N    N-N%2  N+N%2    F(N-N%2)  F(N+N%2)*(N%2)  F(N-N%2)+F(N+N%2)*(N%2)
0    0      0        0         0               0
1    0      2        0         1               1
2    2      2        1         0               1
3    2      4        1         3               4
4    4      4        3         0               3
5    4      6        3         8               11
6    6      6        8         0               8
7    6      8        8         21              29

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

Uò £  MgX-1 +X%2*Mg° X)r
Uò mX{MgX-1 +X%2*Mg++X)r

             // Implicit: U = input integer
Uò mX{       // Create the inclusive range [0..U], and map each item X to:
MgXf2)+      //  Floor X to a multiple of 2, calculate this Fibonacci number, and add:
+X%2*Mg++X)  //  Calculate the (X+1)th Fibonacci number and multiply by X%2.
)r           //  Round the result. (The built-in Fibonacci function returns
             //  a decimal number on higher inputs.)
— ETHproductions
स्रोत
3

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

If[#>2,3#0[#-2]-#0[#-4],#-If[#>1,1,0]]&/@0~Range~#&

मार्टिन के उपरोक्त विचार के समान ही, मैंने समारोह के लिए "आधार मामलों" को परिभाषित करने का एक छोटा तरीका खोजने की कोशिश में कुछ समय बिताया। बहुपद प्रक्षेप एक विक्षोभ था, इसलिए मैं इसके लिए चला गया, नकारात्मक में विस्तार का उपयोग करते हुए काफी कम परिभाषा।

— एक सीमन्स
स्रोत
2

मैथेमेटिका, 56 बाइट्स

f@0=0
f@1=f@2=1
f@3=4
f@n_:=3f[n-2]-f[n-4];
f/@0~Range~#&

बहुत सीधा कार्यान्वयन। एक सहायक कार्य को परिभाषित करता है fऔर फिर एक अनाम फ़ंक्शन का मूल्यांकन करता है जो fसभी परिणामों को प्राप्त करने के लिए एक सीमा पर लागू होता है। यह अनावश्यक रूप से बोझिल लगता है।

एक एकल अनाम फ़ंक्शन हालांकि लंबे समय तक एक बाइट लगता है:

Switch[#,0,0,1,1,2,1,3,4,_,3#0[#-2]-#0[#-4]]&/@0~Range~#&
— मार्टिन एंडर
स्रोत
2

MATL , 17 18 बाइट्स

0ll4i:"y3*5$y-](x

मार्टिन के सीजेएम उत्तर का लगभग सीधा अनुवाद ।

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

0ll4       % push first four numbers: 0,1,1,4
i:         % input n and generate array [1,2,...,n]
"          % for loop. Repeat n times
  y        % copy second-top element from stack
  3*       % multiply by 3
  5$y      % copy fifth-top element from stack
  -        % subtract. This is the next number in the sequence
]          % end loop
(x         % indexing operation and delete. This gets rid of top three numbers
— लुइस मेंडो
स्रोत
2

ब्रेकीलॉग , 51 बाइट्स

:0re{:4<:[0:1:1:4]rm!.|-4=:1&I,?-2=:1&*3-I=.}w,@Sw\

यह एक संख्या को इनपुट के रूप में लेता है और सूची के STDOUT में प्रिंट करता है, प्रत्येक नंबर को अलग करने वाले रिक्त स्थान के साथ।

व्याख्या

§ Main predicate

:0re{...}               § Enumerate integers between 0 and the Input, pass the integer 
                        § as input to sub-predicate 1      
         w,@Sw          § Write sub-predicate 1's output, then write a space
              \         § Backtrack (i.e. take the next integer in the enumeration)


§ Sub-predicate 1

:4<                     § If the input is less than 4
   :[0:1:1:4]rm!.       § Then return the integer in the list [0,1,1,4] at index Input

|                       § Else

-4=:1&I,                § I = sub_predicate_1(Input - 4)
        ?-2=:1&*3-I=.   § Output = sub_predicate_1(Input - 2) * 3 - I

!उप-विधेय 1 के पहले नियम में कटौती आवश्यक है ताकि जब हम पीछे हटें ( \), तो हम एक अनंत लूप में अंत नहीं करते हैं जहां दुभाषिया 4 से कम इनपुट के लिए दूसरे नियम की कोशिश करेगा।

— Fatalize
स्रोत
2

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

x={a,b=0,c=1,d=1,e=4->a<0?:[b,x(a-1,c,d,e,3*d-b)]}

यह फ़ंक्शन x को परिभाषित करता है, जो पहले तर्क के रूप में n में लेता है और बाकी फ़ंक्शन के लिए डिफ़ॉल्ट तर्क के रूप में फिबोकास अनुक्रम में पहले चार नंबर का आधार मामला है।

यहाँ एक n है। बी, सी, डी, और ई अनुक्रम में अगले चार तत्व हैं।

यह n को घटाता है और तब तक घटाता है जब तक n शून्य से कम नहीं होता है - जब यह पुनरावर्तन करता है, तो यह परम रिटर्न वैल्यू को इसके वर्तमान अनुक्रम में पहले तत्व को जोड़ता है। अनुक्रम में अगले चार तत्वों के लिए नए मान पुनरावर्ती कॉल को दिए गए हैं - पिछले तीन तत्वों को पहले तीन होने के लिए स्थानांतरित कर दिया गया है, और 3 * डीबी का उपयोग करके पिछले तत्वों में से दो से एक नया चौथा तत्व उत्पन्न होता है।

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

— पैट्रिक स्टीफन
स्रोत
1

तोरण , १ ९

यह मार्टिन के दृष्टिकोण का एक बहुत ही सीधा अनुवाद है।

0114{@-4@-33*-,i}=4

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

0114    # Push 0, 1, 1, 4 to the stack.
{       # Start a for loop.
 @-4    # Get the stack element at index -4
 @-3    # Get the stack element at index -3
 3      # Push 3 to the stack.
 *      # Multiply the top two elements of the stack.
 -      # Subtract the top two elements of the stack.
  ,     # Switch to loop iterations.
 i      # Get command line args.
}       # End for loop.
=4      # Discard the top 4 elements of the stack.
— मॉर्गन थ्राप्प
स्रोत
1

डीयूपी , 32 बाइट्स

[a:0 1$4[a;1-$a:][1ø3*4ø-]#%%]

Try it here!

एक अनाम लंबोदर जो ढेर पर संख्याओं का एक क्रम छोड़ देता है। उपयोग:

8[a:0 1$4[a;1-$a:][1ø3*4ø-]#%%]!

व्याख्या

[                              {start lambda}
 a:                            {save input number to a}
   0 1$4                       {base cases to get us started}
        [       ][       ]#    {while loop}
         a;1-$a:               {a--, check if a>0}
                  1ø3*4ø-      {3*stack[n-2]-stack[n-4]}

                           %%  {discard top 2 stack items}
                             ] {end lambda}
— मामा फन रोल
स्रोत
1

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

def a(n,x=0,y=1,z=2,w=1,p=0):
 if~n:print[x,z][p];a(n-1,y,x+y,w,z+w,~p)

यह निश्चित रूप से बहुत लंबा लगता है। हालांकि, मैं खुश था कि मुझे बिटवाइज़ notऑपरेटर का उपयोग करने के लिए मिला ... दो बार। एक बार एक समता की तरह आगे और पीछे एक बार फ्लिप, और एक बार जब पुनरावृत्ति को समाप्त करने के लिए nपहुँचता है -1।

चर pहमेशा 0या -1तो होगा, इसलिए यह प्रविष्टियों 0या -1सूची के बीच वैकल्पिक होगा । ( -1पायथन सूची में प्रवेश का अर्थ है अंतिम तत्व चुनना ।)

— mathmandan
स्रोत
1

सी ++ टेम्पलेट मेटा प्रोग्रामिंग, 130 बाइट्स

template<int X>struct L{enum{v=3*L<X-2>::v-L<X-4>::v};};
#define D(X,A) template<>struct L<X>{enum{v=A};};
D(0,0)D(1,1)D(2,1)D(3,4)

पुनरावर्ती परिभाषाएँ किसी तरह C ++ TMP के लिए रोती हैं, उपयोग:

L<x>::v

आप की तरह xहोने के साथ A(x)।

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