Алгоритм игры Быки -коровы в С++

#include <iostream>
#include <fstream>
#include <ctime>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <iterator>
#include <string>
 
void prm(std::vector<std::vector<int> >& pr){
    std::vector<int> a(4);
 
    for(int i = 0; i < 4; ++i) a[i] = i;
    int k = 3, p = k;
    int n = 9;
    while(p >= 0){
        pr.push_back(a);
        while(std::next_permutation(a.begin(), a.end())){
            pr.push_back(a);
 
        }
 
        if(a[k] == n) --p; else p = k;
        if(p >= 0){
            for(int i = k; i >= p; --i){
                a[i] = a[p] + i - p + 1;
            }
        }
    }
 
    return;
}
 
 
class gen{
public:
    gen(int n):next(n){}
    int operator()(){return next++;}
private:
    int next;
};
 
/// если одна корова 0.1
void cow(std::vector<std::vector<int> >& pr, int j){
 
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        for(int k = 0; k < 4; ++k){
            //std::cout << pr[j][k] <<" " << pr[i][k];
            if(pr[j][k] == pr[i][k]){
                pr[i][0] = -1;
                break;
            }
        }
    }
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(std::find(pr[i].begin(), pr[i].end(), pr[j][k]) != pr[i].end()){
                f = true;
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][t]) != pr[i].end()){
                        pr[i][0] = -1;
                        break;
                    }
                }
            }
        }
        if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
//0.2
void cow_2(std::vector<std::vector<int> >& pr, int j){
 
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        for(int k = 0; k < 4; ++k){
            //std::cout << pr[j][k] <<" " << pr[i][k];
            if(pr[j][k] == pr[i][k]){
                pr[i][0] = -1;
                break;
            }if(i == j) continue;
        }
    }
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(std::find(pr[i].begin(), pr[i].end(), pr[j][k]) != pr[i].end()){
                f = true;
                bool f_1 = false;
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][t]) != pr[i].end()){
                        f_1 = true;
                        for(int q = 0; q < 4; ++q){
                            if(q == k || q == t) continue;
                            if(std::find(pr[i].begin(), pr[i].end(), pr[j][q]) != pr[i].end()){
                                pr[i][0] = -1;
                            }
                        }
                    }
                }
                if(!f_1) pr[i][0] = -1;
            }
        }
        if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
// 1.1
void bull_and_cow(std::vector<std::vector<int> >& pr, int j){
 
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(pr[j][k] == pr[i][k]){
                f = true;
                bool f_1 = false;
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    for(int l = 0; l < 4; ++l){
                        if(pr[i][l] == pr[j][t] && t != l){
                            f_1 = true;
                            for(int q = 0; q < 4; ++q){
                                if(q == t || q == k) continue;
                                if(std::find(pr[i].begin(), pr[i].end(), pr[j][q]) != pr[i].end()){
                                    pr[i][0] = -1;
                                }
                            }
                        }
                    }
 
                }
                if(!f_1) pr[i][0] = -1;
            }
        }
        if(!f) pr[i][0] = -1;
    }
 
    pr[j][0] = -1;
 
    return;
}
//1.0
void bull_1(std::vector<std::vector<int> >& pr, int j){
 
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(pr[j][k] == pr[i][k]){
                f = true;
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][t]) != pr[i].end()){
                        pr[i][0] = -1;
                        break;
                    }
                }
 
            }
        }
        if(!f) pr[i][0] = -1;
    }
 
    pr[j][0] = -1;
 
    return;
}
//0.0
void null(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
            if(pr[i][0] < 0) continue;
            bool f = false;
            for(int k = 0; k < 4; ++k){
                if(f) break;
                for(int t = 0; t < 4; ++t){
                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][k]) != pr[i].end()){
                        pr[i][0] = -1;
                        f = true;
                        break;
                    }
                }
            }
 
 
    }
    pr[j][0] = -1;
    return;
}
 
//0.3
void cow_3(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        for(int k = 0; k < 4; ++k){
            //std::cout << pr[j][k] <<" " << pr[i][k];
            if(pr[j][k] == pr[i][k]){
                pr[i][0] = -1;
                break;
            }
        }
    }
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(std::find(pr[i].begin(), pr[i].end(), pr[j][k]) != pr[i].end()){
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][t]) != pr[i].end()){
                        for(int q = 0; q < 4; ++q){
                            if(q == k || q == t) continue;
                            if(std::find(pr[i].begin(), pr[i].end(), pr[j][q]) != pr[i].end()){
 
                                for(int l = 0; l < 4; ++l){
                                    if(l == k || l == q || l == t) continue;
                                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][l]) == pr[i].end()){
                                        f = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
 
//1.2
 
void bull_and_cow_2(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(pr[i][k] == pr[j][k]){
                f = true;
                bool f_1 = false;
                bool f_2 = false;
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    for(int m = 0; m < 4; ++m){
                        if(pr[j][t] == pr[i][m] && t != m){
                            f_1 = true;
                            for(int l = 0; l < 4; ++l){
                                if(l == k || l == t) continue;
                                for(int p = 0; p < 4; ++p){
                                    if(pr[j][l] == pr[i][p] && p != l){
                                        f_2 = true;
                                        for(int y = 0; y < 4; ++y){
                                            if(y == k || y == t || y == l) continue;
                                            if(std::find(pr[i].begin(), pr[i].end(), pr[j][y]) != pr[i].end()){
                                                pr[i][0] = -1;
                                                break;
                                            }
 
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if(!f_1 || !f_2) pr[i][0] = -1;
            }
        }
        if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
 
 
void bull_2(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        bool f_1 = false;
        for(int k = 0; k < 4; ++k){
            if(pr[i][k] == pr[j][k]){
                f = true;
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    if(pr[i][t] == pr[j][t]){
                        f_1 = true;
                        for(int p = 0; p < 4; ++p){
                            if(p == t || p == k) continue;
                            if(std::find(pr[i].begin(), pr[i].end(), pr[j][p]) != pr[i].end())
                                pr[i][0] = -1;
                        }
                    }
                }
            }
        }
        if(!f || !f_1) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
 
void bull_2_and_cow(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(pr[i][k] == pr[j][k]){
                for(int p = 0; p < 4; ++p){
                    if(p == k) continue;
                    if(pr[i][p] == pr[j][p]){
                        for(int l = 0; l < 4; ++l){
                            if(l == p || l == k) continue;
                            for(int w = 0; w < 4; ++w){
                                if(pr[j][l] == pr[i][w] && w != l){
                                    for(int m = 0; m < 4; ++m){
                                        if(m == k || m == p || m == l) continue;
                                        if(std::find(pr[i].begin(), pr[i].end(), pr[j][m]) == pr[i].end())
                                            f = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
//3.0
void bull_3(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(pr[i][k] == pr[j][k]){
                for(int t  = 0; t < 4; ++t){
                    if(t == k) continue;
                    if(pr[i][t] == pr[j][t]){
                        for(int p = 0; p < 4; ++p){
                            if(p == t || p == k) continue;
                            if(pr[i][p] == pr[j][p]){
                                for(int l = 0; l < 4; ++l){
                                    if(l == p || l == k || l == t) continue;
                                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][l]) == pr[i].end()) f = true;
                                }
                            }
                        }
                    }
                }
            }
        }
    if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
 
//0.3
 
void cow_4(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        for(int k = 0; k < 4; ++k){
            //std::cout << pr[j][k] <<" " << pr[i][k];
            if(pr[j][k] == pr[i][k]){
                pr[i][0] = -1;
                break;
            }
        }
    }
 
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int t = 0; t < 4; ++t){
            if(std::find(pr[i].begin(), pr[i].end(), pr[j][t]) != pr[i].end()){
                for(int p = 0; p < 4; ++p){
                    if(p == t) continue;
                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][p]) != pr[i].end()){
                        for(int z = 0; z < 4; ++z){
                            if  (z == p || z == t) continue;
                            if(std::find(pr[i].begin(), pr[i].end(), pr[j][z]) != pr[i].end()){
                                for(int q = 0; q < 4; ++q){
                                    if(q == z || q == p || q == t) continue;
                                    if(std::find(pr[i].begin(), pr[i].end(), pr[j][q]) != pr[i].end())
                                        f = true;
                                }
                            }
                        }
                    }
                }
            }
        }
        if(!f) pr[i][0] = -1;
    }
 
    pr[j][0] = -1;
    return;
}
 
//1.3
void bull_1_and_cow_3(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(pr[i][k] == pr[j][k]){
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    for(int a = 0; a < 4; ++a){
                        if(pr[i][a] == pr[j][t] && t != a){
                            for(int q = 0; q < 4; ++q){
                                if(q == t || q == k) continue;
                                for(int l = 0; l < 4; ++l){
                                    if(pr[i][l] == pr[j][q] && q != l){
                                        for(int m = 0; m < 4; ++m){
                                            if(m == q || m == t || m == k) continue;
                                            for(int s = 0; s < 4; ++s){
                                                if(pr[i][s] == pr[j][m] && m != s){
                                                    f = true;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
 
 
//2.2
void bull_2_cow_2(std::vector<std::vector<int> >& pr, int j){
    for(int i = 0; i < (int)pr.size(); ++i){
        if(i == j) continue;
        if(pr[i][0] < 0) continue;
        bool f = false;
        for(int k = 0; k < 4; ++k){
            if(pr[i][k] == pr[j][k]){
                for(int t = 0; t < 4; ++t){
                    if(t == k) continue;
                    if(pr[i][t] == pr[j][t]){
                        for(int m = 0; m < 4; ++m){
                            if(m == t || m == k) continue;
                            for(int l = 0; l < 4; ++l){
                                if(pr[i][l] == pr[j][m] && m != l){
                                    for(int q = 0; q < 4; ++q){
                                        if(q == m || q == k || q == t) continue;
                                        for(int g = 0; g < 4; ++g){
                                            if(pr[i][g] == pr[j][q] && q != g){
                                                f = true;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if(!f) pr[i][0] = -1;
    }
    pr[j][0] = -1;
    return;
}
 
int f(std::vector<std::vector<int> >& pr){
    for(int i = 0; i < (int)pr.size(); ++i)
        if(pr[i][0] >= 0) return i;
    return -1;
}
int main(){
    std::ofstream out("pr.out");
    std::srand(time(0));
    std::vector<int> shuf(10);
    std::generate(shuf.begin(), shuf.end(), gen(0));
    std::random_shuffle(shuf.begin(), shuf.end());
    std::vector<int> pl_1(shuf.begin(), shuf.begin() + 4);
//  std::copy(pl_1.begin(), pl_1.end(), std::ostream_iterator<int>(std::cout, " "));
    std::vector<std::vector<int> > pr;
    prm(pr);
 
    std::string pl;
    int j;
    while(23){
        j = f(pr);
        std::cout << "answer machine: ";
        for(int i = 0; i < 4; ++i){
            std::cout << pr[j][i];
        }
        std::cout << std::endl;
        std::cout << "<<<<<<<<<<<<<<<<" << std::endl;
        std::cout << "player: ";
        int b, c;
        char ch;
        std::cin >> b >> ch >> c >> ch;
        b = b * 10 + c;
        switch(b){
        case 1: //0b1c
            cow(pr, j);
            break;
        case 2: //"0b2c"
            cow_2(pr, j);
            break;
        case 11: //"1b1c"
            bull_and_cow(pr, j);
            break;
        case 10:  //1b0c"
            bull_1(pr, j);
            break;
        case 0:   //"0b0c"
            null(pr, j);
            break;
        case 3: //"0b3c"
            cow_3(pr, j);
            break;
        case 12://"1b2c"
            bull_and_cow_2(pr, j);
            break;
        case 20: //"2b0c"
            bull_2(pr, j);
            break;
        case 21://"2b1c"
            bull_2_and_cow(pr, j);
            break;
        case 30: //"3b0c"
            bull_3(pr, j);
            break;
        case 4://"0b4c"
            cow_4(pr, j);
            break;
        case 13: //"1b3c"
            bull_1_and_cow_3(pr, j);
            break;
        case 22://"2b2c"
            bull_2_cow_2(pr, j);
            break;
        case 40: //"4b0c"
            std::cout << '\n';
            std::cout << "WIN!!" << std::endl;
            return 0;
            break;
        }
        std::cin.ignore();
        std::cin.clear();
    }
 
 
 
    //for(int i = 0; i < (int)pr.size(); ++i){
    //  for(int j = 0; j < (int)pr[i].size(); ++j){
    //      if(pr[i][0] >= 0)
    //          out << pr[i][j];
    //  }
    //  if(pr[i][0] >= 0)
    //      out << " "<< i << '\n';
    //}
 
    return 0;
}

#include <iostream>
#include <cstring>
#include <limits>
 
using namespace std;
 
void Split(int x, int& a, int& b, int& c, int& d)
{
    d = x % 10; x /= 10;
    c = x % 10; x /= 10;
    b = x % 10; x /= 10;
    a = x % 10;
}
 
bool IsValid(int x)
{
    int a, b, c, d;
    Split(x, a, b, c, d);
    return
        (a >= 1) && (a <= 9) &&
        (a != b) && (a != c) && (a != d) && (b != c) && (b != d) && (c != d);
}
 
bool Matches(int n1, int n2, int bulls, int cows)
{
    int a1, b1, c1, d1, a2, b2, c2, d2;
    Split(n1, a1, b1, c1, d1);
    Split(n2, a2, b2, c2, d2);
    return
        bulls == (
            (a1 == a2) + (b1 == b2) + (c1 == c2) + (d1 == d2)
        ) &&
        cows == (
            (a1 == b2) + (a1 == c2) + (a1 == d2) +
            (b1 == a2) + (b1 == c2) + (b1 == d2) +
            (c1 == a2) + (c1 == b2) + (c1 == d2) +
            (d1 == a2) + (d1 == b2) + (d1 == c2)
        );
}
 
const int setSize = 10000;
bool badNum[setSize];
 
int main()
{
    memset(badNum, 0, sizeof(badNum));
    for (int i = 0; i < setSize; i++)
        badNum[i] = !IsValid(i);
    while (true)
    {
        int bulls, cows;
        int question;
        for (question = 0; question < setSize && badNum[question]; question++);
        if (question >= setSize)
        {
            cout << "bye 8-|";
            break;
        }
        cout << question << " ???" << endl;
        cout << "bulls, cows: ";
        cin >> bulls >> cows;
        if (bulls == 4 && cows == 0)
        {
            cout << "that's it :-)";
            break;
        }
        for (int i = 0; i < setSize; i++)
            badNum[i] = badNum[i] || !Matches(i, question, bulls, cows);
    }
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
}

 bulls == (
                        (a1 == a2) + (b1 == b2) + (c1 == c2) + (d1 == d2)
                ) &&
                cows == (
                        (a1 == b2) + (a1 == c2) + (a1 == d2) +
                        (b1 == a2) + (b1 == c2) + (b1 == d2) +
                        (c1 == a2) + (c1 == b2) + (c1 == d2) +
                        (d1 == a2) + (d1 == b2) + (d1 == c2)
                );