Efficiently compare an integer against a static list of integers in Delphi?

Question

Similarly to any way to compare an integer variable to a list of integers in if statement but in Delphi, how can I test whether an integer variable is contained in a static "list" (loosely speaking - a set that is predefined) of integers (maybe a list of consts, or a list of explicit values) in an if statement?

Now I would do something like this:

if (x = 1) or
   (x = 2263) or
   (x = 263553) or
   (x = whatever_int) then
begin
  //do something;
end;

But I'm trying to avoid lenghty sequences of or conditions.

I'm using Delphi XE6, so if there's something new to achieve this in a clean way, please advise me.

Answer 1

Your current approach is good. The compiler will produce efficient code. If efficiency is of the utmost importance, then you can choose the order of the comparisons so that the most common values are checked first. This requires knowledge of the distribution of your input data.

Another syntactical approach is the case statement. For instance:

case x of
1, 2263, 263553, whatever_int:
  // do other stuff
end;

This results in similar (in fact I suspect identical) code to the if statement. But it is perhaps more concise and easier to read. And in some scenarios the compiler is able to produce a jump table.

If efficiency is of the utmost importance to you then do make sure that you inspect the code that the compiler emits, for release compiler options, and perform profiling.

I do wonder what you really mean by efficient. In programming that term has a specific meaning relating to runtime performance. But I wonder if you are actually more concerned with writing clear and concise code, in which case efficient is the wrong term. The fact that your question talks about avoiding repeated or operators makes me doubt that efficiency is what matters to you.

On the other hand, if runtime performance is what matters then consider giving up on code clarity and implementing an indexed jump table. But don't ever optimise code without first identifying that it is a bottleneck, and profiling any changes you make.

Answer 2

You can make the code much cleaner to read by writing a little function:

//NOTE: This function is written in a way that would be compatible with any version of Delphi.
//Since you're using XE6, there are some improvement options available to you:
// E.g. You can make the function inline, use "for in", use a record helper, use generics
function ContainsInteger(const AValue: Integer; const AArray: array of Integer): Boolean;
var
  I: Integer;
begin
  Result := False;
  for I := Low(AArray) to High(AArray) do
  begin
    if (AArray[I] = AValue) then
    begin
      Result := True;
      Exit;
    end;
  end;
end;

Now you can call your function as follows:

if ContainsInteger(x, [1, 2263, 263553, whatever_int]) then
begin
  //do something;
end;

NOTE: This would be slower than a case statement as described in David's answer, but it has the potential to be significantly faster for longer lists of numbers.

If it's likely this function will be used frequently with longer lists:

• You can specify a requirement that the input array be given in ascending order. (Behaviour would be undefined otherwise.)
• And modify the function to perform a binary search.
• Then for example, a list of 32 numbers would require at most 5 comparisons to find a match using binary search; whereas it would need an average of 16 for the case statement.

NB: As always when fine-tuning optimisations like this:

1. Use profiling to confirm whether you need it here.
2. Use profiling to confirm whether you get the benefit you expect.

Answer 3

given the use case, I would use TList<Integer>, and its methods:

• procedure AddRange(const Values: array of T);
• Contains(const Value: T): Boolean;

Answer 4

Why not just simple:

x : integer;
begin
  if x in [1,2,5] then
  begin
    showmessage('x in 1,2,5');
  end;
end;