# Find permutation array from the cumulative sum array

Given an array arr[] of N elements where each arr[i] is the cumulative sum of the subarray P[0…i] of another array P[] where P is the permutation of the integers from 1 to N. The task is to find the array P[], if no such P exists then print -1.

Examples:

Input: arr[] = {2, 3, 6}
Output: 2 1 3

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• The first element of the cumulative array must be the first element of permutation array and the element at the ith position will be arr[i] – arr[i – 1] as arr[] is the cumulative sum array of the permutation array.
• So, find the array from the cumulative sum array and then mark the occurrence of every element from 1 to N that is present in the generated array.
• If any element is appearing more than once then the permutation is invalid else print the permutation.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the valid permutation ` `void` `getPermutation(``int` `a[], ``int` `n) ` `{ ` ` `  `    ``// Find the array from the cumulative sum ` `    ``vector<``int``> ans(n); ` `    ``ans = a; ` `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``ans[i] = a[i] - a[i - 1]; ` ` `  `    ``// To mark the occurrence of an element ` `    ``bool` `present[n + 1] = { ``false` `}; ` `    ``for` `(``int` `i = 0; i < ans.size(); i++) { ` ` `  `        ``// If current element has already ` `        ``// been seen previously ` `        ``if` `(present[ans[i]]) { ` `            ``cout << ``"-1"``; ` `            ``return``; ` `        ``} ` ` `  `        ``// Mark the current element's occurrence ` `        ``else` `            ``present[ans[i]] = ``true``; ` `    ``} ` ` `  `    ``// Print the required permutation ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``cout << ans[i] << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 2, 3, 6 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``getPermutation(a, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `class` `GFG ` `{ ` ` `  `// Function to find the valid permutation ` `static` `void` `getPermutation(``int` `a[], ``int` `n) ` `{ ` ` `  `    ``// Find the array from the cumulative sum ` `    ``int` `[]ans = ``new` `int``[n]; ` `    ``ans[``0``] = a[``0``]; ` `    ``for` `(``int` `i = ``1``; i < n; i++) ` `        ``ans[i] = a[i] - a[i - ``1``]; ` ` `  `    ``// To mark the occurrence of an element ` `    ``boolean` `[]present = ``new` `boolean``[n + ``1``]; ` `    ``for` `(``int` `i = ``0``; i < ans.length; i++)  ` `    ``{ ` ` `  `        ``// If current element has already ` `        ``// been seen previously ` `        ``if` `(present[ans[i]]) ` `        ``{ ` `            ``System.out.print(``"-1"``); ` `            ``return``; ` `        ``} ` ` `  `        ``// Mark the current element's occurrence ` `        ``else` `            ``present[ans[i]] = ``true``; ` `    ``} ` ` `  `    ``// Print the required permutation ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``System.out.print(ans[i] + ``" "``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `a[] = { ``2``, ``3``, ``6` `}; ` `    ``int` `n = a.length; ` ` `  `    ``getPermutation(a, n); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to find the valid permutation  ` `def` `getPermutation(a, n) :  ` ` `  `    ``# Find the array from the cumulative sum  ` `    ``ans ``=` `[``0``] ``*` `n;  ` `    ``ans[``0``] ``=` `a[``0``];  ` `    ``for` `i ``in` `range``(``1``, n) :  ` `        ``ans[i] ``=` `a[i] ``-` `a[i ``-` `1``];  ` ` `  `    ``# To mark the occurrence of an element  ` `    ``present ``=` `[``0``] ``*` `(n ``+` `1``);  ` `     `  `    ``for` `i ``in` `range``(n) : ` ` `  `        ``# If current element has already  ` `        ``# been seen previously  ` `        ``if` `(present[ans[i]]) : ` `            ``print``(``"-1"``, end ``=` `"");  ` `            ``return``;  ` ` `  `        ``# Mark the current element's occurrence  ` `        ``else` `: ` `            ``present[ans[i]] ``=` `True``;  ` ` `  `    ``# Print the required permutation  ` `    ``for` `i ``in` `range``(n) : ` `        ``print``(ans[i], end ``=` `" "``);  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``a ``=` `[ ``2``, ``3``, ``6` `];  ` `    ``n ``=` `len``(a);  ` ` `  `    ``getPermutation(a, n);  ` `     `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the above approach  ` `using` `System;  ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG  ` `{  ` ` `  `// Function to find the valid permutation ` `static` `void` `getPermutation(``int` `[] a, ``int` `n) ` `{ ` ` `  `    ``// Find the array from the cumulative sum ` `    ``List<``int``> ans = ``new` `List<``int``>(); ` `    ``ans.Add(a); ` `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``ans.Add(a[i] - a[i - 1]); ` ` `  `    ``// To mark the occurrence of an element ` `    ``List<``int``> present = ``new` `List<``int``>(); ` ` `  `    ``for` `(``int` `i = 0; i < n+1; i++) ` `        ``present.Add(0); ` ` `  `    ``for` `(``int` `i = 0; i < ans.Count; i++)  ` `    ``{ ` ` `  `        ``// If current element has already ` `        ``// been seen previously ` `        ``if` `(present[ans[i]] == 1) ` `        ``{ ` `            ``Console.Write(``"-1"``); ` `            ``return``; ` `        ``} ` ` `  `        ``// Mark the current element's occurrence ` `        ``else` `            ``present[ans[i]] = 1; ` `    ``} ` ` `  `    ``// Print the required permutation ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``Console.Write(ans[i] + ``" "``); ` `} ` ` `  `// Driver code ` `static` `public` `void` `Main()  ` `{  ` `    ``int``[] a = { 2,3,6}; ` `    ``int` `n = a.Length;  ` `    ``getPermutation(a, n);  ` `}  ` `} ` ` `  `// This code is ontributed by mohit kumar 29  `

Output:

```2 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 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.