finish ch7

Author: AstinCHOI

7장_추상_데이터_구조/13_reverse_string_with_stack.py

@@ -0,0 +1,18 @@
+from stack import Stack
+
+def reverse_string_with_stack(str1):
+  s = Stack()
+  revStr = ''
+
+  for c in str1:
+    s.push(c)
+
+  while not s.isEmpty():
+    revStr += s.pop()
+
+  return revStr
+
+if __name__ == '__main__':
+  str1 = '버피는 천사다.'
+  print(str1)
+  print(reverse_string_with_stack(str1))

7장_추상_데이터_구조/14_balance_parenthesis_str_stack.py

@@ -0,0 +1,30 @@
+from stack import Stack
+
+def balance_par_str_with_stack(str1):
+    s = Stack()
+    balanced = True
+    index = 0
+
+    while index < len(str1) and balanced:
+        symbol = str1[index]
+
+        if symbol == "(":
+            s.push(symbol)
+
+        else:
+            if s.isEmpty():
+                balanced = False
+            else:
+                s.pop()
+
+        index = index + 1
+
+    if balanced and s.isEmpty():
+        return True
+
+    else:
+        return False
+
+if __name__ == '__main__':
+    print(balance_par_str_with_stack('((()))'))
+    print(balance_par_str_with_stack('(()'))

7장_추상_데이터_구조/15_dec2bin_with_stack.py

@@ -0,0 +1,19 @@
+from stack import Stack
+
+def dec2bin_with_stack(decnum):
+    s = Stack()
+    str_aux = ''
+
+    while decnum > 0:
+        dig = decnum % 2
+        decnum = decnum // 2
+        s.push(dig)
+
+    while not s.isEmpty():
+        str_aux += str(s.pop())
+
+    return str_aux
+
+if __name__ == '__main__':
+    decnum = 9
+    print(dec2bin_with_stack(decnum))

7장_추상_데이터_구조/16_stack_with_min.py

@@ -0,0 +1,59 @@
+from stack import Stack
+
+
+class NodeWithMin(object):
+    def __init__(self, value=None, minimum=None):
+        self.value = value
+        self.minimum = minimum
+
+
+class StackMin(Stack):
+    def __init__(self):
+        self.items = []
+        self.minimum = None
+
+    def push(self, value):
+        if self.isEmpty() or self.minimum > value:
+           self.minimum = value
+        self.items.append(NodeWithMin(value, self.minimum))
+
+    def peek(self):
+        return self.items[-1].value
+
+    def peekMinimum(self):
+        return self.items[-1].minimum
+
+    def pop(self):
+        item = self.items.pop()
+        if item:
+            if item.value == self.minimum:
+                self.minimum = self.peekMinimum()
+            return item.value
+        else:
+            print("Stack is empty.")
+
+    def __repr__(self):
+        aux = []
+        for i in self.items:
+            aux.append(i.value)
+        return f"{aux}"
+
+
+if __name__ == '__main__':
+    stack = StackMin()
+    print(f"스택이 비었나요? {stack.isEmpty()}")
+    print("스택에 숫자 10~1과 1~4를 추가합니다.")
+    for i in range(10, 0, -1):
+        stack.push(i)
+    for i in range(1, 5):
+        stack.push(i)
+    print(stack)
+
+    print(f"스택 크기: {stack.size()}")
+    print(f"peek: {stack.peek()}")
+    print(f"peekMinimum: {stack.peekMinimum()}")
+    print(f"pop: {stack.pop()}")
+    print(f"peek: {stack.peek()}")
+    print(f"peekMinimum: {stack.peekMinimum()}")
+    print(f"스택이 비었나요? {stack.isEmpty()}")
+    print(stack)

7장_추상_데이터_구조/17_set_of_stacks.py

@@ -0,0 +1,44 @@
+from stack import Stack
+
+class SetOfStacks(Stack):
+    def __init__(self, capacity=4):
+        self.setofstacks = []
+        self.items = []
+        self.capacity = capacity
+
+    def push(self, value):
+        if self.size() >= self.capacity:
+            self.setofstacks.append(self.items)
+            self.items = []
+        self.items.append(value)
+
+    def pop(self):
+        value = self.items.pop()
+        if self.isEmpty() and self.setofstacks:
+            self.items = self.setofstacks.pop()
+        return value
+
+    def sizeStack(self):
+        return len(self.setofstacks) * self.capacity + self.size()
+
+    def __repr__(self):
+        aux = []
+        for s in self.setofstacks:
+             aux.extend(s)
+        aux.extend(self.items)
+        return f"{aux}"
+
+if __name__ == '__main__':
+    capacity = 5
+    stack = SetOfStacks(capacity)
+    print(f"스택이 비었나요? {stack.isEmpty()}")
+    print("스택에 숫자 0~9를 추가합니다.")
+    for i in range(10):
+        stack.push(i)
+    print(stack)
+    print(f"스택 크기: {stack.sizeStack()}")
+    print(f"peek: {stack.peek()}")
+    print(f"pop: {stack.pop()}")
+    print(f"peek: {stack.peek()}")
+    print(f"스택이 비었나요? {stack.isEmpty()}")
+    print(stack)

7장_추상_데이터_구조/18_palindrome_checker_with_deque.py

@@ -0,0 +1,35 @@
+import string
+import collections
+
+from deque import Deque
+
+
+STRIP = string.whitespace + string.punctuation + "\"'"
+
+
+def palindrome_checker_with_deque(str1):
+    d1 = Deque()
+    d2 = collections.deque()
+
+    for s in str1.lower():
+        if s not in STRIP:
+            d2.append(s)
+            d1.enqueue(s)
+
+    eq1 = True
+    while d1.size() > 1 and eq1:
+        if d1.dequeue_front() != d1.dequeue():
+            eq1 = False
+
+    eq2 = True
+    while len(d2) > 1 and eq2:
+        if d2.pop() != d2.popleft():
+            eq2 = False
+
+    return eq1, eq2
+
+if __name__ == '__main__':
+    str1 = 'Madam Im Adam'
+    str2 = 'Buffy is a Slayer'
+    print(palindrome_checker_with_deque(str1))
+    print(palindrome_checker_with_deque(str2)) 

7장_추상_데이터_구조/19_animal_shelter.py

@@ -0,0 +1,89 @@
+class Node(object):
+    def __init__(self, animalName=None, animalKind=None, pointer=None):
+        self.animalName = animalName
+        self.animalKind = animalKind
+        self.pointer = pointer
+        self.timestamp = 0
+
+
+class AnimalShelter(object):
+    def __init__(self):
+        self.headCat = None
+        self.headDog = None
+        self.tailCat = None
+        self.tailDog = None
+        self.animalNumber = 0
+    
+    def enqueue(self, animalName, animalKind):
+        self.animalNumber += 1
+        newAnimal = Node(animalName, animalKind)
+        newAnimal.timestamp = self.animalNumber
+
+        if animalKind == 'cat':
+            if not self.headCat:
+                self.headCat = newAnimal
+            if self.tailCat:
+                self.tailCat.pointer = newAnimal
+            self.tailCat = newAnimal
+
+        elif animalKind == 'dog':
+            if not self.headDog:
+                self.headDog = newAnimal
+            if self.tailDog:
+                self.tailDog.pointer = newAnimal
+            self.tailDog = newAnimal
+
+    def dequeueDog(self):
+        if self.headDog:
+            newAnimal = self.headDog
+            self.headDog = newAnimal.pointer
+            return str(newAnimal.animalName)
+        else:
+            print("개가 없습니다!")
+
+    def dequeueCat(self):
+        if self.headCat:
+            newAnimal = self.headCat
+            self.headCat = newAnimal.pointer
+            return str(newAnimal.animalName)
+        else:
+            print("고양이가 없습니다!")
+
+    def dequeueAny(self):
+        if self.headCat and not self.headDog:
+            return self.dequeueCat()
+        elif self.headDog and not self.headCat:
+            return self.dequeueDog()
+        elif self.headDog and self.headCat:
+            if self.headDog.timestamp < self.headCat.timestamp:
+                return self.dequeueDog()
+            else:
+                return self.dequeueCat()
+        else:
+            print("동물이 없습니다.")
+
+    def _print(self):
+        print("고양이:")
+        cats = self.headCat
+        while cats:
+            print(f"\t{cats.animalName}")
+            cats = cats.pointer
+        print("개:")
+        dogs = self.headDog
+        while dogs:
+            print(f"\t{dogs.animalName}")
+            dogs = dogs.pointer
+
+
+if __name__ == '__main__':
+    qs = AnimalShelter()
+    qs.enqueue('밥', 'cat')
+    qs.enqueue('미아', 'cat')
+    qs.enqueue('요다', 'dog')
+    qs.enqueue('울프', 'dog')
+    qs._print()
+
+    print("하나의 개와 고양이에 대해서 dequeue를 실행합니다.")
+    qs.dequeueDog()
+    qs.dequeueCat()
+    qs._print()

7장_추상_데이터_구조/1_stack.py

@@ -10,7 +10,7 @@ def push(self, value):
 
     def pop(self):
         value = self.items.pop()
-        if value:
+        if value is not None:
             return value
         else:
             print("Stack is empty.")

7장_추상_데이터_구조/20_find_N_largest_smallest_items_seq.py

@@ -0,0 +1,37 @@
+import heapq
+
+
+def find_N_largest_items_seq(seq, N):
+    return heapq.nlargest(N,seq)
+    
+def find_N_smallest_items_seq(seq, N):
+    return heapq.nsmallest(N, seq)
+
+def find_smallest_items_seq_heap(seq):
+    heapq.heapify(seq)
+    return heapq.heappop(seq)
+   
+def find_smallest_items_seq(seq):
+    return min(seq)
+
+def find_N_smallest_items_seq_sorted(seq, N):
+    return sorted(seq)[:N]
+    
+def find_N_largest_items_seq_sorted(seq, N):
+    return sorted(seq)[len(seq)-N:]
+
+def test_find_N_largest_smallest_items_seq():
+    seq = [1, 3, 2, 8, 6, 10, 9]
+    N = 3
+    assert(find_N_largest_items_seq(seq, N) == [10, 9, 8])
+    assert(find_N_largest_items_seq_sorted(seq, N) == [8, 9, 10])
+    assert(find_N_smallest_items_seq(seq, N) == [1,2,3])
+    assert(find_N_smallest_items_seq_sorted(seq, N) == [1,2,3])
+    assert(find_smallest_items_seq(seq) == 1)
+    assert(find_smallest_items_seq_heap(seq) == 1)
+        
+    print("테스트 통과!")
+
+
+if __name__ == '__main__':
+    test_find_N_largest_smallest_items_seq()

7장_추상_데이터_구조/21_merge_sorted_seqs.py

@@ -0,0 +1,20 @@
+import heapq
+
+
+def merge_sorted_seqs(seq1, seq2):
+    result = []
+    for c in heapq.merge(seq1, seq2):
+        result.append(c)
+    return result
+
+def test_merge_sorted_seqs():
+    seq1 = [1, 2, 3, 8, 9, 10]
+    seq2 = [2, 3, 4, 5, 6, 7, 9]
+    seq3 = seq1 + seq2
+    assert(merge_sorted_seqs(seq1, seq2) == sorted(seq3))
+        
+    print("테스트 통과!")
+
+
+if __name__ == '__main__':
+    test_merge_sorted_seqs()