Related Articles

# Largest number N which can be reduced to 0 in K steps

• Difficulty Level : Hard
• Last Updated : 11 May, 2021

Given an integer N. The following tasks are performed:

• The number is noted.
• The leading digit from N is subtracted from N and the resulting value is stored back in N.
• The new value of N is again noted.
• This process is continued till N becomes 0. Finally, 0 is noted down in the end.

For example, take N = 13. The numbers noted down in the process of reducing 13 to 0 will be:

• 13
• 13 – 1 = 12
• 12 – 1 = 11
• 11 – 1 = 10
• 10 – 1 = 9
• 9 – 9 = 0

Given an integer K, which is the total count of numbers noted down in the process of reducing a number N to 0 as described above, the task is to find the largest possible value of the starting number N.

Examples:

Input: k = 2
Output:
Explanation: Numbers noted = {9}

• Subtract Leading digit: 9 – 9 = 0. Numbers noted = {9, 0}

Input: k = 3
Output: 10
Explanation: Numbers noted = {10}

• Subtract Leading digit: 10 – 1 = 9. Numbers noted = {10, 9}
• Subtract Leading digit: 9 – 9 = 0. Numbers noted = {10, 9, 0}

Approach: The idea is to observe that the maximum possible value of N will always be less than 10*K. Therefore, the idea is to apply binary search in the range K to 10*K and to look for the greatest number which can be reduced to 0 in K steps.
To find the largest possible number:

1. Initialize left to k and right to k*10.
2. Initialize mid to (left + right) / 2.
3. Get the count of the number noted down to convert mid to 0 and store it in len.
4. Follow divide and conquer approach: While len is not equal to k
• Update the mid to the current (left + right) / 2.
• Get the count when starting with mid.
• If the count is greater than mid, update right to mid.
• Else, update left to mid.
5. Now, mid has one value which will result in k integers written down.
6. To find the largest such number:
• While the count is equal to k:
• If the current count is not equal to the count got by taking mid+1, break
• Else, keep incrementing mid by 1.
7. mid is now the largest possible integer if k integers are written down.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement above approach` `#include ``using` `namespace` `std;` `// Utility function to return the first``// digit of a number.``int` `firstDigit(``int` `n)``{``    ``// Remove last digit from number``    ``// till only one digit is left``    ``while` `(n >= 10) {``        ``n /= 10;``    ``}` `    ``// return the first digit``    ``return` `n;``}` `// Utility function that returns the count of numbers``// written down when starting from n``int` `getCount(``int` `n)``{``    ``int` `count = 1;` `    ``while` `(n != 0) {``        ``int` `leadDigit = firstDigit(n);``        ``n -= leadDigit;``        ``count++;``    ``}``    ``return` `count;``}` `// Function to find the largest number N which``// can be reduced to 0 in K steps``int` `getLargestNumber(``int` `k)``{``    ``int` `left = k;``    ``int` `right = k * 10;``    ``int` `mid = (left + right) / 2;` `    ``// Get the sequence length of the mid point``    ``int` `len = getCount(mid);` `    ``// Until k sequence length is reached``    ``while` `(len != k) {` `        ``// Update mid point``        ``mid = (left + right) / 2;` `        ``// Get count of the new mid point``        ``len = getCount(mid);` `        ``if` `(len > k) {` `            ``// Update right to mid``            ``right = mid;``        ``}``        ``else` `{` `            ``// Update left to mid``            ``left = mid;``        ``}``    ``}` `    ``// Increment mid point by one while count``    ``// is equal to k to get the maximum value``    ``// of mid point``    ``while` `(len == k) {` `        ``if` `(len != getCount(mid + 1)) {``            ``break``;``        ``}` `        ``mid++;``    ``}` `    ``return` `(mid);``}` `// Driver Code``int` `main()``{``    ``int` `k = 3;` `    ``cout << getLargestNumber(k);` `    ``return` `0;``}`

## Java

 `// Java program to implement above approach``import` `java.io.*;` `class` `GFG``{``    ` `// Utility function to return the first``// digit of a number.``static` `int` `firstDigit(``int` `n)``{``    ``// Remove last digit from number``    ``// till only one digit is left``    ``while` `(n >= ``10``)``    ``{``        ``n /= ``10``;``    ``}` `    ``// return the first digit``    ``return` `n;``}` `// Utility function that returns the count of numbers``// written down when starting from n``static` `int` `getCount(``int` `n)``{``    ``int` `count = ``1``;` `    ``while` `(n != ``0``)``    ``{``        ``int` `leadDigit = firstDigit(n);``        ``n -= leadDigit;``        ``count++;``    ``}``    ``return` `count;``}` `// Function to find the largest number N which``// can be reduced to 0 in K steps``static` `int` `getLargestNumber(``int` `k)``{``    ``int` `left = k;``    ``int` `right = k * ``10``;``    ``int` `mid = (left + right) / ``2``;` `    ``// Get the sequence length of the mid point``    ``int` `len = getCount(mid);` `    ``// Until k sequence length is reached``    ``while` `(len != k)``    ``{` `        ``// Update mid point``        ``mid = (left + right) / ``2``;` `        ``// Get count of the new mid point``        ``len = getCount(mid);` `        ``if` `(len > k)``        ``{` `            ``// Update right to mid``            ``right = mid;``        ``}``        ``else``        ``{` `            ``// Update left to mid``            ``left = mid;``        ``}``    ``}` `    ``// Increment mid point by one while count``    ``// is equal to k to get the maximum value``    ``// of mid point``    ``while` `(len == k)``    ``{` `        ``if` `(len != getCount(mid + ``1``))``        ``{``            ``break``;``        ``}` `        ``mid++;``    ``}` `    ``return` `(mid);``}` `    ``// Driver Code``    ``public` `static` `void` `main (String[] args)``    ``{` `        ``int` `k = ``3``;``        ``System.out.println (getLargestNumber(k));``    ``}``}` `// This code is contributed by jit_t`

## Python3

 `# Python3 program to implement above approach` `# Utility function to return the first``# digit of a number.``def` `firstDigit(n) :` `    ``# Remove last digit from number``    ``# till only one digit is left``    ``while` `(n >``=` `10``) :``        ``n ``/``/``=` `10``;``    ` `    ``# return the first digit``    ``return` `n;` `# Utility function that returns``# the count of numbers written``# down when starting from n``def` `getCount(n) :``    ` `    ``count ``=` `1``;` `    ``while` `(n !``=` `0``) :``        ``leadDigit ``=` `firstDigit(n);``        ``n ``-``=` `leadDigit;``        ``count ``+``=` `1``;``    ` `    ``return` `count;` `# Function to find the largest number N``# which can be reduced to 0 in K steps``def` `getLargestNumber(k) :` `    ``left ``=` `k;``    ``right ``=` `k ``*` `10``;``    ``mid ``=` `(left ``+` `right) ``/``/` `2``;` `    ``# Get the sequence length of the mid point``    ``length ``=` `getCount(mid);` `    ``# Until k sequence length is reached``    ``while` `(length !``=` `k) :` `        ``# Update mid point``        ``mid ``=` `(left ``+` `right) ``/``/` `2``;` `        ``# Get count of the new mid point``        ``length ``=` `getCount(mid);` `        ``if` `(length > k) :` `            ``# Update right to mid``            ``right ``=` `mid;``        ` `        ``else` `:` `            ``# Update left to mid``            ``left ``=` `mid;``        ` `    ``# Increment mid point by one while count``    ``# is equal to k to get the maximum value``    ``# of mid point``    ``while` `(length ``=``=` `k) :` `        ``if` `(length !``=` `getCount(mid ``+` `1``)) :``            ``break``;``        ` `        ``mid ``+``=` `1``;``    ` `    ``return` `mid;` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``k ``=` `3``;` `    ``print``(getLargestNumber(k));` `# This code is contributed by Ryuga`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `// Utility function to return the first``// digit of a number.``static` `int` `firstDigit(``int` `n)``{``    ``// Remove last digit from number``    ``// till only one digit is left``    ``while` `(n >= 10)``    ``{``        ``n /= 10;``    ``}` `    ``// return the first digit``    ``return` `n;``}` `// Utility function that returns the count of numbers``// written down when starting from n``static` `int` `getCount(``int` `n)``{``    ``int` `count = 1;` `    ``while` `(n != 0)``    ``{``        ``int` `leadDigit = firstDigit(n);``        ``n -= leadDigit;``        ``count++;``    ``}``    ``return` `count;``}` `// Function to find the largest number N which``// can be reduced to 0 in K steps``static` `int` `getLargestNumber(``int` `k)``{``    ``int` `left = k;``    ``int` `right = k * 10;``    ``int` `mid = (left + right) / 2;` `    ``// Get the sequence length of the mid point``    ``int` `len = getCount(mid);` `    ``// Until k sequence length is reached``    ``while` `(len != k)``    ``{` `        ``// Update mid point``        ``mid = (left + right) / 2;` `        ``// Get count of the new mid point``        ``len = getCount(mid);` `        ``if` `(len > k)``        ``{` `            ``// Update right to mid``            ``right = mid;``        ``}``        ``else``        ``{` `            ``// Update left to mid``            ``left = mid;``        ``}``    ``}` `    ``// Increment mid point by one while count``    ``// is equal to k to get the maximum value``    ``// of mid point``    ``while` `(len == k)``    ``{` `        ``if` `(len != getCount(mid + 1))``        ``{``            ``break``;``        ``}` `        ``mid++;``    ``}` `    ``return` `(mid);``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``int` `k = 3;` `    ``Console.WriteLine( getLargestNumber(k));``}``}` `// This code is contributed by Arnab Kundu`

## PHP

 `= 10)``    ``{``        ``\$n` `= (int)(``\$n` `/ 10);``    ``}` `    ``// return the first digit``    ``return` `\$n``;``}` `// Utility function that returns the``// count of numbers written down when``// starting from n``function` `getCount(``\$n``)``{``    ``\$count` `= 1;` `    ``while` `(``\$n` `!= 0)``    ``{``        ``\$leadDigit` `= firstDigit(``\$n``);``        ``\$n` `-= ``\$leadDigit``;``        ``\$count``++;``    ``}``    ``return` `\$count``;``}` `// Function to find the largest number N``// which can be reduced to 0 in K steps``function` `getLargestNumber(``\$k``)``{``    ``\$left` `= ``\$k``;``    ``\$right` `= ``\$k` `* 10;``    ``\$mid` `= (int)((``\$left` `+ ``\$right``) / 2);` `    ``// Get the sequence length``    ``// of the mid point``    ``\$len` `= getCount(``\$mid``);` `    ``// Until k sequence length is reached``    ``while` `(``\$len` `!= ``\$k``)``    ``{` `        ``// Update mid point``        ``\$mid` `= (int)((``\$left` `+ ``\$right``) / 2);` `        ``// Get count of the new mid point``        ``\$len` `= getCount(``\$mid``);` `        ``if` `(``\$len` `> ``\$k``)``        ``{` `            ``// Update right to mid``            ``\$right` `= ``\$mid``;``        ``}``        ``else``        ``{` `            ``// Update left to mid``            ``\$left` `= ``\$mid``;``        ``}``    ``}` `    ``// Increment mid point by one while count``    ``// is equal to k to get the maximum value``    ``// of mid point``    ``while` `(``\$len` `== ``\$k``)``    ``{``        ``if` `(``\$len` `!= getCount(``\$mid` `+ 1))``        ``{``            ``break``;``        ``}` `        ``\$mid``++;``    ``}` `    ``return` `(``\$mid``);``}` `// Driver Code``\$k` `= 3;``echo``(getLargestNumber(``\$k``));` `// This code is contributed by Code_Mech.``?>`

## Javascript

 ``
Output:
`10`

My Personal Notes arrow_drop_up