按倒序打印输入字符串

Question

使用if 和 while/do - while，我的工作是按相反顺序打印以下用户的输入(字符串值)。

例如:

输入字符串值:"You are American"反向输出:"American are You"

有什么办法可以做到吗?

我试过了

string a;
cout << "enter a string: ";
getline(cin, a);
a = string ( a.rbegin(), a.rend() );
cout << a << endl;
return 0;

…但这将颠倒单词和的拼写顺序，而拼写不是我要的。

我也应该在if和while语句中添加，但不知道如何添加。

Answer 1

算法为:

1. 反转整个字符串
2. 倒序

#include<iostream>
#include<algorithm>
using namespace std;
string reverseWords(string a)
{ 
    reverse(a.begin(), a.end());
    int s = 0;
    int i = 0;
    while(i < a.length())
    {
        if(a[i] == ' ')
        {
             reverse(a.begin() + s, a.begin() + i);
             s = i + 1;
        }
        i++;
    }
    if(a[a.length() - 1] != ' ')  
    {
        reverse(a.begin() + s, a.end());           
    }
    return a; 
}

Answer 2

这是一个基于C的方法，它将与c++编译器一起编译，它使用堆栈来最小化char *字符串的创建。通过最少的工作，这可以适应使用c++类，以及用do-while或while块简单地替换各种for循环。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINE_LENGTH 1000
#define MAX_WORD_LENGTH 80
void rev(char *str) 
{
    size_t str_length = strlen(str);
    int str_idx;
    char word_buffer[MAX_WORD_LENGTH] = {0};
    int word_buffer_idx = 0;
    for (str_idx = str_length - 1; str_idx >= 0; str_idx--)
        word_buffer[word_buffer_idx++] = str[str_idx];
    memcpy(str, word_buffer, word_buffer_idx);
    str[word_buffer_idx] = '';
}
int main(int argc, char **argv) 
{
    char *line = NULL;
    size_t line_length;
    int line_idx;
    char word_buffer[MAX_WORD_LENGTH] = {0};
    int word_buffer_idx;
    /* set up line buffer - we cast the result of malloc() because we're using C++ */
    line = (char *) malloc (MAX_LINE_LENGTH + 1);
    if (!line) {
        fprintf(stderr, "ERROR: Could not allocate space for line buffer!n");
        return EXIT_FAILURE;
    }
    /* read in a line of characters from standard input */
    getline(&line, &line_length, stdin);
    /* replace newline with NUL character to correctly terminate 'line' */
    for (line_idx = 0; line_idx < (int) line_length; line_idx++) {
        if (line[line_idx] == 'n') {
            line[line_idx] = '';
            line_length = line_idx; 
            break;
        }
    }
    /* put the reverse of a word into a buffer, else print the reverse of the word buffer if we encounter a space */
    for (line_idx = line_length - 1, word_buffer_idx = 0; line_idx >= -1; line_idx--) {
        if (line_idx == -1) 
            word_buffer[word_buffer_idx] = '', rev(word_buffer), fprintf(stdout, "%sn", word_buffer);
        else if (line[line_idx] == ' ')
            word_buffer[word_buffer_idx] = '', rev(word_buffer), fprintf(stdout, "%s ", word_buffer), word_buffer_idx = 0;
        else
            word_buffer[word_buffer_idx++] = line[line_idx];
    }
    /* cleanup memory, to avoid leaks */
    free(line);
    return EXIT_SUCCESS;
}

用c++编译器编译，然后使用:

$ g++ -Wall test.c -o test
$ ./test
foo bar baz
baz bar foo

Answer 3

这个例子一次解包一个输入字符串，并通过反向连接来构建输出字符串。'

#include <iostream>
#include <sstream>
using namespace std;
int main()
{
  string inp_str("I am British");
  string out_str("");
  string word_str;
  istringstream iss( inp_str );

  while (iss >> word_str) {
    out_str = word_str + " " + out_str;
  } // while (my_iss >> my_word) 
  cout << out_str << endl;
  return 0;
} // main

"

Answer 4

这只使用了if和while中的一个。

#include <string>
#include <iostream>
#include <sstream>

void backwards(std::istream& in, std::ostream& out)
{
   std::string word;
   if (in >> word)   // Read the frontmost word
   {
      backwards(in, out);  // Output the rest of the input backwards...
      out << word << " ";  // ... and output the frontmost word at the back
   }
}
int main()
{
   std::string line;
   while (getline(std::cin, line))
   {
      std::istringstream input(line);
      backwards(input, std::cout);
      std::cout << std::endl;
   }
}

Answer 5

您可以尝试使用' '(单个空格)字符作为分隔符来获得string的vector。

下一步是向后遍历该向量以生成反向字符串。

它可能是这样的(split是来自那篇文章的字符串分割函数):

Edit 2:如果您出于某种原因不喜欢vector s，您可以使用数组(注意指针可以充当数组)。本例在堆上分配一个固定大小的数组，您可以将其更改为，当当前字数达到一定值时，将其大小加倍。

使用array代替vector的解决方案:

#include <iostream>
#include <string>
using namespace std;
int getWords(string input, string ** output)
{
    *output = new string[256];  // Assumes there will be a max of 256 words (can make this more dynamic if you want)
    string currentWord;
    int currentWordIndex = 0;
    for(int i = 0; i <= input.length(); i++)
    {
        if(i == input.length() || input[i] == ' ')  // We've found a space, so we've reached a new word
        {
            if(currentWord.length() > 0)
            {
                (*output)[currentWordIndex] = currentWord;
                currentWordIndex++;
            }
            currentWord.clear();
        }
        else
        {
            currentWord.push_back(input[i]);    // Add this character to the current word
        }
    }
    return currentWordIndex;    // returns the number of words
}
int main ()
{
    std::string original, reverse;
    std::getline(std::cin, original);  // Get the input string
    string * arrWords;
    int size = getWords(original, &arrWords);  // pass in the address of the arrWords array
    int index = size - 1;
    while(index >= 0)
    {
       reverse.append(arrWords[index]);
       reverse.append(" ");
       index--;
    }
    std::cout << reverse << std::endl;
    return 0;
}

编辑:添加包括，main功能，while循环格式

#include <vector>
#include <string>
#include <iostream>
#include <sstream>

// From the post
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
   std::stringstream ss(s);
   std::string item;
   while(std::getline(ss, item, delim)) {
       elems.push_back(item);
   }
   return elems;
}

std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    return split(s, delim, elems);
}
int main ()
{
    std::string original, reverse;
    std::cout << "Input a string: " << std::endl;
    std::getline(std::cin, original);  // Get the input string
    std::vector<std::string> words = split(original, ' ');
    std::vector<std::string>::reverse_iterator rit = words.rbegin();
    while(rit != words.rend())
    {
       reverse.append(*rit);
       reverse.append(" "); // add a space
       rit++;
    }
    std::cout << reverse << std::endl;
    return 0;
}

Answer 6

这里的代码使用字符串库来检测输入流中的空白，并相应地重写输出句子

算法为1. 使用getline函数获取输入流以捕获空格。将pos1初始化为0。2. 查找输入流中的第一个空格3.如果没有找到空格，则输入流为输出4. 否则，获取pos1后第一个空白的位置，即pos2。5. 将pos1和pos2之间的子字符串保存在输出句子的开头;剪下来。6. Pos1现在位于空格后的第一个字符处。7. 重复4、5和6，直到没有空格。8. 将最后一个子字符串添加到newSentence的开头。-

#include <iostream> 
#include <string> 
  using namespace std; 
int main ()
{ 
    string sentence; 
    string newSentence;
    string::size_type pos1; 
    string::size_type pos2; 
    string::size_type len; 
    cout << "This sentence rewrites a sentence backward word by wordn"
            "Hello world => world Hello"<<endl;
    getline(cin, sentence); 
    pos1 = 0; 
    len = sentence.length();
    pos2 = sentence.find(' ',pos1); 
    while (pos2 != string::npos)
        {
            newSentence = sentence.substr(pos1, pos2-pos1+1) + newSentence; 
            pos1 = pos2 + 1;
            pos2 = sentence.find(' ',pos1);       
        }
    newSentence = sentence.substr(pos1, len-pos1+1) + " "  + newSentence;
    cout << endl << newSentence  <<endl; 
    return 0;
}