Haskell: Разделяне на списък в кортеж от два нови списъка

Вашата функция split връща двойка, но в последния случай използвате ++ за резултата от split. Това ще бъде типова грешка, тъй като ++ работи със списъци, а не с двойки. Има и грешка при типа, защото fst и snd са функции за избиране на елементите на двойка, но вие ги използвате по странен начин.

Освен това използвайте съвпадение на шаблони вместо дължина. Също така, случаят, в който тествате дали дължината е 2, не е необходим, тъй като общият случай премахва 2 елемента, което ви отвежда до основния случай на празния списък.

Можете също да направите функцията си по-обща, като използвате променлива тип a вместо Int в типа.

[Редактиране]: Добавен код

split :: [a] -> ([a], [a])
split [] = ([], [])
split [x] = ([x], [])
split (x:y:xys) = (x:xs, y:ys) where (xs, ys) = split xys

Друг начин да направите това е с взаимна рекурсия. Излиза много лесно за четене:

split xs = (odds xs, evens xs)

odds (x:xs) = x : evens xs
odds xs     = []

evens xs = odds (drop 1 xs)

split :: [a] -> ([a], [a])
split xs | null xs = ([], [])
         | otherwise = (head xs : snd pair, fst pair)
  where pair = split (tail xs)

Но трябва да използвате сгъване:

split :: [a] -> ([a], [a])
split = foldr (\x (ys, zs) -> (x : zs, ys)) ([], [])

Уикито Blow Your Mind на Haskell има няколко реда:

-- splitting in two (alternating)
-- "1234567" -> ("1357", "246")

-- the lazy match with ~ is necessary for efficiency, especially enabling
-- processing of infinite lists
foldr (\a ~(x,y) -> (a:y,x)) ([],[])

(map snd *** map snd) . partition (even . fst) . zip [0..]

transpose . unfoldr (\a -> toMaybe (null a) (splitAt 2 a))

Две алтернативни версии:

split = conv . map (map snd) . groupWith (even.fst) . zip [0..] where
  conv [xs,ys] = (xs,ys)

split xs = (ti even xs, ti odd xs) where
  ti f = map snd . filter (f.fst) . zip [0..]

Има грешка в последната клауза. Трябва да получите резултати от рекурсивно извикване и след това да добавите първи и втори елемент към тях.

split :: [Int] -> ([Int],[Int])
split xs | length(xs) == 0 = ([],[])
         | length(xs) == 1 = (xs !! 0 : [],[])
         | length(xs) == 2 = (xs !! 0 : [], xs !! 1 : [])
         | otherwise = let (fst, snd) = split(drop 2 xs) in
                     (xs !! 0 : fst, xs !! 1 : snd)

В случай, че търсите някакъв алтернативен начин да направите това, по-долу е едно такова изпълнение:

split xs = 
     let (a,b) = partition (odd . snd) (zip xs [1..]) 
     in ( (map fst a), (map fst b))

Ето едно просто решение:

Като вземем списък [a], можем да го разделим на два нови списъка, първо започваме с деклариране на това, което се случва с празен списък, тук можете да избирате между връщане на грешка Празен списък или просто връщане на два празни списъка, както е показано по-долу , в случай на един елемент в списъка, ние го разделяме на един, съдържащ x и един празен списък ([x],[ ]). В случаите с размер на списъка › 1 ние изчисляваме n (дължината на списъка, разделена на 2), след което „вземаме“ първите n елемента в нов списък и „изтриваме“ n елемента от оригиналния списък xs.

split :: [a] -> ([a],[a])
split [] = ([],[])
split [x] = ([x],[])
split xs = (take n xs, drop n xs)
    where n = (length xs) `div` 2