# C program to find reverse of a number using recursion

Learn how to write a C program to find the reverse of a number using recursion. This guide covers the concept of recursion, a detailed algorithm, and complete code examples.

Reversing a number is a common task in programming that involves rearranging the digits of the number in the opposite order. One of the efficient ways to achieve this is by using recursion, a technique where a function calls itself. In this article, we'll explore how to write a C program to find the reverse of a number using recursion. We'll explain the concept of recursion, outline the algorithm, and provide a complete C program with detailed explanations.

## Understanding Recursion

Recursion is a technique in which a function calls itself to solve a smaller instance of the same problem. It consists of two main parts:

**Base Case**: The condition under which the recursive function stops calling itself.**Recursive Case**: The part where the function calls itself with modified parameters.

## Algorithm to Reverse a Number Using Recursion

To reverse a number using recursion, the main idea is to extract the last digit of the number and add it to a reversed version of the remaining digits. This process continues until there are no more digits left.

Here's a step-by-step breakdown:

**Extract the Last Digit**: Use the modulus operator (%) to get the last digit of the number.**Remove the Last Digit**: Use integer division (/) to remove the last digit from the number.**Recursive Call**: Pass the remaining number to the recursive function along with the current reverse number multiplied by 10 plus the last digit.**Base Case**: When the number becomes 0, return the reverse number.

## Write a C program to find reverse of a number using recursion

Here is the complete C program to find the reverse of a number using recursion:

```
#include <stdio.h>
// Recursive function to find the reverse of a number
int reverseNumber(int num, int reverse) {
if (num == 0) // Base case
return reverse;
else {
int lastDigit = num % 10; // Extract the last digit
reverse = reverse * 10 + lastDigit; // Update the reverse number
return reverseNumber(num / 10, reverse); // Recursive call
}
}
int main() {
int number, reverse = 0;
// Input the number from the user
printf("Enter a number: ");
scanf("%d", &number);
// Call the recursive function
reverse = reverseNumber(number, 0);
// Output the reversed number
printf("The reverse of %d is %d.", number, reverse);
return 0;
}
```

**Output**

```
Enter a number: 4563
The reverse of 4563 is 3654.
```

## Explanation of the Code

**Recursive Function**:`reverseNumber`

- This function takes two parameters: the original number (
`num`

) and the reverse number so far (`reverse`

). **Base Case**: If`num`

is 0, the function returns`reverse`

, which contains the reversed number.**Recursive Case**:`lastDigit = num % 10;`

extracts the last digit of`num`

.`reverse = reverse * 10 + lastDigit;`

updates the reverse number by shifting the current digits left and adding the new last digit.`return reverseNumber(num / 10, reverse);`

calls the function recursively with the remaining number and updated reverse.

- This function takes two parameters: the original number (
**Main Function**:`main`

- It prompts the user to enter a number and reads it into the
`number`

variable. - It calls
`reverseNumber`

with the initial reverse value set to 0. - Finally, it prints the reversed number.

- It prompts the user to enter a number and reads it into the

## Example Runs

### Example 1

```
Enter a number: 1234
The reverse of 1234 is 4321.
```

### Example 2

```
Enter a number: 56789
The reverse of 56789 is 98765.
```