forked from neetcode-gh/leetcode
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge branch 'main' of https://github.com/gautham-8/neetcode-gh-leetcode
- Loading branch information
Showing
3 changed files
with
180 additions
and
2 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,42 @@ | ||
| /* | ||
| Given an integer n, our task is to count how many strings of length n can be formed under the following rules: | ||
| Each character is a lower case vowel ('a', 'e', 'i', 'o', 'u') | ||
| Each vowel 'a' may only be followed by an 'e'. | ||
| Each vowel 'e' may only be followed by an 'a' or an 'i'. | ||
| Each vowel 'i' may not be followed by another 'i'. | ||
| Each vowel 'o' may only be followed by an 'i' or a 'u'. | ||
| Each vowel 'u' may only be followed by an 'a'. | ||
| Since the answer may be too large, we have to return it modulo 10^9 + 7. | ||
| Example. For n = 2, Output = 10 | ||
| Explanation: All possible strings of length 2 that can be formed as per the given rules are: "ae", "ea", "ei", "ia", "ie", "io", "iu", | ||
| "oi", "ou" and "ua". | ||
| So we return 10 as our answer. | ||
| Time: O(n) | ||
| Space: O(1) | ||
| */ | ||
|
|
||
|
|
||
| class Solution { | ||
| const unsigned int mod = 1e9+7; | ||
| public: | ||
| int countVowelPermutation(int n) { | ||
| vector<int> prev(5,1), curr(5, 0); | ||
| for(int i=1; i<n; i++) { | ||
| curr[0] = prev[1] % mod; | ||
| curr[1] = (prev[0] + prev[2]) % mod; | ||
| curr[2] = ((prev[0] % mod) + (prev[1] % mod) + (prev[3] % mod) + (prev[4] % mod)) % mod; | ||
| curr[3] = (prev[4] + prev[2]) % mod; | ||
| curr[4] = prev[0] % mod; | ||
| prev = curr; | ||
| } | ||
| int ans = 0; | ||
| for(auto &a:prev) ans = (ans + a) % mod; | ||
| return ans; | ||
| } | ||
| }; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,136 @@ | ||
| /* | ||
| * Merge sort | ||
| */ | ||
| class Solution { | ||
| fun sortArray(nums: IntArray): IntArray { | ||
| mergeSort(nums, 0, nums.lastIndex) | ||
| return nums | ||
| } | ||
|
|
||
| private fun mergeSort(nums: IntArray, left: Int, right: Int) { | ||
| if(left == right) return | ||
|
|
||
| val mid = (left + right) / 2 | ||
| mergeSort(nums, left, mid) | ||
| mergeSort(nums, mid + 1, right) | ||
| merge(nums, left, mid, right) | ||
|
|
||
| return | ||
| } | ||
|
|
||
| private fun merge(nums: IntArray, left: Int, mid: Int, right: Int) { | ||
| val leftPart = nums.copyOfRange(left, mid + 1) | ||
| val rightPart = nums.copyOfRange(mid + 1, right + 1) | ||
| var i = left | ||
| var j = 0 | ||
| var k = 0 | ||
|
|
||
| while(j < leftPart.size && k < rightPart.size) { | ||
| if(leftPart[j] <= rightPart[k]) { | ||
| nums[i] = leftPart[j] | ||
| j++ | ||
| }else{ | ||
| nums[i] = rightPart[k] | ||
| k++ | ||
| } | ||
| i++ | ||
| } | ||
|
|
||
| while(j < leftPart.size) { | ||
| nums[i] = leftPart[j] | ||
| j++ | ||
| i++ | ||
| } | ||
|
|
||
| while(k < rightPart.size) { | ||
| nums[i] = rightPart[k] | ||
| k++ | ||
| i++ | ||
| } | ||
| } | ||
| } | ||
|
|
||
| /* | ||
| * Quick sort | ||
| * This will fail testcase 17/19 (used to pass earlier, before adding new testcases), I still added it here for interest. | ||
| * It fails on test case where we have an array with many elements of which all are 2's. This will have quicksort to run as | ||
| * its worst case, which is O(n^2). But on average this will run O(nlogn) | ||
| */ | ||
| class Solution { | ||
| fun sortArray(nums: IntArray): IntArray { | ||
|
|
||
| quickSort(nums, 0, nums.lastIndex) | ||
| return nums | ||
| } | ||
|
|
||
| private fun quickSort(nums: IntArray, low: Int, high: Int) { | ||
| if (low < high) { | ||
| val pivotIndex = partition(nums, low, high) | ||
| quickSort(nums, low, pivotIndex - 1) | ||
| quickSort(nums, pivotIndex + 1, high) | ||
| } | ||
| } | ||
|
|
||
| private fun partition(nums: IntArray, low: Int, high: Int): Int { | ||
| val pivot = nums[high] | ||
| var i = low | ||
|
|
||
| for(j in low until high) { | ||
| if (nums[j] <= pivot) { | ||
| nums.swap(i, j) | ||
| i++ | ||
| } | ||
| } | ||
|
|
||
| nums.swap(i, high) | ||
| return i | ||
| } | ||
|
|
||
| fun IntArray.swap(i: Int, j: Int) { | ||
| this[i] = this[j].also{ this[j] = this[i] } | ||
| } | ||
| } | ||
|
|
||
| /* | ||
| * Heap sort | ||
| */ | ||
| class Solution { | ||
| fun sortArray(nums: IntArray): IntArray { | ||
|
|
||
| heapSort(nums) | ||
| return nums | ||
| } | ||
|
|
||
| private fun heapSort(nums: IntArray) { | ||
| val n = nums.size | ||
|
|
||
| for(i in (n/2 - 1) downTo 0) | ||
| heapify(nums, n, i) | ||
|
|
||
| for(i in n-1 downTo 0) { | ||
| nums.swap(0, i) | ||
| heapify(nums, i, 0) | ||
| } | ||
| } | ||
|
|
||
| private fun heapify(nums: IntArray, n: Int, i: Int) { | ||
| var largest = i | ||
|
|
||
| val left = 2 * i + 1 | ||
| val right = 2 * i + 2 | ||
|
|
||
| if(left < n && nums[left] > nums[largest]) | ||
| largest = left | ||
| if(right < n && nums[right] > nums[largest]) | ||
| largest = right | ||
|
|
||
| if(largest != i) { | ||
| nums.swap(i, largest) | ||
| heapify(nums, n, largest) | ||
| } | ||
| } | ||
|
|
||
| fun IntArray.swap(i: Int, j: Int) { | ||
| this[i] = this[j].also{ this[j] = this[i] } | ||
| } | ||
| } |