Updated readme

Author: javadev

README.md

@@ -5,33 +5,33 @@
 
 Hard
 
-Given an unsorted integer array `nums`, return the smallest missing positive integer.
+Given an unsorted integer array `nums`. Return the _smallest positive integer_ that is _not present_ in `nums`.
 
-You must implement an algorithm that runs in `O(n)` time and uses constant extra space.
+You must implement an algorithm that runs in `O(n)` time and uses `O(1)` auxiliary space.
 
 **Example 1:**
 
 **Input:** nums = [1,2,0]
 
 **Output:** 3
 
-**Explanation:** The numbers in the range [1,2] are all in the array.
+**Explanation:** The numbers in the range [1,2] are all in the array. 
 
 **Example 2:**
 
 **Input:** nums = [3,4,-1,1]
 
 **Output:** 2
 
-**Explanation:** 1 is in the array but 2 is missing.
+**Explanation:** 1 is in the array but 2 is missing. 
 
 **Example 3:**
 
 **Input:** nums = [7,8,9,11,12]
 
 **Output:** 1
 
-**Explanation:** The smallest positive integer 1 is missing.
+**Explanation:** The smallest positive integer 1 is missing. 
 
 **Constraints:**
 
@@ -47,35 +47,30 @@ func firstMissingPositive(nums []int) int {
 			nums[i] = 0
 		}
 	}
-
 	for i := 0; i < len(nums); i++ {
 		val := abs(nums[i])
 		if val > 0 && val <= len(nums) {
 			if nums[val-1] > 0 {
 				nums[val-1] = nums[val-1] * -1
 				continue
 			}
-
 			if nums[val-1] == 0 {
 				nums[val-1] = -1 * (len(nums) + 1)
 			}
 		}
 	}
-
 	for i := 1; i <= len(nums); i++ {
 		if nums[i-1] >= 0 {
 			return i
 		}
 	}
-
 	return len(nums) + 1
 }
 
 func abs(n int) int {
 	if n >= 0 {
 		return n
 	}
-
 	return n * -1
 }
 ```

src/main/go/g0001_0100/s0041_first_missing_positive/readme.md

@@ -5,32 +5,34 @@
 
 Medium
 
-Given an array of non-negative integers `nums`, you are initially positioned at the first index of the array.
+You are given a **0-indexed** array of integers `nums` of length `n`. You are initially positioned at `nums[0]`.
 
-Each element in the array represents your maximum jump length at that position.
+Each element `nums[i]` represents the maximum length of a forward jump from index `i`. In other words, if you are at `nums[i]`, you can jump to any `nums[i + j]` where:
 
-Your goal is to reach the last index in the minimum number of jumps.
+*   `0 <= j <= nums[i]` and
+*   `i + j < n`
 
-You can assume that you can always reach the last index.
+Return _the minimum number of jumps to reach_ `nums[n - 1]`. The test cases are generated such that you can reach `nums[n - 1]`.
 
 **Example 1:**
 
 **Input:** nums = [2,3,1,1,4]
 
 **Output:** 2
 
-**Explanation:** The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
+**Explanation:** The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index. 
 
 **Example 2:**
 
 **Input:** nums = [2,3,0,1,4]
 
-**Output:** 2
+**Output:** 2 
 
 **Constraints:**
 
 *   <code>1 <= nums.length <= 10<sup>4</sup></code>
 *   `0 <= nums[i] <= 1000`
+*   It's guaranteed that you can reach `nums[n - 1]`.
 
 ## Solution
 

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

@@ -5,25 +5,25 @@
 
 Medium
 
-Given an array `nums` of distinct integers, return _all the possible permutations_. You can return the answer in **any order**.
+Given an array `nums` of distinct integers, return all the possible permutations. You can return the answer in **any order**.
 
 **Example 1:**
 
 **Input:** nums = [1,2,3]
 
-**Output:** [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+**Output:** [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 
 
 **Example 2:**
 
 **Input:** nums = [0,1]
 
-**Output:** [[0,1],[1,0]]
+**Output:** [[0,1],[1,0]] 
 
 **Example 3:**
 
 **Input:** nums = [1]
 
-**Output:** [[1]]
+**Output:** [[1]] 
 
 **Constraints:**
 

src/main/go/g0001_0100/s0046_permutations/readme.md

@@ -65,27 +65,14 @@ type ListNode struct {
  * }
  */
 func detectCycle(head *ListNode) *ListNode {
-	if head == nil || head.Next == nil {
-		return nil
-	}
-	slow := head
-	fast := head
-	for fast != nil && fast.Next != nil {
-		fast = fast.Next.Next
-		slow = slow.Next
-		// intersected inside the loop.
-		if slow == fast {
-			break
+	m := map[*ListNode]bool{}
+	for head != nil {
+		if m[head] == true {
+			return head
 		}
+		m[head] = true
+		head = head.Next
 	}
-	if fast == nil || fast.Next == nil {
-		return nil
-	}
-	slow = head
-	for slow != fast {
-		slow = slow.Next
-		fast = fast.Next
-	}
-	return slow
+	return nil
 }
 ```

src/main/go/g0101_0200/s0142_linked_list_cycle_ii/readme.md

@@ -39,8 +39,6 @@ Given the `head` of a linked list, return _the list after sorting it in **ascend
 ## Solution
 
 ```golang
-import "slices"
-
 type ListNode struct {
 	Val  int
 	Next *ListNode
@@ -54,22 +52,46 @@ type ListNode struct {
  * }
  */
 func sortList(head *ListNode) *ListNode {
-	curr := head
-	a := []*ListNode{}
-	for curr != nil {
-		a = append(a, curr)
-		curr = curr.Next
+	if head == nil || head.Next == nil {
+		return head
+	}
+	mid := findMid(head)
+	left := sortList(head)
+	right := sortList(mid)
+	return merge(left, right)
+}
+
+func findMid(head *ListNode) *ListNode {
+	var prev *ListNode
+	slow, fast := head, head
+	for fast != nil && fast.Next != nil {
+		prev = slow
+		slow = slow.Next
+		fast = fast.Next.Next
+	}
+	prev.Next = nil
+	return slow
+}
+
+func merge(left, right *ListNode) *ListNode {
+	pointer := new(ListNode)
+	res := pointer
+	for left != nil && right != nil {
+		if left.Val < right.Val {
+			pointer.Next = left
+			left = left.Next
+		} else {
+			pointer.Next = right
+			right = right.Next
+		}
+		pointer = pointer.Next
+	}
+	if left != nil {
+		pointer.Next = left
 	}
-	slices.SortFunc(a, func(l1, l2 *ListNode) int {
-		return l1.Val - l2.Val
-	})
-	newNode := &ListNode{}
-	curr = newNode
-	for _, node := range a {
-		curr.Next = node
-		curr = node
+	if right != nil {
+		pointer.Next = right
 	}
-	curr.Next = nil
-	return newNode.Next
+	return res.Next
 }
 ```

src/main/go/g0101_0200/s0148_sort_list/readme.md

@@ -38,35 +38,44 @@ Return `true` if you can finish all courses. Otherwise, return `false`.
 ## Solution
 
 ```golang
+type State int
+
+const (
+	Unvisited State = iota
+	Visiting
+	Visited
+)
+
 func canFinish(numCourses int, prerequisites [][]int) bool {
-	graph := map[int][]int{}
-	for _, edge := range prerequisites {
-		graph[edge[1]] = append(graph[edge[1]], edge[0])
+	visited := make([]State, numCourses)
+	graph := make([][]int, numCourses)
+	for _, dep := range prerequisites {
+		graph[dep[1]] = append(graph[dep[1]], dep[0])
 	}
-	indegree := make([]int, numCourses)
-	queue := []int{}
 	for i := 0; i < numCourses; i++ {
-		for _, v := range graph[i] {
-			indegree[v]++
+		if visited[i] == Unvisited {
+			if !dfs(i, visited, graph) {
+				return false
+			}
 		}
 	}
-	for i := 0; i < numCourses; i++ {
-		if indegree[i] == 0 {
-			queue = append(queue, i)
-		}
+	return true
+}
+
+func dfs(start int, visited []State, graph [][]int) bool {
+	if visited[start] == Visiting {
+		return false
 	}
-	visited := 0
-	for len(queue) > 0 {
-		node := queue[0]
-		queue = queue[1:]
-		visited++
-		for _, v := range graph[node] {
-			indegree[v]--
-			if indegree[v] == 0 {
-				queue = append(queue, v)
-			}
+	if visited[start] == Visited {
+		return true
+	}
+	visited[start] = Visiting
+	for _, next := range graph[start] {
+		if !dfs(next, visited, graph) {
+			return false
 		}
 	}
-	return visited == numCourses
+	visited[start] = Visited
+	return true
 }
 ```

src/main/go/g0201_0300/s0207_course_schedule/readme.md

@@ -55,25 +55,21 @@ func findTargetSumWays(nums []int, s int) int {
 	for _, num := range nums {
 		sum += num
 	}
-
 	if s > sum || (sum+s)%2 != 0 {
 		return 0
 	}
-
 	dp := make([][]int, (sum+s)/2+1)
 	for i := range dp {
 		dp[i] = make([]int, len(nums)+1)
 	}
 	dp[0][0] = 1
-
 	for i := 0; i < len(nums); i++ {
 		if nums[i] == 0 {
 			dp[0][i+1] = dp[0][i] * 2
 		} else {
 			dp[0][i+1] = dp[0][i]
 		}
 	}
-
 	for i := 1; i < len(dp); i++ {
 		for j := 0; j < len(nums); j++ {
 			dp[i][j+1] += dp[i][j]
@@ -82,7 +78,6 @@ func findTargetSumWays(nums []int, s int) int {
 			}
 		}
 	}
-
 	return dp[(sum+s)/2][len(nums)]
 }
 ```