Hình tam giác một danh sách trong Haskell

Tôi quan tâm đến việc viết một hàm Haskell hiệu quả triangularize :: [a] -> [[a]], lấy một danh sách (có lẽ là vô hạn) và "tam giác hóa" nó thành một danh sách các danh sách. Ví dụ, triangularize [1..19]nên trả lại

[[1,  3,  6,  10, 15]
,[2,  5,  9,  14]
,[4,  8,  13, 19]
,[7,  12, 18]
,[11, 17]
,[16]]

Theo hiệu quả, tôi có nghĩa là tôi muốn nó chạy trong O(n)thời gian mà nđộ dài của danh sách.

Lưu ý rằng điều này khá dễ thực hiện trong một ngôn ngữ như Python, bởi vì việc thêm vào cuối danh sách (mảng) là một hoạt động thời gian không đổi. Một hàm Python rất bắt buộc thực hiện điều này là:

def triangularize(elements):
    row_index = 0
    column_index = 0
    diagonal_array = []
    for a in elements:
        if row_index == len(diagonal_array):
            diagonal_array.append([a])
        else:
            diagonal_array[row_index].append(a)
        if row_index == 0:
            (row_index, column_index) = (column_index + 1, 0)
        else:
            row_index -= 1
            column_index += 1
    return diagonal_array

Điều này xuất hiện bởi vì tôi đã sử dụng Haskell để viết một số chuỗi "tabl" trong Từ điển bách khoa toàn thư về chuỗi số nguyên (OEIS) và tôi muốn có thể chuyển đổi một chuỗi (1 chiều) thông thường thành một (2- chiều) thứ nguyên) trình tự các chuỗi theo cách chính xác.

Có lẽ có một số cách thông minh (hoặc không thông minh) để foldrvượt qua danh sách đầu vào, nhưng tôi không thể sắp xếp nó ra.

Làm tăng kích thước khối:

chunks :: [a] -> [[a]]
chunks = go 0 where
    go n [] = []
    go n as = b : go (n+1) e where (b,e) = splitAt n as

Sau đó chỉ cần hoán chuyển hai lần:

diagonalize :: [a] -> [[a]]
diagonalize = transpose . transpose . chunks

Hãy thử nó trong ghci:

> diagonalize [1..19]
[[1,3,6,10,15],[2,5,9,14],[4,8,13,19],[7,12,18],[11,17],[16]]

Điều này dường như có liên quan trực tiếp đến đối số lý thuyết tập hợp chứng minh rằng tập hợp các cặp số nguyên nằm trong sự tương ứng một-một với tập hợp các số nguyên (có thể đếm được ). Đối số liên quan đến cái gọi là hàm ghép Cantor .

Vì vậy, vì tò mò, hãy xem liệu chúng ta có thể có được một diagonalizechức năng theo cách đó không. Xác định danh sách vô hạn các cặp Cantor theo cách đệ quy trong Haskell:

auxCantorPairList :: (Integer, Integer) -> [(Integer, Integer)]
auxCantorPairList (x,y) =
    let nextPair = if (x > 0) then (x-1,y+1) else (x+y+1, 0)
    in (x,y) : auxCantorPairList nextPair

cantorPairList :: [(Integer, Integer)]
cantorPairList = auxCantorPairList (0,0)

Và thử điều đó bên trong ghci:

 λ> take 15 cantorPairList
[(0,0),(1,0),(0,1),(2,0),(1,1),(0,2),(3,0),(2,1),(1,2),(0,3),(4,0),(3,1),(2,2),(1,3),(0,4)]
 λ> 

Chúng ta có thể đánh số các cặp và ví dụ trích xuất các số cho các cặp có tọa độ 0 x:

 λ> 
 λ> xs = [1..]
 λ> take 5 $ map fst $ filter (\(n,(x,y)) -> (x==0)) $ zip xs cantorPairList
[1,3,6,10,15]
 λ> 

Chúng tôi nhận ra đây là hàng trên cùng từ kết quả của OP trong văn bản của câu hỏi. Tương tự cho hai hàng tiếp theo:

 λ> 
 λ> makeRow xs row = map fst $ filter (\(n,(x,y)) -> (x==row)) $ zip xs cantorPairList
 λ> take 5 $ makeRow xs 1
[2,5,9,14,20]
 λ> 
 λ> take 5 $ makeRow xs 2
[4,8,13,19,26]
 λ> 

Từ đó, chúng ta có thể viết bản nháp đầu tiên của một diagonalizehàm:

 λ> 
 λ> printAsLines xs = mapM_ (putStrLn . show) xs
 λ> diagonalize xs = takeWhile (not . null) $ map (makeRow xs) [0..]
 λ> 
 λ> printAsLines $ diagonalize [1..19]
[1,3,6,10,15]
[2,5,9,14]
[4,8,13,19]
[7,12,18]
[11,17]
[16]
 λ> 

EDIT: cập nhật hiệu suất

Đối với danh sách 1 triệu mục, thời gian chạy là 18 giây và 145 giây cho 4 triệu mục. Như Redu đã đề cập, điều này có vẻ như phức tạp O (n√n).

Phân phối các cặp trong số các danh sách mục tiêu khác nhau là không hiệu quả, vì hầu hết các hoạt động của bộ lọc đều thất bại.

Để cải thiện hiệu suất, chúng tôi có thể sử dụng cấu trúc Data.Map cho danh sách con mục tiêu.

{-#  LANGUAGE  ExplicitForAll       #-}
{-#  LANGUAGE  ScopedTypeVariables  #-}

import qualified  Data.List  as  L
import qualified  Data.Map   as  M

type MIL a = M.Map Integer [a]

buildCantorMap :: forall a.  [a] -> MIL a
buildCantorMap xs = 
    let   ts     =  zip xs cantorPairList -- triplets (a,(x,y))
          m0     = (M.fromList [])::MIL a
          redOp m (n,(x,y)) = let  afn as = case as of
                                              Nothing  -> Just [n]
                                              Just jas -> Just (n:jas)
                              in   M.alter afn x m
          m1r = L.foldl' redOp m0 ts
    in
          fmap reverse m1r

diagonalize :: [a] -> [[a]]
diagonalize xs = let  cm = buildCantorMap xs
                 in   map snd $ M.toAscList cm

Với phiên bản thứ hai đó, hiệu suất có vẻ tốt hơn nhiều: 568 msec cho danh sách 1 triệu mặt hàng, 2669 msec cho danh sách 4 triệu mặt hàng. Vì vậy, nó gần với độ phức tạp O (n * Log (n)) mà chúng ta có thể hy vọng.

Nó có thể là một ý tưởng tốt để vượt qua một combbộ lọc.

Vậy combbộ lọc làm gì ..? Nó giống như splitAtnhưng thay vì chia tách theo một chỉ mục duy nhất, nó sắp xếp danh sách vô hạn đã cho bằng lược đã cho để phân tách các mục được xác định Truevà Falsetrong lược. Như vậy mà;

comb :: [Bool]  -- yields [True,False,True,False,False,True,False,False,False,True...]
comb = iterate (False:) [True] >>= id

combWith :: [Bool] -> [a] -> ([a],[a])
combWith _ []          = ([],[])
combWith (c:cs) (x:xs) = let (f,s) = combWith cs xs
                         in if c then (x:f,s) else (f,x:s)

λ> combWith comb [1..19]
([1,3,6,10,15],[2,4,5,7,8,9,11,12,13,14,16,17,18,19])

Bây giờ tất cả những gì chúng ta cần làm là kết hợp danh sách vô hạn của chúng ta và lấy fsthàng đầu tiên và tiếp tục kết hợp sndvới cùng comb.

Hãy làm nó;

diags :: [a] -> [[a]]
diags [] = []
diags xs = let (h,t) = combWith comb xs
           in h : diags t

λ> diags [1..19]
[ [1,3,6,10,15]
, [2,5,9,14]
, [4,8,13,19]
, [7,12,18]
, [11,17]
, [16]
]

cũng có vẻ lười biếng quá :)

λ> take 5 . map (take 5) $ diags [1..]
[ [1,3,6,10,15]
, [2,5,9,14,20]
, [4,8,13,19,26]
, [7,12,18,25,33]
, [11,17,24,32,41]
]

Tôi nghĩ rằng sự phức tạp có thể giống như O (n√n) nhưng tôi không thể chắc chắn. Có ý kiến ​​gì không ..?