Merge branch 'DaleStudy:main' into main

Author: limlimjo

3sum/easyone-jwlee.go

@@ -0,0 +1,46 @@
+// 풀이
+// 배열을 정렬하고
+// two pointer 사용
+
+// TC
+// 정렬 O(nlogn) + Two pointer 이중 루프 O(n^2) = O(n^2)
+
+// SC
+// Go의 sort.Ints()는 TimSort를 사용.
+// Merge Sort와 Insertion Sort의 조합으로 동작.
+// 정렬 O(n) + Two pointer O(1) + 결과 배열 O(n) = O(n)
+
+func threeSum(nums []int) [][]int {
+	result := [][]int{}
+	sort.Ints(nums) // nums를 정렬
+
+	for i := 0; i < len(nums)-2; i++ {
+		if i > 0 && nums[i] == nums[i-1] {
+			continue // 중복된 값 건너뜀
+		}
+
+		left, right := i+1, len(nums)-1
+		for left < right {
+			sum := nums[i] + nums[left] + nums[right]
+			if sum == 0 {
+				result = append(result, []int{nums[i], nums[left], nums[right]})
+				left++
+				right--
+
+				// 중복 제거
+				for left < right && nums[left] == nums[left-1] {
+					left++
+				}
+				for left < right && nums[right] == nums[right+1] {
+					right--
+				}
+			} else if sum < 0 {
+				left++
+			} else {
+				right--
+			}
+		}
+	}
+
+	return result
+}

climbing-stairs/easyone-jwlee.go

@@ -0,0 +1,23 @@
+// 풀이
+// 1 일 때, 가능한 step은 1 -> 1가지
+// 2 일 때, 가능한 step은 1 1, 2 -> 2가지
+// 3 일 때, 가능한 step은 1 1 1, 1 2, 2 1 -> 3가지
+// n 일 때, 가능한 stop은 n-1의 가짓수에 1이 붙고, n-2의 가짓수에 2가 붙는다.
+
+// TC
+// O(n)
+
+// SC
+// int타입 변수만 사용해서 O(1)
+
+func climbStairs(n int) int {
+	if n <= 2 {
+		return n
+	}
+	prev := 1 // climb1
+	curr := 2 // climb2
+	for i := 3; i <= n; i++ {
+		prev, curr = curr, (curr + prev)
+	}
+	return curr
+}

construct-binary-tree-from-preorder-and-inorder-traversal/easyone-jwlee.go

@@ -0,0 +1,40 @@
+// 풀이
+// preorder[0]이 제일 꼭대기
+// preorder 배열의 root index, inorder 배열의 시작, inorder 배열의 끝
+// 위의 세가지를 parameter로 받는 재귀함수를 만들어서
+// 왼쪽 서브트리, 오른쪽 서브트리를 순회
+
+// TC
+// map 만들기 O(n) + 재귀함수는 각 노드를 딱 한번씩만 방문하므로 O(n) = O(n)
+
+// SC
+// map O(n) + 재귀함수 최악의 경우 한쪽으로만 노드가 이어지는 경우 O(n) = O(n)
+
+func buildTree(preorder []int, inorder []int) *TreeNode {
+	inorderMap := make(map[int]int)
+	for i, n := range inorder {
+		inorderMap[n] = i
+	}
+
+	var recursive func(rootIndex, inStart, inEnd int) *TreeNode
+	recursive = func(rootIndex, inStart, inEnd int) *TreeNode {
+		if rootIndex >= len(preorder) || inStart > inEnd {
+			return nil
+		}
+		rootVal := preorder[rootIndex]
+		rootInorderIndex := inorderMap[rootVal]
+
+		result := &TreeNode{
+			Val: rootVal,
+		}
+
+		leftSize := rootInorderIndex - inStart
+
+		result.Left = recursive(rootIndex+1, inStart, rootInorderIndex-1)
+		result.Right = recursive(rootIndex+1+leftSize, rootInorderIndex+1, inEnd)
+
+		return result
+	}
+
+	return recursive(0, 0, len(inorder)-1)
+}

contains-duplicate/EstherKim97.py

@@ -0,0 +1,10 @@
+# Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.
+
+def containsDuplicate(nums):
+    seen = set()
+    for num in nums:
+        if num in seen:
+            return True
+        seen.add(num)
+    return False
+

contains-duplicate/hancrysta1.java

@@ -0,0 +1,8 @@
+import java.util.*;
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numSet = Arrays.stream(nums).boxed().collect(Collectors.toSet());
+        if(numSet.size()!=nums.length) return true;
+        else return false;
+    }
+}

decode-ways/easyone-jwlee.go

@@ -0,0 +1,33 @@
+// 풀이
+// dp로 풀이
+// 두자리 수에 적합하면 prev2(i-2)에 해당하는 값을 더하기
+
+// TC
+// O(n)
+
+// SC
+// data type이 int인 변수만 사용했으므로 O(1)
+
+func numDecodings(s string) int {
+	if len(s) == 0 || s[0] == '0' {
+		return 0
+	}
+	prev2, prev1 := 1, 1
+	for i := 1; i < len(s); i++ {
+		curr := 0
+
+		// 한자리수 확인
+		if s[i] != '0' {
+			curr += prev1
+		}
+
+		// 두자리수 확인
+		digit, _ := strconv.Atoi(s[i-1 : i+1])
+		if digit >= 10 && digit <= 26 {
+			curr += prev2
+		}
+
+		prev2, prev1 = prev1, curr
+	}
+	return prev1
+}

top-k-frequent-elements/EstherKim97.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def topKFrequent(self, nums, k):
+        unique_no = set(nums)
+        data = []
+
+        for i in unique_no:
+            count = 0
+            for j in nums:
+                if i == j:
+                    count += 1
+            data.append((count, i))
+        
+        data = sorted(data, reverse=True, key=lambda x:[1])
+
+        return [x[1] for x in data[:k]]
+

top-k-frequent-elements/hancrysta1.java

@@ -0,0 +1,17 @@
+import java.util.*;
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer,Integer> count = new HashMap<>();
+        for(int i=0;i<nums.length;i++){
+            count.put(nums[i],count.getOrDefault(nums[i],0)+1);
+        }
+        List<Integer> sortedCount = new ArrayList<>(count.keySet());
+        sortedCount.sort((a,b)->count.get(b)-count.get(a));//value 기준 키 정렬
+        int[] answer = new int[k];
+        for(int i=0;i<k;i++){
+            answer[i] = sortedCount.get(i);
+        }
+        
+        return answer;
+    }
+}

valid-anagram/easyone-jwlee.go

@@ -0,0 +1,27 @@
+// 풀이
+// s의 rune을 key로 같은 철자의 갯수를 담게하고
+// t와 비교하면서 갯수를 하나씩 감소하게 해서
+// 남은 철자가 있거나 (s에는 있고, r에는 없는 철자가 있는 경우)
+// 더 감소된 철자가 있으면 (s에는 없고, r에만 있는 철자가 있는 경우) false가 return 되게 함.
+
+// TC
+// O(n+n+n) = O(n)
+
+// SC
+// s의 길이만큼 늘어나는 map으로 인해 O(n)
+
+func isAnagram(s string, t string) bool {
+	m := make(map[rune]int)
+	for _, r := range s {
+		m[r]++
+	}
+	for _, r := range t {
+		m[r]--
+	}
+	for _, count := range m {
+		if count < 0 || count > 0 {
+			return false
+		}
+	}
+	return true
+}

valid-palindrome/EstherKim97.py

@@ -0,0 +1,12 @@
+class Solution(object):
+    def isPalindrome(self, s):
+        import re
+        # remove all non-alphanumeric characters
+        s = re.sub(r'\W+', '', s.lower())
+
+        # check if the string is equal forward and backward
+        for i in range(len(s)//2):
+            if s[i] != s[-(i+1)]:
+                return False
+        return True
+

valid-palindrome/hancrysta1.java

@@ -0,0 +1,18 @@
+import java.util.*;
+class Solution {
+    public boolean isPalindrome(String s) {
+        String words = s.toLowerCase().replaceAll("[^0-9A-Za-z]","");
+        //System.out.println(words);
+        Deque<Character> stack = new ArrayDeque<>();
+        for(int i=0;i<words.length();i++){
+            stack.push(words.charAt(i));
+        }
+        while(!stack.isEmpty()){
+            for(int i=0;i<words.length();i++){
+                if(words.charAt(i)==stack.pop()) continue;
+                else return false;
+            }
+        }
+        return true;
+    }
+}