finish

Author: AstinCHOI

.python-version

@@ -0,0 +1 @@
+3.7.0

10장_검색/1_sequential_search.py

@@ -9,8 +9,8 @@ def test_sequential_search():
     seq = [1, 5, 6, 8, 3]
     n1 = 5
     n2 = 7
-    assert(sequential_search(seq, n1) == True)
-    assert(sequential_search(seq, n2) == False)
+    assert(sequential_search(seq, n1) is True)
+    assert(sequential_search(seq, n2) is False)
     print("테스트 통과!")
 
 

10장_검색/2_ordered_sequential_search.py

@@ -12,8 +12,8 @@ def test_ordered_sequential_search():
     seq = [1, 2, 4, 5, 6, 8, 10]
     n1 = 10
     n2 = 7
-    assert(ordered_sequential_search(seq, n1) == True)
-    assert(ordered_sequential_search(seq, n2) == False)
+    assert(ordered_sequential_search(seq, n1) is True)
+    assert(ordered_sequential_search(seq, n2) is False)
     print("테스트 통과!")
 
 

10장_검색/3_quick_select.py

@@ -1,11 +1,11 @@
 import random
 
 
-def quickSelect(seq, k):
-    # 이 부분은 퀵 정렬과 같다.
+def quick_select_cache(seq, k):
     len_seq = len(seq)
     if len_seq < 2:
         return seq[0]
+
     # 피벗을 무작위로 선택할 수 있다.
     # pivot = random.choice(seq)
     ipivot = len_seq // 2
@@ -14,23 +14,54 @@ def quickSelect(seq, k):
     smallerList = [x for i, x in enumerate(seq) if x <= pivot and i != ipivot]
     largerList = [x for i, x in enumerate(seq) if x > pivot and i != ipivot]
 
-    # 이 부분에서 퀵 정렬과 다르다.
-    m = len(smallerList) + 1
+    m = len(smallerList)
     if k == m:
         return pivot
     elif k < m:
-        return quickSelect(smallerList, k)
+        return quick_select_cache(smallerList, k)
     else:
-        return quickSelect(largerList, k-m-1)
+        return quick_select_cache(largerList, k-m-1)
 
 
-if __name__ == "__main__":
-    seq = [10, 60, 100, 50, 60, 75, 31, 50, 30, 20, 120, 170, 200]
-    # seq = [3, 7, 2, 1, 4, 6, 5, 10, 9, 11]
+def swap(seq, x, y):
+    seq[x], seq[y] = seq[y], seq[x]
+
+
+def quick_select(seq, k, left=None, right=None):
+    left = left or 0
+    right = right or len(seq) - 1
+    # ipivot = random.randint(left, right)
+    ipivot = len(seq) // 2
+    pivot = seq[ipivot]
+
+    # 피벗을 정렬 범위 밖으로 이동한다.
+    swap(seq, ipivot, right)
+    swapIndex, i = left, left
+    while i < right:
+        if pivot < seq[i]:
+            swap(seq, i, swapIndex)
+            swapIndex += 1
+        i += 1
 
+    # 피벗 위치를 확정한다.
+    swap(seq, right, swapIndex)
+
+    # 피벗 위치를 확인한다.
+    rank = len(seq) - swapIndex
+    if k == rank:
+        return seq[swapIndex]
+    elif k < rank:
+        return quick_select(seq, k, swapIndex+1, right)
+    else:
+        return quick_select(seq, k, left, swapIndex-1)
+
+
+if __name__ == "__main__":
+    seq = [3, 7, 2, 1, 4, 6, 5, 10, 9, 11]
     k = len(seq) // 2
     print(sorted(seq))
-    print(quickSelect(seq, k))
+    print(quick_select_cache(seq, k-1))
+    print(quick_select(seq, k))
     # 중앙값(median) 출력을 위해서 넘파이를 사용함
     import numpy
     print(numpy.median(seq))

10장_검색/5_search_entry_matrix.py

@@ -15,10 +15,10 @@ def find_elem_matrix_bool(m1, value):
 
 def test_find_elem_matrix_bool():
     m1 = [[1, 2, 8, 9], [2, 4, 9, 12], [4, 7, 10, 13], [6, 8, 11, 15]]
-    assert(find_elem_matrix_bool(m1, 8) == True)
-    assert(find_elem_matrix_bool(m1, 3) == False)
+    assert(find_elem_matrix_bool(m1, 8) is True)
+    assert(find_elem_matrix_bool(m1, 3) is False)
     m2 = [[0]]
-    assert(find_elem_matrix_bool(m2, 0) == True)
+    assert(find_elem_matrix_bool(m2, 0) is True)
     print("테스트 통과!")
 
 

10장_검색/6_searching_in_a_matrix.py

@@ -21,10 +21,10 @@ def test_searching_in_a_matrix():
     a = [[1, 3, 5], [7, 9, 11], [13, 15, 17]]
     import numpy
     b = numpy.array([(1, 2), (3, 4)])
-    assert(searching_in_a_matrix(a, 13) == True)
-    assert(searching_in_a_matrix(a, 14) == False)
-    assert(searching_in_a_matrix(b, 3) == True)
-    assert(searching_in_a_matrix(b, 5) == False)
+    assert(searching_in_a_matrix(a, 13) is True)
+    assert(searching_in_a_matrix(a, 14) is False)
+    assert(searching_in_a_matrix(b, 3) is True)
+    assert(searching_in_a_matrix(b, 5) is False)
     print("테스트 통과!")
 
 

11장_동적_프로그래밍/1_memo.py

@@ -0,0 +1,59 @@
+from functools import wraps
+
+from benchmark import benchmark
+
+
+def memo(func):
+    cache = {}
+
+    @wraps(func)
+    def wrap(*args):
+        if args not in cache:
+            cache[args] = func(*args)
+        return cache[args]
+    return wrap
+
+
+def fib(n):
+    if n < 2:
+        return 1
+    else:
+        return fib(n-1) + fib(n-2)
+
+
+@memo
+def fib2(n):
+    if n < 2:
+        return 1
+    else:
+        return fib2(n-1) + fib2(n-2)
+
+
+def fib3(m, n):
+    if m[n] == 0:
+        m[n] = fib3(m, n-1) + fib3(m, n-2)
+    return m[n]
+
+
+@benchmark
+def test_fib(n):
+    print(fib(n))
+
+
+@benchmark
+def test_fib2(n):
+    print(fib2(n))
+
+
+@benchmark
+def test_fib3(n):
+    m = [0] * (n+1)
+    m[0], m[1] = 1, 1
+    print(fib3(m, n))
+
+
+if __name__ == "__main__":
+    n = 35
+    test_fib(n)
+    test_fib2(n)
+    test_fib3(n)

11장_동적_프로그래밍/1_memoized_fib.py

@@ -1,29 +1,29 @@
+from bisect import bisect
 from itertools import combinations
 from functools import wraps
-from bisect import bisect
 
-from timeit import timeit
+from benchmark import benchmark
 
 
-# 단순 반복문
 def naive_longest_inc_subseq(seq):
+    """ 1) 단순한 방법 """
     for length in range(len(seq), 0, -1):
         for sub in combinations(seq, length):
             if list(sub) == sorted(sub):
                 return len(sub)
 
 
-# 동적 프로그래밍
 def dp_longest_inc_subseq(seq):
+    """ 2) 동적 프로그래밍 """
     L = [1] * len(seq)
+    res = []
     for cur, val in enumerate(seq):
         for pre in range(cur):
             if seq[pre] <= val:
                 L[cur] = max(L[cur], 1 + L[pre])
     return max(L)
 
 
-# 메모이제이션
 def memo(func):
     cache = {}
 
@@ -36,6 +36,7 @@ def wrap(*args):
 
 
 def memoized_longest_inc_subseq(seq):
+    """ 3) 메모이제이션 """
     @memo
     def L(cur):
         res = 1
@@ -46,41 +47,43 @@ def L(cur):
     return max(L(i) for i in range(len(seq)))
 
 
-# 이진 검색
 def longest_inc_bisec(seq):
+    """ 4) 이진 검색 """
     end = []
     for val in seq:
         idx = bisect(end, val)
         if idx == len(end):
             end.append(val)
         else:
             end[idx] = val
+        # print(end)
     return len(end)
 
 
-@timeit
+@benchmark
 def test_naive_longest_inc_subseq():
     print(naive_longest_inc_subseq(s1))
 
 
-@timeit
+@benchmark
 def test_dp_longest_inc_subseq():
     print(dp_longest_inc_subseq(s1))
 
 
-@timeit
+@benchmark
 def test_memoized_longest_inc_subseq():
     print(memoized_longest_inc_subseq(s1))
 
 
-@timeit
+@benchmark
 def test_longest_inc_bisec():
     print(longest_inc_bisec(s1))
 
 
 if __name__ == "__main__":
-    from random import randrange
-    s1 = [randrange(100) for i in range(20)]
+    # from random import randrange
+    # s1 = [randrange(100) for i in range(20)]
+    s1 = [94, 8, 78, 22, 38, 79, 93, 8, 84, 39]
     print(s1)
     test_naive_longest_inc_subseq()
     test_dp_longest_inc_subseq()

11장_동적_프로그래밍/2_memoized_longest_inc_subseq.py

@@ -0,0 +1,16 @@
+from functools import wraps
+import time
+
+
+def benchmark(method):
+    @wraps(method)
+    def timed(*args, **kw):
+        ts = time.time()
+        result = method(*args, **kw)
+        te = time.time()
+        # print("%r: %2.2f ms" % (method.__name__, (te - ts) * 1000))
+        # print(f"{method.__name__}: {((te-ts)*1000):.2f} ms")
+        print("{0}: {1:0.2f} ms".format(method.__name__, ((te-ts)*1000)))
+        return result
+
+    return timed