Removed Main method and adjusted the test file

Author: justanothercoder-hub

src/main/java/com/thealgorithms/recursion/TowerOfHanoi.java

@@ -2,7 +2,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Scanner;
 
 /**
  * TowerOfHanoi - Solves the classic Tower of Hanoi puzzle
@@ -17,12 +16,12 @@
  * Example: If n = 3, Source = 'A', Destination = 'C', Auxiliary = 'B'
  * Resulting moves will guide disks from A to C using B.
  *
- * @author justanothercoder
+ * @author justanothercoder-hub
  * @see <a href="https://en.wikipedia.org/wiki/Tower_of_Hanoi">Tower of Hanoi</a>
  */
-public final class TowerofHanoi {
+public final class TowerOfHanoi {
 
-    private TowerofHanoi() {
+    private TowerOfHanoi() {
 
         // Utility class
     }
@@ -38,7 +37,7 @@ private TowerofHanoi() {
      */
     public static List<String> solveTowerOfHanoi(int n, char source, char destination, char auxiliary) {
         List<String> moves = new ArrayList<>();
-        if(n < 0) {
+        if (n < 0) {
             throw new IllegalArgumentException("Number of disks cannot be negative");
         }
         moveDisks(n, source, destination, auxiliary, moves);
@@ -63,15 +62,4 @@ private static void moveDisks(int n, char source, char destination, char auxilia
         moves.add("Move disk " + n + " from rod " + source + " to rod " + destination);
         moveDisks(n - 1, auxiliary, destination, source, moves);
     }
-
-    public static void main(String[] args) {
-        Scanner scanner = new Scanner(System.in);
-        System.out.print("Enter the number of disks: ");
-        int n = scanner.nextInt();
-        List<String> result = solveTowerOfHanoi(n, 'A', 'C', 'B');
-
-        for(String move : result){
-            System.out.println(move);
-        }
-     }
-    }
+}

src/test/java/com/thealgorithms/recursion/TowerofHanoiTest.java

@@ -1,6 +1,5 @@
 package com.thealgorithms.recursion;
 
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -12,16 +11,15 @@ public class TowerOfHanoiTest {
 
     /**
      * Test Case 1: Base Case (n = 1)
-     * Requirement: Explicitly requested.
      * Logic: With only 1 disk, it should move directly from Source (A) to Destination (C).
      */
     @Test
     public void testBaseCase() {
         List<String> result = TowerOfHanoi.solveTowerOfHanoi(1, 'A', 'C', 'B');
-        
+
         // Assertion 1: Check size (2^1 - 1 = 1 move)
         assertEquals(1, result.size(), "Should have exactly 1 move for 1 disk");
-        
+
         // Assertion 2: Verify the exact string
         assertEquals("Move disk 1 from rod A to rod C", result.get(0));
     }
@@ -33,16 +31,16 @@ public void testBaseCase() {
     @Test
     public void testSmallRecursion() {
         List<String> result = TowerOfHanoi.solveTowerOfHanoi(2, 'A', 'C', 'B');
-        
+
         // Assertion 1: Check size (2^2 - 1 = 3 moves)
         assertEquals(3, result.size());
-        
+
         // Assertion 2: Verify the exact sequence of moves
         List<String> expected = Arrays.asList("Move disk 1 from rod A to rod B", // Small disk to Aux
             "Move disk 2 from rod A to rod C", // Big disk to Dest
             "Move disk 1 from rod B to rod C" // Small disk to Dest
         );
-        
+
         assertEquals(expected, result, "Sequence of moves for 2 disks is incorrect");
     }
 
@@ -53,22 +51,21 @@ public void testSmallRecursion() {
     @Test
     public void testStandardCase() {
         List<String> result = TowerOfHanoi.solveTowerOfHanoi(3, 'A', 'C', 'B');
-        
+
         // Assertion 1: Check size (2^3 - 1 = 7 moves)
         assertEquals(7, result.size());
-        
+
         // Assertion 2: Verify start and end moves specifically
         assertEquals("Move disk 1 from rod A to rod C", result.get(0)); // First move
         assertEquals("Move disk 1 from rod A to rod C", result.get(6)); // Last move
     }
 
     /**
-     * Extra Test Case: Negative Input
-     * Logic: Ensures your "Defensive Programming" check works.
+     * Illegal Input Case: Negative Input
+     * Logic: Ensures the exception is thrown when n is negative.
      */
     @Test
     public void testNegativeInput() {
-         assertThrows(IllegalArgumentException.class, () -> { TowerOfHanoi.solveTowerOfHanoi(-5, 'A', 'C', 'B'); }, 
-"Should throw exception for negative disks");
+        assertThrows(IllegalArgumentException.class, () -> { TowerOfHanoi.solveTowerOfHanoi(-5, 'A', 'C', 'B'); }, "Should throw exception for negative disks");
     }
 }