C语言 给定一个字符串，在字符串的每个字符之间都加一个空格

在C语言中，如果你想要给一个字符串添加空格，可以在遍历字符串的同时，在每个字符后面插入一个空格。这里是一个简单的示例，假设`str`是你要操作的字符串：

#include <stdio.h>
#include <string.h>

void insert_spaces(char *str) {
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        // 将当前字符复制到目标位置
        str[i] = str[i];
        // 在当前字符后面插入空格
        if (i != len - 1) {
            str[i + 1] = ' ';
        }
    }
    // 结束位置不需要添加空格，所以最后一个字符不变
}

int main() {
    char input[] = "HelloWorld";
    printf("Original string: %s\n", input);
    insert_spaces(input);
    printf("String with spaces added: %s\n", input);
    return 0;
}

当你运行这个程序时，输入的"HelloWorld"会变为"Hello World"。

相关问题

用c语言给定一个字符串，翻转该字符串，翻转时单词中的字符顺序不变。例如，如果字符串为"Hello World"，则翻转后为"World Hello"。单词间以一个或多个空格分隔。注意，字符串开头和结尾都可能有多个空格。输出时去掉多余的空格。只在每个单词之间以1个空格间隔。输出的每行末尾没有空格。 输入格式: 输入可能包括多行。每行代表一个字符串，除了空格外，标点符号和普通字母一样处理。你可以认为一行的字符总数不会超过50000个，单词数不会超过600，每个单词的长度也不会超过30。 输出格式: 输出包括多

行，每行为翻转后的字符串。每行末尾没有空格。

C语言代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXN 50010
#define MAXM 610
#define MAXL 35

char s[MAXN];
char words[MAXM][MAXL];
int len[MAXM];

void reverse(char *str, int len) {
    for (int i = 0; i < len / 2; i++) {
        char t = str[i];
        str[i] = str[len - i - 1];
        str[len - i - 1] = t;
    }
}

int main() {
    while (fgets(s, MAXN, stdin) != NULL) {
        int n = strlen(s);
        if (s[n - 1] == '\n') s[--n] = '\0';
        int m = 0, p = 0;
        for (int i = 0; i <= n; i++) {
            if (s[i] == ' ' || s[i] == '\0') {
                if (p > 0) {
                    words[m][p] = '\0';
                    len[m++] = p;
                    p = 0;
                }
            } else {
                words[m][p++] = s[i];
            }
        }
        for (int i = 0, j = m - 1; i < j; i++, j--) {
            char tmp[MAXL];
            int tmplen = len[i];
            memcpy(tmp, words[i], sizeof(char) * tmplen);
            tmp[tmplen] = ' ';
            memcpy(words[i], words[j], sizeof(char) * len[j]);
            words[i][len[j]] = ' ';
            memcpy(words[j], tmp, sizeof(char) * (tmplen + 1));
            len[i] = len[j];
            len[j] = tmplen;
        }
        for (int i = 0; i < m; i++) {
            reverse(words[i], len[i]);
            printf(i == m - 1 ? "%s\n" : "%s ", words[i]);
        }
    }
    return 0;
}

代码思路：

1. 读入字符串s，注意使用fgets函数可以避免字符串长度超过限制的问题。
2. 将字符串s按空格分隔成单词，保存在2维字符数组words中，并记录每个单词的长度。
3. 对每个单词进行翻转。
4. 翻转完后，将单词间的空格调换位置。
5. 输出翻转后的字符串，注意去掉多余的空格和末尾的换行符。

c语言给定一个字符串，翻转该字符串，翻转时单词中的字符顺序不变。例如，如果字符串为"Hello World"，则翻转后为"World Hello"。单词间以一个或多个空格分隔。注意，字符串开头和结尾都可能有多个空格。输出时去掉多余的空格。只在每个单词之间以1个空格间隔。输出的每行末尾没有空格。 输入格式: 输入可能包括多行。每行代表一个字符串，除了空格外，标点符号和普通字母一样处理。你可以认为一行的字符总数不会超过50000个，单词数不会超过600，每个单词的长度也不会超过30。 输出格式: 输出包括多行，每行对应输入的一行，为翻转后的字符串。输出时去掉多余的空格。只在每个单词之前以1个空格间隔。输出的每行末尾没有空格

这道题可以先将整个字符串翻转，然后再单独翻转每个单词即可。具体实现可以使用双指针，一个指针指向单词的起始位置，另一个指针向后遍历直到遇到空格或者字符串末尾，然后将这个单词翻转即可。最后再去掉多余的空格输出即可。

下面是具体的 C 语言实现：

#include <stdio.h>
#include <string.h>

void reverse(char *s, int start, int end) {
    while (start < end) {
        char t = s[start];
        s[start] = s[end];
        s[end] = t;
        start++;
        end--;
    }
}

void reverseWords(char *s) {
    int len = strlen(s);
    // 先翻转整个字符串
    reverse(s, 0, len - 1);
    int i = 0, j = 0;
    while (i < len && j < len) {
        // 找到一个单词的起始位置
        while (i < len && s[i] == ' ') i++;
        // 找到这个单词的结束位置
        j = i;
        while (j < len && s[j] != ' ') j++;
        // 翻转这个单词
        reverse(s, i, j - 1);
        // 处理多余的空格
        while (j < len && s[j] == ' ') j++;
        // 移动 i 指针到下一个单词的起始位置
        i = j;
    }
    // 去掉多余的空格
    i = 0, j = 0;
    while (j < len) {
        while (j < len && s[j] == ' ') j++;
        while (j < len && s[j] != ' ') s[i++] = s[j++];
        while (j < len && s[j] == ' ') j++;
        if (j < len) s[i++] = ' ';
    }
    // 去掉末尾空格
    while (i > 0 && s[i - 1] == ' ') i--;
    s[i] = '\0';
}

int main() {
    char s[50010];
    while (fgets(s, 50010, stdin) != NULL) {
        reverseWords(s);
        printf("%s", s);
    }
    return 0;
}

时间复杂度为 $O(n)$，其中 $n$ 是字符串的长度。