โญ๏ธ ์๊ณ ๋ฆฌ์ฆ(13) : ์ ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ _ Lv.1 โญ๏ธ
01. ๋ฌธ์ ์ค๋ช
๐งฉ ํจ์ solution์ ์ ์ n์ ๋งค๊ฐ๋ณ์๋ก ์
๋ ฅ๋ฐ์ต๋๋ค.
๐งฉ n์ ๊ฐ ์๋ฆฟ์๋ฅผ ํฐ ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํ ์๋ก์ด ์ ์๋ฅผ ๋ฆฌํดํด์ฃผ์ธ์.
๐งฉ ์๋ฅผ ๋ค์ด n์ด 118372๋ฉด 873211์ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
๐ ์ ํ ์กฐ๊ฑด : n์ 1์ด์ 8000000000 ์ดํ์ธ ์์ฐ์์
๋๋ค.
02. " solution.js " ๋ฌธ์ ํ์ด๋ณด๊ธฐ
๐ก ์ ์ n ์ ๋ฌธ์์ด ๋ฐฐ์ด๋ก ๋๋ ๋ค์ ๊ฐ ์์์ ๋ํด ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ , ๋๋ ์์๋ค์ ๋ค์ ํฉ์ณ๋ณด์.
function solution(n) {
let change = n + ""; // ์ซ์ + "" ๋น ๋ฌธ์์ด -> ๋ฌธ์์ด๋ก ๋ฐ๊พธ๊ธฐ
let answer = change.split('');
return Number(answer.sort((a, b) => b - a).join('')); // ๋ฐฐ์ด์ ์ซ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ , ํฉ์ณ์ ๋ฐํํ๊ธฐ
}
// ์์ ์์ ๋ ์งง๊ฒ ์ค์ด๋ฉด,
// function solution(n) { return (n + '').split('').sort((a, b) => b - a).join('') * 1; }
console.log(solution("118372"))
___ ์ฐธ๊ณ ํ๊ธฐ ___
`1 String.prototype.split( ) : ๋ถํ ๊ธฐ์ค์ ๋ฐ๋ผ ๋ฌธ์์ด์ ๋ถํ ํ์ฌ ๋ฐฐ์ด๋ก ๋ฐํํฉ๋๋ค.
`2 Array.prototype.sort( ) : ๋ฐฐ์ด์ ์์๋ฅผ ์ ์ ํ ์์น์ ์ ๋ ฌํ ํ ๊ทธ ๋ฐฐ์ด์ ๋ฐํํฉ๋๋ค. ๊ธฐ๋ณธ ์ ๋ ฌ ์์๋ ๋ฌธ์์ด์ ์ ๋์ฝ๋ ์ฝ๋ ํฌ์ธํธ๋ฅผ ๋ฐ๋ฆ
๋๋ค.
`3 Array.prototype.join( ) : ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ๊ฒฐํฉํ์ฌ ํ๋์ ๋ฌธ์์ด๋ก ๋ฐํํฉ๋๋ค.
๋ฐํ๊ฐ์ผ๋ก ๋์ค๋ ๋ฌธ์์ด์ ๊ตฌ๋ถ์(๋์ด์ฐ๊ธฐ, ํน์๋ฌธ์, - ๋ค์, ๋ฑ)์ ์ง์ ํ ์ ์์ต๋๋ค.
03. ๋ค๋ฅธ ํ์ด ์์๋ณด๊ธฐ
# 1) do ... while๋ฌธ๊ณผ push( ), Math.floor( ) ํ์ฉํ๊ธฐ
function solution(n) {
let nums =[];
do{
nums.push( n % 10 ); // nums์ ์ผ์ ์๋ฆฌ ๊ฐ์ด ์ ์ฅ๋จ
n = Math.floor( n / 10 );
} while( n > 0 ) // nums = [2, 7, 3, 8, 1, 1]
return nums.sort((a, b) => b - a ).join('') *1; // ํ๋ณํ์ ์ํด *1 ํด์ค
return (n + "").split('').sort((a, b) => b - a ).join('') *1;
}
console.log(solution("118372"))
___ ์ฐธ๊ณ ํ๊ธฐ ___
`1 do ... while ๋ฌธ : ํ
์คํธ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ผ๋ก ํ๊ฐ๋ ๋๊น์ง ์ง์ ๋ ๊ตฌ๋ฌธ์ ์คํํ๋ ๋ฃจํ๋ฅผ ๋ง๋ญ๋๋ค.
๊ตฌ๋ฌธ์ด ์คํ๋ ๋ค์ ํ
์คํธ ์กฐ๊ฑด์ด ํ๊ฐ๋จ์ผ๋ก ๊ตฌ๋ฌธ์ ๋ฌด์กฐ๊ฑด ํ ๋ฒ์ ์คํ๋ฉ๋๋ค.
`2 Array.prototype.push( ) : ๋ฐฐ์ด์ ๋ง์ง๋ง์ ์๋ก์ด ์์๋ฅผ ์ถ๊ฐํ ํ, ๋ณ๊ฒฝ๋ ๋ฐฐ์ด์ ๊ธธ์ด(๋ฐฐ์ด์ ์)๋ฅผ ๋ฐํํฉ๋๋ค.
`3 Math.floor( ) : ์ฃผ์ด์ง ์ซ์์ ๊ฐ๊ฑฐ๋ ์์ ์ ์ ์ค์์ ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ฐํํฉ๋๋ค. โ ๋ด๋ฆผ
# 2) ์ฌ๋ฌ ๊ฐ์ง ๋ฉ์๋๋ฅผ ๋ณตํฉ์ ์ผ๋ก ํ์ฉํ ๋ฐฉ๋ฒ
function solution(n) {
let r = 0,
e = 0,
arr = [];
do {
e = n % 10;
// ์ ๋ ฌํ๊ธฐ
if (arr.length == 0) arr.push(e);
else for (let i=0, len=arr.length; i<len; i++) {
if (arr[i] <= e) { arr.splice(i, 0, e); break; }
if (i == len -1) arr.push(e);
}
} while (n = Math.floor( n / 10 ), n > 0);
return parseInt(arr.join(""));
}
console.log(solution("118372"))
___ ์ฐธ๊ณ ํ๊ธฐ ___
`1 if๋ฌธ : if๋ฌธ์ ์ง์ ํ ์กฐ๊ฑด์ด ์ฐธ์ธ ๊ฒฝ์ฐ ๋ช
๋ น๋ฌธ(statement)์ ์คํํฉ๋๋ค. ์กฐ๊ฑด์ด ๊ฑฐ์ง์ธ ๊ฒฝ์ฐ ๋ ๋ค๋ฅธ ๋ช
๋ น๋ฌธ์ด ์คํ๋ ์ ์์ต๋๋ค.
`2 parseInt( ) : ๋ฌธ์์ด ์ธ์๋ฅผ ์ซ์๋ก ๋ณ๊ฒฝํ์ฌ ๋ฐํํฉ๋๋ค. Number( )์ ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋ฉฐ,
์ฐจ์ด์ ์ ์ดํด๋ณด์๋ฉด Number( )์ ๋ฌธ์์ด์ ์ซ์๊ฐ ์๋ ๋ฌธ์๊ฐ ์์ ๊ฒฝ์ฐ ๋ฌด์กฐ๊ฑด NaN ๊ฐ์ด ์ ์ฅ๋๊ณ
parseInt( )๋ ๋ฌธ์์ด์ด ์ซ์๋ก ์์ํ๊ณ ๋ฌธ์๊ฐ ๊ปด์์ ๊ฒฝ์ฐ ๋ฌธ์ ์ ๊น์ง๋ง ์ซ์๋ก ํ๋ณํ ํ ์ ์ฅ๋๋ค๋ ๊ฒ.
# 3) while๋ฌธ๊ณผ pop( ) ํ์ฉํ๊ธฐ
function solution(n) {
let answer = 0;
n += '';
n = n.split('').sort();
while (n.length > 0) {
answer += n.pop();
}
return parseInt(answer);
}
console.log(solution("118372"))
___ ์ฐธ๊ณ ํ๊ธฐ ___
`1 while๋ฌธ : ์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ผ ๋ ์คํ๋๋ ๋ฐ๋ณต๋ฌธ์
๋๋ค.
๋ฐ๋ณต ์์ ์ ์ ์กฐ๊ฑด๋ฌธ์ด ์ฐธ, ๊ฑฐ์ง์ ํ๋จ๋ฐ์ผ๋ฏ๋ก, ์กฐ๊ฑด๋ฌธ์ด ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ, ๋ฌธ์ฅ์ while ๋ฐ๋ณต๋ฌธ ํ๋ก ๊ทธ๋ฅ ๋์ด๊ฐ๋๋ค.
`2 Array.prototype.pop( ) : ๋ฐฐ์ด์์ ๋ง์ง๋ง ์์๋ฅผ ์ ๊ฑฐํ๊ณ ๊ทธ ์์๋ฅผ ๋ฐํํฉ๋๋ค.
'Algorithm_JS' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์๊ณ ๋ฆฌ์ฆ(12) : ํธ๋ํฐ ๋ฒํธ ๊ฐ๋ฆฌ๊ธฐ _ Lv.1 (2) | 2022.11.07 |
---|---|
์๊ณ ๋ฆฌ์ฆ(11) : ์ด์ํ ๋ฌธ์ ๋ง๋ค๊ธฐ _ Lv.1 (2) | 2022.11.06 |
์๊ณ ๋ฆฌ์ฆ(10) : ์๋ฆฟ์ ๋ํ๊ธฐ _ Lv.1 (1) | 2022.11.06 |
์๊ณ ๋ฆฌ์ฆ(9) : ๋๋จธ์ง๊ฐ 1์ด ๋๋ ์ ์ฐพ๊ธฐ _ Lv.1 (4) | 2022.11.04 |
์๊ณ ๋ฆฌ์ฆ(8) : ์์ธ์์ ๊น์๋ฐฉ ์ฐพ๊ธฐ _ Lv.1 (1) | 2022.11.03 |
๋๊ธ