검색
1번 선형검색 알고리즘
- 숫자로 이루어진 리스트에서 사용자가 입력한 숫자를 검색하는 모듈을 다음 요선에 따라 만들어보자.
# 모듈
def searchNumberByLinAlgorithm(ns, sn):
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(f'Search SUCCESS!!')
print(f'Search result INDEX!! : {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.searchNumberByLinAlgorithm(rNums, searchNum)
if resultIdx == -1:
print('No result found')
print(f'search result index : {resultIdx}')
else:
print('>>> Search Result <<<')
print(f'search result index : {resultIdx}')
print(f'search result number : {rNums[resultIdx]}')
2번 이진검색 알고리즘
- 숫자로 이루어진 리스트에서 사용자가 입력한 숫자를 검색하는 모듈을 다음 요건에 따라 만들어보자.
# 모듈
def searchNumberByBinaryAlgorithm(ns, sn):
searchResultIdx = -1
staIdx = 0
endIdx = len(ns) -1
midIdx = (staIdx + endIdx) // 2
midVal = ns[midIdx]
print(f'staIdx : {staIdx}, endIdx : {endIdx}')
print(f'midIdx : {midIdx}, midVal : {midVal}')
print()
while sn >= ns[0] and sn <= ns[len(ns) - 1]:
if sn == ns[len(ns) - 1]:
searchResultIdx = len(ns) - 1
break
if staIdx + 1 == endIdx: # 찾을 숫자가 없을때
if ns[staIdx] != sn and ns[endIdx] != sn:
# 검색을 할려는 숫자가 staIdx에 있는 값도 아니고 endIdx에 있는 값도 아니면 break를 실행하라.
break
if sn > midVal:
staIdx = midIdx
midIdx = (staIdx + endIdx) // 2
midVal = ns[midIdx]
print(f'+ staIdx : {staIdx}, endIdx : {endIdx}')
print(f'+ midIdx : {midIdx}, midVal : {midVal}')
print()
elif sn < midVal:
endIdx = midIdx
midIdx = (staIdx + endIdx) // 2
midVal = ns[midIdx]
print(f'- staIdx : {staIdx}, endIdx : {endIdx}')
print(f'- midIdx : {midIdx}, midVal : {midVal}')
print()
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.searchNumberByBinaryAlgorithm(nums, searchNum)
print(f'nums : {nums}')
print()
if resultIdx == -1:
print('No result found.')
print(f'search result index : {resultIdx}')
print()
else:
print('>>> Search Results <<<')
print(f'search result index : {resultIdx}')
print(f'search result number : {nums[resultIdx]}')
print()
순위
3번 순위 알고리즘
- 숫자로 이루어진 리스트에서 아이템의 순위를 출력하고, 순위에 따라 아이템을 정렬하는 모듈을 만들어보자. 리스트는 50부터 100까지의 난수 20개를 이용하자.
# 모듈
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 i in range(len(ns))]
for idx, rank in enumerate(ranks): # 순위를 정렬시키는 부분
sortedNums[rank] = ns[idx]
return sortedNums
# 실행문
import random
import rankMod
if __name__ == '__main__':
nums = random.sample(range(50, 101),20)
sNums = rankMod.rankAlgorithm(nums)
print(f'sNums : {sNums}')
최솟값
4번 최솟값 알고리즘
- 학급 전체 학생의 시험 점수에 대한 평균과 최솟값을 구하고 평균과 최솟값의 편차를 출력하는 프로그램을 최솟값 알고리즘을 이용해서 만들어보자.
# 모듈
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
# 클래스
class ScoreManagement:
def __init__(self, ss): # 매개변수
self.scores = ss
self.score_total = 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:
# 초기화가 안되어있을때 실행되어 None을 반환한다.
return None
self.score_min = self.scores[0]
for n in self.scores:
if self.score_min > n:
self.score_min = n
return self.score_min
def getMaxScore(self):
if self.scores == None or len(self.scores) == 0:
# 초기화가 안되어있을때 실행되어 None을 반환한다.
return None
self.score_max = self.scores[0]
for n in self.scores:
if self.score_max < n:
self.score_max = n
return self.score_max
def getTotalScore(self):
if self.scores == None or len(self.scores) == 0:
# 초기화가 안되어있을때 실행되어 None을 반환한다.
return None
self.scores_total = 0
for n in self.scores:
self.scores_total += n
return self.scores_total
def getAvgScore(self):
if self.scores == None or len(self.scores) == 0:
# 초기화가 안되어있을때 실행되어 None을 반환한다.
return None
self.score_avg = round(self.getTotalScore() // 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)
# 실행문
import minMod
scores = [100, 64, 94, 66, 75, 58, 99, 76, 96, 74,
54, 73, 88, 70, 68, 50, 95, 89, 69, 98]
# 모듈용
# scores_avg = minMod.getAvg(scores)
# scores_min = minMod.getMaxOrMin(scores,maxFlag=False)
# scores_max = minMod.getMaxOrMin(scores)
# deviation = minMod.getDeviation(scores_avg, scores_min)
#
# print(f'scores_avg : {scores_avg}')
# print(f'scores_min : {scores_min}')
# print(f'scores_max : {scores_max}')
# print(f'deviation : {deviation}')
# 클래스용
import mod2
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()}')- 클래스를 만들어서 실행 시킨 결과
정렬
5번 버블정렬 알고리즘
- 숫자로 이루어진 리스트를 버블정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 만들어보자.
(단 정렬하는 과정도 출력하도록 한다.)
# 모듈
import copy
def sortByBubbleAlgorithm(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'c_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.sortByBubbleAlgorithm(nums)
print(f'Sorted Nums By ASC : {result}')
result = bubbleMod.sortByBubbleAlgorithm(nums, asc=False)
print(f'Sorted Nums By DESC : {result}')
6번 삽입정렬 알고리즘
- 숫자로 이루어진 리스트를 삽입정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 만들어보자.
(단 정렬하는 과정도 출력하도록 한다.)
# 모듈
import copy
def sortInsertAlgorithm(ns,asc = True):
c_ns = copy.copy(ns)
for i1 in range(1, len(c_ns)):
i2 = i1 -1
c_Num = c_ns[i1] # 현재 정렬을 시키고자 하는 데이터를 선언해준다.
if asc: # 오름차순
while c_ns[i2] > c_Num and i2 >= 0:
c_ns[i2 + 1] = c_ns[i2]
i2 -= 1
else: # 내림차순
while c_ns[i2] < c_Num and i2 >= 0:
c_ns[i2 + 1] = c_ns[i2]
i2 -= 1
c_ns[i2 + 1] = c_Num
print(f'c_ns : {c_ns}')
return c_ns
# 실행문
import random
import insertMod
if __name__ == '__main__':
nums = random.sample(range(1, 20), 10)
print(f'Not Sorted Nums :\n{nums}')
result = insertMod.sortInsertAlgorithm(nums)
print(f'Sorted Nums By ASC :\n{result}')
result = insertMod.sortInsertAlgorithm(nums, asc=False)
print(f'Sorted Nums By DESC :\n{result}')
7번 선택정렬 알고리즘
- 숫자로 이루어진 리스트를 선택정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 만들어보자.
(단 정렬하는 과정도 출력하도록 한다.)
# 모듈
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
else: # 내림차순
if c_ns[minIdx] < c_ns[j]:
minIdx = j
c_ns[i], c_ns[minIdx] = c_ns[minIdx], c_ns[i]
print(f'nums : {c_ns}')
return c_ns
# 실행문
import random
import selectMod
if __name__ == '__main__':
nums = random.sample(range(1, 20), 10)
print(f'Not Sorted Nums :\n{nums}')
result = selectMod.sortSelectAlgorithm(nums)
print(f'Sorted Nums By ASC :\n{result}')
result = selectMod.sortSelectAlgorithm(nums, asc=False)
print(f'Sorted Nums By DESC :\n{result}')
8번 병합정렬 알고리즘
- 숫자로 이루어진 리스트를 병합정렬 알고리즘을 이용해서 오름차순과 내림차순으로 정렬하는 모듈을 만들어보자.
(단 정렬하는 과정도 출력하도록 한다.)
# 모듈
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)
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 += leftNums[leftIdx:]
mergeNums += rightNums[rightIdx:]
print(f'mergeNums : {mergeNums}')
return mergeNums
# 실행문
import random
import mergeAlgorithm
if __name__ == '__main__':
nums = random.sample(range(1, 101), 20)
print(f'Not Sorted Nums :\n{nums}')
result = mergeAlgorithm.mSort(nums)
print(f'Sorted Nums By ASC :\n{result}')
result = mergeAlgorithm.mSort(nums, asc=False)
print(f'Sorted Nums By DESC :\n{result}')
최댓값
9번 최댓값 알고리즘
- 최댓값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최댓값과 최댓값의 개수를 찾는 모듈을 만들어보자.(리스트는 1부터 50까지의 난수 30개를 이용하되, 중복이 허용되도록 한다.)
# 클래스
class MaxAlgorithm:
def __init__(self, ns):
self.nums = ns
self.maxNum = 0
self.maxNumCnt = 0
def setMaxNum(self): # 최대값을 설정하는 함수
self.maxNum
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 n 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()}')
최빈값
10번 최빈값 알고리즘
- 다음은 회차별 로또 번호이다. 최빈도 알고리즘을 이용해서 모든 회차의 각각의 번호에 대한 빈도수를 출력하는 프로그램을 만들어보자.
# 클래스
class LottoMode:
def __init__(self, ns):
self.lottoNums = ns
self.modeList = [0 for n in range(1, 47)]
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}')
# {i:>2} 왼쪽정렬인데 두자리로 출력하라는 뜻으로 사용
# 실행문
import random
import mod
lottoNums = []
for i in range(30):
lottoNums.append(list(random.sample(range(1,46),6)))
# print(f'lotto : {lottoNums}')
lm = mod.LottoMode(lottoNums)
mList = lm.getlottoNumMode()
# print(f'mList : {mList}')
lm.printModeList()
최솟값(2)
11번 최솟값 알고리즘
- 최솟값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최솟값과 최솟값의 개수를 찾는 모듈을 만들어보자.(리스트는 1부터 50까지의 난수 30개를 이용하되, 중복이 허용되도록 한다.)
# 클래스
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
# nums = [random.randint(1,50) for i in range(30)]
# print(nums) 조건문사용없이 만들어지게끔 작성해본 코드..
if __name__ == '__main__':
nums = []
for n in range(30):
nums.append(random.randint(1,50))
print(nums)
print(f'nums : {nums}')
ma = minMod.MinAlgorithm(nums)
print(f'min num : {ma.getMinNum()}')
print(f'min num count : {ma.getMinNumCnt()}')
재귀
12번 재귀 알고리즘
- 다음은 A상사의 2021년 월별 매출을 나타내는 표이다. 재귀 알고리즘을 이용해서 1월부터 12월까지 전월대비 매출 증갑액을 나타내는 프로그램을 만들어보자.
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)
nextSales = ss[0]
increase = nextSales - currentSales
if increase > 0:
increase = '+' + str(increase)
print(f'매출 증감액 : {increase}')
return SalesUpAndDown(ss)
if __name__ == '__main__':
SalesUpAndDown(sales)
최빈값(2)
13번 최빈값 알고리즘
- 다음은 어떤 회사의 전직원 나이를 나타내는 리스트이다. 최빈값 알고리즘을 이용해서 나이 분포를 간단한 그래프로 출력한는 모듈을 만들어보자.
# 최대값 구하기(최고 나이 구하기) 클래스
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
# 빈도수 구하기 클래스
import maxMod
class ModeAlgorithm:
def __init__(self, ns, mn):
self.nums = ns
self.maxNum = mn
self.indexes = []
def setIdexList(self):
self.indexes = [0 for i in range(self.maxNum+1)]
for n in self.nums:
self.indexes[n] = 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 = 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 총 3자리로 출력하되 왼쪽방향부터 0으로 채운다는 코드 ex: 001, 002, 003 형식으로
print('+' * maxNum)
self.indexes[maxNumIdx] = 0
n += 1
# 실행문
import random
import modeMod
import maxMod
ages = [random.randint(20,48) for i in range(40)]
# 똑같이 적어가며하기엔 시간이 오래걸려 난수를 이용하였다.
print(f'employee cnt : {len(ages)}명')
# maxNum(최대값 구하기)
maxAlo = maxMod.MaxAlgorithm(ages)
maxAlo.setMaxIdxAndNum()
maxAge = maxAlo.getMaxNum()
print(f'maxAge : {maxAge}세')
# modeMod
modAlo = modeMod.ModeAlgorithm(ages, maxAge)
modAlo.setIdexList()
print(f'IndexList : {modAlo.getIndexList()}')
modAlo.printAges()
순위(2)
14번 순위 알고리즘
- 알파벳 문자들과 정수들에 대한 순위를 정하는 프로그램을 순위 알고리즘을 이용해서 만들어보자. (단, 알파벳은 아스키코드 값을 이용한다.)
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:0>3} \t rank : {ranks[i]+1}')
근삿값
15번 근삿값 알고리즘
- 다음 표는 수심에 따른 수온을 나타내고 있다. 근사값 알고리즘을 이용해서 수심을 입력하면 수온을 출력하는 모듈을 만들어보자.
# 클래스
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]
# 실행문
import nearMod
depth = int(float(input('input depth : ')))
# 실수로 입력이될경우 에러가 발생하기에 정수형으로 변환하기전에
# 실수형으로 변환후 정수형으로 변환하면 에러를 방지할 수 있다.
# int( float( input(문자형으로 출력) 실수 변환) 정수 변환)
print(f'depth : {depth}m')
na = nearMod.NearAlgorithm(depth)
temp = na.getNearNumbers()
print(f'water temperature : {temp}도')
16번 근삿값 알고리즘(2)
- 사용자의 몸무게(kg)와 키(m)를 입력하면 체질량지수(BMI)를 계산하고, 근삿값 알고리즘과 BMI를 이용해서 신체 상태를 출력하는 프로그램을 만들어보자. (BMI : 몸무게 * 키^2)
# 클래스
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):
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:
self.userCondition = self.BMISection[self.nearNum][0]
else:
self.userCondition = self.BMISection[self.nearNum][1]
print(f'self.userCondition : {self.userCondition}')
# 실행문
import nearMod
uWeight = float(input('input weight(Kg) : '))
uHeight = float(input('input height(m) : '))
na = nearMod.BmiAlgorithm(uWeight, uHeight)
na.calculatorBMI()
na.printUserCondition()
재귀(2)
17번 재귀 알고리즘
- 사용자가 정수 두개를 입력하면 작은 정수와 큰 정수 사이의 모든 정수의 합을 구하는 프로그램을 재귀 알고리즘을 이용해서 만들어보자.
# 클래스
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, self.smallNum = n2, 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
num1 = int(input('input Number1 : '))
num2 = int(input('input Number2 : '))
ns = mod.NumsSum(num1, num2)
result = ns.sumBetweenNums()
print(f'result : {result}')
최댓값(2)
18번 최댓값 알고리즘
- 학급 전체 학생의 시험 점수에 대한 평균과 최댓값을 구하고 평균과 최댓값의 편차를 출력하는 프로그램을 최댓값 알고리즘을 이용해서 만들어보자.
# 모듈
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 random
import mod
scores = [random.randint(50, 100) for i in range(20)]
print(f'scores : {scores}')
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}')
평균
19번 평균 알고리즘
- 다음은 어떤 체조선수의 경기 점수이다. 최댓값과 최솟값을 제외한 나머지 점수에 대한 평균을 구하고 순위를 정하는 알고리즘을 만들어보자.
# 최댓값 클래스
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}')
# 최솟값 클래스
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}')
# 근솟값 클래스
class Top5Players:
def __init__(self, cts, ns):
# currentScores : 현재 선수들의 점수
# newScore : 새로운 선수의 점수
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 + 1] = self.newScore
def getFinalTop5Scores(self):
return self.currentScores
# 실행문
import maxAlgorithm
import minAlgorithm
import nearAlgorithm
top5Scores = [9.12, 8.95, 8.12, 6.9, 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}')
print(f'top5Scores : {top5Scores}')
print('-'*50)
maxA = maxAlgorithm.MaxAlgorithm(scores)
maxA.removeMaxScore()
print('-'*50)
minA = minAlgorithm.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()
top5PlayerScores = tp.getFinalTop5Scores()
print(f'new top5PlayerScores : {top5PlayerScores}') 
20번 평균 알고리즘(2)
- 다음은 홍길동 학생을 포함한 학급 전체 학생의 시험점수 평균을 나타낸 표이다. 표를 보고, 홍길동 학생을 제외한 나머지 학생의 평균과 홍길동 학생의 점수의 차이를 출력하는 프로그램을 만들어보자. (출력은 과목별 점수와 평균 점수를 모두 출력한다.)
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
# 19명분 합계점수를 구함
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
# 19명분 합계점수의 평균을 구함.
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
# 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 avg_gap > 0 else avg_gap}')
코딩공부중