奖学金统计与字符串处理算法解析

1. 奖学金统计程序解析

奖学金统计是学校教务管理中的常见需求。这个程序需要处理多种奖学金类型的叠加计算，并输出最高获奖者和总金额。核心逻辑在于正确实现每种奖学金的判断条件。

1.1 奖学金类型与条件

程序处理的五种奖学金条件如下：

1. 院士奖学金：平均成绩>80且发表论文≥1篇（8000元）
2. 五四奖学金：平均成绩>85且班级评议>80（4000元）
3. 成绩优秀奖：平均成绩>90（2000元）
4. 西部奖学金：平均成绩>85且来自西部（1000元）
5. 班级贡献奖：班级评议>80且是学生干部（850元）

关键点在于这些条件是"叠加"而非"互斥"的，一个学生可能同时满足多个条件。

1.2 核心算法实现

cpp复制int schoolship(string name, int fs, int cs, char isg, char iswestern, int sci) {
    int sum = 0;
    if (fs > 80 && sci >= 1) sum += 8000;  // 院士奖学金
    if (fs > 85 && cs >= 80) sum += 4000;  // 五四奖学金
    if (fs > 90) sum += 2000;              // 成绩优秀奖
    if (fs > 85 && iswestern == 'Y') sum += 1000; // 西部奖学金
    if (cs > 80 && isg == 'Y') sum += 850; // 班级贡献奖
    return sum;
}

注意事项：

1. 使用独立if而非if-else，确保条件独立判断
2. 边界条件处理：">"不包含等于，如>80即81及以上
3. 字符型参数用'Y'/'N'表示是否满足条件

1.3 主程序逻辑

cpp复制int main() {
    int N;
    while (cin >> N) {
        string max_name;
        int max_schoolship = -1, total = 0;
        
        for (int i = 0; i < N; i++) {
            string name;
            int fs, cs, sci;
            char isg, iswestern;
            cin >> name >> fs >> cs >> isg >> iswestern >> sci;
            
            int current = schoolship(name, fs, cs, isg, iswestern, sci);
            total += current;
            
            if (current > max_schoolship) {
                max_schoolship = current;
                max_name = name;
            }
        }
        
        cout << max_name << endl << max_schoolship << endl << total << endl;
    }
}

常见问题：

1. 输入数据量大时注意效率问题
2. 多个学生金额相同时，程序会输出最先出现的那个
3. 建议添加输入数据合法性检查

2. 字符串加法器实现

这个加法器需要处理形如"1+2+3"的字符串表达式，计算其总和。核心在于正确解析数字和运算符。

2.1 算法思路

1. 初始化sum=0，当前数字digit=0
2. 遍历字符串：
   • 遇到数字：累积到digit（digit = digit*10 + c-'0'）
   • 遇到非数字：将digit加到sum，重置digit=0
3. 最后处理末尾数字

2.2 代码实现

cpp复制int main() {
    string s;
    while (cin >> s) {
        int digit = 0, sum = 0;
        bool isnum = false;
        
        for (char c : s) {
            if (isdigit(c)) {
                digit = digit * 10 + (c - '0');
                isnum = true;
            } else if (isnum) {
                sum += digit;
                digit = 0;
                isnum = false;
            }
        }
        if (isnum) sum += digit;
        
        cout << sum << endl;
    }
}

注意事项：

1. 使用isdigit()判断数字更安全
2. 处理连续非数字字符的情况
3. 不支持减法等其他运算符
4. 最大数字不超过INT_MAX

3. 序列构造算法

这个序列生成规则独特：每一轮在相邻和为n的数字间插入n。

3.1 生成规则示例

• 第1轮：1 1 → "11"
• 第2轮：在1和1之间插入2 → "121"
• 第3轮：在1+2=3和2+1=3的位置插入3 → "13231"
• 第4轮：在1+3=4、3+2=5、2+3=5、3+1=4的位置插入对应数字

3.2 实现代码

cpp复制vector<string> generate_sequence() {
    vector<string> res;
    vector<int> current = {1, 1};
    res.push_back("11");
    
    for (int round = 2; round <= 9; round++) {
        vector<int> next;
        
        for (int i = 0; i < current.size() - 1; i++) {
            next.push_back(current[i]);
            if (current[i] + current[i+1] == round)
                next.push_back(round);
        }
        next.push_back(current.back());
        
        string s;
        for (int num : next) s += to_string(num);
        res.push_back(s);
        current = next;
    }
    
    return res;
}

优化建议：

1. 预计算所有9轮结果存储起来
2. 使用stringstream拼接字符串效率更高
3. 可扩展支持更多轮次的生成

4. 纯粹合数判断

纯粹合数是指其本身和所有"去高位"后的数都是合数。

4.1 算法步骤

1. 实现合数判断函数isHeShu()
2. 实现去最高位函数Zuigao()
3. 对每个数递归检查所有"去高位"版本

cpp复制bool isPure(int n) {
    int current = n;
    while (current > 0) {
        if (!isHeShu(current)) return false;
        current = Zuigao(current);
    }
    return true;
}

注意事项：

1. 合数判断可优化为检查到sqrt(n)即可
2. 去最高位也可以通过转为字符串后取子串实现
3. 预先计算并存储纯粹合数列表可提高查询效率

5. 最长质数子串查找

在数字串中找出不超过4位的最长质数子串。

5.1 实现要点

1. 质数判断函数优化：

cpp复制bool isPrime(int n) {
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    for (int i = 3; i*i <= n; i += 2)
        if (n % i == 0) return false;
    return true;
}

2. 滑动窗口遍历所有1-4位子串：

cpp复制for (int len = 4; len >= 1; len--) {
    for (int i = 0; i + len <= s.size(); i++) {
        int num = stoi(s.substr(i, len));
        if (isPrime(num)) {
            // 处理结果
        }
    }
}

优化建议：

1. 从最长长度开始查找，找到即可返回
2. 预处理质数表可加速判断
3. 注意前导零的处理

6. 字符串翻译算法

这个翻译规则是：遇到数字n，就将后一个字符重复n+1次。

6.1 算法实现

cpp复制string translate(const string& s) {
    string result;
    for (int i = 0; i < s.size(); i++) {
        if (isdigit(s[i])) {
            int count = s[i] - '0' + 1;
            if (i + 1 < s.size()) {
                result.append(count, s[i+1]);
                i++; // 跳过已处理的字符
            }
        } else {
            result += s[i];
        }
    }
    return result;
}

特殊案例处理：

1. 数字在字符串末尾
2. 连续数字的情况
3. 翻译后字符串可能很长，注意内存

7. 数字分割与排序

将字符串中的'5'视为分隔符，分割后排序输出。

7.1 关键实现

cpp复制vector<int> splitAndSort(const string& s) {
    vector<int> numbers;
    int current = 0;
    bool building = false;
    
    for (char c : s) {
        if (c != '5') {
            current = current * 10 + (c - '0');
            building = true;
        } else if (building) {
            numbers.push_back(current);
            current = 0;
            building = false;
        }
    }
    if (building) numbers.push_back(current);
    
    sort(numbers.begin(), numbers.end());
    return numbers;
}

注意事项：

1. 处理前导零：005应视为5
2. 连续多个5的情况
3. 空字符串或全5字符串的特殊处理

8. 浮点数相等判断

由于浮点数精度问题，不能直接用==比较。

8.1 实现方案

cpp复制bool isEqual(string s1, string s2) {
    double a = stod(s1), b = stod(s2);
    double epsilon = 1e-10;
    return fabs(a - b) < epsilon;
}

精度选择建议：

1. 根据实际需求调整epsilon值
2. 可考虑相对误差比较：(fabs(a-b) < epsilon * max(fabs(a), fabs(b)))
3. 处理科学计数法输入

这些算法问题涵盖了字符串处理、数学计算、条件判断等常见编程场景。在实际应用中，还需要考虑更多边界条件和性能优化。每个解决方案都展示了如何将问题分解为可执行的步骤，并通过代码实现。理解这些基础算法有助于解决更复杂的编程问题。