标签: primes

我有一系列随机数.范围实际上由用户确定,但最多为1000个整数.它们放在这个:

vector<int> n

并且值插入如下:

srand(1);

for (i = 0; i < n; i++)
  v[i] = rand() % n;

我正在创建一个单独的函数来查找所有非素数值.这就是我现在所拥有的,但我知道这完全错了,因为我在系列中得到了素数和复合数.

void sieve(vector<int> v, int n)
{
  int i,j;

  for(i = 2; i <= n; i++)
     {
        cout << i << " % ";
        for(j = 0; j <= n; j++)
           {
              if(i % v[j] == 0)
                 cout << v[j] << endl;
           }
     }
}

当我只有0-1000的一系列数字时,这种方法通常会起作用,但是当我的数字乱序并且重复时,它似乎不起作用.有没有更好的方法在向量中找到非素数？我很想创建另一个向量,用n个数字填充它,然后找到那些非素数,但这会效率低吗？

好的,因为范围是0-1000我想知道是否更容易创建0-n排序的矢量,然后使用筛子找到素数,这是否更接近？

void sieve(vector<int> v, BST<int> t, int n)
{
  vector<int> v_nonPrime(n);
  int i,j;
  for(i = 2; …

我一直试图通过Euler项目的问题27来解决这个问题,但是这个问题似乎让我很难过.首先,代码运行时间太长了(可能在我的机器上运行几分钟,但更重要的是,它返回了错误的答案,虽然在查看了一段时间之后我真的无法发现算法有任何问题.

这是我目前的解决方案代码.

/// Checks number for primality.
let is_prime n = 
    [|1 .. 2 .. sqrt_int n|] |> Array.for_all (fun x -> n % x <> 0)

/// Memoizes a function.
let memoize f = 
    let cache = Dictionary<_, _>()
    fun x -> 
        let found, res = cache.TryGetValue(x)
        if found then
            res
        else
            let res = f x
            cache.[x] <- res
            res

/// Problem 27
/// Find a quadratic formula that produces the maximum number of …

我正在尝试编写此代码以获取第一个initialCapacity素数,然后使用java按顺序打印它们.由于两个原因,它无法正常工作,首先我得到了错误

41:无法从静态上下文引用非静态变量listOfPrimeNumbers

当我尝试运行程序时,即使我将变量更改为静态并运行程序,它也只会打印出"1".所以它只是在构造函数Primes中迭代while循环一次,然后停止,无论我看起来多么努力,我都无法找到问题!有人能帮助我,即使你可以快速看看并告诉我可能出错的地方,我真的很感激.

另外,与非静态和静态变量和方法有关的故事是什么？使用这些时的最佳做法是什么？如果有人可以将我链接到描述这个的页面(我已经google了无效!)我很想读:)

非常感谢你们!

import java.util.*;
public class Primes {
  private ArrayList<Integer> listOfPrimeNumbers;

  public static void main(String[] args) {
    ArrayList<Integer> listOfPrimeNumbers;
    Primes generator=new Primes(50);
    print();
  }

  public Primes( int initialCapacity) {
    listOfPrimeNumbers = new ArrayList<Integer>(initialCapacity);    
    int index=0;
    int counter=0;
    while (counter != initialCapacity  ) {
      if (isPrime(index)) {
        listOfPrimeNumbers.add(index);
        counter++;
        System.out.println(counter);
        index++;
      }
      else {
        index++;
      }
    }
  }
  public boolean isPrime(int candidateNo) {
    Iterator<Integer> iter = listOfPrimeNumbers.iterator( );
    //in here ! ?
    int i=2;
    while ( iter.hasNext( ) …

我有这样的事情:

palindromes=[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 101, 111, 121, ..., 99799, 99899, 99999]
# of course im generating it :)

def isPrime(number):
    for i in range(2,int(number/2)+1):
        if number%i == 0:
            return True
    return False

def removeNonPrimes(palindromes):
    for palindrom in palindromes:
        if isPrime(palindrom):
            palindromes.remove(palindrom)
    return palindromes

palindromes = removeNonPrimes(palindromes)

并且它不会删除所有非素数

我无法弄清楚为什么

附件是用于查找2个数字之间的所有素数的代码.t作为测试用例的数量n,m分别是上限和下限.我运行这个程序,它一直给我sigsegv错误.

#include <iostream>
using namespace std;
int Prime1(int n,int m)
{
    int i,j;
    //cout<<"Enter :"<<endl;
    //cin>>n;
    int x[n];
    for(i=0;i<=n;i++)
    {
        x[i]=1;
    }
    for(i=4;i<=n;i+=2)
    {
        x[i]=0;
    }
    for(i=3;i<=n;i+=2)
    {
        if(x[i])
        {
            for(j=2*i;j<=n;j+=i)
            {
                x[j]=0;
            }
        }
    }
    if(m==1)
    {
        m=m+1;}
        for(i=m;i<=n;i++)
        {
            if(x[i])
            {
                cout<<i<<endl;;
            }
        }

}
int main()
{
    int x,y,t;
    cin>>t;
    while(t!=0)
    {
        cin>>x>>y;
        cout<<endl;
        if(x>y)
        {
            Prime1(x,y);
        }
        else
        {
            Prime1(y,x);
        }
        t--;
    }
    system("pause");
}

我知道这不是寻找素数的最佳方式,也不是最有效的方法; 但是,我似乎无法找到为什么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");

我试图通过递归实现素数,我知道如何用列表来做.

在函数绑定中键入错误

primes :: [Int]   
primes = sieve [2..10]   
sieve[] = []   
sieve(x:xs) = x : sieve (filter p [xs])    
   where p x = xs `mod` x > 0

我也尝试过使用map并在应用程序中遇到类型错误

primes :: [Int]   
primes = sieve [2..10]   
sieve[] = []   
sieve(x:xs) = x : sieve (map (`mod` x > 0) [xs])

我正在努力实现与list相似的功能

sieve (a:x) = a:sieve [y| y<-x, y`mod`a > 0]

如何找到一个pascal三角形的给定行号中的数字总数,该三角形可以被一个素数整除,其中给出行号和素数我在python中使用以下代码

def factorial(x):
    result = 1
    for i in xrange(1,x+1):
        result *= i
    return result

def combination(n,r):
    return factorial(n)/(factorial(n-r)*factorial(r))

p = input()
cnt = 0
for i in range(0,n+1):
    if((combination(n,i)%p)==0):
        cnt += 1
print cnt

但是给定的代码需要很长时间才能获得大数字.你能告诉我一个更好的算法吗？

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

我有一个填充随机数的列表,我想从此列表中返回素数.所以我创建了这些函数:

def is_prime(number):
    for i in range(2, int(sqrt(number)) + 1):
        if number % i == 0:
            return False

    return number > 1

和

def filter_primes(general_list):
    return set(filter(is_prime, general_list))

但我想提高性能,那么我该如何实现呢？