feat: add solutions to lc problem: No.1769 (#3934)

rain84 · web-flow · commit 64a85143f984 · 2025-01-07T07:51:20.000+08:00
diff --git a/solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/README.md b/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 -->
diff --git a/solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/README_EN.md b/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 -->
diff --git a/solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/Solution3.js b/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;
+}
diff --git a/solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/Solution3.ts b/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;
+}
diff --git a/solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/README.md b/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();
diff --git a/solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/README_EN.md b/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();
diff --git a/solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/Solution.cpp b/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);
-    }   
+    }
 };
diff --git a/solution/3300-3399/3377.Digit Operations to Make Two Integers Equal/Solution.java b/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;
                 }

Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ class Solution {`
`183`	`183`
`184`	`184`	`private int solve(int n, int m) {`
`185`	`185`	`PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));`
`186`		`- pq.add(new int[]{n, n});`
	`186`	`+ pq.add(new int[] {n, n});`
`187`	`187`	`Set<Integer> visited = new HashSet<>();`
`188`	`188`
`189`	`189`	`while (!pq.isEmpty()) {`
`@@ -207,7 +207,7 @@ class Solution {`
`207`	`207`	`s[i] = (char) (s[i] + 1);`
`208`	`208`	`int next = Integer.parseInt(new String(s));`
`209`	`209`	`if (!sieve[next] && !visited.contains(next)) {`
`210`		`- pq.add(new int[]{sum + next, next});`
	`210`	`+ pq.add(new int[] {sum + next, next});`
`211`	`211`	`}`
`212`	`212`	`s[i] = c;`
`213`	`213`	`}`
`@@ -216,7 +216,7 @@ class Solution {`
`216`	`216`	`s[i] = (char) (s[i] - 1);`
`217`	`217`	`int next = Integer.parseInt(new String(s));`
`218`	`218`	`if (!sieve[next] && !visited.contains(next)) {`
`219`		`- pq.add(new int[]{sum + next, next});`
	`219`	`+ pq.add(new int[] {sum + next, next});`
`220`	`220`	`}`
`221`	`221`	`s[i] = c;`
`222`	`222`	`}`
`@@ -286,6 +286,7 @@ private:`
`286`	`286`	`}`
`287`	`287`	`return -1;`
`288`	`288`	`}`
	`289`	`+`
`289`	`290`	`public:`
`290`	`291`	`int minOperations(int n, int m) {`
`291`	`292`	`runSieve();`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ class Solution {`
`180`	`180`
`181`	`181`	`private int solve(int n, int m) {`
`182`	`182`	`PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));`
`183`		`- pq.add(new int[]{n, n});`
	`183`	`+ pq.add(new int[] {n, n});`
`184`	`184`	`Set<Integer> visited = new HashSet<>();`
`185`	`185`
`186`	`186`	`while (!pq.isEmpty()) {`
`@@ -204,7 +204,7 @@ class Solution {`
`204`	`204`	`s[i] = (char) (s[i] + 1);`
`205`	`205`	`int next = Integer.parseInt(new String(s));`
`206`	`206`	`if (!sieve[next] && !visited.contains(next)) {`
`207`		`- pq.add(new int[]{sum + next, next});`
	`207`	`+ pq.add(new int[] {sum + next, next});`
`208`	`208`	`}`
`209`	`209`	`s[i] = c;`
`210`	`210`	`}`
`@@ -213,7 +213,7 @@ class Solution {`
`213`	`213`	`s[i] = (char) (s[i] - 1);`
`214`	`214`	`int next = Integer.parseInt(new String(s));`
`215`	`215`	`if (!sieve[next] && !visited.contains(next)) {`
`216`		`- pq.add(new int[]{sum + next, next});`
	`216`	`+ pq.add(new int[] {sum + next, next});`
`217`	`217`	`}`
`218`	`218`	`s[i] = c;`
`219`	`219`	`}`
`@@ -283,6 +283,7 @@ private:`
`283`	`283`	`}`
`284`	`284`	`return -1;`
`285`	`285`	`}`
	`286`	`+`
`286`	`287`	`public:`
`287`	`288`	`int minOperations(int n, int m) {`
`288`	`289`	`runSieve();`
Original file line number	Diff line number	Diff line change
`@@ -45,10 +45,11 @@ class Solution {`
`45`	`45`	`}`
`46`	`46`	`return -1;`
`47`	`47`	`}`
	`48`	`+`
`48`	`49`	`public:`
`49`	`50`	`int minOperations(int n, int m) {`
`50`	`51`	`runSieve();`
`51`	`52`	`if (sieve[n] \|\| sieve[m]) return -1;`
`52`	`53`	`return solve(n, m);`
`53`		`- }`
	`54`	`+ }`
`54`	`55`	`};`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ private void runSieve() {`
`17`	`17`
`18`	`18`	`private int solve(int n, int m) {`
`19`	`19`	`PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));`
`20`		`- pq.add(new int[]{n, n});`
	`20`	`+ pq.add(new int[] {n, n});`
`21`	`21`	`Set<Integer> visited = new HashSet<>();`
`22`	`22`
`23`	`23`	`while (!pq.isEmpty()) {`
`@@ -41,7 +41,7 @@ private int solve(int n, int m) {`
`41`	`41`	`s[i] = (char) (s[i] + 1);`
`42`	`42`	`int next = Integer.parseInt(new String(s));`
`43`	`43`	`if (!sieve[next] && !visited.contains(next)) {`
`44`		`- pq.add(new int[]{sum + next, next});`
	`44`	`+ pq.add(new int[] {sum + next, next});`
`45`	`45`	`}`
`46`	`46`	`s[i] = c;`
`47`	`47`	`}`
`@@ -50,7 +50,7 @@ private int solve(int n, int m) {`
`50`	`50`	`s[i] = (char) (s[i] - 1);`
`51`	`51`	`int next = Integer.parseInt(new String(s));`
`52`	`52`	`if (!sieve[next] && !visited.contains(next)) {`
`53`		`- pq.add(new int[]{sum + next, next});`
	`53`	`+ pq.add(new int[] {sum + next, next});`
`54`	`54`	`}`
`55`	`55`	`s[i] = c;`
`56`	`56`	`}`