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

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

编辑：编辑为不是一个完整的解决方案，而是有用的片段。

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

    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;
}

拆分字符串并解开它们

4 个答案: