[박종훈] 1주차 답안 제출

best-time-to-buy-and-sell-stock/dev-jonghoonpark.md

@@ -0,0 +1,23 @@
+- https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+- time complexity : O(n)
+- space complexity : O(1)
+- https://algorithm.jonghoonpark.com/2024/02/20/leetcode-121
+
+```java
+class Solution {
+    public int maxProfit(int[] prices) {
+        int buyAt = 0;
+        int profit = 0;
+
+        for(int i = 1; i < prices.length; i++) {
+            if (prices[i] < prices[buyAt]) {
+                buyAt = i;
+            } else {
+                profit = Math.max(profit, prices[i] - prices[buyAt]);
+            }
+        }
+
+        return profit;
+    }
+}
+```

contains-duplicate/dev-jonghoonpark.md

@@ -0,0 +1,22 @@
+- https://leetcode.com/problems/contains-duplicate/
+- time complexity : O(n)
+- space complexity : O(n)
+- https://algorithm.jonghoonpark.com/2024/04/24/leetcode-217
+
+```java
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numSet = new HashSet<>();
+        for (int num : nums) {
+            if (numSet.contains(num)) {
+                return true;
+            }
+            numSet.add(num);
+        }
+        return false;
+    }
+}
+```

two-sum/dev-jonghoonpark.md

@@ -0,0 +1,27 @@
+- https://leetcode.com/problems/two-sum/
+- time complexity : O(n)
+- space complexity : O(n)
+- https://algorithm.jonghoonpark.com/2024/01/03/leetcode-1
+
+```java
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> numMap = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+            int _target = target - num;
+
+            if (numMap.containsKey(_target)) {
+                return new int[]{numMap.get(_target), i};
+            }
+            numMap.put(num, i);
+        }
+
+        return null;
+    }
+}
+```

valid-anagram/dev-jonghoonpark.md

@@ -0,0 +1,18 @@
+- https://leetcode.com/problems/valid-anagram/
+- time complexity : O(nlogn)
+- space complexity : O(n)
+- https://algorithm.jonghoonpark.com/2024/04/24/leetcode-242
+
+```java
+import java.util.Arrays;
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        char[] temp1 = s.toCharArray();
+        char[] temp2 = t.toCharArray();
+        Arrays.sort(temp1);
+        Arrays.sort(temp2);
+        return Arrays.equals(temp1, temp2);
+    }
+}
+```

valid-palindrome/dev-jonghoonpark.md

@@ -0,0 +1,28 @@
+- https://leetcode.com/problems/valid-palindrome/
+- time complexity : O(n)
+- space complexity : O(n)
+- https://algorithm.jonghoonpark.com/2024/04/24/leetcode-125
+
+```java
+class Solution {
+    public boolean isPalindrome(String s) {
+        StringBuilder filtered = new StringBuilder();
+        for(char c : s.toCharArray()) {
+            // '0' == 48, '9' == 57, 'A' == 65, 'z' == 122
+            if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z')) {
+                filtered.append(c);
+            } else if ((c >= 'A' && c <= 'Z')) {
+                filtered.append((char) (c + 32));
+            }
+        }
+
+        for(int i = 0; i < filtered.length() / 2; i++) {
+            if (filtered.charAt(i) != filtered.charAt(filtered.length() - i - 1)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+```