Merge pull request #13 from spartanPAGE/master

spartanPAGE

Author: spartanPAGE

spartanPAGE/001 - Name Generator - tests/Readme.txt

@@ -0,0 +1,4 @@
+You need catch framework to compile tests.
+Run using this:
+"001 - Name Generator - tests" > result.txt -r xml
+or similar

spartanPAGE/001 - Name Generator - tests/main.cpp

@@ -0,0 +1,27 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+#include "RandomNameGenerator.hpp"
+#include <random>
+
+TEST_CASE("RandomNameGenerator works well without arguments", "[RandomNameGenerator]"){
+    int seed = 5;
+    std::default_random_engine re(5);
+    SECTION("A RandomNameGenerator with \"\" in constructor and 0's in call()"){
+        RandomNameGenerator<> rng(
+            RandomNameGenerator<>::Prefixes{""},
+            RandomNameGenerator<>::Cores{""},
+            RandomNameGenerator<>::Sufixes{""},
+            re
+        );
+        REQUIRE(rng(0, 0)=="");
+    }
+    SECTION("A RandomNameGenerator with empty containers in constructor and 0's in call()"){
+        RandomNameGenerator<> rng(
+            RandomNameGenerator<>::Prefixes{},
+            RandomNameGenerator<>::Cores{},
+            RandomNameGenerator<>::Sufixes{},
+            re
+        );
+        REQUIRE(rng(0, 0)=="");
+    }
+}

spartanPAGE/001 - Name Generator/Readme.txt

@@ -0,0 +1 @@
+If you're looking for tests, they're in the "001 - Name Generator - tests" project

spartanPAGE/001 - Name Generator/include/RandomNameGenerator.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <vector>
+#include <array>
+#include <string>
+#include <random>
+#include <algorithm>
+
+template<typename RandomEngine = std::default_random_engine>
+class RandomNameGenerator{
+    struct DataCorrector{
+        void operator()(RandomNameGenerator *rng){
+            std::for_each(
+                std::begin(rng->_containers),
+                std::end(rng->_containers),
+                [](ContainerType *container){
+                    if(container->empty())
+                        container->push_back("");
+                }
+            );
+        }
+    };
+public:
+    typedef std::vector<std::string> ContainerType;
+    typedef ContainerType Prefixes;
+    typedef ContainerType Cores;
+    typedef ContainerType Sufixes;
+    typedef std::string Result;
+public:
+    RandomNameGenerator(
+        const Prefixes &prefixes,
+        const Cores &cores,
+        const Sufixes &sufixes,
+        RandomEngine &re
+    ): _prefixes(prefixes), _cores(cores), _sufixes(sufixes), _re(re){
+        constructContainersArray();
+        DataCorrector()(this);
+        constructDistros();
+    }
+
+    Result operator()(
+        size_t minCoreRepeats,
+        size_t maxCoreRepeats
+    ){
+        Result result;
+        Distro coreRepeatsDistribution(minCoreRepeats, maxCoreRepeats);
+        result += _prefixes[_distros[PrefixID](_re)];
+
+        size_t coreRepeats = coreRepeatsDistribution(_re);
+        while(coreRepeats--)
+            result += _cores[_distros[CoreID](_re)];
+
+        return result += _sufixes[_distros[SufixID](_re)];
+    }
+private:
+    void constructDistros(){
+        _distros = std::array<Distro, Count>{
+            Distro(0, _prefixes.size()-1),
+            Distro(0, _cores.size()-1),
+            Distro(0, _sufixes.size()-1)
+        };
+    }
+    void constructContainersArray(){
+         _containers = std::array<ContainerType *, Count>{
+             &_prefixes, &_cores, &_sufixes
+        };
+    }
+private:
+    typedef std::uniform_int_distribution<int> Distro;
+    enum{ PrefixID, CoreID, SufixID, Count /* <-- Have to be the last!*/};
+    std::array<Distro, Count> _distros;
+    std::array<ContainerType *, Count> _containers;
+private:
+    Prefixes _prefixes;
+    Cores _cores;
+    Sufixes _sufixes;
+    RandomEngine &_re;
+};

spartanPAGE/001 - Name Generator/src/main.cpp

@@ -0,0 +1,35 @@
+#include "RandomNameGenerator.hpp"
+
+#include <iostream>
+using namespace std;
+
+int main() {
+    default_random_engine dre(5);
+    size_t times, minCores, maxCores;
+    cin >> times >> minCores >> maxCores;
+    RandomNameGenerator<> rng(
+        RandomNameGenerator<>::Prefixes{
+            "Bal", "Ner",
+            "Xerth", "Vorc", "Norm",
+            "Vaz", "Treth", "Melr",
+            "Jatr", "Urugd", "Petr"
+        },
+        RandomNameGenerator<>::Cores{
+            "",
+            "adur", "aes", "anim", "apoll", "imac",
+            "educ", "equis", "extr", "guius", "haun",
+            "equi", "amora", "hum", "iace", "ille",
+            "inept", "iuv", "obe", "ocul", "orbis"
+        },
+        RandomNameGenerator<>::Sufixes{
+            "us", "as", "es", "ex",
+            "aus", "irg", "orex", "or",
+            "ator", "arox", "urh"
+        },
+        dre
+    );
+
+    while(times--)
+        cout << rng(minCores, maxCores) << endl;
+    return 0;
+}