Merge pull request #2493 from hyeri0903/main

[hyeri0903] WEEK 05 Solutions

Author: hyeri0903

best-time-to-buy-and-sell-stock/hyeri0903.java

@@ -0,0 +1,43 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        /**
+        1. 하루에 팔아서 가장 최대 이익을 구하도록하는 max price return
+        2. 조건
+        - 미래 다른날짜에 판매 (이전 날짜에 판매 x)
+        - choosing a single day
+        - 배열 길이 min = 1, max = 10^5
+        - 원소값 : min = 0, max = 10^4
+        3. 풀이
+        - 1)brtueforce: time complexity O(n^2), space: O(1)
+        - 2)현재 값 - 이전 값 중 가장 최소값 -> maxProfit , 즉 min값을 계속 기억하다가 현재 값과의 차이 중 가장 큰 값을 구하면된다.
+        - time: O(n)
+        - space: O(1)
+         */
+
+        int maxProfit = 0;
+        int minStock = Integer.MAX_VALUE;
+        int n = prices.length;
+
+        for(int i = 0; i<n; i++) {
+            if(prices[i] < minStock) {
+                minStock = prices[i];
+            }
+            if(i > 0 && prices[i] - minStock > maxProfit) {
+                maxProfit = Math.max(maxProfit, prices[i] - minStock);
+            }
+        }
+        return maxProfit;
+
+
+        // for(int i = 0; i < n; i++) {
+        //     int curStock = prices[i];
+        //     for(int j= i + 1; j < n; j++) {
+        //         if(curStock < prices[j]) {
+        //             int curProfit = prices[j] - curStock;
+        //             maxProfit = Math.max(maxProfit, curProfit);
+        //         }
+        //     }
+        // }
+        // return maxProfit;
+    }
+}

encode-and-decode-strings/hyeri0903.py

@@ -0,0 +1,24 @@
+class Solution:
+    """
+    @param: strs: a list of strings
+    @return: encodes a list of strings to a single string.
+    """
+    def encode(self, strs: List[str]):
+        text = ""
+        for str in strs:
+            text += f"{len(str)}:{str}"
+        return text
+
+    """
+    @param: str: A string
+    @return: decodes a single string to a list of strings
+    """
+    def decode(self, s: str):
+        output = []
+        start = 0
+        while start < len(s):
+            mid = s.find(":", start)
+            length = int(s[start:mid])
+            output.append(s[mid + 1 : mid + 1 + length])
+            start = mid + 1 + length
+        return output

group-anagrams/hyeri0903.java

@@ -0,0 +1,42 @@
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        /**
+        1.anagram 끼리 그룹화해서 return
+        2.조건
+        - answer in any order
+        - strs 길이 최소 = 1, 최대 = 10^4
+        - 원소 하나당 길이 최소 = 0, 최대 = 100
+        - 모두 소문자로 구성
+        3.풀이
+        - 1) i번째 이후 단어를 비교해가면서 anagram check, time: O(n^2)
+        - 2) HashMap: string element 를 정렬해서 key 로 사용, 중복되는 Key 있으면 anagram, time: O(n)
+         */
+
+         int n = strs.length;
+         //anagram 체크할 Map
+         Map<String, List<String>> map = new HashMap<>();
+
+         for(int i = 0; i < n; i++) {
+            String curStr = strs[i];
+            char[] tmp = curStr.toCharArray();
+            Arrays.sort(tmp);
+            String key = new String(tmp);
+            //  System.out.println("curStr:" + curStr + ", key: " + key);
+            //Map 에 저장
+            map.putIfAbsent(key, new ArrayList<>());
+            map.get(key).add(curStr);
+            // if(!map.containsKey(key)) {
+            //     List<String> words = new ArrayList<>();
+            //     words.add(curStr);
+            //     map.put(key, words);
+            // } else {
+            //     List<String> words = map.get(key);
+            //     words.add(curStr);
+            //     map.put(key, words);
+            // }
+         }
+
+        
+         return new ArrayList<>(map.values());
+    }
+}

implement-trie-prefix-tree/hyeri0903.java

@@ -0,0 +1,68 @@
+class Trie {
+    class TrieNode {
+        TrieNode[] children;
+        boolean isEnd;
+
+        public TrieNode() {
+            children = new TrieNode[26]; // a ~ z
+            isEnd = false;
+        }
+    }
+
+    private TrieNode root;
+
+    public Trie() {
+        root = new TrieNode();
+    }
+    
+    public void insert(String word) {
+        TrieNode node = root;
+
+        for(char c: word.toCharArray()) {
+            int index = c - 'a';
+            //처음 들어오는 단어는 node 생성
+            if(node.children[index] == null) {
+                node.children[index] = new TrieNode();
+            }
+            //다음 노드로 이동
+            node = node.children[index];
+        }
+        //단어의 끝 표시
+        node.isEnd = true;
+    }
+    
+    public boolean search(String word) {
+        TrieNode node = root;
+        for(char c: word.toCharArray()) {
+            int index = c - 'a';
+            //존재하지 않으면 false return
+            if(node.children[index] == null) {
+                return false;
+            }
+            //다음 노드로 이동
+            node = node.children[index];
+        }
+        return node.isEnd;
+    }
+    
+    public boolean startsWith(String prefix) {
+        //중간에 null을 안만나면 true 반환
+        TrieNode node = root;
+        for(char c: prefix.toCharArray()) {
+            int index = c - 'a';
+            if(node.children[index] == null) {
+                return false;
+            }
+            node = node.children[index];
+        }
+        return true;
+    }
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */

word-break/hyeri0903.java

@@ -0,0 +1,32 @@
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        /**
+        1.문제: s 가 wordDict 로 쪼개질 수 있는지 true/false return
+        2.조건
+        - s 에는 wordDict 가 여러번 나올 수 있음.
+        - s.length() 최소 = 1, 최대 300
+        - wordDict.size() 최소 1, 최대 1000
+        - 한 단어 길이 최소=1, 최대 = 20
+        - 모두 소문자. 모든 wordDict 값은 unique
+        3.풀이
+        - i번째까지 문자열을 만들 수 있는지 check
+         */
+
+         int n = s.length();
+         boolean[] dp = new boolean[n+1];
+
+         dp[0] = true;  //빈 문자열인 경우
+
+         for(int i = 1; i < n+1; i++) {
+            for(int j = 0; j < i; j++) {
+                String subStr = s.substring(j, i);
+                //앞단계 모두 만들 수 있고 && wordDict에 존재하는지 체크
+                if(dp[j] && wordDict.contains(subStr)) {
+                    dp[i] = true;
+                    break; 
+                }
+            }
+         }
+        return dp[n];
+    }
+}