ํ์ด ๐๐ปโ๏ธ
function solution(n, m) {
return [maxAcommonDivisor(n, m), (n * m) / maxAcommonDivisor(n, m)];
}
function maxAcommonDivisor(a, b) {
let remainder = 0;
while (b !== 0) {
remainder = a % b;
a = b;
b = remainder;
}
return a;
}
/*
(ํ์ด)
์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ํจ์๋ฅผ ๋ง๋ค์ด์ค๋ค. ํจ์๋
๋๋จธ์ง ๊ฐ์ ๋ฃ์ด์ฃผ๋ ๋ณ์ํ๋๋ฅผ ์์ฑํด์ฃผ๊ณ while ๋ฌธ์ผ๋ก b๊ฐ 0์ด ๋๋ฉด ํ์ถํ๊ฒ ๋๋๋ฐ ์ด์ ๋
(a๊ฐ ์์๊ฒฝ์ฐ)
remainder = a ๊ฐ ๊ทธ๋๋ก ๋ค์ด๊ฐ
a = b a๋ณด๋ค ํฐ๊ฐ์ธ b๊ฐ ๋ค์ด๊ฐ
b = remainder ๋๋จธ์ง๊ฐ์ด ์๋ a๊ฐ b์ ํ ๋น๋๊ณ ๊ฒฐ๊ตญ a=b b=a ๊ฐ ๋์ด ๋ค์
๋ฐ๋ณต๋ถํฐ๋ ํฐ๊ฐ์์ ์์๊ฐ์ ๋๋ ๋๋จธ์ง๊ฐ์ b์ ํ ๋นํ๊ฒ ๋๋ค ์ด๋ ๊ฒ ๋ฐ๋ณต๋ฌธ์ ๋๋ค๋ณด๋ฉด
๋๋จธ์ง๊ฐ์ ํ ๋น๋ฐ๋ b๋ ๋ง์๋จ์ด์ง ๊ฒฝ์ฐ 0 ์ด ๋๊ณ ๊ทธ๋ ๋๋จธ์ง๋ฅผ 0 ์ผ๋ก ๋ง๋๋ ์์๊ฐ b๋ฅผ
ํ ๋น ๋ฐ์ a๋ฅผ ๋ฆฌํดํด์ ๋ฐ์์ค๋ฉด ๊ทธ๊ฐ์ด ์ต๋๊ณต์ฝ์์ด๋ค.
์ต์๊ณต๋ฐฐ์๋ 2๊ฐ์ ํผ์ฐ์ฐ์ ๊ฐ์ ๊ณฑํ๊ฐ์ ์ต๋๊ณต์ฝ์๋ฅผ ๋๋ ์ฃผ๋ฉด ๋์จ๋ค.
์ดํด๋ ํ๋๋ฐ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ฐ๊ดํ์ฌ ํ์ด๊ฐ๋๊ฑด ์ด๋ ต๋ค...
*/
์ฐธ๊ณ ํ์ด (์ฌ๊ทํจ์, ํจ์๋ถ๋ฆฌ)
function solution(n, m) {
return [greatestCommonDivisor(n, m), leastCommonMultiple(n, m)];
}
//์ต๋ ๊ณต์ฝ์
function greatestCommonDivisor(num1, num2) {
const remainder = num1 % num2;
return num2 === 0 ? num1 : greatestCommonDivisor(num2, remainder);
}
//์ต์ ๊ณต๋ฐฐ์
function leastCommonMultiple(num1, num2) {
return (num1 * num2) / greatestCommonDivisor(num1, num2);
}
- ์ฌ๊ท ํจ์๋ฅผ ์ด์ฉํด ํ์ด๋ธ ํ์ด๋ค.
- ํจ์๋ฅผ ๋ถ๋ฆฌํด ์ฝ์ด๋ด๊ธฐ์ ํจ์ฌ ์ฌ์๋ณด์ธ๋ค.
์ฐธ๊ณ ํ์ด2 (์ฌ๊ทํจ์, ์ค์ฒฉํจ์)
function solution(n, m) {
const gcd = (a, b) => (a % b === 0 ? b : gcd(b, a % b));
const lcm = (a, b) => (a * b) / gcd(a, b);
return [gcd(n, m), lcm(n, m)];
}
- ์ค์ฒฉํจ์๋ฅผ ์ฌ์ฉํ ํ์ด๋ค.
- ์์ ์๋ ์ค์ฒฉํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ฑ๋ฅ์์ ์ด์๊ฐ ์์์ง๋ง ํ์ฌ๋ ์๋ฌด๋ฐ ๋ฌธ์ ๊ฐ ์๊ธฐ์ ๋ถ๋ฆฌํ ํจ์์ ์ค์ฒฉํจ์ ์ค ๋ชฉ์ ๊ณผ ์ฅ์ ์ ๋น๊ตํ์ฌ ์๊ฐํ๋ฉฐ ์ฝ๋๋ฅผ ์ง๋๋ก ๋ ธ๋ ฅํ์.
- ์ฌ๊ทํจ์๋ฅผ ์ฃผ๋ก ์ฌ์ฉํ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฑ.. ์๊ฐ ๋ ๋ ํ๋์ฉ ์ฐพ์์ ์ ๋ฆฌํด๋ณด์.
'์๊ณ ๋ฆฌ์ฆ & ๋ฌธ์ ํ์ด > Programmers-1' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ด์ํ ๋ฌธ์ ๋ง๋ค๊ธฐ (0) | 2022.10.01 |
---|---|
๊ฐ์ ์ซ์๋ ์ซ์ด (0) | 2022.09.30 |
์ฝ์์ ๊ฐ์์ ๋ง์ (0) | 2022.09.28 |
ํ๋ ฌ์ ๋ง์ (0) | 2022.09.27 |
๋ด์ (0) | 2022.09.27 |