2 Sum - Pair Sum Closest to Target

// C Code to find the pair with sum closest to target by
// exploring all the pairs

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

// Function to find the minimum and maximum between two values
int min(int a, int b) {
    return (a < b) ? a : b;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

// Function to find the pair with sum closest to target
int* sumClosest(int arr[], int n, int target) {
    
    // If there are fewer than 2 elements, return NULL
    if (n < 2) {
        return NULL;
    }

    static int res[2];
    int minDiff = INT_MAX;

    // Generating all possible pairs
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            int currSum = arr[i] + arr[j];
            int currDiff = abs(currSum - target);

            // if currDiff is less than minDiff, it indicates
            // that this pair is closer to the target
            if (currDiff < minDiff) {
                minDiff = currDiff;
                res[0] = min(arr[i], arr[j]);
                res[1] = max(arr[i], arr[j]);
            }

            // if currDiff is equal to minDiff, find the one 
            // with the largest difference
            else if (currDiff == minDiff && 
                    (res[1] - res[0]) < abs(arr[i] - arr[j])) {
                res[0] = min(arr[i], arr[j]);
                res[1] = max(arr[i], arr[j]);
            }
        }
    }

    return res;
}

int main() {
    int arr[] = {5, 2, 7, 1, 4};
    int target = 10;
    int n = sizeof(arr) / sizeof(arr[0]);

    int* res = sumClosest(arr, n, target);
    
    if (res != NULL) 
        printf("%d %d\n", res[0], res[1]);
    else 
        printf("-1");

    return 0;
}

// C Program to find pair with sum closest to target 
// using Two Pointer Technique

#include <stdio.h>
#include <limits.h>

// Function to compare elements for sorting
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

// function to return the pair with sum closest to target
int* sumClosest(int arr[], int n, int target) {
    
    // Handle the case when n < 2
    if (n < 2) {
        return NULL;  
    }

    int* res = (int*)malloc(2 * sizeof(int));  
    qsort(arr, n, sizeof(int), compare);
    int minDiff = INT_MAX;
    int left = 0, right = n - 1;

    while (left < right) {
        int currSum = arr[left] + arr[right];

        // Check if this pair is closer than the closest
        // pair so far
        if (abs(target - currSum) < minDiff) {
            minDiff = abs(target - currSum);
            res[0] = arr[left];
            res[1] = arr[right];
        }

        // If this pair has less sum, move to greater values
        if (currSum < target)
            left++;
      
        // If this pair has more sum, move to smaller values
        else if (currSum > target)
            right--;
      
        // If this pair has sum = target, return it
        else
            return res;
    }

    return res;
}

int main() {
    int arr[] = {5, 2, 7, 1, 4};
    int target = 10;
    int n = sizeof(arr) / sizeof(arr[0]);

    int* res = sumClosest(arr, n, target);
    if (res != NULL)
        printf("%d %d\n", res[0], res[1]);
    return 0;
}