๋ฌธ์ ์ค๋ช
https://school.programmers.co.kr/learn/courses/30/lessons/92335?language=java
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก์ Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
์์ ์ ์ n์ด ์ฃผ์ด์ง๋๋ค. ์ด ์ซ์๋ฅผ k์ง์๋ก ๋ฐ๊ฟจ์ ๋, ๋ณํ๋ ์ ์์ ์๋ ์กฐ๊ฑด์ ๋ง๋ ์์(Prime number)๊ฐ ๋ช ๊ฐ์ธ์ง ์์๋ณด๋ ค ํฉ๋๋ค.
- 0P0์ฒ๋ผ ์์ ์์ชฝ์ 0์ด ์๋ ๊ฒฝ์ฐ
- P0์ฒ๋ผ ์์ ์ค๋ฅธ์ชฝ์๋ง 0์ด ์๊ณ ์ผ์ชฝ์๋ ์๋ฌด๊ฒ๋ ์๋ ๊ฒฝ์ฐ
- 0P์ฒ๋ผ ์์ ์ผ์ชฝ์๋ง 0์ด ์๊ณ ์ค๋ฅธ์ชฝ์๋ ์๋ฌด๊ฒ๋ ์๋ ๊ฒฝ์ฐ
- P์ฒ๋ผ ์์ ์์ชฝ์ ์๋ฌด๊ฒ๋ ์๋ ๊ฒฝ์ฐ
- ๋จ, P๋ ๊ฐ ์๋ฆฟ์์ 0์ ํฌํจํ์ง ์๋ ์์์
๋๋ค.
- ์๋ฅผ ๋ค์ด, 101์ P๊ฐ ๋ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, 437674์ 3์ง์๋ก ๋ฐ๊พธ๋ฉด 211020101011์ ๋๋ค. ์ฌ๊ธฐ์ ์ฐพ์ ์ ์๋ ์กฐ๊ฑด์ ๋ง๋ ์์๋ ์ผ์ชฝ๋ถํฐ ์์๋๋ก 211, 2, 11์ด ์์ผ๋ฉฐ, ์ด 3๊ฐ์ ๋๋ค. (211, 2, 11์ k์ง๋ฒ์ผ๋ก ๋ณด์์ ๋๊ฐ ์๋, 10์ง๋ฒ์ผ๋ก ๋ณด์์ ๋ ์์์ฌ์ผ ํ๋ค๋ ์ ์ ์ฃผ์ํฉ๋๋ค.) 211์ P0 ํํ์์ ์ฐพ์ ์ ์์ผ๋ฉฐ, 2๋ 0P0์์, 11์ 0P์์ ์ฐพ์ ์ ์์ต๋๋ค.
์ ์ n๊ณผ k๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. n์ k์ง์๋ก ๋ฐ๊ฟจ์ ๋, ๋ณํ๋ ์ ์์์ ์ฐพ์ ์ ์๋ ์ ์กฐ๊ฑด์ ๋ง๋ ์์์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ ์ฌํญ
- 1 ≤ n ≤ 1,000,000
- 3 ≤ k ≤ 10
์ ์ถ๋ ฅ ์
| n | k | result |
| 437674 | 3 | 3 |
| 110011 | 10 | 2 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ฌธ์ ์ ์์์ ๊ฐ์ต๋๋ค.
์ ์ถ๋ ฅ ์ #2
- 110011์ 10์ง์๋ก ๋ฐ๊พธ๋ฉด 110011์
๋๋ค. ์ฌ๊ธฐ์ ์ฐพ์ ์ ์๋ ์กฐ๊ฑด์ ๋ง๋ ์์๋ 11, 11 2๊ฐ์
๋๋ค.
์ด์ ๊ฐ์ด ์ค๋ณต๋๋ ์์๋ฅผ ๋ฐ๊ฒฌํ๋๋ผ๋ ๋ชจ๋ ๋ฐ๋ก ์ธ์ด์ผ ํฉ๋๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
import java.util.*;
class Solution {
public int solution(int n, int k) {
// ์์ ๊ฐ์ ์ ์ฅํ ๋ณ์ ์์ฑ
int answer = 0;
// n์ k์ง์ ๋ฌธ์์ด๋ก ๋ณํ
String baseK = Integer.toString(n, k);
// '0'์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๊ฐ ๋ถ๋ฆฌ (์ฐ์๋ 0๋ ํ ๋ฒ์ ๋๊ธฐ๋๋ก "0+")
String[] parts = baseK.split("0+");
// ๊ฐ ๊ตฌ๊ฐ์ด ์์์ธ์ง ํ๋ณ
for (String p : parts) {
// ๋น ๋ฌธ์์ด ๋ฐฉ์ด
if (p.isEmpty()) continue;
// k <= 10์ด๋ฏ๋ก p๋ 0~9 ์ซ์๋ง. ๊ทธ๋๋ก 10์ง์๋ก ํ์ฑ
long num = Long.parseLong(p);
if (isPrime(num)) {
answer++;
}
}
return answer;
}
// ์์ ํ๋ณ: √n๊น์ง๋ง ํ์ธ
private boolean isPrime(long x) {
// 0, 1 ์ ์ธ
if (x < 2) return false;
// 2๋ ์์
if (x == 2) return true;
// ์ง์ ์ ๊ฑฐ
if (x % 2 == 0) return false;
// √x ๊น์ง๋ง ๋๋๊ธฐ
long limit = (long) Math.sqrt(x);
// ์ด๋ฏธ ์ง์๋ ์์์ ๊ฑธ๋ ์ผ๋ฏ๋ก ํ์๋ง ํ์ธ
for (long l = 3; l <= limit; l += 2) {
if (x % l == 0) return false;
}
return true;
}
}
๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์๊ฐํ ๋ฐฉํฅ
์ฒ์ ๋ฌธ์ ๋ฅผ ๋ดค์ ๋, ํต์ฌ์ ์ฃผ์ด์ง ์ ์ n์ k์ง์๋ก ๋ณํํ ๋ค 0์ ๊ธฐ์ค์ผ๋ก ์๋ผ ์๊ธด ์๋ค ์ค ์์์ ๊ฐ์๋ฅผ ์ธ๋ ๊ฒ์ด๋ผ๋ ์ ์ ํ์ ํ๋ค. ๋จ์ํ ์ง๋ฒ ๋ณํ๊ณผ ์์ ํ๋ณ ๋ ๊ฐ์ง ๊ณผ์ ์ ์กฐํฉํ๋ฉด ํด๊ฒฐํ ์ ์๋ ๋ฌธ์ ๋ผ๊ณ ํ๋จํ๋ค.
์กฐ๊ฑด์ ๋ถ์ํด ๋ณด๋ฉด ๋จผ์ n์ k์ง์๋ก ๋ฐ๊พธ๋ ๊ณผ์ ์ด ํ์ํ๋ค. ์๋ฐ์์๋ Integer.toString(n, k)๋ฅผ ์ฌ์ฉํ๋ฉด ์์ฝ๊ฒ ๋ฌธ์์ด ํํ์ k์ง์๋ฅผ ์ป์ ์ ์๋ค. ๊ทธ๋ค์์๋ 0์ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๋ถ๋ฆฌํด์ผ ํ๋๋ฐ, ์ด๋ ๋จ์ํ split("0") ๋์ split("0+")๋ฅผ ์ฌ์ฉํ๋ฉด ์ฐ์๋ 0์ ํ ๋ฒ์ ์๋ผ๋ผ ์ ์์ด ๋ถํ์ํ ๋น ๋ฌธ์์ด์ ์ค์ผ ์ ์๋ค. ๊ทธ๋๋ split ๊ฒฐ๊ณผ์๋ ๋น ๋ฌธ์์ด์ด๋ 1 ๊ฐ์ ์์๊ฐ ์๋ ๊ฐ์ด ํฌํจ๋ ์ ์์ผ๋ฏ๋ก ์ด๋ฅผ ๋ฏธ๋ฆฌ ๊ฑธ๋ฌ์ฃผ๋ ์ฒ๋ฆฌ๊ฐ ํ์ํ๋ค.
์์ ํ๋ณ์ ๊ฐ์ฅ ์ค์ํ ๋ถ๋ถ์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด๋ค ์๊ฐ ์์์ธ์ง ํ์ธํ๋ ค๋ฉด 2๋ถํฐ ์๊ธฐ ์์ ์ ๊น์ง ๋ชจ๋ ์๋ก ๋๋ ๋ด์ผ ํ์ง๋ง, ์ด๋ ๋นํจ์จ์ ์ด๋ค. ๋ฐ๋ผ์ √n๊น์ง๋ง ๊ฒ์ฌํด๋ ์ถฉ๋ถํ๋ค๋ ์ฑ์ง์ ์ด์ฉํ๋ ๊ฒ์ด ์ข๋ค. ๋จผ์ 0๊ณผ 1์ ์์๊ฐ ์๋๋ฏ๋ก ์ ์ธํ๊ณ , 2๋ ์ ์ผํ ์ง์ ์์์ด๋ฏ๋ก ๋ฐ๋ก ์์๋ก ์ฒ๋ฆฌํ๋ค. ๊ทธ ์ธ ์ง์๋ ์ ๋ถ ํฉ์ฑ์์ด๋ฏ๋ก ๋น ๋ฅด๊ฒ ๊ฑฐ๋ฅด๊ณ , ํ์๋ง √n๊น์ง ๊ฒ์ฌํ๋ฉด ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ํฐ ์์ ๋ํด์๋ ์๊ฐ ๋ด์ ํ๋ณ์ด ๊ฐ๋ฅํ๋ค.
์ด ๊ณผ์ ์ ์ ๋ฆฌํ๋ฉด, n์ k์ง์๋ก ๋ณํ → 0์ผ๋ก ๋ถ๋ฆฌ → ์ซ์ ํ๋ํ๋๋ฅผ 10์ง์๋ก ๋ณํ → ์์ ํ๋ณ → ์นด์ดํธ๋ผ๋ ํ๋ฆ์ผ๋ก ํ์ด๋ฅผ ์์ฑํ ์ ์๋ค. ์๊ฐ ๋ณต์ก๋๋ ๊ฐ ์กฐ๊ฐ์ ๊ธธ์ด์ ๋ฐ๋ผ ๋ฌ๋ผ์ง์ง๋ง, ์์ ํ๋ณ์ √n๊น์ง๋ง ํ๋ฏ๋ก ์ถฉ๋ถํ ํจ์จ์ ์ด๋ค.
'๐ฆ ํ๋ก๊ทธ๋๋จธ์ค > ๐๏ธ ์๊ณ ๋ฆฌ์ฆ ํ์ด(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋๋ง์ ์ํธ (0) | 2025.09.25 |
|---|---|
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋ ๋งต๊ฒ (0) | 2025.09.23 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ์คํจ์จ (1) | 2025.09.05 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] n์ง์ ๊ฒ์ (2) | 2025.09.02 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋ค์ ์๋ ํฐ ์ ์ฐพ๊ธฐ (2) | 2025.09.01 |