<a id="markdown-bash" name="bash"></a>
Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.
Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length.

Return the indices of the two numbers, index1 and index2, added by one as an integer array [index1, index2] of length 2.
<a id="markdown-return-the-indices-of-the-two-numbers%2C-index1-and-index2%2C-added-by-one-as-an-integer-array-%5Bindex1%2C-index2%5D-of-length-2." name="return-the-indices-of-the-two-numbers%2C-index1-and-index2%2C-added-by-one-as-an-integer-array-%5Bindex1%2C-index2%5D-of-length-2."></a>

The tests are generated such that there is exactly one solution. You may not use the same element twice.

Your solution must use only constant extra space.

Input: numbers = [2,7,11,15], target = 9
Output: [1,2]
Explanation: The sum of 2 and 7 is 9. Therefore, index1 = 1, index2 = 2. We return [1, 2].

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
<a id="markdown-you-are-given-an-integer-array-height-of-length-n.-there-are-n-vertical-lines-drawn-such-that-the-two-endpoints-of-the-ith-line-are-i%2C-0-and-i%2C-height%5Bi%5D." name="you-are-given-an-integer-array-height-of-length-n.-there-are-n-vertical-lines-drawn-such-that-the-two-endpoints-of-the-ith-line-are-i%2C-0-and-i%2C-height%5Bi%5D."></a>

Find two lines that together with the x-axis form a container, such that the container contains the most water.

Return the maximum amount of water a container can store.

Notice that you may not slant the container.

Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.

Notice that the solution set must not contain duplicate triplets.

 

Example 1:

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

 public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        
        for (int i = 0; i <= nums.length - 3; i++) {
            // 不能大于 0
            if (nums[i] > 0) {
                return res;
            }
             // 去重  nums[i] == nums[i + 1] 就排斥-1， -1 ， 2，或者 0， 0， 0
             if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int k = i + 1, j = nums.length - 1;
            while (k < j) {
                int sum = nums[i] + nums[k] + nums[j];
                if (sum > 0) {
                    j--;
                } else if (sum < 0) {
                    k++;
                } else {
                    res.add(Arrays.asList(nums[i], nums[k], nums[j]));
                    // 去重
                    while (k <a j && nums[j] == nums[j - 1]) j--;
<a id="markdown-while-k-%3C-j-%26%26-nums%5Bj%5D-%3D%3D-nums%5Bj---1%5D-j--%3B" name="while-k-%3C-j-%26%26-nums%5Bj%5D-%3D%3D-nums%5Bj---1%5D-j--%3B"></a>
                     while (k < j && nums[k] == nums[k + 1]) k++;
                    j--;
                    k++;
                }
            }
             
        }
        return res;
    }

Given an integer array nums of length n 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 1:

Input: nums = [-1,2,1,-4], target = 1
Output: 2
Explanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

 public int threeSumClosest(int[] nums, int target) {
        
       
        Arrays.sort(nums);
         int res = nums[0] + nums[1] + nums[nums.length - 1];
        for (int i = 0; i <= nums.length - 3; i++) {
            int k = i + 1, j = nums.length - 1;
            
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            while (k < j) {
                int sum = nums[i] +nums[k] +nums[j];
                if (Math.abs(sum - target) < Math.abs(res - target)) {
                    res = sum;
                }
                    
                 if (sum== target) {
                    
                  
                     return sum;
                } else if (sum > target) {
                    j--;
                } else {
                    k++;
                }
            }
        }
          return res;
           
    }