최주은 / 16주차

jueun/week16/1654.js

@@ -0,0 +1,51 @@
+// const input = require("fs")
+//   .readFileSync("/dev/stdin")
+//   .toString()
+//   .trim()
+//   .split("\n");
+
+const input = ["4 11", "802", "743", "457", "539"];
+// const input = ["1 1", "5"];
+
+const [[K, N], lanLines] = [
+  input[0].split(" ").map(BigInt),
+  input.slice(1).map(BigInt),
+];
+
+const solution = (lanLines, n) => {
+  let mid = bigIntMax(...lanLines);
+  let low = 0n,
+    high = mid;
+  let newMid;
+  let maxLength = 0n;
+  let nowCount;
+
+  while (true) {
+    nowCount = getNowCount(lanLines, mid);
+
+    if (nowCount < n) {
+      high = mid;
+    } else if (nowCount >= n) {
+      low = mid;
+      maxLength = bigIntMax(maxLength, mid);
+    }
+
+    newMid = BigInt(BigInt(low) + BigInt(high)) / 2n;
+
+    if (newMid === mid || newMid === low || newMid === high) break;
+    mid = newMid;
+  }
+
+  return maxLength;
+};
+
+const bigIntMin = (...args) =>
+  args.reduce((prev, cur) => (cur < prev ? cur : prev));
+
+const bigIntMax = (...args) =>
+  args.reduce((prev, cur) => (cur > prev ? cur : prev));
+
+const getNowCount = (lanLines, mid) =>
+  lanLines.reduce((prev, cur) => prev + cur / mid, 0n);
+
+console.log(String(solution(lanLines, N)));

jueun/week16/19637.js

@@ -0,0 +1,54 @@
+// const input = require("fs")
+//   .readFileSync("/dev/stdin")
+//   .toString()
+//   .trim()
+//   .split("\n");
+
+const input = [
+  "3 8",
+  "WEAK 10000",
+  "NORMAL 100000",
+  "STRONG 1000000",
+  "0",
+  "9999",
+  "10000",
+  "10001",
+  "50000",
+  "100000",
+  "500000",
+  "1000000",
+];
+
+const [N, M] = input[0].split(" ").map(Number);
+const [ranges, numbers] = [
+  input
+    .slice(1, N + 1)
+    .map((el) => el.split(" ").map((e) => (isNaN(e) ? e : +e))),
+  input.slice(N + 1).map(Number),
+];
+
+const solution = (n, m, ranges, numbers) => {
+  let answer = "";
+  for (let i = 0; i < m; i++) {
+    answer += ranges[findRangeIdx(numbers[i], n, ranges)][0] + "\n";
+  }
+  return answer;
+};
+
+const findRangeIdx = (target, n, ranges) => {
+  let mid = 0,
+    low = 0,
+    high = n - 1;
+  while (low <= high) {
+    mid = Math.floor((low + high) / 2);
+    if (target <= ranges[mid][1]) {
+      high = mid - 1;
+    } else {
+      low = mid + 1;
+    }
+  }
+  if (target > ranges[mid][1]) return mid + 1;
+  else return mid;
+};
+
+console.log(solution(N, M, ranges, numbers));

jueun/week16/2512.js

@@ -0,0 +1,46 @@
+// const input = require("fs")
+//   .readFileSync("/dev/stdin")
+//   .toString()
+//   .trim()
+//   .split("\n")
+
+// const input = ["4", "120 110 140 150", "485"];
+const input = ["5", "70 80 30 40 100", "450"];
+
+const [N, requests, M] = [
+  +input[0],
+  input[1].split(" ").map(Number),
+  +input[2],
+];
+
+const solution = (requests, m) => {
+  let mid = Math.max(...requests);
+  let newMid;
+  let high = mid,
+    low = 0;
+  let sum,
+    maxSum = 0;
+
+  while (true) {
+    sum = requests.reduce((prev, cur) => {
+      if (cur > mid) return prev + mid;
+      else return prev + cur;
+    }, 0);
+
+    if (sum > m) {
+      high = mid;
+    } else if (sum < m) {
+      low = mid;
+      maxSum = Math.max(sum, maxSum);
+    } else {
+      break;
+    }
+    newMid = Math.floor((low + high) / 2);
+    if (newMid === mid) break;
+    else mid = newMid;
+  }
+
+  return mid;
+};
+
+console.log(solution(requests, M));

jueun/week16/2805.js

@@ -0,0 +1,46 @@
+// const input = require("fs")
+//   .readFileSync("/dev/stdin")
+//   .toString()
+//   .trim()
+//   .split("\n")
+
+// const input = ["4 7", "20 15 10 17"];
+const input = ["5 20", "4 42 40 26 46"];
+
+const [[N, M], trees] = [
+  input[0].split(" ").map(Number),
+  input[1].split(" ").map(Number),
+];
+
+const solution = (trees, m) => {
+  const treeSum = trees.reduce((prev, cur) => prev + cur) - m;
+  let mid = Math.max(...trees);
+  let newMid;
+  let high = mid,
+    low = 0;
+  let sum,
+    maxSum = 0;
+
+  while (true) {
+    sum = trees.reduce((prev, cur) => {
+      if (cur > mid) return prev + mid;
+      else return prev + cur;
+    }, 0);
+
+    if (sum > treeSum) {
+      high = mid;
+    } else if (sum < treeSum) {
+      low = mid;
+      maxSum = Math.max(sum, maxSum);
+    } else {
+      break;
+    }
+    newMid = Math.floor((low + high) / 2);
+    if (newMid === mid) break;
+    else mid = newMid;
+  }
+
+  return mid;
+};
+
+console.log(solution(trees, M));

jueun/week16/6236.js

@@ -0,0 +1,49 @@
+// const input = require("fs")
+//   .readFileSync("/dev/stdin")
+//   .toString()
+//   .trim()
+//   .split("\n");
+
+const input = ["7 5", "100", "400", "300", "100", "500", "101", "400"];
+
+const [[N, M], moneys] = [
+  input[0].split(" ").map(Number),
+  input.slice(1).map(Number),
+];
+
+const solution = (n, m, moneys) => {
+  let minMoney = moneys.reduce((prev, cur) => prev + cur);
+  let low = Math.max(...moneys),
+    high = minMoney;
+  let mid = high;
+  let count;
+
+  while (low <= high) {
+    count = getCount(n, mid, moneys);
+
+    if (count > m) {
+      low = mid + 1;
+    } else {
+      minMoney = mid;
+      high = mid - 1;
+    }
+    mid = Math.floor((low + high) / 2);
+  }
+
+  return minMoney;
+};
+
+const getCount = (n, mid, moneys) => {
+  let count = 0,
+    remain = 0;
+
+  for (let i = 0; i < n; i++) {
+    if (remain < moneys[i]) {
+      count++;
+      remain = mid - moneys[i];
+    } else remain -= moneys[i];
+  }
+  return count++;
+};
+
+console.log(solution(N, M, moneys));

jueun/week17/2468.js

@@ -0,0 +1,52 @@
+const fs = require("fs");
+const input = fs
+  .readFileSync(
+    process.platform === "linux" ? "/dev/stdin" : __dirname + "/2468.txt"
+  )
+  .toString()
+  .split("\n")
+  .map((el) => el.split(" ").map(Number));
+
+const N = input[0][0];
+const map = input.slice(1);
+
+const solution = (n, map) => {
+  let maxCount = 0;
+
+  let visited = new Array(n);
+  for (let i = 0; i < n; i++) visited[i] = new Array(n).fill(false);
+
+  const dfs = (i, j, height) => {
+    visited[i][j] = true;
+    if (map[i - 1]?.[j] >= height && !visited[i - 1]?.[j])
+      dfs(i - 1, j, height);
+    if (map[i + 1]?.[j] >= height && !visited[i + 1]?.[j])
+      dfs(i + 1, j, height);
+    if (map[i]?.[j - 1] >= height && !visited[i]?.[j - 1])
+      dfs(i, j - 1, height);
+    if (map[i]?.[j + 1] >= height && !visited[i]?.[j + 1])
+      dfs(i, j + 1, height);
+  };
+
+  let count;
+  for (let rainfall = 1; rainfall <= 100; rainfall++) {
+    count = 0;
+    visited = new Array(n);
+    for (let i = 0; i < n; i++) visited[i] = new Array(n).fill(false);
+
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        if (map[i][j] >= rainfall && !visited[i][j]) {
+          dfs(i, j, rainfall);
+          count++;
+        }
+      }
+    }
+    maxCount = Math.max(maxCount, count);
+    if (count === 0) break;
+  }
+
+  return maxCount;
+};
+
+console.log(solution(N, map));