Arka fon

Çoğu kişi Fibonacci sayılarına aşinadır F(n):

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

Bu yineleme fonksiyonu tarafından oluşturulmaktadır F(n) = F(n-1) + F(n-2)ile F(0)=0ve F(1)=1. A000045

Yakın ilişkili bir dizi Lucas sayılarıdır L(m) :

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

Bu yineleme fonksiyonu tarafından oluşturulmaktadır L(m) = L(m-1) + L(m-2)ile L(0)=2ve L(1)=1. A000032

Eğer çift veya tek endekslere dayalı iki dizi arasında,
A(x) = F(x)eğer x mod 2 = 0ve A(x) = L(x)aksi takdirde yapı ile dönüşüm yapabiliriz . Örneğin, A(4)o F(4)zamandan beri eşittir 4 mod 2 = 0. Bu diziyi arayacağım Lucas-nacci Sayılar , A(x):

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

Bu yineleme fonksiyonu ile oluşturulabilir A(x) = 3*A(x-2) - A(x-4)ile A(0)=0, A(1)=1, A(2)=1ve A(3)=4. A005013

Meydan okuma

Giriş verildiğinde n, yukarıda açıklandığı gibi n+1dahil olmak üzere sayı dizisini A(n)çıktılayın. En az bayt (veya Meta üzerinde ayrı ayrı belirlenen LabVIEW gibi bayt eşdeğerleri ) kazanır.

Giriş

Tek bir negatif olmayan tam sayı n.

Çıktı

Numaraların listesi bundan Lucas-nacci sayıların alt diziyle tekabül A(0)etmek A(n). Liste, yukarıda açıklandığı gibi sıralı bir sırada olmalıdır.

kurallar

• Standart kod golf kuralları ve kaçamak kısıtlamaları geçerlidir.
• Standart giriş / çıkış kuralları geçerlidir.
• Giriş numarası herhangi bir uygun biçimde olabilir: tek veya ondalık, STDIN'den okuma, işlev veya komut satırı bağımsız değişkeni vb. - seçiminiz.
• Çıktı STDOUT'a yazdırılabilir veya işlev çağrısının bir sonucu olarak döndürülebilir. Basılıysa, sayıları ayırt etmek için uygun sınırlayıcılar dahil edilmelidir (boşlukla ayrılmış, virgülle ayrılmış vb.).
• Buna ek olarak, STDOUT çıktısı, çevredeki beyaz alan, son satır sonu vb. İsteğe bağlıdır.
• Girdi tamsayı veya negatif bir tamsayı ise, davranış tanımlanmadığı için program herhangi bir şey yapabilir veya hiçbir şey yapamaz.

Örnekler

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

Jöle, 12 bayt

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

Çevrimiçi deneyin!

Arka fon

F (-1) = 1 ve L (-1) = -1'i tanımlayarak F ve L'yi -1'e genişletebiliriz. Bu, özyinelemeli işlevle tutarlıdır.

Programımız

-1  1
 0  2

Her adımda, bir sonraki çifti oluşturmak için, son çifti tersine çevirir ve sondan bir önceki çifte ekleriz. Örneğin:

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

Bu işleme birkaç adım daha devam edersek,

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

Lucas-nacci dizisi basitçe sol sütundur.

Nasıl çalışır

;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.

^‡ С sola iki bağlantı göz atar: 2ve U+¥. En soldaki bir nilad olduğundan, ilmeğin gövdesi olamaz. Bu nedenle, U+¥gövde olarak kullanılır ve girişten bir sayı okunur. Komut satırı bağımsız değişkenleri olmadığından, bu sayı STDIN'den okunur.

CJam, 21 20 bayt

1 bayt tasarruf için Sp3000'e teşekkürler.

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

Burada test edin.

açıklama

Sadece meydan okuma özelliğinde verilen yinelemeyi kullanır.

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.

Perl 6, 42 bayt

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

kullanım

> 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)

Haskell, 59 , 57 , 56 , 52 , 51 bayt

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

Seri tanımı bu cevaptan uyarlanmıştır .

Daha az golf:

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 starttanımlanan sonsuz liste verir: f(0)=start, f(1)=1, f(n)=f(n-1) + f(n-2). whichStart itek giriş için 2 (Lucas serisi) veya çift için (Fibonacci serisi) 0 döndürür. lucasNacci iLucas-nacci numarasını verir. firstN nlisteden çıkar.

Boomerang tarafından kurtarılan bir bayt.

ES6, 65 bayt

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

Soruda verilen tekrarlama ilişkisini kullanır.

Retina , 70 62 59 bayt

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

f
1

Çevrimiçi deneyin

• Giriş tekli bazda, n 1s.
• 1? $`¶- Her sayı için 0 ila n arasında bir satır oluşturun : , 1, 11, 111, 1111, ...
• m`^(11)*1$ $&ff- ffTek satırlara ekleyin . Bu, işlevi L (0) = 2 ile tohumlar.
• m`$  f-  fTüm satırlara ekleyin (alanı not edin). Bu, Fibonacci sayıları için 0 ve 1 ve Lucas sayıları için 2 ve 1 işlevini tohumlar.
• +`1(f*) (f*) $2 $2$1 - Döngü: Hala 1s varken F (n + 1) = F (n) + F (n-1) değerini hesaplayın.
•  f*   - Her satırın sonundan F (n + 1) çıkarın.
• Değiştir fler 1s geri. Bu gerekli değilse ve fs ile kalabilirsek , uzunluk sadece 55 bayttır.

Oracle SQL 11.2, 218 216 201 bayt

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;

Un-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;

Dizinin ilk 3 öğesini oluşturmak için İŞARET işlevini kullanarak (kötüye??) Birkaç bayt kazanmayı başardım.

Japt, 25 22 21 bayt

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

Çevrimiçi test edin!

Arka fon

Japt'te bir Fibonacci dizisi oluşturmak biraz zor, ama bunu bizim Mgiçin yapacak yerleşik bir modelimiz var . Bununla birlikte, bu bize Lucas dizisini değil, sadece Fibonacci dizisini verir. Bu diziyi kullanarak Lucas dizisini oldukça kolay bir şekilde başarabiliriz:

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

Gördüğünüz gibi, herkes için F(N-1) + F(N+1)eşittir . Bununla birlikte, tek endekslerde sadece Lucas sayılarına ihtiyacımız olduğundan, iki formülü bir araya getirebiliriz: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

Nasıl çalışır

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.)

Mathematica, 52 51 bayt

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

Yukarıda Martin ile çok benzer bir fikir, fonksiyon için "temel vakaları" tanımlamak için daha kısa bir yol bulmaya çalışırken biraz zaman geçirdim. Polinom enterpolasyonu bir büst oldu, bu yüzden oldukça kısa bir tanım elde etmek için uzantıyı negatiflere kullanarak buna gittim.

Mathematica, 56 bayt

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

Çok basit uygulama. Bir yardımcı işlevi tanımlar fve ardından ftüm sonuçları almak için bir aralığa uygulanan adsız bir işlevi değerlendirir . Bu gereksiz yere hantal geliyor.

Tek bir adlandırılmamış işlev, bir bayt daha uzun olsa da:

Switch[#,0,0,1,1,2,1,3,4,_,3#0[#-2]-#0[#-4]]&/@0~Range~#&

MATL , 17 18 bayt

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

Martin CJam cevabının neredeyse doğrudan çevirisi .

Çevrimiçi deneyin!

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

Brachylog , 51 bayt

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

Bu, bir sayıyı girdi olarak alır ve her sayıyı ayıran boşluklarla listeye STDOUT'a yazdırır.

açıklama

§ 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

!Alt yüklem 1'in ilk kuralındaki kesik gereklidir, böylece geri izlediğimizde ( \), yorumlayıcının 4'ten daha az bir girdi için ikinci kuralı deneyeceği sonsuz bir döngü elde edemeyiz.

Mathematica, 41 bayt

LinearRecurrence[{0,3,0,-1},{0,1,1,4},#]&

Groovy, 50 Bayt

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

Bu, n'yi ilk argüman olarak alan ve Fibocas dizisindeki ilk dört sayının temel durumunu işlevin geri kalanı için varsayılan argümanlar olarak içeren x işlevini tanımlar.

burada b, c, d ve e dizideki sonraki dört elementtir.

N'yi sıfırlar ve n sıfırdan küçük olana kadar tekrarlar - tekrarladığında, geçerli dizisindeki ilk öğeyi nihai dönüş değerine ekler. Dizideki sonraki dört öğe için yeni değerler özyinelemeli çağrıya verilir - son üç öğe ilk üç olacak şekilde kaydırılır ve 3 * db kullanılarak önceki öğelerin ikisinden yeni bir dördüncü öğe oluşturulur.

Groovy bir listeye doldurarak birden fazla değeri döndürebileceğinden, yeni değerleri liste yuvalarıyla sınırlar; böylece her çağrı geçerli ilk öğeyi ve kendi listesi olacak özyinelemenin sonucunu döndürür.

R , 55 bayt

A=c(0,1,1,4);for(x in 4:scan()+1)A[x]=3*A[x-2]-A[x-4];A

Çevrimiçi deneyin!

• JayCe sayesinde -24 bayt

Dikmesi , 19

Bu, Martin yaklaşımının oldukça doğrudan bir çevirisi.

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

Nasıl çalışır:

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.

DUP , 32 bayt

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

Try it here!

Yığında sayı dizisi bırakan anonim bir lambda. Kullanımı:

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

açıklama

[                              {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}

Python 2, 71 bayt

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)

Bu kesinlikle çok uzun görünüyor. Ancak, bitsel notoperatörü kullanmamdan memnun kaldım ... iki kez. Bir zamanlar bir parite gibi ileri geri dönün ve bir kez nulaştığında özyinelemeyi sonlandırmak için -1.

Değişken pher zaman ya 0ya olur -1, dolayısıyla girişler 0ya -1da listenin arasında değişecektir . ( -1Python listesinin girişini seçmek, son öğeyi seçmek anlamına gelir.)

C ++ Şablon Meta Programlama, 130 bayt

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)

Yinelemeli tanımlar bir şekilde C ++ TMP, ağlıyor:

L<x>::v

ile xolmak A(x)istersen.