2025-12-17：优惠券校验器。用go语言，你有三个等长数组 code、businessLine 和 isActive，分别记录 n 个优惠券的标识符、所属业务线和是否有效。

把某张券视为“合格”的条件是：标识符非空且只包含字母、数字或下划线；所属业务线为四种中的一种：“electronics”、“grocery”、“pharmacy” 或 “restaurant”；并且 isActive 为 true。

结果应返回所有合格券的标识符组成的列表，排序规则是先按业务线的固定顺序（electronics → grocery → pharmacy → restaurant）分组，然后在每个组内按标识符的字典序从小到大排列。

n == code.length == businessLine.length == isActive.length。

1 <= n <= 100。

0 <= code[i].length, businessLine[i].length <= 100。

code[i] 和 businessLine[i] 由可打印的 ASCII 字符组成。

isActive[i] 的值为 true 或 false。

输入： code = [“SAVE20”,“”,“PHARMA5”,“SAVE@20”], businessLine = [“restaurant”,“grocery”,“pharmacy”,“restaurant”], isActive = [true,true,true,true]。

输出： [“PHARMA5”,“SAVE20”]。

解释：

第一个优惠券有效。

第二个优惠券的标识符为空（无效）。

第三个优惠券有效。

第四个优惠券的标识符包含特殊字符 @（无效）。

题目来自力扣3606。

步骤描述

1. 初始化容器
   程序创建了一个长度为 4 的切片 groups，里面每个元素是一个字符串切片，对应 4 个业务线的分组顺序：

   • groups[0] → electronics
   • groups[1] → grocery
   • groups[2] → pharmacy
   • groups[3] → restaurant
     另外还创建一个空的 ans 切片，用于存放最终结果。

2. 遍历输入数据
   依次对每个 i (0 ≤ i < n) 做以下判断：

   • 检查 code[i] 是否非空字符串。
   • 调用 check 函数判断 code[i] 是否只包含字母、数字或下划线，并且 isActive[i] 为 true。
     • check 内部遍历 code[i] 的每个字符，用 unicode.IsLetter 和 unicode.IsDigit 判断，如果出现非字母/数字/下划线则返回 false。
     • 如果 check 返回 true，说明券是“合格”的。
   • 对合格的券，根据 businessLine[i] 决定放入哪个分组：
     • 如果是 "electronics"，放入 groups[0]
     • 如果是 "grocery"，放入 groups[1]
     • 如果是 "pharmacy"，放入 groups[2]
     • 如果是 "restaurant"，放入 groups[3]
   • 不合格的券（包括空字符串、非法字符、业务线不匹配（但题中业务线只有四种合法，如果给的业务线不在四个之中则不放入，代码中 switch 默认不处理））就忽略。

3. 分组内部排序
   遍历 groups 里的四个切片，对每个业务线分组内的标识符列表调用 sort.Strings 进行字典序排序。

4. 结果合并
   按顺序（electronics → grocery → pharmacy → restaurant）将每个分组排序后的内容依次追加到 ans 中。

5. 返回结果
   最终 ans 就是按照先业务线固定顺序、再组内字典序排列的所有合格券标识符列表。

在给定输入的例子中：

• "SAVE20" → 合格，业务线 "restaurant" → 放入 groups[3]
• "" → 空字符串 → 不合格
• "PHARMA5" → 合格，业务线 "pharmacy" → 放入 groups[2]
• "SAVE@20" → 包含 @ 字符 → 不合格
  最后：
• groups[2] 排序后为 ["PHARMA5"]
• groups[3] 排序后为 ["SAVE20"]
  先 electronics 组（空）→ grocery 组（空）→ pharmacy 组（"PHARMA5"）→ restaurant 组（"SAVE20"）
  最终结果：["PHARMA5", "SAVE20"]

时间复杂度分析

• 遍历 n 张券：O(n)
• 对每个券，check 函数要遍历其标识符的每个字符，设所有 code[i] 总长度为 L，则总检查字符次数为 O(L)
• 分组内部排序：最多 n 个字符串，分成 4 组，最坏情况（所有合格券在同一组）需要对该组 m 个字符串排序，比较开销是 O(m log m)，m ≤ n，所以排序总时间 O(n log n)（因为 4 组总和 ≤ n，每组排序复杂度相加 ≤ n log n 级别）
• 最终遍历 groups 合并结果 O(n)
  总时间复杂度 O(L + n log n)，其中 L 是所有 code[i] 字符总数。

空间复杂度分析：

• groups 数组及其内部切片存储所有合格券标识符，总空间 O(n)
• 排序可能需额外 O(log n) 递归栈空间（Go 的 sort.Strings 用快速排序）
• 结果 ans 额外存储 n 个字符串引用（和 groups 里的引用相同，不重复占用字符串本身空间，但切片结构占用 O(n)）
• 因此总额外空间复杂度 O(n)（主要是存储合格券标识符的引用和分组结构，不包括输入数据占用的空间）。

Go完整代码如下：

package main

import (
	"fmt"
	"sort"
	"unicode"
)

func check(code string, isActive bool) bool {
	for _, c := range code {
		if c != '_' && !unicode.IsLetter(c) && !unicode.IsDigit(c) {
			return false
		}
	}
	return isActive
}

func validateCoupons(code []string, businessLine []string, isActive []bool) []string {
	groups := make([][]string, 4)
	for i := range groups {
		groups[i] = make([]string, 0)
	}

	ans := make([]string, 0)

	for i := 0; i < len(code); i++ {
		if code[i] != "" && check(code[i], isActive[i]) {
			switch businessLine[i] {
			case "electronics":
				groups[0] = append(groups[0], code[i])
			case "grocery":
				groups[1] = append(groups[1], code[i])
			case "pharmacy":
				groups[2] = append(groups[2], code[i])
			case "restaurant":
				groups[3] = append(groups[3], code[i])
			}
		}
	}

	for _, group := range groups {
		sort.Strings(group)
		ans = append(ans, group...)
	}

	return ans
}

func main() {
	code := []string{"SAVE20", "", "PHARMA5", "SAVE@20"}
	businessLine := []string{"restaurant", "grocery", "pharmacy", "restaurant"}
	isActive := []bool{true, true, true, true}
	result := validateCoupons(code, businessLine, isActive)
	fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

import re
from typing import List

def check(code: str, is_active: bool) -> bool:
    """检查优惠码是否只包含字母、数字和下划线，并且处于激活状态"""
    if not code:
        return False
    # 使用正则表达式检查是否只包含字母、数字和下划线
    if not re.fullmatch(r'[\w]+', code):
        return False
    return is_active

def validate_coupons(code: List[str], 
                     business_line: List[str], 
                     is_active: List[bool]) -> List[str]:
    """验证优惠码并按业务线分类排序"""
    # 定义业务线分组顺序
    business_order = ["electronics", "grocery", "pharmacy", "restaurant"]
    
    # 初始化分组字典
    groups = {biz: [] for biz in business_order}
    
    # 遍历所有优惠码
    for i in range(len(code)):
        # 验证优惠码
        if check(code[i], is_active[i]):
            biz = business_line[i]
            # 如果业务线在预定义列表中，则添加到对应分组
            if biz in groups:
                groups[biz].append(code[i])
    
    # 对每个分组进行排序，并按顺序合并结果
    result = []
    for biz in business_order:
        groups[biz].sort()
        result.extend(groups[biz])
    
    return result

def main():
    # 测试数据
    code = ["SAVE20", "", "PHARMA5", "SAVE@20"]
    business_line = ["restaurant", "grocery", "pharmacy", "restaurant"]
    is_active = [True, True, True, True]
    
    # 调用验证函数
    result = validate_coupons(code, business_line, is_active)
    
    # 输出结果
    print(result)
    # 预期输出: ['SAVE20'] (因为: ""为空, "SAVE@20"包含非法字符, 只有"SAVE20"和"PHARMA5"有效，但"PHARMA5"属于pharmacy分组排在restaurant之后)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cctype>

using namespace std;

bool check(const string& code, bool isActive) {
    // 检查优惠码是否只包含字母、数字和下划线
    for (char c : code) {
        if (c != '_' && !isalnum(c)) {
            return false;
        }
    }
    return isActive;
}

vector<string> validateCoupons(const vector<string>& code,
                               const vector<string>& businessLine,
                               const vector<bool>& isActive) {
    // 初始化4个分组，对应electronics, grocery, pharmacy, restaurant
    vector<vector<string>> groups(4);
    vector<string> result;

    for (size_t i = 0; i < code.size(); i++) {
        // 验证优惠码
        if (!code[i].empty() && check(code[i], isActive[i])) {
            // 根据业务线添加到对应分组
            if (businessLine[i] == "electronics") {
                groups[0].push_back(code[i]);
            } else if (businessLine[i] == "grocery") {
                groups[1].push_back(code[i]);
            } else if (businessLine[i] == "pharmacy") {
                groups[2].push_back(code[i]);
            } else if (businessLine[i] == "restaurant") {
                groups[3].push_back(code[i]);
            }
        }
    }

    // 对每个分组排序并合并结果
    for (auto& group : groups) {
        sort(group.begin(), group.end());
        for (const auto& coupon : group) {
            result.push_back(coupon);
        }
    }

    return result;
}

int main() {
    vector<string> code = {"SAVE20", "", "PHARMA5", "SAVE@20"};
    vector<string> businessLine = {"restaurant", "grocery", "pharmacy", "restaurant"};
    vector<bool> isActive = {true, true, true, true};

    vector<string> result = validateCoupons(code, businessLine, isActive);

    // 输出结果
    cout << "[";
    for (size_t i = 0; i < result.size(); i++) {
        cout << "\"" << result[i] << "\"";
        if (i != result.size() - 1) {
            cout << ", ";
        }
    }
    cout << "]" << endl;

    return 0;
}