JavaScript Program to Construct an Array from its pair-sum Array

The pair-sum array is a unique construction that holds the sum of all potential pairs of elements from the original array. At first glance, it might appear to be challenging, but in this article, we'll Construct an array from its pair-sum array and discover some of its most intriguing uses.

What is Pair - Sum Array?

A pair-sum array in JavaScript is an array that holds the total number of potential pairs of elements from the original array. The pair-sum array, designated as pairSumArr, will have a length of n*(n-1)/2 when an array arr of length n is given. This is because it contains the sum of all conceivable combinations of two entries from the original array.

Example 1:

Suppose we have the original array arr = [2, 5, 7]. The pair-sum array will be:
pairSumArr = [2+5, 2+7, 5+7] = [7, 9, 12]
Here, pairSumArr[0] contains the sum of the first two elements of arr, i.e., 2 + 5 = 7. 
Similarly, pairSumArr[1] contains the sum of the first and last elements of arr, i.e., 2 + 7 = 9, 
and pairSumArr[2] contains the sum of the last two elements of arr, i.e., 5 + 7 = 12

Example 2:

2. If we take another example Suppose we have the original array arr = [3, 6, 8, 2]. 
We will construct the pair-sum array for this array.
pairSumArr = [3+6, 3+8, 3+2, 6+8, 6+2, 8+2] 
pairSumArr = [9, 11, 5, 14, 8, 10]
Use of Pair - Sum Array

1. Array Reconstruction: If the pair-sum array is known, it can be used to rebuild the original array. In this procedure, the sum array is reverse-engineered to get the elements of the original array.
2. Combinatorics: Applications of the pair-sum array include combinatorial issues, particularly when array combinations are involved.
3. Optimization Problems: The pair-sum array can assist in identifying patterns and connections between items in some optimization problems, resulting in optimum solutions.
4. Finding Missing Elements: When some items of an array are lost but their pairwise sums are still available, the pair-sum array can be useful. We may determine the elements that are missing by using the pair-sum array.

Constructing the Original Array from Pair-Sum Array

In JavaScript, we may apply a straightforward approach to create an array from its pair-sum array. The approach includes reconstructing the original array by going backward through the pair-sum array generation process given the pair-sum array pairSumArr. The fundamental concept is to use the provided pair-sum array to identify the original array's missing items. We must reverse engineer the pair-sum array's generation in order to create the original array from its pair-sum array. We may effectively rebuild the original array by recognizing the pattern and using the right algorithm.

Approach

The basic algorithm to construct an original array from a pair-sum array includes the following steps as follow.

• Create an array of size n to store the original array elements.
• Iterate n times and find the missing elements of the original array by performing reverse operations on the pair-sum array.
• Calculate the length of the pair-sum array.
• Calculate the length of the Original Array from the given Pair Sum Array.
• Return the reconstructed

Example:

// Function to construct original array 
// from pair sum array
function constructArr(pair, n) {
    let arr = new Array(n);

    // Calculate the first element of 
    // the original array
    // first element = (pair[0] + pair[1] 
    // - pair[n-1]) / 2
    arr[0] = Math.floor(
        (pair[0] + pair[1] - pair[n - 1]) / 2
    );

    for (let i = 1; i < n; i++)
        arr[i] = pair[i - 1] - arr[0];

    return arr;
}
// Function to calculate the length of the 
// original array from the given pair sum array
function calculateOriginalArrayLength(pairSumArrayLength) {
    return Math.ceil(
        (Math.sqrt(8 * pairSumArrayLength + 1) + 1) / 2
    );
}

// Given pair sum array
let pair = [13, 11, 10, 13, 10, 9, 12, 7, 10, 9];

// Calculate the length of the pair sum array
const arrayLength = pair.length;

// Calculate the length of the original array
const originalArrayLength =
    calculateOriginalArrayLength(arrayLength);

// Number of elements in the original array
let n = originalArrayLength;

// Create an array which can store original array
let originalArr = constructArr(pair, n);

// Required Original array from the Pair sum Array
console.log("Original Array:", originalArr);

Original Array: [ 7, 6, 4, 3, 6 ]