Hallo.
Jetzt wird es etwas komplizierter. Ich habe zwei Arrays A und B. OK, bis hierher war es noch einfach.
A={1,2,3}
B={2,3,4,5}

So Aufagbe:
Ich brauche jetzt in Array C alle Elemente die in A enthalten sind aber nicht in B. (Wäre hier 1)
Und alle Elemente in Array D die in B drin sind aber nicht in A. (Wäre hier 4 und 5)

Es kann aber auch sein, dass Array A mehr Elemente enthält, wie Array B.

Das zu programmieren dürfte kein Problem sein. Ich brauche nur eine Idee / Algoritmus. Aber jedesmal, wenn ich mitten drin bin im Überlegen bekomme ich ein Knoten ins Hirn und verliere den Überblick und weiß dann nicht mehr, wo ich war.

markieren

Code:

function in_array(bla: integer; arr: array of integer): Boolean
begin
  result := false;
  for a := 0 to Length(arr) do
    if (arr[a] = bla) then begin
      result := True;
      exit;
    end;
end;


{...}
SetLength(array3, 0);
for a := 0 to length(array1) - 1 do
  if not in_array(array1[a], array2) then begin
   SetLength(array3, Length(array3) + 1);
   array3[Length(array3) - 1] := array1[a];
  end;
end;

SetLength(array4, 0);
for a := 0 to length(array2) - 1 do
  if not in_array(array2[a], array1) then begin
   SetLength(array4, Length(array4) + 1);
   array4[Length(array4) - 1] := array2[a];
  end;
end;
{...}

Die Idee mit dem in_array war der Springendepunkt. Habe es hinbekommen. Eine Lösung kann ich aber nicht posten, würde nichts bringen. Nur so viel man muß drei Fälle unterscheide:
A ist genauso groß wie B, A ist kleiner wie B, A ist größer wie B.

der Lösungsansatz steht ja oben...das sollte reichen...

alternativ kannst du dir mal Sets anschaun...

Kann man Sets dynamisch erstellen?

Es kommt darauf an, was du mit dynamisch meinst.

markieren

Delphi-Quellcode:

var aSet, bSet, cSet: set of Byte;
begin
  aSet := aSet + [10];
  Include(aSet, 20);

  bSet := [10, 20, 30];
  cSet := aSet * bSet; { = [10, 20] }
end;

Es müßten Strings sein und zur Laufzeit kenn ich weder Anzahl der Elemente in einem Set noch wie sie heißen. Das meinte ich mit dynamisch.

Moin Luckie,

simpel, ungetestet, aber sollte gehen:

zusammenfalten · markieren

Delphi-Quellcode:

for i := low(A) to high(A) do
begin
  fFound := false;
  for j := low(B) to high(B) do
  begin
    if A[i] = B[j] then
    begin
      fFound := true;
      break;
    end;
  end;
  if not fFound then
  begin
    // Zu C hinzufügen
  end;
end;

Für die andere Richtung dann analog.

BTW: Und ich hab' so die Ahnung, als hätte ich Dir dieses Problem auch noch eingebrockt

Wenn meine Mail nicht untergegangen ist, dann kennst du ja meine Lösung. Nicht so elegant, wie deine aber sie scheint zu funktionieren.