배열의 원소 삭제하기

문제 설명

정수 배열 arr과 delete_list가 있습니다. arr의 원소 중 delete_list의 원소를 모두 삭제하고 남은 원소들은 기존의 arr에 있던 순서를 유지한 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ arr의 길이 ≤ 100
• 1 ≤ arr의 원소 ≤ 1,000
• arr의 원소는 모두 서로 다릅니다.
• 1 ≤ delete_list의 길이 ≤ 100
• 1 ≤ delete_list의 원소 ≤ 1,000
• delete_list의 원소는 모두 서로 다릅니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번의 arr의 원소 중 1000과 94가 delete_list에 있으므로 이 두 원소를 삭제한 [293, 395, 678]을 return 합니다.

입출력 예 #2

• 예제 2번의 arr의 원소 중 delete_list에 있는 원소는 없습니다. 따라서 arr 그대로인 [110, 66, 439, 785, 1]을 return 합니다.

접근 방법

이 문제는 arr 내부의 원소 중 delete_list에 포함된 값을 제거하고, 나머지는 기존 순서를 유지한 채 반환하는 단순한 필터링 문제다. 핵심은 두 가지로 요약된다.

1. 현재 값이 삭제 대상인지 빠르게 판별해야 한다.
2. 삭제 대상이 아니라면 결과 배열에 포함해야 한다.

이를 JavaScript에서 구현할 때 가장 적합한 도구는 Set과 Array.prototype.filter이다. 두 개념을 명확히 이해하면 코드가 왜 이러한 구조를 취하는지 자연스럽게 파악된다.

Set의 필요성과 동작 원리

Set은 중복을 허용하지 않는 데이터 집합을 저장하는 자료구조로, 특정 값이 포함되어 있는지 판별하는 연산이 평균적으로 O(1)의 시간에 수행된다. 배열에서 동일한 작업을 할 경우 includes를 사용해야 하고, 이는 매번 O(n) 탐색이 필요하므로 전체 성능이 저하된다.

이 문제에서는 삭제해야 할 값들을 Set에 담아두고 has 메서드로 빠르게 포함 여부를 확인하는 전략이 가장 적합하다.

const toDelete = new Set(delete_list);

위 코드는 삭제 대상 목록을 Set으로 변환한다. 이후 toDelete.has(value)는 value가 삭제 대상에 포함되면 true, 포함되지 않으면 false를 반환한다.

filter의 동작 방식

filter는 배열을 처음부터 끝까지 순회하며, 콜백 함수가 true를 반환할 때만 해당 값을 결과 배열에 포함한다. 원본 배열을 직접 수정하지 않고, 조건을 만족하는 값들만 모아 새로운 배열을 생성한다는 점에서 선언적이고 명료한 방식이다.

형식은 다음과 같다.

arr.filter(value => 조건식);

조건식이 true일 때 value는 유지되고, false일 때는 제거된다.

이 문제에서의 조건은 단순하다.

"삭제 대상에 포함되어 있지 않은 값만 남긴다."

따라서 조건식은 !toDelete.has(value)가 된다.

최종 코드

function solution(arr, delete_list) {
  const toDelete = new Set(delete_list);
  return arr.filter(value => !toDelete.has(value));
}

코드 동작 과정

예제 1을 기준으로 실제 동작을 표로 정리하면 다음과 같다.

arr = [293, 1000, 395, 678, 94]

toDelete = new Set([94, 777, 104, 1000, 1, 12])

결과는 [293, 395, 678]이 된다.

다른 구현 방식과의 비교

1. 배열 includes 사용

arr.filter(value => !delete_list.includes(value));

문제의 입력 규모에서는 정상적으로 동작하지만, 삭제 대상 목록이 커지면 반복적으로 전체 배열을 탐색해야 하므로 효율성이 떨어진다.

2. Set 기반 구현

const toDelete = new Set(delete_list);
arr.filter(value => !toDelete.has(value));

삭제 대상 여부를 확인하는 연산이 상수 시간에 이루어지므로 더 안정적이며, 특히 입력 크기가 커지는 환경에서는 필수에 가깝다.

정리

• Set은 삭제 대상 목록을 빠르게 조회하기 위한 최적의 자료구조다.
• filter는 조건 기반 요소 추출에 적합한 선언적 API다.
• 이 두 가지를 조합하면 가독성, 성능, 확장성 모두 균형 잡힌 구조를 만들 수 있다.
• 실무에서도 유지 조건 또는 필터링 조건이 있는 배열 처리에서는 동일한 패턴이 자주 사용된다.

문자열로 변환

문제 설명

정수 n이 주어질 때, n을 문자열로 변환하여 return하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ n ≤ 10000

입출력 예

입출력 예 설명

입출력 예 #1

• 123을 문자열로 변환한 "123"을 return합니다.

입출력 예 #2

• 2573을 문자열로 변환한 "2573"을 return합니다.

1. 가장 명확한 방법 — String(n)

function solution(n) {
  return String(n);
}

왜 이 방식이 좋은가?

• 의도가 가장 분명하다. “숫자를 문자열로 변환한다”는 목적이 코드만 보아도 명확하게 드러난다.
• 암묵적 변환을 피한다. 협업 환경에서는 암묵적 타입 변환이 버그를 유발할 여지가 있으므로, 명시적 변환이 권장된다.
• 변환 대상이 무엇이든 안정적이다. null, undefined 등 특수 값도 명시적으로 문자열로 바뀐다.

2. 템플릿 리터럴 사용 — 백틱 기반 문자열 결합

function solution(n) {
  return `${n}`;
}

장점

• ES6 이후 가장 많이 사용되는 문자열 생성 방식.
• 내부적으로 문자열 연산이 보장되므로 자연스럽게 문자열 타입 변환이 이루어진다.

단점

• "문자열을 만들기 위해 템플릿 문법을 사용한다"는 점에서 약간의 과잉 표현.
• 목적은 "변환"인데 "포매팅" 문법을 쓴 것처럼 보일 수 있다.

3. 문자열 덧셈 — 전통적인 방식

function solution(n) {
  return n + "";
}

평가

• 자바스크립트 초창기부터 존재하던 방식.
• 암묵적 타입 변환에 의존하기 때문에 오늘날에는 선호되지 않는다.
• 코드 리뷰 시 “의도가 불명확하다”는 지적을 받을 여지가 있다.

4. toString() 메서드 사용

function solution(n) {
  return n.toString();
}

장점

• 숫자의 고유 메서드이므로 비교적 직관적이다.

주의 사항

• null이나 undefined에 사용하면 에러를 발생시킨다.
• 이 문제는 입력이 항상 유효하므로 문제는 없지만, 방어적 프로그래밍 관점에서는 String(n)이 더 안전하다.

📌 최종 권장 풀이

function solution(n) {
  return String(n);
}

선택 이유

• 명시적이고 안전하며 협업 환경에서 예측 가능한 패턴.
• 타입 변환이라는 본래 의도를 가장 직관적으로 드러낸다.

두 수의 합

문제 설명

0 이상의 두 정수가 문자열 a, b로 주어질 때, a + b의 값을 문자열로 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ a의 길이 ≤ 100,000
• 1 ≤ b의 길이 ≤ 100,000
• a와 b는 숫자로만 이루어져 있습니다.
• a와 b는 정수 0이 아니라면 0으로 시작하지 않습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번의 a, b는 각각 582, 734이고 582 + 734 = 1316입니다. 따라서 "1316"을 return 합니다.

입출력 예 #2

• 예제 2번의 a, b는 각각 18446744073709551615, 287346502836570928366이고 18446744073709551615 + 287346502836570928366 = 305793246910280479981입니다. 따라서 "305793246910280479981"을 return 합니다.

입출력 예 #3

• 예제 3번의 a, b는 각각 0, 0이고 0 + 0 = 0입니다. 따라서 "0"을 return 합니다.

문제의 핵심은 일반 정수 타입으로 표현할 수 없을 만큼 큰 숫자를 문자열 형태로 받아 직접 덧셈 로직을 구현하는 것이다.

JavaScript의 Number 혹은 BigInt를 쓸 수도 있지만, 이 문제는 문자열 기반 덧셈 알고리즘을 직접 구현하는 경험을 요구한다.

1. 문제의 본질: 문자열 기반 수학 연산

일반 덧셈은 다음의 규칙을 따른다.

1. 가장 낮은 자리부터(오른쪽부터) 계산한다.
2. 각 자리수의 합이 10 이상이면 올림(carry) 를 발생시킨다.
3. 모든 자리를 순회한 뒤 마지막에 carry가 남는다면 가장 앞에 추가한다.

문자열 덧셈도 동일한 원리에 기반하지만, 차이가 있다.

• 숫자를 배열로 변환하거나 거꾸로 순회해야 한다.
• 한 문자열의 길이가 더 길 수 있으므로 두 포인터 방식이 유용하다.
• 반복 횟수는 max(a.length, b.length)으로 결정되며, 최대 100,000번이므로 O(N) 단일 패스로 충분히 빠르다.

2. 기본 알고리즘: Two-Pointer + Carry

핵심 의사코드

• i = a.length - 1, j = b.length - 1
• carry = 0
• while i ≥ 0 or j ≥ 0 or carry > 0
  • 각 자리 숫자를 더함
  • carry 업데이트
  • 문자열에 결과 누적
• 문자열 뒤집기

이 구조는 단일 패스 + 상수 공간의 carry 관리라는 측면에서 가장 이상적이다.

3. JavaScript 구현 — 최적화 버전

function solution(a, b) {
  let i = a.length - 1;
  let j = b.length - 1;
  let carry = 0;
  const result = [];

  while (i >= 0 || j >= 0 || carry > 0) {
    const x = i >= 0 ? a.charCodeAt(i) - 48 : 0;
    const y = j >= 0 ? b.charCodeAt(j) - 48 : 0;

    const sum = x + y + carry;
    result.push(sum % 10);
    carry = Math.floor(sum / 10);

    i--;
    j--;
  }

  return result.reverse().join('');
}

구현 포인트

• charCodeAt 기반 숫자 변환은 문자열 → 숫자 변환 중 가장 빠른 방법 중 하나이다.
• 결과를 배열에 push한 뒤 마지막에 reverse()하는 방식이 가장 단순하며 성능도 충분히 좋다.
• 매 반복에서 정수 연산만 수행되므로 O(N) 시간에 안정적으로 동작한다.

4. 대안적 접근법 비교

4.1 BigInt 사용 (간단하지만 비권장)

function solution(a, b) {
  return (BigInt(a) + BigInt(b)).toString();
}

장점

• 가장 간단하다.
• 자바스크립트 내장 기능을 활용해 읽기 쉽다.

단점

• 문제 취지와 다르다.
• 메모리 사용량 증가, 초대형 입력(10⁵ 자리의 문자열)을 BigInt로 변환하는 비용이 매우 크다.
• 일부 플랫폼에서는 BigInt 연산 overflow나 성능 문제가 발생할 수 있다.

실무에서는 BigInt로 처리하는 것이 이득인 경우도 많지만, 알고리즘 문제에서는 직접 구현이 정답이다.

4.2 앞에서부터 누적하는 방식 (비효율)

// 비효율적: 문자열 앞에 추가 → 매 삽입마다 O(n)
result = digit + result;

이 방식은 문자열 concat 비용이 누적되어 O(N²) 로 악화될 수 있으므로 금지해야 한다.

5. 학습 포인트 정리

문자열 기반 수학을 구현할 때 반드시 고려해야 하는 요소

• 자리수 순회는 오른쪽부터
• 하위 단계에서 발생하는 carry는 상위 단계로 전파
• 문자열 덧셈은 결국 배열 + reverse() 로 귀결된다
• JavaScript에서 숫자 변환은 charCodeAt이 빠르다
• 두 포인터 방식은 큰 입력에서도 성능을 보장한다

0떼기

문제 설명

정수로 이루어진 문자열 n_str이 주어질 때, n_str의 가장 왼쪽에 처음으로 등장하는 0들을 뗀 문자열을 return하도록 solution 함수를 완성해주세요.

제한사항

• 2 ≤ n_str ≤ 10
• n_str이 "0"으로만 이루어진 경우는 없습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• "0010"의 가장 왼쪽에 연속으로 등장하는 "0"을 모두 제거하면 "10"이 됩니다.

입출력 예 #2

• "854020"는 가장 왼쪽에 0이 없으므로 "854020"을 return합니다.

1. 문제 정리

• 입력: "0010", "854020" 같은 정수로 이루어진 문자열 n_str
• 해야 할 일:
  • 문자열 왼쪽에서부터 연속해서 등장하는 '0'들을 전부 제거
  • 단, 중간이나 끝에 있는 0은 유지
• 보장 조건:
  • 길이는 2 이상 10 이하
  • "0"으로만 이루어진 문자열은 없다 → 결과 문자열은 반드시 비어있지 않다

즉, “첫 번째 0이 아닌 문자가 나올 때까지의 0들을 제거하고, 그 뒤는 그대로 둔다”는 문제다.

2. 권장 풀이 — 정규식 replace 사용

가장 간결하면서도 의도가 잘 드러나는 방식은 정규식을 이용한 치환이다.

function solution(n_str) {
  return n_str.replace(/^0+/, '');
}

코드 해설

• ^0+ 정규식의 의미
  • ^ : 문자열의 시작을 의미한다.
  • 0+ : 문자 '0'이 1개 이상 연속해서 나오는 구간을 의미한다.
• n_str.replace(/^0+/, '')
  • 문자열 시작 부분에서 연속된 0들을 찾아서
  • 빈 문자열로 치환 → 즉, 제거한다.

예시 동작

• "0010".replace(/^0+/, '') → "10"
• "854020".replace(/^0+/, '') → "854020" (앞에 0이 없으므로 변경 없음)
• "00012300".replace(/^0+/, '') → "12300" (맨 앞 0만 제거, 뒤의 00은 유지)

왜 이 풀이를 1순위로 추천하는가?

1. 의도가 선언적으로 드러난다

   “문자열 시작(^)에서 0들을 제거하겠다”라는 의도가 코드 레벨에서 바로 보인다.

2. 구현이 매우 간단하고, 에지 케이스까지 자연스럽게 처리한다.

3. 문제의 요구사항(앞쪽 0만 제거)에 정확히 대응하는 패턴이다.

실무에서도 정규식 기반의 replace는 입력 정제, 포맷팅, 마스킹 등에 매우 자주 쓰이는 패턴이므로 익숙해질 가치가 크다.

3. 대안 풀이 1 — 인덱스를 직접 찾는 방식

정규식을 쓰지 않고, 문자열을 직접 순회하며 첫 번째 0이 아닌 문자의 위치를 찾아 slice 하는 방식도 있다.

function solution(n_str) {
  let index = 0;

  while (index < n_str.length && n_str[index] === '0') {
    index++;
  }

  return n_str.slice(index);
}

코드 해설

1. index를 0부터 시작한다.
2. 문자열을 왼쪽에서 오른쪽으로 보면서:
   • 현재 문자가 '0'이면 index++
   • '0'이 아닌 문자를 만나면 반복 종료
3. n_str.slice(index)로 해당 위치부터 끝까지 잘라서 반환

장점

• 동작 방식이 매우 직관적이다.
• 정규식을 모르는 사람에게도 쉽게 설명 가능하다.
• 시간 복잡도는 O(n) → 이 문제 크기(최대 10)에서는 의미 없지만, 길이가 매우 길어져도 효율적이다.

단점

• 같은 기능을 수행하는데 코드 라인이 늘어난다.
• 정규식 풀이에 비해 “패턴 기반 문자열 처리”라는 관점에서는 덜 선언적이다.

정규식을 팀에서 선호하지 않거나, 정규식 사용이 부담되는 초기 학습 단계라면 이 방법도 좋은 선택이다.

4. 대안 풀이 2 — 숫자로 변환 후 다시 문자열로

이 문제는 입력이 “정수로 이루어진 문자열”이며, "0"으로만 이루어진 문자열은 주어지지 않는다고 명시되어 있다.

따라서 숫자로 한 번 변환했다가 다시 문자열로 바꾸는 방식도 동작한다.

function solution(n_str) {
  return String(Number(n_str));
}

혹은:

function solution(n_str) {
  return String(parseInt(n_str, 10));
}

동작 원리

• Number("0010") → 10 (숫자 타입)
• String(10) → "10"

즉, 숫자 변환 과정에서 자동으로 선행 0들이 제거된다.

이 방식의 문제점 (왜 “보조적” 방법인가?)

1. 문제의 요구는 “문자열 처리”인데, 중간에 불필요하게 숫자 타입으로 바꾼다.
   • 문자열 포맷을 유지해야 하는 문제(예: 전화번호, 카드번호 등)에서는 위험할 수 있다.
2. 향후 문제 확장 시, 숫자 범위가 커지면 Number의 정확도 문제(IEEE 754, 2^53 - 1 초과)가 생길 수 있다.
3. "0000000007" 같은 값을 BigInt나 문자열 그대로 다뤄야 하는 케이스에선 부적절하다.

이 문제의 제한(길이 ≤ 10, 모두 정수 문자열)에서는 정상적으로 동작하지만,

타입 변환을 로직으로 쓰는 패턴은 “습관”으로 가져가기엔 위험하다는 점을 인지하는 것이 중요하다.

5. 세 가지 접근 방식 비교

6. 문제 확장/변형 시 고려할 포인트

실무적인 관점에서 이 문제를 확장하면 다음과 같은 질문들이 생긴다.

1. "0"으로만 이루어진 문자열이 들어올 수도 있다면?

   • 예: "0000" → 어떤 결과를 원할 것인가? "0"인지, ""인지?
   • 일반적으로는 "0"으로 normalize(정규화)하는 편이 자연스럽다.

2. 길이가 매우 긴 숫자 문자열 (예: 1000자리) 이라면?

   • Number로 변환하는 방식은 정확도를 잃는다.
   • 이럴 때는 무조건 문자열 기반 처리(정규식 또는 인덱스)를 사용해야 한다.

3. 중간의 0도 제거할 것인가, 앞부분만 제거할 것인가?

   • 이 문제는 “앞부분만” 제거이므로, 정규식에서도 ^를 쓰는 것이 중요하다.

     (/0+/g처럼 전체에서 0을 제거하면 완전히 다른 동작을 한다.)

이런 고민을 통해 “현재 제약 조건에서 왜 이 풀이가 맞는지”뿐 아니라,

“제약이 바뀌면 어느 지점에서 깨지는지”까지 생각하는 습관이 실무에서 큰 힘이 된다.

7. 최종 정리

이 문제에 대한 가장 추천하는 풀이는 다음과 같다.

function solution(n_str) {
  return n_str.replace(/^0+/, '');
}

• 정규식으로 “문자열 시작 지점의 연속된 0”만 제거한다.
• 문제의 요구사항과 정확히 일치하며, 확장성·가독성 측면에서도 우수하다.

문자열을 정수로 변환하기

문제 설명

숫자로만 이루어진 문자열 n_str이 주어질 때, n_str을 정수로 변환하여 return하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ n_str ≤ 5
• n_str은 0부터 9까지의 정수 문자로만 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• "10"을 정수로 바꾸면 10입니다.

입출력 예 #2

• "8542"를 정수로 바꾸면 8542입니다.

1. 문제 핵심 정리

• 입력: "8542"처럼 숫자로만 이루어진 문자열
• 출력: 정수 타입
• 제약이 작기 때문에 성능은 모든 방식이 충분하다.
• 하지만 JavaScript의 특성상 “문자열을 숫자로 바꾸는 다양한 방식”의 차이를 이해하는 것이 학습의 핵심이다.

2. 권장 풀이 — Number() 사용

function solution(n_str) {
  return Number(n_str);
}

왜 Number()인가?

• 명시적 타입 변환(explicit coercion) 함수이며, 가장 의도가 명확한 방식이다.
• JavaScript 엔진이 문자열을 정수/실수 모두 포함한 숫자로 정확하게 변환해준다.
• "0012"와 같이 앞자리 0이 포함되어도 정상 동작한다.
• "10e2"(지수 표기), " 42 "(공백 포함)도 올바르게 처리가능하지만, 이번 문제에서는 입력 범위가 좁아 영향을 주지 않는다.

실무 기준

API 파라미터, 환경 변수(process.env.*), 쿼리 스트링 파싱 등에서 가장 일반적으로 사용되는 방법이다.

명확한 의도 표출 + 예측 가능한 동작 = 협업 환경에서 가장 안전하다.

3. 대안적 풀이 (상황에 따라 유용)

3.1 parseInt

function solution(n_str) {
  return parseInt(n_str, 10);
}

특징

• 문자열을 정수로 변환.
• 두 번째 인자로 10을 명시하면 예상치 못한 진법 문제를 예방할 수 있다.
• 숫자가 아닌 문자를 만나면 변환을 중단한다. ("10px" → 10)

이 문제에서는 왜 굳이 사용할 필요가 없는가?

• 입력값이 오로지 숫자로만 이루어져 있어 Number()와 차이가 없다.
• 하지만 parseInt는 "정수 변환"이라는 의미가 강해 실수를 허용하지 않는다.

3.2 단항 연산자 +

function solution(n_str) {
  return +n_str;
}

장점

• 매우 짧고 빠르다.
• 암묵적 타입 변환을 수행한다.

단점

• 의도가 즉시 드러나지 않는다.

  특히 JS 초중급 개발자에게는 가독성이 좋지 않다.

• " "(공백), " 42 " 등의 값 처리 시 동작이 명확히 보이지 않는다.

실무에서는 팀 규칙에 따라 사용 여부가 달라진다.

퍼포먼스가 중요한 로우 레벨 로직에서는 사용되지만, 일반적인 웹백엔드/프론트 코드에서는 잘 쓰지 않는다.

4. 비추천 풀이

4.1 parseFloat 사용

입력이 정수 문자열이라는 점에서 불필요하다.

4.2 ~~n_str (비트 연산자 활용)

• 빠르긴 하지만 32비트 정수 범위 제한, 부호 처리 등 부작용이 많다.
• 문제에서 요구하는 범위에서는 동작하지만 확장성·가독성 측면에서 배제해야 한다.

5. 전체 비교

6. 예외 케이스 관점 (문제를 확장한다면)

이번 문제는 숫자만 주어지지만, 실제 서비스에서는 다음 케이스도 고려해야 한다.

1. "0012" → 앞자리 0
2. " 42 " → 공백 포함 입력
3. "10px" → 숫자 뒤 문자열 포함
4. "" → 빈 문자열
5. "1e3" → 지수 표기
6. "Infinity" → 무한대
7. "0000000000000000000001" → 매우 긴 숫자 (BigInt 고려)

입력 정제와 숫자 변환 정책이 리스크를 줄이는 핵심이다.

7. 결론 및 학습 포인트

• 이 문제는 단순하지만, JavaScript의 타입 변환 전략을 이해하는 좋은 출발점이다.
• 실무에서는 명시적 타입 변환을 사용하여 코드 의도를 분명히 하는 것이 중요하다.
• 특히 API 개발 시, 숫자·문자열 변환 정책을 일관되게 관리해야 협업 생산성이 올라간다.

최종 권장 코드:

function solution(n_str) {
  return Number(n_str);
}

문자열 정수의 합

문제 설명

한 자리 정수로 이루어진 문자열 num_str이 주어질 때, 각 자리수의 합을 return하도록 solution 함수를 완성해주세요.

제한사항

• 3 ≤ num_str ≤ 100

입출력 예

입출력 예 설명

입출력 예 #1

• 문자열 안의 모든 숫자를 더하면 45가 됩니다.

입출력 예 #2

• 문자열 안의 모든 숫자를 더하면 1이 됩니다.

코드

function solution(num_str) {
  return num_str.split("").reduce((acc, curr) => acc + Number(curr), 0);
}

console.log(solution("123456789")); // 45
console.log(solution("1000000"));   // 1

코드 설명

num_str을 split("")을 사용해 한 글자씩 분리한 배열로 변환한 뒤,

reduce()를 활용하여 각 요소를 Number()로 형변환하면서 누적해 합을 계산하는 방식입니다.

핵심 흐름

"1234" → ["1", "2", "3", "4"] → 1 + 2 + 3 + 4 = 10

사용된 주요 메서드

다른 풀이 방법

1) for-of 반복문 사용

function solution(num_str) {
  let sum = 0;
  for (let n of num_str) sum += Number(n);
  return sum;
}

2) 전개 연산자 + reduce()

const solution = num_str =>
  [...num_str].reduce((a, c) => a + +c, 0);

3) Array.from() 활용

function solution(num_str) {
  return Array.from(num_str, Number).reduce((a, c) => a + c, 0);
}

추가 내용

1. split("") 의 장점

문자열을 전개하는 방식은 여러 가지가 있습니다.

즉, split은 구현은 간단하지만 메모리 할당이 추가됩니다.

문자열이 매우 길거나 메모리 최적화가 중요하다면

for-of 방식이 더 효율적입니다.

2. reduce()를 사용하는 이유

즉, reduce는 의도를 드러내는 함수형 코드입니다.

합을 구하는 상황에서 reduce는 정답에 가깝다.

3. Number(curr) vs parseInt(curr) vs +curr

예시:

parseInt("08px") // 8 ← 좋은 결과인가?
Number("08px")   // NaN ← 에러를 명확히 드러냄

에러를 감추지 않는 것이 더 안전

그래서 Number() 선택도 충분한 이유가 존재합니다.

다른 풀이와 문제점 비교

for-of 방식 (메모리 효율 최고)

function solution(num_str) {
  let sum = 0;
  for (const c of num_str) sum += Number(c);
  return sum;
}

• 장점: 불필요한 중간 배열 생성 없음
• 단점: 함수형 의도가 약해짐

reduce + spread 방식

[...num_str].reduce(...)

• 가독성 좋음
• 하지만 문자열 Iterator → 배열 복사 추가 비용

Array.from 방식

Array.from(num_str, Number)

• 문자 → 숫자 mapping이 한 번에 처리됨
• 하지만 Array.from 자체가 오버헤드가 있음

어떤 방식이 “좋은가”?

즉, 현재 문제의 스케일에서는 가독성과 의도 투명성이 우선 → reduce 기반 풀이가 최선

확장 상황을 생각해보자

예: 1000자리 초과 숫자 → bigint 또는 직접 자리수 연산

결론

좋은 코드는 단순하게 보이지만 내부적으로 많은 트레이드오프를 고려한 결과입니다.

• 왜 reduce인가?

  → "합을 구한다"는 목적과 가장 직결되므로

• 왜 Number인가?

  → 실패 시 오류를 숨기지 않기 때문

• 왜 split인가?

  → 명확하고 직관적인 문자열 처리

정수 부분

문제 설명

실수 flo가 매개 변수로 주어질 때, flo의 정수 부분을 return하도록 solution 함수를 완성해주세요.

제한사항

• 0 ≤ flo ≤ 100

입출력 예

입출력 예 설명

입출력 예 #1

• 1.42의 정수 부분은 1입니다.

입출력 예 #2

• 69.32의 정수 부분은 69입니다.

코드

function solution(flo) {
    return parseInt(flo);
}

설명

• Math.floor() 함수는 주어진 실수의 소수점 이하를 버리고 가장 가까운 정수(작거나 같은 정수) 를 반환합니다.
  • 예: Math.floor(1.42) → 1
  • 예: Math.floor(69.32) → 69

다른 방법들 (참고용)

// 1. 비트 연산자 (소수점 이하 제거)
function solution(flo) {
    return flo | 0;
}

// 2. parseInt 사용
function solution(flo) {
    return parseInt(flo);
}

하지만 위 두 방법은 양수에서는 문제 없지만, 음수가 들어올 수 있는 일반적인 경우에는 Math.floor()가 더 정확하고 안전합니다.

현재 문제의 제한사항에선 flo >= 0이기 때문에 모두 사용 가능하지만, 가장 명확한 방법은 Math.floor()입니다.

Math.floor() vs parseInt() vs 비트 연산 (| 0)

const num = -1.9;

1. Math.floor(num)

Math.floor(-1.9); // ➜ -2

• 설명: 소수점을 버리고, 더 작은 쪽 정수로 내림 (즉, -1.9 → -2)

2. parseInt(num)

parseInt(-1.9); // ➜ -1

• 설명: 문자열로 변환된 수에서 소수점 앞까지만 해석 → 실제로는 문자열 파싱 동작
• ⚠️ 정확한 내림이 아님 — 예상과 다르게 작동할 수 있음

3. num | 0 (비트 연산)

-1.9 | 0; // ➜ -1

• 설명: 비트 연산자 사용 시 소수점 이하 버림 (정수로 강제 변환)
• 그러나 결과는 0 쪽으로 내림 ⇒ -1.9 → -1

결론: Math.floor() 가 더 정확하고 안전한 이유

• Math.floor()는 항상 “작거나 같은 정수”로 내림하여 수학적으로 가장 정확한 내림 함수입니다.
• 반면, parseInt()나 | 0은 양수에는 같게 동작하지만, 음수에서는 “0 방향”으로 내림하여 예기치 않은 결과를 줄 수 있습니다.

👇 정리

따라서, 일반적인 환경에서 정수 부분을 안전하게 구하고 싶다면 Math.floor()를 사용하는 것이 가장 신뢰할 수 있는 방법입니다.

정수로 변환하고 싶다면? — 방법별 차이 정리

🔍 어떤 상황에서 어떤 방법을 쓰면 좋을까?

한 줄 요약

숫자의 정수 부분을 가장 안전하게 얻고 싶다면 Math.trunc()(절삭) 또는 Math.floor()(내림)가 가장 권장된다. (parseInt()와 ~~는 특정 상황을 제외하면 비추천)

전국 대회 선발 고사

문제 설명

0번부터 n - 1번까지 n명의 학생 중 3명을 선발하는 전국 대회 선발 고사를 보았습니다. 등수가 높은 3명을 선발해야 하지만, 개인 사정으로 전국 대회에 참여하지 못하는 학생들이 있어 참여가 가능한 학생 중 등수가 높은 3명을 선발하기로 했습니다.

각 학생들의 선발 고사 등수를 담은 정수 배열 rank와 전국 대회 참여 가능 여부가 담긴 boolean 배열 attendance가 매개변수로 주어집니다. 전국 대회에 선발된 학생 번호들을 등수가 높은 순서대로 각각 a, b, c번이라고 할 때 10000 × a + 100 × b + c를 return 하는 solution 함수를 작성해 주세요.

제한사항

• 3 ≤ rank의 길이 = attendance의 길이 ≤ 100
• rank[i]는 i번 학생의 선발 고사 등수를 의미합니다.
• rank의 원소는 1부터 n까지의 정수로 모두 서로 다릅니다.
• attendance[i]는 i번 학생의 전국 대회 참석 가능 여부를 나타냅니다.
  • attendance[i]가 true라면 참석 가능, false면 참석 불가능을 의미합니다.
• attendance의 원소 중 적어도 3개는 true입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번에서 1등은 6번 학생이지만 전국 대회에 참석 불가능하므로 넘어갑니다. 2등은 2번 학생이고 전국 대회에 참석 가능하므로 1순위로 선발됩니다. 3등은 0번 학생이고 전국 대회에 참석 불가능 하므로 넘어갑니다. 4등과 5등은 각각 4번, 3번 학생이고 두 학생 모두 전국 대회에 참석 가능하므로 각각 2순위, 3순위로 선발됩니다. 3명을 선발하였으므로 6등과 7등은 확인하지 않아도 됩니다. 따라서 10000 × 2 + 100 × 4 + 3 = 20403을 return 합니다.

입출력 예 #2

• 예제 2번에서 1, 2, 3등은 각각 0번, 1번, 2번 학생이고 세 학생 모두 전국 대회에 참석 가능하므로 각각 1순위, 2순위, 3순위로 선발됩니다. 따라서 10000 × 0 + 100 × 1 + 2 = 102를 return 합니다.

입출력 예 #3

• 예제 3번에서 1, 2, 3등은 각각 1번, 3번, 4번 학생이지만 세 학생 모두 전국 대회에 참석 불가능합니다. 다음으로 4, 5, 6등은 각각 5번, 2번, 0번 학생이고 세 학생 모두 전국 대회에 참석 가능하므로 각각 1순위, 2순위, 3순위로 선발됩니다. 따라서 10000 × 5 + 100 × 2 + 0 = 50200을 return 합니다.

코드

/**
 * 전국 대회 선발 고사 - 다양한 풀이법 비교
 */

// ============================================
// 방법 1: 함수형 프로그래밍 (추천 ⭐⭐⭐)
// ============================================
function solution1(rank, attendance) {
  /**
   * 함수형 접근법의 장점:
   * - 체이닝으로 한 번에 읽기 쉬움
   * - 각 단계가 명확하게 분리됨
   * - 불변성을 유지하며 데이터 변환
   */
  return rank
    .map((rankValue, studentIndex) => ({ rankValue, studentIndex })) // 1. 학생 정보 객체화
    .filter((student) => attendance[student.studentIndex]) // 2. 참석 가능한 학생만 필터링
    .sort((a, b) => a.rankValue - b.rankValue) // 3. 등수 기준 오름차순 정렬
    .slice(0, 3) // 4. 상위 3명만 선택
    .reduce((result, student, index) => {
      // 5. 최종 계산
      const multiplier = [10000, 100, 1][index]; // 각 순위별 가중치
      return result + student.studentIndex * multiplier;
    }, 0);
}

// ============================================
// 방법 2: 직관적인 배열 활용 (이해하기 쉬움 ⭐⭐)
// ============================================
function solution2(rank, attendance) {
  /**
   * 직관적 접근법의 장점:
   * - 코드 흐름이 명확함
   * - 초보자도 이해하기 쉬움
   * - 디버깅이 용이함
   */
  const attendableStudents = [];

  // 참석 가능한 학생들의 정보를 수집
  for (let i = 0; i < rank.length; i++) {
    if (attendance[i]) {
      attendableStudents.push({
        studentNumber: i,
        rank: rank[i],
      });
    }
  }

  // 등수 기준으로 정렬 (낮은 등수 = 높은 순위)
  attendableStudents.sort((a, b) => a.rank - b.rank);

  // 상위 3명의 학생 번호로 결과 계산
  const [first, second, third] = attendableStudents;
  return (
    first.studentNumber * 10000 +
    second.studentNumber * 100 +
    third.studentNumber
  );
}

// ============================================
// 방법 3: 원라이너 (간결함 ⭐)
// ============================================
function solution3(rank, attendance) {
  /**
   * 원라이너 접근법:
   * - 매우 간결함
   * - 함수형 프로그래밍의 극치
   * - 가독성은 떨어질 수 있음
   */
  return rank
    .map((r, i) => [r, i])
    .filter(([, i]) => attendance[i])
    .sort(([a], [b]) => a - b)
    .slice(0, 3)
    .reduce(
      (sum, [, studentNum], idx) => sum + studentNum * [10000, 100, 1][idx],
      0
    );
}

// ============================================
// 방법 4: Map 사용 (기존 방법)
// ============================================
function solution_original(rank, attendance) {
  const rankMap = new Map();
  for (let i = 0; i < rank.length; i++) {
    if (attendance[i]) {
      rankMap.set(rank[i], i);
    }
  }
  const sortedRank = Array.from(rankMap.entries()).sort((a, b) => a[0] - b[0]);
  return sortedRank[0][1] * 10000 + sortedRank[1][1] * 100 + sortedRank[2][1];
}

// ============================================
// 성능 비교 및 테스트
// ============================================

/**
 * 추천하는 해결법: solution1 (함수형 프로그래밍)
 *
 * 이유:
 * 1. 가독성이 좋음 - 각 단계가 명확히 보임
 * 2. 유지보수 용이 - 각 체이닝 단계를 독립적으로 수정 가능
 * 3. 모던 JavaScript 스타일 - ES6+ 문법 활용
 * 4. 함수형 프로그래밍 패러다임 - 부작용 없는 순수 함수
 */

// 모든 해결법으로 테스트
const testCases = [
  [
    [3, 7, 2, 5, 4, 6, 1],
    [false, true, true, true, true, false, false],
  ], // 예상: 20403
  [
    [1, 2, 3],
    [true, true, true],
  ], // 예상: 102
  [
    [6, 1, 5, 2, 3, 4],
    [true, false, true, false, false, true],
  ], // 예상: 50200
];

console.log("=== 성능 및 결과 비교 ===");
testCases.forEach((testCase, index) => {
  const [rank, attendance] = testCase;

  console.log(`\n테스트 케이스 ${index + 1}:`);
  console.log(`방법1 (함수형): ${solution1(rank, attendance)}`);
  console.log(`방법2 (직관적): ${solution2(rank, attendance)}`);
  console.log(`방법3 (원라이너): ${solution3(rank, attendance)}`);
  console.log(`기존방법 (Map): ${solution_original(rank, attendance)}`);
});

뒤에서 5등 위로

문제 설명

정수로 이루어진 리스트 num_list가 주어집니다. num_list에서 가장 작은 5개의 수를 제외한 수들을 오름차순으로 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항

• 6 ≤ num_list의 길이 ≤ 30
• 1 ≤ num_list의 원소 ≤ 100

입출력 예

입출력 예 설명

입출력 예 #1

• [12, 4, 15, 46, 38, 1, 14, 56, 32, 10]를 정렬하면 [1, 4, 10, 12, 14, 15, 32, 38, 46, 56]이 되고, 앞에서 부터 6번째 이후의 수들을 고르면 [15, 32, 38, 46, 56]가 됩니다.

코드

function solution(num_list) {
    return num_list.sort((a, b) => a - b).slice(5);
}

코드 설명

1. 리스트를 오름차순 정렬

    num_list.sort((a, b) => a - b)
   

   • sort()를 사용하여 오름차순 정렬.
   • (a, b) => a - b는 숫자 정렬을 위한 비교 함수.

2. 가장 작은 5개의 숫자를 제외하고 반환

    .slice(5)
   

   • slice(5)를 사용하여 앞에서 5개를 제외한 나머지 부분 반환.

뒤에서 5등까지

문제 설명

정수로 이루어진 리스트 num_list가 주어집니다. num_list에서 가장 작은 5개의 수를 오름차순으로 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항

• 6 ≤ num_list의 길이 ≤ 30
• 1 ≤ num_list의 원소 ≤ 100

입출력 예

입출력 예 설명

입출력 예 #1

• [12, 4, 15, 46, 38, 1, 14]를 정렬하면 [1, 4, 12, 14, 15, 38, 46]이 되고, 앞에서 부터 5개를 고르면 [1, 4, 12, 14, 15]가 됩니다.

코드

function solution(num_list) {
    return num_list.sort((a, b) => a - b).slice(0, 5);
}

코드 설명

1. 정렬 (오름차순)

    num_list.sort((a, b) => a - b)

   • sort()를 사용하여 리스트를 오름차순 정렬.
   • (a, b) => a - b는 숫자 정렬을 위한 비교 함수.

2. 가장 작은 5개의 숫자 선택

    .slice(0, 5)

   • slice(0, 5)를 사용하여 정렬된 리스트의 처음 5개 요소를 추출.

결론: sort()로 정렬 후 slice()로 상위 5개 추출.

배열의 길이에 따라 다른 연산하기

문제 설명

정수 배열 arr과 정수 n이 매개변수로 주어집니다. arr의 길이가 홀수라면 arr의 모든 짝수 인덱스 위치에 n을 더한 배열을, arr의 길이가 짝수라면 arr의 모든 홀수 인덱스 위치에 n을 더한 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ arr의 길이 ≤ 1,000
• 1 ≤ arr의 원소 ≤ 1,000
• 1 ≤ n ≤ 1,000

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번의 arr의 길이는 5로 홀수입니다. 따라서 arr의 짝수 인덱스 0, 2, 4에 주어진 n 값인 27을 더하면 [76, 12, 127, 276, 60]이 됩니다. 따라서 [76, 12, 127, 276, 60]를 return 합니다.

입출력 예 #1

• 예제 2번의 arr의 길이는 4로 짝수입니다. 따라서 arr의 홀수 인덱스 1, 3에 주어진 n 값인 100을 더하면 [444, 655, 666, 877]이 됩니다. 따라서 [444, 655, 666, 877]를 return 합니다.

function solution(arr, n) {
    return arr.map((num, i) => (arr.length % 2 === 1 ? i % 2 === 0 : i % 2 === 1) ? num + n : num);
}

코드 설명

1. map()을 사용하여 배열을 변환

• arr.map((num, i) => {...}) : arr의 각 요소를 순회하며 새로운 배열을 생성.

• num은 현재 요소, i는 현재 인덱스.

2. 배열 길이에 따른 인덱스 조건 설정

arr.length % 2 === 1 ? i % 2 === 0 : i % 2 === 1

• arr.length % 2 === 1 (홀수인 경우) → 짝수 인덱스 (i % 2 === 0)에 n을 더함.

• arr.length % 2 === 0 (짝수인 경우) → 홀수 인덱스 (i % 2 === 1)에 n을 더함.

3. 변환된 값을 반환

num + n : num

• 조건을 만족하면 num + n 반환, 그렇지 않으면 원래 값 반환.

웹 문서에서 스크롤이 발생하면 scroll 이벤트가 발생한다. 기본적으로 웹 문서의 크기가 브라우저 창보다 클 경우 스크롤이 자동으로 생성되며, CSS를 이용해 특정 요소에 스크롤을 추가할 수도 있다.

1. 스크롤 이벤트 감지하기

일반적으로 스크롤 이벤트는 브라우저를 대변하는 window 객체에 등록하는 경우가 많다.

window.addEventListener("scroll", () => {
  console.log("스크롤 이벤트 발생");
});

✅ 결과: 웹 문서에서 스크롤이 발생할 때마다 콘솔에 "스크롤 이벤트 발생"이 출력된다.

2. 현재 스크롤 위치 확인하기

스크롤 이벤트를 활용할 때 window 객체의 프로퍼티를 자주 사용한다.

window.addEventListener("scroll", () => {
  console.log(`현재 스크롤 위치: ${window.scrollY}px`);
});

✅ 결과: 현재 문서의 맨 위에서부터 몇 픽셀 만큼 스크롤했는지를 콘솔에 출력.

3. 특정 위치에서 요소 스타일 변경하기

스크롤 이벤트를 활용하여 특정 위치를 기준으로 요소의 스타일을 변경할 수 있다.

const navbar = document.querySelector(".navbar");

window.addEventListener("scroll", () => {
  if (window.scrollY > 30) {
    navbar.classList.add("scrolled");
  } else {
    navbar.classList.remove("scrolled");
  }
});

✅ 결과:

• 30px 이상 스크롤하면 .navbar 요소에 scrolled 클래스 추가 → 그림자 효과 적용

• 30px 이하로 스크롤하면 클래스 제거 → 원래 상태로 복귀

.scrolled {
  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
}

4. 스크롤 방향 감지하기

스크롤을 내릴 때와 올릴 때 다른 동작을 수행할 수도 있다.

let lastScrollY = 0;

window.addEventListener("scroll", () => {
  if (window.scrollY > lastScrollY) {
    console.log("스크롤 내림");
  } else {
    console.log("스크롤 올림");
  }
  lastScrollY = window.scrollY;
});

✅ 결과:

• 아래로 스크롤하면 "스크롤 내림"

• 위로 스크롤하면 "스크롤 올림"

요약

• scroll 이벤트는 웹 문서가 스크롤될 때마다 발생한다.

• window.scrollY를 활용하여 현재 스크롤 위치를 확인할 수 있다.

• 특정 위치 이상 스크롤되면 요소에 클래스를 추가하거나 제거할 수 있다.

• 스크롤 방향을 감지하여 위/아래 이동에 따라 다른 동작을 수행할 수 있다.

이렇게 스크롤 이벤트를 활용하면 다양한 UI 효과를 구현할 수 있다.

문자열 묶기

문제 설명

문자열 배열 strArr이 주어집니다. strArr의 원소들을 길이가 같은 문자열들끼리 그룹으로 묶었을 때 가장 개수가 많은 그룹의 크기를 return 하는 solution 함수를 완성해 주세요.

제한사항

• 1 ≤ strArr의 길이 ≤ 100,000
  • 1 ≤ strArr의 원소의 길이 ≤ 30
  • strArr의 원소들은 알파벳 소문자로 이루어진 문자열입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 각 문자열들을 길이에 맞게 그룹으로 묶으면 다음과 같습니다.

function solution(strArr) {
    const lengthCount = new Map(); // 문자열 길이별 개수를 저장할 Map

    // 각 문자열의 길이를 카운트
    for (const str of strArr) {
        const len = str.length;
        lengthCount.set(len, (lengthCount.get(len) || 0) + 1);
    }

    // 가장 큰 그룹 크기 찾기
    return Math.max(...lengthCount.values());
}

코드설명

1. 문자열 길이별 개수를 저장할 Map 생성

    const lengthCount = new Map();
   

   • Map을 사용하여 문자열 길이를 key로 하고, 해당 길이를 가진 문자열 개수를 value로 저장합니다.

2. 각 문자열의 길이를 Map에 카운트

    for (const str of strArr) {
        const len = str.length;
        lengthCount.set(len, (lengthCount.get(len) || 0) + 1);
    }
   

   • str.length를 이용하여 문자열 길이를 가져옵니다.
   • lengthCount.get(len) || 0: 기존에 해당 길이가 Map에 존재하면 그 값을 가져오고, 없으면 0으로 설정.
   • set(len, count + 1): 해당 길이의 문자열 개수를 증가.

3. 가장 개수가 많은 그룹 찾기

    return Math.max(...lengthCount.values());
   

   • lengthCount.values()는 Map에 저장된 모든 문자열 개수를 반환.
   • Math.max(...)를 이용하여 가장 큰 값을 찾음.

배열 비교하기

문제 설명

이 문제에서 두 정수 배열의 대소관계를 다음과 같이 정의합니다.

• 두 배열의 길이가 다르다면, 배열의 길이가 긴 쪽이 더 큽니다.
• 배열의 길이가 같다면 각 배열에 있는 모든 원소의 합을 비교하여 다르다면 더 큰 쪽이 크고, 같다면 같습니다.

두 정수 배열 arr1과 arr2가 주어질 때, 위에서 정의한 배열의 대소관계에 대하여 arr2가 크다면 -1, arr1이 크다면 1, 두 배열이 같다면 0을 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ arr1의 길이 ≤ 100
• 1 ≤ arr2의 길이 ≤ 100
• 1 ≤ arr1의 원소 ≤ 100
• 1 ≤ arr2의 원소 ≤ 100
• 문제에서 정의한 배열의 대소관계가 일반적인 프로그래밍 언어에서 정의된 배열의 대소관계와 다를 수 있는 점에 유의해주세요.

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번에서는 arr1의 길이는 2이고 arr2의 길이는 3으로 arr2의 길이가 더 깁니다. 따라서 arr2가 arr1보다 크므로 -1을 return 합니다.

입출력 예 #2

• 예제 2번에서는 arr1의 길이과 arr2의 길이가 4로 같습니다. arr1의 모든 원소의 합은 100 + 17 + 84 + 1 = 202이고 arr2의 모든 원소의 합은 55 + 12 + 65 + 36 = 168으로 arr1의 모든 원소의 합이 더 큽니다. 따라서 arr1이 arr2보다 크므로 1을 return 합니다.

입출력 예 #3

• 예제 3번에서는 arr1의 길이와 arr2의 길이가 5로 같고 각 배열의 모든 원소의 합 또한 15로 같습니다. 따라서 arr1과 arr2가 같으므로 0을 return 합니다.

function solution(arr1, arr2) {
    if (arr1.length !== arr2.length) {
        return arr1.length > arr2.length ? 1 : -1;
    }

    const sum1 = arr1.reduce((acc, num) => acc + num, 0);
    const sum2 = arr2.reduce((acc, num) => acc + num, 0);

    return sum1 === sum2 ? 0 : sum1 > sum2 ? 1 : -1;
}

코드설명

1. 배열 길이 비교

    if (arr1.length !== arr2.length) {
        return arr1.length > arr2.length ? 1 : -1;
    }
   

   • 두 배열의 길이가 다를 경우, 더 긴 배열이 크므로 길이를 비교하여 결과를 반환합니다.
   • arr1.length > arr2.length이면 1 반환 (arr1이 더 김).
   • arr1.length < arr2.length이면 1 반환 (arr2가 더 김).

2. 배열 원소의 합 비교

    const sum1 = arr1.reduce((acc, num) => acc + num, 0);
    const sum2 = arr2.reduce((acc, num) => acc + num, 0);
   

   • reduce를 사용하여 배열의 합을 계산합니다.
   • reduce((acc, num) => acc + num, 0)은 배열의 모든 원소를 더하는 역할을 합니다.

3. 합을 비교하여 결과 반환

    return sum1 === sum2 ? 0 : sum1 > sum2 ? 1 : -1;
   

   • 두 배열의 합이 같으면 0 반환.
   • sum1이 크면 1, sum2가 크면 1 반환.

배열의 길이를 2의 거듭제곱으로 만들기

문제 설명

정수 배열 arr이 매개변수로 주어집니다. arr의 길이가 2의 정수 거듭제곱이 되도록 arr 뒤에 정수 0을 추가하려고 합니다. arr에 최소한의 개수로 0을 추가한 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ arr의 길이 ≤ 1,000
• 1 ≤ arr의 원소 ≤ 1,000

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번의 arr의 길이는 6입니다. arr의 길이를 2의 정수 거듭제곱으로 만드는 방법은 0을 2개, 10개, 26개,..., 추가하는 방법이 있고 그중 최소한으로 0을 추가하는 방법은 2개를 추가하는 것입니다. 따라서 [1, 2, 3, 4, 5, 6, 0, 0]을 return 합니다.

입출력 예 #2

• 예제 2번의 arr의 길이는 4이고 이미 2의 정수 거듭제곱입니다. 따라서 뒤에 0을 추가하지 않아도 되므로 [58, 172, 746, 89]를 return 합니다.

function solution(arr) {
    const length = arr.length;
    const targetLength = 2 ** Math.ceil(Math.log2(length)); // 가장 가까운 2의 거듭제곱 계산
    return [...arr, ...Array(targetLength - length).fill(0)]; // 부족한 부분 0으로 채우기
}

코드설명

1. 현재 배열 길이 계산

    const length = arr.length;
   

   • 현재 arr의 길이를 length 변수에 저장합니다.

2. 가장 가까운 2의 거듭제곱 찾기

    const targetLength = 2 ** Math.ceil(Math.log2(length));
   

   • Math.log2(length): 현재 길이의 로그(base 2)를 구합니다.
   • Math.ceil(...): 올림하여 가장 가까운 2의 거듭제곱을 찾습니다.
   • 2 ** ...: 2의 거듭제곱을 계산하여 targetLength에 저장합니다.

3. 부족한 부분을 0으로 채우기

    return [...arr, ...Array(targetLength - length).fill(0)];
   

   • Array(targetLength - length).fill(0): 부족한 길이만큼 0을 채운 배열을 생성합니다.
   • ...arr, ...Array(...): 스프레드 연산자로 arr의 기존 값과 0을 추가한 배열을 합칩니다.

무작위로 K개의 수 뽑기

문제 설명

랜덤으로 서로 다른 k개의 수를 저장한 배열을 만드려고 합니다. 적절한 방법이 떠오르지 않기 때문에 일정한 범위 내에서 무작위로 수를 뽑은 후, 지금까지 나온적이 없는 수이면 배열 맨 뒤에 추가하는 방식으로 만들기로 합니다.

이미 어떤 수가 무작위로 주어질지 알고 있다고 가정하고, 실제 만들어질 길이 k의 배열을 예상해봅시다.

정수 배열 arr가 주어집니다. 문제에서의 무작위의 수는 arr에 저장된 순서대로 주어질 예정이라고 했을 때, 완성될 배열을 return 하는 solution 함수를 완성해 주세요.

단, 완성될 배열의 길이가 k보다 작으면 나머지 값을 전부 -1로 채워서 return 합니다.

제한사항

• 1 ≤ arr의 길이 ≤ 100,000
  • 0 ≤ arr의 원소 ≤ 100,000
• 1 ≤ k ≤ 1,000

입출력 예

입출력 예 설명

입출력 예 #1

• 앞에서부터 서로 다른 k개의 수를 골라내면 [0, 1, 2]가 됩니다. 따라서 [0, 1, 2]를 return 합니다.

입출력 예 #2

• 서로 다른 수의 개수가 2개 뿐이므로 서로 다른 수들을 앞에서부터 차례대로 저장한 [0, 1]에서 이후 2개의 인덱스를 -1로 채워넣은 [0, 1, -1, -1]을 return 합니다.

function solution(arr, k) {
    const set = new Set(arr); // 중복 제거된 값들을 저장
    return set.size > k
        ? [...set].slice(0, k)  // k개까지만 추출
        : [...set, ...Array(k - set.size).fill(-1)]; // 부족하면 -1 채우기
}

코드 설명

1. 중복 제거 (Set 활용)

• new Set(arr)을 이용하여 배열 arr에서 중복을 제거하고 고유한 값들만 저장합니다.
• 예: [0, 1, 1, 2, 2, 3] → {0, 1, 2, 3}.

2. k 개수 확인 후 처리

• set.size > k (고유한 숫자가 k보다 많을 경우)
  • slice(0, k)를 사용하여 k개까지만 선택.
• set.size <= k (고유한 숫자가 k보다 적을 경우)
  • 부족한 개수만큼 -1 을 추가.

배열 만들기 6

문제 설명

0과 1로만 이루어진 정수 배열 arr가 주어집니다. arr를 이용해 새로운 배열 stk을 만드려고 합니다.

i의 초기값을 0으로 설정하고 i가 arr의 길이보다 작으면 다음을 반복합니다.

• 만약 stk이 빈 배열이라면 arr[i]를 stk에 추가하고 i에 1을 더합니다.
• stk에 원소가 있고, stk의 마지막 원소가 arr[i]와 같으면 stk의 마지막 원소를 stk에서 제거하고 i에 1을 더합니다.
• stk에 원소가 있는데 stk의 마지막 원소가 arr[i]와 다르면 stk의 맨 마지막에 arr[i]를 추가하고 i에 1을 더합니다.

위 작업을 마친 후 만들어진 stk을 return 하는 solution 함수를 완성해 주세요.

단, 만약 빈 배열을 return 해야한다면 [-1]을 return 합니다.

제한사항

• 1 ≤ arr의 길이 ≤ 1,000,000
  • arr의 원소는 0 또는 1 입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 각 작업을 마친 후에 배열의 변화를 나타내면 다음 표와 같습니다.

입출력 예 #2

• 각 작업을 마친 후에 배열의 변화를 나타내면 다음 표와 같습니다.

입출력 예 #3

• 각 작업을 마친 후에 배열의 변화를 나타내면 다음 표와 같습니다.

function solution(arr) {
    const stk = [];

    for (const num of arr) {
        if (stk.length === 0 || stk[stk.length - 1] !== num) {
            stk.push(num);
        } else {
            stk.pop();
        }
    }

    return stk.length ? stk : [-1];
}

코드설명

1. 결과 배열 stk 초기화
   • 결과를 저장할 빈 배열 stk을 생성합니다.
2. for ... of 반복문을 사용하여 arr 순회
   • num은 arr의 각 요소를 의미합니다.
3. 조건 처리
   • stk이 비어있거나 stk의 마지막 요소(stk[stk.length - 1])와 현재 요소 num이 다르면 stk.push(num)을 실행하여 stk에 추가합니다.
   • stk의 마지막 요소와 num이 같으면 stk.pop()을 실행하여 stk에서 마지막 요소를 제거합니다.
4. 결과 반환
   • 모든 반복이 끝난 후 stk이 비어있다면 [-1]을 반환합니다.
   • 그렇지 않으면 stk을 그대로 반환합니다.

빈 배열에 추가, 삭제하기

문제 설명

아무 원소도 들어있지 않은 빈 배열 X가 있습니다. 길이가 같은 정수 배열 arr과 boolean 배열 flag가 매개변수로 주어질 때, flag를 차례대로 순회하며 flag[i]가 true라면 X의 뒤에 arr[i]를 arr[i] × 2 번 추가하고, flag[i]가 false라면 X에서 마지막 arr[i]개의 원소를 제거한 뒤 X를 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ arr의 길이 = flag의 길이 ≤ 100
• arr의 모든 원소는 1 이상 9 이하의 정수입니다.
• 현재 X의 길이보다 더 많은 원소를 빼는 입력은 주어지지 않습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번에서 X의 변화를 표로 나타내면 다음과 같습니다

따라서 [3, 3, 3, 3, 4, 4, 4, 4]를 return 합니다.

function solution(arr, flag) {
    const X = []; // 결과 배열 초기화

    arr.forEach((num, i) => {
        if (flag[i]) {
            // flag[i]가 true이면 num을 num * 2번 추가
            X.push(...Array(num * 2).fill(num));
        } else {
            // flag[i]가 false이면 X에서 num개의 원소 제거
            X.splice(-num, num);
        }
    });

    return X;
}

코드설명

1. 결과 배열 X 초기화

    const X = [];
   

   • 초기에는 빈 배열.

2. arr와 flag를 순회하며 처리

    arr.forEach((num, i) => { ... });
   

   • arr[i]의 값 num과 flag[i] 값을 가져와 처리.

3. flag[i]가 true일 경우

    X.push(...Array(num * 2).fill(num));
   

   • Array(num * 2).fill(num): 길이가 num * 2인 배열을 만들고, num 값으로 채움.
   • push(...Array(...)): 스프레드 연산자를 사용하여 배열을 X에 추가.

4. flag[i]가 false일 경우

    X.splice(-num, num);
   

   • splice(-num, num): 배열의 끝에서 num개의 원소를 제거.

5. 최종 결과 반환

    return X;
   

   • 모든 연산을 마친 후 배열 X를 반환.

배열의 원소만큼 추가하기

문제 설명

아무 원소도 들어있지 않은 빈 배열 X가 있습니다. 양의 정수 배열 arr가 매개변수로 주어질 때, arr의 앞에서부터 차례대로 원소를 보면서 원소가 a라면 X의 맨 뒤에 a를 a번 추가하는 일을 반복한 뒤의 배열 X를 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ arr의 길이 ≤ 100
• 1 ≤ arr의 원소 ≤ 100

입출력 예

입출력 예 설명

입출력 예 #1

• 예제 1번에 대해서 a와 X를 나타내보면 다음 표와 같습니다.

따라서 [5, 5, 5, 5, 5, 1, 4, 4, 4, 4]를 return 합니다.

입출력 예 #2

• 예제 2번에 대해서 a와 X를 나타내보면 다음 표와 같습니다.

따라서 [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6]를 return 합니다.

입출력 예 #3

• 예제 2번에 대해서 a와 X를 나타내보면 다음 표와 같습니다.

따라서 [1]을 return 합니다.

function solution(arr) {
    return arr.flatMap((num) => Array(num).fill(num));
}

코드설명

1. Array(num).fill(num):
   • Array(num)는 길이가 num인 빈 배열을 생성합니다.
   • .fill(num)은 배열의 모든 요소를 num으로 채웁니다.
   • 예: Array(5).fill(5) → [5, 5, 5, 5, 5].
2. flatMap 메서드:
   • flatMap은 각 배열 요소에 대해 콜백을 실행하여 반환된 배열을 평탄화(flatten)하여 하나의 배열로 만듭니다.
   • 예: [5, 1, 4].flatMap(...)에서 각 요소마다 배열을 생성하고 결과를 하나의 배열로 병합합니다.
   • 평탄화를 통해 중첩 배열 없이 원하는 결과를 바로 얻을 수 있습니다.
3. 결과 반환:
   • 각 요소를 필요한 만큼 배열에 추가하고, 병합된 최종 배열을 반환합니다.

세 개의 구분자

문제 설명

임의의 문자열이 주어졌을 때 문자 "a", "b", "c"를 구분자로 사용해 문자열을 나누고자 합니다.

예를 들어 주어진 문자열이 "baconlettucetomato"라면 나눠진 문자열 목록은 ["onlettu", "etom", "to"] 가 됩니다.

문자열 myStr이 주어졌을 때 위 예시와 같이 "a", "b", "c"를 사용해 나눠진 문자열을 순서대로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.

단, 두 구분자 사이에 다른 문자가 없을 경우에는 아무것도 저장하지 않으며, return할 배열이 빈 배열이라면 ["EMPTY"]를 return 합니다.

제한사항

• 1 ≤ myStr의 길이 ≤ 1,000,000
  • myStr은 알파벳 소문자로 이루어진 문자열 입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 설명의 예시와 같습니다.

입출력 예 #2

• "c" 이전에는 "a", "b", "c" 이외의 문자가 없습니다.
• "c" 이후에 문자열 "d"가 있으므로 "d"를 저장합니다.
• 따라서 ["d"]를 return 합니다.

입출력 예 #3

• "a", "b", "c" 이외의 문자가 존재하지 않습니다. 따라서 저장할 문자열이 없습니다.
• 따라서 ["EMPTY"]를 return 합니다.

function solution(myStr) {
   return myStr.match(/[^a-c]+/g) || ['EMPTY'];
}

console.log(solution("baconlettucetomato")); // ["onlettu", "etom", "to"]
console.log(solution("cabab")); // ["EMPTY"]

코드설명

1. 정규표현식 [^a-c]+:
   • [^a-c]:
     • a, b, c를 제외한 문자를 매칭합니다.
     • ^는 부정을 의미하며, 대괄호 안에서 사용하면 "해당 범위에 포함되지 않는 문자"를 나타냅니다.
   • +:
     • 한 번 이상 연속으로 나타나는 경우를 매칭합니다.
   • /[^a-c]+/g:
     • "a", "b", "c"가 아닌 문자들의 연속된 그룹을 모두 검색합니다(g 플래그: 전체 검색).
2. match 메서드:
   • myStr.match(/[^a-c]+/g)는 "a", "b", "c"가 아닌 연속된 문자열들을 배열로 반환합니다.
   • 매칭되는 항목이 없을 경우 null을 반환합니다.
3. || ['EMPTY']:
   • match가 null을 반환하면, 결과를 ['EMPTY']로 설정합니다.
   • 이를 통해 빈 배열 대신 "EMPTY" 문자열을 반환하도록 처리합니다.
4. 결과 반환:
   • 매칭된 문자열 배열을 반환하거나, 매칭되지 않는 경우 ['EMPTY']를 반환합니다.