Número formado al sumar el producto de su dígito máximo y mínimo K veces

Dados dos números enteros N y K , la tarea es imprimir el número formado sumando el producto de su dígito máximo y mínimo, K veces. 

Ejemplos 

Entrada: N = 14, K = 3 
Salida: 26 
Explicación: 
M(0)=14 
M(1)=14 + 1*4 = 18 
M(2)=18 + 1*8 = 26 

Entrada: N = 487, K = 100000000 
Salida : 950 
 

Acercarse  

• Una intuición natural es ejecutar un bucle K veces y seguir actualizando el valor de N.
• Pero se puede observar una observación de que después de alguna iteración, el valor mínimo del dígito puede ser cero y después de eso, N nunca se actualizará porque:

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

• Por lo tanto, solo necesitamos averiguar cuándo el dígito mínimo se convirtió en 0. 

A continuación se muestra la implementación del enfoque anterior: 

// 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 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 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# 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

<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>

950

Complejidad temporal: O(K)  
Espacio auxiliar: O(1)