格式化

Author: masx200

add-two-polynomials-represented-as-linked-lists/PolyNodeToArray.ts

@@ -1,4 +1,4 @@
-import { PolyNode } from './PolyNode.ts';
+import { PolyNode } from "./PolyNode.ts";
 
 export function PolyNodeToArray(
     list: PolyNode | null,

add-two-polynomials-represented-as-linked-lists/test.ts

@@ -1,8 +1,8 @@
-import { assertEquals } from 'https://deno.land/[email protected]/testing/asserts.ts';
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
 
-import { ArrayToPolyNode } from './ArrayToPolyNode.ts';
-import addPoly from './index.ts';
-import { PolyNodeToArray } from './PolyNodeToArray.ts';
+import { ArrayToPolyNode } from "./ArrayToPolyNode.ts";
+import addPoly from "./index.ts";
+import { PolyNodeToArray } from "./PolyNodeToArray.ts";
 
 Deno.test("add-two-polynomials-represented-as-linked-lists", () => {
     const cases = [

all-elements-in-two-binary-search-trees/index.ts

@@ -1,6 +1,6 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
-import { inorder } from './inorder.ts';
-import { merge_sort } from './merge_sort.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { inorder } from "./inorder.ts";
+import { merge_sort } from "./merge_sort.ts";
 
 export default function getAllElements(
     root1: TreeNode | null,

all-elements-in-two-binary-search-trees/inorder.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 export function inorder(node: TreeNode | null, res: number[]) {
     if (node) {

all-possible-full-binary-trees/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 export default allPossibleFBT;
 

armstrong-number/test.ts

@@ -1,6 +1,6 @@
-import { assertEquals } from 'asserts';
+import { assertEquals } from "asserts";
 
-import isArmstrong from './index.ts';
+import isArmstrong from "./index.ts";
 
 Deno.test("armstrong-number", () => {
     assertEquals([153, 123, 962, 9999].map(isArmstrong), [

average-of-levels-in-binary-tree/index.ts

@@ -1,5 +1,5 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
-import { sum } from '../richest-customer-wealth/sum.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { sum } from "../richest-customer-wealth/sum.ts";
 
 export default function averageOfLevels(root: TreeNode | null): number[] {
     if (!root) return [];

bP4bmD/index.ts

@@ -1,3 +1,3 @@
-import allPathsSourceTarget from '../all-paths-from-source-to-target/index.ts';
+import allPathsSourceTarget from "../all-paths-from-source-to-target/index.ts";
 
 export { allPathsSourceTarget as default };

balanced-binary-tree/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 export default function isBalanced(root: TreeNode | null): boolean {
     return height(root) >= 0;

basic-calculator-iii/test.ts

@@ -1,5 +1,5 @@
-import { assertEquals } from '../deps.ts';
-import calculate from './index.ts';
+import { assertEquals } from "../deps.ts";
+import calculate from "./index.ts";
 
 Deno.test("basic-calculator-iii", () => {
     assertEquals(calculate("-199+5998"), -199 + 5998);

basic-calculator-iv/index.ts

@@ -1,5 +1,5 @@
-import { parse } from './parse.ts';
-import { tokenize } from './tokenize.ts';
+import { parse } from "./parse.ts";
+import { tokenize } from "./tokenize.ts";
 
 export default function basicCalculatorIV(
     expression: string,

basic-calculator-iv/parse.ts

@@ -1,4 +1,4 @@
-import { Poly } from './Poly.ts';
+import { Poly } from "./Poly.ts";
 
 /**  我们依然使用递归下降法来解决这个问题，文法如下：
 

basic-calculator-iv/test.ts

@@ -1,8 +1,8 @@
-import { assertEquals } from 'https://deno.land/[email protected]/testing/asserts.ts';
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
 
-import basicCalculatorIV from './index.ts';
-import { Poly } from './Poly.ts';
-import { tokenize } from './tokenize.ts';
+import basicCalculatorIV from "./index.ts";
+import { Poly } from "./Poly.ts";
+import { tokenize } from "./tokenize.ts";
 
 Deno.test("poly", () => {
     const p1 = new Poly([

basic-calculator/BinaryExpression.ts

@@ -1,4 +1,4 @@
-import { Expression } from './Expression.ts';
+import { Expression } from "./Expression.ts";
 
 export interface BinaryExpression {
     type: "BinaryExpression";

basic-calculator/Expression.ts

@@ -1,7 +1,7 @@
-import { BinaryExpression } from './BinaryExpression.ts';
-import { NumericLiteral } from './NumericLiteral.ts';
-import { ParenthesizedExpression } from './ParenthesizedExpression.ts';
-import { UnaryExpression } from './UnaryExpression.ts';
+import { BinaryExpression } from "./BinaryExpression.ts";
+import { NumericLiteral } from "./NumericLiteral.ts";
+import { ParenthesizedExpression } from "./ParenthesizedExpression.ts";
+import { UnaryExpression } from "./UnaryExpression.ts";
 
 export type Expression =
     | BinaryExpression

basic-calculator/ExpressionOperator.ts

@@ -1,5 +1,5 @@
-import { BinaryExpression } from './BinaryExpression.ts';
-import { UnaryExpression } from './UnaryExpression.ts';
+import { BinaryExpression } from "./BinaryExpression.ts";
+import { UnaryExpression } from "./UnaryExpression.ts";
 
 export type ExpressionOperator =
     | UnaryExpression["operator"]

basic-calculator/ExpressionType.ts

@@ -1,3 +1,3 @@
-import { Expression } from './Expression.ts';
+import { Expression } from "./Expression.ts";
 
 export type ExpressionType = Expression["type"];

basic-calculator/ParenthesizedExpression.ts

@@ -1,4 +1,4 @@
-import { Expression } from './Expression.ts';
+import { Expression } from "./Expression.ts";
 
 export interface ParenthesizedExpression {
     type: "ParenthesizedExpression";

basic-calculator/Token.ts

@@ -1,3 +1,3 @@
-import { Tokens } from './Tokens.ts';
+import { Tokens } from "./Tokens.ts";
 
 export type Token = Tokens extends (infer P)[] ? P : never;

basic-calculator/UnaryExpression.ts

@@ -1,4 +1,4 @@
-import { Expression } from './Expression.ts';
+import { Expression } from "./Expression.ts";
 
 export interface UnaryExpression {
     type: "UnaryExpression";

basic-calculator/buildExpression.ts

@@ -1,16 +1,16 @@
-import { BinaryExpression } from './BinaryExpression.ts';
-import { buildNumericLiteralExpression } from './buildNumericLiteralExpression.ts';
-import { buildParenthesizedExpression } from './buildParenthesizedExpression.ts';
-import { Expression } from './Expression.ts';
-import { ExpressionOperator } from './ExpressionOperator.ts';
-import { ExpressionType } from './ExpressionType.ts';
-import { getTokenType } from './getTokenType.ts';
-import { State } from './State.ts';
-import { Tokens } from './Tokens.ts';
-import { TokenType } from './TokenType.ts';
-import { transform } from './transform.ts';
-import { UnaryExpression } from './UnaryExpression.ts';
-import { valid_end_states } from './valid_end_states.ts';
+import { BinaryExpression } from "./BinaryExpression.ts";
+import { buildNumericLiteralExpression } from "./buildNumericLiteralExpression.ts";
+import { buildParenthesizedExpression } from "./buildParenthesizedExpression.ts";
+import { Expression } from "./Expression.ts";
+import { ExpressionOperator } from "./ExpressionOperator.ts";
+import { ExpressionType } from "./ExpressionType.ts";
+import { getTokenType } from "./getTokenType.ts";
+import { State } from "./State.ts";
+import { Tokens } from "./Tokens.ts";
+import { TokenType } from "./TokenType.ts";
+import { transform } from "./transform.ts";
+import { UnaryExpression } from "./UnaryExpression.ts";
+import { valid_end_states } from "./valid_end_states.ts";
 
 export function buildExpression(tokens: Tokens): Expression {
     if (tokens.length === 0) {

basic-calculator/buildNumericLiteralExpression.ts

@@ -1,5 +1,5 @@
-import { Expression } from './Expression.ts';
-import { Token } from './Token.ts';
+import { Expression } from "./Expression.ts";
+import { Token } from "./Token.ts";
 
 export function buildNumericLiteralExpression(token: Token) {
     if (typeof token !== "number") {

basic-calculator/buildParenthesizedExpression.ts

@@ -1,6 +1,6 @@
-import { buildExpression } from './buildExpression.ts';
-import { Expression } from './Expression.ts';
-import { Token } from './Token.ts';
+import { buildExpression } from "./buildExpression.ts";
+import { Expression } from "./Expression.ts";
+import { Token } from "./Token.ts";
 
 export function buildParenthesizedExpression(token: Token) {
     if (!Array.isArray(token)) {

basic-calculator/evaluate.ts

@@ -1,4 +1,4 @@
-import { Expression } from './Expression.ts';
+import { Expression } from "./Expression.ts";
 
 export function evaluate(ast: Expression): number {
     if (ast.type === "NumericLiteral") {

basic-calculator/getTokenType.ts

@@ -1,5 +1,5 @@
-import { Token } from './Token.ts';
-import { TokenType } from './TokenType.ts';
+import { Token } from "./Token.ts";
+import { TokenType } from "./TokenType.ts";
 
 export function getTokenType(token: Token) {
     const tokentype: TokenType = typeof token === "number"

basic-calculator/index.ts

@@ -1,6 +1,6 @@
-import { buildExpression } from './buildExpression.ts';
-import { evaluate } from './evaluate.ts';
-import { tokenize } from './tokenize.ts';
+import { buildExpression } from "./buildExpression.ts";
+import { evaluate } from "./evaluate.ts";
+import { tokenize } from "./tokenize.ts";
 
 export default function calculate(s: string): number {
     const tokens = tokenize(s);

basic-calculator/test.ts

@@ -1,8 +1,8 @@
-import { assertEquals } from '../deps.ts';
-import { buildExpression } from './buildExpression.ts';
-import { evaluate } from './evaluate.ts';
-import calculate from './index.ts';
-import { tokenize } from './tokenize.ts';
+import { assertEquals } from "../deps.ts";
+import { buildExpression } from "./buildExpression.ts";
+import { evaluate } from "./evaluate.ts";
+import calculate from "./index.ts";
+import { tokenize } from "./tokenize.ts";
 
 Deno.test("calculate-simple-expression", () => {
     assertEquals(

basic-calculator/tokenize.ts

@@ -1,4 +1,4 @@
-import { Tokens } from './Tokens.ts';
+import { Tokens } from "./Tokens.ts";
 
 export function tokenize(s: string): Tokens {
     const tokens: Tokens = [];

basic-calculator/transform.ts

@@ -1,5 +1,5 @@
-import { State } from './State.ts';
-import { TokenType } from './TokenType.ts';
+import { State } from "./State.ts";
+import { TokenType } from "./TokenType.ts";
 
 export const transform: Record<State, Record<TokenType, State>> = {
     [State.initial]: {

basic-calculator/valid_end_states.ts

@@ -1,3 +1,3 @@
-import { State } from './State.ts';
+import { State } from "./State.ts";
 
 export const valid_end_states = [State["parentheses"], State["number"]];

binary-search-tree-iterator-ii/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 export function* InOrderIterator(root: TreeNode | null): Generator<number> {
     if (!root) return;

binary-search-tree-iterator/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 class BSTIterator {
     #root: TreeNode | null | undefined;

binary-tree-inorder-traversal/index.ts

@@ -1,5 +1,5 @@
-import { inorder } from './inorder.ts';
-import { TreeNode } from './TreeNode.ts';
+import { inorder } from "./inorder.ts";
+import { TreeNode } from "./TreeNode.ts";
 
 export default function inorderTraversal(root: TreeNode | null): number[] {
     if (!root) return [];

binary-tree-inorder-traversal/inorder.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from './TreeNode.ts';
+import { TreeNode } from "./TreeNode.ts";
 
 export function inorder(root: TreeNode | null, output: (a: number) => void) {
     if (!root) return;

binary-tree-level-order-traversal-ii/index.ts

@@ -1,5 +1,5 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
-import { level } from './level.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { level } from "./level.ts";
 
 export default function levelOrderBottom(root: TreeNode | null): number[][] {
     if (!root) return [];

binary-tree-level-order-traversal-ii/level.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 export function level(nodes: TreeNode[], output: (r: number[]) => void) {
     if (nodes.length === 0) return;

binary-tree-level-order-traversal/index.ts

@@ -1,5 +1,5 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
-import { level } from '../binary-tree-level-order-traversal-ii/level.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { level } from "../binary-tree-level-order-traversal-ii/level.ts";
 
 export default function levelOrder(root: TreeNode | null): number[][] {
     if (!root) return [];

binary-tree-level-order-traversal/test.ts

@@ -1,6 +1,6 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
-import { assertEquals } from '../deps.ts';
-import levelOrder from './index.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { assertEquals } from "../deps.ts";
+import levelOrder from "./index.ts";
 
 Deno.test("binary-tree-level-order-traversal", () => {
     const root = new TreeNode(3);

binary-tree-maximum-path-sum/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 function maxPathSum(root: TreeNode | null): number {
     let maxSum = Number.MIN_SAFE_INTEGER; // 最大路径和

binary-tree-paths/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 export default function binaryTreePaths(root: TreeNode | null): string[] {
     const res: string[] = [];

binary-tree-postorder-traversal/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 function postorder(root: TreeNode | null, output: (a: number) => void) {
     if (!root) {

binary-tree-preorder-traversal/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
 
 export default function preorderTraversal(root: TreeNode | null): number[] {
     if (!root) return [];

binary-tree-pruning/index.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from '../mod.ts';
+import { TreeNode } from "../mod.ts";
 
 export default function pruneTree(root: TreeNode | null): TreeNode | null {
     if (!root) return null;

binary-tree-right-side-view/index.ts

@@ -1,5 +1,5 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
-import levelOrder from '../binary-tree-level-order-traversal/index.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import levelOrder from "../binary-tree-level-order-traversal/index.ts";
 
 export default function rightSideView(root: TreeNode | null): number[] {
     return levelOrder(root).map((a) => a[a.length - 1]);

binary-tree-zigzag-level-order-traversal/index.ts

@@ -1,5 +1,5 @@
-import { TreeNode } from '../binary-tree-inorder-traversal/TreeNode.ts';
-import { level } from '../binary-tree-level-order-traversal-ii/level.ts';
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { level } from "../binary-tree-level-order-traversal-ii/level.ts";
 
 export default function zigzagLevelOrder(root: TreeNode | null): number[][] {
     if (!root) return [];

binary-watch/index.ts

@@ -1,4 +1,4 @@
-import hammingWeight from '../number-of-1-bits/index.ts';
+import hammingWeight from "../number-of-1-bits/index.ts";
 
 export default function readBinaryWatch(num: number): string[] {
     const res: string[] = [];

binode-lcci/test.ts

@@ -1,6 +1,6 @@
-import { assertEquals } from '../deps.ts';
-import { TreeNode } from '../mod.ts';
-import increasingBST from './index.ts';
+import { assertEquals } from "../deps.ts";
+import { TreeNode } from "../mod.ts";
+import increasingBST from "./index.ts";
 
 Deno.test("binode-lcci-1", () => {
     assertEquals(

booking-concert-tickets-in-groups/SegmentTree.ts

@@ -1,4 +1,4 @@
-import { TreeNode } from './TreeNode.ts';
+import { TreeNode } from "./TreeNode.ts";
 
 class SegmentTree<T> {
     #root: TreeNode<T>;

booking-concert-tickets-in-groups/index.ts

@@ -1,4 +1,4 @@
-import { SegmentTree } from './SegmentTree.ts';
+import { SegmentTree } from "./SegmentTree.ts";
 
 export default class BookMyShow {
     #seats: number[];

booking-concert-tickets-in-groups/test.ts

@@ -1,7 +1,7 @@
-import { assertEquals } from 'https://deno.land/[email protected]/testing/asserts.ts';
-import { runScript } from 'leetcode-class';
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import { runScript } from "leetcode-class";
 
-import BookMyShow from './index.ts';
+import BookMyShow from "./index.ts";
 
 Deno.test("booking-concert-tickets-in-groups", () => {
     assertEquals(