๋ฌธ์
์ฃผ์ด์ง ์ N๊ฐ ์ค์์ ์์๊ฐ ๋ช ๊ฐ์ธ์ง ์ฐพ์์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ ์ค์ ์์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. N์ 100์ดํ์ด๋ค. ๋ค์์ผ๋ก N๊ฐ์ ์๊ฐ ์ฃผ์ด์ง๋๋ฐ ์๋ 1,000 ์ดํ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฃผ์ด์ง ์๋ค ์ค ์์์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1 ๋ณต์ฌ
4
1 3 5 7
์์ ์ถ๋ ฅ 1 ๋ณต์ฌ
3
ํ์ด
์์๋ฅผ ์ฐพ๋ ํจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ์ "์๋ผํ ์คํ ๋ค์ค์ ์ฒด"
์๋ผํ ์คํ ๋ค์ค์ ์ฒด ํต์ฌ์ "์์์ ๋ฐฐ์๋ ์์๊ฐ ์๋๋ค" ์ด๋ค.
1๋ถํฐ ์ต๋๊ฐ(์ฌ๊ธฐ์๋ 1000)๊น์ง ๋ฏธ๋ฆฌ ๋ชจ๋ ์์๋ฅผ ๊ตฌํด๋๋๋ค.
1~N์ ์ ๊ณฑ๊ทผ๊น์ง ๋๋ฒ์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ต๋ N๊น์ง ์ํ๋๋ฉฐ, O(N)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
์ฝํ๋ฆฐ ํ์ด ์ฝ๋
import java.util.*
fun main() = with(System.`in`.bufferedReader()) {
// ์๋ผํ ์คํ
๋ค์ค์ ์ฒด
val max = 1000
val N = readLine().toInt() // ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ N ๊ฐ
val list = readLine().split(" ").map{ it.toInt() } // ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ๋ฆฌ์คํธ
val primeArray = BooleanArray(max + 1) { true } // 0~1000๊น์ง ์ซ์๊ฐ ์์์ธ์ง ์ฌ๋ถ๋ฅผ ์ ์ฅ
var result = 0 // ์ฃผ์ด์ง ๋ฆฌ์คํธ ์ค ์์์ ๊ฐฏ์
// ์ด๊ธฐ๊ฐ ์ธํ
, 0๊ณผ 1์ ์์๊ฐ ์๋ ์์ธ์ฒ๋ฆฌ
primeArray[0] = false
primeArray[1] = false
// 2๋ถํฐ ์ต๋๊ฐ(1000)์ ๋ฃจํธ ๊ฐ๊น์ง ์ํ
for(i in 2..Math.sqrt(max.toDouble()).toInt()) {
// ํ์ฌ ๊ฐ์ด ์์๋ผ๋ฉด ํ์ฌ ๊ฐ์ ๋ฐฐ์๋ ๋ชจ๋ ์์๊ฐ ์๋
if(primeArray[i]){
// ๋ณธ์ธ์ ์ ๊ณฑ๋ถํฐ ์ต๋๊ฐ(1000)๊น์ง์ ๋ฐฐ์ ์ฒ๋ฆฌ
// ๋ณธ์ธ๋ณด๋ค ์์ ๊ฐ์ ๊ณฑํ๋ ์ผ์ด์ค๋ ์ ํ๋์์ ๊ฒ์ด๋ฏ๋ก ์ํํ์ง ์์ (4x3์ ๊ฒฝ์ฐ, 3x4๋ก ์ํ๋์์)
for(j in i * i..max step i) {
primeArray[ j ] = false
}
}
}
// ์
๋ ฅ๋ ๋ฆฌ์คํธ๋ฅผ ์ํํ๋ฉฐ ์์์ ๊ฐฏ์๋ฅผ ํ์ธ ํ ์ถ๋ ฅ
list.forEach{ if(primeArray[it]) result++ }
println(result)
}
'Programming > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin] ๋ฐฑ์ค 2504 ๊ดํธ์ ๊ฐ ์ฝํ๋ฆฐ ํ์ด - stack (0) | 2025.03.31 |
---|---|
[Kotlin] ๋ฐฑ์ค 14888 - ์ฐ์ฐ์ ๋ผ์๋ฃ๊ธฐ(์ฌ๊ท์์ ํ์ DFS, ๋ฐฑํธ๋ํน) (1) | 2025.03.09 |
[Kotlin] ๋ฐฑ์ค 1292 - ์ฝ๊ฒ ํธ๋ ๋ฌธ์ (1) | 2024.11.13 |
[Kotlin] ๋ฐฑ์ค 2693 - N๋ฒ์งธ ํฐ ์ (2) | 2024.10.27 |
[Kotlin] ๋ฐฑ์ค 2609 - ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์(์ ํด๋ฆฌ๋ ํธ์ ๋ฒ) (0) | 2024.10.20 |