Day49. 알고리즘 문풀 (3)

[연습문제] 최댓값 알고리즘(01)

• [연습문제] 최댓값 알고리즘(1)

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

<실행파일코드>

import random
import module_maximumAlgorithm as mma

if __name__ == '__main__':

    nums = []
    for n in range(30): # 중복이 허용된 랜덤 인수 30개!
        nums.append(random.randint(1, 50))

    print(f'nums : \n {nums}')
    maximum = mma.MaxAlgorithm(nums)
    print(f'max num : {maximum.getMaxNum()}')
    print(f'max num count : {maximum.getMaxNumCnt()}')

<모듈파일코드>

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

        return self.maxNum

    def getMaxNum(self):    # 최댓값만 뽑아내오는 함수
        self.setMaxNum()
        return self.maxNum

    def setMaxNumCnt(self): # 중복을 카운트 해주는 함수
        self.setMaxNum()

        for n in self.nums:
            if self.maxNum == n:    # 최댓값과 n이 같다? -> 중복이 있다!
                self.maxNumCnt += 1 # 카운트

    def getMaxNumCnt(self): # 카운트만 뽑아내오는 함수
        self.setMaxNumCnt()
        return self.maxNumCnt

[연습문제] 최댓값 알고리즘(02)

• [연습문제] 최댓값 알고리즘(2)

• 최댓값 알고리즘
  
  
  학급 전체 학생의 시험 점수에 대한 평균과 최댓값을 구하고
  평균과 최댓값의 편차를 출력하는 프로그램을 최댓값 알고리즘을 이용해서 만들어보자!
  
  
  전체 학생 시험 점수
  [100, 64, 94, 66, 75, 58, 99, 76, 96, 74, 54, 73, 88, 70, 68, 50, 95, 89, 69, 98]

<실행파일코드>

import module_maximumAlgorithm as mma

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

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

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

<모듈파일코드>

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)

[연습문제] 최솟값 알고리즘(01)

• [연습문제] 최소값 알고리즘(1)

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

<실행파일코드>

import random
import module_minimumAlgorithm as mma

if __name__ == '__main__':

    nums = []
    for n in range(30): # 중복 허용 난수 30개!
        nums.append(random.randint(1, 50))

    print(f'nums : \n {nums}')
    minimum = mma.MinAlgorithm(nums)

    print(f'min num : {minimum.getMinNum()}')
    print(f'min num count : {minimum.getMinNumCnt()}')

<모듈파일코드>

class MinAlgorithm:

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

    def setMinNum(self):
        self.minNum = 51    # 난수의 범위를 1~50으로 해놨으므로!

        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

[연습문제] 최솟값 알고리즘(02)

• [연습문제] 최솟값 알고리즘(2)

• 최솟값 알고리즘
  
  
  학급 전체 학생의 시험 점수에 대한 평균과 최솟값을 구하고
  평균과 최솟값의 편차를 출력하는 프로그램을 최솟값 알고리즘을 이용해서 만들어보자!
  
  
  전체 학생 시험 점수
  [100, 64, 94, 66, 75, 58, 99, 76, 96, 74, 54, 73, 88, 70, 68, 50, 95, 89, 69, 98]

<실행파일코드>

# import module_minimumAlgorithm as mma

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

# socres_avg = mma.getAvg(scores)
# # socres_min = mma.getMin(scores)
# socres_min = mma.getMaxOrMin(scores, maxFlag=True)
# deviation = mma.getDeviation(socres_avg, socres_min)
#
# print(f'socres_avg : {socres_avg}')
# print(f'socres_min : {socres_min}')
# print(f'deviation : {deviation}')

import class_minimumAlgorithm

sm = class_minimumAlgorithm.ScoreManagement(scores)

print(f'socres_avg : {sm.getAvgScore()}')
print(f'socres_min : {sm.getMinScore()}')
print(f'socres_max : {sm.getMaxScore()}')
print(f'score_min_deviation : {sm.getMinDeviation()}')
print(f'score_max_deviation : {sm.getMaxDeviation()}')

<모듈파일코드>

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):    # maxFlag가 True면 최대값을 False면 최소값을 구한다

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

        else:
            if resultN > n:
                resultN = n

# 오류발생확인필요!!!

<클래스파일코드>

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  # 초기화 꼭 주의!
        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)