Question

我正在尝试创建一个用于分解素数的pascal程序，即

16 = 2*2*2*2
210 = 2*3*5*7

我应该输入一个数字，我应该返回素数分解。我不理解数学意义上的解决方案，有人可以解释我这个算法或伪代码，只要我理解我正在创建的编程并不是真正的问题。

由于

Answer 1

这种天真的做法是：

k = 2
N = 210
while N > 1:
    if N % k == 0:   // if k evenly divides into N
        print k      // this is a factor
        N = N / k    // divide N by k so that we have the rest of the number left.
    else:
        k = k + 1

主要前提是，如果k除以N，则FACTOR(N)等于k * FACTOR(N / k)。因此请一遍又一遍地执行此操作，直到您无法再考虑N。这样，您就可以获得k1 * k2 * k3 * FACTOR(N / k1 / k2 / k3)等等。

如果从较小的数字开始并开始工作，那么你只会提出素数因素。

所以，对于210，你得到：

k = 2
N = 210

k divides N, so print 2, N becomes 105
k no longer divides N, so k becomes 3
k divides N, so print 3, N becomes 35
k no longer divides N, so k becomes 4
k does not divide N, so k becomes 5
k divides N, so print 5, N becomes 7
k no longer divide N, so k becomes 6
k does not divide N, so k becomes 7
k divides N, so print 7, N becomes 1
N is now equal to 1, so stop.

You get 2 3 5 7

一个基本的改进是你只需要遍历素数。所以，在上面的例子中你可以跳过4和6。

Answer 2

素数是一个只有两个除数的整数。例如，13是素数，因为它只能被1和13（两个除数）整除。 14不是素数，因为它可以被1，2，7和14（四个除数）整除。 4不是素数，因为它可以被1，2和4（三个除数）整除。按照惯例，1不是素数，但这在这里并不重要。

每个大于1的整数都有一个唯一的因子分解（分解）成素数。换句话说，只有一组（多组）素数使得它们的乘积等于给定的数。例如：

14 = 2 * 7
16 = 2 * 2 * 2 * 2
4 = 2 * 2
13 = 13

您的任务是编写一个算法，该算法接受输入大于1的整数，并输出一个素数列表，使其乘积等于输入数。

可以说，最简单的分解算法是trial division。

Answer 3

有两种情况需要考虑输入的数字：

1）数字是素数（在这种情况下，没有可能的因子分解。你应该只将数字作为输出返回）

2）数字不是素数（它可以作为素数的乘积计算）

我将概述以下步骤。请注意，我正在使用另一种着名的算法。我不知道是否有更有效的方法。

1）使用Sieve Of Eratosthenes算法（http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes）查找小于输入的所有素数。在此过程中，您还可以确定输入是否为素数。

2）现在，如果您的号码不是素数，请看第一个将它分开的素数，并继续跟踪您获得的每个数字作为商。

这是一个很好的例子：http://www.youtube.com/watch?v=9m2cdWorIq8

示例：

假设您收到输入为12.

(Operation , Input , Output)

       -      12     -
     12/2     6      2
     6/2      3      2*2
     3/2      3      2*2
     3/3      1      2*2*3

如果在输入字段中按下素数或1，则算法停止。

正如您所看到的，这里的关键是知道素数（2,3,5 ......），以便您可以将输入与它们分开。您还需要确定您的输入是否为素数。两者都可以通过Eratosthenes的Sieve完成。

Answer 4

根据Donald Miner的回答，我做了一个bash功能：

function decompose(){
    r=$(
            k=2;
            N=$1;
            while [ $N -gt 1 ] && [ $(( k ** 2 )) -le $N ];
            do [ "$(( N % k ))" == 0 ] && 
            {
                    echo $k; N=$(( N/k ));
            } || let k++; 
            done
            [ $(( k ** 2 )) -gt $N ] && echo $N
    );
    echo "$r" | uniq | 
    while read n;
    do echo "$n^$(
            echo "$r" | grep '^'"$n"'$' | wc -l
    )";
    done |
    tr '\n' '*' | 
    sed 's/\(\^1\)\?\*$//g; s/\^1\([^0-9]\)/\1/g'; 
    echo;
}

一些样本：

$ decompose 768
2^8*3
$ decompose 110
2*5*11
$ decompose 686567
7*98081
$ echo "7*98081" | bc
686567

如上所述，如果得到素数而不是增量k，它会快得多，但对我来说似乎很好。

将数字分解为素数

4 个答案: