Leonardo Number
Last Updated :
28 Mar, 2023
The Leonardo numbers are a sequence of numbers given by the recurrence:
The first few Leonardo Numbers are 1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, ···
The Leonardo numbers are related to the Fibonacci numbers by below relation:
Given a number n, find n-th Leonardo number.
Examples:
Input : n = 0
Output : 1
Input : n = 3
Output : 5
A simple solution is to recursively compute values.
C++
#include <iostream>
using namespace std;
int leonardo( int n)
{
if (n == 0 || n == 1)
return 1;
return leonardo(n - 1) + leonardo(n - 2) + 1;
}
int main()
{
cout << leonardo(3);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int leonardo( int n)
{
if (n == 0 || n == 1 )
return 1 ;
return (leonardo(n - 1 ) + leonardo(n - 2 ) + 1 );
}
public static void main(String args[])
{
System.out.println(leonardo( 3 ));
}
}
|
Python3
def leonardo(n) :
if (n = = 0 or n = = 1 ) :
return 1
return (leonardo(n - 1 ) + leonardo(n - 2 ) + 1 );
print (leonardo( 3 ))
|
C#
using System;
class GFG {
static int leonardo( int n)
{
if (n == 0 || n == 1)
return 1;
return (leonardo(n - 1) + leonardo(n - 2) + 1);
}
public static void Main()
{
Console.WriteLine(leonardo(3));
}
}
|
PHP
<?php
function leonardo( $n )
{
if ( $n == 0 || $n == 1)
return 1;
return leonardo( $n - 1) +
leonardo( $n - 2) + 1;
}
echo leonardo(3);
?>
|
Javascript
<script>
function leonardo(n)
{
let dp = [];
dp[0] = dp[1] = 1;
for (let i = 2; i <= n; i++)
dp[i] = dp[i - 1] + dp[i - 2] + 1;
return dp[n];
}
document.write(leonardo(3));
</script>
|
Output :
5
Time Complexity: Exponential
Auxiliary Space: O(n) because the function call stack grows linearly with the input n. Each function call adds a new frame to the call stack, which contains local variables and the return address.
A better solution is to use dynamic programming.
C++
#include <iostream>
using namespace std;
int leonardo( int n)
{
int dp[n + 1];
dp[0] = dp[1] = 1;
for ( int i = 2; i <= n; i++)
dp[i] = dp[i - 1] + dp[i - 2] + 1;
return dp[n];
}
int main()
{
cout << leonardo(3);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int leonardo( int n)
{
int dp[] = new int [n + 1 ];
dp[ 0 ] = dp[ 1 ] = 1 ;
for ( int i = 2 ; i <= n; i++)
dp[i] = dp[i - 1 ] + dp[i - 2 ] + 1 ;
return dp[n];
}
public static void main(String[] args)
{
System.out.println(leonardo( 3 ));
}
}
|
Python3
def leonardo(n):
dp = [];
dp.append( 1 );
dp.append( 1 );
for i in range ( 2 , n + 1 ):
dp.append(dp[i - 1 ] +
dp[i - 2 ] + 1 );
return dp[n];
print (leonardo( 3 ));
|
C#
using System;
class GFG {
static int leonardo( int n)
{
int [] dp = new int [n + 1];
dp[0] = dp[1] = 1;
for ( int i = 2; i <= n; i++)
dp[i] = dp[i - 1] + dp[i - 2] + 1;
return dp[n];
}
public static void Main()
{
Console.WriteLine(leonardo(3));
}
}
|
PHP
<?php
function leonardo( $n )
{
$dp [0] = $dp [1] = 1;
for ( $i = 2; $i <= $n ; $i ++)
$dp [ $i ] = $dp [ $i - 1] +
$dp [ $i - 2] + 1;
return $dp [ $n ];
}
echo leonardo(3);
?>
|
JavaScript
<script>
function leonardo(n)
{
var dp = Array.from({length: n+1}, (_, i) => 0);
dp[0] = dp[1] = 1;
for ( var i = 2; i <= n; i++)
dp[i] = dp[i - 1] + dp[i - 2] + 1;
return dp[n];
}
document.write(leonardo(3));
</script>
|
Output :
5
Time Complexity: O(n)
Auxiliary Space: O(n) where n is the input number. This is because dp array has been created of size n+1.
The best solution is to use relation with Fibonacci Numbers. We can find the n-th Fibonacci number in O(Log n) time [See method 4 of this]
C++
#include <iostream>
using namespace std;
void multiply( int F[2][2], int M[2][2])
{
int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void power( int F[2][2], int n)
{
int i;
int M[2][2] = { { 1, 1 }, { 1, 0 } };
for (i = 2; i <= n; i++)
multiply(F, M);
}
int fib( int n)
{
int F[2][2] = { { 1, 1 }, { 1, 0 } };
if (n == 0)
return 0;
power(F, n - 1);
return F[0][0];
}
int leonardo( int n)
{
if (n == 0 || n == 1)
return 1;
return 2 * fib(n + 1) - 1;
}
int main()
{
cout << leonardo(3);
return 0;
}
|
Java
class GFG {
static void multiply( int F[][], int M[][])
{
int x = F[ 0 ][ 0 ] * M[ 0 ][ 0 ] + F[ 0 ][ 1 ] * M[ 1 ][ 0 ];
int y = F[ 0 ][ 0 ] * M[ 0 ][ 1 ] + F[ 0 ][ 1 ] * M[ 1 ][ 1 ];
int z = F[ 1 ][ 0 ] * M[ 0 ][ 0 ] + F[ 1 ][ 1 ] * M[ 1 ][ 0 ];
int w = F[ 1 ][ 0 ] * M[ 0 ][ 1 ] + F[ 1 ][ 1 ] * M[ 1 ][ 1 ];
F[ 0 ][ 0 ] = x;
F[ 0 ][ 1 ] = y;
F[ 1 ][ 0 ] = z;
F[ 1 ][ 1 ] = w;
}
static void power( int F[][], int n)
{
int i;
int M[][] = { { 1 , 1 }, { 1 , 0 } };
for (i = 2 ; i <= n; i++)
multiply(F, M);
}
static int fib( int n)
{
int F[][] = { { 1 , 1 }, { 1 , 0 } };
if (n == 0 )
return 0 ;
power(F, n - 1 );
return F[ 0 ][ 0 ];
}
static int leonardo( int n)
{
if (n == 0 || n == 1 )
return 1 ;
return 2 * fib(n + 1 ) - 1 ;
}
public static void main(String args[])
{
System.out.println(leonardo( 3 ));
}
}
|
Python3
def multiply(F, M ) :
x = F[ 0 ][ 0 ] * M[ 0 ][ 0 ] + F[ 0 ][ 1 ] * M[ 1 ][ 0 ]
y = F[ 0 ][ 0 ] * M[ 0 ][ 1 ] + F[ 0 ][ 1 ] * M[ 1 ][ 1 ]
z = F[ 1 ][ 0 ] * M[ 0 ][ 0 ] + F[ 1 ][ 1 ] * M[ 1 ][ 0 ]
w = F[ 1 ][ 0 ] * M[ 0 ][ 1 ] + F[ 1 ][ 1 ] * M[ 1 ][ 1 ]
F[ 0 ][ 0 ] = x
F[ 0 ][ 1 ] = y
F[ 1 ][ 0 ] = z
F[ 1 ][ 1 ] = w
def power(F, n) :
M = [[ 1 , 1 ], [ 1 , 0 ] ]
for i in range ( 2 , n + 1 ) :
multiply(F, M)
def fib(n) :
F = [ [ 1 , 1 ], [ 1 , 0 ] ]
if (n = = 0 ) :
return 0
power(F, n - 1 )
return F[ 0 ][ 0 ]
def leonardo(n) :
if (n = = 0 or n = = 1 ) :
return 1
return ( 2 * fib(n + 1 ) - 1 )
print (leonardo( 3 ))
|
C#
using System;
class GFG {
static void multiply( int [, ] F, int [, ] M)
{
int x = F[0, 0] * M[0, 0] + F[0, 1] * M[1, 0];
int y = F[0, 0] * M[0, 1] + F[0, 1] * M[1, 1];
int z = F[1, 0] * M[0, 0] + F[1, 1] * M[1, 0];
int w = F[1, 0] * M[0, 1] + F[1, 1] * M[1, 1];
F[0, 0] = x;
F[0, 1] = y;
F[1, 0] = z;
F[1, 1] = w;
}
static void power( int [, ] F, int n)
{
int i;
int [, ] M = { { 1, 1 }, { 1, 0 } };
for (i = 2; i <= n; i++)
multiply(F, M);
}
static int fib( int n)
{
int [, ] F = { { 1, 1 }, { 1, 0 } };
if (n == 0)
return 0;
power(F, n - 1);
return F[0, 0];
}
static int leonardo( int n)
{
if (n == 0 || n == 1)
return 1;
return 2 * fib(n + 1) - 1;
}
public static void Main()
{
Console.WriteLine(leonardo(3));
}
}
|
PHP
<?php
function multiply(& $F , $M )
{
$x = $F [0][0] * $M [0][0] +
$F [0][1] * $M [1][0];
$y = $F [0][0] * $M [0][1] +
$F [0][1] * $M [1][1];
$z = $F [1][0] * $M [0][0] +
$F [1][1] * $M [1][0];
$w = $F [1][0] * $M [0][1] +
$F [1][1] * $M [1][1];
$F [0][0] = $x ;
$F [0][1] = $y ;
$F [1][0] = $z ;
$F [1][1] = $w ;
}
function power(& $F , $n )
{
$M = array ( array (1, 1), array (1, 0));
for ( $i = 2; $i <= $n ; $i ++)
multiply( $F , $M );
}
function fib( $n )
{
$F = array ( array (1, 1), array (1, 0));
if ( $n == 0)
return 0;
power( $F , $n - 1);
return $F [0][0];
}
function leonardo( $n )
{
if ( $n == 0 || $n == 1)
return 1;
return 2 * fib( $n + 1) - 1;
}
echo leonardo(3);
?>
|
Javascript
<script>
function multiply(F , M)
{
var x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
var y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
var z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
var w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
function power(F , n)
{
var i;
var M = [ [ 1, 1 ], [ 1, 0 ] ];
for (i = 2; i <= n; i++)
multiply(F, M);
}
function fib(n)
{
var F = [ [ 1, 1 ], [ 1, 0 ] ];
if (n == 0)
return 0;
power(F, n - 1);
return F[0][0];
}
function leonardo(n)
{
if (n == 0 || n == 1)
return 1;
return 2 * fib(n + 1) - 1;
}
document.write(leonardo(3));
</script>
|
Output :
5
Time Complexity : O(Log n)
Share your thoughts in the comments
Please Login to comment...