# Count distinct elements in every window of size k

Given an array of size n and an integer k, return the of 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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Source: Microsoft Interview Question

A Simple Solution is to traverse the given array, consider every window in it and count distinct elements in the window.

Below is the implementation of the simple solution.

## C++

 `// Simple C++ program to count distinct  ` `// elements in every window of size k ` `#include ` `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

## Java

 `// 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); ` `    ``} ` `} `

## Python3

 `# 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 `

## C#

 `// 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 `

Output:

```3
4
4
3```

Time complexity of the above solution is O(nk2). We can improve time complexity to O(nkLok) by modifying countWindowDistinct() to use sorting. The function can further be optimized to use hashing to find distinct elements in a window. With hashing the time complexity becomes O(nk). Below is a different approach that works in O(n) time.

An Efficient Solution is to use the count of the previous window while sliding the window. The idea is to create a hash map that stores elements of the current window. When we slide the window, we remove an element from the hash and add an element. We also keep track of distinct elements. Below is the algorithm.

• Create an empty hash map. Let hash map be hM
• Initialize distinct element count ‘dist_count’ as 0.
• 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’
• Print ‘dist_count’ for the first window.
• Traverse through the remaining array (or other windows).
• Remove the first element of the previous window.
• If the removed element appeared only once, remove it from hM and do “dist_count–“
• else (appeared multiple times in hM), then decrement its count in hM
• Add the current element (last element of the new window)
• If the added element is not present in hM, add it to hM and do “dist_count++”
• Else (the added element appeared multiple times), increment its count in hM

Below is a dry run of the above approach: Below is the implementation of the above approach:

## C++

 `// An efficient C++ program to  ` `// count distinct elements in ` `// every window of size k ` `#include ` `#include ` `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); ` `   ``int` `k = 4; ` `   ``countDistinct(arr, k, size); ` ` `  `   ``return` `0; ` `} ` `//This solution is contributed by Aditya Goel `

## Java

 `// 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 hM = ` `                      ``new` `HashMap(); ` ` `  `        ``// 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.get(arr[i]) == ``null``) ` `            ``{ ` `                ``hM.put(arr[i], ``1``); ` `                ``dist_count++; ` `            ``} ` `            ``else` `            ``{ ` `               ``int` `count = hM.get(arr[i]); ` `               ``hM.put(arr[i], count+``1``); ` `            ``} ` `        ``} ` ` `  `        ``// Print count of first window ` `        ``System.out.println(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.get(arr[i-k]) == ``1``) ` `            ``{ ` `                ``hM.remove(arr[i-k]); ` `                ``dist_count--; ` `            ``} ` `            ``else` `// reduce count of the removed element ` `            ``{ ` `               ``int` `count = hM.get(arr[i-k]); ` `               ``hM.put(arr[i-k], count-``1``); ` `            ``} ` ` `  `            ``// Add new element of current window ` `            ``// If this element appears first time, ` `            ``// increment distinct element count ` `            ``if` `(hM.get(arr[i]) == ``null``) ` `            ``{ ` `                ``hM.put(arr[i], ``1``); ` `                ``dist_count++; ` `            ``} ` `            ``else` `// Increment distinct element count ` `            ``{ ` `               ``int` `count = hM.get(arr[i]); ` `               ``hM.put(arr[i], count+``1``); ` `            ``} ` ` `  `           ``// Print count of current window ` `            ``System.out.println(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); ` `    ``} ` `} `

## Python3

 `# 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 `

## C#

 `// 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 `

Output:

```3
4
4
3```

Time complexity of the above solution is O(n).