# Two Sum in C Programming with Solution: A Comprehensive Guide

## Introduction

This problem is known as the “Two Sum” problem. In this article, we will delve into the intricacies of solving the Two Sum problem using the C programming language.

We will explore various techniques and provide step-by-step solutions to help you master this problem-solving challenge.

In the world of programming, problem-solving is an essential skill.

One common problem that often arises is finding the two numbers in an array that sum up to a given target value.

## Two Sum in C Programming with Solution Explained

### Two Sum: What is it?

Before we dive into the solution, let’s first understand the problem itself.

The Two Sum problem involves finding two distinct elements in an array whose sum equals a given target value.

The task is to return the indices of these two numbers as the output. If no such pair exists, the algorithm should return an appropriate message.

### Approach 1: Brute Force

One straightforward approach to solving the Two Sum problem is by using brute force.

This method involves checking every possible pair of numbers in the array and comparing their sums to the target value.

Here’s how it can be implemented in C programming:

``````#include <stdio.h>

void twoSum(int arr[], int size, int target) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (arr[i] + arr[j] == target) {
printf("Indices: %d, %d\n", i, j);
return;
}
}
}
printf("No such pair exists.\n");
}

int main() {
int arr[] = {2, 7, 11, 15};
int target = 9;
int size = sizeof(arr) / sizeof(arr);

twoSum(arr, size, target);

return 0;
}``````

### Approach 2: Using Hash Table

While the brute force approach works, it is not the most efficient solution, especially for larger arrays.

A more optimized approach involves using a hash table to store the elements and their indices.

Also Read: Best 5 Programs on Fibonacci Series in C

This allows for constant-time lookups when searching for the complement of a given number.

Let’s take a look at the implementation:

``````#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
int key;
int value;
struct Node* next;
} Node;

Node* createNode(int key, int value) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->key = key;
newNode->value = value;
newNode->next = NULL;
return newNode;
}

void insert(Node* hashTable[], int key, int value) {
int index = abs(key) % 1000;
if (hashTable[index] == NULL) {
hashTable[index] = createNode(key, value);
} else {
Node* newNode = createNode(key, value);
newNode->next = hashTable[index];
hashTable[index] = newNode;
}
}

int search(Node* hashTable[], int key) {
int index = abs(key) % 1000;
Node* currentNode = hashTable[index];
while (currentNode != NULL) {
if (currentNode->key == key) {
return currentNode->value;
}
currentNode = currentNode->next;
}
return -1;
}

void twoSum(int arr[], int size, int target) {
Node* hashTable = {NULL};

for (int i = 0; i < size; i++) {
int complement = target - arr[i];
int complementIndex = search(hashTable, complement);
if (complementIndex != -1) {
printf("Indices: %d, %d\n", complementIndex, i);
return;
}
insert(hashTable, arr[i], i);
}
printf("No such pair exists.\n");
}

int main() {
int arr[] = {2, 7, 11, 15};
int target = 9;
int size = sizeof(arr) / sizeof(arr);

twoSum(arr, size, target);

return 0;
}``````

Q1: What is the time complexity of the brute force approach?

The brute force approach for solving the Two Sum problem has a time complexity of O(n^2), where n is the size of the input array. This is because we have nested loops that iterate over the array.

Q2: Does the order of the output indices matter?

No, the order of the output indices does not matter. The important aspect is to find two distinct elements in the array that sum up to the target value.

Q3: Are the input numbers always positive?

No, the input numbers can be positive, negative, or zero. The Two Sum problem is designed to handle any integer values.

Q4: Can the array contain duplicate numbers?

Yes, the array can contain duplicate numbers. However, the solution should only return the indices of distinct elements that sum up to the target value.

Q5: How does the hash table approach improve the efficiency?

The hash table approach significantly improves the efficiency by reducing the lookup time to constant time O(1). This allows us to find the complement of a number in the array without iterating through the entire array.

Q6: What if there are multiple pairs that sum up to the target value?

The solutions provided in this article will return the indices of the first encountered pair that satisfies the condition. If there are multiple pairs, you can modify the code to return all pairs or adapt the logic as per your requirements.

## Conclusion

In conclusion, the Two Sum problem in C programming can be efficiently solved using various approaches.

We explored the brute force method and the hash table approach, highlighting their implementations and time complexities.

The hash table approach offers a significant improvement in efficiency, making it the preferred choice for larger arrays.

By understanding and mastering these solutions, you’ll be better equipped to tackle similar problem-solving challenges in the world of programming.

Remember, problem-solving is a skill that improves with practice, so keep challenging yourself with new programming puzzles and projects. Happy coding!