public class Prime
{
public static void main(String args[]){
int i,m=0,flag=0;
int n=3;//it is the number to be checked
m=n/2;
if(n==0||n==1){
System.out.print(n+" is not prime number");
}
else
{
for(i=2;i<=m;i++)//Why are we using m here
为什么这个算法具有指数时间复杂度?
我知道"Modulus“是一个按位运算的运算符,对单个位进行运算。因此,在最坏的情况下,我们需要执行sqrt(2^n)除法。这是一种exp时间算法。
如果这是真的,那么所有的算法不会变成指数时间吗?请解释一下。
Find-Factor(X)
1: if X is even then
2: return ”2 is a factor”
3: end if
4: for i = 3 to Sqrt(X) by +2 do
5: test if X%i = 0, if yes, output ”i is a factor”
6: end for
7
这个程序生成质数。它工作得很好,但我想加快速度,因为它需要相当长的时间来生成所有的质数
#!/usr/bin/python
#intgr = int(raw_input ("Please enter your number: "))
intgr = 50000
for i in range (2, intgr+1):
j = 2
while j<i:
if (i%j) == 0:
break
j += 1
if j == i:
#print "prime",
我想弄清楚这段代码的大O复杂度: prime_factorize(N) {
for (int i = 2; i <= N; i++) {
while (N % i == 0) {
print i
N = N / i
}
}
} 这实际上不是一种编程语言--它只是伪代码。 我知道伪代码在做什么。我也知道代码可以优化为只到sqrt(N),但我想在发布代码时弄清楚代码的运行时。 虽然很容易说运行时是二次的,但我非常确定这是错误的。我之所以认为它是错误的,是因为我知道质数筛分算法是在O(nloglogn)
我在试着做一个素数列表。我已经对它进行了编码,但它只告诉我1 - 100的质数是1。我不确定为什么会发生这种情况。我也想为它做一个JFrame。
import javax.swing.JOptionPane;
public class ProgrammingAssignment7 {
public static void main(String[] args) {
//Scanner Scan = new Scanner (System.in);
//DECLARE VARIABLES
int x = 1;
int i
//获取2到给定范围内的质数//当内部for循环运行2号时,它将9打印为质数。
import java.util.*;
import java.io.*;
class A
{
public static void main(String args[])
{
System.out.println("Enter the number till which the prime number is to be printed:");
Scanner sc = new Scanner(System.in);
int limit = sc.nextInt();
我已经开发了一个算法来寻找给定数字的因子。因此,它还有助于确定给定的数字是否为质数。我觉得这是寻找因子或质数的最快算法。
该算法确定给定的数字在5*N (其中N是输入数字)的时间范围内是否为质数。所以我希望我可以称之为线性时间算法。
如何验证这是否是可用的最快算法?在这件事上有人能帮上忙吗?(比GNFS和其他已知文件系统更快)
算法如下所示
Input: A Number (whose factors is to be found)
Output: The two factor of the Number. If the one of the factor found is 1 then it
我是一个java的初学者,不能理解"count“在这个程序中的用法。我必须在用户输入的某个范围内打印质数。
import java.util.Scanner;
public class JavaProgram
{
public static void main(String args[])
{
int start, end, i, j, count=0;
Scanner scan = new Scanner(System.in);
System.out.print("Enter the Range :\n&
我写了一个快速筛子来测试一个数字是否是质数。我有两个问题:
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
我有一段检查给定数字是否为质数的代码:
If x Mod 2 = 0 Then
Return False
End If
For i = 3 To x / 2 + 1 Step 2
If x Mod i = 0 Then
Return False
End If
Next
Return True
我只对numbers 1E7 <= x <= 2E7使用它。然而,它非常慢-我几乎不能一秒检查300个号码,所以检查所有的x需要超过23天的时间……
有没有人能给我一些改进的建议,或者说一下我可能会以这种方式重复做些什么?
IsNumberPrime(int num):
if num <= 1: return False
i = 0
end = sqrt(num)
while ArrayOfPrimes[i] <= end:
if (num % ArrayOfPrimes[i]) == 0: return False
i = i + 1
return True
此算法检查给定的数字是否为质数ArrayOfPrimes是包含前1000个质数的数组,如2,3,5,7,11……根据我的方法,由于这个算法将只检查直到给定数字的平方根,所以它应该不会超过sqrt(n)/2,所以我的理解是它应该是sqrt
有什么方法可以查看gympy的源代码吗?具体来说,gmpy2.is_prime。
我试过不同的链接
我哪儿都找不到。
我下载了gmpy2,并检查了我的本地驱动器,但是文件扩展名是.pyd。当我打开它时(用记事本),下面是我看到的第几行-
MZ ÿÿ ¸ @ ð º ´ Í!¸LÍ!This program cannot be run in DOS mode.
其余的都是胡言乱语。
我想要写一个非常快的质数检查器,这是我到目前为止遇到的最好的,有人能告诉我如何获得
[x for x in range(1,100) if all(x%y for y in range(2,x))]
不能理解上面的代码是如何返回正确结果的,而应该是
[x for x in range(1,100) if all(x%y!=0 for y in range(2,x))]
原因是如果只有一个条件为True,则所有条件都为True。
我想要一个n数的列表,检查每一项的质数,并记录给定的数是否为质数。不幸的是,我下面显示的代码不能正常工作,我需要帮助找出为什么会发生这种情况。
我的代码片段:
l1 = []
num = int(input("Enter a range of numbers :: "))
for i in range(2, num + 1):
l1.append(i)
for i in range(0, num - 1):
for j in range(2, num):
if l1[i] % j == 0:
print(f'{l1
我正在做项目Euler #7,我写了:
public class Seven {
public static void main(String[] args) {
int i = 0;
int c = 1;
while (c <= 10001) {
if (squareRootIsPrime(i)) {
c++;
}
i++;
}
System.out.println(Math.sqr
我已经在 (SPOJ)上完成了一些挑战,但我似乎无法让 (主生成器)在时间限制内运行。如何提高以下代码的速度?
#include <stdio.h>
#include <math.h>
int is_prime(int n);
void make_sieve();
void fast_prime(int n);
int primes[16000];
int main()
{
int nlines;
int m, n;
make_sieve();
scanf("%d", &nlines);
for (;
我正在解决Euler项目中的问题3问题:
13195的素因子为5、7、13和29。数字600851475143中最大的素因子是什么?
我发现的大多数答案都是利用数组来存储主要因素,并迭代它们来找到最伟大的一个,这似乎不太好。
我最近正在学习js,这在我看来并不像javascript那么简单。有什么办法可以重构这个吗?
var highestPrime = 2;
function divide (limit){
for (var i=3; i<Math.floor(limit/2)+1; i++) {
if (limit%i == 0){
c
朋友们,我有一个示例控制台应用程序,它有一个计算给定数字的因子的方法,并返回与list相同的结果。
如果输入的数字小于9位,则程序工作正常。但是,如果输入的数字是12位数字,则执行将永远进行,并且没有输出,也没有异常。
我附上了执行代码..。
static void Main(string[] args)
{
var list = GetFactors(600851475143);
}
static List<long> GetFactors(long bigNum)
{
var list = new List<long>();
lon
下面代码的运行时间真的很长,有没有更有效的方法来计算200万以下所有质数的和?
primeNumberList = []
previousNumberList = []
for i in range(2,2000000):
for x in range(2,i):
previousNumberList.append(x)
if all(i % n > 0 for n in previousNumberList):
primeNumberList.append(i)
previousNumberList = []
print(s
我要所有质数的和等于两百万。我的程序逻辑是正确的,但是它花费了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:
我曾尝试为编写代码,但显然失败了。所以如果我理解的很好:如果p是质数,那么((a^p)-a)%p=0其中就是p%a!=0。我的代码看起来没问题,因此很可能是我误解了基础知识。这里我漏掉了什么?
private bool IsPrime(int candidate)
{
//checking if candidate = 0 || 1 || 2
int a = candidate + 1; //candidate can't be divisor of candidate+1
if ((Math.Pow(a, candidate)
我正在尝试使用来分解小的(少于40位)复合整数。
import math
from fractions import gcd
import random
def lenstra_elliptic_curve_factor(N):
""" Lenstra's elliptic curve factoring method """
if N <=0:
raise Exception("Integer %s must be possitive " % N)
# Can'