Program to reverse an array using pointers

Write a program to reverse digits of a number

Last Updated : 19 Mar, 2025

Try it on GfG Practice

Given an Integer n, find the reverse of its digits.

Examples:

Input: n = 122
Output: 221
Explanation: By reversing the digits of number, number will change into 221.
Input: n = 200
Output: 2
Explanation: By reversing the digits of number, number will change into 2.
Input: n = 12345
Output: 54321
Explanation: By reversing the digits of number, number will change into 54321.

Reversing Digit by Digit

This idea for this approach is to repeatedly extract the last digit of n using the modulus operator (n % 10) and appending it to the reverse number (revNum). After extracting the digit, the number n is reduced by dividing it by 10 (n = n / 10). This process continues until n becomes 0. Finally, the reversed number (revNum) is returned.

C++

#include <bits/stdc++.h>

using namespace std;

int reverseDigits(int n) {
    int revNum = 0;
    while (n > 0) {
        revNum = revNum * 10 + n % 10;
        n = n / 10;
    }
    return revNum;
}

int main() {
    int n = 4562;
    cout << reverseDigits(n);
    return 0;
}

C

#include <stdio.h>

int reverseDigits(int n) {
    int revNum = 0;
    while (n > 0) {
        revNum = revNum * 10 + n % 10;
        n = n / 10;
    }
    return revNum;
}

int main() {
    int n = 4562;
    printf("%d",reverseDigits(n));
    getchar();
    return 0;
}

Java

// Java program to reverse a number
class GfG {
    static int reverseDigits(int n) {
        int revNum = 0;
        while (n > 0) {
            revNum = revNum * 10 + n % 10;
            n = n / 10;
        }
        return revNum;
    }
  
    public static void main(String[] args) {
        int num = 4562;
        System.out.println(reverseDigits(num));
    }
}

Python

n = 4562
rev = 0

while(n > 0):
    a = n % 10
    rev = rev * 10 + a
    n = n // 10

print(rev)

C#

// C# program to reverse a number
using System;

class GfG {
    static int reverseDigits(int n) {
        int revNum = 0;
        while (n > 0) {
            revNum = revNum * 10 + n % 10;
            n = n / 10;
        }
        return revNum;
    }

    public static void Main() {
        int num = 4562;
        Console.Write(reverseDigits(num));
    }
}

JavaScript

    let num = 4562;

    function reverseDigits(n) {
        let revNum = 0;
        while(n > 0)
        {
            revNum = revNum * 10 + n % 10;
            n = Math.floor(n / 10);
        }
        return revNum;
    }
    
 // function call   
    console.log(reverseDigits(num));

Output

Time Complexity – O(log n)
Space Complexity – O(1)

Using Recursion

This approach uses a recursive function reverseDigits called with the number n andan accumulator variable revNum to store the reversed number, and basePos to keep track of the place value (ones, tens, hundreds, etc.). In each recursive call, the function processes the current digit by dividing n by 10 to reduce it and adding the last digit (n % 10) to revNum, scaled by the basePos. The basePos is then multiplied by 10 to move to the next place value.

C++

#include <bits/stdc++.h>
using namespace std;

void reverseDigits(int n, int &revNum, int &basePos) {
    if (n > 0) {
        reverseDigits(n / 10, revNum, basePos);  
        revNum += (n % 10) * basePos;             
        basePos *= 10;
    }
}

int main() {
    int n = 4562;
    int revNum = 0;
    int basePos = 1;
    reverseDigits(n, revNum, basePos);  
    cout << revNum;
    return 0;
}

C

#include <stdio.h>

void reverseDigits(int n, int *revNum, int *basePos) {
    if (n > 0) {
        reverseDigits(n / 10, revNum, basePos);
        *revNum += (n % 10) * (*basePos);        
        *basePos *= 10;                           
    }
}

int main() {
    int n = 4562;
    int revNum = 0;
    int basePos = 1;
    reverseDigits(n, &revNum, &basePos);  
    printf("%d", revNum);
    return 0;
}

Java

class Solution {
    
    // Function to reverse digits recursively
    public void reverseDigits(int n, int[] revNum, int[] basePos) {
        if (n > 0) {
            
            reverseDigits(n / 10, revNum, basePos);  
            
             // Add current digit with its base position
            revNum[0] += (n % 10) * basePos[0];     
            basePos[0] *= 10;                         
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int n = 4562;
        int[] revNum = {0};  
        int[] basePos = {1};  
        solution.reverseDigits(n, revNum, basePos);
        System.out.println(revNum[0]);  
    }
}

Python

def reverseDigits(n, revNum, basePos):
    if n > 0:
        reverseDigits(n // 10, revNum, basePos)  
        revNum[0] += (n % 10) * basePos[0]       
        basePos[0] *= 10                         

# Driver code
n = 4562
revNum = [0]  
basePos = [1]  
reverseDigits(n, revNum, basePos)
print(revNum[0])

C#

// C# program to reverse digits of a number

using System;
class GfG {
    static int reverseDigits(int n) {
         int revNum = 0;
   		 int basepos = 1;
        if (n > 0) {
            reverseDigits(n / 10);
            revNum += (n % 10) * basepos;
            basepos *= 10;
        }
        return revNum;
    }

    public static void Main() {
        int n = 4562;
        Console.WriteLine(reverseDigits(n));
    }
}

JavaScript

class Solution {
    
    // Function to reverse digits recursively
    reverseDigits(n, revNum, basePos) {
        if (n > 0) {
            this.reverseDigits(Math.floor(n / 10), revNum, basePos);  
            revNum[0] += (n % 10) * basePos[0];                        
            basePos[0] *= 10;                                           
        }
    }
}

// Driver code
let solution = new Solution();
let n = 4562;
let revNum = [0];  
let basePos = [1]; 
solution.reverseDigits(n, revNum, basePos);
console.log(revNum[0]);

Output

Time Complexity – O(log n)
Space Complexity – O(log n)

Using String

This approach reverses a number by converting it into a string, reversing the string, and then converting it back into an integer. This avoids manual digit manipulation by leveraging string operations. The string reversal is done using a built-in function, and the result is then converted back to an integer and returned. This method is straightforward but requires extra space for the string conversion.

C++

// C++ program to reverse a number
#include <bits/stdc++.h>
using namespace std;

int reverseDigits(int n) {
    
    // converting number to string
    string s = to_string(n);

    // reversing the string
    reverse(s.begin(), s.end());

    // converting string to integer
    n = stoi(s);

    // returning integer
    return n;
}
int main() {
    int n = 4562;
    cout << reverseDigits(n);
    return 0;
}

C

// C program to reverse a number
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void reverse(char* begin, char* end) {
    char temp;
    while (begin < end) {
        temp = *begin;
        *begin++ = *end;
        *end-- = temp;
    }
}

void reverseWords(char* s) {
    char* word_begin = s;
    char* temp = s;

    // Reversing individual words as explained in the first step
    while (*temp) {
        temp++;
        if (*temp == '\0') {
            reverse(word_begin, temp - 1);
        }
        else if (*temp == ' ') {
            reverse(word_begin, temp - 1);
            word_begin = temp + 1;
        }
    }
    reverse(s, temp - 1);
}

int reverseDigits(int n) {
    char strin[100];
    sprintf(strin, "%d", n);

    // reversing the string
    reverseWords(strin);

    // converting string to integer
    n = atoi(strin);

    return n;
}

int main() {
    int n = 123456;
    printf("%d\n",reverseDigits(n));
    return 0;
}

Java

// Java program to reverse a number

 class GfG {
    static int reversDigits(int n) {
        // converting number to string
        StringBuffer s
            = new StringBuffer(String.valueOf(n));

        // reversing the string
        s.reverse();

        // converting string to integer
        n = Integer.parseInt(String.valueOf(s));

        // returning integer
        return n;
    }
   
    public static void main(String[] args) {
        int n = 4562;
        System.out.println(reversDigits(n));
    }
}

Python

# Python 3 program to reverse a number
def reversDigits(n):

    # converting number to string
    s = str(n)

    # reversing the string
    s = list(s)
    s.reverse()
    s = ''.join(s)

    # converting string to integer
    n = int(s)
    return n

if __name__ == "__main__":

    num = 4562
    print(reversDigits(num))

C#

// C# program to reverse a number
using System;

public class GfG {

    static string ReverseString(string s) {
        char[] array = s.ToCharArray();
        Array.Reverse(array);
        return new string(array);
    }

    static int reversDigits(int n) {
        // converting number to string
        string s = n.ToString();

        // reversing the string
        s = ReverseString(s);

        // converting string to integer
        n = int.Parse(s);

        // returning integer
        return n;
    }

    static public void Main()  {
        int n = 4562;
        Console.Write(reversDigits(n));
    }
}

JavaScript

// Javascript program to reverse a number

    function reversDigits(n) {
        // converting number to string
        let s = n.toString().split("").reverse().join("");
        
        // converting string to integer
        n = parseInt(s);

        // returning integer
        return s;
    }

// Driver Code
    
    let n = 4562;
    console.log(reversDigits(n));

Output

Time Complexity – O(log n)
Space Complexity – O(1)

Note: The above program doesn’t consider leading zeroes. For example, for 100 programs will print 1. If you want to print 001

Using String and Slicing in Python

The approach used is “Using Slicing”. This technique involves converting the number into a string, then reversing that string by using slicing operations. After reversing, the string is converted back into a number. This method is simple and efficient but requires additional space for storing the string representation of the number.

Python

# Python 3 program to reverse a number
def reversDigits(n):

    # converting number to string
    s = str(n)

    # reversing the string
    s = s[::-1]

    # converting string to integer
    n = int(s)

    # returning integer
    return n

if __name__ == "__main__":

    n = 4562
    print(reversDigits(n))

Output

Time Complexity – O(n)
Space Complexity – O(1)

Program to reverse an array using pointers

Improve

Article Tags :

Practice Tags :

Similar Reads

Write an Efficient C Program to Reverse Bits of a Number

Given an unsigned integer, reverse all bits of it and return the number with reversed bits. Input : n = 1Output : 2147483648 Explanation : On a machine with size of unsigned bit as 32. Reverse of 0....001 is 100....0. Input : n = 2147483648Output : 1 Recommended PracticeReverse BitsTry It!Method1 -

Program to reverse an array using pointers

Prerequisite : Pointers in C/C++ Given an array, write a program to reverse it using pointers . In this program we make use of * operator . The * (asterisk) operator denotes the value of variable . The * operator at the time of declaration denotes that this is a pointer, otherwise it denotes the val

Reverse digits of an integer with overflow handled | Set 2

Given a 32-bit integer N. The task is to reverse N, if the reversed integer overflows, print -1 as the output. Examples Input: N = 123Output: 321 Input: N = -123Output: -321 Input: N = 120Output: 21 Approach: Unlike approaches Set 1 of the article, this problem can be solved simply by using a 64-bit

Reverse actual bits of the given number

Given a non-negative integer n, the task is to reverse the bits in its binary representation and return the resulting decimal number. The reversal should consider only the actual binary digits without any leading zeros. Examples : Input : 11Output : 13Explanation: (11)10 = (1011)2.After reversing th

Javascript Program to Rotate digits of a given number by K

Given two integers N and K, the task is to rotate the digits of N by K. If K is a positive integer, left rotate its digits. Otherwise, right rotate its digits. Examples: Input: N = 12345, K = 2Output: 34512Â Explanation:Â Left rotating N(= 12345) by K(= 2) modifies N to 34512.Â Therefore, the required

Reverse digits of an integer with overflow handled

Write a program to reverse an integer assuming that the input is a 32-bit integer. If the reversed integer overflows, print -1 as the output. Let us see a simple approach to reverse digits of an integer. [GFGTABS] C++ // A simple C program to reverse digits of // an integer. #include <bits/stdc++

Sum of Digits of a Number

Given a number n, find the sum of its digits. Examples : Input: n = 687Output: 21Explanation: The sum of its digits are: 6 + 8 + 7 = 21 Input: n = 12Output: 3Explanation: The sum of its digits are: 1 + 2 = 3 Table of Content Iterative ApproachRecursive ApproachTaking Input Number as StringIterative

Program to print ASCII Value of all digits of a given number

Given an integer N, the task is to print the ASCII value of all digits of N. Examples: Input: N = 8Output: 8 (56)Explanation:ASCII value of 8 is 56 Input: N = 240Output:2 (50)4 (52)0 (48) Approach: Using the ASCII table shown below, the ASCII value of all the digits of N can be printed: DigitASCII V

Program for quotient and remainder of big number

Given a string of numbers and given another number (say m) [0 <= m <= 10^18]. The task is to calculate the modulus of the given number.Examples: Input : num = "214" m = 5 Output : Remainder = 4 Quotient = 42 Input : num = "214755974562154868" m = 17 Output : Remainder = 15 Quotient = 126327043

Rotate digits of a given number by K

Given two integers N and K, the task is to rotate the digits of N by K. If K is a positive integer, left rotate its digits. Otherwise, right rotate its digits. Examples: Input: N = 12345, K = 2Output: 34512 Explanation: Left rotating N(= 12345) by K(= 2) modifies N to 34512. Therefore, the required