Merge pull request #2424 from OstenHun/main

[OstenHun] WEEK 02 Solutions

Author: OstenHun

climbing-stairs/OstenHun.cpp

@@ -0,0 +1,70 @@
+/*
+    You are climbing a staircase. It takes n steps to reach the top.
+
+    Each time you can either climb 1 or 2 steps. 
+    In how many distinct ways can you climb to the top?
+
+    Example 1:
+
+    Input: n = 2
+    Output: 2
+    Explanation: There are two ways to climb to the top.
+    1. 1 step + 1 step
+    2. 2 steps
+
+    Constraints:
+    1 <= n <= 45
+*/
+
+// TimeComplexity : O(n)
+// SpaceComplexity : O(n)
+#include <iostream>
+using namespace std;
+
+#pragma region DpArrayIdea
+namespace dp_array_idea {
+
+class Solution {
+public:
+    int climbStairs(int n) {
+        int dp[45];
+
+        // dp[i]는 i-1번째 칸을 오르는 경우의 수를 말한다.
+        dp[0] = 1;
+        dp[1] = 2;
+
+        for (int i = 2; i < n; i++) {
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+
+        return dp[n-1];
+    }
+};
+
+}  // namespace dp_array_idea
+#pragma endregion
+
+// 배열을 사용하지 않는 풀이
+// Time : O(n)
+// Space : O(1)
+#pragma region FinalSolution
+class Solution {
+public:
+    int climbStairs(int n) {
+        if (n <= 2) {
+            return n;
+        }
+
+        int one_back = 1;
+        int two_back = 2;
+
+        for (int i = 3; i <= n; i++) {
+            int current = one_back + two_back;
+            two_back = one_back;
+            one_back = current;
+        }
+
+        return one_back;
+    }
+};
+#pragma endregion

valid-anagram/OstenHun.cpp

@@ -0,0 +1,111 @@
+/*
+    Given two strings s and t, return true
+    if t is an anagram of s, and false otherwise.
+
+    An anagram is a word or phrase formed by rearranging
+    the letters of a different word or phrase,
+    using all the original letters exactly once.
+
+    Input: s = "anagram", t = "nagaram"
+    Output: true
+*/
+
+#include <string>
+#include <unordered_map>
+using namespace std;
+
+// 첫 번째 풀이 --> 배열 두 개를 이용해서 직접 비교
+#pragma region FirstIdea_TwoArrays
+namespace first_idea {
+
+class Solution {
+public:
+    bool isAnagram(const string& s, const string& t) {
+        int freq_s[26] = {};
+        int freq_t[26] = {};
+
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        for (size_t i = 0; i < s.length(); i++) {
+            freq_s[s[i] - 'a']++;
+        }
+
+        for (size_t i = 0; i < t.length(); i++) {
+            freq_t[t[i] - 'a']++;
+        }
+
+        for (int i = 0; i < 26; i++) {
+            if (freq_s[i] != freq_t[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+}  // namespace first_idea
+#pragma endregion
+
+// 두 번째 풀이 --> 배열 하나를 사용해서 풀이
+#pragma region FinalSolution_OneArray
+class Solution {
+public:
+    bool isAnagram(const string& s, const string& t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        int freq[26] = {};
+
+        for (size_t i = 0; i < s.length(); i++) {
+            freq[s[i] - 'a']++;
+            freq[t[i] - 'a']--;
+        }
+
+        for (int count : freq) {
+            if (count != 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+#pragma endregion
+
+// 세 번째 풀이 --> unordered_map 이용하기
+#pragma region Alternative_UnorderedMap
+namespace unordered_map_idea {
+
+class Solution {
+public:
+    bool isAnagram(const string& s, const string& t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        unordered_map<char, int> freq;
+
+        for (char ch : s) {
+            freq[ch]++;
+        }
+
+        for (char ch : t) {
+            freq[ch]--;
+        }
+
+        for (const auto& [ch, count] : freq) {
+            if (count != 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+}  // namespace unordered_map_idea
+#pragma endregion