update

Author: AstinCHOI

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "python.linting.pylintEnabled": false,
+  "python.linting.pep8Enabled": true,
+  "python.linting.enabled": true
+}

10장_검색/10_intersection_two_arrays.py

@@ -0,0 +1,49 @@
+from binary_search import binary_search_iter
+
+
+# 파이썬 set 사용
+def intersection_two_arrays_sets(seq1, seq2):
+    set1 = set(seq1)
+    set2 = set(seq2)
+    return set1.intersection(set2)
+
+
+# 병합 정렬 사용
+def intersection_two_arrays_ms(seq1, seq2):
+    res = []
+    while seq1 and seq2:
+        if seq1[-1] == seq2[-1]:
+            res.append(seq1.pop())
+            seq2.pop()
+        elif seq1[-1] > seq2[-1]:
+            seq1.pop()
+        else:
+            seq2.pop()
+    res.reverse()
+    return res
+
+
+# 이진 검색 사용
+def intersection_two_arrays_bs(seq1, seq2):
+    if len(seq1) > len(seq2):
+        seq, key = seq1, seq2
+    else:
+        seq, key = seq2, seq1
+    intersec = []
+    for item in key:
+        if binary_search_iter(seq, item):
+            intersec.append(item)
+    return intersec
+
+
+def test_intersection_two_arrays():
+    seq1 = [1, 2, 3, 5, 7, 8]
+    seq2 = [3, 5, 6]
+    assert(set(intersection_two_arrays_sets(seq1, seq2)) == set([3, 5]))
+    assert(intersection_two_arrays_bs(seq1, seq2) == [3, 5])
+    assert(intersection_two_arrays_ms(seq1, seq2) == [3, 5])
+    print('테스트 통과!')
+
+
+if __name__ == "__main__":
+    test_intersection_two_arrays()

10장_검색/1_sequential_search.py

@@ -0,0 +1,18 @@
+def sequential_search(seq, n):
+    for item in seq:
+        if item == n:
+            return True
+    return False
+
+
+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)
+    print('테스트 통과!')
+
+
+if __name__ == "__main__":
+    test_sequential_search()

10장_검색/2_ordered_sequential_search.py

@@ -0,0 +1,21 @@
+def ordered_sequential_search(seq, n):
+    item = 0
+    for item in seq:
+        if item > n:
+            return False
+        if item == n:
+            return True
+    return False
+
+
+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)
+    print('테스트 통과!')
+
+
+if __name__ == "__main__":
+    test_ordered_sequential_search()

10장_검색/3_quick_select.py

@@ -0,0 +1,36 @@
+import random
+
+
+def quickSelect(seq, k):
+    # 이 부분은 퀵 정렬과 같다.
+    len_seq = len(seq)
+    if len_seq < 2:
+        return seq[0]
+    # 피벗을 무작위로 선택할 수 있다.
+    # pivot = random.choice(seq)
+    ipivot = len_seq // 2
+    pivot = seq[ipivot]
+
+    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
+    if k == m:
+        return pivot
+    elif k < m:
+        return quickSelect(smallerList, k)
+    else:
+        return quickSelect(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]
+
+    k = len(seq) // 2
+    print(sorted(seq))
+    print(quickSelect(seq, k))
+    # 중앙값(median) 출력을 위해서 넘파이를 사용함
+    import numpy
+    print(numpy.median(seq))

10장_검색/4_binary_search.py

@@ -0,0 +1,37 @@
+# 재귀함수
+def binary_search_rec(seq, target, low, high):
+    if low > high:
+        return None
+    mid = (low + high) // 2
+    if target == seq[mid]:
+        return mid
+    elif target < seq[mid]:
+        return binary_search_rec(seq, target, low, mid-1)
+    else:
+        return binary_search_rec(seq, target, mid+1, high)
+
+
+# 반복문
+def binary_search_iter(seq, target):
+    high, low = len(seq), 0
+    while low < high:
+        mid = (high + low) // 2
+        if target == seq[mid]:
+            return mid
+        elif target < seq[mid]:
+            high = mid
+        else:
+            low = mid + 1
+    return None
+
+
+def test_binary_search():
+    seq = [1, 2, 5, 6, 7, 10, 12, 12, 14, 15]
+    target = 6
+    assert(binary_search_iter(seq, target) == 3)
+    assert(binary_search_rec(seq, target, 0, len(seq)) == 3)
+    print('테스트 통과!')
+
+
+if __name__ == "__main__":
+    test_binary_search()

10장_검색/5_search_entry_matrix.py

@@ -0,0 +1,26 @@
+def find_elem_matrix_bool(m1, value):
+    found = False
+    row = 0
+    col = len(m1[0]) - 1
+    while row < len(m1) and col >= 0:
+        if m1[row][col] == value:
+            found = True
+            break
+        elif m1[row][col] > value:
+            col -= 1
+        else:
+            row += 1
+    return found
+
+
+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)
+    m2 = [[0]]
+    assert(find_elem_matrix_bool(m2, 0) == True)
+    print('테스트 통과!')
+
+
+if __name__ == "__main__":
+    test_find_elem_matrix_bool()

10장_검색/6_searching_in_a_matrix.py

@@ -0,0 +1,32 @@
+def searching_in_a_matrix(m1, value):
+    rows = len(m1)
+    cols = len(m1[0])
+    lo = 0
+    hi = rows*cols
+    while lo < hi:
+        mid = (lo + hi) // 2
+        row = mid // cols
+        col = mid % cols
+        v = m1[row][col]
+        if v == value:
+            return True
+        elif v > value:
+            hi = mid
+        else:
+            lo = mid+1
+    return False
+
+
+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)
+    print('테스트 통과!')
+
+
+if __name__ == "__main__":
+    test_searching_in_a_matrix()

10장_검색/7_find_max_unimodal_array.py

@@ -0,0 +1,24 @@
+def find_max_unimodal_array(A):
+    if len(A) <= 2:
+        return None
+    left = 0
+    right = len(A)-1
+    while right > left + 1:
+        mid = (left + right) // 2
+        if A[mid] > A[mid-1] and A[mid] > A[mid+1]:
+            return A[mid]
+        elif A[mid] > A[mid-1] and A[mid] < A[mid+1]:
+            left = mid
+        else:
+            right = mid
+    return None
+
+
+def test_find_max_unimodal_array():
+    seq = [1, 2, 5, 6, 7, 10, 12, 9, 8, 7, 6]
+    assert(find_max_unimodal_array(seq) == max(seq))
+    print('테스트 통과!')
+
+
+if __name__ == "__main__":
+    test_find_max_unimodal_array()

10장_검색/8_find_sqrt_bin_search.py

@@ -0,0 +1,23 @@
+def find_sqrt_bin_search(n, error=0.001):
+    lower = n < 1 and n or 1
+    upper = n < 1 and 1 or n
+    mid = lower + (upper - lower) / 2.0
+    square = mid * mid
+    while abs(square - n) > error:
+        if square < n:
+            lower = mid
+        else:
+            upper = mid
+        mid = lower + (upper - lower) / 2.0
+        square = mid * mid
+    return mid
+
+
+if __name__ == "__main__":
+    a = 2
+    b = 9
+    import math
+    print(math.sqrt(a))
+    print(find_sqrt_bin_search(a))
+    print(math.sqrt(b))
+    print(find_sqrt_bin_search(b))