The Exact Query Complexity of Yes-No Permutation Mastermind

Abstract

Mastermind is famous two-player game. The first player (codemaker) chooses a secret code which the second player (codebreaker) is supposed to crack within a minimum number of code guesses (queries). Therefore, the codemaker’s duty is to help the codebreaker by providing a well-defined error measure between the secret code and the guessed code after each query. We consider a variant, called Yes-No AB-Mastermind, where both secret code and queries must be repetition-free and the provided information by the codemaker only indicates if a query contains any correct position at all. For this Mastermind version with n positions and $k\ge n$ colors and $\ell :=k+1-n$, we prove a lower bound of ${\sum }_{j=\ell }^k{log}_{2}j$ and an upper bound of $n{log}_{2}n+k$ on the number of queries necessary to break the secret code. For the important case $k=n$, where both secret code and queries represent permutations, our results imply an exact asymptotic complexity of $\mathsf{\Theta }(nlogn)$ queries.

1. Introduction

Mastermind is a popular two-player board game invented by Mordecai Meirowitz and released in 1971 [1,2]. Its idea is that a codemaker chooses a secret code of fixed length n, where each position is selected from a set of k colors. The second player, codebreaker, has to identify the secret code by a finite sequence of corresponding code guesses (queries), each of which is replied with the number of matching positions and the number of further correct colors. The original game is played by picking pegs of $k=6$ different colors and placing them into rows with $n=4$ holes, where the number of rows (allowed queries) for the codebreaker is limited.

Generalizing the situation to arbitrarily many positions and colors, the codemaker selects a vector $y\in {\left[k\right]}^n$ and the codebreaker gives in each iteration a query in form of a vector $x\in {\left[k\right]}^n$. In the original setting, the codemaker’s reply is the so called black-white error measure, consisting of a pair of numbers, where the first number, $\mathrm{black}(x,y)$, is the number of positions in which x and y coincide and the second number, $\mathrm{white}(x,y)$, is the number of additional colors which appear in both x and y, but at different positions. In this paper, we consider a variant, called Yes-No AB-Mastermind, which is defined by the following properties

• Both secret code and queries must be repetition-free. This property is indicated by the prefix AB and stems from the AB game, better known as “Bulls and Cows” (cf. [1]), which was even known prior to the commercial version of Mastermind with color repetitions.
• The provided information by the codemaker only answers the question whether or not a query contains any correct position at all. This property is introduced by us and referred to by the term “Yes-No”.

Related Works: Mastermind and its variants have been analyzed under different aspects. One of the first analyses of the commercial version with $n=4$ positions and $k=6$ colors is by Knuth [3] and shows that each code can be cracked in at most 5 queries. Even before the appearance of Mastermind as a commercial game, Erdős and Rényi [4] analyzed the asymptotic query complexity of a similar problem with two colors in 1963 to be $\mathsf{\Theta }(nlogn)$. After Knuth’s analysis of the commercial game, many different variants of Mastermind with arbitrary code length n and number of colors k have been investigated. For example, Black-Peg Mastermind restricts its error measure between two codes x and y to the single value $\mathrm{black}(x,y)$ (i.e., the exact number of positions where both codes coincide). This version was introduced in 1983 by Chvátal [5] for the case $k=n$, who provides a deterministic adaptive strategy using $2n\lceil {log}_{2}k\rceil +4n$ queries. Improved upper bounds for this variant and arbitrary n and k where given by Goodrich [6] ($n\lceil {log}_{2}k\rceil +\lceil (2-1/k)n\rceil +k$) and later by Jäger and Peczarski [7] ($n\lceil {log}_{2}n\rceil +k$ for $k\le n$ and $n\lceil {log}_{2}n\rceil +k-n+1$ for $k>n$) but remained in the order of $\mathcal{O}\left(n{log}_{2}n\right)$. Doerr et al. [8] provided a randomized codebreaker strategy that only needs $\mathcal{O}(nloglogn)$ queries in expectation and showed that this asymptotic order even holds for up to $n^{2}loglogn$ colors, if both black and white information is allowed. A first upper bound for AB Mastermind was given by Ker-I Ko and Shia-Chung Teng [9] for the case $k=n$, i.e., secret code and queries represent permutations of $\left[n\right]$. Their non-constructive strategy yields an upper bound of $2n{log}_{2}n+7n$ queries. A constructive strategy by El Ouali and Sauerland [10] reduced this upper bound by a factor of almost 2 and also included the case $k>n$ of Black-Peg AB-Mastermind. The term Black-Peg labels the situation that the error measure between secret code and queries is only “black” information, i.e., the number of coinciding positions, while the “white” information (see above) is omitted. El Ouali et al. [11] combined their upper bound of $(n-3)\lceil {log}_{2}n\rceil +\frac{5}{2}n-1$ queries for $k=n$ and $(n-2)\lceil {log}_{2}n\rceil +k+1$) queries for $k>n$ with a lower bound of n queries, which is implied by a codemaker strategy. It improved the lower bound of $n-loglogn$ by Berger et al [12]. However, a gap between $\mathsf{\Omega }\left(n\right)$ and $\mathcal{O}\left(n{log}_{2}n\right)$ remains for this Mastermind variant. Some facts indicate that closing this gap means to improve both bounds. On the one hand, a careful consideration of the partition of the remaining searchspace with respect to all possible codemaker replies might yield a refined codemaker strategy and possibly increase the lower bound. On the other hand, overcoming the sequential learning process of the codebreaker’s binary search strategy might decrease the upper bound. The latter presumption is reinforced by the results of Afshani et al. [13], who consider another permutation-based variant of Mastermind. There, the secret code is a combination of a binary string and a permutation, (both of length n), queries are binary strings of length n, and the error measure returns the number of leading coincidences in the binary string with respect to the order of the permutation. For this setting, which is also a generalization of the popular leading ones test problem in black box optimization, the authors prove an exact asymptotic query complexity of $\mathsf{\Theta }(nlogn)$ for deterministic strategies but a randomized query complexity of $\mathsf{\Theta }(nloglogn)$.

One of the ultimate goals in the analysis of Mastermind variants is to prove the exact asymptotic query complexity. As mentioned above, closing the asymptotic gap between the lower $\mathsf{\Omega }\left(n\right)$ bound and the upper $\mathcal{O}\left(n{log}_{2}n\right)$ bound is an unsolved problem for Black-Peg AB Mastermind. A related open question is whether the same asymptotic number of queries is required for both (Black-Peg) Mastermind with color repetition and (Black-Peg) AB Mastermind.

Our Contribution: We consider a new variant of AB-Mastermind which is more difficult to play for the codebreaker since the error-measure provided by the codemaker is less informative. Here, for a secret code y the answer $\mathrm{info}(\sigma ,y)$ to a query $\sigma$ is “yes” if some of its positions coincide with the secret code, otherwise the answer is “no”. We first analyze the worst-case performance of query strategies for this Mastermind variant and give a lower bound of ${\sum }_{j=\ell }^k{log}_{2}j$ queries for $k\ge n$, which becomes $n{log}_{2}n-n$ in the case $k=n$. The lower bound even holds if the codebreaker is allowed to use repeated colors in his queries. We further present a deterministic polynomial-time algorithm that identifies the secret code. This algorithm is a modification of the constructive strategy of El Ouali et al. [11]. It returns the secret code in at most $(n-3){log}_{2}n+\frac{5}{2}n-1$ queries in the case $k=n$ and in less than $(n-2){log}_{2}n+k+1$ queries in the case $k>n$. For the important case $k=n$, our results imply the exact asymptotic query complexity of $\mathsf{\Theta }\left(n{log}_{2}n\right)$. Since the considered “Yes-No” error measure implies a new variant of AB-Mastermind, there is no previous reference to compare our results to.

2. Results

2.1. Lower Bound on the Number of Queries

To simulate the worst case, we allow the codemaker to “cheat” in a way that after every query he may decide for a new secret code that is still in agreement with all information he gave so far.

Theorem 1.

Let $k,n\in \mathbb{N}$, $k\ge n$ and $\ell :=k+1-n$. Every strategy for Yes-No AB-Mastermind needs at least ${\displaystyle \sum _{j=\ell }^k}{log}_{2}j$ queries in the worst case.

Proof. 

We give a codemaker strategy that implies the lower bound. For $i\in \mathbb{N}$ let $M_i$ denote the set of secrets that are still possible after the i-th query has been answered, starting with $M_0:=\{y\in {\left[k\right]}^n|\forall i\ne j\in \left[n\right]:y_i\ne y_j\}$. Let $M_i^{\mathrm{yes}}\subset M_i$ be the set of secrets that lead to a yes-answer to the $(i+1)$-th query and $M_i^{\mathrm{no}}:=M_i\backslash M_i^{\mathrm{yes}}$ the set of secrets that lead to a no-answer. The strategy of the codemaker in round $i+1$ is as follows:

• If $|M_i^{\mathrm{yes}}|\ge |M_i^{\mathrm{no}}|$, pick a secret from $M_i^{\mathrm{yes}}$ (and give the answer yes)
• Otherwise pick a secret from $M_i^{\mathrm{no}}$ (and give the answer no)

By using this strategy, the codemaker achieves for every round i that

$$|M_i|=|M_i^{\mathrm{yes}}|+|M_i^{\mathrm{no}}|\le 2max(|M_i^{\mathrm{yes}}|,|M_i^{\mathrm{no}}\left|\right)=2|M_{i+1}|.$$

This implies $|M_i|\ge 2^{-i}\left|M_0\right|$. So, for any $i<{log}_2\left(\right|M_0\left|\right)$ we have

$$|M_i|>2^{-{log}_2\left(\right|M_0\left|\right)}\left|M_0\right|=\frac{|M_0|}{|M_0|}=1,$$

which means that there are still at least two possible secrets left. Since

$${log}_2\left(\right|M_0\left|\right)={log}_2\left(\prod _{j=\ell }^{k}j\right)=\sum _{j=\ell }^k{log}_{2}j,$$

we obtain the claimed lower bound.  □

Corollary 1.

Every strategy for Yes-No Permutation-Mastermind (the case $k=n$) needs at least

$$\sum _{j=1}^n{log}_{2}j\ge \frac{nlogn-n}{log2}$$

queries in the worst case.

We also note that the lower bound on the query complexity of Yes-No AB-Mastermind remains of the asymptotic order $nlogn$ if the number of colors is polynomial in the number of positions ($k=P\left(n\right)$, P a polynomial).

2.2. Upper Bound on the Number of Queries

Theorem 2.

Let $k,n\in \mathbb{N}$, $k\ge n$ and $\ell :=k+1-n$. For $k=n$, there is a strategy for Yes-No AB-Mastermind that identifies every secret code in at most $(n-3){log}_{2}n+\frac{5}{2}n-1$ queries and for $k>n$, there is a strategy that identifies every secret code in less than $(n-2){log}_{2}n+k+1$ queries.

Corollary 2.

The exact asymptotic query complexity of Yes-No Permutation-Mastermind is $\mathsf{\Theta }\left(n{log}_{2}n\right)$.

The proof of Theorem 2 resembles the proof of a corresponding result concerning Black-Peg AB-Mastermind [11], except that the information whether a given query contains a correct but unidentified position is not derived directly but requires special querying outlined by Algorithm 1 below. In a nutshell (including both cases $k=n$ and $k>n$), the strategy consists of k distinct initial queries, each of which consists of the first n positions of a circularly shifted version of the vector $(1,2,\dots ,k)$. From the answers of the initial queries, we will be able to learn the secret code position-wise, keeping record about the positions that have already been identified. As long as there are consecutive initial queries a and b with the property that a coincides with the secret code in at least one yet unidentified position but b does not, we can apply a binary search for the next unidentified position in a, using $\mathcal{O}\left({log}_{2}n\right)$ further queries. Such initial queries a and b exist ever after one (usually after zero) but not all positions of the secret code have been identified.

Proof of Theorem 2.

The case $k=n$: We give a constructive strategy that identifies the positions of the secret code $y\in {\left[n\right]}^n$ one-by-one. In order to keep record about identified positions of the secret code we deal with a partial solution vector x that satisfies $x_i\in \{0,y_i\}$ for all $i\in \left[n\right]$. We call the non-zero positions of x fixed and the zero-positions of x open. The fixed positions of x are the identified positions of the secret code. Remember, that for a query $\sigma =({\sigma }_1,\dots ,{\sigma }_n)$ we denote by

$$\mathrm{info}(\sigma ,y):=\left\{\begin{array}{cc}\mathrm{yes}\hfill & \mathrm{if}\{i\in \left[n\right]|{\sigma }_i=y_i\}\ne \varnothing \hfill \\ \mathrm{no}\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

the information if there is some position in which $\sigma$ coincides with the secret code y. For Yes-No AB-Mastermind the related information whether a query $\sigma$ contains a correct but unidentified position cannot always be derived directly but must be obtained by guessing one or two modifications of $\sigma$, rearranging those positions that coincide with the partial solution x. The required query procedure is summarized as Algorithm 1.

Example 1.

Figure 1 illustrates the four distinct cases that are considered by $\mathrm{infoP}$. In the first and easiest case (panel (a)) the actual query σ does not coincide with the partial solution x. Thus, σ contains a correct unidentified position if and only if it contains a correct position at all, i.e., $\mathrm{infoP}(\sigma ,x,y)=\mathrm{info}(\sigma ,y)$. In the second case (panel (b)), σ and x coincide in more than one position, namely the positions with colors 3, 9 and 10. The modified query ρ is obtained from σ by rearranging these positions in a way that all identified positions get a wrong color while leaving all open positions of σ unchanged. This implies that $\mathrm{infoP}(\sigma ,x,y)=\mathrm{info}(\rho ,y)$. Panels (c) and (d) deal with the case that σ and x coincide in exactly one position, say i. If x already contains a further non-zero position j, we obtain ρ from σ by swapping positions i and j in σ (the positions with colors 3 and 5 in panel (c)). Again, we obtain that $\mathrm{infoP}(\sigma ,x,y)=\mathrm{info}(\rho ,y)$. Finally, if position i is the only yet identified position of the secret code we have to ask two different modified queries to derive $\mathrm{infoP}(\sigma ,x,y)$ (panel (d)). We obtain the two queries ${\rho }_1$ and ${\rho }_2$, each by swapping the identified position (here 3) with another position in σ, (here with 1 and 2, respectively). While the color of the identified position is wrong in both modifications ${\rho }_1$ and ${\rho }_2$, every other position of σ coincides with the corresponding position of at least one modification. Therefore, $\mathrm{infoP}(\sigma ,x,y)=\mathrm{no}$ if and only if $\mathrm{info}({\rho }_1,y)=\mathrm{info}({\rho }_2,y)=\mathrm{no}$.

Figure 1. Illustrating the cases considered by $\mathrm{infoP}$. Panel (a): query $\sigma$ does not coincide with the partial solution x; $\mathrm{infoP}(\sigma ,x,y)=\mathrm{info}(\sigma ,y)$. Panel (b): $\sigma$ and x coincide in more than one position; $\rho$ rearranges these positions of $\sigma$; $\mathrm{infoP}(\sigma ,x,y)=\mathrm{info}(\rho ,y)$. Panel (c): $\sigma$ and x coincide in exactly one position i, but more positions are identified already; $\rho$ is obtained from $\sigma$ by swapping position i with another identified position j; $\mathrm{infoP}(\sigma ,x,y)=\mathrm{info}(\rho ,y)$. Panel (d): Exactly one position is identified and appears to be correct in $\sigma$; two modified queries ${\rho }_1$ and ${\rho }_2$ must be defined, each by swapping the identified position with another one; $\mathrm{infoP}(\sigma ,x,y)=\mathrm{no}$ if and only if $\mathrm{info}({\rho }_1,y)=\mathrm{info}({\rho }_2,y)=\mathrm{no}$.

Algorithm 1: Function infoP

The codebreaker strategy that identifies the secret code y has two phases. In the first phase the codebreaker guesses an initial sequence of n queries that has a predefined structure. In the second phase, the structure of the initial sequence and the corresponding information by the codemaker enable us to identify correct positions $y_i$ of the secret code one after another, each by using a binary search. We denote the vector x restricted to the set $\{s,\dots ,\ell \}$ with ${\left(x_i\right)}_{i=s}^{\ell }$, $s,\ell \in \left[n\right]$.

Phase 1 Consider the n queries, ${\sigma }^1,\dots ,{\sigma }^n$, that are defined as follows: ${\sigma }^1$ represents the identity map and for $j\in [n-1]$, we obtain ${\sigma }^{j+1}$ from ${\sigma }^j$ by a circular shift to the right. For example, if $n=4$, we have ${\sigma }^1=(1,2,3,4)$, ${\sigma }^2=(4,1,2,3)$, ${\sigma }^3=(3,4,1,2)$ and ${\sigma }^4=(2,3,4,1)$. The codebreaker guesses ${\sigma }^1,\dots ,{\sigma }^n$.

Phase 2. Now, the codebreaker identifies the values of y one after another, using a binary search procedure, that we call findNext. The idea is to exploit the information that for $1\le i,j\le n-1$ we have ${\sigma }_i^j={\sigma }_{i+1}^{j+1}$, ${\sigma }_i^n={\sigma }_{i+1}^1$, ${\sigma }_n^j={\sigma }_1^{j+1}$ and ${\sigma }_n^n={\sigma }_1^1$. findNext is used to identify the second correct position to the last correct position in the main loop of the algorithm.

After the first position of y has been found and fixed in x, there exists a $j\in \left[n\right]$ such that $\mathrm{infoP}({\sigma }^j,x,y)=\mathrm{no}$. As long as we have open positions in x, we can either find a $j\in [n-1]$ with $\mathrm{infoP}({\sigma }^j,x,y)=\mathrm{yes}$ but $\mathrm{infoP}({\sigma }^{j+1},x,y)=\mathrm{no}$ and set $r:=j+1$, or we have $\mathrm{infoP}({\sigma }^n,x,y)=\mathrm{yes}$ but $\mathrm{infoP}({\sigma }^1,x,y)=\mathrm{no}$ and set $j:=n$ and $r:=1$. We call such an index j an active index. Let j be an active index and r its related index. Let c be the color of some position of y that is already identified and fixed in the partial solution x. With ${\ell }_j$ and ${\ell }_r$ we denote the position of color c in ${\sigma }^j$ and ${\sigma }^r$, respectively. The color c serves as a pivot color for identifying a correct position m in ${\sigma }^j$ that is not fixed, yet. There are two possible modes for the binary search that depend on the fact if $m\le {\ell }_j$. The mode is indicated by a Boolean variable $\mathrm{leftS}$ and determined by lines 5–9 of findNext. Clearly, $m\le {\ell }_j$ if ${\ell }_j=n$. Otherwise, the codebreaker guesses

$${\sigma }^{j,0}:=\left(c,{\left({\sigma }_i^j\right)}_{i=1}^{{\ell }_j-1},{\left({\sigma }_i^j\right)}_{i={\ell }_j+1}^n\right)=\left({\sigma }_{{\ell }_j}^j,{\left({\sigma }_i^j\right)}_{i=1}^{{\ell }_j-1},{\left({\sigma }_i^j\right)}_{i={\ell }_j+1}^n\right).$$

By the information ${\sigma }_i^j={\sigma }_{i+1}^r$ we obtain that ${\left({\sigma }_i^j\right)}_{i=1}^{{\ell }_j-1}\equiv {\left({\sigma }_i^r\right)}_{i=2}^{{\ell }_j}$. We further know that every open color has a wrong position in ${\sigma }^r$. For that reason, $\mathrm{infoP}({\sigma }^{j,0},x,y)=\mathrm{no}$ implies that $m\le {\ell }_j$. The binary search for the exact value of m is done in the interval $[a,b]$, where m is initialized as n and $[a,b]$ as

$$[a,b]:=\left\{\begin{array}{cc}[1,{\ell }_j]\hfill & \mathrm{if}\mathrm{leftS}\hfill \\ {\ell }_r,n]\hfill & \mathrm{else}\hfill \end{array}\right.$$

(lines 10–15 of findNext). In order to determine if there is an open correct position on the left side of the current center ℓ of $[a,b]$ in ${\sigma }^j$ we can define a case dependent query:

$${\sigma }^{j,\ell }:=\left\{\begin{array}{cc}\left({\left({\sigma }_i^j\right)}_{i=1}^{\ell -1},c,{\left({\sigma }_i^r\right)}_{i=\ell +1}^{{\ell }_j},{\left({\sigma }_i^j\right)}_{i={\ell }_j+1}^n\right)\hfill & \mathrm{if}\mathrm{leftS}\hfill \\ \left({\left({\sigma }_i^r\right)}_{i=1}^{{\ell }_r-1},{\left({\sigma }_i^j\right)}_{i={\ell }_r}^{\ell -1},c,{\left({\sigma }_i^r\right)}_{i=\ell +1}^n\right)\hfill & \mathrm{else}\hfill \end{array}\right.$$

In the first case, the first $\ell -1$ positions of ${\sigma }^{j,\ell }$ coincide with those of ${\sigma }^j$. The remaining positions of ${\sigma }^{j,\ell }$ cannot coincide with the corresponding positions of the secret code if they have not been fixed, yet. This is because the ℓ-th position of ${\sigma }^{j,\ell }$ has the already fixed value c, positions $\ell +1$ to ${\ell }_j$ coincide with the corresponding positions of ${\sigma }^r$ which satisfies $\mathrm{infoP}({\sigma }^r,x,y)=\mathrm{no}$ and the remaining positions have been checked to be wrong in this case (cf. former definition of $\mathrm{leftS}$ in line 5 and line 9, respectively). Thus, there is a correct open position on the left side of ℓ in ${\sigma }^j$, if and only if $\mathrm{infoP}({\sigma }^{j,\ell },x,y)=\mathrm{yes}$. In the second case, the same holds for similar arguments. Now, if there is a correct open position to the left of ℓ, we update the binary search interval $[a,b]$ by $[a,\ell -1]$. Otherwise, we update $[a,b]$ by $[\ell ,b]$.

Algorithm 2: Function findNext

Example 2.

Suppose, that for $n=10$ the secret code y and the partial solution x are given as in the top panel of Figure 2 and that we have first identified the position with color 1, such that 1 is our pivot color. The initial 10 queries ${\sigma }^1,\dots ,{\sigma }^{10}$ together with their current $\mathrm{infoP}$ measures are given in the mid panel of Figure 2. We see that the highlighted queries, ${\sigma }^4$ and ${\sigma }^5$, can be used for the binary search with findNext, since ${\sigma }^4$ has a correct not yet identified position but ${\sigma }^5$ has not. So the active indices are $j=4$ and $r=5$ and the corresponding pivot color positions in ${\sigma }^4$ and ${\sigma }^5$ are ${\ell }_j=4$ and ${\ell }_r=5$. The first query of findNext (cf. lower panel of Figure 2) is ${\sigma }^a$. It begins with the pivot color, followed by the first 3 positions of ${\sigma }^4$ (positions 2 to 4 of ${\sigma }^5$) and positions 5 to 10 of ${\sigma }^4$ (cf. line 7 of findNext). Since $\mathrm{infoP}({\sigma }^a,x,y)=\mathrm{yes}$, the left most correct but unidentified position in ${\sigma }^4$ is none of its first 4 positions. Thus, the binary search is continued in the interval $[5,10]$. It is realized by queries ${\sigma }^b$, ${\sigma }^c$, and ${\sigma }^d$, which are composed according to line 20 of findNext (in this case), and finally identifies position 8 with color 5 of the secret code (generally the position left to the left most pivot color position that receives the answer “yes” in the binary search).

Figure 2. Panel (a): secret code y and partial solution vector x. Panel (b): the initial queries ${\sigma }^j$ and their responses $\mathrm{infoP}({\sigma }^j,x,y)$, indicating if a query and the secret code coincide in any position that has not been identified, yet (i.e., in any 0-position of x). Panel (c): binary search queries to identify the next secret position. The highlighted subsequences correspond to the subsequences of the initial queries that have been selected to apply the binary search.

The Main Algorithm. The main algorithm is outlined as Algorithm 3.

It starts with an empty partial solution and finds the positions of the secret code y one-by-one. The vector v keeps record about which of the initial queries ${\sigma }^1,\dots ,{\sigma }^n$ coincides with the secret code y in some open position. Thus, v is initialized by $v_i:=\mathrm{info}({\sigma }^i,y)$, $i\in \left[n\right]$. The main loop always requires an active index. For that reason, if $v_i=\mathrm{yes}$ for all $i\in \left[n\right]$ in the beginning, we first identify the correct position in ${\sigma }^1$ (which is unique in this case) by $\lfloor \frac{n}{2}\rfloor +1$ queries (each swapping two positions of ${\sigma }^1$) and update x and v, correspondingly. After this step, there will always exist an active index. Every call of findNext in the main loop augments x by a correct solution value. One call of findNext requires at most $1+\lceil {log}_{2}n\rceil$ queries if the partial solution x contains more than one non-zero position, and at most $2+2\lceil {log}_{2}n\rceil$ queries (two queries for each call of infoP) if x has exactly one non-zero position. Thus, Algorithm 3 does not need more than $(n-2)\lceil {log}_{2}n\rceil +\frac{5}{2}n-1$ queries to break the secret code inclusive the $n-1$ initial queries, $\lfloor \frac{n}{2}\rfloor +1$ queries to find the first correct position, $n-3$ calls of findNext and 2 final queries.

Algorithm 3: Codebreaker Strategy for Permutations

The case $k>n$: Let $y=(y_1,\dots ,y_n)$ be the code that must be found. We use the same notations as above.

Phase 1. Consider the k queries ${\overline{\sigma }}^1,\dots ,{\overline{\sigma }}^k$, where ${\overline{\sigma }}^1$ represents the identity map on $\left[k\right]$ and for $j\in [k-1]$, we obtain ${\overline{\sigma }}^{j+1}$ from ${\overline{\sigma }}^j$ by a circular shift to the right. We define k codes ${\sigma }^1,\dots ,{\sigma }^k$ by ${\sigma }^j={\left({\overline{\sigma }}_i^j\right)}_{i=1}^n$, $j\in \left[k\right]$. For example, if $k=5$ and $n=3$, we have ${\sigma }^1=(1,2,3)$, ${\sigma }^2=(5,1,2)$, ${\sigma }^3=(4,5,1)$, ${\sigma }^4=(3,4,5)$ and ${\sigma }^5=(2,3,4)$. Within those k codes, every color appears exactly once at every position and, thus, there are at least $k-n$ initial queries that do not contain any correct position. Since $k>n$, this implies

Lemma 1.

There is a $j\in \left[k\right]$ with $\mathrm{info}({\sigma }^j,y)=\mathrm{no}$.

Phase 2. Having more colors than positions, we can perform our binary search for a next correct position without using a pivot color. The corresponding simplified version of findNext is outlined as Algorithm 4.

Algorithm 4: Function findNext for k > n

Using that version of findNext also allows to simplify our main algorithm (Algorithm 3) by adapting lines 2 and 3, and, due to Lemma 1, skipping lines 4–7, as findNext can be already applied to find the first correct position. Thus, for the required number of queries to break the secret code we have: the initial $k-1$ queries, a call of the modified findNext for every but the last two positions and one or two final queries. This yields that the modified Mastermind Algorithm breaks the secret code in at most $(n-1)\lceil {log}_{2}n\rceil +k+1$ queries.  □

3. Conclusions

We showed that deterministic algorithms for the identification of a secret code in Black-Peg AB-Mastermind can be modified and applied to Yes-No AB-Mastermind. The latter is a new variant of AB-Mastermind which is harder to play for the codebreaker since a less informative error measure is provided. The Yes-No measure only returns the information whether a query and the secret code coincide in any position, while the Black-Peg measure is the number of positions in which both codes coincide. Nevertheless, we proved that the best known asymptotic upper bound for Black-Peg AB-Mastermind does also apply to Yes-No AB-Mastermind, by adapting the corresponding constructive querying strategy. Utilizing a simple codemaker strategy, we further derived corresponding lower bounds for Yes-No AB-Mastermind. Another challenge with AB-Mastermind is that no color repetition is allowed in a query whereas most strategies for other Mastermind variants exploit the property of color repetition. While for most Mastermind variants there is a gap between lower and upper bounds on the worst case number of queries to break the secret code, our results imply that this number is $\mathsf{\Theta }(nlogn)$ for the most popular case $k=n$ of Yes-No AB-Mastermind, which is also referred to as Yes-No Permutation-Mastermind. The same is true for the case $k=c·n$ with constant c. To our knowledge, this result is a first exact asymptotic query complexity proof for a multicolor Mastermind variant, where both secret code and queries are chosen from the same set, here ${\left[k\right]}^n$.

A future challenge will be studying the static variant of Yes-No AB-Mastermind (where the codebreaker must give all but one queries in advance of codemaker’s answers). Lower and upper bounds for static Black-Peg AB-Mastermind were provided as $\mathsf{\Omega }(nlogn)$ and $\mathcal{O}\left(n^{1.525}\right)$, respectively [14].