Java 需要帮助计算每个数到给定数的不同素数因子的数量吗
我想计算每个整数到n的不同素数因子的数量。例如,12=2*2*3,所以它有两个不同的素数因子,2和3。我想将这些值存储在大小为n+1的数组result[]中,其中result[I]包含整数I的不同素数因子的数目 我必须在解决方案中使用以下外部方法:Java 需要帮助计算每个数到给定数的不同素数因子的数量吗,java,list,prime-factoring,Java,List,Prime Factoring,我想计算每个整数到n的不同素数因子的数量。例如,12=2*2*3,所以它有两个不同的素数因子,2和3。我想将这些值存储在大小为n+1的数组result[]中,其中result[I]包含整数I的不同素数因子的数目 我必须在解决方案中使用以下外部方法: List<Integer> getPrimes(int n) { // create array to determine which numbers are prime boolean isPrime[] = new b
List<Integer> getPrimes(int n) {
// create array to determine which numbers are prime
boolean isPrime[] = new boolean[n+1];
for(int i=2; i<=n; i++)
isPrime[i] = true; // assume all are prime, we'll filter below
for(int i=3; i*i<=n; i+=2) {
if (isPrime[i]) { // i is prime, so...
for(int j=i*i; j<=n; j+=i) // remove all its multiples
isPrime[j] = false; // by updating array
}
}
// create list with only the prime numbers
List<Integer> primes = new LinkedList<>();
primes.add(2);
for(int i=3; i<=n; i+=2)
if (isPrime[i])
primes.add(i);
return primes;
}
int[] getNumPrimeFactors(int n) {
int[] result = new int[n + 1];
int counter; // counts the number of different prime factors
boolean isPrime = true;
List<Integer> primeList = getPrimes(n);
for (int i = 2; i < result.length; i++) {
counter = 0;
// checks if i is prime
if (i % 2 == 0) {
isPrime = false;
} else {
for (int j = 3; j * j <= i; j += 2) {
if (i % j == 0)
isPrime = false;
}
}
// if i isnt prime, counts how many different prime factors it has
if (!isPrime) {
for (int prime : primeList) {
if (i % prime == 0)
counter++;
}
result[i] = counter;
} else {
result[i] = 1;
}
}
return result;
}
List getprime(int n){
//创建数组以确定哪些数字是素数
布尔isPrime[]=新布尔[n+1];
对于(int i=2;i这肯定不是最有效的算法,但在我的旧计算机(i5 3570K)上,它的工作时间高达5_000_000,略高于10秒。5_000_000的结果数组之和为14838426
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
public static List<Integer> primeFactors(int number) {
int n = number;
List<Integer> factors = new ArrayList<Integer>();
for (int i = 2; i <= n / i; i++) {
while (n % i == 0) {
factors.add(i);
n /= i;
}
}
if (n > 1) {
factors.add(n);
}
return factors;
}
public static void main(String[] args) {
int[] result = new int[5_000_001];
for (int i = 0; i < result.length; i++) {
result[i] = (int) primeFactors(i).stream().distinct().count();
}
System.out.println(Arrays.stream(result).sum());
}
}
import java.util.ArrayList;
导入java.util.array;
导入java.util.List;
公共班机{
公共静态列表参数(整数){
int n=数字;
列表因子=新的ArrayList();
对于(int i=2;i 1){
因子。添加(n);
}
回报因素;
}
公共静态void main(字符串[]args){
int[]结果=新的int[5_000_001];
for(int i=0;i
我经常发现一个标准“改进”在筛选中很有用,就是为所有值设置最小素数因子(而不仅仅是“真/假”值)。然后是“是素数”决策是检查最小素数因子lpf是否小于该值。这基本上与素数筛一样快,但为在范围内分解数字提供了更直接的途径
在Python中:
lim = 5000000+1
# precalc all least prime factors for composites in range
lpf = [i for i in range(lim)]
for m in range(4,lim,2):
lpf[m] = 2
k = 3
while k*k <= lim:
if lpf[k] == k:
for m in range(k*k, lim, 2*k):
if lpf[m] == m:
lpf[m] = k
k += 2
print('lpf done',lim) ############
# find number of distinct prime factors for each
result = [0]*lim
for a in range(2,lim):
pf = lpf[a]
fc = 1
res = a
while pf < res:
res //= pf
if pf != lpf[res]:
fc += 1
pf = lpf[res]
result[a] = fc
print(result[:11])
print(sum(result[:10+1]))
print(sum(result[:1234+1]))
print(sum(result[:1000000+1]))
lim=5000000+1
#precalc范围内复合材料的所有最小素因子
lpf=[i代表范围内的i(lim)]
对于范围内的m(4,lim,2):
lpf[m]=2
k=3
而k*k