JS 기본of기본 for 코딩테스트

For Loop

• for
  • 기본형

     for (let i = 0; i < 9; i++) {
       console.log(i)
     }

• forEach
  • Array의 prototype을 상속받은 객체가 사용할 수 있는 함수
  • 반복문이 아니라 '함수'. 인자로 함수를 받아 각 배열의 요소에 해당 함수를 적용한다
• for ... in
  • Object에 있는 key에 차례로 접근
  • Array에도 사용할 수도 있지만 일반적으로 Object를 제외한 객체에는 사용하지 말 것
  • for in으로 순회 시, prototype chain을 따라 확장 속성들도 함께 순회
    • 필요 시 Object.keys()로 확장 속성을 피해서만 반복 가능
• for ... of
  • 이터러블한 객체를 모두 순회 가능
  • 내부에 [Symbol.iterator]를 가진 객체라면 어떤 객체든 순회할 수 있으나, 없는 객체는 불가

Hash

• new Map()
  • map.entries()는 iterator 반환
  • map.delete() : 성공 시에만 true
  • map.set()
  • map.get()
  • map.forEach((value, key, map) => { / ... / })

function solution(participant, completion) {
    var answer = '';
    const map = new Map();
    completion.forEach(completePlayer => {
        if (map.get(completePlayer))
            map.set(completePlayer, map.get(completePlayer)+1)
        else map.set(completePlayer, 1)
    })
    participant.forEach(participatedPlayer => {
        if (!map.get(participatedPlayer))
            answer = participatedPlayer
        else map.set(participatedPlayer, map.get(participatedPlayer)-1)
    })
    return answer;
}

List

• arr.indexOf(a) ==> 존재하지 않으면 -1 반환
• arr.lastIndexOf(a) ==> 존재하지 않으면 -1 반환
• arr1.concat(arr2) ==> 원본 배열 수정 없이 새로운 배열 반환
• arr.slice(start, end?) ==> 원본 배열 수정 없이 새로운 배열 반환
• arr.splice(start, n?) ==> 원본 배열에서 start~start+n-1까지를 삭제, 삭제된 배열값 반환
• arr.shift() ==> 원본 배열에서 첫 번째 요소를 제거하고, 제거된 요소를 반환
• arr.unshift(...args) ==> 원본 배열 왼쪽에 요소들을 추가하고, 추가된 배열의 길이를 반환

  • const array1 = [1, 2, 3];
    console.log(array1.unshift(4, 5)); // 5
    console.log(array1); // [4,5,1,2,3]

• arr.flat(n) ==> 원본 배열을 n차원만큼 flatten하게 바꿈. 빈 값은 자동 제거
• 리스트에서 특정 원소의 갯수 찾기
  • arr.filter(x => x==n).length

Sort

• arr.sort()
  • sort 인자로 비교 함수가 없을 경우, 유니코드 순서에 따라 정렬됨
    • [1,2,3,10] => [1,10,2,3]
  • 숫자 오름차순 정렬 예시

    arr.sort(function(a, b)  {
        if(a > b) return 1;
        if(a === b) return 0;
        if(a < b) return -1;
    });

    arr.sort(function(a, b)  {
        return a - b
    });

Math

• Math.floor(3.9) => 3
• Math.ceil(3.1) => 4
• Math.round(3.5) => 4
• Math.min(...arr)
• Math.max(...arr)

Combinations

function combination(arr, selectNum) {
  const result = [];
  if (selectNum === 1) return arr.map((v) => [v]);
  
  arr.forEach((v, idx, arr) => {
    const fixed = v;
    const restArr = arr.slice(idx + 1); // 
    const combinationArr = combination(restArr, selectNum - 1);
    const combineFix = combinationArr.map((v) => [fixed, ...v]);
    result.push(...combineFix);
  });
  return result;
}

Permutations

function permutation(arr, selectNum) {
  let result = [];
  if (selectNum === 1) return arr.map((v) => [v]);

  arr.forEach((v, idx, arr) => {
    const fixer = v;
    const restArr = arr.filter((_, index) => index !== idx); // 
    const permuationArr = permutation(restArr, selectNum - 1);
    const combineFixer = permuationArr.map((v) => [fixer, ...v]);
    result.push(...combineFixer);
  });
  return result;
}