๋ฌธ์
ํ์ด
์ฐ์๋ ์ซ์์ ํฉ์ด n์ด ๋๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ค.
์ฒ์์ ์ฐ์๋ ์ซ์์ ํฉ์ด๋๊น ๋ฑ์ฐจ์์ด๋ก ํ์ด์ผ๊ฒ ๋ค.. ๋ผ๊ณ ์๊ฐํ๊ณ ๋ฌธ์ ๋ฅผ ์ ๊ทผํ๋ค.
์ฒซ ๋ฒ์งธ ํ์ด
๊ธฐ๋ณธ ๋ฒ ์ด์ค๋ ์์ ๋ฑ์ฐจ์์ด ๊ณต์์ ์๊ฐํ๊ณ ๋ฌธ์ ๋ฅผ ํ์๋ค.
1. n==n์ธ ๊ฒฝ์ฐ๋ฅผ ๋ฏธ๋ฆฌ ์ธ์ด์ฃผ๊ธฐ ์ํด count๋ฅผ 1๋ก ์ด๊ธฐํํจ
2. ์ด์ค for๋ฌธ์ผ๋ก ์ ๊ณต์์ ๋ง์กฑํ๋ a, b ๊ฐ์ด ์กด์ฌํ๋ฉด count๋ฅผ ๋๋ ค์ค
3. for๋ฌธ ๋ค ๋๋ฉด count ๋ฐํ
์ด๋ ๊ฒํด์ ํ ์คํธ ์ผ์ด์ค๋ ๋ค ํต๊ณผ๋๋๋ฐ... ์๊ฐ๋ณต์ก๋ O(n^2)์ด๋ผ ๊ทธ๋ฐ์ง ์๊ฐ์ด๊ณผ๊ฐ ๋ธ ใ ใ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ํ๋ฉด ๋๋๋ฐ ์ค๊ธฐ๊ฐ ์๊ฒจ์ ๋ฑ์ฐจ์์ด ๊ณ ์งํ๋ค๊ฐ ์๊ฐ ๋ง์ด ๋ฒ๋ฆฐ ๋ฌธ์ ...ใ ใ
class Solution {
public int solution(int n) {
int count = 1;
for(int a=1; a<n+1; a++){
for (int b=a+1; b<n+1; b++){
if ((b-a+1)*(b+a)/2 == n) count++;
}
}
return count;
}
}
๋๋ฒ์งธ ํ์ด
๊ทธ๋์ ์๊ฐํ ๋๋ฒ์งธ ํ์ด
๋ง์ง๋งํญ์ ๋นผ๊ณ ๊ฐ์ k๋ก ๋ฑ์ฐจ์์ด ์ ์ธ์ฐ๊ณ ๋๋ฒ์งธ ํญ์ฒ๋ผ ์ ๋ฆฌํด์ค๋ค.
๊ทธ๋ผ ์ด๋ ๊ฒ ์ฒซ์งธํญ ๊ณต์์ ์ธ์ธ ์ ์๋๋ฐ, ์ด ๋ ์ฒซ์งธํญ์ด k๋ก ๋๋ ์ ธ์ผ์ง ๋ฌด์กฐ๊ฑด ์์ฐ์๊ฐ ๋๊ธฐ ๋๋ฌธ์ ์ด ๊ณต์์ ํ์ฉํด์ ํ์๋ค.
1. ์์ ์ฒซ์งธํญ ๊ณต์์์ n-(k(k-1)) > 0 ์ด์ฌ์ผ ํ๊ธฐ ๋๋ฌธ์, for๋ฌธ์ ์กฐ๊ฑด์ k(k-1)/2 <n ์ผ๋ก ์ค์ ํด์ค.
2. ๊ทธ๋ฆฌ๊ณ ์ฒซ์งธํญ์ด ์์ฐ์๊ฐ ๋๋ if๋ฌธ์ ํตํด ์กฐ๊ฑด์ ๋ง๋ค๋ฉด ํฉ๊ณต์์ด ์ฑ๋ฆฝํ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ count๋ฅผ ์ฆ๊ฐ์์ผ์ค
== (n-(k(k-1)/2) ์ด๊ฒ k๋ก ๋๋ด์ ๋ ๋๋จธ์ง๊ฐ 0์ธ ๊ฒฝ์ฐ count++
3. for๋ฌธ ๋ค ๋๋ฉด count ๋ฐํํด์ฃผ๊ธฐ
// ๋ฑ์ฐจ์์ด ์ด์ฉ
// k : ์ฐ์๋ ์์ฐ์์ ๊ฐ์, n : ์ฃผ์ด์ง ์
// ์ฒซ์งธํญ = (n-(k(k-1))/2)/k
class Solution {
public int solution(int n) {
int count = 0;
for(int k=1; k*(k-1)/2 < n; k++){
if ((n-(k*(k-1)/2)) % k == 0){ // n - (k*(k-1))/2๊ฐ k๋ก ๋๋์ด ๋จ์ด์ง๋ฉด ํฉ๊ณต์ ์ฑ๋ฆฝ
count++;
}
}
return count;
}
}
๊ฐ์ ํ ํจ์จ์ฑ๋ ํต๊ณผํ๋ค.....
ํ๋ค์๋ค... 1์ฉ ์ฆ๊ฐํด์ ๋ํ๋ for๋ฌธ์ผ๋ก ์ฝ๊ฒ ํ ์ ์์๋๋ฐ ๊ดํ ๋ฑ์ฐจ์์ด ์ฐ๊ณ ์ถ์ด์ ๋ณต์กํ๊ณ ์ด๋ ต๊ฒ ํผ ๋ฏ. ๋ค์์ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ํ์ด๋ด์ผ๊ฒ ๋ค.