东方 - 字符串

字符串

1.字符型

1967. 输出字符的ascii码

#include <iostream>
using namespace std;

int main()
{
	char a;
	cin>>a;
	cout<<int(a)<<endl;
	
	return 0;
 } 

1970. 判断是什么字符

方法一：

#include <iostream>
using namespace std;

int main() {
    char ch;
    cin >> ch;

    if (ch >= 'A' && ch <= 'Z') {
        cout << "upper" << endl;
    } else if (ch >= 'a' && ch <= 'z') {
        cout << "lower" << endl;
    } else if (ch >= '0' && ch <= '9') {
        cout << "digit" << endl;
    }

    return 0;
}

代码解释:

1. 首先,我们使用cin从键盘读入一个字符,并将其存储在变量ch中。

2. 接下来,我们使用条件语句来判断字符的类型:

   • 如果字符的ASCII码在’A’到’Z’之间(即大写字母),则输出"upper"。
   • 如果字符的ASCII码在’a’到’z’之间(即小写字母),则输出"lower"。
   • 如果字符的ASCII码在’0’到’9’之间(即数字),则输出"digit"。

3. 最后,程序结束。

这个代码的逻辑很简单:我们利用字符的ASCII码范围来判断其类型。在ASCII编码中:

• 大写字母的ASCII码范围是65到90,即’A’到’Z’。
• 小写字母的ASCII码范围是97到122,即’a’到’z’。
• 数字的ASCII码范围是48到57,即’0’到’9’。

通过比较字符的ASCII码是否在这些范围内,我们就可以判断出字符的类型。

你可以将这段代码复制到你的C++编译器中,然后运行并测试。当你输入一个字符时,程序会根据字符的类型输出相应的结果。

方法二：

#include <iostream>
#include <cctype>
using namespace std;

int main() {
    char ch;
    cin >> ch;

    if (isupper(ch)) {
        cout << "upper" << endl;
    } else if (islower(ch)) {
        cout << "lower" << endl;
    } else if (isdigit(ch)) {
        cout << "digit" << endl;
    }

    return 0;
}

代码解释:

1. 我们需要包含<cctype>头文件,该头文件提供了一些用于字符处理的函数。

2. 从键盘读入一个字符,并将其存储在变量ch中。

3. 使用C++内置函数判断字符的类型:

   • isupper(ch):如果字符ch是大写字母,则返回非零值(即为真),否则返回零(即为假)。
   • islower(ch):如果字符ch是小写字母,则返回非零值(即为真),否则返回零(即为假)。
   • isdigit(ch):如果字符ch是数字,则返回非零值(即为真),否则返回零(即为假)。

4. 根据内置函数的返回值,使用条件语句输出相应的结果:

   • 如果isupper(ch)为真,则输出"upper"。
   • 如果islower(ch)为真,则输出"lower"。
   • 如果isdigit(ch)为真,则输出"digit"。

5. 程序结束。

使用内置函数可以简化我们的代码,提高可读性和维护性。这些函数在<cctype>头文件中定义,可以直接使用。

你可以将这段代码复制到你的C++编译器中,然后运行并测试。当你输入一个字符时,程序会使用内置函数判断字符的类型,并输出相应的结果。

1971. 大小写转换

方法1：

#include <iostream>
using namespace std;

int main() {
    char ch;
    cin >> ch;

    if (ch >= 'A' && ch <= 'Z') {
        ch = ch + 32;
        cout << ch << endl;
    } else if (ch >= 'a' && ch <= 'z') {
        ch = ch - 32;
        cout << ch << endl;
    }

    return 0;
}

代码解释:

1. 从键盘读入一个字符,并将其存储在变量ch中。

2. 使用条件语句判断字符的类型:

   • 如果字符的ASCII码在’A’到’Z’之间(即大写字母),则将其转换为对应的小写字母并输出。
   • 如果字符的ASCII码在’a’到’z’之间(即小写字母),则将其转换为对应的大写字母并输出。

3. 转换大小写的方法:

   • 对于大写字母,我们将其ASCII码加上32,即可得到对应的小写字母。这是因为在ASCII编码中,大写字母的ASCII码比对应的小写字母的ASCII码小32。
   • 对于小写字母,我们将其ASCII码减去32,即可得到对应的大写字母。

4. 输出转换后的字母。

5. 程序结束。

这个代码使用了基本的ASCII码运算来实现字母的大小写转换。我们利用了大写字母和小写字母在ASCII码表中的规律关系:大写字母的ASCII码比对应的小写字母的ASCII码小32。

通过对字符的ASCII码进行加减运算,我们可以实现字母的大小写转换。如果输入的是大写字母,我们将其ASCII码加上32得到对应的小写字母;如果输入的是小写字母,我们将其ASCII码减去32得到对应的大写字母。

你可以将这段代码复制到你的C++编译器中,然后运行并测试。当你输入一个字母时,程序会根据字母的类型进行相应的大小写转换,并输出结果。

方法二

#include <iostream>
#include <cctype>
using namespace std;

int main() {
    char ch;
    cin >> ch;

    if (isupper(ch)) {
        ch = tolower(ch);
        cout << ch << endl;
    } else if (islower(ch)) {
        ch = toupper(ch);
        cout << ch << endl;
    }

    return 0;
}

代码解释:

1. 我们需要包含<cctype>头文件,该头文件提供了一些用于字符处理的函数。

2. 从键盘读入一个字符,并将其存储在变量ch中。

3. 使用isupper()和islower()函数判断字符的类型:

   • isupper(ch):如果字符ch是大写字母,则返回非零值(即为真),否则返回零(即为假)。
   • islower(ch):如果字符ch是小写字母,则返回非零值(即为真),否则返回零(即为假)。

4. 根据字符的类型,使用tolower()或toupper()函数进行大小写转换:

   • 如果isupper(ch)为真,表示输入的是大写字母,我们使用tolower(ch)函数将其转换为对应的小写字母,并将结果赋值给ch变量。
   • 如果islower(ch)为真,表示输入的是小写字母,我们使用toupper(ch)函数将其转换为对应的大写字母,并将结果赋值给ch变量。

5. 输出转换后的字符ch。

6. 程序结束。

这个代码使用了C++标准库提供的字符处理函数来实现字母的大小写转换。我们先使用isupper()和islower()函数判断输入字符的类型,然后根据字符类型使用tolower()或toupper()函数进行相应的大小写转换。

isupper()和islower()函数用于判断字符是否为大写字母或小写字母,而tolower()和toupper()函数用于将字符转换为对应的小写字母或大写字母。

在C++中,tolower()和toupper()函数的返回值类型是int,而不是char。这意味着我们不能直接将它们的返回值输出为字符。

通过搭配使用这些函数,我们可以方便地实现字母的大小写转换,代码也更加简洁和易读。

你可以将这段代码复制到你的C++编译器中,然后运行并测试。当你输入一个字母时,程序会根据字母的类型进行相应的大小写转换,并输出结果。

1969. 求下一个字母

#include <iostream>
using namespace std;

int main() {
    char ch;
    cin >> ch;

    if (ch >= 'A' && ch < 'Z') {
        ch = ch + 1;
        cout << ch << endl;
    } else if (ch == 'Z') {
        cout << 'A' << endl;
    } else if (ch >= 'a' && ch < 'z') {
        ch = ch + 1;
        cout << ch << endl;
    } else if (ch == 'z') {
        cout << 'a' << endl;
    }

    return 0;
}

代码解释:

1. 从键盘读入一个字符,并将其存储在变量ch中。

2. 使用条件语句判断字符的范围:

   • 如果字符在’A’到’Y’的范围内(即大写字母,但不包括’Z’),将字符的ASCII码加1,得到下一个字母,并输出。
   • 如果字符是’Z’,直接输出’A’。
   • 如果字符在’a’到’y’的范围内(即小写字母,但不包括’z’),将字符的ASCII码加1,得到下一个字母,并输出。
   • 如果字符是’z’,直接输出’a’。

3. 程序结束。

这个代码利用了字符的ASCII码值来判断字母的范围和进行字母的转换。在ASCII编码中,大写字母’A’到’Z’的ASCII码值是连续的,小写字母’a’到’z’的ASCII码值也是连续的。

通过将字符的ASCII码值加1,我们可以得到字母表中的下一个字母。对于特殊情况,如’Z’和’z’,我们需要单独处理,分别输出’A’和’a’。

你可以将这段代码复制到你的C++编译器中,然后运行并测试。当你输入一个字母时,程序会输出该字母的下一个字母。

1093. 打印小写字母表

#include <iostream>
using namespace std;

int main() {
    for (char ch = 'a'; ch <= 'z'; ch++) {
        cout << ch;

        if (ch == 'm') {
            cout << endl;
        }
    }
	cout<<endl;
    for (char ch = 'z'; ch >= 'a'; ch--) {
        cout << ch;

        if (ch == 'n') {
            cout << endl;
        }
    }
	cout<<endl;
    return 0;
}

1974. 字母矩形1

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            char ch = 'A' + i;
            cout << ch;
        }
        cout << endl;
    }

    return 0;
}

代码解释:

1. 从标准输入读取一个整数n,表示要打印的行数和列数。

2. 使用嵌套的for循环来打印字母矩形:

   • 外层循环控制行数,循环变量i从0到n-1。
   • 内层循环控制列数,循环变量j从0到n-1。

3. 在内层循环中:

   • 计算当前行对应的字母,通过将字符’A’与行号i相加得到。
   • 输出当前行对应的字母。

4. 在内层循环结束后,使用cout << endl;进行换行,开始打印下一行。

5. 外层循环结束后,程序结束。

这个代码利用了嵌套循环来打印字母矩形。外层循环控制行数,内层循环控制每行的列数。通过将字符’A’与行号相加,我们可以得到每行对应的字母。

在内层循环中,我们重复输出当前行对应的字母,形成一行相同字母的矩形。在每行输出完成后,我们使用换行符进行换行,开始打印下一行。

你可以将这段代码复制到你的C++编译器中,然后运行并输入一个整数n。程序将输出一个n行n列的字母矩形,其中每行的字母都相同,并按照字母表的顺序递增。

1975. 字母矩形2

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            char ch = 'A' + j;
            cout << ch;
        }
        cout << endl;
    }

    return 0;
}

代码解释:

1. 从标准输入读取一个整数n,表示要打印的行数和列数。

2. 使用嵌套的for循环来打印字母矩形:

   • 外层循环控制行数,循环变量i从0到n-1。
   • 内层循环控制列数,循环变量j从0到n-1。

3. 在内层循环中:

   • 计算当前列对应的字母,通过将字符’A’与列号j相加得到。
   • 输出当前列对应的字母。

4. 在内层循环结束后,使用cout << endl;进行换行,开始打印下一行。

5. 外层循环结束后,程序结束。

与之前的代码相比,这里的主要区别在于内层循环中字母的计算方式。我们将字符’A’与列号j相加,得到每列对应的字母。这样,每行的字母都会按照字母表的顺序递增。

在外层循环中,我们重复打印相同的字母行,形成一个n行n列的字母矩形。每行的字母都按照字母表的顺序排列,行与行之间的字母相同。

你可以将这段代码复制到你的C++编译器中,然后运行并输入一个整数n。程序将输出一个n行n列的字母矩形,其中每行的字母都按照字母表的顺序排列,行与行之间的字母相同。

1976. 字母直角1

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= i; j++) {
            char ch = 'A' + j;
            cout << ch;
        }
        cout << endl;
    }

    return 0;
}

代码解释:

1. 从标准输入读取一个整数n,表示要打印的行数。

2. 使用嵌套的for循环来打印字母直角:

   • 外层循环控制行数,循环变量i从0到n-1。
   • 内层循环控制每行的字母数,循环变量j从0到i。

3. 在内层循环中:

   • 计算当前位置对应的字母,通过将字符’A’与列号j相加得到。
   • 输出当前位置对应的字母。

4. 在内层循环结束后,使用cout << endl;进行换行,开始打印下一行。

5. 外层循环结束后,程序结束。

这个代码利用了嵌套循环来打印字母直角。外层循环控制行数,内层循环控制每行的字母数。

在内层循环中,我们将字符’A’与列号j相加,得到当前位置对应的字母。随着行数的增加,每行的字母数也相应增加。

在每行输出完成后,我们使用换行符进行换行,开始打印下一行。这样,我们就可以得到一个n行的字母直角,其中每行的字母数逐行递增,字母按照字母表的顺序排列。

你可以将这段代码复制到你的C++编译器中,然后运行并输入一个整数n。程序将输出一个n行的字母直角,其中每行的字母数逐行递增,字母按照字母表的顺序排列。

1977. 字母直角2

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {
        char ch = 'A' + i;
        for (int j = 0; j <= i; j++) {
            cout << ch;
        }
        cout << endl;
    }

    return 0;
}

代码解释:

1. 从标准输入读取一个整数n,表示要打印的行数。

2. 使用嵌套的for循环来打印字母直角:

   • 外层循环控制行数,循环变量i从0到n-1。
   • 在外层循环中,计算当前行对应的字母,通过将字符’A’与行号i相加得到。
   • 内层循环控制每行的字母数,循环变量j从0到i。

3. 在内层循环中:

   • 输出当前行对应的字母。

4. 在内层循环结束后,使用cout << endl;进行换行,开始打印下一行。

5. 外层循环结束后,程序结束。

与之前的代码相比,这里的主要区别在于字母的计算位置和内层循环的作用。

我们将字母的计算移到了外层循环中,通过将字符’A’与行号i相加,得到每行对应的字母。这样,每行的字母都会按照字母表的顺序递增。

内层循环的作用是控制每行输出的字母数。随着行数的增加,每行输出的字母数也相应增加。在内层循环中,我们重复输出当前行对应的字母,形成一个字母直角。

在每行输出完成后,我们使用换行符进行换行,开始打印下一行。这样,我们就可以得到一个n行的字母直角,其中每行的字母数逐行递增,字母按照字母表的顺序排列。

你可以将这段代码复制到你的C++编译器中,然后运行并输入一个整数n。程序将输出一个n行的字母直角,其中每行的字母数逐行递增,字母按照字母表的顺序排列。

1094. 字符图形10-字母三角

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {
        // 打印空格
        for (int j = 0; j < n - i - 1; j++) {
            cout << " ";
        }

        // 打印字母
        char ch = 'A' + i;
        for (int j = 0; j < 2 * i + 1; j++) {
            cout << ch;
        }

        cout << endl;
    }

    return 0;
}

代码解释:

1. 从标准输入读取一个整数n,表示要打印的行数。

2. 使用嵌套的for循环来打印字母三角:

   • 外层循环控制行数,循环变量i从0到n-1。

3. 在外层循环中,首先打印空格:

   • 内层循环控制空格数,循环变量j从0到n-i-1。
   • 在内层循环中,输出空格。

4. 接下来,打印字母:

   • 计算当前行对应的字母,通过将字符’A’与行号i相加得到。
   • 内层循环控制每行输出的字母数,循环变量j从0到2*i+1。
   • 在内层循环中,重复输出当前行对应的字母。

5. 在内层循环结束后,使用cout << endl;进行换行,开始打印下一行。

6. 外层循环结束后,程序结束。

这段代码利用了嵌套循环来打印字母三角。外层循环控制行数,内层循环分别控制空格数和字母数。

在每一行中,我们首先打印空格,空格数随着行号的增加而减少。然后,我们打印字母,每行的字母数是一个等差数列,首项为1,公差为2。通过将字符’A’与行号i相加,得到每行对应的字母。

在每行输出完成后,我们使用换行符进行换行,开始打印下一行。这样,我们就可以得到一个n行的字母三角,其中每行的字母数呈等差数列增加,字母按照字母表的顺序排列。

你可以将这段代码复制到你的C++编译器中,然后运行并输入一个整数n。程序将输出一个n行的字母三角,其中每行的字母数呈等差数列增加,字母按照字母表的顺序排列。

1095. 字符图形11-字母正三角

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {
        // 打印空格
        for (int j = 0; j < n - i - 1; j++) {
            cout << " ";
        }

        // 打印字母
        char ch = 'A';
        for (int j = 0; j < 2 * i + 1; j++) {
            cout << ch;
            ch++;
        }

        cout << endl;
    }

    return 0;
}

代码解释:

1. 从标准输入读取一个整数n,表示要打印的行数。

2. 使用嵌套的for循环来打印字母正三角:

   • 外层循环控制行数,循环变量i从0到n-1。

3. 在外层循环中,首先打印空格:

   • 内层循环控制空格数,循环变量j从0到n-i-1。
   • 在内层循环中,输出空格。

4. 接下来,打印字母:

   • 定义一个字符变量ch,初始值为’A’。
   • 内层循环控制每行输出的字母数,循环变量j从0到2*i+1。
   • 在内层循环中,输出当前字母,然后将字母变量ch递增。

5. 在内层循环结束后,使用cout << endl;进行换行,开始打印下一行。

6. 外层循环结束后,程序结束。

这段代码利用了嵌套循环来打印字母正三角。外层循环控制行数,内层循环分别控制空格数和字母数。

在每一行中,我们首先打印空格,空格数随着行号的增加而减少。然后,我们打印字母,每行的字母数是一个等差数列,首项为1,公差为2。我们使用一个字符变量ch来跟踪当前要打印的字母,初始值为’A’。在内层循环中,我们输出当前字母,然后将字母变量递增,以打印下一个字母。

在每行输出完成后,我们使用换行符进行换行,开始打印下一行。这样,我们就可以得到一个n行的字母正三角,其中每行的字母数呈等差数列增加,字母按照字母表的顺序排列。

你可以将这段代码复制到你的C++编译器中,然后运行并输入一个整数n。程序将输出一个n行的字母正三角,其中每行的字母数呈等差数列增加,字母按照字母表的顺序排列。

1858. 数组查找及替换

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

int main() {
    int N, b;
    cin >> N >> b;

    vector<int> arr(N);
    for (int i = 0; i < N; i++) {
        cin >> arr[i];
    }

    vector<int> newArr;
    for (int i = 0; i < N; i++) {
        if (arr[i] % b != 0) {
            newArr.push_back(arr[i]);
        }
    }

    sort(newArr.begin(), newArr.end());

    for (int i = 0; i < newArr.size(); i++) {
        if (newArr[i] >= 65 && newArr[i] <= 90) {
            char ch = static_cast<char>(newArr[i]);
            cout << ch << " ";
        } else {
            cout << newArr[i] << " ";
        }
    }

    return 0;
}

代码解释:

1. 我们使用cin读取数组元素个数N和整数b。

2. 创建一个大小为N的vector数组arr,并使用循环读取N个元素。

3. 创建一个新的vector数组newArr,用于存储不能被b整除的元素。我们使用循环遍历arr数组,如果当前元素不能被b整除,就将其添加到newArr中。

4. 使用sort函数对newArr数组进行排序,默认为升序排序。

5. 遍历newArr数组,对于每个元素,如果其值在’A’到’Z’的ASCII范围内(65到90),就将其转换为对应的字母并输出。否则,直接输出该元素的值。

6. 程序结束。

你可以将这段代码复制到你的C++编译器中,然后运行并输入数组元素个数N、整数b以及N个数组元素。程序将按照题目要求删除可以被b整除的元素,对剩余元素进行排序,并将符合条件的元素替换为对应的字母,最后输出处理后的数组。

1972. 素数字母

以下是使用C++编写的代码:

#include <iostream>
using namespace std;

bool isPrime(int num) {
    if (num < 2) {
        return false;
    }
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    for (char ch = 'A'; ch <= 'Z'; ch++) {
        int ascii = static_cast<int>(ch);
        if (isPrime(ascii)) {
            cout << ascii << " " << ch << endl;
        }
    }

    for (char ch = 'a'; ch <= 'z'; ch++) {
        int ascii = static_cast<int>(ch);
        if (isPrime(ascii)) {
            cout << ascii << " " << ch << endl;
        }
    }

    return 0;
}

代码解释:

1. 我们定义了一个isPrime函数,用于判断一个数是否为素数。该函数接受一个整数参数num,如果num小于2,则返回false(因为1和负数不是素数)。否则,使用循环从2到sqrt(num)遍历,如果num能被任何一个数整除,则返回false。如果循环结束后没有返回false,说明num是素数,返回true。

2. 在main函数中,我们使用两个嵌套的for循环遍历所有的字母。第一个循环遍历大写字母(从’A’到’Z’),第二个循环遍历小写字母(从’a’到’z’)。

3. 在每个循环中,我们使用static_cast将当前字母转换为整数,得到其ASCII码。然后,我们调用isPrime函数判断该ASCII码是否为素数。

4. 如果ASCII码是素数,我们按照要求输出ASCII码和对应的字母,中间用空格隔开。

5. 程序结束。

运行这段代码,将输出所有符合条件的字母的ASCII码和字母本身,按照ASCII码从小到大的顺序排列。

输出结果将类似于:

67 C
71 G
73 I
...
107 k
109 m
113 q
...

每行先输出字母的ASCII码,然后空一格,再输出对应的字母。

1973. 回文字母

方法一

#include <iostream>
using namespace std;

bool isPalindrome(int num) {
    int originalNum = num;
    int reversedNum = 0;
    
    while (num > 0) {
        int digit = num % 10;
        reversedNum = reversedNum * 10 + digit;
        num /= 10;
    }
    
    return originalNum == reversedNum;
}

int main() {
    for (char ch = 'A'; ch <= 'Z'; ch++) {
        int ascii = static_cast<int>(ch);
        if (isPalindrome(ascii)) {
            cout << ch << endl;
        }
    }
    
    return 0;
}

代码解释:

1. 我们定义了一个isPalindrome函数,用于判断一个数是否为回文数。该函数接受一个整数参数num,将其赋值给变量originalNum。

2. 在isPalindrome函数中,我们使用变量reversedNum来存储num的反转数。通过一个while循环,我们不断地取出num的最后一位数字(num % 10),将其添加到reversedNum的末尾(reversedNum * 10 + digit),然后将num除以10(num /= 10)以去掉最后一位数字。重复这个过程,直到num变为0。

3. 最后,我们比较originalNum和reversedNum是否相等。如果相等,说明num是一个回文数,返回true;否则返回false。

4. 在main函数中,我们使用一个for循环遍历所有的大写字母(从’A’到’Z’)。

5. 在循环中,我们使用static_cast将当前字母转换为整数,得到其ASCII码。然后,我们调用isPalindrome函数判断该ASCII码是否为回文数。

6. 如果ASCII码是回文数,我们就输出对应的字母,并换行。

7. 程序结束。

运行这段代码,将输出所有符合条件的大写字母,按照ASCII码从小到大的顺序排列。

输出结果将类似于:

A
B
C
...

每行输出一个满足条件的大写字母。

方法二

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

bool isPalindrome(int num)
{
    string s = to_string(num);
    string rs = s;
    reverse(rs.begin(), rs.end());
    return s == rs;
}

int main() {
    for (char ch = 'A'; ch <= 'Z'; ch++) {
        int ascii = static_cast<int>(ch);
        if (isPalindrome(ascii)) {
            cout << ch << endl;
        }
    }
    
    return 0;
}

代码解释:

1. 我们定义了一个isPalindrome函数,用于判断一个数是否为回文数。该函数接受一个整数参数num。

2. 在isPalindrome函数中,我们首先使用to_string函数将num转换为字符串s。

3. 然后,我们创建一个新的字符串rs,并将s赋值给它。

4. 使用reverse函数将rs翻转。

5. 最后,我们比较s和rs是否相等。如果相等,说明num是一个回文数,返回true;否则返回false。

6. 在main函数中,我们使用一个for循环遍历所有的大写字母(从’A’到’Z’)。

7. 在循环中,我们使用static_cast将当前字母转换为整数,得到其ASCII码。然后,我们调用isPalindrome函数判断该ASCII码是否为回文数。

8. 如果ASCII码是回文数,我们就输出对应的字母,并换行。

9. 程序结束。

运行这段代码,将输出所有符合条件的大写字母,按照ASCII码从小到大的顺序排列。

输出结果将类似于:

B
M
X

每行输出一个满足条件的大写字母。

这个解决方案使用了你提供的方法,通过将数字转换为字符串,然后翻转字符串并进行比较来判断数字是否为回文数。

2.字符串基础

1093. 打印小写字母表

#include <iostream>
using namespace std;

int main() {
    // 正序输出前13个小写字母
    for (char ch = 'a'; ch <= 'm'; ch++) {
        cout << ch;
    }
    cout << endl;

    // 正序输出后13个小写字母
    for (char ch = 'n'; ch <= 'z'; ch++) {
        cout << ch;
    }
    cout << endl;

    // 倒序输出后13个小写字母
    for (char ch = 'z'; ch >= 'n'; ch--) {
        cout << ch;
    }
    cout << endl;

    // 倒序输出前13个小写字母
    for (char ch = 'm'; ch >= 'a'; ch--) {
        cout << ch;
    }
    cout << endl;

    return 0;
}

代码解释:

1. 第一个for循环用于正序输出前13个小写字母:

   • 循环变量ch从字符'a'开始,一直到字符'm'。
   • 在每次循环中,将当前字符ch输出到标准输出。
   • 循环结束后,使用endl输出换行符。

2. 第二个for循环用于正序输出后13个小写字母:

   • 循环变量ch从字符'n'开始,一直到字符'z'。
   • 在每次循环中,将当前字符ch输出到标准输出。
   • 循环结束后,使用endl输出换行符。

3. 第三个for循环用于倒序输出后13个小写字母:

   • 循环变量ch从字符'z'开始,一直到字符'n'。
   • 在每次循环中,将当前字符ch输出到标准输出。
   • 循环结束后,使用endl输出换行符。

4. 第四个for循环用于倒序输出前13个小写字母:

   • 循环变量ch从字符'm'开始,一直到字符'a'。
   • 在每次循环中,将当前字符ch输出到标准输出。
   • 循环结束后,使用endl输出换行符。

5. 程序结束。

这段代码利用了ASCII码的顺序关系,通过循环和字符的比较来输出小写字母。每个循环输出13个字母,并在输出完一行后换行。

你可以将这段代码复制到你的C++编译器中,然后运行。程序将按照要求输出四行,每行包含13个小写字母,分别按照正序和倒序排列。

1101. 时间的差

这个问题可以通过将时间转换为秒数,然后计算两个时间的秒数差来解决。以下是使用C++编写的代码:

#include <iostream>
#include <string>
using namespace std;

int timeToSeconds(string time) {
    int hours = stoi(time.substr(0, 2));
    int minutes = stoi(time.substr(3, 2));
    int seconds = stoi(time.substr(6, 2));
    return hours * 3600 + minutes * 60 + seconds;
}

int main() {
    string time1, time2;
    getline(cin, time1);
    getline(cin, time2);

    int seconds1 = timeToSeconds(time1);
    int seconds2 = timeToSeconds(time2);

    int difference = seconds1 - seconds2;

    cout << difference << endl;

    return 0;
}

代码解释:

1. 首先,我们定义了一个名为timeToSeconds的函数,用于将时间字符串转换为秒数:

   • 函数接受一个字符串参数time,表示时间。
   • 使用stoi函数将时间字符串的小时、分钟和秒部分分别转换为整数。
   • 将小时乘以3600(一小时的秒数),分钟乘以60(一分钟的秒数),再加上秒数,得到总的秒数。
   • 返回计算得到的总秒数。

2. 在main函数中,我们首先使用getline函数从标准输入读取两行时间字符串,分别存储在time1和time2中。

3. 然后,我们调用timeToSeconds函数,将time1和time2转换为对应的秒数,分别存储在seconds1和seconds2中。

4. 接下来,我们计算seconds1和seconds2的差值,得到两个时间之间的秒数差,存储在变量difference中。

5. 最后,我们将difference输出到标准输出,并换行。

6. 程序结束。

这段代码的逻辑如下:

1. 读取两个时间字符串。
2. 将每个时间字符串转换为秒数。
3. 计算两个时间的秒数差。
4. 输出秒数差。

你可以将这段代码复制到你的C++编译器中,然后运行并输入两个时间字符串。程序将输出两个时间之间的秒数差。

需要注意的是,本题保证第一个时间一定大于第二个时间,所以我们直接用第一个时间的秒数减去第二个时间的秒数即可得到秒数差。

1115. 数字和

这个问题可以通过将输入的大数作为字符串处理,然后遍历字符串中的每个字符,将其转换为整数并累加到总和中。以下是使用C++编写的代码:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string number;
    cin >> number;

    int sum = 0;
    for (char digit : number) {
        sum += digit - '0';
    }

    cout << sum << endl;

    return 0;
}

代码解释:

1. 首先,我们从标准输入读取一个字符串number,表示输入的大数。

2. 定义一个整数变量sum,初始值为0,用于存储各位数字的和。

3. 使用一个基于范围的for循环遍历字符串number中的每个字符digit:

   • 字符digit表示当前遍历到的数字字符。
   • 将字符digit减去字符'0',得到对应的整数值。这是因为在ASCII编码中,数字字符的编码是连续的,例如'1'的ASCII码是'0'的ASCII码加1。
   • 将转换后的整数值累加到sum中。

4. 循环结束后,sum中存储了输入大数各位数字的和。

5. 将sum输出到标准输出,并换行。

6. 程序结束。

这段代码的逻辑如下:

1. 读取输入的大数字符串。
2. 初始化变量sum为0,用于存储各位数字的和。
3. 遍历大数字符串中的每个字符:
   • 将当前字符转换为整数。
   • 将转换后的整数累加到sum中。
4. 输出sum,即各位数字的和。

你可以将这段代码复制到你的C++编译器中,然后运行并输入一个大数。程序将输出该大数各位数字的和。

需要注意的是,本题保证输入的大数不超过200位,所以我们可以直接将其作为字符串处理,而不需要使用特殊的大数库或算法。

1134. 国王的魔镜

这个问题可以通过判断字符串的前半部分和后半部分是否相等来确定最初项链的最小长度。如果前半部分和后半部分相等,则说明该部分是通过魔镜变换得到的,可以继续缩短字符串的长度。以下是使用C++编写的代码:

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

int main() {
    string necklace;
    cin >> necklace;

    int length = necklace.length();

    while (length > 0) {
        if (length % 2 != 0) {
            break;
        }

        string firstHalf = necklace.substr(0, length / 2);
        string secondHalf = necklace.substr(length / 2, length / 2);
        reverse(secondHalf.begin(), secondHalf.end());

        if (firstHalf == secondHalf) {
            necklace = firstHalf;
            length = necklace.length();
        } else {
            break;
        }
    }

    cout << length << endl;

    return 0;
}

代码解释:

1. 首先,我们从标准输入读取一个字符串necklace,表示最终的项链。

2. 定义一个整数变量length,表示当前项链的长度,初始值为necklace的长度。

3. 进入一个while循环,直到length为0或不满足条件为止:

   • 如果length为奇数,说明不能再缩短项链的长度,直接退出循环。
   • 将项链的前半部分赋值给字符串firstHalf,后半部分赋值给字符串secondHalf。
   • 使用reverse函数将secondHalf反转。
   • 比较firstHalf和secondHalf是否相等:
     • 如果相等,说明前半部分和后半部分是通过魔镜变换得到的,可以将firstHalf赋值给necklace,并更新length为firstHalf的长度。
     • 如果不相等,说明无法再缩短项链的长度,直接退出循环。

4. 循环结束后,length表示最初项链可能的最小长度。

5. 将length输出到标准输出,并换行。

6. 程序结束。

这段代码的逻辑如下:

1. 读取输入的最终项链字符串。
2. 初始化变量length为项链的长度。
3. 进入循环,直到无法再缩短项链的长度:
   • 如果length为奇数,退出循环。
   • 将项链分为前半部分和后半部分。
   • 反转后半部分。
   • 比较前半部分和反转后的后半部分是否相等:
     • 如果相等,更新necklace为前半部分,并更新length。
     • 如果不相等,退出循环。
4. 输出最初项链可能的最小长度length。

你可以将这段代码复制到你的C++编译器中,然后运行并输入最终项链的字符串。程序将输出最初项链可能的最小长度。

1387. 简单加密

这个问题可以通过将密文中的每个字母按照对应关系进行解密来得到明文。以下是使用C++编写的代码:

#include <iostream>
#include <string>
using namespace std;

char decrypt(char c) {
    if (c >= 'A' && c <= 'E') {
        return c + 21;
    } else if (c >= 'F' && c <= 'Z') {
        return c - 5;
    } else {
        return c;
    }
}

int main() {
    string ciphertext;
    getline(cin, ciphertext);

    string plaintext = "";
    for (char c : ciphertext) {
        plaintext += decrypt(c);
    }

    cout << plaintext << endl;

    return 0;
}

代码解释:

1. 首先,我们定义了一个decrypt函数,用于对单个字符进行解密:

   • 如果字符c在’A’到’E’之间,说明它对应的明文字符在字母表的后21位,因此返回c + 21。
   • 如果字符c在’F’到’Z’之间,说明它对应的明文字符在字母表的前5位,因此返回c - 5。
   • 如果字符c不是字母,直接返回c本身,不进行解密。

2. 在main函数中,我们首先使用getline函数从标准输入读取一行密文字符串ciphertext。

3. 定义一个空字符串plaintext,用于存储解密后的明文。

4. 使用基于范围的for循环遍历ciphertext中的每个字符c:

   • 调用decrypt函数对字符c进行解密,得到对应的明文字符。
   • 将解密后的字符追加到plaintext字符串的末尾。

5. 循环结束后,plaintext中存储了完整的明文。

6. 将plaintext输出到标准输出,并换行。

7. 程序结束。

这段代码的逻辑如下:

1. 读取输入的密文字符串。
2. 初始化一个空字符串plaintext,用于存储解密后的明文。
3. 遍历密文字符串中的每个字符:
   • 对当前字符进行解密。
   • 将解密后的字符追加到plaintext中。
4. 输出解密后的明文plaintext。

你可以将这段代码复制到你的C++编译器中,然后运行并输入密文字符串。程序将输出解密后的明文。

需要注意的是,密文中可能包含非字母的字符,对这些字符不进行解密,直接保留在明文中。

1480. 找字典码最小的字符串

这个问题可以通过读取输入的字符串并逐个比较它们的字典序来找到字典码最小的字符串。以下是使用C++编写的代码:

#include <iostream>
#include <string>
using namespace std;

int main() {
    int n;
    cin >> n;
    cin.ignore();  // 忽略输入流中的换行符
	//使用cin读取后再次使用getline就要忽略掉换行符
    string minString;
    getline(cin, minString);  // 读取第一个字符串作为初始的最小字符串

    for (int i = 1; i < n; i++) {
        string currentString;
        getline(cin, currentString);

        if (currentString < minString) {
            minString = currentString;
        }
    }

    cout << minString << endl;

    return 0;
}

代码解释:

1. 首先,我们从标准输入读取一个整数n,表示字符串的数量。

2. 使用cin.ignore()忽略输入流中的换行符,以便后续使用getline函数读取字符串。

3. 定义一个字符串变量minString,用于存储当前字典码最小的字符串。

   • 使用getline函数读取第一个字符串,并将其赋值给minString作为初始的最小字符串。

4. 使用for循环遍历剩余的n-1个字符串:

   • 定义一个字符串变量currentString,用于存储当前读取的字符串。
   • 使用getline函数读取当前字符串。
   • 使用<运算符比较currentString和minString的字典序:
     • 如果currentString的字典序小于minString,则将currentString赋值给minString,更新最小字符串。

5. 循环结束后,minString中存储的就是字典码最小的字符串。

6. 将minString输出到标准输出,并换行。

7. 程序结束。

这段代码的逻辑如下:

1. 读取字符串的数量n。
2. 读取第一个字符串作为初始的最小字符串。
3. 遍历剩余的n-1个字符串:
   • 读取当前字符串。
   • 比较当前字符串和当前最小字符串的字典序。
   • 如果当前字符串的字典序更小,更新最小字符串。
4. 输出字典码最小的字符串。

你可以将这段代码复制到你的C++编译器中,然后运行并输入字符串的数量以及每个字符串。程序将输出字典码最小的字符串。

1475. 字符串对比

当然,下面是使用C++解答该问题的代码:

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

int main() {
    string str1, str2;
    getline(cin, str1);
    getline(cin, str2);

    int len1 = str1.length();
    int len2 = str2.length();

    if (len1 != len2) {
        cout << 1 << endl;
    } else {
        bool exactMatch = true;
        bool caseInsensitiveMatch = true;

        for (int i = 0; i < len1; i++) {
            if (str1[i] != str2[i]) {
                exactMatch = false;
            }
            if (tolower(str1[i]) != tolower(str2[i])) {
                caseInsensitiveMatch = false;
            }
        }

        if (exactMatch) {
            cout << 2 << endl;
        } else if (caseInsensitiveMatch) {
            cout << 3 << endl;
        } else {
            cout << 4 << endl;
        }
    }

    return 0;
}

代码解释:

1. 首先,我们使用getline函数从标准输入读取两个字符串str1和str2。

2. 获取两个字符串的长度len1和len2。

3. 比较len1和len2:

   • 如果长度不相等,说明属于情况1,输出1,程序结束。
   • 如果长度相等,继续进行后续判断。

4. 定义两个布尔变量exactMatch和caseInsensitiveMatch,分别表示是否完全一致以及忽略大小写是否一致。初始值都设为true。

5. 使用循环遍历两个字符串的每个字符:

   • 比较相应位置上的字符是否完全一致:
     • 如果不一致,将exactMatch设为false。
   • 比较相应位置上的字符在忽略大小写的情况下是否一致:
     • 如果不一致,将caseInsensitiveMatch设为false。
   • 使用tolower函数将字符转换为小写进行比较,以忽略大小写。

6. 循环结束后,根据exactMatch和caseInsensitiveMatch的值判断属于哪种情况:

   • 如果exactMatch为true,说明两个字符串完全一致,属于情况2,输出2。
   • 如果exactMatch为false且caseInsensitiveMatch为true,说明两个字符串在忽略大小写的情况下一致,属于情况3,输出3。
   • 如果exactMatch和caseInsensitiveMatch都为false,说明两个字符串即使忽略大小写也不一致,属于情况4,输出4。

7. 程序结束。

该代码使用了C++的标准库函数和语法特性,可以正确判断两个字符串之间的关系,并输出相应的编号。

1478. 出现次数最多的小写字母

为了解决这个问题,我们可以使用一个长度为26的数组来记录每个小写字母出现的次数,然后遍历字符串,统计每个字母的出现次数。最后,找到出现次数最多的字母并输出。

以下是使用C++编写的解决方案:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str;
    cin >> str;

    int count[26] = {0};  // 用于记录每个字母出现的次数

    // 遍历字符串,统计每个字母的出现次数
    for (char c : str) {
        count[c - 'a']++;
    }

    int maxCount = 0;
    char maxChar = 'a';

    // 找到出现次数最多的字母
    for (int i = 0; i < 26; i++) {
        if (count[i] > maxCount) {
            maxCount = count[i];
            maxChar = 'a' + i;
        }
    }

    cout << maxChar << endl;

    return 0;
}

代码解释:

1. 首先,我们使用cin从标准输入读取一个字符串str。

2. 定义一个长度为26的整型数组count,用于记录每个小写字母出现的次数。数组的下标对应字母的ASCII码值与’a’的差值。

3. 使用基于范围的for循环遍历字符串str中的每个字符c:

   • 对于每个字符c,将其对应的count数组元素加1,即count[c - 'a']++。这样就统计了每个字母的出现次数。

4. 定义两个变量maxCount和maxChar,分别表示最大出现次数和对应的字母。初始值分别为0和’a’。

5. 使用for循环遍历count数组的每个元素:

   • 如果当前元素的值大于maxCount,则更新maxCount为当前元素的值,并将maxChar更新为对应的字母(即’a’ + 当前下标)。
   • 通过这个过程,我们找到了出现次数最多的字母,并在有多个字母出现次数相同时,选择ASCII码值最大的字母。

6. 将maxChar输出到标准输出,即为出现次数最多的小写字母。

7. 程序结束。

这个解决方案的时间复杂度为O(n),其中n为字符串的长度。我们只需要遍历字符串一次来统计每个字母的出现次数,然后再遍历一次count数组找到出现次数最多的字母。空间复杂度为O(1),因为我们使用了固定大小的数组来存储字母的出现次数。

1098. 判断是否构成回文

好的,让我们使用C++来解决这个问题。以下是完整的代码:

#include <iostream>
#include <string>
using namespace std;

bool isPalindrome(string str) {
    int left = 0;
    int right = str.length() - 1;

    while (left < right) {
        if (str[left] != str[right]) {
            return false;
        }
        left++;
        right--;
    }

    return true;
}

int main() {
    string str;
    getline(cin, str);

    // 去除字符串末尾的 '.'
    str = str.substr(0, str.length() - 1);

    if (isPalindrome(str)) {
        cout << "TRUE" << endl;
    } else {
        cout << "FALSE" << endl;
    }

    return 0;
}

代码解释:

1. 我们定义了一个名为isPalindrome的函数,用于判断给定的字符串是否为回文。

   • 函数接受一个字符串str作为参数,返回一个布尔值表示字符串是否为回文。
   • 函数使用两个指针left和right,分别指向字符串的左右两端。
   • 在一个while循环中,我们比较left和right指向的字符是否相等。如果不相等,说明字符串不是回文,返回false。
   • 如果left和right指向的字符相等,将left向右移动,right向左移动,继续比较下一对字符。
   • 当left大于等于right时,说明已经比较完所有字符,字符串是回文,返回true。

2. 在main函数中,我们首先使用getline函数从标准输入读取一行字符串str。

3. 由于输入的字符串以 ‘.’ 结尾,我们需要去除字符串末尾的 ‘.’。

   • 使用substr函数提取字符串的子串,从下标0开始,长度为字符串长度减1,即去除了最后一个字符 ‘.’。

4. 调用isPalindrome函数,将去除 ‘.’ 后的字符串传递给它,判断是否为回文。

5. 如果isPalindrome函数返回true,说明字符串是回文,输出 “TRUE”。

   • 否则,输出 “FALSE”。

6. 程序结束。

这个解决方案的时间复杂度为O(n),其中n为字符串的长度。我们只需要遍历字符串一次,比较左右两端的字符。空间复杂度为O(1),因为我们只使用了常数级别的额外空间。

希望这个解答对你有帮助!如果你还有任何问题,欢迎继续问我。

1102. 字符串中的空格移位

好的,让我们使用C++来解决这个问题。以下是完整的代码:

#include <iostream>
#include <string>
using namespace std;

string moveSpacesToFront(string str) {
    int spaceCount = 0;
    string result = "";

    // 统计字符串中空格的数量
    for (char c : str) {
        if (c == ' ') {
            spaceCount++;
        }
    }

    // 将空格添加到结果字符串的前面
    for (int i = 0; i < spaceCount; i++) {
        result += ' ';
    }

    // 将非空格字符添加到结果字符串的后面
    for (char c : str) {
        if (c != ' ') {
            result += c;
        }
    }

    return result;
}

int main() {
    string str;
    getline(cin, str);

    string result = moveSpacesToFront(str);
    cout << result << endl;

    return 0;
}

代码解释:

1. 我们定义了一个名为moveSpacesToFront的函数,用于将字符串中的所有空格移到最前面。

   • 函数接受一个字符串str作为参数,返回移动空格后的新字符串。
   • 函数首先定义一个变量spaceCount用于统计字符串中空格的数量,以及一个空字符串result用于存储结果。
   • 使用基于范围的for循环遍历字符串str中的每个字符c,如果c是空格,将spaceCount加1。
   • 接下来,使用一个for循环,将spaceCount个空格添加到result字符串的前面。
   • 最后,再次使用基于范围的for循环遍历字符串str中的每个字符c,如果c不是空格,将其添加到result字符串的后面。
   • 函数返回移动空格后的新字符串result。

2. 在main函数中,我们首先使用getline函数从标准输入读取一行字符串str。

3. 调用moveSpacesToFront函数,将读取的字符串str传递给它,获取移动空格后的新字符串result。

4. 将result输出到标准输出。

5. 程序结束。

这个解决方案的时间复杂度为O(n),其中n为字符串的长度。我们需要遍历字符串两次,一次统计空格数量,一次构建结果字符串。空间复杂度也为O(n),因为我们需要创建一个新的字符串来存储结果。

1125. 删除字符串中间的*

#include <iostream>
#include <string>
using namespace std;

string removeMiddleStars(string str) {
    int left = 0;
    int right = str.length() - 1;

    // 找到左边第一个非*字符的位置
    while (left < right && str[left] == '*') {
        left++;
    }

    // 找到右边最后一个非*字符的位置
    while (right > left && str[right] == '*') {
        right--;
    }

    string result = "";

    // 将左边的*添加到结果字符串
    for (int i = 0; i < left; i++) {
        result += '*';
    }

    // 将中间的非*字符添加到结果字符串
    for (int i = left; i <= right; i++) {
        if (str[i] != '*') {
            result += str[i];
        }
    }

    // 将右边的*添加到结果字符串
    for (int i = right + 1; i < str.length(); i++) {
        result += '*';
    }

    return result;
}

int main() {
    string str;
    cin >> str;

    string result = removeMiddleStars(str);
    cout << result << endl;

    return 0;
}

代码解释:

1. 我们定义了一个名为removeMiddleStars的函数,用于删除字符串中间的*。

   • 函数接受一个字符串str作为参数,返回删除中间*后的新字符串。
   • 函数首先定义两个指针left和right,分别指向字符串的左右两端。
   • 使用一个while循环,从左到右找到第一个非*字符的位置,更新left指针。
   • 使用另一个while循环,从右到左找到最后一个非*字符的位置,更新right指针。
   • 定义一个空字符串result用于存储结果。
   • 使用一个for循环,将左边的*添加到result字符串中,从下标0到left-1。
   • 使用另一个for循环,将中间的非*字符添加到result字符串中,从下标left到right。
   • 最后,使用一个for循环,将右边的*添加到result字符串中,从下标right+1到字符串末尾。
   • 函数返回删除中间*后的新字符串result。

2. 在main函数中,我们首先使用cin从标准输入读取一个字符串str。

3. 调用removeMiddleStars函数,将读取的字符串str传递给它,获取删除中间*后的新字符串result。

4. 将result输出到标准输出。

5. 程序结束。

这个解决方案的时间复杂度为O(n),其中n为字符串的长度。我们需要遍历字符串一次来找到左右两端的非*字符位置,然后再遍历一次构建结果字符串。空间复杂度也为O(n),因为我们需要创建一个新的字符串来存储结果。

1133. 字符串的反码

好的,让我们使用C++来解决这个问题。以下是完整的代码:

#include <iostream>
#include <string>
using namespace std;

char getInverseChar(char c) {
    if (c >= 'a' && c <= 'z') {
        return 'z' - (c - 'a');
    } else if (c >= 'A' && c <= 'Z') {
        return 'Z' - (c - 'A');
    } else {
        return c;
    }
}

string getInverseString(string str) {
    string result = "";

    for (char c : str) {
        result += getInverseChar(c);
    }

    return result;
}

int main() {
    string str;
    cin >> str;

    string inverseStr = getInverseString(str);
    cout << inverseStr << endl;

    return 0;
}

代码解释:

1. 我们首先定义了一个名为getInverseChar的函数,用于计算单个字符的反码。

   • 函数接受一个字符c作为参数,返回其反码字符。
   • 如果c是小写字母(即在’a’到’z’的范围内),则返回’z’ - (c - ‘a’),即与’z’的距离等于其与’a’的距离。
   • 如果c是大写字母(即在’A’到’Z’的范围内),则返回’Z’ - (c - ‘A’),即与’Z’的距离等于其与’A’的距离。
   • 如果c不是字母,则直接返回c本身。

2. 接下来,我们定义了一个名为getInverseString的函数,用于计算整个字符串的反码。

   • 函数接受一个字符串str作为参数,返回其反码字符串。
   • 定义一个空字符串result用于存储结果。
   • 使用基于范围的for循环遍历字符串str中的每个字符c。
   • 对于每个字符c,调用getInverseChar函数计算其反码字符,并将结果添加到result字符串中。
   • 函数返回反码字符串result。

3. 在main函数中,我们首先使用cin从标准输入读取一个字符串str。

4. 调用getInverseString函数,将读取的字符串str传递给它,获取其反码字符串inverseStr。

5. 将inverseStr输出到标准输出。

6. 程序结束。

这个解决方案的时间复杂度为O(n),其中n为字符串的长度。我们需要遍历字符串一次,对每个字符计算其反码。空间复杂度也为O(n),因为我们需要创建一个新的字符串来存储结果。

1312. 看完动漫要几天？

好的,让我们使用C++来解决这个问题。以下是完整的代码:

#include <iostream>
#include <string>
using namespace std;

int calculateDays(int totalMinutes, string startTime, string endTime) {
    int startHour = stoi(startTime.substr(0, 2));
    int startMinute = stoi(startTime.substr(3, 2));
    int endHour = stoi(endTime.substr(0, 2));
    int endMinute = stoi(endTime.substr(3, 2));

    int dailyMinutes = (endHour - startHour) * 60 + (endMinute - startMinute);
    int days = (totalMinutes + dailyMinutes - 1) / dailyMinutes;

    return days;
}

int main() {
    int totalMinutes;
    string startTime, endTime;

    cin >> totalMinutes;
    cin >> startTime;
    cin >> endTime;

    int days = calculateDays(totalMinutes, startTime, endTime);
    cout << days << endl;

    return 0;
}

代码解释:

1. 我们首先定义了一个名为calculateDays的函数,用于计算小明看完动漫需要的天数。

   • 函数接受三个参数:动漫的总分钟数totalMinutes,每天看动漫的开始时间startTime和结束时间endTime。
   • 使用stoi函数将开始时间和结束时间的小时和分钟部分转换为整数。
   • 计算每天可以看动漫的分钟数dailyMinutes,即结束时间减去开始时间的分钟数。
   • 计算需要的天数days,使用公式(totalMinutes + dailyMinutes - 1) / dailyMinutes。这里使用了向上取整的技巧,通过加上dailyMinutes - 1后再除以dailyMinutes,可以确保结果向上取整。
   • 函数返回计算得到的天数days。

2. 在main函数中,我们首先定义变量totalMinutes表示动漫的总分钟数,以及字符串startTime和endTime表示每天看动漫的开始时间和结束时间。

3. 使用cin从标准输入读取totalMinutes、startTime和endTime的值。

4. 调用calculateDays函数,将totalMinutes、startTime和endTime作为参数传递给它,计算需要的天数days。

5. 将计算得到的天数days输出到标准输出。

6. 程序结束。

这个解决方案的时间复杂度为O(1),因为我们只需要进行简单的算术运算和字符串操作,与输入的大小无关。空间复杂度也为O(1),因为我们只使用了常数个变量来存储结果。

1321. 时钟旋转（2）

好的,让我们使用C++来解决这个问题。以下是完整的代码:

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

double calculateAngle(string startTime, string endTime) {
    int startHour = stoi(startTime.substr(0, 2));
    int startMinute = stoi(startTime.substr(3, 2));
    int endHour = stoi(endTime.substr(0, 2));
    int endMinute = stoi(endTime.substr(3, 2));

    int totalMinutes = (endHour - startHour) * 60 + (endMinute - startMinute);
    double angle = totalMinutes * 0.5;

    return angle;
}

int main() {
    string startTime, endTime;

    cin >> startTime;
    cin >> endTime;

    double angle = calculateAngle(startTime, endTime);
    cout << fixed << setprecision(1) << angle << endl;

    return 0;
}

代码解释:

1. 我们首先定义了一个名为calculateAngle的函数,用于计算时针旋转的度数。

   • 函数接受两个参数:起始时间startTime和结束时间endTime。
   • 使用stoi函数将起始时间和结束时间的小时和分钟部分转换为整数。
   • 计算总的分钟数totalMinutes,即结束时间减去起始时间的分钟数。
   • 根据题目给出的公式,时针旋转的度数等于总分钟数乘以0.5。
   • 函数返回计算得到的旋转度数angle。

2. 在main函数中,我们首先定义字符串startTime和endTime表示起始时间和结束时间。

3. 使用cin从标准输入读取startTime和endTime的值。

4. 调用calculateAngle函数,将startTime和endTime作为参数传递给它,计算时针旋转的度数angle。

5. 使用cout将计算得到的旋转度数angle输出到标准输出。

   • 使用fixed和setprecision(1)控制输出格式,将结果保留1位小数。

6. 程序结束。

这个解决方案的时间复杂度为O(1),因为我们只需要进行简单的算术运算和字符串操作,与输入的大小无关。空间复杂度也为O(1),因为我们只使用了常数个变量来存储结果。

1402. 字符串加密？

#include <iostream>
#include <string>
using namespace std;

string encrypt(string str) {
    string result = "";

    for (char c : str) {
        if (c >= 'a' && c < 'z') {
            result += c + 1;
        } else if (c >= 'A' && c < 'Z') {
            result += c + 1;
        } else if (c == 'z') {
            result += 'a';
        } else if (c == 'Z') {
            result += 'A';
        } else {
            result += c;
        }
    }

    return result;
}

int main() {
    string str;
    getline(cin, str);

    string encryptedStr = encrypt(str);
    cout << encryptedStr << endl;

    return 0;
}

代码解释:

1. 我们首先定义了一个名为encrypt的函数,用于对给定的字符串进行加密。

   • 函数接受一个字符串str作为参数。
   • 定义一个空字符串result用于存储加密后的结果。
   • 使用基于范围的for循环遍历字符串str中的每个字符c。
   • 对于每个字符c,根据题目给出的加密规则进行处理:
     • 如果c在’a’到’y’的范围内,则将其后继字母添加到result中,即result += c + 1。
     • 如果c在’A’到’Y’的范围内,则将其后继字母添加到result中,即result += c + 1。
     • 如果c是’z’,则将’a’添加到result中。
     • 如果c是’Z’,则将’A’添加到result中。
     • 如果c是其他非字母字符,则直接将其添加到result中。
   • 函数返回加密后的字符串result。

2. 在main函数中,我们首先定义字符串str表示待加密的字符串。

3. 使用getline函数从标准输入读取整行字符串,并将其存储在str中。

4. 调用encrypt函数,将str作为参数传递给它,对字符串进行加密,得到加密后的字符串encryptedStr。

5. 将加密后的字符串encryptedStr输出到标准输出。

6. 程序结束。

这个解决方案的时间复杂度为O(n),其中n是字符串的长度,因为我们需要遍历字符串中的每个字符进行加密。空间复杂度也为O(n),因为我们需要创建一个新的字符串来存储加密后的结果。

3.字符串进阶

1012. 我是第几个单词

以下是使用C++解答该问题的代码，并附有注释和思路讲解：

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

int main() {
    string sentence;
    getline(cin, sentence, '.'); // 读取以'.'结尾的句子

    string word;
    cin >> word; // 读取要查找的单词

    stringstream ss(sentence);
    string currWord;
    int wordCount = 0;
    int totalCharCount = 0;

    while (ss >> currWord) {
        wordCount++; // 统计单词数量
        totalCharCount += currWord.length(); // 统计字符总数

        if (currWord == word) {
            cout << wordCount << endl; // 输出第一次出现的单词位置
            return 0;
        }
    }

    cout << totalCharCount << endl; // 输出字符总数
    return 0;
}

思路讲解：

1. 首先，使用 getline 函数读取以 ‘.’ 结尾的句子，并将其存储在字符串 sentence 中。
2. 然后，使用 cin 读取要查找的单词，并将其存储在字符串 word 中。
3. 创建一个 stringstream 对象 ss，并将 sentence 传递给它。这样可以方便地对句子进行单词的分割和处理。
4. 初始化变量 wordCount 和 totalCharCount，分别用于统计单词数量和字符总数。
5. 使用 while 循环遍历句子中的每个单词，通过 ss >> currWord 将当前单词读取到 currWord 中。
6. 在循环中，每读取一个单词，就将 wordCount 增加1，并将当前单词的长度加到 totalCharCount 上。
7. 判断当前单词 currWord 是否与要查找的单词 word 相同，如果相同，则输出 wordCount，表示找到了第一次出现的单词位置，然后直接返回结束程序。
8. 如果遍历完整个句子都没有找到与 word 相同的单词，则输出 totalCharCount，表示字符总数。

这个解决方案的时间复杂度为 O(n)，其中 n 是句子的长度。我们只需要遍历一次句子中的每个单词，对每个单词进行常数时间的操作，因此时间复杂度是线性的。

空间复杂度为 O(n)，其中 n 是句子的长度。我们使用了一个字符串 sentence 来存储整个句子，因此空间复杂度也是线性的。

总的来说，这个解决方案是比较高效和直观的，通过使用 stringstream 对句子进行分割和处理，可以方便地统计单词数量和字符总数，并在遍历过程中判断是否找到了目标单词。

1116. 调换位置

好的,我来为你提供代码的注释解析和整体题目思路说明。

题目思路:
这个题目要求我们将用逗号隔开的两个英语单词交换位置并输出。我们可以按照以下步骤来解决这个问题:

1. 读取输入的字符串,其中包含两个以逗号隔开的英语单词。
2. 找到逗号的位置,将字符串分割成两个子字符串,分别表示第一个单词和第二个单词。
3. 将第二个单词放在前面,第一个单词放在后面,并在它们之间加上逗号。
4. 输出交换后的结果字符串。

下面是带有注释的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    string input;
    getline(cin, input);  // 读取输入的字符串

    size_t pos = input.find(',');  // 找到逗号的位置

    if (pos != string::npos) {  // 如果找到了逗号
        string word1 = input.substr(0, pos);  // 提取第一个单词
        string word2 = input.substr(pos + 1);  // 提取第二个单词

        string result = word2 + "," + word1;  // 将第二个单词放在前面,第一个单词放在后面,并加上逗号

        cout << result << endl;  // 输出交换后的结果
    } else {
        cout << "Invalid input format." << endl;  // 如果输入格式不正确,输出错误消息
    }

    return 0;
}

代码解析:

1. 我们首先使用getline(cin, input)读取输入的字符串,其中可能包含两个以逗号隔开的英语单词。

2. 然后,我们使用input.find(',')函数找到逗号的位置。如果找到了逗号,pos将保存逗号的下标;如果没有找到逗号,pos将等于string::npos。

3. 接下来,我们使用if语句检查是否找到了逗号。如果找到了逗号,我们执行以下操作:

   • 使用input.substr(0, pos)提取第一个单词,即从下标0开始,长度为pos的子字符串。
   • 使用input.substr(pos + 1)提取第二个单词,即从下标pos + 1开始,直到字符串末尾的子字符串。
   • 将第二个单词放在前面,第一个单词放在后面,并在它们之间加上逗号,形成交换后的结果字符串result。
   • 输出交换后的结果字符串result。

4. 如果没有找到逗号,说明输入的格式不正确,我们输出错误消息"Invalid input format."。

5. 最后,程序返回0,表示执行完毕。

这个代码通过找到逗号的位置,将输入的字符串分割成两个单词,然后交换它们的位置并输出结果。它可以正确处理题目要求的输入格式,并给出相应的输出。

`size_t` 是一个无符号整数类型,通常用于表示对象的大小或者数组的索引。它是在 `<cstddef>` 头文件中定义的。

以下是关于 `size_t` 的一些重要特点:

1. `size_t` 是一个与平台相关的类型,其大小根据所运行的平台而有所不同。在大多数 64 位系统上,`size_t` 是 64 位无符号整数类型,而在 32 位系统上,它通常是 32 位无符号整数类型。

2. `size_t` 用于表示非负整数值,特别适合表示对象的大小、数组的索引以及指针算术运算的结果。

3. 在 C++ 标准库中,许多函数和容器使用 `size_t` 作为参数类型或返回类型,以表示大小或索引。例如,`std::string` 的 `size()` 函数返回 `size_t` 类型的字符串长度。

4. 由于 `size_t` 是无符号类型,因此它不能表示负值。当执行涉及 `size_t` 的算术运算时,需要注意避免下溢(underflow)的情况。

5. 在不同的系统上,`size_t` 的实际类型可能有所不同。例如,在某些系统上,它可能是 `unsigned int`,而在其他系统上,它可能是 `unsigned long` 或 `unsigned long long`。

使用 `size_t` 的一个好处是提高了代码的可移植性。通过使用 `size_t`,你可以确保代码在不同的平台上正确地处理对象大小和索引,而不必担心底层的整数类型。

在上面的代码中,我们使用 `size_t` 作为 `pos` 变量的类型,以存储逗号的位置。这是因为 `std::string` 的 `find()` 函数返回的是 `size_t` 类型的值,表示找到的字符或子字符串的位置。

总之,`size_t` 是一个用于表示大小和索引的无符号整数类型,在 C++ 中广泛用于与对象大小和数组索引相关的场景。

1129. 简单a*b

好的,让我们来解决这个问题。我们可以按照以下步骤来实现:

1. 读取输入的字符串,其中包含一个乘法算式。
2. 从字符串中提取两个整数 a 和 b。
3. 计算 a*b 的结果。
4. 输出计算结果。

下面是使用 C++ 实现的代码:

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

int main() {
    string input;
    getline(cin, input);  // 读取输入的字符串

    stringstream ss(input);  // 创建一个字符串流对象,用于从字符串中提取整数
    long long a, b;
    char mul, eq;

    ss >> a >> mul >> b >> eq;  // 从字符串流中提取两个整数 a 和 b,以及乘号和等号

    long long result = a * b;  // 计算 a*b 的结果

    cout << result << endl;  // 输出计算结果

    return 0;
}

代码解析:

1. 我们首先使用 getline(cin, input) 读取输入的字符串,其中包含一个乘法算式。

2. 然后,我们创建一个 stringstream 对象 ss,并将输入的字符串传递给它。这样,我们就可以方便地从字符串中提取整数和字符。

3. 接下来,我们使用 ss >> a >> mul >> b >> eq 从字符串流中提取两个整数 a 和 b,以及乘号 * 和等号 =。这里假设输入的格式为 a*b=,其中 a 和 b 都是整数。

4. 然后,我们计算 a*b 的结果,并将结果存储在 result 变量中。由于结果可能超出 int 的范围,因此我们将 a、b 和 result 的类型定义为 long long。

5. 最后,我们使用 cout << result << endl 输出计算结果。

这个代码可以正确地处理题目要求的输入格式,并计算出 a*b 的结果。它使用了 stringstream 来方便地从字符串中提取整数和字符,避免了手动解析字符串的麻烦。

需要注意的是,这个代码假设输入的格式正确,即 a*b= 的形式,其中 a 和 b 都是整数。如果输入的格式不正确,代码可能会产生意外的行为。

1130. 简单a+b

好的,让我们来解决这个问题。我们可以按照以下步骤来实现:

1. 读取输入的字符串,其中包含一个加法表达式。
2. 从字符串中提取两个整数 a 和 b。
3. 计算 a+b 的结果。
4. 输出计算结果。

下面是使用 C++ 实现的代码:

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

int main() {
    string input;
    getline(cin, input);  // 读取输入的字符串

    stringstream ss(input);  // 创建一个字符串流对象,用于从字符串中提取整数
    int a, b;
    char plus, eq;

    ss >> a >> plus >> b >> eq;  // 从字符串流中提取两个整数 a 和 b,以及加号和等号

    int result = a + b;  // 计算 a+b 的结果

    cout << result << endl;  // 输出计算结果

    return 0;
}

代码解析:

1. 我们首先使用 getline(cin, input) 读取输入的字符串,其中包含一个加法表达式。

2. 然后,我们创建一个 stringstream 对象 ss,并将输入的字符串传递给它。这样,我们就可以方便地从字符串中提取整数和字符。

3. 接下来,我们使用 ss >> a >> plus >> b >> eq 从字符串流中提取两个整数 a 和 b,以及加号 + 和等号 =。这里假设输入的格式为 a+b=,其中 a 和 b 都是整数。

4. 然后,我们计算 a+b 的结果,并将结果存储在 result 变量中。

5. 最后,我们使用 cout << result << endl 输出计算结果。

这个代码可以正确地处理题目要求的输入格式,并计算出加法表达式的结果。它使用了 stringstream 来方便地从字符串中提取整数和字符,避免了手动解析字符串的麻烦。

需要注意的是,这个代码假设输入的格式正确,即 a+b= 的形式,其中 a 和 b 都是整数。如果输入的格式不正确,代码可能会产生意外的行为。

此外,题目中提到做加法的两个整数都在 0∼109 的范围内,因此使用 int 类型来存储整数和计算结果是足够的。

1100. 词组缩写

你提出了一个很好的问题。确实,我们可以直接使用while (cin >> word)来逐个读取单词,而不需要使用stringstream。使用cin可以简化代码,使其更加简洁明了。

下面是使用cin修改后的代码:

#include <iostream>
#include <string>
#include <cctype>

using namespace std;

int main() {
    string word;
    string abbreviation = "";  // 存储缩写

    while (cin >> word) {  // 使用cin逐个读取单词
        char firstLetter = word[0];  // 获取单词的首字母
        if (islower(firstLetter)) {  // 如果首字母是小写,将其转换为大写
            firstLetter = toupper(firstLetter);
        }
        abbreviation += firstLetter;  // 将大写首字母添加到缩写中
    }

    cout << abbreviation << endl;  // 输出缩写

    return 0;
}

代码解析:

1. 定义一个空字符串abbreviation用于存储缩写。

2. 使用while (cin >> word)循环直接从标准输入中逐个读取单词,每次循环都会读取下一个单词,并将其存储在word变量中。

3. 对于每个单词,我们使用word[0]获取其首字母,并将其存储在firstLetter变量中。

4. 使用islower()函数检查首字母是否为小写字母。如果是,则使用toupper()函数将其转换为大写字母。

5. 将大写首字母添加到abbreviation字符串中,以构建缩写。

6. 重复步骤3-5,直到读取完所有单词。

7. 最后,使用cout << abbreviation << endl输出缩写。

使用cin可以直接从标准输入中读取单词,而不需要先将整个词组读入字符串再进行分割。这样可以简化代码,使其更加简洁易懂。

感谢你的提问,这提醒我们在解决问题时要考虑多种可能的方法,并选择最简洁有效的解决方案。

1103. 字符串压缩

好的,让我们来解决这个问题。我们可以使用一个简单的算法来压缩字符串:遍历字符串,统计连续相同字母的个数,然后根据个数和字母生成压缩后的字符串。

下面是使用C++实现的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    string input;
    cin >> input;  // 读取输入的字符串

    string compressed = "";  // 存储压缩后的字符串
    char currentChar = input[0];  // 当前字符
    int count = 1;  // 当前字符的连续个数

    for (int i = 1; i <= input.length(); i++) {
        if (i < input.length() && input[i] == currentChar) {
            // 如果当前字符与前一个字符相同,连续个数加1
            count++;
        } else {
            // 如果当前字符与前一个字符不同,或者已经到达字符串末尾
            if (count > 1) {
                // 如果连续个数大于1,将个数和字符添加到压缩后的字符串中
                compressed += to_string(count) + currentChar;
            } else {
                // 如果连续个数为1,只添加字符到压缩后的字符串中
                compressed += currentChar;
            }
            
            // 更新当前字符和连续个数
            currentChar = input[i];
            count = 1;
        }
    }

    cout << compressed << endl;  // 输出压缩后的字符串

    return 0;
}

代码解析:

1. 我们使用cin >> input读取输入的字符串,将其存储在input变量中。

2. 定义一个空字符串compressed用于存储压缩后的字符串。

3. 定义变量currentChar表示当前字符,初始化为字符串的第一个字符。

4. 定义变量count表示当前字符的连续个数,初始化为1。

5. 使用for循环遍历字符串,从第二个字符开始。

6. 在循环中,如果当前字符与前一个字符相同,则将count加1。

7. 如果当前字符与前一个字符不同,或者已经到达字符串末尾,则:

   • 如果count大于1,将count转换为字符串,并与currentChar连接起来,添加到compressed中。
   • 如果count等于1,只将currentChar添加到compressed中。

8. 更新currentChar为当前字符,并将count重置为1。

9. 重复步骤6-8,直到遍历完整个字符串。

10. 最后,使用cout << compressed << endl输出压缩后的字符串。

这个算法通过遍历字符串,统计连续相同字符的个数,并根据个数生成压缩后的字符串。如果连续个数大于1,则将个数和字符一起添加到压缩后的字符串中;如果连续个数为1,则只添加字符。

1104. 字符串解压

要解决这个问题,我们需要遍历压缩后的字符串,识别数字和字母,并根据数字重复相应的字母。

下面是使用C++实现的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    string compressed;
    cin >> compressed;  // 读取压缩后的字符串

    string decompressed = "";  // 存储解压后的字符串
    int count = 0;  // 当前字母的重复次数

    for (char ch : compressed) {
        if (isdigit(ch)) {
            // 如果当前字符是数字,将其转换为整数并累加到count中
            count = count * 10 + (ch - '0');
        } else {
            // 如果当前字符是字母
            if (count > 0) {
                // 如果count大于0,将当前字母重复count次并添加到解压后的字符串中
                decompressed += string(count, ch);
                count = 0;  // 重置count为0
            } else {
                // 如果count为0,表示当前字母是单个字母,直接添加到解压后的字符串中
                decompressed += ch;
            }
        }
    }

    cout << decompressed << endl;  // 输出解压后的字符串

    return 0;
}

代码解析:

1. 我们使用cin >> compressed读取压缩后的字符串,将其存储在compressed变量中。

2. 定义一个空字符串decompressed用于存储解压后的字符串。

3. 定义一个整数变量count用于存储当前字母的重复次数,初始化为0。

4. 使用基于范围的for循环遍历compressed字符串中的每个字符。

5. 在循环中,如果当前字符是数字(使用isdigit()函数判断),则将其转换为整数(通过减去字符'0'的ASCII值)并累加到count中。这样可以处理多位数的情况。

6. 如果当前字符是字母,则:

   • 如果count大于0,表示需要重复当前字母。使用string(count, ch)创建一个包含count个ch字符的字符串,并将其添加到decompressed中。然后将count重置为0。
   • 如果count为0,表示当前字母是单个字母,直接将其添加到decompressed中。

7. 重复步骤5-6,直到遍历完整个compressed字符串。

8. 最后,使用cout << decompressed << endl输出解压后的字符串。

这个算法通过遍历压缩后的字符串,识别数字和字母,并根据数字重复相应的字母。对于多位数的情况,通过累加数字字符的值来计算重复次数。如果遇到单个字母,直接将其添加到解压后的字符串中。

1105. 字符串连接

为了解决这个问题,我们可以使用一个辅助数组来记录每个字符是否已经出现过。然后遍历两个字符串,对于每个字符,如果它之前没有出现过,就将其添加到结果字符串中。

下面是使用C++实现的代码:

#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main() {
    string s1, s2;
    cin >> s1 >> s2;  // 读取两个字符串

    vector<bool> appeared(26, false);  // 记录每个字符是否已经出现过
    string result = "";  // 存储连接后的字符串

    // 遍历第一个字符串
    for (char ch : s1) {
        if (!appeared[ch - 'a']) {
            // 如果当前字符之前没有出现过,将其添加到结果字符串中
            result += ch;
            appeared[ch - 'a'] = true;  // 标记该字符已经出现过
        }
    }

    // 遍历第二个字符串
    for (char ch : s2) {
        if (!appeared[ch - 'a']) {
            // 如果当前字符之前没有出现过,将其添加到结果字符串中
            result += ch;
            appeared[ch - 'a'] = true;  // 标记该字符已经出现过
        }
    }

    cout << result << endl;  // 输出连接后的字符串

    return 0;
}

代码解析:

1. 我们使用cin >> s1 >> s2读取两个字符串,分别存储在s1和s2变量中。

2. 定义一个布尔类型的数组appeared,大小为26(对应26个小写字母),初始化为false。这个数组用于记录每个字符是否已经出现过。

3. 定义一个空字符串result用于存储连接后的字符串。

4. 使用基于范围的for循环遍历s1字符串中的每个字符。

5. 在循环中,如果当前字符之前没有出现过(即appeared[ch - 'a']为false),则将其添加到result字符串中,并将appeared[ch - 'a']标记为true,表示该字符已经出现过。

6. 重复步骤4-5,直到遍历完整个s1字符串。

7. 使用基于范围的for循环遍历s2字符串中的每个字符。

8. 在循环中,如果当前字符之前没有出现过(即appeared[ch - 'a']为false),则将其添加到result字符串中,并将appeared[ch - 'a']标记为true,表示该字符已经出现过。

9. 重复步骤7-8,直到遍历完整个s2字符串。

10. 最后,使用cout << result << endl输出连接后的字符串。

这个算法使用一个布尔数组appeared来记录每个字符是否已经出现过。通过遍历两个字符串,对于每个字符,如果它之前没有出现过,就将其添加到结果字符串中。这样可以确保在连接过程中每个字符只出现一次,并保持原有的顺序。

1106. 统计单词个数

当然,我们也可以直接使用while (cin >> word)来逐个读取单词并统计个数,而无需使用字符串流。这种方法更加简洁明了。

下面是使用while (cin >> word)的修改后的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    string word;
    int count = 0;  // 单词计数器

    while (cin >> word) {
        // 使用cin和流运算符(>>)逐个读取单词
        count++;
    }

    cout << count << endl;  // 输出单词个数

    return 0;
}

代码解析:

1. 定义一个字符串变量word用于存储每个读取到的单词。

2. 定义一个整型变量count用于统计单词的个数,初始化为0。

3. 使用while (cin >> word)循环直接从标准输入流cin中逐个读取单词。每次循环读取一个单词,直到达到输入的末尾。

4. 在循环内部,每读取到一个单词,将count增加1。

5. 循环结束后,count的值就是输入中的单词个数。

6. 最后,使用cout << count << endl输出单词个数。

这个修改后的算法直接使用cin和流运算符(>>)来逐个读取单词,而不需要使用字符串流。cin会自动跳过空格,因此无需手动处理多个空格的情况。每读取到一个单词,计数器就增加1,最终得到单词的总个数。

1107. 求英文句子中的最长单词

为了找到句子中最长的单词,我们可以使用字符串流(stringstream)来逐个读取单词,并记录最长单词的长度和内容。

下面是使用C++实现的代码:

#include <iostream>
#include <sstream>
#include <string>

using namespace std;

int main() {
    string sentence;
    getline(cin, sentence);  // 读取一行输入,包括空格

    stringstream ss(sentence);  // 将输入字符串放入字符串流中
    string word;
    string longestWord = "";  // 存储最长的单词

    while (ss >> word) {
        // 使用流运算符(>>)逐个读取单词
        if (word.length() > longestWord.length()) {
            // 如果当前单词比之前的最长单词长,更新最长单词
            longestWord = word;
        }
    }

    cout << longestWord << endl;  // 输出最长的单词

    return 0;
}

代码解析:

1. 我们使用getline(cin, sentence)读取一行输入,包括其中的空格,并将其存储在sentence变量中。

2. 创建一个字符串流对象ss,并将输入字符串sentence传递给它。这样,我们就可以使用字符串流来解析输入字符串。

3. 定义一个字符串变量word用于存储每个读取到的单词。

4. 定义一个字符串变量longestWord用于存储最长的单词,初始化为空字符串。

5. 使用while循环和流运算符(>>)从字符串流ss中逐个读取单词。每次循环读取一个单词,直到达到字符串的末尾。

6. 在循环内部,比较当前单词的长度和之前最长单词的长度:

   • 如果当前单词的长度大于之前最长单词的长度,则更新longestWord为当前单词。

7. 循环结束后,longestWord存储的就是句子中最长的单词。

8. 最后,使用cout << longestWord << endl输出最长的单词。

这个算法利用字符串流(stringstream)逐个读取单词,并在读取过程中记录最长单词的长度和内容。通过比较每个单词的长度,我们可以找到句子中最长的单词。如果有多个长度相同的单词,由于我们是逐个读取单词,因此最终得到的是最前面的那个最长单词。

1108. 正整数N转换成一个二进制数

为了将一个整数转换为二进制表示,我们可以使用位运算和移位操作。具体来说,我们可以通过将整数不断地右移并检查最低位的值来构建二进制字符串。

下面是使用C++实现的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    int n;
    cin >> n;  // 读取整数n

    if (n == 0) {
        cout << "0" << endl;  // 特殊情况:如果n为0,直接输出0
    } else {
        string binary = "";  // 存储二进制表示的字符串

        while (n > 0) {
            int bit = n & 1;  // 获取n的最低位
            binary = to_string(bit) + binary;  // 将最低位添加到二进制字符串的开头
            n >>= 1;  // 将n右移一位
        }

        cout << binary << endl;  // 输出二进制字符串
    }

    return 0;
}

代码解析:

1. 我们使用cin >> n读取整数n。

2. 首先,我们处理特殊情况:如果n为0,直接输出"0"。

3. 对于非零的n,我们定义一个空字符串binary用于存储二进制表示。

4. 使用while循环,当n大于0时重复以下步骤:

   • 使用位运算n & 1获取n的最低位。这个操作会返回最低位的值,要么是0,要么是1。
   • 将最低位转换为字符串,并将其添加到binary字符串的开头。这样可以确保二进制表示的顺序正确。
   • 使用右移运算符>>=将n右移一位。这相当于将n除以2,并丢弃最低位。

5. 循环结束后,binary字符串包含了整数n的二进制表示。

6. 最后,使用cout << binary << endl输出二进制字符串。

这个算法利用位运算和移位操作来逐位构建整数的二进制表示。通过不断右移整数并检查最低位的值,我们可以从低位到高位依次获取二进制位,并将其添加到二进制字符串的开头。最终得到的字符串就是整数的二进制表示。

需要注意的是,这个算法假设整数是非负数。如果需要处理负数,可以先将其转换为相应的正数,然后再进行二进制转换。

1112. 查找子串并替换

为了实现查找和替换功能,我们可以使用字符串的find()和replace()函数。具体来说,我们可以反复查找目标子串,并将其替换为新的子串,直到找不到更多匹配为止。

下面是使用C++实现的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    string str, oldSubstr, newSubstr;
    getline(cin, str);  // 读取原始字符串
    getline(cin, oldSubstr);  // 读取要查找的子串
    getline(cin, newSubstr);  // 读取要替换成的子串

    size_t pos = 0;
    while ((pos = str.find(oldSubstr, pos)) != string::npos) {
        // 查找目标子串的位置
        str.replace(pos, oldSubstr.length(), newSubstr);  // 替换子串
        pos += newSubstr.length();  // 更新下一次查找的起始位置
    }

    cout << str << endl;  // 输出替换后的字符串

    return 0;
}

代码解析:

1. 我们使用getline()函数分别读取原始字符串、要查找的子串和要替换成的子串,并将它们存储在str、oldSubstr和newSubstr变量中。

2. 定义一个变量pos表示当前查找的起始位置,初始值为0。

3. 使用while循环反复查找目标子串:

   • 使用str.find(oldSubstr, pos)查找从位置pos开始的目标子串oldSubstr在str中的位置。
   • 如果找到了目标子串,find()函数会返回子串的起始位置;如果没有找到,则返回string::npos。

4. 如果找到了目标子串:

   • 使用str.replace(pos, oldSubstr.length(), newSubstr)将从位置pos开始的长度为oldSubstr.length()的子串替换为newSubstr。
   • 更新pos的值为替换后的下一个位置,即pos += newSubstr.length()。这样可以确保下一次查找从替换后的子串的末尾开始。

5. 如果没有找到目标子串,while循环将终止。

6. 最后,使用cout << str << endl输出替换后的字符串。

这个算法利用了字符串的find()函数来查找目标子串,并使用replace()函数将其替换为新的子串。通过反复查找和替换,直到找不到更多匹配为止,我们可以实现对整个字符串的查找和替换功能。

需要注意的是,这个算法区分大小写,只有大小写完全一致的子串才会被视为匹配项。如果需要忽略大小写进行匹配,可以先将整个字符串和目标子串转换为统一的大小写再进行查找和替换。

1111. 找最长单词

为了找到最长的含有字母’a’的单词,我们可以使用字符串流(stringstream)来逐个读取单词,并记录最长的含有字母’a’的单词。

下面是使用C++实现的代码:

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

int main() {
    string sentence;
    getline(cin, sentence, '.');  // 读取一行输入,以'.'结尾

    string longestWord = "";  // 存储最长的含有字母'a'的单词

    stringstream ss(sentence);  // 将输入字符串放入字符串流中
    string word;
    while (ss >> word) {
        // 使用流运算符(>>)逐个读取单词
        if (word.find('a') != string::npos && word.length() > longestWord.length()) {
            // 如果当前单词包含字母'a'且比之前的最长单词长,更新最长单词
            longestWord = word;
        }
    }

    if (longestWord.empty()) {
        cout << "NO" << endl;  // 如果没有找到含有字母'a'的单词,输出"NO"
    } else {
        cout << longestWord << endl;  // 输出最长的含有字母'a'的单词
    }

    return 0;
}

代码解析:

1. 我们使用getline(cin, sentence, '.')读取一行输入,以句点’.'作为结束符,并将其存储在sentence变量中。

2. 定义一个字符串变量longestWord用于存储最长的含有字母’a’的单词,初始化为空字符串。

3. 创建一个字符串流对象ss,并将输入字符串sentence传递给它。这样,我们就可以使用字符串流来解析输入字符串。

4. 使用while循环和流运算符(>>)从字符串流ss中逐个读取单词。每次循环读取一个单词,直到达到字符串的末尾。

5. 在循环内部,对于每个读取到的单词,检查它是否包含字母’a’且长度是否大于当前最长单词的长度:

   • 使用word.find('a') != string::npos检查单词是否包含字母’a’。如果找到字母’a’,find()函数会返回字母’a’的位置;如果没有找到,则返回string::npos。
   • 如果当前单词包含字母’a’且长度大于当前最长单词的长度,则更新longestWord为当前单词。

6. 循环结束后,如果longestWord为空,说明没有找到含有字母’a’的单词,输出"NO"。

7. 如果longestWord不为空,则输出最长的含有字母’a’的单词。

这个算法利用字符串流(stringstream)逐个读取单词,并在读取过程中记录最长的含有字母’a’的单词。通过比较每个单词的长度和是否包含字母’a’,我们可以找到最长的满足条件的单词。如果有多个长度相同的单词,由于我们是逐个读取单词,因此最终得到的是最前面的那个单词。

1113. 隐藏的最大整数

为了找到字符串中最大的整数小伙伴,我们可以遍历整个字符串,记录当前遇到的数字字符,并在遇到非数字字符时将数字字符组成的整数与当前最大整数进行比较,如果更大则更新最大整数和其起始位置。

下面是使用 C++ 实现的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    string str;
    cin >> str;  // 读取输入的字符串

    string maxNum = "";  // 存储最大的整数
    int maxPos = -1;  // 存储最大整数的起始位置
    string currentNum = "";  // 存储当前遇到的整数

    for (int i = 0; i < str.length(); i++) {
        if (isdigit(str[i])) {
            // 如果当前字符是数字,将其添加到当前整数中
            currentNum += str[i];
        } else {
            // 如果当前字符不是数字,说明当前整数结束
            if (!currentNum.empty()) {
                // 如果当前整数不为空,与最大整数进行比较
                if (currentNum.length() > maxNum.length() ||
                    (currentNum.length() == maxNum.length() && currentNum > maxNum)) {
                    // 如果当前整数更大,更新最大整数和其起始位置
                    maxNum = currentNum;
                    maxPos = i - currentNum.length();
                }
                currentNum = "";  // 重置当前整数为空
            }
        }
    }

    // 处理字符串末尾的整数
    if (!currentNum.empty()) {
        if (currentNum.length() > maxNum.length() ||
            (currentNum.length() == maxNum.length() && currentNum > maxNum)) {
            maxNum = currentNum;
            maxPos = str.length() - currentNum.length();
        }
    }

    cout << maxPos + 1 << endl;  // 输出最大整数的起始位置(从1开始计数)

    return 0;
}

代码解析:

1. 我们使用 cin >> str 读取输入的字符串,并将其存储在 str 变量中。

2. 定义变量 maxNum 用于存储最大的整数,初始化为空字符串。

3. 定义变量 maxPos 用于存储最大整数的起始位置,初始化为 -1。

4. 定义变量 currentNum 用于存储当前遇到的整数,初始化为空字符串。

5. 使用 for 循环遍历字符串的每个字符:

   • 如果当前字符是数字(使用 isdigit() 函数判断),将其添加到 currentNum 字符串的末尾。
   • 如果当前字符不是数字,说明当前整数结束:
     • 如果 currentNum 不为空,说明遇到了一个完整的整数。
     • 将 currentNum 与 maxNum 进行比较:
       • 如果 currentNum 的长度大于 maxNum 的长度,或者长度相等但 currentNum 字典序更大,则更新 maxNum 为 currentNum,并更新 maxPos 为当前整数的起始位置(即 i - currentNum.length())。
     • 将 currentNum 重置为空字符串,准备记录下一个整数。

6. 循环结束后,处理字符串末尾的整数:

   • 如果 currentNum 不为空,说明字符串以整数结尾。
   • 将 currentNum 与 maxNum 进行比较,如果更大则更新 maxNum 和 maxPos。

7. 最后,输出 maxPos + 1,即最大整数的起始位置(从1开始计数)。

这个算法通过遍历字符串的每个字符,记录当前遇到的数字字符,并在遇到非数字字符时将数字字符组成的整数与当前最大整数进行比较,如果更大则更新最大整数和其起始位置。最终得到的是字符串中最大的整数及其起始位置。

需要注意的是,由于测试数据中包含的整数可能超过20位,因此我们使用字符串来存储和比较整数,而不是使用整型变量。

1114. 趣味填空

这是一个有趣的问题,我们需要在左边的整数中找到一个合适的位置插入加号,使得等式成立。我们可以通过遍历左边整数的每个位置,尝试插入加号,并将左右两边的整数进行比较来解决这个问题。

下面是使用C++实现的代码:

#include <iostream>
#include <string>

using namespace std;

int main() {
    string equation;
    cin >> equation;  // 读取输入的等式

    int equalPos = equation.find('=');  // 查找等号的位置
    string leftNum = equation.substr(0, equalPos);  // 获取等号左边的整数
    string rightNum = equation.substr(equalPos + 1);  // 获取等号右边的整数

    bool found = false;  // 标记是否找到解决方案

    for (int i = 1; i < leftNum.length(); i++) {
        string leftPart = leftNum.substr(0, i);  // 获取加号左边的部分
        string rightPart = leftNum.substr(i);  // 获取加号右边的部分

        if (leftPart[0] != '0' && rightPart[0] != '0') {
            // 如果加号左右两部分都不以0开头
            string newEquation = leftPart + "+" + rightPart + "=" + rightNum;
            if (stoll(leftPart) + stoll(rightPart) == stoll(rightNum)) {
                // 如果等式成立
                cout << newEquation << endl;
                found = true;
                break;
            }
        }
    }

    if (!found) {
        cout << "Impossible!" << endl;  // 如果没有找到解决方案
    }

    return 0;
}

代码解析:

1. 我们使用cin >> equation读取输入的等式字符串。

2. 使用equation.find('=')查找等号的位置,将等式分为左右两部分:

   • 使用equation.substr(0, equalPos)获取等号左边的整数字符串,存储在leftNum中。
   • 使用equation.substr(equalPos + 1)获取等号右边的整数字符串,存储在rightNum中。

3. 定义一个布尔变量found用于标记是否找到解决方案,初始化为false。

4. 使用for循环遍历leftNum的每个位置(从1开始,到leftNum.length() - 1结束):

   • 使用leftNum.substr(0, i)获取加号左边的部分,存储在leftPart中。
   • 使用leftNum.substr(i)获取加号右边的部分,存储在rightPart中。

5. 检查leftPart和rightPart是否都不以0开头(排除类似"0123+4=127"的情况):

   • 如果条件满足,则构建一个新的等式字符串newEquation,格式为"leftPart+rightPart=rightNum"。
   • 使用stoll()函数将leftPart、rightPart和rightNum转换为长整型,并判断leftPart和rightPart的和是否等于rightNum。
   • 如果等式成立,输出newEquation,将found标记为true,并使用break语句跳出循环。

6. 如果循环结束后found仍为false,说明没有找到解决方案,输出"Impossible!"。

这个算法通过遍历左边整数的每个位置,尝试插入加号,并将左右两边的整数进行比较来判断等式是否成立。如果找到解决方案,就输出正确的等式;如果没有找到解决方案,就输出"Impossible!"。

需要注意的是,我们使用stoll()函数将字符串转换为长整型进行比较,以支持较大的整数。同时,我们还需要排除加号左右两边以0开头的情况,以避免出现无效的整数表示。

1132. 保留整数

为了解决这个问题，我们可以遍历输入字符串str1，根据字符是否为数字来进行相应的处理。具体步骤如下：

1. 初始化状态：设置一个标志位isNonDigit来表示当前是否处于非数字字符序列中。
2. 遍历字符串：逐个字符检查输入字符串。
   • 如果当前字符是数字，直接将其添加到输出字符串str2中，并设置isNonDigit = false。
   • 如果当前字符不是数字，并且isNonDigit为false，则添加一个'*'到str2中，并设置isNonDigit = true。
3. 输出结果：遍历完成后，输出字符串str2即为所需结果。

C++代码实现

#include <iostream>
#include <cctype> // 包含isdigit函数的头文件
using namespace std;

int main() {
    string str1;
    getline(cin, str1); // 读取一行输入，允许空格存在

    string str2; // 存储输出字符串
    bool isNonDigit = false; // 标记是否处于非数字字符序列中

    for (char ch : str1) { // 遍历输入字符串的每个字符
        if (isdigit(ch)) { // 如果当前字符是数字
            str2 += ch; // 直接添加到str2中
            isNonDigit = false; // 更新状态为不在非数字字符序列中
        } else if (!isNonDigit) { // 如果当前字符不是数字，并且之前不是非数字序列
            str2 += '*'; // 添加一个'*'到str2
            isNonDigit = true; // 更新状态为在非数字字符序列中
        }
        // 如果当前字符不是数字，但已经处于非数字序列中，则不做操作
    }

    cout << str2 << endl; // 输出处理好的字符串

    return 0;
}

代码注释

• getline(cin, str1);：读取包含可能的空格的一行输入到字符串str1。
• for (char ch : str1)：C++范围基于的for循环，用于遍历字符串str1中的每个字符。
• isdigit(ch)：检查当前字符ch是否为数字。
• str2 += ch;：如果ch是数字，将其追加到字符串str2。
• str2 += '*';：如果遇到非数字字符，并且此前的字符序列不是非数字，向str2添加一个'*'。

这段代码利用C++标准库中的isdigit函数来判断字符是否为数字，并根据题目要求进行相应的处理，最终生成并输出符合条件的字符串str2。