Устранение дубликатов полностью в Haskell

Question

У меня есть этот код, но он не делает то, что я хочу полностью, я беру список кортежей;

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

и дает

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

, но я хочу, чтобы дать

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

, где я делаю неправильно? Заранее спасибо.

eliminate :: [(Int,Int)] -> [(Int,Int)] 
eliminate [] = [] 
eliminate (x:xs) 
    | isTheSame xs x = eliminate xs 
    | otherwise  = x : eliminate xs 


isTheSame :: [(Int,Int)] -> (Int,Int) -> Bool 
isTheSame [] _ = False 
isTheSame (x:xs) a 
    | (fst x) == (fst a) && (snd x) == (snd a) = True 
    | otherwise     = isTheSame xs a 

Answer 1

Код почти правильно. Просто измените эту строку

| isTheSame xs x = eliminate xs 

в

| isTheSame xs x = eliminate $ filter (/=x) xs 

Причина заключается в том, что если x содержится в xs, вы хотите удалить все вхождений x.

Тем не менее, есть несколько частей в образце коды, которые могут быть выражены более элегантно:

• (fst x) == (fst a) && (snd x) == (snd a) такими же, как x == a
• isTheSame таких же, как elem, только с его аргументами обратными

Таким образом, мы могли бы выразить функцию eliminate так:

eliminate [] = [] 
eliminate (x:xs) 
    | x `elem` xs = eliminate $ filter (/=x) xs 
    | otherwise = x : eliminate xs  

Answer 2

Это следует сделать это:

-- all possibilities of picking one elt from a domain 
pick :: [a] -> [([a], a)] 
pick []  = [] 
pick (x:xs) = (xs,x) : [ (x:dom,y) | (dom,y) <- pick xs] 

unique xs = [x | (xs,x) <- pick xs, not (elem x xs)] 

Тестирование:

*Main Data.List> unique [(3,2),(1,2),(1,3),(1,2),(4,3),(3,2),(1,2)] 
[(1,3),(4,3)] 

here Больше и Splitting list into a list of possible tuples

---

После Landei's lead, вот короткая версия (хотя она будет возвращать свои результаты сортируются):

import Data.List 

unique xs = [x | [x] <- group . sort $ xs] 

Answer 3

Сокращенный вариант (но результаты будут отсортированы):

import Data.List 

eliminate :: [(Int,Int)] -> [(Int,Int)] 
eliminate = concat . filter ((== 1) . length) . group . sort 

Или с Maybe (спасибо, Маримутху):

import Data.List 
import Data.Maybe 

eliminate = mapMaybe f . group . sort where f [x] = Just x; f _ = Nothing 

Думая о ...мы могли бы использовать списки вместо Maybe:

import Data.List 

eliminate = (>>= f) . group . sort where f [x] = [x]; f _ = [] 

Answer 4

Неэффективная эталонная реализация.

import Data.List 

dups xs = xs \\ nub xs 
eliminate xs = filter (`notElem` dups xs) xs