๋ค์ด๊ฐ๋ฉฐ
- ์ด๋ฒ ์ฃผ๋ ์ธํฐ๋ทฐ ๊ณผ์ ๊ตฌํ์ ๊ฒธํ๋๋ผ ๋ฌธ์ ๋ฅผ ๋ง์ด ํ์ง ๋ชปํ๋ค. ๋ฐธ๋ฐ์ค๋ฅผ ์ ์งํ๋๊ฒ ์ฝ์ง ์์ ๊ฒ ๊ฐ๋ค.
- ์ค์ฐํด์ ์ ๋ ฌ ๋ถ๋ถ์ ๋ค์ ๋ด์ผ๊ฒ ๋ค.
๋ฌธ์ ํ์ด๋ก ๋ฐ๋ก ๋์ด๊ฐ๊ฒ ๋ค.
๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ ์ถ์ฒ ํ๋ก๊ทธ๋๋จธ์ค๋ฐ๋ก๊ฐ๊ธฐ
๋ฌธ์ ์จ๋จธ๋ฆฌ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด๋ก ๊ตฌ์ฑ๋ ๋ฆฌ์คํธ strings์, ์ ์ n์ด ์ฃผ์ด์ก์ ๋, ๊ฐ ๋ฌธ์์ด์ ์ธ๋ฑ์ค n๋ฒ์งธ ๊ธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ ค ํฉ๋๋ค. ์๋ฅผ ๋ค์ด strings๊ฐ ["sun", "bed", "car"]์ด๊ณ n์ด 1์ด๋ฉด ๊ฐ ๋จ์ด์ ์ธ๋ฑ์ค 1์ ๋ฌธ์ "u", "e", "a"๋ก strings๋ฅผ ์ ๋ ฌํฉ๋๋ค. ์ ํ ์กฐ๊ฑด strings๋ ๊ธธ์ด 1 ์ด์, 50์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค. strings์ ์์๋ ์๋ฌธ์ ์ํ๋ฒณ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. strings์ ์์๋ ๊ธธ์ด 1 ์ด์, 100์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค. ๋ชจ๋ strings์ ์์์ ๊ธธ์ด๋ n๋ณด๋ค ํฝ๋๋ค. ์ธ๋ฑ์ค 1์ ๋ฌธ์๊ฐ ๊ฐ์ ๋ฌธ์์ด์ด ์ฌ๋ฟ ์ผ ๊ฒฝ์ฐ, ์ฌ์ ์์ผ๋ก ์์ ๋ฌธ์์ด์ด ์์ชฝ์ ์์นํฉ๋๋ค.
์ด ๋ฌธ์ ๋ ์ฃผ์ด์ง ๋ฌธ์์ด ๋ฐฐ์ด(strings)๊ณผ ์ ์(n)๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์, ๊ฐ ๋ฌธ์์ด์ ์ฃผ์ด์ง n๋ฒ์งธ ๋ฌธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ํ ์ ๋ ฌ๋ ๋ฐฐ์ด์ ๋ฐํ ํ๋ค.
๋ฌธ์์ด์ ๋ค๋ฃจ๋ ๊ฒฝ์ฐ ์ ๋์ฝ๋(Unicode) ๊ฐ์ ์์ฃผ ์ด์ฉํ๋ ํธ์ธ๋ฐ strings ๋ฐฐ์ด์ ๊ฐ ๋ฌธ์์ด์ ๋ํด ๋ฐ๋ณต๋ฌธ์ ์คํํ๋ฉด์, n๋ฒ์งธ ๋ฌธ์๋ฅผ ์ถ์ถํ๊ณ ๊ทธ ๋ฌธ์์ ์ ๋์ฝ๋ ์ฝ๋ ํฌ์ธํธ ๊ฐ์ ์ด์ฉํ์ฌ freq ๋ฐฐ์ด์ ํด๋น ๋ฌธ์์ด์ ์ถ๊ฐํ๋ค. n๋ฒ์งธ ๋ฌธ์์ ์ ๋์ฝ๋ ์ฝ๋ ํฌ์ธํธ์์ 97์ ๋นผ์ฃผ๋ ์ด์ ๋ ์๋ฌธ์ 'a'์ ์ ๋์ฝ๋ ์ฝ๋ ํฌ์ธํธ๊ฐ 97์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ n๋ฒ์งธ ๋ฌธ์๊ฐ 'a'๋ผ๋ฉด 0๋ฒ ์ธ๋ฑ์ค์, 'b'๋ผ๋ฉด 1๋ฒ ์ธ๋ฑ์ค์, 'c'๋ผ๋ฉด 2๋ฒ ์ธ๋ฑ์ค์ ํด๋น ๋ฌธ์์ด์ ์ถ๊ฐํ๊ฒ ๋๋ค.
์ด ๋ฌธ์ ์์ ์ฃผ์ ํ ์ ์ n๋ฒ์งธ ๋ฌธ์๊ฐ ๊ฐ์ ๋ฌธ์์ด์ด ์๋ ๊ฒฝ์ฐ ์ฌ์ ์์ ์ ๋ ฌ์ด ๋ค์ ํ์ํ๋ค. ์๋์ ํ ์คํธ ์ผ์ด์ค์์ "abce","adcd" ์ ๊ฐ์ ๊ฒฝ์ฐ๋ "abce"๊ฐ ๋จผ์ ์ถ๋ ฅ๋๋ค.
const assert = require('assert')
function solution(strings, n) {
//๊ฐ ๋ฌธ์์ด์ ์ธ๋ฑ์ค n๋ฒ์งธ ๊ธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์
var answer = []
const freq = Array.from({ length: 26 }, () => [])
strings.map((s) => freq[s[n].charCodeAt() - 97].push(s))
freq.forEach((arr) => {
if (!arr.length) return false
arr.sort()
answer.push(...arr)
})
return answer
}
assert.deepEqual(solution(['sun', 'bed', 'car'], 1), ['car', 'bed', 'sun'])
assert.deepEqual(solution(['abce', 'abcd', 'cdx'], 2), ['abcd', 'abce', 'cdx'])
์ ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ ์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค ๋ฐ๋ก๊ฐ๊ธฐ
ํจ์ solution์ ์ ์ n์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ ฅ๋ฐ์ต๋๋ค. n์ ๊ฐ ์๋ฆฟ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํ ์๋ก์ด ์ ์๋ฅผ ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 118372๋ฉด 873211์ ๋ฆฌํดํ๋ฉด ๋๋ค.
์๋ฐ์คํฌ๋ฆฝํธ์ ๋ด์ฅํจ์๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ๊ณผ ์ฝ์ ์ ๋ ฌ์ ์ง์ ๊ตฌํํ์ฌ ์ ๋ ฌ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์๋ก ๋ฐํํ๋ ๋๊ฐ์ง์ ๋ฐฉ๋ฒ์ ๊ตฌํํ๋ค.
JS ๋ด์ฅํจ์ ์ด์ฉ ์ ์ n์ ๋ฐ์์ ํด๋น ์ ์์ ๊ฐ ์๋ฆฟ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ํ ๋ค์ ์ ์๋ก ๋ณํํ์ฌ ๋ฐํํ๋ ํจ์
function solution(n) {
return parseInt(
n
.toString()
.split('')
.sort((a, b) => b - a)
.join(''),
)
}
- ๋ฌธ์์ด์ ๋ฐฐ์ด๋ก ๋ณํํ ํ, sort ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ์๋ฆฟ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํฉ๋๋ค. ์ ๋ ฌ ํจ์ (a, b) => b - a๋ฅผ ์ฌ์ฉํ์ฌ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค..
- ์ ๋ ฌ๋ ๋ฐฐ์ด์ ๋ค์ ๋ฌธ์์ด๋ก ํฉ์น๊ณ , parseInt๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์์ด์ ์ ์๋ก ๋ณํํ ํ ๋ฐํํ๋ค.
insertion ํจ์ ์ ์ฉ
- ์ฝ์ ์ ๋ ฌ์ ์์๊ฐ ์ ๋ ฌ๋ ๋ถ๋ถ๊ณผ ์ ๋ ฌ๋์ง ์์ ๋ถ๋ถ์ผ๋ก ๋๋์ด ์๋ํ๋ฉฐ, ์ ๋ ฌ๋์ง ์์ ๋ถ๋ถ์ ์์๋ฅผ ํ๋์ฉ ๊ฐ์ ธ์์ ์ ๋ ฌ๋ ๋ถ๋ถ์ ์ฝ์ ํ๋ ๋ฐฉ์์ผ๋ก ๋์
- ์๋์ ์ด๋ฏธ์ง์ ๊ฐ์ด ์ ๋ ฌ๋์ด ์์ง ์์ ๊ทธ ๋ฐฐ์ด(in place)์์ ๋ฐ๋ก ๊ฐ์ ๋น๊ตํ์ฌ ์ธ๋ฑ์ค 0๋ฒ๋ถํฐ ์ ๋ ฌํด ๋๊ฐ๋ค. ์ถ์ฒ: wikipedia Insertion_sort๋์ ๋ฐฉ์
- ์ฃผ์ด์ง ๋ฐฐ์ด์ ๋ ๋ถ๋ถ์ผ๋ก ๋๋๋ค.
- ์ฒซ ๋ฒ์งธ ๋ถ๋ถ์ ์ ๋ ฌ๋ ๋ถ๋ถ์ด๋ฉฐ, ์ด๊ธฐ์๋ ์ฒซ ๋ฒ์งธ ์์ ํ๋๋ง ํฌํจํ๋ค.
- ๋ ๋ฒ์งธ ๋ถ๋ถ์ ์ ๋ ฌ๋์ง ์์ ๋ถ๋ถ์ด๋ฉฐ, ๋๋จธ์ง ๋ชจ๋ ์์๋ค์ ํฌํจํ๋ค.
- ์ ๋ ฌ๋์ง ์์ ๋ถ๋ถ์์ ์์๋ฅผ ํ๋์ฉ ์ ํํ๋ค.
- ์ ํํ ์์๋ฅผ ์ ๋ ฌ๋ ๋ถ๋ถ์ ์ ์ ํ ์์น์ ์ฝ์ ํ๋ค.
- ์ฝ์ ํ ์์น๋ ์ ๋ ฌ๋ ๋ถ๋ถ์์ ์ ํํ ์์๋ณด๋ค ์์ ์์๋ฅผ ๋ง๋๋ฉด ๋ฉ์ถ๋ค.
- ์ ํํ ์์๋ณด๋ค ์์ ์์๋ฅผ ๋ง๋๋ฉด, ๊ทธ ์์ ์์ ๋ค์ ์ ํํ ์์๋ฅผ ์ฝ์ ํ๋ค.
- ์ด ๊ณผ์ ์ ์ ๋ ฌ๋์ง ์์ ๋ถ๋ถ์ ๋ชจ๋ ์์๊ฐ ์ ๋ ฌ๋ ๋ถ๋ถ์ ์ฝ์ ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
๋ชจ๋ ์์๊ฐ ์ ๋ ฌ๋ ๋ถ๋ถ์ ์ฝ์ ๋๋ฉด ์ ๋ ฌ์ด ์๋ฃ๋๋ค.
์ฝ์ ์ ๋ ฌ์ ์ ๋ ฌ ์ค์์๋ ํจ์จ์ฑ์ ๋ฎ์ ํธ์ ์ํ๋ค. ์ ๋ ฌ์ด ๊ฑฐ์ ๋์ด ์๋ ๋ฆฌ์คํธ์์ ์๊ฐ๋ณต์ก๋๊ฐ O(n)์ ๊ฐ๊น์ฐ๋ฉฐ, ๊ฑฐ์ ์ ๋ ฌ์ด ์๋์ด ์๋ ๊ฒฝ์ฐ ์ต์ ์ O(n^2) ์ด ๋ ์ ์๋ค.
๊ทธ๋์ ์์ ํฌ๊ธฐ์ ๋ฆฌ์คํธ๋ ๊ฑฐ์ ์ ๋ ฌ๋ ๋ฆฌ์คํธ์ ์ ํฉํ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
function insertionSort(n) {
let arr = n.toString().split('')
for (let i = 1; i < arr.length; i++) {
for (let j = i; j > 0; j--) {
if (arr[j] > arr[j - 1]) {
;[arr[j], arr[j - 1]] = [arr[j - 1], arr[j]]
}
}
}
return parseInt(arr.join(''))
}