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
Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.
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++
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
void precomput(ll f[])
{
f[0] = 0;
f[1] = 1;
for (ll i = 2; i < 300; i++)
f[i] = (f[i-1] + f[i-2])%100;
}
int findLastDigit(ll f[], int n)
{
return f[n%300];
}
int main ()
{
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
import java.util.Arrays;
class GFG {
static void precomput( long f[])
{
f[ 0 ] = 0 ;
f[ 1 ] = 1 ;
for ( int i = 2 ; i < 300 ; i++)
f[i] = (f[i- 1 ] + f[i- 2 ]) % 100 ;
}
static long findLastDigit( long f[], int n)
{
return (f[(n% 300 )]);
}
public static void main (String args[])
{
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));
}
}
|
Python3
def precomput(f):
f.append( 0 )
f.append( 1 )
for i in range ( 2 , 300 ):
f.append((f[i - 1 ] + f[i - 2 ]) % 100 )
def findLastDigit(f,n):
return f[n % 300 ]
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))
|
C#
using System;
class GFG {
static void precomput( long []f)
{
f[0] = 0;
f[1] = 1;
for ( int i = 2; i < 300; i++)
f[i] = (f[i-1] + f[i-2]) % 100;
}
static long findLastDigit( long []f, int n)
{
return (f[(n % 300)]);
}
public static void Main ()
{
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));
}
}
|
PHP
<?php
function precomput()
{
$f [0] = 0;
$f [1] = 1;
for ( $i = 2; $i < 300; $i ++)
$f [ $i ] = ( $f [ $i - 1] +
$f [ $i - 2]) % 100;
return $f ;
}
function findLastDigit( $f , $n )
{
return $f [ $n % 300];
}
$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" ;
?>
|
Javascript
<script>
function precomput(f)
{
f[0] = 0;
f[1] = 1;
for (let i = 2; i < 300; i++)
f[i] = (f[i-1] + f[i-2])%100;
}
function findLastDigit(f, n)
{
return f[n%300];
}
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>" );
</script>
|
Output:
1
61
13
53
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;
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 {
public static int findLastDigit( int n) {
int f1 = 0 , f2 = 1 , f3;
for ( int i = 1 ; i < n; i++) {
f3 = (f1 + f2) % 100 ;
f1 = f2;
f2 = f3;
}
return f2;
}
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
import math
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
n = 1
print (findLastDigit(n))
n = 61
print (findLastDigit(n))
n = 7
print (findLastDigit(n))
n = 67
print (findLastDigit(n))
|
C#
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));
|
Time Complexity: O(N).
Auxiliary Space: O(1), no extra space is required, so it is a constant.
Please Login to comment...