[Python 기초] 03 기초 수학

홍랑·2021년 10월 12일
0

Python

목록 보기
3/6
*using Python - PyCharm Community Edition

📌 기초 수학

코딩 테스트에도 기본이 되는 기초 수학을 파이썬으로 해결해보자.

📚 약수

  • 어떤 수를 나누어 떨어지게 하는 수
# 반복문을 통해 나머지가 0인 수 찾아 출력
inputN = int(input('0보다 큰 정수 입력: '))

for number in range(1, inputN + 1):
    if inputN % number == 0:
        print('{}의 약수 : {}'.format(inputN, number))

📚 소수

  • 1과 자신만을 약수로 가지는 수
  • 1 제외
# 반복문과 변수 flag를 통해 입력 정수까지 소수, 합성수 판별
inputN = int(input('0보다 큰 정수 입력: '))

for number in range(2, inputN + 1):
    flag = True

    for n in range(2, number):
        if number % n == 0:
            flag = False
            break

    if flag:
        print('{} : 소수!'.format(number))
    else:
        print('{} : 합성수!'.format(number))

📚 소인수

  • 약수(인수) 중에서 소수인 숫자
  • 소인수분해: 1보다 큰 정수를 소인수의 곱으로 나타낸 것
inputN = int(input('1보다 큰 정수 입력: '))

n = 2
while n <= inputN:
    if inputN % n == 0:
        print('소인수 : {}'.format(n))
        inputN /= n			# 한 번 소인수분해 하고 그 수를 다시 분해하는 과정
    else:
        n += 1
        
n = 2
searchN = []
while n <= inputN:
    if inputN % n == 0:
        print('소인수 : {}'.format(n))
        if searchN.count(n) == 0: 	# 해당 변수랑 같은 값 몇 개인지 반환
            searchN.append(n)
        elif searchN.count(n) == 1:
            searchN.remove(n)
        inputN /= n
    else:
        n += 1

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

📚 최대공약수

  • 공약수: 두 개 이상의 수에서 공통된 약수
    - 최대공약수: 공약수 중 가장 큰 수
  • 소인수분해를 이용해 구할 수 있음
for i in range(1, (num1+ num2)):
    if num1 % i == 0 and num2 % i == 0:
        print('공약수: {}'.format(i))
        maxNum = i

print('최대공약수: {}'.format(maxNum))

유클리드 호제법

while temp2 > 0:
    temp = temp2
    temp2 = temp1 % temp2
    temp1 = temp

print('{}, {}의 최대공약수: {}'.format(num1, num2, temp1))

for n in range(1, (temp1 + 1)):
    if temp1 % n == 0:
        print('{}, {}의 공약수: {}'.format(num1, num2, n))

📚 최대공배수

  • 공약수: 두 개 이상의 수에서 공통된 배수
    - 최소공배수: 공배수 중 가장 작은 수
for i in range(1, (num1 + 1)):
    if num1 % i == 0 and num2 % i == 0:
        print('공약수: {}'.format(i))
        maxNum = i

print('최대공약수: {}'.format(maxNum))

minNum = (num1 * num2) // maxNum
print('최소공배수: {}'.format(minNum))

📚 진법

  • 특정 숫자 몇 개를 사용하여 수를 표현하는 방법

10진수 >> x진수

  • binary: bin()
  • octal: oct()
  • Hexadecimal: hex()
print('2진수: {}'.format(bin(num)))
print('8진수: {}'.format(oct(num)))
print('16진수: {}'.format(hex(num)))

print('2진수: {}'.format(format(num, '#b')))
print('8진수: {}'.format(format(num, '#o')))
print('16진수: {}'.format(format(num, '#x')))

x진수 >> 10진수

print('2진수(0b11110) -> 10진수({})'.format(int('0b11110', 2)))
print('8진수(0o36) -> 10진수({})'.format(int('0o36', 8)))
print('16진수(0x1e) -> 10진수({})'.format(int('0x1e', 16)))

📚 수열

  • 규칙성을 가지고 나열되어 있는 수들

등차수열: 연속된 두 항의 차이가 일정한 수열

  • 등차 중항: (an-1 + an+1) / 2 = an
num1 = int(input('a1 입력: '))
numD = int(input('공차 입력: '))
numN = int(input('n 입력: '))

# 특정 항의 값 구하기
# 등차 수열(일반항) 공식: an = a1 + (n-1) * d
valueN = num1 + (numN-1) * numD
print('{}번째 항의 값: {}'.format(numN, valueN))

# 공식 사용하지 않는 경우
valueN = 0
n = 1
while n <= numN:

    if n == 1:
        valueN = num1
        print('{}번째 행의 값: {}'.format(n, valueN))
        n += 1
        continue

    valueN += numD
    print('{}번째 행의 값: {}'.format(n, valueN))
    n += 1

# n번째 항까지의 합 구하기
# 등차 수열(합) 공식: sn = n(a1 + an) / 2
valueN = num1 + (numN-1) * numD
sumN = numN * (num1 + valueN) / 2
print('{}번째 항까지의 합: {}'.format(numN, int(sumN)))

# 공식 사용하지 않는 경우
valueN = 0
sumN = 0
n = 1
while n <= numN:

    if n == 1:
        valueN = num1
        sumN += valueN
        print('{}번째 항까지의 값: {}'.format(n, valueN))
        n += 1
        continue

    valueN += numD
    sumN += valueN
    print('{}번째 항까지의 값: {}'.format(n, sumN))
    n += 1

등비수열: 연속된 두 항의 비가 일정한 수열

  • 등비 중항: an-1 * an+1 = an^2
# n번째 항의 값 출력하기
num1 = int(input('a1 입력: '))
numR = int(input('공비 입력: '))
numN = int(input('n 입력: '))

valueN = 0
n = 1
while n <= numN:

    if n == 1:
        valueN = num1
        print('{}번째 항의 값: {}'.format(n, valueN))
        n += 1
        continue

    valueN *= numR
    print('{}번째 항의 값: {}'.format(n, valueN))
    n += 1
    
# 등비 수열 공식: an = a1 * r^(n-1)
valueN = num1 * (numR ** (numN - 1))
print('{}번째 항의 값: {}'.format(numN, valueN))

# n번째 항까지의 합 구하기
sumN = 0
while n <= numN:

    if n == 1:
        valueN = num1
        sumN += valueN
        print('{}번째 항까지의 합: {}'.format(n, sumN))
        n += 1
        continue

    valueN *= numR
    sumN += valueN
    print('{}번째 항까지의 합: {}'.format(n, sumN))
    n += 1
    
 # 등비 수열 합
 # sn = a1 * (1 - r^n) / (1 - r)
sumN = num1 * (1 - (numR ** numN)) / (1 - numR)

계차수열: 어떤 수열의 인접하는 두 항의 차로 이루어진 또 다른 수열

numAn1 = int(input('a1 입력: '))
numAn = int(input('an 입력: '))

numBn1 = int(input('b1 입력: '))
numBD = int(input('bn 공차 입력: '))

valueAn = 0
valueBn = 0

n = 1
while n <= numAn:

    if n == 1:
        valueAn = numAn1
        valueBn = numBn1
        print('an의 {}번째 항의 값: {}'.format(n, valueAn))
        print('bn의 {}번째 항의 값: {}'.format(n, valueBn))
        n += 1
        continue

    valueAn += valueBn
    valueBn += numBD
    print('an의 {}번째 항의 값: {}'.format(n, valueAn))
    print('bn의 {}번째 항의 값: {}'.format(n, valueBn))
    n += 1

피보나치 수열

  • 세 번째 항은 두 번째 항과 첫 번째 항을 더한 합
# 피보나치 수 계산
inputN = int(input('n 입력: '))

valueN = 0
sumN = 0

valuePreN2 = 0
valuePreN1 = 0

n = 1
while n <= inputN:
    if n == 1 or n == 2:
        valueN = 1
        valuePreN2 = valueN
        valuePreN2 = valueN

        sumN += valueN
        n += 1

    else:
        valueN = valuePreN2 + valuePreN1
        valuePreN2 = valuePreN1
        valuePreN1 = valueN
        n+= 1

print('{}번째 항의 값: {}'.format(inputN, valueN))
print('{}번째 항까지의 값: {}'.format(inputN, sumN))

군수열

  • 여러 개의 항을 묶었을 때 규칙성을 가지는 수열
inputN = int(input('n항 입력: '))

flag = True
n = 1; nCnt = 1; searchN = 0

while flag:

    for i in range(1, (n + 1)):
        if i == n:
            print('{}'.format(i), end='')
        else:
            print('{},'.format(i), end='')

        nCnt += 1
        if nCnt > inputN:
            searchN = i
            flag = False
            break

    print()
    n += 1

print('{}항: {}'.format(inputN, searchN))

📚 시그마 ∑

  • 수열의 합을 나타내는 기호
# 시그마를 이용해 난타낸 수열의 합
# 등차수열
num1 = int(input('a1 입력: '))
numD = int(input('공차 입력: '))
numN = int(input('n 입력: '))

valueN = num1 + (numN - 1) * numD
sumN = numN * (num1 + valueN) / 2
print('{}번째 항까지의 합: {}'.format(numN, sumN))

# 등비수열
num1 = int(input('a1 입력: '))
numR = int(input('공비 입력: '))
numN = int(input('n 입력: '))

sumN = num1 * (1 - (numR ** numN)) / (1 - numR)
print('{}번째 항까지의 합: {}'.format(numN, sumN))

📚 팩토리얼 !

  • 1부터 양의 정수 n까지의 정수를 모두 곱한 것
inputN = int(input('n 입력: '))

# 반복문 사용
result = 1
for n in range(1, (inputN + 1)):
    result *= n

print('{}팩토리얼: {}'.format(inputN, result))

# 재귀함수 사용
def factorialFun(n):
    if n == 1: return 1

    return n * factorialFun(n-1)

print('{}팩토리얼: {}'.format(inputN, factorialFun(inputN)))

# math 라이브러리 사용

import math
print('{}팩토리얼: {}'.format(inputN, math.factorial(inputN))

📚 순열

  • nPr: n개에서 r개를 택하여 나열하는 경우의 수
  • 순서 상관있이 r개 선택
  • 팩토리얼(계승)을 이용해 나타낼 수 있음
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
result = 1

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

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

원 순열

  • 시작과 끝의 구분이 없느 순열
# n명의 친구가 원탁 테이블에 앉을 수 있는 순서를 계산해보자.
n = int(input('친구 수 입력: '))
result = 1
for i in range(1, n):
    result *= i

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

📚 조합

  • n개에서 r개를 택하는 경우의 수
  • 순서 상관없이 r개 선택
  • nCr
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
resultP = 1
resultR = 1
resultC = 1

# 순열 구하기
for n in range(numN, (numN - numR), -1):
    print('n : {}'.format(n))
    resultP *= n

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

# R! 구하기
for n in range(numR, 0, -1):
    print('n : {}'.format(n))
    resultR *= n

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

# 총 결과
resultC = int(resultP / resultR)
print('resultC : {}'.format(resultC))

📚 확률

  • 모든 사건에서 특정한 사건이 일어날 수 있는 수
  • 조합을 활용해 확률을 알아낼 수 있다
# 박스에 '꽝'이 적힌 종이가 4장 있고, 
# '선물'이 적힌 종이가 3장이 있을 때, 
# 파이썬을 이용해서 꽝' 2장과 '선물' 1장을 뽑는 확률을 출력하자.

def proFun():
    numN = int(input('numN 입력: '))
    numR = int(input('numR 입력: '))

    resultP = 1
    resultR = 1
    resultC = 1

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

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

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

    return resultC

# 전체 7C3
sample = proFun()
print('sample: {}'.format(sample))

# 꽝 뽑을 때
event1 = proFun()
print('sample: {}'.format(event1))

# 선물 뽑을 때
event2 = proFun()
print('sample: {}'.format(event2))

# 최종 가능성
probability = (event1 * event2) / sample
print('probability: {}%'.format(round(probability * 100, 2)))
profile
호랑이 기운이 솟아나요🐯

0개의 댓글