# Find permutation array from the cumulative sum array

• Last Updated : 01 Mar, 2022

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

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[0] = a[0];``    ``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[0]);` `    ``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[0]);``    ``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 contributed by mohit kumar 29`

## Javascript

 ``

Output:

`2 1 3`

Time Complexity: O(n)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up