# Reduce number to a single digit by subtracting adjacent digits repeatedly

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 = 6972Output:2

| 6 – 9 | = 3

| 9 – 7 | = 2

| 7 – 2 | = 5

After first step we get325but325is 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 become13, we’ll reduce it further

| 1 – 3 | = 2Input:N = 123456Output:0

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

- Count the number of digits in
**N**and store the value in**l**.

- Create an array
**a[]**of size**l**.

- Copy the given number into the array
**a[]**.

- 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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.