(显示素数因子)——————刚学Java的新人写代码

编写一个程序,提示用户输入一个正整数,然后以降序显示它的所有最小因子。 例如:如果整数为120, 那么显示的最小因子为 5、3、2、2、2。使用StackOflntegers类存 储因子(例如:2、2、2、3、5), 获取之后按倒序显示这些因子

————————方法块:

import java.util.Arrays;

public class StackOfIntegers {
    private int integer;

    public StackOfIntegers(int integer) {
        this.integer = integer;
    }

    private static int k = 0;
    //存储所有的素数
    private static int l = 0;

    //存储素数因子
    //验证是否为素数
    public int[] GetPrime() {
        int[] getPrime = new int[this.integer];
        //prime下标
        boolean isPrime = true;
        for (int i = 2; i < this.integer; i++) {
            for (int h = 2; h < i; h++) {
                if (i % h == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                getPrime[k] = i;
                k++;
            } else isPrime = true;
        }
        return getPrime;
    }

    //计算出所有的素数
    public int[] Prime() {
        int[] get = GetPrime();
        int[] prime1 = new int[k];
        boolean judge=false;
        while (this.integer != 0) {
            for (int a = k - 1; a >= 0; a--) {
                if ((int) (this.integer / get[a]) == (double) this.integer / get[a]) {
                    prime1[l] = get[a];
                    this.integer /= get[a];
                    l++;
                }
                if (integer == get[a] || integer == 1) {
                    prime1[l] = get[a];
                    judge=true;
                    break;
                }
            }
            if (judge)
                break;
        }
        int[] prime=new int[l+1];
        for (int i=0;i<l+1;i++){
            prime[i]=prime1[i];
        }
        Arrays.sort(prime);
        return prime;
    }
}

——————代码块

import java.util.Arrays;
import java.util.Scanner;

public class Exercise10_05 {
    public static void main(String[] args) {
        System.out.print("Please input a integer :");
        Scanner input = new Scanner(System.in);
        int integer=input.nextInt();
        StackOfIntegers stackOfIntegers = new StackOfIntegers(integer);
        int[] a=stackOfIntegers.Prime();
        System.out.print("All the prime factors of the "+integer+ " are :");
        System.out.print(Arrays.toString(a));
        input.close();
    }
}

在这里插入图片描述

  • 1
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
寻找质数因子的问题可以用多进程来解决,其中可以利用共享内存来进行进程之间的通信。 首先,我们可以将寻找质数因子的任务分成多个子任务,每个子任务由一个进程来处理。每个进程都会搜索一定范围内的整数,以找到这些整数的所有质数因子。这里可以使用线性筛法或试除法等算法来实现。 为了避免每个进程都需要重新计算和存储质数表,我们可以利用共享内存来存储质数表,并让每个进程共享这个质数表。这样可以减少计算量和内存占用。 具体实现上,我们可以创建一个共享内存段,并在其中存储质数表。然后,创建多个子进程,每个子进程都可以访问这个共享内存段,并从中获取质数表。每个子进程都会搜索一定范围内的整数,并将找到的质数因子存储在共享内存段中。父进程可以等待所有子进程结束后,从共享内存段中读取所有的质数因子,以得到整个数的所有质数因子。 需要注意的是,共享内存的使用需要考虑进程之间的同步和互斥问题,以避免竞争条件和数据一致性问题。可以使用信号量或互斥锁等机制来解决这些问题。 下面是一个简单的示例代码,用于寻找一个数的所有质数因子: ```python import multiprocessing import ctypes # 线性筛法生成质数表 def generate_primes(n): is_prime = [True] * (n+1) primes = [] for i in range(2, n+1): if is_prime[i]: primes.append(i) for p in primes: if p * i > n: break is_prime[p * i] = False if i % p == 0: break return primes # 子进程函数,搜索一定范围内的整数,并将找到的质数因子存储在共享内存段中 def find_prime_factors(start, end, primes, shared_array): for i in range(start, end+1): n = i for p in primes: while n % p == 0: shared_array[i-start].append(p) n //= p if __name__ == '__main__': # 创建共享内存段和进程池 shared_array_size = 1000 shared_array = multiprocessing.Array(ctypes.py_object, shared_array_size) pool_size = multiprocessing.cpu_count() pool = multiprocessing.Pool(processes=pool_size) # 生成质数表 max_num = 100 primes = generate_primes(max_num) # 分配子任务给进程池 chunk_size = max_num // pool_size chunk_starts = [i * chunk_size for i in range(pool_size)] chunk_ends = [(i+1) * chunk_size - 1 for i in range(pool_size)] chunk_ends[-1] = max_num results = [] for i in range(pool_size): start = chunk_starts[i] end = chunk_ends[i] result = pool.apply_async(find_prime_factors, args=(start, end, primes, shared_array)) results.append(result) # 等待所有子进程结束 for result in results: result.wait() # 从共享内存段中读取所有的质数因子 all_factors = [] for i in range(max_num): factors = shared_array[i] if len(factors) > 0: all_factors.append((i, factors)) print(all_factors) ``` 在上面的代码中,我们使用了共享内存段来存储每个整数的质数因子列表。在每个子进程中,我们搜索了一定范围内的整数,并将找到的质数因子加入到对应整数的质数因子列表中。在父进程中,我们从共享内存段中读取了所有的质数因子,并输出了结果。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值