😢 스터디노트(알고리즘 문제풀이 1~5)

꼭꼭 다시풀어보기!! 😰

💡 [연습문제] 검색 알고리즘 01

💡 숫자로 이루어진 리스트에서 사용자가 입력한 숫자를 검색하는 모듈을 다음 요건에 따라 생성
1. 검색 모듈은 선형 검색 알고리즘을 이용하자.
2. 리스트는 1부터 20까지의 정수 중에서 난수 10개를 이용하자.
3. 검색 과정을 로그로 출력하자.
4. 검색에 성공하면 해당 정수의 인덱스를 출력하고, 검색 결과가 없다면 –1을 출력하자

# linear search 파일 

class Search:
    def __init__(self, nums, searchNum):
        self.numbers = nums
        self.searchNumber = searchNum
        self.searchIdx = -1

    def printNumbersAndSearchNumber(self):
        print(f'Numbers : {self.numbers}')
        print(f'Search Number : {self.searchNumber}')

    def findSearchNum(self):
        n = 0
        while True:
            if n == len(self.numbers):
               self.searchIdx = -1
               break
            elif self.numbers[n] == self.searchNumber:
                self.searchIdx = n
                break
            else:
                n += 1


    def getSearchResult(self):
        if self.searchIdx == -1:
            print('Search FAIL!')
            print(f'Search result INDEX : {self.searchIdx}')
        else:
            print('Search SUCCESS!')
            print(f'Search result INDEX : {self.searchIdx}')

            print('>>> Search Result <<<')
            print(f'search result index : {self.searchIdx}')
            print(f'search result number : {self.searchNumber}')

# 숫자로 이루어진 리스트에서 사용자가 입력한 숫자를 검색하는 모듈을 다음 요건에 따라 생성
# 1. 검색 모듈은 선형 검색 알고리즘을 이용하자.
# 2. 리스트는 1부터 20까지의 정수 중에서 난수 10개를 이용하자.
# 3. 검색 과정을 로그로 출력하자.
# 4. 검색에 성공하면 해당 정수의 인덱스를 출력하고, 검색 결과가 없다면 –1을 출력하자


import random
import linearSearch

if __name__ == '__main__':

    searchNumber = int(input('찾으려는 숫자 입력 : '))
    numbers = random.sample(range(1, 21),10)
    sn = linearSearch.Search(numbers, searchNumber)
    sn.printNumbersAndSearchNumber()
    sn.findSearchNum()
    sn.getSearchResult()

---

💡 [연습문제] 검색 알고리즘 02

💡 숫자로 이루어진 리스트에서 사용자가 입력한 숫자를 검색하는 모듈을 다음 요건에 따라 생성
1. 검색 모듈은 이진 검색 알고리즘을 이용하자.
2. 리스트는 [1, 2, 4, 6, 7, 8, 10, 11, 13, 15, 16, 17, 20, 21, 23, 24, 27, 28]를 이용하자.
3. 검색 과정을 로그로 출력하자.
4. 검색에 성공하면 해당 정수의 인덱스를 출력하고, 검색 결과가 없다면 –1을 출력하자

# binarySearch 파일

class Search():

    def __init__(self,nums, searchNum):
        self.searchNumber = searchNum
        self.list = nums
        self.searchNumberIdx = -1
        self.midVal = 0
        self.midIdx = 0
        self.startIdx = 0
        self.endIdx = len(self.list) -1

    def sortNumber(self):
        sorted(self.list)

    def setMidNumberAndMidIdx(self):
        self.midIdx = (self.startIdx + self.endIdx) // 2
        self.midVal = self.list[self.midIdx]
        print(f'staIdx : {self.startIdx}, endIdx : {self.endIdx}')
        print(f'midIdx : {self.midIdx}, midVal : {self.midVal}')

    def searchNum(self):
        while self.list[0] <= self.searchNumber and self.list[len(self.list)-1] >= self.searchNumber:
            if self.searchNumber == self.list[len(self.list)-1]:
                self.searchNumberIdx = len(self.list)-1
                print(f'staIdx : {self.startIdx}, endIdx : {self.endIdx}')
                print(f'midIdx : {self.midIdx}, midVal : {self.midVal}')
                break
            elif self.searchNumber == self.midVal:
                self.searchNumberIdx = self.midIdx
                print(f'staIdx : {self.startIdx}, endIdx : {self.endIdx}')
                print(f'midIdx : {self.midIdx}, midVal : {self.midVal}')
                break
            elif self.startIdx + 1 == self.endIdx: # 리스트 내에 숫자가 없을 경우 ★★★★★
                if self.list[self.startIdx] != self.searchNumber and self.list[self.endIdx] != self.searchNumber:
                    break
            elif self.searchNumber > self.midVal:
                self.startIdx = self.midIdx
                self.midIdx = (self.startIdx + self.endIdx) // 2
                self.midVal = self.list[self.midIdx]
                print(f'+staIdx : {self.startIdx}, endIdx : {self.endIdx}')
                print(f'-midIdx : {self.midIdx}, midVal : {self.midVal}')
            elif self.searchNumber < self.midVal:
                self.endIdx = self.midIdx
                self.midIdx = (self.startIdx + self.endIdx) // 2
                self.midVal = self.list[self.midIdx]
                print(f'-staIdx : {self.startIdx}, endIdx : {self.endIdx}')
                print(f'+midIdx : {self.midIdx}, midVal : {self.midVal}')
        return self.midIdx

    def printResult(self):
        print(f'nums : {self.list}')
        if self.searchNumberIdx == -1:
            print('No results found')
            print(f'search result index : {self.searchNumberIdx}')
        else:
            print('>>> Search Results <<<')
            print(f'search result index : {self.searchNumberIdx}')
            print(f'search result number : {self.searchNumber}')

# 숫자로 이루어진 리스트에서 사용자가 입력한 숫자를 검색하는 모듈을 다음 요건에 따라 생성
#1. 검색 모듈은 이진 검색 알고리즘을 이용하자.
#2. 리스트는 [1, 2, 4, 6, 7, 8, 10, 11, 13, 15, 16, 17, 20, 21, 23, 24, 27, 28]를 이용하자.
#3. 검색 과정을 로그로 출력하자.
#4. 검색에 성공하면 해당 정수의 인덱스를 출력하고, 검색 결과가 없다면 –1을 출력하자

import binarySearch

if __name__ == '__main__':

    nums = [1, 2, 4, 6, 7, 8, 10, 11, 13, 15, 16, 17, 20, 21, 23, 24, 27, 28]
    inputNumber = int(input('input search number : '))
    isn = binarySearch.Search(nums, inputNumber)
    isn.sortNumber()
    isn.setMidNumberAndMidIdx()
    isn.searchNum()
    isn.printResult()

---

💡 [연습문제] 순위 알고리즘 01

💡 숫자로 이루어진 리스트에서 아이템의 순위를 출력하고, 순위에 따라 아이템을 정렬하는 모듈을 생성. 리스트는 50부터 100까지의 난수 20개를 이용

# rank 파일

def rank(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'rank : {ranks}')

    for i, n in enumerate(ns):
        print(f'num : {n} \t rank : {ranks[i]}')

    sortedNum = [0 for n in range(len(ns))] # ★★★★★
    for idx, rank in enumerate(ranks):
        sortedNum[rank] = ns[idx]

    return sortedNum

# 숫자로 이루어진 리스트에서 아이템의 순위를 출력하고, 순위에 따라 아이템을
# 정렬하는 모듈을 생성. 리스트는 50부터 100까지의 난수 20개를 이용

import random
import rank

if __name__ == '__main__':

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

---

[연습문제] 순위 알고리즘 02

알파벳 문자들과 정수들에 대한 순위를 정하는 프로그램을 순위 알고리즘을 이용해서 생성.
단, 알파벳은 아스키코드 값을 이용

# 알파벳 문자들과 정수들에 대한 순위를 정하는 프로그램을 순위 알고리즘을 이용해서 생성
# 단, 알파벳은 아스키코드 값을 이용

def rankAlgorithm(datas):
    ascIIDatas = []
    ranks = [0 for i in range(len(datas))]

    print(f'Datas : {datas}')


    for data in datas:
       if str(type(data)) == '<class \'int\'>':
           ascIIDatas.append(data)
       else:
           ascIIDatas.append(ord(data))
    print(f'ascIIDatas : {ascIIDatas}')

    for idx,data1 in enumerate(ascIIDatas):
        for data2 in ascIIDatas:
            if data1 < data2:
                ranks[idx] += 1
    print(f'ranks : {ranks}')

    for idx, data in enumerate(datas):
        print(f'data : {data}\t\t rank : {ranks[idx]+1}')
    return ascIIDatas



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

---

💡 [연습문제] 정렬 알고리즘 01

💡 숫자로 이루어진 리스트를 버블정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다.)

# bubbleMod 파일

import copy

def bubbleSort(nums, asc = True):

    c_nums = copy.copy(nums)

    length = len(c_nums)-1
    for i in range(length):
        for j in range(length-i):
            if asc:
                if c_nums[j] > c_nums[j+1]:
                    c_nums[j],c_nums[j+1] = c_nums[j+1], c_nums[j]
            else:
                if c_nums[j] < c_nums[j + 1]:
                    c_nums[j], c_nums[j + 1] = c_nums[j + 1], c_nums[j]

            print(f'sorting nums : {c_nums}')
        print()
    return c_nums

# 숫자로 이루어진 리스트를 버블정렬 알고리즘을 이용해서 오름차순과
# 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다.)

import random
import bubbleMod

if __name__ == '__main__':

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

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

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

---

💡 [연습문제] 정렬 알고리즘 02

💡 숫자로 이루어진 리스트를 삽입정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다)

# insertMod 파일

import copy


def sortInsertAlgorithm(ns, asc = True):

    c_ns = copy.copy(ns)

    for i1 in range(1, len(c_ns)):
        i2 = i1 -1
        currNum = c_ns[i1]

        if asc: #asc
            while c_ns[i2] > currNum and i2 >= 0:
                c_ns[i2 + 1] = c_ns[i2]
                i2 -= 1
        else: #desc
            while c_ns[i2] < currNum and i2 >= 0:
                c_ns[i2 + 1] = c_ns[i2]
                i2 -= 1
        c_ns[i2 +1] = currNum
        print(f'c_ns : {c_ns}')
    return  c_ns

# 숫자로 이루어진 리스트를 삽입정렬 알고리즘을 이용해서 오름차순과
# 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다)

import random
import insertMod

if __name__ == '__main__':
    nums = random.sample(range(1, 21),10)

    print(f'not sorted nums : {nums}')
    result = insertMod.sortInsertAlgorithm(nums)
    print(f'sorted nums by ASC: {result}')

    print(f'not sorted nums : {nums}')
    result = insertMod.sortInsertAlgorithm(nums, asc=False)
    print(f'sorted nums by DESC: {result}')

---

💡 [연습문제] 정렬 알고리즘 03

💡 숫자로 이루어진 리스트를 선택정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다.)

# selectMod 파일

import copy

def sortSelectAlgorithm(ns, asc = True):

    c_ns = copy.copy(ns)

    for i in range(len(c_ns)-1):
        minIdx = i
        for j in range(i+1, len(c_ns)):
            if asc:
                if c_ns[minIdx] > c_ns[j]:
                    minIdx = j # i값을 빼고 나머지 값들 중에 더 작은 값을 찾아다 minidx를 찾음 끝까지 비교해봄
            else:
                if c_ns[minIdx] < c_ns[j]:
                    minIdx = j
        c_ns[i], c_ns[minIdx] = c_ns[minIdx], c_ns[i]
        print(c_ns)

# 숫자로 이루어진 리스트를 선택정렬 알고리즘을 이용해서 오름차순과
# 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다.)

import random
import selectMod

if __name__ == '__main__':

    nums = random.sample(range(1, 21), 10)
    print(f'not sorted nums : \n{nums}')
    print()
    result = selectMod.sortSelectAlgorithm(nums)
    print(f'sorted nums by ASC : \n{nums}')
    print()
    print(f'not sorted nums : \n{nums}')
    result = selectMod.sortSelectAlgorithm(nums, asc = False)
    print(f'sorted nums by ASC : \n{nums}')

---

💡 [연습문제] 정렬 알고리즘 04

💡 숫자로 이루어진 리스트를 병합정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다.)

# mergeSort 파일

import copy

def sortMergeAlgorithm(ns, asc = True):

    c_ns = copy.copy(ns)

    if len(c_ns) < 2:
        return c_ns

    midIdx = len(c_ns) // 2
    leftNums = sortMergeAlgorithm(c_ns[0:midIdx], asc=asc)
    rightNums = sortMergeAlgorithm(c_ns[midIdx:len(c_ns)], asc=asc)

    mergeNums = []
    leftIdx = 0; rightIdx = 0

    while leftIdx < len(leftNums) and rightIdx < len(rightNums):
        if asc:
            if leftNums[leftIdx] < rightNums[rightIdx]:
                mergeNums.append(leftNums[leftIdx])
                leftIdx += 1
            else:
                mergeNums.append(rightNums[rightIdx])
                rightIdx += 1
        else:
            if leftNums[leftIdx] > rightNums[rightIdx]:
                mergeNums.append(leftNums[leftIdx])
                leftIdx += 1
            else:
                mergeNums.append(rightNums[rightIdx])
                rightIdx += 1
    mergeNums = mergeNums + leftNums[leftIdx:]
    mergeNums = mergeNums + rightNums[rightIdx:]


    print(f'mergeNums : {mergeNums}')

    return mergeNums

#  숫자로 이루어진 리스트를 병합정렬 알고리즘을 이용해서 오름차순과
# 내림차순으로 정렬하는 모듈을 생성.(단 정렬하는 과정도 출력하도록 한다.)

import random
import mergeSort

nums = random.sample(range(0, 101),20)

print(f'not sorted rNums : {nums}')
result = mergeSort.sortMergeAlgorithm(nums)
print(f'sorted rNums by ASC : {result}')
print()

print(f'not sorted rNums : {nums}')
result = mergeSort.sortMergeAlgorithm(nums, asc=False)
print(f'sorted rNums by DESC : {result}')

---

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

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

# maxAlgorithm 파일

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

    def setMaxNum(self):
        self.maxNum = self.nums[0]

        for num in self.nums:
            if num >= self.maxNum:
                self.maxNum = num

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

    def setMaxNumCnt(self):
        for n in self.nums:
            if self.maxNum == n:
                self.maxNumCnt +=1

    def getMaxNumCnt(self):
        return self.maxNumCnt

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

import random
import maxAlgorithm

if __name__ == '__main__':

    nums = []
    for n in range(30):
        nums.append(random.randint(1, 50))
    print(f'nums : {nums}')
    result = maxAlgorithm.MaxAlgorithm(nums)
    result.setMaxNum()
    result.setMaxNumCnt()
    print(f'max num : {result.getMaxNum()}')
    print(f'max num cnt : {result.getMaxNumCnt()}')

---

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

학급 전체 학생의 시험 점수에 대한 평균과 최댓값을 구하고 평균과 최댓값의 편차를 출력하는 프로그램을 최댓값 알고리즘을 이용해서 생성

# 학급 전체 학생의 시험 점수에 대한 평균과 최댓값을 구하고 평균과 최댓값의
# 편차를 출력하는 프로그램을 최댓값 알고리즘을 이용해서 생성

def maxAlgorithm(nums):
    nums = nums
    avgScore = 0
    maxScore = nums[0]
    sumScore = 0
    maxDeviation = 0
    avgDeviation = 0

    for n in nums:
        sumScore += n
        if maxScore < n:
            maxScore = n

    avgScore = round(sumScore / len(nums), 2)
    print(f'평균 : {avgScore}')
    print(f'최댓값 : {maxScore}')
    for n in nums:
        maxDeviation = n - maxScore
        avgDeviation = n  - avgScore
        print(f'평균과의 편차 : {round(avgDeviation,2)},\t 최댓값의 편차 : {maxDeviation}')


students = [100, 64, 94, 66, 75, 58, 99, 76, 96, 75, 54, 73, 88, 70, 68, 50, 95, 89, 69, 98]
maxAlgorithm(students)

---

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

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

# minAlgorithm 파일

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

    def setMinNum(self):
        self.minNum = self.nums[0]
        for num in self.nums:
            if self.minNum > num:
                self.minNum = num

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

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

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

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

import random
import minAlgorithm

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

    print(f'nums : {nums}')

    mn = minAlgorithm.MinAlgorithm(nums)
    print(f'min num : {mn.getMinNum()}')
    print(f'min num count : {mn.getMinNumCnt()}')

---

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

학급 전체 학생의 시험 점수에 대한 평균과 최솟값을 구하고 평균과 최솟값의 편차를 출력하는 프로그램을 최솟값 알고리즘을 이용해서 생성

# 학급 전체 학생의 시험 점수에 대한 평균과 최솟값을 구하고 평균과 최솟값의
# 편차를 출력하는 프로그램을 최솟값 알고리즘을 이용해서 생성

def minAlgorithm(nums):
    nums = nums
    minScore = nums[0]
    sumScore = 0
    avgScore = 0
    minDiviation = 0
    avgDeviation = 0

    for num in nums:
        sumScore += num
        if minScore > num:
            minScore = num

    avgScore = round(sumScore / len(nums),2)

    print(f'평균 : {avgScore}, 최솟값 : {minScore}')

    for num in nums:
        minDiviation = num - minScore
        avgDeviation = num - avgScore

        print(f'[{num} 점] : 평균의 편차 : {round(avgDeviation,2)}, 최솟값의 편차 : {minDiviation}')



students = [100, 64, 94, 66, 75, 58, 99, 76, 96, 75, 54, 73, 88, 70, 68, 50, 95, 89, 69, 98]
minAlgorithm(students)

---

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

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

# maxAlgorithm2 파일

class MaxAlgorithm:

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

    def setMaxIdxAndMaxNum(self):
        self.maxNum = 0
        self.maxIdx = 0

        for idx, num in enumerate(self.nums):
            if self.maxNum < num:
                self.maxNum = num
                self.maxIdx = idx

    def getMaxNum(self):
        return self.maxNum

    def getMaxIdx(self):
        return self.maxIdx

# modeAlgorithm 파일

import maxAlgorithm2


class ModeAlgorithm:
    def __init__(self, nums, mn):
        self.nums = nums
        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] += 1

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

    def printAges(self):

        n = 1
        while True:
            maxAlo = maxAlgorithm2.MaxAlgorithm(self.indexes)
            maxAlo.setMaxIdxAndMaxNum()
            maxNum = maxAlo.getMaxNum()
            maxNumIdx = maxAlo.getMaxIdx()

            if maxNum == 0: # indexes 안에 모든 값이 0 이될 경우 while문 나옴
                break
            print(f'[{n:0>3}] {maxNumIdx}세 빈도수 : {maxNum} \t', end='') # n:0>3 : 3개의 자리를 만들어 값을 입력하는데 빈 자리는 0으로 채움 ★★★★★
            print(f'+'*maxNum)
            self.indexes[maxNumIdx] = 0 # 가장 큰 값을 0으로 만들고 그 다음 큰값을 반복적으로 구하기 위해

            n += 1

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


import maxAlgorithm2
import modeAlgorithm

ageList = [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'emplyee cnt : {len(ageList)}')

maxAlo = maxAlgorithm2.MaxAlgorithm(ageList)
maxAlo.setMaxIdxAndMaxNum()
maxAge = maxAlo.getMaxNum()
maxAgeIdx = maxAlo.getMaxIdx()

print(f'maxAge : {maxAge}')


modAlo = modeAlgorithm.ModeAlgorithm(ageList, maxAge)
modAlo.setIndexList()
modAlo.getIndexList()
print(f'IndexList : {modAlo.getIndexList()}')
modAlo.printAges()

---

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

💡 다음은 회차별 로또 번호이다. 최빈도 알고리즘을 이용해서 모든 회차의 각각의 번호에 대한 빈도수를 출력하는 프로그램을 생성

# lottoMaxAlgorithm 파일

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

    def setMaxNumAndMaxNumIdx(self):
        self.maxNum = self.nums[0]
        self.maxNumIdx = 0

        for idx, num in enumerate(self.nums):
            if self.maxNum < num:
                self.maxNum = num
                self.maxNumIdx = idx

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

    def getMaxNumIdx(self):
        self.setMaxNumAndMaxNumIdx()
        return self.maxNumIdx
        

# lottoModeAlgorithm 파일

class ModeAlgorithm:
    def __init__(self, nums, maxnum):
        self.nums = nums
        self.maxNum = maxnum
        self.indexes = []


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

    def getIndexes(self):
        self.setIndexes()
        return self.indexes

    def setMode(self):
        self.setIndexes()
        for num in self.nums:
            self.indexes[num] += 1
        return self.indexes

    def printModeNumber(self):
        self.setIndexes()
        self.setMode()
        for idx, num in enumerate(self.indexes):
            if idx != 0:
                print(f'번호 : {idx}\t, 빈도 : {num},\t', end='')
                print('*'*num)
                

# 다음은 회차별 로또 번호이다. 최빈도 알고리즘을 이용해서 모든 회차의 각각의
# 번호에 대한 빈도수를 출력하는 프로그램을 생성

import lottoMaxAlgorithm
import lottoModeAlgorithm

lotto = [[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], [33, 28, 45, 21, 38, 24], [4, 30, 29, 28, 32, 38],
         [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]]

lotto2 = []
for list in lotto:
    for num in list:
        lotto2.append(num)
print(f'lotto : {lotto2}')

lt = lottoMaxAlgorithm.MaxAlgorithm(lotto2)
maxNum = lt.getMaxNum()
print(f'max number : {maxNum}')
print(f'max number idx : {lt.getMaxNumIdx()}')


index = lottoModeAlgorithm.ModeAlgorithm(lotto2,maxNum)
#print(index.setMode())
index.printModeNumber()

---

💡 [연습문제] 근사값 알고리즘 01

💡 다음 표는 수심에 따른 수온을 나타내고 있다. 근사값 알고리즘을 이용해서 수심을 입력하면 수온을 출력하는 모듈 생성

# near 파일

class near:

    def __init__(self, num):
        self.num = num
        self.depth = {}
        self.diff = 0
        self.nearNum = 0
        self.nearNum2 = 0

    def setDepthAndTemperatur(self):
        self.depth = {0: 24, 5: 22, 10: 20, 15: 16, 20: 13, 25: 10, 30: 6}
        self.diff = 30
        self.temp = 6

    def setNearNum(self):
        self.setDepthAndTemperatur()

        #내가 한 것
        # for dp, temperatur in self.depth.items(): # ★
        #     absVal = abs(self.num - dp)
        #
        #     if self.diff > absVal:
        #         self.diff = absVal
        #         self.nearNum = temperatur
        # return self.nearNum

        for n in self.depth.keys():  #내가 한 것을 돌리고 싶을 때는 주석처리 필요
            absNum = abs(n - self.num)
            if absNum < self.diff:
                self.diff = absNum
                self.nearNum = n

        self.nearNum2 = self.depth[self.nearNum]
        return self.nearNum2


    def printResult(self):
        #self.setDepthAndTemperatur()
        self.setNearNum()
        print(f'depth : {self.num} m')
        #print(f'water temperature : {self.nearNum} 도') #내가 한 것과 같이 해야 함
        print(f'water temperature : {self.nearNum2} 도') #내가 한 것을 돌리고 싶을 때는 주석처리 필요

# 다음 표는 수심에 따른 수온을 나타내고 있다. 근사값 알고리즘을 이용해서 수심을
# 입력하면 수온을 출력하는 모듈 생성

import near

inputDepth = int(float(input('input depth : ')))  #int(float())을 하면 실수형이 입력 되었을 때 int형으로 변환 가능 ★
id = near.near(inputDepth)
id.printResult()

---

💡 [연습문제] 근사값 알고리즘 02

💡 사용자의 몸무게(kg)와 키(m)를 입력하면 체질량지수(BMI)를 계산하고, 근삿값 알고리즘과 BMI표를 이용해서 신체 상태를 출력하는 프로그램을 생성

# nearMod 파일

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


    def calculatorBMI(self):
        # 몸무게 / 키^2
        self.userBMI = round(self.userWeight / (self.userHeight * self.userHeight),2)
        print(f'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:
            self.userCondition = self.BMISection[self.nearNum][0] # bmi 기준 값보다 작으면 0번째 인덱스
        else:
            self.userCondition = self.BMISection[self.nearNum][1]
        print(f'self.userCondition : {self.userCondition}')

#  사용자의 몸무게(kg)와 키(m)를 입력하면 체질량지수(BMI)를 계산하고, 근삿값
# 알고리즘과 BMI표를 이용해서 신체 상태를 출력하는 프로그램을 생성

import nearMod

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


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

---

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

💡 다음은 ‘A상사’의 2021년 월별 매출을 나타내는 표이다. 재귀 알고리즘을 이용해서 1월부터 12월까지 전월대비 매출 증감액을 나타내는 프로그램을 생성

# 다음은 ‘A상사’의 2021년 월별 매출을 나타내는 표이다. 재귀 알고리즘을 이용해서
# 1월부터 12월까지 전월대비 매출 증감액을 나타내는 프로그램을 생성



def salesUpAndDown(ss):
    if len(ss) == 1:
        return ss

    print(f'sales : {ss}')
    currentSales = ss.pop(0)
    nextSales = ss[0]

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

    return salesUpAndDown(ss) # pop으로 ss 리스트의 앞 값을 삭제한걸 다시 부름


if __name__ == '__main__':

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

---

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

💡 사용자가 정수 두개를 입력하면 작은 정수와 큰 정수 사이의 모든 정수의 합을 구하는 프로그램을 재귀 알고리즘을 이용해서 생성

# mod 파일

class NumsSum:
    def __init__(self, n1, n2):
        self.bigNum = 0
        self.smallNum = 0
        self.setM1M2(n1, n2) # ★★★

    def setM1M2(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) # ★
        

# 사용자가 정수 두개를 입력하면 작은 정수와 큰 정수 사이의 모든 정수의 합을 구하는
# 프로그램을 재귀 알고리즘을 이용해서 생성

import mod

if __name__ == '__main__':

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

---

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

💡 다음은 어떤 체조선수의 경기 점수이다. 최댓값과 최솟값을 제외한 나머지 점수에 대한 평균을 구하고 순위를 정하는 알고리즘을 생성

# maxAlgorithm3 파일

class MaxAlgorithm:

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

    def removeMaxScore(self):
        self.maxScore = self.scores[0] # 먼저 첫번째값 설정

        for idx, score in enumerate(self.scores):
            if self.maxScore < score:
                self.maxScore = score
                self.maxScoreIdx = idx

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

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

# minAlgorithm3 파일

class MinAlgorithm:

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

    def removeMinScore(self):
        self.minScore = self.scores[0] # 먼저 첫번째값 설정

        for idx, score in enumerate(self.scores):
            if self.minScore > score:
                self.minScore = score
                self.minScoreIdx = idx

        print(f'self.maxScore : {self.minScore}')
        print(f'self.maxScoreIdx : {self.minScoreIdx}')

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

# nearAlgorithm 파일

class Top5Player:
    def __init__(self, cts, ns):
        self.currentScores = cts
        self.newScores = ns

    def setAlignScores(self):
        nearIdx = 0
        minNum = 10.0 # 가장 큰 값으로 우선 설정

        for idx, score in enumerate(self.currentScores):
            absNum = abs(self.newScores - score)

            if absNum < minNum:
                minNum = absNum #근사값
                nearIdx = idx

        if self.newScores >= self.currentScores[nearIdx]: #근사값보다 큰 경우
            for i in range(len(self.currentScores) -1, nearIdx, -1): #끝에서 근사값 전까지
                self.currentScores[i] = self.currentScores[i-1] # ★
            self.currentScores[nearIdx] = self.newScores # 근사값에 새로운 점수 입력
        else:
            for i in range(len(self.currentScores) -1, nearIdx+1, -1):
            # 끝에서 근사값 다음까지, 근사값 위치에 현재 값을 넣을거고 이건 그 이후 값을 넣기 위해
                self.currentScores[i] = self.currentScores[i-1] # ★
            self.currentScores[nearIdx+1] = self.newScores # 근사값 다음에 새로운 점수 입력 ★★★★★

    def getFinalTop5Scores(self):
        return self.currentScores

---

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

다음은 홍길동 학생을 포함한 학급 전체 학생의 시험 점수 평균을 나타낸 표이다. 표를 보고, 홍길동 학생을 제외한 나머지 학생의 평균과 홍길동 학생의 점수의 차이를 출력하는 프로그램을 생성.(출력은 과목별 점수와 평균 점수를 모두 출력한다.)

# 다음은 홍길동 학생을 포함한 학급 전체 학생의 시험 점수 평균을 나타낸 표이다.
# 표를 보고, 홍길동 학생을 제외한 나머지 학생의 평균과 홍길동 학생의 점수의 차이를
# 출력하는 프로그램을 생성.(출력은 과목별 점수와 평균 점수를 모두 출력한다.)


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
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
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
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 eng_gap > 0 else round(eng_gap,2)}')
print(f'수학 점수 차이 : {"+" + str(round(mat_gap,2)) if mat_gap > 0 else round(mat_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_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(avg_gap) if his_gap > 0 else avg_gap}')

💻 출처 : 제로베이스 데이터 취업 스쿨