[moonjonghoo]25.02.27 (#51)

* 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 /기초

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

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

* 타겟_넘버 /중급

* N과_M(1) /기초

* N과_M(2) /기초

* 소수_찾기 /고급

* 부분수열의_합 /중급

* K번쨰수 /중급

* 가장_큰_수 / 심화

* H-index/심화

* 두_개_뽑아서_더하기 /중급

Author: Moonjonghoo

Moonjonghoo/backtracking/N과_M(1).js

@@ -0,0 +1,29 @@
+const fs = require("fs");
+const input = fs.readFileSync("example.txt").toString().split(" ").map(Number);
+const [N, M] = input;
+let arr = [];
+for (let i = 1; i <= N; i++) arr.push(i);
+let visited = new Array(N).fill(false);
+let selected = [];
+
+let answer = "";
+function backtrack(arr, depth) {
+  if (depth === M) {
+    let result = [];
+    for (let i of selected) result.push(arr[i]);
+    for (let x of result) answer += x + " ";
+    answer += "\n";
+    return;
+  }
+  for (let i = 0; i < arr.length; i++) {
+    if (visited[i]) continue;
+    selected.push(i);
+    visited[i] = true;
+    backtrack(arr, depth + 1);
+    selected.pop();
+    visited[i] = false;
+  }
+}
+backtrack(arr, 0);
+
+console.log(answer);

Moonjonghoo/backtracking/N과_M(2).js

@@ -0,0 +1,23 @@
+const fs = require("fs");
+const input = fs.readFileSync("example.txt").toString().split(" ").map(Number);
+const [N, M] = input;
+
+let selected = [];
+let answer = "";
+
+function backtrack(start, depth) {
+  if (depth === M) {
+    answer += selected.join(" ") + "\n";
+    return;
+  }
+
+  for (let i = start; i <= N; i++) {
+    // `start`부터 탐색하여 오름차순 조합 유지
+    selected.push(i);
+    backtrack(i + 1, depth + 1); // 다음 탐색은 `i + 1`부터
+    selected.pop(); // 백트래킹 (되돌아가기)
+  }
+}
+
+backtrack(1, 0);
+console.log(answer);

Moonjonghoo/backtracking/부분수열의_합.js

@@ -0,0 +1,27 @@
+const fs = require("fs");
+const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");
+
+const [N, S] = input[0].split(" ").map(Number);
+const numbers = input[1].split(" ").map(Number);
+
+let count = 0;
+
+function backtrack(index, sum) {
+  if (index === N) {
+    return;
+  }
+
+  sum += numbers[index];
+
+  if (sum === S) {
+    count++;
+  }
+
+  backtrack(index + 1, sum);
+
+  backtrack(index + 1, sum - numbers[index]);
+}
+
+backtrack(0, 0);
+
+console.log(count);

Moonjonghoo/backtracking/소수_찾기.js

@@ -0,0 +1,52 @@
+function isPrime(num) {
+  if (num === 0) return false;
+  if (num === 1) return false;
+  // 반복문 수행 횟수를 줄였다
+  for (let i = 2; i <= num / 2; i++) {
+    if (num % i === 0) return false;
+  }
+  return true;
+}
+
+const getPermutations = (arr, num) => {
+  const results = [];
+
+  if (num === 1) return arr.map((v) => [v]);
+
+  arr.forEach((fixed, index, origin) => {
+    const rest = [...origin.slice(0, index), ...origin.slice(index + 1)];
+
+    const permutations = getPermutations(rest, num - 1);
+
+    const attached = permutations.map((v) => [fixed, ...v]);
+
+    results.push(...attached);
+  });
+
+  return results;
+};
+
+function solution(numbers) {
+  let arr = numbers.split("");
+  let answer = [];
+  for (let i = 0; i < arr.length; i++) {
+    let combination = getPermutations(arr, i + 1);
+    for (let j = 0; j < combination.length; j++) {
+      let sum = "";
+
+      for (let k = 0; k < combination[j].length; k++) {
+        sum = sum + combination[j][k];
+      }
+      answer.push(Number(sum));
+    }
+  }
+  let a = new Set(answer);
+  let array = Array.from(a);
+  let count = 0;
+  for (let i = 0; i < array.length; i++) {
+    if (isPrime(array[i])) {
+      count++;
+    }
+  }
+  return count;
+}

Moonjonghoo/sort/H-index.js

@@ -0,0 +1,15 @@
+function solution(citations) {
+  // 인용 수를 내림차순으로 정렬
+  citations.sort((a, b) => b - a);
+
+  let h = 0;
+  // 논문 수와 인용 수 비교
+  for (let i = 0; i < citations.length; i++) {
+    if (citations[i] >= i + 1) {
+      h = i + 1;
+    } else {
+      break;
+    }
+  }
+  return h;
+}

Moonjonghoo/sort/K번쨰수.js

@@ -0,0 +1,14 @@
+function solution(array, commands) {
+    var answer = [];
+  
+    for (let i = 0; i < commands.length; i++) {
+      let newarr;
+      for (let j = 0; j < commands[i].length; j++) {
+        newarr = array
+          .slice(commands[i][0] - 1, commands[i][1])
+          .sort((a, b) => a - b);
+      }
+      answer.push(newarr[commands[i][2] - 1]);
+    }
+    return answer;
+  }

Moonjonghoo/sort/가장_큰_수.js

@@ -0,0 +1,10 @@
+//TODO: 풀어야됨 모르겠음
+function solution(numbers) {
+  let result = numbers
+    .map((num) => num.toString())
+    .sort((a, b) => b + a - (a + b))
+    .join("");
+  return result[0] === "0" ? "0" : result;
+}
+
+console.log(solution([6, 10, 2]));

Moonjonghoo/sort/두_개_뽑아서_더하기.js

@@ -0,0 +1,13 @@
+function solution(numbers) {
+  var answer = [];
+  for (let i = 0; i < numbers.length; i++) {
+    for (let j = i + 1; j < numbers.length; j++) {
+      answer.push(numbers[i] + numbers[j]);
+    }
+  }
+
+  return [...new Set(answer)].sort((a, b) => a - b);
+}
+
+console.log(solution([2, 1, 3, 4, 1]));
+console.log(solution([5, 0, 2, 7]));

example.txt

@@ -1,6 +1 @@
-4 5 1
-1 2
-1 3
-1 4
-2 4
-3 4
+