This algorithm evaluates a simple dot-notation path expression against a nested Map structure representing YAML data. It allows accessing nested values by key and elements within lists by index. This is useful for config...

The `evaluate` method splits the path string into segments. It then iteratively traverses the nested `Map` and `List` structures. The `navigate` helper method dispatches to `navigateMap` or `navigateList` based on the current data type. `navigateMap` handles key lookups, returning `null` if a key is absent. `navigateList` parses array indices, checking for valid format and bounds, returning `null` for out-of-bounds access. Edge cases include empty or null inputs, missing keys, invalid path segments, and out-of-bounds list indices. The time complexity is O(P) where P is the number of segments in the path, as each segment is processed once. Space complexity is O(1) excluding the input data, as only a few variables are used for traversal.

function evaluate(yamlData, path): segments = split path by '.' current = yamlData for each segment in segments: current = navigate(current, segment) if current is null: return null return current function navigate(curre...

This algorithm searches for a specific element within a nested YAML structure represented by nested Maps and Lists. It takes an array of path segments, where segments can be map keys or array indices (as strings). The fu...

The `findElement` method iterates through the provided `path` array. For each `segment`, it calls `navigateToSegment` to advance the traversal. `navigateToSegment` checks if the `current` object is a `Map` or a `List`. If it's a `Map`, it uses the `segment` as a key to retrieve the next object. If it's a `List`, it attempts to parse the `segment` as an integer index. Crucially, it checks if the parsed index is within the valid bounds of the list (`0 <= index < list.size()`). If at any point the `current` object is not a `Map` or `List`, or if a key/index is not found or is out of bounds, `null` is returned. The loop boundaries are managed by the standard `for` loop, and array index checks are explicit. Time complexity is O(P) where P is the length of the path, assuming map and list operations are O(1) on average. Space complexity is O(1) excluding the input data.

function findElement(yamlData, path): if yamlData is null or path is null or path is empty: return null current = yamlData for each segment in path: current = navigateToSegment(current, segment) if current is null: retur...

This algorithm implements a recursive strategy for merging two YAML-like map structures. It prioritizes values from the 'overlay' map when keys conflict, recursively merging nested maps and concatenating lists. A deep co...

The `merge` function initializes the process by deep-copying the base map. The `mergeRecursive` helper then iterates through the overlay map. If a key exists only in the overlay, it's added to the base with a deep copy. If a key exists in both and both values are maps, recursion is used to merge them. If both values are lists, they are concatenated (a common strategy, though others exist). Otherwise, the overlay value overwrites the base value, again with a deep copy. The `deepCopy` helper is essential for preventing shared references and ensuring immutability of inputs. Edge cases include null base or overlay maps, and handling of scalar values versus complex types (maps/lists). Time complexity is roughly O(N*M) in the worst case, where N and M are the sizes of the maps, due to deep copying and traversal. Space complexity is O(N+M) for the new merged map and temporary copies.

function merge(baseMap, overlayMap): if baseMap is null: return deepCopy(overlayMap) if overlayMap is null: return deepCopy(baseMap) resultMap = deepCopy(baseMap) mergeRecursive(resultMap, overlayMap) return resultMap fu...

This Java code defines a utility for merging two YAML-like map structures. The `mergeYamlMaps` function takes a base map and an overlay map. It recursively merges them, prioritizing values from the overlay map. If a key...

The `mergeYamlMaps` function merges two maps, `baseMap` and `overlayMap`, into a new map. It handles null inputs by returning the non-null map or an empty map if both are null. It initializes the `mergedMap` with a copy of `baseMap`. Then, it iterates through each entry in `overlayMap`. If a key exists in both maps and both corresponding values are instances of `Map`, it recursively calls `mergeYamlMaps` to merge these nested maps. Otherwise, the value from `overlayMap` overwrites the value in `mergedMap` for that key. The time complexity is roughly O(N*M) in the worst case, where N is the number of entries in the base map and M is the number of entries in the overlay map, considering the recursive calls and map operations. However, for typical nested structures, it's more akin to O(Total Elements * Average Map Operations). The space complexity is O(D), where D is the maximum depth of nested maps, due to the recursion stack. Edge cases handled include null maps, non-map values, and overwriting nested maps with non-map values.

function mergeYamlMaps(baseMap, overlayMap): if baseMap is null: return copy of overlayMap or empty map if overlayMap is null if overlayMap is null: return copy of baseMap mergedMap = copy of baseMap for each key, overla...

This Java code provides a basic function to check if a specific key exists in a single-level map, simulating a simple YAML mapping. The `simpleKeyExists` method takes the map and the key as input and returns true if the...

The `simpleKeyExists` function checks for the presence of a single key within a map. It first handles two edge cases: if the input `data` map is null, or if the input `key` is null, it immediately returns `false` as the key cannot be found under these conditions. If both the map and key are valid, it directly uses the `containsKey()` method of the `Map` interface to determine if the `key` exists as a key in the `data` map and returns the boolean result. The time complexity is O(1) on average for hash-based maps like `HashMap`, as `containsKey()` is typically a constant-time operation. The space complexity is O(1) as it uses a constant amount of extra space. This function is straightforward and avoids recursion or complex logic, making it very efficient for its purpose.

function simpleKeyExists(data, key): if data is null: return false if key is null: return false return data.containsKey(key)

This Java code implements a recursive function to check for the existence of a nested key within a map structure, simulating a YAML document. The `keyExists` method takes the map and a dot-separated key string. It recurs...

The `keyExists` function determines if a nested key, specified by a dot-separated string, exists within a map. It employs recursion. The base cases are when the input map is null/empty or the key is null/empty, both returning false. The key is split into at most two parts: the current segment and the rest. It checks if the `currentSegment` is a key in the `data` map. If not, it returns false. If it is the last segment, it returns true. If the value associated with `currentSegment` is not a map and there are more segments, it returns false. Otherwise, it recursively calls `keyExists` on the nested map with the remaining key segments. The time complexity is O(D * K), where D is the depth of the key and K is the average length of a key segment, due to splitting and map lookups. Space complexity is O(D) due to the recursion depth. Edge cases include null/empty maps, null/empty keys, keys pointing to non-map values, and keys that partially match but don't fully exist.

function keyExists(data, key): if data is null or data is empty: return false if key is null or key is empty: return false segments = split key by '.' (max 2 parts) currentSegment = segments[0] if currentSegment is not i...

This Java code provides functionality to reverse a list of strings, mimicking the reversal of a YAML sequence. The `reverseSequence` method performs an in-place reversal using a two-pointer approach. A helper method, `cr...

The `reverseSequence` method reverses a list of strings in-place. It initializes two pointers, `left` at the beginning and `right` at the end of the list. The `while` loop continues as long as `left` is less than `right`. Inside the loop, it swaps the elements at the `left` and `right` indices using a temporary variable. Then, `left` is incremented and `right` is decremented, moving the pointers towards the center. The loop terminates when the pointers meet or cross, indicating the entire list has been reversed. The time complexity is O(N/2), which simplifies to O(N), where N is the number of elements in the sequence, as each element is swapped at most once. The space complexity is O(1) because the reversal is done in-place, using only a constant amount of extra space for the temporary variable. Edge cases handled include null lists, empty lists, and lists with a single element, all of which are correctly identified as already reversed and require no action.

function reverseSequence(sequence): if sequence is null or size of sequence <= 1: return left = 0 right = size of sequence - 1 while left < right: swap sequence[left] and sequence[right] increment left decrement right fu...

This Java code defines a utility class for validating YAML path strings. It includes a method to check if individual path segments are valid, ensuring they contain only allowed characters and do not include reserved symb...

The `isValidSegment` function checks if a single string segment is valid for a YAML path. It first handles null or empty segments, returning false. It then checks for forbidden characters like spaces, colons, and slashes, which are problematic in pathing. Finally, it iterates through the segment's characters, ensuring each is either a letter, digit, hyphen, or underscore. The `isValidYamlPath` function splits the input path by dots and calls `isValidSegment` for each resulting segment. If any segment is invalid, the entire path is deemed invalid. The time complexity for `isValidSegment` is O(k), where k is the length of the segment, due to character iteration. The space complexity is O(1). The `isValidYamlPath` function has a time complexity of O(N*K) in the worst case, where N is the number of segments and K is the average segment length, due to splitting and segment validation. Its space complexity is O(N) for storing the split segments. Edge cases handled include null/empty paths, empty segments (due to double dots), and segments with invalid characters.

function isValidSegment(segment): if segment is null or empty: return false if segment contains ' ' or ':' or '/': return false for each character c in segment: if c is not alphanumeric and c is not '-' and c is not '_':...