[LeetCode-JS 30 days] #2. Array Transformation - 1(#์ํ)
2024.08.03 - [๐ ๏ธ Tool/FE] - [LeetCode-JS 30 days] #1. Closures ๊ฐ๋ - 1(#์๋ #๋ณด์กด)
[LeetCode-JS 30 days] #1. Closures ๊ฐ๋ - 1(#์๋ #๋ณด์กด)
์๊ธฐ ์ฝ๊ฒ ์ฐ์๊ณ ๋ง์ ์ฌ๋๋ค์๊ฒ ๊ฒ์ฆ๋ ์ค๋ช ์ด LeetCode Discuss์ ์ฌ๋ผ์ค๋ ๊ฒ์ ํ์ธํ๊ณ , JS Basic ๊ณต๋ถ์ ์ด๋ฅผ ํ์ฉํด๋ณด๊ณ ์ ํ์๋ค. LeetCode PS์ฒ๋ผ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉฐ JS์ basic skill์ ์ตํ ์ ์๋
seungineer.tistory.com
์๊ธฐ ์ฝ๊ฒ ์ฐ์๊ณ ๋ง์ ์ฌ๋๋ค์๊ฒ ๊ฒ์ฆ๋ ์ค๋ช ์ด LeetCode Discuss์ ์ฌ๋ผ์ค๋ ๊ฒ์ ํ์ธํ๊ณ , JS Basic ๊ณต๋ถ์ ์ด๋ฅผ ํ์ฉํด๋ณด๊ณ ์ ํ์๋ค. LeetCode PS์ฒ๋ผ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉฐ JS์ basic skill์ ์ตํ ์ ์๋๋ก ๊ตฌ์ฑ๋์ด ์๋ค.
- Closures
- Basic Array Transformations
- Function Transformations
- Promises and Time
- JSON
- Classes
์ด 6๊ฐ์ Part๋ก ๊ตฌ์ฑ๋๋ฉฐ ๋ณธ ํฌ์คํธ์์๋ Basic Array Transformation์ ๋ํด ๋ค๋ฃฌ๋ค.
Apply Transformation Over Each Element in Array
๋ฌธ์ ๋ฅผ ํธ๋ ๊ฒ๋ณด๋ค ํด๋น ๋ฌธ์ ์ Discussion์ ๊ณต๋ถํ ๋ด์ฉ์ด ๋ง๋ค!
์์ฝ
Array.map() ๋ฉ์๋ ์ฌ์ฉ์ ์ ํํ๋๋ก ๋ฌธ์ ๊ฐ ์ธํ ๋ ์ด์ ๋ ๋ญ๊น?
- Loops, functions, recursion๊ณผ ๊ฐ์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์๊ฐํด ๋ณด๋๋ก ์ ๋ํ๋ค.
- ๋๊ท๋ชจ ๋ฐฐ์ด์์ Array.map()์ด ํญ์ ๊ฐ์ฅ ํจ๊ณผ์ ์ด์ง ์๋ค.
- ๋ค์ํ ๋ฐฐ์ด ์กฐ์ ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ์์ ์ต์ํด์ง๊ธฐ ์ํจ์ด๋ค.
- Array.map()์ ์ฌ์ฉํ๋ฉด ๋ฌธ์ ๊ฐ ๋๋ฌด ์ฌ์์ง๋ค.
1. for๋ฌธ๊ณผ ๊ฐ์ ๋ด์ ์ปจํ ์ด๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
๊ฐ๊ฐ์ ๋ฐฐ์ด ์์์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ ๊ทผํ์ฌ fn ํจ์๋ก transform ๋ฐํ๋๋ ๊ฐ์ ์ปจํ ์ด๋์ ์ ์ฅํ๋ค.
var map = function(arr, fn) {
const transformedArr = [];
for (let i = 0; i < arr.length; i++) {
transformedArr[i] = fn(arr[i], i);
}
return transformedArr;
};
์๋ก์ด ์ปจํ ์ด๋๊ฐ ์๋ ๊ธฐ์กด์ ๊ฐ์ด ๋ด๊ฒจ ์๋ arr๋ฅผ ๋ณํํ๋ ๋ฐฉ๋ฒ๋ ์๋ค.
var map = function(arr, fn) {
for (let i = 0; i < arr.length; ++i) {
arr[i] = fn(arr[i], i);
}
return arr;
};
- ์ ๋ฐฉ๋ฒ์ bad practice๋ก ์ด๋ ๊ฒ๋ ์ ์ฉ์ด ๋จ๋ง์ ์๊ณ ์์.
- Bad practice์ธ ์ด์ ๋ ๊ฐ์ฅ ์ค์ํ ์๋ณธ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊ณตํด๋ฒ๋ฆฌ๊ฒ ๋๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
- ์ด๋ ๊ฒ ๊ฐ๊ณตํด๋ฒ๋ ค์ ์๋ณธ ๋ฐ์ดํฐ๋ฅผ ๋ค์ ์์ฒญํ๋๋ ์๋ก์ด ์ปจํ ์ด๋์ ๊ฐ์ ์ ์ฅํ๋ ๊ฒ ๋ซ๋ค.
python๊ณผ๋ ๋ค๋ฅด๊ฒ ๋ฐฐ์ด์ ์ด๋ค index์ ๊ฐ์ด ์กด์ฌํ์ง ์๋๋ผ๋ index์ ๊ฐ์ ํ ๋นํ ์ ์์
Time Complexity, Space Complexity
- ์ ์ฝ๋: O(n), O(n)
- ์๋ ์ฝ๋: O(n), O(1)
2. forEach ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
forEach ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ input array๋ฅผ iterate ํ๊ณ , ๊ฐ element์ map function์ ์ ์ฉํ ์ ์๋ค. ์ดํ ์๋ก์ด ๋ฐฐ์ด์ ๋ณํ๋ ๊ฐ์ ์ ์ฅํ๋ค.
var map = function(arr, fn) {
const transformedArr = [];
arr.forEach((element, index) => {
transformedArr[index] = fn(element, index);
});
return transformedArr;
};
map ๋ฉ์๋๋ ์๋ก์ด ๋ฐฐ์ด์ return ํ์ง๋ง forEach๋ undefined๋ฅผ return ํจ
Time Complexity, Space Complexity
- O(n), O(n)
3. reduce ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
reduce ๋ฉ์๋ ๋ํ input array๋ฅผ iterate ํ๊ณ , ๊ฐ element์ map function์ ์ ์ฉํ ์ ์๋ค. ์ดํ ์๋ก์ด ๋ฐฐ์ด์ ๋ณํ๋ ๊ฐ์ accumulate ํ ์ ์๋ค.
var map = function(arr, fn) {
return arr.reduce((transformedArr, element, index) => {
transformedArr[index] = fn(element, index);
return transformedArr;
}, []);
};
transformedArr๋ฅผ ๋ฐ๋ก ์ ์ธํ์ง ์๊ณ , reduce ๋ฉ์๋ ๋ด์์ ์ฒ๋ฆฌํ๋ฉฐ, ๋ชจ๋ ์์๋ฅผ iterate ํ ํ์๋ accumulate ํ ๋ฐฐ์ด์ return ํ๋ ๊ฒ์ ์ ์ ์์
Time Complexity, Space Complexity
- O(n), O(n)
reduce ๋ฉ์๋ ํ์์ ์๋์ ๊ฐ๋ค.
arr.reduce((acc,cur,idx,src)->{
return ๊ฒฐ๊ณผ
},์ด๊ธฐ๊ฐ);
์ฌ๊ธฐ์ ์ด๊ธฐ๊ฐ์ด ์ธํ ์ด ๋์ด ์๋ ์๋์ ๋ฐ๋ผ์ ๋ฐ๋๋ ๋ถ๋ถ์ด ์๋ค. ์ด๊ธฐ๊ฐ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ idx๊ฐ 0์ผ ๋ arr ๋ฐฐ์ด์ 0๋ฒ์งธ ๊ฐ์ด acc์ ์ด๊ธฐ๊ฐ์ด ๋๋ค. ์ฆ, ์ด๊ธฐ๊ฐ์ด ์์ผ๋ฉด idx๋ 0์ ๊ฑด๋ ๋๋ ๊ฒ์ด๋ค.
// ์ด๊ธฐ๊ฐ์ด ์๋ ๊ฒฝ์ฐ
const input = [1,2,3,4];
const result = input.reduce((acc,cur,idx)=>{
console.log(acc,cur,idx);
return acc+cur;
},0)
// 0 1 0
// 1 2 1
// 3 3 2
// 6 4 3
console.log(result); //10
// ์ด๊ธฐ๊ฐ์ด ์๋ ๊ฒฝ์ฐ
const input = [1,2,3,4];
const result = input.reduce((acc,cur,idx)=>{
console.log(acc,cur,idx);
return acc+cur;
})
// 1 2 1
// 3 3 2
// 6 4 3
console.log(result); //10
reduce((acc, cur, idx, src) => {}, ์ด๊ธฐ๊ฐ) ํํ์ด๊ณ , cur, src๋ option์ด๋ค.
์ด๊ธฐ๊ฐ์ด ์์ผ๋ฉด idx๊ฐ 0์ผ ๋๋ฅผ ๊ฑด๋ ๋๊ณ , acc = arr[0]์ด ๋๋ค.
4. for ... of loop ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
for๋ฌธ์ ํตํด input array๋ฅผ iterate ํ๊ณ , ๊ฐ element์ map function์ ์ ์ฉํ ์ ์๋ค.
var map = function(arr, fn) {
const transformedArr = [];
let index = 0;
for (const element of arr) {
transformedArr[index] = fn(element, index);
index++;
}
return transformedArr;
};
python์ `for k in arr:` ์ ๊ฐ์
Filter Elements from Array
Discuss ํญ์ผ๋ก ๋ฌ๋ ค ๊ฐ์
์์ฝ
- ์๋ฐ์คํฌ๋ฆฝํธ์์ truthy์ falsy
// falsy
false;
0
-0
0n (BigInt zero)
'' (empty string)
null
undefined
NaN
// truthy
// falsy๋ฅผ ์ ์ธํ ๋ชจ๋
// ์๋๋ ํฌํจ๋จ์ ์ ์
'0' (๋จ์ผ์ zero๋ฅผ ํฌํจํ๋ string)
'false' (๋ฌธ์์ด false๋ฅผ ํฌํจํ๋ string)
[] (empty array)
{} (empty object)
function() {} (empty function)
python๊ณผ ๋ฌ๋ฆฌ ๋น ๋ฐฐ์ด, ๋น ๊ฐ์ฒด๋ true
์์ ์ดํด๋ณธ ๋ด์ฉ๊ณผ ์ค๋ณต๋ ๋ด์ฉ์ ์ ์ธํ์๋ค.
1. flatMap ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
๋ฐฐ์ด์ ๊ฐ ์์์ ํจ์๋ฅผ ์ ์ฉํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ค์ ์๋ก์ด ๋ฐฐ์ด๋ก ๋ง๋ ๋ค(flatten).
var filter = function(arr, fn) {
return arr.flatMap((i, j) => fn(i, j) ? [i] : []);
};
arr = [1, 2, 3, 4, 5];
fn = (i, j) => i % 2 === 0;
filter(arr, fn); // [2, 4]
๋ฐฐ์ด์ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ๋ง์ผ๋ก ์๋ก์ด ๋ฐฐ์ด์ return ํจ์ ์ ์ ์๋ค.