最优雅的方式来生成素数
实现此功能的最佳方式是什么：
ArrayList generatePrimes(int n)
此函数会生成第一个n素数（编辑：n>1}，因此generatePrimes(5)会返回ArrayList {2, 3, 5, 7, 11}。 （我在C＃中这样做，但我对Java实现感到满意 - 或者其他类似的语言（所以不是Haskell））。
我知道怎么写这个函数，但是当我昨晚做的时候它并没有像我希望的那样结束。以下是我提出的建议：
ArrayList generatePrimes(int toGenerate)
{
ArrayList primes = new ArrayList();
primes.Add(2);
primes.Add(3);
while (primes.Count < toGenerate)
{
int nextPrime = (int)(primes[primes.Count - 1]) + 2;
while (true)
{
bool isPrime = true;
foreach (int n in primes)
{
if (nextPrime % n == 0)
{
isPrime = false;
break;
}
}
if (isPrime)
{
break;
}
else
{
nextPrime += 2;
}
}
primes.Add(nextPrime);
}
return primes;
}
我并不太关心速度，虽然我不希望它显然效率低下。我不介意使用哪种方法（天真或筛子或其他任何方法），但我确实希望它相当短而且显而易见。
编辑：感谢所有回复的人，尽管很多人都没有回答我的实际问题。重申一下，我想要一个非常干净的代码片段来生成素数列表。我已经知道如何以不同的方式做到这一点，但我很容易编写尽可能不清晰的代码。在这个主题中，提出了一些很好的选择：
- 我原来的一个更好的版本（Peter Smit，jmservera和Rekreativc）
- Eratosthenes（starblue）筛子的非常干净的实施
- 使用Java的
BigInteger和nextProbablePrime代码非常简单，但我无法想象它的效率特别高（dfa） - 使用LINQ懒洋洋地生成素数列表（Maghis）
- 在文本文件中放入大量素数，并在必要时阅读（darin）
编辑2 ：我implemented in C#这里给出的几种方法，以及此处未提及的另一种方法。他们都有效地找到了第一个 n 素数（我有一个decent method找到了提供给筛子的限制。）
25 个答案:
答案 0 :(得分：47)
使用估算值
pi(n) = n / log(n)
为n次找到极限的素数，然后用筛子。估计低估了n的素数，因此筛子将略大于必要的，这是可以的。
这是我的标准Java筛选器，在普通笔记本电脑上计算出大约一秒钟的第一百万个素数：
public static BitSet computePrimes(int limit)
{
final BitSet primes = new BitSet();
primes.set(0, false);
primes.set(1, false);
primes.set(2, limit, true);
for (int i = 0; i * i < limit; i++)
{
if (primes.get(i))
{
for (int j = i * i; j < limit; j += i)
{
primes.clear(j);
}
}
}
return primes;
}
答案 1 :(得分：34)
非常感谢所有提供有用答案的人。以下是我在C＃中查找第一个 n 素数的几种不同方法的实现。前两种方法几乎就是这里发布的内容。 （海报名称在标题旁边。）我计划在某个时候对阿特金进行筛选，尽管我怀疑它不会像现在的方法那么简单。如果有人能够看到任何改进这些方法的方法我都很想知道： - ）
标准方法（Peter Smit，jmservera，Rekreativc）
第一个素数是2.将其添加到素数列表中。下一个素数是下一个数字，该数字不能被此列表中的任何数字整除。
public static List<int> GeneratePrimesNaive(int n)
{
List<int> primes = new List<int>();
primes.Add(2);
int nextPrime = 3;
while (primes.Count < n)
{
int sqrt = (int)Math.Sqrt(nextPrime);
bool isPrime = true;
for (int i = 0; (int)primes[i] <= sqrt; i++)
{
if (nextPrime % primes[i] == 0)
{
isPrime = false;
break;
}
}
if (isPrime)
{
primes.Add(nextPrime);
}
nextPrime += 2;
}
return primes;
}
通过仅测试可测试数字的平方根之间的可分性来优化这一点;并且只测试奇数。通过仅测试6k+[1, 5]或30k+[1, 7, 11, 13, 17, 19, 23, 29]或so on表单的数字，可以进一步优化此功能。
Eratosthenes筛选（starblue）
This finds all the primes to k。要列出第一个 n 素数，我们首先需要近似 n 素数的值。以下方法as described here执行此操作。
public static int ApproximateNthPrime(int nn)
{
double n = (double)nn;
double p;
if (nn >= 7022)
{
p = n * Math.Log(n) + n * (Math.Log(Math.Log(n)) - 0.9385);
}
else if (nn >= 6)
{
p = n * Math.Log(n) + n * Math.Log(Math.Log(n));
}
else if (nn > 0)
{
p = new int[] { 2, 3, 5, 7, 11 }[nn - 1];
}
else
{
p = 0;
}
return (int)p;
}
// Find all primes up to and including the limit
public static BitArray SieveOfEratosthenes(int limit)
{
BitArray bits = new BitArray(limit + 1, true);
bits[0] = false;
bits[1] = false;
for (int i = 0; i * i <= limit; i++)
{
if (bits[i])
{
for (int j = i * i; j <= limit; j += i)
{
bits[j] = false;
}
}
}
return bits;
}
public static List<int> GeneratePrimesSieveOfEratosthenes(int n)
{
int limit = ApproximateNthPrime(n);
BitArray bits = SieveOfEratosthenes(limit);
List<int> primes = new List<int>();
for (int i = 0, found = 0; i < limit && found < n; i++)
{
if (bits[i])
{
primes.Add(i);
found++;
}
}
return primes;
}
Sundaram筛选
我最近才发现this sieve，但它可以非常简单地实现。我的实施并不像Eratosthenes的筛子那么快，但它比天真的方法快得多。
public static BitArray SieveOfSundaram(int limit)
{
limit /= 2;
BitArray bits = new BitArray(limit + 1, true);
for (int i = 1; 3 * i + 1 < limit; i++)
{
for (int j = 1; i + j + 2 * i * j <= limit; j++)
{
bits[i + j + 2 * i * j] = false;
}
}
return bits;
}
public static List<int> GeneratePrimesSieveOfSundaram(int n)
{
int limit = ApproximateNthPrime(n);
BitArray bits = SieveOfSundaram(limit);
List<int> primes = new List<int>();
primes.Add(2);
for (int i = 1, found = 1; 2 * i + 1 <= limit && found < n; i++)
{
if (bits[i])
{
primes.Add(2 * i + 1);
found++;
}
}
return primes;
}
答案 2 :(得分：11)
重新提出一个旧问题，但在玩LINQ时我偶然发现了它。
此代码需要带有并行扩展的.NET4.0或.NET3.5
public List<int> GeneratePrimes(int n) {
var r = from i in Enumerable.Range(2, n - 1).AsParallel()
where Enumerable.Range(2, (int)Math.Sqrt(i)).All(j => i % j != 0)
select i;
return r.ToList();
}
答案 3 :(得分：9)
你正在走好路。
一些评论
-
primes.Add（3）;使该函数不适用于number = 1
-
你不必用最接近待测数字的平方根来测试分区。
建议代码：
ArrayList generatePrimes(int toGenerate)
{
ArrayList primes = new ArrayList();
if(toGenerate > 0) primes.Add(2);
int curTest = 3;
while (primes.Count < toGenerate)
{
int sqrt = (int) Math.sqrt(curTest);
bool isPrime = true;
for (int i = 0; i < primes.Count && primes.get(i) <= sqrt; ++i)
{
if (curTest % primes.get(i) == 0)
{
isPrime = false;
break;
}
}
if(isPrime) primes.Add(curTest);
curTest +=2
}
return primes;
}
答案 4 :(得分：8)
你应该看看probable primes。请特别注意Randomized Algorithms和Miller–Rabin primality test。
为了完整起见，您可以使用java.math.BigInteger：
public class PrimeGenerator implements Iterator<BigInteger>, Iterable<BigInteger> {
private BigInteger p = BigInteger.ONE;
@Override
public boolean hasNext() {
return true;
}
@Override
public BigInteger next() {
p = p.nextProbablePrime();
return p;
}
@Override
public void remove() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public Iterator<BigInteger> iterator() {
return this;
}
}
@Test
public void printPrimes() {
for (BigInteger p : new PrimeGenerator()) {
System.out.println(p);
}
}
答案 5 :(得分：6)
绝不是有效的，但可能最具可读性：
public static IEnumerable<int> GeneratePrimes()
{
return Range(2).Where(candidate => Range(2, (int)Math.Sqrt(candidate)))
.All(divisor => candidate % divisor != 0));
}
使用：
public static IEnumerable<int> Range(int from, int to = int.MaxValue)
{
for (int i = from; i <= to; i++) yield return i;
}
事实上，这里只是一些帖子的变体，格式很好。
答案 6 :(得分：4)
使用素数numbers generator创建primes.txt然后：
class Program
{
static void Main(string[] args)
{
using (StreamReader reader = new StreamReader("primes.txt"))
{
foreach (var prime in GetPrimes(10, reader))
{
Console.WriteLine(prime);
}
}
}
public static IEnumerable<short> GetPrimes(short upTo, StreamReader reader)
{
int count = 0;
string line = string.Empty;
while ((line = reader.ReadLine()) != null && count++ < upTo)
{
yield return short.Parse(line);
}
}
}
在这种情况下，我在方法签名中使用Int16，因此我的primes.txt文件包含0到32767之间的数字。如果要将其扩展为Int32或Int64，则primes.txt可能会大得多。
答案 7 :(得分：4)
版权所有2009 by St.Wittum 13189 Berlin GERMANY在CC-BY-SA许可下 https://creativecommons.org/licenses/by-sa/3.0/
计算所有PRIMES的简单但最优雅的方法是这样的， 但这种方式很慢，而且对于更高的数字，内存成本要高得多 因为使用教师（！）功能...但它演示了一种变化 Wilson Theoreme在一个应用程序中通过算法生成所有素数 用Python实现
#!/usr/bin/python
f=1 # 0!
p=2 # 1st prime
while True:
if f%p%2:
print p
p+=1
f*=(p-2)
答案 8 :(得分：4)
以下是C＃中 Eratosthenes Sieve 的实现：
IEnumerable<int> GeneratePrimes(int n)
{
var values = new Numbers[n];
values[0] = Numbers.Prime;
values[1] = Numbers.Prime;
for (int outer = 2; outer != -1; outer = FirstUnset(values, outer))
{
values[outer] = Numbers.Prime;
for (int inner = outer * 2; inner < values.Length; inner += outer)
values[inner] = Numbers.Composite;
}
for (int i = 2; i < values.Length; i++)
{
if (values[i] == Numbers.Prime)
yield return i;
}
}
int FirstUnset(Numbers[] values, int last)
{
for (int i = last; i < values.Length; i++)
if (values[i] == Numbers.Unset)
return i;
return -1;
}
enum Numbers
{
Unset,
Prime,
Composite
}
答案 9 :(得分：4)
我可以提供以下C＃解决方案。它绝不是快速的，但它的作用非常明确。
public static List<Int32> GetPrimes(Int32 limit)
{
List<Int32> primes = new List<Int32>() { 2 };
for (int n = 3; n <= limit; n += 2)
{
Int32 sqrt = (Int32)Math.Sqrt(n);
if (primes.TakeWhile(p => p <= sqrt).All(p => n % p != 0))
{
primes.Add(n);
}
}
return primes;
}
我遗漏了任何支票 - 如果限制是负数或小于2（目前该方法总是至少返回两个作为素数）。但这很容易解决。
<强>更新
使用以下两种扩展方法
public static void Do<T>(this IEnumerable<T> collection, Action<T> action)
{
foreach (T item in collection)
{
action(item);
}
}
public static IEnumerable<Int32> Range(Int32 start, Int32 end, Int32 step)
{
for (int i = start; i < end; i += step)
}
yield return i;
}
}
您可以按如下方式重写它。
public static List<Int32> GetPrimes(Int32 limit)
{
List<Int32> primes = new List<Int32>() { 2 };
Range(3, limit, 2)
.Where(n => primes
.TakeWhile(p => p <= Math.Sqrt(n))
.All(p => n % p != 0))
.Do(n => primes.Add(n));
return primes;
}
它的效率较低（因为经常重新评估平方根）但它的代码更清晰。可以重写代码来懒惰地枚举素数，但这会使代码混乱很多。
答案 10 :(得分：4)
我知道你要求非Haskell解决方案，但是我在这里包含了这个问题，因为它与这个问题有关，而且Haskell对于这类事情也很漂亮。
module Prime where
primes :: [Integer]
primes = 2:3:primes'
where
-- Every prime number other than 2 and 3 must be of the form 6k + 1 or
-- 6k + 5. Note we exclude 1 from the candidates and mark the next one as
-- prime (6*0+5 == 5) to start the recursion.
1:p:candidates = [6*k+r | k <- [0..], r <- [1,5]]
primes' = p : filter isPrime candidates
isPrime n = all (not . divides n) $ takeWhile (\p -> p*p <= n) primes'
divides n p = n `mod` p == 0
答案 11 :(得分：3)
我使用一些LINQ在c＃中编写了一个简单的Eratosthenes实现。
不幸的是，LINQ不提供无限的整数序列，所以你必须使用int.MaxValue：（
我不得不在一个无限类型中缓存候选sqrt，以避免为每个缓存的素数计算它（看起来有点难看）。
我使用之前的素数列表直到候选人的sqrt
cache.TakeWhile(c => c <= candidate.Sqrt)
并检查每个Int从2开始对它
.Any(cachedPrime => candidate.Current % cachedPrime == 0)
以下是代码：
static IEnumerable<int> Primes(int count)
{
return Primes().Take(count);
}
static IEnumerable<int> Primes()
{
List<int> cache = new List<int>();
var primes = Enumerable.Range(2, int.MaxValue - 2).Select(candidate => new
{
Sqrt = (int)Math.Sqrt(candidate), // caching sqrt for performance
Current = candidate
}).Where(candidate => !cache.TakeWhile(c => c <= candidate.Sqrt)
.Any(cachedPrime => candidate.Current % cachedPrime == 0))
.Select(p => p.Current);
foreach (var prime in primes)
{
cache.Add(prime);
yield return prime;
}
}
另一个优化是避免在创建List之前检查偶数并返回2。 这样，如果调用方法只需要1个prime，它将避免所有混乱：
static IEnumerable<int> Primes()
{
yield return 2;
List<int> cache = new List<int>() { 2 };
var primes = Enumerable.Range(3, int.MaxValue - 3)
.Where(candidate => candidate % 2 != 0)
.Select(candidate => new
{
Sqrt = (int)Math.Sqrt(candidate), // caching sqrt for performance
Current = candidate
}).Where(candidate => !cache.TakeWhile(c => c <= candidate.Sqrt)
.Any(cachedPrime => candidate.Current % cachedPrime == 0))
.Select(p => p.Current);
foreach (var prime in primes)
{
cache.Add(prime);
yield return prime;
}
}
答案 12 :(得分：3)
使用相同的算法可以做得更短：
List<int> primes=new List<int>(new int[]{2,3});
for (int n = 5; primes.Count< numberToGenerate; n+=2)
{
bool isPrime = true;
foreach (int prime in primes)
{
if (n % prime == 0)
{
isPrime = false;
break;
}
}
if (isPrime)
primes.Add(n);
}
答案 13 :(得分：1)
这是一个python代码示例，打印出低于200万的所有素数的总和：
from math import *
limit = 2000000
sievebound = (limit - 1) / 2
# sieve only odd numbers to save memory
# the ith element corresponds to the odd number 2*i+1
sieve = [False for n in xrange(1, sievebound + 1)]
crosslimit = (int(ceil(sqrt(limit))) - 1) / 2
for i in xrange(1, crosslimit):
if not sieve[i]:
# if p == 2*i + 1, then
# p**2 == 4*(i**2) + 4*i + 1
# == 2*i * (i + 1)
for j in xrange(2*i * (i + 1), sievebound, 2*i + 1):
sieve[j] = True
sum = 2
for i in xrange(1, sievebound):
if not sieve[i]:
sum = sum + (2*i+1)
print sum
答案 14 :(得分：1)
在Functional Java中使用基于流的编程，我想出了以下内容。类型Natural基本上是BigInteger＆gt; = 0。
public static Stream<Natural> sieve(final Stream<Natural> xs)
{ return cons(xs.head(), new P1<Stream<Natural>>()
{ public Stream<Natural> _1()
{ return sieve(xs.tail()._1()
.filter($(naturalOrd.equal().eq(ZERO))
.o(mod.f(xs.head())))); }}); }
public static final Stream<Natural> primes
= sieve(forever(naturalEnumerator, natural(2).some()));
现在你有一个值，你可以携带，这是一个无限的素数流。你可以这样做：
// Take the first n primes
Stream<Natural> nprimes = primes.take(n);
// Get the millionth prime
Natural mprime = primes.index(1000000);
// Get all primes less than n
Stream<Natural> pltn = primes.takeWhile(naturalOrd.lessThan(n));
对筛子的解释：
- 假设参数流中的第一个数字是素数，并将其放在返回流的前面。返回流的其余部分是仅在被要求时才生成的计算。
- 如果有人要求流的其余部分，请在参数流的其余部分调用筛子，过滤掉可被第一个数字整除的数字（除法的余数为零）。
您需要进行以下导入：
import fj.P1;
import static fj.FW.$;
import static fj.data.Enumerator.naturalEnumerator;
import fj.data.Natural;
import static fj.data.Natural.*;
import fj.data.Stream;
import static fj.data.Stream.*;
import static fj.pre.Ord.naturalOrd;
答案 15 :(得分：1)
我个人认为这是一个很短的＆amp;干净（Java）实现：
static ArrayList<Integer> getPrimes(int numPrimes) {
ArrayList<Integer> primes = new ArrayList<Integer>(numPrimes);
int n = 2;
while (primes.size() < numPrimes) {
while (!isPrime(n)) { n++; }
primes.add(n);
n++;
}
return primes;
}
static boolean isPrime(int n) {
if (n < 2) { return false; }
if (n == 2) { return true; }
if (n % 2 == 0) { return false; }
int d = 3;
while (d * d <= n) {
if (n % d == 0) { return false; }
d += 2;
}
return true;
}
答案 16 :(得分：1)
我使用我编写的函数库在Java中完成它，但由于我的库使用与Enumerations相同的概念，我确信代码是可适应的：
Iterable<Integer> numbers = new Range(1, 100);
Iterable<Integer> primes = numbers.inject(numbers, new Functions.Injecter<Iterable<Integer>, Integer>()
{
public Iterable<Integer> call(Iterable<Integer> numbers, final Integer number) throws Exception
{
// We don't test for 1 which is implicit
if ( number <= 1 )
{
return numbers;
}
// Only keep in numbers those that do not divide by number
return numbers.reject(new Functions.Predicate1<Integer>()
{
public Boolean call(Integer n) throws Exception
{
return n > number && n % number == 0;
}
});
}
});
答案 17 :(得分：1)
尝试此LINQ查询，它会按预期生成素数
var NoOfPrimes= 5;
var GeneratedPrime = Enumerable.Range(1, int.MaxValue)
.Where(x =>
{
return (x==1)? false:
!Enumerable.Range(1, (int)Math.Sqrt(x))
.Any(z => (x % z == 0 && x != z && z != 1));
}).Select(no => no).TakeWhile((val, idx) => idx <= NoOfPrimes-1).ToList();
答案 18 :(得分：1)
// Create a test range
IEnumerable<int> range = Enumerable.Range(3, 50 - 3);
// Sequential prime number generator
var primes_ = from n in range
let w = (int)Math.Sqrt(n)
where Enumerable.Range(2, w).All((i) => n % i > 0)
select n;
// Note sequence of output:
// 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
foreach (var p in primes_)
Trace.Write(p + ", ");
Trace.WriteLine("");
答案 19 :(得分：1)
为了使它更优雅，你应该将你的IsPrime测试重构为一个单独的方法，并在其之外处理循环和增量。
答案 20 :(得分：1)
这是我能在短时间内想到的最优雅的。
ArrayList generatePrimes(int numberToGenerate)
{
ArrayList rez = new ArrayList();
rez.Add(2);
rez.Add(3);
for(int i = 5; rez.Count <= numberToGenerate; i+=2)
{
bool prime = true;
for (int j = 2; j < Math.Sqrt(i); j++)
{
if (i % j == 0)
{
prime = false;
break;
}
}
if (prime) rez.Add(i);
}
return rez;
}
希望这有助于给你一个想法。我确信这可以进行优化，但它可以让您了解如何使您的版本更加优雅。
编辑：如评论中所述，此算法确实为numberToGenerate＆lt;返回了错误的值。 2.我只想指出，我并没有试图给他发一个很好的方法来产生素数（看看亨利的答案），我正在指出他的方法如何变得更优雅。
答案 21 :(得分：0)
最简单的方法是试错：如果2到n-1之间的任何数字除以候选素数，你可以尝试。
第一个快捷方式当然是a）你只需要检查奇数，而b）你只能检查高达sqrt（n）的分频器。
在您的情况下，您也可以在此过程中生成所有先前的素数，您只需要检查列表中的任何素数（最多为sqrt（n））是否除以n。 应该是你能获得的最快的钱： - ）
修改
好的，代码，你问了。但我警告你:-)，这是5分钟快速而又脏的Delphi代码：
procedure TForm1.Button1Click(Sender: TObject);
const
N = 100;
var
PrimeList: TList;
I, J, SqrtP: Integer;
Divides: Boolean;
begin
PrimeList := TList.Create;
for I := 2 to N do begin
SqrtP := Ceil(Sqrt(I));
J := 0;
Divides := False;
while (not Divides) and (J < PrimeList.Count)
and (Integer(PrimeList[J]) <= SqrtP) do begin
Divides := ( I mod Integer(PrimeList[J]) = 0 );
inc(J);
end;
if not Divides then
PrimeList.Add(Pointer(I));
end;
// display results
for I := 0 to PrimeList.Count - 1 do
ListBox1.Items.Add(IntToStr(Integer(PrimeList[I])));
PrimeList.Free;
end;
答案 22 :(得分：0)
我通过在Wikki上首次阅读“Atve的Sieve”加上我之前给出的一些想法得到了这一点 - 我花了很多时间从头开始编写代码并完全归于那些批评我编译器的人，非常密集的编码风格+我甚至没有第一次尝试运行代码...我学习使用的许多范例都在这里，只需阅读和哭泣，得到你能做到的。
绝对＆amp;在任何使用之前完全确定要测试所有这些，当然不要向任何人展示 - 这是为了阅读和考虑这些想法。我需要让primality工具工作，所以这是我每次开始工作时开始的地方。
获得一个干净的编译，然后开始删除有缺陷的东西 - 我有近1.08万次可用代码的按键操作，这样做，...使用你可以做的。
我明天会处理我的版本。
package demo;
// This code is a discussion of an opinion in a technical forum.
// It's use as a basis for further work is not prohibited.
import java.util.Arrays;
import java.util.HashSet;
import java.util.ArrayList;
import java.security.GeneralSecurityException;
/**
* May we start by ignores any numbers divisible by two, three, or five
* and eliminate from algorithm 3, 5, 7, 11, 13, 17, 19 completely - as
* these may be done by hand. Then, with some thought we can completely
* prove to certainty that no number larger than square-root the number
* can possibly be a candidate prime.
*/
public class PrimeGenerator<T>
{
//
Integer HOW_MANY;
HashSet<Integer>hashSet=new HashSet<Integer>();
static final java.lang.String LINE_SEPARATOR
=
new java.lang.String(java.lang.System.getProperty("line.separator"));//
//
PrimeGenerator(Integer howMany) throws GeneralSecurityException
{
if(howMany.intValue() < 20)
{
throw new GeneralSecurityException("I'm insecure.");
}
else
{
this.HOW_MANY=howMany;
}
}
// Let us then take from the rich literature readily
// available on primes and discount
// time-wasters to the extent possible, utilizing the modulo operator to obtain some
// faster operations.
//
// Numbers with modulo sixty remainder in these lists are known to be composite.
//
final HashSet<Integer> fillArray() throws GeneralSecurityException
{
// All numbers with modulo-sixty remainder in this list are not prime.
int[]list1=new int[]{0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
32,34,36,38,40,42,44,46,48,50,52,54,56,58}; //
for(int nextInt:list1)
{
if(hashSet.add(new Integer(nextInt)))
{
continue;
}
else
{
throw new GeneralSecurityException("list1");//
}
}
// All numbers with modulo-sixty remainder in this list are are
// divisible by three and not prime.
int[]list2=new int[]{3,9,15,21,27,33,39,45,51,57};
//
for(int nextInt:list2)
{
if(hashSet.add(new Integer(nextInt)))
{
continue;
}
else
{
throw new GeneralSecurityException("list2");//
}
}
// All numbers with modulo-sixty remainder in this list are
// divisible by five and not prime. not prime.
int[]list3=new int[]{5,25,35,55};
//
for(int nextInt:list3)
{
if(hashSet.add(new Integer(nextInt)))
{
continue;
}
else
{
throw new GeneralSecurityException("list3");//
}
}
// All numbers with modulo-sixty remainder in
// this list have a modulo-four remainder of 1.
// What that means, I have neither clue nor guess - I got all this from
int[]list4=new int[]{1,13,17,29,37,41,49,53};
//
for(int nextInt:list4)
{
if(hashSet.add(new Integer(nextInt)))
{
continue;
}
else
{
throw new GeneralSecurityException("list4");//
}
}
Integer lowerBound=new Integer(19);// duh
Double upperStartingPoint=new Double(Math.ceil(Math.sqrt(Integer.MAX_VALUE)));//
int upperBound=upperStartingPoint.intValue();//
HashSet<Integer> resultSet=new HashSet<Integer>();
// use a loop.
do
{
// One of those one liners, whole program here:
int aModulo=upperBound % 60;
if(this.hashSet.contains(new Integer(aModulo)))
{
continue;
}
else
{
resultSet.add(new Integer(aModulo));//
}
}
while(--upperBound > 20);
// this as an operator here is useful later in your work.
return resultSet;
}
// Test harness ....
public static void main(java.lang.String[] args)
{
return;
}
}
//eof
答案 23 :(得分：0)
要查找前100个素数，可以考虑以下java代码。
int num = 2;
int i, count;
int nPrimeCount = 0;
int primeCount = 0;
do
{
for (i = 2; i <num; i++)
{
int n = num % i;
if (n == 0) {
nPrimeCount++;
// System.out.println(nPrimeCount + " " + "Non-Prime Number is: " + num);
num++;
break;
}
}
if (i == num) {
primeCount++;
System.out.println(primeCount + " " + "Prime number is: " + num);
num++;
}
}while (primeCount<100);
答案 24 :(得分：0)
试试这段代码。
protected bool isPrimeNubmer(int n)
{
if (n % 2 == 0)
return false;
else
{
int j = 3;
int k = (n + 1) / 2 ;
while (j <= k)
{
if (n % j == 0)
return false;
j = j + 2;
}
return true;
}
}
protected void btn_primeNumbers_Click(object sender, EventArgs e)
{
string time = "";
lbl_message.Text = string.Empty;
int num;
StringBuilder builder = new StringBuilder();
builder.Append("<table><tr>");
if (int.TryParse(tb_number.Text, out num))
{
if (num < 0)
lbl_message.Text = "Please enter a number greater than or equal to 0.";
else
{
int count = 1;
int number = 0;
int cols = 11;
var watch = Stopwatch.StartNew();
while (count <= num)
{
if (isPrimeNubmer(number))
{
if (cols > 0)
{
builder.Append("<td>" + count + " - " + number + "</td>");
}
else
{
builder.Append("</tr><tr><td>" + count + " - " + number + "</td>");
cols = 11;
}
count++;
number++;
cols--;
}
else
number++;
}
builder.Append("</table>");
watch.Stop();
var elapsedms = watch.ElapsedMilliseconds;
double seconds = elapsedms / 1000;
time = seconds.ToString();
lbl_message.Text = builder.ToString();
lbl_time.Text = time;
}
}
else
lbl_message.Text = "Please enter a numberic number.";
lbl_time.Text = time;
tb_number.Text = "";
tb_number.Focus();
}
这是aspx代码。
<form id="form1" runat="server">
<div>
<p>Please enter a number: <asp:TextBox ID="tb_number" runat="server"></asp:TextBox></p>
<p><asp:Button ID="btn_primeNumbers" runat="server" Text="Show Prime Numbers" OnClick="btn_primeNumbers_Click" />
</p>
<p><asp:Label ID="lbl_time" runat="server"></asp:Label></p>
<p><asp:Label ID="lbl_message" runat="server"></asp:Label></p>
</div>
</form>
结果： 少于一秒的10000个素数
63秒内100000个素数
前100个Prime数字的屏幕截图
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？