如何在C和Perl中反转句子

问题描述

| 如果句子是 \“我的名字是杰克\” 那么输出应该是 “杰克叫我的名字”。 我做了一个程序，使用ѭ0来分隔单词，然后将它们压入堆栈， 弹出并连接。 除此之外，还有其他更有效的方法吗？ 在Perl中做起来容易吗？     

解决方法

您可以测试它是否更有效，但是在Perl中，您可以按照以下方式进行操作：

my $reversed = join( \" \",reverse( split( / /,$string ) ) );

    ,Perl使这种文本操作非常容易，您甚至可以在shell上轻松测试一下：

echo \"run as fast as you can\" | perl -lne \'print join $\",reverse split /\\W+/\'

要么：

echo \"all your bases are belong to us\" | perl -lne \'@a=reverse /\\w+/g;print \"@a\"\'

    ,C的策略可能是这样的： 1）反转字符串的字符。这导致单词是正确的大致位置，尽管是向后的。 2）反转字符串中每个单词的字符。 我们将需要一个函数来反转缓冲区中的字符：

/*
 * Reverse characters in a buffer.
 * 
 * If provided \"My name is Jack\",modifies the input to become
 * \"kcaJ si eman yM\".
 */
void reverse_chars(char * buf,int cch_len)
{
    char * front = buf,*back = buf + cch_len - 1;

    while (front < back)
    {
        char tmp = *front;
        *front = *back;
        *back = tmp;
        front ++;
        back --;
    }
}

为了将输入缓冲区分成单词，一个函数返回缓冲区中非空格字符的数量。 （strtok（）修改缓冲区，更难于就地使用）

int word_len(char *input)
{
    char * p = input;

    while (*p && !isspace(*p))
        p++;

    return p - input;
}

最后，我们需要一个函数，该函数使用这两个助手来实现第一段中描述的策略。

/*
 * Reverse words in a buffer.
 *
 * Given the input \"My name is Jack\",modifies the input to become
 * \"Jack is name My\"
 */
void reverse_words(char *input)
{
     int cch_len = strlen(input);

     /* Part 1: Reverse the string characters. */
     reverse_chars(input,cch_len);

     char * p = input;

     /* Part 2: Loop over one word at a time. */
     while (*p)
     {
         /* Skip leading spaces */
         while (*p && isspace(*p))
             p++;

         if (*p)
         {
             /* Advance one complete word. */
             int cch_word = word_len(p);
             reverse_chars(p,cch_word);
             p += cch_word;
         }
     }
}

    ,您已经在C语言中获得了几个版本，但是它们给我的印象比实际可能要复杂得多。如果没有其他理由，我会考虑这样的事情：

#define MAX 32

char *words[MAX];
char word[256];
int pos = 0;

for (pos=0; pos<MAX && scanf(\"%255s\",word); pos++)
    words[pos] = strdup(word);

while (--pos >= 0)
  printf(\"%s \",words[pos]);  

C和Perl之间的一个可能的“中间”级别是C ++：

std::istringstream input(\"My name is Jack\");
std::vector<std::string> words((std::istream_iterator<std::string>(input)),std::istream_iterator<std::string>());

std::copy(words.rbegin(),words.rend(),std::ostream_iterator<std::string>(std::cout,\" \"));

    ,这是一个C想法，它使用一点递归为您做堆栈：

void rev(char * x){
  char * p;
  if(p = strchr(x,\' \')){
    rev(p+1);
    printf(\"%.*s \",p-x,x);
  }
  else{
    printf(\"%s \",x);
  }

}

    ,在regexp和perl特殊变量的帮助下，会有些乐趣：)

$_ = \"My name is Jack\";
unshift @_,\"$1 \" while /(\\w+)/g;
print @_;

编辑 还有一个杀手（到目前为止）：

$,=\' \';print reverse /\\w+/g;

小小的解释：$，是打印输出分隔符的特殊变量。当然，您可以在没有此特殊var的情况下以较短的方式进行操作：

print reverse /\\w+ ?/g;

但是结果可能不像上面的示例那样令人满意。     ,使用

reverse

：

my @words = split / /,$sentence;
my $newSentence = join(\' \',reverse @words);

    ,在Perl中做起来可能容易得多，但是...

char *strrtok(char *str,const char *delim)
{
    int i,j;

    for (i = strlen(str) - 1; i > 0; i--)
    {
        // Sets the furthest set of contiguous delimiters to null characters
        if (strchr(delim,str[i]))
        {
            j = i + 1;

            while (strchr(delim,str[i]) && i >= 0)
            {
                str[i] = \'\\0\';
                i--;
            }

            return &(str[j]);
        }
    }

    return str;
}

反之，其工作方式类似于ѭ0，但是您继续将指针传递到原始字符串位置，而不是在第一次调用后传递NULL。另外，对于开始和结束情况，您应该获得空字符串。     ,C版：

#include <string.h>
int main()
{
char s[] = \"My name is Jack\";
char t[100];
int i = 0,j = 0,k = 0;

for(i = strlen(s) - 1 ; i >= 0 ;i--)
{
    if(s[i] == \' \' || i == 0)
    {
        j = i == 0 ?  i : i + 1;
        for(j = j; s[j] != \'\\0\'; j++) t[k++] = s[j];
        t[k++] = \' \';
        s[i] = \'\\0\';
    }
}
t[k] = \'\\0\';
printf(\"%s\\n\",t);
return 0;
}

    ,C示例

char * srtrev (char * str) {

       int l = strlen(str);
       char * rev;
       while(l != 0)
       {
         rev += str[ --l];
       }
        return rev;
}