Question

I am not experienced in LISP and list processing, but I have a set of C++ STL vectors (or strings) on which I need to perform the following operations:

IdenticalHead (v1, v2): Return the biggest sequence that both v1 and v2 start with it.

IdenticalTail (v1, v2): Return the biggest sequence that both v1 and v2 end with it.

IdenticalTailHead (v1, v2): Return the biggest sequence that v1 ends with it and v2 starts with it.

For example:

if v1 = (a,b,c,e,f), v2 = (a,b,d,e,f), then:

IdenticalHead (v1, v2) = (a,b)
IdenticalTail (v1, v2) = (e,f)

if v1 = (a,b,c), v2 = (b,c,g), then:

IdenticalTailHead (v1, v2) = (b,c)

My question is that are these standard operations in LISP or any other language? Do they have standard names like CDR and CAR?

Answer 1

No, there are no standard operators for these. But identical-head is not hard to write:

(defun identical-head (l1 l2)
  (and l1 l2 (equal (car l1) (car l2))
       (cons (car l1) (identical-head (cdr l1) (cdr l2)))))

I don’t know of an easier way to write identical-tail except reversing the input lists, calling identical-head, and then reversing the result, since lists only allow forward traversal, not backward.

(defun identical-tail (l1 l2)
  (reverse (identical-head (reverse l1) (reverse l2))))

Here’s how I’d write identical-tail-head:

(defun identical-tail-head (l1 l2)
  (labels ((starts-with-p (list prefix)
             (cond ((null prefix) t)
                   ((null list) nil)
                   ((equal (car list) (car prefix))
                    (starts-with-p (cdr list) (cdr prefix))))))
    (cond ((null l1) nil)
          ((starts-with-p l2 l1) l1)
          (t (identical-tail-head (cdr l1) l2)))))

It’s not a very efficient way to do it, since it’s O(n²), but (again) given that lists are forward-traversal-only, I haven’t come up with a better way.