Find the minimum distance between two numbers

Try it on GfG Practice

Given an unsorted array arr[] and two numbers x and y, find the minimum distance between x and y in arr[]. The array might also contain duplicates. You may assume that both x and y are different and present in arr[].

Examples: 

Input: arr[] = {1, 2}, x = 1, y = 2
Output: Minimum distance between 1 and 2 is 1.
Explanation: 1 is at index 0 and 2 is at index 1, so the distance is 1

Input: arr[] = {3, 4, 5}, x = 3, y = 5
Output: Minimum distance between 3 and 5 is 2.
Explanation: 3 is at index 0 and 5 is at index 2, so the distance is 2

Input: arr[] = {3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3}, x = 3, y = 6
Output: Minimum distance between 3 and 6 is 4.
Explanation: 3 is at index 0 and 6 is at index 4, so the distance is 4

Input: arr[] = {2, 5, 3, 5, 4, 4, 2, 3}, x = 3, y = 2
Output: Minimum distance between 3 and 2 is 1.
Explanation: 3 is at index 7 and 2 is at index 6, so the distance is 1

Method 1: 

The task is to find the distance between two given numbers, So find the distance between any two elements using nested loops. The outer loop for selecting the first element (x) and the inner loop is for traversing the array in search for the other element (y) and taking the minimum distance between them.

Follow the steps below to implement the above idea:

• Create a variable m = INT_MAX
• Run a nested loop, the outer loop runs from start to end (loop counter i), the inner loop runs from i+1 to end (loop counter j).
• If the ith element is x and jth element is y or vice versa, update m as m = min(m,j-i)
• Print the value of m as minimum distance

Below is the implementation of the above approach:

// C++ program to Find the minimum
// distance between two numbers
#include <bits/stdc++.h>
using namespace std;

int minDist(int arr[], int n, int x, int y)
{
    int i, j;
    int min_dist = INT_MAX;
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            if ((x == arr[i] && y == arr[j]
                 || y == arr[i] && x == arr[j])
                && min_dist > abs(i - j)) {
                min_dist = abs(i - j);
            }
        }
    }
    if (min_dist > n) {
        return -1;
    }
    return min_dist;
}

/* Driver code */
int main()
{
    int arr[] = { 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 3;
    int y = 6;

    cout << "Minimum distance between " << x << " and " << y
         << " is " << minDist(arr, n, x, y) << endl;
}

// This code is contributed by Shivi_Aggarwal

// C program to Find the minimum
// distance between two numbers
#include <limits.h> // for INT_MAX
#include <stdio.h>
#include <stdlib.h> // for abs()

int minDist(int arr[], int n, int x, int y)
{
    int i, j;
    int min_dist = INT_MAX;
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            if ((x == arr[i] && y == arr[j]
                 || y == arr[i] && x == arr[j])
                && min_dist > abs(i - j)) {
                min_dist = abs(i - j);
            }
        }
    }
    if (min_dist > n) {
        return -1;
    }
    return min_dist;
}

/* Driver program to test above function */
int main()
{
    int arr[] = { 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 0;
    int y = 6;

    printf("Minimum distance between %d and %d is %d\n", x,
           y, minDist(arr, n, x, y));
    return 0;
}

// Java Program to Find the minimum
// distance between two numbers
import java.io.*;

class MinimumDistance {
    int minDist(int arr[], int n, int x, int y)
    {
        int i, j;
        int min_dist = Integer.MAX_VALUE;
        for (i = 0; i < n; i++) {
            for (j = i + 1; j < n; j++) {
                if ((x == arr[i] && y == arr[j]
                     || y == arr[i] && x == arr[j])
                    && min_dist > Math.abs(i - j))
                    min_dist = Math.abs(i - j);
            }
        }
        if (min_dist > n) {
            return -1;
        }
        return min_dist;
    }

    public static void main(String[] args)
    {
        MinimumDistance min = new MinimumDistance();
        int arr[] = { 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3 };
        int n = arr.length;
        int x = 0;
        int y = 6;

        System.out.println("Minimum distance between " + x
                           + " and " + y + " is "
                           + min.minDist(arr, n, x, y));
    }
}

# Python3 code to Find the minimum
# distance between two numbers


def minDist(arr, n, x, y):
    min_dist = 99999999
    for i in range(n):
        for j in range(i + 1, n):
            if (x == arr[i] and y == arr[j] or
                    y == arr[i] and x == arr[j]) and min_dist > abs(i-j):
                min_dist = abs(i-j)
        return min_dist


# Driver code
arr = [3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3]
n = len(arr)
x = 3
y = 6
print("Minimum distance between ", x, " and ",
      y, "is", minDist(arr, n, x, y))

# This code is contributed by "Abhishek Sharma 44"

// C# code to Find the minimum
// distance between two numbers
using System;

class GFG {
    
    static int minDist(int []arr, int n,
                           int x, int y) 
    {
        int i, j;
        int min_dist = int.MaxValue;
        for (i = 0; i < n; i++) 
        {
            for (j = i + 1; j < n; j++) 
            {
                if ((x == arr[i] && 
                     y == arr[j] || 
                     y == arr[i] && 
                       x == arr[j])
                    && min_dist >
                   Math.Abs(i - j))
                   
                    min_dist =
                    Math.Abs(i - j);
            }
        }
        return min_dist;
    }
    
    // Driver function
    public static void Main()
    {
        int []arr = {3, 5, 4, 2, 6,
              5, 6, 6, 5, 4, 8, 3};
        int n = arr.Length;
        int x = 3;
        int y = 6;

        Console.WriteLine("Minimum "
               + "distance between "
         + x +  " and " + y + " is " 
           + minDist(arr, n, x, y));
    }
}

// This code is contributed by Sam007

<script>

// Javascript program to find the minimum
// distance between two numbers
function minDist(arr, n, x, y)
{
    var i, j;
    var min_dist = Number.MAX_VALUE;
    
    for(i = 0; i < n; i++)
    {
        for(j = i + 1; j < n; j++) 
        {
            if ((x == arr[i] && y == arr[j] || 
                 y == arr[i] && x == arr[j]) && 
                 min_dist > Math.abs(i - j))
                min_dist = Math.abs(i - j);
        }
    }
    if(min_dist>n)
      {
        return -1;
      }
    return min_dist;
}

// Driver code
var arr = [ 3, 5, 4, 2, 6, 5, 
            6, 6, 5, 4, 8, 3 ];
var n = arr.length;
var x = 3;
var y = 6;

document.write("Minimum distance between " + x +
               " and " + y + " is " +
               minDist(arr, n, x, y));

// This code is contributed by gauravrajput1 

</script>

<?php
// PHP program to Find the minimum 
// distance between two numbers

function minDist($arr, $n, $x, $y)
{
    $i; $j;
    $min_dist = PHP_INT_MAX;
    for ($i = 0; $i < $n; $i++)
    {
        for ($j = $i + 1; $j < $n; $j++)
        {
            if( ($x == $arr[$i] and $y == $arr[$j] or
                $y == $arr[$i] and $x == $arr[$j]) and
                             $min_dist > abs($i - $j))
            {
                $min_dist = abs($i - $j);
            }
        }
    }
  if($min_dist>$n)
      {
        return -1;
      }
    return $min_dist;
}

    // Driver Code
    $arr = array(3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3);
    $n = count($arr);
    $x = 0;
    $y = 6;

    echo "Minimum distance between ",$x, " and ",$y," is "; 
    echo minDist($arr, $n, $x, $y);

// This code is contributed by anuj_67.
?>

Minimum distance between 3 and 6 is 4

Time Complexity: O(n^2), Nested loop is used to traverse the array.
Auxiliary Space: O(1), no extra space is required.

Method 2: 

The basic approach is to check only consecutive pairs of x and y. For every element x or y, check the index of the previous occurrence of x or y and if the previous occurring element is not similar to current element update the minimum distance. But a question arises what if an x is preceded by another x and that is preceded by a y, then how to get the minimum distance between pairs. By analyzing closely it can be seen that every x followed by a y or vice versa can only be the closest pair (minimum distance) so ignore all other pairs.

Follow the steps below to implement the above idea: 

• Create a variable prev=-1 and m= INT_MAX
• Traverse through the array from start to end.
• If the current element is x or y, prev is not equal to -1 and array[prev] is not equal to current element then update m = min(current_index - prev, m), i.e. find the distance between consecutive pairs and update m with it.
• print the value of m

Below is the implementation of the above approach:

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

int minDist(int arr[], int n, int x, int y)
{
        
    //previous index and min distance
    int p = -1, min_dist = INT_MAX;
    
    for(int i=0 ; i<n ; i++)
    {
        if(arr[i]==x || arr[i]==y)
        {
            //we will check if p is not equal to -1 and 
            //If the element at current index matches with
            //the element at index p , If yes then update 
            //the minimum distance if needed 
            if( p != -1 && arr[i] != arr[p])
                min_dist = min(min_dist , i-p);
             
            //update the previous index 
            p=i;
        }
    }
    //If distance is equal to int max 
    if(min_dist==INT_MAX)
        return -1;

    return min_dist;
}

/* Driver code */
int main()
{
    int arr[] = {3, 5, 4, 2, 6, 3, 0, 0, 5, 4, 8, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 3;
    int y = 6;

    cout << "Minimum distance between " << x <<
                        " and " << y << " is "<<
                        minDist(arr, n, x, y) << endl;
    return 0;
}

// This code is contributed by Mukul singh.

#include <stdio.h>
#include <limits.h> // For INT_MAX

//returns minimum of two numbers
int min(int a ,int b)
{
    if(a < b)
        return a;
    return b;
}

int minDist(int arr[], int n, int x, int y)
{
    //previous index and min distance
    int i=0,p=-1, min_dist=INT_MAX;
    
    for(i=0 ; i<n ; i++)
    {
        if(arr[i] ==x || arr[i] == y)
        {
            //we will check if p is not equal to -1 and 
            //If the element at current index matches with
            //the element at index p , If yes then update 
            //the minimum distance if needed 
            if(p != -1 && arr[i] != arr[p])
                min_dist = min(min_dist,i-p);
             
            //update the previous index 
            p=i;
        }
    }
    //If distance is equal to int max 
    if(min_dist==INT_MAX)
       return -1;
    return min_dist;
}

/* Driver program to test above function */
int main()
{
    int arr[] ={3, 5, 4, 2, 6, 3, 0, 0, 5, 4, 8, 3};
    int n = sizeof(arr)/sizeof(arr[0]);
    int x = 3;
    int y = 6;

    printf("Minimum distance between %d and %d is %d\n", x, y,
            minDist(arr, n, x, y));
    return 0;
}

import java.io.*;

class MinimumDistance
{
    int minDist(int arr[], int n, int x, int y) 
    {
        
    //previous index and min distance
    int i=0,p=-1, min_dist=Integer.MAX_VALUE;
    
    for(i=0 ; i<n ; i++)
    {
        if(arr[i] ==x || arr[i] == y)
        {
            //we will check if p is not equal to -1 and 
            //If the element at current index matches with
            //the element at index p , If yes then update 
            //the minimum distance if needed 
            if(p != -1 && arr[i] != arr[p])
                min_dist = Math.min(min_dist,i-p);
             
            //update the previous index 
            p=i;
        }
    }
    //If distance is equal to int max 
    if(min_dist==Integer.MAX_VALUE)
       return -1;
    return min_dist;
}

    /* Driver program to test above functions */
    public static void main(String[] args) {
        MinimumDistance min = new MinimumDistance();
        int arr[] = {3, 5, 4, 2, 6, 3, 0, 0, 5, 4, 8, 3};
        int n = arr.length;
        int x = 3;
        int y = 6;

        System.out.println("Minimum distance between " + x + " and " + y
                + " is " + min.minDist(arr, n, x, y));
    }
}

import sys

def minDist(arr, n, x, y):
    
    #previous index and min distance
    i=0
    p=-1
    min_dist = sys.maxsize;
    
    for i in range(n): 
    
        if(arr[i] ==x or arr[i] == y):
        
            #we will check if p is not equal to -1 and 
            #If the element at current index matches with
            #the element at index p , If yes then update 
            #the minimum distance if needed 
            if(p != -1 and arr[i] != arr[p]):
                min_dist = min(min_dist,i-p)
             
            #update the previous index 
            p=i
        
    
    #If distance is equal to int max 
    if(min_dist == sys.maxsize):
       return -1
    return min_dist

 
# Driver program to test above function */
arr = [3, 5, 4, 2, 6, 3, 0, 0, 5, 4, 8, 3]
n = len(arr)
x = 3
y = 6
print ("Minimum distance between %d and %d is %d\n"%( x, y,minDist(arr, n, x, y)));

# This code is contributed by Shreyanshi Arun.

// C# program to Find the minimum 
// distance between two numbers
using System;
class MinimumDistance {
    
    static int minDist(int []arr, int n,
                       int x, int y) 
    {
    //previous index and min distance
    int i=0,p=-1, min_dist=int.MaxValue;
    
    for(i=0 ; i<n ; i++)
    {
        if(arr[i] ==x || arr[i] == y)
        {
            //we will check if p is not equal to -1 and 
            //If the element at current index matches with
            //the element at index p , If yes then update 
            //the minimum distance if needed 
            if(p != -1 && arr[i] != arr[p])
                min_dist = Math.Min(min_dist,i-p);
             
            //update the previous index 
            p=i;
        }
    }
    //If distance is equal to int max 
    if(min_dist==int.MaxValue)
       return -1;
 
   return min_dist;
}
    // Driver Code
    public static void Main() 
    {
        
        int []arr = {3, 5, 4, 2, 6, 3, 
                     0, 0, 5, 4, 8, 3};
        int n = arr.Length;
        int x = 3;
        int y = 6;
        Console.WriteLine("Minimum distance between " + x + " and " + y
                                       + " is " + minDist(arr, n, x, y));
    }
}

// This code is contributed by anuj_67.

<script>
function minDist(arr , n , x , y) 
{
    
    // previous index and min distance
    var i=0,p=-1, min_dist=Number.MAX_VALUE;
    
    for(i=0 ; i<n ; i++)
    {
        if(arr[i] ==x || arr[i] == y)
        {
         // we will check if p is not equal to -1 and 
        // If the element at current index matches with
        // the element at index p , If yes then update 
        // the minimum distance if needed 
        if(p != -1 && arr[i] != arr[p])
            min_dist = Math.min(min_dist,i-p);
         
        // update the previous index 
            p=i;
        }
    }
    // If distance is equal to var max 
    if(min_dist==Number.MAX_VALUE)
       return -1;
    return min_dist;
}

    /* Driver program to test above functions */

    var arr = [3, 5, 4, 2, 6, 3, 0, 0, 5, 4, 8, 3];
    var n = arr.length;
    var x = 3;
    var y = 6;

    document.write("Minimum distance between " + x + " and " + y
            + " is " + minDist(arr, n, x, y));

// This code contributed by shikhasingrajput 

</script>

<?php
// PHP program to Find the minimum 
// distance between two numbers

function minDist($arr, $n, $x, $y)
{
    
    //previous index and min distance
    $i=0;
    $p=-1;
    $min_dist=PHP_INT_MAX;
    
    for($i=0 ; $i<$n ; $i++)
    {
        if($arr[$i] ==$x || $arr[$i] == $y)
        {
            //we will check if p is not equal to -1 and 
            //If the element at current index matches with
            //the element at index p , If yes then update 
            //the minimum distance if needed 
            if($p != -1 && $arr[$i] != $arr[$p])
                $min_dist = min($min_dist,$i-$p);
             
            //update the previous index 
            $p=$i;
        }
    }
    //If distance is equal to int max 
    if($min_dist==PHP_INT_MAX)
       return -1;
    return $min_dist;
}

/* Driver program to test above function */
    $arr =array(3, 5, 4, 2, 6, 3, 0, 0, 5,
                                    4, 8, 3);
    $n = count($arr);
    $x = 3;
    $y = 6;

    echo "Minimum distance between $x and ",
         "$y is ", minDist($arr, $n, $x, $y);

// This code is contributed by anuj_67.
?>

Minimum distance between 3 and 6 is 1

Time Complexity: O(n), Only one traversal of the array is needed.
Auxiliary Space: O(1), As no extra space is required.

Method 3:

The problem says that we want a minimum distance between x and y. So the approach is traverse the array and while traversing in array if we got the number as x or y then we will store the difference between indices of previously found x or y and newly find x or y and like this for every time we will try to minimize the difference.

Follow the steps below to implement the above idea: 

•    Create variables idx1 = -1, idx2 = -1 and min_dist = INT_MAX;
•    Traverse the array from i = 0 to i = n-1 where n is the size of array.
•    While traversing if the current element is x then store index of current element in idx1 or if the current element is y then store index of current element in idx2.
•    If idx1 and idx2 variables are not equal to -1 then store minimum of min_dist, difference of idx1 and idx2 into    ans.
•    At the end of traversal, if idx1 or idx2 are still -1(x or y not found in array) then return -1 or else return              min_dist.

Below is the implementation of the above approach:

// C++ program to Find the minimum
// distance between two numbers
#include <bits/stdc++.h>
using namespace std;
 
int minDist(int arr[], int n, int x, int y)
{
    //idx1 and idx2 will store indices of
    //x or y and min_dist will store the minimum difference
    int idx1=-1,idx2=-1,min_dist = INT_MAX;
    for(int i=0;i<n;i++)
    {
       //if current element is x then change idx1
       if(arr[i]==x)
       {
          idx1=i;
       }
       //if current element is y then change idx2
       else if(arr[i]==y)
       {
          idx2=i;
       }
       //if x and y both found in array
       //then only find the difference and store it in min_dist
       if(idx1!=-1 && idx2!=-1)
       min_dist=min(min_dist,abs(idx1-idx2));
    }
    
    //if left or right did not found in array
    //then return -1
    if(idx1==-1||idx2==-1)
    return -1;
    //return the minimum distance
    else
    return min_dist;
}
 
/* Driver code */
int main()
{
    int arr[] = { 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 3;
    int y = 6;
 
    cout << "Minimum distance between " << x << " and " << y
         << " is " << minDist(arr, n, x, y) << endl;
}
 

// Java program to Find the minimum
// distance between two numbers
import java.io.*;
public class GFG {

    static int minDist(int arr[], int n, int x, int y)
    {
        // idx1 and idx2 will store indices of
        // x or y and min_dist will store the minimum
        // difference
        int idx1 = -1, idx2 = -1,
            min_dist = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            // if current element is x then change idx1
            if (arr[i] == x) {
                idx1 = i;
            }
            // if current element is y then change idx2
            else if (arr[i] == y) {
                idx2 = i;
            }
            // if x and y both found in array
            // then only find the difference and store it in
            // min_dist
            if (idx1 != -1 && idx2 != -1)
                min_dist = Math.min(min_dist,
                                    Math.abs(idx1 - idx2));
        }

        // if left or right did not found in array
        // then return -1
        if (idx1 == -1 || idx2 == -1)
            return -1;
        // return the minimum distance
        else
            return min_dist;
    }

    /* Driver code */
    public static void main(String[] args)
    {
        int arr[] = { 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3 };
        int n = arr.length;
        int x = 3;
        int y = 6;

        System.out.println("Minimum distance between " + x
                           + " and " + y + " is "
                           + minDist(arr, n, x, y));
    }
}

// This code is contributed by Lovely Jain

# Python program to Find the minimum
# distance between two numbers
import sys

def minDist(arr, n, x, y) :
    
    # idx1 and idx2 will store indices of
    # x or y and min_dist will store the minimum difference
    idx1=-1; idx2=-1; min_dist = sys.maxsize;
    for i in range(n) :
       # if current element is x then change idx1
       if arr[i]==x :
          idx1=i
          
       # if current element is y then change idx2
       elif arr[i]==y :
          idx2=i
       
       # if x and y both found in array
       # then only find the difference and store it in min_dist
       if idx1!=-1 and idx2!=-1 :
           min_dist=min(min_dist,abs(idx1-idx2));
    
    # if left or right did not found in array
    # then return -1
    if idx1==-1 or idx2==-1 :
        return -1
    # return the minimum distance
    else :
        return min_dist
  
# Driver code
if __name__ == "__main__" :
    
    arr = [ 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3]
    n = len(arr)
    x = 3
    y = 6
    print ("Minimum distance between %d and %d is %d\n"%( x, y,minDist(arr, n, x, y)));

# this code is contributed by aditya942003patil

// C# program to Find the minimum 
// distance between two numbers
using System;
class MinimumDistance {

  static int minDist(int []arr, int n,
                     int x, int y) 
  {
    //idx1 and idx2 will store indices of
    //x or y and min_dist will store the minimum difference
    int idx1=-1,idx2=-1,min_dist = int.MaxValue;
    for(int i=0;i<n;i++)
    {
      //if current element is x then change idx1
      if(arr[i]==x)
      {
        idx1=i;
      }
      //if current element is y then change idx2
      else if(arr[i]==y)
      {
        idx2=i;
      }
      //if x and y both found in array
      //then only find the difference and store it in min_dist
      if(idx1!=-1 && idx2!=-1)
        min_dist=Math.Min(min_dist,Math.Abs(idx1-idx2));
    }

    //if left or right did not found in array
    //then return -1
    if(idx1==-1||idx2==-1)
      return -1;
    //return the minimum distance
    else
      return min_dist;
  }
  // Driver Code
  public static void Main() 
  {

    int []arr = { 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3};
    int n = arr.Length;
    int x = 3;
    int y = 6;
    Console.WriteLine("Minimum distance between " + x + " and " + y
                      + " is " + minDist(arr, n, x, y));
  }
}

// This code is contributed by aditya942003patil.

<script>
function minDist(arr , n , x , y) 
{
    
    //idx1 and idx2 will store indices of
    //x or y and min_dist will store the minimum difference
    var idx1=-1,idx2=-1,min_dist = Number.MAX_VALUE;
    for(var i=0;i<n;i++)
    {
       //if current element is x then change idx1
       if(arr[i]==x)
       {
          idx1=i;
       }
       //if current element is y then change idx2
       else if(arr[i]==y)
       {
          idx2=i;
       }
       //if x and y both found in array
       //then only find the difference and store it in min_dist
       if(idx1!=-1 && idx2!=-1)
       min_dist=Math.min(min_dist,Math.abs(idx1-idx2));
    }
    
    //if left or right did not found in array
    //then return -1
    if(idx1==-1||idx2==-1)
    return -1;
    //return the minimum distance
    else
    return min_dist;
    
}

    /* Driver program to test above functions */

    var arr = [ 3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3];
    var n = arr.length;
    var x = 3;
    var y = 6;

    document.write("Minimum distance between " + x + " and " + y
            + " is " + minDist(arr, n, x, y));

// This code contributed by aditya942003patil 

</script>

Minimum distance between 3 and 6 is 4

Time Complexity: O(n), Only one traversal of the array is required.
Auxiliary Space: O(1), No extra space is required.