zoukankan      html  css  js  c++  java
  • cs11_c++_lab7

    wcount.cc

      1 #include <iostream>
      2 #include <map>
      3 #include <string>
      4 #include <algorithm>
      5 #include <ctype.h>
      6 // So we don't have to type "std::" everywhere...
      7 using namespace std;
      8 
      9 
     10 string processWord(string &word);
     11 void processText(map<string, int>& wordCounts);
     12 void outputWordsByCount(map<string, int>& wordCounts);
     13 
     14 unsigned total = 0;
     15 
     16 int main()
     17 {
     18   map<string, int> wordCounts;
     19 
     20   
     21 
     22   // Process the text on console-input, using the skip-list.
     23   processText(wordCounts);
     24 
     25     cout << "Total words are " << total << endl;
     26     cout << "unique words are " << wordCounts.size() <<endl;
     27 
     28   // Finally, output the word-list and the associated counts.
     29   outputWordsByCount(wordCounts);
     30 }
     31 
     32 
     33 /*
     34  * This helper-function converts a word to all lower-case, and then removes
     35  * any leading and/or trailing punctuation.
     36  *
     37  * Parameters:
     38  *   word    The word to process.  It is passed by-value so that it can be
     39  *           manipulated within the function without affecting the caller.
     40  *
     41  * Return value:
     42  *   The word after all leading and trailing punctuation have been removed.
     43  *   Of course, if the word is entirely punctuation (e.g. "--") then the result
     44  *   may be an empty string object (containing "").
     45  */
     46 string processWord(string &word)
     47 {
     48   /*****************************************/
     49   /* TODO:  Your implementation goes here! */
     50   /*****************************************/
     51     
     52     for(int i = 0;i < word.length(); i++)
     53     {
     54         if(isalpha(word[i]))
     55         {
     56             word[i] = tolower(word[i]);
     57         }
     58     }
     59 
     60     int j = 0;
     61     for(; j < word.length(); j++)
     62     {
     63         if(isalpha(word[j]) || isdigit(word[j]))
     64             break;
     65     }
     66 
     67     int k = word.length()-1;
     68     for(; k >= 0; k--)
     69     {
     70         if(isalpha(word[k]) || isdigit(word[k]))
     71             break;
     72     }
     73     total++;
     74     if(j > k)
     75     {
     76         return "";
     77     }
     78     else
     79     {
     80         return word.substr(j, k-j+1);
     81     }
     82 }
     83 
     84 
     85 void processText(map<string, int>& wordCounts)
     86 {
     87   /*****************************************/
     88   /* TODO:  Your implementation goes here! */
     89   /*****************************************/
     90 
     91     string word;
     92     while(cin >> word)
     93     {
     94         string new_word = processWord(word);
     95         cout<<new_word<<endl;//log        
     96 
     97         if(new_word.length() > 0)
     98         {
     99             wordCounts[new_word]++;
    100         }
    101     }
    102 
    103 /*    for(auto i = wordCounts.begin(); i != wordCounts.end(); i++)
    104     {
    105         cout << i->first << "   " << i->second << endl;
    106     }
    107 */
    108 }
    109 
    110 
    111 /*
    112  * This helper-function outputs the generated word-list in descending order
    113  * of count.  The function uses an STL associative container to sort the words
    114  * by how many times they appear.  Because multiple words can have the same
    115  * counts, a multimap is used.
    116  */
    117 void outputWordsByCount(map<string, int>& wordCounts)
    118 {
    119   multimap<int, string, greater<int> > sortByCount;
    120   map<string, int>::const_iterator wIter;
    121 
    122   for (wIter = wordCounts.begin(); wIter != wordCounts.end(); wIter++)
    123     sortByCount.insert(pair<int, string>(wIter->second, wIter->first));
    124 
    125   multimap<int, string>::const_iterator cIter;
    126   for (cIter = sortByCount.begin(); cIter != sortByCount.end(); cIter++)
    127     cout << cIter->second << "	" << cIter->first << endl;
    128 }
    View Code

    swcount.cc

      1 #include <iostream>
      2 #include <map>
      3 #include <set>
      4 #include <string>
      5 
      6 
      7 // So we don't have to type "std::" everywhere...
      8 using namespace std;
      9 
     10 
     11 void initSkipList(set<string>& skipList);
     12 string processWord(string word);
     13 void processText(set<string>& skipList, map<string, int>& wordCounts);
     14 void outputWordsByCount(map<string, int>& wordCounts);
     15 
     16 int total = 0;
     17 int skipped = 0;
     18 
     19 int main()
     20 {
     21   set<string> skipList;
     22   map<string, int> wordCounts;
     23 
     24   // Initialize the skip-list.
     25   initSkipList(skipList);
     26 
     27   // Process the text on console-input, using the skip-list.
     28   processText(skipList, wordCounts);
     29 
     30     cout << "Total words are------------ " << total << endl;
     31     cout << "unique words are------------ " << wordCounts.size() << endl;
     32     cout << "skipped words are------------ " << skipped << endl;
     33 
     34   // Finally, output the word-list and the associated counts.
     35   outputWordsByCount(wordCounts);
     36 }
     37 
     38 
     39 /*
     40  * This function initializes the skip-list of words.
     41  *
     42  * skipList = the set of words to skip
     43  */
     44 void initSkipList(set<string>& skipList)
     45 {
     46   // Use a pre-specified skip-list.
     47 
     48   const char *swords[] = {
     49     "a", "all", "am", "an", "and", "are", "as", "at",
     50     "be", "been", "but", "by",
     51     "did", "do",
     52     "for", "from",
     53     "had", "has", "have", "he", "her", "hers", "him", "his",
     54     "i", "if", "in", "into", "is", "it", "its",
     55     "me", "my",
     56     "not",
     57     "of", "on", "or",
     58     "so",
     59     "that", "the", "their", "them", "they", "this", "to",
     60     "up", "us",
     61     "was", "we", "what", "who", "why", "will", "with",
     62     "you", "your",
     63     0
     64   };
     65 
     66   for (int i = 0; swords[i] != 0; i++)
     67     skipList.insert(string(swords[i]));
     68 }
     69 
     70 
     71 /*
     72  * This helper-function converts a word to all lower-case, and then removes
     73  * any leading and/or trailing punctuation.
     74  *
     75  * Parameters:
     76  *   word    The word to process.  It is passed by-value so that it can be
     77  *           manipulated within the function without affecting the caller.
     78  *
     79  * Return value:
     80  *   The word after all leading and trailing punctuation have been removed.
     81  *   Of course, if the word is entirely punctuation (e.g. "--") then the result
     82  *   may be an empty string object (containing "").
     83  */
     84 string processWord(string word)
     85 {
     86   /*****************************************/
     87   /* TODO:  Your implementation goes here! */
     88   /*****************************************/
     89 
     90     for(int i = 0;i < word.length(); i++)
     91     {
     92         if(isalpha(word[i]))
     93         {
     94             word[i] = tolower(word[i]);
     95         }
     96     }
     97 
     98     int j = 0;
     99     for(; j < word.length(); j++)
    100      {
    101          if(isalpha(word[j]) || isdigit(word[j]))
    102             break;
    103      }
    104 
    105     int k = word.length()-1;
    106     for(; k >= 0; k--)
    107     {
    108         if(isalpha(word[k]) || isdigit(word[k]))
    109             break;
    110     }
    111  
    112     if(j > k)
    113     {
    114         return "";
    115     }
    116     else
    117     {
    118         total++;    
    119         return word.substr(j, k-j+1);
    120     }
    121 
    122 }
    123 
    124 void processText(set<string>& skipList, map<string, int>& wordCounts)
    125 {
    126   /***********************************/
    127   /* TODO:  Implement this function! */
    128   /***********************************/
    129 
    130     string word;
    131     while(cin >> word)
    132     {
    133         string new_word = processWord(word);    
    134 
    135          if(new_word.length() > 0)
    136          {
    137             if(skipList.find(new_word) == skipList.end())
    138                 wordCounts[new_word]++;
    139             else
    140                 skipped++;
    141          }
    142     }
    143 }
    144 
    145 
    146 /*
    147  * This helper-function outputs the generated word-list in descending order
    148  * of count.  The function uses an STL associative container to sort the words
    149  * by how many times they appear.  Because multiple words can have the same
    150  * counts, a multimap is used.
    151  */
    152 void outputWordsByCount(map<string, int>& wordCounts)
    153 {
    154   multimap<int, string, greater<int> > sortByCount;
    155   map<string, int>::const_iterator wIter;
    156 
    157   for (wIter = wordCounts.begin(); wIter != wordCounts.end(); wIter++)
    158     sortByCount.insert(pair<int, string>(wIter->second, wIter->first));
    159 
    160   multimap<int, string>::const_iterator cIter;
    161   for (cIter = sortByCount.begin(); cIter != sortByCount.end(); cIter++)
    162     cout << cIter->second << "	" << cIter->first << endl;
    163 }
    View Code
  • 相关阅读:
    Hdu 5396 Expression (区间Dp)
    Lightoj 1174
    codeforces 570 D. Tree Requests (dfs)
    codeforces 570 E. Pig and Palindromes (DP)
    Hdu 5385 The path
    Hdu 5384 Danganronpa (AC自动机模板)
    Hdu 5372 Segment Game (树状数组)
    Hdu 5379 Mahjong tree (dfs + 组合数)
    Hdu 5371 Hotaru's problem (manacher+枚举)
    Face The Right Way---hdu3276(开关问题)
  • 原文地址:https://www.cnblogs.com/amdb/p/4470444.html
Copyright © 2011-2022 走看看