Day51. 알고리즘 문풀 (5)

[연습문제] 재귀 알고리즘(01)

• [연습문제] 재귀 알고리즘(1)

• 다음은 'A상사'의 2021년 월별 매출을 나타내는 표이다. 재귀 알고리즘을 이용해서 1월부터 12월까지 전월대비 매출 증감액을 나타내는 프로그램을 만들어보자!
  
  
  월 매출(천원)
  1월 12,000
  2월 13,000
  3월 12,500
  4월 11,000
  5월 10,500
  6월 98,000
  7월 91,000
  8월 91,500
  9월 10,500
  10월 11,500
  11월 12,000
  12월 12,500

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

def salesUpAndDown(ss):

    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)

[연습문제] 재귀 알고리즘(02)

• [연습문제] 재귀 알고리즘(2)

• 사용자가 정수 두개를 입력하면 작은 정수와 큰 정수 사이의 모든 정수의 합을 구하는 프로그램을 재귀 알고리즘을 이용해서 만들어보자!
  
  
  1 2 [3] 4 5 6 7 8 9 [10]
  -> 4 + 5 + 6 + 7 + 8 + 9 = 39
  
  
  9까지의 합을 구하고 3까지의합을 구해서 뺀다

<실행파일코드>

import module_recursion as mr
num1 = int(input(f'input number1 : '))
num2 = int(input(f'input number2 : '))

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

<모듈파일코드>

class NumsSum:

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

    def setN1N2(self, n1, n2):  # 입력받은 수의 큰 수, 작은 수 구분
        self.bigNum = n1
        self.smallNum = n2

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

    def addNum(self, n):    # 숫자까지의 합 구하는 함수
        if n <= 1:
            return n

        return n + self.addNum(n - 1)   # 재귀함수로 계속 더하기 !


    def sumBetweenNums(self):
        return self.addNum(self.bigNum - 1) - self.addNum(self.smallNum)

[연습문제] 평균 알고리즘(01)

• [연습문제] 평균 알고리즘(1)

• 다음은 어떤 체조선수의 경기 점수이다. 최댓값과 최솟값을 제외한 나머지 점수에 대한 평균을 구하고 순위를 정하는 알고리즘을 만들어보자!
  
  
  score1 6.7
  score2 5.9
  score3 8.1
  score4 7.9
  score5 6.7
  score6 7.3
  score7 7.2
  score8 8.2
  score9 6.2
  score10 5.8

<실행파일코드>

import module_maxAlgorithm_avg as ma1
import module_minAlgorithm_avg as ma2
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 = ma1.MaxAlgorithm(scores)
maxA.removeMaxScore()

minA = ma2.MinAlgorithm(scores)
minA.removeMinScore()

total = 0
average = 0

for n in 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()
top5Scores = tp.getFinalTop5Scores()
print(f'top5Scores : {top5Scores}')

<모듈파일코드1>

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'scores : {self.scores}')

<모듈파일코드2>

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'scores : {self.scores}')

<모듈파일코드3>

class Top5Players:  # 최상위 선수 5명만 뽑는 클래스

    def __init__(self, cts, ns):
        self.currentScores = cts
        self.newScore = ns


    def setAlignScore(self):
        nearIdx = 0
        minNum = 10.0

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

        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

        else:
            for i in range(len(self.currentScores) - 1, nearIdx + 1, -1):
                self.currentScores[i] = self.currentScores[i - 1]
            self.currentScores[nearIdx] = self.newScore

    def getFinalTop5Scores(self):
        return self.currentScores

[연습문제] 평균 알고리즘(02)

• [연습문제] 평균 알고리즘(2)

• 다음은 홍길동 학생을 포함한 학급 전체 학생의 시험 점수 평균을 나타낸 표이다.
  표를 보고, 홍길동 학생을 제외한 나머지 학생의 평균과 홍길동 학생의 점수의 차이를 출력하는 프로그램을 만들어보자!
  (출력은 과목별 점수와 평균 점수를 모두 출력한다!)
  
  
  전체 학생 평균 점수(20명) 국어:88 영어:82 수학:90 과학:78 국사:92 과목 전체 평균 점수:86
  
  
  홍길동 학생 점수 국어:85 영어:90 수학:82 과학:88 국사:100

kor_avg = 88
eng_avg = 82
mat_avg = 90
sci_avg = 78
his_avg = 92

hong_kor_score = 85
hong_eng_score = 90
hong_mat_score = 82
hong_sci_score = 88
hong_his_score = 100

stu19Cnt_kor_total = kor_avg * 20 - hong_kor_score  # 19명 학생의 총 점수
stu19Cnt_eng_total = eng_avg * 20 - hong_eng_score
stu19Cnt_mat_total = mat_avg * 20 - hong_mat_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  # 19명 학생의 평균 점수
stu19Cnt_eng_avg = stu19Cnt_eng_total / 19
stu19Cnt_mat_avg = stu19Cnt_mat_total / 19
stu19Cnt_sci_avg = stu19Cnt_sci_total / 19
stu19Cnt_his_avg = stu19Cnt_his_total / 19

kor_gap = hong_kor_score - stu19Cnt_kor_avg # 홍길동 학생을 제외한 19명 학생의 차이
eng_gap = hong_eng_score - stu19Cnt_eng_avg
mat_gap = hong_mat_score - stu19Cnt_mat_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)}')
print(f'영어 점수 차이 : {"+" + str(round(eng_gap, 2)) if kor_gap > 0 else round(eng_gap, 2)}')
print(f'수학 점수 차이 : {"+" + str(round(mat_gap, 2)) if kor_gap > 0 else round(mat_gap, 2)}')
print(f'과학 점수 차이 : {"+" + str(round(sci_gap, 2)) if kor_gap > 0 else round(sci_gap, 2)}')
print(f'국사 점수 차이 : {"+" + str(round(his_gap, 2)) if kor_gap > 0 else round(his_gap, 2)}')

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

hong_total = hong_kor_score + hong_eng_score + hong_mat_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)}')