2023.11.01 ~ 11.26
์ฝ๋ฉ์ ์ํ๊ณ ์ถ๋ค!
๋๋ด์ฃผ๊ฒ ํด์ ์ด๋ค ๋ฌธ์ ๋ , ํ๊ณ ์ถ์ ์ด๋ค ๊ฒ์ด๋ ์ฒ์ฒ ์ฝ๋ฉ ํด๋ด๊ณ ์ถ๋ค!!!!!!!!!!!!!!!!!!
ํ์ง๋ง, ๐ถ๋งํ ๋๋์ด ์๋ค.
Q.
์ด๋ฆ์ด tmp์ธ ํฌ๊ธฐ๊ฐ 0์ธ ๋ฆฌ์คํธ ๋ฐ์ดํฐ๋ฅผ ๋ง๋์์ค.
๋ต : []
tmp = []
print(tmp)
โผ
[]
Q.
data_type ์ด๋ผ๋ ์ด๋ฆ์ ๋ฐ์ดํฐํ์ ํ๋ณํ๋ ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ์ด ํจ์๋ ํ๋์ ์
๋ ฅ์ ๋ฐ์์ ๋ฐ์ดํฐํ์ ์์๋ด์ผ ํฉ๋๋ค. Int, float, string, list, dict, tuple ๋ฑ์ ์์์ผ ํ๋ฉฐ, ๋ง์ฝ list ํ ๋ฐ์ดํฐ๋ผ๋ฉด list ํ ๋ฐ์ดํฐ ์์ ์๋ ๊ฐ ๋ฐ์ดํฐ์ ๋ฐ์ดํฐํ์
๋ ๋ฐํํด์ผ ํฉ๋๋ค. ์๋ ์คํ ์์๋ฅผ ํ์ธํด ์ฃผ์ธ์
โ ๋ต : list, <int, int, list <int, int>, string>
def data_type(value):
if type(value) == list:
result = []
for i in value:
result.append(type(i))
return list, result
else:
result = type(value)
return result
print("2๋ฒ ๋ต์")
print(data_type([2, 3, [2, 3], "Hello"]))
โผ
(<class 'list'>, [<class 'int'>, <class 'int'>, <class 'list'>, <class 'str'>])
Q.
์ฐ๋ฆฌ๋๋ผ์ ๋ฌ๋ฆฌ ๋ฏธ๊ตญ์ ๊ฐ๋จํ ์์ฌ๋ง ํด๋ ํ์ ์ฃผ๋ ๋ฌธํ๊ฐ ์์ต๋๋ค. ๊ทธ๋์ ํ์ ๊ณ์ฐํ๋ ํจ์๋ฅผ ๋ง๋ค๋ฉด ์ข๊ฒ ์ต๋๋ค. ํ์ ํจ์์์ ์
๋ ฅ ๋ฐ๋๋ก ํ์ฃ . ํ์ ๊ณ์ฐํ๋ ํจ์๋ calc_tips๋ผ๋ ์ด๋ฆ์ผ๋ก ํ๊ณ , ์
๋ ฅ์ ์ ์ฒด ๊ธ์ก, ํ ๋น์จ๋ก ํ๋ฉด ๋๊ฒ ๋ค์. ํน์ ์ฌ์ฉ์๊ฐ ํ ๋น์จ์ ์
๋ ฅํ์ง ์์ผ๋ฉด ๋ํดํธ๋ก 10%๋ฅผ ์ ์ฉํ๋๋ก ํด์ฃผ์ธ์. ๊ทธ๋ฐ๋ฐ, 1๋ฌ๋ฌ ๋จ์๋ก ๋ฑ๋ฑ ๋จ์ด์ก์ผ๋ฉด ์ข๊ฒ ์ต๋๋ค. ๋์ ์ ๋ค๊ณ ๋ค๋๋๊ฑด ๋ถํธํ๋๊น์. ๊ทธ๋์ ๋ง์ฝ ๊ณ์ฐํ๋๋ฐ, 5.6๋ฌ๋ฌ๊ฐ ๋์ค๋ฉด ๊ทธ๋ฅ 6๋ฌ๋ฌ๋ก, 5.1๋ฌ๋ฌ๊ฐ ๋์๋ ๊ทธ๋ฅ 6๋ฌ๋ฌ๋ก ๊ณ์ฐํ๋๋ก ํด์ฃผ์ธ์. ํจ์์ ๊ฒฐ๊ณผ๋ return์ด ์๋๋ผ print๊ฐ ๋๋๋ก ํด์ฃผ์ธ์.
import random
totalPrice = random.randint(100, 500)
from math import ceil
tipPercnt = 0.1
def calc_tips(totalPrice, tipPercnt): #ํ์ ๊ณ์ฐํ๋ ํจ์
tipPrice = ceil(totalPrice * tipPercnt)
print(f'ํ ๊ฐ๊ฒฉ : {tipPrice}๋ฌ๋ฌ')
print("3๋ฒ ๋ต์")
print(f'์ ์ฒด๊ธ์ก : {totalPrice}๋ฌ๋ฌ')
calc_tips(totalPrice, tipPercnt)
โผ
์ ์ฒด๊ธ์ก : 444๋ฌ๋ฌ
ํ ๊ฐ๊ฒฉ : 45๋ฌ๋ฌ
Q.
์ฌ๋ฌ ๋ฌธ์ฅ์ผ๋ก ๋ ๋ฌธ์๋ฅผ ์
๋ ฅ๋ฐ์์ ๋งค์นญ๋๋ ๋ฌธ์์ด์ ํ์์ ํด๋น ๋ฌธ์์ด์ ์์น(index)๋ฅผ ์๋ ค์ฃผ๋ search_target์ด๋ผ๋ ์ด๋ฆ์ ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
โ ๋ต : 3, [20, 50, 82]
def search_target(sentence, target):
number = 0
index = []
n = 0
while n < len(sentence):
n = sentence.find(target, n)
if n == -1:
break
else:
number += 1
index.append(n)
n += 1
print(f'{number},{index}')
print("4๋ฒ ๋ต์")
sentence = ("Beautiful is better than ugly. "
"Explicit is better than implicit. "
"Simple is better than complex.")
target = "than"
search_target(sentence, target)
โผ
3,[20, 50, 82]
Q.
์ฌ๋ฌ๋ถ๋ค์ div_ab๋ผ๋ ์ด๋ฆ์ ํจ์๋ฅผ ํ๋ ๋ง๋ค์ด ์ฃผ์ธ์. ์ด ํจ์๋ ์
๋ ฅ ์ธ์๋ก a, b๋ฅผ ๋ฐ์ผ๋ฉฐ, ๋ฐ์ ์ธ์์ ์ฒซ ๋ฒ์งธ๋ฅผ a, ๋ ๋ฒ์งธ๋ฅผ b๋ผ๊ณ ํฉ๋๋ค. ์ด ํจ์๋ ์
๋ ฅ ์ธ์๊ฐ ๊ผญ ์ ์์ฌ์ผ ํ๋ฉฐ, ํจ์ ์ฝ๋ ๋ด๋ถ์์ ์ ์์ธ์ง ์๋์ง๋ฅผ ํ๋ณํ๋๋ก ํด์ ์ ์์ผ ๋๋ง ๋๋์
์ ์ํํ๋๋ก ํด์ฃผ์ธ์. ํจ์์ ์ถ๋ ฅ(return)์ ์๊ณ , ํจ์์ ๋ง์ง๋ง์ print ๋ฌธ์ผ๋ก a / b๋ฅผ ๊ณ์ฐํ๋ ๋๋์
์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ํจ์์
๋๋ค. ์ถ๋ ฅ์ ํํ๋ ์ ํํ๊ฒ๋ ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ ํจ์์
๋๋ค. ์ถ๋ ฅ์ ์ฒซ ๋ฒ์งธ ํญ์ ๋ชซ, ๋ ๋ฒ์งธ ํญ์ ๋๋จธ์ง๊ฐ ๋๋๋ก ์ฝ๋๋ฅผ ์์ฑํด ์ฃผ์ธ์. ์ฌ๋ฌ๋ถ์๊ฒ ํ ๊ฐ์ง ์ํ๊น์ด ์์์ div_ab๋ผ๋ ํจ์๋ฅผ ๋ง๋ค ๋ ๋๋์
๊ธฐํธ( / )๋ ์ด๋ค ๋ชจ๋์ด๋ ๋๋์
์ ์ง์ ์ํํ๋ ๋ช
๋ น์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋๋์
๋ช
๋ น ์์ด ๋๋์
์ ์ํํด ์ฃผ์ธ์.
โ ๋ต : 3๋๋๊ธฐ 2์ ๊ฒฐ๊ณผ : ๋ชซ 1, ๋๋จธ์ง 1
def div_ab(a, b):
if type(a) == int and type(b) == int:
num1 = 0
numA = a
numB = b
n = 0
while True:
if numA < numB:
break
else:
numA -= numB
num1 += 1
n += 1
mod = numB - numA
print(f'{a}๋๋๊ธฐ {b}์ ๊ฒฐ๊ณผ: ๋ชซ{num1}, ๋๋จธ์ง{mod}')
print("5๋ฒ ๋ต์")
a = 3
b = 2
div_ab(a, b)
โผ
3๋๋๊ธฐ 2์ ๊ฒฐ๊ณผ: ๋ชซ1, ๋๋จธ์ง1
Q.
ํ๋
ธ์ดํ ๋ฌธ์ ๊ฐ ์์ต๋๋ค. ์๋ ์ฒจ๋ถ๋ ์ฌ์ง์ ๊ธ์๊ฐ ํ๋ฆฟํ์ง๋ง ์ ๊ฒฝ์ฐ์ง ์์๋ ๋ฉ๋๋ค. ์๋ ๊ทธ๋ฆผ์ ์ค๋ช
ํด ๋ณด๊ฒ ์ต๋๋ค. ํฌ๊ธฐ ์์ผ๋ก ์์ฌ์๋ ์๋ฐ ์ธ ๊ฐ๊ฐ ์์ต๋๋ค. ์ด ์๋ฐ์ A, B, C ์ฅ์ ์ค ํ์ฌ๋ A์ ์์ต๋๋ค. ํ๋
ธ์ด ํ ๋ฌธ์ ๋ ์์ ์๋ฐ ์์ ํฐ ์๋ฐ์ด ์ฌ๋ ค์ง ์ ์๋ค๋ ๊ฒ๊ณผ ํ ๋ฒ์ ํ๋๋ง ์ฎ๊ธธ ์ ์๋ค๋ ๊ฒ์ ์ง์ผ์ผ ํฉ๋๋ค. A์์ C๋ก ๊ฐ์๊ธฐ ๊ฑด๋๊ฐ๋ ๊ฒ์ ๊ด์ฐฎ์ต๋๋ค.
์ฌ๋ฌ๋ถ์ Python์ผ๋ก ์๋ ๊ทธ๋ฆผ์ ๋ฌ์ฌ๋ ํ๋
ธ์ด ํ ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํฉ๋๋ค. ์ฌ๋ฌ๋ถ์ ๋ฌธ์ ๋ ํ๋
ธ์ดํ ์๋ฐ์ ๊ฐ์๋ n๊ฐ์
๋๋ค. ์ด n๊ฐ์ ์๋ฐ์ B ์ง์ ํน์ C ์ง์ ์ผ๋ก ์ฎ๊ธธ ์ ์์ด์ผ ํฉ๋๋ค. ์ฆ, ํ๋
ธ์ดํ ๋ฌธ์ ๋ฅผ ํ ์ฌ๋ฌ๋ถ์ด ์์ฑํด ์ฃผ์ด์ผํ ํจ์๋ ์๋ฐ์ ๊ฐ์(n)์ ์ด๋์ ์๋ฐ์ด ์์ํ๊ณ (start_point) ์ด๋์ ์ฎ๊ธฐ๋์ง(end_point)๋ฅผ ์
๋ ฅ๋ฐ์์ผ ํฉ๋๋ค.
โ ๋ต :
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
def hanoi_sol(discCnt, fromBar, toBar, viaBar):
if discCnt == 1:
print(f'{fromBar} โ {toBar}')
else:
hanoi_sol(discCnt-1, fromBar, viaBar, toBar)
# (discCnt-1)๊ฐ๋ค์ ๊ฒฝ์ ๊ธฐ๋ฅ์ผ๋ก ์ด๋
print(f'{fromBar} โ {toBar}')
# discCnt์ ๋ชฉ์ ๊ธฐ๋ฅ์ผ๋ก ์ด๋
hanoi_sol(discCnt-1, viaBar, toBar, fromBar)
# (discCnt-1)๊ฐ๋ค์ ๋์ฐฉ ๊ธฐ๋ฅ์ผ๋ก ์ด๋
#3๊ฐ์ ์ํ์, 1๋ฒ ์ถ๋ฐ๊ธฐ๋ฅ ๋ถํฐ ์์ํด์, 2๋ฒ ๋์ฐฉ๊ธฐ๋ฅ ๊น์ง ์ฎ๊ธฐ๊ฒ ๋ค, ๊ฒฝ์ ๊ธฐ๋ฅ์ 3๋ฒ ์ด๋ค
hanoi_sol(3, 'A', 'B', 'C')
โผ
A โ B
A โ C
B โ C
A โ B
C โ A
C โ B
A โ B