Question

如果句子是 “我的名字是杰克” 那么输出应该是 “杰克是我的名字。”

我使用strtok()编写了一个程序来分隔单词，然后将它们推入堆栈，弹出它们并连接起来。

还有其他更有效的方法吗？在Perl中更容易做到吗？

Answer 1

是否更高效将是您可以测试的东西，但在Perl中，您可以采取以下措施：

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

Answer 2

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"'

Answer 3

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

Answer 4

你已经在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, " "));

Answer 5

在regexp和perl特殊变量的帮助下获得一些乐趣：）

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

修改

杀手（现在）：

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

很少解释：$，是special variable用于打印输出分隔符。当然，如果没有这个特殊的var，你可以用更短的方式完成它：

print reverse /\w+ ?/g;

但结果可能不如上面的例子那么令人满意。

Answer 6

这是一个C想法，它使用一点递归来为你做堆叠：



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

}

Answer 7

使用reverse：

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

Answer 8

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

这应该与strtok()的反向类似，但是您继续将指针传递给原始字符串位置，而不是在第一次调用后传递NULL。此外，您应该为开始和结束案例获取空字符串。

Answer 9

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

Answer 10

C示例

char * srtrev (char * str) {

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

如何反转C和Perl中的句子

10 个答案: