Python 使用ADT方法转换程序

我是一名初级程序员

我一直在为一项作业的六猜算法中的智囊团解算器编写代码

（有关智囊团及其算法的更多信息：）

我几天前就知道了。但是我们的教授设置了固定的模板，然后我不知道如何将我的代码转换成它

下面是我的代码。可能会很尴尬，但它很有效，而且速度也不慢

---

---

引擎

from mastermind import CodeBreaker

def computeFeedback(code,guess):
    # Given a code and guess computes the feedback string

    b = 0
    w = 0
    inCodeCount = {'A':0,'B':0,'C':0,'D':0, 'E':0, 'F':0}
    inGuessCount = {'A':0,'B':0,'C':0,'D':0, 'E':0, 'F':0}
    for i in range(0,4):
        if code[i] == guess [i]:
            b += 1
        inCodeCount[code[i]] += 1
        inGuessCount[guess[i]] += 1
    for ch in inCodeCount:
        w += min(inCodeCount [ch], inGuessCount [ch])
    w -= b 
    feedback = str(w)+'w'+str(b)+'b'
    return feedback

code = input()

while (code != None):
    guesscount = 0
    myBreaker = CodeBreaker()
    while (guesscount < 8):
        guess = myBreaker.makeGuess()
        print("My guess is:",guess)
        guesscount += 1
        feedback = computeFeedback(code, guess)
        print(feedback)
        if feedback == "0w4b":
            print("Game Over in", guesscount,"steps")
            break
        myBreaker.getFeedback(feedback)
    if guesscount == 8:
        print("Failed to find the solution in 8 steps")
    code = input()

来自mastermind import CodeBreaker
def计算反馈（代码、猜测）：
#给定一个代码并猜测计算反馈字符串
b=0
w=0
inCodeCount={'A'：0，'B'：0，'C'：0，'D'：0，'E'：0，'F'：0}
inGuessCount={A'：0，'B'：0，'C'：0，'D'：0，'E'：0，'F'：0}
对于范围（0,4）内的i：
如果代码[i]==猜测[i]：
b+=1
inCodeCount[代码[i]+=1
inGuessCount[猜测[i]]+=1
对于ch in退计：
w+=min（不计数[ch]，不计数[ch]）
w-=b
反馈=str（w）+'w'+str（b）+'b'
回馈
代码=输入（）
while（代码！=无）：
猜测计数=0
myBreaker=CodeBreaker（）
而（猜测计数<8）：
guess=myBreaker.makeGuess（）
打印（“我的猜测是：”，猜测）
猜测计数+=1
反馈=计算反馈（代码、猜测）
打印（反馈）
如果反馈==“0w4b”：
打印（“游戏结束”，猜数，“步骤”）
打破
myBreaker.getFeedback（反馈）
如果guesscount==8：
打印（“在8个步骤中找不到解决方案”）
代码=输入（）

---

我上课不好。我甚至不知道init应该包含什么。有人能帮忙吗

---

非常感谢

将代码转换为类的最简单方法是将所有代码放入

getFeedback

方法，除了不计算要计算的猜测之外，请记住属性

self.guess

中的猜测，并在下次调用

makeGuess

函数时返回该值。您还需要将所有全局变量（如

common

）转换为属性（如

self.common

）。这是一张草图：

class CodeBreaker:
    def __init__(self):
        self.guess_count = 0
        self.guess = 'ABCD'
        self.common = []

    def makeGuess(self):
        return self.guess

    def getFeedback(self, feedback):
        self.guess_count += 1
        if self.guess_count == 1:
            # ... your code here ...
            self.guess = 'BCDE'
        elif self.guess_count == 2:
            # ... your code here ...
            self.guess = 'CDEF'
        elif self.guess_count == 3:
            # ... your code here ...
        # ... and so on ...

我应该补充一点，您的代码非常重复。以下改变是值得的：

Python标准库已经包含了一个函数，该函数可以完成函数

产品

的工作（尽管它以不同的方式接受其参数），因此您最好改用它

您为每个猜测复制了基本相同的代码（生成组合集，根据最近的猜测评估组合，更新

common

等等）。将此代码放入一个方法中应该很简单，这样您就不必将其复制太多次

猜测数字4和更高的代码几乎相同：当然根本不需要复制此代码（如果猜测计数>=4:，只需编写

，并同时处理它们）

您可能想学习这个类（它使用与您的解决方案类似的方法，但去掉了所有的重复），看看您是否能够弄清楚它是如何工作的：

from itertools import product
from random import choice
from copy import copy

class CodeBreaker(object):
    all_codes = [''.join(c) for c in product(*['ABCDEF'] * 4)]

    def __init__(self):
        self.codes = copy(self.all_codes)
        self.guess = 'AABB'     # Best first guess!

    def makeGuess(self):
        return self.guess

    def getFeedback(self, feedback):
        self.codes = [c for c in self.codes if computeFeedback(c, self.guess) == feedback]
        self.guess = choice(self.codes)

在最坏的情况下，该算法最多可以进行八次猜测，但您有八次猜测，所以这没问题。如果你只有六个猜测，那么你需要一个更聪明的方法。下面的替代算法基于一次向前看进行最佳猜测，最多需要六次猜测。（然而，它运行得非常慢！）同样，你可能会发现研究它是如何工作的很有趣（提示：它需要时间）

以下是（运行速度更慢）：

另外，你教授的密码也不完美！除了不遵循传统的Python风格外（请参阅），它似乎还相当复杂和冗长。为什么不利用Python的类编写一些简短的东西：

from collections import Counter

def computeFeedback(code, guess):
    """
    Return the string `{white}w{black}b` where `black` is a count of the
    characters in `guess` that appear at the same position in `code`
    and `white` is a count of the characters in `guess` that appear at
    a different position in `code`.

    >>> computeFeedback('ABCD', 'ACAD')
    '1w2b'
    >>> computeFeedback('ABAB', 'AABB')
    '2w2b'
    >>> computeFeedback('ABCD', 'DCBA')
    '4w0b'
    """
    w = sum((Counter(code) & Counter(guess)).values())
    b = sum(c == g for c, g in zip(code, guess))
    return '{}w{}b'.format(w - b, b)

---

将代码转换为类的最简单方法是将所有代码放入

getFeedback

方法中，只是不要计算要计算的猜测，而是记住属性

self.guess

中的猜测，并在下次调用

makeGuess

函数时返回该值。您还需要将所有全局变量（如

common

）转换为属性（如

self.common

）。这是一张草图：

class CodeBreaker:
    def __init__(self):
        self.guess_count = 0
        self.guess = 'ABCD'
        self.common = []

    def makeGuess(self):
        return self.guess

    def getFeedback(self, feedback):
        self.guess_count += 1
        if self.guess_count == 1:
            # ... your code here ...
            self.guess = 'BCDE'
        elif self.guess_count == 2:
            # ... your code here ...
            self.guess = 'CDEF'
        elif self.guess_count == 3:
            # ... your code here ...
        # ... and so on ...

我应该补充一点，您的代码非常重复。以下改变是值得的：

Python标准库已经包含了一个函数，该函数可以完成函数

产品

的工作（尽管它以不同的方式接受其参数），因此您最好改用它

您为每个猜测复制了基本相同的代码（生成组合集，根据最近的猜测评估组合，更新

common

等等）。将此代码放入一个方法中应该很简单，这样您就不必将其复制太多次

猜测数字4和更高的代码几乎相同：当然根本不需要复制此代码（如果猜测计数>=4:，只需编写

，并同时处理它们）

您可能想学习这个类（它使用与您的解决方案类似的方法，但去掉了所有的重复），看看您是否能够弄清楚它是如何工作的：

from itertools import product
from random import choice
from copy import copy

class CodeBreaker(object):
    all_codes = [''.join(c) for c in product(*['ABCDEF'] * 4)]

    def __init__(self):
        self.codes = copy(self.all_codes)
        self.guess = 'AABB'     # Best first guess!

    def makeGuess(self):
        return self.guess

    def getFeedback(self, feedback):
        self.codes = [c for c in self.codes if computeFeedback(c, self.guess) == feedback]
        self.guess = choice(self.codes)

在最坏的情况下，该算法最多可以进行八次猜测，但您有八次猜测，所以这没问题。如果你只有六个猜测，那么你需要一个更聪明的方法。下面的替代算法基于一次向前看进行最佳猜测，最多需要六次猜测。（然而，它运行得非常慢！）同样，你可能会发现研究它是如何工作的很有趣（提示：它需要时间）

以下是（运行速度更慢）：

另外，你教授的密码也不完美！除了不遵循传统的pythonst之外

    def getFeedback(self, feedback):
        self.codes = [c for c in self.codes if computeFeedback(c, self.guess) == feedback]
        if len(self.codes) == 1:
            self.guess = self.codes[0]
        else:
            def key(g): return max(Counter(computeFeedback(c, g) for c in self.codes).values())
            self.guess = min(self.all_codes, key = key)

from collections import Counter

def computeFeedback(code, guess):
    """
    Return the string `{white}w{black}b` where `black` is a count of the
    characters in `guess` that appear at the same position in `code`
    and `white` is a count of the characters in `guess` that appear at
    a different position in `code`.

    >>> computeFeedback('ABCD', 'ACAD')
    '1w2b'
    >>> computeFeedback('ABAB', 'AABB')
    '2w2b'
    >>> computeFeedback('ABCD', 'DCBA')
    '4w0b'
    """
    w = sum((Counter(code) & Counter(guess)).values())
    b = sum(c == g for c, g in zip(code, guess))
    return '{}w{}b'.format(w - b, b)