[Gotprgmer] Week4

decode-ways/Gotprgmer.java

@@ -0,0 +1,37 @@
+// 완전탐색을 통해 모든 경우의 수를 구하기 위해 노력하였지만 시간초과가 발생하였습니다.
+// dfs를 통해 풀이하려고 했지만 O(2^N)의 시간복잡도로 인해 시간초과가 발생하였습니다.
+// 이후 dp로 풀이를 시작하였고 어렵지 않게 풀이하였습니다.
+// dp[i] = dp[i-1] + dp[i-2]로 풀이하였습니다.
+// 이때 i번째 문자열을 1자리로 취급할지 2자리로 취급할지에 따라 경우의 수가 달라집니다.
+// 1자리로 취급할 경우 1~9까지 가능하고
+// 2자리로 취급할 경우 10~26까지 가능합니다.
+
+// 시간복잡도 : O(N)
+// 공간복잡도 : O(N)
+class SolutionGotprgmer {
+    public int numDecodings(String s) {
+        // 예외 처리: 문자열이 "0"으로 시작하거나 빈 문자열이면
+        if (s == null || s.length() == 0 || s.charAt(0) == '0') {
+            return 0;
+        }
+        int[] dp = new int[s.length()+1];
+        dp[0] = 1;
+        for(int i=0;i<s.length();i++){
+            int ith = s.charAt(i)-'0';
+            if(ith != 0){
+                dp[i+1] = dp[i];
+            }
+            if(i>0){
+                String twoDigitStr = s.substring(i-1,i+1);
+                int twoDigitNum = Integer.valueOf(twoDigitStr);
+                if(twoDigitNum>=10 && twoDigitNum <27){
+                    dp[i+1] += dp[i-1];
+                }
+            }
+
+        }
+        return dp[s.length()];
+    }
+
+
+}

missing-number/Gotprgmer.java

@@ -0,0 +1,18 @@
+// 단순하게 정렬해서 일치하지 않으면 출력하고 리스트를 벗어나면 그대로 checkNum을 출력하는 방식
+// 시간복잡도 : O(NlogN)
+// 공간복잡도 : O(1)
+
+class SolutionGotprgmer {
+    public int missingNumber(int[] nums) {
+        Arrays.sort(nums);
+        int checkNum = 0;
+        for(int i=0;i<nums.length;i++){
+            if(nums[i] != checkNum){
+                return checkNum;
+            }
+            checkNum += 1;
+        }
+        return checkNum;
+
+    }
+}

reverse-bits/Gotprgmer.java

@@ -0,0 +1,13 @@
+// 처음 문제를 봤을때는 이해가 잘 가지 않았지만,
+// 비트들을 뒤집으라는 설명으로 풀었던 것 같다.
+// Integer.reverse() 메소드를 사용하여 풀었다.
+// 지피티의 도움으로 Integer.reverse()를 사용하라는 힌트를 얻었다.
+// 찾아보니 reverse(N)는 N을 2의 보수 비트로 바꾸고 그것을 뒤집는 방식이었다.
+// 시간복잡도 : O(1) -> Integer가 32비트 고정이라서 O(1)
+// 공간복잡도 : O(1) -> 32비트 고정
+public class Solution {
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+        return Integer.reverse(n);
+    }
+}

two-sum/Gotprgmer.java

@@ -0,0 +1,54 @@
+// 배열을 정렬하여 투포인터로 접근하여 풀었습니다.
+// 정렬된 배열의 인덱스를 찾기 위해 indexOf 메소드를 만들어서 사용했습니다.
+
+// 시간복잡도 : O(NlogN) -> 정렬을 위해 O(NlogN) + 투포인터로 O(N)이므로 O(NlogN)
+// 공간복잡도 : O(N) -> 정렬을 위해 복사한 배열이 필요하므로 O(N)
+class SolutionGotprgmer {
+    public int[] twoSum(int[] nums, int target) {
+        int[] original = new int[nums.length];
+
+        for(int i=0;i<nums.length;i++){
+            original[i] = nums[i];
+        }
+        Arrays.sort(nums);
+
+        int l = 0;
+        int r = nums.length-1;
+        while (l<r){
+            int lV = nums[l];
+            int rV = nums[r];
+            int total = lV + rV;
+            if(total > target){
+                r -= 1;
+            }
+            else if(total < target){
+                l += 1;
+            }
+            else{
+                int[] ans = indexOf(lV,rV,original);
+                l = ans[0];
+                r = ans[1];
+                break;
+            }
+        }
+        return new int[] {l,r};
+    }
+
+    public int[] indexOf(int l,int r, int[] nums){
+        int lIdx = -1;
+        int rIdx = -1;
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i] == l){
+                lIdx = i;
+                break;
+            }
+        }
+        for(int i = nums.length-1;i>-1;i--){
+            if(nums[i] == r){
+                rIdx = i;
+                break;
+            }
+        }
+        return new int[] {lIdx,rIdx};
+    }
+}