blocks|key|1779969|text|首先想到的是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1779970|rand+::+Int+->+IO+[Int]
rand+n+=+mapM+id+(take+n+(repeat+(randomRIO+(1::Int,+6))))|code-block|syntax|javascript|1779971|尽管haskeller可以删除括号|1779972|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

at first thought:

<pre><code>rand :: Int -&gt; IO [Int]
rand n = mapM id (take n (repeat (randomRIO (1::Int, 6))))
</code></pre>

although the haskellers could remove the parens

blocks|key|1779993|text|你在这里基本上问了两个不同的问题。第一个问题可以用getColor+n+=+fst+.+head+$+filter+(\x+->+snd+x+==+n)+diceColor这样的函数来回答。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1779994|然而，你的第二个问题要有趣得多。您不能替换元素。你需要一个可以递归调用自身的函数，这个函数将驱动你的游戏。它需要接受当前得分和保留的骰子列表作为参数。一旦进入，分数将为零，所保存的骰子列表将为空。然后，它将根据需要掷出尽可能多的骰子来填充列表(我不熟悉Yahtzee的规则)，将其输出给用户，并要求选择。如果用户选择结束游戏，该函数将返回分数。如果他选择保留一些骰子，该函数将使用当前得分和保留的骰子列表调用自己。所以，总结一下，playGame+::+Score+->+[Dice]+->+IO+Score。|1779995|免责声明:我也是Haskell的初学者。|1779996|entityMap^0|P|1P|0|5Z|13|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

You are basically asking two different questions here. The first question can be answered with a function like <code>getColor n = fst . head $ filter (\x -&gt; snd x == n) diceColor</code>.

Your second question, however, is much more interesting. You can't replace elements. You need a function that can call itself recursively, and this function will be driving your game. It needs to accept as parameters the current score and the list of kept dice. On entry the score will be zero and the kept dice list will be empty. It will then roll as many dice as needed to fill the list (I'm not familiar with the rules of Yahtzee), output it to the user, and ask for choice. If the user chooses to end the game, the function returns the score. If he chooses to keep some dice, the function calls itself with the current score and the list of kept dice. So, to sum it up, <code>playGame :: Score -&gt; [Dice] -&gt; IO Score</code>.

Disclaimer: I am, too, very much a beginner in Haskell.

blocks|key|1780033|text|所以，有几个问题，让我们逐一回答：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1780034|First：如何使用System.Random中的函数生成整数以外的其他东西(这是一个很慢的生成器，但对于您的应用程序来说，性能并不重要)。有几种方法，对于你的列表，你必须编写一个函数intToColor：|offset|length|style|BOLD|1780035|intToColor+::+Int+->+String
intToColor+n+=+head+.+filter+(\p+->+snd+p+==+n)+$+[("Black",1),("Green",2),("Purple",3),("Red",4),("White",5),("Yellow",6)]|code-block|syntax|javascript|1780036|不是很好。不过，如果你以(键，值)的顺序编写这对代码，你会做得更好，因为在Data.List中有一点对“关联列表”的支持，带有查找函数：|1780037|intToColor+n+=+fromJust+.+lookup+n+$+[(1,"Black"),(2,"Green"),(3,"Purple"),(4,"Red"),(5,"White"),(6,"Yellow")]|1780038|当然，你也可以忘记Int+key在列表中从1到6的事情，因为列表已经被Int索引了：|1780039|intToColor+n+=+["Black","Green","Purple","Red","White","Yellow"]+!!+n|1780040|(注意，这个函数有点不同，因为intToColor+0现在是“黑色”，而不是intToColor+1，但考虑到你的目标，这并不是真的很重要，如果它真的让你震惊，你可以写"!！(n-1)“)|1780041|但由于您的颜色并不是真正的字符串，而更像是符号，因此您可能应该创建一个Color类型：|1780042|data+Color+=+Black+%7C+Green+%7C+Purple+%7C+Red+%7C+White+%7C+Yellow+deriving+(Eq,+Ord,+Show,+Read,+Enum)|1780043|所以现在黑色是一个颜色类型的值，你可以在你的程序中的任何地方使用它(如果你写了Blak，GHC会抗议)，多亏了自动派生的魔力，你可以比较颜色值，或显示它们，或使用toEnum将Int转换为颜色！|1780044|所以现在你可以写：|1780045|randColorIO+::+IO+Color
randColorIO+=+do
+++n+<-+randomRIO+(0,5)
+++return+(toEnum+n)|1780046|对于第二个，您希望在数据结构中存储骰子值(颜色)，并提供保持相同投掷的选项。因此，首先应该存储几次抛出的结果，考虑到同时抛出的最大数量(5)和数据的复杂性，一个简单的列表就足够了，并且考虑到在Haskell中处理列表的函数数量，它是一个很好的选择。|1780047|所以你想掷几个骰子：|1780048|nThrows+::+Int+->+IO+[Color]
nThrows+0+=+return+[]
nThrows+n+=+do
+++c+<-+randColorIO
+++rest+<-+nThrows+(n-1)
+++return+(c+:+rest)|1780049|这是一个很好的第一种方法，这就是你所做的，或多或少，除非你使用if而不是模式匹配，并且你有一个显式的累加器参数(你打算使用尾部递归吗?)，除了严格的累加器(Int而不是lists)，并不是更好。|1780050|当然，Haskell推广高阶函数，而不是直接递归，所以让我们看看组合符，用Hoogle搜索"Int+->+IO+a+->+IO+a“会给出：|1780051|replicateM+::+Monad+m+=>+Int+->+m+a+->+m+[a]|1780052|它做的正是你想要的：|1780053|nThrows+n+=+replicateM+n+randColorIO|1780054|(我甚至不确定我会把它写成一个函数，因为我发现显式表达式更清晰，而且几乎一样简短)|1780055|一旦你有了抛出的结果，你应该检查哪些是相同的，我建议你看看排序，分组，映射和长度来实现这个目标(将你的结果列表转换成相同结果的列表，不是最有效的数据结构，但在这种规模下，是最合适的选择)。然后，将你得到的颜色保留几次只需使用滤镜即可。|1780056|然后你应该写一些更多的函数来处理交互和评分：|1780057|type+Score+=+Int
yahtzee+::+IO+Score
yahtzeeStep+::+Int+->+[[Color]]+->+IO+[[Color]]+--+recursive
scoring+::+[[Color]]+->+Score|1780058|因此，我建议保留并传输一个[Color]，以跟踪被放在一边的内容。这应该足以满足您的需求。|1780059|entityMap^0|0|0|5|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Z|8|@$D|20|E|21|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|22|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|23|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|24|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|25|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|26|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|27|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|28|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|J|7|29|8|@]|9|@]|A|$K|L]]|$1|10|3|11|5|6|7|2A|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2B|8|@]|9|@]|A|$]]|$1|14|3|15|5|J|7|2C|8|@]|9|@]|A|$K|L]]|$1|16|3|17|5|6|7|2D|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|J|7|2F|8|@]|9|@]|A|$K|L]]|$1|1C|3|1D|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2H|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|J|7|2I|8|@]|9|@]|A|$K|L]]|$1|1I|3|1J|5|6|7|2J|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|J|7|2K|8|@]|9|@]|A|$K|L]]|$1|1M|3|1N|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|J|7|2O|8|@]|9|@]|A|$K|L]]|$1|1U|3|1V|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1W|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]]|1X|$]]

So, several questions, lets take them one by one :

First : How to generate something else than integers with the functions from System.Random (which is a slow generator, but for your application, performance isn't vital).
There is several approaches, with your list, you would have to write a function intToColor :

<pre><code>intToColor :: Int -&gt; String
intToColor n = head . filter (\p -&gt; snd p == n) $ [("Black",1),("Green",2),("Purple",3),("Red",4),("White",5),("Yellow",6)]
</code></pre>

Not really nice. Though you could do better if you wrote the pair in the (key, value) order instead since there's a little bit of support for "association list" in Data.List with the lookup function :

<pre><code>intToColor n = fromJust . lookup n $ [(1,"Black"),(2,"Green"),(3,"Purple"),(4,"Red"),(5,"White"),(6,"Yellow")]
</code></pre>

Or of course you could just forget this business of Int key from 1 to 6 in a list since lists are already indexed by Int :

<pre><code>intToColor n = ["Black","Green","Purple","Red","White","Yellow"] !! n
</code></pre>

(note that this function is a bit different since intToColor 0 is "Black" now rather than intToColor 1, but this is not really important given your objective, if it really shock you, you can write "!! (n-1)" instead)

But since your colors are not really Strings and more like symbols, you should probably create a Color type :

<pre><code>data Color = Black | Green | Purple | Red | White | Yellow deriving (Eq, Ord, Show, Read, Enum)
</code></pre>

So now Black is a value of type Color, you can use it anywhere in your program (and GHC will protest if you write Blak) and thanks to the magic of automatic derivation, you can compare Color values, or show them, or use toEnum to convert an Int into a Color !

So now you can write :

<pre><code>randColorIO :: IO Color
randColorIO = do
 n &lt;- randomRIO (0,5)
 return (toEnum n)
</code></pre>

Second, you want to store dice values (colors) in a data structure and give the option to keep identical throws. So first you should stock the results of several throws, given the maximum number of simultaneous throws (5) and the complexity of your data, a simple list is plenty and given the number of functions to handle lists in Haskell, it is the good choice.

So you want to throws several dices :

<pre><code>nThrows :: Int -&gt; IO [Color]
nThrows 0 = return []
nThrows n = do
 c &lt;- randColorIO
 rest &lt;- nThrows (n-1)
 return (c : rest)
</code></pre>

That's a good first approach, that's what you do, more or less, except you use if instead of pattern matching and you have an explicit accumulator argument (were you going for a tail recursion ?), not really better except for strict accumulator (Int rather than lists).

Of course, Haskell promotes higher-order functions rather than direct recursion, so let's see the combinators, searching "Int -> IO a -> IO [a]" with Hoogle gives you :

<pre><code>replicateM :: Monad m =&gt; Int -&gt; m a -&gt; m [a]
</code></pre>

Which does exactly what you want :

<pre><code>nThrows n = replicateM n randColorIO
</code></pre>

(I'm not sure I would even write this as a function since I find the explicit expression clearer and almost as short)

Once you have the results of the throws, you should check which are identical, I propose you look at sort, group, map and length to achieve this objective (transforming your list of results in a list of list of identical results, not the most efficient of data structure but at this scale, the most appropriate choice). Then keeping the colors you got several time is just a matter of using filter.

Then you should write some more functions to handle interaction and scoring :

<pre><code>type Score = Int
yahtzee :: IO Score
yahtzeeStep :: Int -&gt; [[Color]] -&gt; IO [[Color]] -- recursive
scoring :: [[Color]] -&gt; Score
</code></pre>

So I recommend to keep and transmit a [[Color]] to keeps track of what was put aside. This should be enough for your needs.

I'm trying to store randomly generated dice values in some data structure, but don't know how exactly to do it in Haskell. I have so far, only been able to generate random ints, but I want to be able to compare them to the corresponding color values and store the colors instead (can't really conceive what the function would look like). Here is the code I have --

<pre><code>module Main where

import System.IO
import System.Random
import Data.List

diceColor = [("Black",1),("Green",2),("Purple",3),("Red",4),("White",5),("Yellow",6)]
diceRoll = []

rand :: Int -&gt; [Int] -&gt; IO ()
rand n rlst = do
 num &lt;- randomRIO (1::Int, 6)
 if n == 0
 then printList rlst -- here is where I need to do something to store the values
 else rand (n-1) (num:rlst)

printList x = putStrLn (show (sort x))

--matchColor x = doSomething()

main :: IO ()
main = do
 --hSetBuffering stdin LineBuffering
 putStrLn "roll, keep, score?"
 cmd &lt;- getLine
 doYahtzee cmd
 --rand (read cmd) []

doYahtzee :: String -&gt; IO ()
doYahtzee cmd = do
if cmd == "roll" 
 then do rand 5 []
 else putStrLn "Whatever"
</code></pre>

After this, I want to be able to give the user the ability to keep identical dices (as in accumulate points for it) and give them a choice to re-roll the left over dices - I'm thinking this can done by traversing the data structure (with the dice values) and counting the repeating dices as points and storing them in yet another data structure. If the user chooses to re-roll he must be able to call random again and replace values in the original data structure. 

I'm coming from an OOP background and Haskell is new territory for me. Help is much appreciated.

Storing values in a data structure Haskell

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我尝试将随机生成的骰子值存储在一些数据结构中，但不知道如何在Haskell中确切地做到这一点。到目前为止，我只能生成随机整数，但我希望能够将它们与相应的颜色值进行比较，并存储颜色(不能真正想象函数会是什么样子)。这是我的代码--module Main whereimport System.IOimport System...

问在数据结构中存储值Haskell
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在数据结构中存储值HaskellEN