API tools faq
paste
Advertisement
RobertDeMilo

Функциональные объекты 3

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