So ändern Sie ein element in einer Liste in erlang

Habe ich eine Liste, die ich verwendet habe, die Funktion Listen:N-te() auf, um den Rückgabewert der ein element an einem bestimmten index. Weiß jemand wie ich das Bearbeiten kann dieser Wert?

jede Hilfe wäre toll,

Dank

Mark.

EDIT: Hier ist ein bisschen mehr Informationen.
Sagen, ich hatte eine Liste L stellt eine Zeile einer text-basierten grid

L = [H,H,H,H,H].

Und ich möchte den Zugriff auf ein bestimmtes element zum Beispiel sagen, das Dritte und ändern Sie es auf E. Dann, wenn ich die Liste L wieder, es wäre

[H,H,E,H,H]

Ich hoffe, das macht mehr Sinn.

Danke.

InformationsquelleAutor MulletDevil | 2011-01-23
  1. 18

    Einer Liste unveränderlich ist, so kann man nicht "ändern" ein Element in einer Liste. Wenn Sie wirklich wollen, zu ersetzen, können Sie ein Element an einer gegebenen position ist, sollte man anfügen der Liste, bevor das element mit den (geänderten) element und der restlichen Liste:

    1> L=[1,2,3,4,5].
[1,2,3,4,5]
2> lists:sublist(L,2) ++ [lists:nth(3,L)*100] ++ lists:nthtail(3,L).
[1,2,300,4,5]

    EDIT: Das Szenario ist etwas ungewöhnlich, aber... hast du ein bestimmtes problem zur hand? Vielleicht kann es besser ausgedrückt mit z.B. listet:map?

    • sagen, ich hatte die Liste L=[H,H,H,H,H]. und das wollte ich ändern, das 3. element E.
    • Index=3. Listen:Unterliste(L,Index-1) ++ "E" ++ Listen:nthtail(Index L).
    InformationsquelleAutor E Dominique
  2. 11

    Während der Verwendung von Funktionen aus lists führen kann code, scheint klarer, es ist weniger effizient als die Liste der Elemente vor das element, das Sie ändern möchten, wird zweimal kopiert. Es ist effizienter, schreiben die Funktion selbst, und wie Sie wahrscheinlich wickeln Sie den code mit lists in eine Funktion habe ich nicht das Gefühl, es wird weniger klar.

    Statt den code von @D. Nibon würde ich schreiben, die Funktion als:

    %% setnth(Index, List, NewElement) -> List.

setnth(1, [_|Rest], New) -> [New|Rest];
setnth(I, [E|Rest], New) -> [E|setnth(I-1, Rest, New)].

%% Can add following caluse if you want to be kind and allow invalid indexes.
%% I wouldn't!
%% setnth(_, [], New) -> New.

    Die Reihenfolge der Argumente erörtert werden können; leider sind die lists Modul ist keine Hilfe, hier ist es inkonsequent innerhalb des Moduls. Zwar ist dies nicht eine tail-rekursive Funktion habe ich das Gefühl, dass es klarer ist. Auch der Unterschied in der Effizienz ist gering oder nicht vorhanden, so würde ich mit Klarheit. Für weitere Informationen zu diesem Thema finden Sie unter:

    http://www.erlang.org/doc/efficiency_guide/myths.html#tail_recursive

    http://www.erlang.org/doc/efficiency_guide/listHandling.html#id64759

    Für eine vielseitige Funktion, statt nur den neuen Wert, den Sie weiterleiten könnten ein fun die aufgerufen werden würde, mit der alte Wert und der neue Wert wird zurückgegeben. In einer Bibliothek würde ich wahrscheinlich beide.

    InformationsquelleAutor rvirding
  3. 3

    Beim arbeiten mit Listen ein, alle Elemente sind oft von ähnlichen Datentyp oder die Bedeutung. Sie selten sehen Listen wie ["John Doe","1970-01-01","London"] sondern #person{name="John Doe",...} oder sogar, {"John Doe",...}. Ändern Sie einen Wert in einem Datensatz oder Tupel: 

    -record(person,{name,born,city}).
f(#person{}=P) -> P#person{city="New City"}. % record
f({_,_,_,}=Tuple) -> erlang:setelement(3,Tuple,"New City"). % tuple

    Diese möglicherweise nicht lösen, nichts für Ihr spezielles problem. Um Ihr eigenes Beispiel in Kommentar: 

    f1([H1,H2,_H3,H4,H5],E) -> [H1,H2,E,H4,H5].

    Geben Sie eine ausführlichere Beschreibung der Umwelt-und problem-es ist einfacher, unter denen die Lösung könnte am besten funktionieren.

    Edit: Eine (eher schlechte) Lösung 1. 

    replacenth(L,Index,NewValue) -> 
 {L1,[_|L2]} = lists:split(Index-1,L),
 L1++[NewValue|L2].

1> replacenth([1,2,3,4,5],3,foo).
[1,2,foo,4,5]

    Oder etwas effizienter, je nach der Länge der Listen.

    replacenth(Index,Value,List) ->
 replacenth(Index-1,Value,List,[],0).

replacenth(ReplaceIndex,Value,[_|List],Acc,ReplaceIndex) ->
 lists:reverse(Acc)++[Value|List];
replacenth(ReplaceIndex,Value,[V|List],Acc,Index) ->
 replacenth(ReplaceIndex,Value,List,[V|Acc],Index+1).

    Sogar besser ist meine Funktion f1 oben, aber vielleicht, nur vielleicht ist das problem immer noch liegt, wie oben diskutiert, oder hier.

    • Ich bearbeitet die Frage, um mehr details zu bieten. Ich hoffe, das hilft. Danke.
    InformationsquelleAutor D.Nibon
  4. 3
    L = [H,H,H,H,H].

    Und ich möchte den Zugriff auf ein bestimmtes element zum Beispiel sagen, das Dritte und ändern Sie es auf E. Dann, wenn ich die Liste L wieder, es wäre

    [H,H,E,H,H]

    Werden eine echte nitpicker. In Erlang sind die Daten persistent und unveränderlich. Sobald Sie definieren die L = ... Teil, die L in Stein gemeißelt ist. Sie können nicht ändern, es von dort aus. Was Sie tun können ist, erstellen Sie einen neuen Wert ein, und binden Sie es an eine andere variable, L1 sagen und dann halt mit L. Der garbage collector wird dann schnell kurzen Prozess machen L zu recyceln und den Speicher verwendet.

    Daher ist es etwas falsch zu sagen, dass die Verwendung L wieder verändert seinen Inhalt, denn das ist unmöglich.

    Ein weiterer erwähnenswerter Punkt ist, dass, wenn Sie verwenden Sie die Liste, als ob es ein array ist, dann können Sie ein array (aus der array Modul) oder verwenden Sie ein dict (aus der dict - Modul). Es verbessert die Geschwindigkeit der Suchvorgänge und Aktualisierungen in Ihrem Fall. Wenn das, was Sie tun, die meisten ist das Durchlaufen der Liste zu verarbeiten, die über alle Elemente, die Liste ist jedoch wahrscheinlich die Gewinner.

    InformationsquelleAutor I GIVE CRAP ANSWERS
  5. 0

    Wenn du deine Liste so, dass es aus Tupeln, die Sie verwenden können,Listen:keyreplace.

    InformationsquelleAutor btk
  6. -1
    1> lists:reverse(element(2, lists:foldl(fun(E, {I, L}) -> {I + 1, [case I of 2 -> e; _ -> E end|L]} end, {0, []}, [h,h,h,h,h]))).

[h,h,e,h,h]

    Nicht schön, aber ich Wette, die ist sehr effizient.

    • Eine alternative in der gleichen Ader ist fun(R, N, L) -> case lists:split(N-1, L) of {F, [_|T]} -> F ++ [R|T] end end(e,3,[h,h,h,h,h]), aber effizient, diese Implementierungen sind nicht, es sei denn, die Liste ist Recht klein.
    • Wow, wusste nicht, Listen:map/foldl sooooo langsam im Vergleich zu den Listen:split oder sogar Listen:reverse
    InformationsquelleAutor Victor Moroz
Schreibe einen Kommentar