Leetcode!
  • LeetCode!
  • My personal guide to Leetcode
  • Array
    • 11. Container With Most Water
    • 15. 3Sum
    • 219. Contains Duplicate II
    • 238. Product of Array Except Self
    • 245. Shortest Word Distance III
    • 392. Is Subsequence
    • 442. Find All Duplicates in an Array
    • 561. Array Partition I
    • 661. Image Smoother
    • 697. Degree of an Array
    • 723. Candy Crush
    • 832. Flipping an Image
  • Backtracking
    • 294. Flip Game II
    • 401. Binary Watch
    • 1079. Letter Tile Possibilities
  • Binary Search
    • 744. Find Smallest Letter Greater Than Target
    • 852. Peak Index in a Mountain Array
  • String
    • 6. ZigZag Conversion
    • 17. Letter Combinations of a Phone Number
    • 38. Count and Say
    • 521. Longest Uncommon Subsequence I
    • 544. Output Contest Matches
    • 937. Reorder Data in Log Files
  • Design
    • 251. Flatten 2D Vector
    • 281. Zigzag Iterator
  • Hash Table
    • 1. Two Sum
    • 508. Most Frequent Subtree Sum
    • 884. Uncommon Words from Two Sentences
    • 734. Sentence Similarity
  • Linked List
    • 2. Add Two Numbers
  • Unsorted
    • 917. Reverse Only Letters
  • Math
    • 43. Multiply Strings
    • 462. Minimum Moves to Equal Array Elements II
    • 553. Optimal Division
    • 800. Similar RGB Color
  • Greedy
    • 406. Queue Reconstruction by Height
    • 861. Score After Flipping Matrix
  • Tree
    • 701. Insert into a Binary Search Tree
    • 897. Increasing Order Search Tree
  • Divide and Conquer
    • 53. Maximum Subarray
  • Dynamic Programming
    • 62. Unique Paths
    • 63. Unique Paths II
    • 64. Minimum Path Sum
    • 120. Triangle
    • 198. House Robber
    • 213. House Robber II
    • 303. Range Sum Query - Immutable
    • 518. Coin Change 2
    • 750. Number Of Corner Rectangles
    • 337. House Robber III
  • Depth first search
    • 841. Keys and Rooms
  • Trie
    • 677. Map Sum Pairs
  • Two pointer
    • 42. Trapping Rain Water
Powered by GitBook
On this page
  • Approach 1: Brute Force
  • Approach 2: Sliding Window
  • Approach 3: Dictionary of last seen positions
  1. Array

219. Contains Duplicate II

Approach 1: Brute Force

The easiest solution is to brute force our way through for each element in the array and try to find another one close enough to satisfy our condition.

def containsNearbyDuplicate(self, nums, k): 
    """ 
    :type nums: List[int] 
    :type k: int 
    :rtype: bool 
    """ 
    for i in range(len(nums)): 
        for j in range(len(nums)): 
            if i != j and abs(i-j) <= k and nums[i] == nums[j]: 
                return True
    return False

As expected this solution exceeds the time limit at test case 22/23

Time Complexity: O(n²)

Space Complexity: O(1)

Approach 2: Sliding Window

We can take the sliding window approach by looking at the next 'k' positions in the array and looking for matches.

def containsNearbyDuplicate(self, nums, k):        
    """        
    :type nums: List[int]        
    :type k: int        
    :rtype: bool        
    """        
    window = set()        
    for i in range(0, len(nums)):            
        if len(window) >= k+1:                
            window.remove(nums[i-k-1])            
        if nums[i] in window:                
            return True            
        window.add(nums[i])        
    return False

This solution although accepted doesn't really have the best runtime, coming in at a measly 66.5% percentile.

Time Complexity: O(nk) (Lookup in sets is O(1) in Python)

Space Complexity: O(k)

Approach 3: Dictionary of last seen positions

We can iterate over the array and keep track of where we see a number, and then if we see it again, check to see if it passes the distance constraint.

def containsNearbyDuplicate(nums, k): 
    """
    :type nums: List[int] 
    :type k: int 
    :rtype: bool """ 
    dic = {}
    for i, v in enumerate(nums):    
        if v in dic and i - dic[v] <= k:        
            return True    
        dic[v] = i
    return False

As expected, this solution passes with flying colours coming in at a solid 98.3% percentile among other solutions.

Time Complexity: O(n)

Space Complexity: O(n)

Previous15. 3SumNext238. Product of Array Except Self

Last updated 6 years ago