相关疑难解决方法(0)

从这篇文章来看,

/^1?$|^(11+?)\1+$/ 检查一个数字(它在一元中的值)是否为素数.

使用它,perl -l -e '(1 x $_) !~ /^1?$|^(11+?)\1+$/ && print while ++$_;'返回素数列表.

我没有足够的Perl经验,但据我所知,正则表达式对于非素数的数字都是正确的.因此,如果我们使用此表达式打印所有不产生true的数字,我们会有一个素数列表.这就是perl查询尝试做的事情.

关于正则表达式部分,

^1?$部分用于计算1 不是素数

^(11+?)\1+$ 用于匹配从4开始的非素数.

我不明白的是为什么?正则表达式需要.据我说,/^1$|^(11+)\1+$/应该很好,实际上

perl -l -e '(1 x $_) !~ /^1$|^(11+)\1+$/ && print while ++$_;' 给了我相同的素数集.

我对正则表达式的理解有什么缺陷吗？为什么?需要？

是不是?应该匹配前面的表达式的零或一次出现？

我试图使用新的并行功能JDK8,但不幸的是,我无法让它工作.NetBeans 7.1表示不存在"并行"方法.

这种方法需要特殊导入吗？有没有人有示例代码演示Java 8并行性？

我正在创建一个从200万开始的无限整数流,使用朴素素数测试实现过滤此流以生成负载并将结果限制为10.

Predicate<Integer> isPrime = new Predicate<Integer>() {
    @Override
    public boolean test(Integer n) {
        for (int i = 2; i < n; i++) {
            if (n % i == 0) return false;   
        }
        return true;
    }
};

Stream.iterate(200_000_000, n -> ++n)
    .filter(isPrime)
    .limit(10)
    .forEach(i -> System.out.print(i + " "));

这按预期工作.

现在,如果我在过滤之前添加对parallel()的调用,则不会产生任何内容并且处理无法完成.

Stream.iterate(200_000_000, n -> ++n)
    .parallel()
    .filter(isPrime)
    .limit(10)
    .forEach(i -> System.out.print(i + " "));

有人能指出我在这里发生的事情的正确方向吗？

编辑:我不是在寻找更好的素性测试实现(它旨在成为一个长期运行的实现),而是为了解释使用并行流的负面影响.

我创建了一个创建128位UUID字符串的方法,我现在想检查这是否是素数.我不能将字符串放入int中,因为它太大了.任何人都可以建议我如何检查？

这是我用于创建UUID的代码

    public static String uuid()
    {
        UUID uuid = UUID.randomUUID();
        long hi = uuid.getMostSignificantBits();
        long lo = uuid.getLeastSignificantBits();
        byte[] bytes = ByteBuffer.allocate(16).putLong(hi).putLong(lo).array();
        BigInteger big = new BigInteger(bytes);
        String numericUuid = big.toString().replace('-','1'); // just in case
        //System.out.println(numericUuid);
        return(numericUuid);
    }

假设您要编写一个函数/方法来查找素数,那么最有效的方法是什么？我认为这将是一个类似这样的测试:

下面的代码在半c ++中

bool primeTest (int x) { //X is the number we're testing
    int testUpTo = (int)((sqrt(x))+1);
    for (int i=3; i<testUpTo; i+=2){
        if ((x%i)==0) {
            return false;
        }
    }
    return true;
}

有人有更好的方法去解决这个需要较少计算的事情吗？

编辑:略微改变代码,两次.我没有用任何特定的语言写这个,虽然我认为它是因为bool这个词而不是java的C++.

我正在尝试制作最快的算法,以确定数字是否为素数.我这样做的每个数字从3到100,000.

   for(int i = 3; i < 100000; i += 1)
        if(isPrime(i))
            System.out.println(i);

它需要0.52秒.我的朋友建议不要迭代偶数:

for(int i = 3; i < 100000; i += 2)
        if(isPrime(i))
            System.out.println(i);

它需要0.53秒(可能是一个随机的差异).

为什么他的建议没有减少运行时间？如果我遍历较少的数字,我希望程序运行得更快.

代码isPrime():

public static boolean isPrime(int n)
{
    if((n % 2 == 0 && n != 2) || (n % 3 == 0  && n != 3)|| (n % 5 == 0 && n != 5))
        return false;
    for(int i = 5; i < n / 5; i += 2)
    {
        if(n % …

我知道这不是寻找素数的最佳方式,也不是最有效的方法; 但是,我似乎无法找到为什么169计为素数的原因(对于较小的数字,它可以正常工作).

public static int checkPrime(int num, int i)
{
    if (i == num)
        return 1;

    else
    {
        if (num % i == 0)
            return 0;
        else
            checkPrime(num, i+1);

    }

    return 1;
}

主类:

        System.out.println("Type a number");
        number = reader.nextInt();

        if ((number % 10) % 2 == 0)
            result = 0;

        else
            result = checkPrime(number, 2);

        if (result == 1 || number == 2)
            System.out.println(number + " is a prime number");
        else
            System.out.println(number + " is NOT a prime number");

您可以使用BigInteger.isProbablePrime()生成加密安全素数吗？他们"安全"需要什么确定性？

我试图打印出一个数字的所有主要因素.我的代码如下:

public static boolean isPrime(long n){

    long i = n;

    while (i > 0){

        if (n % i == 0 && !(i == 1 || i == n)){

            return false;

        }
        i--;
    }

    return true;

}


public static void primeFactors(long n){

    long i = n;
    while (i > 0){

        if (isPrime(i)){
            System.out.println(i);
        }
        i--;
    }

}

此代码适用于小数字:5,5000,例如,当我向方法输入600851475143时,我的程序运行,没有输出任何内容.为什么会这样？