Generate original array from difference between every two consecutive elements

Given N – 1 differences between two consecutive elements of an array containing N numbers which are in range of 1 to N. The task is to determine the original array using the given differences. If possible print the array, else print -1.

Examples:

Input: diff[] = {2, -3, 2}
Output: arr[] = {2, 4, 1, 3}
4 – 2 = 2
1 – 4 = -3
3 – 1 = 2

Input: diff[] = {2, 2, 2}
Output: -1



Approach: Since we want to generate permutations in the range [1, n] and each digit should occur only once. Take for example,

arr[] = {2, -3, 2}
Here, P2 – P1 = 2, P3 – P2 = -3, P4 – P3 = 2.
Let P1 = x then P2 = x + 2, P3 = P2 – 3 = x + 2 – 3 = x – 1, P4 = P3 + 2 = x – 1 + 2 = x + 1.
So, P1 = x, P2 = x + 2, P3 = x – 1, P4 = x + 1.

Now since we want a permutation from 1 to n, therfore the P[i]’s we get above must also satisfy the condition. Since the value must be satisfied for each and every x, hence for our simplicity we take x = 0.
Now, P1 = 0, P2 = 2, P3 = -1, P4 = 1.

We will sort the p[i]’s, after sorting the consecutive difference between each element must be equal to 1. If at any index we encounter an element p[i] such that p[i] – p[i – 1] != 1 then it is not possible to generate the permutation. To generate the final permutation we will keep track of indices, we can use map or unordered_map to do so.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to print the required permutation
void findPerm(int n, vector<int>& differences)
{
    vector<int> ans;
    ans.clear();
    ans.push_back(0);
  
    // Take x = 0 for simplicity
    int x = 0;
  
    // Calculate aint the differences
    // and store it in a vector
    for (int i = 0; i <= n - 2; ++i) {
        int diff = differences[i];
        x = x + diff;
        ans.push_back(x);
    }
  
    // Preserve the original array
    vector<int> anss = ans;
    sort(ans.begin(), ans.end());
    int flag = -1;
  
    // Check if aint the consecutive elements
    // have difference = 1
    for (int i = 1; i <= n - 1; ++i) {
        int res = ans[i] - ans[i - 1];
        if (res != 1) {
            flag = 0;
        }
    }
  
    // If consecutive elements don't have
    // difference 1 at any position then
    // the answer is impossible
    if (flag == 0) {
        cout << -1;
        return;
    }
  
    // Else store the indices and values
    // at those indices in a map
    // and finainty print them
    else {
        unordered_map<int, int> mpp;
        mpp.clear();
        int j = 1;
        vector<int> value_at_index;
        for (auto& x : ans) {
            mpp[x] = j;
            ++j;
        }
        for (auto& x : anss) {
            value_at_index.push_back(mpp[x]);
        }
        for (auto& x : value_at_index) {
            cout << x << " ";
        }
        cout << endl;
    }
}
  
// Driver code
int main()
{
    vector<int> differences;
    differences.push_back(2);
    differences.push_back(-3);
    differences.push_back(2);
    int n = differences.size() + 1;
    findPerm(n, differences);
  
    return 0;
}

chevron_right


Python3

# Python3 implementation of the approach

# Function to prthe required permutation
def findPerm(n, differences):
ans = []
ans.append(0)

# Take x = 0 for simplicity
x = 0

# Calculate athe differences
# and store it in a vector
for i in range(n – 1):
diff = differences[i]
x = x + diff
ans.append(x)

# Preserve the original array
anss = ans
ans = sorted(ans)
flag = -1

# Check if athe consecutive elements
# have difference = 1
for i in range(1, n):
res = ans[i] – ans[i – 1]
if (res != 1):
flag = 0

# If consecutive elements don’t have
# difference 1 at any position then
# the answer is impossible
if (flag == 0):
print(“-1″)
return

# Else store the indices and values
# at those indices in a map
# and finainty prthem
else:
mpp = dict()
j = 1
value_at_index = []
for x in ans:
mpp[x] = j
j += 1

for x in anss:
value_at_index.append(mpp[x])

for x in value_at_index:
print(x, end = ” “)
print()

# Driver code
differences=[]
differences.append(2)
differences.append(-3)
differences.append(2)
n = len(differences) + 1
findPerm(n, differences)

# This code is contributed by mohit kumar

Output:

2 4 1 3


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : mohit kumar 29