一、问题描述

题目描述

华为商城举办了一个促销活动，如果某顾客是某一秒内最早时刻下单的顾客（可能是多个人），则可以获取免单。

请你编程计算有多少顾客可以获取免单。

输入描述

输入为 n 行数据，每一行表示一位顾客的下单时间

以（年-月-日时-分-秒.毫秒） yyyy-MM-ddHH:mm:ss.fff 形式给出。

0<n<50000
2000<yyyy<2020
0<MM<=12
0<dd<=28
0<=HH<=23
0<=mm<=59
0<=ss<=59
0<=fff<=999

所有输入保证合法。

输出描述

输出一个整数，表示有多少顾客可以获取免单。

用例

输入

3
2019-01-01 00:00:00.001
2019-01-01 00:00:00.002
2019-01-01 00:00:00.003

输出

1

说明
样例 1 中，三个订单都是同一秒内下单，只有第一个订单最早下单，可以免单。

输入

3
2019-01-01 08:59:00.123
2019-01-01 08:59:00.123
2018-12-28 10:08:00.999

输出

3

说明
样例 2 中，前两个订单是同一秒内同一时刻（也是最早）下单，都可免单，第三个订单是当前秒内唯一一个订单（也是最早），也可免单。

输入

5
2019-01-01 00:00:00.004
2019-01-01 00:00:00.004
2019-01-01 00:00:01.006
2019-01-01 00:00:01.006
2019-01-01 00:00:01.005

输出

3

说明
样例 3 中，前两个订单是同一秒内同一时刻（也是最早）下单，第三第四个订单不是当前秒内最早下单，不可免单，第五个订单可以免单。

题目解析

考察数组排序以及字符串操作。

问题分析

要解决这个问题，我们需要确定每个秒内最早下单的顾客数量。关键步骤如下：

1. 解析时间字符串：将输入的时间字符串解析为可以比较的时间格式。这通常涉及到将字符串分割成年、月、日、时、分、秒和毫秒等部分，并转换为适当的数据类型（如整数）。

2. 排序：将所有时间按先后顺序排序。这可以通过使用标准的排序算法实现，如快速排序或归并排序，这些算法在大多数编程语言的标准库中都有实现。

3. 识别最早下单的顾客：遍历排序后的时间列表，识别每一秒内的第一个订单。如果多个订单在同一秒且同一毫秒发生，则这些订单都被认为是该秒的最早订单。

算法逻辑

1. 读取和解析输入：将输入的时间字符串存储在一个列表中，并解析为时间对象或结构，以便于比较。
2. 排序：对解析后的时间列表进行排序。
3. 遍历排序后的时间列表：
   • 初始化一个变量 last_second 来记录上一个处理的时间的秒部分，初始设为一个不可能的值（如 -1）。
   • 初始化一个计数器 exempt_count 来记录可以免单的顾客数量。
   • 遍历排序后的时间列表，对于每个时间：
     • 提取当前时间的秒部分。
     • 如果当前时间的秒部分与 last_second 不同，说明进入了新的一秒，将 last_second 更新为当前秒，并增加 exempt_count。
     • 如果当前时间的秒部分与 last_second 相同，检查毫秒部分，如果与上一个订单的毫秒相同，也增加 exempt_count。
4. 输出结果：输出 exempt_count 作为结果。

这种方法确保了我们能够准确地识别每一秒内的最早订单，从而计算出可以免单的顾客数量。时间复杂度主要由排序步骤决定，为 O(n log n)，其中 n 是订单数量。

二、JavaScript算法源码

以下是 JavaScript 代码的详细中文注释和讲解：

---

JavaScript 代码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");  // 引入 readline 模块，用于读取控制台输入

// 创建 readline 接口
const rl = readline.createInterface({
  input: process.stdin,  // 输入流为标准输入
  output: process.stdout,  // 输出流为标准输出
});

const lines = [];  // 用于存储输入的每一行数据
let n;  // 用于存储输入的第一行数据（表示后续输入的行数）

// 监听 'line' 事件，每次读取一行输入
rl.on("line", (line) => {
  lines.push(line);  // 将当前行数据存入 lines 数组

  // 如果 lines 数组长度为 1，说明读取到第一行数据（n 的值）
  if (lines.length == 1) {
    n = lines[0] - 0;  // 将第一行数据转换为数字并赋值给 n
  }

  // 如果 n 已定义，且 lines 数组长度为 n + 1，说明所有输入已读取完毕
  if (n && lines.length == n + 1) {
    lines.shift();  // 移除 lines 数组中的第一行数据（n 的值）
    console.log(getResult(lines));  // 调用 getResult 函数并输出结果
    lines.length = 0;  // 清空 lines 数组，为下一次输入做准备
  }
});

// 算法实现
function getResult(arr) {
  // 对数组进行排序并反转（从大到小排序）
  arr.sort().reverse();

  // 初始化栈，将数组的最后一个元素压入栈中
  const stack = [arr.pop()];

  // 遍历数组中的剩余元素
  while (arr.length) {
    const time = arr.pop();  // 取出数组的最后一个元素
    const top = stack.at(-1);  // 获取栈顶元素

    // 判断当前元素是否需要压入栈中
    if (top === time || top.substring(0, 19) !== time.substring(0, 19)) {
      stack.push(time);  // 如果满足条件，将当前元素压入栈中
    }
  }

  // 返回栈的长度
  return stack.length;
}

---

代码讲解：

1. 输入处理：

• readline 模块：
  • 用于读取控制台输入。
• rl.on("line", (line) => {...})：
  • 监听 line 事件，每次读取一行输入。
  • 将每一行数据存入 lines 数组。
• n 的作用：
  • 第一行数据表示后续输入的行数。
  • 当 lines 数组长度为 n + 1 时，说明所有输入已读取完毕。
• lines.shift()：
  • 移除 lines 数组中的第一行数据（n 的值），保留后续数据。

2. 算法实现：

• getResult 函数：
  • 参数 arr 是输入的数组。
  • 排序与反转：
    • 使用 arr.sort().reverse() 对数组进行从大到小排序。
  • 栈的使用：
    • 初始化栈 stack，将数组的最后一个元素压入栈中。
    • 遍历数组中的剩余元素：
      • 取出数组的最后一个元素 time。
      • 获取栈顶元素 top。
      • 判断当前元素是否需要压入栈中：
        • 如果 top === time 或 top.substring(0, 19) !== time.substring(0, 19)，则将当前元素压入栈中。
  • 返回结果：
    • 返回栈的长度 stack.length。

3. 输出结果：

• 使用 console.log 输出栈的长度。

---

示例运行：

输入 1：

3
2023-10-01 12:00:00
2023-10-01 12:00:01
2023-10-01 12:00:02

• 输出：

  3
  

• 解释：
  • 输入的时间数组为 ["2023-10-01 12:00:00", "2023-10-01 12:00:01", "2023-10-01 12:00:02"]。
  • 每个时间的前 19 个字符都不同，因此栈的长度为 3。

输入 2：

4
2023-10-01 12:00:00
2023-10-01 12:00:00
2023-10-01 12:00:01
2023-10-01 12:00:01

• 输出：

  2
  

• 解释：
  • 输入的时间数组为 ["2023-10-01 12:00:00", "2023-10-01 12:00:00", "2023-10-01 12:00:01", "2023-10-01 12:00:01"]。
  • 前两个时间相同，后两个时间相同，因此栈的长度为 2。

---

总结：

• 该代码实现了 统计时间数组中不同时间段的个数 的功能。
• 通过排序、栈和字符串截取操作，判断时间是否需要压入栈中。
• 时间复杂度为 O(n log n)，其中 n 是数组的长度。
• 如果有其他问题，欢迎继续提问！

三、Java算法源码

以下是 Java 代码的详细中文注释和讲解：

---

Java 代码

import java.util.Arrays;  // 引入 Arrays 工具类，用于数组排序
import java.util.LinkedList;  // 引入 LinkedList，用于实现栈
import java.util.Scanner;  // 引入 Scanner，用于读取控制台输入

public class Main {
  // 输入获取
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);  // 创建 Scanner 对象，用于读取控制台输入

    int n = Integer.parseInt(sc.nextLine());  // 读取第一行输入，转换为整数 n（表示后续输入的行数）

    String[] arr = new String[n];  // 创建长度为 n 的字符串数组，用于存储后续输入的时间数据
    for (int i = 0; i < n; i++) {
      arr[i] = sc.nextLine();  // 读取每一行输入，存入数组 arr
    }

    System.out.println(getResult(arr));  // 调用 getResult 方法并输出结果
  }

  // 算法入口
  public static int getResult(String[] arr) {
    Arrays.sort(arr);  // 对数组 arr 进行排序（默认按字典序升序）

    LinkedList<String> stack = new LinkedList<>();  // 创建 LinkedList 作为栈
    stack.add(arr[0]);  // 将数组的第一个元素压入栈中

    int i = 1;  // 初始化索引 i，从数组的第二个元素开始遍历
    while (i < arr.length) {
      String time = arr[i++];  // 取出数组的当前元素，并将索引 i 加 1
      String top = stack.getLast();  // 获取栈顶元素

      // 判断当前元素是否需要压入栈中
      if (top.equals(time) || !top.substring(0, 19).equals(time.substring(0, 19))) {
        stack.add(time);  // 如果满足条件，将当前元素压入栈中
      }
    }

    return stack.size();  // 返回栈的长度
  }
}

---

代码讲解：

1. 输入处理：

• Scanner：
  • 用于读取控制台输入。
• n：
  • 第一行输入表示后续输入的行数，转换为整数 n。
• arr：
  • 创建长度为 n 的字符串数组，用于存储后续输入的时间数据。
• for 循环：
  • 读取每一行输入，存入数组 arr。

2. 算法实现：

• getResult 方法：
  • 参数 arr 是输入的字符串数组。
  • 排序：
    • 使用 Arrays.sort(arr) 对数组进行排序（默认按字典序升序）。
  • 栈的使用：
    • 创建 LinkedList 作为栈。
    • 将数组的第一个元素压入栈中。
    • 遍历数组中的剩余元素：
      • 取出当前元素 time。
      • 获取栈顶元素 top。
      • 判断当前元素是否需要压入栈中：
        • 如果 top.equals(time) 或 top.substring(0, 19) 不等于 time.substring(0, 19)，则将当前元素压入栈中。
  • 返回结果：
    • 返回栈的长度 stack.size()。

3. 输出结果：

• 使用 System.out.println 输出栈的长度。

---

示例运行：

输入 1：

3
2023-10-01 12:00:00
2023-10-01 12:00:01
2023-10-01 12:00:02

• 输出：

  3
  

• 解释：
  • 输入的时间数组为 ["2023-10-01 12:00:00", "2023-10-01 12:00:01", "2023-10-01 12:00:02"]。
  • 每个时间的前 19 个字符都不同，因此栈的长度为 3。

输入 2：

4
2023-10-01 12:00:00
2023-10-01 12:00:00
2023-10-01 12:00:01
2023-10-01 12:00:01

• 输出：

  2
  

• 解释：
  • 输入的时间数组为 ["2023-10-01 12:00:00", "2023-10-01 12:00:00", "2023-10-01 12:00:01", "2023-10-01 12:00:01"]。
  • 前两个时间相同，后两个时间相同，因此栈的长度为 2。

---

总结：

• 该代码实现了 统计时间数组中不同时间段的个数 的功能。
• 通过排序、栈和字符串截取操作，判断时间是否需要压入栈中。
• 时间复杂度为 O(n log n)，其中 n 是数组的长度。
• 如果有其他问题，欢迎继续提问！

四、Python算法源码

以下是 Python 代码的详细中文注释和讲解：

---

Python 代码

# 输入获取
n = int(input())  # 读取第一行输入，转换为整数 n（表示后续输入的行数）
arr = [input() for _ in range(n)]  # 读取后续的 n 行输入，存入列表 arr

# 算法入口
def getResult():
    arr.sort(reverse=True)  # 对列表 arr 进行降序排序
    stack = [arr.pop()]  # 初始化栈，将 arr 的最后一个元素压入栈中

    while len(arr) > 0:  # 当 arr 不为空时，循环处理
        time = arr.pop()  # 取出 arr 的最后一个元素
        top = stack[-1]  # 获取栈顶元素

        # 判断当前元素是否需要压入栈中
        if top == time or top[:19] != time[:19]:
            stack.append(time)  # 如果满足条件，将当前元素压入栈中

    return len(stack)  # 返回栈的长度

# 算法调用
print(getResult())  # 调用 getResult 函数并输出结果

---

代码讲解：

1. 输入处理：

• n = int(input())：
  • 读取第一行输入，转换为整数 n，表示后续输入的行数。
• arr = [input() for _ in range(n)]：
  • 使用列表推导式读取后续的 n 行输入，存入列表 arr。

2. 算法实现：

• getResult 函数：
  • 排序：
    • 使用 arr.sort(reverse=True) 对列表 arr 进行降序排序。
  • 栈的使用：
    • 初始化栈 stack，将 arr 的最后一个元素压入栈中。
    • 使用 while 循环遍历 arr 中的剩余元素：
      • 取出 arr 的最后一个元素 time。
      • 获取栈顶元素 top。
      • 判断当前元素是否需要压入栈中：
        • 如果 top == time 或 top[:19] != time[:19]，则将当前元素压入栈中。
  • 返回结果：
    • 返回栈的长度 len(stack)。

3. 输出结果：

• 使用 print(getResult()) 输出栈的长度。

---

示例运行：

输入 1：

3
2023-10-01 12:00:00
2023-10-01 12:00:01
2023-10-01 12:00:02

• 输出：

  3
  

• 解释：
  • 输入的时间列表为 ["2023-10-01 12:00:00", "2023-10-01 12:00:01", "2023-10-01 12:00:02"]。
  • 每个时间的前 19 个字符都不同，因此栈的长度为 3。

输入 2：

4
2023-10-01 12:00:00
2023-10-01 12:00:00
2023-10-01 12:00:01
2023-10-01 12:00:01

• 输出：

  2
  

• 解释：
  • 输入的时间列表为 ["2023-10-01 12:00:00", "2023-10-01 12:00:00", "2023-10-01 12:00:01", "2023-10-01 12:00:01"]。
  • 前两个时间相同，后两个时间相同，因此栈的长度为 2。

---

总结：

• 该代码实现了 统计时间列表中不同时间段的个数 的功能。
• 通过排序、栈和字符串截取操作，判断时间是否需要压入栈中。
• 时间复杂度为 O(n log n)，其中 n 是列表的长度。
• 如果有其他问题，欢迎继续提问！

五、C/C++算法源码：

以下是 C++ 和 C 语言的代码实现，包含详细的中文注释和代码讲解。

---

C++ 代码实现

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 算法入口
int getResult(vector<string>& arr) {
    // 对时间字符串数组进行排序
    sort(arr.begin(), arr.end());

    // 使用栈存储不同时间段的时间字符串
    vector<string> stack;
    stack.push_back(arr[0]); // 将第一个时间字符串压入栈中

    int i = 1;
    while (i < arr.size()) {
        string time = arr[i++]; // 取出当前时间字符串
        string top = stack.back(); // 获取栈顶时间字符串

        // 判断当前时间字符串是否需要压入栈中
        if (top == time || top.substr(0, 19) != time.substr(0, 19)) {
            stack.push_back(time); // 如果满足条件，压入栈中
        }
    }

    return stack.size(); // 返回栈的长度
}

// 主函数
int main() {
    int n;
    cin >> n; // 读取时间字符串的数量
    cin.ignore(); // 忽略换行符

    vector<string> arr(n); // 存储时间字符串的数组
    for (int i = 0; i < n; i++) {
        getline(cin, arr[i]); // 读取每一行时间字符串
    }

    cout << getResult(arr) << endl; // 调用算法并输出结果
    return 0;
}

---

C++ 代码讲解

1. 输入处理：

   • 使用 cin 读取时间字符串的数量 n。
   • 使用 getline 读取每一行时间字符串，并存储到 vector<string> 中。

2. 排序：

   • 使用 sort 对时间字符串数组进行排序，确保时间按字典序排列。

3. 栈的使用：

   • 初始化一个栈 stack，将第一个时间字符串压入栈中。
   • 遍历剩余的时间字符串：
     • 取出当前时间字符串 time。
     • 获取栈顶时间字符串 top。
     • 判断当前时间字符串是否需要压入栈中：
       • 如果 top == time 或 top.substr(0, 19) != time.substr(0, 19)，则将当前时间字符串压入栈中。

4. 输出结果：

   • 返回栈的长度 stack.size()，并输出结果。

---

C 语言代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 比较函数，用于排序
int compare(const void* a, const void* b) {
    return strcmp(*(const char**)a, *(const char**)b);
}

// 算法入口
int getResult(char** arr, int n) {
    // 对时间字符串数组进行排序
    qsort(arr, n, sizeof(char*), compare);

    // 使用栈存储不同时间段的时间字符串
    char** stack = (char**)malloc(n * sizeof(char*));
    int stackSize = 0;
    stack[stackSize++] = arr[0]; // 将第一个时间字符串压入栈中

    int i = 1;
    while (i < n) {
        char* time = arr[i++]; // 取出当前时间字符串
        char* top = stack[stackSize - 1]; // 获取栈顶时间字符串

        // 判断当前时间字符串是否需要压入栈中
        if (strcmp(top, time) == 0 || strncmp(top, time, 19) != 0) {
            stack[stackSize++] = time; // 如果满足条件，压入栈中
        }
    }

    int result = stackSize; // 栈的长度即为结果
    free(stack); // 释放栈的内存
    return result;
}

// 主函数
int main() {
    int n;
    scanf("%d", &n); // 读取时间字符串的数量
    getchar(); // 忽略换行符

    char** arr = (char**)malloc(n * sizeof(char*)); // 存储时间字符串的数组
    for (int i = 0; i < n; i++) {
        arr[i] = (char*)malloc(20 * sizeof(char)); // 为每个时间字符串分配内存
        fgets(arr[i], 20, stdin); // 读取每一行时间字符串
        arr[i][strcspn(arr[i], "\n")] = '\0'; // 去除换行符
    }

    printf("%d\n", getResult(arr, n)); // 调用算法并输出结果

    // 释放内存
    for (int i = 0; i < n; i++) {
        free(arr[i]);
    }
    free(arr);

    return 0;
}

---

C 语言代码讲解

1. 输入处理：

   • 使用 scanf 读取时间字符串的数量 n。
   • 使用 fgets 读取每一行时间字符串，并存储到 char** 数组中。
   • 使用 strcspn 去除每行末尾的换行符。

2. 排序：

   • 使用 qsort 对时间字符串数组进行排序，排序依据是 strcmp 函数。

3. 栈的使用：

   • 初始化一个栈 stack，将第一个时间字符串压入栈中。
   • 遍历剩余的时间字符串：
     • 取出当前时间字符串 time。
     • 获取栈顶时间字符串 top。
     • 判断当前时间字符串是否需要压入栈中：
       • 如果 strcmp(top, time) == 0 或 strncmp(top, time, 19) != 0，则将当前时间字符串压入栈中。

4. 输出结果：

   • 返回栈的长度 stackSize，并输出结果。

5. 内存管理：

   • 使用 malloc 为时间字符串数组和栈分配内存。
   • 使用 free 释放分配的内存，避免内存泄漏。

---

总结

• C++ 和 C 语言的实现思路一致，均通过排序和栈来统计不同时间段的个数。
• C++ 使用了 vector 和 string，代码更简洁。
• C 语言需要手动管理内存，代码稍显复杂，但更贴近底层实现。
• 如果有其他问题，欢迎继续提问！