Given an array, arr[] of integers and an integer K, the task is to print true if there are K consecutive even numbers present else return false.
Input: arr[] = {1, 2, 4, 6, 7, 8}, K = 3
Output: true
Explanation: There are K = 3 consecutive even elements (2, 4, 6) present in the array.Input: arr[] = {1, 2, 3, 4, 5}, K = 2
Output: false
Approach: This can be solved with the following idea:
Get the index of all even elements in arr and check if there are increasing consecutive elements (increasing by 1) present at least K times.
Below is the implementation of the above approach:
- Create a vector index[], and get all indexes of even numbers in it.
- Then, check if consecutive increasing elements are present in the index[] at least K times.
- If yes, print “true”, else “false”.
Below is the implementation for the above approach:
// C++ implementation of the above code #include <bits/stdc++.h> using namespace std;
// Function to check k consecutive // elements present or not void checkConsecutive( int arr[], int n, int k)
{ // Stores index
vector< int > index;
int i = 0;
while (i < n) {
// Even element
if (arr[i] % 2 == 0) {
index.push_back(i);
}
i++;
}
int count = 1;
i = 1;
// Count increasing consecutive
// elements
while (i < index.size()) {
if (index[i] == index[i - 1] + 1) {
count++;
}
else {
count = 1;
}
// If present atleast k times
if (count >= k) {
cout << "true" ;
return ;
}
i++;
}
// If not present
cout << "false" ;
return ;
} // Driver code int main()
{ int N = 6;
int arr[] = { 1, 2, 4, 6, 7, 8 };
int K = 3;
// Function call
checkConsecutive(arr, N, K);
return 0;
} |
// Java implementation of the above code import java.util.*;
class GFG {
// Function to check k consecutive
// elements present or not
public static void checkConsecutive( int arr[], int n,
int k)
{
// Stores index
List<Integer> index = new ArrayList<Integer>();
int i = 0 ;
while (i < n) {
// Even element
if (arr[i] % 2 == 0 ) {
index.add(i);
}
i++;
}
int count = 1 ;
i = 1 ;
// Count increasing consecutive
// elements
while (i < index.size()) {
if (index.get(i) == index.get(i - 1 ) + 1 ) {
count++;
}
else {
count = 1 ;
}
// If present at least k times
if (count >= k) {
System.out.println( "true" );
return ;
}
i++;
}
// If not present
System.out.println( "false" );
return ;
}
// Driver code
public static void main(String[] args)
{
int N = 6 ;
int arr[] = { 1 , 2 , 4 , 6 , 7 , 8 };
int K = 3 ;
// Function call
checkConsecutive(arr, N, K);
}
} // This code is contributed by Prasad Kandekar(prasad264) |
# Python3 implementation of the above code # Function to check k consecutive # elements present or not def checkConsecutive(arr, n, k):
# Stores index
index = []
i = 0
while i < n:
# Even element
if arr[i] % 2 = = 0 :
index.append(i)
i + = 1
count = 1
i = 1
# Count increasing consecutive elements
while i < len (index):
if index[i] = = index[i - 1 ] + 1 :
count + = 1
else :
count = 1
# If present atleast k times
if count > = k:
print ( "true" )
return
i + = 1
# If not present
print ( "false" )
return
# Driver code if __name__ = = '__main__' :
N = 6
arr = [ 1 , 2 , 4 , 6 , 7 , 8 ]
K = 3
# Function call
checkConsecutive(arr, N, K)
|
// JavaScript implementation of the above code // Function to check k consecutive // elements present or not function checkConsecutive(arr, n, k)
{ // Stores index
let index=[];
let i = 0;
while (i < n) {
// Even element
if (arr[i] % 2 == 0) {
index.push(i);
}
i++;
}
let count = 1;
i = 1;
// Count increasing consecutive
// elements
while (i < index.length) {
if (index[i] == index[i - 1] + 1) {
count++;
}
else {
count = 1;
}
// If present atleast k times
if (count >= k) {
document.write( "true" );
return ;
}
i++;
}
// If not present
document.write( "false" );
return ;
} // Driver code let N = 6; let arr = [ 1, 2, 4, 6, 7, 8 ]; let K = 3; // Function call checkConsecutive(arr, N, K); |
// C# implementation of the above code using System;
using System.Collections.Generic;
public class GFG {
// Function to check k consecutive elements present or
// not
public static void checkConsecutive( int [] arr, int n,
int k)
{
// Stores index
List< int > index = new List< int >();
int i = 0;
while (i < n) {
// Even element
if (arr[i] % 2 == 0) {
index.Add(i);
}
i++;
}
int count = 1;
i = 1;
// Count increasing consecutive elements
while (i < index.Count) {
if (index[i] == index[i - 1] + 1) {
count++;
}
else {
count = 1;
}
// If present at least k times
if (count >= k) {
Console.WriteLine( "true" );
return ;
}
i++;
}
// If not present
Console.WriteLine( "false" );
return ;
}
static public void Main()
{
// Code
int N = 6;
int [] arr = { 1, 2, 4, 6, 7, 8 };
int K = 3;
// Function call
checkConsecutive(arr, N, K);
}
} // This code is contributed by karthik. |
true
Time Complexity: O(N)
Auxiliary Space: O(N)
Efficient Approach:
We can avoid use of extra auxiliary space in the above approach. We can just have a counter of consecutive evens as we are traversing the array. Once there is break in continuity of even numbers, we can reset the counter again to 0 and proceed to next element.
The algorithm will be involving the following steps:
- Traverse the array from left to right.
- Initialize a counter variable to 0.
- For each even element, increment the counter variable.
- If an odd element is encountered, reset the counter variable to 0.
- Check if the counter variable is equal to k. If it is, return true.
- If the end of the array is reached and the counter variable is not equal to k, return false.
Below is the implementation of the above approach:
// C++ program to check if there are K consecutive // even numbers present in the array #include<bits/stdc++.h> using namespace std;
// Function to check k consecutive // elements present or not bool checkConsecutiveEven( int arr[], int n, int k) {
// Initializing counter to 0
int count = 0;
// Traversing the array
for ( int i = 0; i < n; i++) {
// If the current element is even
if (arr[i] % 2 == 0) {
// Increment the counter
count++;
// If the counter reaches atleast k
if (count >= k)
return true ;
}
else {
// Reset the counter
count = 0;
}
}
// If k consecutive even numbers are not present
return false ;
} // Driver code int main() {
// Input array
int arr[] = { 1, 2, 4, 6, 7, 8 };
int n = sizeof (arr)/ sizeof (arr[0]);
int k = 3;
// Function call
if (checkConsecutiveEven(arr, n, k))
cout << "true\n" ;
else
cout << "false\n" ;
return 0;
} |
// Java program to check if there are K consecutive // even numbers present in the array import java.util.*;
public class GFG {
// Function to check k consecutive
// elements present or not
public static boolean checkConsecutiveEven( int arr[],
int n, int k)
{
// Initializing counter to 0
int count = 0 ;
// Traversing the array
for ( int i = 0 ; i < n; i++) {
// If the current element is even
if (arr[i] % 2 == 0 ) {
// Increment the counter
count++;
// If the counter reaches atleast k
if (count >= k)
return true ;
}
else {
// Reset the counter
count = 0 ;
}
}
// If k consecutive even numbers are not present
return false ;
}
// Driver code
public static void main(String[] args)
{
// Input array
int arr[] = { 1 , 2 , 4 , 6 , 7 , 8 };
int n = arr.length;
int k = 3 ;
// Function call
if (checkConsecutiveEven(arr, n, k))
System.out.println( "true" );
else
System.out.println( "false" );
}
} |
# Function to check k consecutive elements present or not def checkConsecutiveEven(arr, n, k):
# Initializing counter to 0
count = 0
# Traversing the array
for i in range (n):
# If the current element is even
if arr[i] % 2 = = 0 :
# Increment the counter
count + = 1
# If the counter reaches atleast k
if count > = k:
return True
else :
# Reset the counter
count = 0
# If k consecutive even numbers are not present
return False
# Driver code arr = [ 1 , 2 , 4 , 6 , 7 , 8 ]
n = len (arr)
k = 3
# Function call if checkConsecutiveEven(arr, n, k):
print ( "true" )
else :
print ( "false" )
# This Code is Contributed by Vikas Bishnoi |
// C# program to check if there are K consecutive // even numbers present in the array using System;
class GFG {
// Function to check k consecutive
// elements present or not
static bool CheckConsecutiveEven( int [] arr, int n,
int k) {
// Initializing counter to 0
int count = 0;
// Traversing the array
for ( int i = 0; i < n; i++) {
// If the current element is even
if (arr[i] % 2 == 0) {
// Increment the counter
count++;
// If the counter reaches atleast k
if (count >= k)
return true ;
}
else {
// Reset the counter
count = 0;
}
}
// If k consecutive even numbers are not present
return false ;
}
// Driver code
static void Main( string [] args) {
// Input array
int [] arr = { 1, 2, 4, 6, 7, 8 };
int n = arr.Length;
int k = 3;
// Function call
if (CheckConsecutiveEven(arr, n, k))
Console.WriteLine( "true" );
else
Console.WriteLine( "false" );
}
} |
function checkConsecutiveEven(arr, n, k) {
// Initializing counter to 0
let count = 0;
// Traversing the array
for (let i = 0; i < n; i++) {
// If the current element is even
if (arr[i] % 2 === 0) {
// Increment the counter
count++;
// If the counter reaches atleast k
if (count >= k) {
return true ;
}
} else {
// Reset the counter
count = 0;
}
}
// If k consecutive even numbers are not present
return false ;
} // Driver code let arr = [1, 2, 4, 6, 7, 8]; let n = arr.length; let k = 3; // Function call if (checkConsecutiveEven(arr, n, k)) {
console.log( "true" );
} else {
console.log( "false" );
} |
true
Time Complexity: O(N) where N is the size of array.
Auxiliary Space: O(1) as no extra space has been used.