B2119 删除单词后缀

B2119 删除单词后缀

#include <iostream>

using namespace std;

# include <string.h>

#include <ctype.h>

#include <algorithm>

#include <string.h>

int main(){

  string word;

  cin>>word;

  if(word.size()> 2 && word.substr(word.size() - 2) == "er"){

    word = word.substr(0,word.size() - 2);

  }

  else if(word.size() > 2 && word.substr(word.size() - 2 ) == "ly"){

    word = word.substr(0,word.size() - 2);

  }

  else if(word.size() > 3 && word.substr(word.size() - 3 ) == "ing") {

    word= word.substr(0,word.size() - 3);

  }

  cout<<word;

}

/*### `strcmp(word + len - 2, "er")` 的解释

`strcmp` 是一个 C 标准库函数，用于**比较两个 C 风格的字符串**（即 `char` 数组）。它逐个字符比较两个字符串的 ASCII 值，直到遇到不同的字符或遇到字符串的终止符 `\0`。它的典型使用形式是 `strcmp(str1, str2)`，其返回值如下：

- 如果 `str1` 等于 `str2`，返回 `0`。

- 如果 `str1` 小于 `str2`（按字典顺序），返回负值。

- 如果 `str1` 大于 `str2`（按字典顺序），返回正值。

### `strcmp(word + len - 2, "er")` 的具体含义

- `word + len - 2` 是一个指针运算，表示从字符串 `word` 的倒数第二个字符开始。换句话说，它将 `word` 的内存地址偏移到 `len - 2` 的位置。

  - 例如，如果 `word` 是 `runner`，且 `len` 为 `6`，`word + len - 2` 就指向 `e`，因此相当于指向字符串 `"er"` 的起始位置。

- `strcmp(word + len - 2, "er")` 的作用是：

  - 比较从 `word` 的倒数第二个字符开始的子字符串与 `"er"` 是否相等。

  - 如果 `word` 以 `"er"` 结尾，`strcmp` 将返回 `0`，表示两者相等。

  - 如果 `word` 不是以 `"er"` 结尾，`strcmp` 会返回非零值。

### 使用这种方法的原因

- 由于 `strcmp` 比较的是两个完整的字符串，所以我们通过将指针移动到 `word` 的末尾以只比较后缀部分。

- 这样可以高效地判断一个字符串是否以某个特定的后缀结尾，而无需手动创建新的字符串或使用复杂的循环。

### 示例说明

假设有以下代码：

```c

char word[] = "runner";

int len = strlen(word);

if (strcmp(word + len - 2, "er") == 0) {

    printf("The word ends with 'er'.\n");

} else {

    printf("The word does not end with 'er'.\n");

}

```

- `len` 是 `6`，`word + len - 2` 指向字符串 `"er"` 的起始位置。

- `strcmp(word + len - 2, "er")` 比较的是字符串 `"er"` 与 `"er"`，结果返回 `0`，说明 `word` 确实以 `"er"` 结尾。

### 总结

- `strcmp` 的这种用法利用了指针偏移，直接从字符串的末尾位置开始比较。

- 这是在 C 语言中判断字符串后缀的一种有效方法，因为它避免了额外的字符串分配和拷贝。 */

你可以使用一个 `for` 循环来遍历 `patterbs` 数组，从而判断一个单词是否以指定的后缀（如 `er`、`ly`、`ing`）结尾。这个方法更加灵活和简洁，避免了多次 `if-else` 判断。以下是具体的实现方法：

### 示例代码

```cpp
#include <iostream>
#include <cstring>
using namespace std;

int main() {
    char word[33]; // 假设输入单词最大长度为 32
    cin >> word;

    // 定义后缀数组
    char patterns[][4] = {"er", "ly", "ing"};
    int len = strlen(word);

    // 遍历后缀数组进行匹配
    for (int i = 0; i < 3; ++i) {
        int patternLen = strlen(patterns[i]);
        if (len > patternLen && strcmp(word + len - patternLen, patterns[i]) == 0) {
            // 删除后缀
            word[len - patternLen] = '\0';
            break; // 退出循环，避免多次删除
        }
    }

    cout << word << endl;

    return 0;
}
```

### 解释

1. **定义后缀数组**：`char patterns[][4] = {"er", "ly", "ing"};`
   - `patterns` 是一个二维字符数组，存储需要检查的后缀。每个字符串的长度最多为 `3`，包括空字符 `\0`。

2. **遍历后缀数组**：
   - 使用 `for (int i = 0; i < 3; ++i)` 遍历所有后缀。
   - `strlen(patterns[i])` 获取当前后缀的长度 `patternLen`。

3. **检查并删除后缀**：
   - `if (len > patternLen && strcmp(word + len - patternLen, patterns[i]) == 0)` 检查 `word` 是否以当前后缀结尾。
     - `len > patternLen` 确保单词长度大于当前后缀长度，避免越界访问。
     - `strcmp(word + len - patternLen, patterns[i]) == 0` 用于比较单词的最后 `patternLen` 个字符和 `patterns[i]`。
   - 如果匹配成功，将单词的末尾截断，即 `word[len - patternLen] = '\0';`，从而删除后缀。
   - `break` 语句用于防止多次匹配和删除后缀。

### 代码优势

- **简洁性**：通过一个 `for` 循环和 `patterns` 数组，避免了多次 `if-else` 语句，代码更易于扩展和维护。
- **灵活性**：可以轻松扩展新的后缀，只需要在 `patterns` 数组中添加新元素。
- **效率**：使用 `strcmp` 和指针偏移操作实现快速判断和截断。

在你的示例中，`char patterns[][4] = {"er", "ly", "ing"};` 定义了一个 **二维字符数组**，用于存储需要检查的后缀字符串。让我详细解释这个定义的原理和细节。

### 二维字符数组的定义

1. **`char patterns[][4]` 的含义**：
   - 这是一个二维字符数组，其中每一行（即每个元素）都是一个**字符串**。
   - `4` 表示每个字符串最多可以包含 `3` 个有效字符加上一个**空字符 `\0`**（用于表示字符串结束）。因此，每个字符串的总长度是 `4` 字节。

2. **为什么使用 `4`**：
   - 这是因为最长的字符串是 `"ing"`，包含 `3` 个字符，加上末尾的空字符 `\0`，需要 `4` 个字节的空间。
   - 如果定义为 `char patterns[][3]`，就无法存储 `"ing"`，因为它需要额外的一个字节来存储 `\0` 终止符。

### 如何存储字符串

- `patterns` 是一个二维数组，每个元素实际上是一个 `char` 数组，也可以被视为一个字符串。
- 在内存中，`patterns` 的布局如下：

  ```
  patterns[0] = "er\0"
  patterns[1] = "ly\0"
  patterns[2] = "ing\0"
  ```

  每个字符串末尾都有一个 `\0` 作为字符串结束标志。

### 存储和访问方式

- **存储**：
  - `char patterns[][4]` 创建了一个包含 `3` 行、`4` 列的二维数组，总共占用 `3 x 4 = 12` 个字节的内存。
  - 每行是一个独立的 `char` 数组（字符串），所有行共享一个连续的内存空间。
  - 例如，`patterns[0]` 是一个指向 `"er"` 的 `char` 数组，`patterns[1]` 指向 `"ly"`，`patterns[2]` 指向 `"ing"`。
- **访问**：
  - `patterns[i]` 是一个指针，指向 `patterns` 中的第 `i` 行，即 `patterns[i]` 本身是一个 `char*`，表示一个字符串。
  - 可以通过 `strcmp(patterns[i], "er")` 或 `strlen(patterns[i])` 等字符串函数来操作这些字符串，就像处理普通的 `char*` 一样。

### 二维字符数组与一维字符串数组的区别

- **一维字符数组**：用于存储单个字符串。例如，`char word[33]` 可以存储一个最多为 `32` 个字符的字符串（包含终止符）。
- **二维字符数组**：用于存储多个字符串，每个字符串都有自己的长度和终止符。例如，`char patterns[][4]` 可以存储多个最长为 `3` 个字符的字符串，每个字符串末尾有 `\0`。

### 示例总结

```cpp
char patterns[][4] = {"er", "ly", "ing"};
```

- 这是一个二维字符数组，存储了三个字符串 `"er"`、`"ly"` 和 `"ing"`，每个字符串最多有 `3` 个字符加 `1` 个空字符。
- 你可以通过 `patterns[i]` 访问每个字符串，并使用标准的字符串操作函数（如 `strcmp`、`strlen`）对其进行操作。

是的，你理解得很对。`char patterns[][4] = {"er", "ly", "ing"};` 这种写法是允许的，因为编译器可以**自动推断出数组的行数**。这是 C 和 C++ 中二维数组定义的一种灵活性表现。

### 为什么可以省略行数 `3`

- **推断数组的大小**：当你定义 `char patterns[][4]`，并在初始化时提供了 `{"er", "ly", "ing"}` 三个元素，编译器会自动根据初始化列表的元素数量推断出行数为 `3`。
- **强制指定列大小**：列数 `4` 必须显式指定，因为在内存布局中，每行的大小是固定的，编译器需要知道每行能够存储多少个字符。
  - 每个字符串最多为 `3` 个字符，加上字符串结束符 `\0`，总共需要 `4` 个字符的空间。因此，我们必须指定 `4`。
  - 如果省略列数 `4`（即写成 `char patterns[][] = {"er", "ly", "ing"}`），编译器会报错，因为它无法推断出每行的大小。

### 如何解释 `char patterns[3][4]`

如果我们显式地写成 `char patterns[3][4] = {"er", "ly", "ing"};`，这表示一个二维字符数组，包含 `3` 行、`4` 列。每行都是一个 `char[4]` 数组，可以存储一个字符串，最多 `3` 个字符加 `1` 个空字符 `\0`。

### 编译器如何推断

- 在 `char patterns[][4] = {"er", "ly", "ing"};` 中，编译器根据提供的初始化列表 `{ "er", "ly", "ing" }` 看到有 `3` 个字符串，所以推断出数组有 `3` 行。
- 这就等效于写成 `char patterns[3][4] = {"er", "ly", "ing"};`。

### 省略行数的好处

- **简洁性**：在初始化时，如果你知道要存储的字符串数量，省略行数可以让代码更简洁。
- **灵活性**：如果以后修改了初始化列表的大小，编译器会自动调整行数，而不需要手动更改数组声明中的行数。

### 例子总结

```cpp
char patterns[][4] = {"er", "ly", "ing"};
```

- 编译器推断出有 `3` 行。
- 每行有 `4` 列，存储 `3` 个字符和一个终止符 `\0`。
- 等效于 `char patterns[3][4] = {"er", "ly", "ing"};`，但使用省略行数的写法更为简洁。

在这个例子中：

- 当 `word.size()` 是 `6` 时，`word.size() - 2` 计算出的是 `4`。
- `word.substr(word.size() - 2)` 从索引 `4` 开始，提取 `2` 个字符。这确实会包含从索引 `4` 开始的字符和索引 `5` 的字符（即最后两个字符）。

### 说明

- **索引从 `0` 开始**：字符串的索引是从 `0` 开始的，因此 `word.size() - 2` 指的是字符串倒数第二个字符的索引。
- **`substr()` 函数的行为**：`word.substr(start)` 生成从 `start` 索引开始的子字符串，直到字符串的末尾。`word.substr(start, length)` 则生成从 `start` 开始、长度为 `length` 的子字符串。

### 举例

假设 `word = "runner"`：

- `word.size()` 是 `6`。
- `word.size() - 2` 是 `4`，这对应于字符 `'e'` 的索引位置。
- `word.substr(4)` 或 `word.substr(4, 2)` 会提取从索引 `4` 开始的 `2` 个字符，即字符串 `"er"`。

### 总结

- **包含了第 `4` 个字符和第 `5` 个字符**：`word.substr(4, 2)` 包括索引 `4` 和 `5` 的字符，即字符串 `"er"`。
- 因为索引是从 `0` 开始，所以 `word.size() - 2` 确实表示倒数第二个字符的起始位置。

在这个示例中，我们使用了 `strcmp(word + len - patternLen, patterns[i])` 语句，它的作用是比较两个字符串：`word + len - patternLen` 和 `patterns[i]`。这是一个比较字符串尾部子字符串和给定模式的标准方式。让我详细解释其中的原理和工作机制：

### 1. **`strcmp` 的基本原理**

- `strcmp` 是一个来自 C 标准库 `<cstring>` 的函数，用于比较两个 C 风格的字符串。
- 它逐字符比较两个字符串的 ASCII 值，直到遇到不同的字符或遇到字符串结束符 `\0`。
- 返回值：
  - 如果两个字符串相等，`strcmp` 返回 `0`。
  - 如果第一个字符串小于第二个字符串（按字典顺序），返回负值。
  - 如果第一个字符串大于第二个字符串，返回正值。

### 2. **`strcmp(word + len - patternLen, patterns[i])` 的含义**

- `word + len - patternLen` 是一个指针运算，表示指向字符串 `word` 的某个位置。
  - `word` 是一个字符数组或指针，`len` 是 `word` 的总长度，`patternLen` 是我们要匹配的模式的长度（例如 `2` 或 `3`）。
  - `word + len - patternLen` 让指针从字符串末尾向前移动 `patternLen` 个字符，指向可能的后缀开始位置。
  - 例如，如果 `word = "running"`，`len = 7`，`patternLen = 3`，那么 `word + len - patternLen` 指向字符串 `"ing"` 的起始位置。

- `patterns[i]` 是我们要比较的模式字符串，如 `"er"`、`"ly"`、`"ing"` 等。

- `strcmp(word + len - patternLen, patterns[i])` 通过 `strcmp` 函数从指针位置开始比较 `word` 字符串的尾部和 `patterns[i]`。

### 3. **工作机制**

- 当 `strcmp(word + len - patternLen, patterns[i])` 被调用时，`strcmp` 会从 `word + len - patternLen` 指针开始，与 `patterns[i]` 逐字符进行比较。
  - 如果两者完全相等（包括长度和内容），`strcmp` 返回 `0`，表示匹配成功。
  - 如果不同，则返回一个非零值。

### 4. **示例操作**

假设 `word = "running"`，我们想判断它是否以 `"ing"` 结尾：

1. 计算长度：
   - `len = 7`（长度为 `7`，`r-u-n-n-i-n-g`）。
   - `patternLen = 3`（`"ing"` 的长度）。

2. 计算比较位置：
   - `word + len - patternLen = word + 7 - 3 = word + 4`。
   - 这意味着从 `word[4]` 开始，子字符串是 `"ing"`。

3. 比较：
   - `strcmp(word + 4, "ing")` 会比较 `word[4]` 到 `word[6]` 的内容与 `"ing"` 是否匹配。
   - 如果匹配，返回 `0`，否则返回非零值。

### 5. **为什么使用这种方式？**

- 这种方式利用了指针运算的强大功能，可以高效地从字符串的任意位置开始比较，而不需要额外的字符串复制或创建新字符串。
- 通过计算字符串长度和模式长度，我们可以灵活地检查字符串是否以特定后缀结尾，而不需要手动构建和遍历每个字符。

### 总结

- `strcmp(word + len - patternLen, patterns[i])` 的作用是从 `word` 字符串的尾部开始，与 `patterns[i]` 进行逐字符比较。
- 这种方式依赖于指针运算和 `strcmp` 的逐字符比较功能，能够高效判断字符串的尾部是否匹配特定模式。

原文地址：https://blog.csdn.net/qq_46243318/article/details/143579394

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！