resolved code style violations

Author: Darshan-Baligeri

src/main/java/com/thealgorithms/shufflealogrithm/ConstrainedShuffle.java

@@ -1,59 +1,41 @@
 package com.thealgorithms.shufflealogrithm;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.Arrays;
+import java.util.Random;
 
-public class ConstrainedShuffle {
+public final class ConstrainedShuffle {
 
     private ConstrainedShuffle() {
         // Prevent instantiation
     }
 
     /**
-     * Shuffles the array so that no element stays in its original position.
+     * Shuffles elements in the array while ensuring that the first and last elements remain fixed.
      *
-     * @param array the input array to shuffle with constraints
+     * @param array the input array to shuffle
      */
     public static void constrainedShuffle(int[] array) {
-        // Edge case: Check if array has only one element (no valid shuffle possible)
-        if (array == null || array.length <= 1) {
+        // Edge case: If the array has less than 3 elements, no shuffling can occur
+        if (array == null || array.length < 3) {
             return;
         }
 
-        List<Integer> shuffledList = new ArrayList<>();
-        for (int num : array) {
-            shuffledList.add(num);
-        }
-
-        do {
-            Collections.shuffle(shuffledList);
-        } while (!isValidShuffle(array, shuffledList));
+        Random random = new Random();
+        for (int i = array.length - 1; i > 1; i--) {
+            // Generate a random index between 1 and i (inclusive)
+            int j = random.nextInt(i - 1) + 1;
 
-        for (int i = 0; i < array.length; i++) {
-            array[i] = shuffledList.get(i);
+            // Swap the elements at positions i and j
+            int temp = array[i]; // Temporarily store the element at i
+            array[i] = array[j]; // Move element from j to i
+            array[j] = temp;     // Place the stored element in position j
         }
     }
 
-    /**
-     * Verifies that no element is in its original position in the shuffled list.
-     */
-    private static boolean isValidShuffle(int[] original, List<Integer> shuffled) {
-        for (int i = 0; i < original.length; i++) {
-            if (original[i] == shuffled.get(i)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
     public static void main(String[] args) {
-        int[] array = {1, 2, 3, 4};
+        int[] array = {1, 2, 3, 4, 5};
+        System.out.println("Original Array: " + Arrays.toString(array));
         constrainedShuffle(array);
-
-        System.out.println("Constrained Shuffled Array:");
-        for (int num : array) {
-            System.out.print(num + " ");
-        }
+        System.out.println("Constrained Shuffled Array: " + Arrays.toString(array));
     }
 }

src/main/java/com/thealgorithms/shufflealogrithm/GroupShuffle.java

@@ -4,53 +4,46 @@
 import java.util.Collections;
 import java.util.List;
 
-public class GroupShuffle {
+public final class GroupShuffle {
 
     private GroupShuffle() {
         // Prevent instantiation
     }
 
     /**
-     * Divides the array into k equal-sized groups and shuffles each group separately.
-     * Returns an empty list if the group count exceeds the array length.
+     * Groups and shuffles elements in the array.
      *
-     * @param array the input array to split into groups
-     * @param k     the number of groups to create
-     * @return a list of groups, where each group is a shuffled sublist of the input array
+     * @param array the input array to shuffle
+     * @param groupSize the size of each group
+     * @return a list of shuffled groups
      */
-    public static List<List<Integer>> groupShuffle(int[] array, int k) {
+    public static List<List<Integer>> groupShuffle(int[] array, int groupSize) {
         List<List<Integer>> groups = new ArrayList<>();
 
-        // Edge case: Check if grouping is possible
-        if (k > array.length || k <= 0) {
+        // Edge case: Check if the group size is valid
+        if (array == null || groupSize <= 0) {
             return groups;
         }
 
-        List<Integer> shuffledList = new ArrayList<>();
-        for (int num : array) {
-            shuffledList.add(num);
-        }
-        Collections.shuffle(shuffledList);
-
-        int groupSize = array.length / k;
-        int remainder = array.length % k;
-
-        // Distribute elements into k groups
-        for (int i = 0; i < k; i++) {
-            int end = (i + 1) * groupSize + (i < remainder ? 1 : 0);
-            groups.add(new ArrayList<>(shuffledList.subList(i * groupSize + Math.min(i, remainder), end)));
+        for (int i = 0; i < array.length; i += groupSize) {
+            List<Integer> group = new ArrayList<>();
+            for (int j = i; j < Math.min(i + groupSize, array.length); j++) {
+                group.add(array[j]);
+            }
+            groups.add(group);
         }
 
+        // Shuffle the groups to randomize their order
+        Collections.shuffle(groups);
         return groups;
     }
 
     public static void main(String[] args) {
-        int[] array = {1, 2, 3, 4, 5, 6};
-        int k = 3;
-        List<List<Integer>> groups = groupShuffle(array, k);
+        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        List<List<Integer>> shuffledGroups = groupShuffle(array, 3);
 
         System.out.println("Shuffled Groups:");
-        for (List<Integer> group : groups) {
+        for (List<Integer> group : shuffledGroups) {
             System.out.println(group);
         }
     }

src/main/java/com/thealgorithms/shufflealogrithm/ShuffleByRange.java

@@ -2,43 +2,45 @@
 
 import java.util.Random;
 
-public class ShuffleByRange {
+public final class ShuffleByRange {
 
     private ShuffleByRange() {
         // Prevent instantiation
     }
 
     /**
-     * Shuffles elements within a specified index range, leaving elements outside this range unchanged.
+     * Shuffles elements in the specified range of the array.
      *
      * @param array the input array to shuffle
-     * @param start starting index of the range to shuffle
-     * @param end   ending index of the range to shuffle
+     * @param start the starting index of the range (inclusive)
+     * @param end   the ending index of the range (exclusive)
      */
-    public static void shuffleRange(int[] array, int start, int end) {
-        // Edge case handling
-        if (array == null || start < 0 || end >= array.length || start >= end) {
+    public static void shuffleByRange(int[] array, int start, int end) {
+        // Edge case: Check if the range is valid
+        if (array == null || start < 0 || end > array.length || start >= end) {
             return;
         }
 
         Random random = new Random();
+        for (int i = end - 1; i > start; i--) {
+            int j = random.nextInt(i - start + 1) + start;
 
-        // Shuffle elements only in the specified range
-        for (int i = end; i > start; i--) {
-            int j = start + random.nextInt(i - start + 1);
-            int temp = array[i];
-            array[i] = array[j];
-            array[j] = temp;
+            // Swap the elements at positions i and j
+            int temp = array[i]; // Temporarily store the element at i
+            array[i] = array[j]; // Move element from j to i
+            array[j] = temp;     // Place the stored element in position j
         }
     }
 
     public static void main(String[] args) {
-        int[] array = {10, 20, 30, 40, 50, 60};
-        int start = 1;
-        int end = 4;
-        shuffleRange(array, start, end);
+        int[] array = {1, 2, 3, 4, 5, 6};
+        System.out.println("Original Array: ");
+        for (int num : array) {
+            System.out.print(num + " ");
+        }
 
-        System.out.println("Array after shuffling range:");
+        shuffleByRange(array, 1, 5);
+        System.out.println("\nShuffled Array (Range 1 to 5): ");
         for (int num : array) {
             System.out.print(num + " ");
         }

src/main/java/com/thealgorithms/shufflealogrithm/UnderstandingShuffleAlgo.java

@@ -2,7 +2,7 @@
 
 import java.util.Random;
 
-public class UnderstandingShuffleAlgo {
+public final class UnderstandingShuffleAlgo {
 
     private UnderstandingShuffleAlgo() {
         // Prevent instantiation

src/main/java/com/thealgorithms/shufflealogrithm/UniquePairShuffle.java

@@ -4,7 +4,7 @@
 import java.util.Collections;
 import java.util.List;
 
-public class UniquePairShuffle {
+public final class UniquePairShuffle {
 
     private UniquePairShuffle() {
         // Prevent instantiation
@@ -21,9 +21,7 @@ public static List<int[]> pairShuffle(int[] array) {
         List<int[]> pairs = new ArrayList<>();
 
         // Handle edge case: If the array length is odd, pairing is not possible
-        if (array.length % 2 != 0) {
-            return pairs;
-        }
+        if (array.length % 2 != 0) return pairs;
 
         List<Integer> shuffledList = new ArrayList<>();
         for (int num : array) {

src/main/java/com/thealgorithms/shufflealogrithm/WeightedShuffle.java

@@ -3,7 +3,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class WeightedShuffle {
+public final class WeightedShuffle {
 
     private WeightedShuffle() {
         // Prevent instantiation