From 7a06cf66810e765bd0bb5d78f9af36ccd3d7ffa8 Mon Sep 17 00:00:00 2001 From: Jinho Hyeon Date: Sun, 22 Dec 2024 13:25:25 +0900 Subject: [PATCH] neverlish: week02 --- 3sum/neverlish.go | 79 +++++++++++++++++++ climbing-stairs/neverlish.go | 43 ++++++++++ .../neverlish.go | 48 +++++++++++ decode-ways/neverlish.go | 59 ++++++++++++++ valid-anagram/neverlish.go | 48 +++++++++++ 5 files changed, 277 insertions(+) create mode 100644 3sum/neverlish.go create mode 100644 climbing-stairs/neverlish.go create mode 100644 construct-binary-tree-from-preorder-and-inorder-traversal/neverlish.go create mode 100644 decode-ways/neverlish.go create mode 100644 valid-anagram/neverlish.go diff --git a/3sum/neverlish.go b/3sum/neverlish.go new file mode 100644 index 000000000..89d258627 --- /dev/null +++ b/3sum/neverlish.go @@ -0,0 +1,79 @@ +// 시간복잡도: O(n^2) +// 공간복잡도: O(n) + +package main + +import ( + "sort" + "testing" +) + +func TestThreeSum(t *testing.T) { + test1 := []int{-1, 0, 1, 2, -1, -4} + result1 := threeSum(test1) + + for _, comp := range result1 { + for _, num := range comp { + t.Logf("%d ", num) + } + } + + println("YO") + + if len(result1) != 2 { + t.Errorf("Expected 2, got %d", len(result1)) + } +} + +func twoSum(nums []int, target int) [][]int { + result := [][]int{} + seen := map[int]int{} + for i, num := range nums { + complement := target - num + if _, ok := seen[complement]; ok { + result = append(result, []int{seen[complement], i}) + } + seen[num] = i + } + + return result +} + +func threeSum(nums []int) [][]int { + result := map[int]map[int]map[int]bool{} + + for i, num := range nums[:len(nums)-2] { + if (i > 0 && num == nums[i-1]) { + continue + } + for _, comp := range twoSum(nums[i+1:], 0-num) { + comps := []int{num, nums[comp[0]+i+1], nums[comp[1]+i+1]} + sort.Ints(comps) + comp1 := comps[0] + comp2 := comps[1] + comp3 := comps[2] + if _, ok := result[comp1]; !ok { + result[comp1] = map[int]map[int]bool{} + } + if _, ok := result[comp1][comp2]; !ok { + result[comp1][comp2] = map[int]bool{} + } + result[comp1][comp2][comp3] = true + } + } + + + + answers := [][]int{} + for key1 := range result { + + for key2 := range result[key1] { + for key3 := range result[key1][key2] { + comp := []int{key1, key2, key3} + answers = append(answers, comp) + } + } + } + + return answers +} diff --git a/climbing-stairs/neverlish.go b/climbing-stairs/neverlish.go new file mode 100644 index 000000000..1fa9e7701 --- /dev/null +++ b/climbing-stairs/neverlish.go @@ -0,0 +1,43 @@ +// 시간복잡도: O(n) +// 공간복잡도: O(n) + +package main + +import ( + "testing" +) + +func Test(t *testing.T) { + result1 := climbStairs(2) + + if result1 != 2 { + t.Fatal("failed test1") + } + + result2 := climbStairs(3) + + if result2 != 3 { + t.Fatal("failed test2") + } +} + +func climbStairs(n int) int { + + if n == 1 { + return 1 + } + + if n == 2 { + return 2 + } + dp := make([]int, n+1) + + dp[1] = 1 + dp[2] = 2 + + for i := 3; i <= n; i++ { + dp[i] = dp[i-1] + dp[i-2] + } + + return dp[n] +} diff --git a/construct-binary-tree-from-preorder-and-inorder-traversal/neverlish.go b/construct-binary-tree-from-preorder-and-inorder-traversal/neverlish.go new file mode 100644 index 000000000..0d835f4aa --- /dev/null +++ b/construct-binary-tree-from-preorder-and-inorder-traversal/neverlish.go @@ -0,0 +1,48 @@ +package main + +import "testing" + +func TestBuildTree(t *testing.T) { + preorder := []int{3,9,20,15,7} + inorder := []int{9,3,15,20,7} + + result := buildTree(preorder, inorder) + println(result.Val) + println(result.Left.Val) + println(result.Right.Val) + println(result.Right.Left.Val) + println(result.Right.Right.Val) +} + +type TreeNode struct { + Val int + Left *TreeNode + Right *TreeNode +} + +func findIndex(target int, values []int) int { + for i, v := range values { + if v == target { + return i + } + } + return -1 +} + +func buildTree(preorder []int, inorder []int) *TreeNode { + if len(inorder) == 0 { + return nil + } + Val := preorder[0] + + midIndex := findIndex(Val, inorder) + + Left := buildTree(preorder[1:midIndex+1], inorder[:midIndex]) + Right := buildTree(preorder[midIndex+1:], inorder[midIndex+1:]) + + return &TreeNode{ + Val, + Left, + Right, + } +} diff --git a/decode-ways/neverlish.go b/decode-ways/neverlish.go new file mode 100644 index 000000000..699e60bb6 --- /dev/null +++ b/decode-ways/neverlish.go @@ -0,0 +1,59 @@ +// 시간복잡도: O(n) +// 공간복잡도: O(n) + +package main + +import ( + "testing" +) + +func TestNumDecodings(t *testing.T) { + test1 := "12" + result1 := numDecodings(test1) + + if result1 != 2 { + t.Errorf("Expected 2, got %d", result1) + } + + test2 := "226" + result2 := numDecodings(test2) + + if result2 != 3 { + t.Errorf("Expected 3, got %d", result2) + } + + test3 := "0" + result3 := numDecodings(test3) + + if result3 != 0 { + t.Errorf("Expected 0, got %d", result3) + } + + test4 := "06" + result4 := numDecodings(test4) + + if result4 != 0 { + t.Errorf("Expected 0, got %d", result4) + } +} + +func numDecodings(s string) int { + dp := make([]int, len(s)+1) + + dp[0] = 1 + + for i := 1; i <= len(s); i++ { + curBefore1 := s[i-1] + if curBefore1 != '0' { + dp[i] += dp[i-1] + } + if i > 1 { + curBefore2 := s[i-2] + if curBefore2 != '0' && (curBefore2-'0')*10+(curBefore1-'0') <= 26 { + dp[i] += dp[i-2] + } + } + } + + return dp[len(s)] +} diff --git a/valid-anagram/neverlish.go b/valid-anagram/neverlish.go new file mode 100644 index 000000000..3231be0da --- /dev/null +++ b/valid-anagram/neverlish.go @@ -0,0 +1,48 @@ +// 시간복잡도: O(n) +// 공간복잡도: O(n) + +package main + +import ( + "testing" +) + +func Test(t *testing.T) { + result1 := isAnagram("anagram", "nagaram") + + if !result1 { + t.Fatal("failed test1") + } + + result2 := isAnagram("rat", "car") + + if result2 { + t.Fatal("failed test2") + } +} + +func isAnagram(s string, t string) bool { + if len(s) != len(t) { + return false + } + + sMap := make(map[rune]int) + + for _, c := range s { + sMap[c]++ + } + + for _, c := range t { + if _, ok := sMap[c]; !ok { + return false + } + + sMap[c]-- + + if sMap[c] == 0 { + delete(sMap, c) + } + } + + return len(sMap) == 0 +}