# Rearrange given Array by replacing every element with the element located at mean of adjacent elements

Given an array arr[]. The array contains numbers from 0 to N-1 only, where N is the size of arr[]. The task is to modify the array in such that for each i from 0â‰¤i<N, arr[i] = arr[ (arr[i-1] + arr[i+1]) / 2 ]

There are a few exceptions:

• For first element of the array, arr[i-1] = 0; because previous index does not exist.
• For the last element of the array, arr[i+1] = 0; because next index does not exist.

Examples:

Input: arr[]= {3, 2, 1, 4, 1, 8, 6, 8, 7}
Output: [2, 1, 4, 2, 6, 4, 7, 6, 1]
Explanation: Following are the operations performed to reach the desired output.
For index 0, arr[i-1]=0 and arr[i+1]=2, arr[0]= arr[(0+2)/2] = arr[1] = 2
For index 3, arr[i-1]=1 and arr[i+1]=1, arr[3]= arr[(1+1)/2] = arr[1] = 2

Input: arr[]= {2, 5, 3, 4, 0, 1}
Output: [3, 3, 0, 5, 3, 2]
Explanation: Following are the operations performed to reach the desired output.
For index 1, arr[i-1]=2 and arr[i+1]=3, arr[1]= arr[(2+3)/2] = arr[2] = 3
For index 4, arr[i-1]=4 and arr[i+1]=1, arr[4]= arr[(4+1)/2] = arr[2] = 3

Naive Approach: The simplest way is to create a new array and compute the values for each index using the given array, but this will take extra space. For every index, get the values of previous and next indexes and compute their average. This average will be the index whose value has to be copied at the chosen index in the new array. Thus, arr[i] = arr[ (arr[i-1] + arr[i+1]) / 2 ] will be achieved.

Time complexity: O(N), N is the size of arr[].
Auxiliary Space: O(N)

Efficient approach: This approach traverses the same array once and at the end desired array will be found. Keep track of the previous index element, so that even if its value is modified, the old value is possible to calculate. Only O(1) space is used in this case, that for the temporary variable to store the value of the previous element.

How to achieve this?

Consider two numbers x and y, both are less than N. The aim is to update the value of x (x = y) such that the old value (x=x) is not lost. Basically, just hold two values of x in the same variable. For that purpose First, increment the value x by the factor y*N. Updated x becomes x+y*N. The old value of x can be obtained by taking mod of Updated value; (x+y*N % N). The new value of x can be obtained by taking the quotient by dividing by N, (x+y*N/N). Follow the steps below to solve the given problem.

• Iterate the array arr[] from left to right.
• For every index increment the element by arr[(arr[i-1]+arr[i+1])/2] * N.
• To get the previous of ith element find the modulo with N, i.e arr[i-1]%N.
• To get the next of ith element find the quotient with N, i.e. arr[i+1]/N.
• Again Traverse the array from start to end.
• Print the ith element after dividing the ith element by N, i.e. array[i]/N.

Below is the implementation of the above approach.

## C++

 `// Program to modify the given array` `// as per given constraint.` `#include ` `using` `namespace` `std;`   `// Function to find the previous val` `int` `FindPrev(``int` `i, ``int` `a, ``int` `n)` `{` `    ``if` `(i == 0)` `        ``return` `0;` `    ``else` `        ``return` `a % n;` `}`   `// Function to find the next value` `int` `FindNext(``int` `i, ``int` `a, ``int` `n)` `{` `    ``if` `(i == n - 1)` `        ``return` `0;` `    ``else` `        ``return` `a;` `}`   `// The function to rearrange an array` `// in-place so that arr[i] becomes` `// arr[(arr[i-1]+arr[i+1])/2].` `void` `ModifyTheArray(``int` `arr[], ``int` `n)` `{` `    ``int` `new_ind, new_ind_val, next, prev;`   `    ``// Traverse the array arr[]` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``prev = FindPrev(i, arr[i - 1], n);` `        ``next = FindNext(i, arr[i + 1], n);` `        ``new_ind = (prev + next) / 2;` `        ``new_ind_val = arr[new_ind] % n;` `        ``arr[i] = arr[i] + n * new_ind_val;` `    ``}`   `    ``for` `(``int` `i = 0; i < n; i++)` `        ``arr[i] /= n;` `}`   `// A utility function to display the array of size n` `void` `DisplayArray(``int` `arr[], ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cout << arr[i] << ``" "``;` `    ``cout << endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 3, 2, 1, 4, 1, 8, 6, 8, 7 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``cout << ``"Given array is=> \n"``;` `    ``DisplayArray(arr, N);`   `    ``ModifyTheArray(arr, N);`   `    ``cout << ``"Modified array is=> \n"``;` `    ``DisplayArray(arr, N);` `  `  `    ``return` `0;` `}`

## Java

 `// Java Program to modify the given array` `// as per given constraint.` `import` `java.util.*;` `public` `class` `GFG` `{` `  `  `// Function to find the previous val` `static` `int` `FindPrev(``int` `i, ``int` `a, ``int` `n)` `{` `    ``if` `(i == ``0``)` `        ``return` `0``;` `    ``else` `        ``return` `a % n;` `}`   `// Function to find the next value` `static` `int` `FindNext(``int` `i, ``int` `a, ``int` `n)` `{` `    ``if` `(i == n - ``1``)` `        ``return` `0``;` `    ``else` `        ``return` `a;` `}`   `// The function to rearrange an array` `// in-place so that arr[i] becomes` `// arr[(arr[i-1]+arr[i+1])/2].` `static` `void` `ModifyTheArray(``int` `arr[], ``int` `n)` `{` `    ``int` `new_ind, new_ind_val, next, prev;`   `    ``// Traverse the array arr[]` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `        ``if``(i - ``1` `>= ``0` `){` `            ``prev = FindPrev(i, arr[i - ``1``], n);` `        ``}` `        ``else``{` `            ``prev = ``0``;` `        ``}` `        ``if``(i + ``1` `< n){` `            ``next = FindNext(i, arr[i + ``1``], n);` `        ``}` `        ``else``{` `            ``next = ``0``;` `        ``}` `        ``new_ind = (prev + next) / ``2``;` `        ``new_ind_val = arr[new_ind] % n;` `        ``arr[i] = arr[i] + n * new_ind_val;` `    ``}`   `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``arr[i] /= n;` `}`   `// A utility function to display the array of size n` `static` `void` `DisplayArray(``int` `arr[], ``int` `n)` `{` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``System.out.print(arr[i] + ``" "``);` `    ``System.out.println();` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``int` `arr[] = { ``3``, ``2``, ``1``, ``4``, ``1``, ``8``, ``6``, ``8``, ``7` `};` `    ``int` `N = arr.length;`   `    ``System.out.println(``"Given array is=>"``);` `    ``DisplayArray(arr, N);`   `    ``ModifyTheArray(arr, N);`   `    ``System.out.println(``"Modified array is=>"``);` `    ``DisplayArray(arr, N);` `}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# python3 Program to modify the given array` `# as per given constraint.`   `# Function to find the previous val`     `def` `FindPrev(i, a, n):`   `    ``if` `(i ``=``=` `0``):` `        ``return` `0` `    ``else``:` `        ``return` `a ``%` `n`     `# Function to find the next value` `def` `FindNext(i, a, n):`   `    ``if` `(i ``=``=` `n ``-` `1``):` `        ``return` `0` `    ``else``:` `        ``return` `a`     `# The function to rearrange an array` `# in-place so that arr[i] becomes` `# arr[(arr[i-1]+arr[i+1])/2].` `def` `ModifyTheArray(arr, n):`   `    ``# Traverse the array arr[]` `    ``for` `i ``in` `range``(``0``, n):` `        ``prev ``=` `FindPrev(i, arr[i ``-` `1``], n)` `        ``next` `=` `FindNext(i, arr[i ``+` `1``], n) ``if` `i ``+` `1` `< n ``else` `0` `        ``new_ind ``=` `(prev ``+` `next``) ``/``/` `2` `        ``new_ind_val ``=` `arr[new_ind] ``%` `n` `        ``arr[i] ``=` `arr[i] ``+` `n ``*` `new_ind_val`   `    ``for` `i ``in` `range``(``0``, n):` `        ``arr[i] ``/``/``=` `n`     `# A utility function to display the array of size n` `def` `DisplayArray(arr, n):`   `    ``for` `i ``in` `range``(``0``, n):` `        ``print``(arr[i], end``=``" "``)` `    ``print``()`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``3``, ``2``, ``1``, ``4``, ``1``, ``8``, ``6``, ``8``, ``7``]` `    ``N ``=` `len``(arr)`   `    ``print``(``"Given array is=> "``)` `    ``DisplayArray(arr, N)`   `    ``ModifyTheArray(arr, N)`   `    ``print``(``"Modified array is=> "``)` `    ``DisplayArray(arr, N)`   `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections;`   `class` `GFG` `{` `  ``// Function to find the previous val` `  ``static` `int` `FindPrev(``int` `i, ``int` `a, ``int` `n)` `  ``{` `    ``if` `(i == 0)` `      ``return` `0;` `    ``else` `      ``return` `a % n;` `  ``}`   `  ``// Function to find the next value` `  ``static` `int` `FindNext(``int` `i, ``int` `a, ``int` `n)` `  ``{` `    ``if` `(i == n - 1)` `      ``return` `0;` `    ``else` `      ``return` `a;` `  ``}`   `  ``// The function to rearrange an array` `  ``// in-place so that arr[i] becomes` `  ``// arr[(arr[i-1]+arr[i+1])/2].` `  ``static` `void` `ModifyTheArray(``int` `[]arr, ``int` `n)` `  ``{` `    ``int` `new_ind, new_ind_val, next, prev;`   `    ``// Traverse the array arr[]` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``if``(i - 1 >= 0 ){` `        ``prev = FindPrev(i, arr[i - 1], n);` `      ``}` `      ``else``{` `        ``prev = 0;` `      ``}` `      ``if``(i + 1 < n){` `        ``next = FindNext(i, arr[i + 1], n);` `      ``}` `      ``else``{` `        ``next = 0;` `      ``}` `      ``new_ind = (prev + next) / 2;` `      ``new_ind_val = arr[new_ind] % n;` `      ``arr[i] = arr[i] + n * new_ind_val;` `    ``}`   `    ``for` `(``int` `i = 0; i < n; i++)` `      ``arr[i] /= n;` `  ``}`   `  ``// A utility function to display the array of size n` `  ``static` `void` `DisplayArray(``int` `[]arr, ``int` `n)` `  ``{` `    ``for` `(``int` `i = 0; i < n; i++)` `      ``Console.Write(arr[i] + ``" "``);` `    ``Console.WriteLine();` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{`   `    ``int` `[]arr = { 3, 2, 1, 4, 1, 8, 6, 8, 7 };` `    ``int` `N = arr.Length;`   `    ``Console.WriteLine(``"Given array is=>"``);` `    ``DisplayArray(arr, N);`   `    ``ModifyTheArray(arr, N);`   `    ``Console.WriteLine(``"Modified array is=>"``);` `    ``DisplayArray(arr, N);`   `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

```Given array is=>
3 2 1 4 1 8 6 8 7
Modified array is=>
2 1 4 2 6 4 7 6 1 ```

Time Complexity: O(N), where N is the size of arr[] as we are using a loop to traverse N times.

Auxiliary Space: O(1), as we are not using any extra space.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next