Lisp: Элегантный способ вырезать конечный ноль из списка? (Обзор)

Question

Я хочу написать функцию, которая удаляет конечный нуль из списка. Я впервые попробовал написать его элегантно с помощью рекурсии, но в итоге так:

(defun strip-tail (lst) 
    (let ((last-item-pos (position-if-not #'null lst :from-end t))) 
    (if last-item-pos 
     (subseq lst 0 (1+ last-item-pos))))) 

; Test cases. 
(assert (eq nil (strip-tail nil))) 
(assert (eq nil (strip-tail '(nil)))) 
(assert (equal '(a b) (strip-tail '(a b nil nil)))) 
(assert (equal '(a nil b) (strip-tail '(a nil b nil)))) 
(assert (equal '(a b) (strip-tail '(a b)))) 

Это, возможно, ясно, но я не уверен. Есть ли более ленивый способ сделать это?

Answer 1

Вот что я придумал, если вы не против этого быть разрушительным:

(defvar foo (list 'a 'b 'c nil 'd 'e 'nil 'nil 'f nil nil)) 

(defun get-last-non-nil (list &optional last-seen) 
    (if list 
     (if (car list) 
      (get-last-non-nil (cdr list) list) 
      (get-last-non-nil (cdr list) last-seen)) 
     last-seen)) 

(defun strip-tail (list) 
    (let ((end (get-last-non-nil list))) 
    (if (consp end) 
     (when (car end) (setf (cdr end) nil) list)))) 

(strip-tail foo) -> (A B C NIL D E NIL NIL F) 

Answer 2

Ну, версия будет:

1. обратного список по
2. удалить ведущую Nils
3. свернуть переписку

Код:

(defun list-right-trim (list &optional item) 
    (setf list (reverse list)) 
    (loop for e in list while (eq item e) do (pop list)) 
    (reverse list)) 

Вот еще один вариант:

1. итерация по списку и отметьте положение первого нуля, который только затем Нильс
2. возвратных суб-последовательность

код:

(defun list-right-trim (list &aux (p nil)) 
    (loop for i from 0 and e in list 
    when (and (null p) (null e)) 
    do (setf p i) 
    else when (and p e) do (setf p nil)) 
    (if p (subseq list 0 p) list)) 

Answer 3

Я попытался с помощью рекурсии, но он не работает на GNU CL:

(defun strip(lst) 
    (if (null (last lst)) 
     (strip (butlast lst))    
    lst)) 

идея:

1. тест, если элемент последний список равен нулю, если так сделать рекурсивный вызов с последний элемент удаляется (butlast)
2. затем возвращают сам список

Answer 4

Ну, это я на самом деле это не ответ, но я подумал, что я тоже поставил бы это здесь, чтобы он был лучше видимым.

В вашей первоначальной реализации, как вы думаете, следует обрабатывать элементы без списка?

* (strip-tail "abcde") 

"abcde" 
* (strip-tail 42) 

debugger invoked on a TYPE-ERROR in thread #<THREAD "initial thread" {A69E781}>: 
    The value 42 is not of type SEQUENCE. 

Answer 5

(defun strip-tail (ls) 
    (labels ((strip-car (l) 
        (cond ((null l)  nil) 
         ((null (car l)) (strip-car (cdr l))) 
         (t    l)))) 
     (reverse (strip-car (reverse ls))))) 

Пример запуска (против ваших тестов):

[1]> (assert (eq nil (strip-tail nil))) 
NIL 
[2]> (assert (eq nil (strip-tail '(nil)))) ;' 
NIL 
[3]> (assert (equal '(a b) (strip-tail '(a b nil nil)))) 
NIL 
[4]> (assert (equal '(a nil b) (strip-tail '(a nil b nil)))) 
NIL 
[5]> (assert (equal '(a b) (strip-tail '(a b)))) 
NIL 
[6]> 

Answer 6

Как насчет этого?

(defun strip-tail (lst) 
    (if lst 
    (let ((lst (cons (car lst) (strip-tail (cdr lst))))) 
     (if (not (equal '(nil) lst)) lst)))) 

... интересно, как сделать хвост-рекурсивным, хотя эта версия исчерпала бы стек для больших списков.