以相反的順序打印輸入的字符串詞

Question

使用if and while / do - while ，我的工作是按照相反的順序打印以下用戶的輸入（字符串值）。

例如：

輸入字符串值：“您是美國人”，輸出順序相反：“美國人是您”

有什么辦法嗎？

我努力了

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] = '\0';
}

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] = '\0';
            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] = '\0', rev(word_buffer), fprintf(stdout, "%s\n", word_buffer);
        else if (line[line_idx] == ' ')
            word_buffer[word_buffer_idx] = '\0', 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

您可以嘗試這種解決方案中得到一個vector的string '使用S'（單個空格）字符作為分隔符。

下一步將是向后迭代此向量以生成反向字符串。

看起來像這樣（ split是該文章中的字符串拆分功能）：

編輯2 ：如果出於某種原因不喜歡vector ，則可以使用數組（請注意，指針可以充當數組）。 本示例在堆上分配了一個固定大小的數組，您可能需要更改為，例如，當當前單詞數量達到某個值時，將大小增加一倍。

使用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 5

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 6

此處的代碼使用字符串庫來檢測輸入流中的空格，並相應地重寫輸出語句

算法為1.使用getline函數獲取輸入流以捕獲空格。 將pos1初始化為零。 2.查找輸入流中的第一個空格。3.如果找不到空間，則輸入流為輸出4.否則，獲取pos1之后的第一個空格的位置，即pos2。 5.將子字符串pos1和pos2之間的子字符串保存在輸出語句的開頭； new句子。 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 word\n"
            "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;

}