Added problems in BinarySearch | BitManipulation | Sorting

Author: Prashant Jain

…gate/dsa/array/SearchInsertPosition.java …earch/problems/SearchInsertPosition.javasrc/in/knowledgegate/dsa/array/SearchInsertPosition.java renamed to src/in/knowledgegate/dsa/binarysearch/problems/SearchInsertPosition.java src/in/knowledgegate/dsa/array/SearchInsertPosition.java renamed to src/in/knowledgegate/dsa/binarysearch/problems/SearchInsertPosition.java

@@ -1,4 +1,4 @@
-package in.knowledgegate.dsa.array;
+package in.knowledgegate.dsa.binarysearch.problems;
 
 /**
  * Given a sorted array of distinct integers and a target value, return the

src/in/knowledgegate/dsa/bitmanipulation/FindTheDifference.java

@@ -0,0 +1,43 @@
+package in.knowledgegate.dsa.bitmanipulation;
+
+/**
+ * You are given two strings s and t.
+ *
+ * String t is generated by random shuffling string
+ * s and then add one more letter at a random position.
+ *
+ * Return the letter that was added to t.
+ *
+ * Example 1:
+ * Input: s = "abcde", t = "abcdee"
+ * Output: "e"
+ * Explanation: 'e' is the letter that was added.
+ *
+ * Example 2:
+ * Input: s = "", t = "y"
+ * Output: "y"
+ *
+ * Constraints:
+ * 0 <= s.length <= 1000
+ * t.length == s.length + 1
+ * s and t consist of lowercase English letters.
+ */
+public class FindTheDifference {
+  public static void main(String[] args) {
+    FindTheDifference diff =
+        new FindTheDifference();
+    System.out.println("Output is:" +
+        diff.findTheDifference("abcde", "abcdee"));
+  }
+
+  public char findTheDifference(String s, String t) {
+    char c = t.charAt(t.length() - 1);
+    for (int i = 0; i < s.length(); i++) {
+      c ^= s.charAt(i) ^ t.charAt(i);
+    }
+    return c;
+  }
+}
+
+
+

src/in/knowledgegate/dsa/sorting/problems/CountElements.java

@@ -0,0 +1,62 @@
+package in.knowledgegate.dsa.sorting.problems;
+
+import java.util.Arrays;
+
+/**
+ * Given an integer array nums, return the number of
+ * elements that have both a strictly smaller and
+ * a strictly greater element appear in nums.
+ *
+ * Example 1:
+ * Input: nums = [11,7,2,15]
+ * Output: 2
+ * Explanation: The element 7 has the element 2 strictly
+ * smaller than it and the element 11 strictly greater than it.
+ * Element 11 has element 7 strictly smaller than it
+ * and element 15 strictly greater than it.
+ * In total there are 2 elements having both a strictly
+ * smaller and a strictly greater element appear in nums.
+ *
+ *  Example 2:
+ * Input: nums = [-3,3,3,90]
+ * Output: 2
+ * Explanation: The element 3 has the element -3
+ * strictly smaller than it and the element 90
+ * strictly greater than it.
+ * Since there are two elements with the value 3,
+ * in total there are 2 elements having both a strictly
+ * smaller and a strictly greater element appear in nums.
+ *
+ * [1,1,1,2,2,3,4,5,5]
+ *
+ * Constraints:
+ * 1 <= nums.length <= 100
+ * -105 <= nums[i] <= 105
+ */
+public class CountElements {
+
+  public static void main(String[] args) {
+    CountElements elements = new CountElements();
+    int[] nums = new int[]{1,1,1,1,1,1};
+    System.out.println("output is:" + elements.countElements(nums));
+  }
+
+  public int countElements(int[] nums) {
+    Arrays.sort(nums);
+    int beg = -1, end = -1;
+    for (int i = 0; i < nums.length - 1; i++) {
+      if (nums[i + 1] > nums[i]) {
+        beg = i + 1;
+        break;
+      }
+    }
+    for (int i = nums.length - 1; i > 0; i--) {
+      if (nums[i-1] < nums[i]) {
+        end = i - 1;
+        break;
+      }
+    }
+    return beg != -1 && end != -1 ? end - beg + 1
+        : 0;
+  }
+}

src/in/knowledgegate/dsa/sorting/problems/MergeSortedArray.java

@@ -0,0 +1,78 @@
+package in.knowledgegate.dsa.sorting.problems;
+
+import java.util.Arrays;
+
+/**
+ * You are given two integer arrays nums1 and
+ * nums2, sorted in non-decreasing order, and two
+ * integers m and n, representing the number of
+ * elements in nums1 and nums2 respectively.
+ *
+ * Merge nums1 and nums2 into a single array
+ * sorted in non-decreasing order.
+ *
+ * The final sorted array should not be returned
+ * by the function, but instead be stored inside
+ * the array nums1. To accommodate this, nums1 has
+ * a length of m + n, where the first m elements
+ * denote the elements that should be merged, and
+ * the last n elements are set to 0 and should be
+ * ignored. nums2 has a length of n.
+ *
+ *
+ * Example 1:
+ * Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 =
+ * [2,5,6], n = 3 Output: [1,2,2,3,5,6]
+ * Explanation: The arrays we are merging are
+ * [1,2,3] and [2,5,6]. The result of the merge is
+ * [1,2,2,3,5,6] with the underlined elements
+ * coming from nums1.
+ *
+ * Example 2:
+ * Input: nums1 = [1], m = 1, nums2 = [], n = 0
+ * Output: [1] Explanation: The arrays we are
+ * merging are [1] and []. The result of the merge
+ * is [1].
+ *
+ * Example 3:
+ * Input: nums1 = [0], m = 0, nums2 = [1], n = 1
+ * Output: [1] Explanation: The arrays we are
+ * merging are [] and [1]. The result of the merge
+ * is [1]. Note that because m = 0, there are no
+ * elements in nums1. The 0 is only there to
+ * ensure the merge result can fit in nums1.
+ *
+ * Constraints:
+ * nums1.length == m + n nums2.length == n 0 <= m,
+ * n <= 200 1 <= m + n <= 200 -109 <= nums1[i],
+ * nums2[j] <= 109
+ */
+public class MergeSortedArray {
+
+  public static void main(String[] args) {
+    MergeSortedArray merge =
+        new MergeSortedArray();
+    int[] nums1 = new int[]{1,2,3,0,0,0,0};
+    int[] nums2 = new int[]{0,2,5,6};
+    merge.merge(nums1, 3, nums2, 4);
+    System.out.println("Output is:" + Arrays.toString(nums1));
+  }
+
+  public void merge(int[] nums1, int m,
+                    int[] nums2, int n) {
+    int i = m - 1;
+    int j = n - 1;
+    int k = m + n - 1;
+    while (i >= 0 && j >= 0) {
+      if (nums1[i] >= nums2[j]) {
+        nums1[k--] = nums1[i--];
+      } else {
+        nums1[k--] = nums2[j--];
+      }
+    }
+
+    while (j >= 0) {
+      nums1[k--] = nums2[j--];
+    }
+  }
+}