Given 2 lists Olist and Clist. I want to remove items that appears in
both list. How best to do this?

Say,

(setq Olist (list "a" "b" "c" "d" "e"))
(setq Clist (list "ee" "a" "d" "c" "bb"))

i want the result to be like

(setq Olist (list "b" "e"))
(setq Clist (list "ee" "bb"))

order doesn't matter.

i think i can go thru each element and build OlistNew, and removing
Clist to build a ClistNew. But the checking existance and building
item by item would be difficult or very inefficient i think but am not
sure about lisp here.

should i turn them both into hash table first for easy checking
existance?

Thanks.

Xah
∑ http://xahlee.org/

☄

Posted to too many groups by mistake. Sorry. Fixed follow up to just
lisp and emacs.

On Jul 20, 3:16 pm, "xah...@gmail.com" gmail.com> wrote:

That's going on a t-shirt :-)

xahlee@gmail.com wrote:

In F#, convert the lists to sets and use set theoretic operations:

let Olist, Clist = set Olist, set Clist
let union = Olist + Clist
let Olist, Clist = Olist - union, Clist - union

Rainer Joswig and Kent Pitman suggested the Common Lisp solution:

(psetq Olist (set-difference Olist Clist :test #'string=)
Clist (set-difference Clist Olist :test #'string=))

Thanks to Rainer Joswig and Kent Pitman.

Jon Harrop wrote:

O, great. In Mathematica.

olist = {"a", "b", "c", "d", "e"};
clist = {"ee", "a", "d", "c", "bb"};

olist = Complement[olist, clist]
clist = Complement[clist, olist]

btw, if i'm curious and want to have a peek of docs of Caml or F# now
and then, is there a easy to use website?

--------------------------------------
David Kastrup offered a pure elisp solution:

On 2008-07-20, xahlee@gmail.com gmail.com> wrote:

Since you're assigning to variables, wouldn't this be off-topic in
comp.lang.functional? :)

;; items common to both sets

(intersection '("a" "b" "c") '("b" "c" "d") :test #'equal)

-> ("b" "c")

"xahlee@gmail.com" gmail.com> writes:

På Wed, 23 Jul 2008 08:49:03 +0200, skrev David Kastrup gnu.org>:

Not entirely true.
You could store one set in a hash table without making assumptions about
order.
Then you have k * n complexity. I believe SBCL does this for large lists.
K here is a high number so for small lists the approach above is still
better.

On Jul 22, 10:33 pm, "xah...@gmail.com" gmail.com> wrote:

Sorry, my F# code was wrong. It should have been:

let olist = set ["a"; "b"; "c"; "d"; "e"]
let clist = set ["ee"; "a"; "d"; "c"; "bb"]
let olist, clist = olist - clist, clist - olist

There is a site running OCamlJava somewhere but it is not the real
OCaml implementation (e.g. no tail calls).

Easiest to "apt-get install ocaml" under Linux or install Visual
Studio Shell and the F# distribution under Windows.

"John Thingstad" writes:

Hash codes _provide_ an order relation.