From 50dcab428978c79b72fc06c60a46c600d86721da Mon Sep 17 00:00:00 2001 From: GangBean Date: Sat, 21 Dec 2024 09:03:41 +0900 Subject: [PATCH 1/5] feat: solve two sum --- two-sum/GangBean.java | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 two-sum/GangBean.java diff --git a/two-sum/GangBean.java b/two-sum/GangBean.java new file mode 100644 index 000000000..cd5abf382 --- /dev/null +++ b/two-sum/GangBean.java @@ -0,0 +1,35 @@ +class Solution { + public int[] twoSum(int[] nums, int target) { + /** + 1. understanding + - find the indices where the numbers of that index pair sum upto the target number. + - exactly one solution + - use each element only once + - return in any order + 2. strategy + - brute force: + - validate for all pair sum + - hashtable: + - assing hashtable variable to save the nums and index + - while iterate over the nums, + - calculate the diff, and check if the diff in the hashtable. + - or save new entry. + 3. complexity + - time: O(N) + - space: O(N) + */ + + Map map = new HashMap<>(); + + for (int i = 0; i < nums.length; i++) { + int diff = target - nums[i]; + if (map.containsKey(diff)) { + return new int[] {map.get(diff), i}; + } + map.put(nums[i], i); + } + + return new int[] {}; + } +} + From 579021bc75050e36b53a383185c50255e77fba51 Mon Sep 17 00:00:00 2001 From: GangBean Date: Wed, 25 Dec 2024 07:51:13 +0900 Subject: [PATCH 2/5] feat: solve reverse bits --- reverse-bits/GangBean.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 reverse-bits/GangBean.java diff --git a/reverse-bits/GangBean.java b/reverse-bits/GangBean.java new file mode 100644 index 000000000..93f7ad6c1 --- /dev/null +++ b/reverse-bits/GangBean.java @@ -0,0 +1,24 @@ +public class Solution { + // you need treat n as an unsigned value + public int reverseBits(int n) { + /** + 1. understanding + - return the reversed 32 bit input num + 2. strategy + - assign stack + - iterate until stack.size is 32 + - push value % 2, and value /= 2 + 3. complexity + - time: O(1) + - space: O(1) + */ + int reversed = 0; + for (int i = 0; i < 32; i++) { + reversed <<= 1; + reversed |= n & 1; + n >>= 1; + } + return reversed; + } +} + From 4c6e48ba6ce2d280a6c79a5f22a1dd168697d6d2 Mon Sep 17 00:00:00 2001 From: GangBean Date: Wed, 25 Dec 2024 08:45:43 +0900 Subject: [PATCH 3/5] feat: solve product of array except self --- product-of-array-except-self/GangBean.java | 56 ++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 product-of-array-except-self/GangBean.java diff --git a/product-of-array-except-self/GangBean.java b/product-of-array-except-self/GangBean.java new file mode 100644 index 000000000..cf53f48c1 --- /dev/null +++ b/product-of-array-except-self/GangBean.java @@ -0,0 +1,56 @@ +class Solution { + public int[] productExceptSelf(int[] nums) { + /** + 1. understanding + - given integer array nums + - product of which's all elements except that element + - should be under O(N) time complexity + - should not use division operation + 2. strategy + - brute force: O(n^2) + - for every elements, calculate product of other elements + - 1: 2 * [3 * 4] + - 2: 1 * [3 * 4] + - 3: [1 * 2] * 4 + - 4: [1 * 2] * 3 + - dynamic programming + - assign array mem to memorize product till that idx + - mem memorize in ascending order product value and reverse order product value + 3. complexity + - time: O(N) + - space: O(N) + */ + // 1. assign array variable mem + int[][] mem = new int[nums.length][]; + for (int i = 0 ; i < nums.length; i++) { + mem[i] = new int[2]; + } + + // 2. calculate product values + for (int i = 0 ; i < nums.length; i++) { // O(N) + if (i == 0) { + mem[i][0] = nums[i]; + continue; + } + mem[i][0] = nums[i] * mem[i-1][0]; + } + + for (int i = nums.length - 1; i >= 0; i--) { // O(N) + if (i == nums.length - 1) { + mem[i][1] = nums[i]; + continue; + } + mem[i][1] = nums[i] * mem[i+1][1]; + } + + int[] ret = new int[nums.length]; + for (int i = 0; i < nums.length; i++) { // O(N) + int left = (i - 1) >= 0 ? mem[i-1][0] : 1; + int right = (i + 1) < nums.length ? mem[i+1][1] : 1; + ret[i] = left * right; + } + + return ret; + } +} + From 0c544ebb3d9e3b0dd34b642b1898cc39925b5d9e Mon Sep 17 00:00:00 2001 From: GangBean Date: Wed, 25 Dec 2024 09:45:56 +0900 Subject: [PATCH 4/5] feat: solve maximum subarray --- maximum-subarray/GangBean.java | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 maximum-subarray/GangBean.java diff --git a/maximum-subarray/GangBean.java b/maximum-subarray/GangBean.java new file mode 100644 index 000000000..1eebca0ab --- /dev/null +++ b/maximum-subarray/GangBean.java @@ -0,0 +1,28 @@ +class Solution { + public int maxSubArray(int[] nums) { + /** + 1. understanding + - integer array nums + - find largest subarray sum + 2. starategy + - calculate cumulative sum + - mem[i+1] = num[i+1] + mem[i] if (num[i+1] + mem[i] >= 0) else num[i+1] + 3. complexity + - time: O(N) + - space: O(1) + */ + int prev = 0; + int curr = 0; + int max = Integer.MIN_VALUE; + for (int i = 0 ; i < nums.length; i++) { + curr = nums[i]; + if (prev >= 0) { + curr += prev; + } + max = Math.max(max, curr); + prev = curr; + } + return max; + } +} + From cd96d8bb984fd75da74e40931c3ae1f9303b1ffc Mon Sep 17 00:00:00 2001 From: GangBean Date: Fri, 27 Dec 2024 19:53:11 +0900 Subject: [PATCH 5/5] feat: solve combination sum --- combination-sum/GangBean.java | 43 +++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 combination-sum/GangBean.java diff --git a/combination-sum/GangBean.java b/combination-sum/GangBean.java new file mode 100644 index 000000000..04d9b46c1 --- /dev/null +++ b/combination-sum/GangBean.java @@ -0,0 +1,43 @@ +class Solution { + public List> combinationSum(int[] candidates, int target) { + /** + 1. understanding + - find all combinations, which sum to target + - can use same number multiple times + 2. strategy + - dp[target]: all combination, which sum to target + - dp[n + 1] = dp[n] | dp[1] + - [2,3,6,7], target = 7 + - dp[0] = [[]] + - dp[1] = [[]] + - dp[2] = [[2]] + - dp[3] = [[3]] + - dp[4] = dp[2] | dp[2] = [[2,2]] + - dp[5] = dp[2] | dp[3] = [[2,3]] + - dp[6] = dp[2] | dp[4] , dp[3] | dp[3] = [[2,2,2], [3,3]] + - dp[7] = dp[2] | dp[5], dp[3] | dp[4], dp[6] | dp[1], dp[7] = [[2,2,3],] + 3. complexity + - time: O(target * N) where N is length of candidates + - space: O(target * N) + */ + List>[] dp = new List[target + 1]; + for (int i = 0; i <= target; i++) { + dp[i] = new ArrayList<>(); + } + + dp[0].add(new ArrayList<>()); + + for (int candidate : candidates) { + for (int i = candidate; i <= target; i++) { + for (List combination : dp[i - candidate]) { + List newCombination = new ArrayList<>(combination); + newCombination.add(candidate); + dp[i].add(newCombination); + } + } + } + + return dp[target]; + } +} +