well! Here is CH who is learning programming.

Recently, I searched the Internet for answers to questions about LeetCode, and found that there were not many answers, so I came to do one. This is the first article. I hope you like it!

New arrivals, please take care!

I heard for the first time that LeetCode was in station b. at that time, in order to find some topics to consolidate my foundation and find a website for practice, I found this website which is almost a must for programmers——

Li Kou ， leetcode CN com/? utm_ source=LCUS&utm_ medium=ip_ redirect&utm_ campaign=transfer2china

Start practicing above and start from the first question.

Let's get to the point: the requirements are as follows:

The first time was a mistake, so I won't show it to you.

The second time I thought, to output a one-dimensional array, I had to set one first

int[] nums2 = new int[2];

Then, to find two numbers nums[i] and nums[j] from nums so that the sum is exactly the target, set two-layer loops, fill in the qualified I and j in nums2, and finally output nums2 Therefore, the overall code of the second is as follows:

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] nums2 = new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    nums2[0] = i;
                    nums2[1] = j;
                }
            }
        }
        return nums2;
    }
}

But what I didn't think of in the end was that the two numbers to be output were reversed!

So we changed the Third Edition:

Change i and j this time:

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] nums2 = new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if ((nums[i] + nums[j] == target) && (i != j)) {
                    nums2[0] = j;
                    nums2[1] = i;
                }
            }
        }
        return nums2;
    }
}

It passed smoothly this time!

But on closer inspection,

7%？

Change!

Version 4: I saw the official standard answer, which used HashMap, so I went directly: (using the quick query feature of HashMap)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] nums2 = new int[2];
        Map<Integer,Integer> map1 = new HashMap<Integer,Integer>();
        for(int i = 0; i < nums.length; i++) {
            if(map1.containsKey(target - nums[i])){
                nums2[0] = map1.get(target - nums[i]);
                nums2[1] = i;
            }
            map1.put(nums[i],i);
        }
        return nums2;
    }
}

This discovery is sure enough, and the running time is much smaller. It seems to be the problem of for.

But take a closer look:

47%？

Change again!

(be strict with yourself and escape) the fifth edition has nothing to say. It's also a mistake.

Version 6: completely abandon for and use while to shorten the time again:

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map1 = new HashMap<Integer,Integer>();
        int j = 0;
        while (j < nums.length) {
            if(map1.containsKey(target - nums[j])) {
               return new int[]{map1.get(target - nums[j]) , j};
            }
            map1.put(nums[j] , j++);
        }
        return new int[0];
    }
}

Look again:

Finally! It's not comfortable until it's on the excellent line.

The process of six submissions is attached. The last version is the best version I changed to.

Attach another one 0ms (100%) on LeetCode website:

import java.util.HashMap;

class Solution {
    public int[] twoSum(int[] nums, int target) {

        HashMap<Integer, Integer> map = new HashMap<>();
        int left = 0;
        int right = nums.length - 1;

        while (left <= right) {
            if (map.containsKey(target - nums[left])) {
                return new int[]{map.get(target - nums[left]), left};
            }
            map.put(nums[left], left++);
            if (map.containsKey(target - nums[right])) {
                return new int[]{map.get(target - nums[right]), right};
            }
            map.put(nums[right], right--);
        }

        return new int[0];
    }
}

Learning programming, private letters from small partners who want to be together ~ thank you!