由当前项与其最大和最小数字的乘积组成的序列的第N个项

给定两个数字N和K ，其中K表示序列的起始项。任务是找到由当前项与当前项的最大位数和最小位数之和构成的序列的第N个项，即

A_N+1 = A_N + max(digits of A_N) * min(digits of A_N)

例子：

Input: K = 1, N = 5 
Output: 50 
Explanation: 
A₁ = 1 
A₂ = A₁ + minDigit( A₁ ) * maxDigit( A₁ ) = 1 + min(1) * max(1) = 1 + 1*1 = 2 
A₃ = A₂ + minDigit( A₂ ) * maxDigit( A₂ ) = 2 + min(2) * max(2) = 2 + 2*2 = 6 
A₄ = A₃ + minDigit( A₃ ) * maxDigit( A₃ ) = 6 + min(6) * max(6) = 6 + 6*6 = 42 
A₅ = A₄ + minDigit( A₄ ) * maxDigit( A₄ ) = 42 + min(4, 2) * max(4, 2) = 42 + 2*4 = 50
Input: K = 487, N = 2 
Output: 519 
Explanation: 
A₁ = 487 
A₂ = A₁ + minDigit( A₁ ) * maxDigit( a₁ ) = 487 + min(4, 8, 7) * max(4, 8, 7) = 487 + 4*8 = 519 
 

方法：
让我们尝试看看一些观察，

When K = 1, the sequence becomes: 1, 2, 6, 42, 50, 50, 50, … 
When K = 2, the sequence becomes: 2, 6, 42, 50, 50, 50, … 
. 
. 
When K = 5, the sequence becomes: 5, 30, 30, 30, 30, 30, … 
. 
. 
Similarly, When K = 10, the sequence becomes: 10, 10, 10, 10, 10, 10, … 
 

从上面的示例中可以看出，在整数中至少有一位数字变为0之后，该序列最终停止增加。如果任何一位数字变为0，则最小值将始终为0，此后，该序列中的所有整数保持不变。
因此，方法是找到序列的项，直到在当前项的数字中遇到任何0为止，
下面是上述方法的实现。

C++

// C++ program for the above approach.
 
#include 
using namespace std;
 
// Function to find integer
int find(int K, int N)
{
 
    // because 1st integer is K itself
    N--;
 
    while (N--) {
        int curr_term = K;
 
        // Initialize min_d and max_d
        int min_d = 9;
        int max_d = 0;
 
        while (curr_term > 0) {
            int r = curr_term % 10;
 
            // updating min_d and max_d
            min_d = min(min_d, r);
            max_d = max(max_d, r);
 
            curr_term = curr_term / 10;
        }
 
        // break if min digit is 0
        if (min_d == 0) {
            break;
        }
 
        K = K + min_d * max_d;
    }
 
    return K;
}
 
// Driver code
int main()
{
    int K = 487;
    int N = 2;
 
    cout << find(K, N) << endl;
 
    return 0;
}

Java

// Java program for the above approach.
import java.util.*;
 
class GFG{
 
// Function to find integer
static int find(int K, int N)
{
 
    // Because 1st integer is K itself
    N--;
 
    while (N-- != 0)
    {
        int curr_term = K;
 
        // Initialize min_d and max_d
        int min_d = 9;
        int max_d = 0;
 
        while (curr_term > 0)
        {
            int r = curr_term % 10;
 
            // Updating min_d and max_d
            min_d = Math.min(min_d, r);
            max_d = Math.max(max_d, r);
 
            curr_term = curr_term / 10;
        }
 
        // Break if min digit is 0
        if (min_d == 0)
        {
            break;
        }
        K = K + min_d * max_d;
    }
    return K;
}
 
// Driver code
public static void main(String[] args)
{
    int K = 487;
    int N = 2;
 
    System.out.print(find(K, N) + "\n");
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program for the above approach.
 
# Function to find integer
def find(K, N):
     
    # Because 1st integer is K itself
    N = N - 1
     
    for i in range(0, N):
        curr_term = K
         
        # Initialize min_d and max_d
        min_d = 9
        max_d = 0
         
        while curr_term > 0:
            r = int(curr_term % 10)
             
            # Updating min_d and max_d
            min_d = min(min_d, r)
            max_d = max(max_d, r)
             
            curr_term = int(curr_term / 10)
         
        # Break if min digit is 0
        if min_d == 0:
           break
         
        K = K + min_d * max_d
        return K
 
# Driver code
K = 487
N = 2
 
print(find(K, N))
 
# This code is contributed by ishayadav181

C#

// C# program for the above approach.
using System;
 
class GFG{
 
// Function to find integer
static int find(int K, int N)
{
 
    // Because 1st integer is K itself
    N--;
 
    while (N-- != 0)
    {
        int curr_term = K;
 
        // Initialize min_d and max_d
        int min_d = 9;
        int max_d = 0;
 
        while (curr_term > 0)
        {
            int r = curr_term % 10;
 
            // Updating min_d and max_d
            min_d = Math.Min(min_d, r);
            max_d = Math.Max(max_d, r);
 
            curr_term = (int)(curr_term / 10);
        }
 
        // Break if min digit is 0
        if (min_d == 0)
        {
            break;
        }
 
        K = K + min_d * max_d;
    }
    return K;
}
 
// Driver code
public static void Main()
{
    int K = 487;
    int N = 2;
 
    Console.Write(find(K, N));
}
}
 
// This code is contributed by Code_Mech

Javascript

 
// JavaScript program for the above approach.
 
 
// Function to find integer
function find(K, N)
{
 
    // because 1st integer is K itself
    N--;
 
    while (N--) {
        let curr_term = K;
 
        // Initialize min_d and max_d
        let min_d = 9;
        let max_d = 0;
 
        while (curr_term > 0) {
            let r = curr_term % 10;
 
            // updating min_d and max_d
            min_d = Math.min(min_d, r);
            max_d = Math.max(max_d, r);
 
            curr_term = Math.floor(curr_term / 10);
        }
 
        // break if min digit is 0
        if (min_d == 0) {
            break;
        }
 
        K = K + min_d * max_d;
    }
 
    return K;
}
 
// Driver code
  
    let K = 487;
    let N = 2;
 
    document.write(find(K, N) + "<br>");
 
 
// This code is contributed by Surbhi Tyagi.
 

输出：

519

时间复杂度： O(N)