Удалить элементы первого списка по номерам второго списка без использования вспомогательных функций

(defun drop-index (w v &optional (n 0))
  (cond ((null w) nil)
        ((null v) w)
        ((= (car v) n) (drop-index (cdr w) (cdr v) (1+ n)))
        ((cons (car w) (drop-index (cdr w) v (1+ n))))))
 
> (drop-index '(a b c d e) '(1 2 4))
(A D)

(defun drop-index (w v &optional (n 0))
  (cond ((or (null w) (null v)) w)
        ((= (car v) n) (drop-index (cdr w) (cdr v) (1+ n)))
        ((cons (car w) (drop-index (cdr w) v (1+ n))))))
 
> (drop-index '(a b c d e) '(1 2 4))
(A D)

(defun drop (v w)
  (cond
    ((null w) nil)
    ((null v) w)
    ((zerop (car v)) (drop (mapcar '1- (cdr v)) (cdr w)))
    ((cons (car w) (drop (mapcar '1- v) (cdr w))))))

;; racket-lang.org
(define (foo lst indexes)
  (let loop ((lst lst)
             (index 0)
             (indexes (sort indexes <)))
    (let/cc return
      (when (or (null? indexes) (null? lst))
        (return lst))
      (when (= index (first indexes))
        (return (loop (rest lst) (add1 index) (rest indexes))))
      (return (cons (first lst) (loop (rest lst) (add1 index) indexes))))))
 
 
(define (bar lst indexes)
  (let ((counter -1))
    (for/list ((i lst)
               #:unless (and (eq? (void) (set! counter (add1 counter)))
                             (member counter indexes)))
      i)))

(defun dd (lst pl &optional (f nil) (c 0) (tmp nil) (res nil))
  (cond ((null f)  
           (cond ((null lst) (dd nil nil t 0 tmp nil))
                 ((member c pl) (dd (cdr lst) pl nil (+ c 1) (cons (list (car lst) t) tmp)))
                 (t (dd (cdr lst) pl nil (+ c 1) (cons (list (car lst) nil) tmp)))))
        (t (cond ((null tmp) res)
                 ((cadar tmp) (dd nil nil t 0 (cdr tmp) res))
                 (t (dd nil nil t 0 (cdr tmp) (cons (caar tmp) res)))))))
 
==> dd
 
(dd '(a b c d e) '(2 1 1 1 4))
 
==> (a d)

(defun del-items (seq i &optional (c 0))
  (cond
    ((null seq) ())
    ((member c i) (del-items (cdr seq) i (1+ c)))
    (t (cons (car seq) (del-items (cdr seq) i (1+ c))))))

(defun drop-index (w v)
  (drop w (sort (copy-list v) #'<)))
 
(defun drop (w v &optional (n 0))
  (cond ((or (null w) (null v)) w)
        ((= (car v) n) (drop (cdr w) (cdr v) (1+ n)))
        ((cons (car w) (drop (cdr w) v (1+ n))))))
 
> (drop-index '(a b c d e) '(1 2 4))
(A D)
> (drop-index '(a b c d e) '(4 1 2))
(A D)

(defun drop-index (w v)
  (drop w (sort (copy-list v) #'<)))
 
(defun drop (w v &optional ac (n 0))
  (if (or (null w) (null v))
      (append (nreverse ac) w)
      (drop (cdr w)
            (if (= (car v) n) (cdr v) v)
            (if (= (car v) n) ac (cons (car w) ac))
            (1+ n))))
 
> (drop-index '(a b c d e) '(1 2 4))
(A D)
> (drop-index '(a b c d e) '(4 1 2))
(A D)

(defun drop (v w &optional (n 0)
                 &aux (q (cdr w))
                      (m (1+ n)))
  (cond
    ((some 'null (list v w)) w)
    ((find n v) (drop (remove n v) q m))
    ((cons (car w) (drop v q m)))))

(defun drop-index (w v)
  (drop w (sort (copy-list v) #'<)))
 
(defun drop (w v &optional (n 1))
  (cond ((or (null w) (null v)) w)
        ((= (car v) n) (drop (cdr w) (cdr v) (1+ n)))
        ((cons (car w) (drop (cdr w) v (1+ n))))))
 
> (drop-index '(a b c d e) '(2 3 5))
(A D)