[jinho] Week 1 (#632)

* neverlish: week01

* refactor: optimize result slice initialization in topKFrequent function

* docs: add time and space complexity comments to algorithms

Author: neverlish

contains-duplicate/neverlish.go

@@ -0,0 +1,33 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	result1 := containsDuplicate([]int{1, 2, 3, 1})
+
+	if result1 != true {
+		t.Fatal("failed test1")
+	}
+
+	result2 := containsDuplicate([]int{1, 2, 3, 4})
+
+	if result2 != false {
+		t.Fatal("failed test2")
+	}
+}
+
+func containsDuplicate(nums []int) bool {
+	data := make(map[int]bool)
+
+	for _, num := range nums {
+		if data[num] {
+			return true
+		} else {
+			data[num] = true
+		}
+	}
+	return false
+}

house-robber/neverlish.go

@@ -0,0 +1,44 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+package main
+
+import (
+	"testing"
+)
+
+func Test(t *testing.T) {
+	result1 := rob([]int{1, 2, 3, 1})
+
+	if result1 != 4 {
+		t.Fatal("failed test1")
+	}
+
+	result2 := rob([]int{2, 7, 9, 3, 1})
+
+	if result2 != 12 {
+		t.Fatal("failed test2")
+	}
+}
+
+func rob(nums []int) int {
+	length := len(nums)
+
+	if length == 0 {
+		return 0
+	}
+	if length == 1 {
+		return nums[0]
+	}
+
+	moneys := make([]int, length)
+
+	moneys[0] = nums[0]
+	moneys[1] = max(nums[0], nums[1])
+
+	for position := 2; position < length; position++ {
+		moneys[position] = max(moneys[position-1], moneys[position-2]+nums[position])
+	}
+
+	return moneys[length-1]
+}

longest-consecutive-sequence/neverlish.go

@@ -0,0 +1,48 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	result := longestConsecutive([]int{100, 4, 200, 1, 3, 2})
+
+	if result != 4 {
+		t.Fatal("failed test")
+	}
+
+	result2 := longestConsecutive([]int{0, 3, 7, 2, 5, 8, 4, 6, 0, 1})
+
+	if result2 != 9 {
+		t.Fatal("failed test2")
+	}
+}
+
+func longestConsecutive(nums []int) int {
+	numsSet := make(map[int]bool)
+
+	for _, num := range nums {
+		numsSet[num] = true
+	}
+
+	longest := 0
+
+	for num := range numsSet {
+		if !numsSet[num-1] {
+			currentNum := num
+			currentLength := 1
+
+			for numsSet[currentNum+1] {
+				currentNum++
+				currentLength++
+			}
+
+			if currentLength > longest {
+				longest = currentLength
+			}
+		}
+	}
+
+	return longest
+}

top-k-frequent-elements/neverlish.go

@@ -0,0 +1,43 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	result := topKFrequent([]int{1, 1, 1, 2, 2, 3}, 2)
+
+	if result[0] != 1 || result[1] != 2 {
+		t.Fatal("failed test")
+	}
+}
+
+func topKFrequent(nums []int, k int) []int {
+	freq := make(map[int]int)
+
+	for _, num := range nums {
+		freq[num]++
+	}
+
+	freq_by_counts := make(map[int][]int)
+
+	for num, count := range freq {
+		if _, ok := freq_by_counts[count]; !ok {
+			freq_by_counts[count] = []int{}
+		}
+		freq_by_counts[count] = append(freq_by_counts[count], num)
+	}
+
+	result := make([]int, 0, k)
+
+	for count := len(nums); count > 0; count-- {
+		if nums, ok := freq_by_counts[count]; ok {
+			if len(result) >= k {
+				break
+			}
+			result = append(result, nums...)
+		}
+	}
+	return result
+}

valid-palindrome/neverlish.go

@@ -0,0 +1,45 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	result1 := isPalindrome("A man, a plan, a canal: Panama")
+	if result1 != true {
+		t.Fatal("failed test1")
+	}
+
+	result2 := isPalindrome("race a car")
+	if result2 != false {
+		t.Fatal("failed test2")
+	}
+
+	result3 := isPalindrome("")
+
+	if result3 != true {
+		t.Fatal("failed test3")
+	}
+}
+
+func isPalindrome(s string) bool {
+	s = strings.ToLower(s)
+
+	var filtered []rune
+	for _, r := range s {
+		if ('a' <= r && r <= 'z') || ('0' <= r && r <= '9') {
+			filtered = append(filtered, r)
+		}
+	}
+
+	for index, r := range filtered[:len(filtered)/2] {
+		if r != filtered[len(filtered)-index-1] {
+			return false
+		}
+	}
+	return true
+}