New 02-10-17

main.cpp

#include <iostream>
#include <unordered_set>
#include <random>
#include <fstream>


using Key = std::pair<std::string, std::pair<float, float>>;
namespace std {
    template<>
    class hash<Key> {
    public:
        size_t operator()(const Key& s) const
        {
            size_t h1   = std::hash<string>()(s.first);
            size_t h21  = std::hash<float> ()(s.second.first);
            size_t h22  = std::hash<float> ()(s.second.second);

            return h1 ^ ( (h21 * h22) << 1 );
        }
    };
}



int main(int argc, char* argv[]) {

    int N = atoi(argv[1]);

    std::mt19937_64 generator{std::random_device()()};
    std::uniform_real_distribution<float> distribution(0.0f, 10.0f);

    std::uniform_int_distribution<> intDistribution(1, 20);

    //std::pair<float, float> rating;
    //Key FilmRate;
    std::unordered_multiset<Key> hashTable;  // not INT

    std::ifstream ofs;
    ofs.open ("Films.txt", std::ofstream::in);


    for(int i = 0; i < N; ++i)
    {

        auto cinemaSearch = distribution(generator);
        auto IMDB = distribution(generator);

        auto strSize = intDistribution(generator);
        char* s;

        ofs.getline(s, strSize);
        Key key = std::make_pair(s, std::make_pair(cinemaSearch, IMDB));

       // FilmRate.first = s;
       // rating.first = cinemaSearch;
       // rating.second = IMDB;
       // FilmRate.second = rating;

        //rating   = std::make_pair(cinemaSearch, IMDB);
        //FilmRate = std::make_pair(s, rating);

        hashTable.insert(key);

    }

    int max = 0;

    for (unsigned i = 0; i< hashTable.bucket_count(); ++i)
    {
        if (max < hashTable.bucket_size(i))
            max = hashTable.bucket_size(i);
    }

    std::cout << "max = " << max;
    ofs.close();

    return 0;
}