GATE-CS-2006 Problem 3

Introduction

The GATE-CS-2006 problem 3 is a coding problem that requires the implementation of a program to perform a specific task. The task involves working with a given data structure and manipulating the data in a certain way.

Problem Statement

The problem statement requires the implementation of a program that takes as input a set of integers and a target integer. The program should then output a subset of the input integers that add up to the target integer if such a subset exists. If no such subset exists, the program should output "No subset found".

Approach

The problem involves finding a subset of the input integers that add up to the target integer. This can be achieved using a recursive approach. The recursive function can take two parameters: the current index of the input array and the current sum of the elements in the subset. At each call to the function, we can either include the current element in the subset or exclude it. If we include the element, we add it to the current sum and call the function recursively with the updated sum and index. If we exclude the element, we simply call the function recursively with the updated index but the same sum.

We can stop the recursion when we have traversed the entire input array. At this point, we can check if the current sum is equal to the target sum. If it is, we have found a valid subset and we can return the subset. If it is not, we return None.

To optimize the approach, we can use memoization to avoid recalculating the function for the same inputs.

Code

def subset_sum(arr, target):
    memo = {}
    def _subset_sum(idx, curr_sum):
        if idx == len(arr):
            if curr_sum == target:
                return []
            return None
        
        if (idx, curr_sum) in memo:
            return memo[(idx, curr_sum)]

        # Include the current element in the subset
        subset = _subset_sum(idx + 1, curr_sum + arr[idx])
        if subset is not None:
            subset.append(arr[idx])
            memo[(idx, curr_sum)] = subset
            return subset

        # Exclude the current element from the subset
        subset = _subset_sum(idx + 1, curr_sum)
        memo[(idx, curr_sum)] = subset
        return subset

    subset = _subset_sum(0, 0)
    if subset is None:
        print("No subset found")
    else:
        print(subset)

Conclusion

In conclusion, the GATE-CS-2006 Problem 3 involves implementing a program to find a subset of the input integers that add up to a target integer. The approach involves using a recursive function and memoization to optimize the solution. The provided code implements the solution in Python.