Add solutions for Minimum Operations to Make Array Elements Zero in C++, Go, Python, Rust, and TypeScript

Author: trinhminhtriet

solutions/3400-3499/3495.minimum-operations-to-make-array-elements-zero/Solution.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    long long minOperations(vector<vector<int>>& queries) {
+        auto f = [&](long long x) {
+            long long res = 0;
+            long long p = 1;
+            int i = 1;
+            while (p <= x) {
+                long long cnt = min(p * 4 - 1, x) - p + 1;
+                res += cnt * i;
+                i++;
+                p *= 4;
+            }
+            return res;
+        };
+
+        long long ans = 0;
+        for (auto& q : queries) {
+            int l = q[0], r = q[1];
+            long long s = f(r) - f(l - 1);
+            long long mx = f(r) - f(r - 1);
+            ans += max((s + 1) / 2, mx);
+        }
+        return ans;
+    }
+};

solutions/3400-3499/3495.minimum-operations-to-make-array-elements-zero/Solution.go

@@ -0,0 +1,20 @@
+func minOperations(queries [][]int) (ans int64) {
+	f := func(x int64) (res int64) {
+		var p int64 = 1
+		i := int64(1)
+		for p <= x {
+			cnt := min(p*4-1, x) - p + 1
+			res += cnt * i
+			i++
+			p *= 4
+		}
+		return
+	}
+	for _, q := range queries {
+		l, r := int64(q[0]), int64(q[1])
+		s := f(r) - f(l-1)
+		mx := f(r) - f(r-1)
+		ans += max((s+1)/2, mx)
+	}
+	return
+}

solutions/3400-3499/3495.minimum-operations-to-make-array-elements-zero/Solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def minOperations(self, queries: List[List[int]]) -> int:
+        def f(x: int) -> int:
+            res = 0
+            p = i = 1
+            while p <= x:
+                cnt = min(p * 4 - 1, x) - p + 1
+                res += cnt * i
+                i += 1
+                p *= 4
+            return res
+
+        ans = 0
+        for l, r in queries:
+            s = f(r) - f(l - 1)
+            mx = f(r) - f(r - 1)
+            ans += max((s + 1) // 2, mx)
+        return ans

solutions/3400-3499/3495.minimum-operations-to-make-array-elements-zero/Solution.rs

@@ -0,0 +1,26 @@
+impl Solution {
+    pub fn min_operations(queries: Vec<Vec<i32>>) -> i64 {
+        let f = |x: i64| -> i64 {
+            let mut res: i64 = 0;
+            let mut p: i64 = 1;
+            let mut i: i64 = 1;
+            while p <= x {
+                let cnt = std::cmp::min(p * 4 - 1, x) - p + 1;
+                res += cnt * i;
+                i += 1;
+                p *= 4;
+            }
+            res
+        };
+
+        let mut ans: i64 = 0;
+        for q in queries {
+            let l = q[0] as i64;
+            let r = q[1] as i64;
+            let s = f(r) - f(l - 1);
+            let mx = f(r) - f(r - 1);
+            ans += std::cmp::max((s + 1) / 2, mx);
+        }
+        ans
+    }
+}

solutions/3400-3499/3495.minimum-operations-to-make-array-elements-zero/Solution.ts

@@ -0,0 +1,22 @@
+function minOperations(queries: number[][]): number {
+    const f = (x: number): number => {
+        let res = 0;
+        let p = 1;
+        let i = 1;
+        while (p <= x) {
+            const cnt = Math.min(p * 4 - 1, x) - p + 1;
+            res += cnt * i;
+            i++;
+            p *= 4;
+        }
+        return res;
+    };
+
+    let ans = 0;
+    for (const [l, r] of queries) {
+        const s = f(r) - f(l - 1);
+        const mx = f(r) - f(r - 1);
+        ans += Math.max(Math.ceil(s / 2), mx);
+    }
+    return ans;
+}