Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Reduce number to a single digit by subtracting adjacent digits repeatedly

  • Difficulty Level : Easy
  • Last Updated : 26 Apr, 2021

Given a number N, the task is to reduce it to a single-digit number by repeatedly subtracting the adjacent digits. That is, in the first iteration, subtract all the adjacent digits to generate a new number, if this number contains more than one digit, repeat the same process until it becomes a single-digit number.

Examples: 

Input: N = 6972 
Output:
| 6 – 9 | = 3 
| 9 – 7 | = 2 
| 7 – 2 | = 5
After first step we get 325 but 325 is not a single-digit number, so we’ll further reduce it until we do not get single digit number.
| 3 – 2 | = 1 
| 2 – 5 | = 3
And now the number will become 13, we’ll reduce it further 
| 1 – 3 | = 2
Input: N = 123456 
Output:
 

Approach: Here we are using Array to represent the initial number N for simplicity.  

  1. Count the number of digits in N and store the value in l
     
  2. Create an array a[] of size l
     
  3. Copy the given number into the array a[]
     
  4. Calculate the RSF by subtracting the consecutive digits of array a
     

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the resultant digit
// after performing the given operations
int RSF(int n)
{
    while (n >= 10) {
 
        // Creating an extra copy of n
        int x = n;
        int l = 0;
 
        // Counting the number of digits in n
        while (n > 0) {
            n = n / 10;
            l++;
        }
 
        // Now n is 0
        // Creating an array of length l
        int a[l];
 
        // Initializing i with the last index of array
        int i = l - 1;
        while (x > 0) {
 
            // Filling array from right to left
            a[i] = x % 10;
            x = x / 10;
            i--;
        }
 
        // Calculating the absolute consecutive difference
        for (int j = 0; j < l - 1; j++) {
 
            // Updating the value of n in every loop
            n = n * 10 + abs(a[j] - a[j + 1]);
        }
    }
 
    // While loop ends here and we have found
    // the RSF value of N
    return n;
}
 
// Driver code
int main()
{
    int n = 614;
 
    // Passing n to RSF function and getting answer
    int ans = RSF(n);
 
    // Printing the value stored in ans
    cout << ans;
 
    return 0;
}

Java




// Java implementation of the approach
class GFG {
 
    // Function to return the resultant digit
    // after performing the given operations
    static int RSF(int n)
    {
        while (n >= 10) {
 
            // Creating an extra copy of n
            int x = n;
            int l = 0;
 
            // Counting the number of digits in n
            while (n > 0) {
                n = n / 10;
                l++;
            }
 
            // Now n is 0
            // Creating an array of length l
            int a[] = new int[l];
 
            // Initializing i with the last index of array
            int i = l - 1;
 
            while (x > 0) {
 
                // Filling array from right to left
                a[i] = x % 10;
                x = x / 10;
                i--;
            }
 
            // Calculating the absolute consecutive difference
            for (int j = 0; j < l - 1; j++) {
 
                // Updating the value of n in every loop
                n = n * 10 + Math.abs(a[j] - a[j + 1]);
            }
        }
 
        // While loop ends here and we have found
        // the RSF value of N
        return n;
    }
 
    // Driver code
    public static void main(String[] arg)
    {
        int n = 6972;
 
        // Passing n to RSF function and getting answer
        int ans = RSF(n);
 
        // Printing the value stored in ans
        System.out.println(ans);
    }
}

Python3




# Python3 implementation of the approach
 
# Function to return the resultant digit
# after performing the given operations
def RSF(n):
    while (n >= 10):
 
        # Creating an extra copy of n
        x = n;
        l = 0;
 
        # Counting the number of digits in n
        while (n > 0):
            n = n // 10;
            l += 1;
 
        # Now n is 0
        # Creating an array of length l
        a = [0] * l;
 
        # Initializing i with the last index of array
        i = l - 1;
        while (x > 0):
 
            # Filling array from right to left
            a[i] = x % 10;
            x = x // 10;
            i -= 1;
 
        # Calculating the absolute
        # consecutive difference
        for j in range(0, l - 1):
 
            # Updating the value of n in every loop
            n = n * 10 + abs(a[j] - a[j + 1]);
             
    # While loop ends here and we have found
    # the RSF value of N
    return n;
 
# Driver code
if __name__ == '__main__':
    n = 614;
 
    # Passing n to RSF function
    # and getting answer
    ans = RSF(n);
 
    # Printing the value stored in ans
    print(ans);
 
# This code is contributed by Rajput-Ji

C#




// C# implementation of the approach
using System;
class GFG
{
 
// Function to return the resultant digit
// after performing the given operations
static int RSF(int n)
{
    while (n >= 10)
    {
 
        // Creating an extra copy of n
        int x = n;
        int l = 0;
 
        // Counting the number of digits in n
        while (n > 0)
        {
            n = n / 10;
            l++;
        }
 
        // Now n is 0
        // Creating an array of length l
        int []a = new int[l];
 
        // Initializing i with the last index of array
        int i = l - 1;
 
        while (x > 0)
        {
 
            // Filling array from right to left
            a[i] = x % 10;
            x = x / 10;
            i--;
        }
 
        // Calculating the absolute
        // consecutive difference
        for (int j = 0; j < l - 1; j++)
        {
 
            // Updating the value of n in every loop
            n = n * 10 + Math.Abs(a[j] - a[j + 1]);
        }
    }
 
    // While loop ends here and we have found
    // the RSF value of N
    return n;
}
 
// Driver code
public static void Main(String[] arg)
{
    int n = 6972;
 
    // Passing n to RSF function and getting answer
    int ans = RSF(n);
 
    // Printing the value stored in ans
    Console.WriteLine(ans);
}
}
 
// This code is contributed by Princi Singh

Javascript




<script>
// javascript implementation of the approach   
// Function to return the resultant digit
    // after performing the given operations
    function RSF(n) {
        while (n >= 10) {
 
            // Creating an extra copy of n
            var x = n;
            var l = 0;
 
            // Counting the number of digits in n
            while (n > 0) {
                n = parseInt(n / 10);
                l++;
            }
 
            // Now n is 0
            // Creating an array of length l
            var a = Array(l).fill(0);
 
            // Initializing i with the last index of array
            var i = l - 1;
 
            while (x > 0) {
 
                // Filling array from right to left
                a[i] = x % 10;
                x = parseInt(x / 10);
                i--;
            }
 
            // Calculating the absolute consecutive difference
            for (j = 0; j < l - 1; j++) {
 
                // Updating the value of n in every loop
                n = n * 10 + Math.abs(a[j] - a[j + 1]);
            }
        }
 
        // While loop ends here and we have found
        // the RSF value of N
        return n;
    }
 
    // Driver code
        var n = 6972;
 
        // Passing n to RSF function and getting answer
        var ans = RSF(n);
 
        // Printing the value stored in ans
        document.write(ans);
 
// This code contributed by aashish1995
</script>
Output: 
2

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!