Haskell 将Int转换为[Int]

我正在看过去的试卷，不知道如何将

Int

转换为

[Int]

。 例如，其中一个问题要求我们列出一个整数的所有因子，不包括数字本身和1

strictFactors Int -> [Int]
strictFactors x = ???

---

我没有要求任何人帮我回答这个问题！我只是想知道如何将整数输入转换为整数输出列表。谢谢

我是Haskell的新手，但我可以想出无数种方法将Int“转换”为包含相同Int的列表：

import Control.Applicative (pure)                                               

sane_lst :: Int -> [Int]                                                        
sane_lst x = [x]                                                                

lst :: Int -> [Int]                                                             
lst x = take 1 $ repeat x                                                       

lst' :: Int -> [Int]                                                            
lst' = replicate 1                                                              

lst'' :: Int -> [Int]                                                           
lst'' = return                                                                  

lst''' :: Int -> [Int]                                                          
lst''' = pure                                                                   

lst'''' :: Int -> [Int]                                                         
lst'''' x = enumFromTo x x 

我想这里的重点是，你不是“转换”成一个列表，而是“构造”你需要的列表。针对您提出的问题，直截了当的策略是根据您的参数找到合适的开始列表，然后根据需要进行筛选、折叠或理解

例如，当我说：

lst x = take 1 $ repeat x 

---

我首先构造一个无限列表，重复我传入的值，然后从中获取一个只包含第一个元素的列表。因此，如果你想从什么样的列表开始寻找问题的解决方案，你就已经走到了一半。

我对Haskell很陌生，但可以想出无数种方法将Int“转换”为包含相同Int的列表：

import Control.Applicative (pure)                                               

sane_lst :: Int -> [Int]                                                        
sane_lst x = [x]                                                                

lst :: Int -> [Int]                                                             
lst x = take 1 $ repeat x                                                       

lst' :: Int -> [Int]                                                            
lst' = replicate 1                                                              

lst'' :: Int -> [Int]                                                           
lst'' = return                                                                  

lst''' :: Int -> [Int]                                                          
lst''' = pure                                                                   

lst'''' :: Int -> [Int]                                                         
lst'''' x = enumFromTo x x 

我想这里的重点是，你不是“转换”成一个列表，而是“构造”你需要的列表。针对您提出的问题，直截了当的策略是根据您的参数找到合适的开始列表，然后根据需要进行筛选、折叠或理解

例如，当我说：

lst x = take 1 $ repeat x 

---

我首先构造一个无限列表，重复我传入的值，然后从中获取一个只包含第一个元素的列表。因此，如果您考虑需要从什么样的列表开始，以找到问题的解决方案，您就已经走到了一半。

也许查看一些类似的代码最容易。按照要求，我不会给你答案，但你应该能够利用这些想法去做你想做的事情

lcm :: Int -> Int -> Int
lcm x y = head [x*a | a <- [1..], (x*a) `mod` y == 0]

蛮力 这里我们将使用

1

和

x

之间的所有数字对来测试是否可以将

x

作为两个平方数的和：

sumOfSquares :: Int -> [Int]
sumOfSquares x = [ (a,b) | a <- [1..x], b <- [a..x], a^2 + b^2 == x]

因为50=1^2+7^2和50=5^2+5^2

您可以将

sumOfSquares

视为一种工作方式，首先从

[1..x]

列表中选取

a

，该列表包含

1

和

x

之间的数字，然后在该列表和

x

之间选取另一个。然后检查

a^2+b^2==x

。如果这是真的，它会将

（a，b）

添加到结果列表中

生成并检查 这一次，让我们生成一些单数，然后检查它们是否是另一个数的倍数。这将计算最小公倍数（lcm）。例如，15和12的最小公倍数是60，因为它是15和12倍表中的第一个数字

此函数不是您想要的类型，但它使用了您想要的所有技术

lcm :: Int -> Int -> Int
lcm x y = head [x*a | a <- [1..], (x*a) `mod` y == 0]

这一次，数字列表（原则上）是无限的；干得好，我们刚刚挑选了头有

的第一个

（x*a）`mod`y==0
检查数字
x*a
是否是
y
的倍数（
mod
给出除法后的余数）。这是你应该使用的一个关键想法

总结
使用
a也许查看一些类似的代码是最容易的。按照要求，我不会给你答案，但你应该能够利用这些想法去做你想做的事情

lcm :: Int -> Int -> Int
lcm x y = head [x*a | a <- [1..], (x*a) `mod` y == 0]

蛮力
这里我们将使用
1
和
x
之间的所有数字对来测试是否可以将
x
作为两个平方数的和：

sumOfSquares :: Int -> [Int]
sumOfSquares x = [ (a,b) | a <- [1..x], b <- [a..x], a^2 + b^2 == x]

因为50=1^2+7^2和50=5^2+5^2

您可以将
sumOfSquares
视为一种工作方式，首先从
[1..x]
列表中选取
a
，该列表包含
1
和
x
之间的数字，然后在该列表和
x
之间选取另一个。然后检查
a^2+b^2==x
。如果这是真的，它会将
（a，b）
添加到结果列表中

生成并检查
这一次，让我们生成一些单数，然后检查它们是否是另一个数的倍数。这将计算最小公倍数（lcm）。例如，15和12的最小公倍数是60，因为它是15和12倍表中的第一个数字

此函数不是您想要的类型，但它使用了您想要的所有技术

lcm :: Int -> Int -> Int
lcm x y = head [x*a | a <- [1..], (x*a) `mod` y == 0]

这一次，数字列表（原则上）是无限的；干得好，我们刚刚挑选了头有
的第一个

（x*a）`mod`y==0
检查数字
x*a
是否是
y
的倍数（
mod
给出除法后的余数）。这是你应该使用的一个关键想法

总结
使用
a如果您的唯一目标是在类型之间转换（目前），那么
strictFactors x=[x]
是最规范的答案。这个函数也被称为
pure
，因为
[]
是一个
应用程序
和
返回
，因为
[]
是一个
单子
如果你的唯一目标是在类型之间转换（现在），那么
strictFactors x=[x]
就是最规范的答案。这个函数也被称为
pure
，因为
[]
被称为
Applicative
和
return
，因为
[]
被称为
Monad
lst x=[x]
或
lst x=x:[]
最简单的代码是列表理解。或者使用
过滤器
。这些都与简单性相当。<代码> LST x= [X]<代码>或<代码> LST x= x:[[]]/Cord>最简单的代码是列表理解。或者使用
过滤器