์ค์๊ฐ์ ์ด๋ค ์ฃผ์ด์ง ๊ฐ๋ค์ ํฌ๊ธฐ์ ์์๋๋ก ์ ๋ ฌํ์ ๋ ๊ฐ์ฅ ์ค์์ ์์นํ๋ ๊ฐ์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด 1, 2, 7, 10, 11์ ์ค์๊ฐ์ 7์ ๋๋ค. ์ ์ ๋ฐฐ์ด array๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ค์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
array์ ๊ธธ์ด๋ ํ์์ ๋๋ค. 0 < array์ ๊ธธ์ด < 100 -1,000 < array์ ์์ < 1,000
๋ฐฉ๋ฒ 1
sort()๋ฅผ ์ฌ์ฉํด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ ์ถ์ด์ ๋ฐฉ๋ฒ1-1
๋ก ์ฌ์ฉํ๋ ์ ํ์ฑ์ด 44% ๋์ ์คํจ ํ sort()์ ์ ์๋ฅผ ์ฐพ์๋ณด๊ณ ๋ฐฉ๋ฒ1-2
๋ก ์์ ํด์ ํ
์คํธ์ ํต๊ณผ ํ๋ค.
function solution(array) {
let index = Math.floor(array.length/2)
// return answer = array.sort()[index] --- ๋ฐฉ๋ฒ 1-1
return array.sort((a,b)=>a-b)[index] --- ๋ฐฉ๋ฒ 1-2
}
sort()
: sort() ๋ฉ์๋๋ ๋ฐฐ์ด์ ์์๋ฅผ ์ ์ ํ ์์น์ ์ ๋ ฌํ ํ ๊ทธ ๋ฐฐ์ด์ ๋ฐํํฉ๋๋ค. ์ ๋ ฌ์ stable sort๊ฐ ์๋ ์ ์์ต๋๋ค. ๊ธฐ๋ณธ ์ ๋ ฌ ์์๋ ๋ฌธ์์ด์ ์ ๋์ฝ๋ ์ฝ๋ ํฌ์ธํธ๋ฅผ ๋ฐ๋ฆ
๋๋ค. MDN sort()
-> ๊ธฐ๋ณธ ์ ๋ ฌ ์์๊ฐ ๋ฌธ์์ด์ ์ ๋์ฝ๋ ์ฝ๋ ํฌ์ธํธ๋ฅผ ๋ฐ๋ฅด๊ธฐ ๋๋ฌธ์ ์คํจํจ
sort() ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
array.sort((a,b)=>a-b)
sort() ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
array.sort((a,b)=>b-a)
๋ฐฉ๋ฒ 2
index
๋ฅผ ์์ ๊ณ ๋ฐ๋ก ์
๋ ฅํ ๋ฐฉ๋ฒ
function solution(array) {
return array.sort((a, b) => a - b)[Math.floor(array.length / 2)];
}
์ต๋น๊ฐ์ ์ฃผ์ด์ง ๊ฐ ์ค์์ ๊ฐ์ฅ ์์ฃผ ๋์ค๋ ๊ฐ์ ์๋ฏธํฉ๋๋ค. ์ ์ ๋ฐฐ์ด array๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋น๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ฉด -1์ return ํฉ๋๋ค.
0 < array์ ๊ธธ์ด < 100 0 โค array์ ์์ < 1000
Map()
ํค๊ฐ ์๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค๋ ์ ์์ ๊ฐ์ฒด์ ์ ์ฌํฉ๋๋ค. ๋ค๋ง, ๋งต์ ํค์ ๋ค์ํ ์๋ฃํ์ ํ์ฉํ๋ค๋ ์ ์์ ์ฐจ์ด๊ฐ ์์new Map()
โ ๋งต์ ๋ง๋ญ๋๋ค.map.set(key, value)
โ key๋ฅผ ์ด์ฉํด value๋ฅผ ์ ์ฅํฉ๋๋ค.map.get(key)
โ key์ ํด๋นํ๋ ๊ฐ์ ๋ฐํํฉ๋๋ค. key๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด undefined๋ฅผ ๋ฐํํฉ๋๋ค.map.has(key)
โ key๊ฐ ์กด์ฌํ๋ฉด true, ์กด์ฌํ์ง ์์ผ๋ฉด false๋ฅผ ๋ฐํํฉ๋๋ค.map.delete(key)
โ key์ ํด๋นํ๋ ๊ฐ์ ์ญ์ ํฉ๋๋ค.map.clear()
โ ๋งต ์์ ๋ชจ๋ ์์๋ฅผ ์ ๊ฑฐํฉ๋๋ค.map.size
โ ์์์ ๊ฐ์๋ฅผ ๋ฐํํฉ๋๋ค.map.keys()
โ ๊ฐ ์์์ ํค๋ฅผ ๋ชจ์ ๋ฐ๋ณต ๊ฐ๋ฅํ(iterable, ์ดํฐ๋ฌ๋ธ) ๊ฐ์ฒด๋ฅผ ๋ฐํํฉ๋๋ค.map.values()
โ ๊ฐ ์์์ ๊ฐ์ ๋ชจ์ ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ฅผ ๋ฐํํฉ๋๋ค.map.entries()
โ ์์์ [ํค, ๊ฐ]์ ํ ์์ผ๋ก ํ๋ ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ฅผ ๋ฐํํฉ๋๋ค. ์ด ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ for..of๋ฐ๋ณต๋ฌธ์ ๊ธฐ์ด๋ก ์ฐ์
๋๋ค.Math.max()
์
๋ ฅ๊ฐ์ผ๋ก ๋ฐ์ 0๊ฐ ์ด์์ ์ซ์ ์ค ๊ฐ์ฅ ํฐ ์ซ์๋ฅผ ๋ฐํfunction solution(array) {
let map = new Map();
// Map ๊ฐ์ฒด ์ด๊ธฐํ
for(let i = 0; i <= Math.max(...array); i++){
map.set(i, 0);
}
// array ๋ฐฐ์ด์ ์์๊ฐ๊ณผ ์ผ์นํ๋ Map ๊ฐ์ฒด์ key๋ฅผ ์ฆ๊ฐ์ํจ๋ค
for(let i = 0; i < array.length; i++){
map.set(array[i], map.get(array[i]) + 1);
}
// Map ๊ฐ์ฒด์ value๋ง ๋ชจ์์ ๋ฐฐ์ด๋ก ๋ง๋ ๋ค
let arr = Array.from(map.values());
// ์ต๋๊ฐ ์ฐ์ถ
let max = Math.max(...arr);
// ์ต๋๊ฐ์ด ํ๋๋ง ์๋ค๋ฉด max, ์ฌ๋ฌ ๊ฐ ์ค๋ณต๋๋ค๋ฉด -1 ์ถ๋ ฅ
if(arr.indexOf(max) !== arr.lastIndexOf(max)){
return -1;
} else {
return arr.indexOf(max);
}
}