Skip to content
Related Articles

# Smallest element present in every subarray of all possible lengths

• Last Updated : 23 Aug, 2021

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 kvoid uniqueElements(int arr[], int start, int K,                    map& mp){    // Set to store unique elements    set st;     // Add elements to the set    for (int i = 0; i < K; i++)        st.insert(arr[start + i]);     // Iterator of the set    set::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 Kvoid 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[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 Kvoid smallestPresentNumber(int arr[], int N, int K){    map 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 Kvoid generateK(int arr[], int N){    for (int k = 1; k <= N; k++)         // Function call        smallestPresentNumber(arr, N, k);} // Driver Codeint main(){     // Given array    int arr[] = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };     // Size of array    int N = sizeof(arr) / sizeof(arr[0]);     // Function call    generateK(arr, N);     return (0);}

## Java

 // Java program for the above approachimport 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 kdef 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 Kdef 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 Kdef 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 Kdef generateK(arr, N) :     for k in range(1, N + 1) :         # Function call        smallestPresentNumber(arr, N, k); # Driver Codeif __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 approachusing 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 mp)  {     // Set to store unique elements    HashSet st = new HashSet();     // 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 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 mp = new Dictionary();     // 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 lengthsvoid 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 nvoid 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 Nvoid lengthOfSubarray(vector indices[],                      set 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 occurence and        // gaps between occurences        int start = -1;        int gap = -1;         // To cover the distance between last        // occurence and the end of the array        indices[itr].push_back(N);         // To find the distance        // between any two occurences        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 lengthsvoid smallestPresentNumber(int arr[], int N){    // Initializing indices array    vector indices[N + 1];     // Store the numbers present    // in the array    set 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 Codeint main(){    // Given array    int arr[] = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };     // Size of array    int N = sizeof(arr) / sizeof(arr[0]);     // Function Call    smallestPresentNumber(arr, N);     return (0);}

## Java

 // Java program for above approachimport 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 occurence and      // gaps between occurences      int start = -1;      int gap = -1;      int t = (int)itr.next();       // To cover the distance between last      // occurence and the end of the array      indices.get(t).add(N);       // To find the distance      // between any two occurences      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 lengthsdef 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 ndef 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 Ndef 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 occurence and        # gaps between occurences        start = -1        gap = -1                 # To cover the distance between last        # occurence and the end of the array        indices[itr].append(N)                 # To find the distance        # between any two occurences        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 lengthsdef 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 arrayarr = [2, 3, 5, 3, 2, 3, 1, 3, 2, 7] # Size of arrayN = len(arr) # Function CallsmallestPresentNumber(arr, N) # This code is contributed by avanitrachhadiya2155

## C#

 // C# program for above approachusing System;using System.Collections.Generic; class GFG{ // Function to print the common// elements for all subarray lengthsstatic 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 nstatic 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 Nstatic void lengthOfSubarray(List> indices,                               HashSet 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 occurence and        // gaps between occurences        int start = -1;        int gap = -1;        int t = itr;                 // To cover the distance between last        // occurence and the end of the array        indices[t].Add(N);                 // To find the distance        // between any two occurences        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 lengthsstatic void smallestPresentNumber(int[] arr, int N){         // Initializing indices array    List> indices = new List>();         for(int i = 0; i <= N; i++)        indices.Add(new List());         // Store the numbers present    // in the array    HashSet 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[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 codestatic 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)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up