This PowerShell script defines `Is-Palindrome`, a function that determines if a string is a palindrome. It first normalizes the input string by removing non-alphanumeric characters and converting it to lowercase using a...

The `Is-Palindrome` function takes a string and first calls `_NormalizeString` to prepare it for comparison. The `_NormalizeString` helper uses a regular expression `[^a-zA-Z0-9]` to find and remove any characters that are not letters or numbers, and then converts the result to lowercase using `.ToLower()`. This ensures that case and punctuation do not affect the palindrome check. If the normalized string is empty (meaning the original string was empty or contained only non-alphanumeric characters), it's considered a palindrome and `true` is returned. Otherwise, two pointers, `left` and `right`, are initialized to the start and end of the normalized string, respectively. A `while` loop continues as long as `left` is less than `right`. Inside the loop, it compares the characters at the `left` and `right` pointers. If they are not equal, the string is not a palindrome, and `false` is returned immediately. If the characters match, `left` is incremented and `right` is decremented to move the pointers inward. If the loop completes without finding any mismatches, it means the string is a palindrome, and `true` is returned. The time complexity is O(n), where n is the length of the input string, due to normalization and the single pass for comparison. The space complexity is O(n) in the worst case for storing the normalized string.

FUNCTION Is-Palindrome(InputString): Call _NormalizeString(InputString) and store result in normalizedString IF normalizedString is null or empty THEN RETURN true END IF Initialize left pointer to 0 Initialize right poin...

This PowerShell script provides a function `Find-MaxValue` that iterates through an array of integers to identify and return the largest value. It's a fundamental algorithm used in data analysis and statistics to quickly...

The `Find-MaxValue` function begins by checking if the input array `$Numbers` is empty. If it is, an exception is thrown because finding a maximum value in an empty set is undefined. If the array is not empty, the first element `$Numbers[0]` is assigned as the initial `maxValue`. A `for` loop then iterates through the array starting from the second element (index 1) up to, but not including, the last element. Inside the loop, each element `$Numbers[$i]` is compared with the current `maxValue`. If the current element is greater than `maxValue`, `maxValue` is updated to the value of the current element. This ensures that `maxValue` always holds the largest value encountered so far. After the loop completes, the final `maxValue` is returned. The time complexity is O(n), where n is the number of elements in the array, as each element is examined once. The space complexity is O(1) as only a few variables are used regardless of the input size.

FUNCTION Find-MaxValue(Numbers): IF Numbers is empty THEN THROW "Input array cannot be empty." END IF Initialize maxValue to the first element of Numbers FOR i FROM 1 TO length of Numbers - 1 DO IF Numbers[i] > maxValue...

This PowerShell script defines `Generate-FibonacciSequence`, a function that produces the Fibonacci sequence up to a given number of terms. It uses a helper function `_CalculateFibonacciNumber` to compute each individual...

The `Generate-FibonacciSequence` function first validates the input `$NumberOfTerms`. If it's negative, an error is thrown. If it's zero, an empty array is returned. For positive `NumberOfTerms`, it initializes an empty array `$sequence`. It then iterates from 0 up to `NumberOfTerms - 1`, calling the `_CalculateFibonacciNumber` helper for each index `i` and appending the result to the `$sequence` array. The `_CalculateFibonacciNumber` function handles the base cases: returning 0 for `n=0` and 1 for `n=1`. For `n` greater than 1, it uses an iterative approach. It initializes two variables, `$a` to 0 and `$b` to 1. A loop runs from `i=2` up to `n-1`. In each iteration, it calculates the next Fibonacci number by summing `$a` and `$b`, stores it in `$temp`, then updates `$a` to `$b` and `$b` to `$temp`. This effectively shifts the window to calculate the next number in the sequence. Finally, it returns `$b`, which holds the nth Fibonacci number. The time complexity for generating the sequence up to N terms is O(N^2) because calculating each of the N Fibonacci numbers takes O(N) time iteratively. The space complexity is O(N) to store the generated sequence.

FUNCTION Generate-FibonacciSequence(NumberOfTerms): IF NumberOfTerms < 0 THEN THROW "Number of terms cannot be negative." END IF IF NumberOfTerms == 0 THEN RETURN empty array END IF Initialize an empty array called seque...

This PowerShell script defines a function `Reverse-String` that takes a string as input and returns its reversed version. It utilizes a helper function `_ReverseStringHelper` to perform the actual reversal using a two-po...

The `Reverse-String` function first checks for null or empty input strings, returning an empty string immediately as an edge case. If the input is valid, it delegates the reversal to the `_ReverseStringHelper` function. The helper function converts the string to a character array. It then uses two pointers, `left` starting at the beginning and `right` at the end of the array. The `while` loop continues as long as `left` is less than `right`. Inside the loop, characters at the `left` and `right` pointers are swapped using a temporary variable. The `left` pointer is incremented, and the `right` pointer is decremented, moving them towards the center. This process effectively swaps characters from the outside in, resulting in a reversed string. The time complexity is O(n), where n is the length of the string, because each character is visited and swapped at most once. The space complexity is O(n) due to the creation of the character array.

FUNCTION Reverse-String(InputString): IF InputString is null or empty THEN RETURN "" ELSE RETURN _ReverseStringHelper(InputString) END IF END FUNCTION FUNCTION _ReverseStringHelper(StringValue): Convert StringValue to a...

This function identifies and returns the largest integer value present in an array. It iterates through the array, keeping track of the highest number encountered so far. This is useful in scenarios like finding the peak...

The `Find-MaximumValue` function efficiently determines the maximum integer in an array. It first checks for null or empty arrays, returning an error and null to indicate invalid input. The algorithm initializes `$maxValue` with the first element of the array. It then iterates from the second element onwards. In each iteration, it compares the current element with `$maxValue`; if the current element is greater, `$maxValue` is updated. The time complexity is O(n) as it requires a single pass through the array. The space complexity is O(1) because it only uses a few variables. The helper function `Get-ArrayLength` provides a safe way to get array length, handling nulls. The correctness relies on the invariant that `$maxValue` always holds the maximum value seen up to the current iteration.

FUNCTION Find-MaximumValue(Numbers): IF Numbers is null OR Numbers is empty: THROW ERROR "Input array cannot be null or empty." RETURN null SET maxValue = first element of Numbers FOR i FROM 1 TO length of Numbers - 1: I...

This function computes the factorial of a non-negative integer. The factorial of a number is the product of all positive integers less than or equal to that number. It's a fundamental concept in combinatorics and probabi...

The `Calculate-Factorial` function computes the factorial of a given non-negative integer iteratively. It first handles edge cases: if the input `$Number` is negative, it writes an error and returns null. If `$Number` is 0, it correctly returns 1 (0! = 1). For positive numbers, it initializes `$factorial` to 1. A `for` loop then iterates from 1 up to `$Number`, multiplying `$factorial` by the current loop variable `$i` in each step. The time complexity is O(n) because the loop runs `n` times. The space complexity is O(1) as it uses a fixed amount of memory. The helper functions `Is-Negative`, `Is-Zero`, `Get-NumberRange`, and `Multiply-Numbers` demonstrate modularity and provide basic arithmetic operations. The correctness is maintained by the invariant that `$factorial` holds the product of numbers from 1 up to the current loop iteration.

FUNCTION Calculate-Factorial(Number): IF Number < 0: THROW ERROR "Factorial is not defined for negative numbers." RETURN null IF Number == 0: RETURN 1 SET factorial = 1 FOR i FROM 1 TO Number: SET factorial = factorial *...

This function calculates the sum of all integer elements within an array. It iterates through each number in the provided array and adds it to a running total. This is a fundamental operation used in many data analysis a...

The `Calculate-ArraySum` function efficiently computes the sum of integers in an array. It initializes a `$sum` variable to zero. A crucial edge case is handled: if the input array is null or empty, it immediately returns 0, preventing errors. The function then uses a `foreach` loop to traverse each element, adding it to `$sum`. The time complexity is O(n) because each element is visited once. The space complexity is O(1) as only a constant amount of extra space is used for the sum variable. This approach is correct because it systematically accumulates all values.

FUNCTION Calculate-ArraySum(Numbers): SET sum = 0 IF Numbers is null OR Numbers is empty: RETURN 0 FOR EACH number IN Numbers: ADD number to sum RETURN sum END FUNCTION

This function takes a string as input and returns a new string with the characters in reverse order. It's a common string manipulation task used in various applications, such as data validation or creating mirrored text...

The `Reverse-String` function reverses a given string. It handles null or empty input strings by returning an empty string. It initializes an empty string `$reversedString` to build the result. A `for` loop iterates from the last character of the input string down to the first. In each iteration, the character at the current index `$i` is appended to `$reversedString`. The time complexity is O(n), where n is the length of the string, due to iterating through each character once. The space complexity is O(n) because a new string of potentially the same length is created. The helper function `Get-StringLength` safely returns the length of a string, handling null inputs. The logic is sound as it systematically appends characters from end to start.

FUNCTION Reverse-String(InputString): IF InputString is null OR InputString is empty: RETURN "" SET reversedString = "" SET length = length of InputString FOR i FROM length - 1 DOWN TO 0: APPEND character at index i of I...