shushus

Спринт 2. Функциональные объекты. Задание 3.

Dec 8th, 2022
285
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.95 KB | None | 0 0
  1. #include <algorithm>
  2. #include <cmath>
  3. #include <iostream>
  4. #include <map>
  5. #include <set>
  6. #include <string>
  7. #include <utility>
  8. #include <vector>
  9.  
  10. using namespace std;
  11.  
  12. const int MAX_RESULT_DOCUMENT_COUNT = 5;
  13.  
  14. string ReadLine() {
  15.     string s;
  16.     getline(cin, s);
  17.     return s;
  18. }
  19.  
  20. int ReadLineWithNumber() {
  21.     int result;
  22.     cin >> result;
  23.     ReadLine();
  24.     return result;
  25. }
  26.  
  27. vector<string> SplitIntoWords(const string& text) {
  28.     vector<string> words;
  29.     string word;
  30.     for (const char c : text) {
  31.         if (c == ' ') {
  32.             if (!word.empty()) {
  33.                 words.push_back(word);
  34.                 word.clear();
  35.             }
  36.         } else {
  37.             word += c;
  38.         }
  39.     }
  40.     if (!word.empty()) {
  41.         words.push_back(word);
  42.     }
  43.  
  44.     return words;
  45. }
  46.  
  47. struct Document {
  48.     int id;
  49.     double relevance;
  50.     int rating;
  51. };
  52.  
  53. enum class DocumentStatus {
  54.     ACTUAL,
  55.     IRRELEVANT,
  56.     BANNED,
  57.     REMOVED,
  58. };
  59.  
  60. class SearchServer {
  61. public:
  62.     void SetStopWords(const string& text) {
  63.         for (const string& word : SplitIntoWords(text)) {
  64.             stop_words_.insert(word);
  65.         }
  66.     }
  67.  
  68.     void AddDocument(int document_id, const string& document, DocumentStatus status,
  69.                      const vector<int>& ratings) {
  70.         const vector<string> words = SplitIntoWordsNoStop(document);
  71.         const double inv_word_count = 1.0 / words.size();
  72.         for (const string& word : words) {
  73.             word_to_document_freqs_[word][document_id] += inv_word_count;
  74.         }
  75.         documents_.emplace(document_id, DocumentData{ComputeAverageRating(ratings), status});
  76.     }
  77.  
  78.     template <typename Helper>
  79.     vector<Document> FindTopDocuments(const string& raw_query, const Helper& helper) const {
  80.         const Query query = ParseQuery(raw_query);
  81.         auto matched_documents = FindAllDocuments(query, helper);
  82.  
  83.         sort(matched_documents.begin(), matched_documents.end(),
  84.              [](const Document& lhs, const Document& rhs) {
  85.                  if (abs(lhs.relevance - rhs.relevance) < 1e-6) {
  86.                      return lhs.rating > rhs.rating;
  87.                  } else {
  88.                      return lhs.relevance > rhs.relevance;
  89.                  }
  90.              });
  91.         if (matched_documents.size() > MAX_RESULT_DOCUMENT_COUNT) {
  92.             matched_documents.resize(MAX_RESULT_DOCUMENT_COUNT);
  93.         }
  94.         return matched_documents;
  95.     }
  96.    
  97.         vector<Document> FindTopDocuments(const string& raw_query) const {            
  98.         auto result = FindTopDocuments(raw_query, [](int document_id, DocumentStatus status, int rating) { return status == DocumentStatus::ACTUAL; });
  99.             return result;
  100.     }
  101.  
  102.     int GetDocumentCount() const {
  103.         return documents_.size();
  104.     }
  105.  
  106.     tuple<vector<string>, DocumentStatus> MatchDocument(const string& raw_query,
  107.                                                         int document_id) const {
  108.         const Query query = ParseQuery(raw_query);
  109.         vector<string> matched_words;
  110.         for (const string& word : query.plus_words) {
  111.             if (word_to_document_freqs_.count(word) == 0) {
  112.                 continue;
  113.             }
  114.             if (word_to_document_freqs_.at(word).count(document_id)) {
  115.                 matched_words.push_back(word);
  116.             }
  117.         }
  118.         for (const string& word : query.minus_words) {
  119.             if (word_to_document_freqs_.count(word) == 0) {
  120.                 continue;
  121.             }
  122.             if (word_to_document_freqs_.at(word).count(document_id)) {
  123.                 matched_words.clear();
  124.                 break;
  125.             }
  126.         }
  127.         return {matched_words, documents_.at(document_id).status};
  128.     }
  129.    
  130.  
  131. private:
  132.     struct DocumentData {
  133.         int rating;
  134.         DocumentStatus status;
  135.     };
  136.  
  137.     set<string> stop_words_;
  138.     map<string, map<int, double>> word_to_document_freqs_;
  139.     map<int, DocumentData> documents_;
  140.  
  141.     bool IsStopWord(const string& word) const {
  142.         return stop_words_.count(word) > 0;
  143.     }
  144.  
  145.     vector<string> SplitIntoWordsNoStop(const string& text) const {
  146.         vector<string> words;
  147.         for (const string& word : SplitIntoWords(text)) {
  148.             if (!IsStopWord(word)) {
  149.                 words.push_back(word);
  150.             }
  151.         }
  152.         return words;
  153.     }
  154.  
  155.     static int ComputeAverageRating(const vector<int>& ratings) {
  156.         if (ratings.empty()) {
  157.             return 0;
  158.         }
  159.         int rating_sum = 0;
  160.         for (const int rating : ratings) {
  161.             rating_sum += rating;
  162.         }
  163.         return rating_sum / static_cast<int>(ratings.size());
  164.     }
  165.  
  166.     struct QueryWord {
  167.         string data;
  168.         bool is_minus;
  169.         bool is_stop;
  170.     };
  171.  
  172.     QueryWord ParseQueryWord(string text) const {
  173.         bool is_minus = false;
  174.         // Word shouldn't be empty
  175.         if (text[0] == '-') {
  176.             is_minus = true;
  177.             text = text.substr(1);
  178.         }
  179.         return {text, is_minus, IsStopWord(text)};
  180.     }
  181.  
  182.     struct Query {
  183.         set<string> plus_words;
  184.         set<string> minus_words;
  185.     };
  186.  
  187.     Query ParseQuery(const string& text) const {
  188.         Query query;
  189.         for (const string& word : SplitIntoWords(text)) {
  190.             const QueryWord query_word = ParseQueryWord(word);
  191.             if (!query_word.is_stop) {
  192.                 if (query_word.is_minus) {
  193.                     query.minus_words.insert(query_word.data);
  194.                 } else {
  195.                     query.plus_words.insert(query_word.data);
  196.                 }
  197.             }
  198.         }
  199.         return query;
  200.     }
  201.  
  202.     // Existence required
  203.     double ComputeWordInverseDocumentFreq(const string& word) const {
  204.         return log(GetDocumentCount() * 1.0 / word_to_document_freqs_.at(word).size());
  205.     }
  206.  
  207.     template <typename Helper>
  208.     vector<Document> FindAllDocuments(const Query& query, Helper& helper) const {
  209.         map<int, double> document_to_relevance;
  210.         for (const string& word : query.plus_words) {
  211.             if (word_to_document_freqs_.count(word) == 0) {
  212.                 continue;
  213.             }
  214.             const double inverse_document_freq = ComputeWordInverseDocumentFreq(word);
  215.             for (const auto [document_id, term_freq] : word_to_document_freqs_.at(word)) {
  216.                 const auto& document_data = documents_.at(document_id);
  217.                 if (helper(document_id, document_data.status, document_data.rating)) {
  218.                     document_to_relevance[document_id] += term_freq * inverse_document_freq;
  219.                 }
  220.             }
  221.         }
  222.  
  223.         for (const string& word : query.minus_words) {
  224.             if (word_to_document_freqs_.count(word) == 0) {
  225.                 continue;
  226.             }
  227.             for (const auto [document_id, _] : word_to_document_freqs_.at(word)) {
  228.                 document_to_relevance.erase(document_id);
  229.             }
  230.         }
  231.  
  232.         vector<Document> matched_documents;
  233.         for (const auto [document_id, relevance] : document_to_relevance) {
  234.             matched_documents.push_back(
  235.                 {document_id, relevance, documents_.at(document_id).rating});
  236.         }
  237.         return matched_documents;
  238.     }
  239. };
  240.  
  241. // ==================== для примера =========================
  242.  
  243. void PrintDocument(const Document& document) {
  244.     cout << "{ "s
  245.          << "document_id = "s << document.id << ", "s
  246.          << "relevance = "s << document.relevance << ", "s
  247.          << "rating = "s << document.rating
  248.          << " }"s << endl;
  249. }
  250. int main() {
  251.     SearchServer search_server;
  252.     search_server.SetStopWords("и в на"s);
  253.     search_server.AddDocument(0, "белый кот и модный ошейник"s,        DocumentStatus::ACTUAL, {8, -3});
  254.     search_server.AddDocument(1, "пушистый кот пушистый хвост"s,       DocumentStatus::ACTUAL, {7, 2, 7});
  255.     search_server.AddDocument(2, "ухоженный пёс выразительные глаза"s, DocumentStatus::ACTUAL, {5, -12, 2, 1});
  256.     search_server.AddDocument(3, "ухоженный скворец евгений"s,         DocumentStatus::BANNED, {9});
  257.     cout << "ACTUAL by default:"s << endl;
  258.     for (const Document& document : search_server.FindTopDocuments("пушистый ухоженный кот"s)) {
  259.         PrintDocument(document);
  260.     }
  261.     cout << "ACTUAL:"s << endl;
  262.     for (const Document& document : search_server.FindTopDocuments("пушистый ухоженный кот"s, [](int document_id, DocumentStatus status, int rating) { return status == DocumentStatus::ACTUAL; })) {
  263.         PrintDocument(document);
  264.     }
  265.     cout << "Even ids:"s << endl;
  266.     for (const Document& document : search_server.FindTopDocuments("пушистый ухоженный кот"s, [](int document_id, DocumentStatus status, int rating) { return document_id % 2 == 0; })) {
  267.         PrintDocument(document);
  268.     }
  269.     return 0;
  270. }
Advertisement
Add Comment
Please, Sign In to add comment