Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if is possible to get given sum from a given set of elements

  • Difficulty Level : Easy
  • Last Updated : 16 Jun, 2021

Given array of numbers and a integer x. Find whether it is possible or not to get x by adding elements of given array, we may pick a single element multiple times. For a given array, there can be many sum queries.
Examples: 
 

Input : arr[] = { 2, 3}
         q[]  = {8, 7}
Output : Yes Yes
Explanation : 
2 + 2 + 2 + 2 = 8
2 + 2 + 3 = 7

 

The idea is to first sort the given array and then use the concept similar to Sieve of Eratosthenes. First take a large sized array ( which is maximum size of x). Initially keep zero in all it’s indexes. Make 1 at zero index ( we can get zero whatever the array is) . Now, traverse through the whole array and make all possible values as 1.
 

C++




// CPP program to find if we can get given
// sum using elements of given array.
#include <bits/stdc++.h>
using namespace std;
 
// maximum size of x
const int MAX = 1000;
 
// to check whether x is possible or not
int ispossible[MAX];
 
void check(int arr[], int N)
{
    ispossible[0] = 1;
    sort(arr, arr + N);
 
    for (int i = 0; i < N; ++i) {
        int val = arr[i];
 
        // if it is already possible
        if (ispossible[val])
            continue;
 
        // make 1 to all it's next elements
        for (int j = 0; j + val < MAX; ++j)
            if (ispossible[j])
                ispossible[j + val] = 1;
    }
}
 
// Driver code
int main()
{
    int arr[] = { 2, 3 };
    int N = sizeof(arr) / sizeof(arr[0]);
    check(arr, N);
    int x = 7;
    if (ispossible[x])
        cout << x << " is possible.";
    else
        cout << x << " is not possible.";
    return 0;
}
Java



// Java program to find if we can get given
// sum using elements of given array.
import java.util.*;
 
class solution
{
 
// maximum size of x
int MAX = 1000;
 
// to check whether x is possible or not
static int []ispossible = new int[1000];
static void check(int[] arr, int N)
{
     
    ispossible[0] = 1;
    Arrays.sort(arr);
 
    for (int i = 0; i < N; ++i) {
        int val = arr[i];
 
        // if it is already possible
        if (ispossible[val] == 1)
            continue;
 
        // make 1 to all it's next elements
        for (int j = 0; j + val < 1000; ++j)
            if (ispossible[j]== 1)
                ispossible[j + val] = 1;
    }
}
 
// Driver code
public static void main(String args[])
{
    int[] arr = { 2, 3 };
    int N = arr.length;
    check(arr, N);
    int x = 7;
    if (ispossible[x]== 1)
        System.out.println(x+" is possible.");
    else
        System.out.println(x+" is not possible.");
 
}
}
// This code is contributed by
// Shashank_Sharma
Python3



# Python3 program to find if we can get given
# sum using elements of the given array.
def check(arr, N):
 
    ispossible[0] = 1
    arr.sort()
 
    for i in range(0, N):
        val = arr[i]
 
        # if it is already possible
        if ispossible[val]:
            continue
 
        # make 1 to all it's next elements
        for j in range(0, MAX - val):
            if ispossible[j]:
                ispossible[j + val] = 1
 
# Driver code
if __name__ == "__main__":
 
    arr = [2, 3]
    N = len(arr)
     
    # maximum size of x
    MAX = 1000
     
    # to check whether x is possible or not
    ispossible = [0] * MAX
 
    check(arr, N)
    x = 7
     
    if ispossible[x]:
        print(x, "is possible.")
    else:
        print(x, "is not possible.")
     
# This code is contributed by
# Rituraj Jain
C#



// C# program to find if we can get given
// sum using elements of given array.
using System;
 
class GFG
{
     
// to check whether x is possible or not
static int []ispossible = new int[1000];
static void check(int[] arr, int N)
{
     
    ispossible[0] = 1;
    Array.Sort(arr);
 
    for (int i = 0; i < N; ++i)
    {
        int val = arr[i];
 
        // if it is already possible
        if (ispossible[val] == 1)
            continue;
 
        // make 1 to all it's next elements
        for (int j = 0; j + val < 1000; ++j)
            if (ispossible[j] == 1)
                ispossible[j + val] = 1;
    }
}
 
// Driver code
public static void Main()
{
    int[] arr = { 2, 3 };
    int N = arr.Length;
    check(arr, N);
    int x = 7;
    if (ispossible[x]== 1)
        Console.WriteLine(x + " is possible.");
    else
        Console.WriteLine(x + " is not possible.");
}
}
 
// This code is contributed by
// Akanksha Rai
PHP



<?php
// PHP program to find if we can get given
// sum using elements of given array.
 
// maximum size of x
$MAX = 1000;
 
// to check whether x is possible or not
$ispossible[$MAX] = array();
 
function check($arr, $N)
{
    global $MAX;
    $ispossible[0] = 1;
    sort($arr, 0);
 
    for ($i = 0; $i < $N; ++$i)
    {
        $val = $arr[$i];
 
        // if it is already possible
        if ($ispossible[$val])
            continue;
 
        // make 1 to all it's next elements
        for ($j = 0; $j + $val < $MAX; ++$j)
            if ($ispossible[$j])
                $ispossible[$j + $val] = 1;
    }
}
 
// Driver code
$arr = array( 2, 3 );
$N = sizeof($arr);
check($arr, $N);
$x = 7;
if (ispossible[$x])
    echo $x . " is possible.";
else
    echo $x . " is not possible.";
 
// This code is contributed
// by Akanksha Rai
?>
Javascript



<script>
// Javascript program to find if we can get given
// sum using elements of given array.
 
// maximum size of x
let MAX = 1000;
 
// to check whether x is possible or not
let ispossible = new Array(MAX);
 
function check(arr, N)
{
    ispossible[0] = 1;
    arr.sort();
 
    for (let i = 0; i < N; ++i)
    {
        val = arr[i];
 
        // if it is already possible
        if (ispossible[val])
            continue;
 
        // make 1 to all it's next elements
        for (let j = 0; j + val < MAX; ++j)
            if (ispossible[j])
                ispossible[j + val] = 1;
    }
}
 
// Driver code
let arr = new Array( 2, 3 );
let N = arr.length;
check(arr, N);
let x = 7;
if (ispossible[x])
    document.write(x + " is possible.");
else
    document.write(x + " is not possible.");
 
// This code is contributed
// by _sauraahb_jaiswal
</script>
Output: 
 
7 is possible.
 

My Personal Notes
arrow_drop_up
Previous
Python | Plotting charts in excel sheet using openpyxl module | Set 3
Next

Process API Updates in Java
Recommended Articles
Page :
Flip minimum signs of array elements to get minimum sum of positive elements possible
27, Jun 19
Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
21, Aug 20
Sum of array elements possible by appending arr[i] / K to the end of the array K times for array elements divisible by K
19, Apr 21
Check if its possible to make sum of the array odd with given Operations
10, Apr 20
Check if it is possible to split given Array into K odd-sum subsets
19, Jun 20
Check if it is possible to sort an array with conditional swapping of elements at distance K
27, Apr 20
Maximize Sum possible by subtracting same value from all elements of a Subarray of the given Array
15, Aug 20
Maximum modified Array sum possible by choosing elements as per the given conditions
19, Aug 20
Minimum possible sum of array elements after performing the given operation
19, Feb 19
Minimum possible sum of array elements after performing the given operation
14, Apr 20
Possible number of Rectangle and Squares with the given set of elements
11, Oct 18
Minimum LCM and GCD possible among all possible sub-arrays
25, Feb 19
Check if it possible to partition in k subarrays with equal sum
05, Apr 18
Check if sum of arr[i] / j for all possible pairs (i, j) in an array is 0 or not
19, Apr 21
Check if mapping is possible to make sum of first array larger than second array
17, Jun 21
Check if it is possible to construct an Array of size N having sum as S and XOR value as X
20, Aug 21
Check if possible to make Array sum equal to Array product by replacing exactly one element
28, Aug 21
Longest remaining array of distinct elements possible after repeated removal of maximum and minimum elements of triplets
06, Aug 21
Smallest possible integer to be added to N-1 elements in array A such that elements of array B are present in A
21, Sep 21
Check if all array elements can be made divisible by K by replacing array elements with sum of pairs
17, Feb 21
Sum of length of two smallest subsets possible from a given array with sum at least K
10, Mar 21
Sum of bitwise OR of all possible subsets of given set
27, Apr 18
Sum of bitwise AND of all possible subsets of given set
16, May 18
Largest value of K that a set of all possible subset-sum values of given Array contains numbers [0, K]
15, Oct 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
pawan_asipu
@pawan_asipu
Vote for difficulty
Current difficulty :
Easy





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

Start Your Coding Journey Now!