Wert [Word] in Liste/Array vorhanden

[Neutral General]

Funktioniert aber auch nur wenn jeder Wert nur 1x vorkommt oder nicht?

[jfheins]

Sagen wir so: Die Anzahl wird nicht gespeichert. Es sollte aber trotzdem kein Problem sein, die Liste/das Array in ein Hashset zu stopfen und dann damit zu überprüfen ob die Zahl enthalten ist. Bei vielen tests ist das dann durchaus schneller als die lineare Suche.

[Alex_ITA01]

Stimmt, muss mal meine Delphi Version im Profil aktualisieren

Das mit dem Hashset muss ich mir mal angucken.
Die ASM Funktion sieht auch interessant aus, die muss ich aber erstmal genau verstehen

Danke auf alle Fälle für eure Anregungen, könnt natürlich gerne weiter machen

Gruß

[Aphton]

Der Threadstarter hat keine Aussagen über das Array getroffen - ist es z.B. sortiert? Falls ja, ginge es ja mit der binären Suche in Log(N) Zeit.
Ansonstnen über Hashes; oder ganz billig - linear!

[Aphton]

Zitat von Neutral General:

Funktioniert aber auch nur wenn jeder Wert nur 1x vorkommt oder nicht?

Beim Hashset werden meines Wissens nach mehrere Methoden vereint - zuerst einmal die Hashfunktion, die den Index zu einem Element liefert. An dieser Stelle im Hashset befindet sich dann evt. eine sortierte Liste (mit evt. mehreren kollidierenden Einträgen) dort wird wiederum binär gesucht!

Da eine Hashfunktion möglichst Kollisionsfrei vom Design her ist, enthalten die Listen im Hashset meistens nur wenige (eig. 1) Einträge. Gibts Kollisionsen, so ist das auch kein Problem!

[Alex_ITA01]

Hallo zusammen,

also das array ist nicht sortiert und kann unterschiedlich groß sein.

Ich habe es jetzt mit einer TStringList erstmal gemacht und frage dann IndexOf ab.
Generic List hätte ich auch machen können.

Die ASM Funktion muss ich gestehen, verstehe ich nicht ganz. Vielleicht hat mal einer Zeit und Lust mir das zu erklären, was da genau in jeder Zeile passiert?!

Hashset sieht erstmal für meinen "kleinen" Anwendungsfall überdimensioniert aus
Gucke mir das aber gerne mal noch genauer an.

Viele Grüße

[Sir Rufo]

Das mit der StringList ist aber weder elegant noch schnell.

Für solche Basics lege ich mir ein Helferlein zu und kann dann

Delphi-Quellcode:

  var
    LArray : array of Word;
    LValue : Word;
  begin
    if TArrayHandler<Word>.Contains( TArray<Word>( LArray ), LValue )
    then
      begin

      end;
  end;

oder eben eleganter

Delphi-Quellcode:

  var
    LArray : TArray<Word>;
    LValue : Word;
  begin
    if TArrayHandler<Word>.Contains( LArray, LValue )
    then
      begin

      end;
  end;

Das Helferlein selber, dem man auch noch viel mehr beibringen kann (Sortieren, etc.)

Delphi-Quellcode:

unit Utils.ArrayHandler;

interface

  uses
    System.Generics.Defaults;

  type
    TArrayHandler<T> = class
    public
      // Append
      class procedure Append( var AArray : TArray<T>; const AValue : T ); overload;
      class procedure Append( var AArray : TArray<T>; const AValues : TArray<T> ); overload;
      class procedure Append( var AArray : TArray<T>; const AValues : array of T ); overload;
      // Contains
      class function Contains( const AArray : TArray<T>; const AValue : T ) : Boolean; overload;
      class function Contains( const AArray : TArray<T>; const AValue : T; AComparer : IComparer<T> ) : Boolean; overload;
      // Shuffle
      class procedure Shuffle( var AArray : TArray<T> );
    end;

implementation

  { TArrayHandler<T> }

  class procedure TArrayHandler<T>.Append( var AArray : TArray<T>; const AValue : T );
    begin
      SetLength( AArray, Length( AArray ) + 1 );
      AArray[high( AArray )] := AValue;
    end;

  class procedure TArrayHandler<T>.Append( var AArray : TArray<T>; const AValues : TArray<T> );
    var
      LStart : Integer;
      LIdx   : Integer;
      LLow   : Integer;
    begin
      LStart := high( AArray ) + 1;
      SetLength( AArray, Length( AArray ) + Length( AValues ) );
      LLow := low( AValues );

      for LIdx := LLow to high( AValues ) do
        begin
          AArray[LStart + LIdx - LLow] := AValues[LIdx];
        end;
    end;

  class procedure TArrayHandler<T>.Append( var AArray : TArray<T>; const AValues : array of T );
    var
      LStart : Integer;
      LIdx   : Integer;
      LLow   : Integer;
    begin
      LStart := high( AArray ) + 1;
      SetLength( AArray, Length( AArray ) + Length( AValues ) );
      LLow := low( AValues );

      for LIdx := LLow to high( AValues ) do
        begin
          AArray[LStart + LIdx - LLow] := AValues[LIdx];
        end;
    end;

  class function TArrayHandler<T>.Contains( const AArray : TArray<T>; const AValue : T; AComparer : IComparer<T> ) : Boolean;
    var
      LIdx : Integer;
    begin
      for LIdx := low( AArray ) to high( AArray ) do
        if AComparer.Compare( AValue, AArray[LIdx] ) = 0
        then
          Exit( True );
      Result := False;
    end;

  class procedure TArrayHandler<T>.Shuffle( var AArray : TArray<T> );
    var
      LIdx    : Integer;
      LNewIdx : Integer;
      LTmp    : T;
    begin
      for LIdx := high( AArray ) downto low( AArray ) + 1 do
        begin
          LNewIdx := Random( LIdx + 1 );
          if LIdx <> LNewIdx
          then
            begin
              LTmp            := AArray[LIdx];
              AArray[LIdx]    := AArray[LNewIdx];
              AArray[LNewIdx] := LTmp;
            end;
        end;
    end;

  class function TArrayHandler<T>.Contains( const AArray : TArray<T>; const AValue : T ) : Boolean;
    begin
      Result := Self.Contains( AArray, AValue, TComparer<T>.Default );
    end;

end.