https://programmers.co.kr/learn/courses/30/lessons/12915

📝 문제 설명

문자열로 구성된 리스트 strings와 정수 n이 주어졌을 때, 각 문자열의 인덱스 n번째 글자를 기준으로 strings를 오름차순 정렬.

• 조건 : n번째 인덱스의 문자가 같은 문자열이 여럿 일 경우, 사전순으로 앞선 문자열이 앞쪽에 위치.

💡 풀이

1. 우선 조건 부분을 해결하기 위해 sort( ) 함수를 사용하여 문자열들을 사전순으로 정렬해주었다.

2. 사전순으로 정렬된 strings를 n번째 문자의 아스키코드끼리 비교하여 또 한 번 정렬해주었다.

🖥️ 코드

function solution(strings, n) {
    return strings.sort().sort((a, b) => {
        return a[n].charCodeAt() - b[n].charCodeAt(); 
    });
}

• 처음에는 먼저 문자열 전체를 기준으로 하여 사전순으로 정렬하지 않고 코드를 짰었다.
• sort( ) 함수 내에 조건문을 주어서 n번째 문자가 같으면 사전순으로 앞선 문자열이 앞에 위치하도록 하였는데 이렇게 하니 다른 결과가 나왔다.
• 그래서 sort( ) 내부에 console.log(strings)를 넣어 출력해보았다.
• 그런데 strings가 바뀌면서 출력될 것이란 기대와는 달리 정렬하기 전의 strings가 계속해서 출력되었다.
• 어디가 틀렸는지 원인을 알 수 없어 계산되는 횟수를 출력해 보았는데 내가 예상했던 것보다 많이 나왔다.
• 그래서 그 다음으로는 console.log(a[n], b[n], strings, a, b)를 하여 console.log( )안에 눈에 보이는 건 전체 다 넣어서 출력해보았다.
• 확실하게 알 수는 없지만 a와 b는 자리가 바뀌기 전 strings내 이웃해 있는 a와 b끼리 비교를 한 번 하고 또 바뀐 후의 이웃해있는 요소들끼리도 서로 비교를 해가며 제자리를 찾아가는 듯하다.
• 그래서 처음부터 문자열 전체를 기준으로 하여 사전순으로 정렬을 해놓고 난 뒤, n번째 문자끼리 비교하여 문자열들을 재정렬 하였다.

❗ 다른 사람 풀이

function solution(strings, n) {
    // strings 배열
    // n 번째 문자열 비교
    return strings.sort((s1, s2) => s1[n] === s2[n] ? s1.localeCompare(s2) : s1[n].localeCompare(s2[n]));
}

localeCompare( ) 이라는 함수를 처음 봐서 가지고 왔다.

[ localeCompare( ) ]

• 용도 : 정렬했을 때 비교 대상 문자열이 기준 문자열보다 앞에 와야 하는지, 뒤에 와야 하는지, 같은 순서에 배치 되어야 하는지를 나타내는 숫자 반환.
  
• 주의 : 리턴되는 값은 브라우저마다 다를 수 있다.
  
• 문법 기준 문자열.localeCompare(비교 대상 문자열)

  'bed'.localeCompare('sun')  // -2 or -1 (아니면 다른 음수값)
  'sun'.localeCompare('bed')  // 2 or 1 (아니면 다른 양수값)
  'bed'.localeCompare('bed')  // 0

• 예시 설명 (1)

  'bed'.localeCompare('sun') // -1

  기준 문자열('bed')과 비교 대상 문자열('sun')을 비교했을 때 음수가 나온다면, 비교 대상 문자열 'sun'의 순서가 더 뒤쪽에 온다.
  
• 예시 설명 (2)

  'sun'.localeCompare('bed')  // 1

  기준 문자열('sun')과 비교 대상 문자열('bed')을 비교했을 때 양수가 나온다면, 비교 대상 문자열 'bed'의 순서가 더 앞쪽에 온다.
  참조 사이트 바로가기

[ sort( ) 의 return값 ]

• return값이 음수 : s1이 앞에 오도록, s2가 뒤에 오도록 자리 바꿈
• return값이 양수 : s2가 앞에 오도록, s1이 뒤에 오도록 자리 바꿈
• return값이 0 : 자리 변경 없음

https://programmers.co.kr/learn/courses/30/lessons/17682

📝 문제 설명

다트 게임의 기회 : 총 3회 점수|보너스|[옵션]으로 이루어진 문자열 3세트가 주어진다. ** 0~10의 정수와 문자 S, D, T, , #로 구성된 문자열이 입력될 시 총점수를 반환하는 함수를 작성하라.*

• 각 기회마다 얻을 수 있는 점수: 0점 ~ 10점
  
• 보너스
  • S : 점수의 1제곱
  • D : 점수의 2제곱
  • T : 점수의 3제곱
    
  • 옵션
    • 옵션은 존재할 수도, 존재하지 않을 수도 있다.
    • 스타상(*) : 해당 점수와 바로 전에 얻은 점수를 각각 2배로 만든다.
      • 첫 번째 기회에서 스타상이 나올 경우 첫 번째 점수만 2배가 된다.
      • 다른 스타상 효과와 중첩 가능(4배)
    • 아차상(#) : 해당 점수는 마이너스된다.
      • 스타상과 아차상이 중첩돌 경우 중첩된 아차상의 점수는 -2배가 된다.

💡 풀이

1. 점수 vs 보너스/옵션으로 문자열 분리하기

• numArr배열 : 숫자들만 모아둔 배열
• strArr배열 : 보너스와 옵션을 모아둔 배열
• split( ) 함수를 사용하여 문자열을 분리하여 각각 배열로 만들어주었다.
• split( ) 함수의 파라미터로 정규표현식을 사용하였다.
  • separator(구분자) : 끊어주는 부분
  • /[^0-9]/ : 구분자로 '0에서 9까지의 숫자가 아닌 것'이라는 의미의 표현식을 주었다. 숫자가 아닌 부분이 끊는 부분이기 때문에 숫자가 아닌 부분(구분자)은 사라지고 숫자만 남은 배열이 반환된다. ex) 1S2D*3T -> 1 | 2 | "" | 3 | ""
  • /[0-9]/ : 구분자로 '0에서 9까지의 숫자'라는 표현식을 주었다. 숫자가 있는 부분에서 끊기 때문에 숫자가 아닌 문자만 남는다. ex) 1S2D3T -> "" | S | D\ | T
• filter( ) 함수를 사용하여 split( ) 함수를 사용하고 반환된 배열에서 "" 값을 제거해주었다.

2. 보너스/옵션 적용하여 점수 계산하기

• strArr에 있는 보너스와 옵션을 적용하기 위해 반복문을 사용하였다.
• numArr의 길이와 strArr의 길이는 3이다.
• 바깥 for문의 i 변수 : 따라서 strArr에 있는 보너스와 옵션은 차례대로 numArr 배열의 같은 인덱스에 있는 점수에 적용한다.
• 내부 for문의 j 변수 : 옵션이 있는 경우 strArr[i]의 길이가 2가 되기 때문에 이중 for문을 통해 보너스와 옵션을 분리하여 각각 점수에 적용될 수 있도록 하였다.

3. 총 점수 return

• 총 점수 : 보너스와 옵션이 적용된 numArr의 배열 안에 있는 점수들을 reduce( ) 함수를 통해 더하였다.

• 더하는 과정에 있어 점수가 문자열인 경우가 있었다.

• Number(cur) : 따라서 숫자 더하기가 제대로 적용되지 않는 경우가 있어서, numArr 배열 안에 있는 값들을 Number( ) 함수를 통해 숫자로 변환해주었다.

  
  ### 🖥️ 코드 (1) 처음 짠 코드 ```javascript function solution(dartResult) { let num = []; for (let x of dartResult) { if (!isNaN(x)) num.push(Number(x)); else if (x === 'D') { num[num.length - 1] = Math.pow(num[num.length - 1], 2); } else if (x === 'T') { num[num.length - 1] = Math.pow(num[num.length - 1], 3); } else if (x === '*') { if (num.length !== 1) num[num.length - 2] *= 2; num[num.length - 1] *= 2; } else if (x === '#') { num[num.length - 1] *= (-1); } console.log(num) } return num.reduce((acc, cur) => acc + cur, 0); } ``` 이렇게 풀면 숫자로 10이 들어올 경우를 해결해주지 못함.
  (2) 다시 짠 코드 ```javascript function solution(dartResult) { let numArr = dartResult.split(/[^0-9]/).filter((v) => v !== ""); let strArr = dartResult.split(/[0-9]/).filter((v) => v !== "");

  for (let i = 0; i < strArr.length; i++) {

    for (let j = 0; j < strArr[i].length; j++) {
  
        if (strArr[i][j] === 'D') {
           numArr[i] = Math.pow(numArr[i], 2);
        } else if (strArr[i][j] === 'T') {
            numArr[i] = Math.pow(numArr[i], 3);
        } else if (strArr[i][j] === '*') {
            if (i !== 0) numArr[i - 1] *= 2; 
            numArr[i] *= 2;
        } else if (strArr[i][j] === '#') {
            numArr[i] *= (-1);
        }
  
    }

  } return numArr.reduce((acc, cur) => acc + Number(cur), 0); }

  문제를 풀다보니 느낀 점...
  정규 표현식과 문자열 나누는 부분에 대해 취약하다는 것을 깨달았다.
  매번 저 split함수는 쓸 때마다 사용법을 찾아보게 된다...😂

❗ 다른 사람 풀이

function solution(dartResult) {
  const reg = /[\d]+[SDT][*#]*/g;
  const input = dartResult.match(reg);
  const result = [];

  for (let i = 0; i < input.length; i++) {
    let number = input[i].match(/[\d]+/g)[0];
    const bonus = input[i].match(/[SDT]/g)[0];
    const option = input[i].match(/[*#]/g);

    switch (bonus) {
      case 'S':
        number = Number(number);
        break;
      case 'D':
        number = Math.pow(number, 2);
        break;
      case 'T':
        number = Math.pow(number, 3);
        break;
    }

    result[i] = number;

    if (option) {
      switch (option[0]) {
        case '*':
          result[i - 1] *= 2;
          result[i] *= 2;
          break;
        case '#':
          result[i] *= -1;
          break;
      }
    }
  }

  return result.reduce((acc, cur) => {
    return acc + cur;
  });
}

https://programmers.co.kr/learn/courses/30/lessons/12912?language=javascript

📝 문제 설명

두 정수 a, b가 주어졌을 때 a와 b 사이에 속한 모든 정수의 합 return

💡 풀이

1. a와 b가 같다면 아무 수나 return해도 상관 없으니 a를 return

2. a와 b가 같지 않다면, 반복문을 통해서 a와 b 중 작은 수에 해당하는 수 ~ a와 b 중 큰 수 사이에 있는 숫자들을 sum에 누적하여 총 합(sum)을 return

• 작은 수 구하기 : Math.min( )
• 큰 수 구하기 : Math.max( )
  

🖥️ 코드

function solution(a, b) {
    let sum = 0;
    if (a === b) return a;
    for (let i = Math.min(a, b); i <= Math.max(a, b); i++) sum += i;
    return sum;
}

https://programmers.co.kr/learn/courses/30/lessons/12910

📝 문제 설명

arr배열 : 자연수를 담은 배열 array배열의 각 요소들이 divisor로 나누어 떨어지는지 확인 나누어 떨어진다면, 그러한 요소들만 모아서 오름차순으로 정렬한 배열 return

• 나누어 떨어지는 원소가 없다면 [-1]을 return

💡 풀이

1. 일단 arr배열을 오름차순으로 정렬한 후, forEach반복문을 통해 배열 안에 있는 요소가 divisor로 나누어 떨어지는지 확인

• 나누어 떨어지는 요소는 answer배열에 push한다.

2. answer 배열 답으로 반환하기

• answer배열의 길이가 0이라면 나누어 떨어지는 요소가 없는 것이다.
• 삼항연산자를 통해 그런 경우에는 답으로 [-1]을 return한다.
• 그렇지 않은 경우에는 그대로 answer 배열을 return한다.
  

🖥️ 코드

function solution(arr, divisor) {
    let answer = [];
    arr.sort((a, b) => a - b).forEach(i => i % divisor === 0 ? answer.push(i) : null);
    return answer.length === 0 ? [-1] : answer;
}

https://programmers.co.kr/learn/courses/30/lessons/12906

📝 문제 설명

arr배열: 원소가 숫자 0부터 9까지 이루어져 있음 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 제거
원소들의 처음 순서를 유지한채로 연속 숫자 제거 후 남은 수들을 return

💡 풀이

1. arr[i]에 해당하는 요소와 바로 앞에 있는 요소 arr[i-1]을 비교하여, 앞에 있는 요소와 같지 않다면 answer 배열에 해당 요소를 추가해준다.

2. answer배열에는 연속된 숫자 없이, 처음 arr배열에 들어있던 요소가 차례대로 들어가게 된다.
   

🖥️ 코드

function solution(arr)
{
    let answer = [];
    answer.push(arr[0])
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] !== arr[i - 1]) answer.push(arr[i]);
    }

    return answer;
}

❗ 다른 사람 풀이

function solution(arr)
{
    return arr.filter((val,index) => val != arr[index+1]);
}

https://programmers.co.kr/learn/courses/30/lessons/12903

📝 문제 설명

단어 s의 가운데 글자를 반환하는 함수 만들기

• 단어의 길이가 짝수라면 가운데 두 글자 반환

💡 풀이

1. middle : 단어의 가운데 글자 구하기

• 단어의 길이를 2로 나눈 후의 몫이 글자의 가운데 위치에 해당한다.

2. 단어의 길이가 홀수인지 짝수인지 판별

• 단어의 길이를 2로 나눈 나머지가 0이라면 단어의 길이는 짝수
• middle의 바로 앞과 middle 위치에 해당하는 두 글자를 반환하면 가운데 두 글자가 나온다.
• 홀수인 경우는 그대로 middle 위치에 있는 문자를 리턴한다.
  

🖥️ 코드

function solution(s) {
    let middle = Math.floor(s.length / 2);

    if (s.length % 2 === 0) {
        return s[middle - 1] + s[middle];
    } else return s[middle];
}

❗ 다른 사람 풀이

function solution(s) {
    return s.substr(Math.ceil(s.length / 2) - 1, s.length % 2 === 0 ? 2 : 1);
}

Math.ceil( ) : 인수로 전달된 숫자의 소수점 이하를 올림한 정수 반환.

• 1.6의 소수점 이하를 올리면 2가 되고, -1.6의 소수점 이하를 올림하면 -1이 된다. Math.ceil(1.6) // 2 Math.ceil(-1.6) // -1

String.substr( ) : 문자열에서 특정 위치에서 시작하여 특정 문자 수 만큼의 문자들을 반환 더 알아보기

https://programmers.co.kr/learn/courses/30/lessons/82612

📝 문제 설명

부족한 금액 계산하기 놀이기구 원래 이용료 : price N번째 이용시 이용료 : 원래 이용료의 N배
놀이기구를 count번 타게 되면 갖고 있는 금액(money)에서 얼마가 모자라는지 return

💡 풀이

1. sum : 놀이기구를 count번 이용 시, 놀이기구 이용료의 총합계

2. 총 이용료 구하기

• 1부터 count번까지 for문을 돌면서, sum에 각 회차의 이용료를 더해준다.
• i번째 이용시 이용료: price(원래 이용료) x i배

3. 모자란 금액 확인 후 답으로 return

• 총 이용료가 예산(money)보다 크면 총 이용료에서 예산을 뺀(sum-money) 금액만큼 모자라기 때문에 (sum-money)를 return하고, 그렇지 않으면 모자라지 않은 것이므로 0을 return
  

🖥️ 코드

function solution(price, money, count) {
    let sum = 0;
    for (let i = 1; i <= count; i++) {
        sum += (price * i);
    }
    return (sum - money) > 0 ? (sum - money) : 0;
}

https://programmers.co.kr/learn/courses/30/lessons/17681?language=javascript

📝 문제 설명

지도: 한 변의 길이가 n인 정사각형 배열 지도1과 지도2는 정수 배열로 암호화되어 있음 암호화를 풀면 -> 지도의 벽 부분: 1, 공백부분 : 0 정수를 이진수로 바꾸어 암호 해독한다.
암호화된 지도1과 지도2에서 어느 하나라도 벽인 부분은 원래 지도에서도 벽이고, 지도1과 지도2에서 모두 공백이라면 원래 지도에서도 공백이다.
암호화된 지도들을 해독하여 원래의 비밀지도를 '#'과 공백으로 구성된 문자열 배열로 출력

💡 풀이

1. answer배열 : 길이가 n만큼인 배열 생성

2. arr1과 arr2 지도에 있는 자연수들 -> 이진수로 변환

• 이진수 변환 방법: toString()함수 사용
• temp배열 : 이진수로 변환한 값을 배열 요소로 사용, temp 배열은 0과 1의 요소로 구성된다.
• temp의 길이가 n이 안 될 경우, n의 길이를 가질 때까지 앞에 0을 추가해준다.
• arr[i]에 temp배열 할당 : arr1과 arr2 배열의 요소를 자연수에서 이진법을 나타내는 배열로 바꿔준다.
• arr1과 arr2는 2차원 배열이 된다.

3. arr1과 arr2 배열에서 벽과 공백인 부분 파악하여 암호 해독

• arr1과 arr2 배열에서 모두 0인 위치에 해당하는 곳은 answer배열에 공백을, 그렇지 않은 위치에 해당하는 곳은 answer배열에서 '#' 문자를 넣어준 뒤, 최종 지도를 얻는다.
  

🖥️ 코드

function solution(n, arr1, arr2) {
      let answer = Array.from({length: n}, () => "");

      for(let i = 0; i < arr1.length; i++) {
          let temp = [...arr1[i].toString(2)];
          if (temp.length < n) {
            while(temp.length !== n) {
              temp.unshift('0');
            }
          }
          arr1[i] = temp;
      }

      for(let i = 0; i < arr2.length; i++) {
          let temp = [...arr2[i].toString(2)];
          if (temp.length < n) {
            while(temp.length !== n) {
              temp.unshift('0');
            }
          }
          arr2[i] = temp;
      }

      for (let i = 0; i < n; i++) {
          for (let j = 0; j < n ; j++) {
              if (arr1[i][j] === '0' && arr2[i][j] === '0') answer[i] += ' ';
              else answer[i] += '#';
          }
      }
      return answer;
  }

❗ 다른 사람 풀이(1)

function solution(n, arr1, arr2) {
    var answer = [];

    for(let i=0; i<n; i++){
        // toString(2)은 이진수로 반환하는 것.
        const bin = (arr1[i] | arr2[i]).toString(2);
        // console.log(bin);
           let line = [];
        for(let j = bin.length-n; j<bin.length; j++) { // j가(인덱스값)이 -1일 경우 undefined 반환.
            if(bin[j] === '1') { // 1이면 '#', 그 외 ' '
                line.push('#');
            } else {
                line.push(' ');
            }
        }
        answer.push(line.join(''));
    }
    return answer;
}

❗ 다른 사람 풀이(2)

var solution=(n,arr1,arr2)=>arr1.map((a,i)=>(a|arr2[i]).toString(2).padStart(n,0).replace(/0/g,' ').replace(/1/g,'#'))

참고 사이트 바로가기

아... 이거 비트연산자로 해결해야 하는 그런 문제구나...

https://programmers.co.kr/learn/courses/30/lessons/42889

📝 문제 설명

실패율 = 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수
전체 스테이지의 개수 : N 현재 멈춰있는 스테이지 번호가 담긴 배열 : stages 실패율이 높은 스테이지부터 내림차순으로 스테이지 번호가 담긴 배열 return

• N + 1 : 마지막 스테이지(N 번째 스테이지) 까지 클리어 한 사용자를 나타낸다.
• 만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오도록 하면 된다.
• 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다.

💡 풀이

1. failureRate 객체: 1~N까지의 숫자(스테이지)를 key로 갖고, 각각의 값은 0으로 초기화한다. 각 단계 별 실패율을 나타내기 위해 failureRate객체를 만들어주었다. 처음에는 0으로 초기화하였지만 추후, 단계별로 머물러있는 사람들 수를 구한 다음 실패율값을 넣어줄 것이다.

2. stages 배열 순회 : failure[x]++해줌. ex) x가 2인 경우, 2를 key로 갖고 있는 failureRate객체의 값을 +1해준다. N + 1은 스테이지를 다 클리어했으니 제외하기 위해 조건을 설정해주었다. 실패율을 구하기에 앞서, 단계별로 몇 명이 머물러 있는지 stages배열을 순회.

3. 실패율 구하기

• 해당 스테이지에 유저가 없으면 실패율은 0으로 설정하고, 유저가 있으면 문제에 나온대로 실패율을 구한다.

4. answer배열: 요소들이 [스테이지, 해당 스테이지의 실패율]로 이루어져 있다.

5. answer배열 정렬: 실패율이 높은 순서대로 스테이지 정렬(내림차순), 실패율이 같은 것끼리는 스테이지 오름차순으로 정렬.

6. 스테이지만 모아서 newArr에 넣은 후 답으로 return

   
   

🖥️ 코드

function solution(N, stages) {
    let answer = [];
    let failedCnt = 0;  // 스테이지를 올라가면서 클리어하지 못한 사용자 수를 누적
    const failureRate = {}; // 스테이지별 실패율을 표시하기 위한 객체 

    for (let i = 1; i <= N; i++) { // i는 key로 사용되며 스테이지를 나타낸다. 
        failureRate[i] = 0;       // 1단계부터 N단계까지 0으로 초기화한다.
    }

    for (let x of stages) {
        if (x < N + 1) failureRate[x]++; // 단계별로 현재 몇 명이 머물러 있는지 알기 위해 stages배열을 순회.
    }

    for (let i = 1; i <= Object.keys(failureRate).length; i++) {
        let tmp = failureRate[i];

        if (tmp === 0) failureRate[i] = 0; // 해당 스테이지에 유저가 없으면 실패율은 0
        else failureRate[i] = tmp / (stages.length - failedCnt); // 해당 스테이지에 유저가 있으면 실패율 공식에 맞게 실패율을 구함

        failedCnt += tmp; 
    }

    for (let key in failureRate) {
        answer.push([Number(key), failureRate[key]]);
    }
    answer.sort((a, b) => {
        if (a[1] === b[1]) return a[0] - b[0]; // 실패율이 같으면 key 오름차순 정렬
        else return b[1]-a[1]; // 그렇지 않으면 실패율이 높은 순서대로 내림차순 정렬
    } )

    let newArr = [];
    for (let i = 0; i < answer.length; i++) { 
        newArr.push(answer[i][0]); // 정렬한 스테이지 순서대로 newArr배열에 넣기(실패율은 말고 스테이지만) 
    }
    return newArr;
}

스테이지별 실패율을 구했는데 스테이지만 return하려니 따로 분리하는 방법을 생각해내는 게 어려웠다.

❗ 다른 사람 풀이

function solution(N, stages) {
    let stageRatio = [];
    let users = stages.length;

    for(let i = 1; i <= N; i++) {
        let noClear = stages.filter((user) => i === user).length;
        let ratio = noClear/users;
        users -= noClear;
        stageRatio.push({stage:i, ratio:ratio});
    }

    stageRatio.sort((a, b) => {
        if(a.ratio === b.ratio) return a.stage - b.stage;
        else return b.ratio - a.ratio;
    });

    return stageRatio.map(obj => obj.stage);
}

참고 사이트 바로가기

이해하기 쉽게 깔끔하게 코드를 잘 짜신 것 같다! filter()함수로 각 단계별 클리어하지 못한 인원 수 구하는 방법이랑 객체의 프로퍼티를 stage, ratio 이렇게 따로 설정해주는 방법은 생각하지 못했는데 다른 사람 풀이 덕분에 알게 돼서 좋았다.

https://programmers.co.kr/learn/courses/30/lessons/87389

📝 문제 설명

자연수 n을 x로 나눈 나머지가 1이 되도록 하는 가장 작은 자연수 x를 return

💡 풀이

1. 나머지가 1이 되어야 하니 n보다 1작은 수, 즉 (n - 1)을 나누어 떨어지게 하는 수를 찾아야 함

• (n - 1)을 2부터 (n - 1)까지 반복문을 통해서 나누어봄. 가장 작은 x를 찾아야 하니 나머지가 0이 되는 i를 찾는 순간 바로 i를 return한다.

🖥️ 코드

function solution(n) {
    for (let i = 2; i <= (n - 1); i++) {
        if ((n - 1) % i === 0) return i;
    }
}

❗ 다른 사람 풀이

function solution(n, x = 1) {    
    while (x++) {
        if (n % x === 1) {
            return x;
        }
    }    
}

https://programmers.co.kr/learn/courses/30/lessons/86491

📝 문제 설명

모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어짐 모든 명함을 수납할 수 있는 가장 작은 지갑의 크기 return

💡 풀이

1. 가장 긴 가로길이 구하기

• sizes배열에 있는 각각의 size들을 내림차순하여 가로와 세로 길이 중 더 긴 길이를 가로 길이라고 설정 size[0] => 명함의 가로 길이, size[1] => 명함의 세로 길이가 된다.
• size[0]은 w배열에, size[1]은 h배열에 넣기

2. 지갑 크기 : w배열과 h배열에서 가장 긴 길이 값 찾아서 곱하기

🖥️ 코드

function solution(sizes) {
    let answer;
    let w = [], h = [];
    for (let size of sizes) {
        size.sort((a, b) => b - a);
        w.push(size[0]);
        h.push(size[1]);
    }
    answer = Math.max(...w) * Math.max(...h);
    return answer;
}

프로그래머스에 있는 비슷한 풀이들 보니 다른 분들은 나처럼 w배열 h배열을 만들어준 게 아니라 그냥 반복문 안에서 if문을 통해서 가장 큰 가로, 세로 길이 값을 변수에 할당하여 계산하였다.

❗ 다른 사람 풀이

function solution(sizes) {
    const [hor, ver] = sizes.reduce(([h, v], [a, b]) => [Math.max(h, Math.max(a, b)), Math.max(v, Math.min(a, b))], [0, 0])
    return hor * ver;
}

https://programmers.co.kr/learn/courses/30/lessons/12901

📝 문제 설명

2016년 1월 1일은 금요일 2016년 a월 b일은 무슨 요일인지 return

• 요일의 이름은 일요일부터 토요일까지 각각 SUN,MON,TUE,WED,THU,FRI,SAT
• 2016년은 윤년(2월을 29일로 둔 해)

💡 풀이

1. 1월 1일부터 a월 b일까지 계산했을 때의 총 일수 구하기

• days배열 : 요일들이 들어있는 배열. 인덱스 번호를 구할 때는 (totalDays % 7)로 구한다. 1월 1일이 금요일이기 때문에 1 % 7 === 1이 되니까 1번 인덱스의 값은 금요일이다. 따라서 나머지가 0인 경우는 목요일! 그리하여 목.금.토.일.월.화.수의 순서대로 요일을 설정하였다. const days = ['THU', 'FRI', 'SAT','SUN', 'MON', 'TUE', 'WED', ];

• monthDays배열: 각 월마다 일수가 며칠인지 나타냄. (ex. 0번 인덱스에 해당하는 값 : 1월의 총 일수) const monthDays = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

• totalDays : a월 b일까지 총 며칠인지 계산하기 위한 변수 ex. a = 5, b = 24로 날짜가 5월 24일이라면, monthDays의 0번 인덱스(1월)부터 3번 인덱스(4월)까지에 있는 값들을 더한다. 1~4월까지의 합이 totalDays에 누적된다. 그리고 5월의 일수에 해당하는 b값까지 더해주면 총 totalDays를 구할 수 있다.

  나는 처음부터 b값을 totalDays의 값으로 설정해주었고 그다음에 전 월의 일수들을 더해주었다.

2. 요일 구하기: days배열에서 totalDays을 7로 나눈 나머지에 해당하는 인덱스의 값이 답

• days[totalDays % 7]
  

🖥️ 코드

function solution(a, b) {
    let answer = '';
    const days = ['THU', 'FRI', 'SAT','SUN', 'MON', 'TUE', 'WED', ];
    const monthDays = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    let totalDays = b;
    for (let i = 0; i < a - 1; i++) {
        totalDays += monthDays[i]; 
    }
    answer = days[totalDays % 7]; 
    return answer;
}

문제를 보는 즉시 총 일수를 구하여 7로 나누어서 풀어야겠다는 생각이 바로 떠오르지는 않았다...

https://programmers.co.kr/learn/courses/30/lessons/68644

📝 문제 설명

정수배열 numbers 서로 다른 인덱스에 있는 두 개의 수를 뽑아, 두 수를 더해서 만들 수 있는 모든 수를 배열에 오름차순으로 return

💡 풀이

1. 이중 for문 사용하여 서로 다른 인덱스끼리 값 더하기

• i번째에 있는 값 + i번째 인덱스 이후에 있는 값 더하기
• numbers 배열 끝까지 순회하면서 값을 더함
• 이 때, answer에 더한 값이 존재하지 않는다면 더한 값을 answer배열에 push

2. answer배열 오름차순 정렬

🖥️ 코드

function solution(numbers) {
    let answer = [];
    for (let i = 0; i < numbers.length; i++) {
        for (let j = i + 1; j < numbers.length; j++) {
            if (!answer.includes(numbers[i] + numbers[j])) answer.push(numbers[i] + numbers[j]);
        }
    }
    answer.sort((a, b) => a - b);
    return answer;
}

❗ 다른 사람 풀이

function solution(numbers) {
    const temp = []

    for (let i = 0; i < numbers.length; i++) {
        for (let j = i + 1; j < numbers.length; j++) {
            temp.push(numbers[i] + numbers[j])
        }
    }

    const answer = [...new Set(temp)]

    return answer.sort((a, b) => a - b)
}

다른 사람은 Set을 이용했는데 아직 Set에 익숙하지 않아서 그런지 나는 바로 떠오르지 않았다...! 다음에는 잘 활용할 수 있도록 해야겠다.

https://programmers.co.kr/learn/courses/30/lessons/68935

📝 문제 설명

자연수 n의 3진법 구하고, 앞 뒤로 반전시킨 후, 그 3진법을 다시 10진법으로 변환한 값 return

💡 풀이

1. 재귀를 통해 n을 3진법으로 표현

• 재귀 함수의 매개변수인 n이 0이 될때까지 3으로 나눠서 3진법 구하기

2. 3진법으로 표현된 숫자를 반전시키기

• split('') : 문자열을 쪼개서 배열로 만들고
• reverse( ) : 배열의 순서를 거꾸로 만든 뒤,
• join(''): 배열 요소를 연결해 하나의 문자열로 만들기

3. 3진법 -> 10진법 숫자로 변환

• Math.pow(밑, 지수) : 거듭제곱한 결과 반환
• 거듭제곱 횟수 증가: 지수는 점점 커지고 있기 때문에 한 번 계산 후 digit++을 해준다.
  

🖥️ 코드

function solution(n) {
    let answer = 0, number = "", digit = 0;
    function DFS(n) {
        if (n === 0) return;
        else {
            DFS(parseInt(n / 3));
            number += String(n % 3);
        }
    }
    DFS(n);

    number.split('').reverse().join('');
    for (let i of number) {
        answer += (i * (Math.pow(3, digit)));
        digit++;
    }
    return answer;
}

Math.pow( )는 안 써봤는데 문제 풀면서 새롭게 알 수 있었다. 코드짤 때 사용한 나머지 함수들은 내 기준...자주 쓰는데도 계속 까먹고 헷갈리는 함수들이라 문제가 어렵진 않았지만 다시 상기시켜줘서 좋았던 것 같다..ㅠㅠ

❗ 다른 사람 풀이

(1) 풀이 1

function solution(n) {
    const answer = [];
    while(n !== 0) {
        answer.unshift(n % 3); // n % 3 값을 배열의 앞으로 추가하여 3진법을 만듦.
        n = Math.floor(n/3);
    }
    return answer.reduce((acc,v,i) => acc + (v * Math.pow(3, i)),0);   
}

진법 변환 시, 배열의 unshift( )를 활용하여 3진법으로 변환한 것과

나처럼 자리를 나타내는 digit 변수를 따로 만들지 않고도, reduce함수를 써서 i를 활용한 계산이 인상적이다.
(1) 풀이 2

const solution = (n) => {
    return parseInt([...n.toString(3)].reverse().join(""), 3);
}

toString에 진법 변환, parseInt에 특정 진수의 정수로 변환하는 기능이 있는 걸 처음 알았다..ㅇㅅㅇ

https://programmers.co.kr/learn/courses/30/lessons/12982

📝 문제 설명

배열 d : 부서별로 신청한 금액이 들어있음 budget : 예산
예산 내에서 최대 몇 개의 부서에 물품을 지원할 수 있는지 return

💡 풀이

1. 최대한 많은 부서에 물품을 지원하려면 신청 금액이 작은 순서대로 먼저 사준다.

• sort() 함수를 이용하여 d배열을 오름차순으로 정렬

2. 반복문을 돌려서 d배열을 순회하여 금액을 더하는데 금액이 예산을 넘지 않으면 더하고 예산을 넘으면 더 이상 구매할 수 없으니 return한다.

• 이 때, 더하는 게 가능한 경우 answer의 값을 +1씩 증가시켜준다.
  

🖥️ 코드

function solution(d, budget) {
    let answer = 0, sum = 0;
    d.sort((a, b) => a - b);
    for (let money of d) {
        if (sum + money <= budget) {
            answer++;
            sum += money;
        } else return answer;
    }
    return answer;
}

https://programmers.co.kr/learn/courses/30/lessons/77884

📝 문제 설명

left부터 right까지의 모든 수들 중에서, 그 숫자의 약수의 개수가 짝수면 더해야 하고 홀수면 빼야 한다.
그렇게 해서 구한 left부터 right까지의 숫자들의 합을 return

💡 풀이

1. left부터 right까지 반복문을 돌면서 해당 숫자의 약수가 몇 개인지 확인하기

• 매번 반복문을 돌기 전에 cnt = 0으로 초기화: left~right가 몇 개의 약수를 가지고 있는지 확인하기 위함.
• 약수구하기: 1부터 해당 숫자까지 반복문을 돌려서(이중 for문) i로 나누어떨어지면 약수라는 뜻이기 때문에 cnt의 값을 증가시켜줌.

2. cnt의 값이 짝수이면 answer에 해당숫자를 더해주고, 홀수면 answer에서 해당숫자를 빼준다

🖥️ 코드

function solution(left, right) {
    let answer = 0;
    for (let num = left; num <= right; num++) {
        let cnt = 0;
        for (let i = 1; i <= num; i++) {
            if (num % i === 0) cnt++;
        } 
        if (cnt % 2 === 0) answer += num;
        else answer -= num;
    }

    return answer;
}

❗ 다른 사람 풀이

function solution(left, right) {
    var answer = 0;
    for (let i = left; i <= right; i++) {
        if (Number.isInteger(Math.sqrt(i))) {
            answer -= i;
        } else {
            answer += i;
        }
    }
    return answer;
}

....수학을 잘하시나보다....

https://programmers.co.kr/learn/courses/30/lessons/42576

📝 문제 설명

단 한 명 빼고 모두 마라톤 완주, 완주하지 못한 선수의 이름을 return
participant배열 : 마라톤에 참여한 선수들의 이름이 담긴 배열 completion배열 : 완주한 선수들의 이름이 담긴 배열

• 참가자 중에는 동명이인이 있을 수 있다.

💡 풀이

1. 동명이인이 있을수도 있기 때문에 각각의 이름들이 몇 명 참가했는지 확인하기

• 빈 Map객체 생성 -> parcitipant배열을 반복문으로 돌리면서 Map객체(map)에 마라톤에 참여한 선수들의 이름을 키로 갖는 요소를 추가해준다.
• 이 때, 요소의 값은 해당 이름이 나올 때마다 +1 해준다.
• 중복되는 경우라면 1, 2, 3 ... 이렇게 중복된 이름 수만큼 해당 이름을 키로 갖는 요소의 값이 증가할 것이다.

2. 완주한 선수들 확인

• 이번에는 completion배열을 반복문으로 돌리면서 completion에 있는 이름들을 키로 갖고 있는 map객체의 요소값들을 -1씩 해준다.

3. 완주하지 못한 선수 확인

• map객체를 반복문을 돌렸을 때, 요소값이 0이 아닌 키(선수 이름)는 완주하지 못한 선수이다. (완주한 선수들은 2번 과정에서 다 빼주었음)

🖥️ 코드

(1) 처음 짠 코드

function solution(participant, completion) {
    var answer;
    for (let person of completion) {
        let idx = participant.indexOf(person);
        if (idx !== -1) {
            participant.splice(idx, 1);
        }
    }
    answer = participant[0];
    return answer;
}

이 코드는 효율성 테스트에서 시간 초과로 다 실패했다...😭
(2) 다시 짠 코드

function solution(participant, completion) {
    let map = new Map();

    for (let key of participant) {
        if(map.has(key)) map.set(key, map.get(key) + 1);
        else map.set(key, 1);
    }
    for (let name of completion) {
        map.set(name, map.get(name) - 1);
    }
    for (let [key, value] of map) {
        if (value !== 0) return key;
    }
}

프로그래머스 사이트 위에 보니 해시 문제라길래 해시가 뭔지 몰라서 찾아보다가 자바스크립트에서는 Map객체를 이용하는 것 같길래 Map객체에 대해 공부하고 다시 풀어보았다. 이 방법으로 풀었더니 효율성 테스트도 통과했다...😮

해시가 내부적으로 엄청 효율적으로 구성되어 있나... 반복문은 여기서 더 많이 쓴 것 같은데 효율성 테스트도 통과된 게 신기하다. 다음 할 일 : 해시가 뭔지 공부...

❗ 다른 사람 풀이

function solution(participant, completion) {
    const hash = {};

    for(let val of participant) {
      if(!hash[val]) hash[val] = 0; 
      hash[val]++;
    }

    const result = completion.forEach(val => hash[val]--);

    for(let key in hash) if(hash[key]) return key;
}

아....?? 그냥 객체로도 간단히 구현할 수 있었네...??😦🤣🤣

Map객체는 [키와 값]으로 이루어진 요소들의 집합이다.

객체도 키와 값으로 이루어져 있는데, 그렇다면 Map객체와 일반 객체의 차이점은 무엇일까?

[ Map 객체의 생성 ]

• Map 생성자 함수로 생성.

• 인수로는 이터러블 객체를 넣어주며, 인수를 전달하지 않으면 빈 Map객체가 생성됨
• 인수로 전달되는 값은 키와 값의 쌍으로 이루어진 요소로 구성되어야 한다.

// Map객체 생성
const map = new Map();
console.log(map) // Map(0) {}


// 인수로 전달되는 배열의 요소들이 키와 값으로 구성되어져 있다.
const map1 = new Map([['키1', '값1'], ['키2', '값2']]);
console.log(map1); // Map(2) {"키1" => "값1", "키2" => "값2"};


const map2 = new Map(['사과', '바나나']) 
// Uncaught TypeError: Iterator value 1 is not an entry object
// 인수로 전달되는 배열의 요소들이 키와 값으로 구성되어 있지 않고,
// 단순히 '사과', '바나나'라는 값으로만 구성되어져 있기 때문에 TypeError가 발생하였다.

❗ Map 객체에는 *중복된 키*를 갖는 요소가 *존재할 수 없다.*

그런데도 불구하고 키 값이 중복되는 요소를 넣는다면? 중복된 키를 갖는 요소가 존재하면 값이 덮어씌워진다.

const map = new Map([['키1', '값1'], ['키1', '값2']]);
console.log(map); // Map(1) {"키1" => "값2"};

[ Map객체 요소의 개수 ]

• Map.size: Map객체의 요소가 몇 개인지 확인할 때 사용

• size 메서드를 이용하여 Map객체의 크기 변경 불가능

const map = new Map([['키1', '값1'], ['키2' '값2']]);

map.size = 10; // (x) 잘못된 방법! 변경 불가능!
console.log(map.size); // 2

[ 요소 추가 / 삭제 ]

• 요소 추가 : Map객체.set(추가할 요소)
  

• 요소 삭제 : Map객체.delete(삭제할 요소) → delete 메서드는 삭제 성공시에는 true를, 실패시에는 false를 반환함
  
• 요소 일괄 삭제 : Map객체.clear()

const map = new Map();

// 요소 추가
map.set('사과', 'red');
console.log(map); // Map(1) {"사과" => "red"}

map.set('바나나', 'yellow');
map.set('귤', 'orange');
console.log(map); // Map(3) {"사과" => "red", "바나나" => "yellow", "귤" => "orange"}


// 중복된 키를 갖는 요소를 추가하면 값이 덮어써진다.
map.set('사과', 'green');
console.log(map); // Map(3) {"사과" => "green", "바나나" => "yellow", "귤" => "orange"}



// 요소 삭제
map.delete(사과);
console.log(map); // Map(2) {"바나나" => "yellow", "귤" => "orange"}



// 요소 일괄 삭제
map.clear();
console.log(map); // Map(0) {}

[ 요소의 존재 여부 ]

Map객체.has(요소의 key)

const map = new Map();

const lee = { name : 'Lee' };

// Map은 객체도 키로 사용할 수 있다.
map.set(lee, '개발자');  
console.log(map); // Map(1) { {name : "Lee"} => "개발자" }


// lee라는 키를 가진 요소가 존재하는지 확인
console.log(map.has(lee)); // true
console.log(map.has('kim')); // false

[ 요소값 획득 ]

Map객체.get(요소의 key) : 해당 키를 갖는 요소가 있으면 그 요소의 값을 반환

• 인수로 전달한 키를 갖는 요소가 없으면 undefined를 반환

const map = new Map([['사과', '빨갛다'], ['바나나', '노랗다']]);


// 요소값 획득
console.log(map.get('사과'));  // 빨갛다
console.log(map.get('메론'));  // undefined

[ 요소 순회 ]

• forEach((v, k, map) => { }) (1) 첫 번째 인수: 현재 순회중인 요소 값 (2) 두 번째 인수: 현재 순회중인 요소의 키 (3) 세 번째 인수: 현재 순회중인 Map객체 자신
  

• for ... of문

const 강아지 = { name : '초코' };
const 고양이 = { name : '나비' };

const map = new Map([[강아지, 'cute'], [고양이, 'pretty']]);


map.forEach((v, k, map) => console.log(v, k , map));

/* 요소값 , 요소키 , map객체
cute {name: "초코"}
Map(2) {
    {name: "초코"}: "cute"
    {name: "나비"}: "pretty"
}
pretty {name: "나비"}
Map(2) {
    {name: "초코"}: "cute"
    {name: "나비"}: "pretty"
}
*/



for (const key of map.keys()) {
  console.log(key); // {name: "초코"} {name: "나비"}
}

for (const value of map.values()) {
  console.log(value); // cute pretty
}

for (const entry of map.entries()) {
  console.log(entry); // [{name: '초코'}, 'cute'] [{name: '나비'}, 'pretty']
}

살면서 우리는 매번 선택을 해야 하는 상황에 직면하게 된다. 그 순간에 어떠한 선택을 하여야 할까? 현재의 즐거움을 따라서 선택하는 경우도 있고, 때로는 미래를 위해 현재의 만족을 포기하는 선택을 하기도 한다.

그런데 여기 '그리디'라고 현재의 즐거움만 고집하는 알고리즘이 있다. 매 순간마다 그 상황에서의 최적의 답을 선택하여 결과를 도출하는 알고리즘을 그리디 알고리즘이라고 한다.

선택을 하는 순간에는 지금 이 순간, 지금 당장!! 최적으로 보이는 값을 선택하였다. 그러나, 최종적인 값을 봤을 때 그 값이 완전히 100% 최적의 값이 된다고는 할 수 없다.

이렇듯 나중은 생각하지 않고, 당장의 눈 앞에 보이는.. 그 순간에 가장 좋아보이는 것만을 쫒는 욕심을 부리기 때문에 욕심이 많다는 뜻의 그리디란 이름이 붙여진 듯하다.

🤷‍♀️ 그렇다면 최적의 값을 보장해주지 않음에도 불구하고 왜 사용하는 것인가?

앞서 말했듯이 최종적으로 가장 베스트인 값이 나오지 않을 수도 있다.

하지만!

부분적으로 보자면 어쨌든 그동안에 가장 좋은 답이라고 보여지는 값을 꾸준히 선택해왔기 때문에 최적에 가까운 그럴싸한 답을 도출해낼 수 있다. (ex. 위의 그림을 보면 두 번째로 좋은 값인 90이 나오도록 선택된 것을 알 수 있다!)

또한, 이것저것 따지면서 여러 가지를 고려하는 게 아니라 오로지 그 순간에 가장 좋은 것!!! 딱 그것만 보고 선택하기 때문에 계산 속도가 빠르다.

특징

1. 탐욕 선택 속성 : 현재 선택은 미래 선택에 영향을 줄 수 없다. (이미 선택한 것을 뒤집을 수 없다. 다음 선택 시, 이전 선택이 별로인 것 같다고 생각되어 뒤로 돌아가서 다시 선택하거나 할 수 없다(선택 번복x))

2. 최적 부분 구조 : 최적의 답을 도출하는 과정에 있어서 부분적으로는 최적의 답이 포함되어 있다.

3. 항상 최적의 값이 나온다는 것을 보장하지 않는다. (물론 그리디로도 100% 최적의 값이 나올 수 있다. 단, 항상 그런 것은 아니라는 점! 즉 그럴 수도 있고, 아닐 수도 있다.)
   
   

   그리디 알고리즘 예시

   📝 [ 가장 대표적인 그리디 문제 : 거스름돈 ]

   거스름돈으로 사용할 동전의 종류 : 500원, 100원, 50원, 10원 존재 손님에게 거슬러줘야 할 돈이 3420원일 때, 최소한의 동전을 사용하여 거슬러주어라.

   
   

Q. 거스름돈으로 사용할 최소 동전 개수는?

❗ 최적의 방법 선택

• 최소한의 동전을 사용해야 하니 금액이 큰 동전부터 계산하여 거슬러줘야 한다. 매 선택 시, 최적의 선택은 500원 - 100원 - 50원 - 10원순이다.

• 답 : 총 12개 (6 + 4 + 0 + 2)

** 특이점** 이 경우에는 각각의 동전들이 해당 동전보다 크기가 작은 동전들의 배수 형태였기 때문에 그리디 알고리즘으로 최적의 값을 구할 수 있었지만, 서로 배수 형태가 아닌 동전들이 무작위로 주어진다면 그리디로 풀 수 없다.

• (1) 가능한 경우

        앞선 예제는 50(원)은 10(원)의 배수, 100(원)은 50(원)의 배수, 500(원)은 100(원)의 배수였기 때문에 가능했다.

• (2) 불가능한 경우 이번에는 거스름돈이 240원이라고 하자. 그리고 거슬러줄 동전의 종류로는 100원, 80원, 20원 3가지가 있다. (※ 100(원)은 80(원)의 배수가 아니다.)

  
  

  👉 최적의 값 : 80원 x 3 = 240원으로 3개 👉 그리디 알고리즘 : 처음 선택 시 80원이 아니라 가장 좋은 선택으로서 100원을 선택. 계속 선택하다 보면 (100원 x 2) + (20원 x 2) = 240원으로 총 4개가 나온다. 따라서, 완전한 최적의 값이 나오지 않는다.

🤷‍♂️ 어떻게 그리디 알고리즘인지 알 수 있을까?

궁금하여 찾아보았는데....

• 그리디 알고리즘 유형의 문제는 매우 다양하기 때문에 암기한다고 해서 항상 잘 풀 수 있는 알고리즘 유형이 아니다. 많은 유형을 접해보고 문제를 풀어보며 훈련을 해야 한다.
  

• 특정한 문제를 만났을 때 단순히 현재 상황에서 가장 좋아 보이는 것만을 선택해도 문제를 풀 수 있는지를 파악할 수 있어야 한다.
  >- 그리디 알고리즘은 기준에 따라 좋은 것을 선택하는 알고리즘이므로 문제에서 '가장 큰 순서대로', '가장 작은 순서대로'와 같은 기준을 알게 모르게 제시해준다.
  나동빈, 『이것이 취업을 위한 코딩 테스트다 with 파이썬』, 한빛미디어(2020), p 86-87.

문제를 보고... 그리디 알고리즘이다 하고 바로 알아채는 것은... 어려울 것 같기 때문에 그냥 문제를 많이 풀어보면서 자연스럽게 익힐 것...😬;;
.... 😂😂

객체의 모든 프로퍼티를 순회할 때는 for...in문 사용 for (const/let 프로퍼티 key를 나타낼 변수 선언 in 객체이름)

- 참고: 프로퍼티가 심벌인 프로퍼티는 열거하지 않음

// person 객체 생성
const person = {
  name: 'ppyororong',
  age: '200',
  address: 'Seoul'
};


// person객체 프로퍼티 열거
for (const key in person) {
  console.log(key + ': ' + person[key]);
}

// name: ppyororong 
// age: 200
// address: Seoul

for...of문

배열과 같은 이터러블을 순회할 때는 for...of문 사용 for (const/let 변수 of 이터러블)

- 이터러블 프로토콜을 준수한 객체를 이터러블이라고 하는데, 간단하게 순회 가능한 자료구조들을 생각하면 된다.

ex ) 배열, 문자열, Map, Set 등이 이터러블이며, 일반 객체는 이터러블이 아니다.

for (const color of ['red', 'yellow', 'green']) {
  // color 변수에 'red', 'yellow', 'green'이 할당됨

  console.log(color); // red yellow green
}