Check if sum of exactly K elements of the Array can be odd or not
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:
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++
#include <bits/stdc++.h>
using namespace std;
bool isPossible( int arr[],
int N, int K)
{
int oddCount = 0, evenCount = 0;
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 ;
}
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
class GFG{
static boolean isPossible( int arr[],
int N, int K)
{
int oddCount = 0 , evenCount = 0 ;
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 ;
}
}
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" );
}
}
}
|
Python3
def isPossible(arr, N, K):
oddCount = 0
evenCount = 0
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
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" )
|
C#
using System;
class GFG{
static bool isPossible( int []arr,
int N, int K)
{
int oddCount = 0, evenCount = 0;
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 ;
}
}
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" );
}
}
}
|
Javascript
<script>
function isPossible(arr, N, K)
{
let oddCount = 0, evenCount = 0;
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 ;
}
}
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" );
}
</script>
|
Time complexity: O(N), where N represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.
Method 2:Using Recursion
Approach:
In this approach we create a function isOddSumPossible() function first tests the base cases when k is zero or the array size is zero, returning true if the current sum is odd and false otherwise. If k is negative, the method returns false since an odd sum is not possible.
If the base cases fail, the function performs two recursive calls: one that includes the current element in the total and reduces the number of elements to pick by one, and another that excludes the current element while keeping the number of elements to choose constant. The function returns true if either of these recursive calls returns true; otherwise, it returns false.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
bool isOddSumPossible( int arr[], int n, int k, int sum) {
if (k == 0) {
return (sum % 2 != 0);
}
if (n == 0 || k < 0) {
return false ;
}
return isOddSumPossible(arr, n - 1, k - 1, sum + arr[n - 1]) ||
isOddSumPossible(arr, n - 1, k, sum);
}
int main() {
int arr[]={1,2,3,4,5,8};
int K = 5;
int N = sizeof (arr) / sizeof (arr[0]);
if (isOddSumPossible(arr, N, K, 0)) {
cout << "Possible" ;
} else {
cout << "Not Possible" ;
}
return 0;
}
|
Java
import java.util.Arrays;
public class GFG {
static boolean isOddSumPossible( int [] arr, int n, int k, int sum) {
if (k == 0 ) {
return (sum % 2 != 0 );
}
if (n == 0 || k < 0 ) {
return false ;
}
return isOddSumPossible(arr, n - 1 , k - 1 , sum + arr[n - 1 ]) ||
isOddSumPossible(arr, n - 1 , k, sum);
}
public static void main(String[] args) {
int [] arr = { 1 , 2 , 3 , 4 , 5 , 8 };
int K = 5 ;
int N = arr.length;
if (isOddSumPossible(arr, N, K, 0 )) {
System.out.println( "Possible" );
} else {
System.out.println( "Not Possible" );
}
}
}
|
Python
def is_odd_sum_possible_optimized(arr, n, k, memo):
if k = = 0 :
return sum (arr) % 2 ! = 0
if n = = 0 or k < 0 :
return False
if memo[n][k] ! = - 1 :
return memo[n][k]
include = is_odd_sum_possible_optimized(arr, n - 1 , k - 1 , memo)
exclude = is_odd_sum_possible_optimized(arr, n - 1 , k, memo)
memo[n][k] = include or exclude
return memo[n][k]
def main():
arr = [ 1 , 2 , 3 , 4 , 5 , 8 ]
K = 5
N = len (arr)
memo = [[ - 1 ] * (K + 1 ) for _ in range (N + 1 )]
if is_odd_sum_possible_optimized(arr, N, K, memo):
print ( "Possible" )
else :
print ( "Not Possible" )
if __name__ = = "__main__" :
main()
|
C#
using System;
public class GFG
{
public static bool IsOddSumPossible( int [] arr, int n, int k, int sum)
{
if (k == 0)
{
return (sum % 2 != 0);
}
if (n == 0 || k < 0)
{
return false ;
}
return IsOddSumPossible(arr, n - 1, k - 1, sum + arr[n - 1]) ||
IsOddSumPossible(arr, n - 1, k, sum);
}
public static void Main( string [] args)
{
int [] arr = { 1, 2, 3, 4, 5, 8 };
int K = 5;
int N = arr.Length;
if (IsOddSumPossible(arr, N, K, 0))
{
Console.WriteLine( "Possible" );
}
else
{
Console.WriteLine( "Not Possible" );
}
}
}
|
Javascript
function isOddSumPossible(arr, n, k, sum) {
if (k === 0) {
return sum % 2 !== 0;
}
if (n === 0 || k < 0) {
return false ;
}
return isOddSumPossible(arr, n - 1, k - 1, sum + arr[n - 1]) ||
isOddSumPossible(arr, n - 1, k, sum);
}
const arr = [1, 2, 3, 4, 5, 8];
const K = 5;
const N = arr.length;
if (isOddSumPossible(arr, N, K, 0)) {
console.log( "Possible" );
} else {
console.log( "Not Possible" );
}
|
Time complexity: O(2^n), as there are 2^n possible subsets of the input array.
Auxiliary Space: O(n),as the recursion stack can have at most n function calls.
Last Updated :
14 Oct, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...