1

如何解决这个问题？https://code.google.com/codejam/contest/351101/dashboard#s=p1？

我最终得到的代码如下，但它只能将字符串反转一个空格，因为它是记住文字逻辑的代码，反转整个字符串，反转单词，然后完成。空格有点混乱，当我尝试循环检测空格数并采取相应措施时，它失败了。请帮忙！代码：

#include <iostream>
#include <string>

using namespace std;


int main()
{

    char revwrd[100];
    char revstr[100];
    string str;
    getline(cin, str);
    cout<<str;
    int sps[10];

    int len,y=0;
    len = str.length();
    cout<<"\n"<<"The Length of the string is:"<<len;
    for(int x=len-1;x>-1;x--)
    {
        revstr[x] = str[y];
        y++;

    }
    cout<<"\n"<<"The inverse of the string is:"<<"\n";
    for(int z = 0;z<len;z++)
    {
        cout<<revstr[z];
    }
    cout<<"\n";

    int no=0;
    int spaces=0;
    for(int a=0;a<len;a++)
    {
        if(revstr[a]== ' ')
        {
            sps[no]=a;
            no++;
            spaces++;
        }
    }

    int rinc=0;
    int spinc;
    cout<<"\n";
    spinc=sps[0];

    int spinc2 = sps[0]+1;
    int lend;
    for(rinc=0;rinc<sps[0]+1;rinc++)
    {

        revwrd[rinc] = revstr[spinc];
        spinc--;
    }


    for(lend=len;lend>sps[0];lend--)
    {
        revwrd[spinc2] = revstr[lend];
        spinc2++;
    }
    cout<<"Spaces in the string:"<<spaces<<"\n";
    cout<<"The words inversed are:"<<"\n";
    for(int inc=1;inc<len+1;inc++)
    {
        cout<<revwrd[inc];
    }

    return 0;
}
4

6 回答 6

1

挑战的条件是单词之间只有一个空格，并且空格不会出现在行首或行尾，因此对于这个特定的练习 ，您不必担心保留空格；只要您在每个单词之间用一个空格编写输出，就可以了。

考虑到这一点，您可以使用常规格式的输入读取每个单词：

std::string word;
...
while ( stream >> word )
  // do something with word

您不必担心缓冲区大小，您不必担心检测空格等。您不必担心检测换行符，但这很容易使用以下peek方法完成：

while ( stream >> word )
{
  // do something with word;
  if ( stream.peek() == '\n' )
    break;
}

上面的循环将从输入流中读取单个单词，stream直到它看到一个换行符（可能有更好的方法来做到这一点，但它有效）。

现在，为了反转输入的每一行，您显然需要在读取字符串时将它们存储在某处。最简单的做法是将它们存储到向量中：

std::vector< std::string > strings;
...
while ( stream >> word )
{
  strings.push_back( word );
  if ( stream.peek() == '\n' )
    break;
}

所以现在你有一个包含行中所有字符串的向量，你只需要以相反的顺序打印出来。您可以使用反向迭代器遍历向量：

std::vector< std::string >::reverse_iterator it;
for ( it = strings.rbegin(); it != strings.rend(); ++it )
{
  std::cout << *it << " ";
}
std::cout << std::endl;

该rbegin()方法返回一个指向向量中最后一个元素的迭代器；该rend()方法返回一个迭代器，该迭代器指向向量的第一个元素之前的元素；++it使迭代器前进以指向向量中的下一项，回到前面；并*it给出迭代器指向的字符串。您可以获得更深奥的知识并使用copy模板功能：

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

那个单一的方法调用替换了上面的循环。它创建了一个新ostream_iterator的，将字符串写入cout，由单个空格字符分隔。

对于这个特定练习的条件，这绰绰有余。如果您需要保留间距，或考虑标点符号或大写字母，那么您必须做一些较低级别的事情。

于 2013-04-17T16:27:09.667 回答
1

只有几个循环和if：

// Reverse Words 
#include <iostream>
#include <string>

using namespace std;

int main() {
    int tc; cin >> tc; cin.get();
    for(int t = 0; t < tc; t++) {
        string s, k; getline(cin, s);   
        for(int i = (s.length()- 1); i >= 0; i--) {
            if(s[i] == ' ' || (i == 0)) {
                    if(i == 0) k += ' ';
                for(int j = i; j < s.length(); j++) {
                    k += s[j];
                    if(s[j+1] == ' ' ) break;
                }
            } 
        }
        cout << "Case #" << t + 1 << " " << k << endl;
    }   

    return 0;
}
于 2014-04-09T01:02:10.357 回答
0

这个问题真的是为了递归：

void reverse()
{
    string str;
    cin >> str;
    if (cin.peek() != '\n' || cin.eof()) {
        str = " " + str;
        reverse();
    }
    cout << str;
}

int main(int argc, const char * argv[])
{
    int count = 0;
    cin >> count;
    for (int i = 0; i < count; i++) {
        cout << "Case #" << (i + 1) << ": ";
        reverse();
        cout << endl;
    }
    return 0;
}

所以我逐字阅读并在单词前面添加一个空格，直到到达行尾或文件结尾。一旦到达行尾，递归就会展开并以相反的顺序打印读取的字符串。

于 2013-05-10T15:47:11.990 回答
0

这可能会处理多个空格：

std::string ReverseSentence(std::string in)
{
   std::vector<string> words;
   std::string temp = "";
   bool isSpace = false;
   for(int i=0; in.size(); i++)
   {
      if(in[i]!=' ')
      {
         if(isSpace)
         {
            words.push_back(temp);
            temp = "";
            isSpace = false;
         }
         temp+=in[i];
      }
      else
      {
         if(!isSpace)
         {
            words.push_back(temp);
            temp = "";
            isSpace = true;
         }
         temp +=  " ";
      }
   }
   std::reverse(words.begin(),words.end());
   std::string out = "";
   for(int i=0; i<words.size(); i++)
   {
      out+=words[i];
   }
 return out;
}
于 2013-04-17T12:52:46.723 回答
0

你可以按照这个方法：

第 1 步：只需检查输入数组中的空格，将它们的索引号存储在整数数组中。

第 2 步：现在从末尾迭代这个整数数组

step a : make a string by copying characters from this index to previous index .
      note : since for first element there is no previous element in that case you will   copy   from this index to end of the input string .  

step b : step a will give you a word from end of input string now add these word with a space to make your output string .

我希望这能帮到您 。

于 2013-04-17T12:56:14.690 回答
0

我选择了蛮力，我非常想使用指针！

  1. 得到句子
  2. 检测每个单词并将它们放入容器中。
  3. 向后阅读容器。

就是这个：

#include <iostream>
#include <string>
#include <vector>
int main()
{
char *s1 = new char[100];
std::cin.getline(s1, 100);

std::vector<std::string> container;
char* temp = new char[100];
char *p1, *p0;

p1 =p0 = s1;
int i;
do{
    if (*p1==' ' || *p1=='\0'){
        //std::cout<<p1-p0<<' ';
        for(i=0;i<p1-p0;++i) temp[i]=p0[i]; temp[i]='\0';
        p0 = p1+1;
        container.push_back(temp);
        std::cout<<temp;
    }
    p1++;
}while(*(p1-1)!='\0');

std::cout<<std::endl;
for(int i=container.size()-1;i>=0;i--) std::cout<<container[i]<<' ';

return 0;
}
于 2015-05-27T15:43:11.870 回答