行为怪异的元素的向量加法答案

【问题标题】：Vector addition of elements behaving weird行为怪异的元素的向量加法
【发布时间】：2015-03-08 16:27:22
【问题描述】：

在我进入问题描述之前，请注意数据类型 'factrep' 只是 vector<int> 的 typedef。

问题

给定两个factrep 对象f1 和f2，作为参数传递给factrep 函数mult，我希望返回的factrep 对象result 是相乘向量的表示。

另外请注意，对向量元素单独执行的实际算术运算是加法：这是因为向量以素因子指数的形式存储（元素 0 = 素数 2 存储的任何内容的幂），元素 1 = 素数 3 的任何存储的幂）。因此，添加这样的元素应该是正确的，但我的结果并不一致。我会将结果发布在附录中。

这里是相关函数

factrep mult(factrep f1, factrep f2)
{
    factrep a;

    for(unsigned int i=0;  i <f1.size() && f2.size(); i++) a.push_back(0);

    for(int i = 0; i < a.size(); i++)
    {
        a[i] += f1[i]+f2[i];
    }

    return a;
}

这里是包含调试控制台打印的完整代码

#include "facth_new.h"
#include <iostream>
#include <cmath>
#include <climits>
#include <vector>

using namespace std;

std::vector<int> eratosthenes(int n) {
    std::vector<int> result = std::vector<int>();
    if (n < 2) {
        return result;
    }

    // initialize the vector
    std::vector<bool> input(n + 1, true);

    // calculate the upper limit as the square root of
    // of N. all composite numbers <= N must have a
    // factor <= sqrt(N)
    int sqrtN = (int)sqrt(n);

    // iterate from 2 up to the square root of N
    for (int i = 2; i <= sqrtN; i ++) {
        if (! input[i]) {
            // i is a proven composite number,
            // all its multiples have been
            // marked not prime by all its prime factors by now.
            continue;
        }

        // as an optimization, all multiples *less* than
        // the square of i are already marked, (they have
        // another prime factor less than i), so we can start
        // from the square which is the smallest composite
        // not yet marked
        for (int j = i * i; j <= n; j += i) {
            input[j] = false;
        }
    }

    // as n >= 2, then add 2 here
    result.push_back(2);

    // and check only odd numbers here,
    // no other even number can be set
    for (int i = 3; i <= n; i += 2) {
        if (input[i]) {
            result.push_back(i);
        }
    }

    return result;
}


factrep primfact(int n){
    factrep a;

    int m; // still to factorize number

    m=n;

    // continue until nothing to factorize
    for(int i = 0; m != 1; i++)
    {
        a.push_back(0);
        while(m % primes[i] == 0){

            m=m/primes[i];
            a.at(i)++;

        }

    }

    return a;
}

factrep mult(factrep f1, factrep f2)
{
    factrep a;

    for(unsigned int i=0;  i <f1.size() && f2.size(); i++) a.push_back(0);

    for(int i = 0; i < a.size(); i++)
    {
        a[i] += f1[i]+f2[i];
    }

    return a;
}

factrep div(factrep f1, factrep f2)
{
    factrep result;

    for(int i=0; i<f1.size(); i++){
        result.push_back(f1[i]-f2[i]);
    }

    return result;
}

double getval(factrep f)
{
    double result = 1;

    for(unsigned int i = 0; i < f.size(); i++)
    {

        result *= pow(primes[i],f[i]);

    }

    return result;
}

vector<int> primes;

int main() {

    primes = eratosthenes(71);
    cout << "The prime numbers are:\n";

    for(unsigned i = 0; i != primes.size(); i++)
        cout << primes[i] << '\n';

    int num[] = {1, 17, 54, 10, 36, 63, 20, 25};
    factrep f[8];


    for(int i = 0; i != 8; i++) {
        f[i] = primfact(num[i]);
    }

    for(int i = 0; i != 8; i++) {
        cout << '\n' << num[i] << " is factorized as:\nPrime     Exponent\n";
        bool agree = true;
        for(unsigned j = f[i].size(); j < f[i].size(); j++) {
            if((f[i])[j] != 0) {
                agree = false;
            }
        }
        for(unsigned j = 0; j != min(f[i].size(), f[i].size()); j++) {
            if((f[i])[j] != 0) {
                cout << primes[j] << "     " << (f[i])[j] << '\n';
            }
        }
        if(!agree) {
            for(unsigned j = f[i].size(); j != f[i].size(); j++) {
                if((f[i])[j] != 0) {
                    cout << primes[j] << "     " << (f[i])[j] << '\n';
                }
            }
        }
    }

    for(int i = 0; i != 8; i++) {
        cout << "getval of " << num[i] << " is " << getval(f[i]) << "\n\n";
    }

    for(int i = 0; i != 8; i++) {
        for(int j = i; j != 8; j++) {
            factrep res = mult(f[i], f[j]);
            cout << num[i] << " multiplied by " << num[j] << " is " << getval(res) << "\n";
        }
    }
    for(int i = 0; i != 8; i++) {
        for(int j = i; j != 8; j++) {
            factrep res = div(f[i], f[j]);
            cout << num[i] << " divided by " << num[j] << " is " << getval(res) << "\n";
        }
    }

}

最后，我的调试控制台打印，乘法部分发生错误：

The prime numbers are:
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71

1 is factorized as:
Prime     Exponent

17 is factorized as:
Prime     Exponent
17     1

54 is factorized as:
Prime     Exponent
2     1
3     3

10 is factorized as:
Prime     Exponent
2     1
5     1

36 is factorized as:
Prime     Exponent
2     2
3     2

63 is factorized as:
Prime     Exponent
3     2
7     1

20 is factorized as:
Prime     Exponent
2     2
5     1

25 is factorized as:
Prime     Exponent
5     2
getval of 1 is 1

getval of 17 is 17

getval of 54 is 54

getval of 10 is 10

getval of 36 is 36

getval of 63 is 63

getval of 20 is 20

getval of 25 is 25

1 multiplied by 1 is 1
1 multiplied by 17 is 1
1 multiplied by 54 is 1
1 multiplied by 10 is 1
1 multiplied by 36 is 1
1 multiplied by 63 is 1
1 multiplied by 20 is 1
1 multiplied by 25 is 1
17 multiplied by 17 is 289
17 multiplied by 54 is 9.12788e+172
17 multiplied by 10 is 1.69035e+172
17 multiplied by 36 is 3.04263e+173
17 multiplied by 63 is 1.06492e+173
17 multiplied by 20 is 2.36649e+173
17 multiplied by 25 is 2.95811e+173
54 multiplied by 54 is 2916
54 multiplied by 10 is 108
54 multiplied by 36 is 1944
54 multiplied by 63 is 486
54 multiplied by 20 is 216
54 multiplied by 25 is 54
10 multiplied by 10 is 100
10 multiplied by 36 is 9000
10 multiplied by 63 is 90
10 multiplied by 20 is 200
10 multiplied by 25 is 250
36 multiplied by 36 is 1296
36 multiplied by 63 is 324
36 multiplied by 20 is 144
36 multiplied by 25 is 36
63 multiplied by 63 is 3969
63 multiplied by 20 is 61740
63 multiplied by 25 is 540225
20 multiplied by 20 is 400
20 multiplied by 25 is 500
25 multiplied by 25 is 625
1 divided by 1 is 1
1 divided by 17 is 1
1 divided by 54 is 1
1 divided by 10 is 1
1 divided by 36 is 1
1 divided by 63 is 1
1 divided by 20 is 1
1 divided by 25 is 1
17 divided by 17 is 1
17 divided by 54 is 0
17 divided by 10 is 0
17 divided by 36 is 0
17 divided by 63 is 0
17 divided by 20 is 0
17 divided by 25 is 0
54 divided by 54 is 1
54 divided by 10 is 27
54 divided by 36 is 1.5
54 divided by 63 is 6
54 divided by 20 is 13.5
54 divided by 25 is 54
10 divided by 10 is 1
10 divided by 36 is 0.277778
10 divided by 63 is 1.11111
10 divided by 20 is 0.5
10 divided by 25 is 0.4
36 divided by 36 is 1
36 divided by 63 is 4
36 divided by 20 is 9
36 divided by 25 is 36
63 divided by 63 is 1
63 divided by 20 is 3.15
63 divided by 25 is 0.36
20 divided by 20 is 1
20 divided by 25 is 0.8
25 divided by 25 is 1

【问题讨论】：

你应该通过引用而不是值传递那些factrec对象。
非常详细，但您还没有真正缩小范围！
two={1}, three={0,1}, mult(two,three) 将导致对 two[1] 的越界访问。在你学习的时候总是把你的表达完全括起来（即i <f1.size() && f2.size()）。

标签： c++ vector primes prime-factoring

【解决方案1】：

条件i <f1.size() && f2.size() 应该写成i <f1.size() && i < f2.size()

【讨论】：

感谢您指出这个缺陷。但是，当我编辑此条件时，我仍然会得到与发布的结果相同的结果。

【解决方案2】：

你的 for 循环条件：

for(unsigned int i=0;  i <f1.size() && f2.size(); i++)

应该是：

for(unsigned int i=0;  i<f1.size() && i<f2.size(); i++)

这意味着 i 从 0 循环到 min{f1.size(), f2.size()}

【讨论】：

我理解这个条件逻辑缺陷，但是当我编辑它时，我得到了相同的结果。

【解决方案3】：

正如其他人所说，问题在于您的循环条件。除此之外，我还注意到您可以更改一些内容以使您的代码更符合逻辑。

你有以下两个循环

for(unsigned j = f[i].size(); j < f[i].size(); j++) { if((f[i])[j] != 0) { agree = false; } }

for(unsigned j = f[i].size(); j != f[i].size(); j++) { if((f[i])[j] != 0) { cout << primes[j] << " " << (f[i])[j] << '\n'; } }

在这两个中，您都使用 f[i].size() 初始化 j，然后设置条件以在 j==f[i].size() 时结束循环。由于 j 已经是 f[i].size()，这将在第一次迭代后中断。在这种情况下，您根本不需要循环，而可以只使用 if 语句。

【讨论】：