feat: add solutions to lc problems: No.2600~2603

yanglbme · yanglbme · commit aa1a6f664738 · 2023-04-03T23:20:28.000+08:00
* No.2600.K Items With the Maximum Sum
* No.2601.Prime Subtraction Operation
* No.2602.Minimum Operations to Make All Array Elements Equal
* No.2603.Collect Coins in a Tree
diff --git a/solution/2600-2699/2600.K Items With the Maximum Sum/README.md b/solution/2600-2699/2600.K Items With the Maximum Sum/README.md
@@ -135,6 +135,27 @@ func kItemsWithMaximumSum(numOnes int, numZeros int, numNegOnes int, k int) int
 }
 ```
 
+### **TypeScript**
+
+```ts
+function kItemsWithMaximumSum(
+    numOnes: number,
+    numZeros: number,
+    numNegOnes: number,
+    k: number,
+): number {
+    if (numOnes >= k) {
+        return k;
+    }
+    k -= numOnes;
+    if (numZeros >= k) {
+        return numOnes;
+    }
+    k -= numZeros;
+    return numOnes - k;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2600-2699/2600.K Items With the Maximum Sum/README_EN.md b/solution/2600-2699/2600.K Items With the Maximum Sum/README_EN.md
@@ -116,6 +116,27 @@ func kItemsWithMaximumSum(numOnes int, numZeros int, numNegOnes int, k int) int
 }
 ```
 
+### **TypeScript**
+
+```ts
+function kItemsWithMaximumSum(
+    numOnes: number,
+    numZeros: number,
+    numNegOnes: number,
+    k: number,
+): number {
+    if (numOnes >= k) {
+        return k;
+    }
+    k -= numOnes;
+    if (numZeros >= k) {
+        return numOnes;
+    }
+    k -= numZeros;
+    return numOnes - k;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2600-2699/2600.K Items With the Maximum Sum/Solution.ts b/solution/2600-2699/2600.K Items With the Maximum Sum/Solution.ts
@@ -0,0 +1,16 @@
+function kItemsWithMaximumSum(
+    numOnes: number,
+    numZeros: number,
+    numNegOnes: number,
+    k: number,
+): number {
+    if (numOnes >= k) {
+        return k;
+    }
+    k -= numOnes;
+    if (numZeros >= k) {
+        return numOnes;
+    }
+    k -= numZeros;
+    return numOnes - k;
+}
diff --git a/solution/2600-2699/2601.Prime Subtraction Operation/README.md b/solution/2600-2699/2601.Prime Subtraction Operation/README.md
@@ -211,6 +211,51 @@ func primeSubOperation(nums []int) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function primeSubOperation(nums: number[]): boolean {
+    const p: number[] = [];
+    for (let i = 2; i <= 1000; ++i) {
+        let ok = true;
+        for (const j of p) {
+            if (i % j === 0) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok) {
+            p.push(i);
+        }
+    }
+    const search = (x: number): number => {
+        let l = 0;
+        let r = p.length;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (p[mid] > x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    const n = nums.length;
+    for (let i = n - 2; i >= 0; --i) {
+        if (nums[i] < nums[i + 1]) {
+            continue;
+        }
+        const j = search(nums[i] - nums[i + 1]);
+        if (j === p.length || p[j] >= nums[i]) {
+            return false;
+        }
+        nums[i] -= p[j];
+    }
+    return true;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2600-2699/2601.Prime Subtraction Operation/README_EN.md b/solution/2600-2699/2601.Prime Subtraction Operation/README_EN.md
@@ -190,6 +190,51 @@ func primeSubOperation(nums []int) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function primeSubOperation(nums: number[]): boolean {
+    const p: number[] = [];
+    for (let i = 2; i <= 1000; ++i) {
+        let ok = true;
+        for (const j of p) {
+            if (i % j === 0) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok) {
+            p.push(i);
+        }
+    }
+    const search = (x: number): number => {
+        let l = 0;
+        let r = p.length;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (p[mid] > x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    const n = nums.length;
+    for (let i = n - 2; i >= 0; --i) {
+        if (nums[i] < nums[i + 1]) {
+            continue;
+        }
+        const j = search(nums[i] - nums[i + 1]);
+        if (j === p.length || p[j] >= nums[i]) {
+            return false;
+        }
+        nums[i] -= p[j];
+    }
+    return true;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2600-2699/2601.Prime Subtraction Operation/Solution.ts b/solution/2600-2699/2601.Prime Subtraction Operation/Solution.ts
@@ -0,0 +1,40 @@
+function primeSubOperation(nums: number[]): boolean {
+    const p: number[] = [];
+    for (let i = 2; i <= 1000; ++i) {
+        let ok = true;
+        for (const j of p) {
+            if (i % j === 0) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok) {
+            p.push(i);
+        }
+    }
+    const search = (x: number): number => {
+        let l = 0;
+        let r = p.length;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (p[mid] > x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    const n = nums.length;
+    for (let i = n - 2; i >= 0; --i) {
+        if (nums[i] < nums[i + 1]) {
+            continue;
+        }
+        const j = search(nums[i] - nums[i + 1]);
+        if (j === p.length || p[j] >= nums[i]) {
+            return false;
+        }
+        nums[i] -= p[j];
+    }
+    return true;
+}
diff --git a/solution/2600-2699/2602.Minimum Operations to Make All Array Elements Equal/README.md b/solution/2600-2699/2602.Minimum Operations to Make All Array Elements Equal/README.md
@@ -179,6 +179,41 @@ func minOperations(nums []int, queries []int) (ans []int64) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minOperations(nums: number[], queries: number[]): number[] {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const s: number[] = new Array(n + 1).fill(0);
+    for (let i = 0; i < n; ++i) {
+        s[i + 1] = s[i] + nums[i];
+    }
+    const search = (x: number): number => {
+        let l = 0;
+        let r = n;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (nums[mid] >= x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    const ans: number[] = [];
+    for (const x of queries) {
+        const i = search(x + 1);
+        let t = s[n] - s[i] - (n - i) * x;
+        const j = search(x);
+        t += x * j - s[j];
+        ans.push(t);
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2600-2699/2602.Minimum Operations to Make All Array Elements Equal/README_EN.md b/solution/2600-2699/2602.Minimum Operations to Make All Array Elements Equal/README_EN.md
@@ -157,6 +157,41 @@ func minOperations(nums []int, queries []int) (ans []int64) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minOperations(nums: number[], queries: number[]): number[] {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const s: number[] = new Array(n + 1).fill(0);
+    for (let i = 0; i < n; ++i) {
+        s[i + 1] = s[i] + nums[i];
+    }
+    const search = (x: number): number => {
+        let l = 0;
+        let r = n;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (nums[mid] >= x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    const ans: number[] = [];
+    for (const x of queries) {
+        const i = search(x + 1);
+        let t = s[n] - s[i] - (n - i) * x;
+        const j = search(x);
+        t += x * j - s[j];
+        ans.push(t);
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2600-2699/2602.Minimum Operations to Make All Array Elements Equal/Solution.ts b/solution/2600-2699/2602.Minimum Operations to Make All Array Elements Equal/Solution.ts
@@ -0,0 +1,30 @@
+function minOperations(nums: number[], queries: number[]): number[] {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const s: number[] = new Array(n + 1).fill(0);
+    for (let i = 0; i < n; ++i) {
+        s[i + 1] = s[i] + nums[i];
+    }
+    const search = (x: number): number => {
+        let l = 0;
+        let r = n;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (nums[mid] >= x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    const ans: number[] = [];
+    for (const x of queries) {
+        const i = search(x + 1);
+        let t = s[n] - s[i] - (n - i) * x;
+        const j = search(x);
+        t += x * j - s[j];
+        ans.push(t);
+    }
+    return ans;
+}
diff --git a/solution/2600-2699/2603.Collect Coins in a Tree/README.md b/solution/2600-2699/2603.Collect Coins in a Tree/README.md
@@ -272,6 +272,56 @@ func collectTheCoins(coins []int, edges [][]int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function collectTheCoins(coins: number[], edges: number[][]): number {
+    const n = coins.length;
+    const g: Set<number>[] = new Array(n).fill(0).map(() => new Set<number>());
+    for (const [a, b] of edges) {
+        g[a].add(b);
+        g[b].add(a);
+    }
+    let q: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        if (coins[i] === 0 && g[i].size === 1) {
+            q.push(i);
+        }
+    }
+    while (q.length) {
+        const i = q.pop()!;
+        for (const j of g[i]) {
+            g[j].delete(i);
+            if (coins[j] === 0 && g[j].size === 1) {
+                q.push(j);
+            }
+        }
+        g[i].clear();
+    }
+    q = [];
+    for (let k = 0; k < 2; ++k) {
+        for (let i = 0; i < n; ++i) {
+            if (g[i].size === 1) {
+                q.push(i);
+            }
+        }
+        for (const i of q) {
+            for (const j of g[i]) {
+                g[j].delete(i);
+            }
+            g[i].clear();
+        }
+    }
+    let ans = 0;
+    for (const [a, b] of edges) {
+        if (g[a].size > 0 && g[b].size > 0) {
+            ans += 2;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2600-2699/2603.Collect Coins in a Tree/README_EN.md b/solution/2600-2699/2603.Collect Coins in a Tree/README_EN.md
diff --git a/solution/2600-2699/2603.Collect Coins in a Tree/Solution.ts b/solution/2600-2699/2603.Collect Coins in a Tree/Solution.ts
