[스터디노트] 기초 수학2 (등비수열, 등차수열, 시그마, 계차수열, 피보나치수열, 팩토리얼, 군수열, 순열, 조합, 확률)

이수연·2024년 6월 16일
0

수열, 항들의 합과 항의 관계

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

  • 항들의 합과 항의 관계

등차수열

  • 등차 수열: 연속된 두 항의 차이가 일정한 수열!
    • 공차: 일정한 차이가 나는 수
  • 등차 수열 규칙성을 이용해서 일반항을 구할 수 있다
  • 등차 중항: 연속된 세 항에서 가운데 항
    • (17 + 25 = 21 * 2 = 42) / 2 = 21(등차중항)
  • 등차 수열의 합

< 파이썬 실습 >

  • 다음 수열에서 n번째 항의 값을 출력하는 프로그램을 만들어보자.
    • an = {2, 5, 8, 11, 14, 17, 20, 23, 26, 29, ~}
inputN1 = int(input('a1 입력: '))
inputD = int(input('d(공차) 입력: '))
inputN = int(input('n 입력: '))

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

<Output>
a1 입력: 2
n 입력: 6
d(공차) 입력: 3
6번째 항의 값: 17

-----

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

valueN = 0  #n번째 항의 값
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(f'입력하신 {inputN}번째에 해당하는 값은 {valueN}입니다.')

<Output>
a1 입력: 2
d(공차) 입력: 3
n 입력: 7
1번째 항의 값: 2
2번째 항의 값: 5
3번째 항의 값: 8
4번째 항의 값: 11
5번째 항의 값: 14
6번째 항의 값: 17
7번째 항의 값: 20
입력하신 7번째에 해당하는 값은 20입니다.
  • n번째 항까지의 합을 출력하는 프로그램을 만들어보자.
inputN1 = int(input('a1 입력: '))
inputD = int(input('d(공차) 입력: '))
inputN = int(input('n 입력: '))

# n번째 항의 값
valueN = inputN1 + (inputN-1)*inputD

# n번째 항까지의 합
sumN = inputN * (inputN1 + valueN)/2 #나눗셈의 결과는 항상 실수
print(f'{inputN}번째 항까지의 합은 {int(sumN)}입니다.')

<Output>
a1 입력: 5
d(공차) 입력: 4
n 입력: 3
3번째 항까지의 합은 27입니다.

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

valueN = 0  #n번째 항의 값
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}입니다.')

<Output>
a1 입력: 5
d(공차) 입력: 4
n 입력: 4
1번째 항의 값: 5
2번째 항까지의 합: 14
3번째 항까지의 합: 27
4번째 항까지의 합: 44
입력하신 4번째까지의 합은 44입니다.

등비수열

  • 등비수열: 연속된 두 항의 비가 일정한 수열
    • 공비(r): 일정한 비
  • 등비 수열 규칙성을 이용해서 일반항 구하기
  • 등비 중항: 연속된 세 항에서 가운데 항
    • 이전 항과 다음 항의 곱은 등비 중항의 제곱값과 같다
  • 등비수열의 합: 규칙성을 이용해서 모든 항들의 총합을 구할 수 있음.

<파이썬 실습>

  • 등비수열의 n번째 항의 값 구하기
  • 등비수열의 n번째 항까지의 합 구하기
# 등비수열: 일정한 비로 증가하는 숫자의 나열
inputN1 = int(input('a1 입력: '))
inputR = int(input('공비(r) 입력: '))
inputN = int(input('n 입력: '))

valueN = 0
n = 1
sumN = 0
nums = []

while n <= inputN:

    if n == 1:
        valueN = inputN1
        sumN += valueN
        nums.append(valueN)
        n += 1
        continue

    valueN *= inputR
    nums.append(valueN)
    sumN += valueN
    n += 1
print(f'{inputN}번째까지의 나열: {nums}')
print(f'{inputN}번째 항까지의 합: {sumN}')

# 등비수열 일반항 구하기 공식 사용하기: an = a1*r^(n-1)
valueN = inputN1 * (inputR ** (inputN-1))
print(f'[공식 사용] {inputN}번째 항의 값: {valueN}')

# 등비수열의 합 공식 사용하기: sn = a1 * (1-(r^n)/(1-r)
valueN = inputN1 * (1-(inputR**inputN)) / (1-inputR)
print(f'[공식 사용] {inputN}번째까지 항의 합: {int(sumN)}')

<Output>
a1 입력: 2
공비(r) 입력: 2
n 입력: 6
6번째까지의 나열: [2, 4, 8, 16, 32, 64]
6번째 항까지의 합: 126
[공식 사용] 6번째 항의 값: 64
[공식 사용] 6번째까지 항의 합: 126

시그마(Σ)

  • 시그마(Σ)란, 수열의 합을 나타내는 기호

계차 수열

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


    <파이썬 실습>
# 계차수열
# an = {3, 7, 13, 21, 31, 43, 57}
# bn =  {4,  6,  8,  10, 12, 14}  => 공차라 2인 등차수열

inputAN1 = int(input('a1 입력: '))
inputAN = int(input('an 입력: '))
inputBN1 = int(input('b1 입력: '))
inputBD = int(input('bn의 공차(d) 입력: '))

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
        continue

    valueAN = valueAN + valueBN
    valueBN = valueBN + inputBD
    print(f'an의 {n}번째 항의 값: {valueAN}')
    print(f'bn의 {n}번째 항의 값: {valueBN}')
    n += 1

<Output>
a1 입력: 3
an 입력: 7
b1 입력: 4
bn의 공차(d) 입력: 2
an의 1번째 항의 값: 3
bn의 1번째 항의 값: 4
an의 2번째 항의 값: 7
bn의 2번째 항의 값: 6
an의 3번째 항의 값: 13
bn의 3번째 항의 값: 8
an의 4번째 항의 값: 21
bn의 4번째 항의 값: 10
an의 5번째 항의 값: 31
bn의 5번째 항의 값: 12
an의 6번째 항의 값: 43
bn의 6번째 항의 값: 14
an의 7번째 항의 값: 57
bn의 7번째 항의 값: 16

-------

# 계차수열의 합: n^2 + n + 1 = an
# bn이 등차수열이니까 등차수열의 일반항 공식: bn = b1 + (n-1) * d
# bn = 4 + (n-1) * 2 = 2n + 2
# 등차수열 bn의 k-1까지의 합: n(b1 + bn) / 2  -> n에 k-1 대입
# (k-1) * (4 + (2(k-1) + 2)) / 2 = (k-1) * (2k +4) / 2 = (k-1)(k+2) = k^2 + k -2
# 1부터 (n-1)까지 bn의 합 = an - a1   -> an = a1 + (1부터 (n-1)까지 bn의 합)
# an = k^2 + k -2 + 3 = k^2 +k + 1
valueAN = inputAN ** 2 + inputAN + 1
print(f'[공식 사용] an의 {inputAN}번째 항의 값: {valueAN}')

<Output>
[공식 사용] an의 7번째 항의 값: 57

피보나치 수열

  • 세번째 항 = 첫번째 항 + 두번째 항

    <파이썬 실습>
# 피보나치 수열: n3 = n2 + n1  --->  {1, 1, 2, 3, 5, 8, 13, 21 }

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

valueN = 0
sumN = 0

preN2 = 0  #2번째 전
preN1 = 0  #1번째 전 = 바로 이전

n = 1
while n <= inputN:
    if n == 1 or n == 2:
        valueN = 1
        preN2 = valueN
        preN1 = valueN
        sumN += valueN  # n==1, sumN = 1 ---> n==2, sumN = 1+1 =2
        n += 1

    else:
        valueN = preN2 + preN1   #n=3, value= 이전+이이전 = 1+1 =2
        
        # 다음 반복문을 위해 미리 처리
        preN2 = preN1 # 다음 회차에 이이전의 값이 이전의 값이 되어야 하고
        preN1 = valueN  #바로 이전의 값은 현재 회차의 value값이 되어야 함

        sumN += valueN
        n += 1

print(f'{n}번째 항의 값: {valueN}')
print(f'{n}번째 항까지 값: {sumN}')

<Output>
n번째 입력: 6
7번째 항의 값: 8
7번째 항까지 값: 20

팩토리얼

  • 팩토리얼: 1부터 양의 정수 n까지의 정수를 모두 곱한 것
  • 재귀함수: 나 자신을 다시 호출하는 함수
inputN = int(input('n 입력: '))

result = 1
for n in range(1, inputN+1):   #5! = 5*4*3*2*1
    result *= n
print(f'{inputN} 팩토리얼({inputN}!): {result}')

<Output>
n 입력: 5
5 팩토리얼(5!): 120

------------------------------------------
# n == 1이 될 때까지 factorialFun(n-1)에 들어가면서 함수를 호출하여 곱셈을 더할 수 있음
# factorialFun(3) 을 실행하면, 3 * factorialFun(2) = 3 * (2 * factorialFun(1)) = 3 * (2 * 1)

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

    return n * factorialFun(n-1)

print(f'{inputN} 팩토리얼({inputN}!): {factorialFun(inputN)}')

------------ math 내장함수 사용하기------------ 
import math
math.factorial(inputN)

군수열

  • 50번째 항을 구해보자
    1) 군별로 항의 개수: 1,2,3,4,5, ~ => 공차가 1인 등차수열, 즉 sn = 50인 n을 찾으면 된다
    • an = a1 + (n-1)*d
    • sn = n(a1 + an)/2
    • n(1 + 1 + (n-1)1) /2 = n(n+1)/2 = (n^2+n)/2
      => 9 대입: (9      9+9)/2 = 45 -> 9번째 군의 마지막 항이 45번째 항.
      => 10번째 군의 5번째 항은 50번째 항이기 때문에, 50번째 항의 값은 5

<파이썬 실습>

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

flag = True
n = 1; #1군부터 시작
nCnt = 1; #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))

<Output>
n항 입력: 13
1 
1, 2 
1, 2, 3 
1, 2, 3, 4 
1, 2, 3, 
13항: 3

순열

  • 순열: n개에서 r개를 선택하여 순서 있게 나열하는 경우의 수
    • 8P3 = 8!/5! = 876 = 336
    • 7P5 = 7!/2! = 76543 = 2520
  • 실습 문제
    • 세모 카드와 네모 카드를 1장으로 생각
      -> 3장을 뽑을 수 있는 경우의 수: 3! = 3*2 = 6
      -> 세모 카드와 네모 카드의 배열 경우의 수: 2! = 2
      => 6 X 2 = 12

< 파이썬 실습 >

  • 8P3, 7P5 순열의 값을 구하는 프로그램 만들기
numN = int(input('N 입력: '))
numR = int(input('R 입력: '))

result = 1

for n in range(numN, (numN-numR), -1):  #range의 최대를 numN-numR으로 설정해야, numN-numR+1까지 계산 가능
    result *= n
    print(f'n: {n}')
print(f'{numN}P{numR} result: {result}')

<Output>
N 입력: 8
R 입력: 3
n: 8
n: 7
n: 6
8P3 result: 336
------
N 입력: 7
R 입력: 5
n: 7
n: 6
n: 5
n: 4
n: 3
7P5 result: 2520
  • 1~7까지 7장을 7번 뽑는데, 2,4,7이 서로 이웃하도록 나열하는 모든 경우의 수는?
    • '[1, (2,4,7), 3, 5, 6] 로 5장을 순서 있게 나열하는 것'과 '[2, 4, 7] 3장을 순서 있게 나열'하는 값의 곱
    • 즉, 5P5 X 3P3 = 5! X 3! = 720

def calP(numN, numR):
    result = 1
    for n in range(numN, (numN-numR), -1):  #range의 최대를 numN-numR으로 설정해야, numN-numR+1까지 계산 가능
        result *= n
        print(f'n: {n}')
    print(f'{numN}P{numR} result: {result}')
    return result

print(f'5P5 X 3P3 result: {calP(5,5) * calP(3,3)}')

<Output>
n: 5
n: 4
n: 3
n: 2
n: 1
5P5 result: 120
n: 3
n: 2
n: 1
3P3 result: 6
5P5 X 3P3 result: 720

원순열

  • 원순열: 시작과 끝의 구분이 없는 순열
    • {1,2,3}을 원모양으로 나열하면, 순서가 사라지면서 노란색과 초록색 경우만 나옴 => 3!/3 = 2

      < 파이썬 실습 >
  • 4명의 친구가 원탁 테이블에 앉을 수 있는 순서 계산해보기

조합

  • 순열: 순서 상관있게 r개 선택
  • 조합: 순서 상관없이 r개 선택
  • nCr = nPr/r! = n!/(n-r)!r!
print('[nCr 구하기] nPr/r! 공식 활용 ver.')
numN = int(input('N 입력: '))
numR = int(input('R 입력: '))

resultP = 1
resultR = 1
resultC = 1

for n in range(numN, (numN-numR), -1):  #range의 최대를 numN-numR으로 설정해야, numN-numR+1까지 계산 가능
    resultP *= n
    print(f'n: {n}')
print(f'{numN}P{numR} result: {int(resultP)}')

for r in range(numR, 0, -1):
    print(f'r: {r}')
    resultR *= r

resultC = int(resultP / resultR)

print(f'{numN}C{numR} result: {resultC}')

[nCr 구하기] nPr/r! 공식 활용 ver.
N 입력: 8
R 입력: 3
n: 8
n: 7
n: 6
8P3 result: 336
r: 3
r: 2
r: 1
8C3 result: 56
  • 1/5C2: 5장 중 2장 순서없이 선택할 수 있는 경우의 수 중, 삼각형+사각형의 조합은 딱 1개
  • 카드 7장 중 3장을 선택했을 때 3, 4, 5가 동시에 선택될 수 있는 확률은? 답: 1/5C3 
(위 코드에 아래 코드 추가)
result = 1/resultC*100
print(f'{numN}장 중 {numR}장 뽑을 때 3,4,5 조합일 경우의 수: {round(result, 2)}%')
<Output>
5장 중 3장 뽑을 때 3,4,5 조합일 경우의 수: 10.0%

확률

  • 확률: 전체 사건에서 특정 사건이 일어날 수 있는 수
  • 모든 사건 = 표본 공간
  • 특정 사건 = 사건
    [동전]
    • 모든 사건: 앞, 뒤 -> 2가지 경우
    • 특정 사건: 앞 -> 1가지 경우 / 뒤 -> 1가지 경우
    • 확류: 앞 -> 1/2, 뒤 -> 1/2
  • 조합을 이용해서 확률을 알아낼 수 있다.
def calP(numN, numR):
    resultP = 1

    for n in range(numN, (numN - numR), -1):
        resultP *= n

    print(f'{numN}P{numR} result: {resultP}')
    return resultP
def calC(numN, numR):
    resultR = 1
    resultC = 1

    #nPr 순열 구하기: resultR
    resultP = calP(numN, numR)

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

    #nCr 조합 구하기: resultC
    resultC = int(resultP / resultR)

    print(f'{numN}C{numR} result: {resultC}')
    return resultC


pb = calC(4,2)*calC(3,1)/calC(7,3)*100
print(f'prob: {round(pb,2)}%')

<Output>
4P2 result: 12
4C2 result: 6
3P1 result: 3
3C1 result: 3
7P3 result: 210
7C3 result: 35
prob: 51.43%
profile
이수연
이전 포스트

통계학 1. 기초 이산형/연속형 확률 변수

다음 포스트

[자료 구조] 리스트: for/while 반복문, enumerate(), append, insert, pop, del, remove, extend, sort, reverse, slice, index, count

0개의 댓글