View difference between Paste ID: jWtW6Vxn and PPp6sXrq

 // Код поисковой системы из финального задания спринта №2
 #include <algorithm>
 #include <cmath>
 #include <iostream>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 #include <numeric>
 
 using namespace std;
 
 const int MAX_RESULT_DOCUMENT_COUNT = 5;
 constexpr double EPSILON = 1e-6;
 
 string ReadLine() {
     string s;
     getline(cin, s);
     return s;
 }
 
 int ReadLineWithNumber() {
     int result;
     cin >> result;
     ReadLine();
     return result;
 }
 
 vector<string> SplitIntoWords(const string& text) {
     vector<string> words;
     string word;
     for (const char c : text) {
         if (c == ' ') {
             if (!word.empty()) {
                 words.push_back(word);
                 word.clear();
             }
         } else {
             word += c;
         }
     }
     if (!word.empty()) {
         words.push_back(word);
     }
 
     return words;
 }
 
 template <typename StringCollection>
 set<string> NotEmptyStringCollection(const StringCollection& collection) {
     set<string> not_empty_strings_collection;
     for (const auto& stringg : collection) {
         if (!(stringg.empty())) {
             not_empty_strings_collection.insert(stringg);
         }
     }
     return not_empty_strings_collection;
 }
 
 struct Document {
 
     Document() = default;
 
     Document(int id_doc, double relevance_doc, int rating_doc) : id(id_doc), relevance(relevance_doc), rating(rating_doc){}
 
     int id = 0;
     double relevance = 0.0;
     int rating = 0;
 };
 
 enum class DocumentStatus {
     ACTUAL,
     IRRELEVANT,
     BANNED,
     REMOVED,
 };
 
 class SearchServer {
 public:
 
     explicit SearchServer(const string& stop_words_string) : SearchServer(SplitIntoWords(stop_words_string)){}
 
     template <typename StringCollection>
     explicit SearchServer(const StringCollection& stop_words) : stop_words_(NotEmptyStringCollection(stop_words)){}
 
     void AddDocument(int document_id, const string& document, DocumentStatus status,
                      const vector<int>& ratings) {
         const vector<string> words = SplitIntoWordsNoStop(document);
         const double inv_word_count = 1.0 / words.size();
         for (const string& word : words) {
             word_to_document_freqs_[word][document_id] += inv_word_count;
         }
         documents_.emplace(document_id, DocumentData{ComputeAverageRating(ratings), status});
     }
 
     template <typename Helper>
     vector<Document> FindTopDocuments(const string& raw_query, const Helper& helper) const {
         const Query query = ParseQuery(raw_query);
         auto matched_documents = FindAllDocuments(query, helper);
 
         sort(matched_documents.begin(), matched_documents.end(),
              [](const Document& lhs, const Document& rhs) {
                  if (abs(lhs.relevance - rhs.relevance) < EPSILON) {
                      return lhs.rating > rhs.rating;
                  } else {
                      return lhs.relevance > rhs.relevance;
                  }
              });
         if (matched_documents.size() > MAX_RESULT_DOCUMENT_COUNT) {
             matched_documents.resize(MAX_RESULT_DOCUMENT_COUNT);
         }
         return matched_documents;
     }
 
     vector<Document> FindTopDocuments(const string& raw_query, DocumentStatus status) const {
         auto result = FindTopDocuments(raw_query, [status](int id, const DocumentStatus& doc_status, int raring) {return status == doc_status;});
         return result;
     }
 
     vector<Document> FindTopDocuments(const string& raw_query) const {
        auto result = FindTopDocuments(raw_query, DocumentStatus::ACTUAL);
        return result;
     }
 
     int GetDocumentCount() const {
         return documents_.size();
     }
 
     tuple<vector<string>, DocumentStatus> MatchDocument(const string& raw_query,
                                                         int document_id) const {
         const Query query = ParseQuery(raw_query);
         vector<string> matched_words;
         for (const string& word : query.plus_words) {
             if (word_to_document_freqs_.count(word) == 0) {
                 continue;
             }
             if (word_to_document_freqs_.at(word).count(document_id)) {
                 matched_words.push_back(word);
             }
         }
         for (const string& word : query.minus_words) {
             if (word_to_document_freqs_.count(word) == 0) {
                 continue;
             }
             if (word_to_document_freqs_.at(word).count(document_id)) {
                 matched_words.clear();
                 break;
             }
         }
         return {matched_words, documents_.at(document_id).status};
     }
 
 
 private:
     struct DocumentData {
         int rating;
         DocumentStatus status;
     };
 
     set<string> stop_words_;
     map<string, map<int, double>> word_to_document_freqs_;
     map<int, DocumentData> documents_;
 
     bool IsStopWord(const string& word) const {
         return stop_words_.count(word) > 0;
     }
 
     vector<string> SplitIntoWordsNoStop(const string& text) const {
         vector<string> words;
         for (const string& word : SplitIntoWords(text)) {
             if (!IsStopWord(word)) {
                 words.push_back(word);
             }
         }
         return words;
     }
 
     static int ComputeAverageRating(const vector<int>& ratings) {
         if (ratings.empty()) {
             return 0;
         }
         /*int rating_sum = 0;
         for (const int rating : ratings) {
             rating_sum += rating;
         }*/
         return accumulate(ratings.begin(), ratings.end(), 0) / static_cast<int>(ratings.size());
     }
 
     struct QueryWord {
         string data;
         bool is_minus;
         bool is_stop;
     };
 
     QueryWord ParseQueryWord(string text) const {
         bool is_minus = false;
         // Word shouldn't be empty
         if (text[0] == '-') {
             is_minus = true;
             text = text.substr(1);
         }
         return {text, is_minus, IsStopWord(text)};
     }
 
     struct Query {
         set<string> plus_words;
         set<string> minus_words;
     };
 
     Query ParseQuery(const string& text) const {
         Query query;
         for (const string& word : SplitIntoWords(text)) {
             const QueryWord query_word = ParseQueryWord(word);
             if (!query_word.is_stop) {
                 if (query_word.is_minus) {
                     query.minus_words.insert(query_word.data);
                 } else {
                     query.plus_words.insert(query_word.data);
                 }
             }
         }
         return query;
     }
 
     // Existence required
     double ComputeWordInverseDocumentFreq(const string& word) const {
         return log(GetDocumentCount() * 1.0 / word_to_document_freqs_.at(word).size());
     }
 
     template <typename Helper>
     vector<Document> FindAllDocuments(const Query& query, Helper& helper) const {
         map<int, double> document_to_relevance;
         for (const string& word : query.plus_words) {
             if (word_to_document_freqs_.count(word) == 0) {
                 continue;
             }
             const double inverse_document_freq = ComputeWordInverseDocumentFreq(word);
             for (const auto [document_id, term_freq] : word_to_document_freqs_.at(word)) {
                 const auto& document_data = documents_.at(document_id);
                 if (helper(document_id, document_data.status, document_data.rating)) {
                     document_to_relevance[document_id] += term_freq * inverse_document_freq;
                 }
             }
         }
 
         for (const string& word : query.minus_words) {
             if (word_to_document_freqs_.count(word) == 0) {
                 continue;
             }
             for (const auto [document_id, _] : word_to_document_freqs_.at(word)) {
                 document_to_relevance.erase(document_id);
             }
         }
 
         vector<Document> matched_documents;
         for (const auto [document_id, relevance] : document_to_relevance) {
             matched_documents.push_back(
                 {document_id, relevance, documents_.at(document_id).rating});
         }
         return matched_documents;
     }
 };
 
 // ==================== для примера =========================