From e05461fec88d3e33aa4b3ab8a93b22d050673295 Mon Sep 17 00:00:00 2001 From: minji-go Date: Sat, 21 Dec 2024 21:10:56 +0900 Subject: [PATCH 1/6] refactor: construct binary tree from preorder and inorder traversal - correct complexity --- .../minji-go.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/construct-binary-tree-from-preorder-and-inorder-traversal/minji-go.java b/construct-binary-tree-from-preorder-and-inorder-traversal/minji-go.java index 1f7f3a769..bb5efde92 100644 --- a/construct-binary-tree-from-preorder-and-inorder-traversal/minji-go.java +++ b/construct-binary-tree-from-preorder-and-inorder-traversal/minji-go.java @@ -2,7 +2,7 @@ Problem: https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/ Description: Given two integer arrays preorder and inorder, construct and return the binary tree. Concept: Array, Hash Table, Divide and Conquer, Tree, Binary Tree - Time Complexity: O(NM), Runtime 2ms + Time Complexity: O(N²), Runtime 2ms Space Complexity: O(N), Memory 45.02MB */ import java.util.HashMap; From 8ca1cc0865d3c70c6bc0b2bb860a1396eef1be90 Mon Sep 17 00:00:00 2001 From: minji-go Date: Sun, 22 Dec 2024 01:03:28 +0900 Subject: [PATCH 2/6] feat: two sum --- two-sum/minji-go.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 two-sum/minji-go.java diff --git a/two-sum/minji-go.java b/two-sum/minji-go.java new file mode 100644 index 000000000..8464665fd --- /dev/null +++ b/two-sum/minji-go.java @@ -0,0 +1,21 @@ +/* + Problem: https://leetcode.com/problems/two-sum/ + Description: return indices of the two numbers such that they add up to target. not use the same element twice. + Topics: Array, Hash Table + Time Complexity: O(N), Runtime 2ms + Space Complexity: O(N), Memory 45.1MB +*/ +class Solution { + public int[] twoSum(int[] nums, int target) { + Map numIndex = new HashMap<>(); + for(int secondIndex=0; secondIndex Date: Sun, 22 Dec 2024 01:03:41 +0900 Subject: [PATCH 3/6] feat: reverse bits --- reverse-bits/minji-go.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 reverse-bits/minji-go.java diff --git a/reverse-bits/minji-go.java b/reverse-bits/minji-go.java new file mode 100644 index 000000000..de134e9db --- /dev/null +++ b/reverse-bits/minji-go.java @@ -0,0 +1,19 @@ +/* + Problem: https://leetcode.com/problems/reverse-bits/ + Description: Reverse bits of a given 32 bits unsigned integer + Topics: Divide and Conquer, Bit Manipulation + Time Complexity: O(1), Runtime 1ms + Space Complexity: O(1), Memory 41.72MB +*/ +public class Solution { + public int reverseBits(int n) { + long unsignedNum = n > 0 ? n : n + 2 * (long) Math.pow(2,31); //= Integer.toUnsignedLong() + + int reversedNum = 0; + for(int i=31; i>=0; i--){ + if(unsignedNum % 2 == 1) reversedNum += (long) Math.pow(2,i); //= (1< Date: Fri, 27 Dec 2024 00:32:00 +0900 Subject: [PATCH 4/6] feat: maximum subarray --- maximum-subarray/minji-go.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 maximum-subarray/minji-go.java diff --git a/maximum-subarray/minji-go.java b/maximum-subarray/minji-go.java new file mode 100644 index 000000000..617d215a7 --- /dev/null +++ b/maximum-subarray/minji-go.java @@ -0,0 +1,18 @@ +/* + Problem: https://leetcode.com/problems/maximum-subarray/ + Description: return the largest sum of the subarray, contiguous non-empty sequence of elements within an array. + Concept: Array, Divide and Conquer, Dynamic Programming + Time Complexity: O(N), Runtime 1ms + Space Complexity: O(1), Memory 57.02MB +*/ +class Solution { + public int maxSubArray(int[] nums) { + int max = nums[0]; + int sum = nums[0]; + for(int i=1; i Date: Fri, 27 Dec 2024 00:32:47 +0900 Subject: [PATCH 5/6] feat: product of array except self --- product-of-array-except-self/minji-go.java | 24 ++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 product-of-array-except-self/minji-go.java diff --git a/product-of-array-except-self/minji-go.java b/product-of-array-except-self/minji-go.java new file mode 100644 index 000000000..62d19204c --- /dev/null +++ b/product-of-array-except-self/minji-go.java @@ -0,0 +1,24 @@ +/* + Problem: https://leetcode.com/problems/product-of-array-except-self/ + Description: return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i]. + Concept: Array, Prefix Sum + Time Complexity: O(N), Runtime 5ms + Space Complexity: O(N), Memory 54.6MB - O(1) except the output array +*/ +class Solution { + public int[] productExceptSelf(int[] nums) { + int[] answer = new int[nums.length]; + Arrays.fill(answer, 1); + + int prefixProduct = 1; + int suffixProduct = 1; + for(int i=1; i Date: Fri, 27 Dec 2024 11:19:35 +0900 Subject: [PATCH 6/6] feat: combination sum --- combination-sum/minji-go.java | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 combination-sum/minji-go.java diff --git a/combination-sum/minji-go.java b/combination-sum/minji-go.java new file mode 100644 index 000000000..ab895923a --- /dev/null +++ b/combination-sum/minji-go.java @@ -0,0 +1,33 @@ +/* + Problem: https://leetcode.com/problems/combination-sum/ + Description: return a list of all unique combinations of candidates where the chosen numbers sum to target + Concept: Array, Backtracking + Time Complexity: O(Nⁿ), Runtime 2ms + Space Complexity: O(N), Memory 44.88MB + + - Time Complexity, Space Complexity를 어떻게 계산해야할지 어렵네요 :( +*/ +class Solution { + public List> answer = new ArrayList<>(); + + public List> combinationSum(int[] candidates, int target) { + Arrays.sort(candidates); + findCombination(candidates, target, new ArrayList<>(), 0); + return answer; + } + + public void findCombination(int[] candidates, int target, List combination, int idx) { + if(target == 0) { + answer.add(new ArrayList<>(combination)); + return; + } + + for(int i=idx; i target) break; + + combination.add(candidates[i]); + findCombination(candidates, target-candidates[i], combination, i); + combination.remove(combination.size()-1); + } + } +}