[cionci]

Posto ormai il mio, fa cacare, lo so, ma ormai l'avevo fatto con un'altra idea in testa (che il numero di estratti per ruota non potesse variare). Comunque l'ho adattato al numero variabile di estratto ed ho trovato un modo molto carino (grazie al C++) per generare le combinazioni semplici dei numeri, spero interessi a qualcuno

#include <iostream>
#include <fstream>
#include <map>
#include <list>
#include <string>
#include <vector>
#include <iomanip>

using namespace std;

#define DATAFILENAME    "LottoDataDifficile.txt"
#define SEARCHFILENAME  "LottoFindDifficile.txt"


void parseNumberString(const string &numbers, vector<int> &unsortedNumbers)
{
    unsigned int i = 0;
    int items = 0;
    while(i < numbers.size())
    {
        if(numbers[i] >= '0' && numbers[i] <= '9')
        {
            unsortedNumbers.push_back(numbers[i] - '0');
            if(numbers[i+1] >= '0' && numbers[i+1] <= '9')
            {
                ++i;
                unsortedNumbers.at(items) = unsortedNumbers.at(items) * 10 + (numbers[i] - '0');
            }
            ++items;
        }
        ++i;
    }
}

class Drawing
{
    vector<int> sortedNumbers;
    const string city;
    const string date;
    const string numbers;


public:
    Drawing(const string &city, const string &date, const string &numbers): city(city), date(date), numbers(numbers)
    {
        parseNumberString(numbers, sortedNumbers);

        sort(sortedNumbers.begin(), sortedNumbers.end());
    }

    const string & getCity()
    {
        return city;
    }

    const string & getDate()
    {
        return date;
    }

    const string & getNumbersString()
    {
        return numbers;
    }

    const vector<int> & getNumbersVector()
    {
        return sortedNumbers;
    }
};


class SimpleCombination
{
    unsigned int count;
    vector<int> markers;
    vector<int> values;
    bool hasNextCombination;

public:
    SimpleCombination(const vector<int> &values, unsigned int count): count(count), values(values)
    {
        for(unsigned int i = 0; i < values.size(); ++i)
        {
            markers.push_back((i < count) ? 1 : 0);
        }

        next_permutation(markers.begin(), markers.end());
        hasNextCombination = true;
    }

    bool hasNext()
    {
        return hasNextCombination;
    }

    void nextCombination(vector<int> & combination)
    {
        combination.resize(values.size());
        for(unsigned int i = 0; i < values.size(); i++)
        {
            combination.at(i) = values.at(i) * markers.at(i);
        }
        hasNextCombination = next_permutation(markers.begin(), markers.end());
    }
};

//#define INDEXTYPE long
#define INDEXTYPE double


class Database
{
    map<INDEXTYPE, list<Drawing *> > drawings;
    int numberCount;

    INDEXTYPE computeIndex(const vector<int> v)
    {
        INDEXTYPE index = 0;
        INDEXTYPE multiplier = 1;
        for(unsigned int i = 0; i < v.size(); i++)
        {
            if(v.at(i) > 0)
            {
                index += v.at(i) * multiplier;
                multiplier *= 100;
            }
        }

        return index;
    }

public:
    Database(int numberCount): numberCount(numberCount)
    {
    }

    void insertDrawing(Drawing *drawing)
    {
        for(int i = 1; i <= numberCount; ++i)
        {
            SimpleCombination sc(drawing->getNumbersVector(), i);
            do
            {
                vector<int> combination;
                sc.nextCombination(combination);
                drawings[computeIndex(combination)].push_back(drawing);
            }
            while(sc.hasNext());
        }
    }

    list<Drawing *> & findDrawing(const string &numbers)
    {
        vector<int> sortedNumbers;
        parseNumberString(numbers, sortedNumbers);

        sort(sortedNumbers.begin(), sortedNumbers.end());

        return drawings[computeIndex(sortedNumbers)];
    }
};


int main()
{
    ifstream f(DATAFILENAME);

    string date, city, numbers;

    if(f.fail()) return 1;

    getline(f, numbers);
    getline(f, numbers, ' ');

    int numberCount;
    f >> numberCount;

    if(f.fail()) return 1;
    Database db(numberCount);

    getline(f, numbers);

    while(1)
    {
        getline(f, date, ' ');
        if(f.eof() || f.fail()) break;
        getline(f, city, ' ');
        getline(f, numbers);
        Drawing * d = new Drawing(city, date, numbers);
        db.insertDrawing(d);
    }

    f.close();

    f.open(SEARCHFILENAME);

    if(f.fail()) return 1;

    int count;
    getline(f, date, ' ');
    f >> count;
    getline(f, numbers);
    for(int i = 0; i < count; ++i)
    {
        getline(f, numbers);
        list<Drawing *> &l = db.findDrawing(numbers);

        if(l.size() <= 0) continue;

        cout << "-- " << numbers << " --" << endl;

        for(list<Drawing *>::iterator it = l.begin(); it != l.end(); it++)
        {
            cout  << (*it)->getDate() << " " << (*it)->getCity() << " " <<  (*it)->getNumbersString() << endl;
        }
    }
    return 0;
}