# Code submitted six times -- LeetCode learning notes 1

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!

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!

Keywords: Java

Added by shayman on Mon, 27 Dec 2021 21:47:43 +0200