add

Author: shashankch

src/LeetcodeQuestions/SubsetSum.java

@@ -0,0 +1,65 @@
+package LeetcodeQuestions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SubsetSum {
+
+
+
+    public static void helper(int arr[], int tar, int sum, int i, List<Integer> out,
+            List<List<Integer>> res) {
+
+
+        if (sum > tar) {
+            return;
+        }
+        if (tar == sum) {
+
+            res.add(new ArrayList<>(out));
+            return;
+        }
+
+
+        for (int k = i; k < arr.length; k++) {
+
+            out.add(arr[k]);
+            helper(arr, tar, sum + arr[k], k, out, res);
+            out.remove(out.size() - 1);
+        }
+
+
+
+    }
+
+
+    public static List<List<Integer>> combSum(int arr[], int tar) {
+
+        List<Integer> out = new ArrayList<>();
+        List<List<Integer>> res = new ArrayList<>();
+        helper(arr, tar, 0, 0, out, res);
+
+        return res;
+
+
+    }
+
+
+
+    public static void main(String[] args) {
+
+        int arr[] = {2, 3, 6, 7};
+        int tar = 7;
+        for (List<Integer> li : combSum(arr, tar)) {
+
+            System.out.println(li);
+
+        }
+
+
+
+    }
+
+
+
+}

src/LeetcodeQuestions/uniquePath.java

@@ -0,0 +1,31 @@
+package LeetcodeQuestions;
+
+import recursion.quicksort;
+
+// https://leetcode.com/problems/unique-paths/
+// https://leetcode.com/problems/unique-paths-ii/
+public class uniquePath {
+
+   
+
+    public static boolean uniquePathone() {
+
+
+
+
+
+    }
+
+
+
+    public static void main(String[] args) {
+
+        int arr[][]={{0,0,0},{0,1,0},{0,0,0}};
+      
+       
+
+        System.out.println();
+
+    }
+
+}

src/arrays/AlternateArrayarrange.java

@@ -0,0 +1,40 @@
+package arrays;
+
+public class AlternateArrayarrange {
+
+
+    public static int[] helper(int n) {
+
+
+
+        int arr[] = new int[n];
+        int val = 1, s = 0, e = n - 1;
+        while (s < e) {
+
+
+            arr[s] = val;
+            val++;
+            arr[e] = val;
+
+            val++;
+
+            s++;
+            e--;
+
+        }
+
+        if (n % 2 != 0) {
+
+            arr[s] = val;
+        }
+
+
+        return arr;
+
+    }
+
+
+    public static void main(String[] args) {
+
+    }
+}

src/arrays/IntersectionArrays.java

@@ -0,0 +1,32 @@
+package arrays;
+
+public class IntersectionArrays {
+
+
+    public static void helper(int[] input1, int[] input2) {
+
+        int n = input1.length;
+        int m = input2.length;
+
+        for (int i = 0; i < n; i++) {
+
+            for (int j = 0; j < m; j++) {
+
+
+                if (input1[i] == input2[j]) {
+
+                    System.out.println(input1[i]);
+                    input2[j] = Integer.MIN_VALUE;
+                    break;
+
+                }
+            }
+        }
+
+    }
+
+    public static void main(String[] args) {
+
+    }
+
+}

src/arrays/arraySum.java

@@ -0,0 +1,45 @@
+package arrays;
+
+public class arraySum {
+
+
+    public static int sum(int[] input) {
+
+        int sum = 0;
+        for (int i = 0; i < input.length; i++) {
+
+            sum += input[i];
+
+
+        }
+
+
+        return sum;
+
+    }
+
+    public static int linearSearch(int[] arr, int num) {
+
+
+        for (int i = 0; i < arr.length; i++) {
+
+
+            if (arr[i] == num) {
+
+                return i;
+            }
+
+
+        }
+
+        return -1;
+
+
+    }
+
+    public static void main(String[] args) {
+
+    }
+
+
+}

src/arrays/swapAlternate.java

@@ -0,0 +1,27 @@
+package arrays;
+
+public class swapAlternate {
+
+
+    public static void helper(int[] input) {
+
+        int n = input.length;
+        for (int i = 0; i < n - 1; i += 2) {
+
+
+
+            int temp = input[i];
+            input[i] = input[i + 1];
+            input[i + 1] = temp;
+
+
+
+        }
+
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+}

src/arrays/uniqueElement.java

@@ -0,0 +1,75 @@
+package arrays;
+
+public class uniqueElement {
+
+
+    public static int uniquehelper(int[] arr) {
+
+        int pos = -1;
+        boolean unique = true;
+        int i, j;
+        for (i = 0; i < arr.length; i++) {
+
+            unique = true;
+            for (j = 0; j < arr.length; j++) {
+
+
+                if (i != j && arr[i] == arr[j]) {
+                    unique = false;
+                }
+
+
+            }
+            if (unique) {
+
+
+                pos = i;
+                break;
+
+            }
+
+        }
+
+
+
+        return arr[pos];
+
+
+
+    }
+
+
+    public static int duplicatehelper(int[] arr) {
+
+        int pos = -1;
+
+        int i, j;
+        for (i = 0; i < arr.length; i++) {
+
+
+            for (j = 0; j < arr.length; j++) {
+
+
+                if (i != j && arr[i] == arr[j]) {
+
+                    pos = i;
+
+                    break;
+
+                }
+
+            }
+        }
+
+
+
+        return arr[pos];
+
+    }
+
+
+
+    public static void main(String[] args) {
+
+    }
+}