Merge branch 'neetcode-gh:main' into main

Author: adelajaOlamilekan

Diff for: README.md

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    void sortColors(vector<int>& nums) {
+        int p1=0,p2=nums.size()-1;
+        for(int i=p1;i<=p2;i++)
+        {
+            if(nums[i]==0)
+            {
+                swap(nums[i],nums[p1]);
+                p1++;
+            }
+            if(nums[i]==2)
+            {
+                swap(nums[i],nums[p2]);
+                p2--;
+                i--;
+            }
+        }
+        
+        
+    }
+};

Diff for: cpp/0075-Sort-colors.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
+        int j=0;
+        int i=0;
+        if(n==0) return;
+        if(m==0)
+        {  
+         for(int i = 0; i < n; i++){
+                nums1[i] = nums2[i];
+            } return;
+        } 
+        while(i<m)
+        {
+            if(nums1[i]>nums2[j])
+            {
+                swap(nums1[i],nums2[j]);
+                sort(nums2.begin(),nums2.end());
+            }
+            i++;
+        }
+        j=0;
+        while(i<m+n)
+        {
+            nums1[i] = nums2[j];
+            j++;
+            i++;
+        }
+        
+    }
+};

Diff for: cpp/0088-Merge-sorted-array.cpp

@@ -0,0 +1,41 @@
+func isMatch(s string, p string) bool {
+    // dp[i][j] is true if p[:i] matches s[:j]
+    dp := make([][]bool, len(p) + 1)
+    for i := 0; i < len(p) + 1; i++ {
+        dp[i] = make([]bool, len(s) + 1)
+        for j := 0; j < len(s) + 1; j++ {
+            dp[i][j] = false
+        }
+    }
+
+    dp[0][0] = true
+
+    // Base case for i = 0 is already set up, as empty pattern can only match empty string
+    // But a nonempty pattern can match an empty string, so we do base cases for j = 0
+    for i := 1; i < len(p); i++ {
+        if p[i] == '*' {
+            dp[i + 1][0] = dp[i - 1][0]
+        }
+    }
+    
+    // Now for the general case
+    for i := 0; i < len(p); i++ {
+        for j := 0; j < len(s); j++ {
+            if p[i] == '.' || p[i] == s[j] {
+                // Single character matches
+                dp[i + 1][j + 1] = dp[i][j]
+            } else if p[i] == '*' {
+                // Wildcard - check that the character matches
+                // or if we can have 0 repetitions of the previous char
+                dp[i + 1][j + 1] = dp[i - 1][j + 1] || dp[i][j + 1]
+                if p[i - 1] == '.' || p[i - 1] == s[j] {
+                    if dp[i + 1][j] {
+                        dp[i + 1][j + 1] = dp[i + 1][j]
+                    }
+                }
+            }
+        }
+    }
+
+    return dp[len(p)][len(s)]
+}

Diff for: go/0010-regular-expression-matching.go

@@ -0,0 +1,47 @@
+func ladderLength(beginWord string, endWord string, wordList []string) int {
+    if !contains(wordList, endWord) {
+        return 0
+    }
+    
+    nei := make(map[string][]string)
+    wordList = append(wordList, beginWord)
+    for _, word := range wordList {
+        for j := 0; j < len(word); j++ {
+            pattern := word[:j] + "*" + word[j + 1:]
+            nei[pattern] = append(nei[pattern], word)
+        }
+    }
+    
+    visit := map[string]bool{beginWord: true}
+    q := []string{beginWord}
+    res := 1
+    for len(q) != 0 {
+        for tmp := len(q); tmp > 0; tmp-- {
+            word := q[0]
+            q = q[1:]
+            if word == endWord {
+                return res
+            }
+            for j := 0; j < len(word); j++ {
+                pattern := word[:j] + "*" + word[j + 1:]
+                for _, neiWord := range nei[pattern] {
+                    if !visit[neiWord] {
+                        visit[neiWord] = true
+                        q = append(q, neiWord)
+                    }
+                }
+            }
+        }
+        res += 1
+    }
+    return 0
+}
+
+func contains(s []string, word string) bool {
+    for _, element := range s {
+        if element == word {
+            return true
+        }
+    }
+    return false
+}

Diff for: go/0127-word-ladder.go

@@ -0,0 +1,41 @@
+const CRS = 0
+const PRE = 1
+func findOrder(numCourses int, prerequisites [][]int) []int {
+    prereq := make([][]int, 0)
+    for i := 0; i < numCourses; i++ {
+        prereq = append(prereq, make([]int, 0))
+    }
+    for _, edge := range prerequisites {
+        prereq[edge[CRS]] = append(prereq[edge[CRS]], edge[PRE])
+    }
+    
+    output := make([]int, 0)
+    visit, cycle := make([]bool, numCourses), make([]bool, numCourses)
+    
+    var dfs func(int) bool
+    dfs = func(crs int) bool {
+        if cycle[crs] {
+            return false
+        } else if visit[crs] {
+            return true
+        }
+        
+        cycle[crs] = true
+        for _, pre := range prereq[crs] {
+            if !dfs(pre) {
+                return false
+            }
+        }
+        cycle[crs] = false
+        visit[crs] = true
+        output = append(output, crs)
+        return true
+    }
+    
+    for c := 0; c < numCourses; c++ {
+        if dfs(c) == false {
+            return []int{}
+        }
+    }
+    return output
+}

Diff for: go/0210-course-schedule-ii.go

@@ -0,0 +1,8 @@
+func moveZeroes(nums []int) {
+	for l, r := 0, 0; r < len(nums); r++ {
+		if nums[r] != 0 {
+			nums[l], nums[r] = nums[r], nums[l]
+			l++
+		}
+	}
+}

Diff for: go/0283-move-zeroes.go

@@ -0,0 +1,20 @@
+func wordPattern(pattern string, s string) bool {
+	words := strings.Split(s, " ")
+	if len(pattern) != len(words) {
+		return false
+	}
+
+	seenChr, seenWord := make(map[byte]int, len(pattern)), make(map[string]int, len(pattern))
+	for i := 0; i < len(pattern); i++ {
+		chrPos, chrOk := seenChr[pattern[i]]
+		wordPos, wordOk := seenWord[words[i]]
+		if chrOk != wordOk || chrPos != wordPos {
+			return false
+		}
+
+		seenChr[pattern[i]] = i
+		seenWord[words[i]] = i
+	}
+
+	return true
+}

Diff for: go/0283-move-zeros.go

@@ -0,0 +1,50 @@
+type IntHeap []int
+func (h IntHeap) Len() int           { return len(h) }
+func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *IntHeap) Push(x interface{}) {*h = append(*h, x.(int))}
+func (h *IntHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+type MedianFinder struct {
+    small IntHeap
+    large IntHeap
+}
+
+
+func Constructor() MedianFinder {
+    return MedianFinder{small: IntHeap{}, large: IntHeap{}}
+}
+
+
+func (this *MedianFinder) AddNum(num int)  {
+    if len(this.large) > 0 && num > this.large[0] {
+        heap.Push(&this.large, num)
+    } else {
+        heap.Push(&this.small, -1 * num)
+    }
+    
+    if len(this.small) > len(this.large) + 1 {
+        val := -1 * heap.Pop(&this.small).(int)
+        heap.Push(&this.large, val)
+    }
+    if len(this.large) > len(this.small) + 1 {
+        val := heap.Pop(&this.large).(int)
+        heap.Push(&this.small, -1 * val)
+    }
+}
+
+
+func (this *MedianFinder) FindMedian() float64 {
+    if len(this.small) > len(this.large) {
+        return float64(-1 * this.small[0])
+    } else if len(this.large) > len(this.small) {
+        return float64(this.large[0])
+    }
+    return float64(-1 * this.small[0] + this.large[0]) / 2
+}

Diff for: go/0290-word-pattern.go

@@ -0,0 +1,42 @@
+func pacificAtlantic(heights [][]int) [][]int {
+    ROWS, COLS := len(heights), len(heights[0])
+    pac, atl := make(map[int]bool), make(map[int] bool)
+    
+    var dfs func(int, int, map[int]bool, int)
+    dfs = func(r, c int, visit map[int]bool, prevHeight int) {
+        if (
+            visit[r*COLS + c] ||
+            r < 0 ||
+            c < 0 ||
+            r == ROWS ||
+            c == COLS ||
+            heights[r][c] < prevHeight) {
+            return;
+        }
+        visit[r*COLS + c] = true
+        dfs(r + 1, c, visit, heights[r][c])
+        dfs(r - 1, c, visit, heights[r][c])
+        dfs(r, c + 1, visit, heights[r][c])
+        dfs(r, c - 1, visit, heights[r][c])
+    }
+    
+    for c := 0; c < COLS; c++ {
+        dfs(0, c, pac, heights[0][c])
+        dfs(ROWS - 1, c, atl, heights[ROWS - 1][c])
+    }
+    
+    for r := 0; r < ROWS; r++ {
+        dfs(r, 0, pac, heights[r][0])
+        dfs(r, COLS - 1, atl, heights[r][COLS - 1])
+    }
+    
+    res := make([][]int, 0)
+    for r := 0; r < ROWS; r++ {
+        for c := 0; c < COLS; c++ {
+            if pac[r*COLS + c] && atl[r*COLS + c] {
+                res = append(res, []int{r, c})
+            }
+        }
+    }
+    return res
+}

Diff for: go/0295-find-median-from-data-stream.go

@@ -0,0 +1,29 @@
+func islandPerimeter(grid [][]int) int {
+    ROWS, COLS := len(grid), len(grid[0])
+    visit := make(map[int]bool)
+    
+    var dfs func(int, int) int
+    dfs = func(i, j int) int {
+        if i >= ROWS || j >= COLS || i < 0 || j < 0 || grid[i][j] == 0 {
+            return 1
+        } else if visit[i*COLS + j] {
+            return 0
+        }
+        
+        visit[i*COLS + j] = true
+        perim := dfs(i, j + 1)
+        perim += dfs(i + 1, j)
+        perim += dfs(i, j - 1)
+        perim += dfs(i - 1, j)
+        return perim
+    }
+    
+    for i := 0; i < ROWS; i++ {
+        for j := 0; j < COLS; j++ {
+            if grid[i][j] != 0 {
+                return dfs(i, j)
+            }
+        }
+    }
+    return -1
+}

Diff for: go/0417-pacific-atlantic-water-flow.go

@@ -0,0 +1,26 @@
+func isAlienSorted(words []string, order string) bool {
+    // first differing char
+    // if word A is prefix of word B, word B must be AFTER word A
+    orderInd := make(map[byte]int)
+    for i := 0; i < len(order); i++ {
+        orderInd[order[i]] = i
+    }
+    
+    for i := 0; i < len(words) - 1; i++ {
+        w1, w2 := words[i], words[i + 1]
+        
+        for j := 0; j < len(w1); j++ {
+            if j == len(w2) {
+                return false
+            }
+            
+            if w1[j] != w2[j] {
+                if orderInd[w2[j]] < orderInd[w1[j]] {
+                    return false
+                }
+                break
+            }
+        }
+    }
+    return true
+}