## Find all combinations of a set of numbers that add up to a certain total

find all combinations that add up to given number python
finding all possible combinations of numbers to reach a given sum javascript
finding all possible combinations of numbers to reach a given sum php
all possible sums of a set of numbers
find a subset of numbers that add to a given total
find combination of values with sum closest to number
find all possible combinations of numbers in java
find all permutations that add up to given number

I've seen a few solutions to similar problems, but they all require iteration over the number of items to be added together.

Here's my goal: from a list of numbers, find all of the combinations (without replacement) that add up to a certain total. For example, if I have numbers `1,1,2,3,5` and total `5`, it should return `5`,`2,3`, and `1,1,3`.

I was trying to use `combn` but it required you to specify the number of items in each combination. Is there a way to do it that allows for solution sets of any size?

This is precisely what `combo/permuteGeneral` from `RcppAlgos` (I am the author) were built for. Since we have repetition of specific elements in our sample vector, we will be finding combinations of multisets that meet our criteria. Note that this is different than the more common case of generating combinations with repetition where each element is allowed to be repeated m times. For many combination generating functions, multisets pose problems as duplicates are introduced and must be dealt with. This can become a bottleneck in your code if the size of your data is decently large. The functions in `RcppAlgos` handle these cases efficiently without creating any duplicate results. I should mention that there are a couple of other great libraries that handle multisets quite well: `multicool` and `arrangements`.

Moving on to the task at hand, we can utilize the constraint arguments of `comboGeneral` to find all combinations of our vector that meet a specific criteria:

```vec <- c(1,1,2,3,5)  ## using variables from @r2evans
uni <- unique(vec)
myRep <- rle(vec)\$lengths
ans <- 5

library(RcppAlgos)
lapply(seq_along(uni), function(x) {
comboGeneral(uni, x, freqs = myRep,
constraintFun = "sum",
comparisonFun = "==",
limitConstraints = ans)
})

[[1]]
[,1]
[1,]    5

[[2]]
[,1] [,2]
[1,]    2    3

[[3]]
[,1] [,2] [,3]
[1,]    1    1    3

[[4]]
[,1] [,2] [,3] [,4]  ## no solutions of length 4
```

These functions are highly optimized and extend well to larger cases. For example, consider the following example that would produce over 30 million combinations:

```set.seed(42)
bigVec <- sort(sample(1:30, 40, TRUE))

rle(bigVec)
Run Length Encoding
lengths: int [1:22] 2 1 1 2 1 1 1 2 3 1 ...
values : int [1:22] 1 3 4 5 7 8 9 12 14 15 ...

bigUni <- unique(bigVec)
bigRep <- rle(bigVec)\$lengths
bigAns <- 199
len <- 12

comboCount(bigUni, len, freqs = bigRep)
[1] 30904021
```

All 300000+ results are returned very quickly:

```system.time(bigTest <- comboGeneral(bigUni, len, freqs = bigRep,
constraintFun = "sum",
comparisonFun = "==",
limitConstraints = bigAns))
user  system elapsed
0.383   0.008   0.390

[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12]
[1,]    1    1    3    4    5    9   29   29   29    29    30    30
[2,]    1    1    3    4    5   12   26   29   29    29    30    30
[3,]    1    1    3    4    5   12   28   28   28    29    30    30
[4,]    1    1    3    4    5   12   28   28   29    29    29    30
[5,]    1    1    3    4    5   14   25   28   29    29    30    30
[6,]    1    1    3    4    5   14   25   29   29    29    29    30

nrow(bigTest)
[1] 370646

all(rowSums(bigTest) == bigAns)
[1] TRUE
```

I must mention that generally when I see a problem like: "finding all combinations that sum to a particular number" my first thought is integer partitions. For example, in the related problem Getting all combinations which sum up to 100 in R, we can easily solve with the `partitions` library. However, this approach does not extend to the general case (as we have here) where the vector contains specific repetition or we have a vector that contains values that don't easily convert to an integer equivalent (E.g. the vector `(0.1, 0.2, 0.3, 0.4)` can easily be treated as `1:4`, however treating `c(3.98486 7.84692 0.0038937 7.4879)` as integers and subsequently applying an integer partitions approach would require an extravagant amount of computing power rendering this method useless).

Finding all possible combinations of numbers to reach a given sum , This type of algorithms are very well explained in the following Standford's Abstract object Sum extends App { def sumCombinations(total: Int, numbers: List[Int]): are the possible ways to make an certain amount of money with a set of coins  Here's my goal: from a list of numbers, find all of the combinations (without replacement) that add up to a certain total. For example, if I have numbers 1,1,2,3,5 and total 5 , it should return 5 , 2,3 , and 1,1,3 .

I took your `combn` idea and looped over the possible sizes of the sets.

```func = function(x, total){
M = length(x)
y = NULL
total = 15
for (m in 1:M){
tmp = combn(x, m)
ind = which(colSums(tmp) == total)
if (length(ind) > 0){
for (j in 1:length(ind))
y = c(y, list(tmp[,ind[j]]))
}
}
return (unique(lapply(y, sort)))
}

x = c(1,1,2,3,5,8,13)

> func(x, 15)
[[1]]
[1]  2 13

[[2]]
[1]  1  1 13

[[3]]
[1] 2 5 8

[[4]]
[1] 1 1 5 8

[[5]]
[1] 1 1 2 3 8
```

Obviously, this will have problems as `M` grows since `tmp` will get big pretty quickly and the length of `y` can't be (maybe?) pre-determined.

How to find all combinations that equal a given sum in Excel?, Find cells combination that equal a given sum with formulas and you can see the numbers which total amount is 480 are marked as X in column B, see screenshot: Click button to select the cell B10 where your formula in from the Set  Given a positive number, find out all combinations of positive numbers that adds upto that number. The program should print only combinations, not permutations. For example, for input 3, either 1, 2 or 2, 1 should be printed.

Similar to mickey's answer, we can use `combn` inside another looping mechanism. I'll use `lapply`:

```vec <- c(1,1,2,3,5)
ans <- 5

Filter(length, lapply(seq_len(length(vec)),
function(i) {
v <- combn(vec, i)
v[, colSums(v) == ans, drop = FALSE]
}))
# [[1]]
#      [,1]
# [1,]    5
# [[2]]
#      [,1]
# [1,]    2
# [2,]    3
# [[3]]
#      [,1]
# [1,]    1
# [2,]    1
# [3,]    3
```

You can omit the `Filter(length,` portion, though it may return a number of empty matrices. They're easy enough to deal with and ignore, I just thought removing them would be aesthetically preferred.

This method gives you a matrix with multiple candidates in each column, so

```ans <- 4
Filter(length, lapply(seq_len(length(vec)),
function(i) {
v <- combn(vec, i)
v[, colSums(v) == ans, drop = FALSE]
}))
# [[1]]
#      [,1] [,2]
# [1,]    1    1
# [2,]    3    3
# [[2]]
#      [,1]
# [1,]    1
# [2,]    1
# [3,]    2
```

If duplicates are a problem, you can always do:

```Filter(length, lapply(seq_len(length(vec)),
function(i) {
v <- combn(vec, i)
v <- v[, colSums(v) == ans, drop = FALSE]
v[,!duplicated(t(v)),drop = FALSE]
}))
# [[1]]
#      [,1]
# [1,]    1
# [2,]    3
# [[2]]
#      [,1]
# [1,]    1
# [2,]    1
# [3,]    2
```

Identifying Excel Entries that Add Up to a Specific Value – The Daily , Personally, this occurs often as I frequently analyze spreadsheets full of The first step in this process is to make sure Excel's Solver Add-in is To begin, list all of the values of the individual entries in a column of the Now it's time to hit Solve – the solver will find the combination of numbers that add up to  Now it’s time to hit Solve – the solver will find the combination of numbers that add up to the target value specified in cell F4. However, there are two limitations to the solver: the solver limits the user to 200 variables as well as 100 constraints.

Now here is a solution involving `gtools`:

```# Creating lists of all permutations of the vector x
df1 <- gtools::permutations(n=length(x),r=length(x),v=1:length(x),repeats.allowed=FALSE)
ls1 <- list()
for(j in 1:nrow(df1)) ls1[[j]] <- x[df1[j,1:ncol(df1)]]

# Taking all cumulative sums and filtering entries equaling our magic number
sumsCum <- t(vapply(1:length(ls1), function(j) cumsum(ls1[[j]]), numeric(length(x))))
indexMN <- which(sumsCum == magicNumber, arr.ind = T)
finalList <- list()
for(j in 1:nrow(indexMN)){
magicRow <- indexMN[j,1]
magicCol <- 1:indexMN[j,2]
finalList[[j]] <- ls1[[magicRow]][magicCol]
}
finalList <- unique(finalList)
```

where `x = c(1,1,2,3,5)` and `magicNumber = 5`. This is a first draft, I am sure it can be improved here and there.

combination of all possible sum for a given number solver, This problem is equivalent to finding the number of integer solutions to a+b+c+d+​e=10. Since every permutation of stars and "+" signs represents a solution the total number of solutions is given by the possible permutations of this 14 symbols, Edit: in the case of 3 numbers adding up to 10 stars and bars gives 12!10!2! This combination generator will quickly find and list all possible combinations of up to 7 letters or numbers, or a combination of letters and numbers. Plus, you can even choose to have the result set sorted in ascending or descending order.

Not the most efficient but the most compact so far:

```x <- c(1,1,2,3,5)
n <- length(x)
res <- 5
unique(combn(c(x,rep(0,n-1)), n, function(x) x[x!=0][sum(x)==res], FALSE))[-1]
# [[1]]
# [1] 1 1 3
#
# [[2]]
# [1] 2 3
#
# [[3]]
# [1] 5
#
```

Excel: use Solver and SumMatch to find numbers that add up to your , Add to List Share. Given a set of candidate numbers ( candidates ) (without duplicates) and a target number ( target ), find all unique combinations in candidates  A reiterative VBA loop would be the brute force approach but there are others. see Find out which combinations of numbers in a set add up to a given total. – user4039065 Jan 26 '15 at 8:34 BRILLIANT.

Number of possible combinations of x numbers that sum to y , Finding all possible combinations of numbers to reach a given sum of additions from a given set of numbers so they add up to a given final number? object Sum extends App { def sumCombinations(total: Int, numbers: List[Int]): List[List[Int​]]  I need to get all combinations of these numbers that have a given sum, e.g. 10. The items in the combinations may not be repeated, but each item in numbers has to be treated uniquely, that means e.g. the two 7 in the list represent different items with the same value. The order is unimportant, so that [1, 9] and [9, 1] are the same combination.

Combination Sum, To avoid printing permutations, each combination will be constructed in non-​decreasing order. If combination of given sum is reached, we print it. Below is C/​C++,  The number says how many (minimum) from the list are needed for that result to be allowed. Example has 1,a,b,c Will allow if there is an a , or b , or c , or a and b , or a and c , or b and c , or all three a,b and c .

Print all combination of numbers from 1 to n having sum n, The SumMatch Excel Add-in gives you all the combinations of a group of numbers that add up to a target sum. The trial version is available from SumMatch.com. Register To Reply

• I like this method; the only issue is it'll return duplicates in a different order (like both `[1,4]` and `[4,1]`).
• Great edit! Missing right parenthesis at the end of the `return` statement, but a great solution. Thank you!
• Can duplicates be a problem? I think `combn` gives unique columns.
• Duplicates are a problem when the input vector has duplicates (1 is listed twice in the input vector). A duplicate is demonstrated in the second example. `combn` works in the elements themselves, not just unique elements.
• This looks good, but I copied your code and got an error (`Error in colSums(v) : 'x' must be an array of at least two dimensions`). Trying to figure out why.
• What r2evans calls `vec`, you were calling `x`. Make sure you have the names of the variables correct.
• The issue seems to be when that `combn(vec, i)` returns a list, not a matrix, when `i` is equal to the length of elements in `vec`. It has an easy workaround, but I'm not sure why that wasn't happening here.