하드러너 블레이크 (Hard-Learner Blake)

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

📍 약수, 소수, 소인수 찾아내기

import random

rNum = random.randint(100, 1000)
print(f'rNum: {rNum}')

for num in range(1, rNum+1):

    soinsuFlag = 0

    # 약수
    if rNum % num == 0:
        print(f'약수 : {num}')
        soinsuFlag += 1
    
    # 소수
    if num != 1:
        flag = True
        for n in range(2, num):
            if num % n == 0:
                flag = False
                break
        
        if flag:
            print(f'소수 : {num}')
            soinsuFlag += 1

    # 소인수
    if soinsuFlag == 2:
        print(f'소인수 : {num}')

지정한 숫자(rNum)를 나누었을 때 나머지가 0이면 약수

해당 숫자까지 2부터 나누었을 때 나머지가 0인 경우가 없으면 소수

약수이면서 소수인 수 => 소인수

📍 진수(진법) 변환

dNum = 23

# 10진수 -> 2, 8, 16진수

print(f'2진수 : {bin(dNum)}')
print(f'8진수 : {oct(dNum)}')
print(f'16진수 : {hex(dNum)}')

print(format(dNum, 'b')) # 2진수 숫자만
print(format(dNum, 'o')) # 8진수 숫자만
print(format(dNum, 'x')) # 16진수 숫자(문자)만

# x진수 -> 10진수
print(int('10111', 2))
print(int('27', 8))
print(int('27', 16))

# X진수 -> X진수
print('2진수(0b10101) -> 8진수({})'.format(oct(0b10101)))
print('2진수(0b10101) -> 10진수({})'.format(int(0b10101)))
print('2진수(0b10101) -> 16진수({})'.format(hex(0b10101)))

2진수 등으로 바꾸면 '0b'와 같이 앞에 필요없는 문자가 붙게 된다.

format(dNum, 'b') 와 같이 사용하는게 가장 필요한 기능 일 듯 하다.

📍 등차수열, 등비수열, 계차수열

# 등차수열

inputA1 = 1 # 초항
inputD = 2 # 공차
inputN = 9 # n

# 등차 수열(일반항) 공식: an = a1 + (n-1) * d
valueN = inputA1 + (inputN-1) * inputD
print('{}번째 항의 값: {}'.format(inputN, valueN))

# 등차 수열(합) 공식: sn = n(a1 + an) / 2
sumN = inputN * (inputA1 + valueN) / 2
print('{}번째 항까지의 합: {}'.format(inputN, int(sumN)))

# 등비수열

inputA1 = 1 # 초항
inputR = 2 # 공비
inputN = 9 # n

# 등비 수열(일반항) 공식: an = a1 * r^(n-1)
valueN = inputA1 * (inputR ** (inputN-1))
print('{}번째 항의 값: {}'.format(inputN, valueN))

# 등비 수열(합) 공식: sn = a1 * (1 - r^n) / (1-r)
sumN = inputA1 * (1 - (inputR ** inputN)) / (1 - inputR)
print('{}번째 항까지의 합: {}'.format(inputN, int(sumN)))

# 계차수열

#{2, 5, 11, 20, 32, 47, 65, 86, 110, 137, 167, …}

# bn : 계차 항

# an - a1 = (b1 부터 bn-1 까지 합)

# (3n^2 - 3n + 4)/2 = an

inputA1 = int(input('a1 입력: '))
inputN = int(input('an 입력: '))

valueAN = ((3 * inputN ** 2) - (3 * inputN) + 4) / 2
print('an의 {}번째 항의 값: {}'.format(inputN, int(valueAN)))

일반항 공식만 알고 있다면 그대로 대입하면 된다.

일반항 공식을 모르더라도 for문을 통해 쉽게 해결할 수 있지만, 시간복잡도 측면에서 좋지않다.

# 피보나치

# 1, 1, 2, 3, 5, 8 ...

def fibo(n):
    if n in (1, 2):
        return 1
    
    else:
        return fibo(n-1) + fibo(n-2)


fibo(6)

피보나치 수열을 이전 두 행을 더해서 다음 행의 값이 되는 수열이다.

패턴이 있기 때문에 재귀함수를 호출해서 사용할 수도 있고, for 문을 통해 해결할 수도 있다.

재귀함수의 활용 사례를 보여주는 대표적인 수열이다.

📍 순열, 조합

# 순열 
# 9P4

# 9 * 8 * 7 * 6 

numN = 9
numR = 4
result = 1

for n in range(numN, (numN-numR), -1):
    print('n : {}'.format(n))
    result *= n

print('result: {}'.format(result))

# 조합
#9c4

# 9 * 8 * 7 * 6 / 4 * 3 * 2 * 1

numN = 9
numR = 4
resultP = 1
resultR = 1
resultC = 1

for n in range(numN, (numN-numR), -1):
    print('n : {}'.format(n))
    resultP = resultP * n

print('resultP: {}'.format(resultP))

for n in range(numR, 0, -1):
    print('n : {}'.format(n))
    resultR = resultR * n

resultC = int(resultP / resultR)
print('resultC: {}'.format(resultC))

순열의 계산 공식을 알고 있다면 그대로 대입만 하면 된다. 

조합은 순열을 계산한 후 팩토리얼로 나눠주기만 하면 된다.

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

📍 한/영 사전 프로그래밍

from abc import ABCMeta
from abc import abstractmethod

class AbsDictionary(metaclass=ABCMeta):
    
    def __init__(self):
        self.wordDict = {}
    
    @abstractmethod
    def registWord(self, w1, w2):
        pass
    
    @abstractmethod
    def removeWord(self, w1):
        pass

    @abstractmethod
    def updateWord(self, w1, w2):
        pass

    @abstractmethod
    def searchWord(self, w1):
        pass

먼저 한/영, 영/한 등 사전을 만드는 상위 클래스를 만들어주고, 추상클래스로 구현하여 구체적인 하위 클래스 사전에서 메소드를 만들도록 강제한다.

class KorToEng(AbsDictionary): # 상위 클래스 상속받기

    def __init__(self):
        super().__init__()

    def registWord(self, w1, w2):
        print(f'단어 등록 / {w1} : {w2} ')
        self.wordDict[w1] = w2

    def removeWord(self, w1):
        print(f'단어 제거 / {w1}')
        del self.wordDict[w1]

    def updateWord(self, w1, w2):
        print(f'단어 변경 / {w1} : {w2} ')
        self.wordDict[w1] = w2

    def searchWord(self, w1):
        print(f'단어 검색 / {w1} : {self.wordDict[w1]}')

    
    def printWord(self):
        for i in self.wordDict:
            print(f'{i} -> {self.wordDict[i]}')

상위 추상클래스를 상속 받아 구체적으로 메소드를 구현한다.

import ADictionary as ad # 다른 실행 파일에서 위의 클래스가 저장된 Adictionary.py를 불러온다

kte = ad.KorToEng()

kte.registWord('책', 'bok')
kte.registWord('나비', 'butterfly')
kte.registWord('연필', 'pencil')
kte.registWord('학생', 'studen')
kte.registWord('선생님', 'teacher')

kte.printWord()

kte.updateWord('책', 'book')
kte.searchWord('책')

kte.removeWord('책')

kte.printWord()

이와 같은 방식으로 한영 사전 KorToEng() 클래스를 불러와 kte 인스턴스를 선언한다.

KorToEng 클래스에 구현해 놓은 메소드들을 이용할 수 있게 된다.

📍 소수 판별기 프로그래밍

class NotPrimeException(Exception):
    
    def __init__(self, n):
        super().__init__(f'{n} is not a prime number')

class PrimeException(Exception):

    def __init__(self, n):
        super().__init__(f'{n} is a prime number')

NotPrimeException : 소수가 아니라고 표현하는 (exception 발생시키는 X) 클래스 정의

PrimeException : 소수라고 표현하는 (exception 발생시키는 X) 클래스 정의

def isPrime(number):
    flag = True
    for i in range(2, number):
        if number % i == 0:
            flag = False
            break
    

    if flag == True:
        raise PrimeException(number)
    else:
        raise NotPrimeException(number)

isPrime 함수 : 숫자가 소수인지 판별하고, 맞다면 PrimeException을, 아니라면 NotPrimeException을 발생(raise)시키는 기능

import Primecheck as pc
import random


prime_nums = []

n = 0
while n < 10:
    rn = random.randint(2, 1000)
    
    if rn not in prime_nums:
        try:
            pc.isPrime(rn)
        
        except pc.PrimeException as e:
            print(e)
            prime_nums.append(rn)
        
        except pc.NotPrimeException as e:
            print(e)
            continue

    else:
        print(f'{rn} is already in')
        continue

    n += 1

print(prime_nums)

소수를 확인하는 primecheck.py를 불러오기

2 ~ 1000 의 난수가 소수면 PrimeException이 발생하고 리스트에 추가, 소수가 아니면 NotPrimeException이 발생하고 다시 iter를 실행하는 반복문 작성

📍 상품 총 구매금액 계산하기 프로그래밍

g1price = 1200; g2price = 1000; g3price = 800
g4price = 2000; g5price = 900

def calculate(*gcs):

    gcsDic = {}
    againCntInput = {}

    for idx, gc in enumerate(gcs):
        try:
            gcsDic[f'g{idx+1}'] = int(gc)
        
        except Exception as e:
            againCntInput[f'g{idx+1}'] = gc
            print(e)
    
    totalPrice = 0
    for g in gcsDic:
        totalPrice += globals()[f'{g}price'] * gcsDic[g]
    totalPrice = format(totalPrice, ',')

    print(f'총 구매금액 : {totalPrice}원')

    print(f'미결제 항목')
    for g in againCntInput:
        print(f'상품: {g}, 구매 개수: {againCntInput[g]}')

상품금액 x 구매 개수로 총 구매금액을 구하는데, 개수로 숫자가 아닌 값이 입력되면 예외처리

* globals() : 변수 = 값으로 선언된 모든 것을 딕셔너리로 반환해주는 함수

import goods as gd

g1Cnt = input('goods1 구매 개수: ')
g2Cnt = input('goods2 구매 개수: ')
g3Cnt = input('goods3 구매 개수: ')
g4Cnt = input('goods4 구매 개수: ')
g5Cnt = input('goods5 구매 개수: ')

gd.calculate(g1Cnt, g2Cnt, g3Cnt, g4Cnt, g5Cnt)