Question 1.Two Sum - not sorted array and pick two element

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> hashmap = new HashMap<Integer, Integer>();

        for(int i =0; i< nums.length; i++){
            hashmap.put(nums[i], i);
        }

        for(int i = 0; i < nums.length; i++){
            if(hashmap.containsKey(target - nums[i]) && hashmap.get(target - nums[i]) != i ){
                return new int[]{i, hashmap.get(target-nums[i])};
            }
        }
        return null;
    }
}

Question 2. Two Sum - sorted array and pick two element

• Input:numbers={2, 7, 11, 15}, target=9 Output : index1=1, index2=2
• Original

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] res = new int[2];

        for(int i = 0; i < numbers.length; i++){
            int bigIdx = search(numbers, i+1, numbers.length-1, target - numbers[i]);
            if(bigIdx != Integer.MIN_VALUE){
                res[0] = i+1;
                res[1] = bigIdx+1;
                break;
            }

        }
        return res;

    }
    public int search(int[] numbers, int l, int r, int target){
        if( l < 0 || r > numbers.length-1){
            return Integer.MIN_VALUE;
        }
        if(l > r){
            return Integer.MIN_VALUE;
        }

        int m = (l+r)/2;

        if(numbers[m] < target){
            return search(numbers, m+1, r, target);
        }
        if(numbers[m] > target){
            return search(numbers, l, m-1, target);
        }
        return m;
    }
}

• Upgard

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int l = 0;
        int r = numbers.length-1;

        while(numbers[l] + numbers[r] != target){
            if(numbers[l] + numbers[r] > target){
                r--;
            }else{
                l++;
            }
        }
        return new int[]{l+1, r+1};
    }
}

Question 3. Intersection of Two Arrays

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1.length == 0 || nums2.length == 0){
            return new int[]{};
        }
        HashSet<Integer> set = new HashSet<Integer>();
        HashSet<Integer> res = new HashSet<Integer>();

        for(int item : nums1){
            set.add(item);
        }
        for(int item : nums2){
            if(set.contains(item)){
                res.add(item);
            }
        }
        return res.stream().mapToInt(i->i).toArray() == null ? new int[]{} : res.stream().mapToInt(i->i).toArray();  
    }
}