This function merges two already sorted arrays of integers into a single, new sorted array. It uses a two-pointer approach to efficiently compare elements from both input arrays and build the merged result. This is a cor...

The `mergeSortedArrays` function takes two sorted integer arrays, `arr1` and `arr2`, and returns a new array containing all elements from both, also sorted. It initializes an empty array `mergedArray` to store the result and two pointers, `i` for `arr1` and `j` for `arr2`, both starting at index 0. The main loop continues as long as both pointers are within their respective array bounds. In each iteration, it compares the elements at `arr1[i]` and `arr2[j]`. The smaller element is appended to `mergedArray`, and its corresponding pointer is incremented. After the main loop finishes, one of the arrays might still have remaining elements. Two separate `while` loops are used to append any leftover elements from `arr1` and then from `arr2` to `mergedArray`. The time complexity is O(m + n), where m and n are the lengths of `arr1` and `arr2` respectively, because each element from both arrays is examined and appended exactly once. The space complexity is O(m + n) because a new array is created to store the merged result. Edge cases like empty input arrays are handled at the beginning, returning the non-empty array or an empty array if both are empty.

function mergeSortedArrays(arr1, arr2): initialize mergedArray as empty list initialize pointer i to 0 for arr1 initialize pointer j to 0 for arr2 if arr1 is empty: return arr2 if arr2 is empty: return arr1 while i < len...

This function finds the largest integer value stored within a binary tree. It traverses the tree, comparing node values to keep track of the maximum encountered so far. This is a common operation for analyzing tree data...

The `findMaximumInBinaryTree` function finds the maximum value in a binary tree using recursion. It first handles the base case: if the `root` is `nil` (an empty tree), it returns `nil`. Otherwise, it initializes `maxValue` with the value of the current `rootNode`. It then recursively calls itself on the left child (`rootNode.left`). If the recursive call returns a non-nil value (meaning the left subtree is not empty), it updates `maxValue` to be the greater of the current `maxValue` and the maximum from the left subtree. The same process is repeated for the right child (`rootNode.right`). This ensures that `maxValue` always holds the largest value found in the current node and its subtrees. The time complexity is O(n), where n is the number of nodes in the tree, because each node is visited exactly once. The space complexity is O(h) in the average case (for a balanced tree) and O(n) in the worst case (for a skewed tree), due to the recursion stack depth, where h is the height of the tree. This recursive approach correctly identifies the maximum value by systematically exploring all nodes.

function findMaximumInBinaryTree(root): if root is null: return null maxValue = root.value leftMax = findMaximumInBinaryTree(root.left) if leftMax is not null: maxValue = max(maxValue, leftMax) rightMax = findMaximumInBi...

This function identifies the first character in a given string that appears only once. It iterates through the string twice: first to count character frequencies and then to find the first character with a frequency of o...

The `findFirstNonRepeatingCharacter` function uses a two-pass approach with a hash map (dictionary in Swift) to efficiently solve the problem. In the first pass, it iterates through the input string `text` and populates a dictionary `characterCounts` where keys are characters and values are their frequencies. The `default: 0` syntax in Swift conveniently initializes the count to zero if the character is encountered for the first time. The time complexity for this pass is O(n), where n is the length of the string, as each character is processed once. In the second pass, the function iterates through the string again. For each character, it checks its count in the `characterCounts` dictionary. The first character found with a count of 1 is returned. If the loop completes without finding such a character (meaning all characters repeat or the string was empty), it returns `nil`. The time complexity for the second pass is also O(n) in the worst case. Therefore, the overall time complexity is O(n). The space complexity is O(k), where k is the number of unique characters in the string, due to the storage required for the dictionary. This approach correctly handles edge cases such as empty strings (via `guard`) and strings where all characters repeat.

function findFirstNonRepeatingCharacter(text): if text is empty: return nil create an empty dictionary called characterCounts for each character in text: increment count for character in characterCounts for each characte...

This function calculates the sum of all integers within a given array. It handles the specific case of an empty array by returning zero. This is a fundamental operation used in various data analysis and aggregation tasks...

The `sumArrayElements` function iterates through an array of integers and accumulates their sum. It first checks if the input array is empty. If it is, the function immediately returns 0, which is the correct sum for an empty set of numbers. Otherwise, it initializes a `totalSum` variable to 0 and then loops through each element in the array, adding it to `totalSum`. The time complexity is O(n) because each element is visited exactly once. The space complexity is O(1) as only a constant amount of extra space is used for the `totalSum` variable. This approach is straightforward and guarantees correctness by handling the empty array edge case explicitly.

function sumArrayElements(numbers): if numbers is empty: return 0 initialize totalSum to 0 for each number in numbers: add number to totalSum return totalSum

This function finds the starting and ending positions of a given target value in a sorted array of integers. It utilizes a modified binary search algorithm to efficiently locate the first and last occurrences. This is us...

The `searchRange` function uses a helper function `findBoundary` twice, once to find the first occurrence and once to find the last. `findBoundary` implements a binary search. When the target is found at `mid`, it records `mid` as a potential boundary. If `findFirst` is true, it continues searching in the left half (`high = mid - 1`) to find an even earlier occurrence. If `findFirst` is false, it searches the right half (`low = mid + 1`) for a later occurrence. This process guarantees that `boundaryIndex` will hold the correct first or last index if the target exists. The time complexity is O(log n) because binary search is performed twice. The space complexity is O(1) as only a few variables are used. Edge cases include an empty array, the target not being present, and the target being at the boundaries of the array.

function searchRange(nums, target): if nums is empty: return [-1, -1] first_index = findBoundary(nums, target, true) if first_index is -1: return [-1, -1] last_index = findBoundary(nums, target, false) return [first_inde...

This implementation provides a Queue data structure (First-In, First-Out) using two Stacks (Last-In, First-Out). The `enqueue` operation adds elements to one stack, while the `dequeue` and `peek` operations transfer elem...

The `MyQueue` struct uses two arrays, `enqueueStack` and `dequeueStack`, to simulate a queue. `enqueue` simply appends to `enqueueStack`. `dequeue` first checks if `dequeueStack` is empty. If it is, all elements from `enqueueStack` are popped and pushed onto `dequeueStack`, reversing their order. Then, the top element is popped from `dequeueStack`. This ensures FIFO behavior. `peek` works similarly to `dequeue` but returns the top element of `dequeueStack` without popping it, or the last element of `enqueueStack` if `dequeueStack` is empty. The `isEmpty` method checks if both stacks are empty. The time complexity for `enqueue` is O(1). The amortized time complexity for `dequeue` and `peek` is O(1), as each element is pushed and popped from each stack at most once. In the worst case, when a transfer occurs, `dequeue` can be O(n), where n is the number of elements in `enqueueStack`. The space complexity is O(n) to store the elements in the stacks.

struct MyQueue: enqueueStack: array dequeueStack: array init(): enqueueStack = empty array dequeueStack = empty array enqueue(x): add x to end of enqueueStack dequeue(): if dequeueStack is empty: if enqueueStack is empty...

This Swift code implements a thread-safe Dependency Injection (DI) container. It allows for registering services with different lifecycles (singleton or transient) and resolving them. The container uses type erasure and...

The `DIContainer` class manages the registration and resolution of services. It uses a dictionary `registrations` where keys are `ObjectIdentifier`s of service types and values are `Registration` structs. Each `Registration` stores the service's `Scope` (singleton or transient) and a `ServiceFactory` (a type-erased closure that creates an instance). A `NSRecursiveLock` is used to ensure thread safety during registration and resolution operations, preventing race conditions. When resolving a singleton service, the container first checks if an instance already exists; if not, it creates one using the factory and stores it. For transient services, a new instance is created every time `resolve` is called. The `register` method takes a factory closure that receives the `DIContainer` itself, allowing services to resolve their own dependencies. This design promotes loose coupling and testability by abstracting object creation and dependencies. Time complexity for registration is O(1) on average. Resolution complexity depends on the scope: O(1) for singleton (after first creation) and O(1) for transient (excluding the factory's complexity). Space complexity is O(N) where N is the number of registered services.

enum Scope { singleton, transient } protocol Service {} typealias ServiceFactory = () -> Any struct Registration { scope, factory, singletonInstance? } class DIContainer: private registrations: Dictionary<ObjectIdentifie...

This Swift code defines a Combine pipeline that processes a stream of integers. It first filters out all even numbers, then squares the remaining odd numbers. The transformed values are then published to any subscribers....

The `createProcessedIntegerPipeline` function sets up a reactive data processing pipeline using Apple's Combine framework. It starts with a `PassthroughSubject` which acts as the source of integers. The pipeline then applies a sequence of operators: `.filter { $0 % 2 != 0 }` keeps only the odd numbers, and `.map { $0 * $0 }` squares each of these odd numbers. Finally, `.eraseToAnyPublisher()` is used to hide the specific publisher type, returning a generic `AnyPublisher`. Subscribers can then connect to this publisher using `.sink` to receive the processed values. The pipeline is designed to be error-free (`Never` error type) for this specific example, simplifying error handling. The time complexity is effectively O(1) per element processed by the pipeline, as each operation is a constant-time transformation or filter. The space complexity is O(1) for the pipeline itself, plus any storage needed by subscribers.

class IntegerPublisher: create a PassthroughSubject for Integers (no errors) function send(value): send value to subject function finish(): send completion to subject function createProcessedIntegerPipeline(): get the su...