ERROR: Your kernel version indicates a revision number of 255 or greater. Glibc has a number of built in assumptions that this revision number is less than 255. If you\'ve built your own kernel, please make sure that any custom version numbers are appended to the upstream kernel number with a dash or some other delimiter.

这个错误通常意味着你的内核版本号超出了 Glibc 所能处理的范围。Glibc 的代码中有一些假设，认为内核版本号小于 255。如果你自己编译了内核，请确保自定义版本号是用连字符或其他分隔符附加到上游内核号码中的。例如，如果你的上游内核版本是 5.10.1，你可以将自定义版本号设置为 5.10.1-mycustomversion。这样做可以避免与 Glibc 的问题。

相关问题

用c++解决下述问题：描述 Some words have power. It can make a string containing it become more powerful (larger weight). The weight of a word in a string is defined as the number of its occurences in the string multiplied by its value, while the weight of the string is defined as the sum of all words' weights. Given some words with their values, you should output the string consisting of these words which make the string's weight maximal. 输入 The input consists of multiple test cases. The first line of the input is an integer T, indicating the number of the test cases. Each test case starts with a line consisting of two integers: N and M, indicating the string's maximum length and the number of the words. Each of the following M lines consists of a word Wi. The last line of each test case consists of M integers, while the i-th number indicates the value Vi of Wi. Technical Specification: 1. T ≤ 15 2. 0 < N ≤ 50, 0 < M ≤ 100. 3. The length of each word is less than 11 and bigger than 0. 4. 1 ≤ Vi ≤ 100. 5. All the words in the input are different. 6. All the words just consist of 'a' - 'z'. 输出 For each test case, output the string which has the maximal weight in a single line.If there are multiple answers, output the shortest one. If there are still multiple answers, output the smallest one in lexicographical order. The answer may be an empty string.

这道题需要使用动态规划来解决。我们可以定义dp[i]表示长度为i的字符串的最大权值，它可以通过枚举最后一个单词得到。具体地，我们枚举最后一个单词为Wi，那么dp[i]就可以由dp[i-len(Wi)] + Vi得到，其中len(Wi)表示单词Wi的长度，Vi表示单词Wi的权值。最后我们在dp数组中找到最大权值的位置，然后倒推出字符串即可。

代码如下：

Define a Vehicle class and its subclasses Bike and Car. The detailed requirements are: (1) Data members: a) Vehicle’s data members include: wheels(indicates the number of tires) and weight(indicates the weight of the vehicle). b) Bike has an additional data member: price(indicates the weight of the vehicle). c) Car has an additional data members: passenger_load(indicates the load of the vehicle). (2) Member functions: a) Each class should have a constructor to initialize its data members. b) Define in each class a function show() to display its data members. (3) A global function showVehicle(Vehicle &vehicle) to call a Vehicle object’s show() function to display its content. (4) The main() function: a) Define a Car object car and an array bikes to store two Bike objects. b) Use the function showVehicle to display the information of car. c) Define a Vehicle pointer p_bikes to point to the array and display each bike’s information with a loop(Call show () in the bike subclass)

Sure, here is a possible implementation in C++:

#include <iostream>
using namespace std;

class Vehicle {
protected:
    int wheels;
    int weight;
public:
    Vehicle(int w, int ww) : wheels(w), weight(ww) {}
    virtual void show() {
        cout << "Wheels: " << wheels << ", Weight: " << weight << endl;
    }
};

class Bike : public Vehicle {
private:
    int price;
public:
    Bike(int w, int ww, int p) : Vehicle(w, ww), price(p) {}
    void show() override {
        cout << "Bike: ";
        Vehicle::show();
        cout << "Price: " << price << endl;
    }
};

class Car : public Vehicle {
private:
    int passenger_load;
public:
    Car(int w, int ww, int pl) : Vehicle(w, ww), passenger_load(pl) {}
    void show() override {
        cout << "Car: ";
        Vehicle::show();
        cout << "Passenger load: " << passenger_load << endl;
    }
};

void showVehicle(Vehicle& vehicle) {
    vehicle.show();
}

int main() {
    Car car(4, 1000, 5);
    Bike bikes[2] = {Bike(2, 20, 100), Bike(2, 25, 120)};
    showVehicle(car);
    Vehicle* p_bikes = bikes;
    for (int i = 0; i < 2; ++i) {
        p_bikes[i].show();  // call show() of the Bike subclass
    }
    return 0;
}

In this implementation, the `Vehicle` class is defined with two data members `wheels` and `weight`, and a virtual `show()` function to display them. The `Bike` class is defined as a subclass of `Vehicle` with an additional data member `price`, and overrides the `show()` function to print out the bike's information with a "Bike" prefix. Similarly, the `Car` class is defined as a subclass of `Vehicle` with an additional data member `passenger_load`, and overrides the `show()` function to print out the car's information with a "Car" prefix.

The `showVehicle()` function is defined as a global function that takes a reference to a `Vehicle` object and calls its `show()` function. This function is used to display the information of `car` in the `main()` function.

In the `main()` function, a `Car` object `car` and an array of two `Bike` objects `bikes` are defined and initialized with constructor calls. The `showVehicle()` function is called with `car` to display its information. Then, a `Vehicle` pointer `p_bikes` is defined to point to the `bikes` array, and a loop is used to call the `show()` function of each `Bike` object through `p_bikes[i]`.

When running the program, the output should be:

Car: Wheels: 4, Weight: 1000
Passenger load: 5
Bike: Wheels: 2, Weight: 20
Price: 100
Bike: Wheels: 2, Weight: 25
Price: 120