코린이[코딩 어린이]

flat() 메서드

flat() 메서드는 모든 하위 배열 요소를 지정한 깊이까지 재귀적으로 이어붙인 새로운 배열을 생성합니다.

구문

const newArr = arr.flat([depth]);

매개변수

• depth: 중첩 배열 구조를 평탄화할 때 사용할 깊이 값입니다. [ 기본값 = 1 ]

반환 값

하위 배열을 이어붙인 새로운 배열입니다.

예제

중첩 배열 평탄화

const arr1 = [1, 2, [3, 4]];
arr1.flat(); // [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat(); // [1, 2, 3, 4, [5, 6]]

const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2); // [1, 2, 3, 4, 5, 6]

const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

배열 구멍 제거 ( flat() 메서드는 배열의 빈 공간도 제거해줍니다. )

const arr5 = [1, 2, , 4, 5];
arr5.flat(); // [1, 2, 4, 5]

숫자 찾기

문제 설명

function solution(num, k) {
    var answer = 0;

    let arr = num.toString().split("");

    let found = arr.findIndex(el => Number(el) === k)
    if (found > -1) found++;

    answer = found;
    return answer;
}

console.log(solution(29183, 1)); // 3
console.log(solution(232443, 4)); // 4
console.log(solution(123456, 7)); // -1

먼저 num 숫자를 toStirng 메서드로 string으로 바꾸고 split() 메서드로 배열로 만들어줍니다.

이 후, findIndex() 메서드로 k와 일치하는것이 없으면 -1을 일치하는게 있으면 자리 수를 넘겨줘야 하기 때문에 +1을 해서 넘겨줍니다.

findLastIndex() 메서드

findLastIndex() 메서드는 배열을 역순으로 반복하고 주어진 판별 함수를 만족하는 첫 번째 요소의 인덱스를 반환합니다.

만족하는 요소가 없으면 -1을 반환합니다.

구문

// Arrow function
findLastIndex((element) => { /* … */ })
findLastIndex((element, index) => { /* … */ })
findLastIndex((element, index, array) => { /* … */ })

// Callback function
findLastIndex(callbackFn)
findLastIndex(callbackFn, thisArg)

// Inline callback function
findLastIndex(function (element) { /* … */ })
findLastIndex(function (element, index) { /* … */ })
findLastIndex(function (element, index, array) { /* … */ })
findLastIndex(function (element, index, array) { /* … */ }, thisArg)

매개변수

• callback: 3개의 인수를 취해 배열의 각 값에 대해 실행할 함수입니다.
• element: 배열에서 처리중인 현재 요소입니다.
• index: 배열에서 처리중인 현재 요소의 인덱스입니다.
• array: findLastIndex 함수가 호출된 배열입니다.
• thisArg: 선택사항. 콜백을 실행할 때 this로 사용할 객체입니다.

반환 값

테스트를 통과한 배열의 첫 번째 요소의 인덱스를 반환합니다. ( 뒤에서 )

일치하는 요소가 없으면 -1을 반환합니다.

예제

역 배열에서 첫 번째 소수의 인덱스 찾기

let arr = [4, 6, 8, 12];
let arr1 = [4, 5, 6, 7, 8, 9, 10, 11, 12, 15];

const isPrime = (ele) => {
  if (ele % 2 === 0 || ele < 2) return false;

  for (let i = 3; i <= Math.sqrt(ele); i += 2) {
    if (ele % i === 0) return false;
  }

  return true;
}

console.log(arr.findLastIndex(isPrime)); // -1
console.log(arr1.findLastIndex(isPrime)); // 7

n의 배수 고르기

문제 설명

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

    answer = numlist.filter(num => num % n === 0);

    return answer;
}

console.log(solution(3, [4, 5, 6, 7, 8, 9, 10, 11, 12])); // [6, 9, 12]
console.log(solution(5, [1, 9, 3, 10, 13, 5])); // [10, 5]
console.log(solution(12, [2, 100, 120, 600, 12, 12])); // [120, 600, 12, 12]

filter() 메서드로 나머지가 0이 나오는 요소들로 새로운 배열을 만들어줍니다.

findLast() 메서드

findLast() 메서드는 배열을 역순으로 반복하고 제공된 테스트 기능을 만족하는 첫 번째 요소의 값을 반환합니다.

만족하는 테스트 기능의 요소가 없으면 undefined가 반환됩니다.

구문

// Arrow function
findLast((element) => { /* … */ })
findLast((element, index) => { /* … */ })
findLast((element, index, array) => { /* … */ })

// Callback function
findLast(callbackFn)
findLast(callbackFn, thisArg)

// Inline callback function
findLast(function (element) { /* … */ })
findLast(function (element, index) { /* … */ })
findLast(function (element, index, array) { /* … */ })
findLast(function (element, index, array) { /* … */ }, thisArg)

매개변수

• callbackFn: 배열의 각 요소에 대해 실행할 함수입니다.
• element: 배열에서 처리 중인 현재 요소입니다.
• index: 배열에서 처리 중인 현재 요소의 인덱스입니다.
• array: findLast 함수가 호출된 배열입니다.
• thisArg: this를 실행할 때 사용할 값 callbackFn입니다.

반환 값

제공된 테스트 기능을 만족하는 첫 번째 요소의 값을 반환합니다. ( 뒤에서 )

일치하는 값이 없는 경우에는 undefined를 반환합니다.

예제

역 배열에서 2보다 작은 첫번째 quantity 찾기 

const arr = [
  { name: "사과", quantity: 2 },
  { name: "바나나", quantity: 9 },
  { name: "감", quantity: 0 },
  { name: "체리", quantity: 1 },
  { name: "파인애플", quantity: 5 },
];

const isNotEnough = (item) => {
  return item.quantity < 2;
}

console.log(arr.findLast(isNotEnough)); // {name: '체리', quantity: 1}

findIndex() 메서드

findIndex() 메서드는 주어진 판별 함수를 만족하는 배열의 첫 번째 요소에 대한 인덱스를 반환합니다. 만족하는 요소가 없으면 -1을 반환합니다.

구문

arr.findIndex(callback(element[, index[, array]])[, thisArg]);

매개변수

• callback: 3개의 인수를 취해 배열의 각 값에 대해 실행할 함수입니다.
• element: 배열에서 처리중인 현재 요소입니다.
• index: 배열에서 처리중인 현재 요소의 인덱스입니다.
• array: findIndex 함수가 호출된 배열입니다.
• thisArg: 선택사항. 콜백을 실행할 때 this로 사용할 객체입니다.

반환 값

요소가 테스트를 통과하면 배열의 인덱스를 반환합니다. 그렇지 않으면 -1을 반환합니다.

예제

배열에서 소수의 색인 찾기

let arr = [4, 6, 8, 12];
let arr1 = [4, 6, 7, 22];

const isPrime = (ele, index, array) => {
  let start = 2;
  while (start <= Math.sqrt(ele)) {
    if (ele % start++ < 1) {
      return false;
    }
  }
  return ele > 1;
}

console.log(arr.findIndex(isPrime)); // -1
console.log(arr1.findIndex(isPrime)); // 2

Math.sqrt() 함수 : 숫자의 제곱근을 반환합니다.

ex ) Math.sqrt(9); // 3

자릿수 더하기

문제 설명

function solution(n) {
    var answer = 0;

    let arr = n.toString().split("");

    for (let i = 0; i < arr.length; i++) {
        answer = answer + Number(arr[i])
    }
    return answer;
}

console.log(solution(1234)); // 10
console.log(solution(930211)); // 16

n이라는 숫자를 toString() 메서드로 string으로 변경시켜준다음, split() 메서드로 한글자씩 배열로 만들어줍니다.

이 후, for문을 통해 answer에 숫자를 더해줍니다.

OX퀴즈

문제 설명

function solution(quiz) {
    var answer = [];


    for (let i = 0; i < quiz.length; i++) {
      let arr = quiz[i].split(" ");

      let x = Number(arr[0]);
      let y = Number(arr[2]);
      let z = Number(arr.at(-1));

      if (arr[1] === "-") {
        if (x - y === z) answer.push("O");
        else if (x - y !== z) answer.push("X");
      } else if (arr[1] === "+") {
        if (x + y === z) answer.push("O");
        else if (x + y !== z) answer.push("X");
      }
    }

    return answer;
}

console.log(solution(["3 - 4 = -3", "5 + 6 = 11"])); // ['X', 'O']
console.log(solution(["19 - 6 = 13", "5 + 66 = 71", "5 - 15 = 63", "3 - 1 = 2"])); // ['O', 'O', 'X', 'O']

연산 기호와 숫자 사이에 항상 공백이 존재한다고 했기 때문에 띄어쓰기마다 split() 메서드로 분리를 해줍니다.

그리고 수식의 형태가 X [연산자] Y = Z로 고정이기 때문에 배열의 0번 2번 마지막 배열을 숫자로 변경해 줍니다.

이후, 수식이 맞으면 "O"를 틀리면 "X"를 answer 배열에 넣어줍니다.

find() 메서드

find() 메서드는 주어진 판별 함수를 만족하는 첫 번째 요소의 값을 반환합니다. 만약 그런 요소가 없을 경우에는 undefined를 반환합니다.

구문

arr.find(callback[, thisArg]);

매개변수

• callback: 배열의 각 값에 대해 실행할 함수입니다. 아래 세 인자를 받습니다. 
• index: 콜백함수에서 처리할 현재 요소의 인덱스
• array: find 함수를 호출한 배열
• thisArg: 선택 항목. 콜백이 호출될 때 this로 사용할 객체

반환 값

주어진 판별 함수를 만족하는 첫 번째 요소의 값을 반환합니다. ( 그 외에는 undefined를 반환합니다. )

예제

10보다 큰 가장 첫 번째 요소 찾기

const arr = [5, 7, 1, 100, 130, 42];

const found = arr.find(el => el > 10);

console.log(found); // 100

속성 중 하나를 사용하여 배열에서 객체 찾기

const inventory = [
    { name: '사과', quantity: 2 },
    { name: '바나나', quantity: 0 },
    { name: '체리', quantity: 5 }
];

const result = inventory.find(fruit => fruit.name === '체리');

console.log(result) // { name: '체리', quantity: 5 }

크기가 작은 부분문자열

문제 설명

1번 ( 풀어쓰기 )

function solution(t, p) {
    var answer = 0;

    let arr = [];

    for (let i = 0; i < t.length; i++) {
        let newArray = t;
        if (newArray.slice(i, p.length + i).length !== p.length) break;
        arr.push(newArray.slice(i, p.length + i));
    }

    for (let i = 0; i < arr.length; i ++) {
        if (Number(arr[i]) <= p) answer++;
    }
    return answer;
}

console.log(solution("3141592", "271")); // 2
console.log(solution("500220839878", "7")); // 8
console.log(solution("10203", "15")); // 3

먼저 첫 번째 for문에서 arr 배열에 잘라준 숫자로 된 문자열을 넣어줍니다.

그리고 두 번째 for문에서 비교를 해줍니다.

2번 ( 줄이기 )

function solution(t, p) {
    var answer = 0;

    let arr = [];
    for (let i = 0; i < t.length; i++) {
        let newArray = t;

        if (newArray.slice(i, p.length + i).length === p.length) {
            if (Number(newArray.slice(i, p.length + i)) <= p) answer++;
        }
    }
    return answer;
}

console.log(solution("3141592", "271")); // 2
console.log(solution("500220839878", "7")); // 8
console.log(solution("10203", "15")); // 3