Given a number N, the task is to print the maximum between the sum and multiplication of the digits of the given number until the number is reduced to a single digit.
Note: Sum and multiplication of digits to be done until the number is reduced to a single digit.
Let’s take an example where N = 19,
19 breaks into 1+9=10 then 10 breaks into 1+0=1. 1 is a single digit sum.
Also, 19 breaks into 1*9 = 9. 9 is a single digit multiplication.
So, output is 9 i.e. maximum of 9 and 1.
Input: N = 631 Output: 8 Input: 110 Output: 2
Approach:
- Check if a number is less than 10 then the sum and product will be the same. So, return that number.
- Else,
- Find the sum of digits repeatedly using Method 2 of Finding sum of digits of a number until sum becomes single digit.
- And, Find the product of digits repeatedly using Method 1 of Finding sum of digits of a number until sum becomes single digit.
- Return the maximum of both.
Below is the implementation of above approach:
// CPP implementation of above approach #include<bits/stdc++.h> using namespace std;
// Function to sum the digits until it
// becomes a single digit
long repeatedSum( long n)
{
if (n == 0)
return 0;
return (n % 9 == 0) ? 9 : (n % 9);
}
// Function to product the digits until it
// becomes a single digit
long repeatedProduct( long n)
{
long prod = 1;
// Loop to do sum while
// sum is not less than
// or equal to 9
while (n > 0 || prod > 9) {
if (n == 0) {
n = prod;
prod = 1;
}
prod *= n % 10;
n /= 10;
}
return prod;
}
// Function to find the maximum among
// repeated sum and repeated product
long maxSumProduct( long N)
{
if (N < 10)
return N;
return max(repeatedSum(N), repeatedProduct(N));
}
// Driver code
int main()
{
long n = 631;
cout << maxSumProduct(n)<<endl;
return 0;
}
// This code is contributed by mits |
// Java implementation of above approach import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
// Function to sum the digits until it
// becomes a single digit
public static long repeatedSum( long n)
{
if (n == 0 )
return 0 ;
return (n % 9 == 0 ) ? 9 : (n % 9 );
}
// Function to product the digits until it
// becomes a single digit
public static long repeatedProduct( long n)
{
long prod = 1 ;
// Loop to do sum while
// sum is not less than
// or equal to 9
while (n > 0 || prod > 9 ) {
if (n == 0 ) {
n = prod;
prod = 1 ;
}
prod *= n % 10 ;
n /= 10 ;
}
return prod;
}
// Function to find the maximum among
// repeated sum and repeated product
public static long maxSumProduct( long N)
{
if (N < 10 )
return N;
return Math.max(repeatedSum(N), repeatedProduct(N));
}
// Driver code
public static void main(String[] args)
{
long n = 631 ;
System.out.println(maxSumProduct(n));
}
} |
# Python 3 implementation of above approach # Function to sum the digits until # it becomes a single digit def repeatedSum(n):
if (n = = 0 ):
return 0
return 9 if (n % 9 = = 0 ) else (n % 9 )
# Function to product the digits # until it becomes a single digit def repeatedProduct(n):
prod = 1
# Loop to do sum while
# sum is not less than
# or equal to 9
while (n > 0 or prod > 9 ) :
if (n = = 0 ) :
n = prod
prod = 1
prod * = n % 10
n / / = 10
return prod
# Function to find the maximum among # repeated sum and repeated product def maxSumProduct(N):
if (N < 10 ):
return N
return max (repeatedSum(N),
repeatedProduct(N))
# Driver code if __name__ = = "__main__" :
n = 631
print (maxSumProduct(n))
# This code is contributed # by ChitraNayal |
// C# implementation of // above approach using System;
class GFG
{ // Function to sum the digits // until it becomes a single digit public static long repeatedSum( long n)
{ if (n == 0)
return 0;
return (n % 9 == 0) ?
9 : (n % 9);
} // Function to product the digits // until it becomes a single digit public static long repeatedProduct( long n)
{ long prod = 1;
// Loop to do sum while
// sum is not less than
// or equal to 9
while (n > 0 || prod > 9)
{
if (n == 0)
{
n = prod;
prod = 1;
}
prod *= n % 10;
n /= 10;
}
return prod;
} // Function to find the maximum among // repeated sum and repeated product public static long maxSumProduct( long N)
{ if (N < 10)
return N;
return Math.Max(repeatedSum(N),
repeatedProduct(N));
} // Driver code public static void Main()
{ long n = 631;
Console.WriteLine(maxSumProduct(n));
} } // This code is contributed // by inder_verma |
<script> // javascript implementation of above approach // Function to sum the digits until it
// becomes a single digit
function repeatedSum(n) {
if (n == 0)
return 0;
return (n % 9 == 0) ? 9 : (n % 9);
}
// Function to product the digits until it
// becomes a single digit
function repeatedProduct(n) {
var prod = 1;
// Loop to do sum while
// sum is not less than
// or equal to 9
while (n > 0 || prod > 9) {
if (n == 0) {
n = prod;
prod = 1;
}
prod *= n % 10;
n = parseInt(n/10);
}
return prod;
}
// Function to find the maximum among
// repeated sum and repeated product
function maxSumProduct(N) {
if (N < 10)
return N;
return Math.max(repeatedSum(N), repeatedProduct(N));
}
// Driver code
var n = 631;
document.write(maxSumProduct(n));
// This code contributed by aashish1995 </script> |
8
Time Complexity: O(log10n)
Auxiliary Space: O(1)