C-分开串并解开它们

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

可以准确地进行您描述的方式进行混乱。不要忘记挂麦洛克，这样您就不会更改原始字符串，因此可以在循环结束后保持字符串。

        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] = '';

也不要忘记末尾的空字符！

虽然冗长，但至少这样您可以在每个步骤中看到推理。

虽然有关于家庭作业问题的策略...？

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]='';
       /*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;
}