๊ฐ๋ก ๊ธธ์ด๊ฐ Wcm, ์ธ๋ก ๊ธธ์ด๊ฐ Hcm์ธ ์ง์ฌ๊ฐํ ์ข ์ด๊ฐ ์์ต๋๋ค. ์ข ์ด์๋ ๊ฐ๋ก, ์ธ๋ก ๋ฐฉํฅ๊ณผ ํํํ๊ฒ ๊ฒฉ์ ํํ๋ก ์ ์ด ๊ทธ์ด์ ธ ์์ผ๋ฉฐ, ๋ชจ๋ ๊ฒฉ์์นธ์ 1cm x 1cm ํฌ๊ธฐ์ ๋๋ค. ์ด ์ข ์ด๋ฅผ ๊ฒฉ์ ์ ์ ๋ฐ๋ผ 1cm ร 1cm์ ์ ์ฌ๊ฐํ์ผ๋ก ์๋ผ ์ฌ์ฉํ ์์ ์ด์๋๋ฐ, ๋๊ตฐ๊ฐ๊ฐ ์ด ์ข ์ด๋ฅผ ๋๊ฐ์ ๊ผญ์ง์ 2๊ฐ๋ฅผ ์๋ ๋ฐฉํฅ์ผ๋ก ์๋ผ ๋์์ต๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ํ์ฌ ์ง์ฌ๊ฐํ ์ข ์ด๋ ํฌ๊ธฐ๊ฐ ๊ฐ์ ์ง๊ฐ์ผ๊ฐํ 2๊ฐ๋ก ๋๋์ด์ง ์ํ์ ๋๋ค. ์๋ก์ด ์ข ์ด๋ฅผ ๊ตฌํ ์ ์๋ ์ํ์ด๊ธฐ ๋๋ฌธ์, ์ด ์ข ์ด์์ ์๋ ์ข ์ด์ ๊ฐ๋ก, ์ธ๋ก ๋ฐฉํฅ๊ณผ ํํํ๊ฒ 1cm ร 1cm๋ก ์๋ผ ์ฌ์ฉํ ์ ์๋ ๋งํผ๋ง ์ฌ์ฉํ๊ธฐ๋ก ํ์์ต๋๋ค.๊ฐ๋ก์ ๊ธธ์ด W์ ์ธ๋ก์ ๊ธธ์ด H๊ฐ ์ฃผ์ด์ง ๋, ์ฌ์ฉํ ์ ์๋ ์ ์ฌ๊ฐํ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
W | H | result |
---|---|---|
8 | 12 | 80 |
์ ์ถ๋ ฅ ์ #1๊ฐ๋ก๊ฐ 8, ์ธ๋ก๊ฐ 12์ธ ์ง์ฌ๊ฐํ์ ๋๊ฐ์ ๋ฐฉํฅ์ผ๋ก ์๋ฅด๋ฉด ์ด 16๊ฐ ์ ์ฌ๊ฐํ์ ์ฌ์ฉํ ์ ์๊ฒ ๋ฉ๋๋ค. ์๋ ์ง์ฌ๊ฐํ์์๋ 96๊ฐ์ ์ ์ฌ๊ฐํ์ ๋ง๋ค ์ ์์์ผ๋ฏ๋ก, 96 - 16 = 80 ์ ๋ฐํํฉ๋๋ค.
// a > b ํฐ ๊ฒฝ์ฐ์ผ๋ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋
// ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ(while ์ฌ์ฉ)
int temp;
while (a % b != 0) {
temp = a % b;
a = b;
b = temp;
}
// while ๋ฌธ์ด ๋๋๋ฉด b๊ฐ ์ต๋๊ณต์ฝ์๋ก ์ค์
public class Solution {
// ํ๋ก๊ทธ๋๋จธ์ค LEVEL2 ๋ฉ์ฉกํ ์ฌ๊ฐํ - 2
// ๋ฌธ์ URL : <https://programmers.co.kr/learn/courses/30/lessons/62048>
/*
๊ฐ๋ก : 2, ์ธ๋ก : 3
์ต๋๊ณต์ฝ์ : 1
์ฌ์ฉ๋ชปํ๋ ์ฌ๊ฐํ : ((2/1) + (3/1) - 1) * 1 = 4
์ฌ์ฉ๊ฐ๋ฅ ์ฌ๊ฐํ : 2
๊ฐ๋ก : 8, ์ธ๋ก : 12
์ต๋๊ณต์ฝ์ : 4
์ฌ์ฉ๋ชปํ๋ ์ฌ๊ฐํ : ((8/4) + (12/4) - 1) * 4 = 16
์ฌ์ฉ๊ฐ๋ฅ ์ฌ๊ฐํ : 96 - 16 = 60
*/
public long solution(int w, int h) {
long answer = 1;
int gcp = gcp(Math.max(w, h), Math.min(w, h));
// answer ๊ฐ์ด long ์ด๊ธฐ ๋๋ฌธ์ long ํํ๋ก casting ํ์
Long lGcp = Long.valueOf(gcp);
Long lw = Long.valueOf(w);
Long lh = Long.valueOf(h);
answer = (lw * lh) - (((lw/lGcp) + (lh/lGcp) - 1) * lGcp);
return answer;
}
// ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ(์ต๋๊ณต์ฝ์ ์ถ์ถ) --> while ๋ฌธ ์ฌ์ฉ
private int gcp(int a, int b) {
int temp;
while (a % b != 0) {
temp = a % b;
a = b;
b = temp;
}
return b;
}
}
<aside> ๐ ์ฐธ์กฐ Github Code
</aside>