하드러너 블레이크 (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))

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

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