Haskell 列表理解 0 和 1

Question

我正在尝试编写一个

row :: Int -> Int -> [Int]
row n v

返回 n 个整数列表的函数，所有 0，除了第 v 个元素，它需要成为 1。

例如，

row 0 0 = []
row 5 1 = [1,0,0,0,0]
row 5 3 = [0,0,1,0,0]

我是 Haskell 的新手，对此有很多困难。特别是我不知道如何让它重复0。我理解构建列表的概念，例如 [1..n]，但我只是得到 [1,2,3,4,5]

任何帮助我们将不胜感激。谢谢。

Answer 1

尝试：

let row n v = map (\x -> if x == v then 1 else 0) [1..n]

Answer 2

这里有一个“monadic”解决方案：

row n v = [(v-1, 0), (1, 1), (n-v, 0)] >>= (uncurry replicate)

replicate 函数多次重复给定值，例如 replicate (v-1) 0 给出一个 v- 列表1 零。 uncurry 用于修改 replicate 以接受一个元组而不是两个单个参数。有趣的运算符 >>= 是 monad 的核心；对于列表，它与带有翻转参数的 concatMap 相同。

Answer 3

提供全面的列表：

 row n v = [if x == v then 1 else 0 | x <- [1..n]]

或使用 fromEnum （感谢 dave4420）

 row n v = [fromEnum (x == v) | x <- [1..n]]

Answer 4

这也应该有效：

row n v = replicate (v-1)­ 0 ++ [1] ++ repl­icate (n-v)­ 0

Answer 5

还有另一种解决方案，递归地构建列表：

row :: Int -> Int -> [Int]
row 0 _ = []
row n 1 = 1 : (row (n-1) 0)
row n m = 0 : (row (n-1) (m-1))

还有一个更具可读性的解决方案，其中“取”零：

row :: Int -> Int -> [Int]
row 0 _ = []
row n m = take (m - 1) zeros ++ [1] ++ take (n - m) zeros
    where zeros = (iterate id 0)

Answer 6

具有两个临时变量 c 和 lst 的简单递归循环。 c 用于计数，lst 是我们必须返回的列表。

row :: Int -> Int -> [ Int ]
row 0 0 = []
row n v = rowHelp n v 1 [] where
    rowHelp n v c lst
            | c > n = lst
            | v == c = rowHelp n v ( c + 1 ) ( lst ++ [ 1 ] )
            | otherwise = rowHelp n v ( c + 1 ) ( lst ++ [ 0 ] )

~
～

Answer 7

haskell 的乐趣在于它可以让你以表达算法的方式编写程序。所以尝试一下：

row n v = [if (x `mod` v==0) then 1 else 0  | x <- [1..n] ]

首先创建一个从 1,2 到 n 的列表。
然后检查该数字是否可以被 v 整除，如果是，则将 1 插入到输出列表中，如果不是 0。

示例：

> row 0 0
[]
> row 5 1
[1,0,0,0,0]
> row 5 3
[0,0,1,0,0]
> row 15 3
[0,0,1,0,0,1,0,0,1,0,0,1,0,0,1]

HTH Chris

Answer 8

我喜欢基于 Chris 的解决方案演示一种自上而下的方法：

row n v = result           
    where
        result = take n numbers        -- our result will have a length of n
        numbers = map trans [1,2,..]   -- and is some transformation of
                                       -- the list of natural numbers
        trans e
           | e `mod` v == 0  = 1       -- let every v-th element be 1
           | otherwise       = 0       -- 0 otherwise

这种风格强调函数式编程的思想，即写下某个值（如 row n v）应该是什么，而不是试图写下函数的作用。回想起一个关于鲜为人知的编程语言萨特的众所周知的笑话，人们可以说在纯函数式编程中，函数什么也不做，它们只是做。