파이썬 기초수학

Variety_·2021년 9월 28일
0

Python

목록 보기
5/12

약수와 소수

def)약수 : 어떤 수는 나누어떨어지게 하는 수

inputNum = int(input("정수 입력"))
for number in range(1, (inputNum + 1)):
    if num % number == 0:
        print(f'{inputNum}의 약수{number}')

def)소수 : 1과 자기자신만을 약수로 가지는 수, 단 1은 제외

inputNum = int(input("정수 입력"))
for number in range(2, (inputNum+1)):
    flag = True
    for n in range(2, number):
        if number % n ==0:
            flag = False
            break
    if(flag):
        print(f"{number} : 소수")
    elsE:
        print(f'{number} : 합성수')

소인수분해

소인수 : 약수(인수) 중에서 소수인 수

소인수분해 : 1보다 큰 정수를 소인수의 곱으로 나타낸 것

inputNumber = int(input("1보다 큰 정수 입력 : "))

n = 2
while n<= inputNumber:
    if inputNumber % n ==0:
        prtin('소인수 {}'.format(n))
        inputNumber /= n
    else:
        n += 1
72에 어떤 수 x를 곱했을 때 이 수는 y의 제곱이 된다.
x의 최소값을 구하면?

searchNumber = []
n = 2
while n<= inputNumber:
    if inputNumber % n ==0:
        prtin('소인수 {}'.format(n))
        if searchNubers.count(n) == 0:
            searchNumbers.append(n)
        elif searchNubers.count(n) == 1:
            searchNumbers.remove(n)      # 이렇게 동작시켜 최종적으로 남는애를 한 번 고밯면 됨
    else:
        n += 1

최대공약수

최대공약수(gcd) : 공통된 약수 중 가장 큰 수, 소인수분해를 이용하면 최대공약수 및 공약수를 구할 수 있다.

공통인 소인수의 거듭제곱에서 지수가 작은 수를 모두 곱한다.ㅈ

좀 더 편리하게 구하는 방법 : 소수로 나눗셈하기 -> 일반적으로 최대공약수 구할 때 사용하는 방법 

num1 = int(input('1보다 큰 정수 입력'))
num2 = int(input('1보다 큰 정수 입력'))
maxNum = 0

for i in range(1, (num1 + 1)):
    if num1 % i ==0 and num2 % i ==0:
        print('공약수 : {}'.format(i))
        maxNum = i
print(f'최대 공약수 : {maxNum}')

유클리드 호제법

num1 = int(input('1보다 큰 정수 입력'))
num2 = int(input('1보다 큰 정수 입력'))
temp1 = num1; temp2 = num2

while temp2 > 0:
    temp = temp2
    temp2 =temp1 % temp2
    temp1 = temp
print(f'{num1}, {num2}의 최대공약수 {num}')

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

최소공배수

공배수 : 두 개 이상의 수에서 공통된 배수

최소공배수(lcm) : 공배수 중 가장 작은 수를 최소공배수라고 한다.

소인수분해를 이용해 최소공배수 및 공배수를 구할 수 있다.

공통인 소인수의 거듭제곱에서 지수가 크고 공통아닌 수를 모두 곱한다.

num1 = int(input('1보다 큰 정수 입력'))
num2 = int(input('1보다 큰 정수 입력'))
maxNum = 0

for i in range(1, (num1 + 1)):
    if num1 % i ==0 and num2 % i ==0:
        print('공약수 : {}'.format(i))
        maxNum = i
print(f'최대 공약수 : {maxNum}')

minNum= (num1 * num2) // maxNum
print('최소공배수: {}'.format(minNum))
# 세 개의 수를 입력해 최소 공배수를 구하기

num1 = int(input('1보다 큰 정수 입력'))
num2 = int(input('1보다 큰 정수 입력'))
num3 = int(input('1보다 큰 정수 입력'))
maxNum = 0

for i in range(1, (num1 + 1)):
    if num1 % i ==0 and num2 % i ==0:
        print('공약수 : {}'.format(i))
        maxNum = i
print(f'최대 공약수 : {maxNum}')

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

newNum = minNum

for i in range(1, (newNum +1)):
    if newNum % i ==0 and num3 % i ==0:
        maxNum = i
minNum = (newNum * num3) // maxNum
prtin(f"{num1}, {num2}, {num3}의 최소공배수 : {minNum}")

진법

진법 : 특정 숫자 몇 개를 사용하여 수를 표시하는 방법

ex) 16진법은 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F를 사용

2진수 -> 8진수 변환 : 뒤에서부터 3자리씩 구분하고 빈 자리는 0으로 채운다. 2진수를 10진수로 변환한거 그대로 쓰면 ㅇㅋ .

ex) 1010100 -> 001/010/100(세글자씩 끊음) -> 124

2진수 -> 16진수 변환 : 뒤에서부터 4자리씩 구분해서 하면 됨.

10진수 -> 2,8,16 진수 변환
format 함수를 사용. bin(), oct(), heX() 사용
환한 결과는 str 타입, b,o,x에 
을 붙여서 사용하면 0b 처럼 진수를 의미하는 내용도 같이 출력 됨
format(bin(dNum))format(nNum, '#b')format(nNum,'b')

x진수를 10진수로 변환

.format(int(''진수''),형태)

#예시
print("2진수 (0b11110) -> 10진수
({})".format(int('ob1110', 2)))

x진수를 x진수로 변환

print("2진수(0b1110) -> 8진수({})".format(oct(0b1110)))

수열

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

An=Sn−Sn−1,단n>=2,a1=S1A_n = S_n - S_n-1 , 단 n>=2, a_1=S_1

등차수열

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

아래는 등차수열의 일반항이다.

an=a1+(n−1)da_n = a_1 + (n-1)d

등차 중항 : 연속된 세 항에서 가운데 항

아래와 같은 성질을 갖는다.

(a+b)/2=c(a + b) /2 =c

등차 수열의 합은 아래와 같다

Sn=n(a1+an)/2S_n = n(a_1+a_n)/2
Sn=n(a1+an)/2S_n = n(a_1+a_n)/2
# n번쨰 항의 값을 출력하는 프로그램
inputN1 = int(input("a1 입력 :"))
inputD = int(input("공차 입력 :"))
inputN = int(input("n 입력 :"))

valueN = 0
n = 1
while n <= inputN :
    
    if n==1:
        valueN = inputN1
        print(f'{n}번째 항의 값 {valueN}')
        n += 1
        continue
    valueN += inputD
    print(f'{n}번째 항의 값 :{}')
    n += 1
print(f'{inputN}번쨰 항의 값 : {valueN}')

valueN = inputN1 + (inputN-1) * inputD
#다음 수열을 보고 n번째 항까지의 합을 출력

inputN1 = int(input("a1 입력 :"))
inputD = int(input("공차 입력 :"))
inputN = int(input("n 입력 :"))

valueN = 0
sumN = 0
n = 1
while n <= inputN :
    
    if n==1:
        valueN = inputN1
        sumN = valueN
        print(f'{n}번째 항의 값 {valueN}')
        n += 1
        continue
    valueN += inputD
    sumN += valueN
    print(f"{n}번째 항까지의 합 : {sumN}")
    n += 1
print(f"{inputN} 번째 항까지의 값 {sumN}")

valueN = inputN1 * (inputN - 1 ) * inputD
sumN = inputN * (inputN1 + valueN) / 2

등비수열

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

an=a1∗r∗∗(n−1)a_n = a_1 * r ** (n-1)
# n 번쨰 항의 값을 출력하는 프로그램
inputN1 = int(input("a1 입력 :"))
inputR = int(input("공비 입력 : "))
inputN = int(input("n 입력 : "))

valueN = 0 
n = 1
whilte n <= inputN:
    if n==1:
        valueN = inputN1
        print(f"{n}번쨰 항의 값 : {valueN}")
        n += 1
        continue
    valueN += inputR
    print(f"{n}번쨰 항의 값 : {valueN}")
    n += 1
print(f"{inputN}번째 항의 값 {valueN}")

#일반항 공식 이용

valueN = inputN1 * (inputR ** (inputN-1))
print(f"{inputN}번째 항의 값 : {valueN}")

​ 

#S_n 출력!!!!!!!!!!!
inputN1 = int(input("a1 입력 :"))
inputR = int(input("공비 입력 : "))
inputN = int(input("n 입력 : "))
valueN = 0
sumN = 0
n = 1
while n<=inputN:
    if n==1:
        valueN = inputN1
        sumN += valueN
        print(f"{n}번째 항까지의 합 : {sumN}")
        n += 1
        continue
    valueN *= inputR
    sumN += valueN
    print(f"{n}번째 항까지의 합 : {sumN}")
    n += 1
print(f"{unputN}번쨰 항까지의 합 : {sumN}")

등비 수열 합공식

Sn=a1∗(1−rn)/(1−r)S_n = a_1 * (1-r^n) / (1-r)
sumN = inputN1 * (1 - (inputR ** inputN)) / (1 - inputR)

시그마(sigma)

sigma : 수열의 합을 나타내는 기호

계차 수열

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

an=a1+sigama(bn)    when  k=1  to  k=n−1a_n = a_1 + sigama(b_n)~~~~when~~k=1~~to~~k= n-1
inputAN1 = int(input("a1 입력"))
inputAN = int(input("an 입력"))
inputBN1 = int(input("b1 입력"))
inputBD = int(input("bn 공차 입력"))
valueAN = 0
valueBN = 0
n = 1
while n <= inputAN:
    
    if n == 1:
        valueAN = inputAN1
        valueBN = inputBN1
        print(f"an의 {n}번째 항의 값{valueAN}")
        print(f"bn의 {n}번째 항의 값{valueBN}")
        n += 1

피보나치 수열

피보나치 수열 : 처음 두 항을 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
        valuePreN1 = valueN
        sumN += valueN
        n += 1
    else:
        valueN = valuePreN2 + valuePreN1
        valuePreN2 = valuePreN1
        sumN += valueN
        n += 1
print(f"{inputN}번째의 값 : {valueN}")
print(f"{inputN}번째 항까지의 합 : {sumN}")

팩토리얼

팩토리얼 : 1부터 양의 정수 n까지의 모든 정수를 곱한 것, 단 0!은 1로 정의한다.

# 반복문
result = 1
for n in range(1, inputN +1):
    result *= n
print(f"{inputN} 팩토리얼 : {result}")

result = 1
n = 1
while n<= inputN:
    result *= n
    n += 1
print(f"{inputN} 팩토리얼 : {result}")

#재귀 함수
def factorialFun(n):
    if n==1 :
        return 1
    return n * factorialFun(n - 1)
print(f"{inputN} 팩토리얼 : {factorialFun(inputN)}")

#모듈
import math
math.factorial(n)

군수열

군수열 : 여러 개의 항을 묶었을 때 규칙성을 가지는 수열

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(f"{inputN}항 : {searchN}")
inputN = int(input("n항 입력 : "))

flag = True
n =1; nCnt = 1; searchNC = 0; searchNP = 0
while flag:
    
    for i in range(1, (n + 1)):
        if i ==n:
            print("{}/{}".format(i, (n - i + 1)), end = '')
        else:
            print("{}/{}".format(i, (n - i + 1)), end = '')
            
        nCnt += 1
        if(nCnt > inputN):
            searchN = i
            searchNP = n - i +1
            flag = False
            break
    print()
    n += 1
print(f"{inputN}항 : {searchN}/{searchNP}")

순열

순열 : n개에서 r개를 택하여 나열하는 경우의 수

nPr=n(n−1)(n−2)...(n−r+1),(단0<r<=n)nPr = n(n-1)(n-2)...(n-r+1), (단 0<r<=n)
numN = int(input('N 입력'))
numR = int(input('R 입력'))
result = 1

for n in range(numN, (numN-numR), -1):
    print(f" n : {n}")
    result = result * n
print(f"result : {result}")

원순열 : 시작과 끝의 구분이 없는 순열 (n-1)! 으로 계산

조합

조합 : 순서 상관없이 n개 에서 r개를 택하는 경우의 수

numN = int(input('N 입력'))
numR = int(input('R 입력'))
resultP = 1
resultR = 1
resultC = 1

for n in range(numN, (numN-numR), -1):
    print(f"n : {n}")
    resultP = resultP * n
print("resultP : {resultP}")

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

resultC = int(resultP / resultR)
print(f"resultC : {resultC}")

확률

확률 : 특정 사건이 일어날 수 있는 경우의 수

모든 사건 : 표본 공간, 특정 사건 : 사건

profile
Variety_
이전 포스트

파이썬 기초4

다음 포스트

파이썬 자료형

0개의 댓글