Lisp - Merging Sequences

---

---

In Lisp, we can merge sequences in multiple ways. In this chapter, we'll explore multiple scenarios and functions to merge sequences.

Concatenating Sequences

To concatenate List objects end-to-end, we can use append function as shown below:

Example - concatenating lists using append function

; concatenate and print merged list
(print (append '(1 2 3) '(4 5 6)))

Output

When you execute the code, it returns the following result −

(1 2 3 4 5 6)

To concatenate vector objects end-to-end, we can use array merging as shown below:

Example - concatenating lists using append function

; function to merge vectors
(defun mergeVectors(v1 v2)
   ; create size by merging length of two vectors
   (setq size (+ (length v1) (length v2)))
   ; create a vector of merged size
   (setq result (make-array size))
   
   ; loop over first vector and push the entries to the result vector   
   (loop for i from 0 below (length v1) 
      do (setf (aref result i) (aref v1 i)))
   ; loop over second vector and push the entries to the result vector   
   (loop for j from (length v1) below size 
      do (setf (aref result j) (aref v2 (- j (length v2)))))
   ; return the result
   result
)

; define vectors
(defvar v1 #(1 2 3))
(defvar v2 #(4 5 6))

; print merged vectors
(print(mergeVectors v1 v2))

Output

When you execute the code, it returns the following result −

#(1 2 3 4 5 6) 

To concatenate strings, We can use concatenate function as shown below:

Example - concatenating string using concatenate function

; concatenate strings
(write-line(concatenate 'string "Hello " "World")) 

Output

When you execute the code, it returns the following result −

Hello World

Interleaving Sequences

We can define a custom interleaving method to add alternate elements of two sequences as shown below:

Example - interleaving sequences

; define a function to interleave lists
(defun interleave (list1 list2)
  (cond
    ((null list1) list2)
    ((null list2) list1)
    (t (cons (car list1) (interleave list2 (cdr list1))))))

; interleave and print result
(print(interleave '(1 2 3) '(4 5 6))) 

Output

When you execute the code, it returns the following result −

(1 4 2 5 3 6)

Merging Sorted Sequences

In order to merge sorted sequences, while maintaining the sorted order, we can recursively sort and merge sequences as shown below:

Example - interleaving sequences

; merge a sorted sequence
(defun merge-sorted (list1 list2)
  (cond
    ((null list1) list2)
    ((null list2) list1)
    ((< (car list1) (car list2)) (cons (car list1) (merge-sorted (cdr list1) list2)))
    (t (cons (car list2) (merge-sorted list1 (cdr list2))))))

; print the sorted lists
(print(merge-sorted '(1 3 5) '(2 4 6)))

Output

When you execute the code, it returns the following result −

(1 2 3 4 5 6)