Código Delphi [-]
...
var
  col: TListColumn;
  it : TListItem;
  i  : Integer;
begin
  ListView1.ViewStyle := vsReport;

  // columnas y titulos
  for i := 0 to ListBox1.items.Count-1 do
  begin
    col := ListView1.Columns.Add;
    col.Caption := Format('Campo %d',[i+1]);
    col.Width := ListView1.Canvas.TextWidth('Campo 0')+20;
  end;

  // items y subitems
  it := ListView1.Items.Add;
  it.Caption := ListBox1.Items[0];
  for i := 1 to ListBox1.Items.Count-1 do
    it.SubItems.Add(ListBox1.Items[i]);
end;

Código Delphi [-]
unit Combinaciones;

interface

type
  TCombinacion = Int64;
  TCombinacionHelper = record helper for TCombinacion
  private
    function GetNumero(ANum: byte): Boolean;
    function AsString(const value: TCombinacion): string; overload;
    function GetCount: Integer;
  public
    procedure AddNumero(const ANum: byte);                 // Inserta un numero en la combinacion
    procedure aleatorio;                                   // rellena con una combinacion aleatoria
    function AsString: string; overload;                   // devuelve la combinacion como un string
    procedure clear;                                       // vacia la combinacion
    function comparar(const combinacion: TCombinacion): Tcombinacion;
    function obtenerComunes(const combinacion: Tcombinacion): string;

    property Count:Integer read GetCount;                  // Indica cuantos numeros tiene esta combinacion
    // esta propiedad es para comparar si un determinado numero pertenece a la combinación
    property Numero[ANum:byte]:Boolean read GetNumero;
  published
    // añadir tantos metodos load como sea necesarios
    function load(list: array of Byte): boolean; overload; // carga una combinacion determinada
  end;


implementation

uses System.SysUtils;

const
  NumeroMax: Byte = 49;  // 1.. 49
  MaxCount: integer = 5;


{ TCombinacionHelper }
procedure TCombinacionHelper.AddNumero(const ANum: byte);
begin
  Self := self or (int64(1) shl ANum);
end;

procedure TCombinacionHelper.aleatorio;
var
  i: longint;
  value: Byte;
begin
  i := 0;
  clear;
  repeat
    //Genera un numero aleatorio entre 1 y 49
    value := Random(NumeroMax - 1) + 1;
    if not Numero[value] then begin
      //si el numero no esta en la combinacion entonces lo añade
      AddNumero(value);
      Inc(i);
    end;
    //y se repite hasta obtener el maximo de numeros necesarios para la combinacion
  until (i >= MaxCount);
end;

function TCombinacionHelper.AsString: string;
begin
  result := AsString(Self);
end;

procedure TCombinacionHelper.clear;
begin
  Self := 0;
end;

function TCombinacionHelper.comparar(
  const combinacion: TCombinacion): Tcombinacion;
begin
  Result := self and combinacion;
end;

function TCombinacionHelper.GetCount: Integer;
var
  aux: Int64;
begin
  Result := 0;
  aux := self;
  while (aux > 0) do begin
    if (aux and Int64(1)) = 1 then
      Inc(result);
    aux := aux shr 1;
  end;
end;

function TCombinacionHelper.GetNumero(ANum: byte): Boolean;
begin
  Result := ((self and (int64(1) shl ANum)) <> 0);
end;

function TCombinacionHelper.load(list: array of Byte): boolean;
var
  i: LongInt;
begin
  Result := False;
  clear;
  if length(list) = MaxCount then begin
    for i := 0 to High(list) do
      AddNumero(list[i]);
    Result := true;
  end;
end;

function TCombinacionHelper.obtenerComunes(
  const combinacion: Tcombinacion): string;
begin
  Result := Comparar(combinacion).AsString;
end;

function  TCombinacionHelper.AsString(const value: TCombinacion):string;
var
  i:integer;
begin
  result := '';
  for i := 1 to NumeroMax do
    if value.Numero[i] then
      result := result + IntToStr(i) + ' ';
end;

end.

Código Delphi [-]
uses Combinaciones;

procedure TForm1.Button1Click(Sender: TObject);
var
  Combinacion: TCombinacion;
begin
  //genera una combinacion aleatoria
  Combinacion.aleatorio;
  //combierte la combinacion en un texto
  memo1.lines.add(Combinacion.AsString + #9 + '(' + IntToStr(Combinacion.count) + ')');
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  cs1: string;
  Combinacion1, Combinacion2: TCombinacion;
  comunes: TCombinacion;
  i: LongInt;
begin
  //cargar una combinacion predeterminada
  if not Combinacion1.load([1, 5, 8, 13, 33]) then begin
    MessageDlg('La combinacion no es valida!!!', mtError, [mbOK], 0);
    exit;
  end;

  //guarda la combinacion1 en un string;
  cs1 := Combinacion1.AsString;
  //genera un bucle para analizar 100 combinaciones aleatorias
  for i := 1 to 100 do begin
    //generar una combinacion aleatoria
    Combinacion2.aleatorio;
    /// compara una combinacion con otra y obtine los comunes a ambas combinaciones
    comunes := Combinacion2.comparar(Combinacion1);
    /// si el valor es 0 entonces no hay numeros comunes
    if comunes <> 0 then
      memo1.Lines.Add(cs1 + #9 + Combinacion2.AsString + #9 + '(' + IntToStr(comunes.count) + ') ' + comunes.AsString);
  end;
end;

Código Delphi [-]
unit RandomArray; //fuente: https://www.experts-exchange.com/que...f-numbers.html

{$MODE Delphi}

interface

uses LCLIntf, LCLType, LMessages;

type
  TIntegerArray = array[0..32760*2] of Integer;
  PIntegerArray = ^TIntegerArray;

function CompRandArray(var IntArrayPtr: PIntegerArray; Count, LowRange, HighRange: integer): boolean;

implementation

function CompRandArray(var IntArrayPtr: PIntegerArray; Count, LowRange, HighRange: integer): boolean;
var
  I, J: integer;
  HaveDup: boolean;
begin
  Result := True;
  if (HighRange - LowRange + 1) < (Count) then
  begin
    Result := False;
    Exit;
  end;
  Randomize;
  for I := 0 to Count - 1 do
  begin
    IntArrayPtr^[i] := LowRange + Random(HighRange - LowRange + 1);
    Repeat
    HaveDup := False;
    for J := 0 to I - 1 do
    begin
      if (IntArrayPtr^[J] = IntArrayPtr^[i]) and (I <> J) then
      begin
        IntArrayPtr^[i] := LowRange + Random(HighRange - LowRange + 1);
        HaveDup := True;
        break;
      end;
    end;
    Until HaveDup = False;
  end;
end;

end.

Código Delphi [-]
unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ComCtrls, Grids, RandomArray;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    grid: TStringGrid;
    Label1: TLabel;
    lista: TListView;
    ListBox1: TListBox;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private

  public

  end;

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
var
  RandomArray: PIntegerArray; //This is a pointer type to Dynamic array
  i, Ctr, Count, Low, High: integer;

  begin
    Count := 6; //fill with 20 items
    Low := 1; //Lowest Random Number
    High := 49; //Highest Random Number
    GetMem(RandomArray, Count*SizeOf(Integer)); //Allocate memory
    try
      ListBox1.Clear;
      if CompRandArray(RandomArray, Count, Low, High) then
        For Ctr := 0 to Count - 1 do
        //if false Something went wrong
        ListBox1.Items.Add(IntToStr(RandomArray^[Ctr])); //dont forget ^
    finally
      FreeMem(RandomArray, Count*SizeOf(Integer)); //DeAllocate
    end;
  end;

procedure TForm1.Button2Click(Sender: TObject);
var
  i,j: integer;

begin
  with Lista.Items.Add do
      begin
        for i:= 0 to listBox1.Items.Count -1 do
        SubItems.Add(listBox1.Items.Strings[i]);
      end;
  button1.Click;
end;

end.

Código Delphi [-]
program project1;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes, SysUtils, fgl
  { you can add units after this };

type
  TCheckDuplicate = specialize TFPGMap; // Para verificar que el numero no este repetido
  TRandomInt = class; // La clase "externa" que usaras
  TRandomIntEnumerator = class // la clase que se encarga de generar los numeros, usando un enumerador
  private
    FMax: int64; // Cuantos numeros por generar?
    FIndex: int64;
    FGen: TRandomInt;
    FSet: TCheckDuplicate;
  public
    constructor Create(generator:TRandomInt; max: int64);
    function MoveNext: Boolean;
    function GetCurrent: int64;
    property Current: int64 read GetCurrent;
  end;

  TRandomInt = class(TObject)
  private
    FMax: int64;
  public
    constructor Create(max: int64);
    function GetEnumerator: TRandomIntEnumerator;
  end;
{ TRandomInt }

constructor TRandomInt.Create(max: int64);
begin
  inherited Create;
  FMax := max;
end;

function TRandomInt.GetEnumerator: TRandomIntEnumerator;
begin
  Result := TRandomIntEnumerator.Create(Self, FMax);
end;

{ TRandomIntEnumerator }

constructor TRandomIntEnumerator.Create(generator:TRandomInt; max: int64);
begin
  inherited Create;
  FSet := TCheckDuplicate.Create;
  FIndex := 0;
  FMax := max;
  FGen := generator;
end;

function TRandomIntEnumerator.GetCurrent: int64;
var
  num: int64;
begin
  num := random(MaxInt); // O colocas el maximo posible
  while True do
  begin
       //Verifico que no se ha generado antes...
       if FSet.IndexOf(num) = -1 then
       begin
         break;
       end;
       FSet.Add(num);
       num := random(MaxInt);
  end;
  Result := num;
end;

function TRandomIntEnumerator.MoveNext: Boolean;
begin
  Result := FIndex < FMax;
  Inc(FIndex);
end;

var
  i:int64;

// Como se usa:
begin

  for i in TRandomInt.Create(100000) do
  begin
    writeln(IntToStr(i));
  end;
  ReadLn;
end.

Código Delphi [-]
{$mode objfpc}{$H+}
{$MODESWITCH TYPEHELPERS}

uses SysUtils;

type
  TCombinacion = Int64;
  TCombinacionHelper = type helper for TCombinacion
  private
    function GetNumero(ANum: byte): Boolean;
    function AsString(const value: TCombinacion): string; overload;
    function GetCount: Integer;
  public
    procedure AddNumero(const ANum: byte);                 // Inserta un numero en la combinacion
    procedure aleatorio;                                   // rellena con una combinacion aleatoria
    function AsString: string; overload;                   // devuelve la combinacion como un string
    procedure clear;                                       // vacia la combinacion
    function comparar(const combinacion: TCombinacion): Tcombinacion;
    function obtenerComunes(const combinacion: Tcombinacion): string;

    property Count:Integer read GetCount;                  // Indica cuantos numeros tiene esta combinacion
    // esta propiedad es para comparar si un determinado numero pertenece a la combinación
    property Numero[ANum:byte]:Boolean read GetNumero;

    // añadir tantos metodos load como sea necesarios
    function load(list: array of Byte): boolean; overload; // carga una combinacion determinada
  published
  end;

Código Delphi [-]
const
  MaxCount: integer = 5;

  ...
  
function TCombinacionHelper.load(list: array of Byte): boolean;
var
  i: LongInt;
begin
  Result := False;
  clear;
  // if length(list) = MaxCount then begin   //<-- Quita esta linea 
    for i := 0 to High(list) do
      AddNumero(list[i]);
    Result := true;
  // end;    //<-- Quita esta linea
end;

Código Delphi [-]
var
  i:longint;
  combinacion1, comunes:Tcombinacion;
  cs1: string;
  lista:  array of TCombinacion;
begin
  try
    setLength(lista, 5000);
    //rellenar una lista de 5000 elementos con una combinación aleatoria
    for i:=0 to high(lista) do
      lista[i].aleatorio;

    //cargar la combinación maestra
    if not Combinacion1.load([1, 45, 33, 14, 20, 22]) then begin
      MessageDlg('La combinacion no es valida!!!', mtError, [mbOK], 0);
      exit;
    end;

    // guarda la combinacion1 en un string,
    // esto es solamente por acelerar el proceso a la hora de mostrar la combinacion
    // como string y no repetirlo en cada ciclo del bucle
    cs1 := Combinacion1.AsString;
    //recorre el bucle para analizar todas las combinaciones con la combinacion principal
    for i := 0 to high(lista) do begin
      /// compara una combinacion con otra y obtine los comunes a ambas combinaciones
      comunes := lista[i].comparar(Combinacion1);
      /// si el valor es 0 entonces no hay numeros comunes
      if comunes <> 0 then
        memo1.Lines.Add(cs1 + #9 + lista[i].AsString + #9 + '(' + IntToStr(comunes.count) + ') ' + comunes.AsString);
    end;
  finally
    setLength(lista, 0);
  end;

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
  i:longint;
  combinacion1, comunes:Tcombinacion;
  cs1: string;
  lista:  array of TCombinacion;
begin
  try
    setLength(lista, 50000);
    //rellenar una lista de 5000 elementos con una combinación aleatoria
    for i:=0 to high(lista) do
      lista[i].aleatorio;

    //cargar la combinación maestra
    if not Combinacion1.load([StrToInt(edit1.Text)]) then begin
      MessageDlg('La combinacion no es valida!!!', mtError, [mbOK], 0);
      exit;
    end;

    // guarda la combinacion1 en un string,
    // esto es solamente por acelerar el proceso a la hora de mostrar la combinacion
    // como string y no repetirlo en cada ciclo del bucle
    cs1 := Combinacion1.AsString;
    //recorre el bucle para analizar todas las combinaciones con la combinacion principal
    for i := 0 to high(lista) do begin
      /// compara una combinacion con otra y obtine los comunes a ambas combinaciones
      comunes := lista[i].comparar(Combinacion1);
      /// si el valor es 0 entonces no hay numeros comunes
      if comunes <> 0 then
        memo1.Lines.Add(cs1 + #9 + lista[i].AsString + #9 + '(' + IntToStr(comunes.count) + ') ' + comunes.AsString);
    end;
  finally
    setLength(lista, 0);
  end;
end;

Código Delphi [-]
Combinacion1.load([StrToInt(edit1.Text)])

Código Delphi [-]
    ...
    // añadir tantos metodos load como sea necesarios
    function load(list: array of Byte): boolean; overload; // carga una combinacion determinada
    function load(value:int64):boolean; overload; //carga a partir de un Int64   

    ...

function TCombinacionHelper.load(value: int64): boolean;
begin
  self:=value;
  result:=true;
end;

Código Delphi [-]
  if not Combinacion1.load(StrToInt(edit1.Text)) then begin
      MessageDlg('La combinacion no es valida!!!', mtError, [mbOK], 0);
      exit;
  end;

Código Delphi [-]
var
   numeros:Array[1..6] of byte;
begin
  ...
  numeros[1]:=StrToInt(label1.caption);  
  numeros[2]:=StrToInt(label2.caption);
  ...
  numeros[6]:=StrToInt(label6.caption);

  combinacion1.load(numeros);
  ...
end;

Código Delphi [-]
...
...
case comb.ItemIndex of
    0: //corresponde con el valor 5000
    begin
    listBox1.Clear;
    //repeat;
    listBox1.clear;
    setLength(list, 5000);
    //rellenar una list de 5000 elementos con una combinación aleatoria
    for i:=0 to high(list) do
      list[i].aleatorio2;

    //cargar la combinación maestra
    if not Combinacion1.load([1, 45, 33, 14, 20, 22]) then begin
      MessageDlg('La combinacion no es valida!!!', mtError, [mbOK], 0);
      exit;
    end;

    // guarda la combinacion1 en un string,
    // esto es solamente por acelerar el proceso a la hora de mostrar la combinacion
    // como string y no repetirlo en cada ciclo del bucle
    cs1 := '23 45 17 15 22 36'; //Combinacion1.AsString;
    //recorre el bucle para analizar todas las combinaciones con la combinacion principal
    for i := 0 to high(list) do begin
      /// compara una combinacion con otra y obtine los comunes a ambas combinaciones
      comunes := list[i].comparar(Combinacion1);
      /// si el valor es 0 entonces no hay numeros comunes
      if comunes <> 0 then
        //memo1.Lines.Add(cs1 + #9 + lista[i].AsString + #9 + '(' + IntToStr(comunes.count) + ') ' + comunes.AsString);
        listBox1.Items.Add(IntToStr(listBox1.Items.Count)+#9+'Maestra: '+cs1 + #9 + 'Aleatoria: '+list[i].AsString + #9 + '(' + IntToStr(comunes.count) + ') ' + comunes.AsString);
      if comunes = 5 then
      with lista.Items.Add do
      begin
        caption:= IntToStr(lista.items.count);
        subItems.Add(cs1);
        subItems.Add(list[i].AsString);
        subItems.Add(IntToStr(comunes.count));
      end;
    end;
    inc (int);
    {until lista.Items.Count > 1 ;
    label4.visible:= true;
    label4.Caption:='Realizadas '+IntToStr(int)+' pasadas.';
    panel1.Visible:= false;}
    end;

Código Delphi [-]
cs1 := '23 45 17 15 22 36';

Código Delphi [-]
function TForm1.GetComboBoxValue: Integer;
begin
  result:=0;
  with combobox1, items do
    if Itemindex>=0 then
      try
        //Convierte la cadena del combo en un numero
        result:=StrToInt(Items[itemIndex]);
      except
      end;
end;

procedure TForm1.GenerarCombinacionesAleatorias(const Numero:Integer);
var
  i:longint;
begin
  setLength(listCombinaciones, Numero);
  for i:=0 to High(listCombinaciones) do
    listCombinaciones[i].aleatorio;
end;  

function TForm1.BuscarMejorcombinacion: Tcombinacion;
begin
  //cargar la combinación maestra
  ... 
end; 

procedure TForm1.Button9Click(Sender: TObject);
var
  NumeroDeElementos:Integer;
  CombinacionMaestra:TCombinacion;
begin
  //Obtiene el numero de elementos seleccionado por el usuario en el combobox
  NumeroDeElementos:=GetComboBoxValue;
  //Genera una lista de N elementos de combinaciones aleatorios, mostrándolas en un listbox
  GenerarCombinacionesAleatorias(NumeroDeElementos);
  // Obtiene la combinación maestra
  CombinacionMaestra:=BuscarMejorcombinacion;
  //compara las combinaciones aleatorias con la combinación maestra
  CompararCombinacionesAleatorias(CombinacionMaestra);
end;

Código Delphi [-]
...
...
case comb.ItemIndex of
    0: //corresponde con el valor 5000
    begin
  ...

*.- te recomiendo que a las variables importantes y mas o menos globales les pongas nombres descriptivos que a simple vista sean fácilmente identificable.

Código Delphi [-]
cs1 := '23 45 17 15 22 36';

Código Delphi [-]
cs1 := CombinacionMaestra.AsString;