Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if sum of exactly K elements of the Array can be odd or not

  • Difficulty Level : Hard
  • Last Updated : 13 May, 2021

Given an array, arr[] and an integer K. Check whether it is possible to get an odd sum by choosing exactly K elements of the array.

Examples: 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 2, 3}, K = 2 
Output: Possible 
Explanation: 
{2, 3} ⇾ 2 + 3 = 5



Input: arr[] = {2, 2, 4, 2}, K = 4 
Output: Not Possible 
Explanation: {2, 2, 4, 2} ⇾ 2 + 2 + 4 + 2 = 10 
No other possibilities as K is equal to the size of array 

Approach: On observing, it is found that there are three cases.

  • First, count the number of odd and even elements.
  • Case 1: When all elements are even. Then, sum will always be even irrespective of the value of K as even + even = even.
  • Case 2: When all elements are odd. Then, the sum will depend only on the value of K. 
    If K is odd, then the sum will be odd as every odd pair makes the sum even and in the end, one odd element makes the sum odd as even + odd = odd. 
    If K is even, then every odd element get paired and become even, therefore the sum becomes even.
  • Case 3: When K <= N, then sum depends only on the number of odd elements. If the number of odd elements is even, then the sum will be even as odd + odd = even, which implies every odd pair will become even. And if we add even elements to the sum, the sum will remain even as even + even = even.

Below is the implementation of the above approach: 

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function returns true if
// it is possible to have
// odd sum
bool isPossible(int arr[],
                int N, int K)
{
    int oddCount = 0, evenCount = 0;
 
    // counting number of odd
    // and even elements
    for (int i = 0; i < N; i++) {
        if (arr[i] % 2 == 0)
            evenCount++;
        else
            oddCount++;
    }
    if (evenCount == N
        || (oddCount == N && K % 2 == 0)
        || (K == N && oddCount % 2 == 0))
        return false;
    else
        return true;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 8 };
    int K = 5;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    if (isPossible(arr, N, K))
        cout << "Possible";
    else
        cout << "Not Possible";
 
    return 0;
}
Java



// Java implementation of the above approach
class GFG{
 
// Function returns true if
// it is possible to have
// odd sum
static boolean isPossible(int arr[],
                          int N, int K)
{
    int oddCount = 0, evenCount = 0;
     
    // Counting number of odd
    // and even elements
    for(int i = 0; i < N; i++)
    {
       if (arr[i] % 2 == 0)
       {
           evenCount++;
       }
       else
       {
           oddCount++;
       }
    }
    if (evenCount == N ||
       (oddCount == N && K % 2 == 0) ||
       (K == N && oddCount % 2 == 0))
    {
        return false;
    }
    else
    {
        return true;
    }
}
     
// Driver code
public static void main (String[] args)
{
    int arr[] = { 1, 2, 3, 4, 5, 8 };
    int K = 5;
    int N = arr.length;
     
    if (isPossible(arr, N, K))
    {
        System.out.println("Possible");
    }
    else
    {
        System.out.println("Not Possible");
    }
}
}
 
// This code is contributed by AnkitRai01
Python3



# Python3 implementation of the above approach
 
# Function returns true if it
# is possible to have odd sum
def isPossible(arr, N, K):
     
    oddCount = 0
    evenCount = 0
 
    # Counting number of odd
    # and even elements
    for i in range(N):
        if (arr[i] % 2 == 0):
            evenCount += 1
        else:
            oddCount += 1
             
    if (evenCount == N or
       (oddCount == N and K % 2 == 0) or
       (K == N and oddCount % 2 == 0)):
        return False
    else:
        return True
 
# Driver code
if __name__ == '__main__':
     
    arr = [ 1, 2, 3, 4, 5, 8 ]
    K = 5
    N = len(arr)
 
    if (isPossible(arr, N, K)):
        print("Possible")
    else:
        print("Not Possible")
 
# This code is contributed by mohit kumar 29   
C#



// C# implementation of the above approach
using System;
 
class GFG{
 
// Function returns true if
// it is possible to have
// odd sum
static bool isPossible(int []arr,
                       int N, int K)
{
    int oddCount = 0, evenCount = 0;
 
    // Counting number of odd
    // and even elements
    for(int i = 0; i < N; i++)
    {
       if (arr[i] % 2 == 0)
       {
           evenCount++;
       }
       else
       {
           oddCount++;
       }
    }
    if (evenCount == N ||
       (oddCount == N && K % 2 == 0) ||
       (K == N && oddCount % 2 == 0))
    {
        return false;
    }
    else
    {
        return true;
    }
}
 
// Driver code
public static void Main (string[] args)
{
    int []arr = { 1, 2, 3, 4, 5, 8 };
    int K = 5;
    int N = arr.Length;
 
    if (isPossible(arr, N, K))
    {
        Console.WriteLine("Possible");
    }
    else
    {
        Console.WriteLine("Not Possible");
    }
}
}
 
// This code is contributed by AnkitRai01
Javascript



<script>
// Javascript implementation of the above approach
 
// Function returns true if
// it is possible to have
// odd sum
function isPossible(arr, N, K)
{
    let oddCount = 0, evenCount = 0;
      
    // Counting number of odd
    // and even elements
    for(let i = 0; i < N; i++)
    {
       if (arr[i] % 2 == 0)
       {
           evenCount++;
       }
       else
       {
           oddCount++;
       }
    }
    if (evenCount == N ||
       (oddCount == N && K % 2 == 0) ||
       (K == N && oddCount % 2 == 0))
    {
        return false;
    }
    else
    {
        return true;
    }
}
 
  // Driver Code
     
    let arr = [ 1, 2, 3, 4, 5, 8 ];
    let K = 5;
    let N = arr.length;
      
    if (isPossible(arr, N, K))
    {
        document.write("Possible");
    }
    else
    {
        document.write("Not Possible");
    }
 
// This code is contributed by target_2.
</script>
Output
Possible
Time complexity: O(N)



My Personal Notes
arrow_drop_up
Previous
Difference between Amazon S3 and MediaFire
Next

Type Assertions in Golang
Recommended Articles
Page :
Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays
16, Dec 20
Check if an array can be sorted by rearranging odd and even-indexed elements or not
06, Apr 21
Queries to check whether all the elements can be made positive by flipping signs exactly K times
29, May 19
Check if all array elements can be made divisible by K by replacing array elements with sum of pairs
17, Feb 21
Maximum array sum that can be obtained after exactly k changes
26, Mar 19
Count numbers with exactly K non-zero digits and distinct odd digit sum
30, Apr 20
Check if possible to make Array sum equal to Array product by replacing exactly one element
28, Aug 21
Find the Array Permutation having sum of elements at odd indices greater than sum of elements at even indices
07, Jul 21
Construct an Array of size N in which sum of odd elements is equal to sum of even elements
22, Apr 20
Minimum increments to make all array elements equal with sum same as the given array after exactly one removal
04, Dec 20
Find the longest sub-array having exactly k odd numbers
26, Jan 18
Check if X can be reduced to 0 in exactly T moves by substracting D or 1 from it
13, Aug 21
Check if a number can be expressed as a product of exactly K prime divisors
22, Apr 20
Maximize sum of odd-indexed array elements by repeatedly selecting at most 2*M array elements from the beginning
23, May 21
Check whether a number has exactly three distinct factors or not
09, Oct 17
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Find the nearest odd and even perfect squares of odd and even array elements respectively
05, Mar 21
Check if rearranging Array elements can form a Palindrome or not
17, Aug 21
Maximize the sum of differences of consecutive elements after removing exactly K elements
02, Jan 20
Minimize the sum of differences of consecutive elements after removing exactly K elements
06, Jan 20
Check if an array can be split into 3 subsequences of equal sum or not
27, Aug 20
Check if Array elements can be maximized upto M by adding all elements from another array
02, Jul 20
Check if sum of the given array can be reduced to 0 by reducing array elements by K
03, Jan 21
Check if K distinct array elements form an odd sum
20, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
babayaga18
@babayaga18
Vote for difficulty
Current difficulty :
Hard





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