feat(*):base on deno

Author: guocaoyi

.prettierrc

@@ -0,0 +1,10 @@
+import {
+  assertEquals,
+  assertArrayContains,
+} from "https://deno.land/std/testing/asserts.ts";
+
+Deno.test("0001.two-sum", () => {
+  const x = 1 + 2;
+  assertEquals(x, 3);
+  assertArrayContains([1, 2, 3, 4, 5, 6], [3], "Expected 3 to be in the array");
+});

algorithms/0001.two-sum/index.test.ts

@@ -1,20 +1,19 @@
 /**
  * # 1. Two Sum
- * 
+ *
  * Given an array of integers, return **indices** of the two numbers such that they add up to a specific target.
- * 
+ *
  * You may assume that each input would have ***exactly*** one solution, and you may not use the same element twice.
- * 
+ *
  * ## Example
- * 
+ *
  * ```bash
  * Given nums = [2, 7, 11, 15], target = 9,
- * 
+ *
  * Because nums[0] + nums[1] = 2 + 7 = 9,
  * return [0, 1].
  * ```
  */
-type Submission = (nums: number[], target: number) => number[]
 
 /**
  * 嵌套循环遍历
@@ -25,18 +24,15 @@ type Submission = (nums: number[], target: number) => number[]
  * @runtime 120 ms < 40.065%
  * @memory N/A
  */
-export const twoSum: Submission = (
-  nums: number[],
-  target: number
-): number[] => {
+export const twoSum = (nums: number[], target: number): number[] => {
   for (let i: number = 0; i < nums.length; i++) {
     for (let j = i + 1; j < nums.length; j++) {
       if (nums[i] + nums[j] == target) {
-        return [i, j]
+        return [i, j];
       }
     }
   }
-}
+};
 
 /**
  * 哈希存储
@@ -45,19 +41,16 @@ export const twoSum: Submission = (
  * @runtime 80 ms < 59.00%
  * @memory N/A
  */
-export const twoSum1: Submission = (
-  nums: number[],
-  target: number
-): number[] => {
-  const map: any = {}
-  nums.forEach((i, k) => (map[i] = k))
+export const twoSum1 = (nums: number[], target: number): number[] => {
+  const map: any = {};
+  nums.forEach((i, k) => (map[i] = k));
   for (let i = 0; i < nums.length; i++) {
-    const x = target - nums[i]
+    const x = target - nums[i];
     if (x in map && map[x] != i) {
-      return [i, map[x]]
+      return [i, map[x]];
     }
   }
-}
+};
 
 /**
  * 哈希存储
@@ -66,22 +59,19 @@ export const twoSum1: Submission = (
  * @runtime 56 ms < 100.00%
  * @memory N/A
  */
-export const twoSum2: Submission = (
-  nums: number[],
-  target: number
-): number[] => {
-  const map: any = {}
-  const length: number = nums.length
+export const twoSum2 = (nums: number[], target: number): number[] => {
+  const map: any = {};
+  const length: number = nums.length;
   for (let i = 0; i < length; i++) {
-    map[nums[i]] = i
+    map[nums[i]] = i;
   }
   for (let i = 0; i < length; i++) {
-    const x = target - nums[i]
+    const x = target - nums[i];
     if (x in map && map[x] != i) {
-      return [i, map[x]]
+      return [i, map[x]];
     }
   }
-}
+};
 
 /**
  * 哈希遍历
@@ -90,17 +80,14 @@ export const twoSum2: Submission = (
  * @runtime 52 ms < 100%
  * @memory N/A
  */
-export const twoSum3: Submission = (
-  nums: number[],
-  target: number
-): number[] => {
-  const map: { number: number } | any = {}
-  const length = nums.length
+export const twoSum3 = (nums: number[], target: number): number[] => {
+  const map: { number: number } | any = {};
+  const length = nums.length;
   for (let i = 0; i < length; i++) {
-    const x = target - nums[i]
+    const x = target - nums[i];
     if (x in map && map[x] != i) {
-      return [map[x], i]
+      return [map[x], i];
     }
-    map[nums[i]] = i
+    map[nums[i]] = i;
   }
-}
+};

algorithms/0001.two-sum/index.ts

@@ -0,0 +1,36 @@
+import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+
+import { lengthOfLongestSubstring } from "./index.ts";
+
+Deno.test({
+  name: `0003 Longest Substring Without Repeating Characters
+  Input: "abcabcbb"
+  Output: 3
+  `,
+  fn(): void {
+    const result = lengthOfLongestSubstring("abcabcbb");
+    assertEquals(result, 3);
+  },
+});
+
+Deno.test({
+  name: `0003 Longest Substring Without Repeating Characters
+  Input: "bbbbb"
+  Output: 1
+  `,
+  fn(): void {
+    const result = lengthOfLongestSubstring("bbbbb");
+    assertEquals(result, 1);
+  },
+});
+
+Deno.test({
+  name: `0003 Longest Substring Without Repeating Characters
+  Input: "pwwkew"
+  Output: 3
+  `,
+  fn(): void {
+    const result = lengthOfLongestSubstring("pwwkew");
+    assertEquals(result, 3);
+  },
+});

algorithms/0003.longest-substring-without-repeating-characters/index.test.ts

@@ -24,7 +24,6 @@
  *              Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
  * ```
  */
-type Submission = (s: string) => number
 
 /**
  *
@@ -33,27 +32,27 @@ type Submission = (s: string) => number
  * @runtime 116 ms > 55.08%
  * @memory N/A
  */
-export const lengthOfLongestSubstring: Submission = (s: string): number => {
-  let maxSub: string = ''
-  let currentSub: string = ''
+export const lengthOfLongestSubstring = (s: string): number => {
+  let maxSub: string = "";
+  let currentSub: string = "";
 
-  const arr: string[] = s.split('')
+  const arr: string[] = s.split("");
   arr.forEach((s: string) => {
     if (currentSub.includes(s)) {
       // 存在
       if (currentSub.length >= maxSub.length) {
-        maxSub = currentSub
+        maxSub = currentSub;
       }
-      let [lStr, rStr] = currentSub.split(s)
-      currentSub = rStr || ''
-      currentSub += s
+      let [lStr, rStr] = currentSub.split(s);
+      currentSub = rStr || "";
+      currentSub += s;
     } else {
       // 不存在
-      currentSub += s
+      currentSub += s;
       if (currentSub.length >= maxSub.length) {
-        maxSub = currentSub
+        maxSub = currentSub;
       }
     }
-  })
-  return maxSub.length
-}
+  });
+  return maxSub.length;
+};

algorithms/0003.longest-substring-without-repeating-characters/index.ts

@@ -0,0 +1,13 @@
+import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+
+import { findMedianSortedArrays } from "./index.ts";
+
+Deno.test("0004.median-of-two-sorted-arrays", () => {
+  const result = findMedianSortedArrays([1, 3], [2]);
+  assertEquals(result, 2.0);
+});
+
+Deno.test("0004.median-of-two-sorted-arrays", () => {
+  const result = findMedianSortedArrays([1, 2], [3, 4]);
+  assertEquals(result, 2.5);
+});

algorithms/0004.median-of-two-sorted-arrays/READEME.md

@@ -1,29 +1,28 @@
 /**
  * # 4. Median of Tow Sorted Arrays
- * 
+ *
  * There are two sorted arrays **nums1** and **nums2** of size m and n respectively.
- * 
+ *
  * Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
- * 
+ *
  * You may assume **nums1** and **nums2** cannot be both empty.
- * 
+ *
  * ## Example
- * 
+ *
  * ```bash
  * nums1 = [1, 3]
  * nums2 = [2]
- * 
+ *
  * The median is 2.0
  * ```
- * 
+ *
  * ```bash
  * nums1 = [1, 2]
  * nums2 = [3, 4]
- * 
+ *
  * The median is (2 + 3)/2 = 2.5
  * ```
  */
-type Submission = (nums1: number[], nums2: number[]) => number
 
 /**
  * 递归
@@ -32,46 +31,46 @@ type Submission = (nums1: number[], nums2: number[]) => number
  * @runtime 168 ms > 19.48%
  * @memory 15.8 MB <
  */
-export const findMedianSortedArrays: Submission = (
+export const findMedianSortedArrays = (
   nums1: number[],
-  nums2: number[]
+  nums2: number[],
 ): number => {
   const findKth = (nums1: number[], nums2: number[], k: number): number => {
-    let m: number = nums1.length
-    let n: number = nums2.length
+    let m: number = nums1.length;
+    let n: number = nums2.length;
     if (m > n) {
-      return findKth(nums2, nums1, k)
+      return findKth(nums2, nums1, k);
     }
     if (m === 0) {
-      return nums2[k - 1]
+      return nums2[k - 1];
     }
     if (k === 1) {
-      return Math.min(nums1[0], nums2[0])
+      return Math.min(nums1[0], nums2[0]);
     }
-    let pa = Math.floor(k / 2) < m ? Math.floor(k / 2) : m
-    let pb = k - pa
+    let pa = Math.floor(k / 2) < m ? Math.floor(k / 2) : m;
+    let pb = k - pa;
     if (nums1[pa - 1] < nums2[pb - 1]) {
-      let t1 = nums1.slice(pa)
-      return findKth(t1, nums2, k - pa)
+      let t1 = nums1.slice(pa);
+      return findKth(t1, nums2, k - pa);
     } else if (nums1[pa - 1] > nums2[pb - 1]) {
-      let t2 = nums2.slice(pb)
+      let t2 = nums2.slice(pb);
       //nums2.splice(0,pb);
-      return findKth(nums1, t2, k - pb)
+      return findKth(nums1, t2, k - pb);
     } else {
-      return nums1[pa - 1]
+      return nums1[pa - 1];
     }
-  }
+  };
 
-  let m = nums1.length
-  let n = nums2.length
-  let tol = m + n
+  let m = nums1.length;
+  let n = nums2.length;
+  let tol = m + n;
   if (tol / 2 - Math.floor(tol / 2) > 0.1) {
-    return findKth(nums1, nums2, Math.floor(tol / 2) + 1)
+    return findKth(nums1, nums2, Math.floor(tol / 2) + 1);
   } else {
     return (
       (findKth(nums1, nums2, Math.floor(tol / 2)) +
         findKth(nums1, nums2, Math.floor(tol / 2) + 1)) /
       2
-    )
+    );
   }
-}
+};