Reversing a number is a common programming task that often arises in various applications. Whether you are a beginner or an experienced programmer, understanding how to reverse a number in C is a fundamental skill that can enhance your problem-solving abilities. In this article, we will explore the concept of reversing a number in C, discuss different approaches to achieve this task, and provide valuable insights to help you grasp the concept effectively.

## Understanding the Problem

Before diving into the implementation details, let’s first understand what it means to reverse a number. Reversing a number involves rearranging its digits in the opposite order. For example, if we reverse the number 123, we get 321. Similarly, reversing 98765 gives us 56789.

## Approaches to Reverse a Number in C

There are several approaches to reverse a number in C. In this section, we will discuss three commonly used methods:

### 1. Using Arithmetic Operations

The first approach involves using arithmetic operations to reverse a number. Here’s a step-by-step breakdown of this method:

- Initialize a variable to store the reversed number (let’s call it
`reversedNum`

) and set it to 0. - Extract the last digit of the given number using the modulo operator (
`%`

) and store it in a separate variable. - Multiply the
`reversedNum`

variable by 10 and add the extracted digit to it. - Divide the given number by 10 to remove the last digit.
- Repeat steps 2-4 until the given number becomes 0.
- The final value of
`reversedNum`

will be the reversed number.

Let’s illustrate this approach with an example:

```
#include <stdio.h>
int reverseNumber(int num) {
int reversedNum = 0;
while (num != 0) {
int digit = num % 10;
reversedNum = reversedNum * 10 + digit;
num /= 10;
}
return reversedNum;
}
int main() {
int number = 12345;
int reversedNumber = reverseNumber(number);
printf("Reversed number: %dn", reversedNumber);
return 0;
}
```

In this example, we define a function `reverseNumber`

that takes an integer `num`

as input and returns the reversed number. We then call this function in the `main`

function to reverse the number 12345. The output of this program will be:

```
Reversed number: 54321
```

### 2. Using Arrays

The second approach involves using arrays to reverse a number. Here’s how it works:

- Convert the given number into a string.
- Create an array to store the digits of the number.
- Iterate through the string and store each digit in the array.
- Reverse the array by swapping the elements from the beginning and the end.
- Convert the reversed array back into a number.

Let’s see an example implementation:

```
#include <stdio.h>
#include <string.h>
int reverseNumber(int num) {
char str[20];
sprintf(str, "%d", num);
int length = strlen(str);
int digits[length];
for (int i = 0; i < length; i++) {
digits[i] = str[i] - '0';
}
for (int i = 0, j = length - 1; i < j; i++, j--) {
int temp = digits[i];
digits[i] = digits[j];
digits[j] = temp;
}
int reversedNum = 0;
for (int i = 0; i < length; i++) {
reversedNum = reversedNum * 10 + digits[i];
}
return reversedNum;
}
int main() {
int number = 98765;
int reversedNumber = reverseNumber(number);
printf("Reversed number: %dn", reversedNumber);
return 0;
}
```

In this example, we use the `sprintf`

function to convert the given number into a string. We then iterate through the string and store each digit in the `digits`

array. After reversing the array, we convert it back into a number by multiplying each digit by the appropriate power of 10. The output of this program will be:

```
Reversed number: 56789
```

### 3. Using Recursion

The third approach involves using recursion to reverse a number. Here’s how it can be done:

- If the given number is less than 10, return it as the reversed number.
- Extract the last digit of the given number using the modulo operator.
- Divide the given number by 10 to remove the last digit.
- Recursively call the function with the reduced number.
- Multiply the result of the recursive call by 10 and add the extracted digit to it.
- The final value will be the reversed number.

Let’s see an example implementation:

```
#include <stdio.h>
int reverseNumber(int num) {
if (num < 10) {
return num;
}
int digit = num % 10;
int reducedNum = num / 10;
int reversedNum = reverseNumber(reducedNum);
return reversedNum * 10 + digit;
}
int main() {
int number = 54321;
int reversedNumber = reverseNumber(number);
printf("Reversed number: %dn", reversedNumber);
return 0;
}
```

In this example, the `reverseNumber`

function is implemented recursively. If the given number is less than 10, it is returned as the reversed number. Otherwise, the function extracts the last digit, reduces the number, and recursively calls itself with the reduced number. The output of this program will be:

```
Reversed number: 12345
```

## Conclusion

<p

## Recent comments