Merge branch 'DaleStudy:main' into main

Author: river20s

3sum/Gotprgmer.java

@@ -0,0 +1,37 @@
+// 이전에 투포인터를 활용하여 시도했지만 중복된 값들을 처리하는데 어려움이 있었습니다.
+// 그래서 해답을 보았고 새로운 방법으로 풀어보았습니다.
+// 서로 다른 i와 j 인덱스를 2중 for문으로 진행하면서
+// i와 j사이 수들을 set으로 관리합니다.
+// set에 -nums[i]-nums[j]가 존재하면 결과 리스트에 추가합니다.
+// 시간복잡도 : O(N^2)
+// 공간복잡도 : O(N)
+class SolutionGotprgmer {
+    public List<List<Integer>> threeSum(int[] nums) {
+        // 결과를 저장할 리스트
+        List<List<Integer>> result = new ArrayList<>();
+        Set<Integer> set;
+        Set<List<Integer>> resultSet = new HashSet<>();
+        List<Integer> numList;
+
+
+        // 리스트 정렬
+        Arrays.sort(nums);
+        for(int i=0;i<nums.length-2;i++){
+            if (i > 0 && nums[i - 1] == nums[i]) continue;
+
+            set = new HashSet<>();
+            for(int j=i+1;j<nums.length;j++){
+                int checkNum = nums[i]+nums[j];
+                if(set.contains(-checkNum)){
+                    numList = new ArrayList<>(Arrays.asList(nums[i], -checkNum, nums[j]));
+                    if(!resultSet.contains(numList)){
+                        result.add(numList);
+                        resultSet.add(numList);
+                    }
+                }
+                set.add(nums[j]);
+            }
+        }
+        return result;
+    }
+}

3sum/higeuni.js

@@ -0,0 +1,43 @@
+// complexity
+// time: O(n^2)
+// - sort: O(n log n)
+// - for loop: O(n)
+// - while loop: O(n)
+// space: O(n)
+// - sortedNums: O(n)
+// - else : O(1)
+
+var threeSum = function(nums) {
+  const sortedNums = nums.sort((a, b) => a - b)
+  const lengthOfArray = nums.length;
+  const answer = [];
+
+  for(let i = 0; i < lengthOfArray; i++ ) {
+      if (i > 0 && nums[i] === nums[i - 1]) continue;
+      const target = (-1) * sortedNums[i];
+
+      let left = i + 1;
+      let right = lengthOfArray - 1;
+
+      while(left < right) {
+          const sumOfLeftAndRight = sortedNums[left] + sortedNums[right];
+          const diff = sumOfLeftAndRight - target;
+
+          if( diff > 0 ){
+              right -= 1;
+          } else if ( diff < 0 ){
+              left += 1
+          } else {
+              answer.push([sortedNums[i], sortedNums[left], sortedNums[right]]);
+              // 중복되는 부분을 처리하는 과정에서 계속 fail되어 찾아보니 이렇게 해야 통과되었다.
+              while(left < right && sortedNums[left] === sortedNums[left + 1]) left ++;
+              while(left < right && sortedNums[right] === sortedNums[right - 1]) right --;
+              
+              left++;
+              right--;
+          }
+      }
+  }
+  return answer
+};
+

climbing-stairs/Gotprgmer.java

@@ -0,0 +1,16 @@
+// dp문제
+// i번째 계단을 가려면 i-1번째 계단까지의 경우의 수와 i-2번째 계단까지의 경우의 수를 합친 것
+// 시간복잡도 : O(N)
+// 공간복잡도 : O(N)
+class Solution {
+    public int climbStairs(int n) {
+        int[] dp = new int[n+1];
+        dp[0] = 1;
+        dp[1] = 1;
+        for(int i=2;i<n+1;i++){
+            dp[i] = dp[i-1]+dp[i-2];
+        }
+        return dp[n];
+
+    }
+}

climbing-stairs/higeuni.js

@@ -0,0 +1,20 @@
+// complexity
+// time: O(n)
+// - for loop: O(n)
+// space: O(1)
+// - n에 관계없이 상수개의 변수만 사용되므로 O(1)
+
+var climbStairs = function(n) {
+  let num1 = 1;
+  let num2 = 1;
+  let temp = 0;
+
+  for(let i = 2; i<=n; ++i ) {
+      temp = num2;
+      num2 = num1 + num2;
+      num1 = temp;
+  }
+  
+  return num2;
+};
+

house-robber/Gotprgmer.java

@@ -0,0 +1,38 @@
+// 해당 문제는 dfs로 풀이 하던 도중, 시간제한으로 풀지 못하였습니다.
+// 이후 답을 참고하였고, 메모이제이션을 떠올리게 되었습니다.
+// 풀이 아이디어는 i번째 인덱스를 선택한 합과 i+1번째 인덱스를 선택한 합중에 큰 것을 선택하는 것이 가장 큰 아이디어 였습니다.
+// 그런데 중복된 과정이 존재하기에 메모이제이션을 활용하여
+// 원래는 O(2^N)의 시간복잡도를
+// 각 인덱스에 해당하는 함수호출을 1번씩만 하도록 유도하여 시간복잡도를 해결하였습니다.
+// 시간복잡도 : O(N)
+// 공간복잡도 : O(N)
+
+class SolutionGotprgmer {
+    static int[] memo;
+    static int answer;
+    public int rob(int[] nums) {
+        answer = 0;
+        memo = new int[nums.length];
+        for(int i=0;i<nums.length;i++){
+            memo[i] = -1;
+        }
+        return dfs(nums,0);
+    }
+    public int dfs(int[] nums, int idx){
+        if(idx<nums.length){
+
+            if(memo[idx] != -1){
+                return memo[idx];
+            }
+            else{
+                memo[idx] = Math.max(nums[idx]+dfs(nums,idx+2),dfs(nums,idx+1));
+                return memo[idx];
+            }
+        }
+        else{
+            return 0;
+        }
+
+
+    }
+}

longest-consecutive-sequence/Gotprgmer.java

@@ -0,0 +1,29 @@
+import java.util.*;
+class SolutionGotprgmer {
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for(int num:nums){
+            set.add(num);
+        }
+        System.out.println(set);
+        int answer = 0;
+        for(int num:nums){
+            //왼쪽으로 확장
+            int left = 0;
+            while(set.contains(num-(left+1))){
+                left += 1;
+            }
+
+            //오른쪽으로 확장
+            int right = 0;
+            while(set.contains(num+right+1)){
+                right += 1;
+            }
+            System.out.println(String.valueOf(left)+" " + String.valueOf(right));
+            answer = Math.max(answer,left+right+1);
+        }
+
+        return answer;
+
+    }
+}

valid-anagram/Gotprgmer.java

@@ -0,0 +1,30 @@
+// 각 s와 t의 알파벳 수를 카운팅 시켜서 마지막에 카운팅이 모두 같으면 true
+// 그렇지 않으면 false;
+
+// 시간복잡도 O(N) => 1중 for문
+// 공간복잡도 O(N) => N개 알파벳이 들어있는 Map 2개
+class SolutionGotprgmer {
+    public boolean isAnagram(String s, String t) {
+        Map<Character,Integer> sMap = new HashMap<>();
+        Map<Character,Integer> tMap = new HashMap<>();
+        if(s.length() != t.length()){
+            return false;
+        }
+        for(int i=0;i<s.length();i++){
+            char sChar = s.charAt(i);
+            char tChar = t.charAt(i);
+            sMap.put(sChar,sMap.getOrDefault(sChar,0)+1);
+            tMap.put(tChar,tMap.getOrDefault(tChar,0)+1);
+        }
+        boolean flag = true;
+        for(char c:sMap.keySet()){
+            if(!sMap.getOrDefault(c,0).equals(tMap.getOrDefault(c,0))){
+                flag = false;
+                System.out.println(c);
+                break;
+            }
+        }
+
+        return flag;
+    }
+}

valid-anagram/higeuni.js

@@ -0,0 +1,14 @@
+// complexity
+// time: O(n log n)
+// - sort: O(n log n)
+// - split: O(n)
+// - join: O(n)
+// space: O(n)
+// - sortedS: O(n)
+// - sortedT: O(n)
+// - else : O(1)
+
+var isAnagram = function(s, t) {
+  return s.split('').sort().join('') === t.split('').sort().join('')
+};
+