shushus

Спринт 1. Учёт минус-слов.

Dec 7th, 2022
130
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 4.55 KB | None | 0 0
  1. #include <algorithm>
  2. #include <iostream>
  3. #include <set>
  4. #include <string>
  5. #include <utility>
  6. #include <vector>
  7.  
  8. using namespace std;
  9.  
  10. const int MAX_RESULT_DOCUMENT_COUNT = 5;
  11.  
  12. string ReadLine() {
  13.     string s;
  14.     getline(cin, s);
  15.     return s;
  16. }
  17.  
  18. int ReadLineWithNumber() {
  19.     int result = 0;
  20.     cin >> result;
  21.     ReadLine();
  22.     return result;
  23. }
  24.  
  25. vector<string> SplitIntoWords(const string& text) {
  26.     vector<string> words;
  27.     string word;
  28.     for (const char c : text) {
  29.         if (c == ' ') {
  30.             if (!word.empty()) {
  31.                 words.push_back(word);
  32.                 word.clear();
  33.             }
  34.         } else {
  35.             word += c;
  36.         }
  37.     }
  38.     if (!word.empty()) {
  39.         words.push_back(word);
  40.     }
  41.  
  42.     return words;
  43. }
  44.  
  45. struct Document {
  46.     int id;
  47.     int relevance;
  48. };
  49.  
  50. class SearchServer {
  51. public:
  52.     void SetStopWords(const string& text) {
  53.         for (const string& word : SplitIntoWords(text)) {
  54.             stop_words_.insert(word);
  55.         }
  56.     }
  57.  
  58.     void AddDocument(int document_id, const string& document) {
  59.         const vector<string> words = SplitIntoWordsNoStop(document);
  60.         documents_.push_back({document_id, words});
  61.     }
  62.  
  63.     vector<Document> FindTopDocuments(const string& raw_query) const {
  64.         const Query query_words = ParseQuery(raw_query);
  65.         auto matched_documents = FindAllDocuments(query_words);
  66.  
  67.         sort(matched_documents.begin(), matched_documents.end(),
  68.              [](const Document& lhs, const Document& rhs) {
  69.                  return lhs.relevance > rhs.relevance;
  70.              });
  71.         if (matched_documents.size() > MAX_RESULT_DOCUMENT_COUNT) {
  72.             matched_documents.resize(MAX_RESULT_DOCUMENT_COUNT);
  73.         }
  74.         return matched_documents;
  75.     }
  76.  
  77. private:
  78.     struct DocumentContent {
  79.         int id = 0;
  80.         vector<string> words;
  81.     };
  82.    
  83.     struct Query{
  84.         set<string> plus_w;
  85.         set<string> minus_w;
  86.     };
  87.  
  88.     vector<DocumentContent> documents_;
  89.  
  90.     set<string> stop_words_;
  91.  
  92.     bool IsStopWord(const string& word) const {
  93.         return stop_words_.count(word) > 0;
  94.     }
  95.  
  96.     vector<string> SplitIntoWordsNoStop(const string& text) const {
  97.         vector<string> words;
  98.         for (const string& word : SplitIntoWords(text)) {
  99.             if (!IsStopWord(word)) {
  100.                 words.push_back(word);
  101.             }
  102.         }
  103.         return words;
  104.     }
  105.  
  106.     Query ParseQuery(const string& text) const {
  107.         Query query;
  108.         for (const string& word : SplitIntoWordsNoStop(text)) {
  109.             if (word[0] != '-') {
  110.                 query.plus_w.insert(word);
  111.             }
  112.             else {
  113.                 query.minus_w.insert(word.substr(1));
  114.              }
  115.         }
  116.         return query;
  117.     }
  118.  
  119.     vector<Document> FindAllDocuments(const Query query_words) const {
  120.         vector<Document> matched_documents;
  121.         for (const auto& document : documents_) {
  122.             const int relevance = MatchDocument(document, query_words);
  123.             if (relevance > 0) {
  124.                 matched_documents.push_back({document.id, relevance});
  125.             }
  126.         }
  127.         return matched_documents;
  128.     }
  129.  
  130.     static int MatchDocument(const DocumentContent& content, const Query query_words) {
  131.         if (query_words.plus_w.empty()) {
  132.             return 0;
  133.         }
  134.         set<string> matched_words;
  135.         for (const string& word : content.words) {
  136.             if (matched_words.count(word) != 0) {
  137.                 continue;
  138.             }
  139.             if (query_words.minus_w.count(word) != 0) {
  140.                 matched_words.clear();
  141.                 break;
  142.             }
  143.             if (query_words.plus_w.count(word) != 0) {
  144.                 matched_words.insert(word);
  145.             }
  146.         }
  147.         return static_cast<int>(matched_words.size());
  148.     }
  149. };
  150.  
  151. SearchServer CreateSearchServer() {
  152.     SearchServer search_server;
  153.     search_server.SetStopWords(ReadLine());
  154.  
  155.     const int document_count = ReadLineWithNumber();
  156.     for (int document_id = 0; document_id < document_count; ++document_id) {
  157.         search_server.AddDocument(document_id, ReadLine());
  158.     }
  159.  
  160.     return search_server;
  161. }
  162.  
  163. int main() {
  164.     const SearchServer search_server = CreateSearchServer();
  165.  
  166.     const string query = ReadLine();
  167.     for (const auto& [document_id, relevance] : search_server.FindTopDocuments(query)) {
  168.         cout << "{ document_id = "s << document_id << ", "
  169.              << "relevance = "s << relevance << " }"s << endl;
  170.     }
  171. }
Advertisement
Add Comment
Please, Sign In to add comment