combinatorics

Suppose we have n bins in which we are throwing k balls. What is a fast (i.e. using numpy/scipy instead of python code) way to generate all possible outcomes as a matrix? For example, if n = 4 and k = 3 , we'd want the following numpy.array : 3 0 0 0 2 1 0 0 2 0 1 0 2 0 0 1 1 2 0 0 1 1 1 0 1 1 0 1 1 0 2 0 1 0 1 1 1 0 0 2 0 3 0 0 0 2 1 0 0 2 0 1 0 1 2 0 0 1 1 1 0 1 0 2 0 0 3 0 0 0 2 1 0 0 1 2 0 0 0 3 Apologies if any permutation was missed, but this is the general idea. The generated permutations don't have to be in any particular order, but the above list was convenient for categorically

I have below a function (from a previous question that went unanswered) that creates an array with n amount of values. The sum of the array is equal to $max. function randomDistinctPartition($n, $max) { $partition= array(); for ($i = 1; $i < $n; $i++) { $maxSingleNumber = $max - $n; $partition[] = $number = rand(1, $maxSingleNumber); $max -= $number; } $partition[] = $max; return $partition; } For example: If I set $n = 4 and $max = 30. Then I should get the following. array(5, 7, 10, 8); However, this function does not take into account duplicates and 0s. What I would like - and have been

I didn't find a better way to phrase this question in the title. If you can, please edit. I have a list of lists like this: a = [['a','b'],[1,2]] now, I'd like a function that spits out all possible combination like this: [['a',1],['a',2],['b',1],['b',2]] where nor the number of lists in a is known in advance, nor is the length of each of the sub lists known in advance, but all the combinations that come out should contain 1 item from every sublist. You need itertools.product() : >>> list(itertools.product(*a)) [('a', 1), ('a', 2), ('b', 1), ('b', 2)] This may be what itertools.product()

I have a PostgreSQL table of this form: base_id int | mods smallint[] 3 | {7,15,48} I need to populate a table of this form: combo_id int | base_id int | mods smallint[] 1 | 3 | 2 | 3 | {7} 3 | 3 | {7,15} 4 | 3 | {7,48} 5 | 3 | {7,15,48} 6 | 3 | {15} 7 | 3 | {15,48} 8 | 3 | {48} I think I could accomplish this using a function that does almost exactly this, iterating over the first table and writing combinations to the second table: Generate all combinations in SQL But, I'm a Postgres novice and cannot for the life of me figure out how to do this using plpgsql. It doesn't need to be

I need a way of calculating combinations without running out of memory. Here's what i have so far. public static long combination(long n, long k) // nCk { return (divideFactorials(factorial(n), ((factorial(k) * factorial((n - k)))))); } public static long factorial(long n) { long result; if (n <= 1) return 1; result = factorial(n - 1) * n; return result; } public static long divideFactorials(long numerator, long denominator) { return factorial(Math.Abs((numerator - denominator))); } I have tagged it as C#, but the solution should ideally be language independent. public static long combination

Is there good implementation of Hungarian algorithm in standard python libraries? jcomeau_ictx I just tried: pip install munkres and it worked. Here you can find a short explanation on how to use it. I got an error trying to install "hungarian". Check this munkres out There are multiple Options: pip install munkres Documentation here pip install hungarian Documentation here pip install scipy scipy.optimize.linear_sum_assignment Documentation here 来源： https://stackoverflow.com/questions/4075669/hungarian-algorithm-in-python

In combinatorial mathematics, a Langford pairing , also called a Langford sequence, is a permutation of the sequence of 2n numbers 1, 1, 2, 2, ..., n, n in which the two ones are one unit apart, the two twos are two units apart, and more generally the two copies of each number k are k units apart. For example: Langford pairing for n = 3 is given by the sequence 2,3,1,2,1,3. What is a good method to solve this in haskell or C Can you suggest an algorithm to solve it (Do not want to use brute force)? --------------------------EDIT---------------------- How could we define the mathematical rules