feat: add solutions to lc problem: No.1769

solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/README.md

@@ -447,4 +447,62 @@ int* minOperations(char* boxes, int* returnSize) {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 3
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function minOperations(boxes: string): number[] {
+    const n = boxes.length;
+    const ans = Array(n).fill(0);
+    const ones: number[] = [];
+
+    for (let i = 0; i < n; i++) {
+        if (+boxes[i]) {
+            ones.push(i);
+        }
+    }
+
+    for (let i = 0; i < n; i++) {
+        for (const j of ones) {
+            ans[i] += Math.abs(i - j);
+        }
+    }
+
+    return ans;
+}
+```
+
+#### JavaScript
+
+```js
+function minOperations(boxes) {
+    const n = boxes.length;
+    const ans = Array(n).fill(0);
+    const ones = [];
+
+    for (let i = 0; i < n; i++) {
+        if (+boxes[i]) {
+            ones.push(i);
+        }
+    }
+
+    for (let i = 0; i < n; i++) {
+        for (const j of ones) {
+            ans[i] += Math.abs(i - j);
+        }
+    }
+
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/README_EN.md

@@ -439,4 +439,62 @@ int* minOperations(char* boxes, int* returnSize) {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 3
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function minOperations(boxes: string): number[] {
+    const n = boxes.length;
+    const ans = Array(n).fill(0);
+    const ones: number[] = [];
+
+    for (let i = 0; i < n; i++) {
+        if (+boxes[i]) {
+            ones.push(i);
+        }
+    }
+
+    for (let i = 0; i < n; i++) {
+        for (const j of ones) {
+            ans[i] += Math.abs(i - j);
+        }
+    }
+
+    return ans;
+}
+```
+
+#### JavaScript
+
+```js
+function minOperations(boxes) {
+    const n = boxes.length;
+    const ans = Array(n).fill(0);
+    const ones = [];
+
+    for (let i = 0; i < n; i++) {
+        if (+boxes[i]) {
+            ones.push(i);
+        }
+    }
+
+    for (let i = 0; i < n; i++) {
+        for (const j of ones) {
+            ans[i] += Math.abs(i - j);
+        }
+    }
+
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/Solution3.js

@@ -0,0 +1,19 @@
+function minOperations(boxes) {
+    const n = boxes.length;
+    const ans = Array(n).fill(0);
+    const ones = [];
+
+    for (let i = 0; i < n; i++) {
+        if (+boxes[i]) {
+            ones.push(i);
+        }
+    }
+
+    for (let i = 0; i < n; i++) {
+        for (const j of ones) {
+            ans[i] += Math.abs(i - j);
+        }
+    }
+
+    return ans;
+}

solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/Solution3.ts

@@ -0,0 +1,19 @@
+function minOperations(boxes: string): number[] {
+    const n = boxes.length;
+    const ans = Array(n).fill(0);
+    const ones: number[] = [];
+
+    for (let i = 0; i < n; i++) {
+        if (+boxes[i]) {
+            ones.push(i);
+        }
+    }
+
+    for (let i = 0; i < n; i++) {
+        for (const j of ones) {
+            ans[i] += Math.abs(i - j);
+        }
+    }
+
+    return ans;
+}

solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/README.md

@@ -183,7 +183,7 @@ class Solution {
 
     private int solve(int n, int m) {
         PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
-        pq.add(new int[]{n, n});
+        pq.add(new int[] {n, n});
         Set<Integer> visited = new HashSet<>();
 
         while (!pq.isEmpty()) {
@@ -207,7 +207,7 @@ class Solution {
                     s[i] = (char) (s[i] + 1);
                     int next = Integer.parseInt(new String(s));
                     if (!sieve[next] && !visited.contains(next)) {
-                        pq.add(new int[]{sum + next, next});
+                        pq.add(new int[] {sum + next, next});
                     }
                     s[i] = c;
                 }
@@ -216,7 +216,7 @@ class Solution {
                     s[i] = (char) (s[i] - 1);
                     int next = Integer.parseInt(new String(s));
                     if (!sieve[next] && !visited.contains(next)) {
-                        pq.add(new int[]{sum + next, next});
+                        pq.add(new int[] {sum + next, next});
                     }
                     s[i] = c;
                 }
@@ -286,6 +286,7 @@ private:
         }
         return -1;
     }
+
 public:
     int minOperations(int n, int m) {
         runSieve();

solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/README_EN.md

@@ -180,7 +180,7 @@ class Solution {
 
     private int solve(int n, int m) {
         PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
-        pq.add(new int[]{n, n});
+        pq.add(new int[] {n, n});
         Set<Integer> visited = new HashSet<>();
 
         while (!pq.isEmpty()) {
@@ -204,7 +204,7 @@ class Solution {
                     s[i] = (char) (s[i] + 1);
                     int next = Integer.parseInt(new String(s));
                     if (!sieve[next] && !visited.contains(next)) {
-                        pq.add(new int[]{sum + next, next});
+                        pq.add(new int[] {sum + next, next});
                     }
                     s[i] = c;
                 }
@@ -213,7 +213,7 @@ class Solution {
                     s[i] = (char) (s[i] - 1);
                     int next = Integer.parseInt(new String(s));
                     if (!sieve[next] && !visited.contains(next)) {
-                        pq.add(new int[]{sum + next, next});
+                        pq.add(new int[] {sum + next, next});
                     }
                     s[i] = c;
                 }
@@ -283,6 +283,7 @@ private:
         }
         return -1;
     }
+
 public:
     int minOperations(int n, int m) {
         runSieve();

solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/Solution.cpp

@@ -45,10 +45,11 @@ class Solution {
         }
         return -1;
     }
+
 public:
     int minOperations(int n, int m) {
         runSieve();
         if (sieve[n] || sieve[m]) return -1;
         return solve(n, m);
-    }   
+    }
 };

solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/Solution.java

@@ -17,7 +17,7 @@ private void runSieve() {
 
     private int solve(int n, int m) {
         PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
-        pq.add(new int[]{n, n});
+        pq.add(new int[] {n, n});
         Set<Integer> visited = new HashSet<>();
 
         while (!pq.isEmpty()) {
@@ -41,7 +41,7 @@ private int solve(int n, int m) {
                     s[i] = (char) (s[i] + 1);
                     int next = Integer.parseInt(new String(s));
                     if (!sieve[next] && !visited.contains(next)) {
-                        pq.add(new int[]{sum + next, next});
+                        pq.add(new int[] {sum + next, next});
                     }
                     s[i] = c;
                 }
@@ -50,7 +50,7 @@ private int solve(int n, int m) {
                     s[i] = (char) (s[i] - 1);
                     int next = Integer.parseInt(new String(s));
                     if (!sieve[next] && !visited.contains(next)) {
-                        pq.add(new int[]{sum + next, next});
+                        pq.add(new int[] {sum + next, next});
                     }
                     s[i] = c;
                 }