Заменить элемент в списке в Common Lisp?

быстро вы можете сделать это с помощью JS на list-replace

(defun replace-nth-from-list  (list n elem)  
      (cond  
        ((null list) ())  
        (t (append (subseq list 0 n) elem (subseq list (+ 1 n)(length list))))))

Звучит так, будто ты хочешь либо rplaca, либо заменить. См. http://www.lispworks.com/documentation/HyperSpec/Body/f_rplaca.htm или http://www.lispworks.com/documentation/HyperSpec/Body/f_replac.htm#. заменить

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

Вот решение в Схеме (потому что я знаю это лучше, чем Common Lisp, и у меня есть переводчик для проверки моей работы):

(define (replace-nth list n elem)
  (cond
    ((null? list) ())
    ((eq? n 0) (cons elem (cdr list)))
    (#t (cons (car list) (replace-nth (cdr list) (- n 1) elem)))))

Я просто пытаюсь исправить код Хаззена:

(define (replace-nth list n elem)
  (cond 
    ((null? list) ())
    ((eq? n 0) (cons elem list))
    (#t (cons(car list) (replace-nth (cdr list) (- n 1) elem)))))

> (replace-nth (list 3 2 9 2) 2 8)
(3 2 8 9 2)

Этот код вставил новый элемент в список. Если мы хотим заменить элемент:

(define (replace-nth list n elem)
  (cond 
    ((null? list) ())
    ((eq? n 0) (cons elem (cdr list)))
    (#t (cons(car list) (replace-nth (cdr list) (- n 1) elem)))))

> (replace-nth (list 3 2 9 2) 2 8)
(3 2 8 2)

0 < = n < = длина (список) - 1

Используйте [ЗАМЕНЯЮТ] [1] (я использую X вместо Вашего T, поскольку T является истинным значением в Lisp):

(replace L (list X) :start1 N)

[1]: http://www.lispworks.com/documentation/HyperSpec/Body/f_replac.htm ЗАМЕНА

(setf (nth N L) NEW)

должен добиться цели.

совет hazzen хорош (используйте массивы), так как Вы, вероятно, хотите сделать, много этих разрушительных обновлений и списков очень неэффективно наугад доступ. Самый легкий способ сделать это

(setq A (make-array 5) :initial-contents '(4 3 0 2 1))
(setf (elt 2 A) 'not-a-number)

, где A является массивом (хотя elt работы для любой последовательности).

• elt определение, с примерами setf .
• make-array определение, с примерами

Однако, если Вы должны быть функциональными, который является

1. , Вы хотите иметь в наличии, и старые и новые списки
2. Вы хотите, чтобы старое и новое совместно использовали как можно больше памяти.

Тогда необходимо использовать язык Common LISP, эквивалентный из кода hazzen:

(defun replace1 (list n elem)
  (cond
    ((null list) ())
    ((= n 0) (cons elem list))
    (t (cons (car list) (replace1 (cdr list) (1- n) elem)))))

Это выглядит медленным, потому что это, и это, вероятно, почему это не включено в стандарт.

код hazzen является версией Схемы, которая полезна, это - то, что Вы используете.

Очевидное решение является медленным и использует память, как отмечено другими. Если возможно, необходимо попытаться задержать замену элемента (элементов), пока Вы не должны выполнять другую поэлементную операцию в списке, например, (loop for x in list do ...).

Тот путь, Вы амортизируете далеко концентрирующий (память) и повторение (CPU).

(setf (nth N L) T)

самый ясный, самый сжатый, и самый быстрый путь, если то, что Вы хотите сделать, является "разрушительной" модификацией, т.е. на самом деле измените существующий список. Это не выделяет новой памяти.