comment puis-je ajouter à une liste sans créer une paire en pointillés

Question

comment puis-je append (1 2 3) à la fin de () pour faire ((1 2 3))
Comment puis-je joins (4 5 6) à la fin de que pour faire ((1 2 3) (4 5 6))
comment puis-je ajouter "|" à la fin de que pour faire ((1 2 3) (4 5 6) "|")

sans paires en pointillés.

Je travaille avec Chicken Scheme mais je vais prendre une réponse de n'importe quel régime à ce stade. Notez que n'importe laquelle de ces listes pourrait aussi être une liste imbriquée de qui sait quoi ... Je suis en train d'écrire un exemple trivial.

note: @sjamaan montre une solution utilisant l'ajout qui consiste à tout emballer dans une autre liste pour compenser l'ajout de faire des choses AUTRES que ce que le nom dit.

(append (list 1 2 3) "|") ;=> (1 2 3 . "|") ;^^ didn't actually append, created a dotted pair (append '(1 2 3) (list 4 5 6)) ;=> (1 2 3 4 5 6) ; don't want unwrapped list ;^^ didn't actually append the list i gave it but appended the contents of the list.

Fondamentalement, je suis l'espoir d'une méthode append qui ajoute en fait ce que vous lui donnez, n'ajoute le contenu, ou il prend et fait une paire en pointillés. Peut-être que je suis juste un rêveur ... Je peux écrire une méthode "pas vraiment append" qui prend juste les params que vous lui donnez et les enveloppe dans une liste externe pour compenser mais c'est juste stupide ... Sûrement schéma a un moyen de append sans cette folie.

Answer 1

Voici comment append est fait:

(define (append2 lst1 lst2) 
    (if (null? lst1) 
     lst2        ; the second list is unaltered 
     (cons (car lst1) 
      (append2 (cdr lst1) lst2)))) 

fait une chaîne paire composée de tous les éléments lst1 et lst2.Il ne fait pas une paire où il y a nont en lst2 si:

(append2 '(1 2 3) '(4 5)) ; ==> (1 2 3 4 5) 
(append2 '(1 2 3) '()) ; ==> (1 2 3) and not (1 2 3()) 
(append2 '(1 2 3) '5)  ; ==> (1 2 3 . 5) 

Notez que chaque liste comme (1 2 3) est en fait (1 2 3 .()) ou encore plus correctement (1 . (2 . (3 .())))

Comment puis-je joins (1 2 3) à la fin de () pour faire ((1 2 3))

(define (insert-last e lst) 
    (let helper ((lst lst)) 
    (if (pair? lst) 
     (cons (car lst) 
       (helper (cdr lst))) 
     (cons e '())))) 

(insert-last '(1 2 3) '())      
; ==> ((1 2 3)) 

comment puis-je append (4 5 6) à la fin de que pour faire ((1 2 3) (4 5 6))

(insert-last '(4 5 6) '((1 2 3))) 
; ==> ((1 2 3) (4 5 6)) 

Comment puis-je joins "|" à la fin de que pour faire ((1 2 3) (4 5 6) "|")

(insert-last "|" '((1 2 3) (4 5 6))) 
; ==> ((1 2 3) (4 5 6) "|") 

Sachez que cela ressemble beaucoup à append. Ce sont la pire façon de faire cette liste puisque vous faites une nouvelle liste à chaque fois. C'est O (n) pour chaque insert et O (n^2) pour n éléments. Si vous pouvez le faire dans l'ordre inverse, vous obtenez quelque chose qui fait O (1) au lieu de O (n) pour chaque insertion. Au lieu de insert-last vous utilisez cons:

(cons '"|" '())    ; ==> ("|") 
(cons '(4 5 6) '("|"))  ; ==> ((4 5 6) "|") 
(cons '(1 2 3) '((4 5 6) "|") ; ==> ((1 2 3) (4 5 6) "|") 

Ceci est O (1), O (n) pour n éléments traités. Si vous avez besoin de le faire dans l'ordre d'origine, vous pouvez accumuler, puis inversez ..

(cons '(1 2 3) '())    ; ==> ((1 2 3)) 
(cons '(4 5 6) '((1 2 3)))   ; ==> ((4 5 6) (1 2 3)) 
(cons '"|" '((4 5 6) (1 2 3))) ; ==> ("|" (4 5 6) (1 2 3)) 
(reverse '("|" (4 5 6) (1 2 3)) ; ==> ((1 2 3) (4 5 6) "|") 

Ceci est O (1), puis O (n) pour l'inverse, mais il est encore O (1) amortis. O (n) pour n éléments que vous traitez.

Answer 2

La procédure que vous cherchez est sans surprise appelée append (à partir de SRFI-1). Il ajoute une liste de choses sur une autre liste. Cela ne signifie pas que si vous voulez ajouter un seul élément, vous aurez besoin de faire une liste de ce:

(append '() '((1 2 3))) => ((1 2 3)) 
(append '((1 2 3)) '((4 5 6))) => ((1 2 3) (4 5 6)) 
(append '((1 2 3) (4 5 6)) '("|")) => ((1 2 3) (4 5 6) "|") 

Il accepte plusieurs arguments, qui seront tous être annexée à eachother dans cet ordre, vous peut également faire:

(append '() '((1 2 3)) '((4 5 6)) '("|")) => ((1 2 3) (4 5 6) "|") 

Espérons que cela aide!

Answer 3

append n'ajoute pas d'atomes aux listes. Il concatène les listes. Vous devez lever l'atome jusqu'à une liste avant que la concaténation ait un sens.

(append xs (list y)) 

Mais il est logique de souligner (reverse (cons y (reverse xs))) qui a le même résultat. reverse suggère que vous pourriez construire votre liste en arrière si vous avez besoin d'ajouter des atomes à la fin.

Answer 4

Que vous le vouliez ou non, les cellules par contre seront créées, car les listes sont constituées de contre-cellules.

comment puis-je append (1 2 3) à la fin de() pour ((1 2 3))

CL-USER 24 > (list '(1 2 3)) 
((1 2 3)) 

comment je joins (4 5 6) à la fin de ce faire ((1 2 3) (4 5 6))

CL-USER 25 > (append '((1 2 3)) (list '(4 5 6))) 
((1 2 3) (4 5 6)) 

comment puis-je ajouter "|" à la fin de ce faire ((1 2 3) (4 5 6) « | »)

CL-USER 26 > (append '((1 2 3) (4 5 6)) (list "|")) 
((1 2 3) (4 5 6) "|")