[Python] 기초수학 코드구현

계차수열

# 두 항의 차로 이루어진 수열
# 어떤 수열이 인접하는 또다른 수열
# 계차수열을 이용하여 구할 수 있음

# n번째 항의 값을 출력하는 프로그램
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("an의 {}번째 항의 값:{}".format(n, valueAN))
        print("bn의 {}번째 항의 값:{}".format(n, valueBN))
        n += 1
        continue

    valueAN = valueAN + valueBN
    valueBN = valueBN + inputBD
    print("an의 {}번째 항의 값:{}".format(n, valueAN))
    print("bn의 {}번째 항의 값:{}".format(n, valueBN))
    n += 1
print("an의 {}번째 항의 값:{}".format(inputAN, valueAN))
print("bn의 {}번째 항의 값:{}".format(inputAN, valueBN))

 

군수열

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

from turtle import Turtle


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



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 -1 + 1)),end =" ")

        nCnt += 1
        if (nCnt > inputN):
            searchNC = i
            searchNP = n - i + 1
            flag= False
            break

    print()
    n +=1

print("{}항: {}/{}".format(inputN, searchNC, searchNP))

 

등비수열

# 등비수열 = 비가 같은 수열
inputN1 = int(input("a1 입력: "))
inputR = int(input("공비 입력: "))
inputN = int(input("n 입력: "))

valueN = 0
n = 1
while n <= inputN:
    
    if n == 1:
        valueN = inputN1
        print("{}번째의 값: {}".format(n, valueN))
    
    valueN *= inputR
    print("{}번째 행의 값: {}".format(n, valueN))
    n += 1
print("{}번째 행의 값: {}".format(inputN, valueN))

# 공식을 알경우, an = a1 * r(n-1)

inputN1 = int(input("a1 입력: "))
inputR = int(input("공비 입력: "))
inputN = int(input("n 입력: "))

valueN = inputN1 * (inputR**(inputN-1))
print(valueN)



# 등비수열 합을 구하는 코드
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("{}번째 항까지의 합: {}".format(n, sumN))
        n += 1
        continue

    valueN *= inputR
    sumN *= valueN
    print("{}번째 항까지의 합: {}".format(n, sumN))
    n += 1
    
print("{}번째 항까지의 합:".format(inputN, sumN))

# sn = a1 * (1- r^n) / (1-r)
sumN = inputN1 * (1 - (inputR ** inputN)) / (1-inputR)
print("{}번째 항까지의 합:{}".format(inputN, int(sumN)))

 

등차수열

# 수열: 규칙성을 가지고 나열된 수들
# 2씩증가하는 숫자의 열을 가지고 나열하는 수들 
# an = 2n (n은 차수) {an} 으로 표기함
# an = 2n+1
# 특정항은 특정항까지의 합에서 특정항 이전의 항까지의 합과 같다
# 등차수열 : 연속된 두 항의 차이가 일정한 수열
# 등차수열 규칙성을 이용해서 일반항을 구할 수 있다.
# 등차수열 공식 : an = a1 + (n-1) * d
# 등차수열 합 : sn = n(a1 +an) / 2

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

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

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

    valueN += inputN
    print("{}번째 항의 값:{}".format(n, valueN))
    n += 1
print("{} 번째 항의 값: {}".format(inputN, valueN))


# 등차수열 공식으로 출력하는 프로그램(일반화 공식)
valueN = inputN1 + (inputN-1) * inputD
print(valueN)

# 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 = inputN
        sumN = valueN
        print("{}번째 항의 값: {}".format(n, sumN))
        n += 1
        continue

    valueN += inputD
    sumN += valueN
    print("{}번째 항의 값:{}".format(n, sumN))
    n += 1
print("{} 번째 항의 값: {}".format(inputN, sumN))

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

 

소인수와 소인수분해

# 소인수: 수를 곱으로 나타낼때 소수와 인수를 합쳐서 소인수라고 함 약수 중에서 소수를 소인수라고 함
# 12의 소인수 : 2 ,3
# 25의 소인수 : 5
# 36의 소인수 : 2, 3
# 41의 소인수 : 41

# 소인수분해 : 1보다 큰 정수를 소인수의 곱으로 나타낸 것을 소인수분해라고 함
# 20의 소인수분해 : 2^2 * 5
# 36의 소인수분해 : 2^2 * 3^2
# 25의 소인수분해 : 5^2
# 41의 소인수분해 : 41

# 실습 : 약수를 구해보자
# 14 = (1, 2, 7, 14)
# 154 = (1, 2, 7, 11, 114, 22, 77, 154)
# 1547 = (1, 7, 13, 17, 91, 119 ,221, 1547)

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

# 입력된 값의 소인수 찾는 코드
n = 2
while n <= inputNumber:
    if inputNumber % n == 0:
        print("소인수 {}".format(n))
        inputNumber /= n 
    else:
        n += 1

# 72에 x를 곱하면 y의 제곱이 된다고 할 때, x 에 해당하는 가장 작은 정수를 구하는 코드
n = 2
searchNumbers = []
while n <= inputNumber:
    if inputNumber % n == 0:
        print("소인수 {}".format(n))
        if searchNumbers.count(n) == 0:
            searchNumbers.append(n)
        elif searchNumbers.count(n) == 1:
            searchNumbers.remove(n)
        inputNumber /= n 
    else:
        n += 1
print(searchNumbers)

 

순열

# 순열 코드
numN = int(input("numN 입력:"))
numR = int(input("numR 입력:"))
result = 1

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

# 원 순열 4명의 친구가 원탁 테이블에 앉을 수 있는 순서를 계산해보자
n = int(input("친구 수 입력"))
result = 1
for i in range(1, n):
	result *= i

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

 

시그마

# 시그마란? 수열의합을 합을 타나내는 기호이다.
# 1부터 n항까지 합을 구할때 사용
# sn = n(a1 + an) / 2

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

valueN = 0
sumN = 0

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

# sn = a1 * (1 - r^n) / (1 - r)
inputN1 = int(input("a1 입력: "))
inputR = int(input("공비 입력: "))
inputN = int(input("n 입력: "))
sumN = inputN1 * (1- inputR**inputN) / (1-inputR)

 

약수와 소수

# 약수 : 어떤 수를 나누어 덜어지게 하는 수
# 소수 : 1과 그 수 자신만을 약수로 가지는 수
# 실습
# q1 1부터 30까지 숫자 중 5로 나눈 몫과 나머지가 모두 소수인 숫자는?
# -> 먼저 몫이 소수인 숫자는 2, 3, 5
# -> 5에 몫을 곱함 --> 10, 15, 25
# -> 나머지가 소수이면 5보다 작은 소수는 2, 3이 있음 이것을 각각 더하면
# -> 12, 13, 17, 18, 27, 28

# q2 1부터 30까지 숫사 중 소수 는?
# -> 2를 제거한 2의 배수 제거
# -> 3을 제거한 3의 배수 제거
# -> 5를 제거한 5의 배수 제거
# -> 7을 제거한 7의 배수 제거
# -> 11을 제거한 11의 배수 제거
# -> 13을 제거한 13의 배수 제거
# -> 17 제거
# -> 19 제거 
# -> 23 제거
# -> 29 제거


user = int(input("0보다 큰 정수 입력:"))

# 약수 코드
for number in range(1, user+1):
    if user % number == 0:
        print("{}의 약수".format(number))

# 소수 코드
for number in range(2, user +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))

 

조합

numN = int(input("numN 입력:"))
numR = int(input("numR 입력:"))
resultP = 1
resultR = 1
resultC = 1

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


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

resultC = int(resultP /resultR)
print(resultC)

# 카드 5장 중 2장을 선택했을때 삼각형과 사각형이 동시에 선택될 확률?

 

진법

# 진법 : 생활에서 사용하는 10진법 외에 프로그램에서 사용하는 다양한 진법에 대해서 살펴보자
# 2진법 : 0, 1
# 8진법 : 0 ~ 7 8개사용
# 10진법 : 0~9 10개 사용
# 16진법 : 0~F 까지 16개 사용

# 10진수 -> 2진수, 8진수, 16진수
# binary : bin() "2진수"
# octal : oct() "8진수"
# hexadcimal : hex() "16진수"

dNum = 30
print(f"2진수 : {format(dNum,"#b")}")


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

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

print(f"2진수 : {format(dNum,"#b")}")
print(f"8진수 : {format(dNum,"#o")}")
print(f"16진수 : {format(dNum,"#x")}")

print("{0:#b},{0:#o},{0:#x}".format(dNum))

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

 

최대공약수

# 최대공약수 : 공통된 약수중에 가장 큰 수
# 12의 약수, 20의 약수의 공약수 1, 2, 4 
# 공약수중 가장 큰 공약수를 최대공약수라고 함 즉 , 4
# 소인수 분해를 통해 최대공약수 및 공약수를 구할 수 있음

# 실습
# 12, 54, 72 ->최대공약수 및 공약수 6 (1,2,3,6) -> 소인수분해 이용
# 25, 115, 255 -> 최대공약수 및 공약수 5 (1,5) -> 소인수분해 이용
# 빵 112개와 우유 80개를 학생들한테 남김없이 동일하게 나눠주려고 할때최대 몇명의 학생이 가질수있는지?
# -> 112와 80의 최대공약수를 구함! 16명 학생 한명망 빵7개랑 우유 5개를 받음

# 두 개의 수를 입력하면 공약수와 최대공약수를 출력하는 코드
num1 = int(input("1보다 큰 정수 입력:")) # 1번이 가장 작은수여야 한다는 가정
num2 = int(input("1보다 큰 정수 입력:"))
max_num = 0

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


# 세 개의 수를 입력하면 공약수와 최대공약수를 출력하는 코드
num1 = int(input("1보다 큰 정수 입력:")) # 1번이 가장 작은수여야 한다는 가정
num2 = int(input("1보다 큰 정수 입력:"))
num3 = int(input("1보다 큰 정수 입력:"))

max_num = 0

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


# 유클리드 호제법
# x, y 최대공약수는 y, r(x%y)의 최대공약수와 같다
num1 = int(input("1보다 큰 정수 입력:")) # 1번이 가장 작은수여야 한다는 가정
num2 = int(input("1보다 큰 정수 입력:"))

temp1 = num1
temp2 = num2

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

print(temp)

 

최소공배수

# 두개 이상의 수에서 공통된 배수를 공배수라고 함
# 공배수 중 가장 작은 수를 최소공배수라고 한다.
# 12 , 21 ,33 의 최소공배수 924
# 12, 36, 48 최소공배수 144

# 2, 5, 8 중 하나만 제외하고 나머지 두 개의 수는 5를 곱하여도 최소공배수에 변함이 없다.
# 5를 곱하였을 때 최소 공배수에 변함이 있는 수를 찾아보자
# 2,5, 8 의 최소공배수 -> 40
# 10, 5, 8 의 최소공배수 -> 40
# 2, 25, 8 의 최소공배수 -> 200
# 2, 5, 40의 최소공배수 -> 40



# 2개의 수의 최소공배수
num1 = int(input("1보다 큰 정수 입력:")) # 1번이 가장 작은수여야 한다는 가정
num2 = int(input("1보다 큰 정수 입력:"))
max_num = 0

for i in range(1, num1 +1):
    if num1 % i == 0 and num2 % i == 0:
        print("공약수: {}".format(i))
        max_num = i
print("최대공약수 : {}".format(max_num))
min_num = (num1 * num2) // max_num
print("최소공배수 : {}".format(min_num))


# 3개의 수의 최소공배수
num1 = int(input("1보다 큰 정수 입력:")) # 1번이 가장 작은수여야 한다는 가정
num2 = int(input("1보다 큰 정수 입력:"))
num3 = int(input("1보다 큰 정수 입력:"))
max_num = 0

for i in range(1, num1 +1):
    if num1 % i == 0 and num2 % i == 0:
        print("공약수: {}".format(i))
        max_num = i
print("최대공약수 : {}".format(max_num))
min_num = (num1 * num2) // max_num
print("최소공배수 : {}".format(min_num))
new_num = min_num

for i in range(1, new_num + 1):
    if new_num % i == 0 and num3 % i ==0:
        max_num = i

min_num = (new_num * num3) // max_num
print("최대공배수: {}".format())


# 섬마을에 과일, 생선, 야채가 들어온다
# 과일 선박 : 3일주기
# 생선 선박 : 4일 주기
# 야채 선박 : 5일 주기

ship1 = 3 ; ship2 = 4 ; ship3 = 5
maxday = 0

for i in range(1, ship1+1):
    if ship1 % i == 0 and ship2 % i == 0:
        maxday = i

print("최대공약수 : {}".format(maxday))

minday = (ship1 * ship2) // maxday
print(f"{ship1}, {ship2}의 최소공배수: {minday}")

newday = minday

for i in range(1, newday+1):
    if newday % i == 0 and ship3 % i == 0:
        maxday = i

print("최대공약수 : {}".format(maxday))

minday = (newday * ship3) // maxday
print(f"{ship1}, {ship2}, {ship3}의 최소공배수: {minday}")


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('최대공약수 : {}'.format(maxNum))

minNum = (num1 * num2) // maxNum

print('최소공배수: {}'.format(minNum))

 

팩토리얼

# 0! = 1 = 1
# 1! = 1 = 1
# 2! = 1 x 2
# 3! = 1 x 2 x 3

inputN = int(input("n 입력:"))

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


# 반복문 이용 while문
result = 1
n = 1
while n <=inputN:
    result *= n
    n += 1
print(f"{inputN} 팩토리얼 : {result}")

# 재귀함수를 이용하는 경우
def facotorailFun(n):
    if n == 1: return 1
    return n * facotorailFun(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
        valuePreN1 = valueN
        sumN += valueN
        n += 1

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

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

 

확률

# 박스에 "꽝"이 적힌 종이가 4개 있고, "선물"이 적힌 종이가 3장 있을 때, 파이썬을 이용해서 "꽝" 2장과 "선물" 1장을
# 구하는 확률을 구하는 코드
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)

for n in range(numR,0,-1):
    resultR *= n

resultC = int(resultP/resultR)



# 함수로 구현
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 = resultP * n
    for n in range(numR,0,-1):
        resultR = resultR * n

    resultC = int(resultP/resultR)

    return resultC

smaple = profun()
print(f"smaple.:{smaple}")

event1 = profun()
print(f"smaple.:{event1}")

event2 = profun()
print(f"smaple.:{event2}")

prob = (event1 * event2) / smaple
print(f"prob : {round(prob * 100,2)}%")