1010. Pairs of Songs With Total Durations Divisible by 60

You are given a list of songs where the ith song has a duration of time[i] seconds.

Return the number of pairs of songs for which their total duration in seconds is divisible by 60. Formally, we want the number of indices i, j such that i < j with (time[i] + time[j]) % 60 == 0.

 

Example 1:

Input: time = [30,20,150,100,40]
Output: 3
Explanation: Three pairs have a total duration divisible by 60:
(time[0] = 30, time[2] = 150): total duration 180
(time[1] = 20, time[3] = 100): total duration 120
(time[1] = 20, time[4] = 40): total duration 60
Example 2:

Input: time = [60,60,60]
Output: 3
Explanation: All three pairs have a total duration of 120, which is divisible by 60.
 

Constraints:

1 <= time.length <= 6 * 104
1 <= time[i] <= 500

题目翻译：
给定一个歌曲列表，其中第 i 首歌曲的持续时间为 time[i] 秒。
返回总持续时间（秒数）能被 60 整除的歌曲对数。形式上，我们希望找到索引 i、j 的数量，使得 i < j 且 (time[i] + time[j]) % 60 == 0。

示例 1：

输入：time = [30,20,150,100,40]
输出：3
解释：有三对歌曲总持续时间可以被 60 整除：
(time[0] = 30, time[2] = 150): 总持续时间 180
(time[1] = 20, time[3] = 100): 总持续时间 120
(time[1] = 20, time[4] = 40): 总持续时间 60
示例 2：

输入：time = [60,60,60]
输出：3
解释：所有三对歌曲总持续时间为 120，可以被 60 整除。

约束条件：

1 <= time.length <= 6 * 10^4
1 <= time[i] <= 500

// 导入必要的库
import java.util.HashMap;
import java.util.Map;

public class Solution {
    // 定义 numPairsDivisibleBy60 方法，参数为一个整数数组 time
    public int numPairsDivisibleBy60(int[] time) {
        // 创建一个 HashMap，用于存储余数和出现次数
        Map<Integer, Integer> remainders = new HashMap<>();
        // 初始化计数器
        int count = 0;

        // 遍历 time 数组
        for (int t : time) {
            // 计算当前歌曲时间与 60 的余数
            int remainder = t % 60;
            // 计算需要的另一首歌曲的余数，使得它们的总和可以被 60 整除
            int complement = (60 - remainder) % 60;

            // 如果 HashMap 中存在 complement，更新计数器
            count += remainders.getOrDefault(complement, 0);
            // 更新当前余数在 HashMap 中的计数
            remainders.put(remainder, remainders.getOrDefault(remainder, 0) + 1);
        }

        // 返回计数器结果
        return count;
    }
}

best answer
// 定义一个名为 Solution 的类
class Solution {
    // 定义一个名为 numPairsDivisibleBy60 的公共方法，参数为一个整数数组 time
    public int numPairsDivisibleBy60(int[] time) {
       
        // 初始化结果变量 ans 为 0
        int ans = 0;
        // 定义一个长度为 60 的整数数组 map，用于记录每个余数出现的次数
        int[] map = new int[60];
        // 使用 for 循环遍历整数数组 time
        for (int i = 0; i < time.length; i++) {
            // 计算当前歌曲的持续时间 time[i] 除以 60 的余数，并将其存储在变量 a 中
            int a = time[i] % 60;
            // 定义一个变量 p，并将 a 赋值给它
            int p = a;
            // 如果 a 等于 0，则将 p 设置为 60
            if (a == 0) {
                p = 60;
            }
          
            // 将 map 数组中索引为 60-p 的元素值累加到结果变量 ans 中
            ans += map[60 - p];
            
            // 将 a 位置的 map 数组元素值递增 1
            map[a]++;
        }
        // 返回结果变量 ans
        return ans;
    }
}
这段代码定义了一个名为 Solution 的类，其中包含一个名为 numPairsDivisibleBy60 的公共方法，用于计算给定歌曲列表中，总持续时间可以被 60 整除的歌曲对数。方法首先初始化结果变量 ans 为 0，并定义一个长度为 60 的整数数组 map，用于记录每个余数出现的次数。接下来，使用 for 循环遍历整数数组 time，计算当前歌曲的持续时间除以 60 的余数，并将其存储在变量 a 中。随后，根据当前余数 a 更新结果变量 ans 和 map 数组。最后，返回结果变量 ans。