This C# code calculates the total number of vowels within a given string. It is designed to be case-insensitive, meaning both 'a' and 'A' are counted as vowels. This functionality is commonly used in text analysis, natur...

The `CountVowels` function iterates through each character of the input string `text`. It maintains a counter `vowelCount`, initialized to zero. For every character, it checks if it exists within a predefined string containing all lowercase and uppercase vowels (`"aeiouAEIOU"`). If a character is found in the vowel string, the `vowelCount` is incremented. The function handles edge cases by returning 0 if the input string is null or empty, preventing potential `NullReferenceException` or unnecessary iteration. The time complexity is O(n), where n is the length of the string, because each character is examined exactly once. The `string.Contains()` operation on a small, fixed-size string like `vowels` is effectively O(1). The space complexity is O(1) as it only uses a constant amount of extra space for variables. The algorithm is correct because it systematically checks every character against the complete set of vowels and correctly increments the count for each match.

function CountVowels(text): if text is null or empty: return 0 vowelCount = 0 vowels = "aeiouAEIOU" for each character `currentChar` in `text`: if `vowels` contains `currentChar`: increment `vowelCount` return `vowelCoun...

This C# code finds a peak element in a 2D grid. A peak element is defined as an element that is strictly greater than all its adjacent neighbors (up, down, left, right). The algorithm uses a binary search approach on the...

The `FindPeakElement` function aims to locate any element in a 2D grid that is greater than its immediate neighbors. It employs a binary search strategy across the columns. In each step of the binary search, it identifies the row containing the maximum value within the current `midCol`. It then compares this maximum element with its left and right neighbors. If the element is greater than both, it checks its up and down neighbors to confirm if it's a 2D peak. If the element is smaller than its left neighbor, the search space is narrowed to the left half of the columns; otherwise, it's narrowed to the right half. The `FindMaxInColumn` helper efficiently finds the row index of the maximum element in a specified column. The time complexity is O(rows * log(cols)) because for each column in the binary search (log(cols) iterations), we scan the entire column to find the maximum (rows operations). The space complexity is O(1) as it only uses a few variables for tracking indices and values. Edge cases like null or empty grids, and single-element grids are handled. The correctness relies on the fact that if the maximum element in a column is not a peak, its larger neighbor must lie in the direction of that neighbor, guiding the binary search towards a region containing a peak.

function FindPeakElement(grid): if grid is null or empty: return [-1, -1] rows = number of rows in grid cols = number of columns in grid if rows == 1 and cols == 1: return [0, 0] left = 0 right = cols - 1 while left <= r...

This C# code efficiently finds the minimum element in a rotated sorted array. A rotated sorted array is an array that was originally sorted in ascending order and then had its elements shifted cyclically. The algorithm u...

The `FindMin` function aims to find the smallest element in an array that was originally sorted and then rotated. It employs a binary search strategy. The core idea is to compare the middle element (`nums[mid]`) with the rightmost element (`nums[right]`). If `nums[mid] > nums[right]`, it implies that the rotation point (and thus the minimum element) must lie in the right half of the array (from `mid + 1` to `right`), because the right half is 'out of order' relative to the left half. Therefore, we update `left = mid + 1`. Conversely, if `nums[mid] <= nums[right]`, it means the minimum element is either `nums[mid]` itself or lies in the left half (from `left` to `mid`), as this segment is still in ascending order or `nums[mid]` is the minimum. In this case, we update `right = mid`. The loop continues until `left` equals `right`, at which point `nums[left]` (or `nums[right]`) is the minimum element. The initial check `if (nums[left] <= nums[right])` handles the edge case where the array is not rotated at all or rotated by `n` elements, in which case the first element is the minimum. The time complexity is O(log n) due to the binary search. The space complexity is O(1) as it only uses a few variables. This algorithm correctly identifies the minimum by progressively narrowing down the search space based on the properties of a rotated sorted array.

function FindMin(nums): if nums is null or empty: throw an exception left = 0 right = length of nums - 1 // If the array is not rotated, the first element is the minimum. if nums[left] <= nums[right]: return nums[left] w...

This C# function reverses the order of words in a given string. It intelligently handles cases with multiple spaces between words, as well as leading and trailing spaces, ensuring the output string has words separated by...

The `ReverseWords` function takes a string `s` and returns a new string with the words in reversed order. First, it checks for null or whitespace input using `string.IsNullOrWhiteSpace(s)`, returning an empty string if true. This handles edge cases like null, empty, or strings containing only spaces. The core logic involves splitting the input string into an array of words using `s.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)`. The `RemoveEmptyEntries` option is crucial as it automatically discards any empty strings that result from multiple spaces or leading/trailing spaces, ensuring only actual words are captured. After splitting, `Array.Reverse(words)` is called to reverse the order of elements in the `words` array. Finally, `string.Join(" ", words)` concatenates the reversed words back into a single string, using a single space as the delimiter. The time complexity is dominated by the split and join operations, which are typically O(n), where n is the length of the string. The `Array.Reverse` operation is O(k), where k is the number of words. Thus, the overall time complexity is O(n). The space complexity is O(n) in the worst case, as a new string and an array of words are created, potentially storing all characters of the original string.

function ReverseWords(s): if s is null or whitespace: return "" words = split s by space, removing empty entries reverse the order of elements in the words array result = join elements of words array with a single space...

This C# code calculates the Longest Common Subsequence (LCS) of two strings using dynamic programming. A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changin...

The `FindLCS` function uses dynamic programming to solve the LCS problem. A 2D array `dp` of size `(m+1) x (n+1)` is created, where `m` and `n` are the lengths of `text1` and `text2` respectively. `dp[i, j]` stores the length of the LCS of `text1[0..i-1]` and `text2[0..j-1]`. The table is filled using the recurrence relation: if `text1[i-1] == text2[j-1]`, then `dp[i, j] = dp[i-1, j-1] + 1`; otherwise, `dp[i, j] = max(dp[i-1, j], dp[i, j-1])`. The base cases `dp[0, j]` and `dp[i, 0]` are 0. After filling the table, `dp[m, n]` holds the length of the LCS. The LCS string is reconstructed by backtracking from `dp[m, n]`: if `text1[i-1] == text2[j-1]`, the character is appended to the LCS and we move to `dp[i-1, j-1]`; otherwise, we move to the cell that yielded the maximum value (`dp[i-1, j]` or `dp[i, j-1]`). The time complexity is O(m*n) for filling the DP table and O(m+n) for reconstruction, totaling O(m*n). The space complexity is O(m*n) for the DP table.

function FindLCS(text1, text2): m = length of text1 n = length of text2 dp = 2D array of size (m+1) x (n+1), initialized to 0 for i from 1 to m: for j from 1 to n: if text1[i-1] == text2[j-1]: dp[i, j] = dp[i-1, j-1] + 1...

This C# code implements an in-place merge of two sorted arrays. It assumes the first array has sufficient allocated space to accommodate all elements from both arrays. The algorithm efficiently merges the elements by wor...

The `MergeSortedArraysInPlace` function merges `arr2` into `arr1` such that `arr1` remains sorted. It uses three pointers: `p1` for the last element of the valid portion of `arr1`, `p2` for the last element of `arr2`, and `pMerged` for the last position of the merged array (`m + n - 1`). The core logic iterates while both `p1` and `p2` are non-negative. In each iteration, it compares `arr1[p1]` and `arr2[p2]`. The larger element is placed at `arr1[pMerged]`, and the corresponding pointer (`p1` or `p2`) and `pMerged` are decremented. After the loop, if `p2` is still non-negative, it means there are remaining elements in `arr2` that are smaller than all remaining elements in `arr1` (or `arr1` is exhausted), so these are copied to the beginning of `arr1`. The time complexity is O(m + n) because each element is visited and moved at most once. The space complexity is O(1) as the merge is performed in-place, using only a few extra variables for pointers.

function MergeSortedArraysInPlace(arr1, m, arr2, n): pointer p1 = m - 1 pointer p2 = n - 1 pointer pMerged = m + n - 1 while p1 >= 0 and p2 >= 0: if arr1[p1] > arr2[p2]: arr1[pMerged] = arr1[p1] decrement p1 else: arr1[p...

This C# code defines a function `IsSorted` that checks if an integer array is sorted in non-decreasing order. It iterates through the array, comparing each element with its immediate successor. If it finds any element th...

The `IsSorted` function determines if an array `arr` is sorted in non-decreasing order. It first handles edge cases: a `null` array throws an `ArgumentNullException`, and arrays with zero or one element are considered sorted, returning `true`. For arrays with two or more elements, a `for` loop iterates from the first element (`index 0`) up to the second-to-last element (`arr.Length - 2`). In each iteration, it compares `arr[i]` with `arr[i + 1]`. If `arr[i] > arr[i + 1]` at any point, it signifies a violation of the non-decreasing order, and the function immediately returns `false`. If the loop finishes without returning `false`, it implies that `arr[i] <= arr[i + 1]` for all `i` from `0` to `arr.Length - 2`, meaning the array is sorted, and the function returns `true`. The time complexity is O(n) in the worst case (when the array is sorted or the unsorted pair is at the end), as it may need to check all adjacent pairs. The space complexity is O(1) as it only uses a few variables for loop control and comparison.

function IsSorted(arr): if arr is null: throw ArgumentNullException if length of arr is 0 or 1: return true for i from 0 to length of arr - 2: if arr[i] > arr[i + 1]: return false return true

This C# code finds a peak element in an array using a binary search approach. A peak element is defined as an element that is strictly greater than its adjacent neighbors. If an element is at the boundary of the array, i...

The `FindPeakElement` function leverages binary search to efficiently locate a peak element. The core idea is that if `nums[mid] > nums[mid + 1]`, then a peak must exist in the left half (including `mid`) because either `nums[mid]` is itself a peak, or there's an element to its left that's even larger, continuing the upward trend. Conversely, if `nums[mid] <= nums[mid + 1]`, then a peak must exist in the right half (excluding `mid`) because `nums[mid + 1]` is greater than or equal to `nums[mid]`, suggesting an upward trend or a plateau that eventually must descend. The loop invariant is that a peak element is guaranteed to exist within the `[left, right]` range. The time complexity is O(log n) due to the binary search, and the space complexity is O(1) as it only uses a few variables. Edge cases like empty or single-element arrays are handled, and the definition of a peak element at boundaries is implicitly managed by the binary search logic and the comparison `nums[mid] > nums[mid + 1]`.

function FindPeakElement(nums): if nums is null or empty: throw error if nums has 1 element: return index 0 left = 0 right = length of nums - 1 while left < right: mid = left + (right - left) / 2 if nums[mid] > nums[mid...