拆分字符串并解扰它们

Question

我有一个任务要求我们拆分一个字符串并解读它。例如：

“rsedreve*_emth_*kema*_ot_*si*_skta_*uryo”

变成： “你的任务是让它们反转。”

到目前为止，我只是拆分字符串：

 char secondString[50];

 char *secondString_ptr;

 strcpy(secondString, "rsedreve*_*emth*_*kema*_*ot*_*si*_*skta*_*uryo");

 secondString_ptr = strtok(secondString, "*_*");

 while(secondString_ptr != NULL){
            printf("%s ", secondString_ptr);
            secondString_ptr = strtok(NULL, "*_*");
    }

输出：

rsedreve emth kema ot si skta uryo

显然，这里的模式是从这些标记长度的一半开始，将这些字符添加到 char[] 中，然后将每个标记开头的字符添加到末尾。有人可以帮助我并告诉我如何做到这一点吗？

Answer 1

由于您已经拆分了字符串，因此您需要对它们进行解读。我认为最简单的解读方法是交换适当的字母。

所以你找到中间，然后与开头交换，依此类推。例如，如果您有“123456”，则交换 1 和 4，然后交换 2 和 5，然后交换 3 和 6。

这是一个可以做到这一点的基本功能：

char* unscramble(char *input)
{
        int len = strlen(input);
        int half = len >> 1;
        int i;
        for (i=0 ;i<half; i++)
        {
                int temp = input[i];
                input[i] = input[half+i];
                input[half+i] = temp;
        }
        return input;
}

Answer 2

不是简单地打印每个令牌，而是找到令牌的长度，进行解扰，将其推入堆栈，然后反向打印出来。

编辑：经过编辑，不是一个完整的解决方案，而是很有帮助的 sn-ps。

您可以使用数组，例如，作为简单的“堆栈”

    char *pseudoStack[MAX_WORDS];
    int stackPos = 0;

像这样添加到堆栈中

    pseudoStack[stackPos] = unscrambled;
    stackPos++;

然后像这样打印

    for (i = stackPos - 1; i >= 0; i--) {
        printf("%s ", pseudoStack[i]);
        free(pseudoStack[i]);
    }

可以完全按照您描述的方式进行解扰。不要忘记malloc，这样你就不会改变原来的字符串，这样你就可以在循环结束后保留​​字符串。

        char *unscrambled = malloc(MAX_WORD_LENGTH * sizeof(char));
        int unscrambledPos = 0;
        for (i = middle; i < wordLength; i++) {
            unscrambled[unscrambledPos] = secondString_ptr[i];
            unscrambledPos++;
        }
        for (i = 0; i < middle; i++) {
            unscrambled[unscrambledPos] = secondString_ptr[i];
            unscrambledPos++;
        }
        unscrambled[wordLength] = '\0';

也不要忘记最后的空字符！

虽然比较冗长，但至少这样你可以看到每一步的推理。

是否有关于 stackoverflow 的关于作业问题的政策...？

Answer 3

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
main()
{
    char secondString[50];
    char *secondString_ptr;
    int i,j,n,stack_pointer=0;
    char *Word;
    char *stack[50];
    strcpy(secondString, "rsedreve*_*emth*_*kema*_*ot*_*si*_*skta*_*uryo");

    secondString_ptr = strtok(secondString, "*_*");

    while(secondString_ptr != NULL){
            n=strlen(secondString_ptr);
            Word=(char *)malloc(n);
       /*the second half and the first half form the meaningful word*/
       /*so split the word into two part and assign to the variable. Like this*/
            for(i=n/2,j=0;i<n;i++)
                    Word[j++]=secondString_ptr[i];
            for(i=0;i<n/2;i++)
                    Word[j++]=secondString_ptr[i];
            Word[j]='\0';
       /*put all this word in the stack and increment the pointer*/
            secondString_ptr = strtok(NULL, "*_*");
    }
    stack[stack_pointer]=NULL;
    for(i=stack_pointer-1;i>=0;i--)
            printf("%s ",stack[i]);
     printf("\n");      

}

这是满足您要求的算法。

Answer 4

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

int unscrambling(char *str){
    char *p = strtok(str, "*_");
    if(p){
        char temp[50];
        int len = strlen(p);
        int len1 = len >> 1;
        int len2 = len - len1;
        //char temp[len2];
/*
        memcpy(temp, p, len2);
        memcpy(p, p+len2, len1);
        memcpy(p+len1, temp, len2);
*/
        memcpy(temp, p, len1);
        memcpy(p, p+len1, len2);
        memcpy(p+len2, temp, len1);
        if(unscrambling(NULL))
            *p = toupper(*p);
        if(str)
            printf("%s.\n", p);
        else
            printf("%s ", p);
        return 0;
    }
    return 1;
}

int main(){
    char string[50];

    strcpy(string, "rsedreve*_*emth*_*kema*_*ot*_*si*_*skta*_*uryo");
    unscrambling(string);
    strcpy(string, "rsedreve*_emth_*kema*_ot_*si*_skta_*uryo");
    unscrambling(string);
    return 0;
}