230201(수)

type NumberArray = number[];

  const solution = (
    array: NumberArray,
    commands: NumberArray[],
  ): NumberArray => {
    return commands.map(
      (command) =>
        array.slice(command[0] - 1, command[1]).sort((a, b) => a - b)[
          command[2] - 1
        ],
    );
  };

function solution(array, commands) {
  let answer = [];
  for (let command of commands) {
    let arr = new Array(...array);
    let i = command[0];
    let j = command[1];
    let k = command[2];
    let tempArr = arr.splice(i - 1, j - i + 1);
    tempArr.sort((a,b) => a-b);
    let num = tempArr[k - 1];
    answer.push(num);
  }
  return answer;
}

type ChangeString = (word: string) => string;
  const changeOddCapital = (word: string): string => {
    return [...word]
      .map((l, i) => (i % 2 ? l.toLowerCase() : l.toUpperCase()))
      .join('');
  };

  const solutionCurrying =
    (fn: ChangeString) =>
    (s: string): string => {
      return s.split(' ').map(fn).join(' ');
    };

  const solution = solutionCurrying(changeOddCapital);

function solution(s) {
    let words = s.split(' ');
    const changeUpperLower = (word) => {
        let arrWord = [...word]
        for (let i = 0; i < arrWord.length; i++) {
            arrWord[i] = i % 2 === 0 ? arrWord[i].toUpperCase() : arrWord[i].toLowerCase();
        }
        return arrWord.join('');
    }
    return words.map((word) => changeUpperLower(word)).join(' ');
}

const solutionCurrying =
    (firstPattern: number[]) =>
    (secondPattern: number[]) =>
    (thirdPattern: number[]) =>
    (answers: number[]): number[] => {
      const scores = [
        answers.filter(
          (answer, i) => answer === firstPattern[i % firstPattern.length],
        ).length,
        answers.filter(
          (answer, i) => answer === secondPattern[i % secondPattern.length],
        ).length,
        answers.filter(
          (answer, i) => answer === thirdPattern[i % thirdPattern.length],
        ).length,
      ];
      const maxScore = Math.max(...scores);
      return scores
        .map((score, i) => (score === maxScore ? i + 1 : 0))
        .filter((score) => score);
    };

  let [firstPatterns, secondPatterns, thirdPatterns] = [
    [1, 2, 3, 4, 5],
    [2, 1, 2, 3, 2, 4, 2, 5],
    [3, 3, 1, 1, 2, 2, 4, 4, 5, 5],
  ];

  const solution =
    solutionCurrying(firstPatterns)(secondPatterns)(thirdPatterns);

function solution(answers) {
    const lengthAns = answers.length;
    const first = [1,2,3,4,5];
    const second = [2,1,2,3,2,4,2,5];
    const third = [3,3,1,1,2,2,4,4,5,5];
    const firstAns = new Array(Math.ceil(lengthAns / first.length)).fill(first).flat();
    const secondAns = new Array(Math.ceil(lengthAns / second.length)).fill(second).flat();
    const thirdAns = new Array(Math.ceil(lengthAns / third.length)).fill(third).flat();
    let countFirst = 0;
    let countSecond = 0;
    let countThird = 0;
    for (let i=0; i < lengthAns; i++) {
        if (answers[i] === firstAns[i]) {
            countFirst++;
        }
        if (answers[i] === secondAns[i]) {
            countSecond++;
        }
        if (answers[i] === thirdAns[i]) {
            countThird++;
        }
    }
    let answer = [];
    let temp = [countFirst, countSecond, countThird];
    let countMax = Math.max(...temp);
    for (let i = 0; i < 3; i++) {
        if (temp[i] === countMax) {
            answer.push(i+1)
        }
    }
    return answer;
    }

type NumberArray = number[];
  type NumberStack = (number | undefined)[];
  const solution = (board: NumberArray[], moves: NumberArray): number => {
    const stack: NumberStack = [];
    let count: number = 0;
    const machineStacks: NumberArray[] = new Array(board.length)
      .fill(0)
      .map((_, i) =>
        board.flat().filter((num, j) => num && j % board.length === i),
      );
    const pickedNums = moves
      .map((move) => {
        let picked = machineStacks[move - 1].shift();
        return picked ? picked : -1;
      })
      .filter((num) => num >= 0);
    pickedNums.forEach((pickedNum) => {
      let stackPick = stack.pop();
      stackPick === pickedNum ? count++ : stack.push(stackPick, pickedNum);
    });
    return count * 2;
  };

function solution(board, moves) {
    let answer = 0;
    const n = board.length;
    let basket = [];
    let moveToIndex = moves.map((move) => move - 1);

    for (let move of moveToIndex) {
        for (let i = 0; i < n; i++) {
            if (board[i][move]) {
                if (basket[basket.length - 1] === board[i][move]) {
                    basket.pop();
                    board[i][move] = 0;
                    answer += 2;
                    break;
                } else {
                basket.push(board[i][move]);
                board[i][move] = 0;
                break;
                }
            }
        }
    }

    return answer;
}