feat: leetcode contest 317

Author: upupming

leetcode/contest-317/6220. Average Value of Even Numbers That Are Divisible by Three.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const averageValue = function (nums) {
+  let sum = 0; let cnt = 0
+  for (const a of nums) {
+    if (a % 2 === 0 && a % 3 === 0) sum += a, cnt += 1
+  }
+  if (cnt === 0) return 0
+  return Math.floor(sum / cnt)
+}

leetcode/contest-317/6221. Most Popular Video Creator.js

@@ -0,0 +1,31 @@
+/**
+ * @param {string[]} creators
+ * @param {string[]} ids
+ * @param {number[]} views
+ * @return {string[][]}
+ */
+const mostPopularCreator = function (cs, is, vs) {
+  const n = cs.length; const cnt = {}; const by = {}
+  for (let i = 0; i < n; i++) {
+    if (cnt[cs[i]] == null) cnt[cs[i]] = 0
+    if (by[cs[i]] == null) by[cs[i]] = []
+    cnt[cs[i]] += vs[i]
+    by[cs[i]].push([is[i], vs[i]])
+  }
+  const hv = Math.max(...Object.values(cnt))
+  for (const x of Object.keys(by)) {
+    by[x].sort((a, b) => {
+      if (a[1] === b[1]) return a[0] < b[0] ? -1 : 1
+      return -(a[1] - b[1])
+    })
+  }
+  // console.log(JSON.stringify(by))
+  const ans = []; const has = {}
+  for (let i = 0; i < n; i++) {
+    if (cnt[cs[i]] === hv && !has[cs[i]]) {
+      ans.push([cs[i], by[cs[i]][0][0]])
+      has[cs[i]] = 1
+    }
+  }
+  return ans
+}

leetcode/contest-317/6222. Minimum Addition to Make Integer Beautiful.js

@@ -0,0 +1,21 @@
+/**
+ * @param {number} n
+ * @param {number} target
+ * @return {number}
+ */
+const makeIntegerBeautiful = function (n, target) {
+  const a = String(n).split('').map(Number)
+  const m = a.length
+  const sum = a.reduce((p, c) => p + c, 0)
+  if (sum <= target) return 0
+  let tmp = 0; let bs = 0
+  for (let i = 0; i < m; i++) {
+    const j = m - 1 - i
+    tmp += a[j] * Math.pow(10, i)
+    bs += a[j]
+    const t = Math.pow(10, i + 1)
+    if (sum - bs + 1 <= target) {
+      return t - tmp
+    }
+  }
+}

leetcode/contest-317/6223. Height of Binary Tree After Subtree Removal Queries.js

@@ -0,0 +1,55 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const treeQueries = function (root, queries) {
+  const map = {}
+
+  const num_ch = (node) => {
+    let cnt = 0
+    if (node.left) cnt++
+    if (node.right) cnt++
+    return cnt
+  }
+  const dfs = (node, p = null) => {
+    if (node == null) return
+    map[node.val] = node
+    if (p && num_ch(p) === 1) node.lp = p.lp, node.lpn = p.lpn + 1
+    else node.lp = node, node.lpn = 0
+    // console.log(node.val, node.lp?.val)
+    dfs(node.left, node)
+    dfs(node.right, node)
+    node.height = Math.max(node.left?.height ?? 0, node.right?.height ?? 0) + 1
+    node.parent = p
+  }
+  root.lp = root
+  root.lpn = 0
+  dfs(root)
+
+  const ans = []
+  for (const q of queries) {
+    let node = map[q].lp
+    node.newHeight = map[q].lpn
+    // console.log(node, node.newHeight)
+    while (node && node.parent) {
+      const p = node.parent
+      let sible = null
+      for (const x of [p.left, p.right]) if (x !== node) sible = x
+      p.newHeight = Math.max(node.newHeight, sible?.height ?? 0) + 1
+
+      // console.log(node.val, node.newHeight, sible?.val, sible?.height, p.val, p.newHeight)
+      node = p
+    }
+    ans.push(root.newHeight - 1)
+  }
+  return ans
+}

leetcode/残酷刷题/1735. Count Ways to Make Array With Product.js

@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const waysToFillArray = function (queries) {
+  const ans = []; const N = 1e4 + 15; const P = BigInt(1e9 + 7)
+  const c = Array(N).fill(0).map(() => Array(15).fill(0n))
+  const v = {}; const p = []
+  for (let i = 2; i <= N; i++) {
+    if (v[i]) continue
+    p.push(i)
+    for (let j = i; j <= N / i; j++) v[i * j] = 1
+  }
+  for (let i = 0; i < N; i++) {
+    c[i][0] = 1n
+    for (let j = 1; j <= Math.min(i, 14); j++) {
+      c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % P
+    }
+  }
+  for (let [n, k] of queries) {
+    let s = 1n
+    for (let i = 0; p[i] <= k; i++) {
+      let t = 0
+      while (k % p[i] === 0) t++, k /= p[i]
+      s = s * c[n + t - 1][t] % P
+    }
+    ans.push(Number(s))
+  }
+  return ans
+}

leetcode/残酷刷题/1819. Number of Different Subsequences GCDs.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countDifferentSubsequenceGCDs = function (nums) {
+  const g = []
+  const gcd = (a, b) => b ? gcd(b, a % b) : a
+  for (const x of nums) {
+    for (let y = 1; y <= Math.sqrt(x); y++) {
+      if (x % y === 0) {
+        if (g[y] == null) g[y] = x
+        else g[y] = gcd(g[y], x)
+        if (y != x / y) {
+          if (g[x / y] == null) g[x / y] = x
+          else g[x / y] = gcd(g[x / y], x)
+        }
+      }
+    }
+  }
+  let ans = 0
+  for (let i = 1; i <= 2e5; i++) {
+    if (g[i] == i) ans++
+  }
+  return ans
+}

leetcode/残酷刷题/204. Count Primes.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countPrimes = function (n) {
+  const seen = new Uint8Array(n); const p = []
+  for (let i = 2; i < n; i++) {
+    if (!seen[i]) p.push(i)
+    for (let j = 0; p[j] <= n / i; j++) {
+      seen[p[j] * i] = 1
+      if (i % p[j] === 0) break
+    }
+  }
+  return p.length
+}