Integerwerte vergleichen

[dutyfree]

Hallo,

wie kann ich am besten verschiedene Integerwerte vergleichen?

Also ich habe 10 Werte und will gucken ob es welche doppelt oder dreifach gibt..

danke

[-187-]

Du kannst die Werte in einer TStringList mit einer Schleife durchlaufen und zählen wie oft ein Wert vorkommt.

[mkinzler]

Am Besten zuerst sortieren

[Bernhard Geyer]

Falls du D2009 oder neuer hast dürfte eine generische TList<Integer> das beste sein.

[markus5766h]

. . . oder . . . ein Array of Integer benutzen und per Schleife
prüfen ob ein Wert mehrfach vorhanden ist.

[ibp]

wie liegen denn die Werte vor?

[Bjoerk]

ich habe, als ich mich seiner Zeit in dynamische Arrays und Objektorientierung eingearbeitet habe, mal eine unit IntergerListen erstellt.

Delphi-Quellcode:

unit IntegerListen;

interface

type
  TIntegerListe = class (TObject)
    Count : integer;
    Item : array of integer;
    function getItem (const k: integer) : integer;
    procedure setItem (const k: integer; const u: integer);
    procedure addItem (const u: integer);
    procedure insItem (const k: integer; const u: integer);
    procedure delItem (const k: integer);
    procedure clear;
    procedure sort;
    function IndexOf (const u: integer) : integer;
  public
    constructor Create;
    destructor Destroy; override;
  end;

implementation

function TIntegerListe.getItem (const k: integer) : integer;
begin
  RESULT:=Item[k];
end;

procedure TIntegerListe.setItem (const k: integer; const u: integer);
begin
  Item[k]:=u;
end;

procedure TIntegerListe.addItem (const u: integer);
begin
  Count:=Count+1;
  setLength(Item,Count);
  Item[Count-1]:=u;
end;

procedure TIntegerListe.insItem (const k: integer; const u: integer);
var
  i: integer;
begin
  Count:=Count+1;
  setLength(Item,Count);
  for i:=Count-1 downto k+1 do Item[i]:=Item[i-1];
  Item[k]:=u;
end;

procedure TIntegerListe.delItem (const k: integer);
var
  i: integer;
begin
  Count:=Count-1;
  for i:=k to Count-1 do Item[i]:=Item[i+1];
  Item[Count]:=0;
  setLength(Item,Count);
end;

procedure TIntegerListe.clear;
begin
  Count:=0;
  setLength(Item,Count);
end;

constructor TIntegerListe.Create;
begin
  inherited Create;
  clear;
end;

destructor TIntegerListe.Destroy;
begin
  clear;
  inherited;
end;

procedure TIntegerListe.Sort;
var
  i,j,s: integer;
begin
  for i:=0 to Count-2 do
    for j:=i+1 to Count-1 do
    begin
      s:=Item[i];
      if Item[i]>Item[j] then
      begin
        Item[i]:=Item[j];
        Item[j]:=s;
      end;
    end;
end;

function TIntegerListe.IndexOf (const u: integer): integer;
var
  i: integer;
begin
  result:=-1;
  for i:=0 to Count-1 do
    if Item[i]=u then
    begin
      result:=i;
      break;
    end;
end;

end.

Damit sollte es relativ einfach gehen, z.B. so:

Delphi-Quellcode:

implementation

uses
  IntegerListen;

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  Liste,Doppel : TIntegerListe;
  i,j : integer;
begin
  // Liste erzeugen
  Liste := TIntegerListe.Create;
  Doppel := TIntegerListe.Create;

  // Liste füllen
  Liste.addItem(5);
  Liste.addItem(2);
  Liste.addItem(-5);
  Liste.addItem(3);
  Liste.addItem(5);
  Liste.addItem(5);

  // Doppel initialisieren
  for i:=0 to Liste.Count-1 do
    Doppel.addItem(1);

  // Doppel herausfinden
  for i:=0 to Liste.Count-2 do
    for j:=i+1 to Liste.Count-1 do
      if Liste.Item[i]=Liste.Item[j] then
        Doppel.Item[i]:=Doppel.Item[i]+1;

  // Doppel rauslöschen
  i:=-1;
  while i<=Liste.Count-2 do
  begin
    i:=i+1;
    if Doppel.getItem(i)>1 then
    begin
      Liste.delItem(i);
      Doppel.delItem(i);
      i:=i-1;
    end;
  end;

  // ggf. sortieren
  Liste.sort;

  // Liste ausgeben
  for i:=0 to Liste.Count-1 do
    showmessage (IntToStr(Liste.getItem(i)));

  // und tschüß
  Liste.Free;
  Doppel.Free;
end;