Fibonacci Coding

18 Oct, 2021
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++
C
Java
Python3
C#
Javascript
/* C++ program for Fibonacci Encoding of a positive integer n */#include <bits/stdc++.h>using namespace std; // To limit on the largest Fibonacci number to be used#define N 30 /* Array to store fibonacci numbers.  fib[i] is going   to store (i+2)'th Fibonacci number*/int fib[N]; // Stores values in fib and returns index of the largest// fibonacci number smaller than n.int largestFiboLessOrEqual(int n){    fib[0] = 1;  // Fib[0] stores 2nd Fibonacci No.    fib[1] = 2;  // Fib[1] stores 3rd Fibonacci No.     // Keep Generating remaining numbers while previously    // generated number is smaller    int i;    for (i=2; fib[i-1]<=n; i++)        fib[i] = fib[i-1] + fib[i-2];     // Return index of the largest fibonacci number    // smaller than or equal to n. Note that the above    // loop stopped when fib[i-1] became larger.    return (i-2);} /* Returns pointer to the char string which corresponds to   code for n */char* fibonacciEncoding(int n){    int index = largestFiboLessOrEqual(n);     //allocate memory for codeword    char *codeword = (char*)malloc(sizeof(char)*(index+3));     // index of the largest Fibonacci f <= n    int i = index;     while (n)    {        // Mark usage of Fibonacci f (1 bit)        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';     //return pointer to codeword    return codeword;} /* driver function */int main(){    int n = 143;    cout <<"Fibonacci code word for " <<n <<" is " << fibonacciEncoding(n);         return 0;}// This code is contributed by shivanisinghss2110
/* C program for Fibonacci Encoding of a positive integer n */ #include<stdio.h>#include<stdlib.h> // To limit on the largest Fibonacci number to be used#define N 30 /* Array to store fibonacci numbers.  fib[i] is going   to store (i+2)'th Fibonacci number*/int fib[N]; // Stores values in fib and returns index of the largest// fibonacci number smaller than n.int largestFiboLessOrEqual(int n){    fib[0] = 1;  // Fib[0] stores 2nd Fibonacci No.    fib[1] = 2;  // Fib[1] stores 3rd Fibonacci No.     // Keep Generating remaining numbers while previously    // generated number is smaller    int i;    for (i=2; fib[i-1]<=n; i++)        fib[i] = fib[i-1] + fib[i-2];     // Return index of the largest fibonacci number    // smaller than or equal to n. Note that the above    // loop stopped when fib[i-1] became larger.    return (i-2);} /* Returns pointer to the char string which corresponds to   code for n */char* fibonacciEncoding(int n){    int index = largestFiboLessOrEqual(n);     //allocate memory for codeword    char *codeword = (char*)malloc(sizeof(char)*(index+3));     // index of the largest Fibonacci f <= n    int i = index;     while (n)    {        // Mark usage of Fibonacci f (1 bit)        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';     //return pointer to codeword    return codeword;} /* driver function */int main(){    int n = 143;    printf("Fibonacci code word for %d is %s\n", n, fibonacciEncoding(n));    return 0;}
// Java program for Fibonacci Encoding// of a positive integer nimport java.io.*; class GFG{     // To limit on the largest Fibonacci// number to be usedpublic static int N = 30; // Array to store fibonacci numbers.// fib[i] is going to store (i+2)'th// Fibonacci numberpublic static int[] fib = new int[N]; // Stores values in fib and returns index of// the largest fibonacci number smaller than n. public static int largestFiboLessOrEqual(int n){         // Fib[0] stores 2nd Fibonacci No.    fib[0] = 1;          // Fib[1] stores 3rd Fibonacci No.    fib[1] = 2;          // Keep Generating remaining numbers while    // previously generated number is smaller    int i;    for(i = 2; fib[i - 1] <= n; i++)    {        fib[i] = fib[i - 1] + fib[i - 2];    }         // Return index of the largest fibonacci    // number smaller than or equal to n.    // Note that the above loop stopped when    // fib[i-1] became larger.    return(i - 2);} // Returns pointer to the char string which// corresponds to code for npublic static String fibonacciEncoding(int n){    int index = largestFiboLessOrEqual(n);         // Allocate memory for codeword    char[] codeword = new char[index + 3];         // Index of the largest Fibonacci f <= n    int i = index;         while (n > 0)    {                 // Mark usage of Fibonacci f(1 bit)        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';    String string = new String(codeword);         // Return pointer to codeword    return string;} // Driver codepublic static void main(String[] args){    int n = 143;         System.out.println("Fibonacci code word for " +                       n + " is " + fibonacciEncoding(n));}} // This code is contributed by avanitrachhadiya2155
# Python3 program for Fibonacci Encoding# of a positive integer n # To limit on the largest# Fibonacci number to be usedN = 30 # Array to store fibonacci numbers.# fib[i] is going to store# (i+2)'th Fibonacci numberfib = [0 for i in range(N)] # Stores values in fib and returns index of# the largest fibonacci number smaller than n.def largestFiboLessOrEqual(n):    fib[0] = 1 # Fib[0] stores 2nd Fibonacci No.    fib[1] = 2 # Fib[1] stores 3rd Fibonacci No.     # Keep Generating remaining numbers while    # previously generated number is smaller    i = 2     while fib[i - 1] <= n:        fib[i] = fib[i - 1] + fib[i - 2]        i += 1     # Return index of the largest fibonacci number    # smaller than or equal to n. Note that the above    # loop stopped when fib[i-1] became larger.    return (i - 2) # Returns pointer to the char string which# corresponds to code for ndef fibonacciEncoding(n):    index = largestFiboLessOrEqual(n)     # allocate memory for codeword    codeword = ['a' for i in range(index + 2)]     # index of the largest Fibonacci f <= n    i = index     while (n):                 # Mark usage of Fibonacci f (1 bit)        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 and fib[i] > n):            codeword[i] = '0'            i = i - 1     # additional '1' bit    codeword[index + 1] = '1'     # return pointer to codeword    return "".join(codeword) # Driver Coden = 143print("Fibonacci code word for", n,         "is", fibonacciEncoding(n))          # This code is contributed by Mohit Kumar
// C# program for Fibonacci Encoding// of a positive integer nusing System; class GFG{     // To limit on the largest Fibonacci// number to be usedpublic static int N = 30; // Array to store fibonacci numbers.// fib[i] is going to store (i+2)'th// Fibonacci numberpublic static int[] fib = new int[N]; // Stores values in fib and returns index of// the largest fibonacci number smaller than n. public static int largestFiboLessOrEqual(int n){         // Fib[0] stores 2nd Fibonacci No.    fib[0] = 1;       // Fib[1] stores 3rd Fibonacci No.    fib[1] = 2;       // Keep Generating remaining numbers while    // previously generated number is smaller    int i;    for(i = 2; fib[i - 1] <= n; i++)    {        fib[i] = fib[i - 1] + fib[i - 2];    }         // Return index of the largest fibonacci    // number smaller than or equal to n.    // Note that the above loop stopped when    // fib[i-1] became larger.    return(i - 2);} // Returns pointer to the char string which// corresponds to code for npublic static String fibonacciEncoding(int n){    int index = largestFiboLessOrEqual(n);         // Allocate memory for codeword    char[] codeword = new char[index + 3];      // Index of the largest Fibonacci f <= n    int i = index;    while (n > 0)    {                 // Mark usage of Fibonacci f(1 bit)        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';    string str = new string(codeword);      // Return pointer to codeword    return str;} // Driver codestatic public void Main(){    int n = 143;         Console.WriteLine("Fibonacci code word for " +                      n + " is " + fibonacciEncoding(n));}} // This code is contributed by rag2127
<script>// Javascript program for Fibonacci Encoding// of a positive integer n         // To limit on the largest Fibonacci// number to be used    let N = 30;         // Array to store fibonacci numbers.// fib[i] is going to store (i+2)'th// Fibonacci number    let fib = new Array(N);              // Stores values in fib and returns index of// the largest fibonacci number smaller than n.    function largestFiboLessOrEqual(n)    {        // Fib[0] stores 2nd Fibonacci No.    fib[0] = 1;          // Fib[1] stores 3rd Fibonacci No.    fib[1] = 2;          // Keep Generating remaining numbers while    // previously generated number is smaller    let i;    for(i = 2; fib[i - 1] <= n; i++)    {        fib[i] = fib[i - 1] + fib[i - 2];    }          // Return index of the largest fibonacci    // number smaller than or equal to n.    // Note that the above loop stopped when    // fib[i-1] became larger.    return(i - 2);    }         // Returns pointer to the char string which// corresponds to code for n    function fibonacciEncoding(n)    {        let index = largestFiboLessOrEqual(n);          // Allocate memory for codeword    let codeword = new Array(index + 3);          // Index of the largest Fibonacci f <= n    let i = index;          while (n > 0)    {                  // Mark usage of Fibonacci f(1 bit)        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 pointer to codeword    return string;    }         // Driver code    let n = 143;    document.write("Fibonacci code word for " +                       n + " is " + fibonacciEncoding(n));         // This code is contributed by unknown2108</script>
Output:
Fibonacci code word for 143 is 01010101011
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.
This article is contributed by Yash Varyani. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
mohit kumar 29
avanitrachhadiya2155
rag2127
unknown2108
shivanisinghss2110
rochelledeulley
Fibonacci
Mathematical
Mathematical
Fibonacci
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.