combinatorics

The function combn() generates all combinations of the elements of x taken m at a time. It is very fast and efficient for nCm small (where n is the number of elements of x) but it quickly runs out of memory. For example: > combn(c(1:50), 12, simplify = TRUE) Error in matrix(r, nrow = len.r, ncol = count) : invalid 'ncol' value (too large or NA) I would like to know if the function combn() can be modified such that it generates only k chosen combinations. Let's call this new function chosencombn(). Then we would have: > combn(c("a", "b", "c", "d"), m=2) [,1] [,2] [,3] [,4] [,5] [,6] [1,] "a" "a

I want to generate combinations that associate indices in a list with "slots". For instance, (0, 0, 1) means that 0 and 1 belong to the same slot while 2 belongs to an other. (0, 1, 1, 1) means that 1, 2, 3 belong to the same slot while 0 is by itself. In this example, 0 and 1 are just ways of identifying these slots but do not carry information for my usage. Consequently, (0, 0, 0) is absolutely identical to (1, 1, 1) for my purposes, and (0, 0, 1) is equivalent to (1, 1, 0) . The classical cartesian product generates a lot of these repetitions I'd like to get rid of. This is what I obtain

Given an array ['a', 'b', 'c', 'd', 'e', 'f'] , how would I get a list of all subsets containing two, three, and four elements? I'm quite new to Ruby (moving from C#) and am not sure what the 'Ruby Way' would be. basicxman Check out Array#combination Then something like this: 2.upto(4) { |n| array.combination(n) } Tweaking basicxman's a little bit: 2.upto(4).flat_map { |n| array.combination(n).to_a } #=> [["a", "b"], ["a", "c"], ["a", "d"], ..., ["c", "d", "e", "f"]] 来源： https://stackoverflow.com/questions/7356030/find-all-subsets-of-size-n-in-an-array-using-ruby

I was wondering how to solve such a problem using DP. Given n balls and m bins, each bin having max. capacity c1, c2,...cm. What is the total number of ways of distributing these n balls into these m bins. The problem I face is How to find a recurrence relation (I could when the capacities were all a single constant c). There will be several test cases, each having its own set of c1,c2....cm. So how would the DP actually apply for all these test cases because the answer explicitly depends on present c1,c2....cm, and I can't store (or pre-compute) the answer for all combinations of c1,c2....cm.

I am sure this problem has a formal name, and knowing that name would probably help me find the solution, but I don't know it, and wording the problem for Google keeps pointing me to the Knapsack Problem , which isn't the same thing. I want to take some value X and find every possible combination of splitting that value into N stacks of whole integers. In case my wording is confusing, here is an example of X = 4, N = 3 Stack -> 1 | 2 | 3 | ---------------------- #1-----> 4 | 0 | 0 | ---------------------- #2-----> 3 | 1 | 0 | ---------------------- #3-----> 2 | 1 | 1 | ----------------------

In Python 2.7 I need a method that returns all possible products of a list or tuple of int . Ie. if input is (2, 2, 3, 4) , then I'd want a output like (3, 4, 4) , 2 * 2 = 4 (2, 4, 6) , 2 * 3 = 6 (2, 3, 8) , 2 * 4 = 8 (3, 4, 4) , 2 * 2 = 4 (2, 2, 12) , 3 * 4 = 12 (2, 24) , 2 * 3 * 4 = 24 (3, 16) , 2 * 2 * 4 = 16 (4, 12) , 2 * 2 * 3 = 12 (48) , 2 * 2 * 3 * 4 = 48 wrapped up in a list or tuple . I figure that a nice implementation is probably possible using combinations from itertools , but I'd appreciate any help. Note that I am only interested in distinct lists, where order of int plays no

I want to rank and unrank combinations with an Element distance constraint. Selected elements cannot repeated. For example: n := 10 elements choose from k := 5 elements being choosen d := 3 max distance between 2 choosen elements 1,3,5,8,9 matches the constraint 1,5,6,7,8 dont matches the constraint How can ranking the combination with given distance constraint, where 1,2,3,4,5 is smaller than 1,2,3,4,6 ? Is there a way do the ranking without compute the combinations with smaller Rank? You can do this by first creating and populating a two-dimensional array, which I will call NVT for "number