Minimum removals in a number to be divisible by 10 power raised to K

Given two positive integers N and K. Find the minimum number of digits that can be removed from the number N such that after removals the number is divisible by 10K or print -1 if it is impossible.

Examples:

Input : N = 10904025, K = 2
Output : 3
Explanation : We can remove the digits 4, 2 and 5 such that the number 
becomes 10900 which is divisible by 102.

Input : N = 1000, K = 5
Output : 3
Explanation : We can remove the digits 1 and any two zeroes such that the
number becomes 0 which is divisible by 105

Input : N = 23985, K = 2
Output : -1


Approach : The idea is to start traversing the number from the last digit while keeping a counter. If the current digit is not zero, increment the counter variable, otherwise decrement variable K. When K becomes zero, return counter as answer. After traversing the whole number, check if the current value of K is zero or not. If it is zero, return counter as answer, otherwise return answer as number of digits in N – 1, since we need to reduce the whole number to a single zero which is divisible by any number. Also, if the given number does not contain any zero, return -1 as answer.

Below is the implementation of above approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP Program to count the number
// of digits that can be removed such
// that number is divisible by 10^K
#include <bits/stdc++.h>
using namespace std;
  
// function to return the required
// number of digits to be removed
int countDigitsToBeRemoved(int N, int K)
{
    // Converting the given number
    // into string
    string s = to_string(N);
  
    // variable to store number of
    // digits to be removed
    int res = 0;
  
    // variable to denote if atleast
    // one zero has been found
    int f_zero = 0;
    for (int i = s.size() - 1; i >= 0; i--) {
        if (K == 0)
            return res;
        if (s[i] == '0') {
  
            // zero found
            f_zero = 1;
            K--;
        }
        else
            res++;
    }
  
    // return size - 1 if K is not zero and
    // atleast one zero is present, otherwise
    // result
    if (!K)
        return res;
    else if (f_zero)
        return s.size() - 1;
    return -1;
}
  
// Driver Code to test above function
int main()
{
    int N = 10904025, K = 2;
    cout << countDigitsToBeRemoved(N, K) << endl;
  
    N = 1000, K = 5;
    cout << countDigitsToBeRemoved(N, K) << endl;
  
    N = 23985, K = 2;
    cout << countDigitsToBeRemoved(N, K) << endl;
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to count the number 
// of digits that can be removed such 
// that number is divisible by 10^K 
  
public class GFG{
      
    // function to return the required 
    // number of digits to be removed 
    static int countDigitsToBeRemoved(int N, int K) 
    
        // Converting the given number 
        // into string 
        String s = Integer.toString(N); 
      
        // variable to store number of 
        // digits to be removed 
        int res = 0
      
        // variable to denote if atleast 
        // one zero has been found 
        int f_zero = 0
        for (int i = s.length() - 1; i >= 0; i--) { 
            if (K == 0
                return res; 
            if (s.charAt(i) == '0') { 
      
                // zero found 
                f_zero = 1
                K--; 
            
            else
                res++; 
        
      
        // return size - 1 if K is not zero and 
        // atleast one zero is present, otherwise 
        // result 
        if (K == 0
            return res; 
        else if (f_zero == 1
            return s.length() - 1
        return -1
    
      
    // Driver Code to test above function 
    public static void main(String []args)
    
        int N = 10904025;
        int K = 2
        System.out.println(countDigitsToBeRemoved(N, K)) ; 
      
        N = 1000 ;
        K = 5
        System.out.println(countDigitsToBeRemoved(N, K))  ;
      
        N = 23985;
        K = 2
        System.out.println(countDigitsToBeRemoved(N, K)) ; 
    
  
    // This code is contributed by Ryuga
    }

chevron_right


Python3

# Python3 Program to count the number
# of digits that can be removed such
# that number is divisible by 10^K

# function to return the required
# number of digits to be removed
def countDigitsToBeRemoved(N, K):

# Converting the given number
# into string
s = str(N);

# variable to store number of
# digits to be removed
res = 0;

# variable to denote if atleast
# one zero has been found
f_zero = 0;
for i in range(len(s) – 1, -1, -1):
if (K == 0):
return res;
if (s[i] == ‘0’):

# zero found
f_zero = 1;
K -= 1;
else:
res += 1;

# return size – 1 if K is not zero and
# atleast one zero is present, otherwise
# result
if (K == 0):
return res;
elif (f_zero > 0):
return len(s) – 1;
return -1;

# Driver Code
N = 10904025;
K = 2;
print(countDigitsToBeRemoved(N, K));

N = 1000;
K = 5;
print(countDigitsToBeRemoved(N, K));

N = 23985;
K = 2;
print(countDigitsToBeRemoved(N, K));

# This code is contributed by mits

C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to count the number 
// of digits that can be removed such 
// that number is divisible by 10^K 
   
using System;
public class GFG{
       
    // function to return the required 
    // number of digits to be removed 
    static int countDigitsToBeRemoved(int N, int K) 
    
        // Converting the given number 
        // into string 
        string s = Convert.ToString(N); 
       
        // variable to store number of 
        // digits to be removed 
        int res = 0; 
       
        // variable to denote if atleast 
        // one zero has been found 
        int f_zero = 0; 
        for (int i = s.Length - 1; i >= 0; i--) { 
            if (K == 0) 
                return res; 
            if (s[i] == '0') { 
       
                // zero found 
                f_zero = 1; 
                K--; 
            
            else
                res++; 
        
       
        // return size - 1 if K is not zero and 
        // atleast one zero is present, otherwise 
        // result 
        if (K == 0) 
            return res; 
        else if (f_zero == 1) 
            return s.Length - 1; 
        return -1; 
    
       
    // Driver Code to test above function 
    public static void Main()
    
        int N = 10904025;
        int K = 2; 
        Console.Write(countDigitsToBeRemoved(N, K)+"\n") ; 
       
        N = 1000 ;
        K = 5; 
        Console.Write(countDigitsToBeRemoved(N, K)+"\n")  ;
       
        N = 23985;
        K = 2; 
        Console.Write(countDigitsToBeRemoved(N, K)+"\n") ; 
    
   
     
    }

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP Program to count the number
// of digits that can be removed such
// that number is divisible by 10^K
  
// function to return the required
// number of digits to be removed
function countDigitsToBeRemoved($N, $K)
{
    // Converting the given number
    // into string
    $s = strval($N);
  
    // variable to store number of
    // digits to be removed
    $res = 0;
  
    // variable to denote if atleast
    // one zero has been found
    $f_zero = 0;
    for ($i = strlen($s)-1; $i >= 0; $i--) {
        if ($K == 0)
            return $res;
        if ($s[$i] == '0') {
  
            // zero found
            $f_zero = 1;
            $K--;
        }
        else
            $res++;
    }
  
    // return size - 1 if K is not zero and
    // atleast one zero is present, otherwise
    // result
    if (!$K)
        return $res;
    else if ($f_zero)
        return strlen($s) - 1;
    return -1;
}
  
// Driver Code to test above function
  
    $N = 10904025;
    $K = 2;
    echo countDigitsToBeRemoved($N, $K)."\n";
  
    $N = 1000;
    $K = 5;
    echo countDigitsToBeRemoved($N, $K)."\n";
  
    $N = 23985;
    $K = 2;
    echo countDigitsToBeRemoved($N, $K);
      
// This code is contributed by mits
?>

chevron_right


Output:

3
3
-1

Time Complexity :Number of digits in the given number.



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 : Ryuga, Ita_c, Mithun Kumar