GFG App
Open App
Browser
Continue

Check if the given number K is enough to reach the end of an array

Given an array arr[] of n elements and a number K. The task is to determine if it is possible to reach the end of the array by doing the below operations:
Traverse the given array and,

• If any element is found to be non-prime then decrement the value of K by 1.
• If any element is prime then refill the value of K to its initial value.

If it is possible to reach the end of array with (K > 0), then print YES otherwise print NO.

Examples

```Input : K = 2, arr[]={ 6, 3, 4, 5, 6};
Output : Yes
Explanation :
1- arr[0] is not prime, so K = K-1 = 1
2- arr[1] is prime so K will be refilled to its
initial value. Therefore,  K = 2.
3- arr[2] is not prime.
Therefore,  K = 2-1 = 1
4- arr[3] is prime so K will be refilled to its
initial value. Therefore,  K = 2.
5- arr[4] is not prime.
Therefore,  K = 2-1 = 1
6- Since the end of the array is reached with K>=0
So output is YES

Input :  k=3, arr[]={ 1, 2, 10, 4, 6, 8};
Output : No```

Recommended: Please solve it on “PRACTICE “first, before moving on to the solution.

Simple Approach

• Traverse each element of the array and Check if the value of the current element is prime or not.
• If it is Prime then refill the power of K else decrements by 1.
• If it is possible to reach the end of the array with (K > 0) then print “YES” otherwise “NO”.

Below is the implementation of the above approach:

C++

 `// C++ program to check if it is possible` `// to reach the end of the array` `#include ` `using` `namespace` `std;`   `// Function To check number is prime or not` `bool` `is_Prime( ``int` `num ) ` `{` `    ``// because 1 is not prime ` `    ``if``(num == 1)` `    ``return` `false``;` `    `  `    ``for``(``int` `i=2 ; i*i <= num ; i++ )` `    ``{` `        ``if``( num % i == 0 )` `        ``return` `false``;` `    ``}` `    `  `return` `true``; ` `}`   `// Function to check whether it is possible` `// to reach the end of the array or not     ` `bool` `isReachable( ``int` `arr[] , ``int` `n , ``int` `k)` `{   ` `    ``// store initial value of K` `    ``int` `x = k ;` `            `  `    ``for``(``int` `i=0 ; i < n ; i++ )` `    ``{` `        ``// Call is_prime function to` `        ``// check if a number is prime. ` `        ``if``( is_Prime(arr[i]) )` `        ``{` `            ``// Refill K to initial value` `            ``k = x;` `        ``}                 ` `        ``else` `        ``{` `            ``// Decrement k by 1` `            ``k-- ;                 ` `        ``}`   `    `  `        ``if``( k <= 0 && i < (n-1) && (!is_Prime(arr[i+1])) )` `            ``return` `false` `;` `    ``}` `            `  `    ``return` `true` `;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 6, 3, 4, 5, 6};` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]) ;` `    ``int` `k = 2 ;`   `        `  `    ``isReachable( arr , n , k ) ? cout << ``"Yes"` `<< endl : ` `                                    ``cout << ``"No"` `<< endl ; ` `        `  `    ``return` `0 ;` `} `

Java

 `// Java program to check if ` `// it is possible to reach` `// the end of the array` `import` `java.io.*;` `import` `java.util.*;` `import` `java.lang.*;`   `class` `GFG` `{` `    `  `// Function To check ` `// number is prime or not` `static` `boolean` `is_Prime(``int` `num) ` `{` `    ``// because 1 is not prime ` `    ``if``(num == ``1``)` `    ``return` `false``;` `    `  `    ``for``(``int` `i = ``2` `;` `            ``i * i <= num ; i++ )` `    ``{` `        ``if``(num % i == ``0``)` `        ``return` `false``;` `    ``}` `    `  `return` `true``; ` `}`   `// Function to check whether ` `// it is possible to reach` `// the end of the array or not     ` `static` `boolean` `isReachable(``int` `arr[] , ` `                           ``int` `n , ``int` `k)` `{ ` `    ``// store initial value of K` `    ``int` `x = k ;` `            `  `    ``for``(``int` `i = ``0` `; i < n ; i++ )` `    ``{` `        ``// Call is_prime function to` `        ``// check if a number is prime. ` `        ``if``(is_Prime(arr[i]))` `        ``{` `            ``// Refill K to ` `            ``// initial value` `            ``k = x;` `        ``}                 ` `        ``else` `        ``{` `            ``// Decrement k by 1` `            ``k-- ;                 ` `        ``}`   `    `  `        ``if``(k <= ``0` `&& i < (n - ``1``) && ` `          ``(is_Prime(arr[i + ``1``]) != ``true``))` `            ``return` `false` `;` `    ``}` `            `  `    ``return` `true` `;` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    ``int` `arr[] = ``new` `int``[]{ ``6``, ``3``, ``4``, ``5``, ``6``};` `    ``int` `n = arr.length;` `    ``int` `k = ``2` `;`   `    ``if``(isReachable(arr, n, k) == ``true``)` `        ``System.out.print(``"Yes"` `+ ``"\n"``);` `     ``else` `        ``System.out.print(``"No"` `+ ``"\n"``); ` `} ` `}`

Python3

 `# Python 3 program to check if it is ` `# possible to reach the end of the array` `from` `math ``import` `sqrt`   `# Function To check number is prime or not` `def` `is_Prime(num):` `    `  `    ``# because 1 is not prime ` `    ``if``(num ``=``=` `1``):` `        ``return` `False` `    ``k ``=` `int``(sqrt(num)) ``+` `1`   `    ``for` `i ``in` `range``(``2``, k, ``1``):` `        ``if``(num ``%` `i ``=``=` `0``):` `            ``return` `False` `            `  `    ``return` `True`   `# Function to check whether it is possible` `# to reach the end of the array or not ` `def` `isReachable(arr, n , k):` `    `  `    ``# store initial value of K` `    ``x ``=` `k` `            `  `    ``for` `i ``in` `range``(``0``, n, ``1``):` `        `  `        ``# Call is_prime function to` `        ``# check if a number is prime. ` `        ``if``( is_Prime(arr[i])):` `            `  `            ``# Refill K to initial value` `            ``k ``=` `x     ` `        ``else``:` `            `  `            ``# Decrement k by 1` `            ``k ``-``=` `1`        `    `  `        ``if``(k <``=` `0` `and` `i < (n ``-` `1``) ``and` `          ``(is_Prime(arr[i ``+` `1``])) ``=``=` `False``):` `            ``return` `False` `            `  `    ``return` `True`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``6``, ``3``, ``4``, ``5``, ``6``]` `    ``n ``=` `len``(arr)` `    ``k ``=` `2`   `    ``if` `(isReachable( arr , n , k )):` `        ``print``(``"Yes"``)` `    ``else``:` `        ``print``(``"No"``)`   `# This code is contributed by` `# Sahil_Shelangia`

C#

 `// C# program to check if ` `// it is possible to reach` `// the end of the array` `using` `System;`   `class` `GFG` `{` `    `  `// Function To check ` `// number is prime or not` `static` `bool` `is_Prime(``int` `num) ` `{` `    ``// because 1 is not prime ` `    ``if``(num == 1)` `    ``return` `false``;` `    `  `    ``for``(``int` `i = 2 ;` `            ``i * i <= num ; i++ )` `    ``{` `        ``if``(num % i == 0)` `        ``return` `false``;` `    ``}` `    `  `return` `true``; ` `}`   `// Function to check whether ` `// it is possible to reach` `// the end of the array or not ` `static` `bool` `isReachable(``int` `[]arr , ` `                        ``int` `n , ``int` `k)` `{ ` `    ``// store initial ` `    ``// value of K` `    ``int` `x = k ;` `            `  `    ``for``(``int` `i = 0 ; i < n ; i++ )` `    ``{` `        ``// Call is_prime function ` `        ``// to check if a number ` `        ``// is prime. ` `        ``if``(is_Prime(arr[i]))` `        ``{` `            ``// Refill K to ` `            ``// initial value` `            ``k = x;` `        ``}             ` `        ``else` `        ``{` `            ``// Decrement k by 1` `            ``k-- ;             ` `        ``}`   `    `  `        ``if``(k <= 0 && i < (n - 1) && ` `        ``(is_Prime(arr[i + 1]) != ``true``))` `            ``return` `false` `;` `    ``}` `            `  `    ``return` `true` `;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `[]arr = ``new` `int``[]{ 6, 3, 4, 5, 6};` `    ``int` `n = arr.Length;` `    ``int` `k = 2 ;`   `    ``if``(isReachable(arr, n, k) == ``true``)` `        ``Console.WriteLine(``"Yes"` `+ ``"\n"``);` `    ``else` `        ``Console.WriteLine(``"No"` `+ ``"\n"``); ` `} ` `}`   `// This code is contributed by vt_m`

PHP

 ``

Javascript

 ``

Output

`Yes`

Time complexity: O(N(sqrt N))

Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using the Sieve of Eratosthenes to check if a number is prime or not.

Below is the implementation of the efficient approach:

C++

 `// C++ program to check if it is possible` `// to reach the end of the array` `#include ` `#define MAX 1000000` `using` `namespace` `std;`   `// Function for Sieve of Eratosthenes` `void` `SieveOfEratosthenes( ``int` `sieve[], ``int` `max ) ` `{   ` `    ``for``(``int` `i=0; i

Java

 `// Java program to check if it is possible` `// to reach the end of the array` `class` `GFG ` `{`   `    ``static` `int` `MAX = ``1000000``;`   `    ``// Function for Sieve of Eratosthenes` `    ``static` `void` `SieveOfEratosthenes(``int` `sieve[], ``int` `max) ` `    ``{` `        ``for` `(``int` `i = ``0``; i < max; i++) ` `        ``{` `            ``sieve[i] = ``1``;` `        ``}`   `        ``for` `(``int` `i = ``2``; i * i < max; i++) ` `        ``{` `            ``if` `(sieve[i] == ``1``)` `            ``{` `                ``for` `(``int` `j = i * ``2``; j < max; j += i) ` `                ``{` `                    ``sieve[j] = ``0``;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Function to check if it is possible to` `    ``// reach end of the array     ` `    ``static` `boolean` `isReachable(``int` `arr[], ``int` `n, ` `                                ``int` `sieve[], ``int` `k) ` `    ``{` `        ``// store initial value of K` `        ``int` `x = k;`   `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{` `            ``if` `(sieve[arr[i]] == ``1``) ` `            ``{` `                ``// Refill K to initial value` `                ``k = x;` `            ``} ` `            ``else` `            ``{` `                ``// Decrement k by 1` `                ``k -= ``1``;` `            ``}`   `            ``if` `((k <= ``0``) && (i < (n - ``1``))` `                    ``&& (sieve[arr[i + ``1``]] == ``0``)) ` `            ``{` `                ``return` `false``;` `            ``}` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `arr[] = {``6``, ``3``, ``4``, ``5``, ``6``};` `        ``int``[] sieve = ``new` `int``[MAX];` `        ``int` `n = arr.length;` `        ``int` `k = ``2``;`   `        ``SieveOfEratosthenes(sieve, MAX);`   `        ``if` `(isReachable(arr, n, sieve, k)) ` `        ``{` `            ``System.out.println(``"Yes"``);` `        ``} ` `        ``else` `        ``{` `            ``System.out.println(``"No"``);` `        ``}` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

Python3

 `# Python3 program to check if it is` `# possible to reach the end of the ` `# array ` `import` `math `   `# Function for Sieve of Eratosthenes ` `def` `SieveOfEratosthenes(sieve, ``max``): ` `    `  `    ``for` `i ``in` `range``(``0``, ``max``):` `        ``sieve[i] ``=` `1` `        `  `    ``sqt ``=` `int``(math.sqrt(``max``))` `    `  `    ``for` `i ``in` `range``(``2``, sqt):` `        ``if` `(sieve[i] ``=``=` `1``): ` `            ``for` `j ``in` `range``(i ``*` `2``, ``max``, i):` `                ``sieve[j] ``=` `0`   `# Function to check if it is possible to ` `# reach end of the array     ` `def` `isReachable(arr, n, sieve, k):` `    `  `    ``# store initial value of K ` `    ``x ``=` `k` `    ``for` `i ``in` `range``(``0``, n):` `        ``if` `(sieve[arr[i]] !``=` `0``): ` `            `  `            ``# Refill K to initial value ` `            ``k ``=` `x        ` `        ``else``:` `            `  `            ``# Decrement k by 1 ` `            ``k ``-``=` `1` `        ``if` `((k <``=` `0``) ``and` `(i < (n ``-` `1``)) ``and` `           ``(sieve[arr[i ``+` `1``]] ``=``=` `0``)):` `            ``return` `0` `            `  `    ``return` `1`   `# Driver Code ` `arr ``=` `[ ``6``, ``3``, ``4``, ``5``, ``6` `] ` `sieve ``=` `[``0` `for` `x ``in` `range``(``1000000``)] `   `n ``=` `len``(arr) ` `k ``=` `2`   `SieveOfEratosthenes(sieve, ``1000000``)`   `ch ``=` `isReachable(arr, n, sieve, k)`   `if` `(ch):` `    ``print``(``"Yes"``) ` `else``:` `    ``print``(``"No"``)` `    `  `# This code is contributed by Stream_Cipher`

C#

 `// C# program to check if it is possible` `// to reach the end of the array` `using` `System;`   `class` `GFG` `{` `    ``static` `int` `MAX = 1000000;`   `    ``// Function for Sieve of Eratosthenes` `    ``static` `void` `SieveOfEratosthenes(``int` `[]sieve, ``int` `max) ` `    ``{` `        ``for` `(``int` `i = 0; i < max; i++) ` `        ``{` `            ``sieve[i] = 1;` `        ``}`   `        ``for` `(``int` `i = 2; i * i < max; i++) ` `        ``{` `            ``if` `(sieve[i] == 1)` `            ``{` `                ``for` `(``int` `j = i * 2; j < max; j += i) ` `                ``{` `                    ``sieve[j] = 0;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Function to check if it is possible to` `    ``// reach end of the array ` `    ``static` `bool` `isReachable(``int` `[]arr, ``int` `n, ` `                                ``int` `[]sieve, ``int` `k) ` `    ``{` `        ``// store initial value of K` `        ``int` `x = k;`   `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{` `            ``if` `(sieve[arr[i]] == 1) ` `            ``{` `                ``// Refill K to initial value` `                ``k = x;` `            ``} ` `            ``else` `            ``{` `                ``// Decrement k by 1` `                ``k -= 1;` `            ``}`   `            ``if` `((k <= 0) && (i < (n - 1))` `                    ``&& (sieve[arr[i + 1]] == 0)) ` `            ``{` `                ``return` `false``;` `            ``}` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// Driver Code` `    ``static` `public` `void` `Main ()` `    ``{` `        ``int` `[]arr = {6, 3, 4, 5, 6};` `        ``int``[] sieve = ``new` `int``[MAX];` `        ``int` `n = arr.Length;` `        ``int` `k = 2;`   `        ``SieveOfEratosthenes(sieve, MAX);`   `        ``if` `(isReachable(arr, n, sieve, k)) ` `        ``{` `            ``Console.WriteLine(``"Yes"``);` `        ``} ` `        ``else` `        ``{` `            ``Console.WriteLine(``"No"``);` `        ``}` `    ``}` `}`   `/* This code contributed by ajit. */`

Javascript

 ``

Output

`Yes`

Time complexity: O(MAX * log(log(MAX)))

Auxiliary Space: O(MAX)

My Personal Notes arrow_drop_up