[JustDevRae] 25.02.22

JustDevRae/Graph/delivery.js

@@ -0,0 +1,33 @@
+function solution(N, road, K) {
+  const graph = Array.from({ length: N + 1 }, () => []);
+  for (const [a, b, c] of road) {
+    graph[a].push({ node: b, cost: c });
+    graph[b].push({ node: a, cost: c });
+  }
+
+  const distance = new Array(N + 1).fill(Infinity);
+  distance[1] = 0;
+
+  const visited = new Array(N + 1).fill(false);
+
+  for (let i = 1; i <= N; i++) {
+    let current = -1;
+
+    for (let j = 1; j <= N; j++) {
+      if (!visited[j] && (current === -1 || distance[j] < distance[current])) {
+        current = j;
+      }
+    }
+
+    if (current === -1) break;
+
+    visited[current] = true;
+
+    for (const { node, cost } of graph[current]) {
+      if (distance[node] > distance[current] + cost) {
+        distance[node] = distance[current] + cost;
+      }
+    }
+  }
+  return distance.filter((time) => time <= K).length;
+}

JustDevRae/Graph/find_if_path_exists_in_graph.js

@@ -0,0 +1,25 @@
+var validPath = function (n, edges, source, destination) {
+  const adjacencyList = new Array(n).fill(0).map(() => []);
+  for (const [nodeA, nodeB] of edges) {
+    adjacencyList[nodeA].push(nodeB);
+    adjacencyList[nodeB].push(nodeA);
+  }
+
+  const visitedNodes = new Array(n).fill(false);
+  const bfsQueue = [source];
+  visitedNodes[source] = true;
+
+  while (bfsQueue.length) {
+    const currentNode = bfsQueue.shift();
+    if (currentNode === destination) return true;
+
+    for (const adjacentNode of adjacencyList[currentNode]) {
+      if (!visitedNodes[adjacentNode]) {
+        visitedNodes[adjacentNode] = true;
+        bfsQueue.push(adjacentNode);
+      }
+    }
+  }
+
+  return false;
+};

JustDevRae/Graph/find_the_town_judge.js

@@ -0,0 +1,16 @@
+var findJudge = function (n, trust) {
+  if (n === 1) return 1;
+
+  const trustScore = new Array(n + 1).fill(0);
+
+  for (const [a, b] of trust) {
+    trustScore[a]--;
+    trustScore[b]++;
+  }
+
+  for (let i = 1; i <= n; i++) {
+    if (trustScore[i] === n - 1) return i;
+  }
+
+  return -1;
+};

JustDevRae/Graph/game_map_shortest_distance.js

@@ -0,0 +1,30 @@
+function solution(maps) {
+  const n = maps.length;
+  const m = maps[0].length;
+
+  const dx = [0, 0, 1, -1];
+  const dy = [1, -1, 0, 0];
+
+  let queue = [];
+  queue.push([0, 0]);
+
+  while (queue.length) {
+    const [y, x] = queue.shift();
+
+    if (y === n - 1 && x === m - 1) {
+      return maps[y][x];
+    }
+
+    for (let i = 0; i < 4; i++) {
+      const ny = y + dy[i];
+      const nx = x + dx[i];
+
+      if (ny >= 0 && ny < n && nx >= 0 && nx < m && maps[ny][nx] === 1) {
+        maps[ny][nx] = maps[y][x] + 1;
+        queue.push([ny, nx]);
+      }
+    }
+  }
+
+  return -1;
+}

JustDevRae/Graph/target_number.js

@@ -0,0 +1,17 @@
+function solution(numbers, target) {
+  let count = 0;
+
+  function DFS(index, currentSum) {
+    if (index === numbers.length) {
+      if (currentSum === target) count++;
+      return;
+    }
+
+    DFS(index + 1, currentSum + numbers[index]);
+    DFS(index + 1, currentSum - numbers[index]);
+  }
+
+  DFS(0, 0);
+
+  return count;
+}

JustDevRae/Hash/make_B_with_A.js

@@ -0,0 +1,21 @@
+function solution(before, after) {
+  var answer = 0;
+  const beforeCount = {};
+  const afterCount = {};
+
+  for (const char of before) {
+    beforeCount[char] = (beforeCount[char] || 0) + 1;
+  }
+
+  for (const char of after) {
+    afterCount[char] = (afterCount[char] || 0) + 1;
+  }
+
+  for (const key in beforeCount) {
+    if (beforeCount[key] !== afterCount[key]) {
+      return (answer = 0);
+    }
+  }
+
+  return (answer = 1);
+}

JustDevRae/Hash/morse_code.js

@@ -0,0 +1,37 @@
+function solution(letter) {
+  var answer = "";
+  const morse = {
+    ".-": "a",
+    "-...": "b",
+    "-.-.": "c",
+    "-..": "d",
+    ".": "e",
+    "..-.": "f",
+    "--.": "g",
+    "....": "h",
+    "..": "i",
+    ".---": "j",
+    "-.-": "k",
+    ".-..": "l",
+    "--": "m",
+    "-.": "n",
+    "---": "o",
+    ".--.": "p",
+    "--.-": "q",
+    ".-.": "r",
+    "...": "s",
+    "-": "t",
+    "..-": "u",
+    "...-": "v",
+    ".--": "w",
+    "-..-": "x",
+    "-.--": "y",
+    "--..": "z",
+  };
+  const str = letter.split(" ");
+
+  for (const s of str) {
+    answer += morse[s];
+  }
+  return answer;
+}

JustDevRae/Hash/not_finish_runner.js

@@ -0,0 +1,21 @@
+function solution(participant, completion) {
+  const obj = {};
+
+  for (const p of participant) {
+    if (obj[p]) {
+      obj[p] += 1;
+    } else {
+      obj[p] = 1;
+    }
+  }
+
+  for (const c of completion) {
+    obj[c] -= 1;
+  }
+
+  for (const key in obj) {
+    if (obj[key] > 0) {
+      return key;
+    }
+  }
+}

JustDevRae/Hash/rank_order.js

@@ -0,0 +1,6 @@
+function solution(score) {
+  const averages = score.map(([english, math]) => (english + math) / 2);
+  const sortedAverages = [...averages].sort((a, b) => b - a);
+
+  return averages.map((avg) => sortedAverages.indexOf(avg) + 1);
+}

JustDevRae/Hash/setting_order_care.js

@@ -0,0 +1,10 @@
+function solution(emergency) {
+  const sorted = [...emergency].sort((a, b) => b - a);
+  const rankMap = new Map();
+
+  sorted.forEach((value, index) => {
+    rankMap.set(value, index + 1);
+  });
+
+  return emergency.map((value) => rankMap.get(value));
+}

JustDevRae/Queue/card_bundle.js

@@ -0,0 +1,15 @@
+function solution(cards1, cards2, goal) {
+  var answer = "";
+  for (let word of goal) {
+    if (word == cards1[0]) {
+      cards1.shift();
+    } else if (word == cards2[0]) {
+      cards2.shift();
+    } else {
+      answer = "No";
+      break;
+    }
+  }
+
+  return (answer = "Yes");
+}

JustDevRae/Queue/find_point_position.js

@@ -0,0 +1,10 @@
+function solution(dot) {
+  var answer = 0;
+
+  if (dot[0] > 0 && dot[1] > 0) answer = 1;
+  if (dot[0] < 0 && dot[1] > 0) answer = 2;
+  if (dot[0] < 0 && dot[1] < 0) answer = 3;
+  if (dot[0] > 0 && dot[1] < 0) answer = 4;
+
+  return answer;
+}

JustDevRae/Queue/login_success.js

@@ -0,0 +1,16 @@
+function solution(id_pw, db) {
+  var answer = "";
+  for (let i = 0; i < db.length; i++) {
+    if (id_pw[0] === db[i][0]) {
+      if (id_pw[1] === db[i][1]) {
+        answer = "login";
+        break;
+      }
+      answer = "wrong pw";
+      break;
+    } else {
+      answer = "fail";
+    }
+  }
+  return answer;
+}

JustDevRae/Queue/make_hamburger.js

@@ -0,0 +1,20 @@
+function solution(ingredient) {
+  const burger = [];
+  let answer = 0;
+  for (let i of ingredient) {
+    burger.push(i);
+
+    if (
+      burger.length >= 4 &&
+      burger[burger.length - 4] === 1 &&
+      burger[burger.length - 3] === 2 &&
+      burger[burger.length - 2] === 3 &&
+      burger[burger.length - 1] === 1
+    ) {
+      burger.splice(burger.length - 4, 4);
+      answer++;
+    }
+  }
+
+  return answer;
+}

JustDevRae/Queue/pair_count.js

@@ -0,0 +1,13 @@
+function solution(n) {
+  var answer = 0;
+
+  // 1부터 n까지 숫자를 확인
+  for (let i = 1; i <= n; i++) {
+    // i가 n의 약수인지 확인
+    if (n % i === 0) {
+      // i가 n의 약수인지 확인
+      answer++;
+    }
+  }
+  return answer;
+}

JustDevRae/Queue/process.js

@@ -0,0 +1,20 @@
+function solution(priorities, location) {
+  var answer = 0;
+  const queue = priorities.map((priority, index) => ({ priority, index }));
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+
+    const highPriority = queue.some((item) => item.priority > current.priority);
+
+    if (highPriority) {
+      queue.push(current);
+    } else {
+      answer++;
+
+      if (current.index === location) {
+        return answer;
+      }
+    }
+  }
+}

JustDevRae/Set/contains_duplicate.js

@@ -0,0 +1,4 @@
+var containsDuplicate = function (nums) {
+  const numSet = new Set(nums);
+  return numSet.size !== nums.length;
+};

JustDevRae/Set/pick_random_k_numbers.js

@@ -0,0 +1,18 @@
+function solution(arr, k) {
+  const uniqueSet = new Set();
+  const result = [];
+
+  for (const num of arr) {
+    if (!uniqueSet.has(num)) {
+      uniqueSet.add(num);
+      result.push(num);
+    }
+    if (result.length === k) break;
+  }
+
+  while (result.length < k) {
+    result.push(-1);
+  }
+
+  return result;
+}

JustDevRae/Set/prime_factorization.js

@@ -0,0 +1,15 @@
+function solution(n) {
+  let result = [];
+  let divisor = 2;
+
+  while (n > 1) {
+    if (n % divisor === 0) {
+      result.push(divisor);
+      n /= divisor;
+    } else {
+      divisor++;
+    }
+  }
+
+  return [...new Set(result)];
+}

JustDevRae/Set/remove_duplicate_chars.js

@@ -0,0 +1,4 @@
+function solution(my_string) {
+  var answer = [...new Set(my_string)].join("");
+  return answer;
+}

JustDevRae/Set/unique_chars_only.js

@@ -0,0 +1,16 @@
+function solution(s) {
+  const charSet = new Set();
+  const duplicateSet = new Set();
+
+  for (const char of s) {
+    if (charSet.has(char)) {
+      duplicateSet.add(char);
+    } else {
+      charSet.add(char);
+    }
+  }
+
+  const uniqueChars = [...charSet].filter((char) => !duplicateSet.has(char));
+
+  return uniqueChars.sort().join("");
+}