# Find initial sequence that produces a given Array by cyclic increments upto index P

Given an array arr[] consisting of N elements and an integer P, the task is to find the initial array from which given arr[] is produced by the following operations:

• An element arr[i] from the initial array is selected. The ith index is reduced to 0.
• arr[i] indices are increased by 1 in a cyclic manner such that the last index to be incremented is P.

Examples:

Input: arr[] = {4, 3, 1, 6}, P = 4
Output: 3 2 5 4
Explanation:
The element arr is chosen from the initial array. The following arr[i] operations modifies the given array in the following sequence:
{3, 2, 0, 4} -> {3, 2, 0, 5} -> {4, 2, 0, 5} -> {4, 3, 0, 5} -> {4, 3, 1, 5} -> {4, 3, 1, 6}
Input: arr[] = {3, 2, 0, 2, 7}, P = 2
Output: 2 1 4 1 6

Approach: The above problem can be solved using below steps:

1. Find the minimum element in the array and subtract min – 1 from every index.
2. Now start subtracting 1 from the (P – 1)th index and repeat for all indices on the left in a cyclic manner until an index becomes 0.
3. Add the number of operations to that index.
4. The current state of arr[] gives the required initial state. Print the array.

Below is the implementation of the above approach :

## C++

 `// C++ program to implement the` `// above approach`   `#include ` `using` `namespace` `std;`   `// Function to generate and return the` `// required initial arrangement` `void` `findArray(``int``* a,` `               ``int` `n,` `               ``int` `P)` `{` `    ``// Store the minimum element` `    ``// in the array` `    ``int` `mi = *min_element(a, a + n);`   `    ``// Store the number of increments` `    ``int` `ctr = 0;` `    ``mi = max(0, mi - 1);`   `    ``// Subtract mi - 1 from every index` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``a[i] -= mi;`   `        ``ctr += mi;` `    ``}`   `    ``// Start from the last index which` `    ``// had been incremented` `    ``int` `i = P - 1;`   `    ``// Stores the index chosen to` `    ``// distribute its element` `    ``int` `start = -1;`   `    ``// Traverse the array cyclically and` `    ``// find the index whose element was` `    ``// distributed` `    ``while` `(1) {`   `        ``// If any index has its` `        ``// value reduced to 0` `        ``if` `(a[i] == 0) {`   `            ``// Index whose element was` `            ``// distributed` `            ``start = i;`   `            ``break``;` `        ``}`   `        ``a[i] -= 1;` `        ``ctr += 1;` `        ``i = (i - 1 + n) % n;` `    ``}`   `    ``// Store the number of increments` `    ``// at the starting index` `    ``a[start] = ctr;`   `    ``// Print the original array` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``cout << a[i] << ``", "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5;` `    ``int` `P = 2;`   `    ``int` `arr[] = { 3, 2, 0, 2, 7 };`   `    ``findArray(arr, N, P);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement the` `// above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to generate and return the` `// required initial arrangement` `static` `void` `findArray(``int` `[]a, ``int` `n,` `                               ``int` `P)` `{` `    `  `    ``// Store the minimum element` `    ``// in the array` `    ``int` `mi = Arrays.stream(a).min().getAsInt();`   `    ``// Store the number of increments` `    ``int` `ctr = ``0``;` `    ``mi = Math.max(``0``, mi - ``1``);`   `    ``// Subtract mi - 1 from every index` `    ``for``(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``a[i] -= mi;` `        ``ctr += mi;` `    ``}`   `    ``// Start from the last index which` `    ``// had been incremented` `    ``int` `i = P - ``1``;`   `    ``// Stores the index chosen to` `    ``// distribute its element` `    ``int` `start = -``1``;`   `    ``// Traverse the array cyclically and` `    ``// find the index whose element was` `    ``// distributed` `    ``while` `(``true``) ` `    ``{`   `        ``// If any index has its` `        ``// value reduced to 0` `        ``if` `(a[i] == ``0``)` `        ``{`   `            ``// Index whose element was` `            ``// distributed` `            ``start = i;` `            ``break``;` `        ``}` `        ``a[i] -= ``1``;` `        ``ctr += ``1``;` `        ``i = (i - ``1` `+ n) % n;` `    ``}`   `    ``// Store the number of increments` `    ``// at the starting index` `    ``a[start] = ctr;`   `    ``// Print the original array` `    ``for``(i = ``0``; i < n; i++)` `    ``{` `        ``System.out.print(a[i] + ``", "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``5``;` `    ``int` `P = ``2``;` `    ``int` `arr[] = { ``3``, ``2``, ``0``, ``2``, ``7` `};`   `    ``findArray(arr, N, P);` `}` `}`   `// This code is contributed by Rajput-Ji`

## C#

 `// C# program to implement the` `// above approach` `using` `System;` `using` `System.Linq;` `class` `GFG{`   `// Function to generate and return the` `// required initial arrangement` `static` `void` `findArray(``int` `[]a, ``int` `n,` `                               ``int` `P)` `{` `    `  `    ``// Store the minimum element` `    ``// in the array` `    ``int` `mi = a.Min();`   `    ``// Store the number of increments` `    ``int` `ctr = 0;` `    ``mi = Math.Max(0, mi - 1);`   `    ``// Subtract mi - 1 from every index` `    ``int` `i;` `    ``for``(i = 0; i < n; i++)` `    ``{` `        ``a[i] -= mi;` `        ``ctr += mi;` `    ``}`   `    ``// Start from the last index which` `    ``// had been incremented` `     ``i = P - 1;`   `    ``// Stores the index chosen to` `    ``// distribute its element` `    ``int` `start = -1;`   `    ``// Traverse the array cyclically and` `    ``// find the index whose element was` `    ``// distributed` `    ``while` `(``true``) ` `    ``{`   `        ``// If any index has its` `        ``// value reduced to 0` `        ``if` `(a[i] == 0)` `        ``{`   `            ``// Index whose element was` `            ``// distributed` `            ``start = i;` `            ``break``;` `        ``}` `        ``a[i] -= 1;` `        ``ctr += 1;` `        ``i = (i - 1 + n) % n;` `    ``}`   `    ``// Store the number of increments` `    ``// at the starting index` `    ``a[start] = ctr;`   `    ``// Print the original array` `    ``for``(i = 0; i < n; i++)` `    ``{` `        ``Console.Write(a[i] + ``", "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `N = 5;` `    ``int` `P = 2;` `    ``int` `[]arr = { 3, 2, 0, 2, 7 };`   `    ``findArray(arr, N, P);` `}` `}`   `// This code is contributed by Rohit_ranjan`

Output:

```2, 1, 4, 1, 6,

```

Time Complexity: O(N)
Auxiliary Space: O(1) 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 : Rajput-Ji, Rohit_ranjan