์ฒ ์์ ์ํฌ๋ ์ ์๋์ผ๋ก๋ถํฐ ์ซ์๊ฐ ํ๋์ฉ ์ ํ ์นด๋๋ค์ ์ ๋ฐ์ฉ ๋๋ ์ ๊ฐ์ง ํ, ๋ค์ ๋ ์กฐ๊ฑด ์ค ํ๋๋ฅผ ๋ง์กฑํ๋ ๊ฐ์ฅ ํฐ ์์ ์ ์ a์ ๊ฐ์ ๊ตฌํ๋ ค๊ณ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ์นด๋๋ค์ 10, 5, 20, 17์ด ์ ํ ์๋ ๊ฒฝ์ฐ์ ๋ํด ์๊ฐํด ๋ด ์๋ค. ๋ง์ฝ, ์ฒ ์๊ฐ [10, 17]์ด ์ ํ ์นด๋๋ฅผ ๊ฐ๊ณ , ์ํฌ๊ฐ [5, 20]์ด ์ ํ ์นด๋๋ฅผ ๊ฐ๋๋ค๋ฉด ๋ ์กฐ๊ฑด ์ค ํ๋๋ฅผ ๋ง์กฑํ๋ ์์ ์ ์ a๋ ์กด์ฌํ์ง ์์ต๋๋ค. ํ์ง๋ง, ์ฒ ์๊ฐ [10, 20]์ด ์ ํ ์นด๋๋ฅผ ๊ฐ๊ณ , ์ํฌ๊ฐ [5, 17]์ด ์ ํ ์นด๋๋ฅผ ๊ฐ๋๋ค๋ฉด, ์ฒ ์๊ฐ ๊ฐ์ง ์นด๋๋ค์ ์ซ์๋ ๋ชจ๋ 10์ผ๋ก ๋๋ ์ ์๊ณ , ์ํฌ๊ฐ ๊ฐ์ง ์นด๋๋ค์ ์ซ์๋ ๋ชจ๋ 10์ผ๋ก ๋๋ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ฒ ์์ ์ํฌ๋ ๊ฐ๊ฐ [10, 20]์ด ์ ํ ์นด๋, [5, 17]์ด ์ ํ ์นด๋๋ก ๋๋ ๊ฐ์ก๋ค๋ฉด ์กฐ๊ฑด์ ํด๋นํ๋ ์์ ์ ์ a๋ 10์ด ๋ฉ๋๋ค.
์ฒ ์๊ฐ ๊ฐ์ง ์นด๋์ ์ ํ ์ซ์๋ค์ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด arrayA
์ ์ํฌ๊ฐ ๊ฐ์ง ์นด๋์ ์ ํ ์ซ์๋ค์ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด arrayB
๊ฐ ์ฃผ์ด์ก์ ๋, ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์ฅ ํฐ ์์ ์ ์ a๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๋ง์ฝ, ์กฐ๊ฑด์ ๋ง์กฑํ๋ a๊ฐ ์๋ค๋ฉด, 0์ return ํด ์ฃผ์ธ์.
arrayA
์ ๊ธธ์ด = arrayB
์ ๊ธธ์ด โค 500,000arrayA
์ ์์, arrayB
์ ์์ โค 100,000,000arrayA
์ arrayB
์๋ ์ค๋ณต๋ ์์๊ฐ ์์ ์ ์์ต๋๋ค.arrayA | arrayB | result |
---|---|---|
[10, 17] | [5, 20] | 0 |
[10, 20] | [5, 17] | 10 |
[14, 35, 119] | [18, 30, 102] | 7 |
์ ์ถ๋ ฅ ์ #1
์ ์ถ๋ ฅ ์ #2
์ ์ถ๋ ฅ ์ #3
function solution(arrayA, arrayB) {
// ์ค๋ณต๋ ์์ ์ ๊ฑฐ ํ ์ค๋ฆ์ฐจ ์ ์ ๋ ฌ
arrayA = [...new Set(arrayA)].sort((a,b) => a-b)
arrayB = [...new Set(arrayB)].sort((a,b) => a-b)
// ์ต๋ ๊ณต์ฝ์๋ฅผ ์ฐพ๋ ํจ์, ๋ฐ๋ณต์ ์์๊ฐ์ action ๋ฐฐ์ด์ ์ต์๊ฐ๋ถํฐ 1์ฉ ๋ฎ์์ง๋ฉฐ ํ์
function findCommonDivisor(action, target) {
for(let i = action[0] ; i > 0 ; i --) {
if(action.every(a => a%i === 0) && target.every(a => a%i !== 0)) return i
}
return 0
}
// ์ฒ ์ ์นด๋๋ฅผ ๋ชจ๋ ๋๋๊ณ ์ํฌ ์นด๋๋ฅผ ๋๋์ง ๋ชปํ๋ ๊ฒฝ์ฐ์ ๊ทธ ๋ฐ๋์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ ์ค ๊ฐ์ฅ ํฐ ์
return Math.max(findCommonDivisor(arrayA, arrayB), findCommonDivisor(arrayB, arrayA));
}