List Haskell中无限列表的笛卡尔积

我有一个有限列表的函数

> kart :: [a] -> [b] -> [(a,b)]
> kart xs ys = [(x,y) | x <- xs, y <- ys]

卡丁车：：[a]->[b]->[（a，b）]

---

>卡丁车xs ys=[（x，y）| x你的第一个定义，

卡丁车xs ys=[（x，y）| x
序曲>让卡丁车=（\xs-ys->[（x，y）| ls-map（\y->（x，y））ys，（x，y）：t卡丁车
卡丁车：：[t]->[t1]->[（t，t1）]
序曲>乘坐10美元卡丁车[0..][1..]
[(0,1),(0,2),(0,3),(0,4),(0,5),(0,6),(0,7),(0,8),(0,9),(0,10)]
序曲>乘坐10美元卡丁车[0..][5..10]
[(0,5),(0,6),(0,7),(0,8),(0,9),(0,10),(1,5),(1,6),(1,7),(1,8)]
模式

这是另一个人功能的正确输出

阅读从右上角到左下角（左上角除外）的对角线条纹：

a1 a2 a3 a4
b1 b2 b3
c1 c2
d1

a1-a2 b1-a3 b2 c1-a4 b3 c2 d1

模式是上升的。先是一组1，然后是一组2，依此类推。
第一个数字表示相同的数字。在每个组中，数字是颠倒的。
字母在每组中按顺序排列，但数字在每组中按相反顺序排列

如果给出11-22-33，就有可能得到一个倒数的公式
基数为3的是3+1-2位数或3+1-1=3，3+1-2=2，3+1-3=1将第二位数转换为
1 3-2 2-3 1

所以模式是

[(m,n) |i <-[1..4], (m,n) <-zip (take i "abcd") (reverse $ take i "1234")]

[（m，n）| i
null$filter（\（x，y）->y>0）$kart[0..][0..]
给出
False
但是
null$filter（\（x，y）->x>0）$kart[0..][0..]
不终止；如果
ys
有限，您的
kart
仅包含多个
x
s。您最后的输出列表缺失
（1105）
。它仍然令人印象深刻。我还没有机会运行Norman Ramsey的，但它看起来很棒。笛卡尔的产品很吸引人。我用
mergeAll
生成了一个，其中任何不重复的都是一个素数。@fp_mora这是下一个，试试
拿21美元的卡丁车i3[1..][100..
或
卡丁车i3[1..][100..]！！20
或
elemIndex（1105）$kart_i3[1..][100..
。
！！
使用的Haskell索引是基于0的。由于你的问题，我希望从现在开始记得
elemIndex
；谢谢！（我现在意识到这是我需要使用的，唉，这是大量的尝试和错误，哦）@will__ness对角线可以使用三角形数字。当取无限列表的第一部分时，我们总是使用5或10的倍数。如果我们想要20，那么
trin=foldl（+）1[2..n]
和
revtn=floor（sqrt（n*2））
We
revtn 20
返回
6
最上面一行的长度。
tri 6
返回
21
，对角线上的元素数和三角形数。你的Lambda演算生成器充满了（^x（x））（^x（x））（^x（x）），让Haskell大吃一惊。
(x:xs) >>= g = g x ++ (xs >>= g)
(x:xs) ++ ys = x : (xs ++ ys)

(x:xs) >>/ g = g x +/ (xs >>/ g)
(x:xs) +/ ys = x : (ys +/ xs)
[]     +/ ys = ys

kart_i xs ys = xs >>/ (\x ->
               ys >>/ (\y -> [(x,y)]))

Prelude> take 20 $ kart_i [1..] [100..]
[(1,100),(2,100),(1,101),(3,100),(1,102),(2,101),(1,103),(4,100),(1,104),(2,102)
,(1,105),(3,101),(1,106),(2,103),(1,107),(5,100),(1,108),(2,104),(1,109),(3,102)]

kart_i2 xs ys = foldr g [] [map (x,) ys | x <- xs]
  where
     g a b = head a : head b : g (tail a) (tail b)

kart_i3 xs ys = g [] [map (x,) ys | x <- xs]
  where                                          -- works both for finite 
     g [] [] = []                                --  and infinite lists
     g a  b  = concatMap (take 1) a
                ++ g (filter (not.null) (take 1 b ++ map (drop 1) a))
                     (drop 1 b)

Prelude> take 20 $ kart_i3 [1..] [100..]
[(1,100),(2,100),(1,101),(3,100),(2,101),(1,102),(4,100),(3,101),(2,102),(1,103)
,(5,100),(4,101),(3,102),(2,103),(1,104),(6,100),(5,101),(4,102),(3,103),(2,104)]

genFromPair (e1, e2) = [x*e1 + y*e2 | x <- [0..], y <- [0..]]

genFromPair (e1, e2) = [0*e1 + y*e2 | y <- [0..]]

Prelude> let kart = (\xs ys -> [(x,y) | ls <- map (\x -> map (\y -> (x,y))  ys)  xs, (x,y) <- ls])
Prelude> :t kart
kart :: [t] -> [t1] -> [(t, t1)]
Prelude> take 10 $ kart [0..] [1..]
[(0,1),(0,2),(0,3),(0,4),(0,5),(0,6),(0,7),(0,8),(0,9),(0,10)]
Prelude> take 10 $ kart [0..] [5..10]
[(0,5),(0,6),(0,7),(0,8),(0,9),(0,10),(1,5),(1,6),(1,7),(1,8)]

a1 a2 a3 a4
b1 b2 b3
c1 c2
d1

[(m,n) |i <-[1..4], (m,n) <-zip (take i "abcd") (reverse $ take i "1234")]

diag2 xs ys = [(m,r) |n <-[1..], (m,r) <-zip (take n xs) (reverse $ take n ys)]
take 21 $ diag2 [1..] [1..]