Related Articles

# First negative integer in every window of size k

• Difficulty Level : Medium
• Last Updated : 20 Jul, 2021

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:

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.

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

 `// C++ implementation to find the first negative``// integer in every window of size k``#include ``using` `namespace` `std;`` ` `// function to find the first negative``// integer in every window of size k``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

## Java

 `// Java implementation to find the first negative``// integer in every window of size k``import` `java.util.*;` `class` `solution``{` `// function to find the first negative``// integer in every window of size k``static` `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

## Python3

 `# 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 k``def` `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 Code``arr ``=` `[``12``, ``-``1``, ``-``7``, ``8``, ``-``15``, ``30``, ``16``, ``28``]``n ``=` `len``(arr)``k ``=` `3``printFirstNegativeInteger(arr, n, k)` `# This code is contributed by 'Smitha dinesh semwal'`

## C#

 `// C# implementation to find``// the first negative integer``// in every window of size k``using` `System;` `class` `GFG``{` `// function to find the first negative``// integer in every window of size k``static` `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 code``public` `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`

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 comparitively 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++

 `// C++ implementation to find the first negative``// integer in every window of size k``#include ` `using` `namespace` `std;`` ` `// function to find the first negative``// integer in every window of size k``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.``    ``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 functions``int` `main()``{``    ``int` `arr[] = {12, -1, -7, 8, -15, 30, 16, 28};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``int` `k = 3;``    ``printFirstNegativeInteger(arr, n, k);``    ``return` `0;``}`

## Java

 `// Java implementation to find the``// first negative integer in``// every window of size k``import` `java.util.*;``class` `GFG``{` `// function to find the first negative``// integer in every window of size k``static` `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 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 Code``public` `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

 `# Python3 implementation to find the``# first negative integer in every window``# of size k import deque() from collections``from` `collections ``import` `deque` `# function to find the first negative``# integer in every window of size k``def` `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 Code``if` `__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#

 `// C# implementation to find the``// first negative integer in``// every window of size k``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// function to find the first negative``// integer in every window of size k``static` `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] + ``" "``);``        ` `        ``// 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 < (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] + ``" "``);``    ``else``        ``Console.Write(``"0"` `+ ``" "``);    ``}` `// Driver Code``public` `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`

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 positive elements.

Below is the solution based upon this approach.

## C++

 `// C++ code for First negative integer``// in every window of size k``#include ``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<

## Java

 `// Java code for First negative integer``// in every window of size k``import` `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 code``public` `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

 `# Python3 code for First negative integer``# in every window of size k``def` `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#

 `// C# code for First negative integer``// in every window of size k``using` `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 code``static` `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`

## Javascript

 ``

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.