[4주차] 알고리즘 문제풀이

[선형검색 연습문제]

• 문제 1)
  

모듈: lineMod

def searchNumberByLineAlgorithm(ns, sn):  # numbers, searchnum

    searchResultIdx = -1

    print(f'Numbers: {ns}')
    print(f'Search Numbers: {sn}')

    n = 0
    while True:

        if n == len(ns):     # 끝까지 검색했는데도 검색이 안된 경우
            print('Search FAIL!')
            break

        if ns[n] == sn:
            searchResultIdx = n
            print('Search Success!')
            print(f'Search result Idx: {searchResultIdx}')
            break

        n += 1

    return searchResultIdx

실행파일) 

import lineMod
import random

if __name__ == '__main__':

    rNums = random.sample(range(1,21),10)
    searchNum = int(input('input search number: '))

    resultIdx =  lineMod.searchNumberByLineAlgorithm(rNums, searchNum)
    if resultIdx == -1:
        print('No result found')
        print(f'search result index: {resultIdx}')
    else:
        print('>>> Search Results <<<')
        print(f'search result index: {resultIdx}')
        print(f'search result number: {rNums[resultIdx]}')

[이진검색 연습문제]

• 문제 1)

모듈: binaryMod

def searchNumberByBinary(ns, sn):

    searchResultIdx = -1

    startIdx = 0
    endIdx = len(ns)-1
    midIdx = (startIdx + endIdx) // 2
    midVal = ns[midIdx]

    print(f'startIdx: {startIdx}, endIdx: {endIdx}')
    print(f'midIdx: {midIdx}, midVal: {midVal}')

    while sn >= ns[0] and sn <= ns[len(ns)-1]:

        if sn == ns[len(ns)-1]:     # 리스트를 다 돌았는데 숫자가 없을 때
            searchResultIdx = len(ns)-1
            break

        if startIdx + 1 == endIdx:   # ex. 8,10 두개만 남을 경우, 9를 입력했을때 값을 출력하기 위한 수식
            if ns[startIdx] != sn and ns[endIdx] != sn:
                break

        if sn > midVal:
            startIdx = midIdx
            midIdx = (startIdx+endIdx) // 2
            midVal = ns[midIdx]
            print(f'+startIdx: {startIdx}, endIdx: {endIdx}')
            print(f'+midIdx: {midIdx}, midVal: {midVal}')

        elif sn < midVal:
            endIdx = midIdx
            midIdx = (startIdx + endIdx) // 2
            midVal = ns[midIdx]
            print(f'_startIdx: {startIdx}, endIdx: {endIdx}')
            print(f'_midIdx: {midIdx}, midVal: {midVal}')

        elif sn == midVal:
            searchResultIdx = midIdx
            break

    return searchResultIdx

실행파일) 

import binaryMod

if __name__ == '__main__':
    nums = [1, 2, 4, 6, 7, 8, 10, 11, 13, 15, 16, 17, 20, 21, 23, 24, 27, 28]
    searchNum = int(input('input search number: '))

    resultIdx = binaryMod.searchNumberByBinary(nums,searchNum)
    print(f'nums: {nums}')

    if resultIdx == -1:
        print('No results found.')
        print(f'search result index: {resultIdx}')
    else:
        print('>>> search results <<<')
        print(f'search result index: {resultIdx}')
        print(f'search result number: {nums[resultIdx]}')

[순위 연습문제]

• 문제 1) 숫자로 이루어진 리스트에서 아이템의 순위를 출력하고, 순위에 따라 아이템을 정렬하는 모듈을 만들어보자. (리스트는 50부터 100까지의 난수 20개)

모듈: rankMod

def rankAlgorithm(ns):

    ranks = [0 for i in range(len(ns))]

    for idx, n1 in enumerate(ns):
        for n2 in ns:
            if n1 < n2:
                ranks[idx] += 1

    print(f'nums: {ns}')
    print(f'ranks: {ranks}')

    for i, n in enumerate(ns):  # 순위 따라 원본 재정렬 하는 코드
        print(f'num: {n}:\t rank: {ranks[i]+1}')

    sortedNums = [0 for n in range(len(ns))]

    for idx, rank in enumerate(ranks):
        sortedNums[rank] = ns[idx]

    return sortedNums

실행파일)

import rankMod
import random

if __name__ == '__main__':

    nums = random.sample(range(50,101),20)
    sNums = rankMod.rankAlgorithm(nums)
    print(f'sNums: {sNums}')

• 문제 2) 알파벳 문자들과 정수들에 대한 순위를 정하는 프로그램을 순위 알고리즘을 이용해서 만들어보자. 단, 알파벳은 아스키코드 값을 이용한다.

datas = [32, 'a', 'z', 45, 'G', 39, 50, 'T', 't', 22, 31, 55, 's', 63, 59, 'E']
print(f'datas: {datas}')

ascIIDatas = []
for data in datas:
    if str(data).isalpha():
        ascIIDatas.append(ord(data))
        continue

    ascIIDatas.append(data)

print(f'ascIIDatas: {ascIIDatas}')

ranks = [0 for i in range(len(ascIIDatas))]
print(f'ranks before: {ranks}')

for idx, data1 in enumerate(ascIIDatas):
    for data2 in ascIIDatas:
        if data1 < data2:
            ranks[idx] += 1

print(f'ranks after: {ranks}')

for i, d in enumerate(datas):
    print(f'data: {d: >2} \t rank: {ranks[i] + 1}위')

# {d: >2} 는 두 자리를 표현하는 데 오른쪽 정렬로 하겠다는 뜻.

[버블정렬 연습문제]

• 문제 1) 숫자로 이루어진 리스트를 버블정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 만들어보자.

모듈: bubbleMod

import copy

def sortByBubble(ns, asc=True):

    c_ns = copy.copy(ns)
    length = len(c_ns) -1

    for i in range(length):
        for j in range(length - i):

            if asc:
                if c_ns[j] > c_ns[j+1]:
                    c_ns[j], c_ns[j+1] = c_ns[j+1], c_ns[j]
            else:
                if c_ns[j] < c_ns[j+1]:
                    c_ns[j], c_ns[j+1] = c_ns[j+1], c_ns[j]

            print(f'ns: {c_ns}')
        print()

    return c_ns

실행파일) 

import random
import bubbleMod

if __name__ == '__main__':

    nums = random.sample(range(1,21), 10)
    print(f'not sorted nums: {nums}')

    result = bubbleMod.sortByBubble(nums)
    print(f'sorted nums by ASC: {result}')

    result = bubbleMod.sortByBubble(nums, asc=False)
    print(f'sorted nums by DSC: {result}')

[병합정렬 연습문제]

• 문제 1) 숫자로 이루어진 리스트를 병합정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 만들어보자.

모듈: mergeAlgorithm

def mSort(ns, asc=True):
    if len(ns) < 2:
        return ns

    midIdx = len(ns) // 2
    leftNums = mSort(ns[0:midIdx], asc=asc)
    rightNums = mSort(ns[midIdx: len(ns)], asc=asc)

    mergedNums = []
    leftIdx = 0; rightIdx = 0
    while leftIdx < len(leftNums) and rightIdx < len(rightNums):

        if asc:
            if leftNums[leftIdx] < rightNums[rightIdx]:
                mergedNums.append(leftNums[leftIdx])
                leftIdx += 1    # 한 번 추가한건 제외하기 위해
            else:
                mergedNums.append(rightNums[rightIdx])
                rightIdx += 1

        else:
            if leftNums[leftIdx] > rightNums[rightIdx]:
                mergedNums.append(leftNums[leftIdx])
                leftIdx += 1
            else:
                mergedNums.append(rightNums[rightIdx])
                rightIdx += 1

    mergedNums += leftNums[leftIdx:]
    mergedNums += rightNums[rightIdx:]

    print(f'mergeNums: {mergedNums}')
    return mergedNums

실행파일) 

import random
import mergeAlgorithm

rNums = random.sample(range(1,101),20)
print(f'rNums: {rNums}')
print(f'mergeAlgorithm.mSort(rNums): {mergeAlgorithm.mSort(rNums)}')
print(f'mergeAlgorithm.mSort(rNums): {mergeAlgorithm.mSort(rNums, asc=False)}')

[최댓값 연습문제]

• 문제 1) 최댓값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최댓값과 최댓값의 개수를 찾는 모듈을 만들어보자.
  • (리스트는 1부터 50까지의 난수 30개, 중복 허용)

모듈: maxMod

class MaxAlgorithm:

    def __init__(self, ns):
        self.nums = ns
        self.maxNum = 0
        self.maxNumCnt = 0

    def setMaxNum(self):
        self.maxNum = 0

        for n in self.nums:
            if self.maxNum < n:
                self.maxNum = n

    def getMaxNum(self):
        self.setMaxNum()
        return self.maxNum

    def setMaxNumCnt(self):
        self.setMaxNum()

        for n in self.nums:
            if self.maxNum == n:
                self.maxNumCnt += 1

    def getMaxNumCnt(self):
        self.setMaxNumCnt()
        return self.maxNumCnt

실행파일) 

import random
import maxMod

if __name__ == '__main__':

    nums = []
    for i in range(30):
        nums.append(random.randint(1,50))

    print(f'nums: {nums}')
    ma = maxMod.MaxAlgorithm(nums)
    print(f'max num: {ma.getMaxNum()}')
    print(f'max num count: {ma.getMaxNumCnt()}')

• 문제 2) 학급 전체 학생의 시험 점수에 대한 평균과 최댓값을 구하고 평균과 최댓값의 편차를 출력해보자.

모듈: mod

def getAvg(ns):

    total = 0
    for n in ns:
        total += n

    return total / len(ns)

def getMax(ns):

    maxN = ns[0]
    for n in ns:
        if maxN < n:
            maxN = n

    return maxN

def getDeviation(n1, n2):

    return round(abs(n1-n2),2)

실행파일) 

import mod

scores = [100, 64, 94, 66, 75, 58, 99, 76, 96, 74,
          54, 73, 88, 70, 68, 50, 95, 89, 69, 98]

scores_avg = mod.getAvg(scores)
scores_max = mod.getMax(scores)
deviation = mod.getDeviation(scores_avg, scores_max)

print(f'scores_avg: {scores_avg}점')
print(f'scores_max: {scores_max}점')
print(f'deviation: {deviation}점')

[최솟값 연습문제]

• 문제 1) 최솟값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최솟값과 최솟값의 개수를 찾는 모듈을 만들어보자.
  -> (리스트는 1부터 50까지의 난수 30개를 이용하되, 중복 허용)

모듈: minMod

class MinAlgorithm:

    def __init__(self, ns):
        self.nums = ns
        self.minNum = 0
        self.minNumCnt = 0

    def setMinNum(self):
        self.minNum = 51

        for n in self.nums:
            if self.minNum > n:
                self.minNum = n

    def getMinNum(self):
        self.setMinNum()
        return self.minNum

    def setMinNumCnt(self):
        self.setMinNum()
        for n in self.nums:
            if self.minNum == n:
                self.minNumCnt += 1

    def getMinNumCnt(self):
        self.setMinNumCnt()
        return self.minNumCnt

실행파일) 

import random
import minMod

if __name__ == '__main__':

    nums = []
    for i in range(30):
        nums.append(random.randint(1,50))

    print(f'nums: {nums}')
    ma = minMod.MinAlgorithm(nums)
    print(f'최솟값: {ma.getMinNum()}')
    print(f'최솟값의 개수: {ma.getMinNumCnt()}')

• 문제 2) 학급 전체 학생의 시험 점수에 대한 평균과 최솟값을 구하고 평균과 최솟값의 편차를 출력하는 프로그램을 만들자.

기본 모듈: mod 

def getAvg(ns):

    total = 0
    for n in ns:
        total += n

    return total / len(ns)

def getMin(ns):

    minN = ns[0]
    for n in ns:
        if minN > n:
            minN = n

    return minN

def getDeviation(n1, n2):
    return round(abs(n1 - n2), 2)

# 한번에 최솟값, 최댓값 구하는 함수
def getMaxOrMin(ns, maxFlag = True):

    resultN = ns[0]
    for n in ns:
        if maxFlag:
            if resultN < n:
                resultN = n
        else:
            if resultN > n:
                resultN = n

    return resultN

심화 모듈: mod2

# mod를 심화해서 클래스 구현

class ScoreManagement:

    def __init__(self, ss):
        self.scores = ss
        self.score_tot = 0
        self.score_avg = 0
        self.score_min = 0
        self.score_max = 0

    def getMinScore(self):
        if self.scores == None or len(self.scores) == 0:  # 모종의 이유로 초기화가 되지 않았다면
            return None

        self.score_min = self.scores[0]
        for score in self.scores:
            if self.score_min > score:
                self.score_min = score

        return self.score_min

    def getMaxScore(self):
        if self.scores == None or len(self.scores) == 0:
            return None

        self.score_max = self.scores[0]
        for score in self.scores:
            if self.score_max < score:
                self.score_max = score

        return self.score_max

    def getTotScore(self):
        if self.scores == None or len(self.scores) == 0:
            return None

        self.score_tot = 0   # 여기서 초기화 하지 않으면 외부에서 getTotScore을 호출할때마다
                             # 누적된 값이 계속 더 해지기 때문에 반드시 초기화 필요.
        for score in self.scores:
            self.score_tot += score

        return self.score_tot

    def getAvgScore(self):
        if self.scores == None or len(self.scores) == 0:
            return None

        self.score_avg = round(self.getTotScore() / len(self.scores), 2)

        return self.score_avg

    def getMaxDeviation(self):   # 평균과 최댓값과의 편차
        result = abs(self.getAvgScore() - self.getMaxScore())
        return round(result, 2)

    def getMinDeviation(self):   # 평균과 최솟값과의 편차
        result = abs(self.getAvgScore() - self.getMinScore())
        return round(result, 2)

실행파일) 

# 기본 mod 모듈
import mod
scores = [100, 64, 94, 66, 75, 58, 99, 76, 96, 74,
          54, 73, 88, 70, 68, 50, 95, 89, 69, 98]

scores_avg = mod.getAvg(scores)
scores_min  = mod.getMaxOrMin(scores, maxFlag=False)
deviation =  mod.getDeviation(scores_avg, scores_min)

print(f'scores_avg: {scores_avg}')
print(f'scores_min: {scores_min}')
print(f'deviation: {deviation}')

# 심화 mod2 모듈

import mod2

scores = [100, 64, 94, 66, 75, 58, 99, 76, 96, 74,
          54, 73, 88, 70, 68, 50, 95, 89, 69, 98]

sm = mod2.ScoreManagement(scores)
print(f'score_avg: {sm.getAvgScore()}')
print(f'score_min: {sm.getMinScore()}')
print(f'score_max: {sm.getMaxScore()}')
print(f'score_min_deviation: {sm.getMinDeviation()}')
print(f'score_max_deviation: {sm.getMaxDeviation()}')

[최빈값 연습문제]

• 문제 1)
  
  -> 팁: 최댓값을 구하고 최빈값을 구한다.

최댓값 모듈: maxMod

class MaxAlgorithm():

    def __init__(self, ns):
        self.nums = ns
        self.maxNum = 0
        self.maxNumIdx = 0

    def setMaxIdxAndNum(self):
        self.maxNum = 0
        self.maxNumIdx = 0

        for i, n in enumerate(self.nums):
            if self.maxNum < n:
                self.maxNum = n
                self.maxNumIdx = i

    def getMaxNum(self):
        return self.maxNum

    def getMaxIdx(self):
        return self.maxNumIdx

최빈값 모듈: modeMod

import maxMod

class ModeAlgorithm:

    def __init__(self, ns, mn):  # ages, maxNum
        self.nums = ns
        self.maxNum = mn
        self.indexes = []

    def setIndexList(self):
        self.indexes = [0 for i in range(self.maxNum + 1)]

        for n in self.nums:
            self.indexes[n] = self.indexes[n] + 1
            # 해당하는 나이가 나올때마다 그 나이의 인덱스에 가서 더하기 1


    def getIndexList(self):
        if sum(self.indexes) == 0:
            return None
        else:
            return self.indexes

    def printAges(self):

        n = 1
        while True:

            maxAlo = maxMod.MaxAlgorithm(self.indexes)   # 최댓값의 명수에 대한 +를 출력하는 과정
            maxAlo.setMaxIdxAndNum()
            maxNum = maxAlo.getMaxNum()
            maxNumIdx = maxAlo.getMaxIdx()

            if maxNum == 0:    # 아직 초기화가 안됐다면
                break

            print(f'[{n:0>3}] {maxNumIdx}세 빈도수: {maxNum}\t', end='')  # {n: 0>3} 은 총 세 자리를 맞추되 오른쪽 정렬, 비어있는 자리는 0으로 채운다.
            print('+' * maxNum)
            self.indexes[maxNumIdx] = 0    # 최댓값의 개수에 대한 +만 출력되기 때문에 이를 0으로 초기화해야 다음것도 순차적으로 출력됨

            n += 1

실행파일) 

import modeMod
import maxMod

ages = [25, 27, 27, 24, 31, 34, 33, 31, 29, 25,
        45, 37, 38, 46, 47, 22, 24, 29, 33, 35,
        27, 34, 37, 40, 42, 29, 27, 25, 26, 27,
        31, 31, 32, 38, 25, 27, 28, 40, 41, 34]

print(f'employee cnt: {len(ages)}명')

maxAlo = maxMod.MaxAlgorithm(ages)
maxAlo.setMaxIdxAndNum()
maxAge = maxAlo.getMaxNum()
print(f'maxAge: {maxAge}세')

modAlo = modeMod.ModeAlgorithm(ages, maxAge)
modAlo.setIndexList()
print(f'IndexList: {modAlo.getIndexList()}')

modAlo.printAges()

• 문제 2)
  

모듈: mod

class LottoMode:

    def __init__(self, ln):
        self.lottoNums = ln
        self.modeList = [0 for n in range(1,47)]   # lotto 번호 중 빈도수를 나타내는 리스트
                                                   # (46개를 만들고 index 0 값은 사용 안함)

    def getLottoNumMode(self):

        for roundNums in self.lottoNums:   # 한번 반복될때마다 한 회차
            for num in roundNums:          # 한 회차마다의 번호를 알기 위한 반복문 필요
                self.modeList[num] = self.modeList[num] + 1

        return self.modeList

    def printModeList(self):
        if sum(self.modeList) == 0:   # getLottoNumMode가 아직 호출되어 있지 않은 상태.
            return None

        for i, m in enumerate(self.modeList):
            if i != 0:    # index 0 값을 빼야 번호 총 45개
                print(f'번호: {i:>2}, 빈도: {m}, {"*" * m}')

실행파일) 

import mod

lottoNums = [[13, 23, 15, 5, 6, 39], [36, 13, 5, 3, 30, 16], [43, 1, 15, 9, 3, 38],
             [32, 42, 24, 45, 8, 31], [18, 39, 41, 11, 4, 9], [12, 39, 11, 38, 32, 5],
             [29, 25, 13, 6, 14, 8], [21, 33, 19, 20, 42, 7], [6, 28, 3, 45, 41, 24],
             [42, 15, 8, 5, 35, 4], [14, 4, 35, 24, 29, 3], [15, 20, 6, 37, 34, 39],
             [27, 5, 32, 15, 25, 19], [45, 25, 2, 8, 30, 43], [4, 19, 33, 10, 6, 24],
             [25, 26, 45, 23, 24, 16], [33, 28, 45, 21, 38, 24], [4, 30, 29, 28, 32, 38],
             [11, 28, 12, 2, 42, 3], [40, 29, 16, 8, 9, 28], [6, 9, 37, 30, 3, 35],
             [29, 18, 41, 28, 38, 15], [9, 31, 13, 44, 1, 36], [36, 1, 37, 32, 15, 12],
             [41, 32, 16, 6, 26, 33], [12, 43, 10, 29, 39, 9], [41, 9, 23, 35, 18, 17],
             [35, 38, 3, 28, 36, 31], [21, 44, 4, 29, 18, 7], [20, 23, 6, 2, 34, 44]]


lm = mod.LottoMode(lottoNums)
mList = lm.getLottoNumMode()
# print(f'mList: {mList}')

lm.printModeList()

[근삿값 연습문제]

• 문제 1)

모듈: nearMod

class NearAlgorithm:

    def __init__(self, d):
        self.temps = {0:24, 5:22, 10:20, 15:16, 20:13, 25: 10, 30:6}
        self.depth = d
        self.nearNum = 0
        self.minNum = 24   # 일단 제일 큰 걸로 설정

    def getNearNumbers(self):

        for n in self.temps.keys():
            absNum = abs(n - self.depth)  # 0, 5, 10, 15, 20, 25, 30과 내가 입력한 수심의 차이
            if absNum < self.minNum:
                self.minNum = absNum
                self.nearNum = n

        return self.temps[self.nearNum]  # 우리가 반환해야 할 것은 근사치의 value값

실행파일) 

import nearMod

depth = int(float(input('input depth: ')))
print(f'depth: {depth}m')

na = nearMod.NearAlgorithm(depth)
temp = na.getNearNumbers()
print(f'water temperature: {temp}도')

• 문제 2)
  
  -> Bmi : 몸무게 / 키 ** 2

모듈: nearMode

class BmiAlgorithm:

    def __init__(self, w, h):

        self.BMISection = {18.5: ['저체중', '정상'],   # 근삿값이 저체중일수도 정상일수도 있으므로
                           23: ['정상', '과체중'],
                           25: ['과체중','비만']}
        self.userWeight = w
        self.userHeight = h
        self.userBMI = 0
        self.userCondition = ''
        self.nearNum = 0
        self.minNum = 25    # 최댓값이 25기 때문

    def calculatorBMI(self):
        self.userBMI = round(self.userWeight / self.userHeight ** 2, 2)
        print(f'self.userBMI: {self.userBMI}')

    def printUserCondition(self):

        for n in self.BMISection.keys():
            absNum = abs(n - self.userBMI)
            if absNum < self.minNum:
                self.minNum = absNum
                self.nearNum = n

        print(f'self.nearNum: {self.nearNum}')

        if self.userBMI <= self.nearNum:     # 사용자 입력 bmi 값이 근사치보다 작으면 저체중, 정상 중에 저체중
            self.userCondition = self.BMISection[self.nearNum][0]
        else:
            self.userCondition = self.BMISection[self.nearNum][1]

        print(f'self.userCondition: {self.userCondition}')

실행파일) 

import nearMode

uWeight = float(input('input weight(kg): '))
uHeight = float(input('input height(m): '))

na = nearMode.BmiAlgorithm(uWeight,uHeight)
na.calculatorBMI()
na.printUserCondition()

[재귀 연습문제]

• 문제 1)
  

sales = [12000, 13000, 12500, 11000, 10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]

def salesUpAndDown(ss):   # sales

    if len(ss) == 1:
        return ss

    print(f'sales: {ss}')
    currentSales = ss.pop(0)  # 현재 12000, [13000, 12500, 11000, 10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]
    nextSales = ss[0]

    increase = nextSales - currentSales
    if increase > 0:
        increase = '+' + str(increase)
    print(f'매출 증감액: {increase}')

    return salesUpAndDown(ss)


if __name__ == '__main__':
    salesUpAndDown(sales)

• 문제 2) 사용자가 정수 두개를 입력하면 작은 정수와 큰 정수 사이의 모든 정수의 합을 구하는 프로그램을 재귀 알고리즘을 이용해서 만들어보자.

모듈: mod

class NumsSum:

    def __init__(self, n1, n2):
        self.bigNum = 0
        self.smallNum = 0
        self.setN1N2(n1, n2)

    def setN1N2(self, n1, n2):   # n1, n2 중 큰 숫자, 작은 숫자 구분
        self.bigNum = n1
        self.smallNum = n2

        if n1 < n2:
            self.bigNum = n2
            self.smallNum = n1

    def addNum(self, n):    # n까지의 합

        if n <= 1:
            return n

        return n + self.addNum(n-1)

    def sumBetweenNums(self):    # (큰 숫자 - 1까지의 총합) - (작은 숫자 까지의 총합)
        return self.addNum(self.bigNum-1) - self.addNum(self.smallNum)

실행파일) 

import mod

num1 = int(input('input number1: '))
num2 = int(input('input number2: '))

ns = mod.NumsSum(num1, num2)
result = ns.sumBetweenNums()
print(f'result: {result}')

[평균 연습문제]

• 문제 1)
  

-> 팁: 최댓값 알고리즘, 최솟값 알고리즘, 근삿값 알고리즘, 평균 알고리즘 모두 이용

최댓값 모듈: maxAlgorithm

class MaxAlgorithm:

    def __init__(self, ss):
        self.scores = ss
        self.maxScore = 0
        self.maxIdx = 0

    def removeMaxScore(self):
        self.maxScore = self.scores[0]

        for i, s in enumerate(self.scores):
            if self.maxScore < s:
                self.maxScore = s
                self.maxIdx = i

        print(f'self.maxScore: {self.maxScore}')
        print(f'self.maxIdx: {self.maxIdx}')

        self.scores.pop(self.maxIdx)
        print(f'self.scores: {self.scores}')

최솟값 모듈: minAlgorithm

class MinAlgorithm:

    def __init__(self, ss):
        self.scores = ss
        self.minScore = 0
        self.minIdx = 0

    def removeMinScore(self):
        self.minScore = self.scores[0]

        for i, s in enumerate(self.scores):
            if self.minScore > s:
                self.minScore = s
                self.minIdx = i

        print(f'self.minScore: {self.minScore}')
        print(f'self.minIdx: {self.minIdx}')

        self.scores.pop(self.minIdx)
        print(f'self.scores: {self.scores}')

근삿값 모듈: nearAlgorithm

class Top5Players:

    def __init__(self, cts, ns):   # 원래 선수들의 점수, 새로운 점수
        self.currentScores = cts
        self.newScore = ns

    def setAlignScore(self):    # 새로운 점수가 들어왔으니 top5 재정렬
        nearIdx = 0
        minNum = 10.0

        for i, s in enumerate(self.currentScores):
            absNum = abs(self.newScore - s)
            if absNum < minNum:
                minNum = absNum
                nearIdx = i

        # 새로 추가된 값이 원래 top5 리스트에서 찾은 근삿값보다 큰 경우
        if self.newScore >= self.currentScores[nearIdx]:
            for i in range(len(self.currentScores)-1, nearIdx, -1):
                self.currentScores[i] = self.currentScores[i-1]
            self.currentScores[nearIdx] = self.newScore

        # 새로 추가된 값이 원래 top5 리스트에서  찾은 근삿값보다 작은 경우
        else:
            for i in range(len(self.currentScores)-1, nearIdx+1, -1):
                self.currentScores[i] = self.currentScores[i-1]
            self.currentScores[nearIdx+1] = self.newScore

    def getFinalTop5Scores(self):
        return self.currentScores

실행파일) 

import maxAlgorithm
import minAlgorithm
import nearAlgorithm

top5Scores = [9.12, 8.95, 8.12, 6.90, 6.18]
scores = [6.7, 5.9, 8.1, 7.9, 6.7, 7.3, 7.2, 8.2, 6.2, 5.8]
print(f'scores: {scores}')

maxA = maxAlgorithm.MaxAlgorithm(scores)
maxA.removeMaxScore()

maxA = minAlgorithm.MinAlgorithm(scores)
maxA.removeMinScore()

total = 0
average = 0

for n in scores:   # 최댓값, 최솟값이 제외된 숫자들이 scores 리스트에 남아있음.
    total += n

average = round(total / len(scores), 2)

print(f'total: {round(total,2)}점')
print(f'average: {average}점')

tp = nearAlgorithm.Top5Players(top5Scores, average)
tp.setAlignScore()
top5PlayerScores = tp.getFinalTop5Scores()
print(f'top5PlayerScores: {top5PlayerScores}')

• 문제 2)
  

kor_avg = 88; eng_avg = 82; math_avg = 90; sci_avg = 78; his_avg = 92

hong_kor_score = 85; hong_eng_score = 90; hong_math_score = 82
hong_sci_score = 88; hong_his_score = 100

stu19Cnt_kor_total = kor_avg * 20 - hong_kor_score
stu19Cnt_eng_total = eng_avg * 20 - hong_eng_score
stu19Cnt_math_total = math_avg * 20 - hong_math_score
stu19Cnt_sci_total = sci_avg * 20 - hong_sci_score
stu19Cnt_his_total = his_avg * 20 - hong_his_score

stu19Cnt_kor_avg = stu19Cnt_kor_total / 19
stu19Cnt_eng_avg = stu19Cnt_eng_total / 19
stu19Cnt_math_avg = stu19Cnt_math_total / 19
stu19Cnt_sci_avg = stu19Cnt_sci_total / 19
stu19Cnt_his_avg = stu19Cnt_his_total / 19

kor_gap = hong_kor_score - stu19Cnt_kor_avg
eng_gap = hong_eng_score - stu19Cnt_eng_avg
math_gap = hong_math_score - stu19Cnt_math_avg
sci_gap = hong_sci_score - stu19Cnt_sci_avg
his_gap = hong_his_score - stu19Cnt_his_avg

print(f'국어 점수 차이: {"+" + str(round(kor_gap, 2)) if kor_gap > 0 else round(kor_gap, 2)}')   # + 표시안할거면 그냥 {round(kor_gap, 2)}')
print(f'영어 점수 차이: {"+" + str(round(eng_gap, 2)) if eng_gap > 0 else round(eng_gap, 2)}')
print(f'수학 점수 차이: {"+" + str(round(math_gap, 2)) if math_gap > 0 else round(math_gap, 2)}')
print(f'과학 점수 차이: {"+" + str(round(sci_gap, 2)) if sci_gap > 0 else round(sci_gap, 2)}')
print(f'국사 점수 차이: {"+" + str(round(his_gap, 2)) if his_gap > 0 else round(his_gap, 2)}')

stu19Cnt_total = stu19Cnt_kor_avg + stu19Cnt_eng_avg + stu19Cnt_math_avg + stu19Cnt_sci_avg + stu19Cnt_his_avg
stu19Cnt_avg = stu19Cnt_total / 5

hong_total = hong_kor_score + hong_eng_score + hong_math_score + hong_sci_score + hong_his_score
hong_avg = hong_total / 5

avg_gap = round(hong_avg - stu19Cnt_avg, 2)
print(f'평균 점수 차이: {"+" + str(round(avg_gap, 2)) if avg_gap > 0 else round(avg_gap, 2)}')