Program to find last two digits of Nth Fibonacci number

Given a number ‘n’, write a function that prints the last two digits of n-th (‘n’ can also be a large number) Fibonacci number.
Examples:

Input : n = 65
Output : 65

Input : n = 365
Output : 65

A simple solution is to find n-th Fibonacci number and print its last two digit. But N can be very large, so it wouldn’t work.
A better solution is to use the fact that after 300-th Fibonacci number last two digits starts repeating.
1) Find m = n % 300.
2) Return m-th Fibonacci number.

C++

// Program to find last two digits of n-th
// Fibonacci number
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

// Fills f[] with first 300 fibonacci numbers

void precomput(ll f[])
{

    /* 0th and 1st number of the series are 0 and 1*/

    f[0] = 0;

    f[1] = 1;

    /* Add the previous 2 numbers in the series

       and store last two digits of result */

    for (ll i = 2; i < 300; i++)

        f[i] = (f[i-1] + f[i-2])%100;
}

// Returns last two digits of n'th Fibonacci 
// Number

int findLastDigit(ll f[], int n)
{

    return f[n%300];
}

/* Driver program to test above function */

int main ()
{

    // Precomputing units digit of first 300

    // Fibonacci numbers

    ll f[300] = {0};

    precomput(f);
 
    ll n = 1;

    cout << findLastDigit(f, n) << endl;

    n = 61;

    cout << findLastDigit(f, n) << endl;

    n = 7;

    cout << findLastDigit(f, n) << endl;

    n = 67;

    cout << findLastDigit(f, n) << endl;

    return 0;
}

Java

// Program to find last two digits of 
// n-th Fibonacci number

import java.util.Arrays;

class GFG {

    // Fills f[] with first 300 

    // fibonacci numbers

    static void precomput(long f[])

    {

        /* 0th and 1st number of the

        series are 0 and 1*/

        f[0] = 0;

        f[1] = 1;

        /* Add the previous 2 numbers in 

        the series and store last two 

        digits of result */

        for (int i = 2; i < 300; i++)

            f[i] = (f[i-1] + f[i-2]) % 100;

    }

    // Returns last two digits of n'th

    // Fibonacci Number

    static long findLastDigit(long f[], int n)

    {

        return (f[(n%300)]);

    }

    /* Driver program to test above function */

    public static void main (String args[])

    {

        // Precomputing units digit of 

        // first 300 Fibonacci numbers

        long f[] = new long[300];

        Arrays.fill(f,0);

        precomput(f);

        int n = 1;

        System.out.println(findLastDigit(f, n));

        n = 61;

        System.out.println(findLastDigit(f, n));

        n = 7;

        System.out.println(findLastDigit(f, n));

        n = 67;

        System.out.println(findLastDigit(f, n));

    }
}
 
/*This code is contributed by Nikita Tiwari.*/

Python3

# Python code to find last two 
# digits of n-th Fibonacci number
 
def precomput(f):

    # 0th and 1st number of the series 

    # are 0 and 1

    f.append(0)

    f.append(1)

    # Add the previous 2 numbers in the series

    # and store last two digits of result

    for i in range(2,300):

        f.append((f[i-1] + f[i-2]) % 100)
 
# Returns last two digits of 
# n'th Fibonacci Number     

def findLastDigit(f,n):

    return f[n%300]

# driver code

f = list()
precomput(f)

n = 1

print(findLastDigit(f, n))

n = 61

print(findLastDigit(f, n))

n = 7

print(findLastDigit(f, n))

n = 67

print(findLastDigit(f, n))
 
# This code is contributed by "Abhishek Sharma 44"

// Program to find last two digits of 
// n-th Fibonacci number

using System;
 
class GFG {

    // Fills f[] with first 300 

    // fibonacci numbers

    static void precomput(long []f)

    {

        /* 0th and 1st number of the

        series are 0 and 1*/

        f[0] = 0;

        f[1] = 1;

        /* Add the previous 2 numbers in 

        the series and store last two 

        digits of result */

        for (int i = 2; i < 300; i++)

            f[i] = (f[i-1] + f[i-2]) % 100;

    }

    // Returns last two digits of n'th

    // Fibonacci Number

    static long findLastDigit(long []f, int n)

    {

        return (f[(n % 300)]);

    }

    /* Driver program to test above function */

    public static void Main ()

    {

        // Precomputing units digit of 

        // first 300 Fibonacci numbers

        long []f = new long[300];

        precomput(f);

        int n = 1;

        Console.WriteLine(findLastDigit(f, n));

        n = 61;

        Console.WriteLine(findLastDigit(f, n));

        n = 7;

        Console.WriteLine(findLastDigit(f, n));

        n = 67;

        Console.WriteLine(findLastDigit(f, n));

    }
}
 
// This code is contributed by anuj_67.

PHP

<?php
// Program to find last two 
// digits of n-th Fibonacci 
// number
 
// Fills f[] with first 
// 300 fibonacci numbers

function precomput()
{

    /* 0th and 1st number of

    the series are 0 and 1*/

    $f[0] = 0;

    $f[1] = 1;
 
    /* Add the previous 2 numbers 

    in the series and store last 

    two digits of result */

    for ($i = 2; $i < 300; $i++)

        $f[$i] = ($f[$i - 1] + 

                  $f[$i - 2]) % 100;

    return $f;
}
 
// Returns last two digits 
// of n'th Fibonacci Number

function findLastDigit($f, $n)
{

    return $f[$n % 300];
}
 
// Driver code
 
// Precomputing units digit 
// of first 300 Fibonacci numbers

$f = precomput();
 
$n = 1;

echo findLastDigit($f, $n) . "\n";

$n = 61;

echo findLastDigit($f, $n) . "\n";

$n = 7;

echo findLastDigit($f, $n) . "\n";

$n = 67;

echo findLastDigit($f, $n) . "\n";
 
// This code is contributed by mits.
?>

Javascript

<script>
 
// Program to find last two digits of n-th
// Fibonacci number
 
// Fills f[] with first 300 fibonacci numbers

function precomput(f)
{

    /* 0th and 1st number of the series are 0 and 1*/

    f[0] = 0;

    f[1] = 1;
 
    /* Add the previous 2 numbers in the series

    and store last two digits of result */

    for (let i = 2; i < 300; i++)

        f[i] = (f[i-1] + f[i-2])%100;
}
 
// Returns last two digits of n'th Fibonacci
// Number

function findLastDigit(f, n)
{

    return f[n%300];
}
 
/* Driver program to test above function */
 
    // Precomputing units digit of first 300

    // Fibonacci numbers

    let f = new Uint8Array(300);

    precomput(f);
 
    let n = 1;

    document.write(findLastDigit(f, n) + "<br>");

    n = 61;

    document.write(findLastDigit(f, n) + "<br>");

    n = 7;

    document.write(findLastDigit(f, n) + "<br>");

    n = 67;

    document.write(findLastDigit(f, n) + "<br>");

// This code is contributed by Mayank Tyagi
 
</script>

Output:

Time Complexity: O(300), it will run in constant time.
Auxiliary Space: O(300), no extra space is required, so it is a constant.

Approach 2: Iterative Approach:

In this implementation, we simply iterate through the Fibonacci sequence up to the n-th number, keeping track of the last two digits of each number using the modulo operator. This allows us to compute the last two digits of even large Fibonacci numbers without needing to store all of the previous numbers in the sequence.

Here Are steps of this approach:

We start by initializing the first two terms of the sequence to 0 and 1 respectively. Then, for each i from 2 to n, we calculate the ith Fibonacci number by adding the (i-1)th and (i-2)th Fibonacci numbers.
In each iteration, we keep track of the previous two Fibonacci numbers using two variables, prev and curr. Initially, prev is set to 0 and curr is set to 1. In each iteration, we update prev to curr and curr to the sum of prev and curr. After n iterations, the value of curr is the nth Fibonacci number.
This approach has a time complexity of O(n) and a space complexity of O(1) since we only need to store two variables at any given time. This makes it more efficient than the recursive approach, which has a time complexity of O(2^n) and a space complexity of O(n). However, the iterative approach can be harder to understand than the recursive approach for some people, as it involves more explicit manipulation of variables and requires a good understanding of loops and basic arithmetic operations.

C++

#include <bits/stdc++.h>

using namespace std;
 
// Function to find last two digits of the n-th Fibonacci number

int findLastTwoDigits(int n) {

    int a = 0, b = 1;

    if (n == 0)

        return a;

    if (n == 1)

        return b;
 
    for (int i = 2; i <= n; i++) {

        int c = (a + b) % 100;

        a = b;

        b = c;

    }

    return b;
}
 
int main() {

    int n = 1;

    cout << findLastTwoDigits(n) << endl;

    n = 61;

    cout << findLastTwoDigits(n) << endl;

    n = 7;

    cout << findLastTwoDigits(n) << endl;

    n = 67;

    cout << findLastTwoDigits(n) << endl;

    return 0;
}

Java

import java.util.*;
 
public class LastTwoDigitsFibonacci {

    // Function to find last two digits of n-th Fibonacci number

    public static int findLastDigit(int n) {

        int f1 = 0, f2 = 1, f3;

        // Iterate till n-1

        for (int i = 1; i < n; i++) {

            f3 = (f1 + f2) % 100;

            f1 = f2;

            f2 = f3;

        }

        // Return last two digits of n-th Fibonacci number

        return f2;

    }
 
    // Driver code

    public static void main(String[] args) {

        int n = 1;

        System.out.println(findLastDigit(n));

        n = 61;

        System.out.println(findLastDigit(n));

        n = 7;

        System.out.println(findLastDigit(n));

        n = 67;

        System.out.println(findLastDigit(n));

    }
}

Python3

# Program to find last two digits of n-th
# Fibonacci number

import math
 
# Returns last two digits of n'th Fibonacci
# Number

def findLastDigit(n):

    a = 0

    b = 1

    if (n <= 1):

        return n

    else:

        for i in range(2, n + 1):

            c = (a + b) % 100

            a = b

            b = c

        return b
 
# Driver program to test above function

n = 1

print(findLastDigit(n))

n = 61

print(findLastDigit(n))

n = 7

print(findLastDigit(n))

n = 67

print(findLastDigit(n))

using System;
 
class Program
{

    static int FindLastDigit(int n)

    {

        int a = 0, b = 1, c;

        for (int i = 2; i <= n; i++)

        {

            c = (a + b) % 100;

            a = b;

            b = c;

        }

        return b;

    }
 
    static void Main(string[] args)

    {

        int n = 1;

        Console.WriteLine(FindLastDigit(n));

        n = 61;

        Console.WriteLine(FindLastDigit(n));

        n = 7;

        Console.WriteLine(FindLastDigit(n));

        n = 67;

        Console.WriteLine(FindLastDigit(n));

    }
}

Javascript

function findLastTwoDigits(n) {

    let a = 0, b = 1;

    if (n === 0)

        return a;

    if (n === 1)

        return b;
 
    for (let i = 2; i <= n; i++) {

        let c = (a + b) % 100;

        a = b;

        b = c;

    }

    return b;
}
 
console.log(findLastTwoDigits(1));
console.log(findLastTwoDigits(61));
console.log(findLastTwoDigits(7));
console.log(findLastTwoDigits(67));

Output

Time Complexity: O(N).
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Article Tags :

DSA

Mathematical

Misc

Fibonacci