Rearrange given Array by replacing every element with the element located at mean of adjacent elements
Last Updated :
06 Jun, 2022
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 <iostream>
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 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 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# 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.
<script>
// JavaScript program to modify the given array
// as per given constraint.
// Function to find the previous val
function FindPrev(i, a, n)
{
if (i == 0)
return 0;
else
return a % n;
}
// Function to find the next value
function 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].
function ModifyTheArray(arr, n)
{
let new_ind, new_ind_val, next, prev;
// Traverse the array arr[]
for(let i = 0; i < n; i++)
{
prev = FindPrev(i, arr[i - 1], n);
next = FindNext(i, arr[i + 1], n);
new_ind = Math.floor((prev + next) / 2);
new_ind_val = arr[new_ind] % n;
arr[i] = arr[i] + n * new_ind_val;
}
for(let i = 0; i < n; i++)
arr[i] = Math.floor(arr[i] / n);
}
// A utility function to display the array of size n
function DisplayArray(arr, n)
{
for(let i = 0; i < n; i++)
document.write(arr[i] + " ")
document.write('<br')
}
// Driver Code
let arr = [ 3, 2, 1, 4, 1, 8, 6, 8, 7 ];
let N = arr.length;
document.write("Given array is=> " + "<br>");
DisplayArray(arr, N);
ModifyTheArray(arr, N);
document.write("Modified array is=> " + "<br>");
DisplayArray(arr, N);
// This code is contributed by Potta Lokesh
</script>
OutputGiven 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.
Similar Reads
Make all array elements even by replacing adjacent pair of array elements with their sum
Given an array arr[] of size N, the task is to make all array elements even by replacing a pair of adjacent elements with their sum. Examples: Input: arr[] = { 2, 4, 5, 11, 6 }Output: 1Explanation:Replacing a pair (arr[2], arr[3]) with their sum ( = 5 + 11 = 16) modifies arr[] to { 2, 4, 16, 16, 6 }
8 min read
Rearrange given Array such that each elements is not equal to mean of adjacent elements
Given an array arr consisting of N unique integers, the task is to rearrange the array such that element at index i of array should not be mean of adjacent elements (i.e., of index i-1 and i+1). Any possible rearrangement can be returned. Example: Input: arr = [5, 4, 3, 2, 1]Output: [5, 3, 4, 2, 1]E
5 min read
Reduce given Array by replacing adjacent elements with their difference
Given an array arr[] consisting of N elements(such that N = 2k for some k ? 0), the task is to reduce the array and find the last remaining element after merging all elements into one. The array is reduced by performing the following operation: Merge the adjacent elements i.e merge elements at indic
5 min read
Make all array elements even by replacing any pair of array elements with their sum
Given an array arr[] consisting of N positive integers, the task is to make all array elements even by replacing any pair of array elements with their sum. Examples: Input: arr[] = {5, 6, 3, 7, 20}Output: 3Explanation: Operation 1: Replace arr[0] and arr[2] by their sum ( = 5 + 3 = 8) modifies arr[]
5 min read
Make all Array elements equal by replacing it with adjacent elements
Given an array A[] of size N, the task is to find the minimum number of moves required to make array elements equal where you can make adjacent elements equal in one move. Examples: Input: A = {1, 6, 5, 1, 7, 1}, N = 6Output: 3Explanation: Replace 6 with 1, 5 with 1, and then at last replace 7 with
5 min read
Maximum sum of Array formed by replacing each element with sum of adjacent elements
Given an array arr[] of size N, the task is to find the maximum sum of the Array formed by replacing each element of the original array with the sum of adjacent elements.Examples: Input: arr = [4, 2, 1, 3] Output: 23 Explanation: Replacing each element of the original array with the sum of adjacent
9 min read
Minimize Array sum by replacing elements such that Relation among adjacent elements in maintained
Given an array arr[] of size N, the task is to minimize the array sum after replacing array elements with positive integers in a way such the relation among the adjacent elements (pattern of the array)is maintained. Note: If arr[i] = arr[i+1] then in the new array they both can be the same or one ca
7 min read
Rearrange the Array to maximize the elements which is smaller than both its adjacent elements
Given an array arr[] consisting of N distinct integers, the task is to rearrange the array elements such that the count of elements that are smaller than their adjacent elements is maximum. Note: The elements left of index 0 and right of index N-1 are considered as -INF. Examples: Input: arr[] = {1,
7 min read
Replace all elements of given Array with average of previous K and next K elements
Given an array arr[] containing N positive integers and an integer K. The task is to replace every array element with the average of previous K and next K elements. Also, if K elements are not present then adjust use the maximum number of elements available before and after. Examples: Input: arr[] =
11 min read
Replace every element in a circular array by sum of next K elements
Given a circular array arr[] of N integers and an integer K, the task is to print the array after the following operations: If K is non-negative, then replace A[i] with the sum of the next K elements.If K is negative, then replace it with the sum of previous K elements. A cyclic array means the next
15+ min read