This Ruby method determines if a given string is a palindrome, meaning it reads the same forwards and backward. It first cleans the input string by removing non-alphanumeric characters and converting it to lowercase, the...

The `is_palindrome?` method checks if a string reads the same forwards and backward. It handles `nil` or empty strings by returning `true`. The core logic involves cleaning the input string: it converts the string to lowercase using `downcase` and removes any characters that are not lowercase letters or digits using `gsub(/[^a-z0-9]/, '')`. This ensures that case and punctuation do not affect the palindrome check. Finally, it compares the `cleaned_str` with its reversed version (`cleaned_str.reverse`). If they are identical, the string is a palindrome, and the method returns `true`; otherwise, it returns `false`. The time complexity is dominated by the `gsub` and `reverse` operations, both of which are O(n), where n is the length of the string. The space complexity is O(n) due to the creation of the `cleaned_str` and its reversed copy.

function is_palindrome(input_string): if input_string is null or empty: return true initialize cleaned_string by converting input_string to lowercase and removing non-alphanumeric characters return cleaned_string is equa...

This Ruby method reverses a given string. It iterates through the string from the last character to the first, appending each character to a new string. This is a fundamental operation used in various text processing tas...

The `reverse_string` method takes a string as input and returns its reversed version. It first checks for edge cases: if the input string is nil or empty, it returns an empty string. Otherwise, it initializes an empty string `reversed` and an index pointing to the last character of the input string. A `while` loop iterates as long as the index is non-negative. In each iteration, the character at the current index is appended to `reversed`, and the index is decremented. This ensures that characters are added in reverse order. 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 reversed string.

function reverse_string(input_string): if input_string is empty or null: return empty string initialize reversed_string as empty string initialize index to length of input_string - 1 while index is greater than or equal...

This Ruby code defines a `TreeNode` class and a `insert_into_bst` method to add a new value to a Binary Search Tree (BST). The method recursively traverses the tree, placing the new value in its correct sorted position....

The `insert_into_bst` function inserts a new node with value `val` into a Binary Search Tree rooted at `root`. The base case for the recursion is when `root` is `nil`, meaning an empty subtree; in this case, a new `TreeNode` is created and returned. If `val` is less than the current node's value (`root.val`), the function attempts to insert into the left subtree. If the left child is `nil`, a new node is created and assigned as the left child. Otherwise, the function recursively calls itself on the left subtree. If `val` is greater than `root.val`, the process is mirrored for the right subtree. If `val` is equal to `root.val`, no insertion occurs, preserving the BST property that all nodes in the left subtree are less than the root, and all nodes in the right subtree are greater. The time complexity for insertion in a balanced BST is O(log n), where n is the number of nodes, because the search path is logarithmic. In the worst case (a skewed tree), it degrades to O(n). The space complexity is O(log n) for a balanced tree due to the recursion stack, and O(n) for a skewed tree.

class TreeNode: value left_child right_child function insert_into_bst(root, value): if root is null: return new TreeNode with value if value < root.value: if root.left_child is null: root.left_child = new TreeNode with v...

This Ruby method calculates the factorial of a non-negative integer. The factorial of a number n (denoted as n!) is the product of all positive integers less than or equal to n. For example, 5! = 5 * 4 * 3 * 2 * 1 = 120....

The `factorial` method computes n! for a given non-negative integer `n`. It first checks for invalid input: if `n` is negative, it raises an `ArgumentError` because the factorial is not defined for negative numbers. The base case is handled next: if `n` is 0, the method returns 1, as 0! is defined as 1. For positive integers, the method initializes a `result` variable to 1. It then uses a `each` loop to iterate through all integers from 1 up to `n` (inclusive). In each iteration, the current integer `i` is multiplied with the `result`. After the loop completes, `result` holds the calculated factorial value, which is then returned. The time complexity is O(n) because the loop runs `n` times. The space complexity is O(1) as it only uses a few variables regardless of the input size.

function factorial(n): if n is less than 0: raise error "Factorial not defined for negative numbers" if n is 0: return 1 initialize result to 1 for i from 1 to n (inclusive): result = result * i return result

This Ruby code calculates 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. For example, the factorial of 5 (denoted as 5!) is 5...

The `factorial` function computes the factorial of a non-negative integer `n`. It first checks for invalid input (negative numbers) and raises an `ArgumentError`. The base case `n == 0` returns 1, as 0! is defined as 1. For `n > 0`, it initializes a `result` variable to 1 and then iterates from 1 up to `n` (inclusive), multiplying `result` by each number in the sequence. The time complexity is O(n) because it performs `n` multiplications. The space complexity is O(1) as it only uses a few variables. This iterative approach is straightforward and avoids potential stack overflow issues associated with deep recursion for large `n`.

function factorial(n): if n < 0: raise error if n == 0: return 1 initialize result = 1 for i from 1 to n: result = result * i return result

This Ruby code implements the merge sort algorithm, a highly efficient, comparison-based sorting algorithm. It works by recursively dividing an array into smaller subarrays until each subarray contains only one element (...

Merge sort is a divide-and-conquer algorithm. The `merge_sort` function first checks for the base case: an array with 0 or 1 element is already sorted. Otherwise, it divides the array into two halves, recursively calls `merge_sort` on each half, and then uses the `merge` helper function to combine the two sorted halves into a single sorted array. The `merge` function takes two sorted arrays, `left` and `right`, and iterates through them, comparing elements and adding the smaller one to a `merged` array. Any remaining elements from either array are appended. The time complexity of merge sort is O(n log n) in all cases (best, average, and worst) because the array is consistently divided and merged. The space complexity is O(n) due to the auxiliary space required for the `merged` array during the merge step. This algorithm is stable, meaning that elements with equal values maintain their relative order in the sorted output.

function merge_sort(array): if array length <= 1: return array find middle index split array into left and right halves sorted_left = merge_sort(left half) sorted_right = merge_sort(right half) return merge(sorted_left,...

This Ruby code implements the binary search algorithm, an efficient method for finding an item from a sorted list of items. It works by repeatedly dividing in half the portion of the list that could be the target, until...

The `binary_search` function efficiently finds a target value within a sorted array. It starts by defining a search space using `low` and `high` pointers. In each iteration, it calculates the `mid` index and compares the element at `mid` with the `target`. If they match, the index is returned. If the element at `mid` is less than the `target`, the search continues in the right half (`low = mid + 1`); otherwise, it continues in the left half (`high = mid - 1`). The loop terminates when `low` exceeds `high`, indicating the target is not present. 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 and O(log n) for the recursive version due to call stack usage. Edge cases include empty arrays and targets not present. The `find_first_occurrence` helper demonstrates handling duplicates.

function binary_search(sorted_array, target): if array is empty: return -1 initialize low = 0 initialize high = length of array - 1 while low <= high: calculate mid = low + (high - low) / 2 if array[mid] == target: retur...

This Ruby code defines a function to determine 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 implementation clean...

The `is_palindrome?` function checks if a string is a palindrome. It first cleans the input string by converting it to lowercase and removing any characters that are not letters or numbers using `downcase.gsub(/[^a-z0-9]/, '')`. This ensures that variations in casing and punctuation do not prevent a string from being recognized as a palindrome. Then, it compares the cleaned string with its reversed version. If they are identical, the function returns `true`; otherwise, it returns `false`. The time complexity is dominated by the cleaning and reversing operations, which are O(n), where n is the length of the string. The space complexity is also O(n) due to the creation of the cleaned and reversed strings. The `is_palindrome_iterative` helper provides a simpler, case-sensitive check.

function is_palindrome(string): if string is null or empty: return true clean string: convert to lowercase, remove non-alphanumeric chars if cleaned string length <= 1: return true reverse the cleaned string if cleaned s...