Write a program to find minimum elements in array which has sum equals to given value

Thu, 21 May 2026 12:28:37 +0000

Solving problems related to data structures and algorithm has become the norm of many technical interviews in recent times. So whether you are a beginner or seasoned developer, it is important you keep your problem solving skills active. In this article we are going to look at how to solve a common coding interview question with a clear explanation of the algorithm. So grab your coffee and let's dive in!

Problem Definition

Given an array arr[] and a target integer S, the objective is to determine the least amount of elements from the array arr[] whose total adds up to the integer S, where any element from the array can only be selected once to achieve a sum of S.

Test case 1
Inputs
6
2, 1, 3, 4, 7
Output: 2
Explanation
The first line of the input indicates the target integer S while the second with comma separately integers is the content of the array.
Possible solutions:
2 + 1 + 3 = 6
2 + 4 = 6
Therefore the minimum number of elements is 2.

Test case 2
Inputs
4
1, 2, 5, 6, 7
Output: -1
Explanation
There are not possible solutions since no elements of the array can sum up to give 4 therefore the result is -1

Solution to problem

Here is an example program in Python that finds the minimum number of elements in an array that add up to a given value:


def min_elements_with_sum(arr, target_sum):
    n = len(arr)
    dp = [float('inf')] * (target_sum + 1)
    dp[0] = 0

    for i in range(n):
        for j in range(target_sum, arr[i]-1, -1):
            dp[j] = min(dp[j], dp[j-arr[i]] + 1)

    if dp[target_sum] == float('inf'):
        return -1
    return dp[target_sum]

The program works by using a dynamic programming approach to find the minimum number of elements that add up to a given target sum.

It initializes a list dp of size target_sum + 1 with all elements set to positive infinity.
The base case is when the target sum is 0, in which case the minimum number of elements is 0.
For each element in the input array,

it iterates through the dp list in reverse order, starting from the target_sum and ending at arr[i]-1
It updates the value of dp[j] with the minimum of the current value and dp[j-arr[i]] + 1.
If dp[target_sum] is still infinity, it means that the target sum cannot be achieved with the given array.

Else, it returns dp[target_sum] as the minimum number of elements required to achieve the target sum.

The Time complexity of this algorithm is O(n*S) where n is the size of array and S is the target sum. Space complexity is O(S).

This algorithm is based on the Unbounded Knapsack problem which is a classic problem in dynamic programming where we need to select items from a set such that we maximize the total value of the items while still staying within the given weight (or sum in this case) constraint.

Understanding the concept of dynamic programming

Dynamic programming is a powerful technique for solving complex problems by breaking them down into simpler, overlapping subproblems. It is a method for solving problems by breaking them down into smaller, overlapping subproblems and storing the solutions to these subproblems in a table, called a "dp table", to avoid redundant computation.

Dynamic programming can be applied to both optimization and counting problems. It is particularly useful for solving problems that have an "optimal substructure" property, meaning that an optimal solution to the problem can be constructed from optimal solutions to smaller subproblems.

There are two main approaches to dynamic programming: top-down (also known as memoization) and bottom-up (also known as tabulation).

Top-down dynamic programming, also known as memoization, involves recursively solving the problem and storing the solutions to subproblems in a table as they are calculated. This approach avoids redundant computation by checking the table for a stored solution before solving a subproblem.

Here is an example of a top-down dynamic programming solution for the problem of finding the nth Fibonacci number:


def fibonacci(n, dp):
    if n == 0 or n == 1:
        return n
    if dp[n] is not None:
        return dp[n]
    dp[n] = fibonacci(n-1, dp) + fibonacci(n-2, dp)
    return dp[n]

n = 10
dp = [None] * (n + 1)
print(fibonacci(n, dp))

Bottom-up dynamic programming, also known as tabulation, involves solving the problem by starting with the smallest subproblems and building up to the final solution. This approach avoids the need for recursion and can be more efficient than the top-down approach when the subproblems are not recursive in nature.

Here is an example of a bottom-up dynamic programming solution for the problem of finding the nth Fibonacci number:


def fibonacci(n):
    dp = [0, 1] + [0] * (n - 1)
    for i in range(2, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]
    return dp[n]

print(fibonacci(10))

Dynamic programming can be applied to a wide range of problems, including but not limited to:

Combinatorial optimization problems, such as the Knapsack problem, the Traveling Salesman problem, and the Longest Common Subsequence problem.
Graph algorithms, such as shortest path algorithms and minimum spanning tree algorithms
String algorithms, such as computing the Levenshtein distance

Dynamic programming is a powerful technique that can be used to solve complex problems efficiently. However, it can be difficult to design an efficient dynamic programming solution for a problem, and it is not always the best approach for solving a problem.

Conclusion

In this article, we have looked at how to solve a common coding interview question and also explain the concept of dynamic programming. Having this knowledge will help you to tackle similar problems and also to broaden your approach of tackling problems.

References

Dynamic Programming - Algorithms and Data Structures - https://www.ics.uci.edu/~eppstein/161/960229.html

Coder Legion - Recent posts tagged dynamic-programming