feat: add solutions to lc problem: No.3495

Author: yanglbme

solution/3400-3499/3495.Minimum Operations to Make Array Elements Zero/README.md

@@ -110,25 +110,137 @@ tags:
 #### Python3
 
 ```python
-
+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
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long minOperations(int[][] queries) {
+        long ans = 0;
+        for (int[] q : queries) {
+            int l = q[0], r = q[1];
+            long s = f(r) - f(l - 1);
+            long mx = f(r) - f(r - 1);
+            ans += Math.max((s + 1) / 2, mx);
+        }
+        return ans;
+    }
+
+    private long f(long x) {
+        long res = 0;
+        long p = 1;
+        int i = 1;
+        while (p <= x) {
+            long cnt = Math.min(p * 4 - 1, x) - p + 1;
+            res += cnt * i;
+            i++;
+            p *= 4;
+        }
+        return res;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+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;
+    }
+};
 ```
 
 #### Go
 
 ```go
+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
+}
+```
 
+#### TypeScript
+
+```ts
+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;
+}
 ```
 
 <!-- tabs:end -->

solution/3400-3499/3495.Minimum Operations to Make Array Elements Zero/README_EN.md

@@ -107,25 +107,137 @@ tags:
 #### Python3
 
 ```python
-
+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
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long minOperations(int[][] queries) {
+        long ans = 0;
+        for (int[] q : queries) {
+            int l = q[0], r = q[1];
+            long s = f(r) - f(l - 1);
+            long mx = f(r) - f(r - 1);
+            ans += Math.max((s + 1) / 2, mx);
+        }
+        return ans;
+    }
+
+    private long f(long x) {
+        long res = 0;
+        long p = 1;
+        int i = 1;
+        while (p <= x) {
+            long cnt = Math.min(p * 4 - 1, x) - p + 1;
+            res += cnt * i;
+            i++;
+            p *= 4;
+        }
+        return res;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+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;
+    }
+};
 ```
 
 #### Go
 
 ```go
+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
+}
+```
 
+#### TypeScript
+
+```ts
+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;
+}
 ```
 
 <!-- tabs:end -->

solution/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;
+    }
+};

solution/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
+}

solution/3400-3499/3495.Minimum Operations to Make Array Elements Zero/Solution.java

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

solution/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

solution/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;
+}