logik/solver.hpp

#pragma once
#include <vector>
#include <iostream>

using std::vector;
using std::cout;

struct Game {
	int N, M;
	// Table of NxM saying which position can hold which color
	vector<vector<bool>> possible;
	Game(int p_N, int p_M) : N(p_N), M(p_M) {
		possible = vector<vector<bool>>(N, vector<bool>(M, 1));
	}

	// Learning functions
	void cannot_be(int n, int col) {
		possible[n][col] = false;
	}
	void must_be(int must_n, int col) {
		for(int n = 0; n < N; n++)
			if(n != must_n)
				possible[n][col] = 0;
	}
	void empty_color(int col) {
		for(int n = 0; n < N; n++)
			possible[n][col] = 0;
	}

	// Checking
	int final_color(int n) {
		int final_col, count = 0;
		for(int col = 0; col < M; col++)
			if(possible[n][col]) {
				final_col = col;
				count++;
			}

		if(count == 1)
			return final_col;
		return -1;
	}
	
	// Print known information
	void print() {
		cout << " ";
		for(int col = 0; col < M; col++)
			cout << col;
		cout << std::endl;
		for(int i = 0; i < N; i++) {
			cout << i;
			for(auto col : possible[i])
				cout << col;
			cout << std::endl;;
		}
	}
};

// For remembering guesses with their responses
struct Historic_guess {
	vector<int> guess, response;
	Historic_guess(vector<int> p_guess, vector<int> p_response) {
		guess = p_guess;
		response = p_response;
	}
};

class Solver {
	Game known;
	vector<Historic_guess> history = {};
	vector<int> sequence;
public:
	Solver(int p_N, int p_M) : known({p_N, p_M}) {
		sequence = vector<int>(p_N, -1);
	}
	vector<int> guess() {
		// TODO
		return {};
	}

	// Specific reactions
	void if_not_here_then_nowhere(vector<int> guess) {
		// Get all positions of these colors
		auto positions_of_colors = vector<vector<int>>(known.M, vector<int>(0));
		for(int n = 0; n < known.N; n++)
			positions_of_colors[guess[n]].push_back(n);

		// If color can't be anywhere here, it can't be in the sequence
		for(int col = 0; col < known.M; col++) {
			int possible_count = 0;
			for(int n : positions_of_colors[col])
				if(known.possible[n][col])
					possible_count++;
			if(possible_count == 0 && positions_of_colors[col].size() > 0)
				known.empty_color(col);
		}
	}
	void not_here(vector<int> guess) {
		for(int n = 0; n < known.N; n++)
			known.cannot_be(n, guess[n]);
	}
	void empty(vector<int> guess) {
		for(int col : guess)
			known.empty_color(col);
	}

	bool learn_back(Historic_guess hist) {
		bool something_to_learn = true;
		// TODO
		return something_to_learn;
	}
	void learn(vector<int> guess, vector<int> response) {
		bool something_to_learn;
		// None of these colors are there
		if(response[0] == 0 && response[1] == 0) {
			empty(guess);
			something_to_learn = false;
		}

		// None at the right spot
		else if(response[1] == 0) {
			not_here(guess);
			something_to_learn = false;
		}

		// At least only on the right spot
		else if(response[0] == 0) {
			if_not_here_then_nowhere(guess);
			something_to_learn = true;
		}

		// TODO nonzero / nonzero
		else {
			something_to_learn = true;
		}

		// Learn from previous guesses
		for(int i = 0; i < history.size(); i++)
			if(!learn_back(history[i])) {
				// If there is nothing left to learn from the guess
				history.erase(history.begin()+i);
				i--;
			}


		// Write to history
		if(something_to_learn)
			history.push_back({guess, response});
	}
	void print() {
		known.print();
	}
};