In this HackerRank Minimum Distance problem you have Given a, find the minimum distance between any pair of equal elements in the array. If no such value exists, return -1.

HackerRank Minimum Distance problem solution


Problem solution in Python programming.

class Solution:
    def __init__(self):
        self.size = int(input())
        self.array1 = get_int_list(input())

    def calculate(self):
        val_dict = {}
        for i,val in enumerate(self.array1):
            if val in val_dict:
                val_dict[val].append(i)
            else:
                val_dict[val]=[i]
        min_val = None
        for indices in val_dict.values():
            if len(indices) > 1:
                for i in range(0,len(indices)-1):
                    if min_val is None or (indices[i+1]-indices[i]) < min_val:
                        min_val = indices[i+1]-indices[i]
        if min_val is None:
            return -1
        else:
            return min_val


def main():
    my_object = Solution()
    print(my_object.calculate())


def get_int_list(in_str):
    return [int(i) for i in in_str.strip().split()]


if __name__ == "__main__":
    main()


Problem solution in Java Programming.

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a[] = new int[n];
        for(int i=0; i < n; i++){
            a[i] = in.nextInt();
        }
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                if (a[i] == a[j]) {
                    int temp = j - i;
                    if (temp < min) {
                        min = temp;
                    }
                }
            }
        }
        if (min == Integer.MAX_VALUE)
            min = -1;
        System.out.println(min);
    }
}


Problem solution in C++ programming.

#include <bits/stdc++.h>

#define all(x) (x).begin(), (x).end()
#define li long long
#define itn int

using namespace std;

inline int nxt(){
    int n;
    scanf("%d", &n);
    return n;
}

int gcd(int x, int y){
    while (y){
        x %= y;
        swap(x, y);
    }
    return x;
}

const int mod = 1000000007;

int main(){

    int n = nxt();
    vector<int> a(n);
    for (int i = 0; i < n; i++){
        a[i] = nxt();
    }

    int ans = -1;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < i; j++){
            if (a[i] == a[j]){
                if (i - j < ans || ans == -1)
                    ans = i - j;
            }
        }
    }

    cout << ans << "\n";

    return 0;
}


Problem solution in C programming.

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

int main(){
    int n;
    int distance = 1001;
    scanf("%d",&n);
    int *A = malloc(sizeof(int) * n);
    for(int i = 0; i < n; i++){
       scanf("%d",&A[i]);
    }
    
    
    for(int i = 1; i < n; i++){
       for(int j=i-1;j>=0;j--)
       {
           if(A[i]==A[j])
           {
               if(i-j < distance)
                   distance = i-j;
               break;
           }
       }
    }
    
    if(distance == 1001)
        distance = -1;
    
    printf("%d\n",distance);
    return 0;
}


Problem solution in JavaScript programming.

process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
    input_stdin += data;
});

process.stdin.on('end', function () {
    input_stdin_array = input_stdin.split("\n");
    main();    
});

function readLine() {
    return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////

function main() {
    readLine()
    i=readLine().split` `
    r=[]
    i.map((x,y,z)=>(z.slice(0).splice(y,1),~(I=z.indexOf(x))&&r.push(Math.abs(y-I))))
    console.log(Math.min(...r.filter(x=>x).length>0?r.filter(x=>x):[-1]))
}