Fibonacci Coding
Last Updated :
17 Apr, 2023
Fibonacci coding encodes an integer into binary number using Fibonacci Representation of the number. The idea is based on Zeckendorf’s Theorem which states that every positive integer can be written uniquely as a sum of distinct non-neighboring Fibonacci numbers (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ……..).
The Fibonacci code word for a particular integer is exactly the integer’s Zeckendorf representation with the order of its digits reversed and an additional “1” appended to the end. The extra 1 is appended to indicate the end of code (Note that the code never contains two consecutive 1s as per Zeckendorf’s Theorem. The representation uses Fibonacci numbers starting from 1 (2’nd Fibonacci Number). So the Fibonacci Numbers used are 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 141, …….
Given a number n, print its Fibonacci code.
Examples:
Input: n = 1
Output: 11
1 is first Fibonacci number in this representation
and an extra 1 is appended at the end.
Input: n = 11
Output: 001011
11 is sum of 8 and 3. The last 1 represents extra 1
that is always added. A 1 before it represents 8. The
third 1 (from beginning) represents 3.
We strongly recommend you to minimize your browser and try this yourself first.
The following algorithm takes an integer as input and generates a string that stores Fibonacci Encoding.
Find the largest Fibonacci number f less than or equal to n. Say it is the i’th number in the Fibonacci series. The length of codeword for n will be i+3 characters (One for extra 1 appended at the end, One because i is an index, and one for ‘\0’). Assuming that the Fibonacci series is stored:
- Let f be the largest Fibonacci less than or equal to n, prepend ‘1’ in the binary string. This indicates usage of f in representation for n. Subtract f from n: n = n – f
- Else if f is greater than n, prepend ‘0’ to the binary string.
- Move to the Fibonacci number just smaller than f .
- Repeat until zero remainder (n = 0)
- Append an additional ‘1’ to the binary string. We obtain an encoding such that two consecutive 1s indicate the end of a number (and the start of the next).
Below is the implementation of above algorithm.
C++
#include <bits/stdc++.h>
using namespace std;
#define N 30
int fib[N];
int largestFiboLessOrEqual( int n)
{
fib[0] = 1;
fib[1] = 2;
int i;
for (i=2; fib[i-1]<=n; i++)
fib[i] = fib[i-1] + fib[i-2];
return (i-2);
}
char * fibonacciEncoding( int n)
{
int index = largestFiboLessOrEqual(n);
char *codeword = ( char *) malloc ( sizeof ( char )*(index+3));
int i = index;
while (n)
{
codeword[i] = '1' ;
n = n - fib[i];
i = i - 1;
while (i>=0 && fib[i]>n)
{
codeword[i] = '0' ;
i = i - 1;
}
}
codeword[index+1] = '1' ;
codeword[index+2] = '\0' ;
return codeword;
}
int main()
{
int n = 143;
cout << "Fibonacci code word for " <<n << " is " << fibonacciEncoding(n);
return 0;
}
|
C
#include<stdio.h>
#include<stdlib.h>
#define N 30
int fib[N];
int largestFiboLessOrEqual( int n)
{
fib[0] = 1;
fib[1] = 2;
int i;
for (i=2; fib[i-1]<=n; i++)
fib[i] = fib[i-1] + fib[i-2];
return (i-2);
}
char * fibonacciEncoding( int n)
{
int index = largestFiboLessOrEqual(n);
char *codeword = ( char *) malloc ( sizeof ( char )*(index+3));
int i = index;
while (n)
{
codeword[i] = '1' ;
n = n - fib[i];
i = i - 1;
while (i>=0 && fib[i]>n)
{
codeword[i] = '0' ;
i = i - 1;
}
}
codeword[index+1] = '1' ;
codeword[index+2] = '\0' ;
return codeword;
}
int main()
{
int n = 143;
printf ( "Fibonacci code word for %d is %s\n" , n, fibonacciEncoding(n));
return 0;
}
|
Java
import java.io.*;
class GFG{
public static int N = 30 ;
public static int [] fib = new int [N];
public static int largestFiboLessOrEqual( int n)
{
fib[ 0 ] = 1 ;
fib[ 1 ] = 2 ;
int i;
for (i = 2 ; fib[i - 1 ] <= n; i++)
{
fib[i] = fib[i - 1 ] + fib[i - 2 ];
}
return (i - 2 );
}
public static String fibonacciEncoding( int n)
{
int index = largestFiboLessOrEqual(n);
char [] codeword = new char [index + 3 ];
int i = index;
while (n > 0 )
{
codeword[i] = '1' ;
n = n - fib[i];
i = i - 1 ;
while (i >= 0 && fib[i] > n)
{
codeword[i] = '0' ;
i = i - 1 ;
}
}
codeword[index + 1 ] = '1' ;
codeword[index + 2 ] = '\0' ;
String string = new String(codeword);
return string;
}
public static void main(String[] args)
{
int n = 143 ;
System.out.println( "Fibonacci code word for " +
n + " is " + fibonacciEncoding(n));
}
}
|
Python3
N = 30
fib = [ 0 for i in range (N)]
def largestFiboLessOrEqual(n):
fib[ 0 ] = 1
fib[ 1 ] = 2
i = 2
while fib[i - 1 ] < = n:
fib[i] = fib[i - 1 ] + fib[i - 2 ]
i + = 1
return (i - 2 )
def fibonacciEncoding(n):
index = largestFiboLessOrEqual(n)
codeword = [ 'a' for i in range (index + 2 )]
i = index
while (n):
codeword[i] = '1'
n = n - fib[i]
i = i - 1
while (i > = 0 and fib[i] > n):
codeword[i] = '0'
i = i - 1
codeword[index + 1 ] = '1'
return "".join(codeword)
n = 143
print ( "Fibonacci code word for" , n,
"is" , fibonacciEncoding(n))
|
C#
using System;
class GFG{
public static int N = 30;
public static int [] fib = new int [N];
public static int largestFiboLessOrEqual( int n)
{
fib[0] = 1;
fib[1] = 2;
int i;
for (i = 2; fib[i - 1] <= n; i++)
{
fib[i] = fib[i - 1] + fib[i - 2];
}
return (i - 2);
}
public static String fibonacciEncoding( int n)
{
int index = largestFiboLessOrEqual(n);
char [] codeword = new char [index + 3];
int i = index;
while (n > 0)
{
codeword[i] = '1' ;
n = n - fib[i];
i = i - 1;
while (i >= 0 && fib[i] > n)
{
codeword[i] = '0' ;
i = i - 1;
}
}
codeword[index + 1] = '1' ;
codeword[index + 2] = '\0' ;
string str = new string (codeword);
return str;
}
static public void Main()
{
int n = 143;
Console.WriteLine( "Fibonacci code word for " +
n + " is " + fibonacciEncoding(n));
}
}
|
Javascript
<script>
let N = 30;
let fib = new Array(N);
function largestFiboLessOrEqual(n)
{
fib[0] = 1;
fib[1] = 2;
let i;
for (i = 2; fib[i - 1] <= n; i++)
{
fib[i] = fib[i - 1] + fib[i - 2];
}
return (i - 2);
}
function fibonacciEncoding(n)
{
let index = largestFiboLessOrEqual(n);
let codeword = new Array(index + 3);
let i = index;
while (n > 0)
{
codeword[i] = '1 ';
// Subtract f from n
n = n - fib[i];
// Move to Fibonacci just smaller than f
i = i - 1;
// Mark all Fibonacci > n as not used
// (0 bit), progress backwards
while (i >= 0 && fib[i] > n)
{
codeword[i] = ' 0 ';
i = i - 1;
}
}
// Additional ' 1 ' bit
codeword[index + 1] = ' 1 ';
codeword[index + 2] = ' \0';
let string =(codeword).join( "" );
return string;
}
let n = 143;
document.write( "Fibonacci code word for " +
n + " is " + fibonacciEncoding(n));
</script>
|
Output:
Fibonacci code word for 143 is 01010101011
Time complexity :- O(N)
Space complexity :- O(N+K)
Illustration
Field of application:
Data Processing & Compression – representing the data (which can be text, image, video…) in such a way that the space needed to store or transmit data is less than the size of input data. Statistical methods use variable-length codes, with the shorter codes assigned to symbols or group of symbols that have a higher probability of occurrence. If the codes are to be used over a noisy communication channel, their resilience to bit insertions, deletions and to bit-flips is of high importance.
Read more about the application here.
Share your thoughts in the comments
Please Login to comment...