문자열 내림차순으로 배치하기

유니코드에서 대문자는 소문자보다 번호가 낮은데 아마 그래서 문제 조건도 이렇게 준것같다.

나의 풀이

이럴수가 왜 안되는거지?...

알고보니 sort 안에 (a,b) => b-a는 숫자에만 된다는듯하다.

function sol0(s) {
    var answer = [...s]

    answer = answer.sort().reverse()

    answer = answer.join("")
    return answer;
}

다른 사람의 풀이

// 다른 사람의 풀이1
function sol1(s) {
  return s
    .split("")
    .sort()
    .reverse()
    .join("");
}

펼침 연산자 ... 와 .split("") 중 어느게 더 빠른지 봐야겠다.

// 다른 사람의 풀이2
function sol2(s) {
    return s.split("").sort((a,b) => a<b ? 1:-1).join("")
}

// 다른 사람의 풀이3
function sol3(s) {
    return s.split('').sort((a, b) => {
        if (a > b) return -1;
        if (b > a) return 1;
        return 0;
    }).join('');
}

같은 코드인데 3항 연산자와 if문 중첩의 차이다. 과연 속도의 차이는 누구의 손을 들어줄것인가?

속도 비교

오늘 친구들은 다 $O(N)$ 복잡도이니 아마 부하량에 따른 차이는 안클것이다.

// 솔루션0
function sol0(s) {
  var answer = [...s];

  answer = answer.sort().reverse();

  answer = answer.join("");
  return answer;
}

// 솔루션1
function sol1(s) {
  return s.split("").sort().reverse().join("");
}

// 솔루션2
function sol2(s) {
  return s
    .split("")
    .sort((a, b) => (a < b ? 1 : -1))
    .join("");
}

// 솔루션3
function sol3(s) {
  return s
    .split("")
    .sort((a, b) => {
      if (a > b) return -1;
      if (b > a) return 1;
      return 0;
    })
    .join("");
}

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

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

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

async function main() {
  const a = "dljnsfXCVWEDfssdfaslkWEGXSDv";

  await runSolutionWithTiming(sol0, a);

  await runSolutionWithTiming(sol1, a);
  await runSolutionWithTiming(sol2, a);
  await runSolutionWithTiming(sol3, a);
}

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

↑ 기본 작동 시간
↓ 문자열을 10배로 늘린 경우

// 솔루션0
function sol0(s) {
  var answer = [...s];

  answer = answer.sort().reverse();

  answer = answer.join("");
  return answer;
}

function sol00(s) {
  var answer = s.split("");

  answer = answer.sort().reverse();

  answer = answer.join("");
  return answer;
}

내 방법이 sol1보다 느린 이유가 ...와 split("")의 차인가 싶어서 이것만 고쳐봤다.

공부하며 느낀 점

분명 내가 무언가 근본적으로 잘못 이해하고 있는듯하다.

내가 짠 코드를 sol1과 최대한 같게 만든 sol00은 sol1과 사실상 차이가 없는 코드이다.

하지만 sol1 보다 sol00 이 더 빠르다.

1백만회 반복으로 3세트, 심지어 부하량을 10배로 늘려서 한번더했는데도 결과가 같다면 진짜로 내 코드가 더 빠른게 맞을 것이다.

sol0은 answer를 여러번 재할당 하였다.
즉, 메모리에 값을 여러번 바꾼것이다.

반대로 sol1은 아마도 한번만(?) 썼을것인데 어째서 한번만 한게 더 빠르게 끝는 것일까?

컴퓨터도 한번에 여러개 하지말고 나눠하는게 더 효율적인 것일까? 좀 더 알아봐야겠다.

이유의 원인 진단.

1. Node.js v8엔진이 객체를 변수에저장하지 않고 사용하는 Chaining이 변수에 값을 담는 것보다 느리다.

2. sol00 과 sol1의 비교가 공정하지 못하다

2.의 경우 내가 최대한 똑같이 만들었다고 스스로 믿기 때문에 이유는 1.인것같다.