阿里智能阿里智能笔试 0411

笔试时间：2025年04月11日

历史笔试传送门：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

题目

对于给定的长为 n、由大小写字母混合构成的字符串 8，将其全部小写字母选出，得到新的字符串 t (可能为空)，记下标从 1 开始，对 t 进行排序，使得:

t 中奇数位置的字母均不小于其相邻的字母

t 中偶数位置的字母均不大于其相邻的字母

因为这样的字符串具有波浪形，故称其为波浪字符串。这里的大小即为字母表中的顺序，'a' 最小，'z' 最大。你只需要直接输出排序后的字符串 t 即可.

输入描述

第一行输入一个整数n(1 ≤ n ≤ 10^5)，表示字符串s 的长度。

第二行输入一个长度为 n、由大小写字母混合构成的字符串 s

输出描述

输出一个仅由小写字母构成的字符串，表示最终得到的t如果存在多个解决方案，您可以输出任意一个，系统会自动判定是否正确。注意，自测运行功能可能因此返回错误结果，请自行检查答案正确性。

样例输入

6

ciallo

样例输出

liocla

参考题解

从控制台读取一个整数表示字符串长度，再读取一个由大小写字母混合构成的字符串。然后从该字符串中提取出所有小写字母，将这些小写字母进行排序，最后按照特定规则（奇数位置字母不小于相邻字母，偶数位置字母不大于相邻字母）重新排列这些小写字母并输出。

C++：[此代码未进行大量数据的测试，仅供参考]

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

void reverse(vector<char>& arr) {
    int i = 0, j = arr.size() - 1;
    while (i < j) {
        swap(arr[i], arr[j]);
        i++;
        j--;
    }
}

int main() {
    int n;
    cin >> n;
    cin.ignore(); // consume newline
    string s;
    getline(cin, s);

    vector<char> t;
    for (char c : s) {
        if (islower(c)) {
            t.push_back(c);
        }
    }

    sort(t.begin(), t.end());
    int m = t.size();
    if (m == 0) {
        cout << endl;
        return 0;
    }

    int mid = (m + 1) / 2;
    vector<char> larger(t.end() - mid, t.end());
    vector<char> smaller(t.begin(), t.end() - mid);
    reverse(smaller);

    vector<char> result(m);
    int l = 0, sIdx = 0;
    for (int i = 0; i < m; i++) {
        if (i % 2 == 0)
            result[i] = larger[l++];
        else
            result[i] = smaller[sIdx++];
    }

    for (char c : result)
        cout << c;
    cout << endl;

    return 0;
}

Java：[此代码未进行大量数据的测试，仅供参考]

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public staticvoid main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        String s = sc.nextLine();
        StringBuilder tBuilder = new StringBuilder();
        for (char c : s.toCharArray()) {
            if (Character.isLowerCase(c)) {
                tBuilder.append(c);
            }
        }
        char[] t = tBuilder.toString().toCharArray();
        Arrays.sort(t);
        int m = t.length;
        if (m == 0) {
            System.out.println();
            return;
        }
        int mid = (m + 1) / 2;
        char[] larger = Arrays.copyOfRange(t, m - mid, m);
        char[] smaller = Arrays.copyOfRange(t, 0, m - mid);
        reverse(smaller);
        char[] result = new char[m];
        int l = 0, sIdx = 0;
        for (int i = 0; i < m; i++) {
            if (i % 2 == 0) {
                result[i] = larger[l++];
            } else {
                result[i] = smaller[sIdx++];
            }
        }
        System.out.println(newString(result));
    }

    private staticvoid reverse(char[] arr) {
        int i = 0, j = arr.length - 1;
        while (i < j) {
            char tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

n = int(input())
s = input()

t = [c for c in s if c.islower()]
t.sort()
m = len(t)

if m == 0:
    print()
else:
    mid = (m + 1) // 2
    larger = t[-mid:]
    smaller = t[:m - mid][::-1]  # reversed
    result = []

    l = sIdx = 0
    for i in range(m):
        if i % 2 == 0:
            result.append(larger[l])
            l += 1
        else:
            result.append(smaller[sIdx])
            sIdx += 1

    print("".join(result))