Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
2
Task/Fibonacci-n-step-number-sequences/00-META.yaml
Normal file
2
Task/Fibonacci-n-step-number-sequences/00-META.yaml
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Fibonacci_n-step_number_sequences
|
||||
60
Task/Fibonacci-n-step-number-sequences/00-TASK.txt
Normal file
60
Task/Fibonacci-n-step-number-sequences/00-TASK.txt
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
These number series are an expansion of the ordinary [[Fibonacci sequence]] where:
|
||||
# For <math>n = 2</math> we have the Fibonacci sequence; with initial values <math>[1, 1]</math> and <math>F_k^2 = F_{k-1}^2 + F_{k-2}^2</math>
|
||||
# For <math>n = 3</math> we have the tribonacci sequence; with initial values <math>[1, 1, 2]</math> and <math>F_k^3 = F_{k-1}^3 + F_{k-2}^3 + F_{k-3}^3</math>
|
||||
# For <math>n = 4</math> we have the tetranacci sequence; with initial values <math>[1, 1, 2, 4]</math> and <math>F_k^4 = F_{k-1}^4 + F_{k-2}^4 + F_{k-3}^4 + F_{k-4}^4</math><br>...
|
||||
# For general <math>n>2</math> we have the Fibonacci <math>n</math>-step sequence - <math>F_k^n</math>; with initial values of the first <math>n</math> values of the <math>(n-1)</math>'th Fibonacci <math>n</math>-step sequence <math>F_k^{n-1}</math>; and <math>k</math>'th value of this <math>n</math>'th sequence being <math>F_k^n = \sum_{i=1}^{(n)} {F_{k-i}^{(n)}}</math>
|
||||
|
||||
For small values of <math>n</math>, [[wp:Number prefix#Greek_series|Greek numeric prefixes]] are sometimes used to individually name each series.
|
||||
|
||||
:::: {| style="text-align: left;" border="4" cellpadding="2" cellspacing="2"
|
||||
|+ Fibonacci <math>n</math>-step sequences
|
||||
|- style="background-color: rgb(255, 204, 255);"
|
||||
! <math>n</math> !! Series name !! Values
|
||||
|-
|
||||
| 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 ...
|
||||
|-
|
||||
| 4 || tetranacci || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ...
|
||||
|-
|
||||
| 5 || pentanacci || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ...
|
||||
|-
|
||||
| 6 || hexanacci || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ...
|
||||
|-
|
||||
| 7 || heptanacci || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ...
|
||||
|-
|
||||
| 8 || octonacci || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ...
|
||||
|-
|
||||
| 9 || nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ...
|
||||
|-
|
||||
| 10 || decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ...
|
||||
|}
|
||||
|
||||
Allied sequences can be generated where the initial values are changed:
|
||||
: '''The [[wp:Lucas number|Lucas series]]''' sums the two preceding values like the fibonacci series for <math>n=2</math> but uses <math>[2, 1]</math> as its initial values.
|
||||
|
||||
<!-- Lucas numbers, Lucas number, Lucas series [added to make searches easier.] -->
|
||||
|
||||
<br>
|
||||
;Task:
|
||||
# Write a function to generate Fibonacci <math>n</math>-step number sequences given its initial values and assuming the number of initial values determines how many previous values are summed to make the next number of the series.
|
||||
# Use this to print and show here at least the first ten members of the Fibo/tribo/tetra-nacci and Lucas sequences.
|
||||
|
||||
|
||||
;Related tasks:
|
||||
* [[Fibonacci sequence]]
|
||||
* [http://mathworld.wolfram.com/Fibonaccin-StepNumber.html Wolfram Mathworld]
|
||||
* [[Hofstadter Q sequence]]
|
||||
* [[Leonardo numbers]]
|
||||
|
||||
|
||||
;Also see:
|
||||
* [https://www.youtube.com/watch?v=PeUbRXnbmms Lucas Numbers - Numberphile] (Video)
|
||||
* [https://www.youtube.com/watch?v=fMJflV_GUpU Tribonacci Numbers (and the Rauzy Fractal) - Numberphile] (Video)
|
||||
* [[wp:Lucas number|Wikipedia, Lucas number]]
|
||||
* [http://mathworld.wolfram.com/FibonacciNumber.html MathWorld, Fibonacci Number]
|
||||
* [http://www.math-cs.ucmo.edu/~curtisc/articles/howardcooper/genfib4.pdf Some identities for r-Fibonacci numbers]
|
||||
* [[oeis:A000045|OEIS Fibonacci numbers]]
|
||||
* [[oeis:A000032|OEIS Lucas numbers]]
|
||||
<br><br>
|
||||
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
T Fiblike
|
||||
Int addnum
|
||||
[Int] memo
|
||||
|
||||
F (start)
|
||||
.addnum = start.len
|
||||
.memo = copy(start)
|
||||
|
||||
F ()(n)
|
||||
X.try
|
||||
R .memo[n]
|
||||
X.catch IndexError
|
||||
V ans = sum((n - .addnum .< n).map(i -> (.)(i)))
|
||||
.memo.append(ans)
|
||||
R ans
|
||||
|
||||
V fibo = Fiblike([1, 1])
|
||||
print((0.<10).map(i -> fibo(i)))
|
||||
|
||||
V lucas = Fiblike([2, 1])
|
||||
print((0.<10).map(i -> lucas(i)))
|
||||
|
||||
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)))
|
||||
print(‘n=#2, #5nacci -> #. ...’.format(n, name, (0.<15).map(i -> String(@fibber(i))).join(‘ ’)))
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
* Fibonacci n-step number sequences - 14/04/2020
|
||||
FIBONS CSECT
|
||||
USING FIBONS,R13 base register
|
||||
B 72(R15) skip savearea
|
||||
DC 17F'0' savearea
|
||||
SAVE (14,12) save previous context
|
||||
ST R13,4(R15) link backward
|
||||
ST R15,8(R13) link forward
|
||||
LR R13,R15 set addressability
|
||||
LA R6,2 i=2
|
||||
DO WHILE=(C,R6,LE,=F'7') do i=2 to 7
|
||||
ST R6,IR ir=i
|
||||
IF C,R6,EQ,=F'7' THEN if i=7 then - Lucas
|
||||
LA R0,2 2
|
||||
ST R0,IR ir=2
|
||||
ENDIF , endif
|
||||
LA R0,1 1
|
||||
ST R0,T t(1)=1
|
||||
IF C,R6,EQ,=F'7' THEN if i=7 then - Lucas
|
||||
LA R0,2 2
|
||||
ST R0,T t(1)=2
|
||||
ENDIF , endif
|
||||
LA R0,1 1
|
||||
ST R0,T+4 t(2)=1
|
||||
LA R7,3 j=3
|
||||
DO WHILE=(C,R7,LE,=A(NMAX)) do j=3 to nmax
|
||||
SR R0,R0 0
|
||||
ST R0,SUM sum=0
|
||||
LR R11,R7 j
|
||||
S R11,IR j-ir
|
||||
LR R8,R7 k=j
|
||||
BCTR R8,0 k=j-1
|
||||
DO WHILE=(CR,R8,GE,R11) do k=j-1 to j-ir by -1
|
||||
IF LTR,R8,P,R8 THEN if k>0 then
|
||||
LR R1,R8 k
|
||||
SLA R1,2 ~
|
||||
L R2,T-4(R1) t(k)
|
||||
L R1,SUM sum
|
||||
AR R1,R2 +
|
||||
ST R1,SUM sum=sum+t(k)
|
||||
ENDIF , endif
|
||||
BCTR R8,0 k--
|
||||
ENDDO , enddo k
|
||||
L R0,SUM sum
|
||||
LR R1,R7 j
|
||||
SLA R1,2 ~
|
||||
ST R0,T-4(R1) t(j)=sum
|
||||
LA R7,1(R7) j++
|
||||
ENDDO , enddo j
|
||||
MVC PG,=CL120' ' clear buffer
|
||||
LA R9,PG @buffer
|
||||
LR R1,R6 i
|
||||
BCTR R1,0 i-1
|
||||
MH R1,=H'5' ~
|
||||
LA R4,BONACCI-5(R1) @bonacci(i-1)
|
||||
MVC 0(5,R9),0(R4) output bonacci(i-1)
|
||||
LA R9,5(R9) @buffer
|
||||
IF C,R6,NE,=F'7' THEN if i<>7 then
|
||||
MVC 0(7,R9),=C'nacci: ' output 'nacci: '
|
||||
ELSE , else
|
||||
MVC 0(7,R9),=C' : ' output ' : '
|
||||
ENDIF , endif
|
||||
LA R9,7(R9) @buffer
|
||||
LA R7,1 j=1
|
||||
DO WHILE=(C,R7,LE,=A(NMAX)) do j=1 to nmax
|
||||
LR R1,R7 j
|
||||
SLA R1,2 ~
|
||||
L R2,T-4(R1) t(j)
|
||||
XDECO R2,XDEC edit t(j)
|
||||
MVC 0(6,R9),XDEC+6 output t(j)
|
||||
LA R9,6(R9) @buffer
|
||||
LA R7,1(R7) j++
|
||||
ENDDO , enddo j
|
||||
XPRNT PG,L'PG print buffer
|
||||
LA R6,1(R6) i++
|
||||
ENDDO , enddo i
|
||||
L R13,4(0,R13) restore previous savearea pointer
|
||||
RETURN (14,12),RC=0 restore registers from calling sav
|
||||
NMAX EQU 18 sequence length
|
||||
BONACCI DC CL5' fibo',CL5'tribo',CL5'tetra',CL5'penta',CL5' hexa'
|
||||
DC CL5'lucas' bonacci(6)
|
||||
IR DS F ir
|
||||
SUM DS F sum
|
||||
T DS (NMAX)F t(nmax)
|
||||
XDEC DS CL12 temp for xdeco
|
||||
PG DS CL120 buffer
|
||||
REGEQU
|
||||
END FIBONS
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
(defun sum (xs)
|
||||
(if (endp xs)
|
||||
0
|
||||
(+ (first xs)
|
||||
(sum (rest xs)))))
|
||||
|
||||
(defun n-bonacci (prevs limit)
|
||||
(if (zp limit)
|
||||
nil
|
||||
(let ((next (append (rest prevs)
|
||||
(list (sum prevs)))))
|
||||
(cons (first next)
|
||||
(n-bonacci next (1- limit))))))
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
# returns an array of the first required count elements of an a n-step fibonacci sequence #
|
||||
# the initial values are taken from the init array #
|
||||
PROC n step fibonacci sequence = ( []INT init, INT required count )[]INT:
|
||||
BEGIN
|
||||
[ 1 : required count ]INT result;
|
||||
[]INT initial values = init[ AT 1 ];
|
||||
INT step = UPB initial values;
|
||||
# install the initial values #
|
||||
FOR n TO step DO result[ n ] := initial values[ n ] OD;
|
||||
# calculate the rest of the sequence #
|
||||
FOR n FROM step + 1 TO required count DO
|
||||
result[ n ] := 0;
|
||||
FOR p FROM n - step TO n - 1 DO result[ n ] +:= result[ p ] OD
|
||||
OD;
|
||||
result
|
||||
END; # required count #
|
||||
|
||||
# prints the elements of a sequence #
|
||||
PROC print sequence = ( STRING legend, []INT sequence )VOID:
|
||||
BEGIN
|
||||
print( ( legend, ":" ) );
|
||||
FOR e FROM LWB sequence TO UPB sequence DO print( ( " ", whole( sequence[ e ], 0 ) ) ) OD;
|
||||
print( ( newline ) )
|
||||
END; # print sequence #
|
||||
|
||||
# print some sequences #
|
||||
print sequence( "fibonacci ", n step fibonacci sequence( ( 1, 1 ), 10 ) );
|
||||
print sequence( "tribonacci ", n step fibonacci sequence( ( 1, 1, 2 ), 10 ) );
|
||||
print sequence( "tetrabonacci", n step fibonacci sequence( ( 1, 1, 2, 4 ), 10 ) );
|
||||
print sequence( "lucus ", n step fibonacci sequence( ( 2, 1 ), 10 ) )
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
nStep ← {⊃(1↓⊢,+/)⍣(⍺-1)⊢⍵}
|
||||
nacci ← 2*0⌈¯2+⍳
|
||||
↑((⍳10)nStep¨⊂)¨(nacci¨2 3 4),⊂2 1
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
function sequence(values, howmany) {
|
||||
init_length = length(values)
|
||||
for (i=init_length + 1; i<=howmany; i++) {
|
||||
values[i] = 0
|
||||
for (j=1; j<=init_length; j++) {
|
||||
values[i] += values[i-j]
|
||||
}
|
||||
}
|
||||
result = ""
|
||||
for (i in values) {
|
||||
result = result values[i] " "
|
||||
}
|
||||
delete values
|
||||
return result
|
||||
}
|
||||
|
||||
# print some sequences
|
||||
END {
|
||||
a[1] = 1; a[2] = 1
|
||||
print("fibonacci :\t",sequence(a, 10))
|
||||
|
||||
a[1] = 1; a[2] = 1; a[3] = 2
|
||||
print("tribonacci :\t",sequence(a, 10))
|
||||
|
||||
a[1] = 1 ; a[2] = 1 ; a[3] = 2 ; a[4] = 4
|
||||
print("tetrabonacci :\t",sequence(a, 10))
|
||||
|
||||
a[1] = 2; a[2] = 1
|
||||
print("lucas :\t\t",sequence(a, 10))
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
DEFINE MAX="15"
|
||||
|
||||
PROC GenerateSeq(CARD ARRAY init BYTE nInit CARD ARRAY seq BYTE nSeq)
|
||||
CARD next
|
||||
BYTE i,j,n
|
||||
|
||||
IF nInit<nSeq THEN
|
||||
n=nInit
|
||||
ELSE
|
||||
n=nSeq
|
||||
FI
|
||||
|
||||
FOR i=0 TO n-1
|
||||
DO
|
||||
seq(i)=init(i)
|
||||
OD
|
||||
|
||||
FOR i=n TO nSeq-1
|
||||
DO
|
||||
next=0
|
||||
FOR j=i-nInit TO i-1
|
||||
DO
|
||||
next==+seq(j)
|
||||
OD
|
||||
seq(i)=next
|
||||
OD
|
||||
RETURN
|
||||
|
||||
PROC PrintSeq(CHAR ARRAY name CARD ARRAY seq BYTE n)
|
||||
BYTE i
|
||||
|
||||
PrintF("%S=[",name)
|
||||
FOR i=0 TO n-1
|
||||
DO
|
||||
PrintC(seq(i))
|
||||
IF i<n-1 THEN
|
||||
Print(" ")
|
||||
ELSE
|
||||
PrintE("]")
|
||||
FI
|
||||
OD
|
||||
RETURN
|
||||
|
||||
PROC SetInverseVideo(CHAR ARRAY text)
|
||||
BYTE i
|
||||
|
||||
FOR i=1 TO text(0)
|
||||
DO
|
||||
text(i)=text(i) OR $80
|
||||
OD
|
||||
RETURN
|
||||
|
||||
PROC Test(CHAR ARRAY name CARD ARRAY init CARD ARRAY nInit BYTE nSeq)
|
||||
CARD ARRAY seq(MAX)
|
||||
|
||||
SetInverseVideo(name)
|
||||
GenerateSeq(init,nInit,seq,nSeq)
|
||||
PrintSeq(name,seq,nSeq)
|
||||
RETURN
|
||||
|
||||
PROC Main()
|
||||
CARD ARRAY fibInit=[1 1 2 4 8 16 32 64 128 256 512]
|
||||
CARD ARRAY lucInit=[2 1]
|
||||
|
||||
Test("lucas",lucInit,2,MAX)
|
||||
Test("fibonacci",fibInit,2,MAX)
|
||||
Test("tribonacci",fibInit,3,MAX)
|
||||
Test("tetranacci",fibInit,4,MAX)
|
||||
Test("pentanacci",fibInit,5,MAX)
|
||||
Test("hexanacci",fibInit,6,MAX)
|
||||
Test("heptanacci",fibInit,7,MAX)
|
||||
Test("octanacci",fibInit,8,MAX)
|
||||
Test("nonanacci",fibInit,9,MAX)
|
||||
Test("decanacci",fibInit,10,MAX)
|
||||
RETURN
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
package Bonacci is
|
||||
|
||||
type Sequence is array(Positive range <>) of Positive;
|
||||
|
||||
function Generate(Start: Sequence; Length: Positive := 10) return Sequence;
|
||||
|
||||
Start_Fibonacci: constant Sequence := (1, 1);
|
||||
Start_Tribonacci: constant Sequence := (1, 1, 2);
|
||||
Start_Tetranacci: constant Sequence := (1, 1, 2, 4);
|
||||
Start_Lucas: constant Sequence := (2, 1);
|
||||
end Bonacci;
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package body Bonacci is
|
||||
|
||||
function Generate(Start: Sequence; Length: Positive := 10) return Sequence is
|
||||
begin
|
||||
if Length <= Start'Length then
|
||||
return Start(Start'First .. Start'First+Length-1);
|
||||
else
|
||||
declare
|
||||
Sum: Natural := 0;
|
||||
begin
|
||||
for I in Start'Range loop
|
||||
Sum := Sum + Start(I);
|
||||
end loop;
|
||||
return Start(Start'First)
|
||||
& Generate(Start(Start'First+1 .. Start'Last) & Sum, Length-1);
|
||||
end;
|
||||
end if;
|
||||
end Generate;
|
||||
|
||||
end Bonacci;
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
with Ada.Text_IO, Bonacci;
|
||||
|
||||
procedure Test_Bonacci is
|
||||
|
||||
procedure Print(Name: String; S: Bonacci.Sequence) is
|
||||
begin
|
||||
Ada.Text_IO.Put(Name & "(");
|
||||
for I in S'First .. S'Last-1 loop
|
||||
Ada.Text_IO.Put(Integer'Image(S(I)) & ",");
|
||||
end loop;
|
||||
Ada.Text_IO.Put_Line(Integer'Image(S(S'Last)) & " )");
|
||||
end Print;
|
||||
|
||||
begin
|
||||
Print("Fibonacci: ", Bonacci.Generate(Bonacci.Start_Fibonacci));
|
||||
Print("Tribonacci: ", Bonacci.Generate(Bonacci.Start_Tribonacci));
|
||||
Print("Tetranacci: ", Bonacci.Generate(Bonacci.Start_Tetranacci));
|
||||
Print("Lucas: ", Bonacci.Generate(Bonacci.Start_Lucas));
|
||||
Print("Decanacci: ",
|
||||
Bonacci.Generate((1, 1, 2, 4, 8, 16, 32, 64, 128, 256), 15));
|
||||
end Test_Bonacci;
|
||||
|
|
@ -0,0 +1,244 @@
|
|||
use AppleScript version "2.4"
|
||||
use framework "Foundation"
|
||||
use scripting additions
|
||||
|
||||
|
||||
-- Start sequence -> Number of terms -> terms
|
||||
-- takeNFibs :: [Int] -> Int -> [Int]
|
||||
on takeNFibs(xs, n)
|
||||
script go
|
||||
on |λ|(xs, n)
|
||||
if 0 < n and 0 < length of xs then
|
||||
cons(head(xs), ¬
|
||||
|λ|(append(tail(xs), {sum(xs)}), n - 1))
|
||||
else
|
||||
{}
|
||||
end if
|
||||
end |λ|
|
||||
end script
|
||||
go's |λ|(xs, n)
|
||||
end takeNFibs
|
||||
|
||||
-- fibInit :: Int -> [Int]
|
||||
on fibInit(n)
|
||||
script powerOfTwo
|
||||
on |λ|(x)
|
||||
2 ^ x as integer
|
||||
end |λ|
|
||||
end script
|
||||
cons(1, map(powerOfTwo, enumFromToInt(0, n - 2)))
|
||||
end fibInit
|
||||
|
||||
-- TEST ---------------------------------------------------
|
||||
on run
|
||||
set intTerms to 15
|
||||
script series
|
||||
on |λ|(s, n)
|
||||
justifyLeft(12, space, s & "nacci") & " -> " & ¬
|
||||
showJSON(takeNFibs(fibInit(n), intTerms))
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
set strTable to unlines(zipWith(series, ¬
|
||||
words of ("fibo tribo tetra penta hexa hepta octo nona deca"), ¬
|
||||
enumFromToInt(2, 10)))
|
||||
|
||||
justifyLeft(12, space, "Lucas ") & " -> " & ¬
|
||||
showJSON(takeNFibs({2, 1}, intTerms)) & linefeed & strTable
|
||||
end run
|
||||
|
||||
-- GENERIC FUNCTIONS --------------------------------------
|
||||
|
||||
-- Append two lists.
|
||||
-- append (++) :: [a] -> [a] -> [a]
|
||||
-- append (++) :: String -> String -> String
|
||||
on append(xs, ys)
|
||||
xs & ys
|
||||
end append
|
||||
|
||||
-- cons :: a -> [a] -> [a]
|
||||
on cons(x, xs)
|
||||
if list is class of xs then
|
||||
{x} & xs
|
||||
else
|
||||
x & xs
|
||||
end if
|
||||
end cons
|
||||
|
||||
-- enumFromToInt :: Int -> Int -> [Int]
|
||||
on enumFromToInt(m, n)
|
||||
if m ≤ n then
|
||||
set lst to {}
|
||||
repeat with i from m to n
|
||||
set end of lst to i
|
||||
end repeat
|
||||
return lst
|
||||
else
|
||||
return {}
|
||||
end if
|
||||
end enumFromToInt
|
||||
|
||||
-- foldl :: (a -> b -> a) -> a -> [b] -> a
|
||||
on foldl(f, startValue, xs)
|
||||
tell mReturn(f)
|
||||
set v to startValue
|
||||
set lng to length of xs
|
||||
repeat with i from 1 to lng
|
||||
set v to |λ|(v, item i of xs, i, xs)
|
||||
end repeat
|
||||
return v
|
||||
end tell
|
||||
end foldl
|
||||
|
||||
-- head :: [a] -> a
|
||||
on head(xs)
|
||||
if xs = {} then
|
||||
missing value
|
||||
else
|
||||
item 1 of xs
|
||||
end if
|
||||
end head
|
||||
|
||||
-- justifyLeft :: Int -> Char -> String -> String
|
||||
on justifyLeft(n, cFiller, strText)
|
||||
if n > length of strText then
|
||||
text 1 thru n of (strText & replicate(n, cFiller))
|
||||
else
|
||||
strText
|
||||
end if
|
||||
end justifyLeft
|
||||
|
||||
-- Lift 2nd class handler function into 1st class script wrapper
|
||||
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
|
||||
on mReturn(f)
|
||||
if class of f is script then
|
||||
f
|
||||
else
|
||||
script
|
||||
property |λ| : f
|
||||
end script
|
||||
end if
|
||||
end mReturn
|
||||
|
||||
-- map :: (a -> b) -> [a] -> [b]
|
||||
on map(f, xs)
|
||||
tell mReturn(f)
|
||||
set lng to length of xs
|
||||
set lst to {}
|
||||
repeat with i from 1 to lng
|
||||
set end of lst to |λ|(item i of xs, i, xs)
|
||||
end repeat
|
||||
return lst
|
||||
end tell
|
||||
end map
|
||||
|
||||
-- min :: Ord a => a -> a -> a
|
||||
on min(x, y)
|
||||
if y < x then
|
||||
y
|
||||
else
|
||||
x
|
||||
end if
|
||||
end min
|
||||
|
||||
-- Egyptian multiplication - progressively doubling a list, appending
|
||||
-- stages of doubling to an accumulator where needed for binary
|
||||
-- assembly of a target length
|
||||
-- replicate :: Int -> a -> [a]
|
||||
on replicate(n, a)
|
||||
set out to {}
|
||||
if n < 1 then return out
|
||||
set dbl to {a}
|
||||
|
||||
repeat while (n > 1)
|
||||
if (n mod 2) > 0 then set out to out & dbl
|
||||
set n to (n div 2)
|
||||
set dbl to (dbl & dbl)
|
||||
end repeat
|
||||
return out & dbl
|
||||
end replicate
|
||||
|
||||
-- showJSON :: a -> String
|
||||
on showJSON(x)
|
||||
set c to class of x
|
||||
if (c is list) or (c is record) then
|
||||
set ca to current application
|
||||
set {json, e} to ca's NSJSONSerialization's ¬
|
||||
dataWithJSONObject:x options:0 |error|:(reference)
|
||||
if json is missing value then
|
||||
e's localizedDescription() as text
|
||||
else
|
||||
(ca's NSString's alloc()'s ¬
|
||||
initWithData:json encoding:(ca's NSUTF8StringEncoding)) as text
|
||||
end if
|
||||
else if c is date then
|
||||
"\"" & ((x - (time to GMT)) as «class isot» as string) & ".000Z" & "\""
|
||||
else if c is text then
|
||||
"\"" & x & "\""
|
||||
else if (c is integer or c is real) then
|
||||
x as text
|
||||
else if c is class then
|
||||
"null"
|
||||
else
|
||||
try
|
||||
x as text
|
||||
on error
|
||||
("«" & c as text) & "»"
|
||||
end try
|
||||
end if
|
||||
end showJSON
|
||||
|
||||
-- sum :: [Num] -> Num
|
||||
on sum(xs)
|
||||
script add
|
||||
on |λ|(a, b)
|
||||
a + b
|
||||
end |λ|
|
||||
end script
|
||||
|
||||
foldl(add, 0, xs)
|
||||
end sum
|
||||
|
||||
-- tail :: [a] -> [a]
|
||||
on tail(xs)
|
||||
set blnText to text is class of xs
|
||||
if blnText then
|
||||
set unit to ""
|
||||
else
|
||||
set unit to {}
|
||||
end if
|
||||
set lng to length of xs
|
||||
if 1 > lng then
|
||||
missing value
|
||||
else if 2 > lng then
|
||||
unit
|
||||
else
|
||||
if blnText then
|
||||
text 2 thru -1 of xs
|
||||
else
|
||||
rest of xs
|
||||
end if
|
||||
end if
|
||||
end tail
|
||||
|
||||
-- unlines :: [String] -> String
|
||||
on unlines(xs)
|
||||
set {dlm, my text item delimiters} to ¬
|
||||
{my text item delimiters, linefeed}
|
||||
set str to xs as text
|
||||
set my text item delimiters to dlm
|
||||
str
|
||||
end unlines
|
||||
|
||||
-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
|
||||
on zipWith(f, xs, ys)
|
||||
set lng to min(length of xs, length of ys)
|
||||
if 1 > lng then return {}
|
||||
set lst to {}
|
||||
tell mReturn(f)
|
||||
repeat with i from 1 to lng
|
||||
set end of lst to |λ|(item i of xs, item i of ys)
|
||||
end repeat
|
||||
return lst
|
||||
end tell
|
||||
end zipWith
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
-- Parameters:
|
||||
-- n: …nacci step size as integer. Alternatively "Lucas".
|
||||
-- F: Maximum …nacci index required. (0-based.)
|
||||
on fibonacciNStep(n, F)
|
||||
script o
|
||||
property sequence : {0}
|
||||
end script
|
||||
if (n is "Lucas") then set {n, item 1 of o's sequence} to {2, 2}
|
||||
|
||||
-- F1 (if included) is always 1.
|
||||
if (F > 0) then set end of o's sequence to 1
|
||||
-- F2 (ditto) is F0 + F1.
|
||||
if (F > 1) then set end of o's sequence to (beginning of o's sequence) + (end of o's sequence)
|
||||
-- Each further number up to and including Fn is twice the number preceding it.
|
||||
if (n > F) then set n to F
|
||||
repeat (n - 2) times
|
||||
set end of o's sequence to (end of o's sequence) * 2
|
||||
end repeat
|
||||
-- Beyond Fn, each number is twice the one preceding it, minus the number n places before that.
|
||||
set nBeforeEnd to -(n + 1)
|
||||
repeat (F - n) times
|
||||
set end of o's sequence to (end of o's sequence) * 2 - (item nBeforeEnd of o's sequence)
|
||||
end repeat
|
||||
|
||||
return o's sequence
|
||||
end fibonacciNStep
|
||||
|
||||
-- Test code:
|
||||
set maxF to 15 -- Length of sequence required after the initial 0 or 2.
|
||||
set seriesNames to {missing value, "fibonacci: ", "tribonacci: ", "tetranacci: ", "pentanacci: ", ¬
|
||||
"hexanacci: ", "heptanacci: ", "octonacci: ", "nonanacci: ", "decanacci: "}
|
||||
set output to {}
|
||||
|
||||
set astid to AppleScript's text item delimiters
|
||||
set AppleScript's text item delimiters to ", "
|
||||
repeat with nacciSize from 2 to 10
|
||||
set end of output to (item nacciSize of seriesNames) & fibonacciNStep(nacciSize, maxF) & " …"
|
||||
end repeat
|
||||
set end of output to "Lucas: " & fibonacciNStep("lucas", maxF) & " …"
|
||||
set AppleScript's text item delimiters to linefeed
|
||||
set output to output as text
|
||||
set AppleScript's text item delimiters to astid
|
||||
|
||||
return output
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
"fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610 …
|
||||
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 …
|
||||
pentanacci: 0, 1, 1, 2, 4, 8, 16, 31, 61, 120, 236, 464, 912, 1793, 3525, 6930 …
|
||||
hexanacci: 0, 1, 1, 2, 4, 8, 16, 32, 63, 125, 248, 492, 976, 1936, 3840, 7617 …
|
||||
heptanacci: 0, 1, 1, 2, 4, 8, 16, 32, 64, 127, 253, 504, 1004, 2000, 3984, 7936 …
|
||||
octonacci: 0, 1, 1, 2, 4, 8, 16, 32, 64, 128, 255, 509, 1016, 2028, 4048, 8080 …
|
||||
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 …
|
||||
Lucas: 2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843, 1364 …"
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
naccis: #[
|
||||
lucas: [2 1]
|
||||
fibonacci: [1 1]
|
||||
tribonacci: [1 1 2]
|
||||
tetranacci: [1 1 2 4]
|
||||
pentanacci: [1 1 2 4 8]
|
||||
hexanacci: [1 1 2 4 8 16]
|
||||
heptanacci: [1 1 2 4 8 16 32]
|
||||
octonacci: [1 1 2 4 8 16 32 64]
|
||||
nonanacci: [1 1 2 4 8 16 32 64 128]
|
||||
decanacci: [1 1 2 4 8 16 32 64 128 256]
|
||||
]
|
||||
|
||||
anyNacci: function [start, count][
|
||||
n: size start
|
||||
result: new start
|
||||
do.times: count-n ->
|
||||
result: result ++ sum last.n:n result
|
||||
|
||||
return join.with:", " to [:string] result
|
||||
]
|
||||
|
||||
loop naccis [k,v][
|
||||
print [pad (k ++ ":") 12 anyNacci v 15]
|
||||
]
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
for i, seq in ["nacci", "lucas"]
|
||||
Loop, 9 {
|
||||
Out .= seq "(" A_Index + 1 "): "
|
||||
for key, val in NStepSequence(i, 1, A_Index + 1, 15)
|
||||
Out .= val (A_Index = 15 ? "`n" : "`, ")
|
||||
}
|
||||
MsgBox, % Out
|
||||
|
||||
NStepSequence(v1, v2, n, k) {
|
||||
a := [v1, v2]
|
||||
Loop, % k - 2 {
|
||||
a[j := A_Index + 2] := 0
|
||||
Loop, % j < n + 2 ? j - 1 : n
|
||||
a[j] += a[j - A_Index]
|
||||
}
|
||||
return, a
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
# Rosetta Code problem: https://www.rosettacode.org/wiki/Fibonacci_n-step_number_sequences
|
||||
# by Jjuanhdez, 06/2022
|
||||
|
||||
arraybase 1
|
||||
print " fibonacci =>";
|
||||
dim a = {1,1}
|
||||
call fib (a)
|
||||
print " tribonacci =>";
|
||||
dim a = {1,1,2}
|
||||
call fib (a)
|
||||
print " tetranacci =>";
|
||||
dim a = {1,1,2,4}
|
||||
call fib (a)
|
||||
print " pentanacci =>";
|
||||
dim a = {1,1,2,4,8}
|
||||
call fib (a)
|
||||
print " hexanacci =>";
|
||||
dim a = {1,1,2,4,8,16}
|
||||
call fib (a)
|
||||
print " heptanacci =>";
|
||||
dim a = {1,1,2,4,8,16,32}
|
||||
call fib (a)
|
||||
print " octonacci =>";
|
||||
dim a = {1,1,2,4,8,16,32,64}
|
||||
call fib (a)
|
||||
print " nonanacci =>";
|
||||
dim a = {1,1,2,4,8,16,32,64,128}
|
||||
call fib (a)
|
||||
print " decanacci =>";
|
||||
dim a = {1,1,2,4,8,16,32,64,128,256}
|
||||
call fib (a)
|
||||
print " lucas =>";
|
||||
dim a = {2,1}
|
||||
call fib (a)
|
||||
end
|
||||
|
||||
subroutine fib (a)
|
||||
dim f(24) fill 0
|
||||
b = 0
|
||||
for x = 1 to a[?]
|
||||
b += 1
|
||||
f[x] = a[x]
|
||||
next x
|
||||
for i = b to 13 + b
|
||||
print rjust(f[i-b+1], 5);
|
||||
if i <> 13 + b then print ","; else print ", ..."
|
||||
for j = (i-b+1) to i
|
||||
f[i+1] = f[i+1] + f[j]
|
||||
next j
|
||||
next i
|
||||
end subroutine
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
@% = 5 : REM Column width
|
||||
|
||||
PRINT "Fibonacci:"
|
||||
DIM f2%(1) : f2%() = 1,1
|
||||
FOR i% = 1 TO 12 : PRINT f2%(0); : PROCfibn(f2%()) : NEXT : PRINT " ..."
|
||||
|
||||
PRINT "Tribonacci:"
|
||||
DIM f3%(2) : f3%() = 1,1,2
|
||||
FOR i% = 1 TO 12 : PRINT f3%(0); : PROCfibn(f3%()) : NEXT : PRINT " ..."
|
||||
|
||||
PRINT "Tetranacci:"
|
||||
DIM f4%(3) : f4%() = 1,1,2,4
|
||||
FOR i% = 1 TO 12 : PRINT f4%(0); : PROCfibn(f4%()) : NEXT : PRINT " ..."
|
||||
|
||||
PRINT "Lucas:"
|
||||
DIM fl%(1) : fl%() = 2,1
|
||||
FOR i% = 1 TO 12 : PRINT fl%(0); : PROCfibn(fl%()) : NEXT : PRINT " ..."
|
||||
END
|
||||
|
||||
DEF PROCfibn(f%())
|
||||
LOCAL i%, s%
|
||||
s% = SUM(f%())
|
||||
FOR i% = 1 TO DIM(f%(),1)
|
||||
f%(i%-1) = f%(i%)
|
||||
NEXT
|
||||
f%(i%-1) = s%
|
||||
ENDPROC
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
NStep ← ⊑(1↓⊢∾+´)∘⊢⍟⊣
|
||||
Nacci ← (2⋆0∾↕)∘(⊢-1˙)
|
||||
|
||||
>((↕10) NStep¨ <)¨ (Nacci¨ 2‿3‿4) ∾ <2‿1
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
@echo off
|
||||
|
||||
echo Fibonacci Sequence:
|
||||
call:nfib 1 1
|
||||
echo.
|
||||
|
||||
echo Tribonacci Sequence:
|
||||
call:nfib 1 1 2
|
||||
echo.
|
||||
|
||||
echo Tetranacci Sequence:
|
||||
call:nfib 1 1 2 4
|
||||
echo.
|
||||
|
||||
echo Lucas Numbers:
|
||||
call:nfib 2 1
|
||||
echo.
|
||||
|
||||
pause>nul
|
||||
exit /b
|
||||
|
||||
:nfib
|
||||
setlocal enabledelayedexpansion
|
||||
|
||||
for %%i in (%*) do (
|
||||
set /a count+=1
|
||||
set seq=!seq! %%i
|
||||
)
|
||||
set "seq=%seq% ^| "
|
||||
set n=-%count%
|
||||
set /a n+=1
|
||||
for %%i in (%*) do (
|
||||
set F!n!=%%i
|
||||
set /a n+=1
|
||||
)
|
||||
|
||||
for /l %%i in (1,1,10) do (
|
||||
set /a termstart=%%i-%count%%
|
||||
set /a termend=%%i-1
|
||||
for /l %%j in (!termstart!,1,!termend!) do (
|
||||
set /a F%%i+=!F%%j!
|
||||
)
|
||||
set seq=!seq! !F%%i!
|
||||
)
|
||||
echo %seq%
|
||||
|
||||
endlocal
|
||||
exit /b
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
110p>>55+109"iccanaceD"22099v
|
||||
v9013"Tetranacci"9014"Lucas"<
|
||||
>"iccanobirT"2109"iccanobiF"v
|
||||
>>:#,_0p20p0>:01-\2>#v0>#g<>>
|
||||
^_@#:,+55$_^ JH v`1:v#\p03<
|
||||
_$.1+:77+`^vg03:_0g+>\:1+#^
|
||||
50p-\30v v\<>\30g1-\^$$_:1-
|
||||
05g04\g< >`#^_:40p30g0>^!:g
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
( ( nacci
|
||||
= Init Cnt N made tail
|
||||
. ( plus
|
||||
= n
|
||||
. !arg:#%?n ?arg&!n+plus$!arg
|
||||
| 0
|
||||
)
|
||||
& !arg:(?Init.?Cnt)
|
||||
& !Init:? [?N
|
||||
& !Init:?made
|
||||
& !Cnt+-1*!N:?times
|
||||
& -1+-1*!N:?M
|
||||
& whl
|
||||
' ( !times+-1:~<0:?times
|
||||
& !made:? [!M ?tail
|
||||
& !made plus$!tail:?made
|
||||
)
|
||||
& !made
|
||||
)
|
||||
& ( pad
|
||||
= len w
|
||||
. @(!arg:? [?len)
|
||||
& @(" ":? [!len ?w)
|
||||
& !w !arg
|
||||
)
|
||||
& (fibonacci.1 1)
|
||||
(tribonacci.1 1 2)
|
||||
(tetranacci.1 1 2 4)
|
||||
(pentanacci.1 1 2 4 8)
|
||||
(hexanacci.1 1 2 4 8 16)
|
||||
(heptanacci.1 1 2 4 8 16 32)
|
||||
(octonacci.1 1 2 4 8 16 32 64)
|
||||
(nonanacci.1 1 2 4 8 16 32 64 128)
|
||||
(decanacci.1 1 2 4 8 16 32 64 128 256)
|
||||
(lucas.2 1)
|
||||
: ?L
|
||||
& whl
|
||||
' ( !L:(?name.?Init) ?L
|
||||
& out$(str$(pad$!name ": ") nacci$(!Init.12))
|
||||
)
|
||||
);
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <numeric>
|
||||
#include <iterator>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <iomanip>
|
||||
|
||||
std::vector<int> nacci ( const std::vector<int> & start , int arity ) {
|
||||
std::vector<int> result ( start ) ;
|
||||
int sumstart = 1 ;//summing starts at vector's begin + sumstart as
|
||||
//soon as the vector is longer than arity
|
||||
while ( result.size( ) < 15 ) { //we print out the first 15 numbers
|
||||
if ( result.size( ) <= arity )
|
||||
result.push_back( std::accumulate( result.begin( ) ,
|
||||
result.begin( ) + result.size( ) , 0 ) ) ;
|
||||
else {
|
||||
result.push_back( std::accumulate ( result.begin( ) +
|
||||
sumstart , result.begin( ) + sumstart + arity , 0 )) ;
|
||||
sumstart++ ;
|
||||
}
|
||||
}
|
||||
return std::move ( result ) ;
|
||||
}
|
||||
|
||||
int main( ) {
|
||||
std::vector<std::string> naccinames {"fibo" , "tribo" ,
|
||||
"tetra" , "penta" , "hexa" , "hepta" , "octo" , "nona" , "deca" } ;
|
||||
const std::vector<int> fibo { 1 , 1 } , lucas { 2 , 1 } ;
|
||||
for ( int i = 2 ; i < 11 ; i++ ) {
|
||||
std::vector<int> numberrow = nacci ( fibo , i ) ;
|
||||
std::cout << std::left << std::setw( 10 ) <<
|
||||
naccinames[ i - 2 ].append( "nacci" ) <<
|
||||
std::setw( 2 ) << " : " ;
|
||||
std::copy ( numberrow.begin( ) , numberrow.end( ) ,
|
||||
std::ostream_iterator<int>( std::cout , " " ) ) ;
|
||||
std::cout << "...\n" ;
|
||||
numberrow = nacci ( lucas , i ) ;
|
||||
std::cout << "Lucas-" << i ;
|
||||
if ( i < 10 ) //for formatting purposes
|
||||
std::cout << " : " ;
|
||||
else
|
||||
std::cout << " : " ;
|
||||
std::copy ( numberrow.begin( ) , numberrow.end( ) ,
|
||||
std::ostream_iterator<int>( std::cout , " " ) ) ;
|
||||
std::cout << "...\n" ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
// This class forms a simple 'generator', where operator() returns the next
|
||||
// element in the series. It uses a small sliding window buffer to minimize
|
||||
// storage overhead.
|
||||
class nacci_t
|
||||
{
|
||||
std::vector< int > history;
|
||||
unsigned windex; // sliding window index
|
||||
unsigned rindex; // result index
|
||||
int running_sum; // sum of values in sliding window
|
||||
|
||||
public:
|
||||
|
||||
nacci_t( unsigned int order, int a0 = 1, int a1 = 1 )
|
||||
: history( order + 1 ), windex( 0 ), rindex( order - 1 ),
|
||||
running_sum( a0 + a1 )
|
||||
{
|
||||
// intialize sliding window
|
||||
history[order - 1] = a0;
|
||||
history[order - 0] = a1;
|
||||
}
|
||||
|
||||
int operator()()
|
||||
{
|
||||
int result = history[ rindex ]; // get 'nacci number to return
|
||||
running_sum -= history[ windex ]; // old 'nacci falls out of window
|
||||
|
||||
history[ windex ] = running_sum; // new 'nacci enters the window
|
||||
running_sum += running_sum; // new 'nacci added to the sum
|
||||
|
||||
if ( ++windex == history.size() ) windex = 0;
|
||||
if ( ++rindex == history.size() ) rindex = 0;
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
for ( unsigned int i = 2; i <= 10; ++i )
|
||||
{
|
||||
nacci_t nacci( i ); // fibonacci sequence
|
||||
|
||||
std::cout << "nacci( " << i << " ): ";
|
||||
|
||||
for ( int j = 0; j < 10; ++j )
|
||||
std::cout << " " << nacci();
|
||||
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
for ( unsigned int i = 2; i <= 10; ++i )
|
||||
{
|
||||
nacci_t lucas( i, 2, 1 ); // Lucas sequence
|
||||
|
||||
std::cout << "lucas( " << i << " ): ";
|
||||
|
||||
for ( int j = 0; j < 10; ++j )
|
||||
std::cout << " " << lucas();
|
||||
|
||||
std::cout << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
|
||||
namespace Fibonacci
|
||||
{
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
PrintNumberSequence("Fibonacci", GetNnacciNumbers(2, 10));
|
||||
PrintNumberSequence("Lucas", GetLucasNumbers(10));
|
||||
PrintNumberSequence("Tribonacci", GetNnacciNumbers(3, 10));
|
||||
PrintNumberSequence("Tetranacci", GetNnacciNumbers(4, 10));
|
||||
Console.ReadKey();
|
||||
}
|
||||
|
||||
private static IList<ulong> GetLucasNumbers(int length)
|
||||
{
|
||||
IList<ulong> seedSequence = new List<ulong>() { 2, 1 };
|
||||
return GetFibLikeSequence(seedSequence, length);
|
||||
}
|
||||
|
||||
private static IList<ulong> GetNnacciNumbers(int seedLength, int length)
|
||||
{
|
||||
return GetFibLikeSequence(GetNacciSeed(seedLength), length);
|
||||
}
|
||||
|
||||
private static IList<ulong> GetNacciSeed(int seedLength)
|
||||
{
|
||||
IList<ulong> seedSquence = new List<ulong>() { 1 };
|
||||
|
||||
for (uint i = 0; i < seedLength - 1; i++)
|
||||
{
|
||||
seedSquence.Add((ulong)Math.Pow(2, i));
|
||||
}
|
||||
|
||||
return seedSquence;
|
||||
}
|
||||
|
||||
private static IList<ulong> GetFibLikeSequence(IList<ulong> seedSequence, int length)
|
||||
{
|
||||
IList<ulong> sequence = new List<ulong>();
|
||||
|
||||
int count = seedSequence.Count();
|
||||
|
||||
if (length <= count)
|
||||
{
|
||||
sequence = seedSequence.Take((int)length).ToList();
|
||||
}
|
||||
else
|
||||
{
|
||||
sequence = seedSequence;
|
||||
|
||||
for (int i = count; i < length; i++)
|
||||
{
|
||||
ulong num = 0;
|
||||
|
||||
for (int j = 0; j < count; j++)
|
||||
{
|
||||
num += sequence[sequence.Count - 1 - j];
|
||||
}
|
||||
|
||||
sequence.Add(num);
|
||||
}
|
||||
}
|
||||
|
||||
return sequence;
|
||||
}
|
||||
|
||||
private static void PrintNumberSequence(string Title, IList<ulong> numbersequence)
|
||||
{
|
||||
StringBuilder output = new StringBuilder(Title).Append(" ");
|
||||
|
||||
foreach (long item in numbersequence)
|
||||
{
|
||||
output.AppendFormat("{0}, ", item);
|
||||
}
|
||||
|
||||
Console.WriteLine(output.ToString());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
/*
|
||||
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.*/
|
||||
|
||||
#include<stdlib.h>
|
||||
#include<stdio.h>
|
||||
|
||||
int *
|
||||
anynacci (int *seedArray, int howMany)
|
||||
{
|
||||
int *result = malloc (howMany * sizeof (int));
|
||||
int i, j, initialCardinality;
|
||||
|
||||
for (i = 0; seedArray[i] != 0; i++);
|
||||
initialCardinality = i;
|
||||
|
||||
for (i = 0; i < initialCardinality; i++)
|
||||
result[i] = seedArray[i];
|
||||
|
||||
for (i = initialCardinality; i < howMany; i++)
|
||||
{
|
||||
result[i] = 0;
|
||||
for (j = i - initialCardinality; j < i; j++)
|
||||
result[i] += result[j];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
int fibo[] = { 1, 1, 0 }, tribo[] = { 1, 1, 2, 0 }, tetra[] = { 1, 1, 2, 4, 0 }, luca[] = { 2, 1, 0 };
|
||||
int *fibonacci = anynacci (fibo, 10), *tribonacci = anynacci (tribo, 10), *tetranacci = anynacci (tetra, 10),
|
||||
*lucas = anynacci(luca, 10);
|
||||
int i;
|
||||
|
||||
printf ("\nFibonacci\tTribonacci\tTetranacci\tLucas\n");
|
||||
|
||||
for (i = 0; i < 10; i++)
|
||||
printf ("\n%d\t\t%d\t\t%d\t\t%d", fibonacci[i], tribonacci[i],
|
||||
tetranacci[i], lucas[i]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
% Find the Nth element of a given n-step sequence
|
||||
n_step = proc (seq: sequence[int], n: int) returns (int)
|
||||
a: array[int] := sequence[int]$s2a(seq)
|
||||
for i: int in int$from_to(1,n) do
|
||||
sum: int := 0
|
||||
for x: int in array[int]$elements(a) do
|
||||
sum := sum + x
|
||||
end
|
||||
array[int]$reml(a)
|
||||
array[int]$addh(a,sum)
|
||||
end
|
||||
return(array[int]$bottom(a))
|
||||
end n_step
|
||||
|
||||
% Generate the initial sequence for the Fibonacci n-step sequence of length N
|
||||
anynacci = proc (n: int) returns (sequence[int])
|
||||
a: array[int] := array[int]$[1]
|
||||
for i: int in int$from_to(0,n-2) do
|
||||
array[int]$addh(a, 2**i)
|
||||
end
|
||||
return(sequence[int]$a2s(a))
|
||||
end anynacci
|
||||
|
||||
% Given an initial sequence, print the first N elements
|
||||
print_n = proc (seq: sequence[int], n: int)
|
||||
po: stream := stream$primary_output()
|
||||
for i: int in int$from_to(0, n-1) do
|
||||
stream$putright(po, int$unparse(n_step(seq, i)), 4)
|
||||
end
|
||||
stream$putl(po, "")
|
||||
end print_n
|
||||
|
||||
start_up = proc ()
|
||||
s = struct[name: string, seq: sequence[int]]
|
||||
po: stream := stream$primary_output()
|
||||
seqs: array[s] := array[s]$[
|
||||
s${name: "Fibonacci", seq: anynacci(2)},
|
||||
s${name: "Tribonacci", seq: anynacci(3)},
|
||||
s${name: "Tetranacci", seq: anynacci(4)},
|
||||
s${name: "Lucas", seq: sequence[int]$[2,1]}
|
||||
]
|
||||
|
||||
for seq: s in array[s]$elements(seqs) do
|
||||
stream$putleft(po, seq.name, 12)
|
||||
print_n(seq.seq, 10)
|
||||
end
|
||||
end start_up
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
(defn nacci [init]
|
||||
(letfn [(s [] (lazy-cat init (apply map + (map #(drop % (s)) (range (count init))))))]
|
||||
(s)))
|
||||
|
||||
(let [show (fn [name init] (println "first 20" name (take 20 (nacci init))))]
|
||||
(show "Fibonacci" [1 1])
|
||||
(show "Tribonacci" [1 1 2])
|
||||
(show "Tetranacci" [1 1 2 4])
|
||||
(show "Lucas" [2 1]))
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
(defun gen-fib (lst m)
|
||||
"Return the first m members of a generalized Fibonacci sequence using lst as initial values
|
||||
and the length of lst as step."
|
||||
(let ((l (- (length lst) 1)))
|
||||
(do* ((fib-list (reverse lst) (cons (loop for i from 0 to l sum (nth i fib-list)) fib-list))
|
||||
(c (+ l 2) (+ c 1)))
|
||||
((> c m) (reverse fib-list)))))
|
||||
|
||||
(defun initial-values (n)
|
||||
"Return the initial values of the Fibonacci n-step sequence"
|
||||
(cons 1
|
||||
(loop for i from 0 to (- n 2)
|
||||
collect (expt 2 i))))
|
||||
|
||||
(defun start ()
|
||||
(format t "Lucas series: ~a~%" (gen-fib '(2 1) 10))
|
||||
(loop for i from 2 to 4
|
||||
do (format t "Fibonacci ~a-step sequence: ~a~%" i (gen-fib (initial-values i) 10))))
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
void main() {
|
||||
import std.stdio, std.algorithm, std.range, std.conv;
|
||||
|
||||
const(int)[] memo;
|
||||
size_t addNum;
|
||||
|
||||
void setHead(int[] head) nothrow @safe {
|
||||
memo = head;
|
||||
addNum = head.length;
|
||||
}
|
||||
|
||||
int fibber(in size_t n) nothrow @safe {
|
||||
if (n >= memo.length)
|
||||
memo ~= iota(n - addNum, n).map!fibber.sum;
|
||||
return memo[n];
|
||||
}
|
||||
|
||||
setHead([1, 1]);
|
||||
10.iota.map!fibber.writeln;
|
||||
setHead([2, 1]);
|
||||
10.iota.map!fibber.writeln;
|
||||
|
||||
const prefixes = "fibo tribo tetra penta hexa hepta octo nona deca";
|
||||
foreach (immutable n, const name; prefixes.split.enumerate(2)) {
|
||||
setHead(1 ~ iota(n - 1).map!q{2 ^^ a}.array);
|
||||
writefln("n=%2d, %5snacci -> %(%d %) ...", n, name,
|
||||
15.iota.map!fibber);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
import std.stdio, std.algorithm, std.range, std.conv;
|
||||
|
||||
struct fiblike(T) {
|
||||
const(T)[] memo;
|
||||
immutable size_t addNum;
|
||||
|
||||
this(in T[] start) nothrow @safe {
|
||||
this.memo = start.dup;
|
||||
this.addNum = start.length;
|
||||
}
|
||||
|
||||
T opCall(in size_t n) nothrow @safe {
|
||||
if (n >= memo.length)
|
||||
memo ~= iota(n - addNum, n)
|
||||
.map!(i => opCall(i))
|
||||
.sum
|
||||
.to!int;
|
||||
return memo[n];
|
||||
}
|
||||
}
|
||||
|
||||
void main() {
|
||||
auto fibo = fiblike!int([1, 1]);
|
||||
iota(10).map!fibo.writeln;
|
||||
|
||||
auto lucas = fiblike!int([2, 1]);
|
||||
iota(10).map!lucas.writeln;
|
||||
|
||||
const prefixes = "fibo tribo tetra penta hexa hepta octo nona deca";
|
||||
foreach (immutable n, const name; prefixes.split.enumerate(2)) {
|
||||
auto fib = fiblike!int(1 ~ iota(n - 1).map!q{2 ^^ a}.array);
|
||||
writefln("n=%2d, %5snacci -> %(%d %) ...",
|
||||
n, name, 15.iota.map!fib);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
import std.stdio, std.algorithm, std.range, std.traits;
|
||||
|
||||
struct Fiblike(T) {
|
||||
T[] tail;
|
||||
|
||||
int opApply(int delegate(immutable ref T) dg) {
|
||||
int result, pos;
|
||||
foreach (immutable x; tail) {
|
||||
result = dg(x);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
foreach (immutable i; tail.length.iota.cycle) {
|
||||
immutable x = tail.sum;
|
||||
result = dg(x);
|
||||
if (result)
|
||||
break;
|
||||
tail[i] = x;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
// std.range.take doesn't work with opApply.
|
||||
ForeachType!It[] takeApply(It)(It iterable, in size_t n) {
|
||||
typeof(return) result;
|
||||
foreach (immutable x; iterable) {
|
||||
result ~= x;
|
||||
if (result.length == n)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void main() {
|
||||
Fiblike!int([1, 1]).takeApply(10).writeln;
|
||||
Fiblike!int([2, 1]).takeApply(10).writeln;
|
||||
|
||||
const prefixes = "fibo tribo tetra penta hexa hepta octo nona deca";
|
||||
foreach (immutable n, const name; prefixes.split.enumerate(2)) {
|
||||
auto fib = Fiblike!int(1 ~ iota(n - 1).map!q{2 ^^ a}.array);
|
||||
writefln("n=%2d, %5snacci -> %s", n, name, fib.takeApply(15));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
void main() {
|
||||
import std.stdio, std.algorithm, std.range, std.concurrency;
|
||||
|
||||
immutable fibLike = (int[] tail) => new Generator!int({
|
||||
foreach (x; tail)
|
||||
yield(x);
|
||||
foreach (immutable i; tail.length.iota.cycle)
|
||||
yield(tail[i] = tail.sum);
|
||||
});
|
||||
|
||||
foreach (seed; [[1, 1], [2, 1]])
|
||||
fibLike(seed).take(10).writeln;
|
||||
|
||||
immutable prefixes = "fibo tribo tetra penta hexa hepta octo nona deca";
|
||||
foreach (immutable n, const name; prefixes.split.enumerate(2)) {
|
||||
auto fib = fibLike(1 ~ iota(n - 1).map!q{2 ^^ a}.array);
|
||||
writefln("n=%2d, %5snacci -> %(%s, %), ...", n, name, fib.take(15));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
PROGRAM FIBON
|
||||
|
||||
!
|
||||
! for rosettacode.org
|
||||
!
|
||||
|
||||
DIM F[20]
|
||||
|
||||
PROCEDURE FIB(TIPO$,F$)
|
||||
FOR I%=0 TO 20 DO
|
||||
F[I%]=0
|
||||
END FOR
|
||||
B=0
|
||||
LOOP
|
||||
Q=INSTR(F$,",")
|
||||
B=B+1
|
||||
IF Q=0 THEN
|
||||
F[B]=VAL(F$)
|
||||
EXIT
|
||||
ELSE
|
||||
F[B]=VAL(MID$(F$,1,Q-1))
|
||||
F$=MID$(F$,Q+1)
|
||||
END IF
|
||||
END LOOP
|
||||
|
||||
PRINT(TIPO$;" =>";)
|
||||
FOR I=B TO 14+B DO
|
||||
IF I<>B THEN PRINT(",";) END IF
|
||||
PRINT(F[I-B+1];)
|
||||
FOR J=(I-B)+1 TO I DO
|
||||
F[I+1]=F[I+1]+F[J]
|
||||
END FOR
|
||||
END FOR
|
||||
PRINT
|
||||
END PROCEDURE
|
||||
|
||||
BEGIN
|
||||
PRINT(CHR$(12);) ! CLS
|
||||
FIB("Fibonacci","1,1")
|
||||
FIB("Tribonacci","1,1,2")
|
||||
FIB("Tetranacci","1,1,2,4")
|
||||
FIB("Lucas","2,1")
|
||||
END PROGRAM
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
;; generate a recursive lambda() for a x-nacci
|
||||
;; equip it with memoïzation
|
||||
;; bind it to its name
|
||||
(define (make-nacci name seed)
|
||||
(define len (1+ (vector-length seed)))
|
||||
(define-global name
|
||||
`(lambda(n) (for/sum ((i (in-range (1- n) (- n ,len) -1))) (,name i))))
|
||||
(remember name seed)
|
||||
name)
|
||||
|
||||
(define nacci-family `(
|
||||
(Fibonacci #(1 1))
|
||||
(Tribonacci #(1 1 2))
|
||||
(Tetranacci #(1 1 2 4))
|
||||
(Decanacci #(1 1 2 4 8 16 32 64 128 256))
|
||||
(Random-😜-nacci ,(list->vector (take 6 (shuffle (iota 100)))))
|
||||
(Lucas #(2 1))))
|
||||
|
||||
(define (task naccis)
|
||||
(for ((nacci naccis))
|
||||
(define-values (name seed) nacci)
|
||||
(make-nacci name seed)
|
||||
(printf "%s[%d] → %d" name (vector-length seed) (take name 16))))
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
defmodule RC do
|
||||
def anynacci(start_sequence, count) do
|
||||
n = length(start_sequence)
|
||||
anynacci(Enum.reverse(start_sequence), count-n, n)
|
||||
end
|
||||
|
||||
def anynacci(seq, 0, _), do: Enum.reverse(seq)
|
||||
def anynacci(seq, count, n) do
|
||||
next = Enum.sum(Enum.take(seq, n))
|
||||
anynacci([next|seq], count-1, n)
|
||||
end
|
||||
end
|
||||
|
||||
IO.inspect RC.anynacci([1,1], 15)
|
||||
|
||||
naccis = [ lucus: [2,1],
|
||||
fibonacci: [1,1],
|
||||
tribonacci: [1,1,2],
|
||||
tetranacci: [1,1,2,4],
|
||||
pentanacci: [1,1,2,4,8],
|
||||
hexanacci: [1,1,2,4,8,16],
|
||||
heptanacci: [1,1,2,4,8,16,32],
|
||||
octonacci: [1,1,2,4,8,16,32,64],
|
||||
nonanacci: [1,1,2,4,8,16,32,64,128],
|
||||
decanacci: [1,1,2,4,8,16,32,64,128,256] ]
|
||||
Enum.each(naccis, fn {name, list} ->
|
||||
:io.format("~11s: ", [name])
|
||||
IO.inspect RC.anynacci(list, 15)
|
||||
end)
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
-module( fibonacci_nstep ).
|
||||
|
||||
-export( [nacci/2, task/0] ).
|
||||
|
||||
nacci( N, Ns ) when N =< erlang:length(Ns) ->
|
||||
{Sequence, _Not_sequence} = lists:split( N, Ns ),
|
||||
Sequence;
|
||||
nacci( N, Ns ) ->
|
||||
Nth = erlang:length( Ns ),
|
||||
{_Nth, Sequence_reversed} = lists:foldl( fun nacci_foldl/2, {Nth, lists:reverse(Ns)}, lists:seq(Nth+1, N) ),
|
||||
lists:reverse( Sequence_reversed ).
|
||||
|
||||
task() ->
|
||||
Names_and_funs = [{X, fun (N) -> nacci( N, Y ) end} || {X, Y} <- [{fibonacci, [1, 1]}, {tribonacci, [1, 1, 2]}, {tetranacci, [1, 1, 2, 4]}, {lukas, [2, 1]}]],
|
||||
[io:fwrite( "~p: ~p~n", [X, Y(10)] ) || {X, Y} <- Names_and_funs].
|
||||
|
||||
|
||||
|
||||
nacci_foldl( _N, {Nth, Ns} ) ->
|
||||
{Sum_ns, _Not_sum_ns} = lists:split( Nth, Ns ),
|
||||
{Nth, [lists:sum(Sum_ns) | Ns]}.
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
let fibinit = Seq.append (Seq.singleton 1) (Seq.unfold (fun n -> Some(n, 2*n)) 1)
|
||||
|
||||
let fiblike init =
|
||||
Seq.append
|
||||
(Seq.ofList init)
|
||||
(Seq.unfold
|
||||
(function | least :: rest ->
|
||||
let this = least + Seq.reduce (+) rest
|
||||
Some(this, rest @ [this])
|
||||
| _ -> None) init)
|
||||
|
||||
let lucas = fiblike [2; 1]
|
||||
|
||||
let nacci n = Seq.take n fibinit |> Seq.toList |> fiblike
|
||||
|
||||
[<EntryPoint>]
|
||||
let main argv =
|
||||
let start s = Seq.take 15 s |> Seq.toList
|
||||
let prefix = "fibo tribo tetra penta hexa hepta octo nona deca".Split()
|
||||
Seq.iter
|
||||
(fun (p, n) -> printfn "n=%2i, %5snacci -> %A" n p (start (nacci n)))
|
||||
(Seq.init prefix.Length (fun i -> (prefix.[i], i+2)))
|
||||
printfn " lucas -> %A" (start (fiblike [2; 1]))
|
||||
0
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
USING: formatting fry kernel make math namespaces qw sequences ;
|
||||
|
||||
: n-bonacci ( n initial -- seq ) [
|
||||
[ [ , ] each ] [ length - ] [ length ] tri
|
||||
'[ building get _ tail* sum , ] times
|
||||
] { } make ;
|
||||
|
||||
qw{ fibonacci tribonacci tetranacci lucas }
|
||||
{ { 1 1 } { 1 1 2 } { 1 1 2 4 } { 2 1 } }
|
||||
[ 10 swap n-bonacci "%-10s %[%3d, %]\n" printf ] 2each
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
: length @ ; \ length of an array is stored at its address
|
||||
: a{ here cell allot ;
|
||||
: } , here over - cell / over ! ;
|
||||
|
||||
defer nacci
|
||||
|
||||
: step ( a- i n -- a- i m )
|
||||
>r 1- 2dup nacci r> + ;
|
||||
|
||||
: steps ( a- i n -- m )
|
||||
0 tuck do step loop nip nip ;
|
||||
|
||||
:noname ( a- i -- n )
|
||||
over length over > \ if i is within the array
|
||||
if cells + @ \ fetch i...if not,
|
||||
else over length 1- steps \ get length of array for calling step and recurse
|
||||
then ; is nacci
|
||||
|
||||
: show-nacci 11 1 do dup i nacci . loop cr drop ;
|
||||
|
||||
." fibonacci: " a{ 1 , 1 } show-nacci
|
||||
." tribonacci: " a{ 1 , 1 , 2 } show-nacci
|
||||
." tetranacci: " a{ 1 , 1 , 2 , 4 } show-nacci
|
||||
." lucas: " a{ 2 , 1 } show-nacci
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
! save this program as file f.f08
|
||||
! gnu-linux command to build and test
|
||||
! $ a=./f && gfortran -Wall -std=f2008 $a.f08 -o $a && echo -e 2\\n5\\n\\n | $a
|
||||
|
||||
! -*- mode: compilation; default-directory: "/tmp/" -*-
|
||||
! Compilation started at Fri Apr 4 23:20:27
|
||||
!
|
||||
! a=./f && gfortran -Wall -std=f2008 $a.f08 -o $a && echo -e 2\\n8\\ny\\n | $a
|
||||
! Enter the number of terms to sum: Show the the first how many terms of the sequence? Accept this initial sequence (y/n)?
|
||||
! 1 1
|
||||
! 1 1 2 3 5 8 13 21
|
||||
!
|
||||
! Compilation finished at Fri Apr 4 23:20:27
|
||||
|
||||
program f
|
||||
implicit none
|
||||
integer :: n, terms
|
||||
integer, allocatable, dimension(:) :: sequence
|
||||
integer :: i
|
||||
character :: answer
|
||||
write(6,'(a)',advance='no')'Enter the number of terms to sum: '
|
||||
read(5,*) n
|
||||
if ((n < 2) .or. (29 < n)) stop'Unreasonable! Exit.'
|
||||
write(6,'(a)',advance='no')'Show the the first how many terms of the sequence? '
|
||||
read(5,*) terms
|
||||
if (terms < 1) stop'Lazy programmer has not implemented backward sequences.'
|
||||
n = min(n, terms)
|
||||
allocate(sequence(1:terms))
|
||||
sequence(1) = 1
|
||||
do i = 0, n - 2
|
||||
sequence(i+2) = 2**i
|
||||
end do
|
||||
write(6,*)'Accept this initial sequence (y/n)?'
|
||||
write(6,*) sequence(:n)
|
||||
read(5,*) answer
|
||||
if (answer .eq. 'n') then
|
||||
write(6,*) 'Fine. Enter the initial terms.'
|
||||
do i=1, n
|
||||
write(6, '(i2,a2)', advance = 'no') i, ': '
|
||||
read(5, *) sequence(i)
|
||||
end do
|
||||
end if
|
||||
call nacci(n, sequence)
|
||||
write(6,*) sequence(:terms)
|
||||
deallocate(sequence)
|
||||
|
||||
contains
|
||||
|
||||
subroutine nacci(n, s)
|
||||
! nacci =: (] , +/@{.)^:(-@#@]`(-#)`])
|
||||
integer, intent(in) :: n
|
||||
integer, intent(inout), dimension(:) :: s
|
||||
integer :: i, terms
|
||||
terms = size(s)
|
||||
! do i = n+1, terms
|
||||
! s(i) = sum(s(i-n:i-1))
|
||||
! end do
|
||||
i = n+1
|
||||
if (n+1 .le. terms) s(i) = sum(s(i-n:i-1))
|
||||
do i = n + 2, terms
|
||||
s(i) = 2*s(i-1) - s(i-(n+1))
|
||||
end do
|
||||
end subroutine nacci
|
||||
end program f
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
' FB 1.05.0 Win64
|
||||
|
||||
' Deduces the step, n, from the length of the dynamic array passed in
|
||||
' and fills it out to 'size' elements
|
||||
Sub fibN (a() As Integer, size As Integer)
|
||||
Dim lb As Integer = LBound(a)
|
||||
Dim ub As Integer = UBound(a)
|
||||
Dim length As Integer = ub - lb + 1
|
||||
If length < 2 OrElse length >= size Then Return
|
||||
ub = lb + size - 1
|
||||
Redim Preserve a(lb To ub)
|
||||
Dim sum As Integer
|
||||
For i As Integer = lb + length to ub
|
||||
sum = 0
|
||||
For j As Integer = 1 To Length
|
||||
sum += a(i - j)
|
||||
Next j
|
||||
a(i) = sum
|
||||
Next i
|
||||
End Sub
|
||||
|
||||
Sub printSeries(a() As Integer, name_ As String) '' name is a keyword
|
||||
Print name_; " =>";
|
||||
For i As Integer = LBound(a) To UBound(a)
|
||||
Print Using "####"; a(i);
|
||||
Print " ";
|
||||
Next
|
||||
Print
|
||||
End Sub
|
||||
|
||||
Const size As Integer = 13 '' say
|
||||
Redim a(1 To 2) As Integer
|
||||
a(1) = 1 : a(2) = 1
|
||||
fibN(a(), size)
|
||||
printSeries(a(), "fibonacci ")
|
||||
Redim Preserve a(1 To 3)
|
||||
a(3) = 2
|
||||
fibN(a(), size)
|
||||
printSeries(a(), "tribonacci")
|
||||
Redim Preserve a(1 To 4)
|
||||
a(4) = 4
|
||||
fibN(a(), size)
|
||||
printSeries(a(), "tetranacci")
|
||||
erase a
|
||||
Redim a(1 To 2)
|
||||
a(1) = 2 : a(2) = 1
|
||||
fibN(a(), size)
|
||||
printSeries(a(), "lucas ")
|
||||
Print
|
||||
Print "Press any key to quit"
|
||||
Sleep
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
import util.TextTable
|
||||
native scala.collection.mutable.Queue
|
||||
|
||||
def fibLike( init ) =
|
||||
q = Queue()
|
||||
|
||||
for i <- init do q.enqueue( i )
|
||||
|
||||
def fib =
|
||||
q.enqueue( sum(q) )
|
||||
q.dequeue() # fib()
|
||||
|
||||
0 # fib()
|
||||
|
||||
def fibN( n ) = fibLike( [1] + [2^i | i <- 0:n-1] )
|
||||
|
||||
val lucas = fibLike( [2, 1] )
|
||||
|
||||
t = TextTable()
|
||||
t.header( 'k', 'Fibonacci', 'Tribonacci', 'Tetranacci', 'Lucas' )
|
||||
t.line()
|
||||
|
||||
for i <- 1..5
|
||||
t.rightAlignment( i )
|
||||
|
||||
seqs = (fibN(2), fibN(3), fibN(4), lucas)
|
||||
|
||||
for k <- 1..10
|
||||
t.row( ([k] + [seqs(i)(k) | i <- 0:4]).toIndexedSeq() )
|
||||
|
||||
print( t )
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func g(i []int, c chan<- int) {
|
||||
var sum int
|
||||
b := append([]int(nil), i...) // make a copy
|
||||
for _, t := range b {
|
||||
c <- t
|
||||
sum += t
|
||||
}
|
||||
for {
|
||||
for j, t := range b {
|
||||
c <- sum
|
||||
b[j], sum = sum, sum+sum-t
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
for _, s := range [...]struct {
|
||||
seq string
|
||||
i []int
|
||||
}{
|
||||
{"Fibonacci", []int{1, 1}},
|
||||
{"Tribonacci", []int{1, 1, 2}},
|
||||
{"Tetranacci", []int{1, 1, 2, 4}},
|
||||
{"Lucas", []int{2, 1}},
|
||||
} {
|
||||
fmt.Printf("%10s:", s.seq)
|
||||
c := make(chan int)
|
||||
// Note/warning: these goroutines are leaked.
|
||||
go g(s.i, c)
|
||||
for j := 0; j < 10; j++ {
|
||||
fmt.Print(" ", <-c)
|
||||
}
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
def fib = { List seed, int k=10 ->
|
||||
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"
|
||||
def n = seed.size()
|
||||
assert n > 1 : "The seed must contain at least two elements"
|
||||
List result = [] + seed
|
||||
if (k < n) {
|
||||
result[0..k]
|
||||
} else {
|
||||
(n..k).inject(result) { res, kk ->
|
||||
res << res[-n..-1].sum()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
[
|
||||
' fibonacci':[1,1],
|
||||
'tribonacci':[1,1,2],
|
||||
'tetranacci':[1,1,2,4],
|
||||
'pentanacci':[1,1,2,4,8],
|
||||
' hexanacci':[1,1,2,4,8,16],
|
||||
'heptanacci':[1,1,2,4,8,16,32],
|
||||
' octonacci':[1,1,2,4,8,16,32,64],
|
||||
' nonanacci':[1,1,2,4,8,16,32,64,128],
|
||||
' decanacci':[1,1,2,4,8,16,32,64,128,256],
|
||||
' lucas':[2,1],
|
||||
].each { name, seed ->
|
||||
println "${name}: ${fib(seed,10)}"
|
||||
}
|
||||
|
||||
println " lucas[0]: ${fib([2,1],0)}"
|
||||
println " tetra[3]: ${fib([1,1,2,4],3)}"
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
import Control.Monad (zipWithM_)
|
||||
import Data.List (tails)
|
||||
|
||||
fiblike :: [Integer] -> [Integer]
|
||||
fiblike st = xs
|
||||
where
|
||||
xs = st <> map (sum . take n) (tails xs)
|
||||
n = length st
|
||||
|
||||
nstep :: Int -> [Integer]
|
||||
nstep n = fiblike $ take n $ 1 : iterate (2 *) 1
|
||||
|
||||
main :: IO ()
|
||||
main = do
|
||||
mapM_ (print . take 10 . fiblike) [[1, 1], [2, 1]]
|
||||
zipWithM_
|
||||
( \n name -> do
|
||||
putStr (name <> "nacci -> ")
|
||||
print $ take 15 $ nstep n
|
||||
)
|
||||
[2 ..]
|
||||
(words "fibo tribo tetra penta hexa hepta octo nona deca")
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
------------ FIBONACCI N-STEP NUMBER SEQUENCES -----------
|
||||
|
||||
nStepFibonacci :: Int -> [Int]
|
||||
nStepFibonacci =
|
||||
nFibs
|
||||
. (1 :)
|
||||
. fmap (2 ^)
|
||||
. enumFromTo 0
|
||||
. subtract 2
|
||||
|
||||
nFibs :: [Int] -> [Int]
|
||||
nFibs ys@(z : zs) = z : nFibs (zs <> [sum ys])
|
||||
|
||||
--------------------------- TEST -------------------------
|
||||
main :: IO ()
|
||||
main = do
|
||||
putStrLn $
|
||||
justifyLeft 12 ' ' "Lucas" <> "-> "
|
||||
<> show (take 15 (nFibs [2, 1]))
|
||||
(putStrLn . unlines)
|
||||
( zipWith
|
||||
( \s n ->
|
||||
justifyLeft 12 ' ' (s <> "naccci")
|
||||
<> ("-> " <> show (take 15 (nStepFibonacci n)))
|
||||
)
|
||||
( words
|
||||
"fibo tribo tetra penta hexa hepta octo nona deca"
|
||||
)
|
||||
[2 ..]
|
||||
)
|
||||
|
||||
justifyLeft :: Int -> Char -> String -> String
|
||||
justifyLeft n c s = take n (s <> replicate n c)
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
import Data.Bifunctor (second)
|
||||
import Data.List (transpose, uncons, unfoldr)
|
||||
|
||||
------------ FIBONACCI N-STEP NUMBER SEQUENCES -----------
|
||||
|
||||
a000032 :: [Int]
|
||||
a000032 = unfoldr (recurrence 2) [2, 1]
|
||||
|
||||
nStepFibonacci :: Int -> [Int]
|
||||
nStepFibonacci =
|
||||
unfoldr <$> recurrence
|
||||
<*> (($ 1 : fmap (2 ^) [0 ..]) . take)
|
||||
|
||||
recurrence :: Int -> [Int] -> Maybe (Int, [Int])
|
||||
recurrence n =
|
||||
( fmap
|
||||
. second
|
||||
. flip (<>)
|
||||
. pure
|
||||
. sum
|
||||
. take n
|
||||
)
|
||||
<*> uncons
|
||||
|
||||
--------------------------- TEST -------------------------
|
||||
main :: IO ()
|
||||
main =
|
||||
putStrLn $
|
||||
"Recurrence relation sequences:\n\n"
|
||||
<> spacedTable
|
||||
justifyRight
|
||||
( ("lucas:" : fmap show (take 15 a000032)) :
|
||||
zipWith
|
||||
( \k n ->
|
||||
(k <> "nacci:") :
|
||||
fmap
|
||||
show
|
||||
(take 15 $ nStepFibonacci n)
|
||||
)
|
||||
(words "fibo tribo tetra penta hexa hepta octo nona deca")
|
||||
[2 ..]
|
||||
)
|
||||
|
||||
------------------------ FORMATTING ----------------------
|
||||
spacedTable ::
|
||||
(Int -> Char -> String -> String) -> [[String]] -> String
|
||||
spacedTable aligned rows =
|
||||
let columnWidths =
|
||||
fmap
|
||||
(maximum . fmap length)
|
||||
(transpose rows)
|
||||
in unlines $
|
||||
fmap
|
||||
(unwords . zipWith (`aligned` ' ') columnWidths)
|
||||
rows
|
||||
|
||||
justifyRight :: Int -> Char -> String -> String
|
||||
justifyRight n c = (drop . length) <*> (replicate n c <>)
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
procedure main(A)
|
||||
every writes("F2:\t"|right((fnsGen(1,1))\14,5) | "\n")
|
||||
every writes("F3:\t"|right((fnsGen(1,1,2))\14,5) | "\n")
|
||||
every writes("F4:\t"|right((fnsGen(1,1,2,4))\14,5) | "\n")
|
||||
every writes("Lucas:\t"|right((fnsGen(2,1))\14,5) | "\n")
|
||||
every writes("F?:\t"|right((fnsGen!A)\14,5) | "\n")
|
||||
end
|
||||
|
||||
procedure fnsGen(cache[])
|
||||
n := *cache
|
||||
every i := seq() do {
|
||||
if i > *cache then every (put(cache,0),cache[i] +:= cache[i-n to i-1])
|
||||
suspend cache[i]
|
||||
}
|
||||
end
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
procedure fnsGen(cache[])
|
||||
every i := seq() do {
|
||||
if i := (i > *cache, *cache) then {
|
||||
every (sum := 0) +:= !cache
|
||||
put(cache, sum) # cache only 'just enough'
|
||||
pop(cache)
|
||||
}
|
||||
suspend cache[i]
|
||||
}
|
||||
end
|
||||
|
|
@ -0,0 +1 @@
|
|||
nacci =: (] , +/@{.)^:(-@#@]`(-#)`])
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
10 nacci 2 1 NB. Lucas series, first 10 terms
|
||||
2 1 3 4 7 11 18 29 47 76
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
TESTS =: }."1 fixdsv noun define [ require 'tables/dsv' NB. Tests from task description
|
||||
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 ...
|
||||
4 tetranacci 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ...
|
||||
5 pentanacci 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ...
|
||||
6 hexanacci 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ...
|
||||
7 heptanacci 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ...
|
||||
8 octonacci 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ...
|
||||
9 nonanacci 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ...
|
||||
10 decanacci 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ...
|
||||
)
|
||||
testNacci =: ] -: #@] nacci {. NB. Given an order & test sequence, compare nacci to sequence
|
||||
OT =: __ ".&.> (<<<1) { |: TESTS NB. 'nacci order and test sequence
|
||||
(> 1 {"1 TESTS) ,. ' ' ,. (u: 16b274c 16b2713) {~ (testNacci }:)&>/ OT NB. ✓ or ❌ for success or failure
|
||||
fibonacci ✓
|
||||
tribonacci ✓
|
||||
tetranacci ✓
|
||||
pentanacci ✓
|
||||
hexanacci ✓
|
||||
heptanacci ✓
|
||||
octonacci ✓
|
||||
nonanacci ✓
|
||||
decanacci ✓
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
class Fibonacci
|
||||
{
|
||||
public static int[] lucas(int n, int numRequested)
|
||||
{
|
||||
if (n < 2)
|
||||
throw new IllegalArgumentException("Fibonacci value must be at least 2");
|
||||
return fibonacci((n == 2) ? new int[] { 2, 1 } : lucas(n - 1, n), numRequested);
|
||||
}
|
||||
|
||||
public static int[] fibonacci(int n, int numRequested)
|
||||
{
|
||||
if (n < 2)
|
||||
throw new IllegalArgumentException("Fibonacci value must be at least 2");
|
||||
return fibonacci((n == 2) ? new int[] { 1, 1 } : fibonacci(n - 1, n), numRequested);
|
||||
}
|
||||
|
||||
public static int[] fibonacci(int[] startingValues, int numRequested)
|
||||
{
|
||||
int[] output = new int[numRequested];
|
||||
int n = startingValues.length;
|
||||
System.arraycopy(startingValues, 0, output, 0, n);
|
||||
for (int i = n; i < numRequested; i++)
|
||||
for (int j = 1; j <= n; j++)
|
||||
output[i] += output[i - j];
|
||||
return output;
|
||||
}
|
||||
|
||||
public static void main(String[] args)
|
||||
{
|
||||
for (int n = 2; n <= 10; n++)
|
||||
{
|
||||
System.out.print("nacci(" + n + "):");
|
||||
for (int value : fibonacci(n, 15))
|
||||
System.out.print(" " + value);
|
||||
System.out.println();
|
||||
}
|
||||
for (int n = 2; n <= 10; n++)
|
||||
{
|
||||
System.out.print("lucas(" + n + "):");
|
||||
for (int value : lucas(n, 15))
|
||||
System.out.print(" " + value);
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
function fib(arity, len) {
|
||||
return nacci(nacci([1,1], arity, arity), arity, len);
|
||||
}
|
||||
|
||||
function lucas(arity, len) {
|
||||
return nacci(nacci([2,1], arity, arity), arity, len);
|
||||
}
|
||||
|
||||
function nacci(a, arity, len) {
|
||||
while (a.length < len) {
|
||||
var sum = 0;
|
||||
for (var i = Math.max(0, a.length - arity); i < a.length; i++)
|
||||
sum += a[i];
|
||||
a.push(sum);
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
function main() {
|
||||
for (var arity = 2; arity <= 10; arity++)
|
||||
console.log("fib(" + arity + "): " + fib(arity, 15));
|
||||
for (var arity = 2; arity <= 10; arity++)
|
||||
console.log("lucas(" + arity + "): " + lucas(arity, 15));
|
||||
}
|
||||
|
||||
main();
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
(() => {
|
||||
'use strict';
|
||||
|
||||
// Start sequence -> Number of terms -> terms
|
||||
|
||||
// takeNFibs :: [Int] -> Int -> [Int]
|
||||
const takeNFibs = (xs, n) => {
|
||||
const go = (xs, n) =>
|
||||
0 < n && 0 < xs.length ? (
|
||||
cons(
|
||||
head(xs),
|
||||
go(
|
||||
append(tail(xs), [sum(xs)]),
|
||||
n - 1
|
||||
)
|
||||
)
|
||||
) : [];
|
||||
return go(xs, n);
|
||||
};
|
||||
|
||||
// fibInit :: Int -> [Int]
|
||||
const fibInit = n =>
|
||||
cons(
|
||||
1,
|
||||
map(x => Math.pow(2, x),
|
||||
enumFromToInt(0, n - 2)
|
||||
)
|
||||
);
|
||||
|
||||
// TEST -----------------------------------------------------------------
|
||||
const main = () => {
|
||||
const
|
||||
intTerms = 15,
|
||||
strTable = unlines(
|
||||
zipWith(
|
||||
(s, n) =>
|
||||
justifyLeft(12, ' ', s + 'nacci') + ' -> ' +
|
||||
showJSON(
|
||||
takeNFibs(fibInit(n), intTerms)
|
||||
),
|
||||
words('fibo tribo tetra penta hexa hepta octo nona deca'),
|
||||
enumFromToInt(2, 10)
|
||||
)
|
||||
);
|
||||
|
||||
return justifyLeft(12, ' ', 'Lucas ') + ' -> ' +
|
||||
showJSON(takeNFibs([2, 1], intTerms)) + '\n' +
|
||||
strTable;
|
||||
};
|
||||
|
||||
// GENERIC FUNCTIONS ----------------------------
|
||||
|
||||
// append (++) :: [a] -> [a] -> [a]
|
||||
// append (++) :: String -> String -> String
|
||||
const append = (xs, ys) => xs.concat(ys);
|
||||
|
||||
// cons :: a -> [a] -> [a]
|
||||
const cons = (x, xs) =>
|
||||
Array.isArray(xs) ? (
|
||||
[x].concat(xs)
|
||||
) : (x + xs);
|
||||
|
||||
// enumFromToInt :: Int -> Int -> [Int]
|
||||
const enumFromToInt = (m, n) =>
|
||||
m <= n ? iterateUntil(
|
||||
x => n <= x,
|
||||
x => 1 + x,
|
||||
m
|
||||
) : [];
|
||||
|
||||
// head :: [a] -> a
|
||||
const head = xs => xs.length ? xs[0] : undefined;
|
||||
|
||||
// iterateUntil :: (a -> Bool) -> (a -> a) -> a -> [a]
|
||||
const iterateUntil = (p, f, x) => {
|
||||
const vs = [x];
|
||||
let h = x;
|
||||
while (!p(h))(h = f(h), vs.push(h));
|
||||
return vs;
|
||||
};
|
||||
|
||||
// justifyLeft :: Int -> Char -> String -> String
|
||||
const justifyLeft = (n, cFiller, s) =>
|
||||
n > s.length ? (
|
||||
s.padEnd(n, cFiller)
|
||||
) : s;
|
||||
|
||||
// map :: (a -> b) -> [a] -> [b]
|
||||
const map = (f, xs) => xs.map(f);
|
||||
|
||||
// showJSON :: a -> String
|
||||
const showJSON = x => JSON.stringify(x);
|
||||
|
||||
// sum :: [Num] -> Num
|
||||
const sum = xs => xs.reduce((a, x) => a + x, 0);
|
||||
|
||||
// tail :: [a] -> [a]
|
||||
const tail = xs => 0 < xs.length ? xs.slice(1) : [];
|
||||
|
||||
// unlines :: [String] -> String
|
||||
const unlines = xs => xs.join('\n');
|
||||
|
||||
// words :: String -> [String]
|
||||
const words = s => s.split(/\s+/);
|
||||
|
||||
// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
|
||||
const zipWith = (f, xs, ys) =>
|
||||
Array.from({
|
||||
length: Math.min(xs.length, ys.length)
|
||||
}, (_, i) => f(xs[i], ys[i], i));
|
||||
|
||||
// MAIN ---
|
||||
return main();
|
||||
})();
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
# Input: the initial array
|
||||
def nacci(arity; len):
|
||||
arity as $arity | len as $len
|
||||
| reduce range(length; $len) as $i
|
||||
(.;
|
||||
([0, (length - $arity)] | max ) as $lower
|
||||
| . + [ .[ ($lower) : length] | add] ) ;
|
||||
|
||||
def fib(arity; len):
|
||||
arity as $arity | len as $len
|
||||
| [1,1] | nacci($arity; $arity) | nacci($arity; $len) ;
|
||||
|
||||
def lucas(arity; len):
|
||||
arity as $arity | len as $len
|
||||
| [2,1] | nacci($arity; $arity) | nacci($arity; $len) ;
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
def main:
|
||||
(range(2; 11) | "fib(\(.)): \(fib(.; 15))"),
|
||||
(range(2; 11) | "lucas(\(.)): \(lucas(.; 15))")
|
||||
;
|
||||
|
||||
main
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
type NFib{T<:Integer}
|
||||
n::T
|
||||
klim::T
|
||||
seeder::Function
|
||||
end
|
||||
|
||||
type FState
|
||||
a::Array{BigInt,1}
|
||||
adex::Integer
|
||||
k::Integer
|
||||
end
|
||||
|
||||
function Base.start{T<:Integer}(nf::NFib{T})
|
||||
a = nf.seeder(nf.n)
|
||||
adex = 1
|
||||
k = 1
|
||||
return FState(a, adex, k)
|
||||
end
|
||||
|
||||
function Base.done{T<:Integer}(nf::NFib{T}, fs::FState)
|
||||
fs.k > nf.klim
|
||||
end
|
||||
|
||||
function Base.next{T<:Integer}(nf::NFib{T}, fs::FState)
|
||||
f = sum(fs.a)
|
||||
fs.a[fs.adex] = f
|
||||
fs.adex = rem1(fs.adex+1, nf.n)
|
||||
fs.k += 1
|
||||
return (f, fs)
|
||||
end
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
function fib_seeder{T<:Integer}(n::T)
|
||||
a = zeros(BigInt, n)
|
||||
a[1] = one(BigInt)
|
||||
return a
|
||||
end
|
||||
|
||||
function fib{T<:Integer}(n::T, k::T)
|
||||
NFib(n, k, fib_seeder)
|
||||
end
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
function luc_rc_seeder{T<:Integer}(n::T)
|
||||
a = zeros(BigInt, n)
|
||||
a[1] = 3
|
||||
a[2] = -1
|
||||
return a
|
||||
end
|
||||
|
||||
function luc_rc{T<:Integer}(n::T, k::T)
|
||||
NFib(n, k, luc_rc_seeder)
|
||||
end
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
function luc_seeder{T<:Integer}(n::T)
|
||||
a = -ones(BigInt, n)
|
||||
a[end] = big(n)
|
||||
return a
|
||||
end
|
||||
|
||||
function luc{T<:Integer}(n::T, k::T)
|
||||
NFib(n, k, luc_seeder)
|
||||
end
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
lo = 2
|
||||
hi = 10
|
||||
klim = 16
|
||||
|
||||
print("n-step Fibonacci for n = (", lo, ",", hi)
|
||||
println(") up to k = ", klim, ":")
|
||||
for i in 2:10
|
||||
print(@sprintf("%5d => ", i))
|
||||
for j in fib(i, klim)
|
||||
print(j, " ")
|
||||
end
|
||||
println()
|
||||
end
|
||||
|
||||
println()
|
||||
print("n-step Rosetta Code Lucas for n = (", lo, ",", hi)
|
||||
println(") up to k = ", klim, ":")
|
||||
for i in 2:10
|
||||
print(@sprintf("%5d => ", i))
|
||||
for j in luc_rc(i, klim)
|
||||
print(j, " ")
|
||||
end
|
||||
println()
|
||||
end
|
||||
|
||||
println()
|
||||
print("n-step MathWorld Lucas for n = (", lo, ",", hi)
|
||||
println(") up to k = ", klim, ":")
|
||||
for i in 2:10
|
||||
print(@sprintf("%5d => ", i))
|
||||
for j in luc(i, klim)
|
||||
print(j, " ")
|
||||
end
|
||||
println()
|
||||
end
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
// version 1.1.2
|
||||
|
||||
fun fibN(initial: IntArray, numTerms: Int) : IntArray {
|
||||
val n = initial.size
|
||||
require(n >= 2 && numTerms >= 0)
|
||||
val fibs = initial.copyOf(numTerms)
|
||||
if (numTerms <= n) return fibs
|
||||
for (i in n until numTerms) {
|
||||
var sum = 0
|
||||
for (j in i - n until i) sum += fibs[j]
|
||||
fibs[i] = sum
|
||||
}
|
||||
return fibs
|
||||
}
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
val names = arrayOf("fibonacci", "tribonacci", "tetranacci", "pentanacci", "hexanacci",
|
||||
"heptanacci", "octonacci", "nonanacci", "decanacci")
|
||||
val initial = intArrayOf(1, 1, 2, 4, 8, 16, 32, 64, 128, 256)
|
||||
println(" n name values")
|
||||
var values = fibN(intArrayOf(2, 1), 15).joinToString(", ")
|
||||
println("%2d %-10s %s".format(2, "lucas", values))
|
||||
for (i in 0..8) {
|
||||
values = fibN(initial.sliceArray(0 until i + 2), 15).joinToString(", ")
|
||||
println("%2d %-10s %s".format(i + 2, names[i], values))
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
function nStepFibs (seq, limit)
|
||||
local iMax, sum = #seq - 1
|
||||
while #seq < limit do
|
||||
sum = 0
|
||||
for i = 0, iMax do sum = sum + seq[#seq - i] end
|
||||
table.insert(seq, sum)
|
||||
end
|
||||
return seq
|
||||
end
|
||||
|
||||
local fibSeqs = {
|
||||
{name = "Fibonacci", values = {1, 1} },
|
||||
{name = "Tribonacci", values = {1, 1, 2} },
|
||||
{name = "Tetranacci", values = {1, 1, 2, 4}},
|
||||
{name = "Lucas", values = {2, 1} }
|
||||
}
|
||||
for _, sequence in pairs(fibSeqs) do
|
||||
io.write(sequence.name .. ": ")
|
||||
print(table.concat(nStepFibs(sequence.values, 10), " "))
|
||||
end
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
numSequence := proc(initValues :: Array)
|
||||
local n, i, values;
|
||||
n := numelems(initValues);
|
||||
values := copy(initValues);
|
||||
for i from (n+1) to 15 do
|
||||
values(i) := add(values[i-n..i-1]);
|
||||
end do;
|
||||
return values;
|
||||
end proc:
|
||||
|
||||
initValues := Array([1]):
|
||||
for i from 2 to 10 do
|
||||
initValues(i) := add(initValues):
|
||||
printf ("nacci(%d): %a\n", i, convert(numSequence(initValues), list));
|
||||
end do:
|
||||
printf ("lucas: %a\n", convert(numSequence(Array([2, 1])), list));
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
f2=Function[{l,k},
|
||||
Module[{n=Length@l,m},
|
||||
m=SparseArray[{{i_,j_}/;i==1||i==j+1->1},{n,n}];
|
||||
NestList[m.#&,l,k]]];
|
||||
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
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
import sequtils, strutils
|
||||
|
||||
proc fiblike(start: seq[int]): auto =
|
||||
var memo = start
|
||||
proc fibber(n: int): int =
|
||||
if n < memo.len:
|
||||
return memo[n]
|
||||
else:
|
||||
var ans = 0
|
||||
for i in n-start.len ..< n:
|
||||
ans += fibber(i)
|
||||
memo.add ans
|
||||
return ans
|
||||
return fibber
|
||||
|
||||
let fibo = fiblike(@[1,1])
|
||||
echo toSeq(0..9).map(fibo)
|
||||
let lucas = fiblike(@[2,1])
|
||||
echo toSeq(0..9).map(lucas)
|
||||
|
||||
for n, name in items({2: "fibo", 3: "tribo", 4: "tetra", 5: "penta", 6: "hexa",
|
||||
7: "hepta", 8: "octo", 9: "nona", 10: "deca"}):
|
||||
var se = @[1]
|
||||
for i in 0..n-2:
|
||||
se.add(1 shl i)
|
||||
let fibber = fiblike(se)
|
||||
echo "n = ", align($n, 2), ", ", align(name, 5), "nacci -> ", toSeq(0..14).mapIt($fibber(it)).join(" "), " ..."
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
(define (n-fib-iterator ll)
|
||||
(cons (car ll)
|
||||
(lambda ()
|
||||
(n-fib-iterator (append (cdr ll) (list (fold + 0 ll)))))))
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
(print "2, fibonacci : " (ltake (n-fib-iterator '(1 1)) 15))
|
||||
(print "3, tribonacci: " (ltake (n-fib-iterator '(1 1 2)) 15))
|
||||
(print "4, tetranacci: " (ltake (n-fib-iterator '(1 1 2 4)) 15))
|
||||
(print "5, pentanacci: " (ltake (n-fib-iterator '(1 1 2 4 8)) 15))
|
||||
(print "2, lucas : " (ltake (n-fib-iterator '(2 1)) 15))
|
||||
|
||||
; ==>
|
||||
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)
|
||||
4, tetranacci: (1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536)
|
||||
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)
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
gen(n)=k->my(v=vector(k,i,1));for(i=3,min(k,n),v[i]=2^(i-2));for(i=n+1,k,v[i]=sum(j=i-n,i-1,v[j]));v
|
||||
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
|
||||
for(n=2,10,print(n"\t"gen(n)(10)))
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
<?php
|
||||
/**
|
||||
* @author Elad Yosifon
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param int $x
|
||||
* @param array $series
|
||||
* @param int $n
|
||||
* @return array
|
||||
*/
|
||||
function fib_n_step($x, &$series = array(1, 1), $n = 15)
|
||||
{
|
||||
$count = count($series);
|
||||
|
||||
if($count > $x && $count == $n) // exit point
|
||||
{
|
||||
return $series;
|
||||
}
|
||||
|
||||
if($count < $n)
|
||||
{
|
||||
if($count >= $x) // 4 or less
|
||||
{
|
||||
fib($series, $x, $count);
|
||||
return fib_n_step($x, $series, $n);
|
||||
}
|
||||
else // 5 or more
|
||||
{
|
||||
while(count($series) < $x )
|
||||
{
|
||||
$count = count($series);
|
||||
fib($series, $count, $count);
|
||||
}
|
||||
return fib_n_step($x, $series, $n);
|
||||
}
|
||||
}
|
||||
|
||||
return $series;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array $series
|
||||
* @param int $n
|
||||
* @param int $i
|
||||
*/
|
||||
function fib(&$series, $n, $i)
|
||||
{
|
||||
$end = 0;
|
||||
for($j = $n; $j > 0; $j--)
|
||||
{
|
||||
$end += $series[$i-$j];
|
||||
}
|
||||
$series[$i] = $end;
|
||||
}
|
||||
|
||||
|
||||
/*=================== OUTPUT ============================*/
|
||||
|
||||
header('Content-Type: text/plain');
|
||||
$steps = array(
|
||||
'LUCAS' => array(2, array(2, 1)),
|
||||
'FIBONACCI' => array(2, array(1, 1)),
|
||||
'TRIBONACCI' => array(3, array(1, 1, 2)),
|
||||
'TETRANACCI' => array(4, array(1, 1, 2, 4)),
|
||||
'PENTANACCI' => array(5, array(1, 1, 2, 4)),
|
||||
'HEXANACCI' => array(6, array(1, 1, 2, 4)),
|
||||
'HEPTANACCI' => array(7, array(1, 1, 2, 4)),
|
||||
'OCTONACCI' => array(8, array(1, 1, 2, 4)),
|
||||
'NONANACCI' => array(9, array(1, 1, 2, 4)),
|
||||
'DECANACCI' => array(10, array(1, 1, 2, 4)),
|
||||
);
|
||||
|
||||
foreach($steps as $name=>$pair)
|
||||
{
|
||||
$ser = fib_n_step($pair[0],$pair[1]);
|
||||
$n = count($ser)-1;
|
||||
|
||||
echo $name." => ".implode(',', $ser) . "\n";
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
(subscriptrange, fixedoverflow, size):
|
||||
n_step_Fibonacci: procedure options (main);
|
||||
declare line character (100) varying;
|
||||
declare (i, j, k) fixed binary;
|
||||
|
||||
put ('n-step Fibonacci series: Please type the initial values on one line:');
|
||||
get edit (line) (L);
|
||||
line = trim(line);
|
||||
k = tally(line, ' ') - tally(line, ' ') + 1; /* count values */
|
||||
|
||||
begin;
|
||||
declare (n(k), s) fixed decimal (15);
|
||||
get string (line || ' ') list ( n );
|
||||
|
||||
if n(1) = 2 then put ('We have a Lusas series');
|
||||
else put ('We have a ' || trim(k) || '-step Fibonacci series.');
|
||||
|
||||
put skip edit ( (trim(n(i)) do i = 1 to k) ) (a, x(1));
|
||||
do j = k+1 to 20; /* In toto, generate 20 values in the series. */
|
||||
s = sum(n); /* the next value in the series */
|
||||
put edit (trim(s)) (x(1), a);
|
||||
do i = lbound(n,1)+1 to k; /* Discard the oldest value */
|
||||
n(i-1) = n(i);
|
||||
end;
|
||||
n(k) = s; /* and insert the new value */
|
||||
end;
|
||||
end;
|
||||
end n_step_Fibonacci;
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
program FibbonacciN (output);
|
||||
|
||||
type
|
||||
TintArray = array of integer;
|
||||
const
|
||||
Name: array[2..11] of string = ('Fibonacci: ',
|
||||
'Tribonacci: ',
|
||||
'Tetranacci: ',
|
||||
'Pentanacci: ',
|
||||
'Hexanacci: ',
|
||||
'Heptanacci: ',
|
||||
'Octonacci: ',
|
||||
'Nonanacci: ',
|
||||
'Decanacci: ',
|
||||
'Lucas: '
|
||||
);
|
||||
var
|
||||
sequence: TintArray;
|
||||
j, k: integer;
|
||||
|
||||
function CreateFibbo(n: integer): TintArray;
|
||||
var
|
||||
i: integer;
|
||||
begin
|
||||
setlength(CreateFibbo, n);
|
||||
CreateFibbo[0] := 1;
|
||||
CreateFibbo[1] := 1;
|
||||
i := 2;
|
||||
while i < n do
|
||||
begin
|
||||
CreateFibbo[i] := CreateFibbo[i-1] * 2;
|
||||
inc(i);
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure Fibbonacci(var start: TintArray);
|
||||
const
|
||||
No_of_examples = 11;
|
||||
var
|
||||
n, i, j: integer;
|
||||
begin
|
||||
n := length(start);
|
||||
setlength(start, No_of_examples);
|
||||
for i := n to high(start) do
|
||||
begin
|
||||
start[i] := 0;
|
||||
for j := 1 to n do
|
||||
start[i] := start[i] + start[i-j]
|
||||
end;
|
||||
end;
|
||||
|
||||
begin
|
||||
for j := 2 to 10 do
|
||||
begin
|
||||
sequence := CreateFibbo(j);
|
||||
Fibbonacci(sequence);
|
||||
write (Name[j]);
|
||||
for k := low(sequence) to high(sequence) do
|
||||
write(sequence[k], ' ');
|
||||
writeln;
|
||||
end;
|
||||
setlength(sequence, 2);
|
||||
sequence[0] := 2;
|
||||
sequence[1] := 1;
|
||||
Fibbonacci(sequence);
|
||||
write (Name[11]);
|
||||
for k := low(sequence) to high(sequence) do
|
||||
write(sequence[k], ' ');
|
||||
writeln;
|
||||
end.
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
program FibbonacciN (output);
|
||||
{$IFNDEF FPC}
|
||||
{$APPTYPE CONSOLE}
|
||||
{$ENDIF}
|
||||
const
|
||||
MAX_Nacci = 10;
|
||||
|
||||
No_of_examples = 11;// max 90; (golden ratio)^No < 2^64
|
||||
Name: array[2..11] of string = ('Fibonacci: ',
|
||||
'Tribonacci: ',
|
||||
'Tetranacci: ',
|
||||
'Pentanacci: ',
|
||||
'Hexanacci: ',
|
||||
'Heptanacci: ',
|
||||
'Octonacci: ',
|
||||
'Nonanacci: ',
|
||||
'Decanacci: ',
|
||||
'Lucas: '
|
||||
);
|
||||
|
||||
type
|
||||
tfibIdx = 0..MAX_Nacci;
|
||||
tNacVal = Uint64;// longWord
|
||||
tNacci = record
|
||||
ncSum : tNacVal;
|
||||
ncLastFib : array[tFibIdx] of tNacVal;
|
||||
ncNextIdx : array[tFibIdx] of tFibIdx;
|
||||
ncIdx : tFibIdx;
|
||||
ncValue : tFibIdx;
|
||||
end;
|
||||
|
||||
|
||||
function CreateNacci(n: tFibIdx): TNacci;
|
||||
var
|
||||
i : tFibIdx;
|
||||
sum :tNacVal;
|
||||
begin
|
||||
//With result do
|
||||
with CreateNacci do
|
||||
begin
|
||||
ncLastFib[0] := 1;
|
||||
ncLastFib[1] := 1;
|
||||
For i := 2 to n-1 do
|
||||
ncLastFib[i] := ncLastFib[i-1] * 2;
|
||||
|
||||
Sum := 0;
|
||||
For i := 0 to n-1 do
|
||||
sum := sum +ncLastFib[i];
|
||||
ncSum := Sum;
|
||||
//No need to do a compare
|
||||
//inc(idx);
|
||||
//if idx>= n then
|
||||
// idx := 0;
|
||||
//idx := nextIdx[idx]
|
||||
For i := 0 to n-2 do
|
||||
ncNextIdx[i] := i+1;
|
||||
ncNextIdx[n-1] := 0;
|
||||
ncIdx := 0;
|
||||
end;
|
||||
end;
|
||||
|
||||
function LehmerCreate:TNacci;
|
||||
begin
|
||||
with LehmerCreate do
|
||||
begin
|
||||
ncLastFib[0] := 2;
|
||||
ncLastFib[1] := 1;
|
||||
ncSum := 3;
|
||||
ncNextIdx[0] := 1;
|
||||
ncNextIdx[1] := 0;
|
||||
ncIdx := 0;
|
||||
end;
|
||||
end;
|
||||
|
||||
function NextNacci(var Nacci:tNacci):tNacVal;
|
||||
var
|
||||
NewSum :tNacVal;
|
||||
begin
|
||||
with Nacci do
|
||||
begin
|
||||
NewSum := 2*ncSum- ncLastFib[ncIdx];
|
||||
ncLastFib[ncIdx] := ncSum;
|
||||
ncIdx := ncNextIdx[ncIdx];
|
||||
NextNacci := ncSum;
|
||||
ncSum := NewSum;
|
||||
end;
|
||||
end;
|
||||
|
||||
var
|
||||
Nacci : tNacci;
|
||||
j, k: integer;
|
||||
|
||||
BEGIN
|
||||
for j := 2 to 10 do
|
||||
begin
|
||||
Nacci := CreateNacci(j);
|
||||
write (Name[j]);
|
||||
For k := 0 to j-1 do
|
||||
write(Nacci.ncLastFib[k],' ');
|
||||
For k := j to No_of_examples-1 do
|
||||
write(NextNacci(Nacci),' ');
|
||||
writeln;
|
||||
end;
|
||||
|
||||
write (Name[11]);
|
||||
j := 2;
|
||||
Nacci := LehmerCreate;
|
||||
For k := 0 to j-1 do
|
||||
write(Nacci.ncLastFib[k],' ');
|
||||
For k := j to No_of_examples-1 do
|
||||
write(NextNacci(Nacci),' ');
|
||||
writeln;
|
||||
END.
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
// unfold infinite sequences. Nigel Galloway: September 8th., 2022
|
||||
function unfold<gN,gG>(n:Func<gG,(gN,gG)>; g:gG): sequence of gN;
|
||||
begin
|
||||
var (x,r):=n(g);
|
||||
yield x;
|
||||
yield sequence unfold(n,r);
|
||||
end;
|
||||
function unfold<gN,gG>(n:Func<array of gG,(gN,array of gG)>;params g:array of gG): sequence of gN := unfold(n,g);
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
// Fibonacci n-step number sequences. Nigel Galloway: September 8th., 2022
|
||||
var nFib:=function(n:array of biginteger): (biginteger,array of biginteger)->(n.First,n[1:].Append(n.Sum).ToArray);
|
||||
begin
|
||||
var fib:=unfold(nFib,1bi,1bi);
|
||||
fib.Take(20).Println;
|
||||
var tri:=unfold(nFib,fib.Take(3));
|
||||
tri.Take(20).Println;
|
||||
var tet:=unfold(nFib,tri.Take(4));
|
||||
tet.Take(20).Println;
|
||||
var pen:=unfold(nFib,tet.Take(5));
|
||||
pen.Take(20).Println;
|
||||
var hex:=unfold(nFib,pen.Take(6));
|
||||
hex.Take(20).Println;
|
||||
var hep:=unfold(nFib,hex.Take(7));
|
||||
hep.Take(20).Println;
|
||||
var oct:=unfold(nFib,hep.Take(8));
|
||||
oct.Take(20).Println;
|
||||
var non:=unfold(nFib,oct.Take(9));
|
||||
non.Take(20).Println;
|
||||
var dec:=unfold(nFib,non.Take(10));
|
||||
dec.Take(20).Println;
|
||||
var luc:=unfold(nFib,2bi,1bi);
|
||||
luc.Take(20).Println;
|
||||
end.
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
use strict;
|
||||
use warnings;
|
||||
use feature <say signatures>;
|
||||
no warnings 'experimental';
|
||||
use List::Util <max sum>;
|
||||
|
||||
sub fib_n ($n = 2, $xs = [1], $max = 100) {
|
||||
my @xs = @$xs;
|
||||
while ( $max > (my $len = @xs) ) {
|
||||
push @xs, sum @xs[ max($len - $n, 0) .. $len-1 ];
|
||||
}
|
||||
@xs
|
||||
}
|
||||
|
||||
say $_-1 . ': ' . join ' ', (fib_n $_)[0..19] for 2..10;
|
||||
say "\nLucas: " . join ' ', fib_n(2, [2,1], 20);
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
(phixonline)-->
|
||||
<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: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><</span><span style="color: #000000;">2</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">+</span><span style="color: #000000;">n</span><span style="color: #0000FF;">*</span><span style="color: #000000;">l</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">1</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #004080;">atom</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">nacci_noo</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</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: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">min</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">nacci_noo</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">i</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: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">names</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"lucas fibo tribo tetra penta hexa hepta octo nona deca"</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">4</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">10</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">nacci_noo</span><span style="color: #0000FF;">(</span><span style="color: #000000;">j</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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>
|
||||
<!--
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
(de nacci (Init Cnt)
|
||||
(let N (length Init)
|
||||
(make
|
||||
(made Init)
|
||||
(do (- Cnt N)
|
||||
(link (apply + (tail N (made)))) ) ) ) )
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
# Fibonacci
|
||||
: (nacci (1 1) 10)
|
||||
-> (1 1 2 3 5 8 13 21 34 55)
|
||||
|
||||
# Tribonacci
|
||||
: (nacci (1 1 2) 10)
|
||||
-> (1 1 2 4 7 13 24 44 81 149)
|
||||
|
||||
# Tetranacci
|
||||
: (nacci (1 1 2 4) 10)
|
||||
-> (1 1 2 4 8 15 29 56 108 208)
|
||||
|
||||
# Lucas
|
||||
: (nacci (2 1) 10)
|
||||
-> (2 1 3 4 7 11 18 29 47 76)
|
||||
|
||||
# Decanacci
|
||||
: (nacci (1 1 2 4 8 16 32 64 128 256) 15)
|
||||
-> (1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172)
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#Create generator of extended fibonaci
|
||||
Function Get-ExtendedFibonaciGenerator($InitialValues ){
|
||||
$Values = $InitialValues
|
||||
{
|
||||
#exhaust initial values first before calculating next values by summation
|
||||
if ($InitialValues.Length -gt 0) {
|
||||
$NextValue = $InitialValues[0]
|
||||
$Script:InitialValues = $InitialValues | Select -Skip 1
|
||||
return $NextValue
|
||||
}
|
||||
|
||||
$NextValue = $Values | Measure-Object -Sum | Select -ExpandProperty Sum
|
||||
$Script:Values = @($Values | Select-Object -Skip 1) + @($NextValue)
|
||||
|
||||
$NextValue
|
||||
}.GetNewClosure()
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
$Name = 'fibo tribo tetra penta hexa hepta octo nona deca'.Split()
|
||||
0..($Name.Length-1) | foreach { $Index = $_
|
||||
$InitialValues = @(1) + @(foreach ($I In 0..$Index) { [Math]::Pow(2,$I) })
|
||||
$Generator = Get-ExtendedFibonaciGenerator $InitialValues
|
||||
[PSCustomObject] @{
|
||||
n = $InitialValues.Length;
|
||||
Name = "$($Name[$Index])naci";
|
||||
Sequence = 1..15 | foreach { & $Generator } | Join-String -Separator ','
|
||||
}
|
||||
} | Format-Table -AutoSize
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
Procedure.i FibonacciLike(k,n=2,p.s="",d.s=".")
|
||||
Protected i,r
|
||||
if k<0:ProcedureReturn 0:endif
|
||||
if p.s
|
||||
n=CountString(p.s,d.s)+1
|
||||
for i=0 to n-1
|
||||
if k=i:ProcedureReturn val(StringField(p.s,i+1,d.s)):endif
|
||||
next
|
||||
else
|
||||
if k=0:ProcedureReturn 1:endif
|
||||
if k=1:ProcedureReturn 1:endif
|
||||
endif
|
||||
for i=1 to n
|
||||
r+FibonacciLike(k-i,n,p.s,d.s)
|
||||
next
|
||||
ProcedureReturn r
|
||||
EndProcedure
|
||||
|
||||
; The fact that PureBasic supports default values for procedure parameters
|
||||
; is very useful in a case such as this.
|
||||
; Since:
|
||||
; k=4
|
||||
; Debug FibonacciLike(k) ;good old Fibonacci
|
||||
|
||||
; Debug FibonacciLike(k,3) ;here we specified n=3 [Tribonacci]
|
||||
; Debug FibonacciLike(k,3,"1.1.2") ;using the default delimiter "."
|
||||
; Debug FibonacciLike(k,3,"1,1,2",",") ;using a different delimiter ","
|
||||
; the last three all produce the same result.
|
||||
|
||||
; as do the following two for the Lucas series:
|
||||
; Debug FibonacciLike(k,2,"2.1") ;using the default delimiter "."
|
||||
; Debug FibonacciLike(k,2,"2,1",",") ;using a different delimiter ","
|
||||
|
||||
m=10
|
||||
t.s=lset("n",5)
|
||||
for k=0 to m
|
||||
t.s+lset(str(k),5)
|
||||
next
|
||||
Debug t.s
|
||||
for n=2 to 10
|
||||
t.s=lset(str(n),5)
|
||||
for k=0 to m
|
||||
t.s+lset(str(FibonacciLike(k,n)),5)
|
||||
next
|
||||
Debug t.s
|
||||
next
|
||||
Debug ""
|
||||
p.s="2.1"
|
||||
t.s=lset(p.s,5)
|
||||
for k=0 to m
|
||||
t.s+lset(str(FibonacciLike(k,n,p.s)),5)
|
||||
next
|
||||
Debug t.s
|
||||
Debug ""
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
>>> def fiblike(start):
|
||||
addnum = len(start)
|
||||
memo = start[:]
|
||||
def fibber(n):
|
||||
try:
|
||||
return memo[n]
|
||||
except IndexError:
|
||||
ans = sum(fibber(i) for i in range(n-addnum, n))
|
||||
memo.append(ans)
|
||||
return ans
|
||||
return fibber
|
||||
|
||||
>>> fibo = fiblike([1,1])
|
||||
>>> [fibo(i) for i in range(10)]
|
||||
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
|
||||
>>> lucas = fiblike([2,1])
|
||||
>>> [lucas(i) for i in range(10)]
|
||||
[2, 1, 3, 4, 7, 11, 18, 29, 47, 76]
|
||||
>>> for n, name in zip(range(2,11), 'fibo tribo tetra penta hexa hepta octo nona deca'.split()) :
|
||||
fibber = fiblike([1] + [2**i for i in range(n-1)])
|
||||
print('n=%2i, %5snacci -> %s ...' % (n, name, ' '.join(str(fibber(i)) for i in range(15))))
|
||||
|
||||
|
||||
n= 2, fibonacci -> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ...
|
||||
n= 3, tribonacci -> 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ...
|
||||
n= 4, tetranacci -> 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ...
|
||||
n= 5, pentanacci -> 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ...
|
||||
n= 6, hexanacci -> 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ...
|
||||
n= 7, heptanacci -> 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ...
|
||||
n= 8, octonacci -> 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ...
|
||||
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 ...
|
||||
>>>
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
>>> class Fiblike():
|
||||
def __init__(self, start):
|
||||
self.addnum = len(start)
|
||||
self.memo = start[:]
|
||||
def __call__(self, n):
|
||||
try:
|
||||
return self.memo[n]
|
||||
except IndexError:
|
||||
ans = sum(self(i) for i in range(n-self.addnum, n))
|
||||
self.memo.append(ans)
|
||||
return ans
|
||||
|
||||
|
||||
>>> fibo = Fiblike([1,1])
|
||||
>>> [fibo(i) for i in range(10)]
|
||||
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
|
||||
>>> lucas = Fiblike([2,1])
|
||||
>>> [lucas(i) for i in range(10)]
|
||||
[2, 1, 3, 4, 7, 11, 18, 29, 47, 76]
|
||||
>>> for n, name in zip(range(2,11), 'fibo tribo tetra penta hexa hepta octo nona deca'.split()) :
|
||||
fibber = Fiblike([1] + [2**i for i in range(n-1)])
|
||||
print('n=%2i, %5snacci -> %s ...' % (n, name, ' '.join(str(fibber(i)) for i in range(15))))
|
||||
|
||||
|
||||
n= 2, fibonacci -> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ...
|
||||
n= 3, tribonacci -> 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ...
|
||||
n= 4, tetranacci -> 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ...
|
||||
n= 5, pentanacci -> 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ...
|
||||
n= 6, hexanacci -> 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ...
|
||||
n= 7, heptanacci -> 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ...
|
||||
n= 8, octonacci -> 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ...
|
||||
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 ...
|
||||
>>>
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
from itertools import islice, cycle
|
||||
|
||||
def fiblike(tail):
|
||||
for x in tail:
|
||||
yield x
|
||||
for i in cycle(xrange(len(tail))):
|
||||
tail[i] = x = sum(tail)
|
||||
yield x
|
||||
|
||||
fibo = fiblike([1, 1])
|
||||
print list(islice(fibo, 10))
|
||||
lucas = fiblike([2, 1])
|
||||
print list(islice(lucas, 10))
|
||||
|
||||
suffixes = "fibo tribo tetra penta hexa hepta octo nona deca"
|
||||
for n, name in zip(xrange(2, 11), suffixes.split()):
|
||||
fib = fiblike([1] + [2 ** i for i in xrange(n - 1)])
|
||||
items = list(islice(fib, 15))
|
||||
print "n=%2i, %5snacci -> %s ..." % (n, name, items)
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
'''Fibonacci n-step number sequences'''
|
||||
|
||||
from itertools import chain, count, islice
|
||||
|
||||
|
||||
# A000032 :: () -> [Int]
|
||||
def A000032():
|
||||
'''Non finite sequence of Lucas numbers.
|
||||
'''
|
||||
return unfoldr(recurrence(2))([2, 1])
|
||||
|
||||
|
||||
# nStepFibonacci :: Int -> [Int]
|
||||
def nStepFibonacci(n):
|
||||
'''Non-finite series of N-step Fibonacci numbers,
|
||||
defined by a recurrence relation.
|
||||
'''
|
||||
return unfoldr(recurrence(n))(
|
||||
take(n)(
|
||||
chain(
|
||||
[1],
|
||||
(2 ** i for i in count(0))
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
# recurrence :: Int -> [Int] -> Int
|
||||
def recurrence(n):
|
||||
'''Recurrence relation in Fibonacci and related series.
|
||||
'''
|
||||
def go(xs):
|
||||
h, *t = xs
|
||||
return h, t + [sum(take(n)(xs))]
|
||||
return go
|
||||
|
||||
|
||||
# ------------------------- TEST -------------------------
|
||||
# main :: IO ()
|
||||
def main():
|
||||
'''First 15 terms each n-step Fibonacci(n) series
|
||||
where n is drawn from [2..8]
|
||||
'''
|
||||
labels = "fibo tribo tetra penta hexa hepta octo nona deca"
|
||||
table = list(
|
||||
chain(
|
||||
[['lucas:'] + [
|
||||
str(x) for x in take(15)(A000032())]
|
||||
],
|
||||
map(
|
||||
lambda k, n: list(
|
||||
chain(
|
||||
[k + 'nacci:'],
|
||||
(
|
||||
str(x) for x
|
||||
in take(15)(nStepFibonacci(n))
|
||||
)
|
||||
)
|
||||
),
|
||||
labels.split(),
|
||||
count(2)
|
||||
)
|
||||
)
|
||||
)
|
||||
print('Recurrence relation series:\n')
|
||||
print(
|
||||
spacedTable(table)
|
||||
)
|
||||
|
||||
|
||||
# ----------------------- GENERIC ------------------------
|
||||
|
||||
# take :: Int -> [a] -> [a]
|
||||
# take :: Int -> String -> String
|
||||
def take(n):
|
||||
'''The prefix of xs of length n,
|
||||
or xs itself if n > length xs.
|
||||
'''
|
||||
def go(xs):
|
||||
return (
|
||||
xs[0:n]
|
||||
if isinstance(xs, (list, tuple))
|
||||
else list(islice(xs, n))
|
||||
)
|
||||
return go
|
||||
|
||||
|
||||
# unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
|
||||
def unfoldr(f):
|
||||
'''Generic anamorphism.
|
||||
A lazy (generator) list unfolded from a seed value by
|
||||
repeated application of f until no residue remains.
|
||||
Dual to fold/reduce.
|
||||
f returns either None, or just (value, residue).
|
||||
For a strict output value, wrap in list().
|
||||
'''
|
||||
def go(x):
|
||||
valueResidue = f(x)
|
||||
while None is not valueResidue:
|
||||
yield valueResidue[0]
|
||||
valueResidue = f(valueResidue[1])
|
||||
return go
|
||||
|
||||
|
||||
# ---------------------- FORMATTING ----------------------
|
||||
|
||||
# spacedTable :: [[String]] -> String
|
||||
def spacedTable(rows):
|
||||
columnWidths = [
|
||||
max([len(x) for x in col])
|
||||
for col in zip(*rows)
|
||||
]
|
||||
return '\n'.join([
|
||||
' '.join(
|
||||
map(
|
||||
lambda x, w: x.rjust(w, ' '),
|
||||
row, columnWidths
|
||||
)
|
||||
)
|
||||
for row in rows
|
||||
])
|
||||
|
||||
|
||||
# MAIN ---
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
[ 0 swap witheach + ] is sum ( [ --> n )
|
||||
|
||||
[ tuck size -
|
||||
dup 0 < iff
|
||||
[ split drop ]
|
||||
else
|
||||
[ dip [ dup size negate swap ]
|
||||
times
|
||||
[ over split
|
||||
dup sum join join ]
|
||||
nip ] ] is n-step ( n [ --> [ )
|
||||
|
||||
[ ' [ 1 1 ] n-step ] is fibonacci ( n --> [ )
|
||||
|
||||
[ ' [ 1 1 2 ] n-step ] is tribonacci ( n --> [ )
|
||||
|
||||
[ ' [ 1 1 2 4 ] n-step ] is tetranacci ( n --> [ )
|
||||
|
||||
[ ' [ 2 1 ] n-step ] is lucas ( n --> [ )
|
||||
|
||||
' [ fibonacci tribonacci tetranacci lucas ]
|
||||
witheach
|
||||
[ dup echo say ": " 10 swap do echo cr ]
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/*REXX program calculates and displays a N-step Fibonacci sequence(s). */
|
||||
parse arg FibName values /*allows a Fibonacci name, starter vals*/
|
||||
if FibName\='' then do; call nStepFib FibName,values; signal done; end
|
||||
/* [↓] no args specified, show a bunch*/
|
||||
call nStepFib 'Lucas' , 2 1
|
||||
call nStepFib 'fibonacci' , 1 1
|
||||
call nStepFib 'tribonacci' , 1 1 2
|
||||
call nStepFib 'tetranacci' , 1 1 2 4
|
||||
call nStepFib 'pentanacci' , 1 1 2 4 8
|
||||
call nStepFib 'hexanacci' , 1 1 2 4 8 16
|
||||
call nStepFib 'heptanacci' , 1 1 2 4 8 16 32
|
||||
call nStepFib 'octonacci' , 1 1 2 4 8 16 32 64
|
||||
call nStepFib 'nonanacci' , 1 1 2 4 8 16 32 64 128
|
||||
call nStepFib 'decanacci' , 1 1 2 4 8 16 32 64 128 256
|
||||
call nStepFib 'undecanacci' , 1 1 2 4 8 16 32 64 128 256 512
|
||||
call nStepFib 'dodecanacci' , 1 1 2 4 8 16 32 64 128 256 512 1024
|
||||
call nStepFib '13th-order' , 1 1 2 4 8 16 32 64 128 256 512 1024 2048
|
||||
done: exit /*stick a fork in it, we're all done. */
|
||||
/*────────────────────────────────────────────────────────────────────────────*/
|
||||
nStepFib: procedure; parse arg Fname,vals,m; if m=='' then m=30; L=
|
||||
N=words(vals)
|
||||
do pop=1 for N /*use N initial values. */
|
||||
@.pop=word(vals,pop) /*populate initial numbers*/
|
||||
end /*pop*/
|
||||
do j=1 for m /*calculate M Fib numbers.*/
|
||||
if j>N then do; @.j=0 /*initialize the sum to 0.*/
|
||||
do k=j-N for N /*sum the last N numbers.*/
|
||||
@.j=@.j+@.k /*add the [N-j]th number.*/
|
||||
end /*k*/
|
||||
end
|
||||
L=L @.j /*append Fib number──►list*/
|
||||
end /*j*/
|
||||
|
||||
say right(Fname,11)'[sum'right(N,3) "terms]:" strip(L) '···'
|
||||
return
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#lang racket
|
||||
|
||||
;; fib-list : [Listof Nat] x Nat -> [Listof Nat]
|
||||
;; Given a non-empty list of natural numbers, the length of the list
|
||||
;; becomes the size of the step; return the first n numbers of the
|
||||
;; sequence; assume n >= (length lon)
|
||||
(define (fib-list lon n)
|
||||
(define len (length lon))
|
||||
(reverse (for/fold ([lon (reverse lon)]) ([_ (in-range (- n len))])
|
||||
(cons (apply + (take lon len)) lon))))
|
||||
|
||||
;; Show the series ...
|
||||
(define (show-fibs name l)
|
||||
(printf "~a: " name)
|
||||
(for ([n (in-list (fib-list l 20))]) (printf "~a, " n))
|
||||
(printf "...\n"))
|
||||
|
||||
;; ... with initial 2-powers lists
|
||||
(for ([n (in-range 2 11)])
|
||||
(show-fibs (format "~anacci" (case n [(2) 'fibo] [(3) 'tribo] [(4) 'tetra]
|
||||
[(5) 'penta] [(6) 'hexa] [(7) 'hepta]
|
||||
[(8) 'octo] [(9) 'nona] [(10) 'deca]))
|
||||
(cons 1 (build-list (sub1 n) (curry expt 2)))))
|
||||
;; and with an initial (2 1)
|
||||
(show-fibs "lucas" '(2 1))
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
sub nacci ( $s = 2, :@start = (1,) ) {
|
||||
my @seq = |@start, { state $n = +@start; @seq[ ($n - $s .. $n++ - 1).grep: * >= 0 ].sum } … *;
|
||||
}
|
||||
|
||||
put "{.fmt: '%2d'}-nacci: ", nacci($_)[^20] for 2..12 ;
|
||||
|
||||
put "Lucas: ", nacci(:start(2,1))[^20];
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
sub fib ($n, @xs is copy = [1]) {
|
||||
flat gather {
|
||||
take @xs[*];
|
||||
loop {
|
||||
take my $x = [+] @xs;
|
||||
@xs.push: $x;
|
||||
@xs.shift if @xs > $n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for 2..10 -> $n {
|
||||
say fib($n, [1])[^20];
|
||||
}
|
||||
say fib(2, [2,1])[^20];
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
# Project : Fibonacci n-step number sequences
|
||||
|
||||
f = list(12)
|
||||
|
||||
see "Fibonacci:" + nl
|
||||
f2 = [1,1]
|
||||
for nr2 = 1 to 10
|
||||
see "" + f2[1] + " "
|
||||
fibn(f2)
|
||||
next
|
||||
showarray(f2)
|
||||
see " ..." + nl + nl
|
||||
|
||||
see "Tribonacci:" + nl
|
||||
f3 = [1,1,2]
|
||||
for nr3 = 1 to 9
|
||||
see "" + f3[1] + " "
|
||||
fibn(f3)
|
||||
next
|
||||
showarray(f3)
|
||||
see " ..." + nl + nl
|
||||
|
||||
see "Tetranacci:" + nl
|
||||
f4 = [1,1,2,4]
|
||||
for nr4 = 1 to 8
|
||||
see "" + f4[1] + " "
|
||||
fibn(f4)
|
||||
next
|
||||
showarray(f4)
|
||||
see " ..." + nl + nl
|
||||
|
||||
see "Lucas:" + nl
|
||||
f5 = [2,1]
|
||||
for nr5 = 1 to 10
|
||||
see "" + f5[1] + " "
|
||||
fibn(f5)
|
||||
next
|
||||
showarray(f5)
|
||||
see " ..." + nl + nl
|
||||
|
||||
func fibn(fs)
|
||||
s = sum(fs)
|
||||
for i = 2 to len(fs)
|
||||
fs[i-1] = fs[i]
|
||||
next
|
||||
fs[i-1] = s
|
||||
return fs
|
||||
|
||||
func sum(arr)
|
||||
sm = 0
|
||||
for sn = 1 to len(arr)
|
||||
sm = sm + arr[sn]
|
||||
next
|
||||
return sm
|
||||
|
||||
func showarray(fn)
|
||||
svect = ""
|
||||
for p = 1 to len(fn)
|
||||
svect = svect + fn[p] + " "
|
||||
next
|
||||
see svect
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
def anynacci(start_sequence, count)
|
||||
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
|
||||
(count-n).times do # Loop for the remaining results up to count
|
||||
result << result.last(n).sum # Get the last n element from result and append its total to Array
|
||||
end
|
||||
result
|
||||
end
|
||||
|
||||
naccis = { lucas: [2,1],
|
||||
fibonacci: [1,1],
|
||||
tribonacci: [1,1,2],
|
||||
tetranacci: [1,1,2,4],
|
||||
pentanacci: [1,1,2,4,8],
|
||||
hexanacci: [1,1,2,4,8,16],
|
||||
heptanacci: [1,1,2,4,8,16,32],
|
||||
octonacci: [1,1,2,4,8,16,32,64],
|
||||
nonanacci: [1,1,2,4,8,16,32,64,128],
|
||||
decanacci: [1,1,2,4,8,16,32,64,128,256] }
|
||||
|
||||
naccis.each {|name, seq| puts "%12s : %p" % [name, anynacci(seq, 15)]}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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]
|
||||
tribonacci : [1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136]
|
||||
tetranacci : [1, 1, 2, 4, 8, 15, 29, 56, 108, 208, 401, 773, 1490, 2872, 5536]
|
||||
pentanacci : [1, 1, 2, 4, 8, 16, 31, 61, 120, 236, 464, 912, 1793, 3525, 6930]
|
||||
hexanacci : [1, 1, 2, 4, 8, 16, 32, 63, 125, 248, 492, 976, 1936, 3840, 7617]
|
||||
heptanacci : [1, 1, 2, 4, 8, 16, 32, 64, 127, 253, 504, 1004, 2000, 3984, 7936]
|
||||
octonacci : [1, 1, 2, 4, 8, 16, 32, 64, 128, 255, 509, 1016, 2028, 4048, 8080]
|
||||
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]
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
a = fib(" fibonacci ", "1,1")
|
||||
a = fib("tribonacci ", "1,1,2")
|
||||
a = fib("tetranacci ", "1,1,2,4")
|
||||
a = fib(" pentanacc ", "1,1,2,4,8")
|
||||
a = fib(" hexanacci ", "1,1,2,4,8,16")
|
||||
a = fib(" lucas ", "2,1")
|
||||
|
||||
function fib(f$, s$)
|
||||
dim f(20)
|
||||
while word$(s$,b+1,",") <> ""
|
||||
b = b + 1
|
||||
f(b) = val(word$(s$,b,","))
|
||||
wend
|
||||
PRINT f$; "=>";
|
||||
for i = b to 13 + b
|
||||
print " "; f(i-b+1); ",";
|
||||
for j = (i - b) + 1 to i
|
||||
f(i+1) = f(i+1) + f(j)
|
||||
next j
|
||||
next i
|
||||
print
|
||||
end function
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
struct GenFibonacci {
|
||||
buf: Vec<u64>,
|
||||
sum: u64,
|
||||
idx: usize,
|
||||
}
|
||||
|
||||
impl Iterator for GenFibonacci {
|
||||
type Item = u64;
|
||||
fn next(&mut self) -> Option<u64> {
|
||||
let result = Some(self.sum);
|
||||
self.sum -= self.buf[self.idx];
|
||||
self.buf[self.idx] += self.sum;
|
||||
self.sum += self.buf[self.idx];
|
||||
self.idx = (self.idx + 1) % self.buf.len();
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
fn print(buf: Vec<u64>, len: usize) {
|
||||
let mut sum = 0;
|
||||
for &elt in buf.iter() { sum += elt; print!("\t{}", elt); }
|
||||
let iter = GenFibonacci { buf: buf, sum: sum, idx: 0 };
|
||||
for x in iter.take(len) {
|
||||
print!("\t{}", x);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fn main() {
|
||||
print!("Fib2:");
|
||||
print(vec![1,1], 10 - 2);
|
||||
|
||||
print!("\nFib3:");
|
||||
print(vec![1,1,2], 10 - 3);
|
||||
|
||||
print!("\nFib4:");
|
||||
print(vec![1,1,2,4], 10 - 4);
|
||||
|
||||
print!("\nLucas:");
|
||||
print(vec![2,1], 10 - 2);
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue