如何在C和Perl中反转句子

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

我使用

strtok（）

编写了一个程序来分离单词，然后将它们推到堆栈上， 弹出并连接它们

还有比这更有效的方法吗？

---

在Perl中更容易做到吗？

效率是否更高将是您可以测试的事情，但在Perl中，您可以按照以下几点来做：

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

---

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

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

使用：

使用：

C示例

char * srtrev (char * str) {

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

C示例

char * srtrev (char * str) {

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

---

Perl使这种文本操作变得非常简单，您甚至可以在shell上轻松地进行测试：

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

或：

---

Perl使这种文本操作变得非常简单，您甚至可以在shell上轻松地进行测试：

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

或：

---

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

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

/*
 * 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的策略可以是：

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

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

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

---

用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。此外，应该为开始和结束情况获取空字符串。

在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。此外，应该为开始和结束案例获取空字符串。

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

#包括
int main（）
{
char s[]=“我的名字是杰克”；
chart[100]；
int i=0，j=0，k=0；
对于（i=strlen（s）-1；i>=0；i--）
{
如果（s[i]=''|i==0）
{
j=i==0？i:i+1；
对于（j=j；s[j]！='\0'；j++）t[k++]=s[j]；
t[k++]=''；
s[i]='\0'；
}
}
t[k]='\0'；
printf（“%s\n”，t）；
返回0；
}

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

#包括
int main（）
{
char s[]=“我的名字是杰克”；
chart[100]；
int i=0，j=0，k=0；
对于（i=strlen（s）-1；i>=0；i--）
{
如果（s[i]=''|i==0）
{
j=i==0？i:i+1；
对于（j=j；s[j]！='\0'；j++）t[k++]=s[j]；
t[k++]=''；
s[i]='\0'；
}
}
t[k]='\0'；
printf（“%s\n”，t）；
返回0；
}

您已经获得了两个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]);  

#定义最大值32
字符*字[MAX]；
字符字[256]；
int pos=0；
用于（位置=0；位置=0）
printf（“%s”，单词[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, " "));

std:：istringstream输入（“我的名字是杰克”）；
std：：矢量字（（std：：istream_迭代器（输入）），
std:：istreamu迭代器（）；
std:：copy（words.rbegin（），words.rend（），
std：：ostream_迭代器（std：：cout，“”）；

您已经获得了两个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]);  

#定义最大值32
字符*字[MAX]；
字符字[256]；
int pos=0；
用于（位置=0；位置=0）
printf（“%s”，单词[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, " "));

std:：istringstream输入（“我的名字是杰克”）；
std：：矢量字（（std：：istream_迭代器（输入）），
std:：istreamu迭代器（）；
std:：copy（words.rbegin（），words.rend（），
std：：ostream_迭代器（std：：cout，“”）；

从regexp和perl特殊变量中得到一些帮助，会很有趣：）

编辑

和一个杀手（现在）：

小说明：$用于打印输出分隔符。当然，您可以在不使用此特殊变量的情况下以更短的方式完成此操作：

print reverse /\w+ ?/g;

---

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

一些有趣的事情，可以从regexp和perl特殊变量中得到一些帮助：）

编辑

和一个杀手（现在）：

小说明：$用于打印输出分隔符。当然，您可以在不使用此特殊变量的情况下以更短的方式完成此操作：

print reverse /\w+ ?/g;

---

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

这里有一个C思想，它使用一点递归来为您进行堆叠：

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

}

---

下面是一个C思想，它使用一点递归来为您进行堆叠：

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

}

---

它反转字符，而不是单词。

rev

从不初始化。它反转字符，而不是单词。

rev

从不初始化。它在Perl中比在C中简单得多。它在Perl中比在C中简单得多。“

/

”应该是“

/

”，不是吗？当我在样本数据上测试它时，我得到“

emananysikcaj

”。（谢谢你，Markdown，你忽略了我在代码中小心的空格！）@Jonathan Leffler:当然，我错了。正在考虑拆分（没有参数）。“

/

”应该是“

/

”，不是吗？当我在样本数据上测试它时，我得到“

emananysikcaj

”。（谢谢你，马克，你忽视了我的关心