✍️ How Each Java File is Written in General

Each Java file in this repository follows a clear and standardized structure to ensure consistency and readability. Here’s how each file is structured:

1. Problem Link: Each Java file begins with a comment block containing a link to the problem’s page (e.g., LeetCode, HackerRank, etc.).
2. Question: The problem number and name of the problem are listed.
3. Problem Statement: A detailed description of the problem is included, based on the given website page, with:
   • Problem Statement
   • Example(s)
   • Constraints
   • Follow-ups (if any)
4. Approach: This section explains the approach to solving the problem, including:
   • Step-by-step explanation of the approach
   • Time Complexity
   • Space Complexity
5. Package Name: The package name is defined at the top of the solution.
6. Imports: All necessary imports are listed just after the package name.
7. Main Solution: The main solution follows the imports and is written in an easy-to-understand format.
8. Helper Methods: Helper methods are included when necessary to make the solution more modular.
9. Main Method: A main method is provided to test the solution with sample inputs.

📝 Example of a Java File

Here’s an example of a Java file for the problem Two Sum from LeetCode:

/*
LeetCode Problem: https://leetcode.com/problems/two-sum/

Question: 1. Two Sum

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.

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

Constraints:
- 2 <= nums.length <= 10^4
- -10^9 <= nums[i] <= 10^9
- -10^9 <= target <= 10^9
*/

 /*
 Approach: 
 We solve this problem using a HashMap to store the numbers and their indices.
 We iterate through the array and check if the complement of the current number exists in the HashMap.
 If it does, we return the indices of the current number and the complement.
 If the complement does not exist, we add the current number to the HashMap with its index as the value.
 
 Time Complexity: O(n), where n is the number of elements in the array.
 Space Complexity: O(n), where n is the number of elements in the array.
 */

package Arrays.Easy;

public class _1_Two_Sum {
    // Method to find two indices of numbers adding up to target
    public static int[] twoSum(int[] nums, int target) {
        java.util.Map<Integer, Integer> map = new java.util.HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                // Found the pair
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }

        // If no solution found, return null
        return null;
    }

    // Main method to test twoSum
    public static void main(String[] args) {
        int[] nums = { 2, 7, 11, 15 };
        int target = 9;

        int[] result = twoSum(nums, target);

        if (result != null) {
            System.out.println("Indices: " + result[0] + ", " + result[1]);
        } else {
            System.out.println("No two sum solution found.");
        }
    }
}

📜 License

MIT License © 2025 Be-A-Guptaji DSA

📬 Contact

👨‍💻 Aryan Baadlas
📧 aryanbaadlas@gmail.com

⭐ Show some love!

If you like this project, give it a star ⭐ on GitHub!