Solve 'Longest Substring Without Repeating Characters'

Author: obalunenko

add-two-numbers/main.go renamed to add-two-numbers/add.go

@@ -1,4 +1,4 @@
-package main
+package addtwonumbers
 
 // ListNode represents singly-linked list.
 type ListNode struct {

add-two-numbers/main_test.go renamed to add-two-numbers/add_test.go

@@ -1,4 +1,4 @@
-package main
+package addtwonumbers
 
 import (
 	"testing"

hamming_distance/main.go renamed to hamming_distance/hamming.go

@@ -1,4 +1,4 @@
-package main
+package hammingdistance
 
 import (
 	"strconv"

hamming_distance/hamming_test.go

@@ -1,4 +1,4 @@
-package main
+package hammingdistance
 
 import (
 	"fmt"

hamming_distance/spec.md

@@ -1,6 +1,6 @@
 # 461 Hamming Distance
 
-<https://leetcode.com/problems/hamming-distance/description/>
+<https://leetcode.com/problems/hamming-distance/>
 
 The Hamming distance between two integers is the number of positions
 at which the corresponding bits are different.

jewels_and_stones/main.go renamed to jewels_and_stones/jewels.go

@@ -1,4 +1,4 @@
-package main
+package jewelsandstones
 
 import "fmt"
 

jewels_and_stones/jewels_test.go

@@ -1,4 +1,4 @@
-package main
+package jewelsandstones
 
 import (
 	"fmt"

jewels_and_stones/spec.md

@@ -1,6 +1,6 @@
 # 771 Jewels and Stones
 
-<https://leetcode.com/problems/jewels-and-stones/description/>
+<https://leetcode.com/problems/jewels-and-stones>
 
 You're given strings J representing the types of stones that are jewels, and S representing the stones you have.
 Each character in S is a type of stone you have.  You want to know how many of the stones you have are also jewels.

judge_route_circle/main.go renamed to judge_route_circle/judge.go

@@ -1,36 +1,35 @@
-package main
+package judgecircle
 
 import (
-	"fmt"
 	"strings"
 )
 
-type Robot struct {
-	position Position
+type robot struct {
+	position position
 }
 
-type Position struct {
+type position struct {
 	x int
 	y int
 }
 
-func (r *Robot) moveRight() {
+func (r *robot) moveRight() {
 	r.position.y++
 }
 
-func (r *Robot) moveLeft() {
+func (r *robot) moveLeft() {
 	r.position.y--
 }
 
-func (r *Robot) moveUp() {
+func (r *robot) moveUp() {
 	r.position.x++
 }
 
-func (r *Robot) moveDown() {
+func (r *robot) moveDown() {
 	r.position.x--
 }
 
-func (r *Robot) Move(moves string) {
+func (r *robot) move(moves string) {
 	for _, step := range moves {
 		switch strings.ToUpper(string(step)) {
 		case "R":
@@ -41,23 +40,21 @@ func (r *Robot) Move(moves string) {
 			r.moveUp()
 		case "D":
 			r.moveDown()
-		default:
-			fmt.Printf("Wrong movement!")
 		}
 	}
 }
 
 func judgeCircle(moves string) bool {
-	robot := Robot{
-		position: Position{
+	r := robot{
+		position: position{
 			x: 0,
 			y: 0,
 		},
 	}
 
-	robot.Move(moves)
+	r.move(moves)
 
-	if robot.position.x == 0 && robot.position.y == 0 {
+	if r.position.x == 0 && r.position.y == 0 {
 		return true
 	}
 

judge_route_circle/judge_circle_test.go

@@ -1,4 +1,4 @@
-package main
+package judgecircle
 
 import (
 	"fmt"

judge_route_circle/spec.md

@@ -1,24 +1,25 @@
-# 657 Judge Route Circle
+# 657. Robot Return to Origin
 
-<https://leetcode.com/problems/judge-route-circle/description/>
+<https://leetcode.com/problems/robot-return-to-origin/>
 
-Initially, there is a Robot at position (0, 0). Given a sequence of its moves, 
-judge if this robot makes a circle, which means it moves back to the original place.
+There is a robot starting at position (0, 0), the origin, on a 2D plane. Given a sequence of its moves, judge if this robot ends up at (0, 0) after it completes its moves.
 
-The move sequence is represented by a string. And each move is represent by a character. 
-The valid robot moves are R (Right), L (Left), U (Up) and D (down). 
-The output should be true or false representing whether the robot makes a circle.
+The move sequence is represented by a string, and the character moves[i] represents its ith move. Valid moves are R (right), L (left), U (up), and D (down). If the robot returns to the origin after it finishes all of its moves, return true. Otherwise, return false.
+
+Note: The way that the robot is "facing" is irrelevant. "R" will always make the robot move to the right once, "L" will always make it move left, etc. Also, assume that the magnitude of the robot's movement is the same for each move.
 
 Example 1:
 
 ```text
 Input: "UD"
 Output: true
+Explanation: The robot moves up once, and then down once. All moves have the same magnitude, so it ended up at the origin where it started. Therefore, we return true.
 ```
 
 Example 2:
 
 ```text
 Input: "LL"
 Output: false
+Explanation: The robot moves left twice. It ends up two "moves" to the left of the origin. We return false because it is not at the origin at the end of its moves.
 ```

longest-substring-without-repeating-characters/spec.md

@@ -0,0 +1,28 @@
+# 3. Longest Substring Without Repeating Characters
+
+Given a string, find the length of the longest substring without repeating characters.
+
+Example 1:
+
+``` text
+Input: "abcabcbb"
+Output: 3
+Explanation: The answer is "abc", with the length of 3.
+```
+
+Example 2:
+
+```text
+Input: "bbbbb"
+Output: 1
+Explanation: The answer is "b", with the length of 1.
+```
+
+Example 3:
+
+```text
+Input: "pwwkew"
+Output: 3
+Explanation: The answer is "wke", with the length of 3.
+             Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
+```

longest-substring-without-repeating-characters/substring.go

@@ -0,0 +1,63 @@
+package longestsubstring
+
+import (
+	"sort"
+)
+
+func lengthOfLongestSubstring(s string) int {
+	if s == "" {
+		return 0
+	}
+
+	substrings := split(s)
+	if len(substrings) == 0 {
+		return 0
+	}
+
+	sort.Sort(byLen(substrings))
+
+	return len(substrings[0])
+}
+
+type byLen []string
+
+func (a byLen) Len() int {
+	return len(a)
+}
+
+func (a byLen) Less(i, j int) bool {
+	return len(a[i]) > len(a[j])
+}
+
+func (a byLen) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func split(s string) []string {
+	var substrings []string
+
+	length := len(s)
+	if length == 1 {
+		substrings = append(substrings, s)
+	}
+	for i := 0; i < length; i++ {
+		var cur string
+
+		seen := make(map[string]struct{})
+
+		for j := i; j < length; j++ {
+			e := string(s[j])
+
+			if _, exist := seen[e]; !exist {
+				cur += e
+				seen[e] = struct{}{}
+			} else {
+				break
+			}
+		}
+
+		substrings = append(substrings, cur)
+	}
+
+	return substrings
+}

longest-substring-without-repeating-characters/substring_test.go

@@ -0,0 +1,75 @@
+package longestsubstring
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_lengthOfLongestSubstring(t *testing.T) {
+	type args struct {
+		s string
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "abcabcbb",
+			args: args{
+				s: "abcabcbb",
+			},
+			want: 3,
+		},
+		{
+			name: "bbbbb",
+			args: args{
+				s: "bbbbb",
+			},
+			want: 1,
+		},
+		{
+			name: "pwwkew",
+			args: args{
+				s: "pwwkew",
+			},
+			want: 3,
+		},
+		{
+			name: "empty string",
+			args: args{
+				s: "",
+			},
+			want: 0,
+		},
+		{
+			name: "empty string with spaces",
+			args: args{
+				s: " ",
+			},
+			want: 1,
+		},
+		{
+			name: "one letter",
+			args: args{
+				s: "a",
+			},
+			want: 1,
+		},
+		{
+			name: "no repeated",
+			args: args{
+				s: "au",
+			},
+			want: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := lengthOfLongestSubstring(tt.args.s)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

unique_morse_code_words/spec.md

@@ -1,6 +1,6 @@
 # 804 Unique Morse Code Words
 
-<https://leetcode.com/problems/unique-morse-code-words/description/>
+<https://leetcode.com/problems/unique-morse-code-words/>
 
 International Morse Code defines a standard encoding where each letter is mapped to a series of dots and dashes,
 as follows: "a" maps to ".-", "b" maps to "-...", "c" maps to "-.-.", and so on.