Given the first two digits of a large number digit1 and digit2. Also given a number c and the length of the actual large number. The next n-2 digits of the large number are calculated using the formula digit[i] = ( digit[i – 1]*c + digit[i – 2] ) % 10. The task is to check whether the number formed is divisible by 41 or not.
Examples:
Input: digit1 = 1 , digit2 = 2 , c = 1 , n = 3
Output: YES
The number formed is 123
which is divisible by 41
Input: digit1 = 1 , digit2 = 4 , c = 6 , n = 3
Output: NO
A naive approach is to form the number using the given formula. Check if the number formed is divisible by 41 or not using % operator. But since the number is very large, it will not be possible to store such a large number.
Efficient Approach : All the digits are calculated using the given formula and then the associative property of multiplication and addition is used to check if it is divisible by 41 or not. A number is divisible by 41 or not means (number % 41) equals 0 or not.
Let X be the large number thus formed, which can be written as.
X = (digit[0] * 10^n-1) + (digit[1] * 10^n-2) + … + (digit[n-1] * 10^0)
X = ((((digit[0] * 10 + digit[1]) * 10 + digit[2]) * 10 + digit[3]) … ) * 10 + digit[n-1]
X % 41 = ((((((((digit[0] * 10 + digit[1]) % 41) * 10 + digit[2]) % 41) * 10 + digit[3]) % 41) … ) * 10 + digit[n-1]) % 41
Hence after all the digits are calculated, below algorithm is followed:
- Initialize the first digit to ans.
- Iterate for all n-1 digits.
- Compute ans at every ith step by (ans * 10 + digit[i]) % 41 using associative property.
- Check for the final value of ans if it divisible by 41 or not.
Below is the implementation of the above approach.
C++
#include <bits/stdc++.h>
using namespace std;
bool DivisibleBy41( int first, int second, int c, int n)
{
int digit[n];
digit[0] = first;
digit[1] = second;
for ( int i = 2; i < n; i++)
digit[i] = (digit[i - 1] * c + digit[i - 2]) % 10;
int ans = digit[0];
for ( int i = 1; i < n; i++)
ans = (ans * 10 + digit[i]) % 41;
if (ans % 41 == 0)
return true ;
else
return false ;
}
int main()
{
int first = 1, second = 2, c = 1, n = 3;
if (DivisibleBy41(first, second, c, n))
cout << "YES" ;
else
cout << "NO" ;
return 0;
}
|
C
#include <stdbool.h>
#include <stdio.h>
bool DivisibleBy41( int first, int second, int c, int n)
{
int digit[n];
digit[0] = first;
digit[1] = second;
for ( int i = 2; i < n; i++)
digit[i] = (digit[i - 1] * c + digit[i - 2]) % 10;
int ans = digit[0];
for ( int i = 1; i < n; i++)
ans = (ans * 10 + digit[i]) % 41;
if (ans % 41 == 0)
return true ;
else
return false ;
}
int main()
{
int first = 1, second = 2, c = 1, n = 3;
if (DivisibleBy41(first, second, c, n))
printf ( "YES" );
else
printf ( "NO" );
return 0;
}
|
Java
import java.io.*;
class GFG {
static boolean DivisibleBy41( int first, int second,
int c, int n)
{
int digit[] = new int [n];
digit[ 0 ] = first;
digit[ 1 ] = second;
for ( int i = 2 ; i < n; i++)
digit[i]
= (digit[i - 1 ] * c + digit[i - 2 ]) % 10 ;
int ans = digit[ 0 ];
for ( int i = 1 ; i < n; i++)
ans = (ans * 10 + digit[i]) % 41 ;
if (ans % 41 == 0 )
return true ;
else
return false ;
}
public static void main(String[] args)
{
int first = 1 , second = 2 , c = 1 , n = 3 ;
if (DivisibleBy41(first, second, c, n))
System.out.println( "YES" );
else
System.out.println( "NO" );
}
}
|
Python3
def DivisibleBy41(first,
second, c, n):
digit = [ 0 ] * n
digit[ 0 ] = first
digit[ 1 ] = second
for i in range ( 2 , n):
digit[i] = (digit[i - 1 ] * c +
digit[i - 2 ]) % 10
ans = digit[ 0 ]
for i in range ( 1 , n):
ans = (ans * 10 + digit[i]) % 41
if (ans % 41 = = 0 ):
return True
else :
return False
first = 1
second = 2
c = 1
n = 3
if (DivisibleBy41(first,
second, c, n)):
print ( "YES" )
else :
print ( "NO" )
|
C#
using System;
class GFG {
static bool DivisibleBy41( int first, int second, int c,
int n)
{
int [] digit = new int [n];
digit[0] = first;
digit[1] = second;
for ( int i = 2; i < n; i++)
digit[i]
= (digit[i - 1] * c + digit[i - 2]) % 10;
int ans = digit[0];
for ( int i = 1; i < n; i++)
ans = (ans * 10 + digit[i]) % 41;
if (ans % 41 == 0)
return true ;
else
return false ;
}
public static void Main()
{
int first = 1, second = 2, c = 1, n = 3;
if (DivisibleBy41(first, second, c, n))
Console.Write( "YES" );
else
Console.Write( "NO" );
}
}
|
PHP
<?php
function DivisibleBy41( $first , $second , $c , $n )
{
$digit [ $n ] = range(1, $n );
$digit [0] = $first ;
$digit [1] = $second ;
for ( $i = 2; $i < $n ; $i ++)
$digit [ $i ] = ( $digit [ $i - 1] * $c +
$digit [ $i - 2]) % 10;
$ans = $digit [0];
for ( $i = 1; $i < $n ; $i ++)
$ans = ( $ans * 10 + $digit [ $i ]) % 41;
if ( $ans % 41 == 0)
return true;
else
return false;
}
$first = 1;
$second = 2;
$c = 1;
$n = 3;
if (DivisibleBy41( $first , $second , $c , $n ))
echo "YES" ;
else
echo "NO" ;
?>
|
Javascript
<script>
function DivisibleBy41(first, second, c, n)
{
let digit = new Array(n).fill(0);
digit[0] = first;
digit[1] = second;
for (let i = 2; i < n; i++)
digit[i] = (digit[i - 1] * c +
digit[i - 2]) % 10;
let ans = digit[0];
for (let i = 1; i < n; i++)
ans = (ans * 10 +
digit[i]) % 41;
if (ans % 41 == 0)
return true ;
else
return false ;
}
let first = 1, second = 2, c = 1, n = 3;
if (DivisibleBy41(first, second, c, n))
document.write( "YES" );
else
document.write( "NO" );
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Approach: Alternating Digit Sum approach
- Calculate the first two digits of the large number.
- Calculate the remaining digits of the large number using the given formula: digit[i] = ( digit[i – 1]*c + digit[i – 2] ) % 10. Append each digit to a list of digits.
- Calculate the alternating sum of the digits starting from the rightmost digit: add the rightmost digit to the sum, subtract the next digit from the sum, add the next digit to the sum, and so on, alternating the sign of each term.
- Check if the alternating sum is divisible by 41. If yes, return “YES”; otherwise, return “NO”.
C++
#include <iostream>
#include <vector>
using namespace std;
string isDivisibleBy41( int digit1, int digit2, int c, int n)
{
vector< int > digits{ digit1, digit2 };
for ( int i = 2; i < n; i++) {
digits.push_back((digits[i - 1] * c + digits[i - 2])
% 10);
}
int sum = 0;
int sign = 1;
for ( int i = n - 1; i >= 0; i--) {
sum += sign * digits[i];
sign = -sign;
}
if (sum % 41 == 0) {
return "YES" ;
}
else {
return "NO" ;
}
}
int main()
{
int digit1 = 4;
int digit2 = 5;
int c = 3;
int n = 10;
string result = isDivisibleBy41(digit1, digit2, c, n);
cout << result << endl;
return 0;
}
|
Python3
def is_divisible_by_41(digit1, digit2, c, n):
digits = [digit1, digit2]
for i in range ( 2 , n):
digits.append((digits[i - 1 ] * c + digits[i - 2 ]) % 10 )
sum = 0
sign = 1
for i in range (n - 1 , - 1 , - 1 ):
sum + = sign * digits[i]
sign = - sign
if sum % 41 = = 0 :
return "YES"
else :
return "NO"
digit1 = 1
digit2 = 4
c = 6
n = 3
print (is_divisible_by_41(digit1, digit2, c, n))
|
Java
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args)
{
int digit1 = 4 ;
int digit2 = 5 ;
int c = 3 ;
int n = 10 ;
String result
= isDivisibleBy41(digit1, digit2, c, n);
System.out.println(result);
}
public static String
isDivisibleBy41( int digit1, int digit2, int c, int n)
{
List<Integer> digits = new ArrayList<>();
digits.add(digit1);
digits.add(digit2);
for ( int i = 2 ; i < n; i++) {
digits.add(
(digits.get(i - 1 ) * c + digits.get(i - 2 ))
% 10 );
}
int sum = 0 ;
int sign = 1 ;
for ( int i = n - 1 ; i >= 0 ; i--) {
sum += sign * digits.get(i);
sign = -sign;
}
if (sum % 41 == 0 ) {
return "YES" ;
}
else {
return "NO" ;
}
}
}
|
Javascript
function isDivisibleBy41(digit1, digit2, c, n) {
let digits = [digit1, digit2];
for (let i = 2; i < n; i++) {
digits.push((digits[i - 1] * c + digits[i - 2]) % 10);
}
let sum = 0;
let sign = 1;
for (let i = n - 1; i >= 0; i--) {
sum += sign * digits[i];
sign = -sign;
}
if (sum % 41 == 0) {
return "YES" ;
} else {
return "NO" ;
}
}
let digit1 = 4;
let digit2 = 5;
let c = 3;
let n = 10;
let result = isDivisibleBy41(digit1, digit2, c, n);
console.log(result);
|
C#
using System;
using System.Collections.Generic;
class MainClass {
public static string
IsDivisibleBy41( int digit1, int digit2, int c, int n)
{
List< int > digits = new List< int >();
digits.Add(digit1);
digits.Add(digit2);
for ( int i = 2; i < n; i++) {
digits.Add((digits[i - 1] * c + digits[i - 2])
% 10);
}
int sum = 0;
int sign = 1;
for ( int i = n - 1; i >= 0; i--) {
sum += sign * digits[i];
sign = -sign;
}
if (sum % 41 == 0) {
return "YES" ;
}
else {
return "NO" ;
}
}
public static void Main( string [] args)
{
int digit1 = 4;
int digit2 = 5;
int c = 3;
int n = 10;
string result
= IsDivisibleBy41(digit1, digit2, c, n);
Console.WriteLine(result);
}
}
|
The time complexity of the Alternating Digit Sum approach is O(n), where n is the length of the large number.
The auxiliary space of the approach is also O(n), as we need to store the list of digits.