[jinho] week 8

clone-graph/neverlish.go

@@ -0,0 +1,108 @@
+// A: node 의 갯수, B: neighbors의 길이
+// 시간복잡도: O(A + B)
+// 공간복잡도: O(A + B)
+
+package main
+
+import "testing"
+
+func Test_cloneGraph(t *testing.T) {
+	result1 := cloneGraph(&Node{
+		Val: 1,
+		Neighbors: []*Node{
+			{
+				Val: 2,
+				Neighbors: []*Node{
+					{
+						Val: 4,
+						Neighbors: []*Node{
+							{
+								Val: 3,
+								Neighbors: []*Node{
+									{
+										Val: 1,
+									},
+									{
+										Val: 4,
+									},
+								},
+							},
+							{
+								Val: 1,
+								Neighbors: []*Node{
+									{
+										Val: 3,
+									},
+									{
+										Val: 2,
+									},
+								},
+							},
+						},
+					},
+					{
+						Val: 1,
+						Neighbors: []*Node{
+							{
+								Val: 4,
+							},
+							{
+								Val: 2,
+							},
+						},
+					},
+				},
+			},
+			{
+				Val: 3,
+				Neighbors: []*Node{
+					{
+						Val: 4,
+					},
+					{
+						Val: 1,
+					},
+				},
+			},
+		},
+	})
+
+	if result1.Val != 1 {
+		t.Fatal(result1.Val)
+	}
+}
+
+type Node struct {
+	Val       int
+	Neighbors []*Node
+}
+
+func dfs(node *Node, visited map[*Node]*Node) *Node {
+	if node == nil {
+		return nil
+	}
+
+	if _, ok := visited[node]; ok {
+		return visited[node]
+	}
+
+	cloneNode := &Node{Val: node.Val}
+
+	visited[node] = cloneNode
+
+	for _, neighbor := range node.Neighbors {
+		cloneNode.Neighbors = append(cloneNode.Neighbors, dfs(neighbor, visited))
+	}
+
+	return cloneNode
+}
+
+func cloneGraph(node *Node) *Node {
+	if node == nil {
+		return nil
+	}
+
+	visited := make(map[*Node]*Node)
+
+	return dfs(node, visited)
+}

longest-common-subsequence/neverlish.go

@@ -0,0 +1,44 @@
+// 시간복잡도: O(n^2)
+// 공간복잡도: O(n^2)
+
+package main
+
+import "testing"
+
+func Test_longestCommonSubsequence(t *testing.T) {
+	result1 := longestCommonSubsequence("abcde", "ace")
+
+	if result1 != 3 {
+		t.Fatal(result1)
+	}
+
+	result2 := longestCommonSubsequence("abc", "abc")
+
+	if result2 != 3 {
+		t.Fatal(result2)
+	}
+
+	result3 := longestCommonSubsequence("abc", "def")
+
+	if result3 != 0 {
+		t.Fatal(result3)
+	}
+}
+
+func longestCommonSubsequence(text1 string, text2 string) int {
+	prev := make([]int, len(text2)+1)
+	curr := make([]int, len(text2)+1)
+
+	for i := 1; i <= len(text1); i++ {
+		for j := 1; j <= len(text2); j++ {
+			if text1[i-1] == text2[j-1] {
+				curr[j] = prev[j-1] + 1
+			} else {
+				curr[j] = max(prev[j], curr[j-1])
+			}
+		}
+		prev, curr = curr, prev
+	}
+
+	return prev[len(text2)]
+}

longest-repeating-character-replacement/neverlish.go

@@ -0,0 +1,51 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+
+package main
+
+import "testing"
+
+func Test_characterReplacement(t *testing.T) {
+	result1 := characterReplacement("ABAB", 2)
+	if result1 != 4 {
+		t.Fatal(result1)
+	}
+
+	result2 := characterReplacement("AABABBA", 1)
+	if result2 != 4 {
+		t.Fatal(result2)
+	}
+}
+
+func maxValue(m map[byte]int) int {
+	max := 0
+	for _, v := range m {
+		if v > max {
+			max = v
+		}
+	}
+	return max
+}
+
+func characterReplacement(s string, k int) int {
+	max_length := 0
+	counter := make(map[byte]int)
+
+	window_start := 0
+	window_end := 0
+
+	for window_end < len(s) {
+		counter[s[window_end]]++
+
+		for window_end-window_start+1-maxValue(counter) > k {
+			counter[s[window_start]]--
+			window_start++
+		}
+
+		max_length = max(max_length, window_end-window_start+1)
+
+		window_end++
+	}
+
+	return max_length
+}

number-of-1-bits/neverlish.go

@@ -0,0 +1,34 @@
+// 시간복잡도: O(1)
+// 공간복잡도: O(1)
+
+package main
+
+import "testing"
+
+func Test_hammingWeight(t *testing.T) {
+	result1 := hammingWeight(11)
+	if result1 != 3 {
+		t.Fatal(result1)
+	}
+
+	result2 := hammingWeight(128)
+
+	if result2 != 1 {
+		t.Fatal(result2)
+	}
+
+	result3 := hammingWeight(2147483645)
+
+	if result3 != 30 {
+		t.Fatal(result3)
+	}
+}
+
+func hammingWeight(n int) int {
+	result := 0
+	for n > 0 {
+		result += n & 1
+		n >>= 1
+	}
+	return result
+}

sum-of-two-integers/neverlish.go

@@ -0,0 +1,27 @@
+// 시간복잡도: O(log n)
+// 공간복잡도: O(1)
+
+package main
+
+import "testing"
+
+func Test_getSum(t *testing.T) {
+	result1 := getSum(1, 2)
+	if result1 != 3 {
+		t.Fatal(result1)
+	}
+
+	result2 := getSum(2, 3)
+	if result2 != 5 {
+		t.Fatal(result2)
+	}
+}
+
+func getSum(a int, b int) int {
+	for b != 0 {
+		carry := a & b
+		a = a ^ b
+		b = carry << 1
+	}
+	return a
+}