프로그래머스

참조한 페이지

프로그래머스

제일 작은 수 제거하기

나의 풀이

우선 길이가 1 이하인 경우 [-1]을 리턴하고 그렇지 않으면 두가지 방법이 있을 것같다.

작은 수를 찾기

1. for문을 돌면서 제일 작은 수를 넣은 배열을 하나 만들고 최종적으로 빼버리기
2. 배열에서 가장 작은 숫자를 찾은 뒤 그것만 제외해버리기

아마 2번이 더 빠를 것같다.

작은 수를 뺀 배열을 만들기

1. 배열에서 작은 수를 빼버리기
2. 작은 수만빼고 배열을 복제해버리기

아마 1번이 더 빠르겠지만 왠지 빈칸이 남을 것같다.

방법별로 속도 비교

// 작은수 1
function min1(numbers) {
  var answer = numbers[0];
  const length = numbers.length;

  for (let i = 0; i < length; i++) {
    if (answer > numbers[i]) {
      answer = numbers[i];
    }
  }

  return answer;
}

// 작은 수 2
function min2(numbers) {
  var answer = Math.min(...numbers);

  return answer;
}

의외로 for문을 돌리는게 빠르다. 혹시 ...을 쓴게 문제일까?

// 작은 수 3
function min3() {
  var answer = Math.min(1, 9, 3, 5);

  return answer;
}

async function qwe() {
  const startTime = new Date();
  for (let i = 0; i < 10000000; i++) {
    await min3();
  }
  const endTime = new Date();
  const executionTime = endTime - startTime;

  console.log(`min3 실행 시간: ${executionTime}ms`);
}

정답이었다. 역시 형변환같은게 중간에 끼어있다면 같은 형식이라도 느려질 수 밖에 없다. 하지만, 어떤 배열이 들어오든간에 작동해야하기 때문에 ...을 쓸 수 밖에 없을 듯하다.

// 빼기 1
function minus1(number) {
  const length = number.length;
  for (let i = 0; i < length; i++) {
    if (number[i] === 1) {
      number.splice(i, 1);
      i--;
    }
  }

  return number;
}

// 빼기 2
function minus2(number) {
  const number2 = number.filter((number) => number > 1);
  return number2;
}

filter를 사용하는 것보다 for문을 돌리는 것이 더 빠르다.

그럼 속도는 11 > 12 > 21 > 22 순이라고 생각할 수 있다.

실제로 조합해보자.

속도 비교

// 11
function sol11(number) {
  const length = number.length;

  if (length <= 1) {
    return [-1];
  }
  var small = number[0];

  for (let i = 0; i < length; i++) {
    if (small > number[i]) {
      small = number[i];
    }
  }

  for (let i = 0; i < length; i++) {
    if (number[i] === small) {
      number.splice(i, 1);
      i--;
    }
  }

  return number;
}

// 12
function sol12(number) {
  const length = number.length;

  if (length <= 1) {
    return [-1];
  }
  var small = number[0];

  for (let i = 0; i < length; i++) {
    if (small > number[i]) {
      small = number[i];
    }
  }

  const number2 = number.filter((number) => number > small);
  return number2;
}

// 21
function sol21(number) {
  const length = number.length;

  if (length <= 1) {
    return [-1];
  }
  var small = Math.min(...number);

  for (let i = 0; i < length; i++) {
    if (number[i] === small) {
      number.splice(i, 1);
      i--;
    }
  }

  return number;
}

// 22
function sol22(number) {
  const length = number.length;

  if (length <= 1) {
    return [-1];
  }
  var small = Math.min(...number);

  for (let i = 0; i < length; i++) {
    if (small > number[i]) {
      small = number[i];
    }
  }

  const number2 = number.filter((number) => number > small);
  return number2;
}

//////////////////////////////////////////////////////////

async function runSolutionWithTiming(solutionFn, number1, number2, number3) {
  const startTime = new Date();
  for (let i = 0; i < 10000000; i++) {
    await solutionFn(number1);
    await solutionFn(number2);
    await solutionFn(number3);
  }
  const endTime = new Date();
  const executionTime = endTime - startTime;

  console.log(`${solutionFn.name} 실행 시간: ${executionTime}ms`);
}

async function main() {
  const number1 = [1, 9, 3, 5];
  const number2 = [5];
  const number3 = [563, 99];

  await runSolutionWithTiming(sol11, number1, number2, number3);
  await runSolutionWithTiming(sol12, number1, number2, number3);
  await runSolutionWithTiming(sol21, number1, number2, number3);
  await runSolutionWithTiming(sol22, number1, number2, number3);
}

main()
  .then(() => {
    console.log("모든 실행이 완료되었습니다.");
  })
  .catch((error) => {
    console.error("에러 발생:", error);
  });

22 > 11 > 21 > 12 순이다?...

당연히 빠른거끼리 조합하는게 빠르게 나올줄 알았는데 의외이다.

참조한 페이지

[Javascript] 배열에서 최대값, 최소값 구하기
[JavaScript]배열의 요소를 삭제하는 방법
Array.prototype.filter()