Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Count of values chosen for X such that N is reduced to 0 after given operations

  • Difficulty Level : Expert
  • Last Updated : 18 Oct, 2021

Given a positive integer N, the task is to find the number of integers X such that after performing the following sequence of operations reduces the value of N to 0.

  • Subtract the value of X from N.
  • If X is a single-digit integer, then stop applying operations.
  • Update the value of X as the sum of digits of X.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Input: N = 9940
Output: 1
Explanation:
Considering the value of  X  as 9910, the value of N can be reduced to 0 as:

  1. Operation 1: Update N as N – X, N = 9939 – 9910 = 30, Update X as sum of digit of X, X = 9 + 9 + 1 + 0 = 19.
  2. Operation 2:  Update N as N – X, N = 30 – 19 = 11, Update X as sum of digit of X, X = 9 + 1 = 10.
  3. Operation 3: Update N as N – X, N = 11 – 10 = 1, Update X as sum of digit of X, X = 1 + 0 = 1.
  4. Operation 4:  Update N as N – X, N = 1 – 1 = 0, Stop applying operations.

Therefore, there exists only one value of X as 1.



Input: N = 9939
Output: 3

Approach: The given problem can be solved using the Greedy Approach which is based on the following observations:

  • It can be observed that choosing the value of X greater than N doesn’t reduce N to 0.
  • It can be surely said that if the number of digits in N is K, then no value of X is less than (N – 10 * K * (K + 1) / 2) and can convert N into 0.

From the above observations, the idea is to iterate over the range [N – 10 * K * (K + 1) / 2, N] and count those values in this range that can convert N into 0 after performing the given operations.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if the value of X
// reduces N to 0 or not
bool check(int x, int N)
{
 
    while (1) {
 
       // Update the value of N as N-x
        N -= x;
 
      // Check if x is a single digit integer
        if (x < 10)
            break;
 
        int temp2 = 0;
        while (x) {
            temp2 *= 10;
            temp2 += (x % 10);
            x /= 10;
        }
        x = temp2;
    }
    if ((x < 10) && (N == 0)) {
        return 1;
    }
    return 0;
}
 
// Function to find the number of values
// X such that N can be reduced to 0
// after performing the given operations
int countNoOfsuchX(int N)
{
   
  // Number of digits in N
    int k = ceil(log10(N));
 
    // Stores the count of value of X
    int count = 1;
 
    // Iterate over all possible value
    // of X
    for (int x =( N - (k * (k + 1) * 5)); x < N; x++) {
      // Check if x follow the conditions
        if (check(x, N)) {
            count += 1;
        }
    }
   
  // Return total count
    return count;
}
 
// Driver code
int main()
{
    int N = 9399;
    cout << countNoOfsuchX(N);
    return 0;
}
 
// This code is contributed by maddler.

Java




// Java program for the above approach
import java.util.*;
 
class GFG {
 
// Function to check if the value of X
// reduces N to 0 or not
static boolean check(int x, int N)
{
 
    while (true) {
 
       // Update the value of N as N-x
        N -= x;
 
      // Check if x is a single digit integer
        if (x < 10)
            break;
 
        int temp2 = 0;
        while (x>0) {
           // temp2 *= 10;
            temp2 += (x % 10);
            x = (int)x/10;
        }
        x = temp2;
    }
    if ((x < 10) && (N == 0)) {
        return true;
    }
    return false;
}
 
// Function to find the number of values
// X such that N can be reduced to 0
// after performing the given operations
static int countNoOfsuchX(int N)
{
   
  // Number of digits in N
    int k = (int)(Math.log10(N))+1;
 
    // Stores the count of value of X
    int count = 1;
 
    // Iterate over all possible value
    // of X
    for (int x =( N - (k * (k + 1) * 5)); x <= N; x++) {
 
      // Check if x follow the conditions
        if (check(x, N)) {
            count += 1;
        }
    }
   
  // Return total count
    return count;
}
 
    // Driver Code
    public static void main(String[] args)
    {
         int N = 9399;
        System.out.println(countNoOfsuchX(N));
    }
}
 
// This code is contributed by sanjoy_2.

Python3




# Python program for the above approach
 
# Function to check if the value of X
# reduces N to 0 or not
def check(x, N):
 
    while True:
 
        # Update the value of N as N-x
        N -= x
 
        # Check if x is a single digit integer
        if len(str(x)) == 1:
            break
 
        # Update x as sum digit of x
        x = sum(list(map(int, str(x))))
 
    if len(str(x)) == 1 and N == 0:
 
        return 1
 
    return 0
 
# Function to find the number of values
# X such that N can be reduced to 0
# after performing the given operations
def countNoOfsuchX(N):
 
    # Number of digits in N
    k = len(str(N))
 
    # Stores the count of value of X
    count = 0
 
    # Iterate over all possible value
    # of X
    for x in range(N - k*(k + 1)*5, N + 1):
        # Check if x follow the conditions
        if check(x, N):
            count += 1
 
    # Return the total count
    return count
 
 
# Driver Code
N = 9939
print(countNoOfsuchX(N))

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to check if the value of X
// reduces N to 0 or not
static bool check(int x, int N)
{
 
    while (true) {
 
       // Update the value of N as N-x
        N -= x;
 
      // Check if x is a single digit integer
        if (x < 10)
            break;
 
        int temp2 = 0;
        while (x>0) {
           // temp2 *= 10;
            temp2 += (x % 10);
            x = (int)x/10;
        }
        x = temp2;
    }
    if ((x < 10) && (N == 0)) {
        return true;
    }
    return false;
}
 
// Function to find the number of values
// X such that N can be reduced to 0
// after performing the given operations
static int countNoOfsuchX(int N)
{
   
  // Number of digits in N
    int k = (int)(Math.Log10(N))+1;
 
    // Stores the count of value of X
    int count = 1;
 
    // Iterate over all possible value
    // of X
    for (int x =( N - (k * (k + 1) * 5)); x <= N; x++) {
 
      // Check if x follow the conditions
        if (check(x, N)) {
            count += 1;
        }
    }
   
  // Return total count
    return count;
}
 
// Driver code
public static void Main()
{
    int N = 9399;
    Console.Write(countNoOfsuchX(N));
}
}
 
// This code is contributed by ipg2016107.

Javascript




<script>
 
// Javascript program for the above approach
 
// Function to check if the value of X
// reduces N to 0 or not
function check(x, N)
{
  
    while (true) {
  
       // Update the value of N as N-x
        N -= x;
  
      // Check if x is a single digit leteger
        if (x < 10)
            break;
  
        let temp2 = 0;
        while (x>0) {
           // temp2 *= 10;
            temp2 += (x % 10);
            x = Math.floor(x / 10);
        }
        x = temp2;
    }
    if ((x < 10) && (N == 0)) {
        return true;
    }
    return false;
}
  
// Function to find the number of values
// X such that N can be reduced to 0
// after performing the given operations
function countNoOfsuchX(N)
{
    
  // Number of digits in N
    let k = Math.floor(Math.log10(N)) + 1;
  
    // Stores the count of value of X
    let count = 1;
  
    // Iterate over all possible value
    // of X
    for (let x =( N - (k * (k + 1) * 5)); x <= N; x++) {
  
      // Check if x follow the conditions
        if (check(x, N)) {
            count += 1;
        }
    }
    
  // Return total count
    return count;
}
 
// Driver Code
     let N = 9399;
     document.write(countNoOfsuchX(N));
 
// This code is contributed by avijitmondal1998.
</script>

 
 

Output: 
3

 

 

Time Complexity: O(log N)
Auxiliary Space: O(log N)

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :