https://leetcode.cn/problems/brace-expansion-ii/ https://leetcode.cn/problems/brace-expansion/

Author: masx200

README.md

@@ -10,6 +10,10 @@ leetcode 测试
 
 ##### 包含的内容如下
 
+https://leetcode.cn/problems/brace-expansion-ii/
+
+https://leetcode.cn/problems/brace-expansion/
+
 https://leetcode.cn/problems/array-nesting/
 
 https://leetcode.cn/problems/super-ugly-number/

brace-expansion-ii/index.ts

@@ -0,0 +1,13 @@
+import { evaluate, parse } from "../brace-expansion/index.ts";
+import { deduplication } from "../fraction-addition-and-subtraction/deduplication.ts";
+
+export default function braceExpansionII(s: string): string[] {
+    if (s.includes("{")) {
+        const m = parse(s);
+
+        if (typeof m === "string") return [m];
+        return deduplication(evaluate(m)).sort();
+    } else {
+        return [s];
+    }
+}

brace-expansion-ii/test.ts

@@ -0,0 +1,31 @@
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import braceExpansionII from "./index.ts";
+Deno.test("brace-expansion-ii", () => {
+    const inputs = [
+        "{a,b}",
+        "{a,b}{c,{d,e}}",
+        "{{a,z},a{b,c},{ab,z}}",
+        "{a,b}c{d,e}f",
+        "abcd",
+        "{a,b,c}",
+        "zabcde{a,b,c}",
+        "zab",
+        "{a,b,c}{a,b,c}",
+        "{a,b}{c,{d,e}}",
+        "{z,{a,b}{c,{d,e}}}",
+    ];
+    const outputs = [
+        ["a", "b"],
+        ["ac", "ad", "ae", "bc", "bd", "be"],
+        ["a", "ab", "ac", "z"],
+        ["acdf", "acef", "bcdf", "bcef"],
+        ["abcd"],
+        ["a", "b", "c"],
+        ["zabcdea", "zabcdeb", "zabcdec"],
+        ["zab"],
+        ["aa", "ab", "ac", "ba", "bb", "bc", "ca", "cb", "cc"],
+        ["ac", "ad", "ae", "bc", "bd", "be"],
+        ["ac", "ad", "ae", "bc", "bd", "be", "z"],
+    ];
+    assertEquals(inputs.map(braceExpansionII), outputs);
+});

brace-expansion/index.ts

@@ -0,0 +1,89 @@
+export default function expand(s: string): string[] {
+    if (s.includes("{")) {
+        const m = parse(s);
+
+        if (typeof m === "string") return [m];
+        return evaluate(m).sort();
+    } else {
+        return [s];
+    }
+}
+export type Expression = AddExpression | MultExpression;
+
+export interface AddExpression {
+    type: "AddExpression";
+    children: (Expression | string)[];
+}
+export interface MultExpression {
+    type: "MultExpression";
+    children: (Expression | string)[];
+}
+
+export function parse(s: string): Expression | string {
+    const m = s.match(/\,|\{|\}|[a-z]+/g) ?? [];
+    if (!m || !m.length) return { type: "AddExpression", children: [] };
+
+    let i = 0;
+
+    function dfs(): Expression | string {
+        const a: (string | Expression)[] = [];
+
+        while (i < m.length) {
+            const value = m[i];
+            if (value === "{") {
+                i++;
+                a.push(dfs());
+            } else if (value === "}") {
+                i++;
+                break;
+            } else {
+                a.push(value);
+                i++;
+            }
+        }
+
+        if (a.length == 1) {
+            return a[0];
+        }
+        return a.includes(",")
+            ? splitAdd(a)
+            : { type: "MultExpression", children: a };
+    }
+    const r = dfs();
+    return r;
+}
+
+function splitAdd(a: (string | Expression)[]): Expression | string {
+    const e: AddExpression = { type: "AddExpression", children: [] };
+    if (a.length === 1) return a[0];
+    const index = a.indexOf(",");
+    if (index < 0) return { type: "MultExpression", children: a };
+
+    if (index === 1) {
+        e.children.push(a[0]);
+    } else {
+        e.children.push({
+            type: "MultExpression",
+            children: a.slice(0, index),
+        });
+    }
+    e.children.push(splitAdd(a.slice(index + 1)));
+    if (e.children.length == 1) {
+        return e.children[0];
+    }
+    return e;
+}
+export function evaluate(m: Expression | string): string[] {
+    if (typeof m === "string") return [m];
+
+    if (m.type === "MultExpression") {
+        return m.children.reduce((p: string[], c): string[] => {
+            const left = p;
+            const right = typeof c === "string" ? [c] : evaluate(c);
+            if (p.length === 0) return right;
+            return left.map((v) => right.map((r) => v + r)).flat();
+        }, [] as string[]);
+    } else {
+        return m.children.map(evaluate).flat();
+    }
+}

brace-expansion/test.ts

@@ -0,0 +1,7 @@
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import expand from "./index.ts";
+Deno.test("brace-expansion", () => {
+    const inputs = ["{a,b}c{d,e}f", "abcd"];
+    const outputs = [["acdf", "acef", "bcdf", "bcef"], ["abcd"]];
+    assertEquals(inputs.map(expand), outputs);
+});