shushus

Спринт 2. Возврат нескольких значений из функции.

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