Related Articles
Generate original array from difference between every two consecutive elements
• Difficulty Level : Hard
• Last Updated : 20 Aug, 2020

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

 `// C++ implementation of the approach``#include ``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;``}`

## Java

 `// Java program to implement the above approach``import` `java.util.*;``class` `GFG ``{`` ` `// Function to print the required permutation``static` `void` `findPerm(``int` `n, Vector differences)``{``    ``Vector ans = ``new` `Vector();``    ``ans.clear();``    ``ans.add(``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.get(i);``        ``x = x + diff;``        ``ans.add(x);``    ``}`` ` `    ``// Preserve the original array``    ``Vector anss = ``new` `Vector();``    ``for``(Integer obj:ans)``        ``anss.add(obj);``         ` `    ``Collections.sort(ans);``    ``int` `flag = -``1``;`` ` `    ``// Check if aint the consecutive elements``    ``// have difference = 1``    ``for` `(``int` `i = ``1``; i <= n - ``1``; ++i)``    ``{``        ``int` `res = ans.get(i) - ans.get(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``) ``    ``{``        ``System.out.print(-``1``);``        ``return``;``    ``}`` ` `    ``// Else store the indices and values``    ``// at those indices in a map``    ``// and finainty print them``    ``else` `    ``{``        ``Map mpp = ``new` `HashMap<>();``        ``mpp.clear();``        ``int` `j = ``1``;``        ``Vector value_at_index = ``new` `Vector();``        ``for` `(Integer x1 : ans) ``        ``{``            ``mpp.put(x1, j);``            ``++j;``        ``}``        ``for` `(Integer x2 : anss) ``        ``{``            ``value_at_index.add(mpp.get(x2));``        ``}``        ``for` `(Integer x3 : value_at_index)``        ``{``            ``System.out.print(x3 + ``" "``);``        ``}``        ``System.out.println();``    ``}``}`` ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``Vector differences = ``new` `Vector();``    ``differences.add(``2``);``    ``differences.add(-``3``);``    ``differences.add(``2``);``    ``int` `n = differences.size() + ``1``;``    ``findPerm(n, differences);``    ``}``}`` ` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach`` ` `# Function to print the 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 print them``    ``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`

## C#

 `// C# program to implement the above approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG{`` ` `// Function to print the required permutation``static` `void` `findPerm(``int` `n, List<``int``> differences)``{``    ``List<``int``> ans = ``new` `List<``int``>();``    ``ans.Clear();``    ``ans.Add(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.Add(x);``    ``}`` ` `    ``// Preserve the original array``    ``List<``int``> anss = ``new` `List<``int``>();``    ``foreach``(``int` `obj ``in` `ans)``        ``anss.Add(obj);``         ` `    ``ans.Sort();``    ``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) ``    ``{``        ``Console.Write(-1);``        ``return``;``    ``}`` ` `    ``// Else store the indices and values``    ``// at those indices in a map``    ``// and finainty print them``    ``else``    ``{``        ``Dictionary<``int``,``                   ``int``> mpp = ``new` `Dictionary<``int``,``                                             ``int``>();``        ``mpp.Clear();``        ``int` `j = 1;``         ` `        ``List<``int``> value_at_index = ``new` `List<``int``>();``        ``foreach` `(``int` `x1 ``in` `ans) ``        ``{``            ``mpp.Add(x1, j);``            ``++j;``        ``}``         ` `        ``foreach` `(``int` `x2 ``in` `anss) ``        ``{``            ``value_at_index.Add(mpp[x2]);``        ``}``         ` `        ``foreach` `(``int` `x3 ``in` `value_at_index)``        ``{``            ``Console.Write(x3 + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}``}`` ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``List<``int``> differences = ``new` `List<``int``>();``    ``differences.Add(2);``    ``differences.Add(-3);``    ``differences.Add(2);``     ` `    ``int` `n = differences.Count + 1;``     ` `    ``findPerm(n, differences);``}``}`` ` `// This code is contributed by Amit Katiyar `
Output:
```2 4 1 3
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up