Sunday, October 6, 2024
Google search engine
HomeData Modelling & AICheck if sum Y can be obtained from the Array by the...

Check if sum Y can be obtained from the Array by the given operations

Given an array of integers arr[] and two integers X and Y, the task is to check if it is possible to obtain a sequence having sum X such that the sum of each element of the subsequence multiplied by an array element is equal to Y
Note: Here X is always less than Y.

Examples:

Input: arr[] = {1, 2, 7, 9, 10}, X = 11, Y = 13 
Output: Yes 
Explanation: 
The given value of X( = 11) can be split into a sequence {9, 2} such that 9 * 1(= arr[0] + 2 * 2(= arr[1]) = 13( = Y)
Input: arr[] ={1, 3, 5, 7}, X = 27, Y = 34 
Output: No

Approach: Follow the steps below in order to solve the problem: 
 

  • Calculate the difference between Y and X.
  • For every array element arr[i], which is > 1, update (Y – X) % (arr[i] – 1).
  • If the difference is reduced 0, print “Yes“. Otherwise, print “No”.

Below is the implementation of the above approach:

C++




// C++ Program to implement
// the above approach
#include <iostream>
using namespace std;
 
// Function to check if it is possible
// to obtain sum Y from a sequence of
// sum X from the array arr[]
void solve(int arr[], int n, int X, int Y)
{
 
    // Store the difference
    int diff = Y - X;
 
    // Iterate over the array
    for (int i = 0; i < n; i++) {
 
        if (arr[i] != 1) {
            diff = diff % (arr[i] - 1);
        }
    }
 
    // If diff reduced to 0
    if (diff == 0)
        cout << "Yes";
    else
        cout << "No";
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 7, 9, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int X = 11, Y = 13;
    solve(arr, n, X, Y);
 
    return 0;
}


Java




// Java program to implement
// the above approach
class GFG{
     
// Function to check if it is possible
// to obtain sum Y from a sequence of
// sum X from the array arr[]
static void solve(int arr[], int n,
                  int X, int Y)
{
     
    // Store the difference
    int diff = Y - X;
 
    // Iterate over the array
    for(int i = 0; i < n; i++)
    {
        if (arr[i] != 1)
        {
            diff = diff % (arr[i] - 1);
        }
    }
 
    // If diff reduced to 0
    if (diff == 0)
        System.out.print( "Yes");
    else
        System.out.print("No");
}
 
// Driver Code
public static void main (String []args)
{
    int arr[] = { 1, 2, 7, 9, 10 };
    int n = arr.length;
    int X = 11, Y = 13;
     
    solve(arr, n, X, Y);
}
}
 
// This code is contributed by chitranayal


Python3




# Python3 program to implement
# the above approach
 
# Function to check if it is possible
# to obtain sum Y from a sequence of
# sum X from the array arr[]
def solve(arr, n, X, Y):
 
    # Store the difference
    diff = Y - X
 
    # Iterate over the array
    for i in range(n):
        if(arr[i] != 1):
            diff = diff % (arr[i] - 1)
 
    # If diff reduced to 0
    if(diff == 0):
        print("Yes")
    else:
        print("No")
 
# Driver Code
arr = [ 1, 2, 7, 9, 10 ]
n = len(arr)
X, Y = 11, 13
 
# Function call
solve(arr, n, X, Y)
 
# This code is contributed by Shivam Singh


C#




// C# program to implement
// the above approach
using System;
 
class GFG{
     
// Function to check if it is possible
// to obtain sum Y from a sequence of
// sum X from the array []arr
static void solve(int []arr, int n,
                  int X, int Y)
{
     
    // Store the difference
    int diff = Y - X;
 
    // Iterate over the array
    for(int i = 0; i < n; i++)
    {
        if (arr[i] != 1)
        {
            diff = diff % (arr[i] - 1);
        }
    }
 
    // If diff reduced to 0
    if (diff == 0)
        Console.Write("Yes");
    else
        Console.Write("No");
}
 
// Driver Code
public static void Main(String []args)
{
    int []arr = { 1, 2, 7, 9, 10 };
    int n = arr.Length;
    int X = 11, Y = 13;
     
    solve(arr, n, X, Y);
}
}
 
// This code is contributed by Amit Katiyar


Javascript




<script>
     
// Javascript program to implement
// the above approach
 
// Function to check if it is possible
// to obtain sum Y from a sequence of
// sum X from the array arr[]
function solve(arr, n, X, Y)
{
 
    // Store the difference
    var diff = Y - X;
 
    // Iterate over the array
    for(var i = 0; i < n; i++)
    {
         
        if (arr[i] != 1)
        {
            diff = diff % (arr[i] - 1);
        }
    }
 
    // If diff reduced to 0
    if (diff == 0)
        document.write("Yes");
    else
        document.write("No");
}
 
// Driver Code
var arr = [ 1, 2, 7, 9, 10 ];
var n = arr.length;
var X = 11, Y = 13;
 
solve(arr, n, X, Y);
 
// This code is contributed by rutvik_56
 
</script>


Output: 

Yes

 

Time Complexity: O(N) 
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments