用一维数组模拟10维数组-管理masterMind概率空间

已于 2024-08-04 01:16:59 修改
阅读量105 收藏
点赞数 3
文章标签： 算法 c++ 数据结构 masterMind金蛋母鸡
于 2024-07-31 15:20:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aw344/article/details/140823821
版权


用N进制(N=ap等于 0~16等)
用N进制的方法计算和统计概率空间240802A版：
std::vector<char> probabilitySpace; // 概率空间 请将 probabilitySpace 改为:

private:
    int positions;  // 位置数
    int colors;  // 颜色数
    int size;  // 概率空间大小
    std::vector<int> secret;  // 秘密序列
    char* charProbabilitySpace;  // 概率空间

注意:char* charProbabilitySpace;  // 概率空间

的用法!

// masterMind24CharNDarray240803C.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include <iostream>
#include <vector>
#include <algorithm>
//#include <cmath>

// 处理输入，支持空格、逗号或无分隔符
void processInput(std::string& input, std::vector<int>& result) {
    input.erase(std::remove_if(input.begin(), input.end(), [](char c) { return c == ' ' || c == ','; }), input.end());

    if (!std::all_of(input.begin(), input.end(), ::isdigit)) {
        std::cerr << "输入无效。请输入仅包含数字的字符，中间可以用空格或逗号分隔。" << std::endl;
        return;
    }//if

    for (char c : input) {
        result.push_back(c - '0');
    }// for
}//processInput

// 珠玑妙算游戏类定义
class Mastermind {
public:
    Mastermind(int numPositions, int numColors) : positions(numPositions), colors(numColors) {
        size = static_cast<int>(std::pow(colors, positions));
        charProbabilitySpace = new char[size];
        initializeProbabilitySpace();
    }// Mastermind

    ~Mastermind() {
        delete[] charProbabilitySpace;
    }// ~Mastermind

    // 生成秘密序列
    void generateSecret() {
        secret.resize(positions);
        for (int i = 0; i < positions; ++i) {
            secret[i] = rand() % colors;
            std::cout << secret[i] << "";
        }
        std::cout << std::endl;
    }// generateSecret

    // 获取用户猜测
    void getUserGuess(std::vector<int>& guess) {
        std::cout << "输入您的猜测 (例如：0012 表示一个4位的猜测): ";
        std::string input;
        std::cin >> input;

        if (input.length() != positions || !std::all_of(input.begin(), input.end(), ::isdigit)) {
            std::cerr << "输入无效。请确保输入正好有 " << positions << " 位数字 (0-9) 且不包含其他字符。" << std::endl;
            getUserGuess(guess);
            return;
        }

        guess.clear();
        for (char c : input) {
            int digit = c - '0';
            if (digit >= 0 && digit < colors) {
                guess.push_back(digit);
            }
            else {
                std::cerr << "输入无效。每位数字必须在 0 和 " << colors - 1 << " 之间。" << std::endl;
                getUserGuess(guess);
                return;
            }// if
        }// for
    }// getUserGuess

    // 提示结构体定义
    struct HintStruct {
        int black;  // 位置和颜色都正确的个数
        int white;  // 颜色正确但位置不对的个数
    };

    // 评估用户猜测
    HintStruct evaluateGuess(const std::vector<int>& guess) {
        HintStruct hint = { 0, 0 };
        std::vector<bool> secretMatched(positions, false);
        std::vector<bool> guessMatched(positions, false);

        for (int i = 0; i < positions; ++i) {
            if (guess[i] == secret[i]) {
                hint.black++;
                secretMatched[i] = true;
                guessMatched[i] = true;
            }// if  
        }// for

        for (int i = 0; i < positions; ++i) {
            if (!guessMatched[i]) {
                for (int j = 0; j < positions; ++j) {
                    if (!secretMatched[j] && guess[i] == secret[j]) {
                        hint.white++;
                        secretMatched[j] = true;
                        break;
                    }// 
                }// for
            }// if
        }// for

        return hint;
    }//evaluateGuess

    // 评估概率
    HintStruct evaluateProbability(const std::vector<int>& candidate, const std::vector<int>& guess) {
        HintStruct hint = { 0, 0 };
        std::vector<bool> candidateMatched(positions, false);
        std::vector<bool> guessMatched(positions, false);

        for (int i = 0; i < positions; ++i) {
            if (candidate[i] == guess[i]) {
                hint.black++;
                candidateMatched[i] = true;
                guessMatched[i] = true;
            }//if
        }//for

        for (int i = 0; i < positions; ++i) {
            if (!guessMatched[i]) {
                for (int j = 0; j < positions; ++j) {
                    if (!candidateMatched[j] && guess[i] == candidate[j]) {
                        hint.white++;
                        candidateMatched[j] = true;
                        break;
                    }//if
                }//for  
            }//if
        }//for

        return hint;
    }//evaluateProbability

    // 初始化概率空间
    void initializeProbabilitySpace() {
        for (int i = 0; i < size; ++i) {
            charProbabilitySpace[i] = 1;
        }
    }

    // 更新概率空间
    void updateProbabilitySpace(const std::vector<int>& guess, const HintStruct& hint) {
        HintStruct candidateHint;
        for (int i = 0; i < size; ++i) {
            if ( 1==charProbabilitySpace[i] ) {
                std::vector<int> candidate = decode(i);
                candidateHint = evaluateProbability(candidate, guess);
                if (candidateHint.black != hint.black || candidateHint.white != hint.white) {
                    charProbabilitySpace[i] = 0;
                    if(0== i%100000)//显示进度,提示每100000个显示一个点,方便查看程序是否在运行
                    {
                    	printf("%d ",i);
                    }
                }//if
            }//if(1==charProbabilitySpace[i]
            if(0== i%100000)
			{
                printf(".");
			}
        }//for
    }//updateProbabilitySpace

    // 返回剩余的可能性数量
    int remainingPossibilities() const {
        return std::count(charProbabilitySpace, charProbabilitySpace + size, 1);
    }

    // 检查是否解决
    bool isSolved(const HintStruct& hint) const {
        return hint.black == positions;
    }

private:
    int positions;  // 位置数
    int colors;  // 颜色数
    int size;  // 概率空间大小
    std::vector<int> secret;  // 秘密序列
    char* charProbabilitySpace;  // 概率空间

    // 解码索引为序列
    std::vector<int> decode(int index) const {
        std::vector<int> result(positions);
        for (int i = positions - 1; i >= 0; --i) {
            result[i] = index % colors;
            index /= colors;
        }
        return result;
    }
};

int main() {
    srand(static_cast<unsigned>(time(0)));

    std::cout << "欢迎来到珠玑妙算游戏…请输入位置数和颜色数，用空格分开(比如输入: 6 10 表示6位的10进制数字或10种颜色做6位全排列,最大支持9 10,当输入10 10内存可能溢出): ";
    int positions, colors;
    std::cin >> positions >> colors;

    Mastermind game(positions, colors);
    game.generateSecret();

    std::vector<int> guess(positions);
    while (true) {
        std::cout << "\nL201剩余的可能性: " << game.remainingPossibilities() << std::endl;

        game.getUserGuess(guess);
        Mastermind::HintStruct hint = game.evaluateGuess(guess);
        std::cout << "黑色 peg 数: " << hint.black << ", 白色 peg 数: " << hint.white << std::endl;

        if (game.isSolved(hint)) {
            std::cout << "恭喜！您破解了密码！" << std::endl;
            game.updateProbabilitySpace(guess, hint);
            std::cout << "\nL212剩余的可能性: " << game.remainingPossibilities() << std::endl;
            break;
        }//if

        game.updateProbabilitySpace(guess, hint);
    }//while

    return 0;
}//main

// masterMind24charNDArray240802B.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include <iostream>
#include <vector>
//#include <string>
#include <algorithm>
//#include <ctime>
//#include <cmath>

// 处理输入，支持空格、逗号或无分隔符
void processInput(std::string& input, std::vector<int>& result) {
    input.erase(std::remove_if(input.begin(), input.end(), [](char c) { return c == ' ' || c == ','; }), input.end());

    if (!std::all_of(input.begin(), input.end(), ::isdigit)) {
        std::cerr << "输入无效。请输入仅包含数字的字符，中间可以用空格或逗号分隔。" << std::endl;
        return;
    }

    for (char c : input) {
        result.push_back(c - '0');
    }// for
}// processInput

// 珠玑妙算游戏类定义
class Mastermind {
public:
    Mastermind(int numPositions, int numColors) : positions(numPositions), colors(numColors) {
        initializeProbabilitySpace();
    }// Mastermind

    // 生成秘密序列
    void generateSecret() {
        secret.resize(positions);
        for (int i = 0; i < positions; ++i) {
            secret[i] = rand() % colors;
            std::cout << secret[i] << " ";
        }// for
        std::cout << std::endl;
    }// generateSecret

    // 获取用户猜测
    void getUserGuess(std::vector<int>& guess) {
        std::cout << "输入您的猜测 (例如：0012 表示一个4位的猜测): ";
        std::string input;
        std::cin >> input;

        if (input.length() != positions || !std::all_of(input.begin(), input.end(), ::isdigit)) {
            std::cerr << "输入无效。请确保输入正好有 " << positions << " 位数字 (0-9) 且不包含其他字符。" << std::endl;
            getUserGuess(guess);
            return;
        }// if

        guess.clear();
        for (char c : input) {
            int digit = c - '0';
            if (digit >= 0 && digit < colors) {
                guess.push_back(digit);
            }// 
            else 
            {//
                std::cerr << "输入无效。每位数字必须在 0 和 " << colors - 1 << " 之间。" << std::endl;
                getUserGuess(guess);
                return;
            }// if
        }// for
    }// getUserGuess

    // 提示结构体定义
    struct HintStruct {
        int black;  // 位置和颜色都正确的个数
        int white;  // 颜色正确但位置不对的个数
    };

    // 评估用户猜测
    HintStruct evaluateGuess(const std::vector<int>& guess) {
        HintStruct hint = { 0, 0 };
        std::vector<bool> secretMatched(positions, false);
        std::vector<bool> guessMatched(positions, false);

        for (int i = 0; i < positions; ++i) {
            if (guess[i] == secret[i]) {
                hint.black++;
                secretMatched[i] = true;
                guessMatched[i] = true;
            }// if
        }// for_i

        for (int i = 0; i < positions; ++i) {
            if (!guessMatched[i]) {
                for (int j = 0; j < positions; ++j) {
                    if (!secretMatched[j] && guess[i] == secret[j]) {
                        hint.white++;
                        secretMatched[j] = true;
                        break;
                    }// if
                }// for_j
            }// if (!guessMatched[i])
        }// for_i

        return hint;
    }// evaluateGuess

    // 评估概率
    HintStruct evaluateProbability(const std::vector<int>& candidate, const std::vector<int>& guess) {
        HintStruct hint = { 0, 0 };
        std::vector<bool> candidateMatched(positions, false);
        std::vector<bool> guessMatched(positions, false);

        for (int i = 0; i < positions; ++i) {
            if (candidate[i] == guess[i]) {
                hint.black++;
                candidateMatched[i] = true;
                guessMatched[i] = true;
            }// if
        }// for_i

        for (int i = 0; i < positions; ++i) {
            if (!guessMatched[i]) {
                for (int j = 0; j < positions; ++j) {
                    if (!candidateMatched[j] && guess[i] == candidate[j]) {
                        hint.white++;
                        candidateMatched[j] = true;
                        break;
                    }// if
                }// for_j 
            }// if (!guessMatched[i]
        }// for_i

        return hint;
    }// evaluateProbability

    // 初始化概率空间
    void initializeProbabilitySpace() {
        int size = std::pow(colors, positions);
        probabilitySpace.resize(size, 1);
    }

    // 更新概率空间
    void updateProbabilitySpace(const std::vector<int>& guess, const HintStruct& hin0t01) {
        size_t size = probabilitySpace.size();
        HintStruct candidateHint;
        for (size_t i = 0; i < size; ++i) {
            if (1 ==probabilitySpace[i] ) {
                std::vector<int> candidate = decode(i);
            //    HintStruct candidateHint = evaluateProbability(candidate, guess);
                candidateHint = evaluateProbability(candidate, guess);//
                if (candidateHint.black != hin0t01.black || (candidateHint.white != hin0t01.white)  ) {
                    probabilitySpace[i] = 0;
                }// if

                if (0 == i % 10000) {
                    std::cout << "" << i << "]";
                }//
					
            }// if
        }// for
    }// updateProbabilitySpace

    // 返回剩余的可能性数量
    int remainingPossibilities() const {
        return std::count(probabilitySpace.begin(), probabilitySpace.end(), 1);
    }// remainingPossibilities

    // 检查是否解决
    bool isSolved(const HintStruct& hint) const {
        return hint.black == positions;
    }// isSolved

private:
    int positions;  // 位置数
    int colors;  // 颜色数
    std::vector<int> secret;  // 秘密序列
    std::vector<char> probabilitySpace;  // 概率空间

    // 解码索引为序列
    std::vector<int> decode(int index) const {
        std::vector<int> result(positions);
        for (int i = positions - 1; i >= 0; --i) {
            result[i] = index % colors;
            index /= colors;
        }// for
        return result;
    }// decode
};// class Mastermind

int main() {
    srand(static_cast<unsigned>(time(0)));

    std::cout << "欢迎来到珠玑妙算游戏…请输入位置数和颜色数，用空格分开(比如输入: 6[空格]10【回车】表示,6位的10进制数字(或10种颜色做6位全排列): ";
    int positions, colors;
    std::cin >> positions >> colors;

    Mastermind game(positions, colors);
    game.generateSecret();

    std::vector<int> guess(positions);
    while (true) {
        std::cout << "\nL191剩余的可能性: " << game.remainingPossibilities() << std::endl;

        game.getUserGuess(guess);
        Mastermind::HintStruct hint = game.evaluateGuess(guess);
        std::cout << "黑色 peg 数: " << hint.black << ", 白色 peg 数: " << hint.white << std::endl;

        if (game.isSolved(hint)) {
            std::cout << "恭喜！您破解了密码！" << std::endl;
            game.updateProbabilitySpace(guess, hint);
            std::cout << "\nL202剩余的可能性: " << game.remainingPossibilities() << std::endl;
            break;
        }// if

        game.updateProbabilitySpace(guess, hint);
    }// while

    return 0;
}//main



32位的版本
模拟 N 进制， N=1~16等等:

// Probability32DArray4masterMind240720B.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <vector>

class Probability32DArrayClass
{
    int  nP; //nP是进制的位数 number of pawns
    int ap; //P是进制数,比如nP=3则是3进制!ap是每个位的可能取值数,比如ap=3则是3进制! assort pawns
    std::vector<char> PrA;

    unsigned long long getIndex(const std::vector<int>& indices) //indices是每个位的值 //返回index数是:具体的总编号位置
	{
        unsigned long long index = 0;
        unsigned long long multiplier = 1;
        for (int i = 0; i < indices.size(); ++i) {
            index += indices[i] * multiplier;
            multiplier *= ap;
        }
        return index;
    }

    void getIndices(unsigned long long index, std::vector<int>& indices) {
		for (int i = 0; i < nP; ++i) {
			indices[i] = index % ap;
			index /= ap;
		}
	}

	void print_getIndices(std::vector<int> indices )
	{
		for (int i = 0; i < indices.size(); ++i) {
			std::cout << indices[i] << " ";
		}
		std::cout << std::endl;
	}



public:
    Probability32DArrayClass(int numPawns, int assortPawns)
        :nP(numPawns), ap(assortPawns)
    {
        //		initializeSet0(numPawns, assortPawns);

    }//probability16DArrayClass(int numPawns, int assortPawns)

    //--------------------------------------------------------------------------------
    //		probability16DArrayClass::initialize
	void initializeSet0(int nP, int ap, int value0=0)
	{
		this->nP = nP;
		this->ap = ap;

		int arraySize = ap;
		for (int tmpI = 1; tmpI < nP; ++tmpI) {
			arraySize *= ap;
		}//for(int tmpI=1; tmpI<nP; ++tmpI)

		PrA.resize(arraySize, 0); //先全部初始化为0

		//*/
		std::vector<int> indicesTmp;
		for (int p = 0; p < ap; ++p) {
			if ((p > 0) && (nP < 16)) break;
			for (int o = 0; o < ap; ++o) {
				if ((o > 0) && (nP < 15)) break;
				for (int n = 0; n < ap; ++n) {
					if ((n > 0) && (nP < 14)) break;
					for (int m = 0; m < ap; ++m) {
						if ((m > 0) && (nP < 13)) break;
						for (int l = 0; l < ap; ++l) {
							if ((l > 0) && (nP < 12)) break;
							for (int k = 0; k < ap; ++k) {
								if ((k > 0) && (nP < 11)) break;
								for (int j = 0; j < ap; ++j) {
									if ((j > 0) && (nP < 10)) break;
									for (int i = 0; i < ap; ++i) {
										if ((i > 0) && (nP < 9)) break;
										for (int h = 0; h < ap; ++h) {
											if ((h > 0) && (nP < 8)) break;
											for (int g = 0; g < ap; ++g) {
												if ((g > 0) && (nP < 7)) break;
												for (int f = 0; f < ap; ++f) {
													if ((f > 0) && (nP < 6)) break;
													for (int e = 0; e < ap; ++e) {
														if ((e > 0) && (nP < 5)) break;
														for (int d = 0; d < ap; ++d) {
															if ((d > 0) && (nP < 4)) break;
															for (int c = 0; c < ap; ++c) {
																if ((c > 0) && (nP < 3)) break;
																for (int b = 0; b < ap; ++b) {
																	if ((b > 0) && (nP < 2)) break;
																	for (int a = 0; a < ap; ++a) {
																		//PrA[getIndex(p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)] = 0;
																		//
																		indicesTmp.clear();

																		//低位在前,高位在后
																		indicesTmp.push_back(a);
																		if(nP>1) indicesTmp.push_back(b);
																		if(nP>2) indicesTmp.push_back(c);
																		if(nP>3) indicesTmp.push_back(d);
																		if(nP>4) indicesTmp.push_back(e);
																		if(nP>5) indicesTmp.push_back(f);
																		if(nP>6) indicesTmp.push_back(g);
																		if(nP>7) indicesTmp.push_back(h);
																		if(nP>8) indicesTmp.push_back(i);
																		if(nP>9) indicesTmp.push_back(j);
																		if(nP>10) indicesTmp.push_back(k);
																		if(nP>11) indicesTmp.push_back(l);
																		if(nP>12) indicesTmp.push_back(m);
																		if(nP>13) indicesTmp.push_back(n);
																		if(nP>14) indicesTmp.push_back(o);
																		if(nP>15) indicesTmp.push_back(p);


																		print_getIndices(indicesTmp);
//																		PrA[getIndex(indicesTmp)] = value0;
																		//
																	}//for (int a = 0; a < ap; ++a)
																}//for (int b = 0; b < ap; ++b)
															}//for (int c = 0; c < ap; ++c)
														}//for (int d = 0; d < ap; ++d)
													}//for (int e = 0; e < ap; ++e)
												}//for (int f = 0; f < ap; ++f)
											}//for (int g = 0; g < ap; ++g)
										}//for (int h = 0; h < ap; ++h)
									}//for_i
								}//for_j
							}//for_k
						}//for_l
					}//for_m
				}//for_n
			}//for_o
		}//for_p
		//-------------------------------------------------------------------------------------------
		//*/
		//
	}//void initializeSet0(int nP, int ap)
    //------------------------------------------------------------------------------------------------

	void get_Array001(int nP, int ap, const std::vector<int>& indices)
	{
//		std::cout << "indices:" << indices << std::endl;
		print_getIndices(indices);
		//*/
		std::vector<int> indicesTmp;
		for (int p = 0; p < ap; ++p) {
			if ((p > 0) && (nP < 16)) break;
			for (int o = 0; o < ap; ++o) {
				if ((o > 0) && (nP < 15)) break;
				for (int n = 0; n < ap; ++n) {
					if ((n > 0) && (nP < 14)) break;
					for (int m = 0; m < ap; ++m) {
						if ((m > 0) && (nP < 13)) break;
						for (int l = 0; l < ap; ++l) {
							if ((l > 0) && (nP < 12)) break;
							for (int k = 0; k < ap; ++k) {
								if ((k > 0) && (nP < 11)) break;
								for (int j = 0; j < ap; ++j) {
									if ((j > 0) && (nP < 10)) break;
									for (int i = 0; i < ap; ++i) {
										if ((i > 0) && (nP < 9)) break;
										for (int h = 0; h < ap; ++h) {
											if ((h > 0) && (nP < 8)) break;
											for (int g = 0; g < ap; ++g) {
												if ((g > 0) && (nP < 7)) break;
												for (int f = 0; f < ap; ++f) {
													if ((f > 0) && (nP < 6)) break;
													for (int e = 0; e < ap; ++e) {
														if ((e > 0) && (nP < 5)) break;
														for (int d = 0; d < ap; ++d) {
															if ((d > 0) && (nP < 4)) break;
															for (int c = 0; c < ap; ++c) {
																if ((c > 0) && (nP < 3)) break;
																for (int b = 0; b < ap; ++b) {
																	if ((b > 0) && (nP < 2)) break;
																	for (int a = 0; a < ap; ++a) {
																		//PrA[getIndex(p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)] = 0;
																		//
																		indicesTmp.clear();

																		//低位在前,高位在后
																		indicesTmp.push_back(a);
																		if (nP > 1) indicesTmp.push_back(b);
																		if (nP > 2) indicesTmp.push_back(c);
																		if (nP > 3) indicesTmp.push_back(d);
																		if (nP > 4) indicesTmp.push_back(e);
																		if (nP > 5) indicesTmp.push_back(f);
																		if (nP > 6) indicesTmp.push_back(g);
																		if (nP > 7) indicesTmp.push_back(h);
																		if (nP > 8) indicesTmp.push_back(i);
																		if (nP > 9) indicesTmp.push_back(j);
																		if (nP > 10) indicesTmp.push_back(k);
																		if (nP > 11) indicesTmp.push_back(l);
																		if (nP > 12) indicesTmp.push_back(m);
																		if (nP > 13) indicesTmp.push_back(n);
																		if (nP > 14) indicesTmp.push_back(o);
																		if (nP > 15) indicesTmp.push_back(p);


																		
																	//	PrA[getIndex(indicesTmp)] = value0;
																		
																		for(int i=0; i<indices.size(); ++i)
																		{
																			if (indicesTmp[i] != indices[i])
																				goto Labe550;
																		}
																		printf("indicesTmp==indices\n");
																		print_getIndices(indicesTmp);
																		goto L990End;
																	
																		//
																	}//for (int a = 0; a < ap; ++a)
																Labe550:
																	;
																}//for (int b = 0; b < ap; ++b)
															}//for (int c = 0; c < ap; ++c)
														}//for (int d = 0; d < ap; ++d)
													}//for (int e = 0; e < ap; ++e)
												}//for (int f = 0; f < ap; ++f)
											}//for (int g = 0; g < ap; ++g)
										}//for (int h = 0; h < ap; ++h)
									}//for_i
								}//for_j
							}//for_k
						}//for_l
					}//for_m
				}//for_n
			}//for_o
		}//for_p

	L990End:
		;

		//-------------------------------------------------------------------------------------------
		//*/
		//
	}//void get_initializeSet0(int nP, int ap)
	//------------------------------------------------------------------------------------------------

};

int main()
{
	Probability32DArrayClass AA01(4, 6);
	AA01.initializeSet0(5, 3, 1);

	AA01.get_Array001(5, 3, { 0,0,1,0,1 });

    std::cout << "Hello World!\n";
}//

// Probability16DArray4masterMind240710A.cpp : 此文件包含 "main" 函数
#include <iostream>
#include <vector>

class Probability16DArrayClass
{
	std::vector<char> PrA;
	int nP; //numPawns;
	int ap; //assortPawns;//几?进制//有多少种颜色(的棋子

	//int getIndex( 16   15     14      13      12     11   10      9      8      7      6      5      4      3      2      1      0)   
	unsigned long long getIndex(int p, int o, int n, int m, int l, int k, int j, int i, int h, int g, int f, int e, int d, int c, int b, int a)
	{
	  //return (p * 15 * 14 * 13 * 12 * 11 * 10 * 09 * 08 * 07 * 06 * 05 * 04 * 03 * 02 * 01
		return (p * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap +
			o * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap +
			n * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap +
			m * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap +
			l * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap +
			k * ap * ap * ap * ap * ap * ap * ap * ap * ap * ap +
			j * ap * ap * ap * ap * ap * ap * ap * ap * ap +
			i * ap * ap * ap * ap * ap * ap * ap * ap +
			h * ap * ap * ap * ap * ap * ap * ap +
			g * ap * ap * ap * ap * ap * ap +
			f * ap * ap * ap * ap * ap +
			e * ap * ap * ap * ap +
			d * ap * ap * ap +
			c * ap * ap +
			b * ap +
			a
			);

	}//int getIndex(int p, int o, int n, int m, int l, int k, int j, int i, int h, int g, int f, int e, int d, int c, int b, int a)
	//

public:
	void initializeSet1(int nP, int ap)
	{
		for (int p = 0; p < ap; ++p) {
			if ((p > 0) && (nP < 16)) break;
			for (int o = 0; o < ap; ++o) {
				if ((o > 0) && (nP < 15)) break;
				for (int n = 0; n < ap; ++n) {
					if ((n > 0) && (nP < 14)) break;
					for (int m = 0; m < ap; ++m) {
						if ((m > 0) && (nP < 13)) break;
						for (int l = 0; l < ap; ++l) {
							if ((l > 0) && (nP < 12)) break;
							for (int k = 0; k < ap; ++k) {
								if ((k > 0) && (nP < 11)) break;
								for (int j = 0; j < ap; ++j) {
									if ((j > 0) && (nP < 10)) break;
									for (int i = 0; i < ap; ++i) {
										if ((i > 0) && (nP < 9)) break;
										for (int h = 0; h < ap; ++h) {
											if ((h > 0) && (nP < 8)) break;
											for (int g = 0; g < ap; ++g) {
												if ((g > 0) && (nP < 7)) break;
												for (int f = 0; f < ap; ++f) {
													if ((f > 0) && (nP < 6)) break;
													for (int e = 0; e < ap; ++e) {
														if ((e > 0) && (nP < 5)) break;
														for (int d = 0; d < ap; ++d) {
															if ((d > 0) && (nP < 4)) break;
															for (int c = 0; c < ap; ++c) {
																if ((c > 0) && (nP < 3)) break;
																for (int b = 0; b < ap; ++b) {
																	if ((b > 0) && (nP < 2)) break;
																	for (int a = 0; a < ap; ++a) {
																		PrA[getIndex(p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)] = 1;
																	}//for (int a = 0; a < ap; ++a)
																}//for (int b = 0; b < ap; ++b)
															}//for (int c = 0; c < ap; ++c)
														}//for (int d = 0; d < ap; ++d)
													}//for (int e = 0; e < ap; ++e)
												}//for (int f = 0; f < ap; ++f)
											}//for (int g = 0; g < ap; ++g)
										}//for (int h = 0; h < ap; ++h)
									}//for_i
								}//for_j
							}//for_k
						}//for_l
					}//for_m
				}//for_n
			}//for_o
		}//for_p

		//
	}//void initializeSet1(int nP, int ap)

	void initializeSet0(int nP, int ap)
	{
		this->nP = nP;
		this->ap = ap;
		this->nP = nP;
		this->ap = ap;

		int arraySize = ap;
		for (int tmpI = 1; tmpI < nP; ++tmpI) {
			arraySize *= ap;
		}//for(int tmpI=1; tmpI<nP; ++tmpI)

		PrA.resize(arraySize, 0); //先全部初始化为0

		//*/
		for (int p = 0; p < ap; ++p) {
			if ((p > 0) && (nP < 16)) break;
			for (int o = 0; o < ap; ++o) {
				if ((o > 0) && (nP < 15)) break;
				for (int n = 0; n < ap; ++n) {
					if ((n > 0) && (nP < 14)) break;
					for (int m = 0; m < ap; ++m) {
						if ((m > 0) && (nP < 13)) break;
						for (int l = 0; l < ap; ++l) {
							if ((l > 0) && (nP < 12)) break;
							for (int k = 0; k < ap; ++k) {
								if ((k > 0) && (nP < 11)) break;
								for (int j = 0; j < ap; ++j) {
									if ((j > 0) && (nP < 10)) break;
									for (int i = 0; i < ap; ++i) {
										if ((i > 0) && (nP < 9)) break;
										for (int h = 0; h < ap; ++h) {
											if ((h > 0) && (nP < 8)) break;
											for (int g = 0; g < ap; ++g) {
												if ((g > 0) && (nP < 7)) break;
												for (int f = 0; f < ap; ++f) {
													if ((f > 0) && (nP < 6)) break;
													for (int e = 0; e < ap; ++e) {
														if ((e > 0) && (nP < 5)) break;
														for (int d = 0; d < ap; ++d) {
															if ((d > 0) && (nP < 4)) break;
															for (int c = 0; c < ap; ++c) {
																if ((c > 0) && (nP < 3)) break;
																for (int b = 0; b < ap; ++b) {
																	if ((b > 0) && (nP < 2)) break;
																	for (int a = 0; a < ap; ++a) {
																		PrA[getIndex(p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)] = 0;
																	}//for (int a = 0; a < ap; ++a)
																}//for (int b = 0; b < ap; ++b)
															}//for (int c = 0; c < ap; ++c)
														}//for (int d = 0; d < ap; ++d)
													}//for (int e = 0; e < ap; ++e)
												}//for (int f = 0; f < ap; ++f)
											}//for (int g = 0; g < ap; ++g)
										}//for (int h = 0; h < ap; ++h)
									}//for_i
								}//for_j
							}//for_k
						}//for_l
					}//for_m
				}//for_n
			}//for_o
		}//for_p
		//-------------------------------------------------------------------------------------------
		//*/
		//
	}//void initializeSet0(int nP, int ap)


public:
	void initialize00(int nP, int ap)
	{
		this->nP = nP;
		this->ap = ap;

		int arraySize = ap;
		for (int tmpI = 1; tmpI < nP; ++tmpI) {
			arraySize *= ap;
		}//for(int tmpI=1; tmpI<nP; ++tmpI)

		PrA.resize(arraySize, 0); //先全部初始化为0
//		initialize001(nP, ap);	//再把符合条件的元素置为1

	}//void initialize(int nP, int ap)



	int countTrueElements()
	{
		int count = 0;

		for (int p = 0; p < ap; ++p) {
			if ((p > 0) && (nP < 16)) break;
			for (int o = 0; o < ap; ++o) {
				if ((o > 0) && (nP < 15)) break;
				for (int n = 0; n < ap; ++n) {
					if ((n > 0) && (nP < 14)) break;
					for (int m = 0; m < ap; ++m) {
						if ((m > 0) && (nP < 13)) break;
						for (int l = 0; l < ap; ++l) {
							if ((l > 0) && (nP < 12)) break;
							for (int k = 0; k < ap; ++k) {
								if ((k > 0) && (nP < 11)) break;
								for (int j = 0; j < ap; ++j) {
									if ((j > 0) && (nP < 10)) break;
									for (int i = 0; i < ap; ++i) {
										if ((i > 0) && (nP < 9)) break;
										for (int h = 0; h < ap; ++h) {
											if ((h > 0) && (nP < 8)) break;
											for (int g = 0; g < ap; ++g) {
												if ((g > 0) && (nP < 7)) break;
												for (int f = 0; f < ap; ++f) {
													if ((f > 0) && (nP < 6)) break;
													for (int e = 0; e < ap; ++e) {
														if ((e > 0) && (nP < 5)) break;
														for (int d = 0; d < ap; ++d) {
															if ((d > 0) && (nP < 4)) break;
															for (int c = 0; c < ap; ++c) {
																if ((c > 0) && (nP < 3)) break;
																for (int b = 0; b < ap; ++b) {
																	if ((b > 0) && (nP < 2)) break;
																	for (int a = 0; a < ap; ++a) {
																		if (1 == PrA[getIndex(p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)]) { ++count; }
																	}//01_for (int a = 0; a < ap; ++a)
																}//f02_or (int b = 0; b < ap; ++b)
															}//03_for (int c = 0; c < ap; ++c)
														}//04_for (int d = 0; d < ap; ++d)
													}//05——for (int e = 0; e < ap; ++e)
												}//06——for (int f = 0; f < ap; ++f)
											}//07——for (int g = 0; g < ap; ++g)
										}//08——for (int h = 0; h < ap; ++h)
									}//09——for_i
									//printf("j=%d ", j);
								}//10——for_j
								printf("k=%d", k);
							}//11——for_k
							printf("l=%d\n", l);
						}//12——for_l
						printf("m=%d\n\n", m);
					}//13——for_m
					printf("n=%d\n\n", n);
				}//14——for_n
				printf("o=%d\n\n", o);
			}//15——for_o
			printf("p=%d\n\n", p);
		}//16-for_p


		return count;
		//===========================================================================================

	}

	//================================================================================================

public:
	Probability16DArrayClass(int numPawns, int assortPawns)
		:nP(numPawns), ap(assortPawns)
	{
//		initializeSet0(numPawns, assortPawns);

	}//probability16DArrayClass(int numPawns, int assortPawns)
	//================================================================================================
};


int main()
{
	Probability16DArrayClass AA01(16, 3);
	
	AA01.initializeSet0(10, 3);
	AA01.initializeSet1(9, 2);
	std::cout << "countTrueElement193s=" << AA01.countTrueElements() << std::endl;

	AA01.initializeSet0(15, 4);
	AA01.initializeSet1(14, 3);
	std::cout << "countTrueElement197s=" << AA01.countTrueElements() << std::endl;



}

​
#include <iostream>
#include <vector>
#include <string>

#define MAX_PAWN08S 8
//#define MAX_PAWN09S 9
#define MAX_PAWN10S 10

class HintStruct {
public:
    int numBlacks;
    int numWhites;
    int numBlanks;

    HintStruct() : numBlacks(0), numWhites(0), numBlanks(0) {}

    void set(int blacks, int whites, int blanks) {
        numBlacks = blacks;
        numWhites = whites;
        numBlanks = blanks;
    }

    bool equals(const HintStruct& obj) const { // for unit testing
        return (obj.numBlacks == numBlacks && obj.numWhites == numWhites && obj.numBlanks == numBlanks);
    }

    std::string toString() const {
        return "[" + std::to_string(numBlacks) + ", " + std::to_string(numWhites) + ", " + std::to_string(numBlanks) + "]";
    }
};

class Probability10DArrayClass {
private:
    HintStruct hint;

    int numPawns;
    int assortPawns;
//    std::vector<int> Probability10DArray;
//    std::vector<bool> Probability10DArray;
    std::vector<char> Probability10DArray;

    int getIndex(int j, int i, int h, int g, int f, int e, int d, int c, int b, int a) const {
        int aP = assortPawns;
        return (
            j * aP * aP * aP * aP * aP * aP * aP * aP * aP+
            i * aP * aP * aP * aP * aP * aP * aP * aP +
            h * aP * aP * aP * aP * aP * aP * aP +
            g * aP * aP * aP * aP * aP * aP +
            f * aP * aP * aP * aP * aP +
            e * aP * aP * aP * aP +
            d * aP * aP * aP +
            c * aP * aP +
            b * aP +
            a);
    }

public:
    Probability10DArrayClass(int numPawns, int assortPawns)
        : numPawns(numPawns), assortPawns(assortPawns) {
        initialize(numPawns, assortPawns);
    }

    void setAllElements(int value) {
        std::fill(Probability10DArray.begin(), Probability10DArray.end(), value);
    }

    void initialize001(int numPawns, int assortPawns ) {
    	
        for (int j = 0; j < assortPawns; ++j) {
            if ((j > 0) && (numPawns < 10)) break;
            for (int i = 0; i < assortPawns; ++i) {
                if ((i > 0) && (numPawns < 9)) break;
                for (int h = 0; h < assortPawns; ++h) {
                    if ((numPawns < 8) && (h > 0)) break;
                    for (int g = 0; g < assortPawns; ++g) {
                        if ((numPawns < 7) && (g > 0)) break;
                        for (int f = 0; f < assortPawns; ++f) {
                            if ((numPawns < 6) && (f > 0)) break;
                            for (int e = 0; e < assortPawns; ++e) {
                                if ((numPawns < 5) && (e > 0)) break;
                                for (int d = 0; d < assortPawns; ++d) {
                                    if ((numPawns < 4) && (d > 0)) break;
                                    for (int c = 0; c < assortPawns; ++c) {
                                        if ((numPawns < 3) && (c > 0)) break;
                                        for (int b = 0; b < assortPawns; ++b) {
                                            if ((numPawns < 2) && (b > 0)) break;
                                            for (int a = 0; a < assortPawns; ++a) {
                                                setElement(j, i, h, g, f, e, d, c, b, a, 1);
                                            }//for_a
                                        }//for_b
                                    }
                                }
                            }
                        }
                    }
                }//for_h
                printf("%d", i);
            }//for_i
            printf("[j=%d\n", j);
        }//for_j
    }

    void initialize(int numPawns, int assortPawns) {
        this->numPawns = numPawns;
        this->assortPawns = assortPawns;

        int arraySize = 1;
        for (int tmpI = 0; tmpI < numPawns; ++tmpI) {
            arraySize *= assortPawns;
        }

        Probability10DArray.resize(arraySize, 0);
//        setAllElements(0);

        initialize001(numPawns, assortPawns);


    }//initialize

    int getElement(int j, int i, int h, int g, int f, int e, int d, int c, int b, int a) const {
        int index = getIndex(j, i, h, g, f, e, d, c, b, a);
        if (index >= static_cast<int>(Probability10DArray.size())) 
//            if (index >= static_cast<char>(Probability10DArray.size()))
        {
            std::cerr << "Error123getElement: index out of range: " << index << std::endl;
            return -2;
        }
        return Probability10DArray[index];
    }

    void setElement(int j, int i, int h, int g, int f, int e, int d, int c, int b, int a, int value) {
        int index = getIndex(j, i, h, g, f, e, d, c, b, a);
        if (index >= static_cast<int>(Probability10DArray.size()))
    //        if (index >= static_cast<char>(Probability10DArray.size()))
        {
            std::cerr << "Error135setElement: index out of range: " << index << std::endl;
            return;
        }
        Probability10DArray[index] = value;
    }

    int countTrueElements() const {
        int count = 0;

        for(int j= 0; j < assortPawns; ++j) {
            if((j > 0) && (numPawns < 10)) break;
            
                    for (int i = 0; i < assortPawns; ++i) {
                        if ((i > 0) && (numPawns < 9)) break;
                        for (int h = 0; h < assortPawns; ++h) {
                            if ((numPawns < 8) && (h > 0)) break;
                            for (int g = 0; g < assortPawns; ++g) {
                                if ((numPawns < 7) && (g > 0)) break;
                                for (int f = 0; f < assortPawns; ++f) {
                                    if ((numPawns < 6) && (f > 0)) break;
                                    for (int e = 0; e < assortPawns; ++e) {
                                        if ((numPawns < 5) && (e > 0)) break;
                                        for (int d = 0; d < assortPawns; ++d) {
                                            if ((numPawns < 4) && (d > 0)) break;
                                            for (int c = 0; c < assortPawns; ++c) {
                                                if ((numPawns < 3) && (c > 0)) break;
                                                for (int b = 0; b < assortPawns; ++b) {
                                                    if ((numPawns < 2) && (b > 0)) break;
                                                    for (int a = 0; a < assortPawns; ++a) {
                                                        if (getElement(j, i, h, g, f, e, d, c, b, a) == 1) {
                                                            ++count;
                                                        }//if
                                                    }//for_a
                                                }//for_b
                                            }// for_c
                                            //if(0== count%10) { printf("%d ", count);}
                                        }// for_d
            //                            if(0==count%100) { printf("%d",count);}
                                    }// for_e
                                    if (0 == count % 100) { printf("%d ", count); }
                                }// for_f
                                if (0 == count % 10) { printf("[%d]\n", count); }
                            }// for_g
                            if (0 == count % 1) { printf("H循环%d]]\n\n", count); }
                        }// for_h
                         { printf("I循环%d]]]]}\n\n\n", count); }
                    }// for_i

         }//for_j
        std::cout << "countTrueElements: " << count << std::endl;
        return count;
    }

    int crossOutBlacks(std::vector<int>& secretCopy, std::vector<int>& feelerCopy) {
        int numBlacks = 0;
        for (size_t i = 0; i < feelerCopy.size(); ++i) {
            if (i < secretCopy.size() && feelerCopy[i] == secretCopy[i]) {
                feelerCopy[i] = -1;
                secretCopy[i] = -1;
                numBlacks++;
            }
        }
        return numBlacks;
    }

    int crossOutWhites(std::vector<int>& secretCopy, std::vector<int>& feelerCopy) {
        int numWhites = 0;
        for (size_t i = 0; i < feelerCopy.size(); ++i) {
            if (feelerCopy[i] == -1) continue;
            auto it = std::find(secretCopy.begin(), secretCopy.end(), feelerCopy[i]);
            if (it != secretCopy.end()) {
                feelerCopy[i] = -1;
                *it = -1;
                numWhites++;
            }
        }
        return numWhites;
    }
};

int main() {
    Probability10DArrayClass A01(6, 2);
//    A01.initialize(10, 8 );
    A01.initialize(10, 8);
    A01.countTrueElements();
    return 0;
}//main 

​

aw344
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值