Parasitic Number(๊ธฐ์์)๋?
๊ธฐ์์๋ฅผ ์ฐพ๋ ๊ณต์
Solution
parasitic ๊ฐ๋
์์ฒด๋ ์ด๋ ต์ง๋ง ํธ๋ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ๋ค.
n์ผ๋ก ๋๋๋ ๊ธฐ์์๋ฅผ ๊ตฌํ๋ ๊ณต์ ์ผ๋ก ์ํ์์๋ฅผ ๊ตฌํ๊ณ ๋ฐ๋ณต๋๋ ๋ถ๋ถ์ ๊ตฌํ๋ฉด ๋๋ค.
๋ค๋ง ๋๋์
, ๊ณฑ์
์ฐ์ฐ ์ ๋๋ฌด ๊ธธ์ด๊ฐ ๊ธด ์๋ ์ธ์ด ์์ฒด์์ ์๋ผ๋ฒ๋ฆฌ๋ฏ๋ก ๋๋์
์ ์ง์ ๊ตฌํํด์ผ ํ๋ค. ๋ฐ๋ผ์ ์ด ์๋ฃจ์
์ 8, 10, 16์ง๋ฒ์ ๋๋์
์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ด๋ค.
// find parasitic number ending in n
function calculateSpecial(n, base) {
let curr=n, decimalStr='', dn=base*n-1,remainder;
do {
decimalStr += (~~(curr/dn)).toString(base)
if (dn <= curr) {
curr = remainder = curr%dn
}
curr *= base
} while (remainder !== n)
return decimalStr.slice(1) // excludes integer part
}
JavaScript
๋ณต์ฌ
โข
dn์ denominator(๋ถ๋ชจ)์ ์ฝ์, remainder๋ ๋๋จธ์ง, period๋ ๋ฐ๋ณต๋๋ ์์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ค.
โข
dn์ ๊ธฐ์์์ ๊ณต์์ ๋ฐ๋ผ 10n -1์ด ๋๋ค. ๋จ ์ฌ๊ธฐ์๋ 8, 10, 16์ง๋ฒ ๋ชจ๋ ๊ตฌํํด์ผ ํ๋ฏ๋ก base๋ฅผ ๊ณฑํด์ค๋ค. base*n - 1
โข
parseInt(curr/dn).toString(base) ์ด์ ํ์๋ ์ฝ๋์์ 16์ง๋ฒ ๊ธฐ์์์์ ๊ณ์ ์๋ฌ๊ฐ ๋ฌ๋๋ฐ ์ด๋ถ๋ถ ๋๋ฌธ์ด์๋ค. 16์ง๋ฒ์ผ ๋ ๋ชซ์์ 10์ด ๋์ด๊ฐ๋ ๊ตฌ๊ฐ์ a,b,c,d,e ๋ก ๋ฐ๊ฟ์ค์ผ ํ๋ค. Math.floor, parseInt, ~~ ์ฐ์ฐ์๋ก ๋ชซ์ ๊ตฌํ ์ ์๋๋ฐ ๊ตฌ๊ธ๋ง์ ํด๋ณด๋ ~~ (tlide ์ฐ์ฐ์)๊ฐ ์ ์ผ ๋น ๋ฅด๋ค๊ณ ํ๋ค. (~~(curr/dn)).toString(base) ์ด๋ ๊ฒ ๋ฐ๊ฟ๋ณด์๋ค.
โข
do ๋ถ๋ถ์ ๋๋์
์ ๊ตฌํํ ๋ถ๋ถ์ด๋ค. decimalStr์ ๋ชซ์ ํด๋นํ๋ ๋ฌธ์์ด๋ค์ ์ง์ด๋ฃ๋๋ค. ๋๋จธ์ง๊ฐ ๋ค์ ์ฒ์ ์์ ๊ฐ์์ง๋ฉด (remainder===n) ์ด๋๋ถํฐ๋ ๊ฐ์ ๋ถ๋ถ์ด ๋ฐ๋ณต๋๊ธฐ ๋๋ฌธ์ ์ฌ๊ธฐ์ breakํ๋ฉด ๋๋ค.
โข
decimalStr.slice(1) parasitic number๋ 0.xxxx์ ๊ฐ์ ํํ์ด๋ค. ์ ์๋ถ๋ฅผ ๋ฒ๋ฆฌ๊ธฐ ์ํด sliceํ๋ค.
Best Practice
const calculateSpecial = (t, i) => {
let l = 0,
n = t,
o = t.toString(i);
do {
o += (n = (l = n * t + ~~(l / i)) % i).toString(i)
} while (l != t);
return o.slice(1)
}
JavaScript
๋ณต์ฌ
โข
i๋ base. n์ ํ์ฌ ์(๋๋์
๊ณผ์ ์ ๊ฑฐ์น๊ณ ์๋ ์), t๋ ์
๋ ฅ๋ฐ์ ์ซ์, l์ ๋๋จธ์ง, o๋ ๋ชซ์ ํด๋นํ๋ค.
โข
์.. ์ ์ด๋ ๊ฒ ๋์จ๊ฑฐ์ง? ๊ฐ๊ฒฐํ๊ธด ํ๋ฐ ์ ์ด๋ ๊ฒ ๋ ๊ฑด์ง ๋ชจ๋ฅด๊ฒ ๋ค.
