华为OD机试算法： 执行时长

题目描述

为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。

假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。

输入描述

• 第一个参数为GPU一次最多执行的任务个数，取值范围[1, 10000]

• 第二个参数为任务数组长度，取值范围[1, 10000]

• 第三个参数为任务数组，数字范围[1, 10000]

输出描述

• 执行完所有任务最少需要多少秒。

用例

输入	3 5 1 2 3 4 5
输出	6
说明	一次最多执行3个任务，最少耗时6s

输入	4 5 5 4 1 1 1
输出	5
说明	一次最多执行4个任务，最少耗时5s

题目解析

• 1.

  首先，我们需要计算GPU一次最多执行的任务个数n。

• 2.

  然后，我们需要遍历任务数组，计算每秒钟需要执行的任务数量。

• 3.

  如果当前秒的任务数量小于等于n，那么直接将当前秒的任务数量累加到已完成任务总数上，并将已完成任务总数除以n向下取整得到已执行的秒数。

• 4.

  如果当前秒的任务数量大于n，那么将当前秒的任务数量减去n，然后将剩余任务数量累加到已完成任务总数上，并将已完成任务总数除以n向下取整得到已执行的秒数。

• 5.

  最后，返回已执行的秒数作为结果。

具体实现步骤如下：

• 1.

  定义一个函数min_time，接收三个参数：GPU一次最多执行的任务个数n，任务数组长度len_tasks，任务数组tasks。

• 2.

  初始化已完成任务总数completed_tasks为0，已执行的秒数executed_seconds为0。

• 3.

  遍历任务数组，对于每个任务，执行以下操作： a. 如果当前秒的任务数量小于等于n，那么将当前秒的任务数量累加到completed_tasks上，并将completed_tasks除以n向下取整得到已执行的秒数。 b. 如果当前秒的任务数量大于n，那么将当前秒的任务数量减去n，然后将剩余任务数量累加到completed_tasks上，并将completed_tasks除以n向下取整得到已执行的秒数。

• 4.

  返回executed_seconds作为结果。

Java算法源码
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    int maxCount = Integer.parseInt(br.readLine());
    int n = Integer.parseInt(br.readLine());
    int[] tasks = new int[n];
    String[] taskStrings = br.readLine().split(" ");
    for (int i = 0; i < n; i++) tasks[i] = Integer.parseInt(taskStrings[i]);

    StringBuilder sb = new StringBuilder();
    sb.append(getResult(maxCount, tasks));
    System.out.println(sb.toString());
  }

  public static int getResult(int maxCount, int[] tasks) {
    int time = 0;
    int remain = 0;

    for (int task : tasks) {
      if (task + remain > maxCount) {
        remain = task + remain - maxCount;
      } else {
        remain = 0;
      }
      time++;
    }

    time += remain / maxCount;
    if (remain % maxCount != 0) time++;

    return time;
  }
}

JS算法源码
 
 const readline = require("readline");

function getMinTime(maxCount, tasks) {
  let time = 0;
  let remain = 0;

  for (let i = 0; i < tasks.length; i++) {
    if (tasks[i] + remain > maxCount) {
      remain = tasks[i] + remain - maxCount;
    } else {
      remain = 0;
    }
    time++;
  }

  time += Math.ceil(remain / maxCount);

  return time;
}

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.question('', (input) => {
  const lines = input.split('\n');
  const maxCount = parseInt(lines[0]);
  const tasksLen = parseInt(lines[1]);
  const tasks = lines[2].split(" ").slice(0, tasksLen).map((ele) => parseInt(ele));

  console.log(getMinTime(maxCount, tasks));

  rl.close();
});

Python算法源码
 
maxCount = int(input())
n = int(input())
tasks = list(map(int, input().split()))

def getResult():
    total_time = sum(tasks)
    full_cycles, remain = divmod(total_time, maxCount)
    return full_cycles + (remain > 0)

print(getResult())