id stringlengths 17 53 | domain stringclasses 5
values | category stringclasses 24
values | difficulty stringclasses 3
values | language stringclasses 10
values | problem stringlengths 29 149 | thinking_1 stringlengths 236 493 | solution_1 stringlengths 166 541 | thinking_2 stringlengths 302 467 | solution_2 stringlengths 184 565 | thinking_3 stringlengths 302 463 | solution_3 stringlengths 169 1.14k | metadata dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
two_sum_python_0_9c257e75 | algorithms | arrays | easy | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_javascript_0_bc17f1e5 | algorithms | arrays | easy | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_java_0_ebf17c1f | algorithms | arrays | easy | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_cpp_0_a2aa5bd7 | algorithms | arrays | easy | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: T... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time c... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losi... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_go_0_0f999560 | algorithms | arrays | easy | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: Th... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time co... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losin... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_rust_0_03b040fd | algorithms | arrays | easy | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_typescript_0_98ba5c24 | algorithms | arrays | easy | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_csharp_0_447c2b6a | algorithms | arrays | easy | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_ruby_0_e72bbf00 | algorithms | arrays | easy | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_swift_0_e2a7c881 | algorithms | arrays | easy | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_python_1_a8a5837d | algorithms | arrays | medium | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_javascript_1_7b7bca53 | algorithms | arrays | medium | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_java_1_5b63d166 | algorithms | arrays | medium | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_cpp_1_ba75ea7d | algorithms | arrays | medium | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_go_1_b6745cfc | algorithms | arrays | medium | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_rust_1_06ac83c7 | algorithms | arrays | medium | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_typescript_1_012669f2 | algorithms | arrays | medium | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_csharp_1_bee45fa5 | algorithms | arrays | medium | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_ruby_1_4a5b3200 | algorithms | arrays | medium | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_swift_1_26bebfa3 | algorithms | arrays | medium | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for large input sizes up to 10^6. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces ti... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_python_2_a360bf71 | algorithms | arrays | easy | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_javascript_2_5e9103ee | algorithms | arrays | easy | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_java_2_42b9bc99 | algorithms | arrays | easy | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_cpp_2_e9844231 | algorithms | arrays | easy | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: T... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time c... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losi... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_go_2_175bbbaa | algorithms | arrays | easy | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: Th... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time co... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losin... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_rust_2_79ec10b4 | algorithms | arrays | easy | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_typescript_2_f27ffee3 | algorithms | arrays | easy | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_csharp_2_f76df49f | algorithms | arrays | easy | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_ruby_2_b95e033e | algorithms | arrays | easy | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_swift_2_44543844 | algorithms | arrays | easy | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use iterative approach to avoid recursion limits. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_python_3_e7b5809b | algorithms | arrays | medium | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_javascript_3_31d573d4 | algorithms | arrays | medium | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_java_3_c3869fe4 | algorithms | arrays | medium | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_cpp_3_1faee00a | algorithms | arrays | medium | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_go_3_fe6406d7 | algorithms | arrays | medium | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_rust_3_eafa765b | algorithms | arrays | medium | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_typescript_3_70ff0807 | algorithms | arrays | medium | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_csharp_3_f144a4a2 | algorithms | arrays | medium | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_ruby_3_c3686e58 | algorithms | arrays | medium | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_swift_3_9ca6c9e7 | algorithms | arrays | medium | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Consider memory constraints for streaming input. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces ti... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_python_4_43095b40 | algorithms | arrays | easy | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_javascript_4_4373f1d6 | algorithms | arrays | easy | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_java_4_1874daac | algorithms | arrays | easy | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_cpp_4_df62eece | algorithms | arrays | easy | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: T... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time c... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losi... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_go_4_dea314a1 | algorithms | arrays | easy | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: Th... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time co... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losin... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_rust_4_826ebf3a | algorithms | arrays | easy | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_typescript_4_51668b30 | algorithms | arrays | easy | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_csharp_4_769e02d2 | algorithms | arrays | easy | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_ruby_4_93a0431c | algorithms | arrays | easy | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_swift_4_0b2db4c8 | algorithms | arrays | easy | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Support both ascending and descending order. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_python_5_05c1df1d | algorithms | arrays | medium | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_javascript_5_f9181b19 | algorithms | arrays | medium | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_java_5_1661bcf8 | algorithms | arrays | medium | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_cpp_5_c141fd90 | algorithms | arrays | medium | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_go_5_8e094503 | algorithms | arrays | medium | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_rust_5_1b0e6e02 | algorithms | arrays | medium | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_typescript_5_b6701476 | algorithms | arrays | medium | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_csharp_5_2d99312c | algorithms | arrays | medium | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_ruby_5_32d05fa4 | algorithms | arrays | medium | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_swift_5_bd338d40 | algorithms | arrays | medium | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Ensure thread-safety for concurrent access. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces ti... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_python_6_98de565d | algorithms | arrays | easy | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_javascript_6_250fb093 | algorithms | arrays | easy | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_java_6_d34c4f5e | algorithms | arrays | easy | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_cpp_6_15735a9d | algorithms | arrays | easy | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: T... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time c... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losi... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_go_6_8ec916d0 | algorithms | arrays | easy | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: Th... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time co... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losin... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_rust_6_f60562e4 | algorithms | arrays | easy | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_typescript_6_3aec703b | algorithms | arrays | easy | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_csharp_6_0ee63911 | algorithms | arrays | easy | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_ruby_6_2411e61a | algorithms | arrays | easy | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_swift_6_f6c13e45 | algorithms | arrays | easy | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Add comprehensive input validation. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_python_7_4daf3cea | algorithms | arrays | medium | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_javascript_7_25361d7a | algorithms | arrays | medium | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_java_7_f6dff740 | algorithms | arrays | medium | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_cpp_7_afca01a7 | algorithms | arrays | medium | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_go_7_8dd0f777 | algorithms | arrays | medium | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_rust_7_dc0f7338 | algorithms | arrays | medium | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_typescript_7_210a152b | algorithms | arrays | medium | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_csharp_7_ec65f76f | algorithms | arrays | medium | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_ruby_7_8d06f686 | algorithms | arrays | medium | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_swift_7_ca9fac45 | algorithms | arrays | medium | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Optimize for cache efficiency. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces ti... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_python_8_ed916def | algorithms | arrays | easy | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_javascript_8_e69e5d6e | algorithms | arrays | easy | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_java_8_7ef8cf45 | algorithms | arrays | easy | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_cpp_8_afe58b4c | algorithms | arrays | easy | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: T... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time c... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losi... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_go_8_baef911f | algorithms | arrays | easy | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: Th... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time co... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without losin... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_rust_8_95af1e24 | algorithms | arrays | easy | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_typescript_8_fa681fef | algorithms | arrays | easy | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
St... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted witho... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_csharp_8_869ae9da | algorithms | arrays | easy | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_ruby_8_cf3c2262 | algorithms | arrays | easy | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_swift_8_635be0f7 | algorithms | arrays | easy | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Use zero-based indexing throughout. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: easy
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: easy
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: easy
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-easy",
"two_sum"
],
"estimated_... |
two_sum_python_9_e54a3a16 | algorithms | arrays | medium | python | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Python | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | def two_sum(nums, target):
"""
Brute Force: Check every pair of elements.
Time: O(N^2), Space: O(1)
"""
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return [] | Approach: Hash Map for Two Sum
Language: Python | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | def two_sum(nums, target):
"""
Optimized: Single-pass hash map for O(1) lookups.
Time: O(N), Space: O(N)
"""
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return [] | Approach: Two Pointer for Two Sum
Language: Python | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | def two_sum(nums, target):
"""
Two Pointer: Sort and use two pointers from both ends.
Time: O(N log N), Space: O(N) for indexed copy
"""
indexed = [(num, i) for i, num in enumerate(nums)]
indexed.sort()
left, right = 0, len(indexed) - 1
while left < right:
current_sum = indexed[l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_javascript_9_c220e766 | algorithms | arrays | medium | javascript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums, target) {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}... | Approach: Hash Map for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums, target) {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
return [seen.get(complement), i];
... | Approach: Two Pointer for Two Sum
Language: Javascript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums, target) {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < right) {
const sum = ind... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_java_9_c76738be | algorithms | arrays | medium | java | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Java | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | import java.util.*;
class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j... | Approach: Hash Map for Two Sum
Language: Java | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | import java.util.*;
class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums... | Approach: Two Pointer for Two Sum
Language: Java | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | import java.util.*;
class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
int[][] indexed = new int[n][2];
for (int i = 0; i < n; i++) {
indexed[i][0]... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_cpp_9_61eb562e | algorithms | arrays | medium | cpp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4:... | #include <vector>
using namespace std;
class Solution {
public:
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time... | #include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> seen;
for (int i = 0; i < (int)nums.size(); i+... | Approach: Two Pointer for Two Sum
Language: Cpp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without lo... | #include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
vector<int> twoSum(vector<int>& nums, int target) {
vector<pair<int, int>> indexed;
for (int i = 0; i < (int)nums.s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_go_9_71eb69d4 | algorithms | arrays | medium | go | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Go | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4: ... | package main
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
func twoSum(nums []int, target int) []int {
n := len(nums)
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
... | Approach: Hash Map for Two Sum
Language: Go | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces time ... | package main
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
func twoSum(nums []int, target int) []int {
seen := make(map[int]int)
for i, num := range nums {
complement := target - num
if idx, ok := seen[complement]; ok {
return []int{idx, i}
... | Approach: Two Pointer for Two Sum
Language: Go | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without los... | package main
import "sort"
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
func twoSum(nums []int, target int) []int {
type pair struct { val, idx int }
indexed := make([]pair, len(nums))
for i, num := range nums {
indexed[i] = pair{num, i}
}
sort.... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_rust_9_0e46b8fd | algorithms | arrays | medium | rust | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Rust | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.len();
for i in 0..n {
for j in (i + 1)..n {
if nums[i] + nums[j] == target {
return vec![i as i32, j as i32];
... | Approach: Hash Map for Two Sum
Language: Rust | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | use std::collections::HashMap;
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
let mut seen = HashMap::new();
for (i, &num) in nums.iter().enumerate() {
let complement = target - num;
if let Some(&... | Approach: Two Pointer for Two Sum
Language: Rust | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
let mut indexed: Vec<(i32, usize)> = nums.into_iter().enumerate()
.map(|(i, v)| (v, i)).collect();
indexed.sort_by_key(|&(v, _)| v);
let (mut l... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_typescript_9_d6240e3d | algorithms | arrays | medium | typescript | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
... | function twoSum(nums: number[], target: number): number[] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i,... | Approach: Hash Map for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduc... | function twoSum(nums: number[], target: number): number[] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
const seen = new Map<number, number>();
for (let i = 0; i < nums.length; i++) {
const complement = target - nums[i];
if (seen.has(complement)) {
... | Approach: Two Pointer for Two Sum
Language: Typescript | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted wit... | function twoSum(nums: number[], target: number): number[] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
const indexed = nums.map((num, i) => [num, i]);
indexed.sort((a, b) => a[0] - b[0]);
let left = 0, right = indexed.length - 1;
while (left < righ... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_csharp_9_fc9484ff | algorithms | arrays | medium | csharp | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step... | using System;
using System.Collections.Generic;
public class Solution {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
public int[] TwoSum(int[] nums, int target) {
int n = nums.Length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
... | Approach: Hash Map for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces t... | using System;
using System.Collections.Generic;
public class Solution {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
Dictionary<int, int> seen = new Dictionary<int, int>();
for (int i = 0; i < nums.Length; i++)... | Approach: Two Pointer for Two Sum
Language: Csharp | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without... | using System;
using System.Linq;
public class Solution {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
public int[] TwoSum(int[] nums, int target) {
var indexed = nums.Select((val, idx) => new[] { val, idx }).ToArray();
Array.Sort(indexed, (a, b)... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_ruby_9_98357854 | algorithms | arrays | medium | ruby | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step 4... | def two_sum(nums, target)
# Brute Force: Check every pair of elements.
# Time: O(N^2), Space: O(1)
n = nums.length
(0...n).each do |i|
((i + 1)...n).each do |j|
return [i, j] if nums[i] + nums[j] == target
end
end
[]
end | Approach: Hash Map for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces tim... | def two_sum(nums, target)
# Optimized: Single-pass hash map for O(1) lookups.
# Time: O(N), Space: O(N)
seen = {}
nums.each_with_index do |num, i|
complement = target - num
return [seen[complement], i] if seen.key?(complement)
seen[num] = i
end
[]
end | Approach: Two Pointer for Two Sum
Language: Ruby | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without l... | def two_sum(nums, target)
# Two Pointer: Sort and use two pointers from both ends.
# Time: O(N log N), Space: O(N)
indexed = nums.map.with_index { |num, i| [num, i] }
indexed.sort_by!(&:first)
left, right = 0, indexed.length - 1
while left < right
sum_val = indexed[left][0] + indexed[right][0]
retur... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
two_sum_swift_9_b8799e3b | algorithms | arrays | medium | swift | Given an array of integers and a target sum, find indices of two numbers that add up to the target. Handle duplicate elements correctly. | Approach: Brute Force for Two Sum
Language: Swift | Difficulty: medium
Step 1: Start with the most straightforward approach: iterate through all possible candidates.
Step 2: Check every valid combination against the problem requirements.
Step 3: This gives higher time complexity but requires minimal extra space.
Step ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Brute Force: Check every pair of elements.
// Time: O(N^2), Space: O(1)
let n = nums.count
for i in 0..<n {
for j in (i + 1)..<n {
if nums[i] + nums[j] == target {
return [i, j]
}
}
}
... | Approach: Hash Map for Two Sum
Language: Swift | Difficulty: medium
Step 1: Trade space for time using a hash map (dictionary) for O(1) lookups.
Step 2: For each element, compute what complement would be needed and check if seen.
Step 3: Single pass: check for complement, then store current element.
Step 4: Reduces ti... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Optimized: Single-pass hash map for O(1) lookups.
// Time: O(N), Space: O(N)
var seen = [Int: Int]()
for (i, num) in nums.enumerated() {
let complement = target - num
if let idx = seen[complement] {
return [idx, i]
... | Approach: Two Pointer for Two Sum
Language: Swift | Difficulty: medium
Step 1: Sort the input first, then use two pointers from both ends.
Step 2: Initialize left at start and right at end of sorted range.
Step 3: Move pointers inward based on comparison with target.
Step 4: Effective when input can be sorted without ... | func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
// Two Pointer: Sort and use two pointers from both ends.
// Time: O(N log N), Space: O(N)
var indexed = nums.enumerated().map { ($1, $0) }
indexed.sort { $0.0 < $1.0 }
var left = 0, right = indexed.count - 1
while left < right {
let s... | {
"approach_1_type": "brute_force",
"approach_2_type": "optimized",
"approach_3_type": "two_pointer",
"time_complexity_1": "O(N^2)",
"time_complexity_2": "O(N)",
"time_complexity_3": "O(N log N)",
"tags": [
"array",
"iteration",
"search",
"difficulty-medium",
"two_sum"
],
"estimate... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.