연습 문제 풀이

약수 & 소수 & 소인수

# 100 ~ 1000사이의 난수에 대해서 약수, 소수, 소인수를 출력하자.
import random

n = random.randint(100,1000)
print(f'선택된 100 ~ 1000 사이의 숫자: {n}')
# 1. 약수
num_list = []

for i in range(1,n+1):
    if n % i == 0:
        num_list.append(i)

# 2. 소수
prime_list = []
for i in range(2,n+1): # 1은 소수가 아니기 때문에 일단 제외
    flag = True
    for num in range(2,i): # 2 ~ (자기자신 - 1)까지의 범주에서 나눠떨어지는 값이 있다면 소수가 아니다.
        if i % num == 0:
            flag = False
            break
    if flag:
        prime_list.append(i)

# 3. 소인수
# 2로 나누는 것부터 시작한다. -> 1은 소수가 아니기 때문에 제외
prime_only_list = []
a = 2
while a <= n:
    if n % a == 0: # 해당 값으로 나눠떨어질 때
        prime_only_list.append(a)
        n /= a
    else:
        a += 1

print(f'약수 출력: {num_list}')
print(f'소수 출력: {prime_list}')
print(f'소인수 출력: {prime_only_list}')
Python
복사

# 하나의 for 문안에서 해결해보기
import random

n = random.randint(100,1000)
print(f'선택된 100 ~ 1000 사이의 숫자: {n}')

num_list = []
prime_list = []
prime_only_list = []

for i in range(1,n+1):
		
		soinsuF = 0 # 소인수인지 확인할 변수 초기화
		
		# 약수
		if n % i == 0:
        num_list.append(i)
				soinsuF += 1

		# 소수
		if i != 1:
				flag = True
				for num in range(2,i):
						if i % num == 0:
								flag = False
								break
				if(flag):
						prime_list.append(i)
						soinsuF += 1

		# 소인수
		if soinsuF >= 2: # 약수이고 소수라면 
				prime_only_list.append(i)


print(f'약수 출력: {num_list}')
print(f'소수 출력: {prime_list}')
print(f'소인수 출력: {prime_only_list}')
Python
복사

# 100부터 1000사이의 난수를 소인수분해하고 각각의 소인수에 대한 지수를 출력하자.
import random

num = random.randint(100,1000)

# 소인수분해 하기
n = 2
print(f'100 ~ 1000 사이의 선택된 숫자 : {num}')
prime_number = []
while n <= num:
    if num % n == 0:
        prime_number.append(n)
        num /= n
    else:
        n += 1

print(f'소인수분해: {prime_number}')

tempNum = 0
for s in prime_number:
    if tempNum != s:
        print(f'소인수 {s}의 개수: {prime_number.count(s)}')
        tempNum = s
    else:
        continue
Python
복사

리스트의 중복되지 않는 원소별 개수를 순차적으로 출력하고 싶다고 할 때, 중복되게 count 를 하지 않게 하기 위한 tip 으로 임의의 tempNum = 0 변수를 초기화하여 활용하는 방법을 사용한다.

특정 원소에 대해 list.count(특정원소)로 개수를 카운트해준 뒤, tempNum = 특정원소 를 해주면 if tempNum ≠ s 라는 조건에 따라 중복된 특정 원소가 나온다면 카운트를 해주지 않게 된다.

최대공약수

# 100 ~ 1000 사이의 두 개의 난수에 대해 공약수와 최대공약수를 출력하고, 서로소인지 출력하자.
import random
n1 = random.randint(100,1000)
n2 = random.randint(100,1000)

# 공약수 확인
c_f = [] # common factor
gc_d = 0 # greatest common divisor


for i in range(1,min(n1,n2)+1):
    if n1 % i == 0 and n2 % i == 0: # 공약수인 조건
        c_f.append(i)
        # 최대공약수 세팅
        gc_d = i

print(f'{n1}와 {n2}의 공약수 : {c_f}')
print(f'{n1}와 {n2}의 최대공약수 : {gc_d}')

# 최대공약수가 1이라면 서로소
if gc_d == 1:
    print(f'{n1}과 {n2}는 서로소')
Python
복사

최소공배수

# 100부터 1000사이의 두 개의 난수에 대해 최대공약수와 최소공배수를 출력하자.

import random

n1 = random.randint(100,1000)
n2 = random.randint(100,1000)

# 1. 최대공약수
gc_d = 0
for i in range(1,min(n1,n2)+1):
    if n1 % i == 0 and n2 % i == 0:
        gc_d = i

# 마지막 변경된 gc_d 값이 최대공약수
# 최소공배수 = (n1 * n2) // gc_d
lc_m = (n1 * n2) // gc_d
print(f'{n1}과 {n2}의 최대공약수 : {gc_d}')
print(f'{n1}과 {n2}의 최소공배수 : {lc_m}')
Python
복사

진법

# 사용자가 입력한 10진수를 2,8,16진수로 변환하자.
Num = int(input('1보다 큰 정수 입력: '))

# 10진수 -> X진수 변환
print(f'{Num}의 2진수 변환: {bin(Num)}')
print(f'{Num}의 8진수 변환: {oct(Num)}')
print(f'{Num}의 16진수 변환: {hex(Num)}')

bi_Num = bin(Num)
oct_Num = oct(Num)
hex_Num = hex(Num)

# X진수 -> 10진수 변환 (int사용)
print(f'{bi_Num}의 10진수 변환: {int(bi_Num,2)}')
print(f'{oct_Num}의 10진수 변환: {int(oct_Num,8)}')
print(f'{hex_Num}의 10진수 변환: {int(hex_Num,16)}')

# X진수 -> X진수 변환 : 똑같이 bin(), oct(), hex(), int() 함수 사용하면 됨.
Python
복사

등차수열

# 수열의 일반항을 구하고 n번째항의 값과 합을 구하자.
a1 = int(input('첫째항 입력: '))
d = int(input('공차 입력: '))
n = int(input('구할 n번째 항의 n입력: '))

# n번째 항의 값
valueN = a1 + (n-1) * d
print(f'n번째 항의 값: {valueN}')

# n번째까지의 합
sumN = (a1 + valueN) * n / 2
print(f'n번째 항까지의 합: {int(sumN)}')
Python
복사

또는 전체 수열의 변화양상을 보고 싶다면

# 수열의 일반항을 구하고 n번째항의 값과 합을 구하자.
a1 = int(input('첫째항 입력: '))
d = int(input('공차 입력: '))
inputN = int(input('구할 n번째 항의 n입력: '))

valueN = 0; sumN = 0;
n = 1
while n <= inputN: # 첫째항 ~ 끝항까지
		if n == 1:
				valueN = a1
				sumN += valueN
				print('{}번째 항의 값: {}'.format(n,valueN))
				print('{}번째 항까지의 합: {}'.format(n,sumN))
				n += 1
				continue

		valueN += d
		sumN += valueN
		print('{}번째 항의 값: {}'.format(n,valueN))
		print('{}번째 항까지의 합: {}'.format(n,sumN))
		n += 1


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

등비수열

•

과정 보기 

# 등비수열의 일반항을 구하고 n번째 항의 값과 합을 구하자.
a1 = int(input('첫째항 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))

valueN = 0; sumN = 0;
n = 1
while n <= inputN:
    if n == 1: # 첫째항 포맷
        valueN = a1
        sumN += valueN
        print('{}번째 항의 값: {}'.format(n,valueN))
        print('{}번째 항까지의 합: {}'.format(n,sumN))
        n += 1
        continue

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

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

공식으로 한번에 하기

# 등비수열의 일반항을 구하고 n번째 항의 값과 합을 구하자.
a1 = int(input('첫째항 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))

valueN = a1 * inputR ** (inputN - 1)
print('{}번째 항의 값: {}'.format(inputN, valueN))
sumN = a1 * (1 - (inputR ** inputN)) / (1 - inputR)
print('{}번째 항까지의 합: {}'.format(inputN, int(sumN)))
Python
복사

시그마

# 첫째항이 2, 공비는 2일때, 30번째 항의 값과 합을 구해보자.
a1 = int(input('첫째항 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))

valueN = a1 * inputR ** (inputN - 1)
print('{}번째 날에 받게 되는 쌀의 양: {}'.format(inputN,valueN))
sumN = a1 * (1 - (inputR ** inputN)) / (1 - inputR)
print('{}번째 날까지 받게 되는 쌀의 양: {}'.format(inputN,int(sumN)))
Python
복사

# 만약 시그마를 이용해서 전체 sumN을 구한다고 하면
sumN = a1 * ((inputR ** inputN) - 1) / (inputR  - 1)
print('{}번째 날까지 받게 되는 쌀의 양: {}'.format(inputN,int(sumN)))
Python
복사

계차수열

# 계차수열의 일반항을 구하고, n항의 값을 출력하자
a1 = int(input('an의 첫째항 입력: '))
b1 = int(input('bn의 첫째항 입력: '))
bd = int(input('bn의 공차 입력: '))
inputN = int(input('구할 n항의 n입력: '))

# bn
valueBn = b1 + (inputN - 2) * bd

# sumBn
sumBn = (inputN - 1) * (b1 + valueBn) / 2

# an
valueAn = a1 + sumBn

print('계차수열의 {}번째 항의 값: {}'.format(inputN, int(valueAn)))
Python
복사

피보나치수열

# 피보나치수열에서 n항의 값과 n항까지의 합을 구하자.
inputN = int(input('n 입력: '))

valueN = 0; sumN = 0

# 전과 전전값을 저장할 변수 초기화
valuePre = 0
valuePre2 = 0

n = 1
while n <= inputN:
    if n == 1 or n == 2:
        valueN = 1
        valuePre = valueN
        valuePre2 = valueN
        sumN += valueN

        n += 1

    else:
        valueN = valuePre + valuePre2
        valuePre2 = valuePre
        valuePre = valueN
        sumN += valueN
        n += 1


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

팩토리얼

# 팩토리얼
import math
n = int(input('팩토리얼 구할 값 입력: '))
# 1. 반복문
def facFun(n):
    result = 1
    for i in range(1,n+1):
        result *= i
    return result

# 2. 재귀함수
def facFun2(n):

    if n == 1:
        return n

    return n * facFun2(n-1) 

# 3. 파이썬 모듈
module_result = math.factorial(n)

# 결과 출력
print(f'{n}! 반복문 결과 : {facFun(n)}')
print(f'{n}! 재귀함수 결과 : {facFun2(n)}')
print(f'{n}! 모듈 결과 : {module_result}')
Python
복사

군수열

# 군수열
# 수열의 합이 최초 100을 초과하는 n번째 항의 값과 n을 출력하자.
flag = True
n = 1 # 군을 의미하는 변수
nCnt = 1 # 항을 의미하는 변수
searchNC = 0; searchNP = 0 # 분모와 분자의 값을 의미하는 변수
sumN = 0
while flag:

    for i in range(1,(n+1)): # 군의 값만큼 반복
        print('{}/{} '.format(i, (n-i+1)), end='') # 분모와 분자 값을 구하기
        sumN = sumN + (i / (n-i+1))
        nCnt += 1

        if sumN > 100:
            searchNC = i
            searchNP = n-i+1
            flag = False
            break # for 문을 빠져나오는

    print()
    n += 1

print('수열의 합이 최초 100을 초과하는 항, 값, 합: {}항, {}/{} , {}'.format(nCnt, searchNC, searchNP, round(sumN,2)))
Python
복사

순열

# 순열을 구하자
numN = int(input('전체 n 입력: '))
numR = int(input('R 입력: '))

# nPr : n * (n-1) *... *(n-r+1)

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

print('result: {}'.format(result))
Python
복사

# 카드 7장을 일렬로 나열, 2,4,7번 카드가 서로 이웃하도록 나열하는 모든 경우의 수
import math
# 3장의 카드를 나열하는 경우의 수를 분모로 나누기
result = math.factorial(5) * math.factorial(3)
print('result: {}'.format(result))
Python
복사

조합

# 조합
inputN = int(input('전체 수 N 입력: '))
inputR = int(input('뽑는 수 R 입력: '))
import math
# n! / r!(n-r)!
n_Fact = math.factorial(inputN)
r_Fact = math.factorial(inputR)
n_rFact = math.factorial(inputN - inputR)
result = n_Fact / (r_Fact * n_rFact)
print(f'{inputN}C{inputR} : {int(result)}')
Python
복사

# 카드 7장 중 3장을 선택했을 떄, 3,4,5가 동시에 선택될 수 있는 확률?
# 일단 분자는 1
# 분모인 7C3 을 구하자
import math

result = math.factorial(7) / (math.factorial(3) * math.factorial(7-3))
print('확률 : {}%'.format(round((1/result)*100,2)))
Python
복사

확률

# 확률
# 꽝 : 6, 선물 : 4
# 꽝 3, 선물 3개를 뽑는 확률을 구하자.
# 조합으로 구하면 모두 해결된다. 6C3 * 4C3 / 10C6
import math
def johap(n,r):
    result = math.factorial(n) / (math.factorial(r) * math.factorial(n-r))
    return int(result)

print('확률 : {}%'.format(round((johap(6,3) * johap(4,3)) / johap(10,6)* 100, 2)))
Python
복사