DEV Community: richk21

The Two Sum problem in Java

richk21 — Sun, 08 Mar 2026 17:17:12 +0000

Two Sum problem is the most common question one can come across while preparing for job interviews in developer roles. I'm writing this blog to tell you about the various approaches you can follow to solve this problem in Java, ranging from the easiest to the best approach.

The problem

You are given a set of numbers in the form of an array and a target sum. You have to find two numbers in this array such that their sum is equal to the given target value. How would you do so?

Easiest and Naive Approach: Brute Force (as always!)

You iterate over each element of the array(x'th element) and create another loop inside the above loop from (x+1)'th element to the end. In each iteration you check if the sum of current element of outer loop and current element of the inner loop add up to the sum. Easy right? Has the highest complexity though!

Code

Following is the code for this approach:

public static int[] getTargetSumIndices(int[] arr, int target){
        for(int i = 0; i < arr.length; i++){
            int x = arr[i]; // element x
            for(int j=i+1; j < arr.length; j++){
                int y = arr[j]; //element y
                int sum = x + y;
                if(target == sum){
                    return new int[] {i, j};
                }
            }
        }
        return new int[] {-1, -1}; // not found
    }

you can use the indices further in the main method get the actual array elements by calling it like this:

public class Main {
    public static void main(String[] args) {
        int[] arr = {11, 2, 5, 0};
        int target = 17;
        int[] result = getTargetSumIndices(arr, target);
        System.out.println("Result: " + arr[result[0]] + " and " + arr[result[1]]);

    }

    public static int[] getTargetSumIndices(int[] arr, int target){
         ...
    }
}

Issues

This might seem like an easy solution to this problem but it incurs the worst time complexity of O(n2) due to a nested for-loop. The best time complexity scenario would be O(1) which would happen if the first elements of outer and inner loop summed up to be the target. Space complexity would be constant with a O(1).

A better approach: Sort + Binary Search

So as we saw that worst time complexity is too big, we want an approach which can work faster for bigger inputs. In this approach we're going to first sort the array, iterate over each element(lets call it x'th element) of this sorted array, find the complement of x with target sum (sum - x) and apply binary search from the (x+1)'th element to last element to find this complement.
So now, this approach looks like this:

Code

The code for this implementation should look like this:

public static int[] getTargetSumPair(int[] arr, int target){
        // sort the array
        Arrays.sort(arr);

        for(int i = 0; i < arr.length; i++) {
            int x = arr[i]; // element x

            //compute complement of x with target sum
            int complement = target - x;

            //binary search - find index of complement
            int y = binarySearch(complement, arr, i+1, arr.length - 1);

            if( y != -1){
                return new int[]{x, y};
            }
        }
        return new int[] {-1, -1}; // not found
    }

    public static int binarySearch(int num, int[] arr, int l, int h){
        while( l <= h ){
            int mid = (l + h) / 2;
            if( arr[mid] > num ){
                h = mid - 1;
            }else if( arr[mid] < num ){
                l = mid + 1;
            }else{
                return arr[mid];
            }
        }
        return -1;
    }

Issues

This approach is creating a time complexity of O(n*log(n)) which is less than our previous approach, but we can still work on it. The space complexity for this method is O(1). Note that the inbuilt sort method is actually optimized dual-pivot quicksort algorithm which has average case time complexity of O(n*log(n)) on data-type int[], which can convert to O(n²) in worst case.

Let's now look at another interesting approach having the same time complexity.

Another O(n * Log(n)) approach: Sort + Two pointer method

In this approach we have to maintain to pointers initially at the two opposite ends of the given array(which needs to be sorted beforehand). If the sum of the elements at the two pointed locations is equal to the target value then simply return their indices. If the sum is less than the target, move left pointer to right to increase sum value and if the sum is greater than the target, move right pointer to left to decrease the sum's value.
This implementation would visually look something like this:

Code

This is what this approach's code would be like in Java:

public static int[] getTargetSumPair(int[] arr, int target){
        // sort the array
        Arrays.sort(arr);

        // set lower and higher pointers
        int l = 0;
        int h = arr.length - 1;

        // do a while loop until l == h (while l is less than h)
        while(l < h ){
            if (arr[l] + arr[h] > target){
                h--; // as sum is greater than target, make bigger number smaller
            }else if(arr[l] + arr[h] < target){
                l++; // as sum is smaller than target, make smaller number bigger
            }else{
                return new int[] {arr[l], arr[h]}; // this means sum == target, so return the arr elements
            }
        }
        return new int[] {-1, -1}; // not found
    }

Issues

Again, as I said, this is another approach of O(n*log(n)) with space complexity of O(1).

We are now going to look at the hash set approach which significantly reduces the time complexity of this problem.

Hash set

This approach is the best one for the two sum problem as it incurs the least time complexity. So in this approach, we're going to create an empty hashset and iterate over the given array elements one by one. For each array element, we first calculate its complement with the target(target - current element), and then check if this complement exists in the hashset - if no, insert the current element in the hashset and if yes, return the current element and its complement as this would be our answer. This logic would be much clear with the gif given below.

Using a hashset makes this algorithm all the more efficient as hashsets have constant time algorithm or O(1) for insertion and lookup.

Code

The code for this approach is as follows:

public static int[] getTargetSumPair(int[] arr, int target){
        HashSet<Integer> seen = new HashSet<>();
        for( int i = 0; i < arr.length; i++){
            int complement = target - arr[i];
            if(!seen.contains(complement)) {
                seen.add(arr[i]);
            }else{
                return new int[] {arr[i], complement};
            }
        }
        return new int[] {-1, -1};
    }

Complexities

This algorithm would incur a time complexity of O(n) which is for a single for-loop iterating over each array element. Other than that - lookup and insertion operations in Hashset is having complexity of O(1). Note that the space complexity here is O(n) as we're saving the visited elements in the hashset.

Conclusion

Hope you liked reading this blog about the Two Sum problem and various approaches you can follow to achieve the right result for this. This is my first Algorithm related blog on dev.to. Writing blogs has been a really engaging way of learning for me, clarify my doubts and I wish to share my understandings with the community as well so as to clear concepts in a fun way using visual tools like gifs. Following this blog I'll be bringing more such content for the developer community to read and flourish!

Code Buddy: Connect, code and upskill

richk21 — Sun, 01 Mar 2026 15:39:26 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

Code Buddy is a tool I created to help the developer and coding community excel in their skills by connecting with various developers having similar areas of focus and skill levels.

What I Built

Code Buddy is a platform to connect developers/coders, track tasks, and achieve weekly coding goals together. Currently, I have created a very simple implementation of the idea which can be gamified further to make it more interactive for the users.

Users can create an account on code buddy and tell us about their focus area and the level of expertise in it and their weekly goal of how many hours they want to devote to it. Once they create this account, they'll get option to connect with others with same area of interest and level of expertise(will be refined further to get users better connection recommendations). Once they're connected to others, they'll be able to assign tasks to these buddies, and get tasks assigned from them as well. Each task can have certain number of points which will be assigned to an individual once the task is completed. The statistical data of how many tasks a user completes or how many tasks they assigned to others would be available on their dashboard along with the number of hours they devoted in learning/perfecting this skill. I think connecting with new people and up-skilling in a gamified way with interactive dashboards and reward system can really help make learning fun as we know staying consistent is so difficult!

Areas for improvement

Code Buddy isn't completely gamified yet and has a very basic implementation of the idea I had in mind, due to shortage of time(weekend challenge!). The point/reward system would be gamified in further versions with a leader-board, to make it more engaging for users. Better algorithm for matching of users would be used to provide right options for buddies based on the user's specific requirements.

Demo

Attaching step-by-step demo of code buddy here.

Code Buddy Live

Code

Following are links to frontend and backend GitHub Repositories:
Frontend Repository
Backend Repository

How I Built It

I have used React with Typescript and Vite for frontend along with packages like React Hook Forms, React Router DOM and Material UI. Backend APIs have been built with Node.js, Express, TypeScript, and MongoDB. For deployment, I have used netlify for frontend and Render for backend service with CI/CD setup for smooth deployment on pushing commits. Additionally I have used ChatGPT to set up basic blueprint of the project and improvised on it accordingly.

Conclusion

Building Code Buddy was a great experience for me as it helped me understand how to set things up efficiently under a time crunch and still stay dedicated to a project, which is what Code Buddy aims to do!

Tally: The Liveability Dashboard

richk21 — Sat, 27 Sep 2025 14:53:07 +0000

What I Built

Ever had a hard time shifting to a completely new neighborhood, area or an entirely new state for job or education? The uncertainty about the locality's living condition can make it even more stressful!
That's where Tally comes in. It is a survey-based solution to this problem. It collects insightful information from the local residents by asking them to rate amenities like schools or hospitals in their area or the standards of living like cleanliness, water quality, air quality, affordability and safety.
Once the survey is submitted, the aggregate data of the community ratings are shown on an interactive dashboard. This gives newcomers a concise snapshot of the area that they may potentially shift to.
I remember when I relocated to a new city for work, choosing the right neighborhood was overwhelming and exhausting. If I had a tool like Tally, it would've made my decisions much easier and quicker.
So in short Tally provides a "Liveability" Dashboard based on reviews from local residents. The accuracy of the dashboard would improve as more surveys are submitted, making it a reliable tool to find your next neighborhood. Moreover, anyone can contribute by filling the survey form, supporting this community-driven initiative.

Demo

Links for demo & repositories

Github Respository for frontend
Github Respository for backend
Frontend Hosted
Backend Hosted

Stack, tools & Libraries

Frontend: React with Typescript
Backend: Node.js with Typescript
Database: Firebase Firestore
UI Components: KendoReact and MUI
Geolocation API: ipapi API for fetching user's location to auto-fill the location fields and creating the dashboard for that location.
Graphs and Charts: Recharts used for visual data on the dashboard.
Additional packages: sass, eslint, dotenv, react-router, etc.
Version control: Github
Backend Hosting & Github: Render
Frontend Hosting & Github: Netlify

Flow & Demo

So let's get started with the demo!

Landing Page & Navbar

At first you will see Tally's landing page:

The navbar contains buttons to navigate to Landing Page, Survey Form and the Dashboard. These buttons are built using KendoReact's SvgIcons.

Survey Form

There are five accordions on the Survey Form. The page's title and subtitle have been made using KendoReact's Typography. Additionally, The accordion headers have a Tooltip functionality also created using KendoReact.

The first two sections are for filling in personal & locality details and the remaining are for ratings and comments.

The locality accordion includes three auto-filled fields (using the ipapi API), to avoid inaccurate data entry by the users. Although, the fields are still editable. In this section I have used the Label, Input and Autocomplete components from KendoReact.

Next we have the rating accordions. MUI's slider component has been used here to gather ratings from the residents about various amenities and factors in their area:

And the last section is for resident's feedback or comments about their locality:

Here I have used TextArea from KendoReact. Finally, the Submit Button has been built using KendoReact's Button component.

Once the entire form is filled the button would be enabled. After submitting, you will see a loading page which is KendoReact's Infinite Spinner Loader. If the form is submitted successfully a success notification is displayed using the Notification component from KendoReact. I will be demonstrating these components in the attached video.

The dashboard

The dashboard includes a search field to search the locality's name(it could be the area, pincode, city or state that you filled in the form), on pressing enter the loading screen would come up. If the data for the search locality was found, it would show the dashboard, else it would show the not found page.

The dashboard looks like this overall:

These charts have been created using React's Recharts Library. They contain dials showing aggregate ratings for various amenities and living standards, a dedicated section listing resident's comments about the area, and charts of the area's age and occupation distribution. The line chart shows various trends in air quality, noise levels, cleanliness and water quality aggregate over time.

A demo

This short demo demonstrates all the components, dashboard charts and the survey form. It also demonstrates how the app behaves when searching for an unknown location as well as the process of submitting a new survey entry. I have used the example of "Mumbai" city(which was not already existing in the database) and added a new survey entry for it which generated it dashboard.
demo video

KendoReact Components Used

The list of KendoReact Component used in Tally:

Input
Button
Autocomplete
Label
Typography
Tooltip
Notification
Infinite Loader
Textarea
SvgIcon

Conclusion

In conclusion, Tally is a user friendly platform designed to visualize living standards of different localities, relying heavily on extensive community participation and authentic feedback to get a wider range of data to visualize upon. Using React, Node, Firebase and component libraries like MUI and KendoReact has definitely contributed to Tally's enhanced performance and User Experience. As it's user base grows, Tally will get more and more accurate, becoming an invaluable tool for people looking to move out to a new place.