This algorithm finds the first character in a given string that appears only once. It iterates through the string twice: first to count the frequency of each character using a map, and then to find the first character wh...

The `findFirstNonRepeatingChar` function takes a string `str` as input. It first checks for edge cases like an empty or null string, returning `null` if either is true. A `Map` named `charCounts` is used to store the frequency of each character. The first loop iterates through the string, incrementing the count for each character in the map. The second loop iterates through the string again. For each character, it checks its count in `charCounts`. If the count is 1, that character is returned as it's the first non-repeating one encountered. If the loop completes without finding such a character, `null` is returned. The time complexity is O(n) because the string is traversed twice, and map operations (get/set) are O(1) on average. The space complexity is O(k), where k is the number of unique characters in the string, due to the map storage.

function findFirstNonRepeatingChar(string): if string is empty or null: return null create a map called charCounts for each character in string: increment count for character in charCounts for each character in string: i...

This algorithm implements binary search to find the correct index for inserting a `target` value into a sorted array `nums` while maintaining its sorted order. If the `target` already exists, it returns the index of its...

The `searchInsert` function takes a sorted array `nums` and a `target` number. It handles the edge case of an empty array by returning 0. It initializes `low` to 0 and `high` to the last index of the array. A variable `insertionPoint` is initialized to `nums.length`, serving as a default if the target is greater than all elements. The `while (low <= high)` loop performs the binary search. Inside the loop, `mid` is calculated to prevent overflow. If `nums[mid]` equals `target`, `insertionPoint` is updated to `mid`, and `high` is decremented to search for the *first* occurrence in the left half. If `nums[mid]` is less than `target`, `low` is updated to `mid + 1`. If `nums[mid]` is greater than `target`, `insertionPoint` is updated to `mid` (as this is a potential insertion spot), and `high` is decremented. The loop invariant is that the target, if present, lies within `[low, high]`, or the insertion point is at or after `low`. Upon loop termination, `insertionPoint` holds the correct index. Time complexity is O(log n) due to binary search. Space complexity is O(1) as only a few variables are used.

function searchInsert(sorted_array, target): if sorted_array is empty: return 0 set low = 0 set high = length of sorted_array - 1 set insertion_point = length of sorted_array while low <= high: calculate mid = low + floo...

This algorithm efficiently finds a single missing number within an array that is supposed to contain all numbers from 0 up to `n` (where `n` is the array's length). It leverages the mathematical property of sums to ident...

The `findMissingNumber` function takes an array `nums` which is expected to contain distinct numbers from 0 to `n` (where `n` is `nums.length`), with exactly one number missing. It handles the edge case of an empty array by returning 0, as in the range [0, 0], 0 is the missing number if the array is empty. It calculates the `expectedSum` of numbers from 0 to `n` using the arithmetic series formula `n * (n + 1) / 2`. Then, it computes the `actualSum` of all numbers present in the input array by iterating through it. The missing number is simply the difference between `expectedSum` and `actualSum`. The time complexity is O(n) because it requires one pass to sum the array elements. The space complexity is O(1) as it only uses a few variables to store sums and `n`.

function findMissingNumber(array): if array is empty: return 0 set n = length of array set expected_sum = n * (n + 1) / 2 set actual_sum = 0 for each number in array: add number to actual_sum return expected_sum - actual...

This function calculates the sum of all numeric elements within an array. It iterates through each element, adding it to a running total. This is a fundamental operation used in data analysis and basic arithmetic process...

The `sumArray` function takes an array `arr` as input. It first checks if the array is null or empty, returning 0 in such cases to handle the edge case gracefully. A variable `sum` is initialized to 0. The function then iterates through the array using a `for` loop. In each iteration, the current element `arr[i]` is added to `sum`. After the loop finishes, the total `sum` is returned. The time complexity is O(n), where n is the number of elements in the array, as it requires a single pass through the array. The space complexity is O(1) because only a constant amount of extra space is used for the `sum` variable and loop counter.

function sumArray(array): if array is empty or null: return 0 initialize sum to 0 for each element in array: add element to sum return sum

This algorithm finds the first character in a given string that appears only once. It's useful in text processing, data analysis, and scenarios where identifying unique elements in a sequence is important. For example, i...

The algorithm uses a two-pass approach with a hash map (JavaScript's Map) to efficiently count character frequencies. In the first pass, it iterates through the string, incrementing the count for each character encountered in the map. This pass has a time complexity of O(n), where n is the length of the string, as each character is processed once. The space complexity is O(k), where k is the number of unique characters in the string, to store the counts. The second pass iterates through the string again. For each character, it checks its count in the map. The first character found with a count of 1 is returned as the result. If the loop completes without finding such a character, it means all characters repeat, and null is returned. Edge cases like an empty string or a string with only repeating characters are handled. The correctness relies on the fact that the second pass preserves the original order of characters, ensuring the *first* non-repeating one is identified.

function findFirstNonRepeatingChar(string): if string is empty: return null create a map called charCounts for each character in string: increment count for character in charCounts for each character in string: if count...

This algorithm implements the insertion operation for a Binary Search Tree (BST). A BST is a data structure where each node has at most two children, and for any given node, all values in its left subtree are less than t...

The `insertIntoBST` function recursively inserts a new value into a Binary Search Tree. The base case for the recursion is when the current `root` is `null`, meaning we've found the correct empty spot to insert the new node. In this case, a new `TreeNode` with the given `val` is created and returned. If the `root` is not `null`, the algorithm compares `val` with `root.val`. If `val` is less than `root.val`, the insertion proceeds into the left subtree by recursively calling `insertIntoBST` on `root.left`. The result of this recursive call (the potentially updated left subtree root) is then assigned back to `root.left`. Conversely, if `val` is greater than or equal to `root.val`, the insertion proceeds into the right subtree. The function always returns the `root` of the subtree it operated on, allowing the parent calls to correctly re-link the modified subtrees. The time complexity for insertion is O(h), where h is the height of the tree, which is O(log n) on average for a balanced BST and O(n) in the worst case (a skewed tree). The space complexity is O(h) due to the recursion stack.

class TreeNode: value left_child right_child function insertIntoBST(root, value): if root is null: return new TreeNode(value) if value < root.value: root.left_child = insertIntoBST(root.left_child, value) else: root.righ...

This function calculates the number of distinct paths a robot can take to reach the bottom-right corner of an m x n grid, starting from the top-left corner. The robot can only move down or right at any point. This proble...

The `uniquePaths` function uses dynamic programming to solve the grid path problem. It initializes a 2D array `dp` where `dp[i][j]` represents the number of unique paths to reach cell `(i, j)`. The base cases are the first row and first column, where there's only one way to reach any cell (by moving only right or only down, respectively). For any other cell `(i, j)`, the number of paths is the sum of paths to the cell above it (`dp[i-1][j]`) and the cell to its left (`dp[i][j-1]`), as these are the only two possible preceding cells. The time complexity is O(m*n) because each cell in the grid is visited once. The space complexity is also O(m*n) to store the DP table.

function uniquePaths(m, n): if m <= 0 or n <= 0: return 0 create dp table of size m x n, initialized to 0 for i from 0 to m-1: dp[i][0] = 1 for j from 0 to n-1: dp[0][j] = 1 for i from 1 to m-1: for j from 1 to n-1: dp[i...

This implementation provides a task scheduler that prioritizes tasks using a min-heap. Tasks are objects with a `name` and `priority` (lower number indicates higher priority). The scheduler inserts all tasks into the min...

The `MinPriorityQueue` class implements a binary min-heap to efficiently manage tasks based on priority. The `insert` method adds a task and maintains the heap property by bubbling up. The `extractMin` method removes and returns the task with the highest priority (smallest priority value) and then restores the heap property by bubbling down. The `processTasks` function takes an array of tasks, inserts them into the priority queue, and then iteratively extracts and processes them until the queue is empty. Time complexity for insertion and extraction is O(log N), where N is the number of tasks. The overall time complexity for processing all tasks is O(N log N). Space complexity is O(N) for storing tasks in the heap.

class MinPriorityQueue: heap = [] insert(task): add task to end of heap bubbleUp(task's index) bubbleUp(index): while index > 0 and parent's priority > current's priority: swap parent and current update index to parent's...