Revisión de código

[danielmj]

Hola, quiero rellenar un listview con los valores de un lisbox pero no se que hago mal Pero devuelve una excepcion.

Código Delphi [-]
procedure TForm1.Button2Click(Sender: TObject);
var
  i,j: integer;

begin
  for i:= 0 to 5 do
  for j:= 0 to listBox1.Items.Count -1 do; //..> el listbox tiene 6 elementos
    lista.Items[i].SubItems[0]:= listBox1.Items.Strings[j];
    ...
    lista.Items[i].SubItems[5]:= listBox1.Items.Strings[j];
end;

Alguna idea o comentario?

[ecfisa]

Hola.

Te pongo un ejemplo que crea las seis columnas con sus títulos y agrega los seis items del ListBox en cada columna creada:

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;

Muestra:


Saludos

[bucanero]

Te dejo por aquí otro ejemplo en donde he creado una especie de clase llamada TCOMBINACION con las posibles funciones que necesitas y donde puedes ver su funcionamiento.

Es unidad totalmente independiente y sin enlaces a la parte visual de la aplicación

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.

y en la pantalla principal se puede usar de la siguiente manera (solo hay dos botones y un memo):

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;

[danielmj]

Gracias ecfisa y bucanero, miraré vuestro codigo sin falta por que ya no sé que mas hacer (lmitación de conocimientos siendo honesto)

En este momento, tengo este codigo para generar los aleatorios no repeditos

en una unidad aparte, uso esta funcion para generar los aleatorios no repetidos:

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.

en la unidad principal tengo esto...

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.

Bien, cada vez que pulso el button1, se genera en el listbox1 una combinacion de 6 numeros aleatorios sin repeticion y si pulso el button2, mete el contenido del listbox1 en el listview y hace una llamada a button1.
Y aqui viene mi problema por mucho que coloco for y while... no consigo rellenar el listview con por ejemplo 50, 100, 140 combinaciones de 6 numeros aleatorios que me entrege la funcion, o mejor dicho, lo rellena pero salvo la primera fila, el resto siempre son la misma combinacion.

Ejemplo:
3 5 7 12 45 32
23 4 12 41 33 13
23 4 12 41 33 13
23 4 12 41 33 13
23 4 12 41 33 13
...

Saludos y muchas gracias por vuestro tiempo, ayuda y paciencia.

[bucanero]

Empezado por danielmj

Y aqui viene mi problema por mucho que coloco for y while... no consigo rellenar el listview con por ejemplo 50, 100, 140 combinaciones de 6 numeros aleatorios que me entrege la funcion, o mejor dicho, lo rellena pero salvo la primera fila, el resto siempre son la misma combinacion.

A mi el código que has publicado me funciona correctamente, el botón numero 1 genera una combinación aleatoria y el botón 2 la inserta en un listview. Y vuelve a generar otra combinación distinta. Si le doy al botón muchas veces, todas las combinaciones que genera son distintas.

Puede ser que tu problema vaya por el RANDOMIZE aunque creo que ya no es necesario inicializarlo pero no se exactamente en LAZARUS como va. Incluye en el create del form el comando randomize.

[danielmj]

Hola bucanero, si, si voy pulsando el boton 2, si lo hace bien, pero mi proposito es que al pulsar el boton 1, se cargue el listview de forma automantica y con por ejemplo 400 combinaciones diferentes y no tener que estar pulsando el button2 todo el tiempo.
Voy a probar lo del randomize pero dudo que me solucione nada en este caso. Gracias.

[mamcx]

Tu problema es que estas mezclando muchas cosas e ignorando la recomendacion de casimiro.

Tienes que aislar cada sub-tarea y una vez este resuelto, ir a la siguiente.

Tu primer problema es generar los numeros aleatorios. Es claro que no entiendes bien esto porque vas pegando el codigo sin darte cuenta que es ineficiente o que tiene errores obvios (como el que sacaste de ese foro).

Una cosa importante es tratar de eliminar las variables globables y semiglobales de tu programa, que mutar estado es de lo mas problematico y fuente de muchos errores.

Te paso un ejemplo de como limitas el codigo a un unico problema: Generar numeros aleatorios no repetidos, y ademas, de forma elegante:

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.

Nota que queda funcionando sin necesidad de decidir si usas array u otra cosa, y sin complicar con variables la claridad del codigo. Cada vez que uses for i in TRandomInt se encargara clase solita de manejar sus datos y reglas internas.

El chequeo de si el numero ya fue usado antes se puede eliminar y la clase queda totalmente eficiente ya que no consume casi nada de memoria, pero veo que te enrueda mucho y el paso de quitar los duplicados quedaria complicado ya que tocaria reajustar las matrices.

Asi, es totalmente encapsulado!


---

Ya teniendo el tema resuelto de los numeros la parte visual deberia resultarte trivial y con los que te han mostrado suficiente...


P.D: Hay mas cosas que se pueden optimizar (como cambiar el hashset por un bitset) pero creo que es suficiente asi...