format ts files

Author: charliesbot

typescript/@types/Node.ts

@@ -3,10 +3,10 @@ declare class ListNode {
   next: ListNode | null;
   prev?: ListNode | null;
   key?: number;
-  
+
   constructor(val: number, next?: ListNode | null);
   constructor(options: { key?: number; value: number });
 }
 
 declare function createLinkedList(values: number[]): ListNode | null;
-declare function linkedListToArray(head: ListNode | null): number[];
+declare function linkedListToArray(head: ListNode | null): number[];

typescript/@types/global.d.ts

@@ -25,7 +25,10 @@ declare global {
   val: number;
   key?: number;
 
-  constructor(valOrOptions: number | ListNodeConstructor, next: ListNode | null = null) {
+  constructor(
+    valOrOptions: number | ListNodeConstructor,
+    next: ListNode | null = null
+  ) {
     if (typeof valOrOptions === 'object') {
       this.prev = null;
       this.next = null;
@@ -40,30 +43,34 @@ declare global {
   }
 };
 
-(globalThis as any).createLinkedList = function(values: number[]): ListNode | null {
+(globalThis as any).createLinkedList = function (
+  values: number[]
+): ListNode | null {
   if (values.length === 0) return null;
-  
+
   const head = new ListNode(values[0]);
   let current = head;
-  
+
   for (let i = 1; i < values.length; i++) {
     current.next = new ListNode(values[i]);
     current = current.next;
   }
-  
+
   return head;
 };
 
-(globalThis as any).linkedListToArray = function(head: ListNode | null): number[] {
+(globalThis as any).linkedListToArray = function (
+  head: ListNode | null
+): number[] {
   const result: number[] = [];
   let current = head;
-  
+
   while (current !== null) {
     result.push(current.val);
     current = current.next;
   }
-  
+
   return result;
 };
 
-export {};
+export {};

typescript/problem_0001/TwoSum.test.ts

@@ -1,7 +1,7 @@
 import { test, expect } from 'vitest';
 import { twoSum } from './TwoSum';
 
-test("twoSum", () => {
+test('twoSum', () => {
   const input = [2, 7, 11, 15];
   expect(twoSum(input, 9)).toStrictEqual([0, 1]);
 });

typescript/problem_0003/LongestSubstringWithoutRepeatingCharacters.test.ts

@@ -1,17 +1,17 @@
 import { test, expect } from 'vitest';
 import { lengthOfLongestSubstring } from './LongestSubstringWithoutRepeatingCharacters';
 
-test("lengthOfLongestSubstring1", () => {
-  const input = "abcabcbb";
+test('lengthOfLongestSubstring1', () => {
+  const input = 'abcabcbb';
   expect(lengthOfLongestSubstring(input)).toEqual(3);
 });
 
-test("lengthOfLongestSubstring2", () => {
-  const input = "bbbbb";
+test('lengthOfLongestSubstring2', () => {
+  const input = 'bbbbb';
   expect(lengthOfLongestSubstring(input)).toEqual(1);
 });
 
-test("lengthOfLongestSubstring3", () => {
-  const input = "pwwkew";
+test('lengthOfLongestSubstring3', () => {
+  const input = 'pwwkew';
   expect(lengthOfLongestSubstring(input)).toEqual(3);
 });

typescript/problem_0005/LongestPalindromicSubstring.test.ts

@@ -1,7 +1,7 @@
 import { test, expect } from 'vitest';
 import { longestPalindrome } from './LongestPalindromicSubstring';
 
-test("longestPalindromicSubstring1", () => {
-  const input = "babad";
-  expect(longestPalindrome(input)).toBe("aba");
+test('longestPalindromicSubstring1', () => {
+  const input = 'babad';
+  expect(longestPalindrome(input)).toBe('aba');
 });

typescript/problem_0007/ReverseInteger.test.ts

@@ -1,28 +1,28 @@
 import { test, expect } from 'vitest';
 import { reverse } from './ReverseInteger';
 
-test("Reverse Integer 1", () => {
+test('Reverse Integer 1', () => {
   const input = 123;
   const output = 321;
 
   expect(reverse(input)).toBe(output);
 });
 
-test("Reverse Integer 2", () => {
+test('Reverse Integer 2', () => {
   const input = -123;
   const output = -321;
 
   expect(reverse(input)).toBe(output);
 });
 
-test("Reverse Integer 3", () => {
+test('Reverse Integer 3', () => {
   const input = 120;
   const output = 21;
 
   expect(reverse(input)).toBe(output);
 });
 
-test("Reverse Integer 4", () => {
+test('Reverse Integer 4', () => {
   const input = 0;
   const output = 0;
 

typescript/problem_0017/LetterCombinationsOfAPhoneNumber.ts

@@ -11,16 +11,16 @@
  */
 
 const numbers = {
-  "0": [" "],
-  "1": [],
-  "2": ["a", "b", "c"],
-  "3": ["d", "e", "f"],
-  "4": ["g", "h", "i"],
-  "5": ["j", "k", "l"],
-  "6": ["m", "n", "o"],
-  "7": ["p", "q", "r", "s"],
-  "8": ["t", "u", "v"],
-  "9": ["w", "x", "y", "z"],
+  '0': [' '],
+  '1': [],
+  '2': ['a', 'b', 'c'],
+  '3': ['d', 'e', 'f'],
+  '4': ['g', 'h', 'i'],
+  '5': ['j', 'k', 'l'],
+  '6': ['m', 'n', 'o'],
+  '7': ['p', 'q', 'r', 's'],
+  '8': ['t', 'u', 'v'],
+  '9': ['w', 'x', 'y', 'z'],
 };
 
 const letterCombinations = function (digits: string) {
@@ -44,7 +44,7 @@ const letterCombinations = function (digits: string) {
     }
   };
 
-  dfs(0, "");
+  dfs(0, '');
 
   return result;
 };

typescript/problem_0020/ValidParentheses.test.ts

@@ -1,17 +1,17 @@
 import { test, expect } from 'vitest';
 import { isValidParenthesis } from './ValidParentheses';
 
-test("isValidParenthesis1", () => {
-  const input = "()";
+test('isValidParenthesis1', () => {
+  const input = '()';
   expect(isValidParenthesis(input)).toBeTruthy();
 });
 
-test("isValidParenthesis2", () => {
-  const input = "()[]{}";
+test('isValidParenthesis2', () => {
+  const input = '()[]{}';
   expect(isValidParenthesis(input)).toBeTruthy();
 });
 
-test("isValidParenthesis3", () => {
-  const input = "([)]";
+test('isValidParenthesis3', () => {
+  const input = '([)]';
   expect(isValidParenthesis(input)).toBeFalsy();
 });

typescript/problem_0020/ValidParentheses.ts

@@ -16,9 +16,9 @@
 
 const isValidParenthesis = (s: string): boolean => {
   const dict: { [key: string]: string } = {
-    "(": ")",
-    "{": "}",
-    "[": "]",
+    '(': ')',
+    '{': '}',
+    '[': ']',
   };
   const array: string[] = [];
 

typescript/problem_0022/GenerateParentheses.test.ts

@@ -1,8 +1,8 @@
 import { test, expect } from 'vitest';
 import { generateParenthesis } from './GenerateParentheses';
 
-test("test1", () => {
+test('test1', () => {
   const n = 3;
-  const result = ["((()))", "(()())", "(())()", "()(())", "()()()"];
+  const result = ['((()))', '(()())', '(())()', '()(())', '()()()'];
   expect(generateParenthesis(n)).toStrictEqual(result);
 });