Open In App

Duplicate within K Distance in an Array

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an integer array arr[] and an integer k, determine whether there exist two indices i and j such that arr[i] == arr[j] and |i - j| ≤ k. If such a pair exists, return 'Yes', otherwise return 'No'.

Examples: 

Input: k = 3, arr[] = [1, 2, 3, 4, 1, 2, 3, 4]
Output: No
Explanation: Each element in the given array arr[] appears twice and the distance between every element and its duplicate is 4.

Input: k = 3, arr[] = [1, 2, 3, 1, 4, 5]
Output: Yes
Explanation: 1 is present at index 0 and 3.

Input: k = 3, arr[] = [1, 2, 3, 4, 5]
Output: No
Explanation: There is no duplicate element in arr[].

[Naive Approach] - O(n * k) Time and O(1) Space

The idea is to run two loops. The outer loop picks every index i as a starting index, and the inner loop compares all elements which are within k distance of i, i.e. i + k.

Below is given the implementation:

C++
#include <bits/stdc++.h>
using namespace std;

bool checkDuplicatesWithinK(vector<int> &arr, int k)
{
    int n = arr.size();
  
    // Traverse for every element
    for (int i = 0; i < n; i++) {
      
        // Traverse next k elements 
        for (int c = 1; c <= k && (i + c) < n; c++) {
            int j = i + c;
          
            // If we find one more occurrence 
            // within k
            if (arr[i] == arr[j])
              return true;
        }
    }
    return false;
}

// Driver method to test above method
int main()
{
    vector<int> arr = {10, 5, 3, 4, 3, 5, 6};
    if (checkDuplicatesWithinK(arr, 3))
        cout << "Yes";
    else
        cout << "No";
    return 0;
}
C
#include <stdio.h>

int checkDuplicatesWithinK(int arr[], int n, int k)
{
    // Traverse for every element
    for (int i = 0; i < n; i++) {
      
        // Traverse next k elements
        for (int c = 1; c <= k && (i + c) < n; c++) {
            int j = i + c;
          
            // If we find one more occurrence within k
            if (arr[i] == arr[j])
                return 1; 
        }
    }
    return 0; 
}

// Driver method to test above method
int main()
{
    int arr[] = {10, 5, 3, 4, 3, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%s\n", checkDuplicatesWithinK(arr, n, 3) ? "Yes" : "No");
    return 0;
}
Java
import java.util.Arrays;

class GfG {
    static boolean checkDuplicatesWithinK(int[] arr, int k) {
        int n = arr.length;

        // Traverse for every element
        for (int i = 0; i < n; i++) {
          
            // Traverse next k elements
            for (int c = 1; c <= k && (i + c) < n; c++) {
                int j = i + c;
              
                // If we find one more occurrence within k
                if (arr[i] == arr[j])
                    return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int[] arr = {10, 5, 3, 4, 3, 5, 6};
        System.out.println(checkDuplicatesWithinK(arr, 3) ? "Yes" : "No");
    }
}
Python
def check_duplicates_within_k(arr, k):
    n = len(arr)

    # Traverse for every element
    for i in range(n):
      
        # Traverse next k elements
        for c in range(1, k + 1):
            j = i + c
            
            # If we find one more occurrence within k
            if j < n and arr[i] == arr[j]:
                return True
              
    return False

# Driver method to test above method
arr = [10, 5, 3, 4, 3, 5, 6]
print("Yes" if check_duplicates_within_k(arr, 3) else "No")
C#
using System;

class GfG
{
    static bool CheckDuplicatesWithinK(int[] arr, int k)
    {
        int n = arr.Length;

        // Traverse for every element
        for (int i = 0; i < n; i++)
        {
            // Traverse next k elements
            for (int c = 1; c <= k && (i + c) < n; c++)
            {
                int j = i + c;
                // If we find one more occurrence within k
                if (arr[i] == arr[j])
                    return true;
            }
        }
        return false;
    }

    public static void Main()
    {
        int[] arr = { 10, 5, 3, 4, 3, 5, 6 };
        Console.WriteLine(CheckDuplicatesWithinK(arr, 3) ? "Yes" : "No");
    }
}
JavaScript
function checkDuplicatesWithinK(arr, k) {
    const n = arr.length;

    // Traverse for every element
    for (let i = 0; i < n; i++) {
    
        // Traverse next k elements
        for (let c = 1; c <= k && (i + c) < n; c++) {
            const j = i + c;
            
            // If we find one more occurrence within k
            if (arr[i] === arr[j]) {
                return true;
            }
        }
    }
    return false;
}

// Driver method to test above method
const arr = [10, 5, 3, 4, 3, 5, 6];
console.log(checkDuplicatesWithinK(arr, 3) ? "Yes" : "No");

Output
Yes

Time Complexity: O(n * k), for each element of the array arr[], we are iterating up to next k elements.
Auxiliary Space: O(1)

[Expected Approach] - Using HashSet - O(n) Time and O(k) Space

The idea is to use HashSet to store elements of the array arr[] and check if there is any duplicate present within a k distance. Also remove elements that are present at more than k distance from the current element. Following is a detailed algorithm.

  1. Create an empty HashSet. 
  2. Traverse all elements from left to right. Let the current element be 'arr[i]' 
    • If the current element 'arr[i]' is present in a HashSet, then return true. 
    • Else add arr[i] to hash and remove arr[i-k] from hash if i >= k

Below is given the implementation:

C++
#include <bits/stdc++.h>
using namespace std;

// C++ program to Check if a given array contains duplicate
// elements within k distance from each other
bool checkDuplicatesWithinK(vector<int> &arr, int k) {
    // Creates an empty hashset
    unordered_set<int> s;

    // Traverse the input array
    for (int i = 0; i < arr.size(); i++) {
      
        // If already present in hash, then we found
        // a duplicate within k distance
        if (s.find(arr[i]) != s.end())
            return true;

        // Add this item to hashset
        s.insert(arr[i]);

        // Remove the k+1 distant item
        if (i >= k)
            s.erase(arr[i - k]);
    }
    return false;
}

// Driver method to test above method
int main () {
    vector<int> arr = {10, 5, 3, 4, 3, 5, 6};
    if (checkDuplicatesWithinK(arr, 3))
        cout << "Yes";
    else
        cout << "No";
}
Java
/* Java program to Check if a given array contains duplicate 
   elements within k distance from each other */
import java.util.*;

class Main
{
    static boolean checkDuplicatesWithinK(int arr[], int k)
    {
        // Creates an empty hashset
        HashSet<Integer> set = new HashSet<>();

        // Traverse the input array
        for (int i=0; i<arr.length; i++)
        {
            // If already present n hash, then we found 
            // a duplicate within k distance
            if (set.contains(arr[i]))
               return true;

            // Add this item to hashset
            set.add(arr[i]);

            // Remove the k+1 distant item
            if (i >= k)
              set.remove(arr[i-k]);
        }
        return false;
    }

    // Driver method to test above method
    public static void main (String[] args)
    {
        int arr[] = {10, 5, 3, 4, 3, 5, 6};
        if (checkDuplicatesWithinK(arr, 3))
           System.out.println("Yes");
        else
           System.out.println("No");
    }
}
Python
# Python 3 program to Check if a given array 
# contains duplicate elements within k distance
# from each other 
def checkDuplicatesWithinK(arr, n, k):

    # Creates an empty list
    myset = set()

    # Traverse the input array
    for i in range(n):
    
        # If already present n hash, then we 
        # found a duplicate within k distance
        if arr[i] in myset:
            return True

        # Add this item to hashset
        myset.add(arr[i])

        # Remove the k+1 distant item
        if (i >= k):
            myset.remove(arr[i - k])
    return False

# Driver Code
if __name__ == "__main__":
    
    arr = [10, 5, 3, 4, 3, 5, 6]
    n = len(arr)
    if (checkDuplicatesWithinK(arr, n, 3)):
        print("Yes")
    else:
        print("No")
C#
/* C# program to Check if a given
array contains duplicate elements 
within k distance from each other */
using System;
using System.Collections.Generic;

class GFG
{
    static bool checkDuplicatesWithinK(int []arr, int k)
    {
        // Creates an empty hashset
        HashSet<int> set = new HashSet<int>();

        // Traverse the input array
        for (int i = 0; i < arr.Length; i++)
        {
            // If already present n hash, then we found 
            // a duplicate within k distance
            if (set.Contains(arr[i]))
                return true;

            // Add this item to hashset
            set.Add(arr[i]);

            // Remove the k+1 distant item
            if (i >= k)
                set.Remove(arr[i - k]);
        }
        return false;
    }

    // Driver code
    public static void Main (String[] args)
    {
        int []arr = {10, 5, 3, 4, 3, 5, 6};
        if (checkDuplicatesWithinK(arr, 3))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
JavaScript
// JavaScript program to Check if a given array contains duplicate
// elements within k distance from each other
function checkDuplicatesWithinK(arr, k) {
    // Creates an empty hashset
    const s = new Set();

    // Traverse the input array
    for (let i = 0; i < arr.length; i++) {
    
        // If already present in hash, then we found
        // a duplicate within k distance
        if (s.has(arr[i]))
            return true;

        // Add this item to hashset
        s.add(arr[i]);

        // Remove the k+1 distant item
        if (i >= k)
            s.delete(arr[i - k]);
    }
    return false;
}

// Driver method to test above method
const arr = [10, 5, 3, 4, 3, 5, 6];
if (checkDuplicatesWithinK(arr, 3))
    console.log('Yes');
else
    console.log('No');

Output
Yes

Time Complexity: O(n), as we are iterating through elements only once.
Auxiliary Space: O(k), to store the k elements in HashSet.


Article Tags :
Practice Tags :

Similar Reads

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy