Sunday, October 6, 2024
Google search engine
HomeData Modelling & AINumber formed by adding product of its max and min digit K...

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

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 

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)
 

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments