Übung macht den Meister - zeigt her eure Lösungen

[generic]

Moin, bei Heise war neulich ein CleanCode Artikel:
https://www.heise.de/hintergrund/Sch...html?seite=all

Diesen hatte ich als Thema für das letzte Video genommen:
https://www.youtube.com/watch?v=NCUajyNGYHY

Baut doch auch mal eine Lösung zur Übung in Delphi und fügt diese hier als Antwort ein.

[TiGü]

Grob der ursprüngliche Java-Code eins zu eins nach Delphi übersetzt:

Delphi-Quellcode:

program Project6;

{$APPTYPE CONSOLE}

{$R *.res}


uses
    System.SysUtils;

procedure start();
begin
    Writeln('Duplikate: ');
end;

procedure Main;
var
    s: string;
    yc, i, j: Integer;
    strings: TArray<string>;
begin
    s := 'Ohne Clean Code ist Code nicht wartbar.';

    s := s.ToLower();

    strings := s.split([' ']);

    start();
    for i := 0 to Length(strings) - 1 do
    begin
        yc := 1;

        for j := i + 1 to Length(strings) - 1 do
        begin
            if (strings[i].equals(strings[j])) then
            begin
                Inc(yc);

                strings[j] := '0';
            end;
        end;

        if ((yc > 1) and (strings[i] <> '0')) then
        begin
            Writeln(strings[i]);
        end;
    end;
end;

begin
    try
        Main;
    except
        on E: Exception do
            Writeln(E.ClassName, ': ', E.Message);
    end;
    Readln;
end.

Und hier eine hausbackende und hemdsärmelige Lösung, die Build-In-Funktionalität nutzt (ab Delphi XE7) und mithilfe flacher Funktionen die Duplikate im String sucht und ausgibt.
Es muss nicht immer gleich eine ganze Klasse sein.
Oft reicht einfach nur eine flache Funktion.

Delphi-Quellcode:

program Project7;

{$APPTYPE CONSOLE}

{$R *.res}

uses
    System.SysUtils,
    System.Generics.Collections;

function GetDuplicatesFromString(const AString: string): TArray<string>;
var
    Map: TDictionary<string, Integer>;
    WordCount: Integer;
    SingleString: string;
    Strings: TArray<string>;
begin
    Result := [];
    Strings := AString.ToLower.Split([' ']);
    Map := TDictionary<string, Integer>.Create;
    try
        for SingleString in Strings do
        begin
            if Map.TryGetValue(SingleString, WordCount) then
            begin
                Map[SingleString] := WordCount + 1; //optionale Zeile, falls man später die Häufigkeit noch braucht
                if WordCount = 1 then
                    Result := Result + [SingleString];
            end
            else
            begin
                WordCount := 1;
                Map.Add(SingleString, WordCount);
            end;
        end;
    finally
        Map.Free;
    end;
end;

procedure PrintStringArray(const AStrings: TArray<string>);
var
    SingleString: string;
begin
    for SingleString in AStrings do
        Writeln(SingleString);
end;

procedure Main;
var
    TestString: string;
    Duplicates: TArray<string>;
begin
    TestString := 'Ohne Clean Code ist Code nicht wartbar.';
    Duplicates := GetDuplicatesFromString(TestString);
    PrintStringArray(Duplicates);
end;

begin
    try
        Main;
    except
        on E: Exception do
            Writeln(E.ClassName, ': ', E.Message);
    end;
    Readln;

end.

[Uwe Raabe]

Ich spar mir mal das drumherum (erstellt in Delphi 11):

Delphi-Quellcode:

function GetDuplicatesFromString(const AString: string): TArray<string>;
const
  cWordDelims: TArray<string> = [' ', ',', '.'];
  cCaseSensitive = False;
var
  KnownWords: TStringList;
  Duplicates: TStringList;
begin
  KnownWords := TStringList.Create(dupIgnore, True, cCaseSensitive);
  try
    Duplicates := TStringList.Create(dupIgnore, True, cCaseSensitive);
    try
      for var CurrentWord in AString.Split(cWordDelims) do
        if KnownWords.IndexOf(CurrentWord) < 0 then
          KnownWords.Add(CurrentWord)
        else
          Duplicates.Add(CurrentWord);
      Result := Duplicates.ToStringArray;
    finally
      Duplicates.Free;
    end;
  finally
    KnownWords.Free;
  end;
end;

Die Ausgabe der Duplikate erfolgt hier alphabetisch und in Bezug auf Groß-/Kleinschreibung wird die Schreibweise des zweiten Vorkommens des Wortes verwendet.

[generic]

@TiGü Danke für die Übersetzung des Beispiels
@Uwe die VAR/Array Sachen sind schon schön in den neuen Compiler. Hab nur XE5

Delphi-Quellcode:

uses
  System.SysUtils,
  System.Generics.Collections;

procedure DuplicatesFromString(source: string; duplicateFound: TProc<string>);
var
  dict: TDictionary<String, integer>;
  s: string;
  i: integer;
  p: TPair<string, integer>;
begin
  dict:=TDictionary<String, integer>.Create();
  try
    for s in source.ToLower().Split([' ']) do
    begin
      i:=0;
      if dict.TryGetValue(s, i) then
        i:=i+1;
      dict.AddOrSetValue(s, i);
    end;

    for p in dict do
      if p.Value>0 then
        duplicateFound(p.Key);
  finally
    dict.Free;
  end;
end;

begin
  try
    Writeln('Duplikate: ');
    DuplicatesFromString('Ohne Clean Code ist Code nicht wartbar.',
      procedure(s: string)
      begin
        Writeln(s);
      end);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;
end.

[Rollo62]

for var ... sehe ich in letzter Zeit öfters.

Kann man wohl mittlerweile verwenden, wenn es mit Arrays geht.
Sind nur eben nicht rückwärtskompatibel.