11์ ๋ง์ง๋ง์ฃผ ์ฃผ๋ง ๋ฆฌ๋ทฐ
๋์ฒด๋ก ์ด๋๊ณผ ๊ณต๋ถ๋ก ์ฃผ๋ง ์๊ฐ์ ๋ณด๋๋ค. 12์์ด ๋๊ธฐ ์ ๋ค์ ๊ฐ๊ฐ์ ๋์ด์ฌ๋ ค ์ฝ๋ฉํ
์คํธ ์ค๋น๋ฅผ ํ๋ ์ค!
- ์ค์ ์คํ ์ฐ์ฑ & ํฌ์ค
- ์คํ ์๋ฐ
- Coding test study (Programmers)
์ฃผ๋ง์ด ๋์๋ง์ ์ค๋๋ง์ ๊ฐ์์ง ์ฐ์ฑ ์ ํด์ฃผ์๋ค. ํจ๋ฉ๊น์ง ์ ํ๊ฐ๋ฉด์๐
๋ฌธ์ ์ค๋ช
S์ฌ์์๋ ๊ฐ ๋ถ์์ ํ์ํ ๋ฌผํ์ ์ง์ํด ์ฃผ๊ธฐ ์ํด ๋ถ์๋ณ๋ก ๋ฌผํ์ ๊ตฌ๋งคํ๋๋ฐ ํ์ํ ๊ธ์ก์ ์กฐ์ฌํ์ต๋๋ค. ๊ทธ๋ฌ๋, ์ ์ฒด ์์ฐ์ด ์ ํด์ ธ ์๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์๋ ์์ต๋๋ค. ๊ทธ๋์ ์ต๋ํ ๋ง์ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์ ์๋๋ก ํ๋ ค๊ณ ํฉ๋๋ค.
๋ฌผํ์ ๊ตฌ๋งคํด ์ค ๋๋ ๊ฐ ๋ถ์๊ฐ ์ ์ฒญํ ๊ธ์ก๋งํผ์ ๋ชจ๋ ์ง์ํด ์ค์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 1,000์์ ์ ์ฒญํ ๋ถ์์๋ ์ ํํ 1,000์์ ์ง์ํด์ผ ํ๋ฉฐ, 1,000์๋ณด๋ค ์ ์ ๊ธ์ก์ ์ง์ํด ์ค ์๋ ์์ต๋๋ค.
๋ถ์๋ณ๋ก ์ ์ฒญํ ๊ธ์ก์ด ๋ค์ด์๋ ๋ฐฐ์ด d์ ์์ฐ budget์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋ ๋ช ๊ฐ์ ๋ถ์์ ๋ฌผํ์ ์ง์ํ ์ ์๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
- ์ ํ์ฌํญ
d๋ ๋ถ์๋ณ๋ก ์ ์ฒญํ ๊ธ์ก์ด ๋ค์ด์๋ ๋ฐฐ์ด์ด๋ฉฐ, ๊ธธ์ด(์ ์ฒด ๋ถ์์ ๊ฐ์)๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
d์ ๊ฐ ์์๋ ๋ถ์๋ณ๋ก ์ ์ฒญํ ๊ธ์ก์ ๋ํ๋ด๋ฉฐ, ๋ถ์๋ณ ์ ์ฒญ ๊ธ์ก์ 1 ์ด์ 100,000 ์ดํ์ ์์ฐ์์ ๋๋ค.
budget์ ์์ฐ์ ๋ํ๋ด๋ฉฐ, 1 ์ด์ 10,000,000 ์ดํ์ ์์ฐ์์ ๋๋ค.
def solution(d, budget):
answer = 0
d.sort()
for i in range(len(d)):
if d[i] <= budget:
answer += 1
budget -= d[i]
else:
break
return answer
์ฃผ์ด์ง ์์ฐ(budget)์ ๋์ง ์๋ ๋ถ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ก, d (๋ถ์ ๋ฆฌ์คํธ)๋ฅผ ์ฐ์ ๋น์ฉ ์์๋๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ ์ดํ ๊ฐ ๋ถ์ ๋ณ cost๊ฐ budget์ ๋์ง ์๋๋ค๋ฉด answer += 1, ์์ฐ -= ์ถ๊ฐํด์ค ๋ถ์ ๋น์ฉ์ผ๋ก for๋ฌธ์ ๋ ์ดํ, ์์ฐ์ ๋์ด๊ฐ๋ ๊ฒฝ์ฐ breakํ๋ ์ข ๋ฃ ์กฐ๊ฑด์ ์ค์ ํด์ฃผ๋ ๋จ์ ๊ตฌํ ๋ฌธ์
- ์ค์ ์บ์น๋ณผ
- ์คํ SQL Study
- Coding test study (Programmers)
ํ์ฌ ์ธํด์ผ๋ก ๋ง๋ ์ฌ๋๋ค๊ณผ ์ค์ ์บ์น๋ณผ!
๋ฌธ์ ์ค๋ช
๋ ์๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ ์์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ๋ณด์ธ์. ๋ฐฐ์ด์ ๋งจ ์์ ์ต๋๊ณต์ฝ์, ๊ทธ๋ค์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฃ์ด ๋ฐํํ๋ฉด ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ ์ 3, 12์ ์ต๋๊ณต์ฝ์๋ 3, ์ต์๊ณต๋ฐฐ์๋ 12์ด๋ฏ๋ก solution(3, 12)๋ [3, 12]๋ฅผ ๋ฐํํด์ผ ํฉ๋๋ค.
- ์ ํ ์ฌํญ
๋ ์๋ 1์ด์ 1000000์ดํ์ ์์ฐ์์ ๋๋ค.
def solution(n, m):
answer = []
for i in range(min(n, m), 0, -1):
if n%i == 0 and m%i == 0:
answer.append(i)
break
for i in range(max(n, m), n*m+1):
if i%n == 0 and i%m == 0:
answer.append(i)
break
return answer
์ฃผ์ด์ง ์
๋ ฅ ๊ฐ n, m์ด ๋ชจ๋ 1๋ฐฑ๋ง ์ดํ์ ์์ฐ์๋ผ๋ ๊ฒ์ ์ฃผ์ํ์ฌ ๋ฌธ์ ๋ฅผ ํ์๋ค.
๊ธฐ๊ปํด์ผ for๋ฌธ 1๋ฒ ์ ๋๋ก ํด๊ฒฐ ๊ฐ๋ฅํ ๋ฌธ์ ์์ ์๊ฒ ๋์๋ค.
์ด์ ๊น์ง ์ฝ์์ ๊ฐ์ ๋ฑ์ ๋ฌป๋ ๋ฌธ์ ๋ง์ ํ์๊ธฐ์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ์ ๊ทผํ๋ ๋ฐฉ์์ ๋ํด ์๊ฒ ๋ ๋ฌธ์ ๋ค.
- ์ต๋๊ณต์ฝ์์ ๊ฒฝ์ฐ, ์ฃผ์ด์ง ์ ๋ ฅ๊ฐ ์ค (์ต์๊ฐ~0)์ ๋ฒ์๋ฅผ ์ด์ฉํ์ฌ n, m์ผ๋ก ๋ชจ๋ ๋๋์ด์ง๋ ๊ฒฝ์ฐ์ ์๋ฅผ answer์ ์ถ๊ฐํ๋ ๋ฐฉ์์ผ๋ก ์ฝ๋๋ฅผ ์งฐ๊ณ
์ต์๊ณต๋ฐฐ์์ ๊ฒฝ์ฐ, ์ฃผ์ด์ง ์ ๋ ฅ๊ฐ ์ค (์ต๋๊ฐ ~ n*m)์ ๋ฒ์๋ฅผ ์ด์ฉํ์ฌ ์ฌ์ด๊ฐ ์ค n,m ๋ชจ๋ ๋๋์ด์ง๋ ๊ฒฝ์ฐ์ ์๋ฅผ answer์ ์ถ๊ฐํ๋ ๋ฐฉ์์ผ๋ก ์ฝ๋๋ฅผ ์งฐ๋ค.
๋ ๊ฒฝ์ฐ์ ์ ๋ชจ๋ ํ ๋ฒ๋ง ์ ๋ ฅ๋ ์ ์๋๋ก break ์ข ๋ฃ ์กฐ๊ฑด์ ๊ฑธ์ด์ฃผ์๋ค.
๋ฌธ์ ์ค๋ช
1๋ถํฐ ์ ๋ ฅ๋ฐ์ ์ซ์ n ์ฌ์ด์ ์๋ ์์์ ๊ฐ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ๋ง๋ค์ด ๋ณด์ธ์.
์์๋ 1๊ณผ ์๊ธฐ ์์ ์ผ๋ก๋ง ๋๋์ด์ง๋ ์๋ฅผ ์๋ฏธํฉ๋๋ค.
(1์ ์์๊ฐ ์๋๋๋ค.)
- ์ ํ ์กฐ๊ฑด
n์ 2์ด์ 1000000์ดํ์ ์์ฐ์์ ๋๋ค.
def solution(n):
answer = 0
check = [True]*(n+1)
for i in range(2, n+1):
if check[i] == True:
answer += 1
for j in range(i, n+1, i):
check[j] = False
return answer
ํจ์จ์ฑ ํต๊ณผ๋ฅผ ์ํด ์๊ทผ ์๊ฐ์ ์ฌ์ฉํ๋ ๋ฌธ์ ๋ค. ์ฃผ์ด์ง n์ ๋ฒ์๊ฐ 2 ~ 1๋ฐฑ๋ง ์ด๊ธฐ์, 2์ค for๋ฌธ์ ์ต์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ณ์ฐํ๋๋ก ํ๋ค.
์ฐ์ , check ๋ฆฌ์คํธ๋ฅผ ์์ฑํ์ฌ ์์์ธ ๊ฒฝ์ฐ True, ์๋๋ฉด False์ธ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด ์๊ฐ ๋ณต์ก๋๋ฅผ ์ค์๋ค. ๋ํ, 2๋ฒ์งธ for๋ฌธ์ ํตํด ์์ ์์๋ก ์ ํด์ง ๊ฐ์ ๋ฐฐ์๋ค์ ๋ชจ๋ False์ฒ๋ฆฌ๋ฅผ ํ์ฌ ์๊ฐ๋ณต์ก๋๋ฅผ ์ค์ฌ์ฃผ์๋ค.
- ์ด๋์ผ๋ก ์ฌ๊ฐ ์๊ฐ ๋ณด๋ด๊ธฐ
- Programmers LV1 ๋ง๋ฌด๋ฆฌ!! >> ๋ด์ผ๋ถํฐ LV2 ๋ฌธ์ ํ์ด ์์
- SQL Study ์งํ! (๋งค์ฃผ ์ผ์์ผ ์์ )
์ค๋๋ถํฐ ๋ํ๊ต ์น๊ตฌ๋ค๊ณผ SQL Study ์งํ!
๋งค์ฃผ ์ผ์์ผ๋ง๋ค ๊ฐ์ ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ๋ ์๊ฐ์ ๊ฐ๊ธฐ๋ก ํ๋ค.
12์ 4์ผ๊น์ง To do list... ํด์ผ ํ ์ผ๋ค์ด ๋์ด๋๊ณ ์๋ค..
๊ทธ๋ฌ๋ Study๋ฅผ ํตํด ๋์ฉ๋ ๋ฐ์ดํฐ๋ค์ ๊ด๋ฆฌํ๋ DB๋ฅผ ์ดํดํ๊ณ ๋ฉด์ ์ค๋น๋ฅผ ์ํ ๊ณผ์ ์ด๋ผ๊ณ ์๊ฐํ๊ณ ์ด์ฌํ ์ค๋นํด๋ณด๋ ค ํ๋ค!