Merge pull request codeisneverodd#98 from codeisneverodd/codeisneverodd

feat: 새로운 해설 4개 추가

Author: codeisneverodd

level-2/교점에-별-만들기.js

@@ -0,0 +1,43 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//더 좋은 풀이가 존재할 수 있습니다.
+//정답 1 - codeisneverodd
+function solution(line) {
+  const getCrossPoint = ([A, B, E], [C, D, F]) => {
+    if (A * D - B * C === 0) return [Infinity, Infinity];
+    return [(B * F - E * D) / (A * D - B * C), (E * C - A * F) / (A * D - B * C)];
+  }; //문제 설명 최하단 참조
+
+  const crossPoints = line.flatMap((lineA, i) =>
+    line
+      .slice(i + 1)
+      .map(lineB => getCrossPoint(lineA, lineB))
+      .filter(([x, y]) => Number.isInteger(x) && Number.isInteger(y))
+  );
+
+  const generateCanvas = crossPoints => {
+    const xPoints = [...crossPoints.map(([x, y]) => x)];
+    const yPoints = [...crossPoints.map(([x, y]) => y)];
+    const [minX, maxX] = [Math.min(...xPoints), Math.max(...xPoints)];
+    const [minY, maxY] = [Math.min(...yPoints), Math.max(...yPoints)];
+    const xLength = Math.abs(maxX - minX) + 1;
+    const yLength = Math.abs(maxY - minY) + 1;
+
+    return {
+      canvas: Array.from({ length: yLength }, () => Array(xLength).fill('.')),
+      draw([x, y], value) {
+        this.canvas[Math.abs(y - maxY)][Math.abs(x - minX)] = value;
+      },
+      print() {
+        return this.canvas.map(row => row.join(''));
+      },
+    };
+  };
+
+  const canvas = generateCanvas(crossPoints);
+
+  crossPoints.forEach(point => {
+    canvas.draw(point, '*');
+  });
+
+  return canvas.print();
+}

level-2/멀리-뛰기.js

@@ -1,6 +1,6 @@
 //https://github.com/codeisneverodd/programmers-coding-test
 //더 좋은 풀이가 존재할 수 있습니다.
-//정답 1 - codeisneveordd
+//정답 1 - codeisneverodd
 function solution(n) {
   if (n < 2) return 1;
   const count = [0, 1, 2, ...Array(n - 2).fill(0)];

level-2/방문-길이.js

@@ -0,0 +1,37 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//더 좋은 풀이가 존재할 수 있습니다.
+//정답 1 - codeisneverodd
+function solution(dirs) {
+  const move = ([x, y], dir) => {
+    let next = [x, y];
+    if (dir === 'U') next = [x, y + 1];
+    if (dir === 'D') next = [x, y - 1];
+    if (dir === 'R') next = [x + 1, y];
+    if (dir === 'L') next = [x - 1, y];
+    if (Math.abs(next[0]) > 5 || Math.abs(next[1]) > 5) return [x, y];
+    return next;
+  };
+
+  const isSameRoute = ([s1, e1], [s2, e2]) => {
+    const isSamePoint = ([x1, y1], [x2, y2]) => x1 === x2 && y1 === y2;
+    return (isSamePoint(s1, s2) && isSamePoint(e1, e2)) || (isSamePoint(s1, e2) && isSamePoint(s2, e1));
+  };
+
+  const trace = {
+    visited: [],
+    visit(start, end) {
+      if (start[0] === end[0] && start[1] === end[1]) return;
+      if (!this.visited.find(route => isSameRoute(route, [start, end]))) this.visited.push([start, end]);
+    },
+  };
+
+  let current = [0, 0];
+
+  dirs.split('').forEach(dir => {
+    const next = move(current, dir);
+    trace.visit(current, next);
+    current = next;
+  });
+
+  return trace.visited.length;
+}

level-2/전력망을-둘로-나누기.js

@@ -0,0 +1,29 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//더 좋은 풀이가 존재할 수 있습니다.
+//정답 1 - codeisneverodd
+function solution(n, wires) {
+  const hasOneOfWire = (tree, [a, b]) => tree.includes(a) || tree.includes(b);
+
+  const convertWiresToTree = wires => [...new Set(wires.flat())];
+
+  const generateTree = (wires, tree) => {
+    if (!wires.find(wire => hasOneOfWire(tree, wire))) return tree;
+
+    const nextWires = wires.filter(wire => !hasOneOfWire(tree, wire));
+    const nextTree = [...tree, ...convertWiresToTree(wires.filter(wire => hasOneOfWire(tree, wire)))];
+
+    return [...new Set(generateTree(nextWires, nextTree))];
+  };
+
+  let minDiff = Infinity;
+  const length = convertWiresToTree(wires).length;
+
+  wires.forEach((_, i) => {
+    const [initWire, ...remainWires] = wires.filter((_, j) => j !== i);
+    const lengthA = generateTree(remainWires, convertWiresToTree([initWire])).length;
+    const diff = Math.abs(lengthA - (length - lengthA));
+    minDiff = Math.min(diff, minDiff);
+  });
+
+  return minDiff;
+}

level-2/줄-서는-방법.js

@@ -0,0 +1,39 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//더 좋은 풀이가 존재할 수 있습니다.
+//정답 1 - codeisneverodd
+function solution(n, k) {
+  const getFactorial = n => {
+    const result = [1, 1, 2, ...Array(n - 2)];
+    result.forEach((_, i) => {
+      if (i > 2) result[i] = result[i - 1] * i;
+    });
+    return result;
+  };
+
+  const getDivision = (dividend, divisor) => {
+    const quotient = Math.floor(dividend / divisor);
+    const remainder = dividend % divisor;
+    return [quotient, remainder];
+  };
+
+  const stepCount = getFactorial(n).reverse();
+
+  const generateSteps = (k, step) => {
+    const [q, r] = getDivision(k, stepCount[step]);
+    if (r === 0) return [q];
+    return [q, ...generateSteps(r, step + 1)];
+  };
+
+  const answer = [];
+
+  const steps = generateSteps(k - 1, 0);
+
+  const notUsedNums = Array.from({ length: n }, (_, i) => i + 1);
+
+  steps.slice(1).forEach(q => {
+    answer.push(notUsedNums[q]);
+    notUsedNums.splice(q, 1);
+  });
+
+  return [...answer, ...notUsedNums];
+}