Operations with lists

Hi Slawa,

Your first question is how to make a list of unique elements, I cannot take credit for writing this, but here is some useful code for doing such an operation:

  procedure(uniquify(L)
    let(((hash makeTable("uniqueList" nil)) (q L) (p cdr(L)))
        hash[car(L)] = t
        while(p
          if(hash[car(p)] then
              p = cdr(p)
              setcdr(q p)
          else
              hash[car(p)] = t
              q = p
              p = cdr(p)
          ); if
        ); while
        L
    ); let
  ); procedure
  ;; this does not change the sort order of the list and is of order N, 
  ;; it uses local variables and a hash table for storage
  
  uniquify(list1)
  => (1 2 3 4)

The other part of your first question, how to remove all repeating elements from the list leaving only elements that were never present more than once; I will have to think about how that can be done.

Your second question is asking for the intersection (or "overlap") of two lists, this can be coded as below:

  procedure(overlap(L1 L2)
    setof(item L1 member(item L2))
  ); procedure
  
  list1 = '(1 2 3 4 5)
  list2 = '(2 4 6 7)
  overlap(list1 list2)
  => (2 4)

 (The procedure name "intersect" already exists, it is a waveform function) This may not be the most efficient code, but if the lists are 'small' then it should be sufficient.

Hopefully this helps you!

Regards,

Lawrence.

1/ Use the newish "unique" command: unique('(1 2 3 4 3 2 1)) => (1 2 3 4)

2/ Try this function:

defun( Lists_or (@rest lists), let((orLst), mapcar(lambda((lst), orLst = append(orLst, if(listp(lst), lst, list(lst)))), lists), unique(orLst)))

Lists_or('(1 2 3 4 5) '(2 4 6 7) ) => (1 2 3 4 5 6 7)

Lists_or('(1 2 3 4 5) 8) => (1 2 3 4 5 8)

Regards,

Dave

Dave,

I think that "unique" must be local custom code, it is not present in the IC5141 or IC614 releases (IC615 is not out yet, so I don't know if that contains such a function, but my guess is that it does not) .

I'm still thinking about how to remove all copies of repeated elements so that only elements that appeared once are included in the output list...

Regards,

Lawrence.

Oops, yes - "unique" is an Allegro function. This is the function I used before "unique" came along:

defun( RemoveDuplicates (itemlist)
 let((sublist)
  while(itemlist
    sublist = cons(car(itemlist), sublist)
    itemlist = remove(car(itemlist), itemlist)
  )
  reverse(sublist)
))

I don't think it's very efficient.

All many thanks for the help.

 To Lawrence ->I hope you can help to solve to me a problem with removal of repeating elements together with their duplicates. But even if it will not turn out, you have very much helped me, thanks.

Best regards

Slawa 

Finding the items only used once in the list could also be achieved with a table:

procedure(usedOnce(L)
  let((count newL)
    count = makeTable("count" 0)
    foreach(item L
        count[item] = count[item]+1
    )
    newL = setof(x L count[x]==1)
  ) ;let
) ;proc

To remove list2 items from list1, do the following:

newList = setof(x list1 !member(x list2))

Derek