shushus

Спринт 2. Вещественные числа и задача о задачах. Задание 1.

Dec 7th, 2022
170
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 7.70 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.     int GetDocumentCount() const{
  63.         return documents_.size();
  64.     }
  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.     vector<Document> FindTopDocuments(const string& raw_query,
  82.                                       DocumentStatus status = DocumentStatus::ACTUAL) const {
  83.         const Query query = ParseQuery(raw_query);
  84.         auto matched_documents = FindAllDocuments(query, status);
  85.  
  86.         sort(matched_documents.begin(), matched_documents.end(),
  87.              [](const Document& lhs, const Document& rhs) {
  88.                  const double EPSILON = 1e-6;
  89.                  if(abs(lhs.relevance-rhs.relevance)<EPSILON){
  90.                     return lhs.rating > rhs.rating;
  91.                  } else{return lhs.relevance>rhs.relevance;}
  92.              });
  93.         if (matched_documents.size() > MAX_RESULT_DOCUMENT_COUNT) {
  94.             matched_documents.resize(MAX_RESULT_DOCUMENT_COUNT);
  95.         }
  96.         return matched_documents;
  97.     }
  98.    
  99.     tuple<vector<string>, DocumentStatus> MatchDocument(const string& raw_query, int document_id) const{
  100.         vector<string> match;
  101.         vector<string> emptyes;
  102.         Query query = ParseQuery(raw_query);
  103.         for (const string& word: query.minus_words){
  104.             if(word_to_document_freqs_.count(word)>0 && word_to_document_freqs_.at(word).count(document_id)>0){
  105.                 return tuple(emptyes, documents_.at(document_id).status);
  106.             }
  107.         }
  108.         for (const string& word: query.plus_words){
  109.             if (word_to_document_freqs_.count(word)>0 &&
  110.                  word_to_document_freqs_.at(word).count(document_id)>0 &&
  111.                  count(match.begin(),match.end(),word)==0 )
  112.                      match.push_back(word);
  113.             }    
  114.         sort(match.begin(), match.end());
  115.         return tuple(match, documents_.at(document_id).status);
  116.     }
  117.  
  118. private:
  119.     struct DocumentData {
  120.         int rating;
  121.         DocumentStatus status;
  122.     };
  123.  
  124.     set<string> stop_words_;
  125.     map<string, map<int, double>> word_to_document_freqs_;
  126.     map<int, DocumentData> documents_;
  127.  
  128.     bool IsStopWord(const string& word) const {
  129.         return stop_words_.count(word) > 0;
  130.     }
  131.  
  132.     vector<string> SplitIntoWordsNoStop(const string& text) const {
  133.         vector<string> words;
  134.         for (const string& word : SplitIntoWords(text)) {
  135.             if (!IsStopWord(word)) {
  136.                 words.push_back(word);
  137.             }
  138.         }
  139.         return words;
  140.     }
  141.  
  142.     static int ComputeAverageRating(const vector<int>& ratings) {
  143.         if (ratings.empty()) {
  144.             return 0;
  145.         }
  146.         int rating_sum = 0;
  147.         for (const int rating : ratings) {
  148.             rating_sum += rating;
  149.         }
  150.         return rating_sum / static_cast<int>(ratings.size());
  151.     }
  152.  
  153.     struct QueryWord {
  154.         string data;
  155.         bool is_minus;
  156.         bool is_stop;
  157.     };
  158.  
  159.     QueryWord ParseQueryWord(string text) const {
  160.         bool is_minus = false;
  161.         // Word shouldn't be empty
  162.         if (text[0] == '-') {
  163.             is_minus = true;
  164.             text = text.substr(1);
  165.         }
  166.         return {text, is_minus, IsStopWord(text)};
  167.     }
  168.  
  169.     struct Query {
  170.         set<string> plus_words;
  171.         set<string> minus_words;
  172.     };
  173.  
  174.     Query ParseQuery(const string& text) const {
  175.         Query query;
  176.         for (const string& word : SplitIntoWords(text)) {
  177.             const QueryWord query_word = ParseQueryWord(word);
  178.             if (!query_word.is_stop) {
  179.                 if (query_word.is_minus) {
  180.                     query.minus_words.insert(query_word.data);
  181.                 } else {
  182.                     query.plus_words.insert(query_word.data);
  183.                 }
  184.             }
  185.         }
  186.         return query;
  187.     }
  188.  
  189.     // Existence required
  190.     double ComputeWordInverseDocumentFreq(const string& word) const {
  191.         return log(documents_.size() * 1.0 / word_to_document_freqs_.at(word).size());
  192.     }
  193.  
  194.     vector<Document> FindAllDocuments(const Query& query, DocumentStatus status) const {
  195.         map<int, double> document_to_relevance;
  196.         for (const string& word : query.plus_words) {
  197.             if (word_to_document_freqs_.count(word) == 0) {
  198.                 continue;
  199.             }
  200.             const double inverse_document_freq = ComputeWordInverseDocumentFreq(word);
  201.             for (const auto [document_id, term_freq] : word_to_document_freqs_.at(word)) {
  202.                 if (documents_.at(document_id).status == status) {
  203.                     document_to_relevance[document_id] += term_freq * inverse_document_freq;
  204.                 }
  205.             }
  206.         }
  207.  
  208.         for (const string& word : query.minus_words) {
  209.             if (word_to_document_freqs_.count(word) == 0) {
  210.                 continue;
  211.             }
  212.             for (const auto [document_id, _] : word_to_document_freqs_.at(word)) {
  213.                 document_to_relevance.erase(document_id);
  214.             }
  215.         }
  216.  
  217.         vector<Document> matched_documents;
  218.         for (const auto [document_id, relevance] : document_to_relevance) {
  219.             matched_documents.push_back(
  220.                 {document_id, relevance, documents_.at(document_id).rating});
  221.         }
  222.         return matched_documents;
  223.     }
  224. };
  225. void PrintDocument(const Document& document) {
  226.     cout << "{ "s
  227.          << "document_id = "s << document.id << ", "s
  228.          << "relevance = "s << document.relevance << ", "s
  229.          << "rating = "s << document.rating
  230.          << " }"s << endl;
  231. }
  232. int main() {
  233.     SearchServer search_server;
  234.     search_server.SetStopWords("и в на"s);
  235.     search_server.AddDocument(0, "белый кот и модный ошейник"s,        DocumentStatus::ACTUAL, {8, -3});
  236.     search_server.AddDocument(1, "пушистый кот пушистый хвост"s,       DocumentStatus::ACTUAL, {7, 2, 7});
  237.     search_server.AddDocument(2, "ухоженный пёс выразительные глаза"s, DocumentStatus::ACTUAL, {5, -12, 2, 1});
  238.     for (const Document& document : search_server.FindTopDocuments("ухоженный кот"s)) {
  239.         PrintDocument(document);
  240.     }
  241. }
Advertisement
Add Comment
Please, Sign In to add comment