2021년 2학기 01분반 기출 모범 답안 풀이

class MyQueue:

  def __init__(self):
    self.storage_original = []
    self.storage_sorted = []

STEP A & E

  def push(self, givenValue):
    if type(givenValue) == type(1):
      value = givenValue
    elif type(givenValue) == type(1.0):
      value = int(givenValue)
    elif type(givenValue) == type('1'):
      str_length = len(givenValue)
      temp = 1
      conv_number = 0
      int_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
      for index in range(str_length):
        if givenValue[str_length - (1+index)] in int_list:
          conv_number += temp * int (givenValue[str_length - (1+ index)])
          temp *= 10
      value = conv_number
    else:
      value = 0

    if value in self.storage_sorted:
      return 'error@duplicated'
    else:
      self.storage_original.append(givenValue)
      self.storage_sorted.append(value)
      return self.storage_sorted[len(self.storage_sorted)-1]

입력 parameter가 string 타입인 경우
숫자로만 이루어진 문자열을 만들기 위해 0 ~ 9의 숫자로 구성된 리스트를 만들어, 문자열의 각 문자가 해당 리스트의 요소인지 구별하여, 해당 문자가 숫자이면, 각 순서에 따라 1의 자리, 10의 자리, 100의 자리..로 문자열을 표현했다.
value 변수를 return하기 전, 기존에 존재했던 변수인지를 검열 후 return값을 반환한다.

STEP B

 def get_original(self):
   return self.storage_original

 def get_filtered(self):
   return self.storage_sorted

 def get_filtered_sorted(self):
   return sorted(self.storage_sorted)

 def get_filtered_reversed(self):
   return list(reversed(self.storage_sorted))

STEP C

  def pop(self, givenValue = -1):
    if givenValue == -1:
      idx_original = self.storage_original[len(self.storage_original) - 1]
      idx_sorted = self.storage_sorted[len(self.storage_sorted) - 1]
      self.storage_original.pop()
      self.storage_sorted.pop()
    else:
      index = self.storage_sorted.index(givenValue)
      idx_original = self.storage_original[index]
      idx_sorted = self.storage_sorted[index]
      self.storage_original.remove(idx_original)
      self.storage_sorted.remove(idx_sorted)
    result = {}
    result[idx_original] = idx_sorted
    return result

index 메서드를 통해 filteredNum => OriginalNum을 발견

string - index 메서드
index()
지정 문자열이 처음 나타나는 위치 반환.
※ 지정 문자열이 없는 경우, Exception (= 에러 처리 코드) 반환.
※ find() 메서드 경우, 지정 문자열이 없는 경우, -1 반환.
※ 검색 범위 지정된 경우, start부터 end(포함 X) 내애서 검색.

• find() 메서드 : 지정 문자열 처음 위치. (없을 시, -1반환)

• index() 메서드 : 지정 문자열 처음 위치. (없을 시, Exception 반환.)

• rfind() 메서드 : 지정 문자열 끝 위치. (없을 시, -1반환)

• rindex() 메서드 : 지정 문자열 끝 위치. (없을 시, Exception 반환.)

  STEP D

  def get_dictionary(self):
    result = {}
    for index in range(len(self.storage_sorted)):
      result[self.storage_sorted[index]] = self.storage_original[index]
    return result

STEP F

  def __add__(self,givenValue):
    result = MyQueue()
    for index in range(len(self.storage_sorted)):
      result.storage_sorted.append(self.storage_sorted[index])
      result.storage_original.append(self.storage_original[index])
    for index in range (len(givenValue.storage_sorted)):
      if (givenValue.storage_sorted[index] in self.storage_sorted) == False:
        result.storage_sorted.append(givenValue.storage_sorted[index])
        result.storage_original.append(givenValue.storage_original[index])
    return result

__add__ 함수는 입력 파라미터를 변화시키는 것이 아니라 둘의 합을 리턴값으로 반환한다는 점을 주의하자!

Result

# [ANSWER END]

#
# 시험 문제
#
# 답안은 위의 [ANSWER START]와 [ANSWER END] 사이에 작성함
# 아래의 STEP.A~F를 수행하여 RESULTS의 결과를 출력하는 MyQueue 클래스를 개발함
# 수행 결과는 아래 RESULTS와 동일해야 함 (결과값, 대소문자, 철자, 빈공간 등 모든 정보가 동일해야 함)
#

''' STEP.A
'''

myQ = MyQueue()

variable_A01 = myQ.push(1)
print('#A.1:({})==>>({})'.format(variable_A01, type(variable_A01)))

variable_A02 = myQ.push('2')
print('#A.2:({})==>>({})'.format(variable_A02, type(variable_A02)))

variable_A03 = myQ.push(3.2)
print('#A.3:({})==>>({})'.format(variable_A03, type(variable_A03)))

variable_A04 = myQ.push([4,5,6])
print('#A.4:({})==>>({})'.format(variable_A04, type(variable_A04)))

variable_A05 = myQ.push('1abc2def3xyx')
print('#A.5:({})==>>({})'.format(variable_A05, type(variable_A05)))

''' STEP.B
'''

variable_B01 = myQ.get_original()
print('#B.1:({})==>>({})'.format(variable_B01, type(variable_B01)))

variable_B02 = myQ.get_filtered()
print('#B.2:({})==>>({})'.format(variable_B02, type(variable_B02)))

variable_B03 = myQ.get_filtered_sorted()
print('#B.3:({})==>>({})'.format(variable_B03, type(variable_B03)))

variable_B04 = myQ.get_filtered()
print('#B.4:({})==>>({})'.format(variable_B04, type(variable_B04)))

variable_B05 = myQ.get_filtered_reversed()
print('#B.5:({})==>>({})'.format(variable_B05, type(variable_B05)))

variable_B06 = myQ.get_filtered()
print('#B.6:({})==>>({})'.format(variable_B06, type(variable_B06)))

''' STEP.C
'''

variable_C01 = myQ.pop()
print('#C.1:({})==>>({})'.format(variable_C01, type(variable_C01)))

variable_C02 = myQ.get_filtered()
print('#C.2:({})==>>({})'.format(variable_C02, type(variable_C02)))

variable_C03 = myQ.pop(2)
print('#C.3:({})==>>({})'.format(variable_C03, type(variable_C03)))

variable_C04 = myQ.get_filtered()
print('#C.4:({})==>>({})'.format(variable_C04, type(variable_C04)))

''' STEP.D
'''

variable_D01 = myQ.get_dictionary()
print('#D.1:({})==>>({})'.format(variable_D01, type(variable_D01)))

variable_D02 = myQ.get_filtered()
print('#D.2:({})==>>({})'.format(variable_D02, type(variable_D02)))

''' STEP.E
'''

variable_E01 = myQ.push(1)
print('#E.1:({})==>>({})'.format(variable_E01, type(variable_E01)))

variable_E02 = myQ.get_filtered()
print('#E.2:({})==>>({})'.format(variable_E02, type(variable_E02)))

variable_E03 = myQ.push('999')
print('#E.3:({})==>>({})'.format(variable_E03, type(variable_E03)))

variable_E04 = myQ.get_filtered()
print('#E.4:({})==>>({})'.format(variable_E04, type(variable_E04)))

''' STEP.F
'''

varQ1 = MyQueue()
varQ1.push('1')
varQ1.push(10)
varQ1.push(2)

varQ2 = MyQueue()
varQ2.push(22)
varQ2.push(999)
varQ2.push(44)

variable_F01 = myQ + varQ1 + varQ2
print('#F.1:({})'.format(type(variable_F01)))

variable_F02 = variable_F01.get_filtered()
print('#F.2:({})==>>({})'.format(variable_F02, type(variable_F02)))

variable_F03 = myQ.get_filtered()
print('#F.3:({})==>>({})'.format(variable_F03, type(variable_F03)))

variable_F04 = varQ1.get_filtered()
print('#F.4:({})==>>({})'.format(variable_F04, type(variable_F04)))

variable_F05 = varQ2.get_filtered()
print('#F.5:({})==>>({})'.format(variable_F05, type(variable_F05)))

''' RESULTS

#A.1:(1)==>>(<class 'int'>)
#A.2:(2)==>>(<class 'int'>)
#A.3:(3)==>>(<class 'int'>)
#A.4:(0)==>>(<class 'int'>)
#A.5:(123)==>>(<class 'int'>)
#B.1:([1, '2', 3.2, [4, 5, 6], '1abc2def3xyx'])==>>(<class 'list'>)
#B.2:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.3:([0, 1, 2, 3, 123])==>>(<class 'list'>)
#B.4:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.5:([123, 0, 3, 2, 1])==>>(<class 'list'>)
#B.6:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#C.1:({'1abc2def3xyx': 123})==>>(<class 'dict'>)
#C.2:([1, 2, 3, 0])==>>(<class 'list'>)
#C.3:({'2': 2})==>>(<class 'dict'>)
#C.4:([1, 3, 0])==>>(<class 'list'>)
#D.1:({1: 1, 3: 3.2, 0: [4, 5, 6]})==>>(<class 'dict'>)
#D.2:([1, 3, 0])==>>(<class 'list'>)
#E.1:(error@duplicated)==>>(<class 'str'>)
#E.2:([1, 3, 0])==>>(<class 'list'>)
#E.3:(999)==>>(<class 'int'>)
#E.4:([1, 3, 0, 999])==>>(<class 'list'>)
#F.1:(<class '__main__.MyQueue'>)
#F.2:([1, 3, 0, 999, 10, 2, 22, 44])==>>(<class 'list'>)
#F.3:([1, 3, 0, 999])==>>(<class 'list'>)
#F.4:([1, 10, 2])==>>(<class 'list'>)
#F.5:([22, 999, 44])==>>(<class 'list'>)
'''