Minimum window size containing atleast P primes in every window of given range
Last Updated :
29 Aug, 2023
Given three integers X, Y and P, the task is to find the minimum window size K such that every window in the range [X, Y] of this size have atleast P prime numbers.
Examples:
Input: X = 2, Y = 8, P = 2
Output: 4
Explanation:
In the range [2, 8], window size of 4 contains atleast 2 primes in each window.
Possible Windows –
{2, 3, 4, 5} – No of Primes = 3
{3, 4, 5, 6} – No of Primes = 2
{4, 5, 6, 7} – No of Primes = 2
{5, 6, 7, 8} – No of Primes = 2
Input: X = 12, Y = 42, P = 3
Output: 14
Explanation:
In the range [12, 42], window size of 14 contains atleast 3 primes in each window.
Naive Approach: Traverse over all the possible window sizes, for each window size traverse in the range [X, Y] and check that each window contains at least K primes. The minimum of these window sizes will be the desired value.
- Define a function isPrime that takes in a number n and returns True if n is prime, else returns False.
- Check if n is less than or equal to 1, return False.
- Loop over all numbers from 2 to the square root of n.
- If n is divisible by any number in the loop, return False.
- If the loop completes without returning False, return True.
- Define the minimumWindowSize function that takes in three parameters X, Y, and P.
- Set min_size to Y – X + 1.
- Loop over all possible window sizes from 2 to min_size.
- For each window size k, loop over all possible starting indices i from X to Y – k + 2.
- Count the number of prime numbers in the window from i to i + k – 1 using the isPrime function.
- If the count is less than P, break out of the inner loop and move on to the next window size k.
- If the count is greater than or equal to P and the loop has reached the last possible starting index Y – k + 1, return the window size k.
- If no such window exists, return -1.
Below is the implementation of the above approach:
C++14
#include <bits/stdc++.h>
using namespace std;
bool isPrime( int n) {
if (n <= 1) {
return false ;
}
for ( int i = 2; i <= sqrt (n); i++) {
if (n % i == 0) {
return false ;
}
}
return true ;
}
int minimumWindowSize( int X, int Y, int P) {
int min_size = Y - X + 1;
for ( int k = 2; k <= min_size; k++) {
for ( int i = X; i <= Y - k + 1; i++) {
int count = 0;
for ( int j = i; j < i + k; j++) {
if (isPrime(j)) {
count++;
}
}
if (count < P) {
break ;
}
if (i == Y - k + 1 && count >= P) {
return k;
}
}
}
return -1;
}
int main() {
int x = 12;
int y = 42;
int p = 3;
cout << minimumWindowSize(x, y, p);
return 0;
}
|
Java
import java.lang.Math;
class Main {
static boolean isPrime( int n)
{
if (n <= 1 ) {
return false ;
}
for ( int i = 2 ; i <= Math.sqrt(n); i++) {
if (n % i == 0 ) {
return false ;
}
}
return true ;
}
static int minimumWindowSize( int X, int Y, int P)
{
int min_size = Y - X + 1 ;
for ( int k = 2 ; k <= min_size; k++) {
for ( int i = X; i <= Y - k + 1 ; i++) {
int count = 0 ;
for ( int j = i; j < i + k; j++) {
if (isPrime(j)) {
count++;
}
}
if (count < P) {
break ;
}
if (i == Y - k + 1 && count >= P) {
return k;
}
}
}
return - 1 ;
}
public static void main(String[] args)
{
int x = 12 ;
int y = 42 ;
int p = 3 ;
System.out.println(minimumWindowSize(x, y, p));
}
}
|
Python
import math
def isPrime(n):
if n < = 1 :
return False
for i in range ( 2 , int (math.sqrt(n)) + 1 ):
if n % i = = 0 :
return False
return True
def minimumWindowSize(X, Y, P):
min_size = Y - X + 1
for k in range ( 2 , min_size + 1 ):
for i in range (X, Y - k + 2 ):
count = 0
for j in range (i, i + k):
if isPrime(j):
count + = 1
if count < P:
break
if i = = Y - k + 1 and count > = P:
return k
return - 1
x = 12
y = 42
p = 3
print (minimumWindowSize(x, y, p))
|
C#
using System;
class GFG
{
static bool IsPrime( int n)
{
if (n <= 1)
{
return false ;
}
for ( int i = 2; i <= Math.Sqrt(n); i++)
{
if (n % i == 0)
{
return false ;
}
}
return true ;
}
static int MinimumWindowSize( int X, int Y, int P)
{
int minSize = Y - X + 1;
for ( int k = 2; k <= minSize; k++)
{
for ( int i = X; i <= Y - k + 1; i++)
{
int count = 0;
for ( int j = i; j < i + k; j++)
{
if (IsPrime(j))
{
count++;
}
}
if (count < P)
{
break ;
}
if (i == Y - k + 1 && count >= P)
{
return k;
}
}
}
return -1;
}
static void Main()
{
int x = 12;
int y = 42;
int p = 3;
Console.WriteLine(MinimumWindowSize(x, y, p));
}
}
|
Javascript
function isPrime(n) {
if (n <= 1) {
return false ;
}
for (let i = 2; i <= Math.sqrt(n); i++) {
if (n % i === 0) {
return false ;
}
}
return true ;
}
function minimumWindowSize(X, Y, P) {
let minSize = Y - X + 1;
for (let k = 2; k <= minSize; k++) {
for (let i = X; i <= Y - k + 1; i++) {
let count = 0;
for (let j = i; j < i + k; j++) {
if (isPrime(j)) {
count++;
}
}
if (count < P) {
break ;
}
if (i === Y - k + 1 && count >= P) {
return k;
}
}
}
return -1;
}
const x = 12;
const y = 42;
const p = 3;
console.log(minimumWindowSize(x, y, p));
|
Time Complexity: O((Y-X+1)3 Sqrt(Y)), where Y-X+1 is the range of integers and Sqrt(Y) is the time complexity of checking if a number is prime or not.
Auxiliary Space: O(1), as we are not using any extra space.
Efficient Approach: The key observation in this problem is if a window size W is the minimum window size satisfying the condition, then all window size in the range [W, Y – X + 1] will satisfy the condition. Using this we can reduce our search space at each step by half which is precisely the idea of Binary Search. Below is the illustration of the steps:
- Search Space: The search space for this problem can be the minimum length of the window size that is 1 and the maximum window size can be the difference between the ending value of the range and the starting value of the range.
low = 1
high = Y - X + 1
- Next Search Space: In each step generally the idea is to check that for the given window size the primes in each window possible have P primes or not with the help of the sliding window technique. Whereas the search space for the problem can be reduced on the basis of below decision:
- Case 1: When the number of primes in each window contains at least P primes, then the size of the window can be reduced to find the window size of less than the current window.
if (checkPPrimes(mid) == True)
high = mid - 1
- Case 2: When the number of primes in each window contains do not have then the window size must be greater than the current window size. Then,
if (checkPPrimes(mid) == False)
low = mid + 1
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool isPrime( int N)
{
if (N < 2)
return false ;
if (N < 4)
return true ;
if ((N & 1) == 0)
return false ;
if (N % 3 == 0)
return false ;
int curr = 5, s = sqrt (N);
while (curr <= s) {
if (N % curr == 0)
return false ;
curr += 2;
if (N % curr == 0)
return false ;
curr += 4;
}
return true ;
}
bool check( int s, int p,
int prefix_sum[], int n)
{
bool satisfies = true ;
for ( int i = 0; i < n; i++) {
if (i + s - 1 >= n)
break ;
if (prefix_sum[i + s - 1] -
(i - 1 >= 0 ?
prefix_sum[i - 1] : 0) < p)
satisfies = false ;
}
return satisfies;
}
int minimumWindowSize( int x, int y,
int p)
{
int prefix_sum[y - x + 1] = { 0 };
for ( int i = x; i <= y; i++) {
if (isPrime(i))
prefix_sum[i - x] = 1;
}
for ( int i = 1; i < y - x + 1; i++)
prefix_sum[i] +=
prefix_sum[i - 1];
int low = 1, high = y - x + 1;
int mid;
while (high - low > 1) {
mid = (low + high) / 2;
if (check(mid, p,
prefix_sum, y - x + 1)) {
high = mid;
}
else
low = mid;
}
if (check(low, p,
prefix_sum, y - x + 1))
return low;
return high;
}
int main()
{
int x = 12;
int y = 42;
int p = 3;
cout << minimumWindowSize(x, y, p);
return 0;
}
|
Java
import java.util.*;
class GFG{
static boolean isPrime( int N)
{
if (N < 2 )
return false ;
if (N < 4 )
return true ;
if ((N & 1 ) == 0 )
return false ;
if (N % 3 == 0 )
return false ;
int curr = 5 , s = ( int ) Math.sqrt(N);
while (curr <= s) {
if (N % curr == 0 )
return false ;
curr += 2 ;
if (N % curr == 0 )
return false ;
curr += 4 ;
}
return true ;
}
static boolean check( int s, int p,
int prefix_sum[], int n)
{
boolean satisfies = true ;
for ( int i = 0 ; i < n; i++) {
if (i + s - 1 >= n)
break ;
if (prefix_sum[i + s - 1 ] -
(i - 1 >= 0 ?
prefix_sum[i - 1 ] : 0 ) < p)
satisfies = false ;
}
return satisfies;
}
static int minimumWindowSize( int x, int y,
int p)
{
int []prefix_sum = new int [y - x + 1 ];
for ( int i = x; i <= y; i++) {
if (isPrime(i))
prefix_sum[i - x] = 1 ;
}
for ( int i = 1 ; i < y - x + 1 ; i++)
prefix_sum[i] +=
prefix_sum[i - 1 ];
int low = 1 , high = y - x + 1 ;
int mid;
while (high - low > 1 ) {
mid = (low + high) / 2 ;
if (check(mid, p,
prefix_sum, y - x + 1 )) {
high = mid;
}
else
low = mid;
}
if (check(low, p,
prefix_sum, y - x + 1 ))
return low;
return high;
}
public static void main(String[] args)
{
int x = 12 ;
int y = 42 ;
int p = 3 ;
System.out.print(minimumWindowSize(x, y, p));
}
}
|
Python3
from math import sqrt
def isPrime(N):
if (N < 2 ):
return False
if (N < 4 ):
return True
if ((N & 1 ) = = 0 ):
return False
if (N % 3 = = 0 ):
return False
curr = 5
s = sqrt(N)
while (curr < = s):
if (N % curr = = 0 ):
return False
curr + = 2
if (N % curr = = 0 ):
return False
curr + = 4
return True
def check(s, p, prefix_sum, n):
satisfies = True
for i in range (n):
if (i + s - 1 > = n):
break
if (i - 1 > = 0 ):
x = prefix_sum[i - 1 ]
else :
x = 0
if (prefix_sum[i + s - 1 ] - x < p):
satisfies = False
return satisfies
def minimumWindowSize(x, y, p):
prefix_sum = [ 0 ] * (y - x + 1 )
for i in range (x ,y + 1 ):
if (isPrime(i)):
prefix_sum[i - x] = 1
for i in range ( 1 ,y - x + 1 ):
prefix_sum[i] + = prefix_sum[i - 1 ]
low = 1
high = y - x + 1
while (high - low > 1 ):
mid = (low + high) / / 2
if (check(mid, p ,prefix_sum, y - x + 1 )):
high = mid
else :
low = mid
if (check(low, p, prefix_sum, y - x + 1 )):
return low
return high
x = 12
y = 42
p = 3
print (minimumWindowSize(x, y, p))
|
C#
using System;
class GFG{
static bool isPrime( int N)
{
if (N < 2)
return false ;
if (N < 4)
return true ;
if ((N & 1) == 0)
return false ;
if (N % 3 == 0)
return false ;
int curr = 5, s = ( int ) Math.Sqrt(N);
while (curr <= s) {
if (N % curr == 0)
return false ;
curr += 2;
if (N % curr == 0)
return false ;
curr += 4;
}
return true ;
}
static bool check( int s, int p,
int []prefix_sum, int n)
{
bool satisfies = true ;
for ( int i = 0; i < n; i++) {
if (i + s - 1 >= n)
break ;
if (prefix_sum[i + s - 1] -
(i - 1 >= 0 ?
prefix_sum[i - 1] : 0) < p)
satisfies = false ;
}
return satisfies;
}
static int minimumWindowSize( int x, int y,
int p)
{
int []prefix_sum = new int [y - x + 1];
for ( int i = x; i <= y; i++) {
if (isPrime(i))
prefix_sum[i - x] = 1;
}
for ( int i = 1; i < y - x + 1; i++)
prefix_sum[i] +=
prefix_sum[i - 1];
int low = 1, high = y - x + 1;
int mid;
while (high - low > 1) {
mid = (low + high) / 2;
if (check(mid, p,
prefix_sum, y - x + 1)) {
high = mid;
}
else
low = mid;
}
if (check(low, p,
prefix_sum, y - x + 1))
return low;
return high;
}
public static void Main(String[] args)
{
int x = 12;
int y = 42;
int p = 3;
Console.Write(minimumWindowSize(x, y, p));
}
}
|
Javascript
<script>
function isPrime(N)
{
if (N < 2)
return false ;
if (N < 4)
return true ;
if ((N & 1) == 0)
return false ;
if (N % 3 == 0)
return false ;
let curr = 5, s = Math.floor(Math.sqrt(N));
while (curr <= s) {
if (N % curr == 0)
return false ;
curr += 2;
if (N % curr == 0)
return false ;
curr += 4;
}
return true ;
}
function check(s, p,
prefix_sum, n)
{
let satisfies = true ;
for (let i = 0; i < n; i++) {
if (i + s - 1 >= n)
break ;
if (prefix_sum[i + s - 1] -
(i - 1 >= 0 ?
prefix_sum[i - 1] : 0) < p)
satisfies = false ;
}
return satisfies;
}
function minimumWindowSize(x, y, p)
{
let prefix_sum = new Array(y - x + 1).fill(0);
for (let i = x; i <= y; i++) {
if (isPrime(i))
prefix_sum[i - x] = 1;
}
for (let i = 1; i < y - x + 1; i++)
prefix_sum[i] +=
prefix_sum[i - 1];
let low = 1, high = y - x + 1;
let mid;
while (high - low > 1) {
mid = Math.floor((low + high) / 2);
if (check(mid, p,
prefix_sum, y - x + 1)) {
high = mid;
}
else
low = mid;
}
if (check(low, p,
prefix_sum, y - x + 1))
return low;
return high;
}
let x = 12;
let y = 42;
let p = 3;
document.write(minimumWindowSize(x, y, p));
</script>
|
Time complexity: O(N*log(N))
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...