Improved tasks

Author: javadev

src/main/ts/g0001_0100/s0002_add_two_numbers/readme.md

@@ -42,7 +42,7 @@ You may assume the two numbers do not contain any leading zero, except the numbe
 ```typescript
 import { ListNode } from '../../com_github_leetcode/listnode'
 
-/*
+/**
  * Definition for singly-linked list.
  * class ListNode {
  *     val: number

src/main/ts/g0001_0100/s0023_merge_k_sorted_lists/readme.md

@@ -43,7 +43,7 @@ _Merge all the linked-lists into one sorted linked-list and return it._
 ```typescript
 import { ListNode } from '../../com_github_leetcode/listnode'
 
-/*
+/**
  * Definition for singly-linked list.
  * class ListNode {
  *     val: number

src/main/ts/g0001_0100/s0030_substring_with_concatenation_of_all_words/readme.md

@@ -45,32 +45,26 @@ function findSubstring(s: string, words: string[]): number[] {
     let n1 = words[0].length
     let n2 = s.length
     let map1 = new Map<string, number>()
-
     for (let ch of words) {
         map1.set(ch, (map1.get(ch) ?? 0) + 1)
     }
-
     for (let i = 0; i < n1; i++) {
         let left = i
         let j = i
         let c = 0
         let map2 = new Map<string, number>()
-
         while (j + n1 <= n2) {
             let word1 = s.substring(j, j + n1)
             j += n1
-
             if (map1.has(word1)) {
                 map2.set(word1, (map2.get(word1) ?? 0) + 1)
                 c++
-
                 while ((map2.get(word1) ?? 0) > (map1.get(word1) ?? 0)) {
                     let word2 = s.substring(left, left + n1)
                     map2.set(word2, (map2.get(word2) ?? 0) - 1)
                     left += n1
                     c--
                 }
-
                 if (c === words.length) {
                     ans.push(left)
                 }

src/main/ts/g0001_0100/s0031_next_permutation/readme.md

@@ -50,15 +50,14 @@ The replacement must be **[in place](http://en.wikipedia.org/wiki/In-place_algor
  */
 function nextPermutation(nums: number[]): void {
     let swapperIndex: number | null = null
-
     for (let ind = nums.length - 1; ind >= 0 && swapperIndex == null; ind--) {
         if (nums[ind] > nums[ind - 1]) {
             swapperIndex = ind - 1
         }
     }
-
-    if (swapperIndex == null) nums.sort((a, b) => a - b)
-    else {
+    if (swapperIndex == null) {
+        nums.sort((a, b) => a - b)
+    } else {
         nums.splice(swapperIndex + 1, nums.length, ...nums.slice(swapperIndex + 1, nums.length).sort((a, b) => a - b))
         let indToBringForward = swapperIndex + 1
         while (nums[indToBringForward] <= nums[swapperIndex]) ++indToBringForward

src/main/ts/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md

@@ -46,7 +46,6 @@ function searchRange(nums: number[], target: number): number[] { //NOSONAR
     let left2 = left1
     let right1 = nums.length - 1
     let right2 = right1
-
     while (left1 <= right1 || left2 <= right2) {
         if (left1 <= right1) {
             let mid1 = Math.floor((left1 + right1) / 2)
@@ -59,7 +58,6 @@ function searchRange(nums: number[], target: number): number[] { //NOSONAR
                 right1 = mid1 - 1
             }
         }
-
         if (left2 <= right2) {
             let mid2 = Math.floor((left2 + right2) / 2)
             if (nums[mid2] == target) {

src/main/ts/g0001_0100/s0036_valid_sudoku/readme.md

@@ -67,19 +67,16 @@ function isValidSudoku(board: string[][]): boolean {
     let rowSet: number[] = new Array(9).fill(0)
     let colSet: number[] = new Array(9).fill(0)
     let boxSet: number[] = new Array(9).fill(0)
-
     for (let i = 0; i < 9; i++) {
         for (let j = 0; j < 9; j++) {
             if (board[i][j] === '.') {
                 continue
             }
             let val = board[i][j].charCodeAt(0) - '0'.charCodeAt(0)
             let boxIndex = Math.floor(i / 3) * 3 + Math.floor(j / 3)
-
             if (rowSet[i] & (1 << val) || colSet[j] & (1 << val) || boxSet[boxIndex] & (1 << val)) {
                 return false
             }
-
             rowSet[i] |= 1 << val
             colSet[j] |= 1 << val
             boxSet[boxIndex] |= 1 << val

src/main/ts/g0001_0100/s0039_combination_sum/readme.md

@@ -60,7 +60,6 @@ It is **guaranteed** that the number of unique combinations that sum up to `targ
 function combinationSum(candidates: number[], target: number): number[][] {
     const result: number[][] = []
     const path: number[] = []
-
     const comFunct = (index: number, sum: number) => {
         if (sum === target) {
             result.push([...path])

src/main/ts/g0001_0100/s0054_spiral_matrix/readme.md

@@ -39,29 +39,24 @@ function spiralOrder(matrix: number[][]): number[] {
         c = 0
     let bigR = matrix.length - 1
     let bigC = matrix[0].length - 1
-
     while (r <= bigR && c <= bigC) {
         for (let i = c; i <= bigC; i++) {
             result.push(matrix[r][i])
         }
         r++
-
         for (let i = r; i <= bigR; i++) {
             result.push(matrix[i][bigC])
         }
         bigC--
-
         for (let i = bigC; i >= c && r <= bigR; i--) {
             result.push(matrix[bigR][i])
         }
         bigR--
-
         for (let i = bigR; i >= r && c <= bigC; i--) {
             result.push(matrix[i][c])
         }
         c++
     }
-
     return result
 }
 

src/main/ts/g0001_0100/s0070_climbing_stairs/readme.md

@@ -33,9 +33,15 @@ Each time you can either climb `1` or `2` steps. In how many distinct ways can y
 
 ```typescript
 function climbStairs(n: number, memo: Record<string, number> = {}): number {
-    if (n in memo) return memo[n]
-    if (n === 0) return 1
-    if (n < 0) return 0
+    if (n in memo) {
+        return memo[n]
+    }
+    if (n === 0) {
+        return 1
+    }
+    if (n < 0) {
+        return 0
+    }
     memo[n] = climbStairs(n - 1, memo) + climbStairs(n - 2, memo)
     return memo[n]
 }

src/main/ts/g0001_0100/s0072_edit_distance/readme.md

@@ -42,7 +42,9 @@ function minDistance(word1: string, word2: string): number {
     const l1 = word1.length
     const l2 = word2.length
     const dfs = (w1: number, w2: number): number => {
-        if (memo[w1][w2] != undefined) return memo[w1][w2]
+        if (memo[w1][w2] != undefined) {
+            return memo[w1][w2]
+        }
         if (w1 == l1 && w2 == l2) {
             memo[w1][w2] = 0
             return 0