스터디노트(수학 4~7)

zoe·2023년 3월 15일
math
0

💡 등차수열(파이썬)

💡 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성
an = {2, 5, 8, 11, 14, 17, 20, 23, 26, 29, … }

# 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성
# an = {2, 5, 8, 11, 14, 17, 20, 23, 26, 29, … }

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

💡 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성

# 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성
# an = {2, 5, 8, 11, 14, 17, 20, 23, 26, 29, … }
# 등차수열(일반항) 공식 : an = a1 + (n-1)*d

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

valueN = inputN1 + (inputN-1) * inputD
print('{}번째 항의 값 : {}' .format(inputN, valueN))

다음 수열을 보고 n번째 항의 합을 출력하는 프로그램을 생성
an = {5, 9, 13, 17, 21, 25, 29, 33… }

# 다음 수열을 보고 n번째 항의 합을 출력하는 프로그램을 생성
# an = {5, 9, 13, 17, 21, 25, 29, 33… }

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}번째 항까지의 합 : {sumN}')
        n += 1
        continue
    valueN += inputD
    sumN += valueN
    print(f'{n}번째 항까지의 합 : {sumN}')
    n += 1

print(f'{inputN}번째 항까지의 합 : {sumN}')

💡 다음 수열을 보고 n번째 항의 합을 출력하는 프로그램을 생성
an = {5, 9, 13, 17, 21, 25, 29, 33… }
등차수열(합) 공식 : sn = n(a1 + an) / 2

# 다음 수열을 보고 n번째 항의 합을 출력하는 프로그램을 생성
# an = {5, 9, 13, 17, 21, 25, 29, 33… }
# 등차수열(합) 공식 : sn = n(a1 + an) / 2

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

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

print(f'{inputN}번째 항까지의 합 : {sumN}')

등비수열

  • 등비수열 : 연속된 두 항의 비가 일정한 수열
    - 등비수열 일반항 : an = a1 * r^(n-1)
  • 등비 수열 규칙성을 이용해서 일반항을 구할 수 있음
  • 등비중항 : 연속된 세 항에서 가운데 항, an ^ 2
  • 등비수열의 합 : sn = a1 * (1 – (r^n)) / (1-r)

다음 수열의 일반항을 구하기

  • 2, 4, 8, 16, 32, 64 : 2 * 2^(n-1) = 2n
  • 5, 15, 45, 135, 405, 1215 : 5 * 3^(n-1)

다음 수열에서 a2과 a6의 등비 중항 구하기

  • 2, 4, 8, ?, 32, 64 : 4*64 = an^2 = 16
  • 5, 15, 45, ?, 405, 1215 : 15 * 1215 = 135

다음 수열의 합을 구하기

  • 2, 4, 8, 16, 32, 64 : 2 * (1 - 2^6) / (-1) = 126
  • 5, 15, 45, 135, 405, 1215 : 5 (1-3^6) / 1 - 3 = 5 (-728) / (-2) = 1820

등비수열(파이썬)

다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 만들어보자.
an = {2, 4, 8, 16, 32, 64, 128, 256, … }

# 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 만들어보자.
# an = {2, 4, 8, 16, 32, 64, 128, 256, … }

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

💡 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 만들어보자.
an = {2, 4, 8, 16, 32, 64, 128, 256, … }

# 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 만들어보자.
# an = {2, 4, 8, 16, 32, 64, 128, 256, … }

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

valueN = inputN1 * (inputR ** (inputN - 1))
print('{}번째 항의 값 : {}'.format(inputN, valueN))

다음 수열을 보고 n번째 항까지의 합을 출력하는 프로그램을 생성
an = {5, 15, 45, 135, 405, 1215, 3645, … }

# 다음 수열을 보고 n번째 항까지의 합을 출력하는 프로그램을 생성
# an = {5, 15, 45, 135, 405, 1215, 3645, … }

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

💡 다음 수열을 보고 n번째 항까지의 합을 출력하는 프로그램을 만들어보자.
an = {5, 15, 45, 135, 405, 1215, 3645, … }
sn = a1 * (1-r^n) / (1-r)

# 다음 수열을 보고 n번째 항까지의 합을 출력하는 프로그램을 만들어보자.
# an = {5, 15, 45, 135, 405, 1215, 3645, … }
# 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)
print('{}번째 항까지의 합 : {}'.format(inputN, sumN))

시그마

  • 시그마(∑) : 수열의 합을 나타내는 기호, 1부터 n까지의 합

시그마를 이용해서 나타낸 수열의 합을 파이썬 프로그램 생성
{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

# 시그마를 이용해서 나타낸 수열의 합을 파이썬 프로그램 생성
#{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}


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

valueN = 0
sumN = 0

# 등차수열 일반항 공식 : a1 + (n-1)d
# 등차수열(합) 공식 : n(a1 + an) / 2
valueN = inputN1 + (inputN - 1) * inputD
sumN = inputN * (inputN1 + valueN) / 2
print('{}번째 항까지의 합 : {}' .format(inputN, sumN))

시그마를 이용해서 나타낸 수열의 합을 파이썬 프로그램으로 생성
{2, 6, 18, 54, 162, 486, 1458, 4374}

# 시그마를 이용해서 나타낸 수열의 합을 파이썬 프로그램으로 생성
# {2, 6, 18, 54, 162, 486, 1458, 4374}
inputN1 = int(input('a1 입력 : '))
inputR = int(input('공비 입력 : '))
inputN = int(input('n 입력 : '))

valueN = 0
sumN = 0

# 등비수열(합) 공식 : sn = a1*(1 - r^n) / (1-r)

sumN = inputN1 * (1-inputR**inputN) / (1-inputR)
print('{}번째 항까지의 합 : {}' .format(inputN, sumN))

계차수열

  • 계차수열 : 어떤 수열의 인접하는 두 항의 차로 이루어진 또 다른 수열
    - {bn}은 {an}의 계차 수열
  • 계차 수열을 이용해서 수열 an의 일반항을 구할 수 있다

계차 수열을 이용해서 수열 an의 일반항을 구하기
{an} = {3, 7, 13, 21, 31, 43, 57}
{bn} = {4, 6, 8, 10, 12, 14}

an -> 4 + (k-1) * 2 = 4 + 2k - 2 = 2k + 2

(k-1)(4 + 2(k-1) + 2) / 2
(k-1)(2k+4) / 2
(k-1)(k+2) = k^2 +k -2
k^2 + k - 2 = an - 3
an = k^2 + k - 2 + 3 = k^2 + k + 1
an = k^2 + k + 1

💡 계차수열(파이썬)

💡 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성
an = {3, 7, 13, 21, 31, 43, 57}
4, 6, 8, 10, 12, 14

#  다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성
# an = {3, 7, 13, 21, 31, 43, 57}
# 4, 6, 8, 10, 12, 14

inputAN1 = int(input('a1 입력 : '))
inputAN = int(input('an 입력 : '))

inputBN1 = int(input('b1 입력 : '))
inputBN = 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 += valueBN
    valueBN += inputBN
    print('an의 {}번째 항의 값 : {}'.format(n, valueAN))
    print('bn의 {}번째 항의 값 : {}'.format(n, valueBN))
    n += 1

print()
print('an의 {}번째 항의 값 : {}'.format(inputAN, valueAN))
print('bn의 {}번째 항의 값 : {}'.format(inputAN, valueBN))


# an = n^2 + n + 1
valueAN = inputAN**2 + inputAN + 1
print('an의 {}번째 항의 값 : {}'.format(inputAN, valueAN))

💡 피보나치 수열

  • 피보나치 수열 : 세번째 항은 두 번째 항과 첫 번째 항을 더한 합
  • a1 = 1, a2 = 1이고 n>2 때 an = an-2 + an-1 이다

💡 파이썬을 이용해서 피보나치 수를 계산하는 프로그램을 생성

# 파이썬을 이용해서 피보나치 수를 계산하는 프로그램을 생성

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

valueN = 0
sumN = 0

valueReN2 = 0
valueReN1 = 0

n = 1
while n <= inputN:
    if n == 1 or n == 2:
        valueN = 1
        valueReN2 = valueN
        valueReN1 = valueN
        sumN += valueN
        n += 1
    else:
        valueN = valueReN1 + valueReN2
        valueReN2 = valueReN1 # 반복문이 다음에 돌기 위해 미리 설정한다고 보면 됨
        valueReN1 = valueN  # 반복문이 다음에 돌기 위해 미리 설정한다고 보면 됨
        sumN += valueN
        n += 1

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

팩토리얼

  • 팩토리얼 : 1부터 양의 정수 n까지의 정수를 모두 곱한 것
    - 💡 0! -> 1
  • 💡 재귀함수 : 나 자신을 다시 호춯하는 함수

파이썬을 이용해서 팩토리얼 결괏값을 출력하는 프로그램을 생성

# 파이썬을 이용해서 팩토리얼 결괏값을 출력하는 프로그램을 생성

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

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

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


result = 1
n = 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)))
print()


import math

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

군수열

  • 군수열 : 여러 개의 항을 묶었을 때 규칙성을 가지는 수열, 군으로 묶었을 때 규칙성이 보이는 수열

💡 군수열(파이썬)

💡 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성

# 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성

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

flag = True
n = 1; nCnt = 1; #cCnt 내가 원하는 항을 찾음
searchN = 0 # searchN 찾는 값

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번째 항의 값을 출력하는 프로그램을 생성

# 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 생성

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:
            searchNC = i
            searchNP = n - i + 1
            flag = False
            break
    print()
    n += 1

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

순열

  • 순열 : n개에서 r개를 택하여 나열하는 수, 순서를 구분
    - nPr = n(n-1)(n-2) … (n-r+1), (단 0 < r <= n)
    - 순열은 팩토리얼(계승) 을 이용해서 나타낼 수 있음
    - n!/ (n-r)!

다음 순열의 값을 구하기

  • 8P3 = 8! / 5! = 876 = 336
  • 7P5 = 7! / 2! = 76543 = 2520

카드 4장을 일렬로 나열하되 삼각형과 사각형이 서로 이웃하도록 나열하는 경우의 수를 구하자

4P2 = 4! / 2! = 4 * 3 = 12

순열(파이썬)

  • 원순열 : 시작과 끝의 구분이 없는 순열
    - n! / n or (n-1)!

파이썬을 이용해서 다음 순열들의 값을 구하는 프로그램을 만들어 보자
8P3, 7P5

# 파이썬을 이용해서 다음 순열들의 값을 구하는 프로그램을 만들어 보자
# 8P3, 7P5

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

result = 1

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

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

4명의 친구가 원탁 테이블에 앉을 수 있는 순서를 계산

# 4명의 친구가 원탁 테이블에 앉을 수 있는 순서를 계산

num = int(input('친구 수 입력 : '))
result = 1
for i in range(1, num): # 1*2*3
    result *= i

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

조합

  • 조합 : n개에서 r개를 택하는 경우의 수
    - nCr = nPr / r! = n! / r!(n-r)! (단 0 < r <= n)

다음 조합의 값을 구하기

  • 8C3 = 8! / (3! (8-3)!) = 876 / 32*1 = 56
  • 7C5 = 7! / (5! 2!) = 76 / 2 = 21

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

5C2 = 5! / (2!3!) = 5 4 / 2 = 10
10 *0.01 = 0.1 10%

조합 (파이썬)

파이썬을 이용해서 다음 조합들의 값을 구하는 프로그램을 생성
8C3, 7C5

# 파이썬을 이용해서 다음 조합들의 값을 구하는 프로그램을 생성
# 8C3, 7C5


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 = resultP * n
print('resultR : {}' .format(resultP))

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


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

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

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

numN = 5
numR = 2

resultP = 1
resultR = 1
resultC = 1

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

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

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

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

resultC = int(resultP / resultR)
print('resultC : {}' .format(resultC))
print('확률 : {}' .format(resultC*0.01))

확률

  • 확률 : 모든 사건에서 특정 사건이 일어날 수 있는 수를 나타낸 것

박스에 ‘꽝’이 적힌 종이가 4장 있고, ‘선물’이 적힌 종이가 3장 있다. 3장을 뽑을 경우 다음 경우의 수를 구하기

꽝:0, 선물:3 → 1 / 7C3
꽝:1, 선물:2 → (4C1 3C2) / 7C3
꽝:2, 선물:1 → (4C2 3C1) / 7C3
꽝:3, 선물:0 → 4C3 / 7C3

박스에 ‘꽝’이 적힌 종이가 5장 있고, ‘선물’이 적힌 종이가 2장 있다. 3장을 뽑을 경우 다음 경우의 수를 구하기

꽝:3, 선물:0 → 1 / 7C3
꽝:2, 선물:1 → (5C2 2C1) / 7C3
꽝:1, 선물:2 → (5C1 2C2) / 7C3

💡 확률(파이썬)

💡 박스에 ‘꽝’이 적힌 종이가 4장 있고, ‘선물’이 적힌 종이가 3장이 있을 때, 파이썬을 이용해서 ‘꽝’2장과 ‘선물’ 1장을 뽑는 확률(%)을 출력

# 박스에 ‘꽝’이 적힌 종이가 4장 있고, ‘선물’이 적힌 종이가 3장이 있을 때,
# 파이썬을 이용해서 ‘꽝’2장과 ‘선물’ 1장을 뽑는 확률(%)을 출력

def proFun():
    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 i in range(numR,0,-1):
        resultR *= i
    print('resultR : {}' .format(resultP))

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

    return resultC

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

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

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

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

💻 출처 : 제로베이스 데이터 취업 스쿨

profile
zoe
#데이터분석 #퍼포먼스마케팅 #데이터 #디지털마케팅
이전 포스트

스터디노트(수학 1~3)

다음 포스트

스터디노트(기초수학 문제풀이 1~3)

0개의 댓글