Data Structures on entangledDEV

LeetCode – Two Sum II

Tue, 19 Dec 2023 09:05:39 +0000

Hey there! Today, let’s dive back into the world of LeetCode problems with Swift.

After successfully conquering the Two Sum problem, we’re geared up to take on the next challenge: Two Sum II.

To make things interesting, let’s explore this problem using a two pointers technique. Ready to tackle it together?

Problem

We are given an array of numbers sorted in non-decreasing order (this means each element is greater or equal to the preceding one) and a target value.

We are asked to find two numbers in the array such that the sum of them is equal to the target value and return those indices.

Here is an example:

Input: numbers = [2,7,11,15], target = 9
Output: [1,2]

Note: The index count specified in the problem starts at 1, not 0.

In this case, the values at indices 1 and 2 sum up to 9. Therefore, the expected output is the array [1,2] representing these indices.

Note: There is always exactly one solution, elements cannot be repeated, and the solution must be achieved using constant extra space.

Solution

For my solution, I opted to leverage the ordered nature of the list by employing a two-pointer approach. With the assurance that the list is already sorted, I establish two pointers. These pointers dynamically adjust based on whether the sum of the elements they point to is smaller or greater than the target. This strategy proves effective in navigating the sorted array efficiently.

func twoSum(_ numbers: [Int], _ target: Int) -> [Int] {
    var left = 0 // pointer at the beginning of the list
    var right = numbers.count - 1 // pointer at the end of the list
    
    // iterating till both pointers are side by side
    while left < right {
        let sum = numbers[left] + numbers[right]
        if sum  > target {
            // since sum is bigger than target we need to make the sum smaller
            right -= 1
        } else if sum < target {
            // since sum is smaller than target we need to make the sum bigger
            left += 1
        } else {
            // we found the two indices, return them
            return [left + 1, right + 1]
        }
    }
    // no indices found, return nothing
    return []
    }

This code efficiently identifies the two indices by employing two pointers initialized at the end of the list. Leveraging the sorted nature of the list, the pointers are strategically moved as needed until a valid solution is found.

The code is well-commented to elucidate each step, and given its straightforward nature, additional explanation may not be necessary.

Conclusion

Wrapping up our exploration of the Two Sum II problem in Swift, we utilized a handy technique known as ’two pointers.’ The inherent order of the list allowed us to smartly navigate through elements, efficiently narrowing down potential pairs that add up to the target value.

Swift’s simplicity and expressiveness played well with this approach, allowing us to implement a clean and concise solution. The language’s array handling, combined with the straightforward syntax, offered a seamless experience in dealing with the intricacies of the problem.

No need for any Swift promotional banner here—just appreciating how the language’s features naturally complemented our strategy. Swift or not, exploring these algorithmic challenges keeps our coding skills sharp and our problem-solving toolkit diverse. Ready for the next challenge?

LeetCode – Two Sum

Thu, 14 Sep 2023 14:32:44 -0600

Let’s continue working with more LeetCode problems, this time focusing on an easy one.

We need to find if, in a given array, we can find two numbers such that they can be added up to a certain target value. We can be certain that there will be only one solution.

Solution

Brute force

As with other problems, one first approach would be to compare all possible combinations to find the two numbers that adds to the target. This solution is easy to implement but it has a bad time performance of $O(n^2)$.

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    var indices = [Int]()
    for i in nums.indices {
        for j in (i + 1)..<nums.count {
            if nums[i] + nums[j] == target {
                indices.append(contentsOf: [i, j])
            }
        }
    }
    return indices
}

You may be wondering why we have (i + 1) in the inner loop. This is to avoid comparing the same value with itself, if we do that we may get a wrong solutions to certain inputs (one example: [3, 2, 4] and 6).

This solutions solves the problem, but it’s slow with a time complexity of $O(n^2)$. Let’s try to find another approach to improve this.

Using a Hash Table

Let’s try to think of the problem as a math equation, we want two values that add up to a certain third value.

This can be represented as the following simple equation.

$$ a + b = target $$

How can this help us? Notice that we already have two of three values of the equation for any given iteration. So we are searching for the third value, this is the value $b$ that can solve the previous equation.

$$ b = target - a $$

This missing value $b$ is just the difference between the target and the current value.

By knowing this, we can store somehow the values and indices of the array and check if some $b$ that can solves the equation is presented in our storing objet. When that happens we are done, and we can return the indices for the current value and the one stored for $b$.

We need an object able to save a value with its index, this is a perfect use for a Hash table. In Swift we have one already build-in, it’s called a Dictionary.

This data structure saves a key-value pair, like a real dictionary do. It’s also important to know that insertion and retrieval takes $O(1)$ time complexity, which make it ideal for this problem.

Here is the solution using this approach.

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    // Storing key: number, value: index in array
    var dic = [Int:Int]()
    
    for (currentNumberIndex, value) in nums.enumerated() {
        let diff = target - value
        
        if let missingNumberIndex = dic[diff] {
            return [missingNumberIndex, currentNumberIndex]
        }
        
        dic[value] = currentNumberIndex
    }

    return [-1,-1]
}

This solution is easy to read and quite efficient because we only check each element once. The time complexity is $O(n)$ and since we are storing each element in a dictionary, the space complexity is also $O(n)$.

Here we are using some cool Swift features:

.enumerated(): returns a tuple containing the current index and value.
Checking for optionals in dictionaries: we are using a if let statement to check whether the value we are missing is already on the dictionary.

Conclusion

This problem provides valuable insights into the efficient use of dictionaries in Swift. We started with a brute force approach that had a time complexity of $O(n^2)$, but then we optimized our solution using a hash table (Dictionary) to achieve a linear time complexity of $O(n)$. By employing the concept of key-value pairs and leveraging Swift’s features like .enumerated(), we were able to find a more elegant and efficient solution.

Exploring different approaches and understanding when to use data structures like dictionaries can greatly enhance our problem-solving skills as developers. Happy coding!

LeetCode – Contains Duplicates

Sun, 10 Sep 2023 07:40:04 -0600

Hello everyone, in this post I want to explore a solution to the Contains Duplicates LeetCode problem using Swift. Most solutions use Python and I think it would be a good idea to try to use Swift to explore how well it behaves for the LeetCode style questions.

The Problem

This problem states that we have an array of integers and it may contain some values that are duplicated, so we need to write a function that check if the given array contains any element more than once.

Here are some examples of valid inputs and outputs:

# Example 1
Input: nums = [1,2,3,1]
Output: true

# Example 2
Input: nums = [1,2,3,4]
Output: false

Solution

To solve this problem we need to find a way to count for at least one duplicity in the array, if this condition happens we can be sure that there are duplicates.

There are several approaches to solve this.

Brute force

We could think that if we select each element and compare with each other we would end up finding the duplicate, this solution involves the use of two nested for.

As we can observe in the image, when we compare each element with every other element, we create a scalability problem as our data set grows.

As an example, in a worse case nested comparison, if we have $30$ elements, we would perform $900$ operations; for $900$ elements, it would be $810,000$. This is why $O(n^2)$ time solutions are problematic when dealing with large data sets. To achieve scalability, we need to optimize our solutions for faster algorithms.

func containsDuplicateBruteForce(_ nums: [Int]) -> Bool {
    for n in 0..<nums.count {
        for m in (n + 1)..<nums.count {
            if nums[n] == nums[m] { return true }
        }
    }
    return false
}

Our solution works but, as we mentioned before, it is not ideal due to its time complexity, resulting in $O(n^2)$. The problem here is that we are doing inefficient comparisons, we can do better.

Sets

We are looking for duplicates, so one possible approach for this problem is to store somehow the elements in a new container that doesn’t allow duplicates, then we can add them and if some element was not able to be inserted we can be sure that there are duplicates.

What data structure have the property of not allowing duplicates? It’s the Set!

Lucky us, Swift already comes with a build-in Set data structure.

Sets are data structures that don’t allow duplicates. We can iterate over the array and insert each element into a new Set. If the insertion fails (i.e., the element already exists in the Set), we return true. Sounds easy enough, let’s code it!.

func containsDuplicate(_ nums: [Int]) -> Bool {
    // Define the Set of integers
    var set = Set<Int>()
        
    // Iterate over the array to generate the Set, if the set returns false we found a duplicate
    for num in nums where !set.insert(num).inserted {
        return true
    }

    // if all elements were inserted then there is no duplicated value
     return false
}

According to some pages, inserting into a Set in Swift uses internally a hash map, this mean that the insertion takes in average $O(1)$, making this solution $O(n)$.

This solution is already quite efficient because we are only iterating over all elements only once, but can we do a simpler code that express the same idea in a more concise way?

We are iterating over the elements to create a new container with its own copy of values, at the end we will end up with two objects. We can take advantage of this in the following manner: if the number of elements on both containers is not the same, then we can assume there are duplicates, in case that both contains the same number of elements we can be sure that there are no duplicates. This solution may lead us to a more expressive and concise code, so let explore it.

func containsDuplicate(_ nums: [Int]) -> Bool {
    // Define the Set of integers
    var set = Set<Int>()
        
    // Iterate over the array to generate the Set, if the set returns false we found a duplicate
    for num in nums {
        set.insert(num)
    }

    // if both containers have the same number of elements, they are equal and no duplicates were found, conversely there are duplicates 
     return set.count < nums.count
}

This is looking simpler to read, but there is one last thing. Set constructors can accept Arrays to instantiate them, we could use this handy property to make a one line solution!.

func containsDuplicate(_ nums: [Int]) -> Bool {
    // If the count of unique elements in the Set is less than the total count, there are duplicates
    Set(nums).count < nums.count
}

This simple line of code solves the problem in an elegant and concise way, we are creating a new set and then calling .count on it, then we use that value to compare it to the size of the original array and returning the result.

The final time complexity of this solution is $O(n)$, because we are implicitly iterating over the array when we create the Set.

Conclusion

I hope this post helps you understand how Swift features can be used to create elegant and efficient solutions. Thanks for reading, and until next time!