# Smallest element present in every subarray of all possible lengths

• Last Updated : 11 Feb, 2022

Given an array arr[] of length N, the task for every possible length of subarray is to find the smallest element present in every subarray of that length.

Examples:

Input: N = 10, arr[] = {2, 3, 5, 3, 2, 3, 1, 3, 2, 7}
Output: -1-1 3 2 2 2 1 1 1 1
Explanation:
For length = 1, no element is common in every subarray of length 1. Therefore, output is -1.
For length = 2, no element is common in every subarray of length 2. Therefore, output is -1.
For length = 3, the common element in every subarray is 3. Therefore, the output is 3.
For length = 4, both 2 and 3 are common in every subarray of length 4. 2 being the smaller, is the required output.
Similarly, for lengths 5 and 6, the smallest common element in every subarray of these lengths is 2.
For lengths 7, 8, 9 and 10, the smallest common element in every subarray of these lengths is 1.

Input: N = 3, arr[] = {2, 2, 2}
Output: 2 2 2

Naive Approach: The idea is to find the common elements in all the subarrays of size K for each possible value of K ( 1 ≤ K ≤ N) and print the smallest common element. Follow the steps below to solve the problem:

1. Add the count of every unique number for every subarray of length K.
2. Check if the count of numbers is equal to the number of subarrays i.e., N – K – 1.
3. If found to be true, then that particular element has occurred in every subarray of size K.
4. For multiple such elements, print the smallest amongst them.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to add count of numbers``// in the map for a subarray of length k``void` `uniqueElements(``int` `arr[], ``int` `start, ``int` `K,``                    ``map<``int``, ``int``>& mp)``{``    ``// Set to store unique elements``    ``set<``int``> st;` `    ``// Add elements to the set``    ``for` `(``int` `i = 0; i < K; i++)``        ``st.insert(arr[start + i]);` `    ``// Iterator of the set``    ``set<``int``>::iterator itr = st.begin();` `    ``// Adding count in map``    ``for` `(; itr != st.end(); itr++)``        ``mp[*itr]++;``}` `// Function to check if there is any number``// which repeats itself in every subarray``// of length K``void` `checkAnswer(map<``int``, ``int``>& mp, ``int` `N, ``int` `K)``{``    ``// Check all number starting from 1``    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``// Check if i occurred n-k+1 times``        ``if` `(mp[i] == (N - K + 1)) {` `            ``// Print the smallest number``            ``cout << i << ``" "``;``            ``return``;``        ``}``    ``}` `    ``// Print -1, if no such number found``    ``cout << -1 << ``" "``;``}` `// Function to count frequency of each``// number in each subarray of length K``void` `smallestPresentNumber(``int` `arr[], ``int` `N, ``int` `K)``{``    ``map<``int``, ``int``> mp;` `    ``// Traverse all subarrays of length K``    ``for` `(``int` `i = 0; i <= N - K; i++) {``        ``uniqueElements(arr, i, K, mp);``    ``}` `    ``// Check and print the smallest number``    ``// present in every subarray and print it``    ``checkAnswer(mp, N, K);``}` `// Function to generate the value of K``void` `generateK(``int` `arr[], ``int` `N)``{``    ``for` `(``int` `k = 1; k <= N; k++)` `        ``// Function call``        ``smallestPresentNumber(arr, N, k);``}` `// Driver Code``int` `main()``{` `    ``// Given array``    ``int` `arr[] = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };` `    ``// Size of array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function call``    ``generateK(arr, N);` `    ``return` `(0);``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;` `class` `GFG``{` `  ``// Function to add count of numbers``  ``// in the map for a subarray of length k``  ``static` `void` `uniqueElements(``int` `arr[], ``int` `start, ``int` `K,``                             ``Map mp)``  ``{``    ``// Set to store unique elements``    ``Set st=``new` `HashSet<>();` `    ``// Add elements to the set``    ``for` `(``int` `i = ``0``; i < K; i++)``      ``st.add(arr[start + i]);` `    ``// Iterator of the set``    ``Iterator itr = st.iterator();` `    ``// Adding count in map``    ``while``(itr.hasNext())``    ``{``      ``Integer t = (Integer)itr.next();``      ``mp.put(t,mp.getOrDefault(t, ``0``) + ``1``);``    ``}` `  ``}` `  ``// Function to check if there is any number``  ``// which repeats itself in every subarray``  ``// of length K``  ``static` `void` `checkAnswer(Map mp, ``int` `N, ``int` `K)``  ``{` `    ``// Check all number starting from 1``    ``for` `(``int` `i = ``1``; i <= N; i++)``    ``{` `      ``// Check if i occurred n-k+1 times``      ``if``(mp.containsKey(i))   ``        ``if` `(mp.get(i) == (N - K + ``1``))``        ``{` `          ``// Print the smallest number``          ``System.out.print(i + ``" "``);``          ``return``;``        ``}``    ``}` `    ``// Print -1, if no such number found``    ``System.out.print(-``1` `+ ``" "``);``  ``}` `  ``// Function to count frequency of each``  ``// number in each subarray of length K``  ``static` `void` `smallestPresentNumber(``int` `arr[], ``int` `N, ``int` `K)``  ``{``    ``Map mp = ``new` `HashMap<>();` `    ``// Traverse all subarrays of length K``    ``for` `(``int` `i = ``0``; i <= N - K; i++)``    ``{``      ``uniqueElements(arr, i, K, mp);``    ``}` `    ``// Check and print the smallest number``    ``// present in every subarray and print it``    ``checkAnswer(mp, N, K);``  ``}` `  ``// Function to generate the value of K``  ``static` `void` `generateK(``int` `arr[], ``int` `N)``  ``{``    ``for` `(``int` `k = ``1``; k <= N; k++)` `      ``// Function call``      ``smallestPresentNumber(arr, N, k);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``// Given array``    ``int` `arr[] = { ``2``, ``3``, ``5``, ``3``, ``2``, ``3``, ``1``, ``3``, ``2``, ``7` `};` `    ``// Size of array``    ``int` `N = arr.length;` `    ``// Function call``    ``generateK(arr, N);` `  ``}``}` `// This code is contributed by offbeat.`

## Python3

 `# Python3 program for the above approach` `# Function to add count of numbers``# in the map for a subarray of length k``def` `uniqueElements(arr, start, K, mp) :` `    ``# Set to store unique elements``    ``st ``=` `set``();` `    ``# Add elements to the set``    ``for` `i ``in` `range``(K) :``        ``st.add(arr[start ``+` `i]);` `    ``# Adding count in map``    ``for` `itr ``in` `st:``        ``if` `itr ``in` `mp :``            ``mp[itr] ``+``=` `1``;``        ``else``:``            ``mp[itr] ``=` `1``;` `# Function to check if there is any number``# which repeats itself in every subarray``# of length K``def` `checkAnswer(mp, N, K) :` `    ``# Check all number starting from 1``    ``for` `i ``in` `range``(``1``, N ``+` `1``) :``        ` `        ``if` `i ``in` `mp :``          ` `            ``# Check if i occurred n-k+1 times``            ``if` `(mp[i] ``=``=` `(N ``-` `K ``+` `1``)) :``    ` `                ``# Print the smallest number``                ``print``(i, end ``=` `" "``);``                ``return``;` `    ``# Print -1, if no such number found``    ``print``(``-``1``, end ``=` `" "``);` `# Function to count frequency of each``# number in each subarray of length K``def` `smallestPresentNumber(arr, N,  K) :``    ``mp ``=` `{};` `    ``# Traverse all subarrays of length K``    ``for` `i ``in` `range``(N ``-` `K ``+` `1``) :``        ``uniqueElements(arr, i, K, mp);` `    ``# Check and print the smallest number``    ``# present in every subarray and print it``    ``checkAnswer(mp, N, K);` `# Function to generate the value of K``def` `generateK(arr, N) :` `    ``for` `k ``in` `range``(``1``, N ``+` `1``) :` `        ``# Function call``        ``smallestPresentNumber(arr, N, k);` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``# Given array``    ``arr ``=` `[ ``2``, ``3``, ``5``, ``3``, ``2``, ``3``, ``1``, ``3``, ``2``, ``7` `];` `    ``# Size of array``    ``N ``=` `len``(arr);` `    ``# Function call``    ``generateK(arr, N);``    ` `    ``# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``// Function to add count of numbers``  ``// in the map for a subarray of length k``  ``static` `void` `uniqueElements(``int``[] arr, ``int` `start,``                             ``int` `K, Dictionary<``int``, ``int``> mp)``  ``{` `    ``// Set to store unique elements``    ``HashSet<``int``> st = ``new` `HashSet<``int``>();` `    ``// Add elements to the set``    ``for` `(``int` `i = 0; i < K; i++)``      ``st.Add(arr[start + i]);` `    ``// Adding count in map``    ``foreach``(``int` `itr ``in` `st)``    ``{``      ``if``(mp.ContainsKey(itr))``      ``{``        ``mp[itr]++;``      ``}``      ``else``{``        ``mp[itr] = 1;``      ``}``    ``}``  ``}` `  ``// Function to check if there is any number``  ``// which repeats itself in every subarray``  ``// of length K``  ``static` `void` `checkAnswer(Dictionary<``int``, ``int``> mp, ``int` `N, ``int` `K)``  ``{` `    ``// Check all number starting from 1``    ``for` `(``int` `i = 1; i <= N; i++)``    ``{` `      ``// Check if i occurred n-k+1 times``      ``if``(mp.ContainsKey(i))   ``        ``if` `(mp[i] == (N - K + 1))``        ``{` `          ``// Print the smallest number``          ``Console.Write(i + ``" "``);``          ``return``;``        ``}``    ``}` `    ``// Print -1, if no such number found``    ``Console.Write(-1 + ``" "``);``  ``}` `  ``// Function to count frequency of each``  ``// number in each subarray of length K``  ``static` `void` `smallestPresentNumber(``int``[] arr, ``int` `N, ``int` `K)``  ``{``    ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();` `    ``// Traverse all subarrays of length K``    ``for` `(``int` `i = 0; i <= N - K; i++)``    ``{``      ``uniqueElements(arr, i, K, mp);``    ``}` `    ``// Check and print the smallest number``    ``// present in every subarray and print it``    ``checkAnswer(mp, N, K);``  ``}` `  ``// Function to generate the value of K``  ``static` `void` `generateK(``int``[] arr, ``int` `N)``  ``{``    ``for` `(``int` `k = 1; k <= N; k++)` `      ``// Function call``      ``smallestPresentNumber(arr, N, k);``  ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{` `    ``// Given array``    ``int``[] arr = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };` `    ``// Size of array``    ``int` `N = arr.Length;` `    ``// Function call``    ``generateK(arr, N);``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``

Output:

`-1 -1 3 2 2 2 1 1 1 1`

Time Complexity: O(N3)
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized if all the indices where the particular number is present in the array are stored using an array and find the minimum length so that it is present in every subarray of length 1 ≤ K ≤ N.

Follow the steps below to solve the problem:

1. Initialize an array, say indices[], to store the index where a particular number occurs corresponding to that index number.
2. Now, for every number which is present in the given array, find the minimum length so that it is present in every subarray of that length.
3. Minimum length can be found by finding the maximum interval at which that particular number repeats itself in the given array. Similarly, find the same for other numbers of the array.
4. Initialize an answer[] array of size N+1 with -1 where answer[i] represents the answer for subarrays of length K.
5. Now, the indices[] array gives the number which was present in every subarray of length, say K, then update answer[K] with the same number if answer[K] was -1.
6. After traversing, update answer[] array such that if a number is present in all the subarrays of length K, then that particular number will also be present in all the subarrays of length greater than K.
7. After updating answer[] array, print all the elements present in that array as the answer for every subarray of length K.

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach` `#include ``using` `namespace` `std;` `// Function to print the common``// elements for all subarray lengths``void` `printAnswer(``int` `answer[], ``int` `N)``{``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``cout << answer[i] << ``" "``;``    ``}``}` `// Function to find and store the``// minimum element present in all``// subarrays of all lengths from 1 to n``void` `updateAnswerArray(``int` `answer[], ``int` `N)``{``    ``int` `i = 0;` `    ``// Skip lengths for which``    ``// answer[i] is -1``    ``while` `(answer[i] == -1)``        ``i++;` `    ``// Initialize minimum as the first``    ``// element where answer[i] is not -1``    ``int` `minimum = answer[i];` `    ``// Updating the answer array``    ``while` `(i <= N) {` `        ``// If answer[i] is -1, then minimum``        ``// can be substituted in that place``        ``if` `(answer[i] == -1)``            ``answer[i] = minimum;` `        ``// Find minimum answer``        ``else``            ``answer[i] = min(minimum, answer[i]);``        ``minimum = min(minimum, answer[i]);``        ``i++;``    ``}``}` `// Function to find the minimum number``// corresponding to every subarray of``// length K, for every K from 1 to N``void` `lengthOfSubarray(vector<``int``> indices[],``                      ``set<``int``> st, ``int` `N)``{``    ``// Stores the minimum common``    ``// elements for all subarray lengths``    ``int` `answer[N + 1];` `    ``// Initialize with -1.``    ``memset``(answer, -1, ``sizeof``(answer));` `    ``// Find for every element, the minimum length``    ``// such that the number is present in every``    ``// subsequence of that particular length or more``    ``for` `(``auto` `itr : st) {` `        ``// To store first occurrence and``        ``// gaps between occurrences``        ``int` `start = -1;``        ``int` `gap = -1;` `        ``// To cover the distance between last``        ``// occurrence and the end of the array``        ``indices[itr].push_back(N);` `        ``// To find the distance``        ``// between any two occurrences``        ``for` `(``int` `i = 0; i < indices[itr].size(); i++) {``            ``gap = max(gap, indices[itr][i] - start);``            ``start = indices[itr][i];``        ``}``        ``if` `(answer[gap] == -1)``            ``answer[gap] = itr;``    ``}` `    ``// Update and store the answer``    ``updateAnswerArray(answer, N);` `    ``// Print the required answer``    ``printAnswer(answer, N);``}` `// Function to find the smallest``// element common in all subarrays for``// every possible subarray lengths``void` `smallestPresentNumber(``int` `arr[], ``int` `N)``{``    ``// Initializing indices array``    ``vector<``int``> indices[N + 1];` `    ``// Store the numbers present``    ``// in the array``    ``set<``int``> elements;` `    ``// Push the index in the indices[A[i]] and``    ``// also store the numbers in set to get``    ``// the numbers present in input array``    ``for` `(``int` `i = 0; i < N; i++) {``        ``indices[arr[i]].push_back(i);``        ``elements.insert(arr[i]);``    ``}` `    ``// Function call to calculate length of``    ``// subarray for which a number is present``    ``// in every subarray of that length``    ``lengthOfSubarray(indices, elements, N);``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };` `    ``// Size of array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``smallestPresentNumber(arr, N);` `    ``return` `(0);``}`

## Java

 `// Java program for above approach``import` `java.util.*;``import` `java.lang.*;` `class` `GFG``{` `  ``// Function to print the common``  ``// elements for all subarray lengths``  ``static` `void` `printAnswer(``int` `answer[], ``int` `N)``  ``{``    ``for` `(``int` `i = ``1``; i <= N; i++)``    ``{``      ``System.out.print(answer[i]+``" "``);``    ``}``  ``}` `  ``// Function to find and store the``  ``// minimum element present in all``  ``// subarrays of all lengths from 1 to n``  ``static` `void` `updateAnswerArray(``int` `answer[], ``int` `N)``  ``{``    ``int` `i = ``0``;` `    ``// Skip lengths for which``    ``// answer[i] is -1``    ``while` `(answer[i] == -``1``)``      ``i++;` `    ``// Initialize minimum as the first``    ``// element where answer[i] is not -1``    ``int` `minimum = answer[i];` `    ``// Updating the answer array``    ``while` `(i <= N) {` `      ``// If answer[i] is -1, then minimum``      ``// can be substituted in that place``      ``if` `(answer[i] == -``1``)``        ``answer[i] = minimum;` `      ``// Find minimum answer``      ``else``        ``answer[i] = Math.min(minimum, answer[i]);``      ``minimum = Math.min(minimum, answer[i]);``      ``i++;``    ``}``  ``}` `  ``// Function to find the minimum number``  ``// corresponding to every subarray of``  ``// length K, for every K from 1 to N``  ``static` `void` `lengthOfSubarray(ArrayList> indices,``                               ``Set st, ``int` `N)``  ``{``    ``// Stores the minimum common``    ``// elements for all subarray lengths``    ``int``[] answer = ``new` `int``[N + ``1``];` `    ``// Initialize with -1.``    ``Arrays.fill(answer, -``1``);` `    ``// Find for every element, the minimum length``    ``// such that the number is present in every``    ``// subsequence of that particular length or more``    ``Iterator itr = st.iterator();``    ``while` `(itr.hasNext())``    ``{` `      ``// To store first occurrence and``      ``// gaps between occurrences``      ``int` `start = -``1``;``      ``int` `gap = -``1``;``      ``int` `t = (``int``)itr.next();` `      ``// To cover the distance between last``      ``// occurrence and the end of the array``      ``indices.get(t).add(N);` `      ``// To find the distance``      ``// between any two occurrences``      ``for` `(``int` `i = ``0``; i < indices.get(t).size(); i++)``      ``{``        ``gap = Math.max(gap, indices.get(t).get(i) - start);``        ``start = indices.get(t).get(i);``      ``}``      ``if` `(answer[gap] == -``1``)``        ``answer[gap] = t;``    ``}` `    ``// Update and store the answer``    ``updateAnswerArray(answer, N);` `    ``// Print the required answer``    ``printAnswer(answer, N);``  ``}` `  ``// Function to find the smallest``  ``// element common in all subarrays for``  ``// every possible subarray lengths``  ``static` `void` `smallestPresentNumber(``int` `arr[], ``int` `N)``  ``{``    ``// Initializing indices array``    ``ArrayList> indices = ``new` `ArrayList<>();` `    ``for``(``int` `i = ``0``; i <= N; i++)``      ``indices.add(``new` `ArrayList());` `    ``// Store the numbers present``    ``// in the array``    ``Set elements = ``new` `HashSet<>();` `    ``// Push the index in the indices[A[i]] and``    ``// also store the numbers in set to get``    ``// the numbers present in input array``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``      ``indices.get(arr[i]).add(i);``      ``elements.add(arr[i]);``    ``}` `    ``// Function call to calculate length of``    ``// subarray for which a number is present``    ``// in every subarray of that length``    ``lengthOfSubarray(indices, elements, N);``  ``}` `  ``// Driver function``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``// Given array``    ``int` `arr[] = { ``2``, ``3``, ``5``, ``3``, ``2``, ``3``, ``1``, ``3``, ``2``, ``7` `};` `    ``// Size of array``    ``int` `N = arr.length;` `    ``// Function Call``    ``smallestPresentNumber(arr, N);``  ``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python program of the above approach` `# Function to print the common``# elements for all subarray lengths``def` `printAnswer(answer, N):``    ``for` `i ``in` `range``(N ``+` `1``):``        ``print``(answer[i], end ``=` `" "``)` `# Function to find and store the``# minimum element present in all``# subarrays of all lengths from 1 to n``def` `updateAnswerArray(answer, N):``    ``i ``=` `0``    ` `    ``# Skip lengths for which``    ``# answer[i] is -1``    ``while``(answer[i] ``=``=` `-``1``):``        ``i ``+``=` `1``    ` `    ``# Initialize minimum as the first``    ``# element where answer[i] is not -1``    ``minimum ``=` `answer[i]``    ` `    ``# Updating the answer array``    ``while``(i <``=` `N):``        ` `        ``# If answer[i] is -1, then minimum``        ``# can be substituted in that place``        ``if``(answer[i] ``=``=` `-``1``):``            ``answer[i] ``=` `minimum``        ` `        ``# Find minimum answer``        ``else``:``            ``answer[i] ``=` `min``(minimum, answer[i])``        ``minimum ``=` `min``(minimum, answer[i])``        ``i ``+``=` `1` `# Function to find the minimum number``# corresponding to every subarray of``# length K, for every K from 1 to N``def` `lengthOfSubarray(indices, st, N):``    ` `    ``# Stores the minimum common``    ``# elements for all subarray lengths``    ``#Initialize with -1.``    ``answer ``=` `[``-``1` `for` `i ``in` `range``(N ``+` `1``)]``    ` `    ``# Find for every element, the minimum length``    ``# such that the number is present in every``    ``# subsequence of that particular length or more``    ``for` `itr ``in` `st:``        ` `        ``# To store first occurrence and``        ``# gaps between occurrences``        ``start ``=` `-``1``        ``gap ``=` `-``1``        ` `        ``# To cover the distance between last``        ``# occurrence and the end of the array``        ``indices[itr].append(N)``        ` `        ``# To find the distance``        ``# between any two occurrences``        ``for` `i ``in` `range``(``len``(indices[itr])):``            ``gap ``=` `max``(gap, indices[itr][i] ``-` `start)``            ``start ``=` `indices[itr][i]``        ` `        ``if``(answer[gap] ``=``=` `-``1``):``            ``answer[gap] ``=` `itr``    ` `    ``# Update and store the answer``    ``updateAnswerArray(answer, N)``    ` `    ``# Print the required answer``    ``printAnswer(answer, N)``    ` `# Function to find the smallest``# element common in all subarrays for``# every possible subarray lengths``def` `smallestPresentNumber(arr, N):``    ` `    ``# Initializing indices array``    ``indices ``=` `[[] ``for` `i ``in` `range``(N ``+` `1``)]``    ` `    ``# Store the numbers present``    ``# in the array``    ``elements ``=` `[]``    ` `    ``# Push the index in the indices[A[i]] and``    ``# also store the numbers in set to get``    ``# the numbers present in input array``    ``for` `i ``in` `range``(N):``        ``indices[arr[i]].append(i)``        ``elements.append(arr[i])``    ` `    ``elements ``=` `list``(``set``(elements))``    ` `    ``# Function call to calculate length of``    ``# subarray for which a number is present``    ``# in every subarray of that length``    ``lengthOfSubarray(indices, elements, N)` `# Driver Code` `# Given array``arr ``=` `[``2``, ``3``, ``5``, ``3``, ``2``, ``3``, ``1``, ``3``, ``2``, ``7``]` `# Size of array``N ``=` `len``(arr)` `# Function Call``smallestPresentNumber(arr, N)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program for above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to print the common``// elements for all subarray lengths``static` `void` `printAnswer(``int``[] answer, ``int` `N)``{``    ``for``(``int` `i = 1; i <= N; i++)``    ``{``        ``Console.Write(answer[i] + ``" "``);``    ``}``}` `// Function to find and store the``// minimum element present in all``// subarrays of all lengths from 1 to n``static` `void` `updateAnswerArray(``int``[] answer, ``int` `N)``{``    ``int` `i = 0;``    ` `    ``// Skip lengths for which``    ``// answer[i] is -1``    ``while` `(answer[i] == -1)``        ``i++;``    ` `    ``// Initialize minimum as the first``    ``// element where answer[i] is not -1``    ``int` `minimum = answer[i];``    ` `    ``// Updating the answer array``    ``while` `(i <= N)``    ``{``        ` `        ``// If answer[i] is -1, then minimum``        ``// can be substituted in that place``        ``if` `(answer[i] == -1)``            ``answer[i] = minimum;``        ` `        ``// Find minimum answer``        ``else``            ``answer[i] = Math.Min(minimum, answer[i]);``            ``minimum = Math.Min(minimum, answer[i]);``            ``i++;``    ``}``}` `// Function to find the minimum number``// corresponding to every subarray of``// length K, for every K from 1 to N``static` `void` `lengthOfSubarray(List> indices,``                               ``HashSet<``int``> st, ``int` `N)``{``    ``// Stores the minimum common``    ``// elements for all subarray lengths``    ``int``[] answer = ``new` `int``[N + 1];``    ` `    ``// Initialize with -1.``    ``Array.Fill(answer, -1);``    ` `    ``// Find for every element, the minimum length``    ``// such that the number is present in every``    ``// subsequence of that particular length or more``    ``foreach``(``int` `itr ``in` `st)``    ``{``        ` `        ``// To store first occurrence and``        ``// gaps between occurrences``        ``int` `start = -1;``        ``int` `gap = -1;``        ``int` `t = itr;``        ` `        ``// To cover the distance between last``        ``// occurrence and the end of the array``        ``indices[t].Add(N);``        ` `        ``// To find the distance``        ``// between any two occurrences``        ``for``(``int` `i = 0; i < indices[t].Count; i++)``        ``{``            ``gap = Math.Max(gap, indices[t][i] - start);``            ``start = indices[t][i];``        ``}``        ``if` `(answer[gap] == -1)``            ``answer[gap] = t;``    ``}``    ` `    ``// Update and store the answer``    ``updateAnswerArray(answer, N);``    ` `    ``// Print the required answer``    ``printAnswer(answer, N);``}` `// Function to find the smallest``// element common in all subarrays for``// every possible subarray lengths``static` `void` `smallestPresentNumber(``int``[] arr, ``int` `N)``{``    ` `    ``// Initializing indices array``    ``List> indices = ``new` `List>();``    ` `    ``for``(``int` `i = 0; i <= N; i++)``        ``indices.Add(``new` `List<``int``>());``    ` `    ``// Store the numbers present``    ``// in the array``    ``HashSet<``int``> elements = ``new` `HashSet<``int``>();``    ` `    ``// Push the index in the indices[A[i]] and``    ``// also store the numbers in set to get``    ``// the numbers present in input array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``indices[arr[i]].Add(i);``        ``elements.Add(arr[i]);``    ``}``    ` `    ``// Function call to calculate length of``    ``// subarray for which a number is present``    ``// in every subarray of that length``    ``lengthOfSubarray(indices, elements, N);``}` `// Driver code``static` `void` `Main()``{``    ` `    ``// Given array``    ``int``[] arr = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };``    ` `    ``// Size of array``    ``int` `N = arr.Length;``    ` `    ``// Function Call``    ``smallestPresentNumber(arr, N);``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`-1 -1 3 2 2 2 1 1 1 1`

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up