Strings zusammenführen und Bereinigen

[creehawk]

Moin Moin.

Ich hatte folgende Sache schon mal hier irgendwo gelesen:

Ich habe 3-10 Strings die so aussehen:

Delphi-Quellcode:

String1 := '1,2,4,6,9';
String2 := '1,3,6,9,10,11';
String3 := '2,3,4,9,10';
etc.

Die möchte ich zusammenführen so dass folgendes herauskommt:

Delphi-Quellcode:

String  := '1,2,3,4,6,9,10,11';

Das Beispiel seinerzeit ging mit Automarken. Aber ich weiß nicht mehr wie das hieß oder wie ich jetzt die Frage formulieren soll....

creehawk

[Der schöne Günther]

Du möchtest

1. Die Zahlen aus jedem String (3-10) erkennen und z.B. in ein Array schreiben
2. Die Zahlen im Array aufsteigend sortieren
3. Doppelte Vorkommen entfernen
4. Aus dem Zahlen-Array wieder einen String machen

Mit welchem Schritt hast du genau Probleme?

[creehawk]

Tja, ich kann mir schon was zusammenschrauben. Das hat aber was Commodore 64 Basic.....

Wie lese ich aus einem String mit dem obigen Aufbau elegant jede einzelne Zahl?

Habe ich die in ein arrray geschrieben wie entferne ich die doppelten Werte?

creehawk

[himitsu]

mit 'nem Comma alle Strings zusammen (Join bzw +)
SplitString
string.Split
StringList.CommaText
such dir was aus

oder erst hier alles Arrays zusammen (AddStringa oder +)

TArray.Sort

FOR mit IF und Delete (oder vorher via stringlist.Duplicates)

Und dann string.Join

[Andreas13]

Zitat:

Zitat von creehawk (Beitrag 1522159)

... Habe ich die in ein arrray geschrieben wie entferne ich die doppelten Werte?

Nach dem Sortieren vergleichst Du, ob benachbarte Werde gleich sind. :-D

[creehawk]

Jupp!

Besten Dank!

creehawk

[DeddyH]

Oder eine TList<integer> nehmen und vor dem Einfügen prüfen, ob IndexOf(AktuelleZahl) < 0 ist.

[arcticwolf]

Delphi-Quellcode:

Uses
  Generics.Collections,
  System.SysUtils;

Type TIntegerList = TList<Integer>;

Type TIntegerListHelper = Class Helper for TIntegerList
     public
       Function  ToString : String;
     end;

Function  TIntegerListHelper.ToString : String;
Var
  i : Integer;
begin
  Result := '[';
  for i := 0 to Count-1 do
  begin
    Result := Result + Items[i].ToString;
    if (i<Count-1) then Result := Result + ', ';
  end;
  Result := Result + ']';
end;

Procedure AddToIntegerList(Var IntegerList:TIntegerList; aString:String);
Var
  StringArray : TArray<string>;
  i : integer;
  Value : Integer;
begin
  StringArray := aString.Split([',']);
  for I := 0 to High(StringArray) do
  begin
    Value := StrToInt(StringArray[i]);
    if (IntegerList.IndexOf(Value)=-1)
       then IntegerList.Add(Value);
  end;
end;

Procedure CreateIntegerList;
Var IntegerList : TIntegerList;
begin
  IntegerList := TIntegerList.Create;
  AddToIntegerList(IntegerList,'1,2,4,6,9');
  AddToIntegerList(IntegerList,'1,3,6,9,10,11');
  AddToIntegerList(IntegerList,'2,3,4,9,10');
  IntegerList.Sort;
  Writeln(IntegerList.ToString);
  IntegerList.Free;
end;

Die Ausgabe sieht dann wie folgt aus:

Code:

[1, 2, 3, 4, 6, 9, 10, 11]

Eventuell noch eine try .. except um StrToInt, wenn Du dir nicht sicher bist, dass nur Zahlen im String sind.

[Uwe Raabe]

Ich hätte auch noch eine Alternative basierend auf einer gepimpten TStringList, die im Wesentlichen auf dem bisher gesagten aufbaut:

Delphi-Quellcode:

type
  TNumberStringList = class(TStringList)
  protected
    function CompareStrings(const S1: string; const S2: string): Integer; override;
  public
    constructor Create;
    procedure AddNumbers(const ACommaText: string);
  end;

constructor TNumberStringList.Create;
begin
  inherited Create(dupIgnore, True, True);
end;

procedure TNumberStringList.AddNumbers(const ACommaText: string);
begin
  AddStrings(ACommaText.Split([',']));
end;

function TNumberStringList.CompareStrings(const S1, S2: string): Integer;
begin
  Result := string.Compare(S1, S2, [TCompareOption.coDigitAsNumbers]);
end;

procedure TestNumberStringList;
var
  String1: string;
  String2: string;
  String3: string;
begin
  String1 := '1,2,4,6,9';
  String2 := '1,3,6,9,10,11';
  String3 := '2,3,4,9,10';
  var lst := TNumberStringList.Create;
  try
    lst.AddNumbers(String1);
    lst.AddNumbers(String2);
    lst.AddNumbers(String3);
    var S := lst.CommaText;
    Assert(S = '1,2,3,4,6,9,10,11');
  finally
    lst.Free;
  end;
end;

Zur Erklärung:

• Mit dem
  Delphi-Quellcode:

  dupIgnore, True

  im Create werden erst gar eine Doubletten hinzugefügt (das zweite True für CaseSensitive ist hier redundant)
• Das
  Delphi-Quellcode:

  coDigitAsNumbers

  im CompareStrings sorgt für eine korrekte Sortierung der Zahlen
• Das AddNumbers vereinfacht das Hinzufügen der einzelnen Listen

Der obige Ansatz funktioniert auch wenn nicht nur Zahlen vorkommen. In dem Fall wäre der CaseSensitive Parameter im Create aber vielleicht doch relevant.

[generic]

Uwe super elegante Lösung! Meine Lösung hätte ähnlich ausgesehen, nur nicht so geschickt mit den Sortieren.
Super mit dem unittest.