华为OD刷题C卷 - 每日刷题 11（执行时长，素数之积）

1、（执行时长）：

这段代码是解决“执行时长”的问题。它提供了一个Java类Main，其中包含main方法和getSeconds方法，用于计算在保证GPU不空闲情况下，执行完成所有任务所需的最短时间。

main方法首先读取GPU一次最多执行的任务个数max，任务数组长度length，然后读取任务数组tasks。接着，调用getSeconds方法并打印所需的总时间。

getSeconds方法通过遍历任务数组，计算每秒钟能完成的任务数，并更新剩余未完成的任务数remain。如果加上剩余任务数后超过了GPU一次执行的最大任务数max，则计算出新的剩余任务数。每处理完一个任务数组元素，时间time加1。最后，如果还有剩余任务，继续计算所需时间直到所有任务完成。

2、（素数之积）：

这段代码是解决“素数之积”的问题。它提供了一个Java类Main，其中包含main方法和getMaxPrimeMulti方法，以及一个辅助方法isPrime，用于找出一个32位正整数的两个素数因子。

main方法读取一个正整数n，然后调用getMaxPrimeMulti方法并打印分解结果。

getMaxPrimeMulti方法首先检查n是否为素数，如果是，则返回"-1 -1"表示无法分解。如果不是，代码遍历从2到sqrt(n)的所有整数，寻找能够整除n的数i。如果找到，检查i和n/i是否都是素数，如果都是，则通过StringJoiner拼接这两个数并返回结果字符串。如果没有找到符合条件的因子，或者i和n/i中有一个不是素数，则返回"-1 -1"。

isPrime方法用于判断一个数是否为素数，通过检查从2到sqrt(n)的整数是否能整除n来判断。

package OD219;

import java.util.Scanner;

/**
 * @description 执行时长
 * @level 5
 * @score 100
 */

/**
 * 题目描述
 * 为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。
 * <p>
 * 假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。
 * <p>
 * 输入描述
 * 第一个参数为GPU一次最多执行的任务个数，取值范围[1, 10000]
 * <p>
 * 第二个参数为任务数组长度，取值范围[1, 10000]
 * <p>
 * 第三个参数为任务数组，数字范围[1, 10000]
 * <p>
 * 输出描述
 * 执行完所有任务最少需要多少秒。
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //一次最多执行的个数
        int max = Integer.parseInt(sc.nextLine());
        //任务数组长度
        int length = Integer.parseInt(sc.nextLine());
        //任务
        int[] tasks = new int[length];
        for (int i = 0; i < length; i++) {
            tasks[i] = sc.nextInt();
        }
        //需要多少秒执行完
        System.out.println(getSeconds(tasks, max));
    }

    //需要多少秒执行完
    public static int getSeconds(int[] tasks, int max) {
        int time = 0;
        int remain = 0;
        for (int task : tasks) {
            if (task + remain > max) {
                //本次处理完后，还有多余任务遗留
                remain = task + remain - max;
            } else {
                //本次处理完后，没有遗留
                remain = 0;
            }
            //每一次都会花费1秒
            time++;
        }
        //如果最后还有多余任务
        while (remain > 0) {
            remain -= max;
            time++;
        }
        return time;
    }
}

package OD222;

import java.util.Scanner;
import java.util.StringJoiner;

/**
 * @description 素数之积
 * @level 6
 * @score 100
 */

/**
 * 题目描述
 * RSA加密算法在网络安全世界中无处不在，它利用了极大整数因数分解的困难度，数据越大，安全系数越高，给定一个 32 位正整数，请对其进行因数分解，找出是哪两个素数的乘积。
 * <p>
 * 输入描述
 * 一个正整数 num 0 < num < 2147483647
 * <p>
 * 输出描述
 * 如果成功找到，以单个空格分割，从小到大输出两个素数，分解失败，请输出-1, -1
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        System.out.println(getMaxPrimeMulti(n));

    }

    /**
     * 返回两个素数积 如果没有则返回-1 -1
     *
     * @param n
     * @return java.lang.String
     * @create 2024/3/21 16:54
     */
    public static String getMaxPrimeMulti(long n) {
        //如果n是素数，则肯定不能分解
        if (isPrime(n)) {
            return "-1 -1";
        }

        StringJoiner sj = new StringJoiner(" ");
        for (long i = 2; i <= Math.sqrt(n); i += 1) {
            //如果能被i整除，则判断i和整除后的结果是否是素数
            if (n % i == 0) {
                if (isPrime(i) && isPrime(n / i)) {
                    sj.add(i + "");
                    sj.add(n / i + "");
                    return sj.toString();
                } else {
                    //i或者n/i 其中有一个不是素数，则n不可能被分解为两个素数之积
                    //减少循环次数
                    break;
                }
            }
        }
        //如果没找到 则返回-1 -1
        return "-1 -1";
    }

    /**
     * 判断n是否是素数
     *
     * @param n
     * @return boolean
     * @create 2024/3/21 16:52
     */
    public static boolean isPrime(long n) {
        for (int i = 2; i <= Math.sqrt(n); i++) {
            //如果能被除了1和自身的数整除，则不是素数
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

}