我要所有质数的和等于两百万。我的程序逻辑是正确的,但是它花费了2百万的太多时间。我怎么才能让它更快呢? num_l=[]
y = int(input("enter till what number do you want the sum"))
for count in range(0,y):
num_l.append(count)
total = 0
for counter in range(0,y):
num = num_l[counter]
if num > 1:
在Haskell中,使用ghci编译器希望创建一个数据类型,它要么是空的,要么是三重的。我试图创建一个空类型,但是数据类型E不允许我使用它。你怎么正确地声明这个?
type Empty = []
data E = Zero Empty | Triple A B C
我一直收到这样的错误:期待多一个参数“空”预期的类型,但‘空’有种类‘* -> *’
我正在创建一个Python程序来确定一个数字是否为质数。这就是我所拥有的:
print("Please enter your number:")
number = int(input())
if number > 2:
for i in range (2,number):
if (number % i) == 0:
print(number, "is not prime")
break
else:
print(number, "
我目前正在处理这个问题,并计划不使用函数。但是,我有一个问题。为什么要将1初始化为标识符"prime"?
int main() {
int loop, number;
int prime = 1;
number = 11;
for(loop = 2; loop < number; loop++) {
if((number % loop) == 0) {
prime = 0;
}
}
if (prime == 1)
printf("%d is prime numb
有人能解释一下这是怎么工作的吗?我不理解的代码行在代码中做了标记。
import java.util.Scanner;
class PrimeCheck
{
public static void main(String args[])
{
boolean isPrime=true;
Scanner scan= new Scanner(System.in);
System.out.println("Enter any number:");
int num=scan.
function getPrimes(max) {
var sieve = [], i, j, primes = [];
for (i = 2; i <= max; ++i) {
if (!sieve[i]) {
// i has not been marked -- it is prime
primes.push(i);
for (j = i << 1; j <= max; j += i) {
sieve[j] = true;
}
}
}
return primes
在C++中,我想打印第一个n质数(本例中假设为n=1000)。
为了做到这一点,我从GMP库中找到了。
我假设你是这样使用它的
int n = 2;
for(int i = 0; i < 1000; i++) {
n = mpz_nextprime(n);
cout << n << endl;
}
但是由于mpz_nextprime有两个mpz_t参数,所以不能编译。
在这种情况下,如何使用mpz_nextprime?
我写了一个快速筛子来测试一个数字是否是质数。我有两个问题:
1)我测试了一个200位的质数,它错误地说它不是质数。我相信这是由于浮点错误(或类似的错误)。我如何才能使这一点更准确?
2)有没有更好的方式来写这篇文章?我使用了decimal来处理更大的数字。这是最好的方法吗?
import math
from decimal import *
def isprime(n):
i = 2
a = 1
if n == 1:
return 0
if n == 2 or n == 3:
return 1
while i < n
我一直在研究这个问题,并在网上找到了一个解决方案,但我不明白算法是如何工作的。
primes=[]
j = 2
def primenum(n,primes):
for i in range(2,len(primes)-1):
if n %i == 0:
return False
while len(primes) < 10002:
value = primenum(j,primes)
if value != False:
primes.append(j)
print(j)
j=
代码对于int数据类型工作得很好,但是600851475143似乎太大了。我怎么才能让它工作呢?
public class Main {
public static void main(String[] args) {
long a = 600851475143L;
boolean prime = false;
long big = 0L;
for (long i = 1L; i < a; i++){
if (a % i == 0){
for (int j = 2
这个小的C脚本检查一个数字是否是质数...不幸的是,它不能完全工作。我知道脚本的低效(例如sqrt优化),这些不是问题所在。
#include <stdio.h>
int main() {
int n, m;
printf("Enter an integer, that will be checked:\n"); // Set 'n' from commandline
scanf("%d", &n); // Set 'n' from commandline
//n = 5; // To s
大家好!所以我几乎完成了一个我在学校里开始研究的问题,这个问题是关于埃拉托色尼筛子的。我设法让程序打印出从2到1000的平方根的所有质数。然而,我的老师要求我使用素数假设(?)作者: C.F.高斯。他是这样说的: C. F.高斯假设(N)小于或等于N的素数的数量定义为(N) = N/loge(N),因为N接近无穷大。这就是素数假设。在for循环中,打印质数的计数器表示其序数(1、2、3等)。和(N)的值。
我试着做了另一个for循环,并打印质数,但对我来说就是不起作用!任何帮助都将不胜感激!:)
import math
def sieves(N):
x = 1000*[0]
我希望我的isPrimeNumber函数返回一个null (这样它就不会打印isPrimeNumber函数中的任何数字),但是方法显然不能返回null。我希望for循环掩盖打印的数字和质数函数,打印不在质数函数中的数字和1,即合成数字。下面是我的代码:
//prints all composite numbers
public class App {
public static void main(String[] args)
{
for(int i = 1; i <= 10000; i++)
{
if (isPrimeN
我正在尝试这个程序来找出两百万以下所有质数的总和,但由于某种原因,我得出的数字远远低于我预期的数字。
这是我的代码。一位同事说,我可能无法用我的程序捕捉到所有的素数,但他不了解C++,我也不明白我怎么会错过它们。
#include <iostream>
using namespace std;
int main()
{
int a = 500000;
int e = 0;
// this is an array to hold all the prime number i find,
// it's initialized to the
谁能告诉我如何用C语言实现算法?我需要生成质数,但是我的算法很慢。
我的代码:
#include <stdio.h>
int prime(long int i)
{
long int j;
int state = 1;
for(j=2;j<i;j++)
{
if((i%j)==0){state=0;break;}
}
return state;
}
int main()
{
int t;
long int m,n,i;
scanf("%d", &t);
我使用非常简单的算法尝试了Project Euler的问题10,运行时间看起来像几个小时。所以我在谷歌上搜索了一种有效的算法,并通过找到了这个。代码重现如下:
int main(int argc, char * argv[])
{
int p, i;
int mark_limit;
long long sum = 0;
memset(bitmask, '\0', sizeof(bitmask));
mark_limit = (int)sqrt(limit);
for (p=2 ; p <= mark_limit ; p+
“前5个以1结尾的质数是: 11,31,41,61,71
写一个程序来计算前5000个以9结尾的素数。你可以使用任何常用的编程语言,如C、C++、Java、C#、Python等。
public class nbrPremier {
public static void main(String[] args) {
int reste;
boolean flag = true;
int n = 0, 5000;
for(int i=2; i <= n/2; i++)
{
//nombre est divisible par lui-meme
reste = n%i;
//si le re
作为完全自学(和StackOverflow)的人,我是大O符号的新手,需要在即将到来的一些面试中更好地理解它。 我的问题是,当复杂度低于N时,如何在Big-O中进行注释?一个例子是质数计算器,它检查直到N/2的每个整数的余数,因为如果我们发现没有小于一半的除数,可以肯定上半部分也不会有。 那么,就符号而言,这是O(N/2),还是N变成了N = N/2? def primecheck(num):
i = 2
while i <= ( num // 2 ):
if not (num % i):
return False
i += 1
return T
我遇到了以下代码片段(函数定义):
choose (x:xs) = choosep x xs
where choosep x [] = x
choosep x (_:_) = x
choosep _ (x:xs) = choosep x xs
在中的“标准库”- 中的0.9.11/Success.curry。在此:
choose :: [a] -> a
和
choosep :: a -> [a] -> a -- BTW, not a _p_redicate
助手递归函数choosep的"p“后缀是已知的命名约定吗?它可能来自函数式编
我想知道我可以在调试或发现程序中的错误方面获得一些帮助。目标是获得用户输入,然后显示素数,从输入到零,从最大素数到最低素数。
问题是,输出包括用户输入,用户输入本身可能是质数,也可能不是质数,并且多次重复质数:(另外,我想知道为什么不包括2?
我的代码:
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
int prime, division, input;
cout << "Please enter a number you wish to
我接到了一个任务,我必须从文件中读取文本并将数字提取到DataGrid中,所以我的问题是如何知道需要多少行或/和多少列才能使DataGrid看起来更漂亮,并用数字填充。
因此,如果我有9个数字,网格应该类似于3x3,或者如果我有18 --> 6x3等等。
数字的数量可以从1到9999999 (很多)。
我在考虑做一些像这样的事情:
int x, i, j; //x-amount of numbers,i-rows,j-columns
while (i * j < a)
{
if (a % 2 == 0)
{
i++;
我需要打印从1到1,000,000的所有质数,并打印从4到10,000的所有偶数和两个质数的和。 我有一个sieve方法,它将数组中的所有非质数更改为0(这个问题特别要求这样做),我需要使用一个goldbach方法传递这个数组,并显示从4到10,000的所有偶数和两个质数之和。 问题的goldbach部分的要点是有效地打印数字,我非常确定我的解决方案使用多项式时间搜索,而正确的解决方案是通过线性时间搜索来完成的。有什么关于我如何优化这个的线索吗? import java.lang.Math;
public class sieveAndGoldbach {
public stati