Sep*_*pia 1 random monads haskell
我正在尝试使用Haskell创建一个Paper Scissors Stone游戏来练习我对它的理解.
不幸的是,下面的源代码给出了不必要的答案
例如:
>play pStone pRandom 1
1 games were played. Player 1 won 1 and player 2 won 1, making the match a draw.
如果玩1场比赛,则应该只有1或0胜.
>play pStone pCopy 100
100 games were played. Player 1 won 1 and player 2 won 1, making the match a draw.
如果玩了100场比赛,那么(在第一轮之后)两个都进行相同的动作,那么应该只有1或0胜.
>play pCopy pAntiCopy 100
100 games were played. Player 1 won 31 and player 2 won 37, making player 2 the overall winner.
根据pCopy和pAntiCopy的预期定义,pAntiCopy应该赢得99或100,pCopy应该赢得0或1.
我认为这种行为的最可能原因是随机数在最后进行评估,这意味着应该依赖于相同随机数的2个值依赖于2个单独的随机数.我在上面是否正确？
如果我是对的,请你告诉我如何纠正这个问题？如果我不对,请告诉我问题是什么以及如何解决？
我已经阅读了一个单独问题的解决方案,建议生成一个随机数列表然后使用它们,将它们作为参数传递给主函数中的相关函数.我不相信这会在这里工作得很好,因为所需的随机数的数量可以是0到2*numRounds,取决于所使用的计划(我打算在这个工作时创建更高级的计划)和代码的可读性会进一步降低.
我是Haskell的新手和一般的函数式编程,所以我为下面的源代码风格道歉.如果您对如何改进有任何建议,也欢迎他们.
import System.Random
data Move= Paper|Scissors|Stone deriving Show
type Plan=([IO Move]->[IO Move]->IO Move)
play :: Plan -> Plan -> Integer -> IO ()
play plan1 plan2 numRounds=do p1intwins<-p1wins;p2intwins<-p2wins;putStr(show numRounds ++ " games were played. Player 1 won " ++ show p1intwins ++ " and player 2 won " ++ show p2intwins ++ ", making " ++ (if p1intwins > p2intwins then "player 1 the overall winner." else (if p1intwins < p2intwins then "player 2 the overall winner." else "the match a draw."))) where (_, _, _, _, _, _, p1wins, p2wins)=(playRound (plan1, plan2, numRounds,[],[], 0, return 0, return 0))
playRound :: (Plan, Plan, Integer, [IO Move], [IO Move], Integer, IO Integer, IO Integer) -> (Plan, Plan, Integer, [IO Move], [IO Move], Integer, IO Integer, IO Integer)
playRound (plan1, plan2, numRounds, p1moves, p2moves, elapsedRounds, p1wins, p2wins)=if elapsedRounds==numRounds then (plan1, plan2, numRounds, p1moves, p2moves, elapsedRounds, p1wins, p2wins) else (playRound (plan1, plan2, numRounds, p1moves++[p1move], p2moves++[p2move], elapsedRounds+1, do p1win<-beatsCaller p1move p2move;p1intwins<-p1wins;return (p1intwins+if p1win then 1 else 0), do p2win<-beatsCaller p2move p1move;p2intwins<-p2wins;return(p2intwins+(if p2win then 1 else 0)) )) where p1move=plan1 p1moves p2moves; p2move=plan2 p2moves p1moves
beatsCaller :: IO Move -> IO Move -> IO Bool
beatsCaller iom1 iom2=do m1<-iom1;m2<-iom2;return(beats m1 m2)
beats :: Move -> Move -> Bool
beats Scissors Paper=True
beats Stone Scissors=True
beats Paper Stone=True
beats _ _=False
-- ###############Plans###################
pStone :: Plan
pStone _ _ = return Stone
pScissors :: Plan
pScissors _ _ = return Scissors
pPaper :: Plan
pPaper _ _ = return Paper
pUScissors :: Plan
pUScissors [] _ = randomMove
pUScissors _ _ = return Scissors
pCopy :: Plan
pCopy _ []= randomMove
pCopy _ theirMoves= last theirMoves
pRandom :: Plan
pRandom _ _=randomMove
pAntiCopy :: Plan
pAntiCopy [] _ = randomMove
pAntiCopy ourMoves _ = do ourMove<-last ourMoves;return(beaterOf ourMove)
-- ##############Plan Logic###############
beaterOf :: Move -> Move
beaterOf Scissors = Stone
beaterOf Paper = Scissors
beaterOf Stone = Paper
randomMove :: IO Move
randomMove=do x<-genRandom;return (doRMove x)
doRMove:: Int -> Move
doRMove rand
|rand==1 =Paper
|rand==2 =Scissors
|rand==3 =Stone
genRandom :: IO Int
genRandom =getStdRandom (randomR (1,3))
我稍微重新格式化并注释了你的源文件.最重要的一点是,你应该改变的类型Plan是[Move] -> [Move] -> IO Move,如下所述.
import System.Random
data Move = Paper | Scissors | Stone
deriving (Show, Eq, Enum, Bounded)
-- Make Move an instance of Random, so that we can use randomIO
-- in order to pick a random Move rather than a hand-written
-- function. We use the derived Enum instance and integer random
-- numbers to do the hard work for us.
instance Random Move where
randomR (l, u) g = (toEnum n, g')
where (n, g') = randomR (fromEnum l, fromEnum u) g
random = randomR (minBound, maxBound)
-- Unchanged, just realigned.
beaterOf :: Move -> Move
beaterOf Scissors = Stone
beaterOf Paper = Scissors
beaterOf Stone = Paper
-- Reimplemented in terms of beaterOf, to avoid unnecessary
-- duplication of error-prone information.
beats :: Move -> Move -> Bool
beats x y = x == beaterOf y
-- Most important change. A plan is a strategy that takes two
-- lists of past moves. These are of type Move, not IO Move, as
-- they have already happened. We then have to determine a new
-- one. Here, to choose the next, we allow IO (such as picking
-- a random number, or asking a human player). I also reverse
-- the order of moves, so that the most recent moves are first,
-- because most strategies access the most recent move, and
-- accessing the head is more efficient in a list.
type Plan = [Move] -- my moves, latest move first
-> [Move] -- opponent's moves, latest move first
-> IO Move -- my next move, may involve IO
--
-- Specific plans (slightly renamed, otherwise unchanged):
--
-- Always plays a particular move.
always :: Move -> Plan
always m _ _ = return m
-- Copies the latest move of opponent.
copy :: Plan
copy _ [] = randomIO
copy _ (latest : _) = return latest
randomly :: Plan
randomly _ _ = randomIO
-- Moves to the beater of our previous move.
antiCopy :: Plan
antiCopy [] _ = randomIO
antiCopy (latest : _) _ = return (beaterOf latest)
uScissors :: Plan
uScissors [] _ = randomIO
uScissors _ _ = return Scissors
-- Play wrapper. Interface as before.
play :: Plan -- my plan
-> Plan -- opponent's plan
-> Integer -- number of rounds to be played
-> IO () -- output is printed as text
play myPlan opPlan rounds = do
(myWins, opWins) <- playRounds
myPlan opPlan rounds
[] [] -- initialize with empty move lists
0 0 -- and 0 wins each
-- print statistics
let overallStatus | myWins > opWins = "Player 1 the overall winner"
| opWins > myWins = "Player 2 the overall winner"
| otherwise = "the match a draw"
putStrLn $ show rounds ++ " games were played. "
++ "Player 1 won " ++ show myWins ++ " and "
++ "Player 2 won " ++ show opWins ++ ", making "
++ overallStatus ++ "."
-- Does all the hard work.
playRounds :: Plan -- my plan
-> Plan -- opponent's plan
-> Integer -- number of rounds still to be played
-> [Move] -- our moves so far, latest first
-> [Move] -- opponent's moves so far, latest first
-> Int -- my wins
-> Int -- opponent's wins
-> IO (Int, Int) -- final wins
playRounds _ _ 0 _ _ myWins opWins =
return (myWins, opWins) -- if no rounds are left to play, return the final statistics
playRound myPlan opPlan rounds myMoves opMoves myWins opWins = do
myMove <- myPlan myMoves opMoves -- here's where a random number might get chosen
opMove <- opPlan opMoves myMoves -- and here again (but nowhere else)
let myWin = myMove `beats` opMove -- this works on the already chosen Move, not on IO Move
opWin = opMove `beats` myMove -- dito
playRound
myPlan opPlan -- as before
(rounds - 1) -- one round is played
(myMove : myMoves) -- adding moves in front of the list is easier
(opMove : opMoves)
(fromEnum myWin + myWins) -- update win count, turning True to 1 and False to 0
(fromEnum opWin + opWins)