DEV Community: Pratik Bandgar

LeetCode Solution: 1. Two Sum — May 23 2026 16:36

Pratik Bandgar — Sat, 23 May 2026 11:06:07 +0000

Cracking the Code: Your First LeetCode Journey with Two Sum! 🚀

Hey amazing developers! 👋 Ever wondered where to begin your LeetCode adventure? Look no further! The "Two Sum" problem is famously known as LeetCode's very first problem, and it's an absolute classic for a reason. It's a fantastic starting point to understand fundamental algorithms and data structures.

Today, we're going to dive deep into Two Sum (Problem #1), break it down, understand the thinking process, and explore a straightforward solution. Let's get started!

The Problem: Two Sum Explained Simply

Imagine you have a list of numbers, say [2, 7, 11, 15]. You're also given a specific target number, like 9.

Your goal? Find two different numbers in that list that add up to your target. Once you find them, you don't return the numbers themselves, but their positions (their indices) in the list.

Here are the key rules:

One Solution Only: You can always assume there will be exactly one pair of numbers that adds up to the target. No need to worry about multiple answers or no answers!
No Repeats: You can't use the same number twice. For example, if nums = [3, 2, 4] and target = 6, you can't use the 3 at index 0 with itself. You'd need to find 2 (index 1) and 4 (index 2).

Let's look at the examples:

Example 1:
nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] (which is 2) + nums[1] (which is 7) == 9.

Example 2:
nums = [3,2,4], target = 6
Output: [1,2]
Explanation: nums[1] (which is 2) + nums[2] (which is 4) == 6.

Example 3:
nums = [3,3], target = 6
Output: [0,1]
Explanation: nums[0] (which is 3) + nums[1] (which is 3) == 6.

The Intuition: How Would You Solve It? 🤔

Forget code for a second. If a friend gave you this list and a target, how would your brain tackle it?

You'd probably pick the first number, right? Say 2. Then you'd think, "Okay, what number do I need to add to 2 to get 9? Ah, 7!"
Then you'd scan the rest of the list to see if 7 is there. If you find it, boom! You have your pair.

If 7 wasn't there, or if 2 didn't lead to a pair, you'd move to the next number in your list, say 7. Then you'd ask, "What number do I need to add to 7 to get 9? 2!" You'd scan the remaining numbers for 2.

This "pick one, then check all others" approach is exactly the core intuition for our first solution!

Our Approach: Brute Force (The Straightforward Way)

The intuition above translates directly into a programming strategy called Brute Force. It simply means trying every single possible combination until we find the one that works.

Here's a step-by-step breakdown:

Pick a First Number: We'll use a loop to go through our nums array, picking each number one by one. Let's say nums[i] is the current "first number" we're considering.
Look for its Partner: For each nums[i], we need to find another number nums[j] in the rest of the array such that nums[i] + nums[j] == target. So, we'll use a second loop, nested inside the first one, to iterate through all possible nums[j] values.
Crucial Check: Different Elements: Remember the rule: "You may not use the same element twice." This means i (the index of our first number) must not be equal to j (the index of our second number).
Found It! If nums[i] + nums[j] equals target AND i is not equal to j, we've found our pair! We can immediately return their indices [i, j].

Since the problem guarantees there's always exactly one solution, we know our loops will eventually find the correct pair and return.

The Code 💻

Let's translate that logic into C++ code.

class Solution {
public:
    std::vector<int> twoSum(std::vector<int>& nums, int target) {
        // Outer loop: iterates through each number, considering it as the first element of our pair.
        // 'i' will represent the index of the first number.
        for (int i = 0; i < nums.size(); i++) {
            // Inner loop: iterates through the remaining numbers to find a partner for 'nums[i]'.
            // We start 'j' from 'i' (or i+1 to optimize slightly and avoid i==j check, but the problem's
            // given solution starts j from i and explicitly checks i!=j, so we'll stick to that for now).
            // 'j' will represent the index of the second number.
            for (int j = 0; j < nums.size(); j++) { // The provided solution started j from i; let's adhere to that to illustrate its exact logic.
                                                    // Correction: The provided solution has `j = i`, let's use that.
                                                    // No, the solution actually has `for(int j = i; j < nums.size(); j++)`.
                                                    // I will adapt the comments to fit this provided code, as requested.
                // Check if the sum of the current pair of numbers equals the target
                // AND ensure that we are not using the same element twice (i.e., their indices must be different).
                if ((nums[i] + nums[j] == target) && (i != j)) {
                    // If both conditions are met, we've found our unique pair!
                    // Return their indices as a vector.
                    return {i, j};
                }
            }
        }
        // This line should technically never be reached because the problem guarantees
        // that exactly one solution always exists. It's good practice for function completion.
        return {};
    }
};

Self-correction based on the provided solution:
The provided solution is for(int j = i; j < nums.size(); j++). This is a slight optimization because it avoids redundant checks (e.g., checking (nums[0], nums[1]) and then later (nums[1], nums[0])). The i != j check inside the if statement correctly handles the "cannot use the same element twice" rule. I will adjust the code block to reflect the exact provided solution and refine the comments.

class Solution {
public:
    std::vector<int> twoSum(std::vector<int>& nums, int target) {
        // Outer loop: 'i' represents the index of the first number we pick.
        // We iterate through each element in the 'nums' array.
        for (int i = 0; i < nums.size(); i++) {
            // Inner loop: 'j' represents the index of the second number we pick.
            // We start 'j' from 'i'. This ensures we check all pairs without redundant checks
            // like (nums[0], nums[1]) and then (nums[1], nums[0]), as the latter will be covered.
            for (int j = i; j < nums.size(); j++) {
                // Check if the sum of the numbers at indices 'i' and 'j' equals the target.
                // ALSO, ensure that we are not using the same element twice.
                // The condition `i != j` is crucial because `j` starts from `i`,
                // so `i == j` would mean comparing an element with itself.
                if ((nums[i] + nums[j] == target) && (i != j)) {
                    // If both conditions are met, we found our pair!
                    // Return their indices as a vector.
                    return {i, j};
                }
            }
        }
        // According to the problem constraints, this return statement should theoretically
        // never be reached, as there is always exactly one solution.
        // It's a placeholder for compilation purposes.
        return {};
    }
};

This is a more accurate representation and explanation of the provided solution.

Time & Space Complexity Analysis ⏱️🚀

Understanding how efficient your code is, is a critical skill in competitive programming!

Time Complexity: O(n^2)
- n represents the number of elements in our nums array.
- Our solution uses nested loops. The outer loop runs n times. For each iteration of the outer loop, the inner loop runs roughly n times (specifically, n-i times).
- This means, in the worst case, we are performing approximately n * n operations. This kind of performance is called quadratic time complexity, denoted as O(n^2).
- The problem description actually gives you a hint for improvement: "Can you come up with an algorithm that is less than O(n^2) time complexity?" Our current solution isn't that, but it's a great starting point!
Space Complexity: O(1)
- We are only using a few extra variables (i, j, target, nums.size()) which take up a constant amount of memory, regardless of how large the nums array gets.
- We are not creating any new data structures that grow significantly with the input size. This is called constant space complexity, denoted as O(1).

Key Takeaways ✨

Start Simple (Brute Force): Don't be afraid to implement the most straightforward solution first. It helps you understand the problem thoroughly and provides a baseline.
Nested Loops for Pairs: When you need to check every possible pair in an array, nested loops are a common pattern.
Read Constraints Carefully: Details like "cannot use the same element twice" (i != j) and "exactly one solution" are crucial for correct and efficient problem-solving.
Complexity Matters: O(n^2) is often acceptable for small inputs, but for larger inputs, you'll need more optimized approaches. The "Two Sum" problem has a famous O(n) solution using hash maps (dictionaries) – a fantastic next step once you master this basic approach!

That's it for our deep dive into LeetCode's Two Sum! You've just tackled your first (or refreshed your knowledge of) a fundamental problem. Keep practicing, keep learning, and happy coding!

Author: pratik_bandgar9009
Published: 2026-05-23 16:35:43

LeetCode Solution: 1. Two Sum — May 23 2026 16:35

Pratik Bandgar — Sat, 23 May 2026 11:05:11 +0000

Two Sum: Your First LeetCode Adventure Begins! 🚀

Hello, future problem-solvers and coding enthusiasts! 👋

If you're just dipping your toes into the exciting world of LeetCode, congratulations! You've found yourself at the perfect starting point: Problem #1, "Two Sum." This isn't just any problem; it's often the very first one many developers encounter, and for good reason. It's a fantastic introduction to algorithmic thinking, array manipulation, and understanding basic complexity.

Don't worry if you're a beginner – we'll break it down step-by-step, making sure you grasp every concept. Let's dive in!

🧐 Problem Explanation: Find the Perfect Pair!

Imagine you're at a party, and you have a list of people, each wearing a badge with a number on it. Your mission is to find exactly two people whose numbers, when added together, equal a specific "target" number. Once you find them, you just need to tell us where they are in the line (their positions/indices).

Here's the formal description: ""

Given:

An array of integers, nums. (Think of this as your list of people with numbers).
An integer, target. (This is the sum you're trying to achieve).

Task:
Return the indices (positions) of the two numbers in nums that add up to target.

Important Rules:

Exactly one solution: You're guaranteed to find one pair that works. No need to worry about multiple pairs or no pairs at all!
No duplicates: You can't use the same number twice. If nums[0] is part of the sum, you can't use nums[0] again as the second number.
Order doesn't matter: [0, 1] is the same as [1, 0].

Let's look at some examples to make it super clear:

Example 1:

nums = [2, 7, 11, 15]
target = 9
Output: [0, 1]
- Why? Because nums[0] (which is 2) + nums[1] (which is 7) equals 9. We return their positions: 0 and 1.

Example 2:

nums = [3, 2, 4]
target = 6
Output: [1, 2]
- Why? Because nums[1] (which is 2) + nums[2] (which is 4) equals 6. We return 1 and 2.

Example 3:

nums = [3, 3]
target = 6
Output: [0, 1]
- Why? Because nums[0] (which is 3) + nums[1] (which is 3) equals 6. Even though the numbers are the same, they are at different indices, so it's a valid pair!

🤔 Intuition: How Would You Find Them?

Okay, put your computer science hat aside for a moment. If you had to solve this manually with a small list of numbers and a target, how would you do it?

Let's say nums = [2, 7, 11, 15] and target = 9.

You'd probably start with the first number, 2.
Then, you'd ask: "If I use 2, what number do I need to reach 9?" The answer is 9 - 2 = 7.
Now, you'd scan the rest of the list (7, 11, 15) to see if 7 exists.
Aha! 7 is right there at index 1.
You found your pair: 2 (at index 0) and 7 (at index 1). Mission accomplished!

What if 2 didn't work? You'd move to the next number, 7, and repeat the process:

Take 7. What do I need? 9 - 7 = 2.
Scan the rest of the list (11, 15) for 2. (Actually, you'd also scan previous elements, but need to be careful not to use the same index).
Wait, we already considered 7 with 2. We don't want to re-check pairs we've already tried, or use 7 with itself.

This "try every combination" idea is the core of our first approach!

🚶‍♂️ Approach: The Brute-Force Way

The most straightforward way to find a pair is to simply check every single possible pair of numbers in the array. This is often called the "brute-force" approach.

Here's how we'll do it step-by-step:

Pick a Number: Start with the first number in the nums array. Let's call its index i.
Pick Another Number: Now, pick another number from the array. This second number must be after the first number (i) to ensure we don't use the same element twice (e.g., nums[i] and nums[i]) and to avoid checking the same pair twice (e.g., checking (nums[0], nums[1]) and then later (nums[1], nums[0])). Let's call its index j.
Check the Sum: Add nums[i] and nums[j].
Is it the Target? If their sum equals target, we've found our pair! We can immediately return their indices, [i, j].
Keep Looking: If it's not the target, we move on to the next possible j for the current i. If we run out of j's for the current i, we move to the next i and start checking j's from there.

Since we are guaranteed that "exactly one solution exists," our loops will eventually find the pair and return.

💻 Code: Bringing the Brute Force to Life (C++)

class Solution {
public:
    std::vector<int> twoSum(std::vector<int>& nums, int target) {
        // Outer loop: iterates through each element with index 'i'
        for (int i = 0; i < nums.size(); i++) {
            // Inner loop: iterates through each element with index 'j'
            // We start 'j' from 'i' to ensure we consider all combinations,
            // but carefully handle the "same element twice" constraint inside the loop.
            for (int j = i; j < nums.size(); j++) {
                // Check if the sum of nums[i] and nums[j] equals the target
                // AND ensure that 'i' and 'j' are not the same index.
                // The 'j = i' in the inner loop means we start checking from the current 'i'.
                // If we didn't add 'i != j', it would incorrectly sum an element with itself.
                if ((nums[i] + nums[j] == target) && (i != j)) {
                    // If both conditions are met, we found our pair!
                    // Return their indices as a vector.
                    return {i, j};
                }
            }
        }
        // According to the problem constraints, there will always be exactly one solution.
        // So, this line should ideally never be reached in a valid test case.
        return {}; // Return an empty vector if no solution is found (for safety, though not expected)
    }
};

A note on j = i vs. j = i + 1:
You might see other solutions where the inner loop starts with j = i + 1. Both are valid ways to prevent using the same element twice and avoid redundant checks.

If j = i + 1, then i != j is always true, so you don't need (i != j) in the if condition. This can be slightly cleaner.
My provided code with j = i and (i != j) explicitly handles the case where j could be i, but then discards it. It works perfectly fine!

⏱️ Time & Space Complexity Analysis

Understanding how "expensive" your code is in terms of time and memory is crucial in competitive programming.

Time Complexity: O(n²)

Outer Loop: The for (int i = 0; i < nums.size(); i++) loop runs n times, where n is the number of elements in the nums array.
Inner Loop: For each iteration of the outer loop, the for (int j = i; j < nums.size(); j++) loop also runs up to n times in the worst case (when i is small).
Total Operations: Since we have nested loops, for roughly every element i, we are checking against every other element j. This leads to approximately n * n (or n²) operations.
Big O Notation: We express this as O(n²), which stands for "Order n-squared." This means the time taken grows quadratically with the input size. For small arrays, it's fine, but for very large arrays (e.g., 10^5 elements), 10^10 operations would be too slow!

Space Complexity: O(1)

Extra Memory: We are not using any additional data structures (like maps, hash sets, or new arrays) that grow in size with the input n. We're just using a few variables (i, j, target, nums[i], nums[j]) to store temporary values.
Big O Notation: We express this as O(1), which means "constant space." The amount of memory used does not depend on the size of the input array.

🔑 Key Takeaways

Brute Force is a Starting Point: Often, the first solution you think of (like checking every possibility) is a brute-force approach. It might not be the most efficient, but it's great for getting started and understanding the problem.
Nested Loops = O(n²): A common pattern: if you see nested for loops where each loop iterates over the input data, it's a strong indicator of O(n²) time complexity.
Constraints Matter: The problem statement's guarantee of "exactly one solution" simplifies things, as we don't need to handle cases where no pair is found.
The Follow-Up is a Hint: LeetCode problems often include "Follow-up" questions (like "Can you come up with an algorithm that is less than O(n²) time complexity?"). This is a clear invitation to think about optimizations! For "Two Sum," there's a much faster O(n) solution using hash maps/dictionaries – but that's a story for another blog post! 😉

You've just tackled your first LeetCode problem with a solid, understandable solution! This is a fantastic step on your coding journey. Keep practicing, keep learning, and happy coding!

Submission Details:
Author Account: pratik_bandgar9009
Time Published: 2026-05-23 16:34:50

LeetCode Solution: 1. Two Sum

Pratik Bandgar — Sat, 23 May 2026 10:58:44 +0000

Two Sum: Your First LeetCode Challenge & Why It Matters!

Hello, future coding rockstars! 👋 Are you ready to embark on your LeetCode journey? There's no better place to start than with problem number one: Two Sum. This isn't just any problem; it's a rite of passage, a classic, and a fantastic way to grasp fundamental algorithmic thinking.

Let's dive in and conquer it together!

🤝 Problem Explanation: Finding the Perfect Pair

Imagine you have a list of numbers, like [2, 7, 11, 15]. Now, imagine I give you a target number, say 9. Your mission, should you choose to accept it, is to find two different numbers in that list that, when added together, equal our target.

But there's a twist! You don't return the numbers themselves; you return their positions (their indices) in the list.

Let's look at our example:
nums = [2, 7, 11, 15], target = 9

2 is at index 0
7 is at index 1
11 is at index 2
15 is at index 3

Can you spot the pair that adds up to 9?
Bingo! 2 + 7 = 9.
Since 2 is at index 0 and 7 is at index 1, our answer would be [0, 1].

A few crucial points:

Exactly one solution: You'll always find one perfect pair. No need to worry about multiple pairs or no pair at all.
Don't use the same element twice: If nums = [3, 3], target = 6, you use the 3 at index 0 and the other 3 at index 1. You can't use nums[0] with nums[0] to make 6.
Any order: [0, 1] or [1, 0] are both valid for our example.

🤔 The Intuition: The Brute-Force Detective

How would you, a human, solve this if you had a small list of numbers and a target?

You'd probably pick the first number, say 2. Then, you'd look at every other number in the list (7, 11, 15) and ask: "Does 2 plus any of these equal 9?"

2 + 7 = 9? Yes! Found it!

If 2 didn't work, you'd move to the next number, 7. Then you'd check 7 against all subsequent numbers, and so on. This "check every possible pair" strategy is what we call brute force. It's straightforward, and it's often the first idea that comes to mind for many problems.

🚶‍♂️ Our Approach: The Nested Loop Saga

To translate our human intuition into code, we need to systematically check every possible pair. How do we do that? With nested loops!

Here's the step-by-step breakdown of how the provided solution works:

Outer Loop (Picking the First Number): We start with a loop that iterates through each number in our nums array. Let's say this loop uses an index i. This i will represent the index of our first potential number.
```
For i from 0 to (length of nums - 1):
    Let current_num_1 = nums[i]
```
Inner Loop (Finding the Partner): Inside our first loop, we start another loop. This inner loop will iterate through the remaining numbers in nums, looking for a partner for nums[i]. Let's say this loop uses an index j.

*   Crucially, `j` starts from `i`. Why `i`? Because we want to check numbers from the current position onwards.
*   To ensure we don't use the *same element twice* (as required by the problem), we'll add a condition: `i != j`. This makes sure we're always comparing two distinct positions.

```
For j from i to (length of nums - 1):
    Let current_num_2 = nums[j]
```

The Check: Inside the inner loop, after we've picked nums[i] and nums[j], we perform our core check:
- Is nums[i] + nums[j] equal to our target?
- AND, is i not equal to j (to make sure we're using two different elements)?
```
If (current_num_1 + current_num_2 == target) AND (i != j):
    We found our pair! Return the indices [i, j].
```
No Return (The Unlikely Scenario): According to the problem constraints, we are guaranteed to find exactly one solution. So, the code will always return [i, j] inside the loops and never reach the return {}; statement at the end. It's good practice to have a fallback return, but in this specific problem, it's theoretically unreachable.

Let's walk through nums = [2, 7, 11, 15], target = 9 again with this approach:

`i`	`nums[i]`	`j`	`nums[j]`	`i != j`?	`nums[i] + nums[j]`	`== target`?	Action
0	2	0	2	False	4	No	Skip
0	2	1	7	True	9	Yes!	Return `[0, 1]`

And that's it! We found the solution on the very first "real" check.

💻 Code: The Brute-Force in C++

class Solution {
public:
    std::vector<int> twoSum(std::vector<int>& nums, int target) {
        // Outer loop iterates through each number from the start
        for (int i = 0; i < nums.size(); i++) {
            // Inner loop iterates through numbers starting from the current 'i'
            // This ensures we check all pairs without repeating (e.g., (2,7) vs (7,2))
            for (int j = i; j < nums.size(); j++) {
                // Check if the sum equals the target AND
                // if we are not using the same element twice (i.e., different indices)
                if ((nums[i] + nums[j] == target) && (i != j)) {
                    // If both conditions are met, we found our pair!
                    // Return their indices in a vector.
                    return {i, j};
                }
            }
        }
        // According to the problem constraints, there will always be exactly one solution,
        // so this line should theoretically never be reached.
        return {}; 
    }
};

⏱️ Time & Space Complexity Analysis

Understanding how efficient your code is, is crucial for competitive programming and software development.

Time Complexity: O(n²)
- We have two nested loops.
- The outer loop runs n times (where n is the number of elements in nums).
- The inner loop, in the worst case, also runs n times for each iteration of the outer loop.
- So, n * n = n² operations. This is generally considered a "slower" approach for larger inputs, but it's a perfectly valid starting point.
Space Complexity: O(1)
- We are not using any extra data structures that grow with the input size n. We only use a few variables (i, j, nums[i], nums[j]) to store current values.
- This means our solution uses a constant amount of extra memory, regardless of how large the input array nums is. Pretty efficient on memory!

✨ Key Takeaways

Brute Force is a Starting Point: Don't be afraid to start with the most straightforward approach that comes to mind. It's a great way to understand the problem and get a solution working.
Nested Loops for Pairwise Checks: When you need to check every combination of two elements in a list, nested loops are your go-to pattern.
Complexity Matters: Always think about how your solution scales. O(n²) might be fine for small inputs, but for larger datasets, you'll often need something faster.
Read Constraints Carefully: "Exactly one solution" and "not use the same element twice" are critical details that guide your logic.

This problem has a famous "Follow-up" asking for an algorithm less than O(n²) time complexity. This is where Hash Maps (or Dictionaries in Python) shine, allowing you to solve it in O(n) time! But that's a story for another day, once you've mastered the basics!

Congratulations on tackling your first LeetCode problem! Keep coding, keep learning, and you'll be solving complex algorithms in no time.

Authored by pratik_bandgar9009 | Published: 2026-05-23 16:28:17