
Problem ๐ป
https://school.programmers.co.kr/learn/courses/30/lessons/120815
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
๋จธ์ฑ์ด๋ค ํผ์๊ฐ๊ฒ๋ ํผ์๋ฅผ ์ฌ์ฏ ์กฐ๊ฐ์ผ๋ก ์๋ผ ์ค๋๋ค. ํผ์๋ฅผ ๋๋ ๋จน์ ์ฌ๋์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, n๋ช ์ด ์ฃผ๋ฌธํ ํผ์๋ฅผ ๋จ๊ธฐ์ง ์๊ณ ๋ชจ๋ ๊ฐ์ ์์ ํผ์ ์กฐ๊ฐ์ ๋จน์ด์ผ ํ๋ค๋ฉด ์ต์ ๋ช ํ์ ์์ผ์ผ ํ๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
์ ํ์ฌํญ
1 ≤ n ≤ 100
| 6 | 1 |
| 10 | 5 |
| 4 | 2 |
Approach 1 โ - ๋์ ์ด๊ธฐ ์ ๊ทผ๋ฒ
์ฌ์ค ์ด๋ป๊ฒ ์ ๊ทผ์ ์์ํด์ผ ํ ์ง๋ ๋ ์ค๋ฅด์ง ์์๋ค...
๋์ ์ํ์ ์ฌ๊ณ ์ฒด๊ณ์ ๋ฏธ์ํจ์ด ๋๋ฌ๋๋ค.
์ํ ์ข ์ด์ฌํ ํ ๊ฑธ...
Approach 2 โญ
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ต์๊ณต๋ฐฐ์(LCM, Least Common Multiple) ์ ๊ฐ๋ ์ ์ฌ์ฉํ๋ฉด ๋๋ค.
ํผ์ ํ ํ์ 6์กฐ๊ฐ์ผ๋ก ๋๋์ด์ง๋ฏ๋ก, 6๊ณผ n(์ฌ๋ ์)์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ฉด ๋๋ค.
๋ ผ๋ฆฌ์ ์ ๊ฐ
1. ๋ฌธ์ ์ดํด
ํผ์ ํ ํ์ 6์กฐ๊ฐ์ผ๋ก ๋๋์ด ์์ผ๋ฉฐ, n๋ช ์ด ๋ชจ๋ ๋จ๊น์์ด ๊ฐ์ ์์ ์กฐ๊ฐ์ ๋จน์ด์ผ ํ๋ค.
์ฆ, 6๊ณผ n์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํด์ผ ํ๋ค.
2. ์ต์๊ณต๋ฐฐ์(LCM) ํ์ฉ
์ต์๊ณต๋ฐฐ์๋ ๋ ์์ ๊ณตํต ๋ฐฐ์ ์ค ๊ฐ์ฅ ์์ ์๋ฅผ ์๋ฏธํ๋ค.
์๋ฅผ ๋ค์ด n = 10์ผ ๋:
• ํผ์ ํ ํ๋น ์กฐ๊ฐ ์ = 6
• ์ฌ๋ ์ = 10
• 6๊ณผ 10์ ์ต์๊ณต๋ฐฐ์๋ 30์ด๋ฏ๋ก, 30์กฐ๊ฐ์ด ํ์ํ๋ค.
์ด๋ ํผ์ ํ ์๋ 30 ÷ 6 = 5ํ์ด ๋๋ค.
3. ํผ์ ํ ์ ๊ณ์ฐ
์ต์๊ณต๋ฐฐ์(LCM)๋ฅผ ํผ์ ํ ํ๋น ์กฐ๊ฐ ์์ธ 6์ผ๋ก ๋๋๋ฉด ํ์ํ ํผ์ ํ ์๋ฅผ ๊ตฌํ ์ ์๋ค.
์์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
= {LCM(6,n)} / 6
์๊ณ ๋ฆฌ์ฆ ๋จ๊ณ
1. 6๊ณผ n์ ์ต๋๊ณต์ฝ์(GCD) ๋ฅผ ๊ตฌํ๋ค.
GCD๋ฅผ ๊ตฌํ๋ฉด ์ต์๊ณต๋ฐฐ์๋ ๋ค์๊ณผ ๊ฐ์ด ๊ณ์ฐํ ์ ์๋ค.
์ต์ ๊ณต๋ฐฐ์(a, b) = (a * b) / {์ต๋๊ณต์ฝ์}(a, b)}
์ฌ๊ธฐ์ a = 6, b = n์ด๋ค.
GCD๋ “Greatest Common Divisor” ์ ์ฝ์๋ก, ์ต๋๊ณต์ฝ์๋ฅผ ์๋ฏธํ๋ค.๋ ์์ ๊ณตํต๋ ์ฝ์ ์ค ๊ฐ์ฅ ํฐ ๊ฐ์ด๋ค.
๋ฐ๋๋ก LCM(Least Common Multiple)์ ์ต์๊ณต๋ฐฐ์๋ก, ๋ ์์ ๊ณตํต๋ ๋ฐฐ์ ์ค ๊ฐ์ฅ ์์ ๊ฐ์ ์๋ฏธํ๋ค.
LCM๊ณผ GCD์ ๊ด๊ณ
๋ ์ a์ b์ ์ต์๊ณต๋ฐฐ์(LCM)๋ ๋ ์์ ๊ณฑ์ ์ต๋๊ณต์ฝ์(GCD)๋ก ๋๋ ๊ฐ์ผ๋ก ๊ตฌํ ์ ์๋ค.
์ด ๊ด๊ณ๋ ์ํ์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ๋ค:์ ์ด ์์ด ์ฑ๋ฆฝํ๋๊ฐ?
• ๋ ์ a์ b์ ๊ณฑ์ ๋ ์์ ๋ชจ๋ ๊ณตํต ์์๋ฅผ ํฌํจํ๋ค.
• ๊ทธ๋ฌ๋ ์ด๋ ๊ณตํต๋ ์ฝ์(์ต๋๊ณต์ฝ์)๊ฐ ์ค๋ณต๋๊ธฐ ๋๋ฌธ์, GCD๋ก ๋๋๋ฉด ์ค๋ณต์ ์ ๊ฑฐํ๊ณ ์ต์๊ณต๋ฐฐ์๊ฐ ๋๋ค.
2. ๊ตฌํ LCM์ 6์ผ๋ก ๋๋์ด ํผ์ ํ ์๋ฅผ ๊ณ์ฐํ๋ค.
Solution ๐ก
class Solution {
public int solution(int n) {
// ์ต๋๊ณต์ฝ์(GCD)๋ฅผ ๊ตฌํ๋ ํจ์
int gcd = gcd(6, n);
// ์ต์๊ณต๋ฐฐ์(LCM)๋ฅผ ๊ตฌํ๊ณ ํผ์ ํ ์ ๊ณ์ฐ
int lcm = (6 * n) / gcd;
// ์ต์๊ณต๋ฐฐ์๋ฅผ ํผ์ ํ ํ๋น ์กฐ๊ฐ ์(6)๋ก ๋๋ ๊ฐ์ด ํ์ํ ํผ์ ํ ์
return lcm / 6;
}
//์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ผ๋ก ์ต๋๊ณต์ฝ์(GCD)๊ตฌํ๊ธฐ
public int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
}
์ฝ๋ ์ค๋ช
1. ์ต๋๊ณต์ฝ์(GCD) ๋ gcd ํจ์๋ฅผ ํตํด ๊ตฌํ๋ค.
• ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ฌ์ฉํด ํจ์จ์ ์ผ๋ก ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค.
2. ์ต์๊ณต๋ฐฐ์(LCM) ๋ GCD๋ฅผ ์ด์ฉํด ๊ณ์ฐํ๋ค:

3. ํผ์ ํ ์๋ LCM์ 6์ผ๋ก ๋๋ ๊ฐ์ด ๋๋ค.

Reference ๐
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ๋ค์ ๊ฒ์๋ฌผ์!

