[Haskell-beginners] Unique integers in a list

[AbdulSattar Mohammed]

On Wed, Mar 28, 2012 at 11:10 AM, Prasanna K Rao <prasannakrao at yahoo.com>wrote:

> Hi,
>
> One way is to define a 'isin' function like this::
>
> isin x (a:[])  = if (x == a) then True else False
> isin x (a:as)  = if (x == a) then True else isin x as
>
>
Unnecessary. We have elem for that.


> and use it like this::
>
> unique (x:xs)   = if not(isin x xs) then [x] ++ unique(xs) else unique(xs)
>

It removes duplicates. Does not remove the elements that have duplicates
(which was asked by OP). It also needs the empty list check to terminate.
It'll fail with Non-exhaustive patterns.

>
> or like this::
>
> unique(x:xs)    = [x | x <- (x:xs), not(isin x xs)] ++ unique xs
>

The not(isin x xs) will definitely fail for all the elements except the
first one because those elements are being taken from xs.


>
> The later being the preferred one. HTH..
>
> If you see correctly, the former is the preferred one (giving different
solution).

To OP,
When we pass x to isSingle x xs, we know that there is at least one x in
xs. If we remove that x and check for the existence of x in the remainder
of the list, we know if there is more than one x.

isSingle x xs = x `notElem` (delete x xs)

delete is in Data.List.

> Regards,
>
>
>   ------------------------------
> *From:* Ramesh Kumar <rameshkumar.techdynamics at ymail.com>
> *To:* "Beginners at haskell.org" <Beginners at haskell.org>
> *Sent:* Wednesday, March 28, 2012 3:03 AM
> *Subject:* [Haskell-beginners] Unique integers in a list
>
> Hi,
>
> I've just started learning Haskell a couple of weeks ago using Simon
> Thompson's "Haskell: Craft of Functional Programming".
> There is an exercise in chapter 7 of the book which goes something like
> this:
>
> Define a function of the type:     unique :: [Integer] -> [Integer]
> which if given a list of integers, should return a list of those integers
> which occur only once in the input list.
> Example:
>    unique [5,2,4,2,3,1,5,2] should result in [4,3,1]
>
>
> *** The questions assumes we know only of list comprehensions and
> recursion.
>
> I am guessing the solution must include something like this:
>
> unique :: [Integer] -> [Integer]
> unique xs = [ x | x <- xs, isSingle x ]
>
> My problem is in defining the function 'isSingle'.
>
> I would greatly appreciate any pointers on this.
>
> Many thanks.
> Ramesh
>
>
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>


-- 
Warm Regards,

AbdulSattar Mohammed



-- 
Warm Regards,

AbdulSattar Mohammed
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/beginners/attachments/20120328/b5269a40/attachment.htm>