shushus

Спринт 2. Перечислимые типы. Задание 1.

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