Алгоритм Python - для игры «Призрак» - нужен способ интеллектуально отыскивать все «выигрышные» перестановки букв

1

Я пишу компьютерную программу для игры в слова "Ghost."

Вот как работают текущие программы:

- Пользователь выбирает букву (прямо сейчас она работает только в том случае, если пользователь перемещается первым)

- У компьютера есть список всех возможных нечетных слов в словаре (это значит, что пользователю нужно будет заполнить каждое слово и, следовательно, проиграть). После каждой буквы, которую пользователь выбирает, список слов, которые компьютер имеет, обрезается через этот цикл:

 wordList = [w for w in wordList if w.startswith(currentWord)]

так что он имеет только слова в своем "wordList", которые соответствуют текущемуWord, который совместно пишется.

- компьютер затем случайным образом выбирает слово из своего текущего списка слов и возвращает соответствующую букву слова через него, а затем обновляет свой список, чтобы включить букву, выбранную с помощью этого примера кода:

 randomnumber = random.randint(0, len(wordList)-1)
 currentWord+=wordList[randomnumber][len(currentWord)]
 wordList = [w for w in wordList if w.startswith(currentWord)]

- Это продолжается до тех пор, пока пользователь не произнесет слово и не обнаружит функцию checkLoss, или если компьютер не сможет продолжить слово без потери и запускает функцию checkBluff. Функция checkBluff требует от пользователя написать то, что он думает, чтобы убедиться, что он не делает этого.

- * ЗДЕСЬ ПРОБЛЕМА: * очевидно, потому что компьютер случайно выбирает, какой символ выбрать, есть определенные слова, которые будут приводить к потере. Например, если первый игрок выбирает слово "d", существует очень высокая вероятность того, что компьютер выберет "e" , потому что есть так много слов, которые имеют "de" и самое начало. Однако, если пользователь на третьем повороте выбирает букву "e" , так что текущая орфография "dee", компьютер не имеет слов в своем списке (есть только одно слово на английском языке, которое соответствует этой форме: "deed" и оно равномерно и, следовательно, проигрывается), поэтому функция блефа запускается, и компьютер теряет, когда пользователь показывает, что он думал о реальном слове "дело".

SO, мне бы хотелось, чтобы алгоритм заставил компьютер задуматься заранее, чтобы он никогда не выбирал последующее письмо, для которого первый игрок может заставить потерю. Итак, если "d" выбрано, компьютер никогда не должен выбирать "e" , потому что это приведет к потере с помощью субэквивалента e. Аналогично, если пользователь выбирает "h", компьютер не должен следовать с "o", потому что пользователь может затем сказать "c", который заставляет "k" накладывать слово "hock".

Я не могу придумать, как это сделать.

При необходимости, здесь программа в полном воплощении:

import os, random, sys, math, string

def checkBluff(currentWord, choice, fullList):
    if choice.startswith(currentWord):
        #print "this is accurate"
        for line in fullList:
            if line == choice:
                return 1
    return 0

def checkLoss(currentWord, fullList):
    for line in fullList:
       if currentWord == line:
           return 1
    return 0 

def instantiateWordList(dictionary, wordList):
    for line in dictionary:
        wordList.append(line.strip())
    return wordList



def main():

    fullDict = open("wordlist.txt", "r") #fullDict contains all possible words
    winFirst = open("firstwin.txt", "r") #winFirst contains all odd-numbered words
    winSecond = open("secondwin.txt", "r")#winSecond contains all even-numbered words
    turn = "Human"
    currentWord = ""
    wordList = []
    fullList= []
    bluff = ""

#Instantiates a list with every word for use in evaluating win/loss
for line in fullDict:
    fullList.append(line.strip())

#Decide who goes first
choice = raw_input("1. I will go first \n2. I will go second\n>>")[0]

if choice == "1":
    wordList = instantiateWordList(winSecond, wordList)
    turn == "Human"
else:  
    wordList = instantiateWordList(winFirst, wordList)
    turn == "Computer"

while True:
    if turn == "Human":  
        choice = raw_input("Choose a letter: ")[0]
        currentWord+=choice


        if checkLoss(currentWord, fullList) == 1:
            print "You have lost by spelling the word "+ currentWord
            break 


        print "**Current Word**"+ currentWord
        wordList = [w for w in wordList if w.startswith(currentWord)]
        turn = "Computer"

    if turn == "Computer":
        try: 
            randomnumber = random.randint(0, len(wordList)-1)
            currentWord+=wordList[randomnumber][len(currentWord)]
            print "I am thinking of the word: "+ str(wordList[randomnumber])
            wordList = [w for w in wordList if w.startswith(currentWord)]

            print "**Current word**: "+ currentWord
            print "length: "+ str(len(wordList))
            turn = "Human"
        except StandardError:
            bluff = raw_input("I call bluff.  What word were you thinking of?\n>>")
            if checkBluff(currentWord, bluff, fullList) == 1:
                print "You actually won!"
                break
            else:
                print "You lost.  You lying son of a bitch."
                break 


if __name__ == "__main__":
    main()
Теги:
string
algorithm
tree

2 ответа

1
Лучший ответ

Вы хотите, чтобы компьютер смотрел в будущее и все же выбирал случайным образом?: -)

Эта игра достаточно предсказуема и достаточно проста для вас, чтобы компьютер всегда выигрывал, если хотите. Фактически, вы можете предварительно подготовить деревья стратегии, чтобы гарантировать выигрыш. Они даже не такие большие, вы могли бы научиться наизусть, если хотите.

Если вы этого не хотите, вы должны смотреть только один раунд вперед. В примере с вашим делом один раунд головы показал бы, что противник может заставить победу в один раунд, чтобы избежать "де". Но он не избежал бы того, что могло бы привести к потере в два раунда.

Но для этого вам нужно пройти все возможности. Затем вы можете выбирать случайным образом между оставшимися вариантами.

  • 0
    Это не должно быть случайным. Я просто хочу узнать, как лучше смотреть в будущее. Как вы реализуете это?
  • 1
    «Дерево побед» XKCD совершенно и категорически неверно. Я проверил его на своем компьютере, и он может думать о выигрышных ходах для каждого. Например, «скакать» легко избежать с помощью «фокуса».
Показать ещё 1 комментарий
0

Чтобы программа не проигрывала, она также должна содержать список слов с четным номером (о, он действительно, не заметил его вначале)

При принятии решения о следующей букве он должен сначала проконсультироваться с списком слов с нумерованным (потерянным). Если n + 2 (4 для n = 1, 6 для n = 3 и т.д., n - текущий буквенный индекс), длинные слова символов, то он не должен использовать букву в n позиции.

Итак, используя пример "дела":

  • Пользовательские типы "d"
  • Программа видит, что есть 1 слово, начинающееся с "d" и длиной 4 символа: "deed".
  • Он добавляет "дело" [1] в список "ограниченных" букв
  • Он просматривает список "выигрывающих" слов, игнорируя те, которые начинаются с "de" и получает список "доступных" символов.
  • Он случайным образом выбирает символ из списка и отображает его пользователю.
  • 0
    Это очень разумная стратегия. Я могу реализовать это довольно легко, я уверен-- (свяжусь с вами). Но гарантирует ли это гарантированный выигрыш, если вы посмотрите только на одну букву?

Ещё вопросы

Сообщество Overcoder
Наверх
Меню