feat: Add ReverseANumber with overloaded methods to reverse integers and arrays

WHAT the code does:
Defines a ReverseANumber class with two overloaded reverse methods:
- reverse(int n): reverses the digits of a single integer using modulus and division.
- reverse(int[] A): creates a new array with elements in reverse order.
In main():
- Demonstrates reversing an integer (569 → 965).
- Demonstrates reversing an array {2, 4, 6, 7} → {7, 6, 4, 2}.

WHY this matters:
Shows method overloading with different parameter types (int vs int[]).
Demonstrates number reversal using arithmetic operations, reinforcing digit manipulation.
Illustrates array reversal using index-based traversal.
Provides an educational example bridging algorithmic logic with object-oriented design.

HOW it works:
For reverse(int n):
- Initialize rev = 0.
- While n != 0, repeatedly extract last digit (n % 10), append to rev, and reduce n by dividing by 10.
- Returns reversed number.
For reverse(int[] A):
- Creates a new array B of same length.
- Iterates from end of A to beginning, copying values into B in reverse order.
main() prints both original and reversed results for clarity.

Tips and gotchas:
The number reversal does not handle negatives; logic could be extended for sign handling.
Array reversal allocates a new array; in-place reversal could be more memory-efficient.
Method overloading improves readability but requires clear signatures to avoid confusion.
For production, prefer descriptive names like reverseNumber and reverseArray for clarity.

Use-cases:
Educational demonstration of method overloading in Java.
Utility functions for digit-based problems (palindrome checks, numeric transformations).
Reversing arrays for algorithmic needs (e.g., stack simulation, data reordering).
Foundation for extending into generic reversal utilities.

Short key: class-reverseanumber overloaded-reverse int-and-array.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section10Methods/src/ReverseANumber.java

@@ -2,52 +2,40 @@ public class ReverseANumber {
     int reverse(int n) //For Single Number.
     {
         int rev=0;
-        while (n!=0)
-        {
+        while (n!=0) {
             rev = rev * 10 + n % 10;
             n=n/10;
         }
         return rev;
     }
-
-    int [] reverse(int A[]) //For Array of integers.
+    int[] reverse(int A[]) //For Array of integers.
     {
         int B[] = new int[A.length];
 
         for(int i=A.length-1,j=0;i>=0;i--,j++)
             B[j]=A[i];
         return B;
     }
-
-    public static void main(String[] args)
-    {
+    public static void main(String[] args) {
         ReverseANumber obj = new ReverseANumber();
-
         // Reverse a single number
         int n = 569;
         int reversedNumber = obj.reverse(n);
 
         System.out.println("Original number: " + n);
-
         System.out.println("Reversed number: " + reversedNumber);
 
         // Reverse an array of integers
         int A[] = {2, 4, 6, 7};
-
         System.out.println("\nOriginal array:");
-
-        for (int num : A)
-        {
+        for (int num : A) {
             System.out.print(num + " ");
         }
 
         int[] reversedArray = obj.reverse(A);
-
         System.out.println("\nReversed array:");
-
-        for (int num : reversedArray)
-        {
+        for (int num : reversedArray) {
             System.out.print(num + " ");
         }
     }
-}
+}