diff --git a/3sum/rivkode.py b/3sum/rivkode.py
index 063ee7d5d..0f211135e 100644
--- a/3sum/rivkode.py
+++ b/3sum/rivkode.py
@@ -1,5 +1,43 @@
 from typing import List, Tuple, Set
 
+class Solution(object):
+    def threeSum(self, nums):
+        result = set()
+        v_set = {}
+
+        for i, v in enumerate(nums):
+            v_set[v] = i
+
+        n = len(nums)
+        for i in range(n):
+            for j in range(i + 1, n):
+                v = nums[i]
+                w = nums[j]
+                target = -(v + w)
+                if target in v_set:
+                    k = v_set[target]
+                    if k != i and k != j:
+                        triplet = tuple(sorted([v, w, target]))
+                        result.add(triplet)
+
+        return list(result)
+
+if __name__ == "__main__":
+    solution = Solution()
+    nums = [-1,0,1,2,-1,-4]
+    result = solution.threeSum(nums)
+    print(result)
+
+
+
+
+
+        
+        
+
+
+# previous version
+
 # threeSum3()
 # Time Complexity O(n ^ 2)
 # - when sorting by sorted function(TimSort) for each string it takes O(nlogn)
@@ -8,58 +46,60 @@
 # - when sorting takes O(1)
 
 
-class Solution:
-    def threeSum(self, nums: List[int]) -> list[tuple[int, ...]]:
-
-        triplets = set()
-        for i in range(len(nums) - 2):
-            for j in range(i + 1, len(nums)):
-                for k in range(j + 1, len(nums)):
-                    if nums[i] + nums[j] + nums[k] == 0:
-                        triplet = [nums[i], nums[j], nums[k]]
-                        triplets.add(tuple(sorted(triplet)))
-
-        return list(triplets)
-
-    def threeSum2(self, nums: List[int]) -> list[tuple[int, ...]]:
-        triplets = set()
-
-        for i in range(len(nums)):
-            seen = set()
-            for j in range(i + 1, len(nums)):
-                res = -(nums[i] + nums[j])
-                if res in seen:
-                    triplet = [nums[i], nums[j], res]
-                    triplets.add(tuple(sorted(triplet)))
-                seen.add(nums[j])
-
-        return list(triplets)
-
-    def threeSum3(self, nums: List[int]) -> list(tuple[int, ...]):
-        triplets = set()
-        nums.sort()
-
-        for i in range(len(nums) - 2):
-            l = i + 1
-            r = len(nums) - 1
-
-            while l < r:
-                res = nums[l] + nums[r] + nums[i]
-                if res > 0:
-                    r -= 1
-                elif res < 0:
-                    l += 1
-                elif res == 0:
-                    triple = (nums[l], nums[r], nums[i])
-                    triplets.add(triple)
-                    l, r = l + 1, r - 1
-                else:
-                    raise Exception
-        return list(triplets)
+# class Solution:
+#     def threeSum(self, nums: List[int]) -> list[tuple[int, ...]]:
 
-if __name__ == "__main__":
-    nums = [-1,0,1,2,-1,-4]
+#         triplets = set()
+#         for i in range(len(nums) - 2):
+#             for j in range(i + 1, len(nums)):
+#                 for k in range(j + 1, len(nums)):
+#                     if nums[i] + nums[j] + nums[k] == 0:
+#                         triplet = [nums[i], nums[j], nums[k]]
+#                         triplets.add(tuple(sorted(triplet)))
+
+#         return list(triplets)
+
+#     def threeSum2(self, nums: List[int]) -> list[tuple[int, ...]]:
+#         triplets = set()
+
+#         for i in range(len(nums)):
+#             seen = set()
+#             for j in range(i + 1, len(nums)):
+#                 res = -(nums[i] + nums[j])
+#                 if res in seen:
+#                     triplet = [nums[i], nums[j], res]
+#                     triplets.add(tuple(sorted(triplet)))
+#                 seen.add(nums[j])
+
+#         return list(triplets)
+
+#     def threeSum3(self, nums: List[int]) -> list(tuple[int, ...]):
+#         triplets = set()
+#         nums.sort()
+
+#         for i in range(len(nums) - 2):
+#             l = i + 1
+#             r = len(nums) - 1
+
+#             while l < r:
+#                 res = nums[l] + nums[r] + nums[i]
+#                 if res > 0:
+#                     r -= 1
+#                 elif res < 0:
+#                     l += 1
+#                 elif res == 0:
+#                     triple = (nums[l], nums[r], nums[i])
+#                     triplets.add(triple)
+#                     l, r = l + 1, r - 1
+#                 else:
+#                     raise Exception
+#         return list(triplets)
+
+# if __name__ == "__main__":
+#     nums = [-1,0,1,2,-1,-4]
+
+
+#     solution = Solution()
+#     solution.threeSum3(nums)
 
 
-    solution = Solution()
-    solution.threeSum3(nums)
diff --git a/climbing-stairs/rivkode.py b/climbing-stairs/rivkode.py
index 9e030f10b..a5d07de06 100644
--- a/climbing-stairs/rivkode.py
+++ b/climbing-stairs/rivkode.py
@@ -1,20 +1,41 @@
 # Time Complexity O(n)
 # - traversing for loop takes O(n)
+# - same with 피보나치
 # Space Complexity O(n)
 # - appending for loop it takes O(n)
 
 class Solution:
-    def climbStairs(self, n: int) -> int:
-        stage = [1, 2, 3]
 
-        for i in range(3, 45):
-            value = stage[i - 1] + stage[i - 2]
-            stage.append(value)
+    def climbStairs(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
 
-        return stage[n - 1]
+        map = {1:1, 2:2}
+
+
+        for i in range(3, n + 1):
+            map[i] = map[i-1] + map[i-2]
+        
+        return map[n]
+
+
+    # def climbStairs(self, n: int) -> int:
+    #     stage = [1, 2, 3]
+
+    #     for i in range(3, 45):
+    #         value = stage[i - 1] + stage[i - 2]
+    #         stage.append(value)
+
+    #     return stage[n - 1]
 
 if __name__ == "__main__":
     solution = Solution()
     result = solution.climbStairs(5)
     print(result)
 
+
+
+
+
diff --git a/product-of-array-except-self/rivkode.py b/product-of-array-except-self/rivkode.py
new file mode 100644
index 000000000..21701414b
--- /dev/null
+++ b/product-of-array-except-self/rivkode.py
@@ -0,0 +1,49 @@
+class Solution(object):
+    def productExceptSelf(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[int]
+        """
+
+        all_multi = 1
+        zero_count = 0
+        result = []
+
+        for v in nums:
+            if v == 0:
+                zero_count += 1
+                continue
+            all_multi *= v
+        all_multi = int(all_multi)
+
+        if zero_count == 0:
+            for v in nums:
+                if v == 0:
+                    result.append(all_multi)
+                else:
+                    cur = all_multi / v
+                    result.append(int(cur))
+        elif zero_count == 1:
+            for v in nums:
+                if v == 0:
+                    result.append(all_multi)
+                else:
+                    result.append(0)
+
+        if zero_count >= 2:
+            return [0 for _ in range(len(nums))]
+        
+        return result
+
+
+if __name__ == "__main__":
+    solution = Solution()
+    # nums = [1,2,3,4]
+    # nums = [-1,1,0,-3,3]
+    nums = [1,2,3,4,0,0]
+    result = solution.productExceptSelf(nums)
+    print(result)
+
+
+
+
diff --git a/valid-anagram/rivkode.py b/valid-anagram/rivkode.py
index 2e44f029a..a25d68a43 100644
--- a/valid-anagram/rivkode.py
+++ b/valid-anagram/rivkode.py
@@ -1,26 +1,68 @@
 from typing import List
 
 # Time Complexity O(n log n)
-# - when sorting by sorted function(TimSort) for each string it takes O(nlogn)
-# - traversing for loop takes O(n)
+# - check len first
+# - make set for one of list for each values
+#   - if there's a duplication, then value += 1. This is a number of count.
+# - fetch value using set.get() method.
+#   - minus 1 and check if it is less than 0 which means it's invalid. return false directly.
 # Space Complexity O(n)
 # - when sorting takes O(n)
 
 class Solution:
     def isAnagram(self, s: str, t: str) -> bool:
-        s_sorted = sorted(s)
-        t_sorted = sorted(t)
 
-        for i in range(len(s_sorted)):
-            if s_sorted[i] != t_sorted[i]:
-                return False
-        return True
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        s_list = list(s)
+        t_list = list(t)
+
+        if len(s_list) != len(t_list):
+            return False
+
+        t_set = {}
+        for t_val in t_list:
+            cur = t_set.get(t_val, 0)
+            cur += 1
+            t_set[t_val] = cur
+            
+        
+        flag = True
+    
+        for s_val in s_list:
+            if t_set.get(s_val):
+                cur = t_set.get(s_val)
+                cur -= 1
+                t_set[s_val] = cur
+                if cur < 0:
+                    flag = False
+                    break 
+            else:
+                flag = False
+                break
+        
+        return flag
+    
+    # previous logic
+        # s_sorted = sorted(s)
+        # t_sorted = sorted(t)
+
+        # for i in range(len(s_sorted)):
+        #     if s_sorted[i] != t_sorted[i]:
+        #         return False
+        # return True
+
 
 if __name__ == "__main__":
     solution = Solution()
 
-    s = "nagaram"
-    t = "anagram"
+    s = "a"
+    t = "ab"
 
     result = solution.isAnagram(s, t)
     print(result)
+
+