Russian Peasant Multiplication Algorithm
It looks to me that you're being too literal.  When trying to convert an analog process to code it's easy to fall into that trap.

Presently you're using 2 loops to make 2 lists.  This is unnecessary.  You can do everything including calculate the answer in one loop.

You're also not checking for which number is the lesser one and which is the greater one.  This is integral to the base algorithm, that you're trying to emulate.

A simplified version could look something like this:

int PeasantMultiply(int num1, int num2)
{
    auto pair = std::minmax(num1, num2);
    int min = pair.first;
    int max = pair.second;
    int total = 0;
    if (min != 0)
    {
        do
        {
            if (min % 2 == 1)
            {
                total += max;
            }
            min /= 2;
            max += max;
        } while (min &gt; 0);
    }
    return total;
}


After looking at this code again, I came upon an optimization.  Instead of using the modulus operator(%), I could accomplish the same thing with and extra int variable and use subtraction instead:

int PeasantMultiply(int num1, int num2)
{
    auto pair = std::minmax(num1, num2);
    int oldMin = pair.first;
    int max = pair.second;
    int total = 0;
    int newMin = 0;
    if (oldMin != 0)
    {
        do
        {
            newMin = oldMin / 2;
            if (oldMin - newMin != newMin)
            {
                total += max;
            }
            oldMin = newMin;
            max += max;
        } while (oldMin &gt; 0);
    }
    return total;
}


In my tests this saves about 10% in time.