👀 다시보기

선형검색

n = 0
while True:
    if n == len(ns):
        print('search Fail!!')
        break

    if ns[n] == sn:
        searchResultIdx = n
        print('search Success!')
        print(f'searchResultIdx : {searchResultIdx}')
        break

• 추가 (보초법)

def serachBinary(ns,sn):
    searchIdx = -1
    ns.append(sn)

    n = 0
    while True:
        if ns[n] == sn:
            if n != len(ns)-1:
                searchIdx = n
            break

        n += 1

    return searchIdx

---

이진검색 while문 조건부

while sn >= ns[0] and sn <= ns[len(ns)-1]:

시작 인덱스와 끝 인덱스가 같을지 무한루프 방지

    if starIdx + 1 == endIdx:
        if ns[starIdx] != sn and ns[endIdx] != sn:break

---

순위를 정하고 순위별로 sort

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}')

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

    sortedNums = [0 for n in range(len(ns))]

    for idx, rank in enumerate(ranks):
        sortedNums[rank] = ns[idx]

    return sortedNums

순위에 맞게 ns의 값을 보내는 것...!
for idx, rank in enumerate(ranks):
sortedNums[rank] = ns[idx]

---

버블정렬 (기본)

for i in range(length):
   for j in range(length-i):
        if cns[j] > cns[j+1]:
            cns[j],cns[j+1] = cns[j+1],cns[j]

---

삽입정렬 (기본)

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

    while c_ns[i2] > cNum and i2 >= 0:
        c_ns[i2+1] = c_ns[i2]
        i2 -= 1
    c_ns[i2+1] = cNum

---

선택 정렬 (기본)

for i in range(len(c_ns)-1):
    minIdx = i
    for j in range(i+1,len(c_ns)):
        if c_ns[minIdx] > c_ns[j]:
            minIdx = j

    c_ns[i],c_ns[minIdx] = c_ns[minIdx],c_ns[i]

---

병합정렬 (기본)

    if len(cns) < 2:
        return cns

    midIdx = cns(ns) // 2
    leftNums = sort(cns[0:midIdx])
    rightNums = sort(cns[midIdx:])

    mergedNums = []
    leftIdx = 0; rightIdx = 0
    while leftIdx < len(leftNums) and rightIdx < len(rightNums):
        if leftNums[leftIdx] < rightNums[rightIdx]:
            mergedNums.append(leftNums[leftIdx])
            leftIdx += 1

        else:
            mergedNums.append(rightNums[rightIdx])
            rightIdx += 1

    mergedNums = mergedNums + leftNums[leftIdx:]
    mergedNums = mergedNums + rightNums[rightIdx:]

    return mergedNums

재귀이기에 if 조건!
while문 조건부...!
while leftIdx < len(leftNums) and rightIdx < len(rightNums):

재귀의 논리값은 asc=asc ★

---

최대값에서 빈도수 추가

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:
                self.maxNumCnt += 1

    def getMaxNumCnt(self):
        self.setMaxNumCnt()
        return self.maxNumCnt

---

중복 허용 난수

    for n in range(30):
        nums.append(random.randint(1,50))

---

가뿐히 끝낸 최대값 편차구하기.

def getDeviation(n1,n2):
    return abs(n1-n2)

---

최대,최소값 한번에 거르는 함수

def getMaxNin(ns,maxFlag=True):
    result = ns[0]

    for n in ns:
        if maxFlag:
            if result < n:
                result = n
        else:
            if result > n:
                result = n

    return result

인수도 다르게 넣어야함
최대값이다 getMaxNin(scores) or getMaxNin(scores,maxFlag=True)
최소값이다 getMaxNin(scores,maxFlag=False)

---

총합, 평균, 편차, 최대값, 최소값 한번에 끝내기

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 getTotalScore(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.score_tot / len(self.scores),2)
        return self.score_avg

    def getMaxDeviation(self):
        result = abs(self.getAvgScore() - self.score_max)

        return round(result,2)

    def getMixDeviation(self):
        result = abs(self.getAvgScore() - self.score_min)

        return round(result,2)

변형해야하는 인수가 없어 초기화가 안되었을 경우

    if self.scores == None or len(self.scores) == 0:
        return None

---

최빈값

def printAges(self):
    n = 1
    while True:
        maxAlo = maxMod3.MaxAlgorithm(self.idexes)
        maxAlo.setMaxIdxAndNum()
        maxNum = maxAlo.getMaxNum()
        maxNumIdx = maxAlo.getMaxIdx()

        if maxNum == 0:
 	          break

       print(f'{n:0>3} {maxNumIdx}세 빈도수 : {maxNum}\t', end='')
       print('*'*maxNum)
       self.idexes[maxNumIdx] = 0

	   n += 1

가장 최대값을 비워줘서 그 다음 순서 오게끔 만드는 코드...★
활용도가 좋을거같다.

n:0>3
출력 숫자 셋팅

💬 코멘트

늘 흥미롭지만 힘든 문제풀이의 날!
그래도 개념을 위해 좀 반복한 부분이 있어서 다른 때보다는 수월했지만..
그래도 어려운건 사실이여서 강의도 듣고 중간에 팀스터디도 하다보니 체력소진이 좀 되어 일부분 못들었다. 코딩테스트 앞두고...긴장감도 더해져 전략상 2강은 내일로 미루고
오늘 학습한 코딩 다시 필사의 길로