Check if a subsequence of length K with odd sum exists
Last Updated :
12 Feb, 2024
Given an array arr[] of integers, the task is to check if it is possible to obtain a subsequence of K elements from the array such that their sum is odd. If it is possible, print Yes. Otherwise, print No.
Examples:
Input: arr[] = { 2, 5, 6, 7, 4 }, K = 3
Output: Yes
Explanation:
Subsequences {2, 5, 6}, {2, 6, 7} and {2, 7, 4} have odd sum
Input: arr[] = { 1, 5, 7, 11 }, K = 4
Output: No
Explanation:
Only subsequence of length 4 is {1, 5, 7, 11} which has even sum (24). Hence no such subsequence exists.
Naive Approach:
The simplest method to solve the problem is to generate all subsequences of length K and check if any of these subsequences have an odd sum. The time complexity for such an approach will be exponential and thus inefficient.
C++
#include <bits/stdc++.h>
using namespace std;
bool isSubsequenceOddSumPossible( const std::vector< int >& arr, int K, int index, int currentSum) {
if (K == 0) return (currentSum % 2 != 0);
if (index == arr.size()) return false ;
bool includeCurrent = isSubsequenceOddSumPossible(arr, K - 1, index + 1, currentSum + arr[index]);
bool excludeCurrent = isSubsequenceOddSumPossible(arr, K, index + 1, currentSum);
return includeCurrent || excludeCurrent;
}
int main() {
vector< int > arr = {2, 3, 5, 7, 4};
int K = 1;
if (isSubsequenceOddSumPossible(arr, K, 0, 0)) cout<< "Yes" ;
else cout<< "No" ;
return 0;
}
|
Java
import java.util.*;
public class GFG {
static boolean isSubsequenceOddSumPossible(List<Integer> arr, int K, int index, int currentSum) {
if (K == 0 ) return (currentSum % 2 != 0 );
if (index == arr.size()) return false ;
boolean includeCurrent = isSubsequenceOddSumPossible(arr, K - 1 , index + 1 , currentSum + arr.get(index));
boolean excludeCurrent = isSubsequenceOddSumPossible(arr, K, index + 1 , currentSum);
return includeCurrent || excludeCurrent;
}
public static void main(String[] args) {
List<Integer> arr = Arrays.asList( 2 , 3 , 5 , 7 , 4 );
int K = 1 ;
if (isSubsequenceOddSumPossible(arr, K, 0 , 0 )) {
System.out.println( "Yes" );
} else {
System.out.println( "No" );
}
}
}
|
Python3
def isSubsequenceOddSumPossible(arr, K, index, currentSum):
if K = = 0 :
return currentSum % 2 ! = 0
if index = = len (arr):
return False
includeCurrent = isSubsequenceOddSumPossible(arr, K - 1 , index + 1 , currentSum + arr[index])
excludeCurrent = isSubsequenceOddSumPossible(arr, K, index + 1 , currentSum)
return includeCurrent or excludeCurrent
arr = [ 2 , 3 , 5 , 7 , 4 ]
K = 1
if isSubsequenceOddSumPossible(arr, K, 0 , 0 ):
print ( "Yes" )
else :
print ( "No" )
|
C#
using System;
using System.Collections.Generic;
class Program
{
static bool IsSubsequenceOddSumPossible(List< int > arr, int K, int index, int currentSum)
{
if (K == 0) return (currentSum % 2 != 0);
if (index == arr.Count) return false ;
bool includeCurrent = IsSubsequenceOddSumPossible(arr, K - 1, index + 1, currentSum + arr[index]);
bool excludeCurrent = IsSubsequenceOddSumPossible(arr, K, index + 1, currentSum);
return includeCurrent || excludeCurrent;
}
static void Main()
{
List< int > arr = new List< int > { 2, 3, 5, 7, 4 };
int K = 1;
if (IsSubsequenceOddSumPossible(arr, K, 0, 0)) Console.WriteLine( "Yes" );
else Console.WriteLine( "No" );
}
}
|
Javascript
function isSubsequenceOddSumPossible(arr, K, index, currentSum) {
if (K === 0) return currentSum % 2 !== 0;
if (index === arr.length) return false ;
const includeCurrent = isSubsequenceOddSumPossible(arr, K - 1,
index + 1, currentSum + arr[index]);
const excludeCurrent = isSubsequenceOddSumPossible(arr, K, index + 1, currentSum);
return includeCurrent || excludeCurrent;
}
const arr = [2, 3, 5, 7, 4];
const K = 1;
if (isSubsequenceOddSumPossible(arr, K, 0, 0)) {
console.log( "Yes" );
} else {
console.log( "No" );
}
|
Time Complexity: O(2^N)
Auxiliary Space: O(N)
Efficient Approach:
The efficient method to approach the above problem will be to count the number of odd elements in the array and then, simply checking for all the edge cases when it will not be possible to find a subsequence with odd sum.
The edge cases to be considered when such a subsequence cannot be generated are as follows:
- If there are no odd elements in the array, any subsequence will contain only even elements and an even sum will be obtained. So, it is not possible to generate a subsequence with odd sum.
- If K is even and there are no even elements present in the array, a subsequence with odd sum is not possible.
For all other cases, it will be possible to generate a subsequence with an odd sum.
Below is the implementation of above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool isSubseqPossible( int arr[], int N, int K)
{
int i;
int odd = 0, even = 0;
for (i = 0; i < N; i++) {
if (arr[i] % 2 == 1)
odd++;
else
even++;
}
if (odd == 0
|| (even == 0 && K % 2 == 0))
return false ;
return true ;
}
int main()
{
int arr[] = { 2, 3, 5, 7, 4 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 3;
cout << (isSubseqPossible(arr, N, K)
? "Yes"
: "No" );
return 0;
}
|
Java
class GFG{
static boolean isSubseqPossible( int []arr,
int N, int K)
{
int i;
int odd = 0 , even = 0 ;
for (i = 0 ; i < N; i++)
{
if (arr[i] % 2 == 1 )
odd++;
else
even++;
}
if (odd == 0 || (even == 0 && K % 2 == 0 ))
return false ;
return true ;
}
public static void main(String args[])
{
int []arr = { 2 , 3 , 5 , 7 , 4 };
int N = arr.length;
int K = 3 ;
System.out.print(isSubseqPossible(arr, N, K) ?
"Yes" : "No" );
}
}
|
Python3
def isSubseqPossible(arr, N, K):
i = 0
odd = 0
even = 0
for i in range (N):
if (arr[i] % 2 = = 1 ):
odd + = 1
else :
even + = 1
if (odd = = 0 or (even = = 0 and K % 2 = = 0 )):
return False
return True
if __name__ = = '__main__' :
arr = [ 2 , 3 , 5 , 7 , 4 ]
N = len (arr)
K = 3
print ( "Yes" if isSubseqPossible(arr, N, K) else "No" )
|
C#
using System;
class GFG{
static bool isSubseqPossible( int []arr,
int N, int K)
{
int i;
int odd = 0, even = 0;
for (i = 0; i < N; i++)
{
if (arr[i] % 2 == 1)
odd++;
else
even++;
}
if (odd == 0 || (even == 0 && K % 2 == 0))
return false ;
return true ;
}
public static void Main()
{
int []arr = { 2, 3, 5, 7, 4 };
int N = arr.Length;
int K = 3;
Console.Write(isSubseqPossible(arr, N, K) ?
"Yes" : "No" );
}
}
|
Javascript
<script>
function isSubseqPossible(arr, N, K)
{
let i;
let odd = 0, even = 0;
for (i = 0; i < N; i++)
{
if (arr[i] % 2 == 1)
odd++;
else
even++;
}
if (odd == 0 || (even == 0 && K % 2 == 0))
return false ;
return true ;
}
let arr = [ 2, 3, 5, 7, 4 ];
let N = arr.length;
let K = 3;
document.write(isSubseqPossible(arr, N, K) ?
"Yes" : "No" );
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Approach#2: Using itertools combinations()
The approach used in this code is to generate all possible subsequences of length K using the itertools.combinations() function and check if any subsequence has an odd sum.
Algorithm
1. Use the itertools.combinations() function to generate all possible subsequences of length K from the input array.
2. Loop through each subsequence and check if its sum is odd using the sum() function and the modulo operator.
3. If a subsequence with an odd sum is found, return “Yes”.
4. If no subsequence with an odd sum is found, return “No”.
C++
#include <iostream>
#include <vector>
using namespace std;
string subsequenceWithOddSum(vector< int >& arr, int K) {
int n = arr.size();
for ( int mask = 0; mask < (1 << n); mask++) {
int sum = 0;
int count = 0;
for ( int i = 0; i < n; i++) {
if ((mask & (1 << i)) != 0) {
sum += arr[i];
count++;
}
}
if (count == K && sum % 2 == 1) {
return "Yes" ;
}
}
return "No" ;
}
int main() {
vector< int > arr = {1, 5, 7, 11};
int K = 4;
cout << subsequenceWithOddSum(arr, K) << endl;
return 0;
}
|
Java
import java.util.*;
public class SubsequenceWithOddSum {
public static String subsequenceWithOddSum( int [] arr, int K) {
int n = arr.length;
for ( int mask = 0 ; mask < ( 1 << n); mask++) {
int sum = 0 ;
int count = 0 ;
for ( int i = 0 ; i < n; i++) {
if ((mask & ( 1 << i)) != 0 ) {
sum += arr[i];
count++;
}
}
if (count == K && sum % 2 == 1 ) {
return "Yes" ;
}
}
return "No" ;
}
public static void main(String[] args) {
int [] arr = { 1 , 5 , 7 , 11 };
int K = 4 ;
System.out.println(subsequenceWithOddSum(arr, K));
}
}
|
Python3
import itertools
def subsequence_with_odd_sum(arr, K):
for sub in itertools.combinations(arr, K):
if sum (sub) % 2 = = 1 :
return "Yes"
return "No"
arr = [ 1 , 5 , 7 , 11 ]
K = 4
print (subsequence_with_odd_sum(arr, K))
|
C#
using System;
using System.Collections.Generic;
class Program
{
static string SubsequenceWithOddSum(List< int > arr, int K)
{
int n = arr.Count;
for ( int mask = 0; mask < (1 << n); mask++)
{
int sum = 0;
int count = 0;
for ( int i = 0; i < n; i++)
{
if ((mask & (1 << i)) != 0)
{
sum += arr[i];
count++;
}
}
if (count == K && sum % 2 == 1)
{
return "Yes" ;
}
}
return "No" ;
}
static void Main()
{
List< int > arr = new List< int > { 1, 5, 7, 11 };
int K = 4;
Console.WriteLine(SubsequenceWithOddSum(arr, K));
}
}
|
Javascript
function subsequenceWithOddSum(arr, K) {
const n = arr.length;
for (let mask = 0; mask < (1 << n); mask++) {
let sum = 0;
let count = 0;
for (let i = 0; i < n; i++) {
if ((mask & (1 << i)) !== 0) {
sum += arr[i];
count++;
}
}
if (count === K && sum % 2 === 1) {
return "Yes" ;
}
}
return "No" ;
}
const arr = [1, 5, 7, 11];
const K = 4;
console.log(subsequenceWithOddSum(arr, K));
|
Time Complexity: O(n^K), where n is the length of the input array. This is because the algorithm generates all possible subsequences of length K, which can be as many as n^K.
Space Complexity: O(K), which is the maximum size of the subsequence stored at any given time. This is because the algorithm only stores one subsequence at a time while checking its sum.
Share your thoughts in the comments
Please Login to comment...