1

我正在写一个 Cardguess 游戏，用户设置答案并让 PC 猜测。对于我的项目，输入卡号是 2。

然后，我需要编写cardguess算法。我已经创建了卡片模块。 

data Suit = Club | Diamond | Heart | Spade
      deriving (Eq, Ord, Bounded, Enum)

suitchars = "CDHS"

data Rank =
    R2 | R3 | R4 | R5 | R6 | R7 | R8 | R9 | R10 |
    Jack | Queen | King | Ace
         deriving (Eq, Ord, Bounded, Enum)

rankchars = "23456789TJQKA"

data Card = Card {suit::Suit, rank::Rank}
      deriving (Eq, Bounded)

instance Ord Card where
    compare (Card s1 r1) (Card s2 r2) =
        let suitorder = compare s1 s2
            in  if suitorder == EQ then compare r1 r2 else suitorder

instance Enum Card where
    fromEnum (Card s r) = (fromEnum s)*13 + (fromEnum r)
    toEnum n = (Card s r)
     where s = toEnum (n `div` 13)
           r = toEnum (n `mod` 13)

而我的策略是将 Suit 和 Rank 分成两部分。最初的猜测可能Card Club R5 是Card Heart Jack

然后我会得到反馈，根据它，我会尝试nextGuess，直到得到正确的答案。

我已经写了initialGuess函数。

我把剩下的卡放在GameState.

initialGuess :: Int -> ([Card], GameState)
initialGuess card_number 
     | card_number == 2   = ((Card Club R5):(Card Heart J),cardDeck)

现在，我需要编写nextGuess代码。

nextGuess :: ([Card],GameState) -> (Int,Int,Int,Int,Int) ->([Card],GameState)

(Int,Int,Int,Int,Int)是反馈值。我如何表示第一个参数([Card],GameState)，这意味着以前的猜测卡和以前的GameState。

4

2 回答 2

1

在这里很难读懂你的想法，但也许你想要这样的东西：

startGuessing guesses state = do
  feedBack <- readFeedback
  let (newGuess, newState) = nextGuess (guesses, state) feedback
  startGuessing (guesses ++ newGuess) newState

main = do
  let (guesses, state) = initialGuess 2      
  startGuessing guesses state
于 2012-10-02T20:34:14.500 回答
1

由于我不明白您的问题，而且您是初学者，因此我将对您帖子的其他一些领域进行吹毛求疵。

  1. 你有

    initialGuess card_number 
     | card_number == 2   = ((Card Club R5):(Card Heart J),cardDeck)

    接受您initialGuess 2现在只需要工作，您的列表语法错误。你的意思是要么

    initialGuess card_number 
     | card_number == 2   = (Card Club R5 : Card Heart J : [], cardDeck)

    或者

    initialGuess card_number 
     | card_number == 2   = ([Card Club R5, Card Heart J], cardDeck)

    它们的意思相同，但后者更清楚。

  2. 你有

    instance Ord Card where
    compare (Card s1 r1) (Card s2 r2) =
        let suitorder = compare s1 s2
            in  if suitorder == EQ then compare r1 r2 else suitorder

    如果你import Data.Monoid，你可以更简单地写成

    instance Ord Card where
    compare (Card s1 r1) (Card s2 r2) = compare s1 s2 `mappend` compare r1 r2

    但更好的做法是将其排除在外，而是让编译器为您编写它：

    data Card = Card {suit::Suit, rank::Rank}
      deriving (Eq, Ord, Bounded)

    生成的Ord实例根据您的需要使用字典顺序。

于 2012-10-02T10:18:32.110 回答