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

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: 9
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 current count is not equal to 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement above approach
  
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

10


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : jit_t, andrew1234