Merge pull request #1215 from b41-41/main

Author: b41-41

climbing-stairs/b41-41.ts

@@ -0,0 +1,53 @@
+function climbStairs(n: number): number {
+    // 방법 1: (Failed)
+    // Set 객체에 '1', '2'를 담고 while문으로 계속 증가시키면서 계산하는 방법
+
+    // 시간 복잡도: O(n * 2^n) - 각 단계마다 가능한 모든 조합을 생성하므로 지수적으로 증가
+    // 공간 복잡도: O(2^n) - 최악의 경우 모든 가능한 조합을 저장해야 함
+    // 실패 이유: 시간 초과
+    const getResult1 = (): number => {
+        const currentSet = new Set<string>(['1', '2']);
+        const resultSet = new Set<string>();
+
+        while (currentSet.size > 0) {
+            const nextSet = new Set<string>();
+
+            currentSet.forEach((path) => {
+                const sum = [...path].reduce((acc, cur) => acc + parseInt(cur), 0);
+                if (sum === n) resultSet.add(path);
+                else if (sum < n) {
+                    nextSet.add(path + '1');
+                    nextSet.add(path + '2');
+                }
+            });
+
+            currentSet.clear();
+            nextSet.forEach((v) => currentSet.add(v));
+        }
+
+        return resultSet.size;
+    };
+
+    // 방법 2:
+    // 앞 2가지 더하기 
+
+    // 시간 복잡도: O(n) - n까지 한 번의 반복문만 실행
+    // 공간 복잡도: O(1) - 고정된 변수(prev2, prev1)만 사용하여 추가 메모리 사용 없음
+    const getResult2 = () => {
+        if(n <= 2) {
+            return n;
+        }
+        
+        let prev2 = 1;
+        let prev1 = 2;
+        for(let i = 3; i <= n; i++) {
+            const curr = prev2 + prev1;
+            prev2 = prev1;
+            prev1 = curr;
+        }
+        return prev1;
+    };
+
+    // return getResult1();
+    return getResult2();
+};

valid-anagram/b41-41.ts

@@ -0,0 +1,94 @@
+function isAnagram(s: string, t: string): boolean {
+    /* 방법 1:
+     * 문자열을 순서대로 정렬 후 맞는지 비교한다.
+
+     * 시간 복잡도: O(n log n) - 문자열 정렬에 O(n log n) 시간이 소요됨
+     * 공간 복잡도: O(n) - 정렬된 문자열을 저장하기 위한 추가 배열 필요
+     */
+    const checkAnagramFromSort = (): boolean => {
+        if (s.length !== t.length) {
+            return false;
+        }
+
+        const sortedS: string[] = [...s].sort();
+        const sortedT: string[] = [...t].sort();
+
+        for(let i = 0; i < s.length; i++) {
+            console.log(sortedS[i], sortedT[i]);
+            if(sortedS[i] !== sortedT[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /* 방법 2: (Failed)
+     * Size 체크 후 Set객체에 s단어를 할당한 후 t에서 has메소드로 체크
+
+     * 시간 복잡도: O(n) - 문자열을 한 번씩 순회
+     * 공간 복잡도: O(k) - k는 고유 문자의 수 (최대 알파벳 개수만큼)
+     * 실패 이유: Set 객체를 사용하여 중복 문자가 사라지기 때문에 정상적인 비교가 불가
+     */
+    const checkAnagramFromSetObject = (): boolean => {
+        const sSet = new Set(s);
+        const tSet = new Set(t);
+
+        if (s.length !== t.length) {
+            return false;
+        } else {
+            for(let str of sSet) {
+                if(!tSet.has(str)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    };
+
+    /* 방법3:
+     * countMap을 만들어 둠
+     * Map<string, number> 타입
+     * S, T의 길이가 일치한다는 가정 하에
+     * S는 알파벳마다 +1을 T는 -1을 계산
+     * 값이 0이 되는 순간 항상 삭제
+     * 전부 돌았을 때 countMap.size가 0인 경우 true
+     * 
+     * 시간 복잡도: O(n) - 문자열을 한 번만 순회
+     * 공간 복잡도: O(k) - k는 고유 문자의 수 (최대 알파벳 개수만큼)
+     */
+    const checkAnagramFromCountMap = ():boolean => {
+        if(s.length !== t.length) return false;
+
+        const countMap = new Map<string, number>();
+
+        for(let i = 0; i < s.length; i++) {
+            const sWord = s[i];
+            const tWord = t[i];
+
+            const prevSValue = countMap.get(sWord) ?? 0;
+            const nextSValue = prevSValue + 1;
+            if(nextSValue === 0) {
+                countMap.delete(sWord)
+            } else {
+                countMap.set(sWord, nextSValue);
+            }
+
+            const prevTValue = countMap.get(tWord) ?? 0;          
+            const nextTValue = prevTValue - 1;
+            if (nextTValue === 0) {
+                countMap.delete(tWord)
+            } else {
+                countMap.set(tWord, nextTValue);
+            }
+        };
+
+        return countMap.size === 0;
+    
+    };
+    
+    // return checkAnagramFromSort();
+    // return checkAnagramFromSetObject();
+    return checkAnagramFromCountMap();
+};