ChatGPT vs Grok for Coding

from bisect import bisect_left

def longest_increasing_subsequence(nums):
    """
    Return one longest increasing subsequence from the input list.

    Approach:
    - We use an O(n log n) method based on "patience sorting".
    - `tails[i]` stores the smallest possible tail value of any increasing
      subsequence of length i + 1.
    - `tails_idx[i]` stores the index in `nums` of that tail value.
    - `prev_idx[i]` stores the index of the previous element in the LIS
      ending at position i, so we can reconstruct the sequence afterward.

    Time Complexity:
    - For each element, we use binary search to find its position in `tails`,
      which takes O(log n).
    - Doing this for all n elements gives O(n log n) total time.

    Space Complexity:
    - O(n) for reconstruction arrays.
    """
    if not nums:
        return []

    tails = []       # tail values
    tails_idx = []   # indices of tail values in nums
    prev_idx = [-1] * len(nums)

    for i, num in enumerate(nums):
        # Find where `num` fits in tails using binary search.
        pos = bisect_left(tails, num)

        # If num extends the largest subsequence found so far
        if pos == len(tails):
            tails.append(num)
            tails_idx.append(i)
        else:
            # Otherwise, replace the existing tail with a smaller value
            tails[pos] = num
            tails_idx[pos] = i

        # Link this element to the previous element in the subsequence
        if pos > 0:
            prev_idx[i] = tails_idx[pos - 1]

    # Reconstruct the LIS by backtracking from the last index
    lis = []
    k = tails_idx[-1]
    while k != -1:
        lis.append(nums[k])
        k = prev_idx[k]

    return lis[::-1]


# Example usage
if __name__ == "__main__":
    arr = [10, 9, 2, 5, 3, 7, 101, 18]
    print(longest_increasing_subsequence(arr))  # Example output: [2, 3, 7, 18]

If you want, I can also provide:

• a simpler O(n²) dynamic programming version
• a version that returns only the length
• a version for non-decreasing subsequences

from typing import List

def longest_increasing_subsequence(nums: List[int]) -> List[int]:
    """
    Finds and returns one longest increasing subsequence (LIS) from the input list.
    
    Approach:
    - Use dynamic programming where dp[i] represents the length of the LIS ending at index i.
    - prev[i] tracks the previous index in the LIS ending at i for reconstruction.
    - For each i from 0 to n-1:
      - dp[i] starts as 1 (single element subsequence).
      - For each j < i, if nums[j] < nums[i] and dp[j] + 1 > dp[i], update dp[i] and prev[i].
    - Find the index with the maximum dp value (end of the longest LIS).
    - Reconstruct the subsequence by backtracking using prev array.
    
    Time Complexity: O(n^2), due to the nested loops over all pairs (i, j) where j < i.
    Space Complexity: O(n), for dp and prev arrays.
    
    Edge cases handled:
    - Empty list: returns [].
    - Single element: returns [nums[0]].
    - All decreasing: returns longest single-element subsequence (first max-length one).
    - Strictly increasing: returns the entire list.
    - Duplicates: strictly increasing (<), so equals are not extended.
    
    Note: If multiple LIS exist with same length, returns one of them (the one ending at the first max-length index).
    """
    n = len(nums)
    if n == 0:
        return []
    
    # dp[i]: length of LIS ending at i
    dp = [1] * n
    # prev[i]: previous index in LIS ending at i (-1 if none)
    prev = [-1] * n
    
    # Fill dp and prev
    for i in range(1, n):
        for j in range(i):
            if nums[j] < nums[i] and dp[j] + 1 > dp[i]:
                dp[i] = dp[j] + 1
                prev[i] = j
    
    # Find the end index of the longest LIS
    max_len = max(dp)
    end_idx = dp.index(max_len)
    
    # Reconstruct the LIS by backtracking
    lis = []
    current = end_idx
    while current != -1:
        lis.append(nums[current])
        current = prev[current]
    
    # Reverse to get in original order
    return lis[::-1]

Example Usage:

print(longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]))  # [2, 3, 7, 101]
print(longest_increasing_subsequence([0, 1, 0, 3, 2, 3]))            # [0, 1, 3] or similar
print(longest_increasing_subsequence([7, 7, 7, 7]))                  # [7]
print(longest_increasing_subsequence([]))                             # []