Skip to content
Related Articles

Related Articles

Check if a subsequence of length K with odd sum exists
  • Last Updated : 07 May, 2021

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




// C++ program to check if a
// subsequence of length K
// with odd sum exists in the
// given array
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if any required
// subsequence exists or not
bool isSubseqPossible(int arr[], int N, int K)
{
    int i;
    // Store count of odd and
    // even elements in the array
    int odd = 0, even = 0;
 
    // Calculate the count of
    // odd and even elements
    for (i = 0; i < N; i++) {
        if (arr[i] % 2 == 1)
            odd++;
        else
            even++;
    }
 
    // If no odd elements exists
    // or no even elements exists
    // when K is even
    if (odd == 0
|| (even == 0 && K % 2 == 0))
 
        // Subsequence is not possible
        return false;
 
    // Possible otherwise
    return true;
}
 
// Driver Code
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



// Java program to check if a
// subsequence of length K
// with odd sum exists in the
// given array
class GFG{
 
// Function to check if any required
// subsequence exists or not
static boolean isSubseqPossible(int []arr,
                             int N, int K)
{
    int i;
     
    // Store count of odd and
    // even elements in the array
    int odd = 0, even = 0;
 
    // Calculate the count of
    // odd and even elements
    for (i = 0; i < N; i++)
    {
        if (arr[i] % 2 == 1)
            odd++;
        else
            even++;
    }
 
    // If no odd elements exists
    // or no even elements exists
    // when K is even
    if (odd == 0 || (even == 0 && K % 2 == 0))
 
        // Subsequence is not possible
        return false;
 
    // Possible otherwise
    return true;
}
 
// Driver Code
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");
}
}
 
// This code is contributed by Code_Mech
Python3



# Python3 program to check if a subsequence
# of length K with odd sum exists in the
# given array
 
# Function to check if any required
# subsequence exists or not
def isSubseqPossible(arr, N, K):
 
    i = 0
     
    # Store count of odd and
    # even elements in the array
    odd = 0
    even = 0
 
    # Calculate the count of
    # odd and even elements
    for i in range(N):
        if (arr[i] % 2 == 1):
            odd += 1
        else:
            even += 1
 
    # If no odd element exists or no
    # even element exists when K even
    if (odd == 0 or (even == 0 and K % 2 == 0)):
 
        # Subsequence is not possible
        return False
 
    # Otherwise possible
    return True
 
# Driver code
if __name__ == '__main__':
 
    arr = [ 2, 3, 5, 7, 4 ]
    N = len(arr)
    K = 3
 
    print("Yes" if isSubseqPossible(arr, N, K) else "No")
 
# This code is contributed by himanshu77
C#



// C# program to check if a
// subsequence of length K
// with odd sum exists in the
// given array
using System;
class GFG{
 
// Function to check if any required
// subsequence exists or not
static bool isSubseqPossible(int []arr,
                             int N, int K)
{
    int i;
     
    // Store count of odd and
    // even elements in the array
    int odd = 0, even = 0;
 
    // Calculate the count of
    // odd and even elements
    for (i = 0; i < N; i++)
    {
        if (arr[i] % 2 == 1)
            odd++;
        else
            even++;
    }
 
    // If no odd elements exists
    // or no even elements exists
    // when K is even
    if (odd == 0 || (even == 0 && K % 2 == 0))
 
        // Subsequence is not possible
        return false;
 
    // Possible otherwise
    return true;
}
 
// Driver Code
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");
}
}
 
// This code is contributed by Code_Mech
Javascript



<script>
 
// JavaScript program to check if a
// subsequence of length K
// with odd sum exists in the
// given array
 
// Function to check if any required
// subsequence exists or not
function isSubseqPossible(arr, N, K)
{
    let i;
       
    // Store count of odd and
    // even elements in the array
    let odd = 0, even = 0;
   
    // Calculate the count of
    // odd and even elements
    for (i = 0; i < N; i++)
    {
        if (arr[i] % 2 == 1)
            odd++;
        else
            even++;
    }
   
    // If no odd elements exists
    // or no even elements exists
    // when K is even
    if (odd == 0 || (even == 0 && K % 2 == 0))
   
        // Subsequence is not possible
        return false;
   
    // Possible otherwise
    return true;
}
   
     
// Driver Code
 
    let arr = [ 2, 3, 5, 7, 4 ];
    let N = arr.length;
    let K = 3;
    document.write(isSubseqPossible(arr, N, K) ?
                                     "Yes" : "No");
           
</script>
Output: 
Yes
 
Time Complexity: O(N) 
Auxiliary Space: O(1)
 
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.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA
My Personal Notes
arrow_drop_up
Previous
Working of Quantum Machine Learning
Next

Check if the number is balanced
Recommended Articles
Page :
Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays
16, Dec 20
Check whether a subsequence exists with sum equal to k if arr[i]> 2*arr[i-1]
04, Jun 19
Maximum length subsequence such that adjacent elements in the subsequence have a common factor
11, Feb 19
Check if a non-contiguous subsequence same as the given subarray exists or not
02, Dec 20
Check if a subarray of length K with sum equal to factorial of a number exists or not
22, Sep 20
Length of longest subsequence whose XOR value is odd
15, Jul 20
Minimum flips of odd indexed elements from odd length subarrays to make two given arrays equal
02, Dec 20
Length of longest Palindromic Subsequence of even length with no two adjacent characters same
04, Feb 20
Check if a cycle of length 3 exists or not in a graph that satisfy a given condition
04, Sep 19
Maximize difference between sum of even and odd-indexed elements of a subsequence
17, Jan 21
Subsequence with maximum odd sum
22, Apr 17
Check if an array has some palindromic subsequence of length at least 3
27, Apr 20
Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
12, Jul 19
Longest Increasing Subsequence using Longest Common Subsequence Algorithm
14, Oct 19
Find the equal pairs of subsequence of S and subsequence of T
22, Nov 19
Count maximum occurrence of subsequence in string such that indices in subsequence is in A.P.
09, Apr 20
Maximum Sum Subsequence of length k
23, May 19
Maximum length Subsequence with alternating sign and maximum Sum
22, Apr 20
Maximize product of digit sum of consecutive pairs in a subsequence of length K
05, May 20
Length of Smallest Subsequence such that sum of elements is greater than equal to K
26, Feb 20
Maximum even sum subsequence of length K
25, Oct 20
Length of longest subsequence having sum of digits of each element as a Composite Number
19, Oct 20
Check if a subarray exists with sum greater than the given Array
16, Apr 20
Check if string can be rearranged so that every Odd length Substring is Palindrome
04, Sep 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
guptakajal15
@guptakajal15
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox