📌 자료구조 연습문제 [최대_최소]
📋 최댓값 알고리즘
- 1최댓값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최댓값과 최댓값의 개수를 찾는 모듈
- 리스트는 1부터 50까지의 난수 30개를 이용하되, 중복 허용
# 최댓값
# 최댓값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최댓값과 최댓값의 개수를 찾는 모듈
# 리스트는 1부터 50까지의 난수 30개를 이용하되, 중복 허용
import random
def maxValue(nums):
valueCnt = [0 for i in range(50)]
maxIdx = 0
for idx, num in enumerate(nums):
valueCnt[num - 1] += 1
if nums[idx] > nums[maxIdx]:
maxIdx = idx
print(f'max num \t: {nums[maxIdx]}')
print(f'max num cnt : {valueCnt[nums[maxIdx] - 1]}')
nums = random.choices(range(1, 51), k=30)
print(f'nums \t\t: {nums}')
maxValue(nums)
nums : [28, 35, 48, 41, 9, 7, 41, 3, 38, 10, 50, 32, 22, 42, 43, 12, 13, 48, 1, 47, 46, 10, 11, 41, 18, 27, 31, 20, 2, 34]
max num : 50
max num cnt : 1
📋 최댓값 알고리즘
- 학급 전체 학생의 시험 점수에 대한 평균과 최댓값을 구하고 평균과 최댓값의 편차를 출려하는 프로그램
# 최댓값 알고리즘
# 학급 전체 학생의 시험 점수에 대한 평균과 최댓값을 구하고 평균과 최댓값의 편차를 출려하는 프로그램
def scoreAlgorithm(scores):
total = 0
avg = 0
deviation = 0
max = scores[0]
for score in scores:
total += score
if max < score:
max = score
avg = round(total / len(scores), 2)
deviation = round(abs(max - avg), 2)
print(f'scores \t\t: {scores}')
print(f'average\t\t: {avg}')
print(f'max \t\t: {max}')
print(f'max-average : {deviation}')
scores = [100, 64, 94, 66, 75, 58, 99, 76, 96, 74, 54, 73, 88, 70, 68, 50, 95, 89, 69, 98]
scoreAlgorithm(scores)
scores : [100, 64, 94, 66, 75, 58, 99, 76, 96, 74, 54, 73, 88, 70, 68, 50, 95, 89, 69, 98]
average : 77.8
max : 100
max-average : 22.2📋 최솟값 알고리즘
- 최솟값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최솟값과 최솟값의 개수를 찾는 모듈
- 리스트는 1부터 50까지의 난수 30개를 이용하되, 중복 허용
# 최솟값 알고리즘
# 최솟값 알고리즘을 이용해서 숫자로 이루어진 리스트에서 최솟값과 최솟값의 개수를 찾는 모듈
# 리스트는 1부터 50까지의 난수 30개를 이용하되, 중복 허용
import random
class minAlgorithm:
def __init__(self, nums):
self.nums = nums
self.min = nums[0]
self.max = nums[0]
def setMinValue(self):
for n in self.nums:
if self.min > n:
self.min = n
def getMinValue(self):
self.setMinValue()
return self.min
def setMaxValue(self):
for n in self.nums:
if self.max < n:
self.max = n
def getMaxValue(self):
self.setMaxValue()
return self.max
def getMinCnt(self):
max = self.getMaxValue()
cntValues = [0 for i in range(max + 1)]
for num in self.nums:
cntValues[num] += 1
return cntValues[self.min]
nums = random.choices(range(1, 51), k=30)
minAl = minAlgorithm(nums)
print(f'nums \t\t: {nums} ')
print(f'min num \t: {minAl.getMinValue()}')
print(f'min num cnt : {minAl.getMinCnt()}')
nums : [28, 36, 9, 45, 40, 45, 4, 13, 37, 38, 39, 41, 38, 19, 42, 39, 25, 17, 5, 27, 12, 15, 23, 7, 48, 2, 39, 39, 41, 50]
min num : 2
min num cnt : 1📌 자료구조 연습문제 [근삿값_최빈값]
📋 최빈값 알고리즘
- 최빈값 알고리즘을 이용해서 나이분포를 간단한 그래프로 출력하는 모듈을 만들어보자
# 최빈값
# 다음은 어떤 회사의 전 직원의 나이를 나타내는 리스트이다.
# 최빈값 알고리즘을 이용해서 나이분포를 간단한 그래프로 출력하는 모듈을 만들어보자
import random
class frequencyAlgo:
def __init__(self, ages):
self.ages = ages
self.max = ages[0]
self.cntList = []
def setMaxValue(self):
for n in self.ages:
if self.max < n:
self.max = n
def getMaxValue(self):
self.setMaxValue()
return self.max
def setFrequencyList(self):
self.cntList = [0 for i in range(self.getMaxValue())]
for age in self.ages:
self.cntList[age - 1] += 1
def getFrequencyList(self):
self.setFrequencyList()
return self.cntList
def setFrequencySort(self):
for i in range(len(self.cntList)):
maxidx = i
for j in range(i + 2, len(self.cntList)):
if self.cntList[maxidx] < self.cntList[j]:
maxidx = j
if self.cntList[maxidx] != 0:
# strNum = str(100 + i)
# strNum = strNum.replace('1', '0', 1)
print(f'[{i + 1:0>3}] {maxidx}세의 빈도수 : {self.cntList[maxidx]} {"+" * self.cntList[maxidx]}')
self.cntList[maxidx] = 0
ages = random.choices(range(25, 51), k=40)
fre = frequencyAlgo(ages)
print(f'employee cnt : {len(ages)}')
print(f'maxAge \t\t: {fre.getMaxValue()}')
print(f'idxList \t: {fre.getFrequencyList()}')
fre.setFrequencySort()
employee cnt : 40
maxAge : 50
idxList : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 3, 3, 2, 1, 4, 1, 1, 2, 1, 1, 0, 1, 1, 2, 1, 3, 2, 3, 0, 1, 2]
[001] 33세의 빈도수 : 4 ++++
[002] 29세의 빈도수 : 3 +++
[003] 30세의 빈도수 : 3 +++
[004] 44세의 빈도수 : 3 +++
[005] 46세의 빈도수 : 3 +++
[006] 31세의 빈도수 : 2 ++
[007] 36세의 빈도수 : 2 ++
[008] 42세의 빈도수 : 2 ++
[009] 45세의 빈도수 : 2 ++
[010] 49세의 빈도수 : 2 ++
[011] 24세의 빈도수 : 1 +
[012] 25세의 빈도수 : 1 +
[013] 26세의 빈도수 : 1 +
[014] 27세의 빈도수 : 1 +
[015] 28세의 빈도수 : 1 +
[016] 32세의 빈도수 : 1 +
[017] 34세의 빈도수 : 1 +
[018] 35세의 빈도수 : 1 +
[019] 37세의 빈도수 : 1 +
[020] 38세의 빈도수 : 1 +
[021] 40세의 빈도수 : 1 +
[022] 41세의 빈도수 : 1 +
[023] 43세의 빈도수 : 1 +
[024] 48세의 빈도수 : 1 +📋 최빈값 알고리즘
- 최빈도 알고리즘을 이용해서 모든 회차의 각각의 번호에 대한 빈도수를 출력하는 프로그램
# 최빈값
# 다음은 횢차별 로또 번호이다.
# 최빈도 알고리즘을 이용해서 모든 회차의 각각의 번호에 대한 빈도수를 출력하는 프로그램
import random
class LottoAlgo:
def __init__(self, lottos):
self.lottos = lottos
self.cntList = []
self.max = 0
def setMaxVal(self):
for i in range(len(self.lottos)):
for j in self.lottos[i]:
if j > self.max:
self.max = j
def getMaxVal(self):
self.setMaxVal()
return self.max
def setCntList(self):
self.cntList = [0 for n in range(self.getMaxVal())]
for i in range(len(self.lottos)):
for n in self.lottos[i]:
self.cntList[n - 1] += 1
def printLottos(self):
self.setCntList()
for idx, n in enumerate(self.cntList):
if self.cntList[idx] != 0:
print(f'번호:\t{idx + 1:>2}, 빈도:\t{self.cntList[idx]} {"*" * self.cntList[idx]}')
lottoNums = []
for i in range(30):
lottoNums.append(random.sample(range(1, 51), 6))
la = LottoAlgo(lottoNums)
la.printLottos()
번호: 1, 빈도: 3 ***
번호: 2, 빈도: 5 *****
번호: 3, 빈도: 4 ****
번호: 4, 빈도: 5 *****
번호: 5, 빈도: 6 ******
번호: 6, 빈도: 4 ****
번호: 7, 빈도: 3 ***
번호: 8, 빈도: 1 *
번호: 9, 빈도: 3 ***
번호: 10, 빈도: 5 *****
번호: 11, 빈도: 4 ****
번호: 12, 빈도: 4 ****
번호: 13, 빈도: 4 ****
번호: 14, 빈도: 4 ****
번호: 15, 빈도: 4 ****
번호: 16, 빈도: 4 ****
번호: 17, 빈도: 4 ****
번호: 18, 빈도: 3 ***
번호: 19, 빈도: 3 ***
번호: 20, 빈도: 3 ***
번호: 21, 빈도: 1 *
번호: 22, 빈도: 4 ****
번호: 23, 빈도: 1 *
번호: 24, 빈도: 4 ****
번호: 25, 빈도: 3 ***
번호: 26, 빈도: 5 *****
번호: 27, 빈도: 4 ****
번호: 28, 빈도: 3 ***
번호: 29, 빈도: 2 **
번호: 30, 빈도: 4 ****
번호: 31, 빈도: 2 **
번호: 32, 빈도: 2 **
번호: 33, 빈도: 2 **
번호: 34, 빈도: 4 ****
번호: 35, 빈도: 6 ******
번호: 36, 빈도: 2 **
번호: 37, 빈도: 3 ***
번호: 38, 빈도: 3 ***
번호: 39, 빈도: 4 ****
번호: 40, 빈도: 3 ***
번호: 41, 빈도: 1 *
번호: 42, 빈도: 2 **
번호: 43, 빈도: 2 **
번호: 44, 빈도: 5 *****
번호: 45, 빈도: 5 *****
번호: 46, 빈도: 3 ***
번호: 47, 빈도: 6 ******
번호: 48, 빈도: 5 *****
번호: 49, 빈도: 6 ******
번호: 50, 빈도: 7 *******
📋 근삿값 알고리즘
- 근삿값 알고리즘을 이용해서 수심을 입력하면 수온을 출력하는 모듈 작성
# 근삿값
# 근삿값 알고리즘을 이용해서 수심을 입력하면 수온을 출력하는 모듈 작성
def getWaterTemp(depth, depthList):
nearVal = abs(depthList[0] - depth)
tempIdx = 0
for idx, d in enumerate(depthList):
if nearVal > abs(d - depth):
nearVal = abs(d - depth)
tempIdx = idx
return tempIdx
depthList = [0, 5, 10, 15, 20, 25, 30]
tempList = [24, 22, 20, 16, 13, 10, 6]
depth = int(input('input depth : '))
print(f'depth : {depth}m')
temper = tempList[getWaterTemp(depth, depthList)]
print(f'water temperature : {temper}도')
input depth : 18
depth : 18m
water temperature : 13도📋 근삿값 알고리즘
- 사용자의 몸무게와 키를 입력하면 체질량지수를 계산하는 프로그램
# 사용자의 몸무게와 키를 입력하면 체질량지수를 계산하는 프로그램
# BMI표를 이용해서 신체 상태를 출력하는 프로그램
# BMI 체중 % (키*키)
def getBMI(myBmi):
bmiList = [18.5, 23, 25]
nearVal = abs(bmiList[0] - myBmi)
nearBMI = bmiList[0]
for bmi in bmiList:
if nearVal > abs(bmi - myBmi):
nearVal = abs(bmi - myBmi)
nearBMI = bmi
return nearBMI
weight = float(input('input weight(kg) : '))
height = float(input('input height(m) : '))
myBmi = round(weight / (height ** 2), 2)
print(f'userBMI : {myBmi}')
nearBmi = getBMI(myBmi)
result = ''
print(f'nearNum : {nearBmi}')
if nearBmi > 25:
result = '비만'
elif nearBmi > 23:
result = '저체중'
elif nearBmi > 18.5:
result = '정상'
else:
result = '저체중'
print(f'user condition : {result}')
input weight(kg) : 45
input height(m) : 1.65
userBMI : 16.53
nearNum : 18.5
user condition : 저체중
📌 자료구조 연습문제 [재귀,평균]
📋 재귀 알고리즘
- 전월대비 매출 증감액
# 재귀
# 전월대비 매출 증감액
def salesGap(sales: list):
if len(sales) < 2:
return
gab = sales[1] - sales[0]
print(f'sales : {sales}')
if gab > 0:
print(f'매출 증감액 : +{gab}')
else:
print(f'매출 증감액 : {gab}')
sales.pop(0)
return salesGap(sales)
sales = [12000, 13000, 12500, 11000, 10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]
salesGap(sales)
sales : [12000, 13000, 12500, 11000, 10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]
매출 증감액 : +1000
sales : [13000, 12500, 11000, 10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]
매출 증감액 : -500
sales : [12500, 11000, 10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]
매출 증감액 : -1500
sales : [11000, 10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]
매출 증감액 : -500
sales : [10500, 98000, 91000, 91500, 10500, 11500, 12000, 12500]
매출 증감액 : +87500
sales : [98000, 91000, 91500, 10500, 11500, 12000, 12500]
매출 증감액 : -7000
sales : [91000, 91500, 10500, 11500, 12000, 12500]
매출 증감액 : +500
sales : [91500, 10500, 11500, 12000, 12500]
매출 증감액 : -81000
sales : [10500, 11500, 12000, 12500]
매출 증감액 : +1000
sales : [11500, 12000, 12500]
매출 증감액 : +500
sales : [12000, 12500]
매출 증감액 : +500
📋 재귀
- 정수 두개를 입력하면 작은 정수와 큰 정수 사이의 모든 정수의 합 구하기
# 재귀
# 정수 두개를 입력하면 작은 정수와 큰 정수 사이의 모든 정수의 합 구하기
def sumBetween(n1, n2):
n1 += 1
n2 -= 1
sumVal = n1 + n2
if n2 < n1:
return 0
elif n2 == n1:
return n1
else:
sumVal += sumBetween(n1, n2)
return sumVal
print(sumBetween(1, 10))
44
📋 평균 알고리즘
- 체조선수의 경기 점수에서 최댓값과 최솟값을 제외한 나머지 평균 구하고 순위를 정하는 알고리즘
# 평균 알고리즘
# 체조선수의 경기 점수에서 최댓값과 최솟값을 제외한 나머지 평균 구하고 순위를 정하는 알고리즘
import copy
def getAverage(scores):
sum = 0
for i in scores:
sum += i
sum -= getMax(scores) + getMin(scores)
return round(sum / (len(scores) - 2), 2)
def getMax(scores):
max = scores[0]
for score in scores:
if max < score:
max = score
return max
def getMin(scores):
min = scores[0]
for score in scores:
if min > score:
min = score
return min
def getRank(scores: list):
ranks = copy.copy(scores)
ranks.append(getAverage(ranks))
maxIdx = 0
for i in range(len(ranks)):
for j in range(i, len(ranks)):
if ranks[maxIdx] < ranks[j]:
maxIdx = j
ranks[i], ranks[maxIdx] = ranks[maxIdx], ranks[i]
return ranks
scores = [6.7, 5.9, 8.1, 7.9, 6.7, 7.3, 7.2, 8.2, 6.2, 5.8]
ranks = getRank(scores)
# print(scores)
# print(ranks)
for idx, score in enumerate(ranks):
print(f'{idx + 1}위 -> {score}')
1위 -> 8.2
2위 -> 8.1
3위 -> 7.9
4위 -> 7.3
5위 -> 7.2
6위 -> 7.0
7위 -> 5.8
8위 -> 6.7
9위 -> 6.7
10위 -> 6.2
11위 -> 5.9📋 평균 알고리즘
- 홍길동 학생을 포함한 학급 전체 학생의 시험 점수 평균을 나타낸 표이다.
- 표를 보고, 홍길동 학생을 제외한 나머지 학생의 평균과 홍길동 학생의 점수의 차이를 출력하는 프로그램
# 평균
# 홍길동 학생을 포함한 학급 전체 학생의 시험 점수 평균을 나타낸 표이다.
# 표를 보고, 홍길동 학생을 제외한 나머지 학생의 평균과 홍길동 학생의 점수의 차이를 출력하는 프로그램
def othersAverage(studentScores, myScores):
totalSum = studentScores * 20
totalSum -= myScores
return round(totalSum / 19, 2)
def getDiffer(n1, n2):
differ = round(n1 - n2, 2)
if differ <= 0:
return str(differ)
else:
return '+' + str(differ)
def printDiffer(studentScores, myscores):
othersAvg = {}
differs = {}
for key in studentScores.keys():
othersAvg[key] = othersAverage(studentScores[key], myscores[key])
for key in othersAvg:
differs[key] = getDiffer(myscores[key], othersAvg[key])
for key in differs:
if key == 'kor':
print(f'국어 점수 차이 : {differs[key]}')
elif key == 'eng':
print(f'영어 점수 차이 : {differs[key]}')
elif key == 'mat':
print(f'수학 점수 차이 : {differs[key]}')
elif key == 'sci':
print(f'과학 점수 차이 : {differs[key]}')
elif key == 'his':
print(f'국사 점수 차이 : {differs[key]}')
myScores = {'kor': 85, 'eng': 90, 'mat': 82, 'sci': 88, 'his': 100}
allStudentScores = {'kor': 88, 'eng': 82, 'mat': 90, 'sci': 78, 'his': 92}
# allStudentScores = [88, 82, 90, 78, 92]
studentAverage = 86
printDiffer(allStudentScores, myScores)
국어 점수 차이 : -3.16
영어 점수 차이 : +8.42
수학 점수 차이 : -8.42
과학 점수 차이 : +10.53
국사 점수 차이 : +8.42
개발하고싶은사람