List Erlang：打印第一个参数和第二个参数之间的素数列表

我刚到二郎，有个问题我已经在这里查看了StackOverflow，并在谷歌上做了很多搜索。

我正在尝试编写一个函数，它接受两个参数并返回它们之间的素数。我最大的问题是素数测试（检查一个数字是否为素数）。我以后再把剩下的东西修好

以下是我目前掌握的代码：

-模块（ListPrime）。
-导出（[primeList/2]）。

primeList（0,0）->
io：格式（“此处没有质数~s~n，[0]）
`

primeList（开始，完成）->
CheckPrime=完成rem启动，
如果
开始=primeList（开始，完成-1）
结束。

基本上我想做的是：


检查Finish是否为素数

如果没有，请转到下一个数字（Finish-1）

继续，直到达到基本情况


它可以编译，但它显然不能做我希望它做的事情，因为我不知道如何检查一个数字是否为素数

我知道素数的定义是什么（一个只能被自身和1整除的数），但当我想到这个定义时，我想到的唯一一件事是：

Finish rem Finish

代码行适用于所使用的任何数字。如何检查一个数字在Erlang中是否为素数？非常感谢。
下面的代码将测试一个数字是否为素数。只需调用函数isPrime，它将返回true或false

-module(isPrime).
-export([isPrime/1]).

 isPrime(0)-> false;
 isPrime(1)-> false;
 isPrime(2)-> true;


isPrime(N)->
  ChPrime = N rem 2,
  if
    ChPrime == 1 -> false;
    ChPrime =:= 1 -> true
end.

试试这个，我希望它能正常工作，只要调用函数
prime
，它就会返回
false
的
true
：

divisors(N) ->
    [ X || X <- lists:seq(1,N), (N rem X)==0].
prime(N) when N == 0; N == 1 ->
    false;
prime(2) ->
    true;
prime(N) ->
    divisors(N) == [1,N].

除数（N）->
[X | | X
错误的
素数（2）->
符合事实的
素数（N）->
除数（N）=[1，N]。
试试这个：

prime([X|_]) when X =< 1 -> error(not_a_prime);
prime([X|Ns]) -> [N || N <- Ns, N rem X /= 0].

当X=<1->错误（非素数）时，
prime（[X |)）；
素数（[X | Ns]）->[N | N您需要一个调用函数！
就这样做吧：

%% caller function
run(X, Y) ->
    prime(lists:seq(X, Y)).

%% prime function
prime([X|_]) when X =< 1 -> error(not_a_prime);
prime([X|Ns]) -> [N || N <- Ns, N rem X /= 0].

%%调用方函数
运行（X，Y）->
素数（列表：seq（X，Y））。
%%素函数
当X=<1->错误（非素数）时，素数（[X |)）；
素数（[X | Ns]）->[N | N这可能不是设置函数的最有效方法，但它可以工作：

prime(2)->true;
prime(N)when N rem 2 =:= 0-> false;
prime(3)->true;
prime(Odd)->prime(Odd,3).

prime(N,I)when N rem I =:= 0->false;
prime(N,I)when I*I > N->true;
prime(N,I)->prime(N,I+2).

primes(Start,Finish)->[X|| X <- lists:seq(Start,Finish), prime(X)].

prime（2）->true；
当N rem 2=：=0->false时的素数（N）；
素数（3）->真；
素数（奇数）->素数（奇数，3）。
当N rem I=：=0->false时的素数（N，I）；
当I*I>N->true时的素数（N，I）；
素数（N，I）->素数（N，I+2）。
底漆（开始、结束）->[X | | X在SICP中有一个关于这一点的讨论，很容易翻译成Erlang。素性测试是一个活跃的研究领域。看。这似乎只是检查2的可除性，并且知道一些数字的测试值。带有两个不同相等运算符的if语句对我来说没有多大意义。这可能有效。它是s简单地说，似乎不需要二的子句。有更快的算法。这似乎只是从Ns中提取不可被X整除的元素。