# 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.

LetP1 = xthenP2 = 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

1ton, therfore theP[i]’swe get above must also satisfy the condition. Since the value must be satisfied for each and everyx, 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++

`// 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*

*filter_none*

## 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

## Recommended Posts:

- Generate original array from an array that store the counts of greater elements on right
- Absolute Difference of all pairwise consecutive elements in an array
- Check if elements of an array can be arranged in a Circle with consecutive difference as 1
- Find original array from encrypted array (An array of sums of other elements)
- Print n smallest elements from given array in their original order
- Find k maximum elements of array in original order
- Count subarrays having total distinct elements same as original array
- Minimum array insertions required to make consecutive difference <= K
- Find elements of array using XOR of consecutive elements
- Replace array elements by sum of next two consecutive elements
- Construct an array from GCDs of consecutive elements in given array
- Sum of consecutive two elements in a array
- Product of all pairwise consecutive elements in an Array
- Modulus of all pairwise consecutive elements in an Array
- Check if array elements are consecutive | Added Method 3

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.