Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Unique integers in a list (Ramesh Kumar)
2. Re: Unique integers in a list (Prasanna K Rao)
3. Unique integers in a list (AbdulSattar Mohammed)
4. Re: Unique integers in a list (Ramesh Kumar)
----------------------------------------------------------------------
Message: 1
Date: Tue, 27 Mar 2012 19:03:05 -0700 (PDT)
From: Ramesh Kumar <[email protected]>
Subject: [Haskell-beginners] Unique integers in a list
To: "[email protected]" <[email protected]>
Message-ID:
<[email protected]>
Content-Type: text/plain; charset="iso-8859-1"
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
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20120327/09420334/attachment-0001.htm>
------------------------------
Message: 2
Date: Tue, 27 Mar 2012 22:40:52 -0700 (PDT)
From: Prasanna K Rao <[email protected]>
Subject: Re: [Haskell-beginners] Unique integers in a list
To: Ramesh Kumar <[email protected]>,
"[email protected]" <[email protected]>
Message-ID:
<[email protected]>
Content-Type: text/plain; charset="iso-8859-1"
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
and use it like this::
unique (x:xs) ? = if not(isin x xs) then [x] ++ unique(xs) else unique(xs)
or like this::
unique(x:xs) ? ?= [x | x <- (x:xs), not(isin x xs)] ++ unique xs
The later being the preferred one. HTH..
Regards,
________________________________
From: Ramesh Kumar <[email protected]>
To: "[email protected]" <[email protected]>
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
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20120327/7358657b/attachment-0001.htm>
------------------------------
Message: 3
Date: Wed, 28 Mar 2012 12:00:49 +0530
From: AbdulSattar Mohammed <[email protected]>
Subject: [Haskell-beginners] Unique integers in a list
To: [email protected]
Message-ID:
<ca+mxqh_cb80jsqspxebf-5tja2bfd1ofkhtzdir0au2tzhj...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
On Wed, Mar 28, 2012 at 11:10 AM, Prasanna K Rao <[email protected]>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 <[email protected]>
> *To:* "[email protected]" <[email protected]>
> *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
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> 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-0001.htm>
------------------------------
Message: 4
Date: Tue, 27 Mar 2012 23:53:49 -0700 (PDT)
From: Ramesh Kumar <[email protected]>
Subject: Re: [Haskell-beginners] Unique integers in a list
To: Prasanna K Rao <[email protected]>, "[email protected]"
<[email protected]>
Message-ID:
<[email protected]>
Content-Type: text/plain; charset="iso-8859-1"
Thanks Prasanna.
Is there a base case for the solution with recursion?
I'm trying with this code but I'm not getting the actual desired result:
isIn :: Integer -> [Integer] -> Bool
isIn _ [] = False
isIn n (x:xs) = if (n == x) then True else isIn n xs
unique :: [Integer] -> [Integer]
unique [] = []
unique (x:xs)?? = if not(isIn x xs) then [x] ++ unique(xs) else unique(xs)
*Main> unique [1,2,3,4,5,4]
[1,2,3,5,4]???????? *** should have been? [1,2,3,5]
Thanks & Regards.
>________________________________
> From: Prasanna K Rao <[email protected]>
>To: Ramesh Kumar <[email protected]>; "[email protected]"
><[email protected]>
>Sent: Wednesday, March 28, 2012 1:40 PM
>Subject: Re: [Haskell-beginners] Unique integers in a list
>
>
>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
>
>
>and use it like this::
>
>
>unique (x:xs) ? = if not(isin x xs) then [x] ++ unique(xs) else unique(xs)
>
>
>
>or like this::
>
>
>unique(x:xs) ? ?= [x | x <- (x:xs), not(isin x xs)] ++ unique xs
>
>
>The later being the preferred one. HTH..
>
>
>Regards,
>
>
>
>
>
>
>________________________________
> From: Ramesh Kumar <[email protected]>
>To: "[email protected]" <[email protected]>
>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
>[email protected]
>http://www.haskell.org/mailman/listinfo/beginners
>
>
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20120327/f146d6e1/attachment.htm>
------------------------------
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 45, Issue 34
*****************************************
