Haskell将元组列表转换为列表列表

我试图将元组列表转换为列表列表。例如，如果我有列表

[（9,1），（6,3），（4,1）]

，那么它将变成

[[9,6,4]，[6]，[6]]

。在元组列表中，

a

表示0-9之间的数字，

b

表示该数字的出现，

a

始终是唯一的

我试图做的是遍历列表

n

次，其中

n=元组列表中的最大b。

每次遍历列表时，我取

a

并将其放入列表中，然后将

b

递减1。如果

b==0

，我就跳过它

从我的例子中，我把

[9,6,4]

放到一个列表中，然后减少每个列表的

b

，所以现在列表看起来像

[（9,0），（6,2），（4,0）]

。然后再看一遍，我取

[6]

，元组列表现在看起来像

[（9,0），（6,1），（4,0）]

。最后，做最后一次

[6]

，现在元组列表中的

b

是

0

，就这样完成了

我已经创建了一个函数，它从元组列表中获取第一个元素iff

b

is>=1，但是我不知道如何在更新的列表中使用每个元组的所有“b-1”来迭代它

turnIntList :: [(Integer, Integer)] -> [[Integer]]
turnIntList [] = []
turnIntList x = ([map (\(a, b) -> case (a,b) of  _ | b >= 1 -> a | otherwise -> -1) x])

我还尝试创建另一个helper函数，该函数接受一个元组列表，并根据

b

的大小将它们转换为一个列表。在main函数中，我将尝试发送[（a，1），（b，1）…]来创建列表，然后在这里跟踪递减

b

，直到完成为止。因此，对于此函数：

pairingL :: [(Integer, Integer)] -> [Integer] -> [Integer]
pairingL ((a,b):xs) l -- = if b /= 0 then [a,b-1] else []
    | null xs = if b == 1 then [a] ++ l else if b > 1 then [a] ++ l ++ pairingL [(a,b-1)] l else l
    | otherwise = 
        if b /= 0 then [a] ++ l ++ pairingL ((a,b-1):xs) l else pairingL xs l


pairingL [(9,1), (7,2), (5,1)]
[9,7,7,5]

pairingL [(1,1), (2,1), (3,1)]
[1,2,3]

pairingL [(1,2), (2,2), (3,2)]
[1,1,2,2,3,3]

我已经尝试过解压列表并使用它、迭代和重复，但我不知道如何让函数多次检查列表，并用新的

b

值更新列表，然后再次执行

总之，我想做的是：

    turnIntList [(9,3),(5,1),(2,1)]
    [[9,5,2],[9],[9]]

    turnIntList [(1,1),(2,1),(3,1),(4,1)]
    [[1,2,3,4]]

    turnIntList [(1,2),(2,2),(3,2)]
    [[1,2,3],[1,2,3]]

    turnIntList [(4,2),(6,1)]
    [[4,6],[4]]

过程： 我从元组中提取第一个元素，将它们添加到列表中，然后用1减去第二个元素。对列表中的每个元组执行此操作后，我重复此过程，直到每个元组的所有第二个元素都为0

重要提示：同样，在元组[（a，b）]列表中，

a

始终是0-9之间的唯一数字，

b>=0

这可能是

turnIntList :: [(Integer, Integer)] -> [[Integer]]
turnIntList [] = [] -- if it doesn’t compile use [[]]
turnIntList ls = [i | (i, _) <- ls] : turnIntList [(i, n - 1) | (i, n) <- ls, n - 1 > 0]

turnIntList:：[（整数，整数）]->[[Integer]]
turnIntList[]=[]--如果它不编译，请使用[[]]
turnIntList ls=[i |（i，)这可能是

turnIntList :: [(Integer, Integer)] -> [[Integer]]
turnIntList [] = [] -- if it doesn’t compile use [[]]
turnIntList ls = [i | (i, _) <- ls] : turnIntList [(i, n - 1) | (i, n) <- ls, n - 1 > 0]

turnIntList:：[（整数，整数）]->[[Integer]]
turnIntList[]=[]--如果它不编译，请使用[[]]
turnIntList ls=[i |（i，)）你还有其他的例子吗？@elmex80对不起，我应该多举一个例子。我添加了一些，并更清楚地解释了这个过程。谢谢。输入输出就足够了。循环的第一步可能会让你分心，
turnIntList=transpose.map（uncurry（flip replicate））
也可以工作，尽管从技术上讲，签名
[（a，Int）]->[[a]]
使用
Int
而不是
Integer
。甚至更短，
turnIntList=（>>=uncurry（翻转复制））
。你还有其他的例子吗？@Elmex80s对不起，我应该多举一个例子。我补充了一些，并更清楚地解释了这个过程。谢谢。输入-输出就足够了。循环的第一步可能会让你分心，
turnIntList=transpose.map（uncurry（flip-replicate））
也可以工作，尽管从技术上讲，签名
[（a，Int）]->[[a]]
使用
Int
而不是
Integer
。甚至更短，
turnIntList=（>>=uncurry（翻转复制））
。我知道必须有一个更简单的列表理解解决方案。我对Haskell很陌生，这是我仍然很薄弱的领域之一。我肯定会更多地阅读它。有一件事我不明白，我想这会引发一个
n
不在范围内的错误，因为它没有在任何地方显式声明呃，这很好。
n
受到内部列表理解@WilliamJonesI的模式匹配的约束。我知道列表理解必须有一个更简单的解决方案。我对Haskell很陌生，这是我仍然很薄弱的领域之一。我肯定会更多地阅读它。有一件事我不明白，我会imagi这将抛出一个
n
不在范围内的错误，因为它没有在任何地方显式声明，但是它工作得很好。
n
受内部列表comprehension@WilliamJones的模式匹配的约束