This Groovy code defines a class `StringReverser` with a method to reverse a given string. It uses a recursive helper function to build the reversed string character by character. This is a fundamental string manipulatio...

The `reverseString` method handles null or short strings as base cases. The `reverseHelper` function recursively appends the character at the current index to the result of reversing the rest of the string. The time complexity is O(n) because each character is processed once. The space complexity is also O(n) due to the recursive call stack. Edge cases like empty strings and single-character strings are explicitly handled, ensuring correctness.

function reverseString(input): if input is null or length of input is 0 or 1: return input return reverseHelper(input, length of input - 1) function reverseHelper(str, index): if index is less than 0: return empty string...

This Groovy code implements Dijkstra's algorithm to find the shortest paths from a single source node to all other nodes in a weighted graph. It uses a priority queue to efficiently select the next node to visit. This al...

Dijkstra's algorithm finds the shortest paths in a graph with non-negative edge weights. It maintains a set of visited nodes and a priority queue of nodes to visit, ordered by their current shortest distance from the source. The algorithm iteratively extracts the node with the smallest distance from the priority queue and relaxes its outgoing edges. Relaxation involves checking if a shorter path to a neighbor can be found through the current node. The time complexity is typically O(E log V) or O(E + V log V) depending on the priority queue implementation, where V is the number of vertices and E is the number of edges. Space complexity is O(V + E) for storing the graph and distances. Edge cases include disconnected graphs (handled by `Integer.MAX_VALUE` distances) and invalid start nodes.

function dijkstra(graph, startNode): distances = map of all nodes to infinity previousNodes = empty map priorityQueue = empty priority queue distances[startNode] = 0 add startNode with distance 0 to priorityQueue while p...

This Groovy code provides a simple utility to sum all the elements within an integer array. It iterates through the array, accumulating the sum of its elements. This is a foundational operation used in data analysis, sta...

The `sumArray` method initializes a `total` variable to 0. It then iterates through each `number` in the input `numbers` array and adds it to `total`. The method handles null or empty arrays by returning 0. The time complexity is O(n), where n is the number of elements in the array, as each element is visited once. The space complexity is O(1) as it only uses a constant amount of extra space for the `total` variable. The algorithm correctly sums positive, negative, and zero values.

function sumArray(numbers): if numbers is null or numbers is empty: return 0 total = 0 for each number in numbers: total = total + number return total

This Groovy code implements the binary search algorithm to efficiently find a target value within a sorted array of integers. It repeatedly divides the search interval in half. This algorithm is fundamental for searching...

Binary search works by repeatedly dividing the search interval in half. It starts with an interval covering the whole array. If the value of the search key is less than the item in the middle of the interval, the search narrows to the lower half. Otherwise, it narrows to the upper half. This process continues until the value is found or the interval is empty. The time complexity is O(log n) because the search space is halved in each step. The space complexity is O(1) for the iterative version. Edge cases include an empty or null array, and the target being smaller than the smallest element or larger than the largest element, all of which are handled by the loop termination and return value of -1.

function binarySearch(sortedArray, target): if sortedArray is null or empty: return -1 low = 0 high = length of sortedArray - 1 while low <= high: mid = low + (high - low) / 2 if sortedArray[mid] == target: return mid el...

This Groovy code provides an iterative implementation of the binary search algorithm. Binary search is an efficient algorithm for finding an item from a sorted list of items. It works by repeatedly dividing in half the p...

The `search` method takes a sorted integer array and a target integer. It initializes `low` to 0 and `high` to the last index of the array. The `while` loop continues as long as `low` is less than or equal to `high`. Inside the loop, the `mid` index is calculated to prevent potential integer overflow. If the element at `mid` matches the `target`, its index is returned. If the element at `mid` is less than the `target`, the search continues in the right half by setting `low` to `mid + 1`. Otherwise, the search continues in the left half by setting `high` to `mid - 1`. If the loop finishes without finding the target, -1 is returned. The time complexity is O(log n) because the search space is halved in each iteration. The space complexity is O(1) as it uses a constant amount of extra space.

FUNCTION search(sortedArray, target): IF sortedArray IS NULL OR length of sortedArray IS 0 THEN RETURN -1 END IF low = 0 high = length of sortedArray - 1 WHILE low <= high: mid = low + (high - low) / 2 IF sortedArray[mid...

This Groovy code implements a function to reverse a given string. It handles null, empty, and single-character strings as edge cases. The core logic iterates through the input string and builds a new string with characte...

The `reverseString` method takes a string as input and returns its reversed version. It first checks for null input, returning null if found. Then, it handles strings of length 0 or 1 by returning them directly, as they are already reversed. For longer strings, it creates a character array of the same length and populates it by picking characters from the input string starting from the last character and moving towards the first. Finally, it constructs and returns a new string from this character array. The time complexity is O(n), where n is the length of the string, because each character is processed once. The space complexity is also O(n) due to the creation of the new character array to store the reversed string.

FUNCTION reverseString(input): IF input IS NULL THEN RETURN NULL END IF length = length of input IF length IS LESS THAN OR EQUAL TO 1 THEN RETURN input END IF CREATE charArray of size length FOR i FROM 0 TO length - 1: c...

This Groovy code implements the Breadth-First Search (BFS) algorithm for a graph represented using an adjacency list. BFS explores a graph level by level, starting from a specified source node. It's commonly used for fin...

The `GraphBFS` class utilizes an adjacency list to represent the graph. The `bfs` method performs the traversal. It initializes a queue and a set to keep track of visited nodes. Starting with the `startNode`, it adds it to the queue and marks it as visited. The algorithm then iteratively dequeues a node, adds it to the result list, and enqueues all its unvisited neighbors, marking them as visited. This process continues until the queue is empty. To handle disconnected components, the code iterates through all nodes in the adjacency list and initiates a new BFS if a node hasn't been visited yet. The time complexity is O(V + E), where V is the number of vertices and E is the number of edges, as each vertex and edge is visited at most once. The space complexity is O(V) for storing the visited set and the queue.

CLASS GraphBFS: ATTRIBUTES: adjacencyList: Map<Integer, List<Integer>> visited: Set<Integer> CONSTRUCTOR(adjList): INITIALIZE adjacencyList FROM adjList INITIALIZE visited AS empty Set METHOD bfs(startNode): result = emp...

This Groovy code implements the Bubble Sort algorithm, a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The pass through the lis...

The `sort` method implements Bubble Sort. It uses two nested loops. The outer loop iterates `n-1` times, where `n` is the length of the array, ensuring that each element has a chance to 'bubble up' to its correct position. The inner loop compares adjacent elements (`arr[j]` and `arr[j+1]`). If `arr[j]` is greater than `arr[j+1]`, they are swapped. A boolean flag `swapped` tracks if any swaps occurred in a pass. If a pass completes without any swaps, it means the array is sorted, and the outer loop breaks early. The time complexity in the worst and average cases is O(n^2), where n is the number of elements. In the best case (already sorted array with the optimization), it's O(n). The space complexity is O(1) as it only uses a constant amount of extra space for the temporary variable during swaps.

FUNCTION sort(arr): n = length of arr IF n IS LESS THAN OR EQUAL TO 1 THEN RETURN END IF swapped = TRUE i = 0 WHILE i < n - 1 AND swapped IS TRUE: swapped = FALSE FOR j FROM 0 TO n - 2 - i: IF arr[j] > arr[j + 1] THEN SW...