#include <iostream>
#include <algorithm>
#include <array>
#include <utility>
#include <random>
#include <set>

class Sudoku
{

    using Board = std::array<std::array<int, 9>, 9>;
    
public:

    Sudoku() : board { } { generate(); }
    Sudoku(Board board) : board { std::move(board) } { }

    /*
    // Alternativ 1:
    bool is_solved()
    {
	for ( size_t i { 0 }; i < 9; ++i ) {
	    std::set<int> blocks  { };
	    std::set<int> rows    { };
	    std::set<int> columns { };
	    for ( size_t j { 0 }; j < 9; ++j ) {
		int const hor { (i / 3) * 3 + (j / 3) };
		int const ver { (i % 3) * 3 + (j % 3) };
		rows.insert(board[i][j]);
		columns.insert(board[j][i]);
		blocks.insert(board[hor][ver]);
	    }
	    if ( check_set(blocks) || check_set(rows) || check_set(columns) )
		return false;
	}
	return true;
    }

    bool check_set(std::set<int> const & available) {
        return available.find(0) != std::end(available) || available.size() != 9;
    }
    // end of Alternativ 1
    */
    
    // Alternativ 2
    bool is_solved() const
    {
	// rows
	for ( auto & row : board ) {
	    std::set<int> available { std::begin(row), std::end(row) };
	    if ( available.find(0) != std::end(available) || available.size() != 9 ) {
	        return false;
	    }
	}

	// columns
	for ( std::size_t column { 0 }; column < 9u; ++column ) {
	    std::set<int> available { };
	    std::transform(std::begin(board), std::end(board),
			   std::inserter(available, std::begin(available)),
			   [column](auto const & row) { return row[column]; });
	    if ( available.find(0) != std::end(available) || available.size() != 9 ) {
	        return false;
	    }
	}

	// blocks
	for ( std::size_t horizontal { 0 }; horizontal < 3u; ++horizontal ) {
	    for ( std::size_t vertical { 0 }; vertical < 3u; ++vertical ) {
		std::set<int> available { };
	        for ( std::size_t column { 0 }; column < 3u; ++column ) {
		    for ( std::size_t rows { 0 }; rows < 3u; ++rows ) {
			available.insert(board[vertical * 3u + rows][horizontal * 3u + column]);
		    }
		}
		if ( available.find(0) != std::end(available) || available.size() != 9 ) {
		    return false;
		}
	    }
	}
	
	return true;
    }
    // end of alternativ 2.
    
    void set(int column, int row, int value)
    { board[row][column] = value; }
    
    int  get(int column, int row) const
    { return board[row][column]; }
    
private:
    
    void generate()
    {
	std::random_device rd;
        for ( auto & row : board ) {
            std::generate(
                    std::begin(row), std::end(row),
                    [&rd]
                    {
                        std::uniform_int_distribution<int> dist { 0, 9 };
                        return dist(rd);
                    });
        }
    }

    Board board { };

};

using namespace std;

int main()
{
    using row = array<int, 9>;
    Sudoku s {
        array<row, 9> {
            row { 4, 7, 8, 6, 2, 5, 9, 3, 1 },
            row { 5, 2, 1, 3, 9, 8, 4, 7, 6 },
            row { 9, 6, 3, 7, 1, 4, 8, 2, 5 },
            row { 3, 8, 5, 2, 6, 9, 7, 1, 4 },
            row { 2, 4, 6, 1, 8, 7, 5, 9, 3 },
            row { 1, 9, 7, 5, 4, 3, 2, 6, 8 },
            row { 6, 5, 2, 4, 7, 1, 3, 8, 9 },
            row { 8, 1, 4, 9, 3, 2, 6, 5, 7 },
            row { 7, 3, 9, 8, 5, 6, 1, 4, 2 }
        }
    };

    if ( s.is_solved() )
    {
        cout << "Rätt lösning" << endl;
    }
    else
    {
        cout << "Felaktig kontroll!" << endl;
    }
}