4.5 done

Author: daeseokyoun

README.md

@@ -43,4 +43,8 @@
 - [3.5 순환 검출](LinkedList/3_5_cycle_detect/README.md)
 - [3.6 두 수 더하기](LinkedList/3_6_add_two_num/README.md)
 ### 스택
-- [4.3 유효한 괄호 검증](Stack/4_3_valid_parentheses/README.md)
+- [4.3 유효한 괄호 검증](Stack/4_3_valid_parentheses/README.md)
+- [4.5.1 계단 오르기](Stack/4_5_1_stairs/README.md)
+- [4.5.2 모든 문자열 치환(permutation)](Stack/4_5_2_permutation/README.md)
+- [4.5.3 동전 교환](Stack/4_5_3_coin_change/README.md)
+- [4.5.4 배열의 두 부분집합의 최소 차이만들기](Stack/4_5_4_min_diff/README.md)

Stack/4_5_1_stairs/README.md

@@ -0,0 +1,13 @@
+## 계단 오르기
+- Page 227
+### Brute-force
+- [stair_bf.py](stair_bf.py)
+
+### LeetCode
+- https://leetcode.com/problems/climbing-stairs/
+
+
+
+
+
+

Stack/4_5_1_stairs/stair_bf.py

@@ -0,0 +1,41 @@
+from typing import List
+
+tests = {
+    1: 2,
+    2: 3,
+    3: 4,
+}
+
+res = {
+    1: 2,
+    2: 3,
+    3: 5,
+}
+
+def check_result(index: int, output: int):
+    if index > len(tests):
+        raise RuntimeError(f'Failed to get {index}th case')
+    return res.get(index, -1) == output
+
+def climbStairs(n: int) -> int:
+    def climb(n, i):
+        if n == i:
+           return 1
+        if n < i:
+           return 0
+            
+        return climb(n, i + 1) + climb(n, i + 2)
+        
+    return climb(n, 0)
+
+def main():
+    for index, input_val in tests.items():
+        res = climbStairs(input_val)
+
+        if check_result(index, res):
+            print(f'Test case {index} is correct: value {res}')
+        else:
+            print(f'Test case {index} is failed: value {res}')
+
+if __name__ == '__main__':
+    main()

Stack/4_5_2_permutation/README.md

@@ -0,0 +1,18 @@
+## 모든 문자열 치환(permutation)
+- Page 229
+### Brute-force 1
+- [perm_bf.py](perm_bf1.py)
+- code 에 ```s_perm(s)``` 부분을 ```find_permutation(s)```으로 변경해야 합니다.
+### Brute-force 2
+- [perm_bf.py](perm_bf1.py)
+
+
+### LeetCode
+- https://leetcode.com/problems/permutations/
+### GeeksForGeeks
+- https://practice.geeksforgeeks.org/problems/permutations-of-a-given-string/0
+
+
+
+
+

Stack/4_5_2_permutation/perm_bf1.py

@@ -0,0 +1,47 @@
+from typing import List
+import collections
+
+tests = {
+    1: "abc"
+}
+
+res = {
+    1: ["abc", "acb", "bac", "bca", "cab", "cba"]
+}
+
+def is_same_list(alist: List, blist: List):
+    return collections.Counter(alist) == collections.Counter(blist)
+
+def check_result(index: int, output: List):
+    if index > len(tests):
+        raise RuntimeError(f'Failed to get {index}th case')
+
+    return is_same_list(output, res.get(index, []))
+
+def find_permutation(s):
+    if len(s) == 1:
+        return list(s)
+
+    ans = []
+    curr = s[0]
+    s = s[1:]
+
+    words = find_permutation(s)
+
+    for sub in words:
+        for i in range(len(sub) + 1):
+            ans.append("".join([sub[:i], curr, sub[i:]]))
+
+    return ans
+
+def main():
+    for index, input_str in tests.items():
+        res = find_permutation(input_str)
+
+        if check_result(index, res):
+            print(f'Test case {index} is correct: value {res}')
+        else:
+            print(f'Test case {index} is failed: value {res}')
+
+if __name__ == '__main__':
+    main()

Stack/4_5_2_permutation/perm_bf2.py

@@ -0,0 +1,41 @@
+from typing import List
+import collections
+
+tests = {
+    1: "abc"
+}
+
+res = {
+    1: ["abc", "acb", "bac", "bca", "cab", "cba"]
+}
+
+def is_same_list(alist: List, blist: List):
+    return collections.Counter(alist) == collections.Counter(blist)
+
+def check_result(index: int, output: List):
+    if index > len(tests):
+        raise RuntimeError(f'Failed to get {index}th case')
+
+    return is_same_list(output, res.get(index, []))
+
+def find_permutation(res, chs, s, e):
+    if s == e - 1:
+        res.append("".join(chs))
+    else:
+        for i in range(s, e):
+            chs[s], chs[i] = chs[i], chs[s]
+            find_permutation(res, chs, s + 1, e)
+            chs[s], chs[i] = chs[i], chs[s] 
+
+def main():
+    for index, input_str in tests.items():
+        res = []
+        find_permutation(res, list(input_str), 0, len(input_str))
+
+        if check_result(index, res):
+            print(f'Test case {index} is correct: value {res}')
+        else:
+            print(f'Test case {index} is failed: value {res}')
+
+if __name__ == '__main__':
+    main()

Stack/4_5_3_coin_change/README.md

@@ -0,0 +1,14 @@
+## 동전 교환
+- Page 232
+### Brute-force 1
+- [coin_change_bf.py](coin_change_bf.py)
+
+### LeetCode
+ - https://leetcode.com/problems/coin-change/
+### GeeksforGeeks
+- https://practice.geeksforgeeks.org/problems/coin-change/0
+
+
+
+
+

Stack/4_5_3_coin_change/coin_change_bf.py

@@ -0,0 +1,55 @@
+from typing import List
+import sys
+
+tests = {
+    1: ([1,2,5], 11),
+    2: ([2], 3),
+    3: ([1], 0),
+    4: ([1], 1),
+    5: ([1], 2)
+}
+
+res = {
+    1: 3,
+    2: -1,
+    3: 0,
+    4: 1,
+    5: 2,
+}
+
+def check_result(index: int, output: int):
+    if index > len(tests):
+        raise RuntimeError(f'Failed to get {index}th case')
+    return res.get(index, -1) == output
+
+def coinChange(coins: List[int], value: int) -> int:
+    def change(v:int):
+        if v == 0:
+            return 0
+
+        min_coin_cnt = sys.maxsize
+        for c in coins:
+            if (v - c) >= 0:
+                change_cnt = change(v - c)
+                if change_cnt < min_coin_cnt:
+                    min_coin_cnt = change_cnt
+
+        return min_coin_cnt + 1
+
+    ans = change(value)
+
+    return ans if ans != sys.maxsize + 1 else -1
+
+def main():
+    for index, data in tests.items():
+        coins = data[0]
+        value = data[1]
+        res = coinChange(coins, value)
+
+        if check_result(index, res):
+            print(f'Test case {index} is correct: value {res}')
+        else:
+            print(f'Test case {index} is failed: value {res}')
+
+if __name__ == '__main__':
+    main()

Stack/4_5_4_min_diff/README.md

@@ -0,0 +1,15 @@
+## 배열의 두 부분집합의 최소 차이만들기
+- Page 234
+### Brute-force 1
+- [min_diff_bf.py](min_diff_bf.py)
+
+### LeetCode
+- https://leetcode.com/problems/partition-equal-subset-sum/
+### GeeksForGeeks
+- https://practice.geeksforgeeks.org/problems/minimum-sum-partition/0
+
+
+
+
+
+

Stack/4_5_4_min_diff/min_diff_bf.py

@@ -0,0 +1,46 @@
+from typing import List
+import sys
+
+tests = {
+    1: [1,5,11,5],
+    2: [1,2,3,5],
+    3: [3, 2, 4, 7, 1]
+}
+
+res = {
+    1: 0,
+    2: 1,
+    3: 1 
+}
+
+def check_result(index: int, output: int):
+    if index > len(tests):
+        raise RuntimeError(f'Failed to get {index}th case')
+    return res.get(index, -1) == output
+
+min_diff = float('inf')
+total = 0
+
+def subset_diff(index: int, nums: List[int], subsum: int):
+    global total, min_diff
+    if index == len(nums):
+        min_diff = min(min_diff, abs(((total - subsum) - subsum)))
+        return
+
+    subset_diff(index + 1, nums, subsum + nums[index])
+    subset_diff(index + 1, nums, subsum)
+
+def main():
+    global total, min_diff
+    for index, arr in tests.items():
+        min_diff = float('inf')
+        total = sum(arr)
+        subset_diff(0, arr, 0)
+
+        if check_result(index, min_diff):
+            print(f'Test case {index} is correct: value {min_diff}')
+        else:
+            print(f'Test case {index} is failed: value {min_diff}')
+
+if __name__ == '__main__':
+    main()