Given an array arr[] of size N and integer Y, the task is to find a minimum of all the differences between the maximum and minimum elements in all the sub-arrays of size Y.
Examples:
Input: arr[] = { 3, 2, 4, 5, 6, 1, 9 } Y = 3
Output: 2
Explanation:
All subarrays of length = 3 are:
{3, 2, 4} where maximum element = 4 and minimum element = 2 difference = 2
{2, 4, 5} where maximum element = 5 and minimum element = 2 difference = 3
{4, 5, 6} where maximum element = 6 and minimum element = 4 difference = 2
{5, 6, 1} where maximum element = 6 and minimum element = 1 difference = 5
{6, 1, 9} where maximum element = 9 and minimum element = 6 difference = 3
Out of these, the minimum is 2.
Input: arr[] = { 1, 2, 3, 3, 2, 2 } Y = 4
Output: 1
Explanation:
All subarrays of length = 4 are:
{1, 2, 3, 3} maximum element = 3 and minimum element = 1 difference = 2
{2, 3, 3, 2} maximum element = 3 and minimum element = 2 difference = 1
{3, 3, 2, 2} maximum element = 3 and minimum element = 2 difference = 1
Out of these, the minimum is 1.
Naive Approach: The naive idea is to traverse for every index i in the range [0, N – Y] use another loop to traverse from ith index to (i + Y – 1)th index and then calculate the minimum and maximum elements in a subarray of size Y and hence calculate the difference of maximum and minimum element for that ith iteration. Finally, by keeping a check on differences, evaluate the minimum difference.
#include<bits/stdc++.h> using namespace std;
// function to calculate the Min difference //between maximum and minimum element //in all Y size subarrays int max_difference( int * arr, int N, int Y)
{ // variable to store Min difference
//between maximum and minimum element/
int ans = INT_MAX;
for ( int i = 0; i <= N - Y; i++) {
int maxi = INT_MIN;
int mini = INT_MAX;
for ( int j = i; j <= i + Y - 1; j++) {
maxi = max(maxi, arr[j]); // finding the maximum element.
mini = min(mini, arr[j]); // finding the minimum element.
}
ans = min(ans, maxi -mini);
}
return ans; //returning the final answer.
} // Driver Code int main()
{ // Given array arr[]
int arr[] = { 1, 2, 3, 3, 2, 2 };
int N = sizeof arr / sizeof arr[0];
// Given subarray size
int Y = 4;
// Function Call
cout << max_difference(arr, N, Y);
return 0;
} |
import sys
# function to calculate the Min difference #between maximum and minimum element #in all Y size subarrays def max_difference(arr, N, Y):
# variable to store Min difference
#between maximum and minimum element/
ans = sys.maxsize;
for i in range ( 0 ,N - Y + 1 ):
maxi = - sys.maxsize;
mini = sys.maxsize;
for j in range (i,i + Y):
maxi = max (maxi, arr[j]); # finding the maximum element.
mini = min (mini, arr[j]); # finding the minimum element.
ans = min (ans, maxi - mini);
return ans; #returning the final answer.
# Driver Code # Given array arr[] arr = [ 1 , 2 , 3 , 3 , 2 , 2 ];
N = len (arr);
# Given subarray size Y = 4 ;
# Function Call print (max_difference(arr, N, Y));
|
// function to calculate the Min difference //between maximum and minimum element //in all Y size subarrays function max_difference(arr, N, Y) {
// variable to store Min difference
//between maximum and minimum element/
let ans = Infinity;
for (let i = 0; i <= N - Y; i++) {
let maxi = -Infinity;
let mini = Infinity;
for (let j = i; j <= i + Y - 1; j++) {
maxi = Math.max(maxi, arr[j]); // finding the maximum element.
mini = Math.min(mini, arr[j]); // finding the minimum element.
}
ans = Math.min(ans, maxi - mini);
}
return ans; //returning the final answer.
} // Driver Code // Given array arr[] let arr = [1, 2, 3, 3, 2, 2]; let N = arr.length; // Given subarray size let Y = 4; // Function Call console.log(max_difference(arr, N, Y)); |
using System;
class Gfg {
// function to calculate the Min difference
// between maximum and minimum element
// in all Y size subarrays
static int max_difference( int [] arr, int N, int Y)
{
// variable to store Min difference
// between maximum and minimum element
int ans = int .MaxValue;
for ( int i = 0; i <= N - Y; i++) {
int maxi = int .MinValue;
int mini = int .MaxValue;
for ( int j = i; j <= i + Y - 1; j++) {
maxi = Math.Max(
maxi,
arr[j]); // finding the maximum element.
mini = Math.Min(
mini,
arr[j]); // finding the minimum element.
}
ans = Math.Min(ans, maxi - mini);
}
return ans; // returning the final answer.
}
// Driver Code
static void Main( string [] args)
{
// Given array arr[]
int [] arr = { 1, 2, 3, 3, 2, 2 };
int N = arr.Length;
// Given subarray size
int Y = 4;
// Function Call
Console.WriteLine(max_difference(arr, N, Y));
}
} |
public class GFG {
public static int maxDifference( int [] arr, int N, int Y) {
// variable to store Min difference
//between maximum and minimum element/
int ans = Integer.MAX_VALUE;
for ( int i = 0 ; i <= N - Y; i++) {
int maxi = Integer.MIN_VALUE;
int mini = Integer.MAX_VALUE;
for ( int j = i; j <= i + Y - 1 ; j++) {
maxi = Math.max(maxi, arr[j]); // finding the maximum element.
mini = Math.min(mini, arr[j]); // finding the minimum element.
}
ans = Math.min(ans, maxi - mini);
}
return ans; //returning the final answer.
}
public static void main(String[] args) {
// Given array arr[]
int [] arr = { 1 , 2 , 3 , 3 , 2 , 2 };
int N = arr.length;
// Given subarray size
int Y = 4 ;
// Function Call
System.out.println(maxDifference(arr, N, Y));
}
} |
1
Time Complexity: O(N*Y) where Y is the given subarray range and N is the size of the array.
Auxiliary Space: O(1)
Efficient Approach: The idea is to use the concept of the approach discussed in the Next Greater Element article. Below are the steps:
- Build two arrays maxarr[] and minarr[], where maxarr[] will store the index of the element which is next greater to the element at ith index and minarr[] will store the index of the next element which is less than the element at the ith index.
- Initialize a stack with 0 to store the indices in both the above cases.
- For each index, i in the range [0, N – Y], using a nested loop and sliding window approach form two arrays submax and submin. These arrays will store maximum and minimum elements in the subarray in ith iteration.
- Finally, calculate the minimum difference.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to get the maximum of all // the subarrays of size Y vector< int > get_submaxarr( int * arr,
int n, int y)
{ int j = 0;
stack< int > stk;
// ith index of maxarr array
// will be the index upto which
// Arr[i] is maximum
vector< int > maxarr(n);
stk.push(0);
for ( int i = 1; i < n; i++) {
// Stack is used to find the
// next larger element and
// keeps track of index of
// current iteration
while (stk.empty() == false
and arr[i] > arr[stk.top()]) {
maxarr[stk.top()] = i - 1;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (!stk.empty()) {
maxarr[stk.top()] = n - 1;
stk.pop();
}
vector< int > submax;
for ( int i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is
// inside or outside the window
while (maxarr[j] < i + y - 1
or j < i) {
j++;
}
submax.push_back(arr[j]);
}
// Return submax
return submax;
} // Function to get the minimum for // all subarrays of size Y vector< int > get_subminarr( int * arr,
int n, int y)
{ int j = 0;
stack< int > stk;
// ith index of minarr array
// will be the index upto which
// Arr[i] is minimum
vector< int > minarr(n);
stk.push(0);
for ( int i = 1; i < n; i++) {
// Stack is used to find the
// next smaller element and
// keeping track of index of
// current iteration
while (stk.empty() == false
and arr[i] < arr[stk.top()]) {
minarr[stk.top()] = i;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (!stk.empty()) {
minarr[stk.top()] = n;
stk.pop();
}
vector< int > submin;
for ( int i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is inside
// or outside the window
while (minarr[j] <= i + y - 1
or j < i) {
j++;
}
submin.push_back(arr[j]);
}
// Return submin
return submin;
} // Function to get minimum difference void getMinDifference( int Arr[], int N,
int Y)
{ // Create submin and submax arrays
vector< int > submin
= get_subminarr(Arr, N, Y);
vector< int > submax
= get_submaxarr(Arr, N, Y);
// Store initial difference
int minn = submax[0] - submin[0];
int b = submax.size();
for ( int i = 1; i < b; i++) {
// Calculate temporary difference
int dif = submax[i] - submin[i];
minn = min(minn, dif);
}
// Final minimum difference
cout << minn << "\n" ;
} // Driver Code int main()
{ // Given array arr[]
int arr[] = { 1, 2, 3, 3, 2, 2 };
int N = sizeof arr / sizeof arr[0];
// Given subarray size
int Y = 4;
// Function Call
getMinDifference(arr, N, Y);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG{
// Function to get the maximum of all // the subarrays of size Y static Vector<Integer> get_submaxarr( int [] arr, int n,
int y)
{ int j = 0 ;
Stack<Integer> stk = new Stack<Integer>();
// ith index of maxarr array
// will be the index upto which
// Arr[i] is maximum
int [] maxarr = new int [n];
Arrays.fill(maxarr, 0 );
stk.push( 0 );
for ( int i = 1 ; i < n; i++)
{
// Stack is used to find the
// next larger element and
// keeps track of index of
// current iteration
while (stk.size() != 0 &&
arr[i] > arr[stk.peek()])
{
maxarr[stk.peek()] = i - 1 ;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (stk.size() != 0 )
{
maxarr[stk.size()] = n - 1 ;
stk.pop();
}
Vector<Integer> submax = new Vector<Integer>();
for ( int i = 0 ; i <= n - y; i++)
{
// j < i used to keep track
// whether jth element is
// inside or outside the window
while (maxarr[j] < i + y - 1 || j < i)
{
j++;
}
submax.add(arr[j]);
}
// Return submax
return submax;
} // Function to get the minimum for // all subarrays of size Y static Vector<Integer> get_subminarr( int [] arr, int n,
int y)
{ int j = 0 ;
Stack<Integer> stk = new Stack<Integer>();
// ith index of minarr array
// will be the index upto which
// Arr[i] is minimum
int [] minarr = new int [n];
Arrays.fill(minarr, 0 );
stk.push( 0 );
for ( int i = 1 ; i < n; i++)
{
// Stack is used to find the
// next smaller element and
// keeping track of index of
// current iteration
while (stk.size() != 0 &&
arr[i] < arr[stk.peek()])
{
minarr[stk.peek()] = i;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (stk.size() != 0 )
{
minarr[stk.peek()] = n;
stk.pop();
}
Vector<Integer> submin = new Vector<Integer>();
for ( int i = 0 ; i <= n - y; i++)
{
// j < i used to keep track
// whether jth element is inside
// or outside the window
while (minarr[j] <= i + y - 1 || j < i)
{
j++;
}
submin.add(arr[j]);
}
// Return submin
return submin;
} // Function to get minimum difference static void getMinDifference( int [] Arr, int N, int Y)
{ // Create submin and submax arrays
Vector<Integer> submin = get_subminarr(Arr, N, Y);
Vector<Integer> submax = get_submaxarr(Arr, N, Y);
// Store initial difference
int minn = submax.get( 0 ) - submin.get( 0 );
int b = submax.size();
for ( int i = 1 ; i < b; i++)
{
// Calculate temporary difference
int dif = submax.get(i) - submin.get(i) + 1 ;
minn = Math.min(minn, dif);
}
// Final minimum difference
System.out.print(minn);
} // Driver code public static void main(String[] args)
{ // Given array arr[]
int [] arr = { 1 , 2 , 3 , 3 , 2 , 2 };
int N = arr.length;
// Given subarray size
int Y = 4 ;
// Function Call
getMinDifference(arr, N, Y);
} } // This code is contributed by decode2207 |
# Python3 program for the above approach # Function to get the maximum of all # the subarrays of size Y def get_submaxarr(arr, n, y):
j = 0
stk = []
# ith index of maxarr array
# will be the index upto which
# Arr[i] is maximum
maxarr = [ 0 ] * n
stk.append( 0 )
for i in range ( 1 , n):
# Stack is used to find the
# next larger element and
# keeps track of index of
# current iteration
while ( len (stk) > 0 and
arr[i] > arr[stk[ - 1 ]]):
maxarr[stk[ - 1 ]] = i - 1
stk.pop()
stk.append(i)
# Loop for remaining indexes
while (stk):
maxarr[stk[ - 1 ]] = n - 1
stk.pop()
submax = []
for i in range (n - y + 1 ):
# j < i used to keep track
# whether jth element is
# inside or outside the window
while (maxarr[j] < i + y - 1 or
j < i):
j + = 1
submax.append(arr[j])
# Return submax
return submax
# Function to get the minimum for # all subarrays of size Y def get_subminarr(arr, n, y):
j = 0
stk = []
# ith index of minarr array
# will be the index upto which
# Arr[i] is minimum
minarr = [ 0 ] * n
stk.append( 0 )
for i in range ( 1 , n):
# Stack is used to find the
# next smaller element and
# keeping track of index of
# current iteration
while (stk and arr[i] < arr[stk[ - 1 ]]):
minarr[stk[ - 1 ]] = i
stk.pop()
stk.append(i)
# Loop for remaining indexes
while (stk):
minarr[stk[ - 1 ]] = n
stk.pop()
submin = []
for i in range (n - y + 1 ):
# j < i used to keep track
# whether jth element is inside
# or outside the window
while (minarr[j] < = i + y - 1 or
j < i):
j + = 1
submin.append(arr[j])
# Return submin
return submin
# Function to get minimum difference def getMinDifference(Arr, N, Y):
# Create submin and submax arrays
submin = get_subminarr(Arr, N, Y)
submax = get_submaxarr(Arr, N, Y)
# Store initial difference
minn = submax[ 0 ] - submin[ 0 ]
b = len (submax)
for i in range ( 1 , b):
# Calculate temporary difference
diff = submax[i] - submin[i]
minn = min (minn, diff)
# Final minimum difference
print (minn)
# Driver code # Given array arr[] arr = [ 1 , 2 , 3 , 3 , 2 , 2 ]
N = len (arr)
# Given subarray size Y = 4
# Function call getMinDifference(arr, N, Y) # This code is contributed by Stuti Pathak |
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG {
// Function to get the maximum of all
// the subarrays of size Y
static List< int > get_submaxarr( int [] arr, int n, int y)
{
int j = 0;
Stack< int > stk = new Stack< int >();
// ith index of maxarr array
// will be the index upto which
// Arr[i] is maximum
int [] maxarr = new int [n];
Array.Fill(maxarr,0);
stk.Push(0);
for ( int i = 1; i < n; i++) {
// Stack is used to find the
// next larger element and
// keeps track of index of
// current iteration
while (stk.Count!=0 && arr[i] > arr[stk.Peek()]) {
maxarr[stk.Peek()] = i - 1;
stk.Pop();
}
stk.Push(i);
}
// Loop for remaining indexes
while (stk.Count!=0) {
maxarr[stk.Count] = n - 1;
stk.Pop();
}
List< int > submax = new List< int >();
for ( int i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is
// inside or outside the window
while (maxarr[j] < i + y - 1
|| j < i) {
j++;
}
submax.Add(arr[j]);
}
// Return submax
return submax;
}
// Function to get the minimum for
// all subarrays of size Y
static List< int > get_subminarr( int [] arr, int n, int y)
{
int j = 0;
Stack< int > stk = new Stack< int >();
// ith index of minarr array
// will be the index upto which
// Arr[i] is minimum
int [] minarr = new int [n];
Array.Fill(minarr,0);
stk.Push(0);
for ( int i = 1; i < n; i++) {
// Stack is used to find the
// next smaller element and
// keeping track of index of
// current iteration
while (stk.Count!=0
&& arr[i] < arr[stk.Peek()]) {
minarr[stk.Peek()] = i;
stk.Pop();
}
stk.Push(i);
}
// Loop for remaining indexes
while (stk.Count!=0) {
minarr[stk.Peek()] = n;
stk.Pop();
}
List< int > submin = new List< int >();
for ( int i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is inside
// or outside the window
while (minarr[j] <= i + y - 1
|| j < i) {
j++;
}
submin.Add(arr[j]);
}
// Return submin
return submin;
}
// Function to get minimum difference
static void getMinDifference( int [] Arr, int N, int Y)
{
// Create submin and submax arrays
List< int > submin
= get_subminarr(Arr, N, Y);
List< int > submax
= get_submaxarr(Arr, N, Y);
// Store initial difference
int minn = submax[0] - submin[0];
int b = submax.Count;
for ( int i = 1; i < b; i++) {
// Calculate temporary difference
int dif = submax[i] - submin[i] + 1;
minn = Math.Min(minn, dif);
}
// Final minimum difference
Console.WriteLine(minn);
}
static void Main() {
// Given array arr[]
int [] arr = { 1, 2, 3, 3, 2, 2 };
int N = arr.Length;
// Given subarray size
int Y = 4;
// Function Call
getMinDifference(arr, N, Y);
}
} // This code is contributed by rameshtravel07. |
<script> // Javascript program for the above approach // Function to get the maximum of all // the subarrays of size Y function get_submaxarr(arr, n, y)
{ var j = 0;
var stk = [];
// ith index of maxarr array
// will be the index upto which
// Arr[i] is maximum
var maxarr = Array(n);
stk.push(0);
for ( var i = 1; i < n; i++) {
// Stack is used to find the
// next larger element and
// keeps track of index of
// current iteration
while (stk.length!=0
&& arr[i] > arr[stk[stk.length-1]]) {
maxarr[stk[stk.length-1]] = i - 1;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (stk.length!=0) {
maxarr[stk[stk.length-1]] = n - 1;
stk.pop();
}
var submax = [];
for ( var i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is
// inside or outside the window
while (maxarr[j] < i + y - 1
|| j < i) {
j++;
}
submax.push(arr[j]);
}
// Return submax
return submax;
} // Function to get the minimum for // all subarrays of size Y function get_subminarr(arr, n, y)
{ var j = 0;
var stk = [];
// ith index of minarr array
// will be the index upto which
// Arr[i] is minimum
var minarr = Array(n);
stk.push(0);
for ( var i = 1; i < n; i++) {
// Stack is used to find the
// next smaller element and
// keeping track of index of
// current iteration
while (stk.length!=0
&& arr[i] < arr[stk[stk.length-1]]) {
minarr[stk[stk.length-1]] = i;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (stk.length!=0) {
minarr[stk[stk.length-1]] = n;
stk.pop();
}
var submin = [];
for ( var i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is inside
// or outside the window
while (minarr[j] <= i + y - 1
|| j < i) {
j++;
}
submin.push(arr[j]);
}
// Return submin
return submin;
} // Function to get minimum difference function getMinDifference(Arr, N, Y)
{ // Create submin and submax arrays
var submin
= get_subminarr(Arr, N, Y);
var submax
= get_submaxarr(Arr, N, Y);
// Store initial difference
var minn = submax[0] - submin[0];
var b = submax.length;
for ( var i = 1; i < b; i++) {
// Calculate temporary difference
var dif = submax[i] - submin[i];
minn = Math.min(minn, dif);
}
// Final minimum difference
document.write( minn + "<br>" );
} // Driver Code // Given array arr[] var arr = [1, 2, 3, 3, 2, 2];
var N = arr.length
// Given subarray size var Y = 4;
// Function Call getMinDifference(arr, N, Y); </script> |
1
Time Complexity: O(N) where N is the size of the array.
Auxiliary Space: O(N) where N is the size of the array.
Related Topic: Subarrays, Subsequences, and Subsets in Array