Fibonacci n-step number sequences: Difference between revisions

{{trans|Python: Callable class}}

 

Int addnum

[Int] memo

L(n, name) zip(2..10, ‘fibo tribo tetra penta hexa hepta octo nona deca’.split(‘ ’))

V fibber = Fiblike([1] [+] (0 .< n - 1).map(i -> Int(2 ^ i)))

 

{{out}}

 

=={{header|360 Assembly}}==

FIBONS CSECT

USING FIBONS,R13 base register

PG DS CL120 buffer

REGEQU

{{out}}

<pre>

 

=={{header|ACL2}}==

(if (endp xs)

0

(list (sum prevs)))))

(cons (first next)

 

Output:

 

=={{header|Action!}}==

 

PROC GenerateSeq(CARD ARRAY init BYTE nInit CARD ARRAY seq BYTE nSeq)

Test("nonanacci",fibInit,9,MAX)

Test("decanacci",fibInit,10,MAX)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Fibonacci_n-step_number_sequences.png Screenshot from Atari 8-bit computer]

First, we specify a package Bonacci, that defines the type Sequence (of Positive numbers), a function Generate that takes a given Start sequence and outputs a generalized N-Bonacci Sequence of a spefified Length, and some constant start sequences.

 

 

type Sequence is array(Positive range <>) of Positive;

Start_Tetranacci: constant Sequence := (1, 1, 2, 4);

Start_Lucas: constant Sequence := (2, 1);

 

The implementation is quite straightforward.

 

 

function Generate(Start: Sequence; Length: Positive := 10) return Sequence is

end Generate;

 

 

Finally, we actually generate some sequences, as required by the task. For convenience, we define a procedure Print that outputs a sequence,

 

 

procedure Test_Bonacci is

Print("Decanacci: ",

Bonacci.Generate((1, 1, 2, 4, 8, 16, 32, 64, 128, 256), 15));

 

The output:

 

=={{header|ALGOL 68}}==

# the initial values are taken from the init array #

PROC n step fibonacci sequence = ( []INT init, INT required count )[]INT:

print sequence( "tetrabonacci", n step fibonacci sequence( ( 1, 1, 2, 4 ), 10 ) );

print sequence( "lucus ", n step fibonacci sequence( ( 2, 1 ), 10 ) )

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

nacci ← 2*0⌈¯2+⍳

{{out}}

<pre>1 1 2 3 5 8 13 21 34 55

=={{header|AppleScript}}==

===Functional===

use framework "Foundation"

use scripting additions

end tell

end zipWith

{{Out}}

<pre>Lucas -> [2,1,3,4,7,11,18,29,47,76,123,199,322,521,843]

===Simple===

 

-- n: …nacci step size as integer. Alternatively "Lucas".

-- F: Maximum …nacci index required. (0-based.)

set AppleScript's text item delimiters to astid

 

 

{{output}}

tribonacci: 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136 …

tetranacci: 0, 1, 1, 2, 4, 8, 15, 29, 56, 108, 208, 401, 773, 1490, 2872, 5536 …

nonanacci: 0, 1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 511, 1021, 2040, 4076, 8144 …

decanacci: 0, 1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1023, 2045, 4088, 8172 …

 

=={{header|AutoHotkey}}==

Loop, 9 {

Out .= seq "(" A_Index + 1 "): "

}

return, a

'''Output:'''

<pre>nacci(2): 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610

 

=={{header|AWK}}==

function sequence(values, howmany) {

init_length = length(values)

print("lucas :\t\t",sequence(a, 10))

}

'''Output:'''

<pre>

lucas : 2 1 3 4 7 11 18 29 47 76

</pre>

 

=={{header|Batch File}}==

@echo off

 

endlocal

exit /b

{{out}}

<pre>

=={{header|BBC BASIC}}==

The BBC BASIC '''SUM''' function is useful here.

PRINT "Fibonacci:"

NEXT

f%(i%-1) = s%

'''Output:'''

<pre>

=={{header|Befunge}}==

 

v9013"Tetranacci"9014"Lucas"<

>"iccanobirT"2109"iccanobiF"v

_$.1+:77+`^vg03:_0g+>\:1+#^

50p-\30v v\<>\30g1-\^$$_:1-

 

{{out}}

=={{header|Bracmat}}==

{{trans|PicoLisp}}

= Init Cnt N made tail

. ( plus

& out$(str$(pad$!name ": ") nacci$(!Init.12))

)

Output:

<pre> fibonacci: 1 1 2 3 5 8 13 21 34 55 89 144

 

=={{header|BQN}}==

Nacci ← (2⋆0∾↕)∘(⊢-1˙)

 

{{out}}

<pre>┌─

 

=={{header|C}}==

The function anynacci determines the n-arity of the sequence from the number of seed elements. 0 ended arrays are used since C does not have a way of determining the length of dynamic and function-passed integer arrays.*/

 

 

return 0;

 

Output:

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

}

}

<pre>Fibonacci 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,

Lucas 2, 1, 3, 4, 7, 11, 18, 29, 47, 76,

 

=={{header|C++}}==

#include <iostream>

#include <numeric>

}

return 0 ;

Output:

<pre>fibonacci : 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ...

This version focuses on a clean, simple class that adapts to any pair of starting numbers and any order. Rather than summing over all history every time, it uses an O(1) incremental update to a running total. Thus, performance remains essentially unchanged even for very large orders.

 

#include <iostream>

#include <vector>

}

}

 

=={{header|Clojure}}==

(letfn [(s [] (lazy-cat init (apply map + (map #(drop % (s)) (range (count init))))))]

(s)))

(show "Tribonacci" [1 1 2])

(show "Tetranacci" [1 1 2 4])

{{out}}

<pre>first 20 Fibonacci (1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765)

 

=={{header|CLU}}==

n_step = proc (seq: sequence[int], n: int) returns (int)

a: array[int] := sequence[int]$s2a(seq)

print_n(seq.seq, 10)

end

{{out}}

<pre>Fibonacci 1 1 2 3 5 8 13 21 34 55

 

=={{header|Common Lisp}}==

(defun gen-fib (lst m)

"Return the first m members of a generalized Fibonacci sequence using lst as initial values

(format t "Lucas series: ~a~%" (gen-fib '(2 1) 10))

(loop for i from 2 to 4

{{out}}

<pre>Lucas series: (2 1 3 4 7 11 18 29 47 76)

=={{header|D}}==

===Basic Memoization===

import std.stdio, std.algorithm, std.range, std.conv;

 

15.iota.map!fibber);

}

{{out}}

<pre>[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

===Callable Struct===

The output is similar.

 

struct fiblike(T) {

n, name, 15.iota.map!fib);

}

 

===Struct With opApply===

The output is similar.

 

struct Fiblike(T) {

writefln("n=%2d, %5snacci -> %s", n, name, fib.takeApply(15));

}

 

===Range Generator Version===

import std.stdio, std.algorithm, std.range, std.concurrency;

 

writefln("n=%2d, %5snacci -> %(%s, %), ...", n, name, fib.take(15));

}

{{out}}

<pre>[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

=={{header|Delphi}}==

See [[#Pascal]].

=={{header|EchoLisp}}==

;; generate a recursive lambda() for a x-nacci

;; equip it with memoïzation

(make-nacci name seed)

(printf "%s[%d] → %d" name (vector-length seed) (take name 16))))

{{out}}

=={{header|Elixir}}==

{{trans|Ruby}}

def anynacci(start_sequence, count) do

n = length(start_sequence)

:io.format("~11s: ", [name])

IO.inspect RC.anynacci(list, 15)

 

{{out}}

 

=={{header|Erlang}}==

-module( fibonacci_nstep ).

 

{Sum_ns, _Not_sum_ns} = lists:split( Nth, Ns ),

{Nth, [lists:sum(Sum_ns) | Ns]}.

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM FIBON

 

FIB("Lucas","2,1")

END PROGRAM

 

=={{header|F_Sharp|F#}}==

 

let fiblike init =

(Seq.init prefix.Length (fun i -> (prefix.[i], i+2)))

printfn " lucas -> %A" (start (fiblike [2; 1]))

Output

<pre>n= 2, fibonacci -> [1; 1; 2; 3; 5; 8; 13; 21; 34; 55; 89; 144; 233; 377; 610]

=={{header|Factor}}==

<code>building</code> is a dynamic variable that refers to the sequence being built by <code>make</code>. This is useful when the next element of the sequence depends on previous elements.

 

: n-bonacci ( n initial -- seq ) [

qw{ fibonacci tribonacci tetranacci lucas }

{ { 1 1 } { 1 1 2 } { 1 1 2 4 } { 2 1 } }

{{out}}

<pre>

 

=={{header|Forth}}==

: a{ here cell allot ;

: } , here over - cell / over ! ;

." tetranacci: " a{ 1 , 1 , 2 , 4 } show-nacci

." lucas: " a{ 2 , 1 } show-nacci

{{out}}

<pre>fibonacci: 1 1 2 3 5 8 13 21 34 55

 

=={{header|Fortran}}==

! save this program as file f.f08

! gnu-linux command to build and test

end subroutine nacci

end program f

 

<pre>

 

=={{header|FreeBASIC}}==

 

' Deduces the step, n, from the length of the dynamic array passed in

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|FunL}}==

native scala.collection.mutable.Queue

 

t.row( ([k] + [seqs(i)(k) | i <- 0:4]).toIndexedSeq() )

 

 

{{out}}

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

Solution using separate goroutines.

 

import "fmt"

fmt.Println()

}

{{out}}

<pre>

=={{header|Groovy}}==

=====Solution=====

assert seed : "The seed list must be non-null and non-empty"

assert seed.every { it instanceof Number } : "Every member of the seed must be a number"

}

}

=====Test=====

' fibonacci':[1,1],

'tribonacci':[1,1,2],

 

println " lucas[0]: ${fib([2,1],0)}"

{{out}}

<pre> fibonacci: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

 

=={{header|Haskell}}==

 

fiblike :: [Integer] -> [Integer]

 

nstep :: Int -> [Integer]

 

main :: IO ()

main = do

{{out}}

<pre>

 

Or alternatively, without imports – using only the default Prelude:

 

nStepFibonacci :: Int -> [Int]

 

justifyLeft :: Int -> Char -> String -> String

<pre>Lucas -> [2,1,3,4,7,11,18,29,47,76,123,199,322,521,843]

fibonaccci -> [1,1,2,3,5,8,13,21,34,55,89,144,233,377,610]

or in terms of '''unfoldr''':

{{Trans|Python}}

import Data.List (transpose, uncons, unfoldr)

 

 

justifyRight :: Int -> Char -> String -> String

{{Out}}

<pre>Recurrence relation sequences:

 

Works in both languages:

every writes("F2:\t"|right((fnsGen(1,1))\14,5) | "\n")

every writes("F3:\t"|right((fnsGen(1,1,2))\14,5) | "\n")

suspend cache[i]

}

 

Output:

A slightly longer version of <tt>fnsGen</tt> that reduces the memory

footprint is:

every i := seq() do {

if i := (i > *cache, *cache) then {

suspend cache[i]

}

 

The output is identical.

=={{header|J}}==

 

2 fibonacci 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ...

3 tribonacci 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ...

octonacci ✓

nonanacci ✓

 

=={{header|Java}}==

'''Code:'''

 

{

public static int[] lucas(int n, int numRequested)

}

}

 

Output:

=={{header|JavaScript}}==

===ES5===

return nacci(nacci([1,1], arity, arity), arity, len);

}

}

 

{{out}}

<pre>fib(2): 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610

 

===ES6===

'use strict';

 

// MAIN ---

return main();

<pre>Lucas -> [2,1,3,4,7,11,18,29,47,76,123,199,322,521,843]

fibonacci -> [1,1,2,3,5,8,13,21,34,55,89,144,233,377,610]

=={{header|jq}}==

{{Works with|jq|1.4}}

def nacci(arity; len):

arity as $arity | len as $len

def lucas(arity; len):

arity as $arity | len as $len

'''Example''':

(range(2; 11) | "fib(\(.)): \(fib(.; 15))"),

(range(2; 11) | "lucas(\(.)): \(lucas(.; 15))")

;

 

{{Out}}

$ jq -M -r -n -f fibonacci_n-step.jq

 

'''Generalized Fibonacci Iterator Definition'''

type NFib{T<:Integer}

n::T

return (f, fs)

end

 

'''Specification of the n-step Fibonacci Iterator'''

 

The seeding for this series of sequences is <math>F_{1-n} = 1</math> and <math>F_{2-n} \ldots F_{0}=0</math>.

function fib_seeder{T<:Integer}(n::T)

a = zeros(BigInt, n)

NFib(n, k, fib_seeder)

end

 

'''Specification of the Rosetta Code n-step Lucas Iterator'''

 

This iterator produces the task description's version of the Lucas Sequence ([https://oeis.org/A000032 OEIS A000032]) and its generalization to n-steps as was done by some of the other solutions to this task. The seeding for this series of sequences is <math>F_{1-n} = 3</math>, <math>F_{2-n} = -1</math> and, for <math>n > 2</math>, <math>F_{3-n} \ldots F_{0}=0</math>.

function luc_rc_seeder{T<:Integer}(n::T)

a = zeros(BigInt, n)

NFib(n, k, luc_rc_seeder)

end

 

'''Specification of the MathWorld n-step Lucas Iterator'''

 

This iterator produces the Mathworld version of the Lucas Sequence ([http://mathworld.wolfram.com/LucasNumber.html Lucas Number] and [https://oeis.org/A000204 OEIS A000204]) and its generalization to n-steps according to Mathworld ([http://mathworld.wolfram.com/Lucasn-StepNumber.html Lucas n-Step Number] and [https://cs.uwaterloo.ca/journals/JIS/VOL8/Noe/noe5.html Primes in Fibonacci n-step and Lucas n-step Sequences]). The seeding for this series of sequences is <math>F_{0} = n</math> and <math>F_{1-n} \ldots F_{-1}=-1</math>.

function luc_seeder{T<:Integer}(n::T)

a = -ones(BigInt, n)

NFib(n, k, luc_seeder)

end

 

'''Main'''

lo = 2

hi = 10

println()

end

 

{{out}}

 

=={{header|Kotlin}}==

 

fun fibN(initial: IntArray, numTerms: Int) : IntArray {

println("%2d %-10s %s".format(i + 2, names[i], values))

}

 

{{out}}

 

=={{header|Lua}}==

local iMax, sum = #seq - 1

while #seq < limit do

io.write(sequence.name .. ": ")

print(table.concat(nStepFibs(sequence.values, 10), " "))

{{out}}

<pre>Fibonacci: 1 1 2 3 5 8 13 21 34 55

 

=={{header|Maple}}==

local n, i, values;

n := numelems(initValues);

printf ("nacci(%d): %a\n", i, convert(numSequence(initValues), list));

end do:

{{out}}

<pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

f2=Function[{l,k},

Module[{n=Length@l,m},

Table[Last/@f2[{1,1}~Join~Table[0,{n-2}],15+n][[-18;;]],{n,2,10}]//TableForm

Table[Last/@f2[{1,2}~Join~Table[0,{n-2}],15+n][[-18;;]],{n,2,10}]//TableForm

Output:

<pre>

=={{header|Nim}}==

{{trans|Python}}

 

proc fiblike(start: seq[int]): auto =

se.add(1 shl i)

let fibber = fiblike(se)

Output:

<pre>@[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

We will use lazy lists, so can get any amount of n-nacci numbers.

 

(define (n-fib-iterator ll)

(cons (car ll)

(lambda ()

(n-fib-iterator (append (cdr ll) (list (fold + 0 ll)))))))

 

Testing:

(print "2, fibonacci : " (ltake (n-fib-iterator '(1 1)) 15))

(print "3, tribonacci: " (ltake (n-fib-iterator '(1 1 2)) 15))

5, pentanacci: (1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930)

2, lucas : (2 1 3 4 7 11 18 29 47 76 123 199 322 521 843)

 

=={{header|PARI/GP}}==

 

Use genV if you prefer to supply a different starting vector.

genV(n)=v->for(i=3,min(#v,n),v[i]=2^(i-2));for(i=n+1,#v,v[i]=sum(j=i-n,i-1,v[j]));v

{{out}}

<pre>2 [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

=={{header|Pascal}}==

{{works with|Free_Pascal}}

 

type

write(sequence[k], ' ');

writeln;

Output:

<pre>% ./Fibbonacci

Fib(n)/Fib(n-1) tends to the golden ratio = 1.618... 1.618^100 > 2^64

{{works with|Free_Pascal}}

program FibbonacciN (output);

{$IFNDEF FPC}

write(NextNacci(Nacci),' ');

writeln;

 

=={{header|Perl}}==

use warnings;

use feature <say signatures>;

 

say $_-1 . ': ' . join ' ', (fib_n $_)[0..19] for 2..10;

{{out}}

<pre>1: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">nacci_noo</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%snacci: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">names</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">f</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

=={{header|PHP}}==

/**

* @author Elad Yosifon

}

 

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let N (length Init)

(make

(made Init)

(do (- Cnt N)

Test:

: (nacci (1 1) 10)

-> (1 1 2 3 5 8 13 21 34 55)

# Decanacci

: (nacci (1 1 2 4 8 16 32 64 128 256) 15)

 

=={{header|PL/I}}==

n_step_Fibonacci: procedure options (main);

declare line character (100) varying;

end;

end;

Output:

<pre>

 

=={{header|Powershell}}==

Function Get-ExtendedFibonaciGenerator($InitialValues ){

$Values = $InitialValues

}.GetNewClosure()

}

 

Example of invocation to generate up to decanaci

 

0..($Name.Length-1) | foreach { $Index = $_

$InitialValues = @(1) + @(foreach ($I In 0..$Index) { [Math]::Pow(2,$I) })

}

} | Format-Table -AutoSize

Sample output

<pre>

 

=={{header|PureBasic}}==

 

Procedure.i FibonacciLike(k,n=2,p.s="",d.s=".")

Debug ""

 

 

'''Sample Output'''

=={{header|Python}}==

===Python: function returning a function===

addnum = len(start)

memo = start[:]

n= 9, nonanacci -> 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ...

n=10, decanacci -> 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ...

 

===Python: Callable class===

def __init__(self, start):

self.addnum = len(start)

n= 9, nonanacci -> 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ...

n=10, decanacci -> 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ...

 

===Python: Generator===

 

def fiblike(tail):

fib = fiblike([1] + [2 ** i for i in xrange(n - 1)])

items = list(islice(fib, 15))

{{out}}

<pre>[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Defining the Lucas series and the N-Step Fibonacci series in terms of unfoldr (dual to functools.reduce).

{{Works with|Python|3.7}}

 

from itertools import chain, count, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Recurrence relation series:

=={{header|Quackery}}==

 

 

[ tuck size -

' [ fibonacci tribonacci tetranacci lucas ]

witheach

 

{{out}}

 

=={{header|Racket}}==

 

;; fib-list : [Listof Nat] x Nat -> [Listof Nat]

(cons 1 (build-list (sub1 n) (curry expt 2)))))

;; and with an initial (2 1)

 

{{out}}

 

===Lazy List with Closure===

my @seq = |@start, { state $n = +@start; @seq[ ($n - $s .. $n++ - 1).grep: * >= 0 ].sum } … *;

}

put "{.fmt: '%2d'}-nacci: ", nacci($_)[^20] for 2..12 ;

 

{{out}}

<pre> 2-nacci: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

A slightly more straight forward way of constructing a lazy list.

{{works with|Rakudo|2015.12}}

flat gather {

take @xs[*];

say fib($n, [1])[^20];

}

 

=={{header|REXX}}==

parse arg FibName values /*allows a Fibonacci name, starter vals*/

if FibName\='' then do; call nStepFib FibName,values; signal done; end

 

say right(Fname,11)'[sum'right(N,3) "terms]:" strip(L) '···'

'''output''' &nbsp; when using the default input:

<pre>

 

=={{header|Ring}}==

# Project : Fibonacci n-step number sequences

 

next

see svect

Output:

<pre>

Lucas:

2 1 3 4 7 11 18 29 47 76 123 199 ...

</pre>

 

=={{header|Ruby}}==

n = start_sequence.length # Get the n-step for the type of fibonacci sequence

result = start_sequence.dup # Create a new result array with the values copied from the array that was passed by reference

decanacci: [1,1,2,4,8,16,32,64,128,256] }

 

{{out}}

fibonacci : [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]

tribonacci : [1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136]

nonanacci : [1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 511, 1021, 2040, 4076, 8144]

decanacci : [1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1023, 2045, 4088, 8172]

 

=={{header|Run BASIC}}==

dim f(20)

wend

for i = b to 13 + b

for j = (i - b) + 1 to i

f(i+1) = f(i+1) + f(j)

next i

print

 

=={{header|Rust}}==

struct GenFibonacci {

buf: Vec<u64>,

print(vec![2,1], 10 - 2);

}

 

Fib2: 1 1 2 3 5 8 13 21 34 55

Fib3: 1 1 2 4 7 13 24 44 81 149

Fib4: 1 1 2 4 8 15 29 56 108 208

Lucas: 2 1 3 4 7 11 18 29 47 76

 

=={{header|Scala}}==

===Simple Solution===

//we rely on implicit conversion from Int to BigInt.

//BigInt is preferable since the numbers get very big, very fast.

inner(init.toVector)

}

 

===Optimizing===

//in the optimized version we don't compute values until it's needed.

//the unoptimized version, computed k elements ahead, where k being

init.to(LazyList) #::: inner(init.toVector)

}

===Optimizing Further===

//instead of summing k elements each phase, we exploit the fact

//that the last element is already the sum of all k preceding elements

v.to(LazyList) #::: inner(v)

}

===Printing===

println(s"Fibonacci: ${fibStream(1,1).take(10).mkString(",")}")

println(s"Tribonacci: ${fibStream(1,1,2).take(10).mkString(",")}")

println(s"Tetranacci: ${fibStream(1,1,2,4).take(10).mkString(",")}")

println(s"Lucas: ${fibStream(2,1).take(10).mkString(",")}")

{{out}}

<pre>

=={{header|Scheme}}==

 

(import (scheme base)

(scheme write)

(display (n-fib '(2 1) 15))

(newline)

 

{{out}}

 

=={{header|Seed7}}==

 

const func array integer: bonacci (in array integer: start, in integer: arity, in integer: length) is func

print("Tetranacci", bonacci([] (1, 1), 4, 10));

print("Lucas", bonacci([] (2, 1), 2, 10));

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

loop {

var len = xs.len

len >= k && break

}

return xs

say fib(i).join(' ')

}

{{out}}

<pre>

 

Using matrix exponentiation:

Matrix.build(k,k, {|i,j|

((i == k-1) || (i == j-1)) ? 1 : 0

for k in (2..9) {

say ("Fibonacci of k=#{k} order: ", (15+k).of { fibonacci_kth_order(_, k) })

{{out}}

<pre>

 

Faster algorithm:

 

return 0 if (n < k-1)

for k in (2..9) {

say ("Fibonacci of k=#{k} order: ", (15+k).of { fibonacci_kth_order(_, k) })

(same output as above)

 

=={{header|Tailspin}}==

templates fibonacciNstep&{N:}

templates next

'

' -> !OUT::write

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

proc fibber {args} {

print10 [fibber 1 1 2 4]

puts "LUCAS"

{{out}}

<pre>

 

=={{header|VBA}}==

 

Sub Main()

Next

Fibonacci_Step = R

 

{{Out}}

 

=={{header|VBScript}}==

'function arguments:

'init - initial series of the sequence(e.g. "1,1")

WScript.StdOut.Write "lucas: " & generate_seq("2,1",15)

WScript.StdOut.WriteLine

 

{{Out}}

{{trans|Visual Basic}}

{{works with|Visual Basic .NET|2011}}

Public Class FibonacciNstep

 

End Function 'FibonacciN

 

{{out}}

<pre>

</pre>

 

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var fibN = Fn.new { |initial, numTerms|

Fmt.write("$2d $-10s", i + 2, names[i])

Fmt.aprint(values, 4, 0, "")

 

{{out}}

 

=={{header|XPL0}}==

 

proc Nacci(N, F0); \Generate Fibonacci N-step sequence

Text(0, "Tetranacci: "); Nacci(4, [1, 1, 2, 4]);

Text(0, " Lucas: "); Nacci(2, [2, 1]);

 

Output:

=={{header|Yabasic}}==

{{trans|Lua}}

local iMax, sum, numb$(1), lim, i

print "Tribonacci:", nStepFibs$("1,1,2", 10)

print "Tetranacci:", nStepFibs$("1,1,2,4", 10)

 

=={{header|zkl}}==

This stores the initial n terms of the sequence and returns a function that, at each call, appends the sum of the terms to the sequence then pops the leading value and returns it.

lucas:=fibN(2,1); do(N){ lucas().print(","); } println(); // Lucas

ns:=L(1); foreach _ in ([ns.len()+1..10]){ // Fibonacci n-step for 2 .. 10

"%2d: ".fmt(ns.len()).print();

(N).pump(List,fibN(ns.xplode())).println();

{{out}}

<pre>