API tools faq
paste
Advertisement
RobertDeMilo

Инициализация поисковой системы

RobertDeMilo
Oct 31st, 2023
62
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 9.52 KB | None | 0 0
raw download clone embed print report
  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.     if (text.empty())
  29.     {
  30.         return {};
  31.     }
  32.  
  33.     vector<string> words;
  34.     string word;
  35.     for (const char c : text) {
  36.         if (c == ' ') {
  37.             if (!word.empty()) {
  38.                 words.push_back(word);
  39.                 word.clear();
  40.             }
  41.         }
  42.         else {
  43.             word += c;
  44.         }
  45.     }
  46.  
  47.     if (!word.empty()) {
  48.         words.push_back(word);
  49.     }
  50.     return words;
  51. }
  52.  
  53. struct Document {
  54.  
  55.     Document() = default;
  56.     Document(int id_, double relevance_, int rating_): id(id_), relevance(relevance_), rating(rating_){}
  57.     int id = 0;
  58.     double relevance = 0.0;
  59.     int rating = 0;
  60. };
  61.  
  62. enum class DocumentStatus {
  63.     ACTUAL,
  64.     IRRELEVANT,
  65.     BANNED,
  66.     REMOVED,
  67. };
  68.  
  69. class SearchServer {
  70. public:
  71.  
  72.     //// инициализируем поисковую систему, передавая стоп-слова в контейнере vector
  73.     //
  74.     //const vector<string> stop_words_vector = { "и"s, "в"s, "на"s, ""s, "в"s }
  75.     //SearchServer search_server1(stop_words_vector);
  76.     //
  77.     //// инициализируем поисковую систему передавая стоп-слова в контейнере set
  78.     //
  79.     //const set<string> stop_words_set = { "и"s, "в"s, "на"s };
  80.     //SearchServer search_server2(stop_words_set);
  81.     //
  82.     //// инициализируем поисковую систему строкой со стоп-словами, разделёнными пробелами
  83.     //SearchServer search_server3("  и  в на   "s);
  84.     template<typename StringContainer>
  85.     SearchServer(const StringContainer& container)
  86.     {
  87.         for (const string& word : container) {
  88.             stop_words_.insert(word);
  89.         }
  90.     }
  91.     SearchServer(const string& text)
  92.     {
  93.         for (const string& word : SplitIntoWords(text)) {
  94.             stop_words_.insert(word);
  95.         }
  96.     }
  97.     /*void SetStopWords(const string& text) {
  98.         for (const string& word : SplitIntoWords(text)) {
  99.             stop_words_.insert(word);
  100.         }
  101.     }*/
  102.  
  103.     void AddDocument(int document_id, const string& document, DocumentStatus status,
  104.         const vector<int>& ratings) {
  105.         const vector<string> words = SplitIntoWordsNoStop(document);
  106.         const double inv_word_count = 1.0 / words.size();
  107.         for (const string& word : words) {
  108.             word_to_document_freqs_[word][document_id] += inv_word_count;
  109.         }
  110.         documents_.emplace(document_id, DocumentData{ ComputeAverageRating(ratings), status });
  111.     }
  112.  
  113.     //Достаточно написать новый метод —
  114. // vector<Document> FindTopDocuments(const string& raw_query, DocumentStatus status) const.
  115. //
  116. // А в нём одну строчку : создали нужную лямбду и вызвали основную версию одноимённого метода.
  117. // Не забудьте избавиться от дублирования кода : версия FindTopDocuments с одним параметром теперь может
  118. // вызывать новую версию этого метода — с DocumentStatus.
  119.  
  120.     vector<Document> FindTopDocuments(const string& raw_query, DocumentStatus doc_status = DocumentStatus::ACTUAL) const
  121.     {
  122.         return FindTopDocuments(raw_query, [doc_status](int document_id, DocumentStatus status, int rating) { return status == doc_status; });
  123.     }
  124.  
  125.     template<typename Pred>
  126.     vector<Document> FindTopDocuments(const string& raw_query, Pred pred) const {
  127.  
  128.         const Query query = ParseQuery(raw_query);
  129.  
  130.         auto matched_documents = FindAllDocuments(query, pred);
  131.  
  132.         sort(matched_documents.begin(), matched_documents.end(),
  133.             [](const Document& lhs, const Document& rhs) {
  134.                 if (abs(lhs.relevance - rhs.relevance) < 1e-6) {
  135.                     return lhs.rating > rhs.rating;
  136.                 }
  137.                 else {
  138.                     return lhs.relevance > rhs.relevance;
  139.                 }
  140.             });
  141.         if (matched_documents.size() > MAX_RESULT_DOCUMENT_COUNT) {
  142.             matched_documents.resize(MAX_RESULT_DOCUMENT_COUNT);
  143.         }
  144.         return matched_documents;
  145.     }
  146.  
  147.  
  148.     tuple<vector<string>, DocumentStatus> MatchDocument(const string& raw_query,
  149.         int document_id) const {
  150.         const Query query = ParseQuery(raw_query);
  151.         vector<string> matched_words;
  152.         for (const string& word : query.plus_words) {
  153.             if (word_to_document_freqs_.count(word) == 0) {
  154.                 continue;
  155.             }
  156.             if (word_to_document_freqs_.at(word).count(document_id)) {
  157.                 matched_words.push_back(word);
  158.             }
  159.         }
  160.         for (const string& word : query.minus_words) {
  161.             if (word_to_document_freqs_.count(word) == 0) {
  162.                 continue;
  163.             }
  164.             if (word_to_document_freqs_.at(word).count(document_id)) {
  165.                 matched_words.clear();
  166.                 break;
  167.             }
  168.         }
  169.         return { matched_words, documents_.at(document_id).status };
  170.     }
  171.  
  172.  
  173.     int GetDocumentCount() const {
  174.         return documents_.size();
  175.     }
  176.  
  177. private:
  178.     //////////////////////////////////////////////////////////////////////////////
  179.     struct DocumentData {
  180.         int rating;
  181.         DocumentStatus status;
  182.     };
  183.  
  184.     set<string> stop_words_;
  185.     map<string, map<int, double>> word_to_document_freqs_;
  186.     map<int, DocumentData> documents_;
  187.  
  188.     struct QueryWord {
  189.         string data;
  190.         bool is_minus;
  191.         bool is_stop;
  192.     };
  193.  
  194.     struct Query {
  195.         set<string> plus_words;
  196.         set<string> minus_words;
  197.     };
  198.     //////////////////////////////////////////////////////////////////////////////
  199.     bool IsStopWord(const string& word) const {
  200.         return stop_words_.count(word) > 0;
  201.     }
  202.  
  203.     vector<string> SplitIntoWordsNoStop(const string& text) const {
  204.         vector<string> words;
  205.         for (const string& word : SplitIntoWords(text)) {
  206.             if (!IsStopWord(word)) {
  207.                 words.push_back(word);
  208.             }
  209.         }
  210.         return words;
  211.     }
  212.  
  213.     static int ComputeAverageRating(const vector<int>& ratings) {
  214.         if (ratings.empty()) {
  215.             return 0;
  216.         }
  217.         int rating_sum = 0;
  218.         for (const int rating : ratings) {
  219.             rating_sum += rating;
  220.         }
  221.         return rating_sum / static_cast<int>(ratings.size());
  222.     }
  223.  
  224.  
  225.  
  226.     QueryWord ParseQueryWord(string text) const {
  227.         bool is_minus = false;
  228.         // Word shouldn't be empty
  229.         if (text[0] == '-') {
  230.             is_minus = true;
  231.             text = text.substr(1);
  232.         }
  233.         return { text, is_minus, IsStopWord(text) };
  234.     }
  235.  
  236.  
  237.  
  238.     Query ParseQuery(const string& text) const {
  239.         Query query;
  240.         for (const string& word : SplitIntoWords(text)) {
  241.             const QueryWord query_word = ParseQueryWord(word);
  242.             if (!query_word.is_stop) {
  243.                 if (query_word.is_minus) {
  244.                     query.minus_words.insert(query_word.data);
  245.                 }
  246.                 else {
  247.                     query.plus_words.insert(query_word.data);
  248.                 }
  249.             }
  250.         }
  251.         return query;
  252.     }
  253.  
  254.     // Existence required
  255.     double ComputeWordInverseDocumentFreq(const string& word) const {
  256.         return log(1.0 * documents_.size() / word_to_document_freqs_.at(word).size());
  257.     }
  258.  
  259.     /* vector<Document> FindAllDocuments(const Query& query, DocumentStatus status) const*/
  260.     template <typename Pred>
  261.     vector<Document> FindAllDocuments(const Query& query, Pred pred) const
  262.     {
  263.         map<int, double> document_to_relevance;
  264.  
  265.         for (const string& word : query.plus_words) {
  266.             if (word_to_document_freqs_.count(word) == 0) {
  267.                 continue;
  268.             }
  269.  
  270.  
  271.             //log(1.0 * documents_.size() / word_to_document_freqs_.at(word).size());
  272.             const double inverse_document_freq = ComputeWordInverseDocumentFreq(word);
  273.  
  274.  
  275.  
  276.             for (const auto& [document_id, term_freq] : word_to_document_freqs_.at(word))
  277.             {
  278.                 bool result = pred(document_id, documents_.at(document_id).status, documents_.at(document_id).rating);
  279.                 /* if (documents_.at(document_id).status == status) */
  280.                 if (result)
  281.                 {
  282.                     document_to_relevance[document_id] += term_freq * inverse_document_freq;
  283.                 }
  284.             }
  285.         }
  286.  
  287.  
  288.         //**********************************************************************************
  289.         for (const string& word : query.minus_words) {
  290.             if (word_to_document_freqs_.count(word) == 0) {
  291.                 continue;
  292.             }
  293.  
  294.             for (const auto [document_id, _] : word_to_document_freqs_.at(word)) {
  295.                 document_to_relevance.erase(document_id);
  296.             }
  297.         }
  298.  
  299.         //**********************************************************************************
  300.         vector<Document> matched_documents;
  301.  
  302.         for (const auto [document_id, relevance] : document_to_relevance) {
  303.             matched_documents.push_back(
  304.                 { document_id, relevance, documents_.at(document_id).rating });
  305.         }
  306.         return matched_documents;
  307.         //**********************************************************************************
  308.     }
  309. };
  310.  
  311. // ==================== для примера =========================
  312.  
  313. void PrintDocument(const Document& document) {
  314.     cout << "{ "s
  315.         << "document_id = "s << document.id << ", "s
  316.         << "relevance = "s << document.relevance << ", "s
  317.         << "rating = "s << document.rating
  318.         << " }"s << endl;
  319. }
  320. int main() {
  321.     // инициализируем поисковую систему, передавая стоп-слова в контейнере vector
  322.     const vector<string> stop_words_vector = { "и"s, "в"s, "на"s, ""s, "в"s };
  323.     SearchServer search_server1(stop_words_vector);
  324.     // инициализируем поисковую систему передавая стоп-слова в контейнере set
  325.     const set<string> stop_words_set = { "и"s, "в"s, "на"s };
  326.     SearchServer search_server2(stop_words_set);
  327.     // инициализируем поисковую систему строкой со стоп-словами, разделёнными пробелами
  328.     SearchServer search_server3("  и  в на   "s);
  329.  
  330.     return 0;
  331. }
  332.  
  333.  
  334.  
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!