1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
ํด๋น ๋ฌธ์ ๋ ๋ฌธ์ ์์ ํ๋ผ๋ ๋๋ก๋ง ํ๋ฉด ๋๋ค.
(1) ๋ฐ์ ์ซ์๋ฅผ N์ง๋ฒ์ผ๋ก ๋ณํํ๋ค.
๋ฌธ์ ๋ฅผ ํ๋ ๋น์์๋ Integer.toString(n, radix)
๋ผ๋ ๋ฌธ๋ฒ์ ์์ง ๋ชปํ๋ค. ํด๋น ๋ฌธ๋ฒ์ n์ 2๋ฒ์งธ ์ธ์์ธ radix์ง๋ฒ์ผ๋ก ๋ณํํด์ String์ผ๋ก ๋ฐํํ๋ค. Integer.toString(n,2)
์ด๋ฉด n์ 2์ง๋ฒ์ผ๋ก ๋ฐํํด์ String ๊ฐ์ผ๋ก ๋ฐํํ๋ ๊ฒ์ด๋ค.
์ด ๋ฌธ๋ฒ์ ๋ชฐ๋ผ์, ์ง์ ๋ฐํํ๋ค.
๋ฐํ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
- ๋ฐ๊พธ๋ ค๋ ์๋ฅผ n, ์ง๋ฒ์ radix๋ผ๊ณ ํ ๋,
n%radix == 0
์ด ๋ ๋๊น์ง n์ radix๋ก ๋๋๋ค.
์ด๋ ๋๋จธ์ง ๊ฐ์ ์ ์ฅํ๊ณ ์๋๋ค. - ๋๋์ด
n%radix == 0
์ด ๋๋ฉด ์ง๊ธ๊น์ง ๋์๋ ๋๋จธ์ง๋ค์ ์ญ์์ผ๋ก ์ค ์ธ์ด๋ค.
์์ธํ ๋ณํ ๋ฐฉ๋ฒ์ ๋ค์ ๋งํฌ์ ๋์์๋ค. ํด๋น ๋งํฌ์์ 10์ง์๋ฅผ 2์ง์ ๋ณํํ๋ ๋ฐฉ๋ฒ์ 2๋ฅผ ๋ค๋ฅธ ์๋ก ๋ฐ๊ฟ์ฃผ๋ฉด ๋ชจ๋ ํตํ๋ค.๋งํฌ
: 2์ง์ 10์ง์ ๋ณํ
(2) ๋ฐํํ ์๋ฅผ 0์ ๊ธฐ์ค์ผ๋ก ์๋ฅธ๋ค.
์ฌ๊ธฐ์๋ 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค. String.split("0")
๋ผ๋ split Method๋ฅผ ์ด์ฉํ ๋ฐฉ์๊ณผ, StringTokenizer("๊ฐ", "delim", delim ํฌํจ ์ฌ๋ถ boolean)
์ ์ด์ฉํ๋ ๋ฐฉ์์ด๋ค.
์ฒซ ๋ฒ์งธ ๋ฐฉ์์ ๋ฐํ ๊ฐ์ด String[] ๋ฐฐ์ด์ด๋ค. ์๋ฆฐ ๊ฐ๋ค์ด ๋ฐฐ์ด์ ์ฐจ๊ณก์ฐจ๊ณก ๋ค์ด๊ฐ๋ค. ์๋ฅด๋ ๊ธฐ์ค์ด ๋๋ delim์ ํฌํจ๋์ง ์๋๋ค.
๋ ๋ฒ์งธ ๋ฐฉ์์ st์ buffer ํ์์ผ๋ก ์๋ฆฐ ๊ฐ๋ค์ด ์ฐจ๋ก๋๋ก ์ ์ฅ๋๋ค. ์ด๋ 3๋ฒ์งธ ์ธ์๊ฐ true์ธ์ง, false์ธ์ง ์ฌ๋ถ์ ๋ฐ๋ผ delim ๊ฐ๋ ํฌํจํ ์ ์๋ค. st.hasMoreTokens()
๋ฅผ ์ด์ฉํด Loop๋ฌธ์ ๋๋ ค์ st.nextToken()
์ผ๋ก ์๋ ค์ง ๊ฐ๋ค ์ค ํ์ฌ ์กฐํ์ค์ธ ๊ฐ์ ๊ฐ์ ธ์ ์์
ํ๋ฉด ๋๋ค.st.hasMoreTokens()
: st์ ์ ์ฅ๋ ๊ฐ๋ค์ด ๋จ์์์๋ true
, ์์ผ๋ฉด false
st.nextToken()
: StringTokenizer๋ก ์๋ฅธ ๊ฐ๋ค ์ค ํ๋๋ฅผ ๋ฐํ, ๋ฐํํ๋ฉด, ๊ทธ ๋ค์ ์๋ฅธ ๊ฐ์ ๋ฐ๋ผ๋ณธ๋ค.
(3) ์์ ํ๋ณ ํ๋ค.
๋ฑ๊ฐ์ ๊ฐ์ ๋ํ ์์ ํ๋ณ์์ผ๋ก, ์๋ผํ ์คํ
๋ค์ค์ ์ฑ๋ฅผ ์ฌ์ฉํ์ง ์๊ณ , n์ ์ ๊ณฑ๊ทผ๊น์ง ์ ์ค n์ ๋๋ ์ ์๋ ๊ฐ์ด ์๋๊ฐ?
๋ฅผ ์ด์ฉํด ์์ ํ๋ณ์ ํ๋ค. ์์ ํ๋ณ์ ๋ํ ์์ธํ ์ด๋ก ์ ๋ค์ ๋งํฌ๋ฅผ ํ์ธํ๊ธฐ๋ฅผ ๋ฐ๋๋ค.๋งํฌ
: ์ฌ์ด ์์ ํ๋ณ๋ฒ
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
class Solution {
// 1. n์ง๋ฒ์ผ๋ก ๋ณํํ๋ค.
// 2. ๋ณํํ ์๋ฅผ 0์ ๊ธฐ์ค์ผ๋ก ์๋ฅธ๋ค.
// 3. ๊ฐ ์ซ์๋ณ๋ก ์์ ํ๋ณ ํ๋ค.
public int solution(int n, int k) {
StringTokenizer st = new StringTokenizer(baseN(n,k),"0", false); // ์ง๋ฒ ๋ณํ ๋ฐ 0๋ง๋ค ์๋ฅด๊ธฐ
int cnt = 0; // ์์๊ฐ ๋์จ ํ์
while(st.hasMoreTokens()){
if(isPrime(Long.parseLong(st.nextToken()))) cnt++;
}
return cnt;
}
public String baseN(int n, int k) {
StringBuilder sb = new StringBuilder();
while(n/k != 0) {
sb.insert(0, n%k);
n = n/k;
}
sb.insert(0, n%k);
return sb.toString();
}
public boolean isPrime(long value) {
if(value == 1) return false;
for(long i = 2; i <= Math.sqrt(value); i++){
if(value%i == 0) return false;
}
return true;
}
}
4. ์ฑ์ฅ ํ๊ธฐ
๋ค๋ฅธ ์ฌ๋์ ํ์ด ์ค ๊น๋ํ ๊ฒ์ด ์์ด์ ์๊ฐํ๋ ค ํ๋ค.
class Solution {
public int solution(int n, int k) {
int ans = 0;
// 1.Integer.toString ์ด์ฉ ๋ฐ๋ก k์ง๋ฒ์ผ๋ก ๋ณํ, 2.split์ผ๋ก ๋๋ ์ ๋ฐฐ์ด๋ก ๋ฐ์
String temp[] = Integer.toString(n, k).split("0");
Loop : for(String t : temp) {
// 0์ด ์ฐ์๋ ๊ฒฝ์ฐ, ๋น์ด์์
if(t.length() == 0) continue;
long a = Long.parseLong(t);
// 1์ ์์๊ฐ ์๋๋ผ์ ํจ์ค
if(a == 1) continue;
// ๋๋ ์ง๋ ๊ฒ์ด ์์ผ๋ฉด ์ธ๊ณฝ์ Loop๋ก ๋์๊ฐ.
for(int i=2; i<=Math.sqrt(a); i++)
if(a%i == 0) continue Loop;
ans++;
}
return ans;
}
}