This Perl script implements the Breadth-First Search (BFS) algorithm to find the shortest path between two nodes in an unweighted graph. BFS systematically explores the graph layer by layer, guaranteeing that the first t...

The `find_shortest_path_bfs` function utilizes a queue to manage nodes to visit and a hash to keep track of visited nodes and their predecessors. It starts by enqueuing the `start_node` and marking it as visited. In each iteration, it dequeues a node, checks if it's the `end_node`, and if so, reconstructs the path using the `parent` hash. Otherwise, it iterates through the node's neighbors, enqueuing unvisited ones and updating their parent pointers. The `reconstruct_path` helper function backtracks from the `end_node` to the `start_node` using the `parent` map to build the path. The time complexity is O(V + E), where V is the number of vertices and E is the number of edges, because each vertex and edge is visited at most once. The space complexity is O(V) for the queue, visited set, and parent map. Edge cases handled include an empty graph, nodes not present in the graph, the start and end nodes being the same, and disconnected graphs where the target is unreachable.

function find_shortest_path_bfs(graph, start_node, end_node): if graph is empty or start/end nodes not in graph: return null if start_node equals end_node: return empty path initialize queue with start_node initialize vi...

This Perl function recursively checks if a given string is a palindrome. A palindrome is a word, phrase, number, or other sequence of characters that reads the same backward as forward. This recursive approach breaks dow...

The `is_palindrome_recursive` function determines if a string reads the same forwards and backward. It employs recursion with two base cases: an empty string or a single-character string are always palindromes. For strings longer than one character, it compares the first and last characters. If they are identical, it makes a recursive call to itself with the substring that excludes these two characters. If the first and last characters differ, the function immediately returns false, indicating it's not a palindrome. The time complexity is O(N), where N is the length of the string, because each character is effectively examined once in the comparisons. The space complexity is O(N) due to the recursion depth, which can go up to N/2 for a palindrome string, leading to N/2 stack frames. This implementation is case-sensitive and does not ignore non-alphanumeric characters.

function is_palindrome_recursive(string): if length of string is 0 or 1: return true first_char = first character of string last_char = last character of string if first_char equals last_char: middle_string = string with...

This Perl script simulates a background job queue consumer. It maintains a simple in-memory queue of jobs and their statuses. The `add_job` function enqueues new tasks, and `process_next_job` attempts to pick up and exec...

The `Background::JobQueueConsumer` module simulates a basic job queue system. `add_job` adds a new job to the `@job_queue` array and initializes its status to 'pending' in the `%job_status` hash. `process_next_job` iterates through the queue to find the first 'pending' job. It marks the job as 'processing' and then uses an `eval` block to simulate the job execution. If the simulated work (or an explicit `die`) causes an exception within the `eval` block, the job is marked as 'failed', and the error is logged. Otherwise, it's marked 'completed'. The job is then removed from the queue. `run_consumer` repeatedly calls `process_next_job` at intervals for a given duration, preventing busy-waiting with `sleep`. Time complexity for `process_next_job` is O(Q) where Q is the current number of jobs in the queue, due to the linear scan. `run_consumer`'s complexity depends on the duration and the sleep interval, but each job processing is O(Q). Space complexity is O(J) where J is the number of jobs stored, for the queue and status hash.

Module Background::JobQueueConsumer: Global job_queue (array). Global job_status (hash). Global next_job_id (integer). Function add_job(job_data): Assign new job_id. Add {id: job_id, data: job_data} to job_queue. Set job...

This Perl script defines a function `reverse_string` that takes a string as input and returns its reversed version. It handles the edge case of an empty or undefined input string by returning an empty string. The core lo...

The `reverse_string` function in Perl is straightforward. It first checks for an undefined or empty input string, returning an empty string immediately if either condition is met. This handles edge cases gracefully. If the input is valid, it uses Perl's highly optimized built-in `reverse` function, which operates on strings by reversing the order of characters. The time complexity of reversing a string of length N using Perl's built-in function is generally considered O(N), as each character must be visited and repositioned. The space complexity is O(N) because a new string of the same length is created to store the reversed result. The correctness relies on the well-tested nature of Perl's core functions.

Function reverse_string(input_string): If input_string is null or empty: Return empty string. Else: Return input_string reversed. Function demonstrate_reversal(test_string): reversed_string = reverse_string(test_string)....

This Perl module, `Text::WordFrequency`, calculates the frequency of words in a given text. It preprocesses the text by converting it to lowercase and removing punctuation, then splits it into individual words. A predefi...

The `Text::WordFrequency` module processes text to count word occurrences. The `new` method initializes an empty hash `$self->{word_counts}` to store the frequencies. The `process_text` method takes the input string, converts it to lowercase using `lc()`, and then uses a regex `s/[^a-z\s]//g` to remove any characters that are not lowercase letters or whitespace. This effectively strips punctuation. The cleaned text is then split into an array of words using `split /\s+/`. The code iterates through these words; if a word is not empty and not present in the `%stop_words` hash, its count is incremented in `$self->{word_counts}`. The `get_word_counts` method returns this hash. The `display_counts` method sorts the words alphabetically and prints them with their frequencies. Time complexity is dominated by text cleaning and splitting, which is roughly O(L) where L is the text length. Iterating through words and updating the hash is O(W) where W is the number of words, with hash operations being amortized O(1). Thus, the overall time complexity is O(L + W). Space complexity is O(U) where U is the number of unique words, to store the counts.

Module Text::WordFrequency: Global stop_words (hash). Method new(): Initialize word_counts (empty hash). Method process_text(text): Convert text to lowercase. Remove all characters except letters and spaces from text. Sp...

This Perl script defines a function `is_critical_error_log` that uses a highly optimized regular expression to identify critical error messages within log lines. The regex is designed for speed by minimizing backtracking...

The `is_critical_error_log` function employs a single, optimized regular expression for efficient log line filtering. The regex `qr/.../xi` is compiled for speed (`x` for free-spacing/comments, `i` for case-insensitivity). It uses non-capturing groups `(?:...)` to avoid overhead. The core logic is `(?:\(?ERROR|CRITICAL)\)?`, which matches 'ERROR' or 'CRITICAL', optionally surrounded by parentheses. A negative lookahead `(?!.*(?:INFO|DEBUG|TRACE|WARN))` is crucial: it ensures that if any of the less severe keywords appear *after* the potential error keyword on the same line, the match fails. This prevents false positives. The initial parts of the regex `(?:[\d\s-:]+)?(?:\s+)?(?:INFO|DEBUG|WARN|TRACE)?(?:\s+)?` are designed to match common log prefixes (timestamps, levels) without consuming too much time or causing excessive backtracking. The time complexity is effectively O(L) where L is the length of the log line, as the regex engine attempts a linear scan. Space complexity is O(1) as it only stores the regex and a boolean result.

Function is_critical_error_log(log_line): Define optimized_critical_error_regex. Return true if log_line matches optimized_critical_error_regex, false otherwise.

This Perl script implements a highly optimized regular expression for validating URLs. The regex is designed to be efficient by minimizing backtracking and using atomic groups (`(?>...)`) and possessive quantifiers where...

The `is_valid_url` function utilizes a complex, optimized regular expression to validate URL strings. The regex employs several techniques for efficiency: `(?>...)` (atomic grouping) prevents backtracking into the group once matched, and `*?` (lazy quantifiers) are used judiciously. The regex breaks down into components: scheme, authority (host and optional userinfo/port), and path/query/fragment. Hostname validation includes checks for valid characters and domain structure. IP address validation uses standard octet ranges. The `x` flag enables free-spacing and comments within the regex, improving readability. The `i` flag makes the match case-insensitive. The time complexity is difficult to state precisely due to the nature of regex engines and backtracking, but for well-formed URLs and optimized regexes, it approaches O(L) where L is the length of the URL string, as the engine attempts to match linearly. However, poorly constructed regexes or pathological inputs can lead to exponential complexity. Space complexity is O(1) as it only stores the regex and a boolean result.

Function is_valid_url(url_string): Define optimized_url_regex. Return true if url_string matches optimized_url_regex, false otherwise. Function test_url_regex(test_url): result = is_valid_url(test_url). Print "URL: '" +...