Added Array Function: Generate All Permutations (n!)

Array_Functions/Permutations/permutations_iterative.cpp

@@ -0,0 +1,41 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+
+using namespace std;
+
+template <typename T>
+vector<vector<T>> generatePermutations(vector<T> arr) {
+    vector<vector<T>> permutations;
+    sort(arr.begin(), arr.end());
+    permutations.push_back(arr);
+    while (true) {
+        int i = arr.size()-2;
+        while (i >= 0 && arr[i] >= arr[i + 1]) {
+            i--;
+        }
+        if (i < 0) break;
+        int j = arr.size()-1;
+        while (arr[j] <= arr[i]) {
+            j--;
+        }
+        swap(arr[i], arr[j]);
+        reverse(arr.begin() + i + 1, arr.end());
+        permutations.push_back(arr);
+    }
+    return permutations;
+}
+
+int main() {
+    vector<int> arr = {1, 3, 2};
+    vector<vector<int>> permutations = generatePermutations(arr);
+
+    for (const auto& perm : permutations) {
+        for (const auto& elem : perm) {
+            cout << elem << " ";
+        }
+        cout << endl;
+    }
+
+    return 0;
+}

Array_Functions/Permutations/permutations_iterative.java

@@ -0,0 +1,39 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class Main {
+    public static <T extends Comparable<T>> List<List<T>> generatePermutations(List<T> arr) {
+        List<List<T>> permutations = new ArrayList<>();
+        Collections.sort(arr);
+        permutations.add(new ArrayList<>(arr));
+        while (true) {
+            int i = arr.size() - 2;
+            while (i >= 0 && arr.get(i).compareTo(arr.get(i + 1)) >= 0) {
+                i--;
+            }
+            if (i < 0) break;
+            int j = arr.size() - 1;
+            while (arr.get(j).compareTo(arr.get(i)) <= 0) {
+                j--;
+            }
+            Collections.swap(arr, i, j);
+            Collections.reverse(arr.subList(i + 1, arr.size()));
+            permutations.add(new ArrayList<>(arr));
+        }
+        return permutations;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> arr = Arrays.asList(1, 3, 2);
+        List<List<Integer>> permutations = generatePermutations(arr);
+
+        for (List<Integer> perm : permutations) {
+            for (Integer elem : perm) {
+                System.out.print(elem + " ");
+            }
+            System.out.println();
+        }
+    }
+}

Array_Functions/Permutations/permutations_iterative.py

@@ -0,0 +1,27 @@
+def generate_permutations(arr):
+    permutations = []
+    arr.sort()
+    permutations.append(arr[:])
+
+    while True:
+        i = len(arr) - 2
+        while i >= 0 and arr[i] >= arr[i + 1]:
+            i -= 1
+        if i < 0:
+            break
+        j = len(arr) - 1
+        while arr[j] <= arr[i]:
+            j -= 1
+
+        arr[i], arr[j] = arr[j], arr[i]
+        arr = arr[:i + 1] + arr[i + 1:][::-1]
+        permutations.append(arr[:])
+
+    return permutations
+
+if __name__ == "__main__":
+    arr = ['a', 'b', 'c', 'd']
+    permutations = generate_permutations(arr)
+
+    for perm in permutations:
+        print(" ".join(map(str, perm)))

Array_Functions/Permutations/permutations_recursive.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+template <typename T>
+void generatePermutations(vector<T>& arr, int l, int r, vector<vector<T>>& result) {
+    if (l == r) {
+        result.push_back(arr);
+    } else {
+        for (int i = l; i <= r; i++) {
+            swap(arr[l], arr[i]);
+            generatePermutations(arr, l + 1, r, result);
+            swap(arr[l], arr[i]);
+        }
+    }
+}
+
+template <typename T>
+vector<vector<T>> getPermutations(vector<T> arr) {
+    vector<vector<T>> result;
+    generatePermutations(arr, 0, arr.size() - 1, result);
+    return result;
+}
+
+int main() {
+    vector<int> arr = {1, 2, 4, 3};
+    vector<vector<int>> permutations = getPermutations(arr);
+
+    for (const auto& perm : permutations) {
+        for (const auto& elem : perm) {
+            cout << elem << " ";
+        }
+        cout << endl;
+    }
+
+    return 0;
+}

Array_Functions/Permutations/permutations_recursive.java

@@ -0,0 +1,46 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Permutations {
+
+    private static <T> void generatePermutations(List<T> arr, int l, int r, List<List<T>> result) {
+        if (l == r) {
+            result.add(new ArrayList<>(arr));
+        } else {
+            for (int i = l; i <= r; i++) {
+                swap(arr, l, i);
+                generatePermutations(arr, l + 1, r, result);
+                swap(arr, l, i);
+            }
+        }
+    }
+
+    private static <T> List<List<T>> getPermutations(List<T> arr) {
+        List<List<T>> result = new ArrayList<>();
+        generatePermutations(arr, 0, arr.size() - 1, result);
+        return result;
+    }
+
+    private static <T> void swap(List<T> arr, int i, int j) {
+        T temp = arr.get(i);
+        arr.set(i, arr.get(j));
+        arr.set(j, temp);
+    }
+
+    public static void main(String[] args) {
+        List<Integer> arr = new ArrayList<>();
+        arr.add(1);
+        arr.add(2);
+        arr.add(4);
+        arr.add(3);
+        List<List<Integer>> permutations = getPermutations(arr);
+
+        for (List<Integer> perm : permutations) {
+            for (Integer elem : perm) {
+                System.out.print(elem + " ");
+            }
+            System.out.println();
+        }
+    }
+}
+

Array_Functions/Permutations/permutations_recursive.py

@@ -0,0 +1,20 @@
+def generate_permutations(arr, l, r, result):
+    if l == r:
+        result.append(arr[:])
+    else:
+        for i in range(l, r + 1):
+            arr[l], arr[i] = arr[i], arr[l]
+            generate_permutations(arr, l + 1, r, result)
+            arr[l], arr[i] = arr[i], arr[l]
+
+def get_permutations(arr):
+    result = []
+    generate_permutations(arr, 0, len(arr) - 1, result)
+    return result
+
+if __name__ == "__main__":
+    arr = ['a', 'b', 'c']
+    permutations = get_permutations(arr)
+
+    for perm in permutations:
+        print(" ".join(map(str, perm)))

RoadMap.md

@@ -15,7 +15,7 @@ These are fundamental algorithms and functions often used in competitive program
 - [x] [Binary Search](Array_Functions/Binary_Search)
 - [x] [Upper bound](Array_Functions/Upper_Bound)
 - [x] [Lower bound (Binary Search)](Array_Functions/Lower_Bound_Binary_Search)
-- [ ] Generate all Permutation (n!)
+- [x] [Generate all Permutation (n!)](Array_Functions/Permutations)
 - [x] [Count occurrences of all elements](Array_Functions/Count_Occurence) 
 
 ### 2. String Algorithms