[moonjonghoo]25.02.20 (#48)

* String_Reversal / 기초

* control_z / 기초

* I_don't_like_English /기초

* String_Calculation / 기초

* Crane_Doll_Picking_Game / 중급

* 순서쌍의_개수 / 기초

* 점의_위치_구하기 / 기초

* 로그인_성공? / 기초

* 특이한_정렬 / 기초

* 프로세스 / 고급

* 프로세스 /고급 수정

* 모스부호(1) / 기초

* A로 B만들기 /기초

* 진료순서/ 기초

* 등수매기기 /기초

* 완주하지 못한 선수 /중급

* maximum_depth_of_binary_tree / 기초

* binary_tree_inorder_traversal /기초

* same_tree /기초

* Invert_Binary_tree/기초

* 중복된_문자_제거 /기초

* 한_번만_등장한_문자 /기초

* 소인수분해 /중급

* 무작위로_K개의_수_뽑기 / 기초

* contains_duplicate /기초

* intersection_of_two_array /기초

* count_the_number_of_consistent_strings /기초

* design_hashset/기초

* repeated_dna_sequences /중급

* longest_consecutive_sequence /중급

* DFS와_BFS /기초

* 전력망을_둘로_나누기 /심화

* 게임_맵_최단거리 /중급

* 타겟_넘버 /중급

Author: Moonjonghoo

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // IntelliSense를 사용하여 가능한 특성에 대해 알아보세요.
+    // 기존 특성에 대한 설명을 보려면 가리킵니다.
+    // 자세한 내용을 보려면 https://go.microsoft.com/fwlink/?linkid=830387을(를) 방문하세요.
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "chrome",
+            "request": "launch",
+            "name": "localhost에 대해 Chrome 시작",
+            "url": "http://localhost:8080",
+            "webRoot": "${workspaceFolder}"
+        }
+    ]
+}

Moonjonghoo/graph/DFS와_BFS.js

@@ -0,0 +1,35 @@
+const fs = require("fs");
+const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");
+
+const [N, M, V] = input[0].split(" ").map(Number);
+const edges = input.slice(1).map((line) => line.split(" ").map(Number));
+
+const graph = Array.from({ length: N + 1 }, () => []);
+edges.forEach(([a, b]) => {
+  graph[a].push(b);
+  graph[b].push(a);
+});
+graph.forEach((node) => node.sort((a, b) => a - b));
+
+const dfs = (v, visited = []) => {
+  if (visited.includes(v)) return;
+  visited.push(v);
+  graph[v].forEach((n) => dfs(n, visited));
+  return visited;
+};
+
+const bfs = (v) => {
+  let queue = [v],
+    visited = [];
+  while (queue.length) {
+    let node = queue.shift();
+    if (!visited.includes(node)) {
+      visited.push(node);
+      queue.push(...graph[node].filter((n) => !visited.includes(n)));
+    }
+  }
+  return visited;
+};
+
+console.log(dfs(V, []).join(" "));
+console.log(bfs(V).join(" "));

Moonjonghoo/graph/게임_맵_최단거리.js

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

Moonjonghoo/graph/전력망을_둘로_나누기.js

@@ -0,0 +1,48 @@
+function solution(n, wires) {
+  let answer = Infinity;
+
+  function dfs(graph, start, visited) {
+    visited[start] = true;
+    let count = 1;
+
+    for (let i = 0; i < graph[start].length; i++) {
+      const neighbor = graph[start][i];
+      if (!visited[neighbor]) {
+        count += dfs(graph, neighbor, visited);
+      }
+    }
+
+    return count;
+  }
+
+  for (let i = 0; i < n - 1; i++) {
+    const graph = Array(n)
+      .fill(null)
+      .map(() => []);
+    for (let j = 0; j < n - 1; j++) {
+      if (i === j) continue;
+      const [a, b] = wires[j];
+      graph[a - 1].push(b - 1);
+      graph[b - 1].push(a - 1);
+    }
+
+    const visited = Array(n).fill(false);
+    let count1 = 0;
+    let count2 = 0;
+
+    for (let j = 0; j < n; j++) {
+      if (!visited[j]) {
+        if (count1 === 0) {
+          count1 = dfs(graph, j, visited);
+        } else {
+          count2 = dfs(graph, j, visited);
+        }
+      }
+    }
+
+    const diff = Math.abs(count1 - count2);
+    answer = Math.min(answer, diff);
+  }
+
+  return answer;
+}

Moonjonghoo/graph/타겟_넘버.js

@@ -0,0 +1,25 @@
+function solution(numbers, target) {
+  let n = numbers.length;
+  let check = Array.from({ length: n }, () => false);
+  let answer = 0;
+  function DFS(v) {
+    if (v === n) {
+      let sum = 0;
+      for (let i = 0; i < n; i++) {
+        if (check[i] === true) {
+          sum += numbers[i];
+        } else if (check[i] === false) {
+          sum -= numbers[i];
+        }
+      }
+      if (sum === target) answer++;
+    } else {
+      check[v] = true;
+      DFS(v + 1);
+      check[v] = false;
+      DFS(v + 1);
+    }
+  }
+  DFS(0);
+  return answer;
+}

Moonjonghoo/set/Contains_Duplicate.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  let hash = new Set();
+  for (let i = 0; i < nums.length; i++) {
+    if (!hash.has(nums[i])) {
+      hash.add(nums[i]);
+    }
+  }
+  if (hash.size !== nums.length) return true;
+  else {
+    return false;
+  }
+};

Moonjonghoo/set/Intersection_of_two_arrays.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var intersection = function (nums1, nums2) {
+  let hash = new Set(nums2);
+  const intersectionSet = new Set([...nums1].filter((x) => hash.has(x)));
+  return [...intersectionSet];
+};
+
+console.log(intersection([1, 2, 2, 1], [2, 2]));

Moonjonghoo/set/count_the_number_of_consistent_strings.js

@@ -0,0 +1,21 @@
+/**
+ * @param {string} allowed
+ * @param {string[]} words
+ * @return {number}
+ */
+var countConsistentStrings = function (allowed, words) {
+  let hash = new Set(allowed.split(""));
+  let answer = words.length;
+  console.log(hash);
+  for (let i = 0; i < words.length; i++) {
+    for (let j = 0; j < words[i].length; j++) {
+      if (!hash.has(words[i][j])) {
+        answer--;
+        break;
+      }
+    }
+  }
+  return answer;
+};
+
+console.log(countConsistentStrings("ab", ["ad", "bd", "aaab", "baa", "badab"]));

Moonjonghoo/set/design_hashset.js

@@ -0,0 +1,40 @@
+var MyHashSet = function () {
+  this.data = [];
+};
+
+/**
+ * @param {number} key
+ * @return {void}
+ */
+MyHashSet.prototype.add = function (key) {
+  if (!this.data.includes(key)) {
+    this.data.push(key);
+  }
+};
+
+/**
+ * @param {number} key
+ * @return {void}
+ */
+MyHashSet.prototype.remove = function (key) {
+  this.data = this.data.filter((x) => x !== key);
+};
+
+/**
+ * @param {number} key
+ * @return {boolean}
+ */
+MyHashSet.prototype.contains = function (key) {
+  if (this.data.includes(key)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+
+let hash = new MyHashSet();
+hash.add(2);
+console.log(hash);
+console.log(hash.contains(2));
+hash.remove(2);
+console.log(hash);

Moonjonghoo/set/longest_consecutive_sequence.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function (nums) {
+  nums.sort((a, b) => a - b);
+  let count = 1;
+  let answer = 0;
+  let max = 0;
+  console.log(nums);
+  while (true) {
+    if (max === nums.length) return answer;
+    if (nums[max + 1] - 1 === nums[max]) {
+      max++;
+      count++;
+    } else {
+      max++;
+      answer = Math.max(answer, count);
+    }
+  }
+};
+
+console.log(longestConsecutive([9, 1, 4, 7, 3, -1, 0, 5, 8, -1, 6]));