Count distinct elements in every window of size k

Given an array of size n and an integer k, return the count of distinct numbers in all windows of size k.

Example:

Input: arr[] = {1, 2, 1, 3, 4, 2, 3};
       k = 4
Output: 3 4 4 3

Explanation:
First window is {1, 2, 1, 3}, count of distinct numbers is 3
Second window is {2, 1, 3, 4} count of distinct numbers is 4
Third window is {1, 3, 4, 2} count of distinct numbers is 4
Fourth window is {3, 4, 2, 3} count of distinct numbers is 3

Input: arr[] = {1, 2, 4, 4};
       k = 2
Output: 2 2 1

Explanation:
First window is {1, 2}, count of distinct numbers is 2
First window is {2, 4}, count of distinct numbers is 2
First window is {4, 4}, count of distinct numbers is 1

Source: This problem has appeared in Microsoft Interview Question.

Naive Approach: The naive solution is to traverse the given array considering every window in it and keeping a count on the distinct elements of the window.

  • Algorithm:



    1. For every index i from 0 to len_array(n) – k, i.e n – k, traverse the array from i to i + k. This is the window
    2. Traverse the window, from i to that index and check if the element is present or not.
    3. If the element is not present in the prefix of the array, i.e no duplicate element is present from i to index-1, then increase the count.
    4. Print the count.
  • Implementation:

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Simple C++ program to count distinct
    // elements in every window of size k
    #include <bits/stdc++.h>
    using namespace std;
      
    // Counts distinct elements in window of size k
    int countWindowDistinct(int win[], int k)
    {
        int dist_count = 0;
      
        // Traverse the window
        for (int i = 0; i < k; i++) {
            // Check if element arr[i] exists in arr[0..i-1]
            int j;
            for (j = 0; j < i; j++)
                if (win[i] == win[j])
                    break;
            if (j == i)
                dist_count++;
        }
        return dist_count;
    }
      
    // Counts distinct elements in all windows of size k
    void countDistinct(int arr[], int n, int k)
    {
        // Traverse through every window
        for (int i = 0; i <= n - k; i++)
            cout << countWindowDistinct(arr + i, k) << endl;
    }
      
    // Driver program
    int main()
    {
        int arr[] = { 1, 2, 1, 3, 4, 2, 3 }, k = 4;
        int n = sizeof(arr) / sizeof(arr[0]);
        countDistinct(arr, n, k);
        return 0;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Simple Java program to count distinct elements in every
    // window of size k
      
    import java.util.Arrays;
      
    class Test {
        // Counts distinct elements in window of size k
        static int countWindowDistinct(int win[], int k)
        {
            int dist_count = 0;
      
            // Traverse the window
            for (int i = 0; i < k; i++) {
                // Check if element arr[i] exists in arr[0..i-1]
                int j;
                for (j = 0; j < i; j++)
                    if (win[i] == win[j])
                        break;
                if (j == i)
                    dist_count++;
            }
            return dist_count;
        }
      
        // Counts distinct elements in all windows of size k
        static void countDistinct(int arr[], int n, int k)
        {
            // Traverse through every window
            for (int i = 0; i <= n - k; i++)
                System.out.println(countWindowDistinct(Arrays.copyOfRange(arr, i, arr.length), k));
        }
      
        // Driver method
        public static void main(String args[])
        {
            int arr[] = { 1, 2, 1, 3, 4, 2, 3 }, k = 4;
      
            countDistinct(arr, arr.length, k);
        }
    }

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # Simple Python3 program to count distinct 
    # elements in every window of size k
    import math as mt 
      
    # Counts distinct elements in window
    # of size k
    def countWindowDistinct(win, k):
      
        dist_count = 0
      
        # Traverse the window
        for i in range(k):
              
            # Check if element arr[i] exists
            # in arr[0..i-1]
            j = 0
            while j < i:
                if (win[i] == win[j]):
                    break
                else:
                    j += 1
            if (j == i):
                dist_count += 1
          
        return dist_count
      
      
    # Counts distinct elements in all 
    # windows of size k
    def countDistinct(arr, n, k):
      
        # Traverse through every window
        for i in range(n - k + 1):
            print(countWindowDistinct(arr[i:k + i], k))
      
    # Driver Code
    arr = [1, 2, 1, 3, 4, 2, 3]
    k = 4
    n = len(arr)
    countDistinct(arr, n, k)
      
    # This code is contributed by 
    # Mohit kumar 29

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Simple C# program to count distinct
    // elements in every window of size k
    using System;
    using System.Collections.Generic;
      
    class GFG {
        // Counts distinct elements in
        // window of size k
        static int countWindowDistinct(int[] win,
                                       int k)
        {
            int dist_count = 0;
      
            // Traverse the window
            for (int i = 0; i < k; i++) {
                // Check if element arr[i]
                // exists in arr[0..i-1]
                int j;
                for (j = 0; j < i; j++)
                    if (win[i] == win[j])
                        break;
                if (j == i)
                    dist_count++;
            }
            return dist_count;
        }
      
        // Counts distinct elements in
        // all windows of size k
        static void countDistinct(int[] arr,
                                  int n, int k)
        {
            // Traverse through every window
            for (int i = 0; i <= n - k; i++) {
                int[] newArr = new int[k];
                Array.Copy(arr, i, newArr, 0, k);
                Console.WriteLine(countWindowDistinct(newArr, k));
            }
        }
      
        // Driver Code
        public static void Main(String[] args)
        {
            int[] arr = { 1, 2, 1, 3, 4, 2, 3 };
            int k = 4;
      
            countDistinct(arr, arr.Length, k);
        }
    }
      
    // This code is contributed by Princi Singh

    chevron_right

    
    

  • Output:

    3
    4
    4
    3
  • Complexity Analysis:

    • Time complexity: O(nk2).
      The time complexity can be improved to O(n*k*log k) by modifying countWindowDistinct() by the use of sorting. The function can further be optimized to use hashing to find distinct elements in a window. With hashing the time complexity becomes O(n*k).
    • Space Complexity: O(1) we no any extra space is needed.

Efficient Approach: So, there is an efficient solution using hashing, though hashing requires extra O(n) space but the time complexity will improve. The trick is to use the count of the previous window while sliding the window. To do this a hash map can be used that stores elements of the current window. The hash-map is also operated on by simultaneous addition and removal of an element while keeping track of distinct elements. The problem deals with finding the count of distinct elements in a window of length k, at any step while shifting the window and discarding all the computation done in the previous step, even though k – 1 elements are same from the previous adjacent window. For example, assume that elements from index i to i + k – 1 are stored in a Hash Map as an element-frequency pair. So, while updating the Hash Map in range i + 1 to i + k, reduce the frequency of the i-th element by 1 and increase the frequency of (i + k)-th element by 1.
Insertion and deletion from the HashMap takes constant time.

  • Algorithm:

    1. Create an empty hash map. Let the hash map be hM.
    2. Initialize the count of distinct element as dist_count to 0.
    3. Traverse through the first window and insert elements of the first window to hM. The elements are used as key and their counts as the value in hM. Also, keep updating dist_count
    4. Print distinct count for the first window.
    5. Traverse through the remaining array (or other windows).
    6. Remove the first element of the previous window.
      • If the removed element appeared only once, remove it from hM and decrease the distinct count, i.e. do “dist_count–“
      • else (appeared multiple times in hM), then decrement its count in hM
    7. Add the current element (last element of the new window)
      • If the added element is not present in hM, add it to hM and increase the distinct count, i.e. do “dist_count++”
      • Else (the added element appeared multiple times), increment its count in hM
  • Below is a dry run of the above approach:
  • Implementation:

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // An efficient C++ program to
    // count distinct elements in
    // every window of size k
    #include <iostream>
    #include <map>
    using namespace std;
      
    void countDistinct(int arr[], int k, int n)
    {
        // Creates an empty hashmap hm
        map<int, int> hm;
      
        // initialize distinct element count for current window
        int dist_count = 0;
      
        // Traverse the first window and store count
        // of every element in hash map
        for (int i = 0; i < k; i++) {
            if (hm[arr[i]] == 0) {
                dist_count++;
            }
            hm[arr[i]] += 1;
        }
      
        // Print count of first window
        cout << dist_count << endl;
      
        // Traverse through the remaining array
        for (int i = k; i < n; i++) {
            // Remove first element of previous window
            // If there was only one occurrence, then reduce distinct count.
            if (hm[arr[i - k]] == 1) {
                dist_count--;
            }
            // reduce count of the removed element
            hm[arr[i - k]] -= 1;
      
            // Add new element of current window
            // If this element appears first time,
            // increment distinct element count
      
            if (hm[arr[i]] == 0) {
                dist_count++;
            }
            hm[arr[i]] += 1;
      
            // Print count of current window
            cout << dist_count << endl;
        }
    }
      
    int main()
    {
        int arr[] = { 1, 2, 1, 3, 4, 2, 3 };
        int size = sizeof(arr) / sizeof(arr[0]);
        int k = 4;
        countDistinct(arr, k, size);
      
        return 0;
    }
    // This solution is contributed by Aditya Goel

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // An efficient Java program to count distinct elements in
    // every window of size k
    import java.util.HashMap;
      
    class CountDistinctWindow {
        static void countDistinct(int arr[], int k)
        {
            // Creates an empty hashMap hM
            HashMap<Integer, Integer> hM = new HashMap<Integer, Integer>();
      
            // Traverse the first window and store count
            // of every element in hash map
            for (int i = 0; i < k; i++)
                hM.put(arr[i], hM.getOrDefault(arr[i], 0) + 1);
      
            // Print count of first window
            System.out.println(hM.size());
      
            // Traverse through the remaining array
            for (int i = k; i < arr.length; i++) {
      
                // Remove first element of previous window
                // If there was only one occurrence
                if (hM.get(arr[i - k]) == 1) {
                    hM.remove(arr[i - k]);
                }
      
                else // reduce count of the removed element
                    hM.put(arr[i - k],  hM.get(arr[i - k]) - 1);            
      
                // Add new element of current window
                // If this element appears first time,
                // set its count as 1,
                hM.put(arr[i], hM.getOrDefault(arr[i], 0) + 1);
      
                // Print count of current window
                System.out.println(hM.size());
            }
        }
      
        // Driver method
        public static void main(String arg[])
        {
            int arr[] = { 1, 2, 1, 3, 4, 2, 3 };
            int k = 4;
            countDistinct(arr, k);
        }
    }

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # An efficient Python program to
    # count distinct elements in
    # every window of size k
    from collections import defaultdict
      
    def countDistinct(arr, k, n):
      
        # Creates an empty hashmap hm 
        mp = defaultdict(lambda:0)
      
        # initialize distinct element 
        # count for current window 
        dist_count = 0
      
        # Traverse the first window and store count 
        # of every element in hash map 
        for i in range(k):
            if mp[arr[i]] == 0:
                dist_count += 1
            mp[arr[i]] += 1
      
        # Print count of first window 
        print(dist_count)
          
        # Traverse through the remaining array 
        for i in range(k, n):
      
            # Remove first element of previous window 
            # If there was only one occurrence, 
            # then reduce distinct count. 
            if mp[arr[i - k]] == 1:
                dist_count -= 1
            mp[arr[i - k]] -= 1
          
        # Add new element of current window 
        # If this element appears first time, 
        # increment distinct element count 
            if mp[arr[i]] == 0:
                dist_count += 1
            mp[arr[i]] += 1
      
            # Print count of current window 
            print(dist_count)
      
    arr = [1, 2, 1, 3, 4, 2, 3]
    n = len(arr)
    k = 4
    countDistinct(arr, k, n)
      
    # This code is contributed by Shrikant13

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // An efficient C# program to count
    // distinct elements in every window of size k
    using System;
    using System.Collections.Generic;
      
    public class CountDistinctWindow {
        static void countDistinct(int[] arr, int k)
        {
            // Creates an empty hashMap hM
            Dictionary<int, int> hM = new Dictionary<int, int>();
      
            // initialize distinct element count for
            // current window
            int dist_count = 0;
      
            // Traverse the first window and store count
            // of every element in hash map
            for (int i = 0; i < k; i++) {
                if (!hM.ContainsKey(arr[i])) {
                    hM.Add(arr[i], 1);
                    dist_count++;
                }
                else {
                    int count = hM[arr[i]];
                    hM.Remove(arr[i]);
                    hM.Add(arr[i], count + 1);
                }
            }
      
            // Print count of first window
            Console.WriteLine(dist_count);
      
            // Traverse through the remaining array
            for (int i = k; i < arr.Length; i++) {
      
                // Remove first element of previous window
                // If there was only one occurrence, then
                // reduce distinct count.
                if (hM[arr[i - k]] == 1) {
                    hM.Remove(arr[i - k]);
                    dist_count--;
                }
                else // reduce count of the removed element
                {
                    int count = hM[arr[i - k]];
                    hM.Remove(arr[i - k]);
                    hM.Add(arr[i - k], count - 1);
                }
      
                // Add new element of current window
                // If this element appears first time,
                // increment distinct element count
                if (!hM.ContainsKey(arr[i])) {
                    hM.Add(arr[i], 1);
                    dist_count++;
                }
                else // Increment distinct element count
                {
                    int count = hM[arr[i]];
                    hM.Remove(arr[i]);
                    hM.Add(arr[i], count + 1);
                }
      
                // Print count of current window
                Console.WriteLine(dist_count);
            }
        }
      
        // Driver method
        public static void Main(String[] arg)
        {
            int[] arr = { 1, 2, 1, 3, 4, 2, 3 };
            int k = 4;
            countDistinct(arr, k);
        }
    }
      
    // This code contributed by Rajput-Ji

    chevron_right

    
    

  • Output:
    3
    4
    4
    3
    
  • Complexity Analysis:

    • Time complexity O(n). As single traversal of the array is required.
    • Space Compelxity O(n). Since, the hashmap requires linear space.

This article is contributed by Piyush. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up