Как заполнить массив предложением?

Question

Например, у меня есть предложение «Я - Пит».Я хочу заполнить это предложение в массив таким образом, что я [0], я [1] Пит [2].Ниже приведен код, который я сделал.Проблема в том, что предложение заполняется в каждом элементе массива.

#include <iostream>
#include <string>
using namespace std;

// function to populate my array
void populateMyArray(string*myArray, string sentence, int size)
{
for (int i = 0; i < size; i++)
{
*myArray = sentence;
    myArray++;
}
}

// function to count works in the sentence
int countWords(string x)
{
int Num = 0;
char prev = ' ';

for (unsigned int i = 0; i < x.size(); i++) {

    if (x[i] != ' ' && prev == ' ') Num++;

    prev = x[i];
}
return Num;
}

int main()
{
string sentence1;

cout << "Please enter a line of text:\n";
getline(cin, sentence1);

int nWords1 = countWords(sentence1);

string *arr1 = new string[nWords1];

populateMyArray(arr1, sentence1, nWords1); //populate array1

for (int i = 0; i < nWords1; i++)
{
    cout << "sentence one: " << arr1[i] << "\n";
}

system("PAUSE");
}

Answer 1

Если я правильно понял, вы пытаетесь разбить входное предложение на слова.

Вы можете сделать это так:

void populateMyArray(string *myArray, string sentence, int size)
{
  int firstCharIndex = -1;
  char prev = ' ';

  for (unsigned int i = 0; i < sentence.size(); i++) {
    // Find the first character index of current word
    if (sentence[i] != ' ' && prev == ' ') {
      firstCharIndex = i;
    }
    // Check if it's the end of current word
    // and get substring from first to last index of current word
    else if (sentence[i] == ' ' && prev != ' ') {
      *myArray = sentence.substr(firstCharIndex, i - firstCharIndex);
      myArray++;
    }
    prev = sentence[i];
  }

  // For the last word
  if (firstCharIndex != -1 && sentence[sentence.size() - 1] != ' ') {
    *myArray = sentence.substr(firstCharIndex, sentence.size() - firstCharIndex);
  }
}

Answer 2

Вместо использования массива используйте std::vector.Таким образом, вам не нужно беспокоиться о переменном размере слова или о переполнении чего-либо в случае, если слово или предложение слишком длинное.Скорее вы можете просто сделать что-то вроде этого:

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

int main() {
  // Get all words on one line
  std::cout << "Enter words: " << std::flush;
  std::string sentence;
  getline(std::cin, sentence);

  // Parse words into a vector
  std::vector<std::string> words;
  std::string word;
  std::istringstream iss(sentence);
  while( iss >> word ) {
    words.push_back(word);
  }

  // Test it out.
  for(auto const& w : words) {
    std::cout << w << std::endl;
  }
}

Для примера предложения I like cats and dogs equally у вас будет: words[0] = I, words[1] = like и т. Д.

Answer 3

Как мыслить как программист.

Первое, что нам нужно, это определения начала или слова и конца слова.Вы можете подумать, что начало слова - это не пробел, которому предшествует пробел, а конец слова - это не пробел, за которым следует пробел.Но эти определения неверны, потому что они игнорируют возможность слова в начале или конце строки.Правильное определение начала слова - это не пробел в начале строки или не пробел, которому предшествует пробел.Точно так же конец слова - это не пробел в конце строки или не пробел, за которым следует пробел.

Теперь у нас есть определения, которые мы фиксируем их в двух функциях.Очень важно разбить сложные проблемы на более мелкие части, и способ сделать это - написать функции (или классы).

bool beginning_of_word(string str, int index)
{
    return str[index] != ' ' && (index == 0 || str[index - 1] == ' ');
}

bool end_of_word(string str, int index)
{
    return str[index] != ' ' && (index == str.size() - 1 || str[index + 1] == ' ');
}

Теперь мы приближаемся, но нам все еще нужна идея поискаследующее начало слова или следующий конец слова, так что мы можем циклически просматривать предложение, находя каждое слово по одному.Вот две функции для поиска следующего начала и следующего конца слова.Они начинаются с данного индекса и находят следующий индекс, который является началом или концом слова.Если такой индекс не найден, они возвращают -1.

int next_beginning_of_word(string str, int index)
{
    ++index;
    while (index < str.size())
    {
        if (beginning_of_word(str, index))
            return index; // index is a start of word so return it
        ++index;
    }
    return -1; // no next word found
}

int next_end_of_word(string str, int index)
{
    ++index;
    while (index < str.size())
    {
        if (end_of_word(str, index))
            return index; // index is an end of word so return it
        ++index;
    }
    return -1; // no next word found
}

Теперь у нас есть способ перебрать слова в предложении, и мы готовы написать основной цикл.Мы используем substr, чтобы вычеркнуть слова из предложения, substr принимает два параметра: индекс начала слова и длину слова.Мы можем получить длину слова, вычтя начало из конца и добавив единицу.

int populateMyArray(string* array, string sentence)
{
    // find the first word
    int start = next_beginning_of_word(sentence, -1);
    int end = next_end_of_word(sentence, -1);
    int count = 0;
    while (start >= 0) // did we find it?
    {
        // add to array
        array[count] = sentence.substr(start, end - start + 1);
        ++count;
        // find the next word
        start = next_beginning_of_word(sentence, start);
        end = next_end_of_word(sentence, end);
    }
    return count;
}

Теперь для дополнительного кредита мы можем переписать countWords, используя next_beginning_of_word

int countWords(string sentence)
{
    int start = next_beginning_of_word(sentence, -1);
    int count = 0;
    while (start >= 0)
    {
        ++count;
        start = next_beginning_of_word(sentence, start);
    }
    return count;
}

Обратите внимание на сходство функций countWords и populateMyArray, циклы очень похожи.Это должно придать вам уверенности.

Именно так работают программисты, когда у вас есть проблема, которая слишком сложна для вашего решения, разбивайте ее на более мелкие части.

Answer 4

Вы можете использовать вектор для сохранения данных, и каждый раз, когда вам нужно использовать пробел между двумя словами, вы будете хранить каждый тип строки в массиве векторов

 #include<bits/stdc++.h>
    using namespace std;
        main()
        {
            string s;
            getline(cin,s);
            vector<string> ss;
            string temp = "";
            s +=" ";
            for(int i = 0 ; i < s.size();i ++){
                if(s[i] != ' ')
                    temp += s[i];
                else{
                        ss.push_back(temp);
                        temp = "";
                }
            }
            for(int i = 0 ; i < ss.size();i ++)
                cout << ss[i] <<" ";
        }