스터디 노트 (기초 수학 01 ~ 30)_0717

(기초 수학 01 ~ 15)

📌 약수

• 어떤 수를 나누어 떨어지게 하는 수
• 나머지가 0이다 (나누어 떨어지기 때문에) 

inputNumber = int(input('0보다 큰 정수 입력 : '))

for number in range (1, inputNumber + 1): 
    if inputNumber % number == 0: #입력한 정수와 반복되어 돌고 있는 정수 둘을 나눠서 나머지가 0일때
        print('{}의 약수 : {}'.format(inputNumber, number))

📌 소수

• 1과 자신만을 약수로 가지는 수 (단, 1은 제외)
• 1~30까지 몫으로 나올 수 있는 소수의 경우의 수를 생각
  • ex) 2,3,5..
• (5*몫)에 5보다 작은 소수를 더한다. (기준이 5로 나눈 몫이기 때문에 기본적으로 5로 나누어 질 수 있어야함)
• 2*5 / 3*5 / 5*5 결과값에 나왔던 앞의 소수 몫의 값을 더해준다
• 12, 13, 17, 18, 27, 28

출처 : 제로베이스 데이터 스쿨

inputNumber = int(input('0보다 큰 정수 입력 : '))

for number in range (2, inputNumber + 1): #2부터 10까지 number가 반복
    flag = True

    for n in range (2, number): #2부터 9까지 n이 반복 된다.
        if number % n == 0: #여기서 number가 10이라 가정, n은 9까지 돈다 그래서 기준이 10이라면, 9까지 나누었을 때 몫이 0이 되는 약수를 다 확인한다
            flag = False
            break

    if flag:
        print('{} : 소수'.format(number))

    else:
        print('{} : 합성수'.format(number) )

📌 소인수 분해

• 약수(인수) 중에서 소수인 숫자를 소인수라고 한다.
• 154의 약수 - [1, 2, 7, 11, 14, 22, 77, 154]
  • 소인수 - [2, 7, 11]

아이패드 굿노트로 오랜만에 문제를 풀어봤다..

#소인수 분해
inputNumber = int(input('1보다 큰 정수 입력 : '))

n = 2 #나누는 기준
while n <= inputNumber:
    if inputNumber % n == 0: #inputnumber가 2로 나누어 떨어지면
        print('소인수 : {}'.format(n)) #소인수이다.
        inputNumber /= n #2로 나누면서 반복
    else:
        n += 1 #만약에 2로 나누어 떨어지지 않으면 n을 +1

#72에 x를 곱하면 y의 제곱이 된다고 할 때, x에 해당하는 가장 작은 정수를 구하자

inputNumber = int(input('1보다 큰 정수 입력 : '))
n = 2
searchNumbers = [] #List는 대괄호로 선언

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 = {}'.format(searchNumbers))

📌 공약수

• 두 개 이상의 수에서 공통된 약수를 공약수라고 한다.
  • 12와 20의 공약수 - (1,2,4)

📌 최대 공약수

• 공약수 중 가장 큰 수를 최대 공약수라고 한다.
• 숫자를 같이 소인수 분해하여 최대 공약수를 구할 수 있다.

#두개의 수를 입력하면 공약수와 최대 공약수를 출력하는 코드를 만들자.

num1 = int(input('1보다 큰 정수 입력 : '))
num2 = int(input('1보다 큰 정수 입력 : '))
maxNum = 0 #최대 공약수
numlist = [] #공약수 리스트
for i in range (1, num1 + 1):
    if num1 % i == 0 and num2 % i == 0: #num1과 num2가 공통적으로 i로 나누었을 때 몫이 0이라면
        numlist.append(i) #공약수 리스트에 넣어주고
        print(f'{num1}과 {num2}의 공약수 : {i}') #실행
        maxNum = i #그 i는 maxNum에 넣어준다 (최대가 나올때까지 계속 갱신)

print(f'{num1}과 {num2}의 최대 공약수 : {maxNum}')
print(f'공약수 리스트 : {numlist}')

📌 유클리드 호제법

출처 : 제로베이스 데이터 스쿨

#두개의 수를 입력하면 공약수와 최대 공약수를 출력하는 코드를 만들자.
#유클리드 호제법

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

temp1 = num1 # 20
temp2 = num2 # 30

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

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

📌 공배수

• 두 개 이상의 수에서 공통된 배수를 공배수라고 한다.
• 그 중 가장 작은 공배수를 최소 공배수라고 한다

📌 최소 공배수 구하기

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(f'공약수 : {i}')
        maxNum = i
    else:
        i += 1

print(f'{num1}와 {num2}의 최대 공약수 : {maxNum}')

num3 = (num1 * num2) // maxNum #두 수를 곱하고 최대 공약수로 나누면 최소 공배수가 나온다.

print(f'{num1}와 {num2}의 최소 공배수 : {num3}')

📌 숫자 3개의 최소 공배수 구하기

#앞선 두개의 수에 대한 최소 공배수를 구한 후, 다시 세 번째 수와의 최소 공배수를 구하면
#숫자 3개의 최소 공배수를 구할 수 있다

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(f'공약수 : {i}')
        maxNum = i
    else:
        i += 1

print(f'{num1}와 {num2}의 최대 공약수 : {maxNum}')

minNum = (num1 * num2) // maxNum

print(f'{num1}와 {num2}의 최소 공배수 : {minNum}')

print()

newNum = minNum

for j in range (1, newNum+1):
    if newNum % j == 0 and num3 % j ==0:
        print(f'공약수 : {j}')
        maxNum = j
    else:
        j += 1

print(f'{newNum}와 {num3}의 최대 공약수 : {maxNum}')

newNum2 = (newNum * num3) // maxNum

print(f'{num1}과 {num2}, {num3}의 최소 공배수 = {newNum2}')

📌 진법

• 2진법 - 0, 1 : bin()
• 8진법 - 0 ~ 7 : oct()
• 10진법 - 0 ~ 9 
• 16진법 - 0 ~ F hex()

#10진수를 X진수로 변환

dNum = 30

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

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

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

print('2진수 : {}'.format(format(dNum, 'b'))) #앞에 상징은 없어지고 변환된 숫자만 나온다
print('8진수 : {}'.format(format(dNum, 'o')))
print('16진수 : {}'.format(format(dNum,'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 = a1 + (n-1)*d
• 등차 중항 : an = (an-1 + an+1) / 2
• 등차 수열의 합 : sn = n(a1 + an) / 2

#다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 만들어보자

inputa1 = int(input('a1 입력 : '))
inputD = int(input('공차 d 입력 : '))
inputN = int(input('n 입력 : '))

ValueN = 0

n = 1

while n <= inputN:

    if n == 1: 
        ValueN = inputa1 #n이 1일때 a1과 같다
        print('{}번째 항의 값 : {}'.format(n, ValueN))
        n += 1 #n에 1을 더하고 다시 while문 처음으로 돌아간다.
        continue

    else:
        ValueN += inputD #계속해서 값에 공차를 더해준다 (입력한 숫자까지)
        print('{}번째 항의 값 : {}'.format(n, ValueN)) 
        n += 1

print('{}번째 항의 값 : {}'.format(inputN, ValueN))

#또 다른 방법
#an = a1 + (n-1)d 활용
ValueN = inputa1 + (inputN - 1) * inputD

print('{}번째 항의 값 : {}'.format(input_N, Value_N))

#다음 수열을 보고 n번째 항까지의 합을 출력하는 프로그램을 만들어보자.
input_a1 = int(input('a1 입력 : '))
input_D = int(input('공차 d 입력 : '))
input_N = int(input('n 입력 : '))

value_N = 0
sum_N = 0
n = 1

while n <= input_N:

    if n == 1:
        value_N = input_a1
        sum_N += value_N
        print('{}번째 항의 값 : {}'.format(n, value_N))
        print('{}번째 항까지의 합 : {}'.format(n, sum_N)) #기존의 수식에 sum을 추가
        n += 1
        continue

    else:
        value_N += input_D
        sum_N += value_N
        print('{}번째 항의 값 : {}'.format(n, value_N))
        print('{}번째 항까지의 합 : {}'.format(n, sum_N))
        n += 1

print('{}번째 항의 값 : {}'.format(input_N, value_N))
print('{}번째 항까지의 합 : {}'.format(input_N, sum_N))


#n번째 항까지의 합 구하는 공식!
#sn = n(a1 + an) / 2
sum_N = input_N * (input_a1 + value_N) / 2
print('{}번째 항까지의 합 : {}'.format(input_N,int(sum_N)))

📌 등비 수열

• 등비 수열의 일반 항 : an = a1 * r^(n-1)
• 등비 수열의 합 : sn = a1 * (1 - (r^n)) / (1-r)

input_a1 = int(input('a1 입력 : '))
input_R = int(input('공비 r 입력 : '))
input_N = int(input('n번째 항 입력 : '))

value_N = 0
sum_N = 0
n = 1

while n <= input_N:
    if n == 1:
        value_N = input_a1
        sum_N +=input_a1
        print('{}번째 항의 값 : {}'.format(n, value_N))
        print('{}번째 항까지의 합 : {}'.format(n, sum_N))
        n += 1
        continue

    else:
        value_N *= input_R
        sum_N += value_N
        print('{}번째 항의 값 : {}'.format(n, value_N))
        print('{}번째 항까지의 합 : {}'.format(n, sum_N))
        n += 1

#등비수열의 n번째 항 공식 = an = a1*r^(n-1)
input_a1 = int(input('a1 입력 : '))
input_R = int(input('공비 r 입력 : '))
input_N = int(input('n번째 항 입력 : '))

value_N = 0
sum_N = 0
n = 1

value_N = input_a1*(input_R ** (input_N-1))

print('{}번째 항 = {}'.format(input_N, value_N))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#sn = a1 * (1 - r^n) / (1-r)
input_a1 = int(input('a1 입력 : '))
input_R = int(input('공비 r 입력 : '))
input_N = int(input('n번째 항 입력 : '))

value_N = 0
n = 1

sum_N = input_a1 * ( 1 - (input_R ** input_N )) / (1 - input_R)

print('{}번째 항까지의 합 : {}'.format(n, int(sum_N)))

(기초 수학 16 ~ 30)

📌 시그마

• 수열의 합을 나타내는 기호

📌 계차수열

an의 계차수열 bn을 이용하여 an의 일반항을 구한다

#an = 3, 7, 13, 21, 31, 43, 57
#bn = 4, 6, 8, 10, 12, 14

input_A1 = int(input('a1 입력 : '))
input_AN = int(input('an 입력 : '))

input_B1 = int(input('B1 입력 : '))
input_BD = int(input('BD 입력 : '))

value_AN = 0
value_BN = 0

n = 1

while n <= input_AN:
    if n == 1:
        value_AN = input_A1
        value_BN = input_B1
        print('an의 {}번째 항의 값 : {}'.format(n, value_AN))
        print('bn의 {}번째 항의 값 : {}'.format(n, value_BN))
        print()
        n+=1
        continue

    else:
        value_AN = value_AN + value_BN
        value_BN = value_BN + input_BD
        print('an의 {}번째 항의 값 : {}'.format(input_AN, value_AN))
        print('bn의 {}번째 항의 값 : {}'.format(input_AN, value_BN))
        print()
        n+=1


# an의 계차수열 bn을 이용하여 an을 구한다!
# n^2 + n + 1 = an

value_AN = input_AN ** 2 + input_AN + 1
print('an의 {}번째 항의 값 : {}'.format(input_AN, value_AN))

📌 피보나치 수열

• 세 번째 항은 두 번째 항과 첫 번째 항을 더한 합이다.
• a1 = 1, a2 = 1이고 n>2 일때 an = an-2 + an-1

# 1, 1, 2, 3, 5, 8 ...
#피보나치 수열

inputN = int(input('n 입력'))

valueN = 0
sumN = 0

valuePreN2 = 0
valuePreN1 = 0

n = 1

while n <= inputN:
    if n == 1 or n == 2: #n이 1, 2일때 
        valueN = 1 #항의 값은 1이다
        valuePreN2 = valueN
        valuePreN1 = valueN
        sumN += valueN #1, 2번째 항까지 더한 값
        print('{}번째 항의 값 : {}'.format(n, valueN))
        print('{}번째 항까지의 합 : {}'.format(n, sumN))
        n += 1
        continue

    else:
        valueN = valuePreN2 + valuePreN1 
        valuePreN2 = valuePreN1 # 1, 1, 2, 3, 5로 가정, PreN2는 PreN1이 되고, N1은 value N이 된다.
        valuePreN1 = valueN
        sumN += valueN
        print('{}번째 항의 값 : {}'.format(n, valueN))
        print('{}번째 항까지의 합 : {}'.format(n, sumN))
        n += 1

📌 팩토리얼

• 1부터 양의 정수 n까지의 정수를 모두 곱한 것

inputN = int(input('양의 정수 n 입력 : '))
#for문을 이용한 팩토리얼 구하기
result = 1

for n in range(1, inputN+1):
    result *= n

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

#while문을 이용한 팩토리얼 구하기
n = 1
result = 1

while n <= inputN:
    result *= n

    n += 1

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

print()

#재귀 함수를 이용한 팩토리얼 구하기

def factorialFun(n):
    if n == 1: return 1

    return n * factorialFun((n - 1))

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

#모듈을 이용한 팩토리얼 구하기
import math
math.factorial(inputN)

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

📌 군수열

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

출처 : 제로베이스 데이터 스쿨

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

📌 순열

• n개에서 r개를 택하여 나열하는 경우의 수
• nPr = n *(n-1) ..... (n-r+1) & n! / (n-r)!

#8P3 , 7P5

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

result = 1

for i in range(numN, numN-numR, -1): #n에서 n-r까지 -1 단계
    print('n : {}'.format(i))
    result *= i

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

📌 원순열

• 시작과 끝의 구분이 없는 수열
• n! / n & (n-1)!

📌 조합

• 순서와 상관없이 r개를 선택하자.
• nCr = n! / r! * (n-r)! & nPr / r!

#nCr = nPr / n! 공식을 이용
numN = int(input('numN 입력 : '))
numR = int(input('numR 입력 : '))

resultP = 1
resultR = 1
resultC = 1

for n in range(numN, numN-numR, -1): #nPr을 구하는 공식

    print('n : {}'.format(n))
    resultP *= n

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

for i in range(numR, 0, -1): #팩토리얼을 구하는 공식

    print('i : {}'.format(i))
    resultR *= i

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

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

📌 확률과 조합

• 조합을 이용하여 확률 구하기

출처 : 제로베이스 데이터 스쿨

def combination():

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

    resultP = 1
    resultR = 1
    resultC = 1

    for i in range(numN, numN-numR, -1):
        resultP *= i
    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

sample = combination()
print('sample : {}'.format(sample))

event1 = combination()
print('event1 : {}'.format(event1))

event2 = combination()
print('event2 : {}'.format(event2))

percent = (event1 * event2) / sample
print('percent : {}%'.format(round(percent*100, 2)))