Related Articles

# Find a subsequence with sum in range [(K+1)/2, K]

• Difficulty Level : Hard
• Last Updated : 14 Jul, 2021

Given an array arr[] consisting of N positive integers and a positive integer K, The task is to find a subsequence of an array arr[] whose sum of the elements is in the range [(K+1)/2, K]. If there is a subsequence then print the indices of the subsequence, otherwise print -1.

Note: There can be multiple answers possible for this problem, print any one of them.

Examples:

Input: arr[ ] = {6, 2, 20, 3, 5, 6}, K = 13
Output: 0 1 3
Explanation:
Sum of elements of the subsequence {6, 2, 3} is 11 that is in the range[(K+1)/2, K].

Input: arr[ ] = {20, 24, 33, 100}, K = 2
Output: -1

Approach: This problem can be solved by traversing over the array arr[ ]. Follow the steps below to solve this problem:

• Initialize a vector ans to store indices of the resultant subsequence and totalSum to store the sum of elements of the subsequence.
• Iterate in the range [0, N-1] using the variable i and perform the following steps:
• If arr[i] > K, continue traversing the elements of the array.
• If arr[i] is in the range [(K+1)/2, K], then return the index of the current element as the answer and terminate the loop.
• If arr[i] +totalSum is less than K, then add the current element to totalSum and add index i in vector ans.
• If the totalSum is not in the given range then print -1, Otherwise print the vector ans.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find a subsequence of the``// given array whose sum of the elements``// is in range [K+1/2, K]``void` `isSumOfSubSeqInRange(``int` `arr[], ``int` `n, ``int` `k)``{` `    ``// Vector to store the subsequence indices``    ``vector<``int``> ans;` `    ``// Variable to store the sum of subsequence``    ``int` `totalSum = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If the current element is``        ``// greater than K then move``        ``// forward``        ``if` `(arr[i] > k) {``            ``continue``;``        ``}` `        ``// If the current element is in``        ``// the given range``        ``if` `(arr[i] >= (k + 1) / 2) {``            ``ans.clear();``            ``ans.push_back(i);``            ``totalSum = arr[i];``            ``break``;``        ``}``        ``// If current element and totalSum``        ``// is less than K``        ``else` `if` `(arr[i] + totalSum <= k) {` `            ``totalSum += arr[i];``            ``ans.push_back(i);``        ``}``    ``}` `    ``// Checking if the totalSum is not``    ``// in the given range then print -1``    ``if` `(2 * totalSum < k) {``        ``cout << -1 << endl;``        ``return``;``    ``}` `    ``// Otherwise print the answer``    ``for` `(``int` `x : ans) {``        ``cout << x << ``" "``;``    ``}``    ``cout << endl;``}` `// Driver Code``int` `main()``{` `    ``// Given Input``    ``int` `arr[] = { 6, 2, 20, 3, 5, 6 };``    ``int` `N = 6;``    ``int` `K = 13;` `    ``// Function Call``    ``isSumOfSubSeqInRange(arr, N, K);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.Vector;` `public` `class` `GFG {` `    ``// Function to find a subsequence of the``    ``// given array whose sum of the elements``    ``// is in range [K+1/2, K]``    ``static` `void` `isSumOfSubSeqInRange(``int` `arr[], ``int` `n,``                                     ``int` `k)``    ``{` `        ``// Vector to store the subsequence indices``        ``Vector ans = ``new` `Vector<>();` `        ``// Variable to store the sum of subsequence``        ``int` `totalSum = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// If the current element is``            ``// greater than K then move``            ``// forward``            ``if` `(arr[i] > k) {``                ``continue``;``            ``}` `            ``// If the current element is in``            ``// the given range``            ``if` `(arr[i] >= (k + ``1``) / ``2``) {``                ``ans.clear();``                ``ans.add(i);``                ``totalSum = arr[i];``                ``break``;``            ``}``            ``// If current element and totalSum``            ``// is less than K``            ``else` `if` `(arr[i] + totalSum <= k) {` `                ``totalSum += arr[i];``                ``ans.add(i);``            ``}``        ``}` `        ``// Checking if the totalSum is not``        ``// in the given range then print -1``        ``if` `(``2` `* totalSum < k) {``            ``System.out.println(-``1``);``            ``return``;``        ``}` `        ``// Otherwise print the answer``        ``for` `(``int` `x : ans) {``            ``System.out.print(x + ``" "``);``        ``}``        ``System.out.println();``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given Input``        ``int` `arr[] = { ``6``, ``2``, ``20``, ``3``, ``5``, ``6` `};``        ``int` `N = ``6``;``        ``int` `K = ``13``;` `        ``// Function Call``        ``isSumOfSubSeqInRange(arr, N, K);``    ``}``}``// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach` `# Function to find a subsequence of the``# given array whose sum of the elements``# is in range [K+1/2, K]``def` `isSumOfSubSeqInRange(arr, n, k):``    ` `    ``# Vector to store the subsequence indices``    ``ans ``=` `[]` `    ``# Variable to store the sum of subsequence``    ``totalSum ``=` `0` `    ``for` `i ``in` `range``(n):``        ` `        ``# If the current element is``        ``# greater than K then move``        ``# forward``        ``if` `(arr[i] > k):``            ``continue` `        ``# If the current element is in``        ``# the given range``        ``if` `(arr[i] >``=` `(k ``+` `1``) ``/` `2``):``            ``ans.clear()``            ``ans.append(i)``            ``totalSum ``=` `arr[i]``            ``break` `        ``# If current element and totalSum``        ``# is less than K``        ``elif` `(arr[i] ``+` `totalSum <``=` `k):``            ``totalSum ``+``=` `arr[i]``            ``ans.append(i)` `    ``# Checking if the totalSum is not``    ``# in the given range then print -1``    ``if` `(``2` `*` `totalSum < k):``        ``print``(``-``1``)``        ``return` `    ``# Otherwise print the answer``    ``for` `x ``in` `ans:``        ``print``(x, end ``=` `" "``)``    ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given Input``    ``arr ``=` `[ ``6``, ``2``, ``20``, ``3``, ``5``, ``6` `]``    ``N ``=` `6``    ``K ``=` `13` `    ``# Function Call``    ``isSumOfSubSeqInRange(arr, N, K)` `# This code is contributed by bgangwar59`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `    ``// Function to find a subsequence of the``    ``// given array whose sum of the elements``    ``// is in range [K+1/2, K]``    ``static` `void` `isSumOfSubSeqInRange(``int``[] arr, ``int` `n,``                                     ``int` `k)``    ``{` `        ``// Vector to store the subsequence indices``        ``List<``int``> ans = ``new` `List<``int``>();` `        ``// Variable to store the sum of subsequence``        ``int` `totalSum = 0;` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// If the current element is``            ``// greater than K then move``            ``// forward``            ``if` `(arr[i] > k) {``                ``continue``;``            ``}` `            ``// If the current element is in``            ``// the given range``            ``if` `(arr[i] >= (k + 1) / 2) {``                ``ans.Clear();``                ``ans.Add(i);``                ``totalSum = arr[i];``                ``break``;``            ``}``          ` `            ``// If current element and totalSum``            ``// is less than K``            ``else` `if` `(arr[i] + totalSum <= k) {` `                ``totalSum += arr[i];``                ``ans.Add(i);``            ``}``        ``}` `        ``// Checking if the totalSum is not``        ``// in the given range then print -1``        ``if` `(2 * totalSum < k) {``            ``Console.WriteLine(-1);``            ``return``;``        ``}` `        ``// Otherwise print the answer``        ``foreach``(``int` `x ``in` `ans)``        ``{``            ``Console.Write(x + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}` `    ``// Driver code``    ``static` `public` `void` `Main ()``    ``{``      ` `        ``// Given Input``        ``int``[] arr = { 6, 2, 20, 3, 5, 6 };``        ``int` `N = 6;``        ``int` `K = 13;` `        ``// Function Call``        ``isSumOfSubSeqInRange(arr, N, K);``    ``}``}` `// This Code is contributed by ShubhamSingh10`

## Javascript

 ``
Output
`0 1 3 `

Time complexity: O(N)
Auxiliary space: O(N)

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.

My Personal Notes arrow_drop_up