isspam/main.cpp at 611ef8d124395a5573f245cc1201a228a051c326

 #include <string>
 #include <string_view>
 #include <fstream>
 #include <algorithm>
 #include <iostream>
 #include <numeric>
 #include <execution>
 #include <format>
 #include <codecvt>
 #include <ranges>
 #ifdef __cpp_lib_print
 #include <print>
 #else
 namespace std {
     template <typename T, typename... Args>
     inline void print(T format, Args&&... args) {
         auto f = std::vformat(format, std::make_format_args(args...));
         std::cout << f;
     }
     template <typename T, typename... Args>
     inline void println(T format, Args&&... args) {
         auto f = std::vformat(format, std::make_format_args(args...));
         std::cout << f << std::endl;
     }
 }
 #endif
 constexpr std::array<std::wstring_view, 35> BAD_WORDS ={
     L"recovery",
     L"techie",
     L"http",
     L"https",
     L"digital",
     L"hack",
     L"::",
     L"//",
     L"com",
     L"@",
     L"crypto",
     L"bitcoin",
     L"wallet",
     L"hacker",
     L"welcome",
     L"whatsapp",
     L"email",
     L"cryptocurrency",
     L"stolen",
     L"freeze",
     L"quick",
     L"crucial",
     L"tracing",
     L"scammers",
     L"expers",
     L"hire",
     L"century",
     L"transaction",
     L"essential",
     L"managing",
     L"contact",
     L"contacting",
     L"understanding",
     L"assets",
     L"funds",
 };
 constexpr auto SHORTEST_BAD_WORD = std::ranges::fold_left(BAD_WORDS, std::numeric_limits<std::size_t>::max(),
                                                           [](std::size_t current, const std::wstring_view &word) {
                                                               return std::min(current, word.size());
                                                           }
     );
 constexpr auto LONGEST_BAD_WORD = std::ranges::fold_left(BAD_WORDS, std::numeric_limits<std::size_t>::min(),
                                                          [](std::size_t current, const std::wstring_view &word) {
                                                              return std::max(current, word.size());
                                                          }
     );
 struct AnalysisResult {
     std::size_t totalWordCount = 0;
     std::size_t totalCapitalizedCount = 0;
     std::size_t totalSentenceCount = 0;
     std::size_t totalNumberCount = 0;
     std::size_t totalForbiddenCount = 0;
     std::size_t fileCount = 1;
     std::size_t failCount = 0;
     operator std::string() const {
         return std::format(
             "Word Count: {}\nCapitalized Count: {}\nSentence Count: {}\nNumber Count: {}\nForbidden Count: {}\nFile Count: {}\nFail Count: {}",
             totalWordCount, totalCapitalizedCount, totalSentenceCount, totalNumberCount, totalForbiddenCount, fileCount, failCount
             );
     }
     friend AnalysisResult operator+(const AnalysisResult &lhs, const AnalysisResult &rhs) {
         return {
             lhs.totalWordCount + rhs.totalWordCount,
             lhs.totalCapitalizedCount + rhs.totalCapitalizedCount,
             lhs.totalSentenceCount + rhs.totalSentenceCount,
             lhs.totalNumberCount + rhs.totalNumberCount,
             lhs.totalForbiddenCount + rhs.totalForbiddenCount,
             lhs.fileCount + rhs.fileCount,
             lhs.failCount + rhs.failCount
         };
     };
 };
 void check_word(std::wstring& word, std::size_t &forbiddenCount) {
     if (word.size() < SHORTEST_BAD_WORD || word.size() > LONGEST_BAD_WORD) {
         return;
     }
     std::transform(word.begin(), word.end(), word.begin(), ::towlower);
     if (std::ranges::find_if(BAD_WORDS, [&word](const std::wstring_view &badWord) {
         // Case-insensitive check if badword is inside word
             return word.contains(badWord);
     }) != BAD_WORDS.end()) {
         forbiddenCount++;
     }
 }
 AnalysisResult parseFile(const std::string_view &filename) {
     std::wifstream file;
     file.imbue(std::locale(std::locale(), new std::codecvt_utf8<wchar_t>));
     file.open(std::string(filename)); // Modified line
     if (!file.is_open()) {
         std::println("File doesn't exist: {}", filename);
         return { };
     }
     AnalysisResult result{ };
     bool inWord = false;
     bool isDigit = false;
     wchar_t c;
     std::wstring word;
     while (file.get(c)) {
         if (c == '.') {
             result.totalSentenceCount++;
         }
         if (std::isspace(c)) {
             inWord = false;
             isDigit = false;
             if (!word.empty()) {
                 check_word(word, result.totalForbiddenCount);
                 word.clear();
             }
             continue;
         } else {
             if (!inWord) {
                 result.totalWordCount++;
                 if (std::isupper(c)) {
                     result.totalCapitalizedCount++;
                 }
             }
             inWord = true;
             if (std::isdigit(c) && !isDigit) {
                 result.totalNumberCount++;
                 isDigit = true;
             }
             word.push_back(c);
         }
     };
     // std::cout << "File state: " << file.rdstate() << " EOF" << file.eof() << " Fail" << file.fail() << " Bad" << file.bad() << std::endl;
     if (!word.empty()) {
         check_word(word, result.totalForbiddenCount);
     }
     file.close();
     if (file.fail() && !file.eof()) {
         result.failCount++;
     }
     return result;
 }
 int main(const int argc, char *argv[]) {
     if (argc < 2) {
         std::println("Usage: {} <file1> <file2> ... <fileN>", argv[0]);
         return 1;
     }
     const AnalysisResult result = std::transform_reduce(std::execution::par_unseq, std::next(argv), argv + argc, AnalysisResult{ .fileCount = 0 },
                                                         std::plus{ },
                                                         parseFile
         );
     double capitalizedPercentage = (result.totalWordCount > 0)
                                        ? static_cast<double>(result.totalCapitalizedCount) / result.totalWordCount * 100.0
                                        : 0;
     double forbiddenPercentage = (result.totalWordCount > 0)
                                      ? static_cast<double>(result.totalForbiddenCount) / result.totalWordCount * 100.0
                                      : 0;
     double wordCountPerSentence = (result.totalSentenceCount > 0)
                                       ? static_cast<double>(result.totalWordCount) / result.totalSentenceCount
                                       : 0;
     std::println("{}\nCapitalized Percentage: {}%\nForbidden Percentage: {}%\nWord Count Per Sentence: {}", std::string(result),
                  capitalizedPercentage, forbiddenPercentage, wordCountPerSentence
         );
     return 0;
 }

No results found.