Hi to all!
I attempted some end of chapter exercises and got stuck with this one
below. Please help me with HINTS so I can understand HOW TO solve it.
Given two lists:
lst1 = (bananas kiwis)
lst2 = (kiwis pears plums bananas cherries)
Write a function occurN that counts how many times an atom in lst1 also
occurs in lst2.
An output using the above lists would look like: (occurN lst1 lst2) is
2.
This is what I have
(defun occurN (lst1 lst2)
(cond
( (or
(null lst1)
(null lst2) )
0)
(t (cond
( (eq (car lst1) (car lst2) )
(1+ (occurN lst1 (cdr lst2) ) ) ) ;atom may appear more than
once
( (occurN lst1 (cdr lst2) ) ) ;increment lst2
(t (occurN (cdr lst1) lst2) ) ) ) ) )
My function gives me 1. I know that its only processing the first
element in list1 and terminating when list2 is null but I dont know how
to extend it so that it also processes the rest of the elements of
lst1. Any hints??
" (typep 'nil '(satisfies identity)) => ?" <··············@yahoo.it> writes:
> (defun counter (list1 list2)
> (length (intersection list1 list2 :test #'eql)))
This isn't what was demanded. It may happen that with some input, and
on some implementations, you get the same results, but the odds are
against you.
--
__Pascal Bourguignon__ http://www.informatimago.com/
Cats meow out of angst
"Thumbs! If only we had thumbs!
We could break so much!"
"Pascal Bourguignon" <····@mouse-potato.com> wrote in message ···················@thalassa.informatimago.com...
>" (typep 'nil '(satisfies identity)) => ?" <··············@yahoo.it> writes:
>> (defun counter (list1 list2)
>> (length (intersection list1 list2 :test #'eql)))
>
> This isn't what was demanded. It may happen that with some input, and
> on some implementations, you get the same results, but the odds are
> against you.
Actually it's not that bad, the problem is
ill-defined if the input lists are not sets.
The phrasing of the question is ambiguous
as to exactly what is being counted.
--
Geoff
Pascal,just read again the first posting and you will find that it is
the right answer!
Given two lists:
lst1 = (bananas kiwis)
lst2 = (kiwis pears plums bananas cherries)
Write a function occurN that counts how many times an atom in lst1 also
occurs in lst2.
Especially when you assume that all elements of the two lists are
symbols.
We might discuss about the test function eq or eql to use, or
implementations that operate sligtly different, but don't ask me to
reference to all possible odds.
the universe is huge, my time is short!
" (typep 'nil '(satisfies identity)) => ?" <··············@yahoo.it> writes:
> Pascal,just read again the first posting and you will find that it is
> the right answer!
>
>
> Given two lists:
> lst1 = (bananas kiwis)
> lst2 = (kiwis pears plums bananas cherries)
>
> Write a function occurN that counts how many times an atom in lst1 also
>
> occurs in lst2.
>
>
>
> Especially when you assume that all elements of the two lists are
> symbols.
>
> We might discuss about the test function eq or eql to use, or
> implementations that operate sligtly different, but don't ask me to
> reference to all possible odds.
> the universe is huge, my time is short!
All right. This "also" indeed seems to indicate that the result must
be less or equal to the length of lst1. I overlooked it and
understood the semantics I implemented in my first follow-up. But I'm
not sure set semantics is what is expected, since the containers are
called lst, not set.
What result would be expected with: lst1 = (bananas kiwis bananas)?
or with: lst2 = (kiwis kiwis bananas pears plums bananas cherries)?
Once again, the only correct answer should have been:
Specifications ambiguous or incomplete.
Please refine our specifications.
--
__Pascal Bourguignon__ http://www.informatimago.com/
Our enemies are innovative and resourceful, and so are we. They never
stop thinking about new ways to harm our country and our people, and
neither do we. -- Georges W. Bush
zion_zii <·········@gmail.com> wrote:
> I attempted some end of chapter exercises and got stuck with this one
> below. Please help me with HINTS so I can understand HOW TO solve it.
>
> Given two lists:
> lst1 = (bananas kiwis)
> lst2 = (kiwis pears plums bananas cherries)
>
> Write a function occurN that counts how many times an atom in lst1 also
> occurs in lst2.
> An output using the above lists would look like: (occurN lst1 lst2) is
> 2.
In your case (assuming just car, cdr, null, atom, etc.) I would start
by splitting the problem in two parts: first write a function, say
ATOM-IN-LIST-P that takes an atom and a list and returns T if the atom
is in the list (and NIL otherwise). Then you can write your desired
function on top of that.
Hey thanks a whole lot. I dont know why I didnt think of it before but
I did as you suggested. I implemented
atom-in-list as follows:
(defun atom-in-list (key lst)
(cond
( (null lst) 0)
(t (cond
( (eq (car lst) key)
(1+ (atom-in-list key (cdr lst) ) ) )
(t (atom-in-list key (cdr lst) ) ) ) ) ) )
and then I called it within occurN as follows:
(defun occurN (lst1 lst2)
(cond
( (or
(null lst1)
(null lst2))
0)
(t (+ (atom-in-list (car lst1) lst2)
(occurN (cdr lst1) lst2) ) ) ) )
This gave me the right answer. Once again. Thanks a whole bunch.
"It is through such communities that real intellectual growth
manifests. The truth faces you elusively" -N.KIGS
"zion_zii" <·········@gmail.com> writes:
> Hey thanks a whole lot. I dont know why I didnt think of it before but
> I did as you suggested. I implemented
> atom-in-list as follows:
>
> (defun atom-in-list (key lst)
> (cond
> ( (null lst) 0)
> (t (cond
> ( (eq (car lst) key)
> (1+ (atom-in-list key (cdr lst) ) ) )
> (t (atom-in-list key (cdr lst) ) ) ) ) ) )
>
> and then I called it within occurN as follows:
>
> (defun occurN (lst1 lst2)
> (cond
> ( (or
> (null lst1)
> (null lst2))
> 0)
> (t (+ (atom-in-list (car lst1) lst2)
> (occurN (cdr lst1) lst2) ) ) ) )
>
> This gave me the right answer. Once again. Thanks a whole bunch.
Well, if you call another function like this, you could as well use
the existing Common Lisp functions.
(defun occur-n (elements list) (count-if (lambda (x) (member x elements)) list))
--
__Pascal Bourguignon__ http://www.informatimago.com/
"You question the worthiness of my code? I should kill you where you
stand!"
Here is my solution using apply and mapcar :
CL-USER> (defun occurN (lst1 lst2)
(apply #'+ (mapcar #'(lambda (e) (count e lst2))
lst1)))
OCCURN
CL-USER> (occurn '(1 2) '(1 2 1 2 1 2))
6
CL-USER> (occurn '() '(a))
0
CL-USER> (occurn '(a) '())
0
CL-USER> (occurn '(bananas kiwis) '(kiwis pears plums bananas
cherries))
2
zion_zii skrev:
> Hi to all!
> I attempted some end of chapter exercises and got stuck with this one
> below. Please help me with HINTS so I can understand HOW TO solve it.
>
> Given two lists:
> lst1 = (bananas kiwis)
> lst2 = (kiwis pears plums bananas cherries)
>
> Write a function occurN that counts how many times an atom in lst1 also
> occurs in lst2.
> An output using the above lists would look like: (occurN lst1 lst2) is
> 2.
> This is what I have
>
> (defun occurN (lst1 lst2)
> (cond
> ( (or
> (null lst1)
> (null lst2) )
> 0)
> (t (cond
> ( (eq (car lst1) (car lst2) )
> (1+ (occurN lst1 (cdr lst2) ) ) ) ;atom may appear more than
> once
> ( (occurN lst1 (cdr lst2) ) ) ;increment lst2
> (t (occurN (cdr lst1) lst2) ) ) ) ) )
>
> My function gives me 1. I know that its only processing the first
> element in list1 and terminating when list2 is null but I dont know how
> to extend it so that it also processes the rest of the elements of
> lst1. Any hints??
Here is my solution using apply and mapcar :
CL-USER> (defun occurN (lst1 lst2)
(apply #'+ (mapcar #'(lambda (e) (count e lst2))
lst1)))
OCCURN
CL-USER> (occurn '(1 2) '(1 2 1 2 1 2))
6
CL-USER> (occurn '() '(a))
0
CL-USER> (occurn '(a) '())
0
CL-USER> (occurn '(bananas kiwis) '(kiwis pears plums bananas
cherries))
2
zion_zii skrev:
> Hi to all!
> I attempted some end of chapter exercises and got stuck with this one
> below. Please help me with HINTS so I can understand HOW TO solve it.
>
> Given two lists:
> lst1 = (bananas kiwis)
> lst2 = (kiwis pears plums bananas cherries)
>
> Write a function occurN that counts how many times an atom in lst1 also
> occurs in lst2.
> An output using the above lists would look like: (occurN lst1 lst2) is
> 2.
> This is what I have
>
> (defun occurN (lst1 lst2)
> (cond
> ( (or
> (null lst1)
> (null lst2) )
> 0)
> (t (cond
> ( (eq (car lst1) (car lst2) )
> (1+ (occurN lst1 (cdr lst2) ) ) ) ;atom may appear more than
> once
> ( (occurN lst1 (cdr lst2) ) ) ;increment lst2
> (t (occurN (cdr lst1) lst2) ) ) ) ) )
>
> My function gives me 1. I know that its only processing the first
> element in list1 and terminating when list2 is null but I dont know how
> to extend it so that it also processes the rest of the elements of
> lst1. Any hints??
Here is my solution using apply and mapcar :
CL-USER> (defun occurN (lst1 lst2)
(apply #'+ (mapcar #'(lambda (e) (count e lst2))
lst1)))
OCCURN
CL-USER> (occurn '(1 2) '(1 2 1 2 1 2))
6
CL-USER> (occurn '() '(a))
0
CL-USER> (occurn '(a) '())
0
CL-USER> (occurn '(bananas kiwis) '(kiwis pears plums bananas
cherries))
2
zion_zii skrev:
> Hi to all!
> I attempted some end of chapter exercises and got stuck with this one
> below. Please help me with HINTS so I can understand HOW TO solve it.
>
> Given two lists:
> lst1 = (bananas kiwis)
> lst2 = (kiwis pears plums bananas cherries)
>
> Write a function occurN that counts how many times an atom in lst1 also
> occurs in lst2.
> An output using the above lists would look like: (occurN lst1 lst2) is
> 2.
> This is what I have
>
> (defun occurN (lst1 lst2)
> (cond
> ( (or
> (null lst1)
> (null lst2) )
> 0)
> (t (cond
> ( (eq (car lst1) (car lst2) )
> (1+ (occurN lst1 (cdr lst2) ) ) ) ;atom may appear more than
> once
> ( (occurN lst1 (cdr lst2) ) ) ;increment lst2
> (t (occurN (cdr lst1) lst2) ) ) ) ) )
>
> My function gives me 1. I know that its only processing the first
> element in list1 and terminating when list2 is null but I dont know how
> to extend it so that it also processes the rest of the elements of
> lst1. Any hints??
Here is my solution using apply and mapcar :
CL-USER> (defun occurN (lst1 lst2)
(apply #'+ (mapcar #'(lambda (e) (count e lst2))
lst1)))
OCCURN
CL-USER> (occurn '(1 2) '(1 2 1 2 1 2))
6
CL-USER> (occurn '() '(a))
0
CL-USER> (occurn '(a) '())
0
CL-USER> (occurn '(bananas kiwis) '(kiwis pears plums bananas
cherries))
2
zion_zii skrev:
> Hi to all!
> I attempted some end of chapter exercises and got stuck with this one
> below. Please help me with HINTS so I can understand HOW TO solve it.
>
> Given two lists:
> lst1 = (bananas kiwis)
> lst2 = (kiwis pears plums bananas cherries)
>
> Write a function occurN that counts how many times an atom in lst1 also
> occurs in lst2.
> An output using the above lists would look like: (occurN lst1 lst2) is
> 2.
> This is what I have
>
> (defun occurN (lst1 lst2)
> (cond
> ( (or
> (null lst1)
> (null lst2) )
> 0)
> (t (cond
> ( (eq (car lst1) (car lst2) )
> (1+ (occurN lst1 (cdr lst2) ) ) ) ;atom may appear more than
> once
> ( (occurN lst1 (cdr lst2) ) ) ;increment lst2
> (t (occurN (cdr lst1) lst2) ) ) ) ) )
>
> My function gives me 1. I know that its only processing the first
> element in list1 and terminating when list2 is null but I dont know how
> to extend it so that it also processes the rest of the elements of
> lst1. Any hints??