.vscode/launch.json

@@ -8,7 +8,7 @@
         "type": "cppdbg",
         "request": "launch",
         "program": "${workspaceRoot}/build/tipplektionen",
-        "args": ["--min-length", "2", "--max-length", "6", "-c", "ctienrsgul", "--capital"],
+        "args": ["--min-length", "2", "--max-length", "6", "-c", "ctienrsg"],
         "cwd": "${workspaceRoot}",
     }]
 }

README.md

@@ -29,15 +29,11 @@ Die Option `-h` listet alle Möglichkeiten auf:
 ```
 Erlaubte Optionen:
   -h [ --help ]           Ausgabe der Hilfe
-  -c [ --characters ] arg  Erlaubte Buchstaben
+  -c [ --characters ] arg Enthaltene Buchstaben
-  -m [ --must-have ] arg   Buchstaben, die im Wort vorhanden sein *müssen* 
-                           (nur in Verbindung mit --characters; Buchstaben 
-                           müssen davon Subset sein.)
   --min-length arg        Minimale Wortlänge
   --max-length arg        Maximale Wortlänge
   --line-length arg       Maximale Zeilenlänge
   -n [ --num-lines ] arg  Anzahl Zeilen
+  --lowercase             Ausgabe nur klein geschrieben
   -d [ --dictfile ] arg   Pfad zur Wörterbuchdatei
-  -l [ --lowercase ]       Ausgabe nur klein geschrieben
-  -s [ --starts-capital ]  Wort muss mit einem Großbuchstaben beginnen
 ```

main.cpp

@@ -16,66 +16,39 @@ namespace po = boost::program_options;
 
 int main(int argc, char *argv[])
 {
-    icu::UnicodeString letters;
+    std::string letters;
-    icu::UnicodeString mustHaveLetters;
     int wordLengthMin{1};
     int wordLengthMax{1024};
     int lineLength{60};
     int numLines{4};
     std::string wordsFile{"/usr/share/dict/ngerman"};
     bool lowercase{false};
-    bool startsCapital{false};
 
     po::options_description desc("Erlaubte Optionen");
     desc.add_options()("help,h", "Ausgabe der Hilfe")(
-        "characters,c", po::value<icu::UnicodeString>(&letters), "Erlaubte Buchstaben")(
+        "characters,c", po::value<std::string>(&letters), "Enthaltene Buchstaben")(
-        "must-have,m", po::value<icu::UnicodeString>(&mustHaveLetters),
+        "min-length", po::value<int>(&wordLengthMin),
-        "Buchstaben, die im Wort vorhanden sein *müssen* (nur in Verbindung mit --characters; "
+        "Minimale Wortlänge")("max-length", po::value<int>(&wordLengthMax), "Maximale Wortlänge")(
-        "Buchstaben müssen davon Subset sein.)")("min-length", po::value<int>(&wordLengthMin),
+        "line-length", po::value<int>(&lineLength),
-                                                 "Minimale Wortlänge")(
+        "Maximale Zeilenlänge")("num-lines,n", po::value<int>(&numLines), "Anzahl Zeilen")(
-        "max-length", po::value<int>(&wordLengthMax),
+        "lowercase", po::bool_switch(&lowercase), "Ausgabe nur klein geschrieben")(
-        "Maximale Wortlänge")("line-length", po::value<int>(&lineLength), "Maximale Zeilenlänge")(
+        "dictfile,d", po::value<std::string>(&wordsFile), "Pfad zur Wörterbuchdatei");
-        "num-lines,n", po::value<int>(&numLines), "Anzahl Zeilen")(
-        "dictfile,d", po::value<std::string>(&wordsFile), "Pfad zur Wörterbuchdatei")(
-        "lowercase,l", po::bool_switch(&lowercase),
-        "Ausgabe nur klein geschrieben")("starts-capital,s", po::bool_switch(&startsCapital),
-                                         "Wort muss mit einem Großbuchstaben beginnen");
 
     po::variables_map vm;
-    try {
     po::store(po::parse_command_line(argc, argv, desc), vm);
     po::notify(vm);
-    } catch (po::error &err) {
-        std::cerr << "Fehler beim Verarbeiten der Optionen:\n";
-        std::cerr << err.what() << std::endl;
-        return 1;
-    }
 
     if (vm.contains("help")) {
         std::cout << desc << std::endl;
         return 1;
     }
 
-    if (mustHaveLetters.length() > 0) {
-        for (int i{0}; i < mustHaveLetters.length(); i++) {
-            auto ch = mustHaveLetters.charAt(i);
-            if (letters.indexOf(ch) == -1) {
-                std::cout
-                    << "Die Buchstaben von --must-have müssen ein Subset von --characters sein."
-                    << std::endl;
-                return 1;
-            }
-        }
-    }
-
     std::ifstream infile(wordsFile);
     std::string line;
     icu::UnicodeString uline;
     std::vector<icu::UnicodeString> words;
-    icu::UnicodeString lettersUpper = letters;
+    icu::UnicodeString ucLetters = icu::UnicodeString::fromUTF8(letters);
-    lettersUpper.toUpper();
+    icu::UnicodeString ucLettersUpper = icu::UnicodeString::fromUTF8(letters).toUpper();
-    icu::UnicodeString mustHaveLettersUpper = mustHaveLetters;
-    mustHaveLettersUpper.toUpper();
     long counter{0};
 
     if (!std::filesystem::exists(wordsFile)) {
@@ -90,30 +63,11 @@ int main(int argc, char *argv[])
         if (length < wordLengthMin || length > wordLengthMax)
             continue;
 
-        if (mustHaveLetters.length() > 0) {
+        if (ucLetters.length() > 0) {
             bool valid = true;
-            for (int i{0}; i < mustHaveLetters.length(); i++) {
+            for (int i{0}; i < uline.length(); i++) {
-                auto ch = mustHaveLetters.charAt(i);
-                auto chU = mustHaveLettersUpper.charAt(i);
-                if (uline.indexOf(ch) == -1 && uline.indexOf(chU) == -1) {
-                    valid = false;
-                    break;
-                }
-            }
-            if (!valid)
-                continue;
-        }
-
-        if (letters.length() > 0) {
-            bool valid = true;
-            for (int i{0}; i < length; i++) {
                 auto ch = uline.charAt(i);
-                if (startsCapital && i == 0) {
+                if (ucLetters.indexOf(ch) == -1 && ucLettersUpper.indexOf(ch) == -1) {
-                    if (lettersUpper.indexOf(ch) == -1) {
-                        valid = false;
-                        break;
-                    }
-                } else if (letters.indexOf(ch) == -1 && lettersUpper.indexOf(ch) == -1) {
                     valid = false;
                     break;
                 }
@@ -129,17 +83,11 @@ int main(int argc, char *argv[])
         counter++;
     }
 
-    if (counter == 0) {
-        std::cout << "Keine Wörter mit den angegebenen Kriterien gefunden." << std::endl;
-        return 0;
-    }
-
     std::cout << "Anzahl infrage kommender Wörter: " << counter << "\n" << std::endl;
 
     std::random_device rdev;
     std::mt19937 rng(rdev());
     std::uniform_int_distribution<std::mt19937::result_type> distrib(0, words.size() - 1);
-
     for (int i{0}; i < numLines; i++) {
         icu::UnicodeString lectionLine;
         while (lectionLine.length() < lineLength) {