leetcode 16. 3sum closest

Author: kalpak92

Hashing/TwoSum.java

@@ -0,0 +1,37 @@
+/*
+ * Given an array of integers, return indices of the two numbers such that they
+ * add up to a specific target.
+ *
+ * You may assume that each input would have exactly one solution, and you may
+ * not use the same element twice.
+ *
+ * Example:
+ *
+ * Given nums = [2, 7, 11, 15], target = 9,
+ *
+ * Because nums[0] + nums[1] = 2 + 7 = 9, return [0, 1].
+ */
+
+class TwoSum {
+    public int[] twoSum(int[] nums, int target) {
+        HashMap<Integer, Integer> diffMap = new HashMap<>();
+        
+        for (int i = 0; i < nums.length; i++)
+        {
+            if(diffMap.containsKey(nums[i]))
+            {
+                return new int[]{diffMap.get(nums[i]), i};
+            }
+            else {
+                diffMap.put((target - nums[i]), i);
+            }
+        }
+        
+        throw new IllegalArgumentException("No two sum solution.");
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {2, 7, 11, 15};
+        int target = 9;
+    }
+}

LeetCode/1. Two Sum/Solution.java

@@ -0,0 +1,32 @@
+/*
+ * Given an array of integers, return indices of the two numbers such that they
+ * add up to a specific target.
+ *
+ * You may assume that each input would have exactly one solution, and you may
+ * not use the same element twice.
+ *
+ * Example:
+ *
+ * Given nums = [2, 7, 11, 15], target = 9,
+ *
+ * Because nums[0] + nums[1] = 2 + 7 = 9, return [0, 1].
+ */
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        HashMap<Integer, Integer> diffMap = new HashMap<>();
+        
+        for (int i = 0; i < nums.length; i++)
+        {
+            if(diffMap.containsKey(nums[i]))
+            {
+                return new int[]{diffMap.get(nums[i]), i};
+            }
+            else {
+                diffMap.put((target - nums[i]), i);
+            }
+        }
+        
+        throw new IllegalArgumentException("No two sum solution.");
+    }
+}

LeetCode/16. 3Sum closest/Solution.java

@@ -0,0 +1,40 @@
+/**
+ * Given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to target. 
+ * Return the sum of the three integers. You may assume that each input would have exactly one solution.
+ * 
+ * Example:
+ * 
+ * Given array nums = [-1, 2, 1, -4], and target = 1.
+ * The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+ */
+
+ class Solution {
+    public int threeSumClosest(int[] nums, int target) {
+        Arrays.sort(nums);
+        int closest = nums[0] + nums[1] + nums[2];
+            
+        for(int i = 0; i < nums.length; i++)
+        {
+            int left = i + 1;
+            int right = nums.length - 1;
+            
+            while(left < right)
+            {
+                int sum = nums[left] + nums[right] + nums[i];
+                
+                if(Math.abs(sum - target) < Math.abs(closest - target))  //check for closeness
+                    closest = sum;
+                
+                if(sum > target)
+                    right --;
+                
+                if(sum < target)
+                    left ++;
+                
+                if(sum == target)
+                    return closest;
+            }
+        }
+        return closest;
+    }
+}

LeetCode/README.md

@@ -1,5 +1,8 @@
 # Leetcode Problems
 
+## Arrays
+- [x] [Two Sum](https://github.com/kalpak92/DataStructures_Algorithms/tree/master/LeetCode/1.%20Two%20Sum)
+- [x] [3Sum Closest]()
 ## Linked List
 
 - [x] [Add Two Numbers](https://github.com/kalpak92/DataStructures_Algorithms/tree/master/LeetCode/2.%20Add%20Two%20Numbers)

Search Algorithms/CheckForDuplicatedInAArray.py renamed to Search Algorithms/Problems/CheckForDuplicatedInAArray.py

@@ -0,0 +1,47 @@
+/**
+ * An Array of integers is given, both +ve and -ve. 
+ * You need to find the two elements such that their sum is closest to zero.
+ */
+
+import java.util.*;
+import java.lang.*;
+public class SumClosestToZero
+{
+    public void twoSumCloseToZero(int[] arr)
+    {
+        int i = 0;
+        int n = arr.length;
+        int j = n - 1;
+        int sum = Integer.MAX_VALUE;
+        int minSum = Integer.MAX_VALUE;
+
+        int min_l = i;
+        int min_r = n - 1;
+        
+        Arrays.sort(arr);
+
+        while(i < j)
+        {
+            sum = arr[i] + arr[j];
+            if(Math.abs(sum) < Math.abs(minSum))
+            {
+                minSum = sum;
+                min_l = i;
+                min_r = j;
+            }
+            if (sum < 0)
+                i++;
+            else
+                j--;            
+        }
+
+        System.out.println("The two elements whose sum is minimum are : " + arr[min_l] + " " + arr[min_r]);
+    }
+
+    public static void main(String[] args) {
+        SumClosestToZero obj  = new SumClosestToZero();
+        int arr[] = {1, 60, -10, 70, -80, 85};
+
+        obj.twoSumCloseToZero(arr);
+    }
+}