Maximum distance between two elements whose absolute difference is K
Last Updated :
14 Mar, 2023
Given an array arr[] and a number K, the task to find the maximum distance between two elements whose absolute difference is K. If it is not possible to find any maximum distance then print “-1”.
Example:
Input: arr[] = {3, 5, 1, 4, 2, 2}
Output: 5
Explanation:
The max distance between the two elements (3, 2) at index 0 and 5 is 5.
Input: arr[] = {11, 2, 3, 8, 5, 2}
Output: 3
Explanation:
The max distance between the two elements (3, 2) at index 2 and 5 is 3.
Naive Approach: The idea is to pick each element(say arr[i]) one by one, search for the previous element (arr[i] – K) and the next element (arr[i] + K). If any of the two-element exists then find the maximum distance between the current element with its next or previous element.
Time Complexity: O(N2)
Auxiliary Space: O(1)
Implementation:-
C++
#include <bits/stdc++.h>
using namespace std;
int maxDistance( int arr[], int K, int N)
{
int ans = -1;
for ( int i=1;i<N;i++)
{
for ( int j=i-1;j>=0;j--)
{
if ( abs (arr[i]-arr[j])==K)
{
ans=max(ans,i-j);
}
}
}
return ans;
}
int main()
{
int arr[] = { 11, 2, 3, 8, 5, 2 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 2;
cout << maxDistance(arr, K, N);
return 0;
}
|
Java
class GFG {
public static int maxDistance( int [] arr, int K, int N)
{
int ans = - 1 ;
for ( int i = 1 ;i < N;i++)
{
for ( int j = i - 1 ;j >= 0 ;j--)
{
if (Math.abs(arr[i] - arr[j]) == K)
{
ans = Math.max(ans,i - j);
}
}
}
return ans;
}
public static void main(String[] args)
{
int [] arr = { 11 , 2 , 3 , 8 , 5 , 2 };
int N = arr.length;
int K = 2 ;
System.out.print(maxDistance(arr, K, N));
}
}
|
Python3
def maxDistance(arr, K, N):
ans = - 1
for i in range ( 1 , N):
for j in range (i - 1 , - 1 , - 1 ):
if abs (arr[i] - arr[j]) = = K:
ans = max (ans, i - j)
return ans
arr = [ 11 , 2 , 3 , 8 , 5 , 2 ]
N = len (arr)
K = 2
print (maxDistance(arr, K, N))
|
C#
using System;
public class GFG
{
static int MaxDistance( int [] arr, int K, int N)
{
int ans = -1;
for ( int i = 1; i < N; i++)
{
for ( int j = i - 1; j >= 0; j--)
{
if (Math.Abs(arr[i] - arr[j]) == K)
{
ans = Math.Max(ans, i - j);
}
}
}
return ans;
}
static void Main( string [] args)
{
int [] arr = { 11, 2, 3, 8, 5, 2 };
int N = arr.Length;
int K = 2;
Console.WriteLine(MaxDistance(arr, K, N));
}
}
|
Javascript
function maxDistance(arr, K, N) {
let ans = -1;
for (let i = 1; i < N; i++) {
for (let j = i - 1; j >= 0; j--) {
if (Math.abs(arr[i] - arr[j]) === K)
ans = Math.max(ans, i - j);
}
}
return ans;
}
const arr = [11, 2, 3, 8, 5, 2];
const N = arr.length;
const K = 2;
console.log(maxDistance(arr, K, N));
|
Time Complexity:- O(N^2)
Auxiliary Space:- O(1)
Efficient Approach: To optimize the above approach, the idea is to use hashmap. Below are the steps:
- Traverse the array and store the index of the first occurrence in a HashMap.
- Now, for each element in the array arr[], check if arr[i] + K and arr[i] – K is present in the hashmap or not.
- If present, then update the distance from both the elements with the arr[i] and check for the next element.
- Print the maximum distance obtained after the above steps.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxDistance( int arr[], int K, int N)
{
unordered_map< int , int > Map;
int maxDist = 0;
for ( int i = 0; i < N; i++)
{
if (Map.find(arr[i]) == Map.end())
Map[arr[i]] = i;
if (Map.find(arr[i] + K) != Map.end())
{
maxDist = max(maxDist,
i - Map[arr[i] + K]);
}
if (Map.find(arr[i] - K) != Map.end())
{
maxDist = max(maxDist,
i - Map[arr[i] - K]);
}
}
if (maxDist == 0)
return -1;
else
return maxDist;
}
int main()
{
int arr[] = { 11, 2, 3, 8, 5, 2 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 2;
cout << maxDistance(arr, K, N);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static int maxDistance( int [] arr, int K)
{
Map<Integer, Integer> map
= new HashMap<>();
int maxDist = 0 ;
for ( int i = 0 ; i < arr.length; i++) {
if (!map.containsKey(arr[i]))
map.put(arr[i], i);
if (map.containsKey(arr[i] + K)) {
maxDist
= Math.max(
maxDist,
i - map.get(arr[i] + K));
}
if (map.containsKey(arr[i] - K)) {
maxDist
= Math.max(maxDist,
i - map.get(arr[i] - K));
}
}
if (maxDist == 0 )
return - 1 ;
else
return maxDist;
}
public static void main(String args[])
{
int [] arr = { 11 , 2 , 3 , 8 , 5 , 2 };
int K = 2 ;
System.out.println(
maxDistance(arr, K));
}
}
|
Python3
def maxDistance(arr, K):
map = {}
maxDist = 0
for i in range ( len (arr)):
if not arr[i] in map :
map [arr[i]] = i
if arr[i] + K in map :
maxDist = max (maxDist,
i - map [arr[i] + K])
if arr[i] - K in map :
maxDist = max (maxDist,
i - map [arr[i] - K])
if maxDist = = 0 :
return - 1
else :
return maxDist
arr = [ 11 , 2 , 3 , 8 , 5 , 2 ]
K = 2
print (maxDistance(arr,K))
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int maxDistance( int [] arr, int K)
{
Dictionary< int ,
int > map = new Dictionary< int ,
int >();
int maxDist = 0;
for ( int i = 0; i < arr.Length; i++)
{
if (!map.ContainsKey(arr[i]))
map.Add(arr[i], i);
if (map.ContainsKey(arr[i] + K))
{
maxDist = Math.Max(maxDist,
i - map[arr[i] + K]);
}
if (map.ContainsKey(arr[i] - K))
{
maxDist = Math.Max(maxDist,
i - map[arr[i] - K]);
}
}
if (maxDist == 0)
return -1;
else
return maxDist;
}
public static void Main(String []args)
{
int [] arr = { 11, 2, 3, 8, 5, 2 };
int K = 2;
Console.WriteLine(
maxDistance(arr, K));
}
}
|
Javascript
<script>
function maxDistance(arr, K, N)
{
var map = new Map();
var maxDist = 0;
for ( var i = 0; i < N; i++)
{
if (!map.has(arr[i]))
map.set(arr[i], i);
if (map.has(arr[i] + K))
{
maxDist = Math.max(maxDist,
i - map.get(arr[i] + K));
}
if (map.has(arr[i] - K))
{
maxDist = Math.max(maxDist,
i - map.get(arr[i] - K));
}
}
if (maxDist == 0)
return -1;
else
return maxDist;
}
var arr = [11, 2, 3, 8, 5, 2];
var N = arr.length;
var K = 2;
document.write( maxDistance(arr, K, N));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...