Flatten a List And Find The Largest Atom Using LISP Assignment Solution.

; Function that takes a single list of numbers and returns the largest number.

(defun flat-max (lst)

    (if (null (cdr lst)) ; if there's only one element

        ; return the first element

        (car lst)

        ; else, return the max of the first element and the list tail

        (max (car lst) (flat-max (cdr lst)))

    )

)

; Function that takes a nested list of numbers and returns the largest number.

(defun full-max (lst)

    (let

        ; get first element in list

        ((first-elem

            (if (listp (car lst)) ; if the element is a list

                (full-max (car lst)) ; first element is the max of the list

                (car lst) ; else it's the first element

            )

        ))

        (if (null (cdr lst)) ; if there's only one element

            ; return the first element

            first-elem

            ; else, return the max of the first element and the list tail

            (max first-elem (full-max (cdr lst)))

        )

    )

)

; Function that takes a single list and returns the reversed list.

(defun flat-rev (lst)

    (if (null lst) ; if empty list

        lst ; return the list

        ; else, return the inverted list tail and append the first element at the end

        (append (flat-rev (cdr lst)) (list (car lst)))

    )

)

; Function that takes a nested list and returns the reversed list.

(defun full-rev (lst)

    (if (null lst) ; if empty list

        lst ; return the list

        ; else, return the inverted list tail and append the first element at the end

        (append (full-rev (cdr lst))

            (if (listp (car lst)) ; if element is a list

                (list (full-rev (car lst))) ; reverse list before appending

                (list (car lst)) ; else, append element as list

            )

        )

    )

)

; Function that takes a nested list and returns a flattened version of the list.

(defun flatten (lst)

    (if (null lst) ; if empty list

        lst ; return the list

        (if (listp (car lst)) ; else, if first element is a list

            ; if it's a list, append flattened tail list at end of first list

            (append (flatten (car lst)) (flatten (cdr lst)))

            ; if not a list, add first element to start of flattened tail list

            (cons (car lst) (flatten (cdr lst)))

        )

    )

)

;???? Apply function sub to expression

(defun apply-sub (expr sub)

    (funcall sub expr) ; evaluate function sub using the given expr value

)

;??? Apply function sub1 after function sub2

(defun compose (sub1 sub2)

    ; create a new function that evaluates sub2 and uses the result to evaluate sub1

    (lambda (&rest x) (funcall sub1 (apply sub2 x)))

)