This T-SQL function identifies the first character in a string that appears only once. It iterates through the string, counts the occurrences of each character using a temporary table, and then iterates again to find the...

The function first handles the edge case of an empty input string by returning NULL. It then iterates through the input string, using a `WHILE` loop and `SUBSTRING`, to populate a temporary table `@CharCounts` with each character and its frequency. A second `WHILE` loop iterates through the original string again. For each character, it checks its count in the `@CharCounts` table. If the count is exactly 1, that character is returned as the first non-repeating character. If the loop completes without finding such a character, it means all characters repeat, and NULL is returned. The time complexity is O(N) because we iterate through the string twice, and table lookups/updates are effectively constant time for a small alphabet. The space complexity is O(K), where K is the number of unique characters in the string, due to the temporary table.

FUNCTION FindFirstNonRepeatingChar(inputString): IF inputString is empty THEN RETURN NULL END IF CREATE a temporary table `charCounts` with columns `charValue` and `count` FOR EACH character `currentChar` in `inputString...

This T-SQL code demonstrates the logic for implementing a queue using two stacks. The `Enqueue` operation pushes elements onto an `inStack`. The `Dequeue` operation first checks if the `outStack` is empty. If it is, all...

The core idea is to use two stacks, `inStack` and `outStack`, to simulate a queue. When an element is enqueued, it's simply pushed onto `inStack`. When a dequeue operation is requested, if `outStack` is empty, all elements from `inStack` are popped and pushed onto `outStack`. This reversal ensures that the element that was at the bottom of `inStack` (the oldest element) becomes the top element of `outStack`. Subsequently, the top element is popped from `outStack`. If `outStack` is not empty, the dequeue operation proceeds directly by popping from `outStack`. This approach ensures that elements are always dequeued in the order they were enqueued (FIFO). The time complexity for enqueue is O(1). The time complexity for dequeue is amortized O(1) because while a transfer operation takes O(N) time (where N is the number of elements in `inStack`), each element is transferred at most once. The space complexity is O(N) to store the elements in the two stacks.

CREATE FUNCTION CreateQueueUsingStacks(): -- This function simulates the creation and operations of a queue using two stacks. -- In a real T-SQL environment, this would typically be a stored procedure or CLR function. --...

This T-SQL function implements the binary search algorithm to efficiently find the index of a target integer within a sorted array. The array is represented as a comma-separated string, which is then parsed into a table...

The function first parses a comma-separated string into a table variable, assigning an index to each element. It initializes `Low` to 0 and `High` to the last index of the array. The core loop continues as long as `Low` is less than or equal to `High`. In each iteration, it calculates the middle index (`Mid`) using a method that prevents integer overflow. It then compares the value at `Mid` with the `Target`. If they match, `Mid` is returned. If the middle value is less than the target, `Low` is updated to `Mid + 1` to search the right half. If the middle value is greater than the target, `High` is updated to `Mid - 1` to search the left half. If the loop finishes without finding the target, -1 is returned. The time complexity is O(log N) due to the halving of the search space in each step. The space complexity is O(N) for storing the array in the table variable, plus O(1) for variables. Edge cases handled include an empty input array, the target being the first or last element, and the target not being present.

FUNCTION BinarySearch(sortedArray, target): Parse sortedArray into an array structure with indices low = 0 high = length(array) - 1 IF array is empty THEN RETURN -1 WHILE low <= high: mid = low + (high - low) / 2 midValu...

This T-SQL function identifies the first character in a string that appears only once. It iterates through the string, counts the occurrences of each character, and records the index of its first appearance. Finally, it...

The function first initializes a table variable to store character counts and their first occurrence indices. It handles edge cases like null or empty input strings by returning NULL. The core logic iterates through the input string, updating the count for each character encountered and storing its first index if it's the first time seeing the character. After counting, it queries the table to find the character with a count of 1 and the minimum `FirstIndex`. This ensures that the *first* non-repeating character is returned. The time complexity is O(N) where N is the length of the string, as we iterate through the string twice (once to count, once implicitly in the final SELECT). The space complexity is O(K) where K is the number of unique characters in the string, for storing counts in the table variable. The invariant maintained is that `CharCount` accurately reflects the frequency and first seen index of characters up to the current iteration point. Correctness is ensured by the final `ORDER BY FirstIndex ASC` clause, guaranteeing the earliest occurring non-repeating character is selected.

FUNCTION FindFirstNonRepeatingChar(inputString): IF inputString is NULL or empty THEN RETURN NULL CREATE table charCounts (char, count, firstIndex) FOR i from 1 to length(inputString): currentChar = character at index i...

This T-SQL function implements the Bubble Sort algorithm to sort a list of integers. The input is a comma-separated string, which is parsed into a table. The algorithm then repeatedly steps through the list, compares adj...

The function first parses the input string into a table variable, assigning row numbers. It handles empty or single-element lists by returning them as is. The core of Bubble Sort involves nested loops. The outer loop controls the number of passes, and the inner loop iterates through adjacent elements. If adjacent elements are out of order (current > next), they are swapped, and a flag `Swapped` is set. The outer loop continues as long as a swap occurred in the previous pass and the number of passes is less than the total count minus one. The time complexity is O(N^2) in the worst and average cases, where N is the number of elements, due to the nested loops. The space complexity is O(N) for storing the numbers in the table variable. The invariant is that after each pass of the outer loop, the largest unsorted element 'bubbles up' to its correct position at the end of the unsorted portion.

FUNCTION BubbleSort(numberList): Parse numberList into an array n = length(array) IF n <= 1 THEN RETURN numberList FOR i from 0 to n-2: swapped = false FOR j from 0 to n-2-i: IF array[j] > array[j+1] THEN swap array[j] a...

This T-SQL function checks if a given string is a palindrome. It first cleans the input string by removing non-alphanumeric characters and converting it to lowercase to ensure a case-insensitive and character-agnostic co...

The function preprocesses the input string by iterating through it, keeping only alphanumeric characters and converting them to lowercase. This ensures that 'Racecar' and 'race car' are treated the same. It handles edge cases where the cleaned string is empty or has only one character, returning true as these are palindromes. The core logic uses two pointers, `Left` starting at the beginning and `Right` at the end of the cleaned string. In a loop, it compares the characters at `Left` and `Right`. If they differ, the function returns false. If they match, `Left` is incremented and `Right` is decremented. The loop continues until `Left` is no longer less than `Right`. If the loop completes without returning false, it means all corresponding characters matched, and the function returns true. The time complexity is O(N) for cleaning the string and O(N/2) for comparison, resulting in O(N) overall, where N is the length of the original string. The space complexity is O(N) for storing the cleaned string. The invariant is that all characters outside the `[Left, Right]` range have been successfully matched.

FUNCTION IsPalindrome(inputString): cleanedString = "" FOR each character in inputString: IF character is alphanumeric THEN cleanedString = cleanedString + toLower(character) n = length(cleanedString) IF n <= 1 THEN RETU...

This T-SQL function finds the Kth smallest element in an unsorted list of numbers using a QuickSelect-like approach. It parses the input string into a table and then iteratively partitions the data around a pivot. Based...

The function parses the input string into a table variable. It handles edge cases for empty lists and invalid K values. The core logic simulates QuickSelect: it picks a pivot, partitions the elements into those smaller than the pivot and those larger. If the pivot's final position is K, it's the answer. If K is less than the pivot's position, the search continues in the left partition; otherwise, it continues in the right partition, adjusting K. The partitioning and re-insertion into the `@Numbers` table is a simplified, less efficient T-SQL simulation of the in-place partitioning of QuickSelect. The average time complexity is O(N), where N is the number of elements, because on average, the search space is reduced by a constant fraction in each step. The worst-case time complexity is O(N^2), similar to QuickSort, if pivots are consistently chosen poorly. The space complexity is O(N) for storing the numbers and temporary partitions. The invariant is that after each partitioning step, the elements to the left of the pivot's final position are smaller, and elements to the right are larger, relative to the pivot.

FUNCTION FindKthSmallest(numberList, k): Parse numberList into an array n = length(array) IF k <= 0 OR k > n THEN RETURN NULL low = 0 high = n - 1 WHILE low <= high: pivotIndex = partition(array, low, high) // partition...

This T-SQL function determines the longest common prefix among a list of strings. The list is provided as a comma-separated string, which is parsed into a table. The function then iterates character by character through...

The function first parses the input comma-separated string into a table variable. It handles edge cases for zero or one string in the input. It then iterates through the characters of the first string. For each character, it checks if it matches the character at the same position in all other strings. If a mismatch occurs or a string is shorter than the current character index, the loop breaks, and the prefix accumulated up to that point is returned. If all characters of the first string match across all other strings, the entire first string is the common prefix. The time complexity is O(S * M), where S is the number of strings and M is the length of the shortest string (or the length of the common prefix). The space complexity is O(S * L_avg), where L_avg is the average length of strings, for storing them in the table variable. The invariant is that `@Prefix` always holds the common prefix found among strings processed so far for the current character index.

FUNCTION LongestCommonPrefix(stringArray): IF stringArray is empty THEN RETURN "" IF stringArray has only one string THEN RETURN that string prefix = "" firstString = stringArray[0] FOR i from 0 to length(firstString) -...