Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Number formed by adding product of its max and min digit K times

  • Difficulty Level : Expert
  • Last Updated : 04 May, 2021

Given two integers N and K, the task is to print the number formed by adding product of its max and min digit, K times. 
M(N+1) = M(N) + maxDigit(M(N)) * minDigit(M(N))

Examples 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Input: N = 14, K = 3 
Output: 26 
Explanation: 
M(0)=14 
M(1)=14 + 1*4 = 18 
M(2)=18 + 1*8 = 26 

Input: N = 487, K = 100000000 
Output: 950 
 



Approach  

  • A natural intuition is to run a loop K times and keep updating the value of N.
  • But one observation can be observed that after some iteration minimum value of digit may be zero and after that N is never going to be updated because:

M(N + 1) = M(N) + 0*(max_digit) 
M(N + 1) = M(N) 
 

  • Hence we just need to figure out when minimum digit became 0. 

Below is the implementation of the above approach: 

C++




// C++ Code for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// function that returns the product of
// maximum and minimum digit of N number.
int prod_of_max_min(int n)
{
    int largest = 0;
    int smallest = 10;
 
    while (n) {
 
        // finds the last digit.
        int r = n % 10;
 
        largest = max(r, largest);
        smallest = min(r, smallest);
 
        // Moves to next digit
        n = n / 10;
    }
 
    return largest * smallest;
}
 
// Function to find the formed number
int formed_no(int N, int K)
{
 
    if (K == 1) {
        return N;
    }
    K--; // M(1) = N
 
    int answer = N;
    while (K--) {
 
        int a_current
            = prod_of_max_min(answer);
 
        // check if minimum digit is 0
        if (a_current == 0)
            break;
 
        answer += a_current;
    }
 
    return answer;
}
 
// Driver Code
int main()
{
 
    int N = 487, K = 100000000;
 
    cout << formed_no(N, K) << endl;
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
     
// Function to find the formed number
public static int formed_no(int N, int K)
{
    if (K == 1)
    {
        return N;
    }
    K--; // M(1) = N
 
    int answer = N;
    while(K != 0)
    {
        int a_current = prod_of_max_min(answer);
 
        // Check if minimum digit is 0
        if (a_current == 0)
            break;
         
        answer += a_current;
    }
    return answer;
}
 
// Function that returns the product of
// maximum and minimum digit of N number.
static int prod_of_max_min(int n)
{
    int largest = 0;
    int smallest = 10;
 
    while(n != 0)
    {
 
        // Finds the last digit.
        int r = n % 10;
 
        largest = Math.max(r, largest);
        smallest = Math.min(r, smallest);
 
        // Moves to next digit
        n = n / 10;
    }
    return largest * smallest;
}
     
// Driver code
public static void main(String[] args)
{
    int N = 487, K = 100000000;
 
    System.out.println(formed_no(N, K));
}
}
 
// This code is contributed by coder001

Python3




# Python3 program for the above approach
 
# Function to find the formed number
def formed_no(N, K):
 
    if (K == 1):
        return N
    K -= 1 # M(1) = N
     
    answer = N
    while (K != 0):
 
        a_current = prod_of_max_min(answer)
 
        # Check if minimum digit is 0
        if (a_current == 0):
            break
 
        answer += a_current
        K -= 1
 
    return answer
 
# Function that returns the product of
# maximum and minimum digit of N number.
def prod_of_max_min(n):
 
    largest = 0
    smallest = 10
 
    while (n != 0):
 
        # Find the last digit.
        r = n % 10
 
        largest = max(r, largest)
        smallest = min(r, smallest)
 
        # Moves to next digit
        n = n // 10
 
    return largest * smallest
 
# Driver Code
if __name__ == "__main__":
 
    N = 487
    K = 100000000
 
    print(formed_no(N, K))
 
# This code is contributed by chitranayal

C#




// C# program for the above approach
using System;
 
class GFG {
     
// Function to find the formed number
public static int formed_no(int N, int K)
{
    if (K == 1)
    {
        return N;
    }
    K--; // M(1) = N
 
    int answer = N;
    while(K != 0)
    {
        int a_current = prod_of_max_min(answer);
 
        // Check if minimum digit is 0
        if (a_current == 0)
            break;
         
        answer += a_current;
    }
    return answer;
}
 
// Function that returns the product of
// maximum and minimum digit of N number.
static int prod_of_max_min(int n)
{
    int largest = 0;
    int smallest = 10;
 
    while(n != 0)
    {
 
        // Finds the last digit.
        int r = n % 10;
 
        largest = Math.Max(r, largest);
        smallest = Math.Min(r, smallest);
 
        // Moves to next digit
        n = n / 10;
    }
    return largest * smallest;
}
     
// Driver code
public static void Main(String[] args)
{
    int N = 487, K = 100000000;
 
    Console.WriteLine(formed_no(N, K));
}
}
 
// This code is contributed by Rohit_ranjan

Javascript




<script>
 
// JavaScript Code for the above approach
 
// Function that returns the product of
// maximum and minimum digit of N number.
function prod_of_max_min(n)
{
    var largest = 0;
    var smallest = 10;
     
    while (n)
    {
         
        // Finds the last digit.
        var r = n % 10;
         
        largest = Math.max(r, largest);
        smallest = Math.min(r, smallest);
         
        // Moves to next digit
        n = parseInt(n / 10);
    }
    return largest * smallest;
}
 
// Function to find the formed number
function formed_no(N, K)
{
    if (K == 1)
    {
        return N;
    }
    K--; // M(1) = N
     
    var answer = N;
     
    while (K--)
    {
        var a_current = prod_of_max_min(answer);
         
        // Check if minimum digit is 0
        if (a_current == 0) break;
         
        answer += a_current;
    }
    return answer;
}
 
// Driver Code
var N = 487,
K = 100000000;
 
document.write(formed_no(N, K) + "<br>");
 
// This code is contributed by rdtank
 
</script>
Output: 
950

 

Time Complexity: O(K) 
Auxiliary Space: O(1)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!