combinatorics | Combinatorics Library for Microsoft .NET

The problem is that you're doing the bit shifts on an int before creating the BigInteger. Just change it to create a BigInteger value of 1 and then do the bit shifts. There's even a static property you can use called BigInteger.One.

I am unaware of an approach with rcppalgos to efficiently get back to the original index, especially if there are repeats in the price vector.

However, we can try to do similar with data.table. It's very possible that this is inadequate for your needs as most of the memory will need to be pre-allocated.

In a 2D space the solution to the problem can be represented like this

As recognized by others this is a an optimization problem. You have linear constraints and a convex objective function, it can be cast to quadratic programming, (read Least squares session)

If you want to minimize the average of w[i] * x[i], this is sum(w[i] * x[i]) / N, if you arrange w[i] as the elements of a (1 x N_vectors) matrix, and each vector x[i] as the i-th row of a (N_vectors x DIM) matrix, it becomes w @ X / N_vectors (with @ being the matrix product operator).

To cast to that form you would have to construct a matrix so that each rows of A*x < b expressing -w[i] < 0, the equality is sum(w) = 1 becomes sum(w) < 1 and -sum(w) < -1. But there there are amazing tools to automate this part.

This can be readily implemented using cvxpy, and you don't have to care about expanding all the constraints.

The following function solves the problem and if the vectors have dimension 2 plot the result.

As mentioned above what you need it is difficult to do this without computing the sum of all pairs, so I am not going to handle that, I am just going to advise about efficient data structures.

Your code adds everything in advance O(n^2) then sorts O(n^2 log(n)), then remove duplicates. But since you are erasing from a vector, that ultimately has complexity linear with the number of elements to the end of the list. It means that the second loop will make the complexity of your algorithm O(n^4).

You can count the unique elements in a sorted array without removing

What you're describing is the number of permutations of n objects. There are n! = 1 × 2 × ... × n (also known as n factorial) such permutations.

One thing that does not work in your example is that all threads are mutating (via push!) the same vectors (result and a) possibly concurrently, thereby allowing race conditions to happen.

One way around this would be to have a collection of vectors (one per thread); each thread only modifies its own vector (identified by it threadid()).

With such a technique, a simplified version of your example could look like this:

For your value "half of N" equal to 3 this would be:

Not the same order, but

Try this: