BOJ, ๋ฒ ๋ฅดํธ๋ ๊ณต์ค
์ฌ์ฉ์ธ์ด : python
๋ฒ ๋ฅดํธ๋ ๊ณต์ค์ ์์์ ์์ฐ์ n์ ๋ํ์ฌ, n๋ณด๋ค ํฌ๊ณ , 2n๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์๋ ์ ์ด๋ ํ๋ ์กด์ฌํ๋ค๋ ๋ด์ฉ์ ๋ด๊ณ ์๋ค.
์ด ๋ช ์ ๋ ์กฐ์ ํ ๋ฒ ๋ฅดํธ๋์ด 1845๋ ์ ์ถ์ธกํ๊ณ , ํํ๋ํฐ ์ฒด๋น์ผํ๊ฐ 1850๋ ์ ์ฆ๋ช ํ๋ค.
์๋ฅผ ๋ค์ด, 10๋ณด๋ค ํฌ๊ณ , 20๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์๋ 4๊ฐ๊ฐ ์๋ค. (11, 13, 17, 19) ๋, 14๋ณด๋ค ํฌ๊ณ , 28๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์๋ 3๊ฐ๊ฐ ์๋ค. (17,19, 23)
์์ฐ์ n์ด ์ฃผ์ด์ก์ ๋, n๋ณด๋ค ํฌ๊ณ , 2n๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์์
๋ฌธ์ ๋ค..!
์ง๋ ๋ฒ ์์ ๋ฌธ์
์์ ์๊ฐ ์ด๊ณผ๋ฅผ ๊ฒช๊ณ ์๋ผํ ์คํ
๋ค์ค ์ฒด๋ฅผ ์๊ฒ ๋์๋ค.
(๋ฌด์์ ๋ชจ๋ ์๋ฅผ ๊ทธ ๋ฏธ๋ง ์๋ค๋ก ๋๋ ๋ณด๋ ์์ฃผ ์์ฒญ๋ ์ฝ๋๋ฅผ ์งฐ์๋ค๋ ์์ใ
ใ
)
๊ทธ๋์ ๋ฌธ์ ๋ฅผ ๋ณด๊ณ ์๋ผํ ์คํ
๋ค์ค ์ฒด๋ฅผ ์ฌ์ฉํด์ผ๊ฒ ๋ค๊ณ ๋ฐ๋ก ์๊ฐํ๋ค!
์๋ผํ ์คํ ๋ค์ค ์ฒด๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์๋ค.
์์๋ฅผ ์ธ๋ ํจ์๋ฅผ ๋ฐ๋ก ๋ง๋ค์ด์, ์์๋ฅผ ์ธ๋ ๋ณ์ count๋ฅผ ๋ง๋ค์ด์ฃผ๊ณ
์์ ์ฌ๋ถ๋ฅผ ํ์ํ๋ prime_check๋ผ๋ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด์ฃผ์๋ค.
(์ธ๋ฑ์ค๊ฐ 0๋ถํฐ ์์ํ๊ธฐ ๋๋ฌธ์, 2์ ์์ ์ฌ๋ถ๋ฅผ index๊ฐ 2์ธ ๊ณณ์ ํ์๋ฅผ ํด์ฃผ๊ณ ์ถ์ด์ ๊ธธ์ด๊ฐ num+1์ธ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์๋ค.)
๊ทธ๋ฆฌ๊ณ for๋ฌธ์ ๋๋ฉด์ ํด๋น ์๊ฐ ์์๋ผ๋ฉด ๊ทธ ์์ ๋ฐฐ์๋ค์ ๋ชจ๋
prime_check์์ 0์ผ๋ก ํ์ํด์ฃผ์๋ค.
๋ง์ง๋ง์ prime_check์์ index 2๋ถํฐ num๊น์ง ์์๊ฐ 1์ผ ๋๋ฅผ countํด์ฃผ๋ฉด ๋!
(์ธ๋ฑ์ค 0๊ณผ 1์ 0ํ๊ณ 1์ ์์ ํ๋ณ ์ ๋ณด๋ผ์ ํ์ No!)
#ํด๋น ์ซ์ ์ดํ์ ์์ ๊ฐฏ์๋ฅผ ๊ตฌํ๋ ํจ์
def prime_count(num):
#์์์ ์๋ฅผ ์ธ๋ ๋ณ์
count = 0
#์์ ์ฒดํฌ๋ฅผ ํด์ฃผ๋ ๋ฆฌ์คํธ
prime_check = [1]*(num+1)
#์๋ผํ ์คํ
๋ค์ค ์ฒด๋ฅผ ์ด์ฉํ ์์ ํ๋ณ
for i in range(2,num+1):
if prime_check[i]:
for j in range(i+i,num+1,i):
prime_check[j] = 0
#์์๋ 0,1์ ํด๋นํ์ง ์์ผ๋๊น
for k in range(2,len(prime_check)):
if prime_check[k]:
count += 1
return count
while True:
#n์ด 0์ด ๋ค์ด์ฌ๋๊น์ง ์
๋ ฅ ๋ฐ๊ธฐ
n = int(input())
if n == 0:
break
print(prime_count(2*n)-prime_count(n))
๋ฌผ๋ก ์ด ๋ฐฉ๋ฒ๋ ๋ฐฑ์ค์์ ์ ๋ต์ผ๋ก ๋์ง๋ง,
์ด์ ์ ์์ ๋ฌธ์ ๋ณด๋ค ์๊ฐ์ด ๋นํจ์จ์ ์ด๋ผ๊ณ ๋๊ปด์ก๋ค๐ค
๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ์ ์ ๋ฐ๋ก ์ฐพ์์ ๋ฐ๋ก ์๋ ๋ฐฉ๋ฒ์ผ๋ก ๋ค์ ํ์๋ค..!
๋ฌธ์ ๋ฅผ ๋ค์ ์๊ฐํด๋ณด๋, sqrt(num)๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ๋ค๋ก๋ง ํ๋ณํ๋ฉด ๋๋ค๐คง
์? ์ฐฌ์ฐฌํ ์์ ํ๋ณ ๊ณผ์ ์ ๋ฐ๋ผ๊ฐ๋ณด๋ฉด!
์ด๋ค ์(k)๊ฐ ์์๊ฐ ๋๋ ค๋ฉด 1๊ณผ ์๊ธฐ ์์ ์ ์ ์ธํ๊ณ ๋ ๋๋ ๋จ์ด์ง๋ฉด ์๋๋ค.
๊ทธ๋ผ 2๋ถํฐ k-1๊น์ง ์๋ค๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ผ๋ฉด ๋๊ฒ ๋ค?!
ํ์ง๋ง ์ฌ๊ธฐ์ ๊ตณ์ด ๋ค ํ์ธํ ํ์๊ฐ ์๋ค๋ ๊ฒ์ด๋ค!
k๋ sqrt(k) ๊ณฑํ๊ธฐ sqrt(k) ๋๋ sqrt(k)๋ณด๋ค ์์ ์์ ํฐ ์์ ๊ณฑ์ผ๋ก
๋ํ๋ผ ์ ์๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์!
์ฌ๊ธฐ์๋ num์ดํ ์น๊ตฌ๋ค์ด ์์์ธ์ง ํ์ธ ํ ๋, sqrt(num)์ดํ
์๋ค๋ก ์๋ผํ ์คํ
๋ค์ค ์ฒด๋ฅผ ํด์ฃผ๋ฉด ๋๋ ๊ฒ์ด๋ค!!!
def prime_count(num):
count = 0
prime_check = [1]*(num+1)
for i in range(2,int(num**0.5)+1):
if prime_check[i]:
for j in range(i+i,num+1,i):
prime_check[j] = 0
for k in range(2,num+1):
if prime_check[k]:
count +=1
return count
while True:
n = int(input())
if n == 0:
break
print(prime_count(2*n)-prime_count(n))
์ด๋ ๊ฒ ๊ณ ์น๊ณ ๋๋ฆฌ๋, ์๊ฐ์ด ํจ์ฌ ์ค์ด๋ค์๋ค!