๐ก ๋ฌธ์
์ฒซ ๋ฒ์งธ ๋ถ์์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๋ปํ๋ numer1, denom1, ๋ ๋ฒ์งธ ๋ถ์์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๋ปํ๋ numer2, denom2๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ ๋ถ์๋ฅผ ๋ํ ๊ฐ์ ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋์ ๋ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ์์๋๋ก ๋ด์ ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
๋ฌธ์ ์๊ตฌ์ฌํญ ๋ถ์:
- ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋ถ์์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ๊ตฌํ๋ค.
- ๊ตฌํ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋ธ๋ค.
- ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋ธ ๊ฒฐ๊ณผ์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ์์๋๋ก ๋ฐฐ์ด์ ๋ด์ return ํ๋ค.
ํด๊ฒฐ ๋ฐฉ๋ฒ:
- ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋ถ์์ ๋ถ๋ชจ(denominator)์ ์ต์๊ณต๋ฐฐ์(lcm)๋ฅผ ๊ตฌํ๋ค.
- ์ต์๊ณต๋ฐฐ์(lcm)๋ก ๊ฐ ๋ถ์์ ๋ถ์(numerator)๋ฅผ ๊ณฑํ ๋ค, ๋ํ์ฌ ์๋ก์ด ๋ถ์๋ฅผ ๊ตฌํ๋ค.
- ์๋ก์ด ๋ถ์์ ์ต์๊ณต๋ฐฐ์(lcm)๋ฅผ ๊ธฐ์ฝ๋ถ์๋ก ๋ํ๋ธ๋ค. ์ด ๋, ๋ถ์์ ๋ถ๋ชจ์ ์ต๋๊ณต์ฝ์(gcd)๋ฅผ ๊ตฌํ ๋ค, ๊ฐ๊ฐ์ ์ต๋๊ณต์ฝ์๋ก ๋๋์ด ์ค๋ค.
์๊ฐ ๋ณต์ก๋:
์ฃผ์ด์ง ๋ฌธ์ ๋ ๋ถ์์ ๋ง์ ์ฐ์ฐ์ ์ํํ๊ณ , ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋ด๋ ๊ฒ์ด ์๊ตฌ๋๋ค. ๋ถ์์ ๋ง์ ์ฐ์ฐ์ ๋ถ๋ชจ์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ ํ, ๋ ๋ถ์์ ๋ถ์๋ฅผ ๊ณฑํ์ฌ ๋ถ๋ชจ๋ก ๋๋๋ ๊ฒ์ผ๋ก ์ํ๋๋ค. ์ด๋ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ๊ณผ์ ์์ O(n)์ ์๊ฐ์ด ํ์ํ๋ฉฐ, ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๊ณฑํ๋ ๊ณผ์ ์์๋ O(n)์ ์๊ฐ์ด ์์๋๋ค.
๋ฐ๋ผ์, ์ฃผ์ด์ง ๋ฌธ์ ์ ์๊ฐ ๋ณต์ก๋๋ O(n)์ด๋ค.
- ์ฃผ์ด์ง ๋ ๋ถ์์ ๋ถ๋ชจ์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ค. ์ต์๊ณต๋ฐฐ์๋ ๋ ์์ ๊ณตํต์ธ ๋ฐฐ์ ์ค ๊ฐ์ฅ ์์ ์๋ฅผ ์๋ฏธํ๋ค.
- ์ต์๊ณต๋ฐฐ์๋ฅผ ์ด์ฉํ์ฌ ๊ฐ ๋ถ์์ ๋ถ์๋ฅผ ๊ณฑํ ๋ค, ๋ํ์ฌ ์๋ก์ด ๋ถ์๋ฅผ ๊ตฌํ๋ค.
- ์๋ก์ด ๋ถ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ธฐ์ฝ๋ถ์๋ก ๋ํ๋ธ๋ค. (๊ธฐ์ฝ๋ถ์: ๋ถ์์ ๋ถ๋ชจ๊ฐ ์๋ก์์ธ ๋ถ์) ์ด๋, ๋ถ์์ ๋ถ๋ชจ์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ ๋ค, ๊ฐ๊ฐ์ ์ต๋๊ณต์ฝ์๋ก ๋๋๋ค.
์๋ฅผ ๋ค์ด, 2/3๊ณผ 3/4์ ํฉ์ ๊ตฌํ๋ค๋ฉด, ๋จผ์ 3๊ณผ 4์ ์ต์๊ณต๋ฐฐ์์ธ 12๋ฅผ ๊ตฌํ๋ค. ๊ทธ๋ฆฌ๊ณ 2/3์ 8/12๋ก, 3/4๋ฅผ 9/12๋ก ๋ณํํ ๋ค, ๋ํด์ค๋ค. ๋ฐ๋ผ์, 2/3 + 3/4 = 8/12 + 9/12 = 17/12๊ฐ ๋๋ค. ๋ง์ง๋ง์ผ๋ก, 17/12๋ฅผ ๊ธฐ์ฝ๋ถ์๋ก ๋ํ๋ด๋ฉด, ๋ถ์์ ๋ถ๋ชจ์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ๊ณผ์ ์ ๊ฑฐ์น๋ค. ์ด ๊ฒฝ์ฐ, 17๊ณผ 12์ ์ต๋๊ณต์ฝ์๋ 1์ด๋ฏ๋ก, 17/12๊ฐ ๊ธฐ์ฝ๋ถ์๊ฐ ๋๋ค.
๐ ๋ด ๋ต์
import java.util.*;
class Solution {
public int[] solution(int numer1, int denom1, int numer2, int denom2) {
// 1. ์ต์๊ณต๋ฐฐ์(lcm) ๊ณ์ฐ
int lcm = (denom1 * denom2) / gcd(denom1, denom2);
// 2. ์๋ก์ด ๋ถ์ ๊ณ์ฐ
int newNumer = numer1 * (lcm / denom1) + numer2 * (lcm / denom2);
// 3. ๊ธฐ์ฝ๋ถ์๋ก ๋ณํ
int gcd = gcd(newNumer, lcm);
return new int[] { newNumer / gcd, lcm / gcd };
}
// ์ต๋๊ณต์ฝ์ ๊ณ์ฐ ํจ์
private int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
}
import java.util.*;
import java.util.stream.*;
class Solution {
public int[] solution(int numer1, int denom1, int numer2, int denom2) {
int lcm = lcm(denom1, denom2);
int newNumer = numer1 * (lcm / denom1) + numer2 * (lcm / denom2);
int gcd = gcd(newNumer, lcm);
return IntStream.of(newNumer / gcd, lcm / gcd).toArray();
}
public int lcm(int a, int b) {
return a * b / gcd(a, b);
}
public int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
}
'๐ Algorithm > PGS' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] ์ต๋น๊ฐ ๊ตฌํ๊ธฐ (JAVA) (0) | 2023.03.12 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] ์ค์๊ฐ ๊ตฌํ๊ธฐ (JAVA) (0) | 2023.03.11 |
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ฐฐ์ด ์์์ ๊ธธ์ด (0) | 2023.03.08 |
[ํ๋ก๊ทธ๋๋จธ์ค] Lv.0 ์ง์์ ํฉ (Java) (0) | 2023.02.22 |
[ํ๋ก๊ทธ๋๋จธ์ค] Lv.0 ์๊ผฌ์น (Java) (0) | 2023.02.22 |