Game for programmers - Bulls and cows

Hi habraedi. I will tell you how to write a Python engine and an approximate bot of the game for programmers. Games for programmers are games that people do not play, but programs.


We will write a version of the game "Bulls and Cows" , in English which is called "Bulls and Cows". The rules of the original game between two people can be read here .
The rules of our game:

1. The engine conceives a number, it is n-digit and the numbers in it cannot be repeated. The engine tells the player program the number n
2. The player program assumes a certain number, informs its engine
3. The engine tells the player program how many digits from the player program number are in the intended and stand in place (Bulls), and how many are in the planned, but do not stand in their place (cows).
4. If the number is not guessed, return to step 2

The player program will communicate with the engine via stdin / out. Our specification assumes that the engine runs the player programs passed to it as arguments.
')

Engine

We first write the functional parts:

Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result

2. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
3. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
5. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
6. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
7. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
8. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
9. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
10. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
11. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
13. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
14. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
15. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
16. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
17. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
18. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
19. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
20. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
21. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
22. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
24. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
25. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
26. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
27. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
28. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
29. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
30. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result
31. Copy Source | Copy HTML #!/usr/bin/python import random class Game (object): def __init__ (self, number= 6 ): if number > 10 : exit() self .number = number self .secret = self . make_secret ( self .number) self .main() def is_right_secret (self, secret): """check all digits are different""" dct = {} for digit in secret: try : if dct[digit]: return False except KeyError: dct[digit] = True return True def make_secret (self, number): """generate number-counted secret""" while True: result = "" for i in range (number): result += "%d" % random .randint( 0 , 9 ) if self . is_right_secret (result): return result

Here we are thinking about the number that player programs will guess. We also check that all the numbers in the number were different. then we run Game.main - the main program loop.

It is also necessary to add the counting function of bulls and cows:

Copy Source | Copy HTML

2. def count_bulls_cows (self, number, secret):
3. "" "count bulls and cows in number / secret" ""
4. cows, bulls = 0 , 0
5. dct = {}
6. for i in range ( len (secret)):
7. if secret [i] == number [i]:
8. bulls + = 1
9. else :
10. dct [secret [i]] = True
11. try :
12. if dct [number [i]]:
13. cows + = 1
14. except KeyError:
15. pass
16. return bulls, cows

Now we introduce constants that will denote code words for communicating with programs by players, and some others:

Copy Source | Copy HTML

2. MESS_NUMBER_DIGITS = "number_digits" #start message
3. MESS_GUESS = "guess!"
4. MESS_COWS = "cows:" #If the matching digits on different positions, they are "cows"
5. MESS_BULLS = "bulls:" #If the matching digits are on their right positions, they are "bulls"
6. MESS_BULLS_COWS_SPLIT = "|" #Splitter between cows and bulls message
7. MAX_TURN_NUMBER = 1000

Now we will describe the gameplay in main (): (I bring it with debug messages)

Copy Source | Copy HTML

1. def main (self):
2. for player in self .players:
3. player.connect ()
4. player.send ( "% s% d" % (MESS_NUMBER_DIGITS, self .number))
5. print ( "% s% d" % (MESS_NUMBER_DIGITS, self .number))
6. starttime = time . time ()
7. while true:
8. if player.turns> MAX_TURN_NUMBER:
9. print ">>>> Player '% s' turns timeout" % player.name
10. player.disconnect ()
11. break
12. answer = player.recieve ()
13. print ">>>> Answer is% s" % answer
14. if len ( self .secret)! = len (answer):
15. self .stop_game ( "wrong number" )
16. bulls, cows = self .count_bulls_cows (answer, self .secret)
17. if bulls == self .number:
18. player.time = time . time () - starttime
19. player.send ( "% s" % MESS_GUESS)
20. player.disconnect ()
21. print ">>>> Player disconected"
22. break
23. else :
24. player.turns + = 1
25. player.send ( "% s% d% s% s% d" % (MESS_BULLS, bulls, \
26. MESS_BULLS_COWS_SPLIT, MESS_COWS, cows))
27. print ( ">>>>% s% d% s% s% d" % (MESS_BULLS, bulls, \
28. MESS_BULLS_COWS_SPLIT, MESS_COWS, cows))
30. winner = self .players [ 0 ]
31. for player in self .players:
32. if player.turns <winner.turns:
33. winner = player
34. print ">>>> Winner name:% s" % winner.name

It's all clear. Take turns playing with each player. First, send the number of digits in the hidden number. We notice time. We take the player's guess number, if you have not guessed (the number of bulls is not equal to the number of digits in the number) - we send the number of bulls / cows and increase the number of moves required by the player to guess, if we guess - stop the timer, write him what he won, disconnect from the player , go to the next.

At the end choose the winner.

We describe the connection technology with the processes of player programs in the Player class:

Copy Source | Copy HTML

2. class Player (object):
3. def __init__ (self, name, progname):
4. self .name = name
5. self .turns = 0
6. self .time = - 1
7. self .progname = progname
9. def connect (self):
10. self .__ proc = subprocess .Popen ( self .progname, stdin = subprocess .PIPE, \
11. stdout = subprocess .PIPE)
13. def send (self, sendstring):
14. self .__ proc.stdin.write (sendstring + '\ n' )
16. def recieve (self)
17. return self .__ proc.stdout. readline () .strip ( '\ n' )
19. def disconnect (self)
20. self .__ proc.terminate ()

Let's rewrite Game .__ init__ a bit to initialize players:

Copy Source | Copy HTML

1. def __init__ (self, number, players_progs):
2. if number> 10 :
3. exit ()
4. self .number = number
5. self .secret = self .make_secret ( self .number)
7. self .players = []
9. for playername in players_progs:
10. self .players.append (Player (playername, players_progs [playername]))
12. self .main ()

Dumb bot

Now you need to test the result. For tests, we need a player program, the simplest. Then it will be an api - class from which real player programs will be inherited
Create a subfolder api in the project folder, and the file mooapi.py in it:

Copy Source | Copy HTML

2. #! / usr / bin / python
3. import random
4. import sys
6. MESS_NUMBER_DIGITS = "number_digits" #start message
7. MESS_GUESS = "guess!"
8. MESS_COWS = "cows:" #If the matching digits on different positions, they are "cows"
9. MESS_BULLS = "bulls:" #If the matching digits are on their right positions, they are "bulls"
10. MESS_BULLS_COWS_SPLIT = "|" #Splitter between cows and bulls message
14. class MooPlayer (object):
16. ## technical functions
17. def send (self, st):
18. sys .stdout.write ( "% s \ n" % st)
19. sys .stdout.flush ()
21. def recieve (self):
22. return sys .stdin. readline () .strip ( "\ n" )
25. def number_split (self, st):
26. num = st.split ( '' )
27. if num [ 0 ] == MESS_NUMBER_DIGITS:
28. return int (num [ 1 ])
29. else :
30. exit ()
32. def answer_split (self, st):
33. try :
34. bullst, cowst = st.split (MESS_BULLS_COWS_SPLIT)
35. except ValueError:
36. exit ()
37. bulls, cows = bullst.split ( '' ), cowst.split ( '' )
38. if bulls [ 0 ] == MESS_BULLS and cows [ 0 ] == MESS_COWS:
39. return bulls [ 1 ], cows [ 1 ]
40. else :
41. exit ()
43. def main (self):
44. self .number = self . number_split ( self . recieve ())
46. while true:
47. try :
48. self .oldguess = guess
49. guess = self . guess (cows = cows, bulls = bulls, firstrun = False)
50. except NameError:
51. guess = self . guess (firstrun = true)
52. self . send ( guess )
53. answer = self . recieve ()
54. if answer == MESS_GUESS:
55. exit ()
56. else :
57. bulls, cows = self . answer_split (answer)
60. ## some functions
61. def is_right_secret (self, secret):
62. "" "check all digits are different" ""
63. dct = {}
64. for digit in secret:
65. try :
66. if dct [digit]:
67. return false
68. except KeyError:
69. dct [digit] = True
70. return true
72. def generate_number (self, number):
73. "" "generate number-counted secret" ""
74. while true:
75. result = ""
76. for i in range (number):
77. result + = "% d" % random .randint ( 0 , 9 )
78. if self . is_right_secret (result):
79. return result
81. ############ Main guess function ###########
82. def guess (self, firstrun, bulls = 0 , cows = 0 ):
83. "This is the main api function. It means that it is the first time run. <br/> bulls / cows number. <br/> also you have: <br/> self.number - number of digits <br/> self.oldguess - old guess try <br/> "" "
84. return self . generate_number ( self .number)
87. if __name__ == "__main__" :
88. mooplayer = mooplayer ()
89. mooplayer. main ()

Everything is simple, a part of the code is copied from the engine module, no analysis takes place, it is simply guessed by a random number.
The one who will write the player program will need to import the mooapi module, inherit its class from MooPlayer and override the function MooPlayer.guess ()

Why I haven’t imported the engine module - for clarity, to those who will write api for other programming languages.
Now you can run the player program and try to play bulls and cows with it:

>>number_digits 4
5032
>>bulls: 0|cows: 0
4123
>>bulls: 0|cows: 0
2890
>>bulls: 0|cows: 0
2691
>>guess!

(>>) indicates keyboard input

Run

now add to the end of the engine module:

Copy Source | Copy HTML

2. if __name__ == "__main__" :
3. game = Game ( 2 , { 'Player1' : "api / mooapi.py" , 'Player2' : "api / mooapi.py" , 'HabraMan' : "api / mooapi.py" })

This will start the game with two-digit numbers, three players with the same api / mooapi.py programs. With double digits, so that our stupid program can guess.

Run the engine module:
>>>> bulls: 0|cows: 1
>>>> Answer is 67
>>>> bulls:1 cows:0
>>>> bulls: 1|cows: 0
>>>> Answer is 87
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 49
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 54
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 82
>>>> bulls:1 cows:0
>>>> bulls: 1|cows: 0
>>>> Answer is 21
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 62
>>>> bulls:2 cows:0
>>>> Player disconected
>>>> Winner name: HabraMan


Works!
In the next post I will tell you how to make the program useful - to screw in it the parsing of the command line arguments and outputting all the good in xml, in which the input to our future flash player on our future site is missing .

Link to full texts of programs

The joy of the engine is that it can be screwed to a multi-site that we are writing now.

You can be the first to implement the Honorable Knuth's algorithm in our bot.