Modify array by replacing every array element with minimum possible value of arr[j] + |j – i|
Last Updated :
14 Apr, 2023
Given an array arr[] of size N, the task is to find a value for each index such that the value at index i is arr[j] + |j – i| where 1 ? j ? N, the task is to find the minimum value for each index from 1 to N.
Example:
Input: N = 5, arr[] = {1, 4, 2, 5, 3}
Output: {1, 2, 2, 3, 3}
Explanation:
arr[0] = arr[0] + |0-0| = 1
arr[1] = arr[0] + |0-1| = 2
arr[2] = arr[2] + |2-2| = 2
arr[3] = arr[2] + |2-3| = 3
arr[4] = arr[4] + |4-4| = 3
The output array will give minimum value at every ith position.
Input: N = 4, arr[] = {1, 2, 3, 4}
Output: {1, 2, 3, 4}
Naive Approach: The idea is to use two nested for loops for traversing the array and for each ith index, find and print the minimum value of arr[j] + |i-j|.
Implementation :
C++
#include <bits/stdc++.h>
using namespace std;
void minAtEachIndex( int n, int arr[]) {
for ( int i = 0; i < n; i++) {
int minValue = INT_MAX;
for ( int j = 0; j < n; j++) {
int val = arr[j] + abs (i-j);
if (val < minValue) {
minValue = val;
}
}
cout << minValue << " " ;
}
return ;
}
int main() {
int arr[] = {1, 4, 2, 5, 3};
int n = sizeof (arr) / sizeof (arr[0]);
minAtEachIndex(n, arr);
return 0;
}
|
Java
import java.util.*;
public class Main {
public static void minAtEachIndex( int n, int [] arr) {
for ( int i = 0 ; i < n; i++) {
int minValue = Integer.MAX_VALUE;
for ( int j = 0 ; j < n; j++) {
int val = arr[j] + Math.abs(i - j);
if (val < minValue) {
minValue = val;
}
}
System.out.print(minValue + " " );
}
return ;
}
public static void main(String[] args) {
int arr[] = { 1 , 4 , 2 , 5 , 3 };
int n = arr.length;
minAtEachIndex(n, arr);
}
}
|
Python3
import sys
def minAtEachIndex(n, arr):
for i in range (n):
minValue = sys.maxsize
for j in range (n):
val = arr[j] + abs (i - j)
if val < minValue:
minValue = val
print (minValue, end = ' ' )
return
if __name__ = = '__main__' :
arr = [ 1 , 4 , 2 , 5 , 3 ]
n = len (arr)
minAtEachIndex(n, arr)
|
C#
using System;
class Program {
static void minAtEachIndex( int n, int [] arr) {
for ( int i = 0; i < n; i++) {
int minValue = int .MaxValue;
for ( int j = 0; j < n; j++) {
int val = arr[j] + Math.Abs(i-j);
if (val < minValue) {
minValue = val;
}
}
Console.Write(minValue + " " );
}
}
static void Main() {
int [] arr = {1, 4, 2, 5, 3};
int n = arr.Length;
minAtEachIndex(n, arr);
}
}
|
Javascript
function minAtEachIndex(n, arr) {
for (let i = 0; i < n; i++) {
let minValue = Number.MAX_SAFE_INTEGER;
for (let j = 0; j < n; j++) {
let val = arr[j] + Math.abs(i - j);
if (val < minValue) {
minValue = val;
}
}
document.write(minValue + " " );
}
}
let arr = [1, 4, 2, 5, 3];
let n = arr.length;
minAtEachIndex(n, arr);
|
Output:
1 2 2 3 3
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach: The idea is to use prefix sum technique from both left and right array traversal and find the minimum for each index. Follow the steps below to solve the problem:
- Take two auxiliary array dp1[] and dp2[] where dp1[] store the answer for the left to right traversal and dp2[] stores the answer for the right to left traversal.
- Traverse the array arr[] from i = 2 to N-1 and calculate min(arr[i], dp1[i-1] + 1).
- Traverse the array arr[] form i = N-1 to 1 and calculate min(arr[i], dp2[i+1] + 1).
- Again traverse the array from 1 to N and print min(dp1[i], dp2[i]) at each iteration.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void minAtEachIndex( int n, int arr[])
{
int dp1[n];
int dp2[n];
int i;
dp1[0] = arr[0];
for (i = 1; i < n; i++)
dp1[i] = min(arr[i], dp1[i - 1] + 1);
dp2[n - 1] = arr[n - 1];
for (i = n - 2; i >= 0; i--)
dp2[i] = min(arr[i], dp2[i + 1] + 1);
vector< int > v;
for (i = 0; i < n; i++)
v.push_back(min(dp1[i], dp2[i]));
for ( auto x : v)
cout << x << " " ;
}
int main()
{
int arr[] = { 1, 4, 2, 5, 3 };
int N = sizeof (arr) / sizeof (arr[0]);
minAtEachIndex(N, arr);
return 0;
}
|
Java
import java.util.*;
import java.util.ArrayList;
import java.util.List;
class GFG{
static void minAtEachIndex( int n, int arr[])
{
int dp1[] = new int [n];
int dp2[] = new int [n];
int i;
dp1[ 0 ] = arr[ 0 ];
for (i = 1 ; i < n; i++)
dp1[i] = Math.min(arr[i], dp1[i - 1 ] + 1 );
dp2[n - 1 ] = arr[n - 1 ];
for (i = n - 2 ; i >= 0 ; i--)
dp2[i] = Math.min(arr[i], dp2[i + 1 ] + 1 );
ArrayList<Integer> v = new ArrayList<Integer>();
for (i = 0 ; i < n; i++)
v.add(Math.min(dp1[i], dp2[i]));
for ( int x : v)
System.out.print(x + " " );
}
public static void main(String[] args)
{
int arr[] = { 1 , 4 , 2 , 5 , 3 };
int N = arr.length;
minAtEachIndex(N, arr);
}
}
|
Python3
def minAtEachIndex(n, arr):
dp1 = [ 0 ] * n
dp2 = [ 0 ] * n
i = 0
dp1[ 0 ] = arr[ 0 ]
for i in range ( 1 , n):
dp1[i] = min (arr[i], dp1[i - 1 ] + 1 )
dp2[n - 1 ] = arr[n - 1 ]
for i in range (n - 2 , - 1 , - 1 ):
dp2[i] = min (arr[i], dp2[i + 1 ] + 1 )
v = []
for i in range ( 0 , n):
v.append( min (dp1[i], dp2[i]))
for x in v:
print (x, end = " " )
if __name__ = = '__main__' :
arr = [ 1 , 4 , 2 , 5 , 3 ]
N = len (arr)
minAtEachIndex(N, arr)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void minAtEachIndex( int n, int []arr)
{
int []dp1 = new int [n];
int []dp2 = new int [n];
int i;
dp1[0] = arr[0];
for (i = 1; i < n; i++)
dp1[i] = Math.Min(arr[i], dp1[i - 1] + 1);
dp2[n - 1] = arr[n - 1];
for (i = n - 2; i >= 0; i--)
dp2[i] = Math.Min(arr[i], dp2[i + 1] + 1);
List< int > v = new List< int >();
for (i = 0; i < n; i++)
v.Add(Math.Min(dp1[i], dp2[i]));
foreach ( int x in v)
Console.Write(x + " " );
}
public static void Main(String[] args)
{
int []arr = { 1, 4, 2, 5, 3 };
int N = arr.Length;
minAtEachIndex(N, arr);
}
}
|
Javascript
<script>
function minAtEachIndex(n, arr)
{
var dp1 = Array(n);
var dp2 = Array(n);
var i;
dp1[0] = arr[0];
for (i = 1; i < n; i++)
dp1[i] = Math.min(arr[i], dp1[i - 1] + 1);
dp2[n - 1] = arr[n - 1];
for (i = n - 2; i >= 0; i--)
dp2[i] = Math.min(arr[i], dp2[i + 1] + 1);
var v = [];
for (i = 0; i < n; i++)
v.push(Math.min(dp1[i], dp2[i]));
v.forEach(x => {
document.write(x + " " );
});
}
var arr = [1, 4, 2, 5, 3];
var N = arr.length;
minAtEachIndex(N, arr);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...