First negative integer in every window of size k

16 May, 2022
Given an array and a positive integer k, find the first negative integer for each window(contiguous subarray) of size k. If a window does not contain a negative integer, then print 0 for that window.
Examples:  
Input : arr[] = {-8, 2, 3, -6, 10}, k = 2
Output : -8 0 -6 -6
First negative integer for each window of size k
{-8, 2} = -8
{2, 3} = 0 (does not contain a negative integer)
{3, -6} = -6
{-6, 10} = -6

Input : arr[] = {12, -1, -7, 8, -15, 30, 16, 28} , k = 3
Output : -1 -1 -7 -15 -15 0
Naive Approach: Run two loops. In the outer loop, take all subarrays(windows) of size k. In the inner loop, get the first negative integer of the current subarray(window).
C++
Java
Python3
C#
Javascript
// C++ implementation to find the first negative// integer in every window of size k#include <bits/stdc++.h>using namespace std;  // function to find the first negative// integer in every window of size kvoid printFirstNegativeInteger(int arr[], int n, int k){    // flag to check whether window contains    // a negative integer or not    bool flag;         // Loop for each subarray(window) of size k    for (int i = 0; i<(n-k+1); i++)              {        flag = false;         // traverse through the current window        for (int j = 0; j<k; j++)        {            // if a negative integer is found, then            // it is the first negative integer for            // current window. Print it, set the flag            // and break            if (arr[i+j] < 0)            {                cout << arr[i+j] << " ";                flag = true;                break;            }        }                 // if the current window does not        // contain a negative integer        if (!flag)            cout << "0" << " ";    }   }  // Driver program to test above functionsint main(){    int arr[] = {12, -1, -7, 8, -15, 30, 16, 28};    int n = sizeof(arr)/sizeof(arr[0]);    int k = 3;    printFirstNegativeInteger(arr, n, k);    return 0;}
// Java implementation to find the first negative// integer in every window of size kimport java.util.*; class solution{ // function to find the first negative// integer in every window of size kstatic void printFirstNegativeInteger(int arr[], int n, int k){    // flag to check whether window contains    // a negative integer or not    boolean flag;         // Loop for each subarray(window) of size k    for (int i = 0; i<(n-k+1); i++)            {        flag = false;         // traverse through the current window        for (int j = 0; j<k; j++)        {            // if a negative integer is found, then            // it is the first negative integer for            // current window. Print it, set the flag            // and break            if (arr[i+j] < 0)            {                System.out.print((arr[i+j])+" ");                flag = true;                break;            }        }                 // if the current window does not        // contain a negative integer        if (!flag)            System.out.print("0"+" ");    }} // Driver program to test above functionspublic static void main(String args[]){    int arr[] = {12, -1, -7, 8, -15, 30, 16, 28};    int n = arr.length;    int k = 3;    printFirstNegativeInteger(arr, n, k);     }}// This code is contributed by// Shashank_Sharma
# Python3 implementation to find the first negative# integer in every window of size k # Function to find the first negative# integer in every window of size kdef printFirstNegativeInteger(arr, n, k):         # Loop for each subarray(window) of size k    for i in range(0, (n - k + 1)):        flag = False         # Traverse through the current window        for j in range(0, k):                     # If a negative integer is found, then            # it is the first negative integer for            # current window. Print it, set the flag            # and break            if (arr[i + j] < 0):                         print(arr[i + j], end = " ")                flag = True                break                 # If the current window does not        # contain a negative integer        if (not(flag)):            print("0", end = " ")     # Driver Codearr = [12, -1, -7, 8, -15, 30, 16, 28]n = len(arr)k = 3printFirstNegativeInteger(arr, n, k) # This code is contributed by 'Smitha dinesh semwal'
// C# implementation to find// the first negative integer// in every window of size kusing System; class GFG{ // function to find the first negative// integer in every window of size kstatic void printFirstNegativeInteger(int []arr,                                    int n, int k){    // flag to check whether window contains    // a negative integer or not    bool flag;         // Loop for each subarray(window) of size k    for (int i = 0; i < (n - k + 1); i++)    {        flag = false;         // traverse through the current window        for (int j = 0; j < k; j++)        {            // if a negative integer is found, then            // it is the first negative integer for            // current window. Print it, set the flag            // and break            if (arr[i + j] < 0)            {                Console.Write((arr[i + j]) + " ");                flag = true;                break;            }        }                 // if the current window does not        // contain a negative integer        if (!flag)            Console.Write("0" + " ");    }} // Driver codepublic static void Main(String []args){    int []arr = {12, -1, -7, 8, -15, 30, 16, 28};    int n = arr.Length;    int k = 3;    printFirstNegativeInteger(arr, n, k);}} // This code has been contributed// by 29AjayKumar
<script> // JavaScript implementation to find// the first negative integer// in every window of size kfunction printFirstNegativeInteger(arr, n, k){    // flag to check whether window contains    // a negative integer or not    let flag;         // Loop for each subarray(window) of size k    for (let i = 0; i<(n-k+1); i++)            {        flag = false;         // traverse through the current window        for (let j = 0; j<k; j++)        {            // if a negative integer is found, then            // it is the first negative integer for            // current window. Print it, set the flag            // and break            if (arr[i+j] < 0)            {                document.write((arr[i+j])+" ");                flag = true;                break;            }        }                 // if the current window does not        // contain a negative integer        if (!flag)            document.write("0"+" ");    }}     // Driver Code         let arr = [12, -1, -7, 8, -15, 30, 16, 28];    let n = arr.length;    let k = 3;    printFirstNegativeInteger(arr, n, k); // This code is contributed by avijitmondal1998.</script>
-1 -1 -7 -15 -15 0 
Output : 
-1 -1 -7 -15 -15 0
Time Complexity : The outer loop runs n-k+1 times and the inner loop runs k times for every iteration of outer loop. So time complexity is O((n-k+1)*k) which can also be written as O(nk) when k is comparatively much smaller than n, otherwise when k tends to reach n, complexity becomes O(k). 
Efficient Approach: It is a variation of the problem of Sliding Window Maximum. We create a Dequeue, Di of capacity k, that stores only useful elements of the current window of k elements. An element is useful if it is in the current window and it is a negative integer. We process all array elements one by one and maintain Di to contain useful elements of current window and these useful elements are all negative integers. For a particular window, if Di is not empty then the element at front of the Di is the first negative integer for that window, else that window does not contain a negative integer.
C++
Java
Python3
C#
Javascript
// C++ implementation to find the first negative// integer in every window of size k#include <bits/stdc++.h> using namespace std;  // function to find the first negative// integer in every window of size kvoid printFirstNegativeInteger(int arr[], int n, int k){    // A Double Ended Queue, Di that will store indexes of    // useful array elements for the current window of size k.    // The useful elements are all negative integers.    deque<int>  Di;      /* Process first k (or first window) elements of array */    int i;    for (i = 0; i < k; i++)        // Add current element at the rear of Di        // if it is a negative integer        if (arr[i] < 0)            Di.push_back(i);         // Process rest of the elements, i.e., from arr[k] to arr[n-1]    for ( ; i < n; i++)    {        // if Di is not empty then the element at the        // front of the queue is the first negative integer        // of the previous window        if (!Di.empty())            cout << arr[Di.front()] << " ";                 // else the window does not have a        // negative integer        else            cout << "0" << " ";          // Remove the elements which are out of this window        while ( (!Di.empty()) && Di.front() < (i - k + 1))            Di.pop_front();  // Remove from front of queue          // Add current element at the rear of Di        // if it is a negative integer        if (arr[i] < 0)            Di.push_back(i);    }      // Print the first negative    // integer of last window    if (!Di.empty())           cout << arr[Di.front()] << " ";    else        cout << "0" << " ";           }  // Driver program to test above functionsint main(){    int arr[] = {12, -1, -7, 8, -15, 30, 16, 28};    int n = sizeof(arr)/sizeof(arr[0]);    int k = 3;    printFirstNegativeInteger(arr, n, k);    return 0;}
// Java implementation to find the// first negative integer in// every window of size kimport java.util.*;class GFG{ // function to find the first negative// integer in every window of size kstatic void printFirstNegativeInteger(int arr[],                                      int n, int k){    // A Double Ended Queue, Di that will    // store indexes of useful array elements    // for the current window of size k.    // The useful elements are all negative integers.    LinkedList<Integer> Di = new LinkedList<>();     // Process first k (or first window)    // elements of array    int i;    for (i = 0; i < k; i++)             // Add current element at the rear of Di        // if it is a negative integer        if (arr[i] < 0)            Di.add(i);         // Process rest of the elements,    // i.e., from arr[k] to arr[n-1]    for ( ; i < n; i++)    {        // if Di is not empty then the element        // at the front of the queue is the first        // negative integer of the previous window        if (!Di.isEmpty())            System.out.print(arr[Di.peek()] + " ");                 // else the window does not have a        // negative integer        else            System.out.print("0" + " ");         // Remove the elements which are        // out of this window        while ((!Di.isEmpty()) &&                 Di.peek() < (i - k + 1))            Di.remove(); // Remove from front of queue         // Add current element at the rear of Di        // if it is a negative integer        if (arr[i] < 0)            Di.add(i);    }     // Print the first negative    // integer of last window    if (!Di.isEmpty())        System.out.print(arr[Di.peek()] + " ");    else        System.out.print("0" + " ");    } // Driver Codepublic static void main(String[] args){    int arr[] = {12, -1, -7, 8, -15, 30, 16, 28};    int n = arr.length;    int k = 3;    printFirstNegativeInteger(arr, n, k);}} // This code is contributed by PrinciRaj1992
# Python3 implementation to find the# first negative integer in every window# of size k import deque() from collectionsfrom collections import deque # function to find the first negative# integer in every window of size kdef printFirstNegativeInteger(arr, n, k):         # A Double Ended Queue, Di that will store    # indexes of useful array elements for the    # current window of size k. The useful    # elements are all negative integers.    Di = deque()     # Process first k (or first window)    # elements of array    for i in range(k):                 # Add current element at the rear of Di        # if it is a negative integer        if (arr[i] < 0):            Di.append(i);         # Process rest of the elements, i.e.,    # from arr[k] to arr[n-1]    for i in range(k, n):                 # if the window does not have        # a negative integer        if (not Di):            print(0, end = ' ')                 # if Di is not empty then the element        # at the front of the queue is the first        # negative integer of the previous window        else:            print(arr[Di[0]], end = ' ');         # Remove the elements which are        # out of this window        while Di and Di[0] <= (i - k):            Di.popleft() # Remove from front of queue         # Add current element at the rear of Di        # if it is a negative integer        if (arr[i] < 0):            Di.append(i);     # Print the first negative    # integer of last window    if not Di:        print(0)    else:        print(arr[Di[0]], end = " ")     # Driver Codeif __name__ =="__main__":    arr = [12, -1, -7, 8, -15, 30, 16, 28]    n = len(arr)    k = 3    printFirstNegativeInteger(arr, n, k); # This code is contributed by# chaudhary_19 (Mayank Chaudhary)
// C# implementation to find the// first negative integer in// every window of size kusing System;using System.Collections.Generic; class GFG{ // function to find the first negative// integer in every window of size kstatic void printFirstNegativeint(int []arr,                                  int n, int k){    // A Double Ended Queue, Di that will    // store indexes of useful array elements    // for the current window of size k.    // The useful elements are all    // negative integers.    List<int> Di = new List<int>();     // Process first k (or first window)    // elements of array    int i;    for (i = 0; i < k; i++)             // Add current element at the rear of Di        // if it is a negative integer        if (arr[i] < 0)            Di.Add(i);         // Process rest of the elements,    // i.e., from arr[k] to arr[n-1]    for ( ; i < n; i++)    {        // if Di is not empty then the element        // at the front of the queue is the first        // negative integer of the previous window        if (Di.Count != 0)            Console.Write(arr[Di[0]] + " ");                 // else the window does not have a        // negative integer        else            Console.Write("0" + " ");         // Remove the elements which are        // out of this window        while ((Di.Count != 0) &&                Di[0] < (i - k + 1))                             // Remove from front of queue            Di.RemoveAt(0);         // Add current element at the rear of Di        // if it is a negative integer        if (arr[i] < 0)            Di.Add(i);    }     // Print the first negative    // integer of last window    if (Di.Count!=0)        Console.Write(arr[Di[0]] + " ");    else        Console.Write("0" + " ");    } // Driver Codepublic static void Main(String[] args){    int []arr = {12, -1, -7, 8, -15, 30, 16, 28};    int n = arr.Length;    int k = 3;    printFirstNegativeint(arr, n, k);}} // This code is contributed by 29AjayKumar
<script> // javascript implementation to find the// first negative integer in// every window of size k     // function to find the first negative    // integer in every window of size k    function printFirstNegativeInteger(arr , n , k)    {             // A Double Ended Queue, Di that will        // store indexes of useful array elements        // for the current window of size k.        // The useful elements are all negative integers.        var Di = [];         // Process first k (or first window)        // elements of array        var i;        for (i = 0; i < k; i++)             // Add current element at the rear of Di            // if it is a negative integer            if (arr[i] < 0)                Di.push(i);         // Process rest of the elements,        // i.e., from arr[k] to arr[n-1]        for (; i < n; i++) {            // if Di is not empty then the element            // at the front of the queue is the first            // negative integer of the previous window            if (Di.length!==0)                document.write(arr[Di[0]] + " ");             // else the window does not have a            // negative integer            else                document.write("0" + " ");             // Remove the elements which are            // out of this window            while ((Di.length!==0) && Di[0] < (i - k + 1))                Di.shift(); // Remove from front of queue             // Add current element at the rear of Di            // if it is a negative integer            if (arr[i] < 0)                Di.push(i);        }         // Print the first negative        // integer of last window        if (Di.length !== 0)            document.write(arr[Di[0]] + " ");        else            document.write("0" + " ");    }     // Driver Code             var arr = [ 12, -1, -7, 8, -15, 30, 16, 28 ];        var n = arr.length;        var k = 3;        printFirstNegativeInteger(arr, n, k); // This code is contributed by Rajput-Ji</script>
-1 -1 -7 -15 -15 0 
Output: 
-1 -1 -7 -15 -15 0
Time Complexity: O(n) Auxiliary Space: O(k)
Optimized Approach:: It is also possible to accomplish this with constant space. The idea is to have a variable firstNegativeIndex to keep track of the first negative element in the k sized window. At every iteration, we skip the elements which no longer fall under the current k size window (firstNegativeIndex <= i – k) as well as the non-negative elements(zero or positive). 
Below is the solution based upon this approach.
C++
Java
Python3
C#
Javascript
// C++ code for First negative integer// in every window of size k#include <iostream>using namespace std; void printFirstNegativeInteger(int arr[], int k, int n){    int firstNegativeIndex = 0;    int firstNegativeElement;             for(int i = k - 1; i < n; i++)    {               // skip out of window and positive elements        while((firstNegativeIndex < i ) &&              (firstNegativeIndex <= i - k ||               arr[firstNegativeIndex] >= 0))        {            firstNegativeIndex ++;        }                 // check if a negative element is found, otherwise use 0        if(arr[firstNegativeIndex] < 0)        {            firstNegativeElement = arr[firstNegativeIndex];        }        else        {            firstNegativeElement = 0;        }        cout<<firstNegativeElement << " ";    }     } // Driver codeint main(){     int arr[] = { 12, -1, -7, 8, -15, 30, 16, 28};      int n = sizeof(arr)/sizeof(arr[0]);     int k = 3;     printFirstNegativeInteger(arr, k, n);   } // This code is contributed by avanitrachhadiya2155
// Java code for First negative integer// in every window of size kimport java.util.*; class GFG{     static void printFirstNegativeInteger(int arr[],                                      int k, int n){    int firstNegativeIndex = 0;    int firstNegativeElement;         for(int i = k - 1; i < n; i++)    {                 // Skip out of window and positive elements        while ((firstNegativeIndex < i ) &&               (firstNegativeIndex <= i - k ||            arr[firstNegativeIndex] >= 0))        {            firstNegativeIndex ++;        }                 // Check if a negative element is        // found, otherwise use 0        if (arr[firstNegativeIndex] < 0)        {            firstNegativeElement = arr[firstNegativeIndex];        }        else        {            firstNegativeElement = 0;        }        System.out.print(firstNegativeElement + " ");    }} // Driver codepublic static void main(String[] args){    int arr[] = { 12, -1, -7, 8, -15, 30, 16, 28 };    int n = arr.length;    int k = 3;         printFirstNegativeInteger(arr, k, n);   }} // This code is contributed by amreshkumar3
# Python3 code for First negative integer# in every window of size kdef printFirstNegativeInteger(arr, k):    firstNegativeIndex = 0     for i in range(k - 1, len(arr)):         # skip out of window and positive elements        while firstNegativeIndex < i and (firstNegativeIndex <= i - k or arr[firstNegativeIndex] >= 0):            firstNegativeIndex += 1         # check if a negative element is found, otherwise use 0        firstNegativeElement = arr[firstNegativeIndex] if arr[firstNegativeIndex] < 0 else 0        print(firstNegativeElement, end=' ')  if __name__ == "__main__":    arr = [12, -1, -7, 8, -15, 30, 16, 28]    k = 3    printFirstNegativeInteger(arr, k) # contributed by Arjun Lather
// C# code for First negative integer// in every window of size kusing System; class GFG{ static void printFirstNegativeInteger(int[] arr,                                      int k, int n){    int firstNegativeIndex = 0;    int firstNegativeElement;         for(int i = k - 1; i < n; i++)    {                 // Skip out of window and positive elements        while ((firstNegativeIndex < i ) &&               (firstNegativeIndex <= i - k ||            arr[firstNegativeIndex] >= 0))        {            firstNegativeIndex ++;        }                 // Check if a negative element is        // found, otherwise use 0        if (arr[firstNegativeIndex] < 0)        {            firstNegativeElement = arr[firstNegativeIndex];        }        else        {            firstNegativeElement = 0;        }        Console.Write(firstNegativeElement + " ");    }   } // Driver codestatic public void Main(){    int[] arr = { 12, -1, -7, 8, -15, 30, 16, 28 };    int n = arr.Length;    int k = 3;         printFirstNegativeInteger(arr, k, n);}} // This code is contributed by rag2127
<script>        // JavaScript Program for the above approach           function printFirstNegativeInteger(arr, k, n) {            let firstNegativeIndex = 0;            let firstNegativeElement;              for (let i = k - 1; i < n; i++) {                 // skip out of window and positive elements                while ((firstNegativeIndex < i) &&                    (firstNegativeIndex <= i - k ||                        arr[firstNegativeIndex] >= 0)) {                    firstNegativeIndex++;                }                 // check if a negative element is found, otherwise use 0                if (arr[firstNegativeIndex] < 0) {                    firstNegativeElement = arr[firstNegativeIndex];                }                else {                    firstNegativeElement = 0;                }                document.write(firstNegativeElement + " ");            }         }         // Driver code         let arr = [12, -1, -7, 8, -15, 30, 16, 28];        let n = arr.length;        let k = 3;        printFirstNegativeInteger(arr, k, n);     // This code is contributed by Potta Lokesh    </script>
-1 -1 -7 -15 -15 0 
Output: 
-1 -1 -7 -15 -15 0
Time Complexity: O(n) Auxiliary Space: O(1)
This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeek’s main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
Shashank_Sharma
29AjayKumar
princiraj1992
chaudhary_19
themaverik
avanitrachhadiya2155
amreshkumar3
rag2127
lokeshpotta20
avijitmondal1998
simranarora5sos
rkbhola5
Rajput-Ji
sweetyty
acayush2002
Amazon
sliding-window
Arrays
Queue
Amazon
sliding-window
Arrays
Queue
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.