Leetcode Java Problems with Solutions have become an integral part of technical interviews for software engineering positions. LeetCode is a platform that hosts a vast array of coding challenges designed to assess a candidate’s problem-solving skills and coding proficiency. These problems cover a wide range of difficulty levels, from easy to hard, and encompass various algorithms and data structures. Aspiring software engineers often use LeetCode to hone their coding abilities and enhance their problem-solving skills, making it a valuable resource in the tech industry.

One notable aspect of Leetcode Java Problems with Solutions is the platform’s emphasis on efficiency and correctness. Java, being a versatile and widely-used programming language, is a preferred choice for many developers tackling LeetCode challenges. The solutions provided by users are often scrutinized not only for correctness but also for their runtime efficiency and space complexity. This dual focus ensures that candidates not only come up with a working solution but also optimize it for performance, a crucial skill in real-world software development.

Moreover, the collaborative nature of LeetCode fosters a vibrant community where programmers from around the world share their solutions and engage in discussions about different approaches. This collaborative learning environment enables individuals to gain insights into alternative solutions and different perspectives on problem-solving, enriching their overall programming knowledge. Leetcode Java Problems with Solutions thus serve as a comprehensive platform that not only assesses and enhances coding skills but also facilitates a global exchange of programming expertise.

Read More:

**Day 1 | Problem Statement **

Given an array of integers `nums`

and an integer `target`

, return *indices of the two numbers such that they add up to target*.

You may assume that each input would have ** exactly one solution**, and you may not use the

*same*element twice.

You can return the answer in any order.

**Leetcode Link:** https://leetcode.com/problems/two-sum/description/

**Example 1:**

Input:nums = [2,7,11,15], target = 9Output:[0,1]Explanation:Because nums[0] + nums[1] == 9, we return [0, 1].

**Example 2:**

Input:nums = [3,2,4], target = 6Output:[1,2]

**Example 3:**

Input:nums = [3,3], target = 6Output:[0,1]

**Constraints:**

`2 <= nums.length <= 10`

^{4}`-10`

^{9}<= nums[i] <= 10^{9}`-10`

^{9}<= target <= 10^{9}**Only one valid answer exists.**

## Approach | Leetcode Java Problems with Solutions

A more efficient approach is to use a hash table. We can iterate through the array once, and for each element, check if the target minus the current element exists in the hash table. If it does, we have found a valid pair of numbers. If not, we add the current element to the hash table.

**An approach using a hash table:**

- Create an empty hash table to store elements and their indices.
- Iterate through the array from left to right.
- For each element nums[i], calculate the complement by subtracting it from the target: complement = target – nums[i].
- Check if the complement exists in the hash table. If it does, we have found a solution.
- If the complement does not exist in the hash table, add the current element nums[i] to the hash table with its index as the value.
- Repeat steps 3-5 until we find a solution or reach the end of the array.
- If no solution is found, return an empty array or an appropriate indicator.

This approach has a time complexity of O(n) since hash table lookups take constant time on average. It allows us to solve the Two Sum problem efficiently by making just one pass through the array.

## Implementation

```
package in.bushansirgur;
import java.util.HashMap;
import java.util.Map;
public class TwoSum {
public static void main(String[] args) {
int nums[] = {2, 7, 11, 15};
int target = 13;
int result[] = twoSum(nums, target);
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
}
}
public static int[] twoSum(int nums[], int target) {
Map<Integer, Integer> hashMap = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int difference = target - nums[i];
if (hashMap.containsKey(difference)) {
return new int[] {i, hashMap.get(difference)};
} else {
hashMap.put(nums[i], i);
}
}
return new int[] {};
}
}
```

**Output:**