init commit

project-1/src/utils/PermutationsGenerator.java

@@ -0,0 +1,94 @@
+package src.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Provides functionality to generate all permutations of n integers in lexicographic (dictionary) order.
+ * The integers in each permutation range from 0 to n-1.
+ *
+ * @author Sean White
+ *
+ * <p><strong>Usage Example:</strong></p>
+ * <pre>
+ * {@code
+ *   PermutationsGenerator generator = new PermutationsGenerator();
+ *   int[][] permutationsFor3 = generator.generate(3);
+ *   for (int[] permutation : permutationsFor3) {
+ *       System.out.println(Arrays.toString(permutation));
+ *   }
+ * }
+ * </pre>
+ *
+ * The above code will generate and print all permutations for n=3 in lexicographic order:
+ * <pre>
+ * [0, 1, 2]
+ * [0, 2, 1]
+ * [1, 0, 2]
+ * [1, 2, 0]
+ * [2, 0, 1]
+ * [2, 1, 0]
+ * </pre>
+ */
+public class PermutationsGenerator {
+
+    /**
+     * Generates all permutations of n integers in lexicographic order.
+     *
+     * @param n The number of integers in each permutation.
+     * @return A 2D array where each row represents a permutation.
+     */
+    public static int[][] generate(int n) {
+        List<int[]> results = new ArrayList<>();
+
+        // Initialize with the smallest permutation (i.e., [0, 1, 2, ..., n-1])
+        int[] current = new int[n];
+        for (int i = 0; i < n; i++) {
+            current[i] = i;
+        }
+        results.add(current.clone());
+
+        while (true) {
+            // Identify the rightmost pair (i, i+1) where current[i] < current[i+1]
+            int i;
+            for (i = n - 2; i >= 0; i--) {
+                if (current[i] < current[i + 1]) {
+                    break;
+                }
+            }
+            // If no such pair exists, we have generated all permutations
+            if (i == -1) {
+                break;
+            }
+
+            // Identify the largest index j > i such that current[i] < current[j]
+            int j;
+            for (j = n - 1; j > i; j--) {
+                if (current[i] < current[j]) {
+                    break;
+                }
+            }
+
+            // Swap elements at indices i and j
+            int temp = current[i];
+            current[i] = current[j];
+            current[j] = temp;
+
+            // Reverse the elements after index i to get the next permutation in lexicographic order
+            int start = i + 1, end = n - 1;
+            while (start < end) {
+                temp = current[start];
+                current[start] = current[end];
+                current[end] = temp;
+                start++;
+                end--;
+            }
+
+            // Store the new permutation
+            results.add(current.clone());
+        }
+
+        // Convert the list of permutations to a 2D array for the final result
+        return results.toArray(new int[0][0]);
+    }
+}