https://leetcode.cn/problems/zigzag-iterator/

Author: masx200

6olJmJ/test.ts

@@ -1,16 +1,15 @@
 import { assertEquals } from "asserts";
-
 import explorationSupply from "./index.ts";
 
 Deno.test("explorationSupply", () => {
     const station = [2, 7, 8, 10],
         pos = [4, 9],
-        输出 = [0, 2];
-    assertEquals(explorationSupply(station, pos), 输出);
+        OUTPUT = [0, 2];
+    assertEquals(explorationSupply(station, pos), OUTPUT);
 });
 Deno.test("explorationSupply", () => {
     const station = [2, 5, 8, 14, 17],
         pos = [1, 14, 11, 2],
-        输出 = [0, 3, 2, 0];
-    assertEquals(explorationSupply(station, pos), 输出);
+        OUTPUT = [0, 3, 2, 0];
+    assertEquals(explorationSupply(station, pos), OUTPUT);
 });

README.md

@@ -2586,4 +2586,6 @@ https://leetcode.cn/problems/print-in-order/
 
 https://leetcode.cn/problems/print-foobar-alternately
 
+https://leetcode.cn/problems/zigzag-iterator/
+
 </details>

count-anagrams/test.ts

@@ -1,16 +1,15 @@
 import { assertEquals } from "asserts";
-
 import countAnagrams from "./index.ts";
 
 Deno.test("count-anagrams", () => {
     const s = "too hot",
-        输出 = 18;
+        OUTPUT = 18;
 
-    assertEquals(countAnagrams(s), 输出);
+    assertEquals(countAnagrams(s), OUTPUT);
 });
 Deno.test("count-anagrams", () => {
     const s = "aa",
-        输出 = 1;
+        OUTPUT = 1;
 
-    assertEquals(countAnagrams(s), 输出);
+    assertEquals(countAnagrams(s), OUTPUT);
 });

minimum-addition-to-make-integer-beautiful/index.ts

@@ -11,7 +11,7 @@ export default function makeIntegerBeautiful(
     // 记录当前执行到第 base + 1 次
     let base = 0;
     for (let i = nArr.length - 1; i >= 0; i--) {
-        // 每次执行判断是否符合结果，若符合直接输出
+        // 每次执行判断是否符合结果，若符合直接OUTPUT
         if (sum <= target) return rz;
         const currNum = nArr[i];
         // 更新结果

minimum-number-of-operations-to-make-string-sorted/test.ts

@@ -1,24 +1,23 @@
 import { assertEquals } from "asserts";
-
 import makeStringSorted from "./index.ts";
 
 Deno.test("minimum-number-of-operations-to-make-string-sorted", () => {
     const s = "leetcodeleetcodeleetcode",
-        输出 = 982157772;
-    assertEquals(makeStringSorted(s), 输出);
+        OUTPUT = 982157772;
+    assertEquals(makeStringSorted(s), OUTPUT);
 });
 Deno.test("minimum-number-of-operations-to-make-string-sorted", () => {
     const s = "cdbea",
-        输出 = 63;
-    assertEquals(makeStringSorted(s), 输出);
+        OUTPUT = 63;
+    assertEquals(makeStringSorted(s), OUTPUT);
 });
 Deno.test("minimum-number-of-operations-to-make-string-sorted", () => {
     const s = "aabaa",
-        输出 = 2;
-    assertEquals(makeStringSorted(s), 输出);
+        OUTPUT = 2;
+    assertEquals(makeStringSorted(s), OUTPUT);
 });
 Deno.test("minimum-number-of-operations-to-make-string-sorted", () => {
     const s = "cba",
-        输出 = 5;
-    assertEquals(makeStringSorted(s), 输出);
+        OUTPUT = 5;
+    assertEquals(makeStringSorted(s), OUTPUT);
 });

minimum-path-sum/test.ts

@@ -1,5 +1,4 @@
 import { assertStrictEquals } from "https://deno.land/std@0.187.0/testing/asserts.ts";
-
 import minPathSum from "./index.ts";
 
 Deno.test("minimum-path-sum", () => {
@@ -8,14 +7,14 @@ Deno.test("minimum-path-sum", () => {
         [1, 5, 1],
         [4, 2, 1],
     ];
-    const 输出 = 7;
-    assertStrictEquals(minPathSum(grid), 输出);
+    const OUTPUT = 7;
+    assertStrictEquals(minPathSum(grid), OUTPUT);
 });
 Deno.test("minimum-path-sum", () => {
     const grid = [
         [1, 2, 3],
         [4, 5, 6],
     ];
-    const 输出 = 12;
-    assertStrictEquals(minPathSum(grid), 输出);
+    const OUTPUT = 12;
+    assertStrictEquals(minPathSum(grid), OUTPUT);
 });

number-of-different-subsequences-gcds/test.ts

@@ -1,14 +1,13 @@
 import { assertEquals } from "asserts";
-
 import countDifferentSubsequenceGCDs from "./index.ts";
 
 Deno.test("number-of-different-subsequences-gcds", () => {
     const nums = [6, 10, 3],
-        输出 = 5;
-    assertEquals(countDifferentSubsequenceGCDs(nums), 输出);
+        OUTPUT = 5;
+    assertEquals(countDifferentSubsequenceGCDs(nums), OUTPUT);
 });
 Deno.test("number-of-different-subsequences-gcds", () => {
     const nums = [5, 15, 40, 5, 6],
-        输出 = 7;
-    assertEquals(countDifferentSubsequenceGCDs(nums), 输出);
+        OUTPUT = 7;
+    assertEquals(countDifferentSubsequenceGCDs(nums), OUTPUT);
 });

partition-to-k-equal-sum-subsets/test.ts

@@ -1,18 +1,17 @@
 import { assertEquals } from "asserts";
-
 import canPartitionKSubsets from "./index.ts";
 
 Deno.test("partition-to-k-equal-sum-subsets", () => {
     const nums = [4, 3, 2, 3, 5, 2, 1],
         k = 4,
-        输出 = true;
+        OUTPUT = true;
 
-    assertEquals(canPartitionKSubsets(nums, k), 输出);
+    assertEquals(canPartitionKSubsets(nums, k), OUTPUT);
 });
 Deno.test("partition-to-k-equal-sum-subsets", () => {
     const nums = [1, 2, 3, 4],
         k = 3,
-        输出 = false;
+        OUTPUT = false;
 
-    assertEquals(canPartitionKSubsets(nums, k), 输出);
+    assertEquals(canPartitionKSubsets(nums, k), OUTPUT);
 });

range-product-queries-of-powers/test.ts

@@ -1,5 +1,4 @@
 import { assertEquals } from "asserts";
-
 import productQueries from "./index.ts";
 
 Deno.test("range-product-queries-of-powers", () => {
@@ -9,11 +8,11 @@ Deno.test("range-product-queries-of-powers", () => {
             [2, 2],
             [0, 3],
         ],
-        输出 = [2, 4, 64];
-    assertEquals(productQueries(n, queries), 输出);
+        OUTPUT = [2, 4, 64];
+    assertEquals(productQueries(n, queries), OUTPUT);
 });
 
 Deno.test("range-product-queries-of-powers", () => {
-    const n = 2, queries = [[0, 0]], 输出 = [2];
-    assertEquals(productQueries(n, queries), 输出);
+    const n = 2, queries = [[0, 0]], OUTPUT = [2];
+    assertEquals(productQueries(n, queries), OUTPUT);
 });

redundant-connection-ii/test.ts

@@ -1,5 +1,4 @@
 import { assertEquals } from "asserts";
-
 import findRedundantDirectedConnection from "./index.ts";
 
 Deno.test("redundant-connection-ii", () => {
@@ -8,9 +7,9 @@ Deno.test("redundant-connection-ii", () => {
             [1, 3],
             [2, 3],
         ],
-        输出 = [2, 3];
+        OUTPUT = [2, 3];
 
-    assertEquals(findRedundantDirectedConnection(edges), 输出);
+    assertEquals(findRedundantDirectedConnection(edges), OUTPUT);
 });
 Deno.test("redundant-connection-ii", () => {
     const edges = [
@@ -20,7 +19,7 @@ Deno.test("redundant-connection-ii", () => {
             [4, 1],
             [1, 5],
         ],
-        输出 = [4, 1];
+        OUTPUT = [4, 1];
 
-    assertEquals(findRedundantDirectedConnection(edges), 输出);
+    assertEquals(findRedundantDirectedConnection(edges), OUTPUT);
 });

shuffle-string/test.ts

@@ -1,13 +1,14 @@
 import { assertEquals } from "asserts";
-
 import restoreString from "./index.ts";
 
 Deno.test("shuffle-string", () => {
-    const s = "codeleet", indices = [4, 5, 6, 7, 0, 2, 1, 3], 输出 = "leetcode";
-    assertEquals(restoreString(s, indices), 输出);
+    const s = "codeleet",
+        indices = [4, 5, 6, 7, 0, 2, 1, 3],
+        OUTPUT = "leetcode";
+    assertEquals(restoreString(s, indices), OUTPUT);
 });
 
 Deno.test("shuffle-string", () => {
-    const s = "abc", indices = [0, 1, 2], 输出 = "abc";
-    assertEquals(restoreString(s, indices), 输出);
+    const s = "abc", indices = [0, 1, 2], OUTPUT = "abc";
+    assertEquals(restoreString(s, indices), OUTPUT);
 });

test/com/github/masx200/leetcode_test/binary_search_tree_iterator/BSTIteratorTest.kt renamed to test/binary_search_tree_iterator/BSTIteratorTest.kt

@@ -1,18 +1,17 @@
 import { assertEquals } from "asserts";
-
 import storedEnergy from "./index.ts";
 
 Deno.test("storedEnergy", () => {
     const storeLimit = 10,
         power = [1, 3, 4, 3, 6],
         supply = [[0, 2, 3]],
-        输出 = 4;
-    assertEquals(storedEnergy(storeLimit, power, supply), 输出);
+        OUTPUT = 4;
+    assertEquals(storedEnergy(storeLimit, power, supply), OUTPUT);
 });
 Deno.test("storedEnergy", () => {
     const storeLimit = 6,
         power = [6, 5, 2, 1, 0],
         supply = [[0, 1, 2], [2, 3, 3]],
-        输出 = 0;
-    assertEquals(storedEnergy(storeLimit, power, supply), 输出);
+        OUTPUT = 0;
+    assertEquals(storedEnergy(storeLimit, power, supply), OUTPUT);
 });

test/com/github/masx200/leetcode_test/construct_binary_search_tree_from_preorder_traversal/SolutionTest.kt renamed to test/construct_binary_search_tree_from_preorder_traversal/SolutionTest.kt

@@ -0,0 +1,41 @@
+export default class ZigzagIterator {
+    #generator: Generator<number, void, unknown>;
+    #value: number | void;
+    #done: boolean | undefined;
+    constructor(v1: number[], v2: number[]) {
+        this.#generator = ZigzagGenerator(v1, v2);
+
+        const result = this.#generator.next();
+        this.#value = result.value;
+        this.#done = result.done;
+    }
+
+    next(): number {
+        const value = this.#value;
+        const result = this.#generator.next();
+        this.#value = result.value;
+        this.#done = result.done;
+        return value ?? -Infinity;
+    }
+    hasNext(): boolean {
+        return !this.#done;
+    }
+}
+
+function* ZigzagGenerator(
+    v1: number[],
+    v2: number[],
+): Generator<number, void, unknown> {
+    if (v1.length < v2.length) {
+        for (let i = 0; i < v1.length; i++) {
+            yield v1[i];
+            yield v2[i];
+        }
+
+        for (let i = v1.length; i < v2.length; i++) {
+            yield v2[i];
+        }
+    } else {
+        yield* ZigzagGenerator(v2, v1);
+    }
+}

test/com/github/masx200/leetcode_test/er_cha_shu_ran_se_ugc/SolutionTest.kt renamed to test/er_cha_shu_ran_se_ugc/SolutionTest.kt

@@ -0,0 +1,45 @@
+import ZigzagIterator from "./index.ts";
+import { assertEquals } from "asserts";
+
+Deno.test("zigzag-iterator", () => {
+    const v1 = [1, 2],
+        v2 = [3, 4, 5, 6],
+        OUTPUT = [1, 3, 2, 4, 5, 6];
+
+    const zzit = new ZigzagIterator(v1, v2);
+
+    const res: number[] = [];
+
+    while (zzit.hasNext()) {
+        res.push(zzit.next());
+    }
+    assertEquals(res, OUTPUT);
+});
+Deno.test("zigzag-iterator", () => {
+    const v1 = [1],
+        v2: number[] = [],
+        OUTPUT = [1];
+
+    const zzit = new ZigzagIterator(v1, v2);
+
+    const res: number[] = [];
+
+    while (zzit.hasNext()) {
+        res.push(zzit.next());
+    }
+    assertEquals(res, OUTPUT);
+});
+Deno.test("zigzag-iterator", () => {
+    const v1: number[] = [],
+        v2 = [1],
+        OUTPUT = [1];
+
+    const zzit = new ZigzagIterator(v1, v2);
+
+    const res: number[] = [];
+
+    while (zzit.hasNext()) {
+        res.push(zzit.next());
+    }
+    assertEquals(res, OUTPUT);
+});