Open In App

Steps to reduce N to zero by subtracting its most significant digit at every step

Given a number . Reduce this number to zero by subtracting the number by it’s most significant digit(Left most digit) at every step. The task is to count the number of steps it takes to be reduced to zero. 
Examples
 

Input: 14
Output: 6
Steps:
14 - 1 = 13
13 - 1 = 12
12 - 1 = 11
11 - 1 = 10
10 - 1 = 9
9 - 9 = 0

Input: 20  
Output: 12
Numbers after series of steps:
20, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 0


 


Naive Approach: A naive approach is to reduce the number by its first digit step-wise and find the count of steps, but the time complexity will be huge if a large number is provided. 
Efficient Approach: The main idea of the efficient approach is to reduce the number of steps in the naive approach. We can skip the steps whose leading digits are the same in consecutive numbers, and count them. The algorithm of skipping those numbers with the same leading digits is as follows: 
 


Below is the implementation of the above approach: 
 

// C++ program to find the count of Steps to
// reduce N to zero by subtracting its most
// significant digit at every step
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number
// of digits in a number m
int countdig(int m)
{
    if (m == 0)
        return 0;
    else
        return 1 + countdig(m / 10);
}
 
// Function to count the number of
// steps to reach 0
int countSteps(int x)
{
    // count the total number of steps
    int c = 0;
    int last = x;
 
    // iterate till we reach 0
    while (last) {
 
        // count the digits in last
        int digits = countdig(last);
 
        // decrease it by 1
        digits -= 1;
 
        // find the number on whose division,
        // we get the first digit
        int divisor = pow(10, digits);
 
        // first digit in last
        int first = last / divisor;
 
        // find the first number less than
        // last where the first digit changes
        int lastnumber = first * divisor;
 
        // find the number of numbers
        // with same first digit that are jumped
        int skipped = (last - lastnumber) / first;
 
        skipped += 1;
 
        // count the steps
        c += skipped;
 
        // the next number with a different
        // first digit
        last = last - (first * skipped);
    }
 
    return c;
}
 
// Driver code
int main()
{
    int n = 14;
 
    cout << countSteps(n);
 
    return 0;
}

                    
// Java program to find the count of Steps to
// reduce N to zero by subtracting its most
// significant digit at every step
 
 
class GFG{
// Function to count the number
// of digits in a number m
static int countdig(int m)
{
    if (m == 0)
        return 0;
    else
        return 1 + countdig(m / 10);
}
 
// Function to count the number of
// steps to reach 0
static int countSteps(int x)
{
    // count the total number of steps
    int c = 0;
    int last = x;
 
    // iterate till we reach 0
    while (last>0) {
 
        // count the digits in last
        int digits = countdig(last);
 
        // decrease it by 1
        digits -= 1;
 
        // find the number on whose division,
        // we get the first digit
        int divisor = (int)Math.pow(10, digits);
 
        // first digit in last
        int first = last / divisor;
 
        // find the first number less than
        // last where the first digit changes
        int lastnumber = first * divisor;
 
        // find the number of numbers
        // with same first digit that are jumped
        int skipped = (last - lastnumber) / first;
 
        skipped += 1;
 
        // count the steps
        c += skipped;
 
        // the next number with a different
        // first digit
        last = last - (first * skipped);
    }
 
    return c;
}
 
// Driver code
public static void main(String[] args)
{
    int n = 14;
 
    System.out.println(countSteps(n));
}
}
// This code is contributed by mits

                    
# Python 3 program to find the
# count of Steps to reduce N to
# zero by subtracting its most
# significant digit at every step
 
# Function to count the number
# of digits in a number m
def countdig(m) :
 
    if (m == 0) :
        return 0
    else :
        return 1 + countdig(m // 10)
 
# Function to count the number
# of steps to reach 0
def countSteps(x) :
     
    # count the total number
    # of steps
    c = 0
    last = x
 
    # iterate till we reach 0
    while (last) :
 
        # count the digits in last
        digits = countdig(last)
 
        # decrease it by 1
        digits -= 1
 
        # find the number on whose
        # division, we get the first digit
        divisor = pow(10, digits)
 
        # first digit in last
        first = last // divisor
 
        # find the first number less
        # than last where the first
        # digit changes
        lastnumber = first * divisor
 
        # find the number of numbers
        # with same first digit that
        # are jumped
        skipped = (last - lastnumber) // first
 
        skipped += 1
 
        # count the steps
        c += skipped
 
        # the next number with a different
        # first digit
        last = last - (first * skipped)
 
    return c
 
# Driver code
n = 14
print(countSteps(n))
 
# This code is contributed by ANKITRAI1

                    
// C# program to find the count of Steps to
// reduce N to zero by subtracting its most
// significant digit at every step
using System;
 
class GFG{
// Function to count the number
// of digits in a number m
static int countdig(int m)
{
    if (m == 0)
        return 0;
    else
        return 1 + countdig(m / 10);
}
 
// Function to count the number of
// steps to reach 0
static int countSteps(int x)
{
    // count the total number of steps
    int c = 0;
    int last = x;
 
    // iterate till we reach 0
    while (last>0) {
 
        // count the digits in last
        int digits = countdig(last);
 
        // decrease it by 1
        digits -= 1;
 
        // find the number on whose division,
        // we get the first digit
        int divisor = (int)Math.Pow(10, digits);
 
        // first digit in last
        int first = last / divisor;
 
        // find the first number less than
        // last where the first digit changes
        int lastnumber = first * divisor;
 
        // find the number of numbers
        // with same first digit that are jumped
        int skipped = (last - lastnumber) / first;
 
        skipped += 1;
 
        // count the steps
        c += skipped;
 
        // the next number with a different
        // first digit
        last = last - (first * skipped);
    }
 
    return c;
}
 
// Driver code
static void Main()
{
    int n = 14;
 
    Console.WriteLine(countSteps(n));
}
}
// This code is contributed by mits

                    
<?php
// PHP program to find the count of Steps to
// reduce N to zero by subtracting its most
// significant digit at every step
 
// Function to count the number
// of digits in a number m
function countdig($m)
{
    if ($m == 0)
        return 0;
    else
        return 1 + countdig( (int)($m / 10));
}
 
// Function to count the number of
// steps to reach 0
function countSteps($x)
{
    // count the total number of steps
    $c = 0;
    $last = $x;
 
    // iterate till we reach 0
    while ($last)
    {
 
        // count the digits in last
        $digits = countdig($last);
 
        // decrease it by 1
        $digits -= 1;
 
        // find the number on whose division,
        // we get the first digit
        $divisor = pow(10, $digits);
 
        // first digit in last
        $first =  (int)($last / $divisor);
 
        // find the first number less than
        // last where the first digit changes
        $lastnumber = $first * $divisor;
 
        // find the number of numbers
        // with same first digit that are jumped
        $skipped = ($last - $lastnumber) / $first;
 
        $skipped += 1;
 
        // count the steps
        $c += $skipped;
 
        // the next number with a different
        // first digit
        $last = $last - ($first * $skipped);
    }
 
    return $c;
}
 
// Driver code
$n = 14;
 
echo countSteps($n);
 
// This code is contributed
// by Akanksha Rai

                    
<script>
// javascript program to find the count of Steps to
// reduce N to zero by subtracting its most
// significant digit at every step   
// Function to count the number
    // of digits in a number m
    function countdig(m) {
        if (m == 0)
            return 0;
        else
            return 1 + countdig(parseInt(m / 10));
    }
 
    // Function to count the number of
    // steps to reach 0
    function countSteps(x) {
        // count the total number of steps
        var c =0;
        var last = x;
 
        // iterate till we reach 0
        while (last > 0) {
 
            // count the digits in last
            var digits = countdig(last);
 
            // decrease it by 1
            digits -= 1;
 
            // find the number on whose division,
            // we get the first digit
            var divisor = parseInt( Math.pow(10, digits));
 
            // first digit in last
            var first = parseInt(last / divisor);
 
            // find the first number less than
            // last where the first digit changes
            var lastnumber = first * divisor;
 
            // find the number of numbers
            // with same first digit that are jumped
            var skipped = parseInt((last - lastnumber) / first);
 
            skipped += 1;
 
            // count the steps
            c += skipped;
 
            // the next number with a different
            // first digit
            last = last - (first * skipped);
        }
 
        return c;
    }
 
    // Driver code
     
        var n = 14;
 
        document.write(countSteps(n));
 
// This code is contributed by todaysgaurav
</script>

                    

Output: 
6

 

Time Complexity: O(N*logN), as in the worst case the while loop will traverse N times and in each traversal we are using power function and countdig function, each of these will cost logN time, so the effective time complexity of the program will be O (N*logN).

Auxiliary Space: O(1), as we are not using any extra space.


Article Tags :