Performance VS Codestruktur/Codevereinfachung

[Der schöne Günther]

Ich will keine Spaßbremse sein, aber das Wichtigste wäre mir eine ordentliche Dokumentation, ganz egal wie die Implementation aussieht. Es muss klar ersichtlich sein dass ich nicht nach "-1" suchen kann da du das als Ersatz für "Nicht gefunden" nimmst. Auch verstehe ich nicht ganz warum du den Wert noch einmal zurückgibst wenn man doch nur den will. Dich interessiert doch nur ob alle drei gefunden wurden. Oder?

Dass der Code leserlich und verständlich ist doch generell wichtiger als vielleicht ein paar Takte zu sparen. Ist es wirklich ein Flaschenhals, erst dann lohnt es sich, auf Geschwindigkeits-Optimierungen zu stürzen.

Dann musst du schauen, wiederverwendbaren Code zu produzieren. Sind es immer fix drei Werte bei denen du wissen willst "Kommt vor? J/N". Warum nicht gleich ein Array machen wo du so viele Werte reinstecken kannst wie du willst?

Ich persönlich würde es so machen:

Delphi-Quellcode:

/// <returns>
///     Gibt an ob alle Elemente in <paramref name="checkFor" />
///      in <paramref name="checkedArray" /> enthalten sind
/// </returns>
/// <param name="checkFor">
///      Elemente können mehrfach vorliegen. Ist zwei mal das Element <c>0</c>
///    enthalten <b>muss</b> <paramref name="checkedArray" /> das Element
///    <c>0</c> zwei mal enthalten, sonst wird <c>False</c> zurückgegeben
/// </param>
function arrayContains(
   const   checkedArray:   TArray<Integer>;
   const   checkFor:      TArray<Integer>
): Boolean;
var
   arrayIterator:      Integer;
   checkForRemaining:   TList<Integer>;
   checkedInteger:      Integer;
begin
   checkForRemaining := TList<Integer>.Create();
   try
      checkForRemaining.AddRange(checkFor);

      for arrayIterator in checkedArray do begin
         for checkedInteger in checkForRemaining do
            if (arrayIterator = checkedInteger) then begin
               checkForRemaining.Remove(checkedInteger);
               Break;
            end;
      end;

      Result := (checkForRemaining.Count = 0);
   finally
      checkForRemaining.Destroy();
   end;
end;

Das ist flexibel (wenn auch auf grade Integer zugeschnitten) und erlaubt auch das Prüfen auf mehrfaches Vorkommen eines Elements.

Delphi-Quellcode:

const
   testArray:   TArray<Integer>   = [4, -12, 0, -1, 99, 0];

   checkFor1:   TArray<Integer>   = [99, 4, 0];
   checkFor2:   TArray<Integer>   = [6, 66, 666];
   checkFor3:   TArray<Integer>   = [0, 0];
   checkFor4:   TArray<Integer>   = [0, 0, 0];
begin
   WriteLn( arrayContains(testArray, checkFor1) );      // True
   WriteLn( arrayContains(testArray, checkFor2) );      // False
   WriteLn( arrayContains(testArray, checkFor3) );      // True
   WriteLn( arrayContains(testArray, checkFor4) );      // False

   readln;
end.

Ich persönlich wäre damit zufrieden. Ist das performant? Nein, wahrscheinlich geht da mehr. Insbesondere wenn es keine Integer sondern Records wären.