Construct an array from its pair-sum array

Try it on GfG Practice

Given a pair-sum array arr[], where each element represents the sum of a unique pair of elements from an unknown original array res[].
The pairs are considered in a specific order:

• First: res[0] + res[1]
• Then: res[0] + res[2], res[0] + res[3], ..., res[0] + res[n-1]
• Then: res[1] + res[2], res[1] + res[3], ..., and so on,
• Until all unique pairs (i, j) such that i < j are covered.

Notes:

• The size of the input array arr[] is always n × (n - 1) / 2, which is the number of unique pairs in an array of size n.
• The task is to reconstruct the original array res[] from arr[].
• It is not guaranteed that a valid res[] exists for every input arr[].
• There can be multiple valid original arrays that result in the same pair-sum array.

Examples

Input: arr[] = [4, 5, 3]
Output: [3, 1, 2]
Explanation: For [3, 1, 2], pairwise sums are (3 + 1), (3 + 2) and (1 + 2)

Input: arr[] = [3]
Output: [1, 2]
Explanation: There may be multiple valid original arrays that produce the same pair-sum array, such as [1, 2] and [2, 1]. Both are considered correct since they yield the same set of pairwise sums.

[Approach] Pair-Sum Decomposition

The approach begins by determining the size n of the original array using the formula for the number of unique pairs: n*(n-1)/2 = length of arr
Solving this gives the size of the original array.

Once n is known, we focus on the first three elements of the pair-sum array. These represent the sums:

• arr[0] = res[0] + res[1]
• arr[1] = res[0] + res[2]
• arr[2] = res[1] + res[2]

By adding the first two and subtracting the third, we can isolate res[0]: res[0] = (arr[0] + arr[1] - arr[2]) / 2.

After finding res[0], the rest of the values in res can be easily calculated. Since the next n - 1 values in arr represent res[0] + res[1], res[0] + res[2], ..., res[0] + res[n-1], we can subtract res[0] from each to find res[1] through res[n-1].

So, for each i from 1 to n - 1: res[i] = arr[i-1] - res[0].

Illustration:

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

vector<int> constructArr(vector<int>& arr) {
    
    if(arr.size() == 1) 
        return {1, arr[0]-1} ;
    
    // size of the result array
    int n = (1 + sqrt(1 + 8 * arr.size())) / 2;
    
    // find the result array
    vector<int> res(n);
    res[0] = (arr[0] + arr[1] - arr[n - 1]) / 2;
    for (int i = 1; i < n; i++)
        res[i] = arr[i - 1] - res[0];
        
    return res;
}


int main() {
    vector<int> arr = {4, 5, 3};
    vector<int> res = constructArr(arr);
    for (int x : res)
        cout << x << " ";
    return 0;
}

import java.util.ArrayList;
import java.util.List;

class GfG {

    public static ArrayList<Integer> constructArr(int[] arr){
        
        // only one pair-sum ⇒ original array has two numbers
        if (arr.length == 1) {
            return new ArrayList<>(List.of(1, arr[0] - 1));
        }

        // compute n from m = n·(n−1)/2  
        // n = (1 + √(1 + 8m)) / 2
        int n = (int) ((1 + Math.sqrt(1 + 8 * arr.length)) / 2);

        int[] res = new int[n];
        
        // res[0] is obtained from the first three relevant sums
        res[0] = (arr[0] + arr[1] - arr[n - 1]) / 2;

        // remaining elements: subtract res[0] from 
        // successive pair sums
        for (int i = 1; i < n; i++) {
            res[i] = arr[i - 1] - res[0];
        }

        ArrayList<Integer> ans = new ArrayList<>(n);
        for (int x : res) ans.add(x);
        return ans;
    }

    public static void main(String[] args) {
    
        int[] arr = {4, 5, 3};
        ArrayList<Integer> res = constructArr(arr);
    
        for (int x : res) System.out.print(x + " ");
    }
}

import math

def constructArr(arr):
    
    # when the pair-sum array has only one element,
    # the original array must have exactly two numbers.
    if len(arr) == 1:
        return [1, arr[0] - 1]

    # size of the original array 
    n = int((1 + math.isqrt(1 + 8 * len(arr))) / 2)

    # reconstruct the original array
    res = [0] * n
    res[0] = (arr[0] + arr[1] - arr[n - 1]) // 2
    for i in range(1, n):
        res[i] = arr[i - 1] - res[0]

    return res

if __name__ == "__main__":
    arr = [4, 5, 3]
    res = constructArr(arr)
    print(' '.join(map(str, res)))

using System;
using System.Collections.Generic;

class GfG{
    
    static List<int> constructArr(int[] arr){
        
        // only one pair-sum ⇒ original array has two numbers
        if (arr.Length == 1)
            return new List<int> { 1, arr[0] - 1 };

        // compute n from m = n·(n−1)/2  ⇒  n = (1 + √(1 + 8m)) / 2
        int n = (int)((1 + Math.Sqrt(1 + 8 * arr.Length)) / 2);

        int[] res = new int[n];
        
        // res[0] is obtained from the first three relevant sums
        res[0] = (arr[0] + arr[1] - arr[n - 1]) / 2;

        // remaining elements: subtract res[0] from successive pair sums
        for (int i = 1; i < n; i++)
            res[i] = arr[i - 1] - res[0];

        return new List<int>(res);
    }

    static void Main(){
        
        int[] arr = { 4, 5, 3 };
        List<int> res = constructArr(arr);
        foreach (int x in res) Console.Write(x + " ");
    }
}

function constructArr(arr) {
    
    // only one pair-sum 
    // the original array has exactly two numbers
    if (arr.length === 1) {
        return [1, arr[0] - 1];
    }

    // size of the original array
    const n = Math.floor((1 + Math.sqrt(1 + 8 * arr.length)) / 2);

    // reconstruct the original array
    const res = new Array(n);
    res[0] = (arr[0] + arr[1] - arr[n - 1]) / 2;
    for (let i = 1; i < n; i++) {
        res[i] = arr[i - 1] - res[0];
    }

    return res;
}

// Driver code
const arr = [4, 5, 3];
const res = constructArr(arr);
console.log(res.join(' ')); 

3 1 2 

Time Complexity: O(n), where n is the size of the original array, since we compute each element of res[] in a single pass.
Auxiliary Space: O(n), for storing the output array res[], no extra space is used beyond that.