# Generate largest N digit number from 0 in K steps by incrementing X or multiplying by Y

• Difficulty Level : Medium
• Last Updated : 11 Jan, 2022

Given integers N, K, X and Y. The task is to find the maximum possible N-digit number in K steps starting from 0. Using the operations given below:

• Increment the value by X, or
• Multiply the value with Y

Examples:

Input: N = 2, K = 5, X = 2, Y = 3
Output: 72
Explanation: Sequence would be {0->2->6->8->24->72}

Input: N = 2, K = 10, X = 2, Y = 3
Output: 98
Explanation: Sequence would be
{0 -> 0 -> 0 -> 2 -> 6 -> 8 -> 10 -> 30 -> 32 -> 96 -> 98}.
Notice that the above mentioned sequence 0 is multiplied by 3 two times.
Another possible sequence is
{0 -> 0 -> 2 -> 4 -> 6 -> 8 -> 10 -> 30 -> 32 -> 96 -> 98}.

Input: N = 3 and K = 4
Output: -1
Explanation: Not possible to create 3-digit number in 4 steps

Approach: The problem can be solved using the concept of recursion. Follow the steps mentioned below:

1. For each recursive step exit the recursive call when:
• If the number of steps taken becomes greater than K, then the recursion must be stopped.
• If the count of digits of current number exceeds N, then there is no need to search on that branch.
• If the current number becomes equal to the maximum N-digit number that may be generated then there is no need for further processing. It will reduce the number extra recursive calls.
• Maximum possible N-digit number that may be generated at any moment is (10N – 1).
2. Now Recursively call for the method with current number incremented by X and current step incremented by 1.
3. Make another recursive call with current number multiplied by Y and current step incremented by 1.
4. Store both the results in a variable.
5. At any point of recursion, return the maximum of the two results stored in the variable.

Below is the implementation of the above approach

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// Function for generating largest` `//  N-digit number in K-steps.` `int` `largestNDigitNumber(``int` `N, ``int` `currentStep,` `                        ``int` `K, ``int` `X, ``int` `Y, ` `                        ``int` `currentValue)` `{` `    ``// Further processing is useless ` `    ``// ifcCurrent value already becomes equal ` `    ``// to largest N-digit number that` `    ``// can be generated` `    ``if` `(currentValue == ``pow``(10, N) - 1)` `        ``return` `currentValue;` `    `  `    ``// Return 0 steps taken is greater than K` `    ``// and also if N or K equal to Zero.` `    ``if` `(currentStep > K || N < 1 || K < 1)` `        ``return` `0;` `    `  `    ``// currentValue exceeds maxValue, ` `    ``// so there is no need to` `    ``// keep searching on that branch.` `    ``if` `(currentValue >= ``pow``(10, N))` `        ``return` `0;` `    `  `    ``// Recursive calls` `    ``int` `result2 = largestNDigitNumber(` `        ``N, currentStep + 1, K, X, Y, ` `        ``currentValue + X);` `    ``int` `result1 = largestNDigitNumber(` `        ``N, currentStep + 1, K, X, Y, ` `        ``currentValue * Y);` `    `  `    ``// If both the results are zero` `    ``// it means maximum is reached.` `    ``if` `(result1 == 0 && result2 == 0)` `        ``return` `currentValue;` `    `  `    ``// Checking for maximum of the two results.` `    ``return` `result1 > result2 ? result1 : result2;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 2, K = 10, X = 2, Y = 3;` `    ``int` `largest = largestNDigitNumber(` `        ``N, 0, K, X, Y, 0);` `    `  `    ``// Checking whether the returned result` `    ``//  is a N-digit number or not.` `    ``if` `(largest < ``pow``(10, (N - 1))) {` `        ``cout << (``"-1"``);` `    ``}` `    ``else` `        ``cout << largest;` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach` `import` `java.util.*;` `class` `GFG` `{`   `  ``// Function for generating largest` `  ``//  N-digit number in K-steps.` `  ``static` `int` `largestNDigitNumber(``int` `N, ``int` `currentStep,` `                                 ``int` `K, ``int` `X, ``int` `Y, ` `                                 ``int` `currentValue)` `  ``{`   `    ``// Further processing is useless ` `    ``// ifcCurrent value already becomes equal ` `    ``// to largest N-digit number that` `    ``// can be generated` `    ``if` `(currentValue == Math.pow(``10``, N) - ``1``)` `      ``return` `currentValue;`   `    ``// Return 0 steps taken is greater than K` `    ``// and also if N or K equal to Zero.` `    ``if` `(currentStep > K || N < ``1` `|| K < ``1``)` `      ``return` `0``;`   `    ``// currentValue exceeds maxValue, ` `    ``// so there is no need to` `    ``// keep searching on that branch.` `    ``if` `(currentValue >= Math.pow(``10``, N))` `      ``return` `0``;`   `    ``// Recursive calls` `    ``int` `result2 = largestNDigitNumber(` `      ``N, currentStep + ``1``, K, X, Y, ` `      ``currentValue + X);` `    ``int` `result1 = largestNDigitNumber(` `      ``N, currentStep + ``1``, K, X, Y, ` `      ``currentValue * Y);`   `    ``// If both the results are zero` `    ``// it means maximum is reached.` `    ``if` `(result1 == ``0` `&& result2 == ``0``)` `      ``return` `currentValue;`   `    ``// Checking for maximum of the two results.` `    ``return` `result1 > result2 ? result1 : result2;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``2``, K = ``10``, X = ``2``, Y = ``3``;` `    ``int` `largest = largestNDigitNumber(` `      ``N, ``0``, K, X, Y, ``0``);`   `    ``// Checking whether the returned result` `    ``//  is a N-digit number or not.` `    ``if` `(largest < Math.pow(``10``, (N - ``1``))) {` `      ``System.out.print(``"-1"``);` `    ``}` `    ``else` `      ``System.out.print(largest);` `  ``}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python code for the above approach`   `# Function for generating largest` `#  N-digit number in K-steps.` `def` `largestNDigitNumber(N, currentStep, K, X, Y, currentValue):`   `    ``# Further processing is useless` `    ``# ifcCurrent value already becomes equal` `    ``# to largest N-digit number that` `    ``# can be generated` `    ``if` `(currentValue ``=``=` `10` `*``*` `N ``-` `1``):` `        ``return` `currentValue`   `    ``# Return 0 steps taken is greater than K` `    ``# and also if N or K equal to Zero.` `    ``if` `(currentStep > K ``or` `N < ``1` `or` `K < ``1``):` `        ``return` `0`   `    ``# currentValue exceeds maxValue,` `    ``# so there is no need to` `    ``# keep searching on that branch.` `    ``if` `(currentValue >``=` `10` `*``*` `N):` `        ``return` `0`   `    ``# Recursive calls` `    ``result2 ``=` `largestNDigitNumber( N, currentStep ``+` `1``, K, X, Y, currentValue ``+` `X)` `    ``result1 ``=` `largestNDigitNumber( N, currentStep ``+` `1``, K, X, Y, currentValue ``*` `Y)`   `    ``# If both the results are zero` `    ``# it means maximum is reached.` `    ``if` `(result1 ``=``=` `0` `and` `result2 ``=``=` `0``):` `        ``return` `currentValue`   `    ``# Checking for maximum of the two results.` `    ``return` `result1 ``if` `result1 > result2 ``else` `result2`   `# Driver code` `N ``=` `2` `K ``=` `10` `X ``=` `2` `Y ``=` `3` `largest ``=` `largestNDigitNumber(N, ``0``, K, X, Y, ``0``)`   `# Checking whether the returned result` `#  is a N-digit number or not.` `if` `(largest < ``10` `*``*` `(N ``-` `1``)):` `    ``print``(``"-1"``)` `else``:` `    ``print``(largest)`   `# This code is contributed by Saurabh Jaiswal.`

## C#

 `// C# code to implement the approach` `using` `System;` `class` `GFG {`   `  ``// Function for generating largest` `  ``//  N-digit number in K-steps.` `  ``static` `int` `largestNDigitNumber(``int` `N, ``int` `currentStep,` `                                 ``int` `K, ``int` `X, ``int` `Y,` `                                 ``int` `currentValue)` `  ``{`   `    ``// Further processing is useless` `    ``// ifcCurrent value already becomes equal` `    ``// to largest N-digit number that` `    ``// can be generated` `    ``if` `(currentValue == Math.Pow(10, N) - 1)` `      ``return` `currentValue;`   `    ``// Return 0 steps taken is greater than K` `    ``// and also if N or K equal to Zero.` `    ``if` `(currentStep > K || N < 1 || K < 1)` `      ``return` `0;`   `    ``// currentValue exceeds maxValue,` `    ``// so there is no need to` `    ``// keep searching on that branch.` `    ``if` `(currentValue >= Math.Pow(10, N))` `      ``return` `0;`   `    ``// Recursive calls` `    ``int` `result2 = largestNDigitNumber(` `      ``N, currentStep + 1, K, X, Y, currentValue + X);` `    ``int` `result1 = largestNDigitNumber(` `      ``N, currentStep + 1, K, X, Y, currentValue * Y);`   `    ``// If both the results are zero` `    ``// it means maximum is reached.` `    ``if` `(result1 == 0 && result2 == 0)` `      ``return` `currentValue;`   `    ``// Checking for maximum of the two results.` `    ``return` `result1 > result2 ? result1 : result2;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int` `N = 2, K = 10, X = 2, Y = 3;` `    ``int` `largest = largestNDigitNumber(N, 0, K, X, Y, 0);`   `    ``// Checking whether the returned result` `    ``//  is a N-digit number or not.` `    ``if` `(largest < Math.Pow(10, (N - 1))) {` `      ``Console.Write(``"-1"``);` `    ``}` `    ``else` `      ``Console.Write(largest);` `  ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`98`

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

My Personal Notes arrow_drop_up
Related Articles