Courses & Certificates

Description: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

def twoSum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i

Description: You are given two non-empty linked lists representing two non-negative integers. Add the two numbers and return the sum as a linked list.

def addTwoNumbers(l1, l2):
    dummy = ListNode(0)
    cur, carry = dummy, 0
    while l1 or l2 or carry:
        v1 = l1.val if l1 else 0
        v2 = l2.val if l2 else 0
        carry, out = divmod(v1 + v2 + carry, 10)
        cur.next = ListNode(out)
        cur = cur.next
        l1 = l1.next if l1 else None
        l2 = l2.next if l2 else None
    return dummy.next

Description: Find the length of the longest substring without repeating characters.

def lengthOfLongestSubstring(s):
    seen = set()
    left = 0
    max_len = 0
    for right, ch in enumerate(s):
        while ch in seen:
            seen.remove(s[left])
            left += 1
        seen.add(ch)
        max_len = max(max_len, right - left + 1)
    return max_len

Description: Given two sorted arrays nums1 and nums2, return the median of the two sorted arrays in O(log(m+n)) time.

def findMedianSortedArrays(nums1, nums2):
    # Binary search solution
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1
    
    x, y = len(nums1), len(nums2)
    low, high = 0, x
    
    while low <= high:
        partitionX = (low + high) // 2
        partitionY = (x + y + 1) // 2 - partitionX
        
        maxX = float('-inf') if partitionX == 0 else nums1[partitionX-1]
        minX = float('inf') if partitionX == x else nums1[partitionX]
        
        maxY = float('-inf') if partitionY == 0 else nums2[partitionY-1]
        minY = float('inf') if partitionY == y else nums2[partitionY]
        
        if maxX <= minY and maxY <= minX:
            if (x + y) % 2 == 0:
                return (max(maxX, maxY) + min(minX, minY)) / 2
            else:
                return max(maxX, maxY)
        elif maxX > minY:
            high = partitionX - 1
        else:
            low = partitionX + 1

Description: Given a string s, return the longest palindromic substring.

def longestPalindrome(s):
    if not s:
        return ""
        
    start = end = 0
    
    for i in range(len(s)):
        # Expand around center for odd length palindromes
        len1 = expand_around_center(s, i, i)
        # Expand around center for even length palindromes
        len2 = expand_around_center(s, i, i + 1)
        max_len = max(len1, len2)
        
        if max_len > end - start:
            start = i - (max_len - 1) // 2
            end = i + max_len // 2
            
    return s[start:end+1]
    
def expand_around_center(s, left, right):
    while left >= 0 and right < len(s) and s[left] == s[right]:
        left -= 1
        right += 1
    return right - left - 1