在c ++中组合两个不同向量的比率

Question

I don't know how to explain it so it if this question exists, just point me to the right topic. I have searched the forum but couldn't find any answer (maybe there is a keyword in mathematics or statistics for this that I am missing).

How do I produce a vector with combined weights from two vectors?

For example given two vectors:

vector_1 = {3, 3, 4}
vector_2 = {5, 5}

We calculate their weights which is the element divided by the sum of the elements in the vector.

weights_1 = {0.3, 0.3, 0.4}
weights_2 = {0.5, 0.5}

These are then combined to produce this vector. The combined weights is the combined ratios of the two vectors.

combined_weights = {0.3, 0.2, 0.1, 0.4}

is there a function that can calculate the combined weights?

combined_weights = calculate(weights_1, weights_2)

The process is:

Step 1: combined_weights = {0.3} 

0.3 is the first element of weights_1.

Step 2: combined_weights = {0.3, 0.2, 0.1} 

The sum of 0.2 and 0.1 is the the second element of weights_1. The sum of the combined_weights vector is equal to the first element of weights_2.

Step 3: combined_weights = {0.3, 0.2, 0.1, 0.4} 

From the combined_weights vector we can get both weights_1 and weights_2, ie

    weights_1 = {0.3, 0.2 + 0.1, 0.4}
    weights_2 = {0.3 + 0.2, 0.1 + 0.4}

My goal is to make vector_1 and vector_2 have similar size.

new_vector_1 = {3, 2, 1, 4}
new_vector_2 = {3, 2, 1, 4}

More generally,

Answer 1

Rather than dividing each weight by it's total, you can find the LCM of your totals, and multiply, which keeps you in integer arithmetic

int total1 = std::accumulate(weights1.begin(), weights1.end(), 0);
int total2 = std::accumulate(weights2.begin(), weights2.end(), 0);
int lcm = std::lcm(total1, total2);

We want to do destructive things below, so we may as well do that to adjusted values

std::deque<int> working1;
std::transform(weights1.begin(), weights1.end(), std::back_inserter(working1), [=](int w){ return w * lcm / total1; });

std::deque<int> working2;
std::transform(weights2.begin(), weights2.end(), std::back_inserter(working2), [=](int w){ return w * lcm / total2; });

Comparing the front elements, you pop the smaller, add it to the output (unless zero), and decrement the larger by that value. Repeat that process until both copies are empty

std::vector<int> combined;

while (!working1.empty() && !working2.empty())
{
    int & top1 = working1.front();
    int & top2 = working2.front();
    if (top1 < top2)
    {
        if (top1 > 0) { combined.push_back(top1) }
        top2 -= top1;
        working1.pop_front();
    }
    else
    {
        if (top2 > 0) { combined.push_back(top2) }
        top1 -= top2;
        working2.pop_front();
    }
}