Day50. 알고리즘 문풀 (4)

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

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

• 다음은 어떤 회사의 전직원 나이를 나타내는 리스트이다.
  최빈값 알고리즘을 이용해서 나이 분포를 간단한 그래프로 출력하는 모듈을 만들어보자!

<실행파일코드>

import module_mode as 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()

<모듈파일코드1>

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

<모듈파일코드2>

import maxMod
class ModeAlgorithm:

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

    def setIndexList(self):
        self.indexes = [0 for i in range(self.maxNum + 1)]  # 직원수만큼 0으로 초기화한 인덱스!

        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 = '')  # 0>3은 000채우고 오른쪽 정렬!
            print('+' * maxNum)
            self.indexes[maxNumIdx] = 0 # 다음값이 최대값이 되어 출력될 수 있도록

            n += 1

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

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

• 다음은 회차별 로또 번호이다. 최빈도 알고리즘을 이용해서 모든 회차의 각각의 번호에 대한 빈도수를 출력하는 프로그램을 만들어보자!

<실행파일코드>

import module_mode

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 = module_mode.LottoMode(lottoNums)
mList = lm.getLottoNumMode()
print(f'mList : {mList}')
lm.printModeList()

<모듈파일코드>

class LottoMode:

    def __init__(self, ln):
        self.lottoNums = ln
        self.modeList = [0 for n in range(1, 47)]  # 로또번호는 1부터 45번까지이므로!

    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: # 초기화 되어 있지 않은 경우
            return None

        for i, m in enumerate(self.modeList):
            if i != 0:
                print(f'번호 : {i:>2}, 빈도 : {m}, {"*" * m}')

[연습문제] 근삿값 알고리즘(01)

• [연습문제] 근삿값 알고리즘(1)

• 다음 표는 수심에 따른 수온을 나타내고 있다. 근사값 알고리즘을 이용해서 수심을 입력하면 수온을 출력하는 모듈을 만들어보자
  
  
  수심(m) 수온(℃)
  0 24
  5 22
  10 20
  15 16
  20 13
  25 10
  30 6

<실행파일코드>

import module_approxi

depth = int(float(input('input depth : '))) # 이렇게하면 소수점도 해결 가능하다!
print(f'depth : {depth}')

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

<모듈파일코드>

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)
            if absNum < self.minNum:
                self.minNum = absNum
                self.nearNum = n

        return self.temps[self.nearNum]

[연습문제] 근삿값 알고리즘(02)

• [연습문제] 근삿값 알고리즘(2)

• 사용자의 몸무게(kg)와 키(m)를 입력하면 체질량지수(BMI)를 계산하고, 근삿값 알고리즘과 BMI표를 이용해서 신체 상태를 출력하는 프로그램을 만들어보자!
  
  
  저체중 18.5 정상 23 과체중 25 비만

<실행파일코드>

import module_approxi as nearMod

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

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

<모듈파일코드>

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    # BMI의 최대값이 25이므로 일단 초기값 25로 설정!


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

    def printUserCondition(self):

        for n in self.BMISection.keys():    # BMISection의 key만 가져옴
            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:
            self.userCondition = self.BMISection[self.nearNum][0]
        else:
            self.userCondition = self.BMISection[self.nearNum][1]

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