Updated readme

Author: javadev

README.md

@@ -35,40 +35,21 @@ You can assume that you can always reach the last index.
 ## Solution
 
 ```typescript
-function jump(nums: number[]): number { //NOSONAR
-    let minJmp = new Array(nums.length)
-    if (nums.length === 1) return 0
-    let prevIndex = 0
-    minJmp[prevIndex] = 0
-    while (prevIndex < nums.length - 1) {
-        let nextMaxJmpTo = nums[prevIndex] + prevIndex
-        let prevIndexJmp = minJmp[prevIndex]
-
-        let farthestJumpVal = -1
-        let farthestJumpIndex = -1
-        for (let i = nextMaxJmpTo; ; i--) {
-            if (i >= nums.length) {
-                continue
-            }
-            if (i === nums.length - 1) {
-                return prevIndexJmp + 1
-            }
-            if (minJmp[i] != undefined) {
-                break
-            }
-            minJmp[i] = prevIndexJmp + 1
-            let curmaxTo = nums[i] + i
-            if (farthestJumpVal < curmaxTo) {
-                farthestJumpVal = curmaxTo
-                farthestJumpIndex = i
-            }
+function jump(nums: number[]): number {
+    let minJump = 0,
+        farthest = 0,
+        currentEnd = 0
+    for (let i = 0; i < nums.length - 1; i++) {
+        farthest = Math.max(farthest, i + nums[i])
+        // If we've reached the end of the current jump range
+        if (i === currentEnd) {
+            minJump++
+            currentEnd = farthest
+
+            if (currentEnd >= nums.length - 1) break
         }
-        if (farthestJumpIndex === -1) {
-            return -1
-        }
-        prevIndex = farthestJumpIndex
     }
-    return minJmp[nums.length - 1]
+    return minJump
 }
 
 export { jump }

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

@@ -53,16 +53,15 @@ How many possible unique paths are there?
 
 ```typescript
 function uniquePaths(m: number, n: number): number {
-    const factorialize = (x: number) => {
-        if (x <= 1) return 1
-        let res = x
-        while (x > 1) {
-            x--
-            res *= x
+    let aboveRow = Array(n).fill(1)
+    for (let row = 1; row < m; row++) {
+        let currentRow = Array(n).fill(1)
+        for (let col = 1; col < n; col++) {
+            currentRow[col] = currentRow[col - 1] + aboveRow[col]
         }
-        return res
+        aboveRow = currentRow
     }
-    return factorialize(m + n - 2) / factorialize(m - 1) / factorialize(n - 1)
+    return aboveRow[n - 1]
 }
 
 export { uniquePaths }

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

@@ -30,7 +30,7 @@ The solution set **must not** contain duplicate subsets. Return the solution in
 ## Solution
 
 ```typescript
-const subsets = (nums: number[]): number[][] => {
+function subsets(nums: number[]): number[][] {
     const sets: number[][] = [[]]
     for (const num of nums) sets.push(...sets.map((set) => [...set, num]))
     return sets

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

@@ -32,16 +32,19 @@ You must write an algorithm that runs in `O(n)` time.
 
 ```typescript
 function longestConsecutive(nums: number[]): number {
-    const set = new Set(nums)
-    let max = 0
-    for (const num of nums) {
-        if (set.has(num + 1)) continue
-        let counter = 1,
-            current = num
-        while (set.has(--current)) counter++
-        max = Math.max(counter, max)
+    let sset = new Set(nums)
+    let maxLen = 0
+    for (let num of sset) {
+        // check its start of the sequence
+        if (!sset.has(num-1)) {
+            let len = 0;
+            while (sset.has(num+len)) {
+                len += 1
+            }
+            maxLen = Math.max(maxLen, len)
+        }
     }
-    return max
+    return maxLen
 }
 
 export { longestConsecutive }

src/main/ts/g0101_0200/s0128_longest_consecutive_sequence/readme.md

@@ -30,8 +30,17 @@ Note that it is the <code>k<sup>th</sup></code> largest element in the sorted or
 
 ```typescript
 function findKthLargest(nums: number[], k: number): number {
-    nums.sort((prev, next) => next - prev)
-    return nums[k - 1]
+    const countingLen = 2e4 + 1
+    const counting = new Int32Array(countingLen)
+    for (const num of nums) {
+        counting[num + 1e4]++;
+    }
+    for (let i = countingLen - 1; i >= 0; i--) {
+        k -= counting[i]
+        if (k <= 0) {
+            return i - 1e4
+        }
+    }
 }
 
 export { findKthLargest }