Revisión de código

[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...

[danielmj]

Hola mamcx,
Tal vez tienes razón, pero creo que es obvio que yo no me dedico a esto de la programación, ni tengo una carrera en sistemas, análisis o informática en general. Para mí es un hobby, y lo mucho o poco que sé es por los 5 años de fp en informática de gestión del 95 al 2000, y ya ha llovido desde entonces como para acordarme de la mayoría de las cosas amén que muchas otras jamás vi.
Es cierto que encontré el código en un foro, pero tengo que coger un poco de aquí y un poco de allí podrá formar una especie de puzzle que me permita evadir mi falta de conocimientos que seguro tu tienes.

Yo vengo aquí buscando ayuda y lo único que puedo dar a cambio es la intención. La intención en intentarlo una y otra vez, buscando aquí y allá y sumando lo poco que sé.
Por otra parte, no he ignorado el consejo de Casimiro, se leer e interpretar un algoritmo sobre papel siempre y cuando esté dentro de mi alcance. En este caso no lo está por eso pregunto. Sino, no podría hacer este programa. Voy a ser más concreto.. en el código que ya tenía, conseguía generar números aleatorios sin repetir, el problema es que desconozco la sintaxis para agregar el contenido del listbox al listview x número de veces.
Antes dije, que estudie 5 años de informática de gestión, pero nunca use programas con interfaz gráfica, siempre fueron Pascal 7 y COBOL para MSDOS ambos. Lo poco que sé de Delphi y su manejo en entornos gráficos, ha sido por cuenta propia de ahí que no conozca tantas rutinas o formas de realizar un programa como podais tener vosotros.

En fin, no me extiendo más, esto lo digo sin ánimo de acritud y su estoy resultando muy pesado, pues me lo decís y yo recojo los bártulos y me voy tal como vine.
Ahora mismo estoy en el curro, fuera de turno pero en el curro, cuando llegue a casa miraré tu código.
Gracias por todo a todos.

[Casimiro Notevi]

Empezado por danielmj

el problema es que desconozco la sintaxis para agregar el contenido del listbox al listview x número de veces.

El último ejemplo de ecfisa hace eso.

Empezado por danielmj

pero nunca use programas con interfaz gráfica, siempre fueron Pascal 7 y COBOL para MSDOS ambos.

Eso te comenté antes, que no necesitas la parte gráfica, porque hace al programa muy lento. Fíjate en el código que ha puesto mamcx, no usa la interfaz gráfica tampoco.
Eso es algo opcional para presentar finalmente los números, o los botones, etc. pero no es necesario para la ejecución del programa.

Empezado por danielmj

En fin, no me extiendo más, esto lo digo sin ánimo de acritud y su estoy resultando muy pesado, pues me lo decís y yo recojo los bártulos y me voy tal como vine.

Nada hombre, con un poco de paciencia y poquito a poquito, verás como lo consigues, pero no debes "empecinarte" en cuestiones gráficas, sino en la rutina de funcionamiento del programa.

[danielmj]

gracias Casimiro, en un rato tengo que salir hacia la oficina del trabajo pero mientras me pongo a revisar codigos. Un saludo.

[danielmj]

Hola bucanero, estoy teniendo problemas con la linea "record helper for" lazarus no la reconoce, al parecer se implementó a partir de la version XE3. Intengo encontrar algo similar pero por ahora nada. Así que no puedo probar tu codigo. Saludos.
Por cierto, tengo d7 corriendo en linux y tampoco lo reconoce.

[bucanero]

Veo que en lazarus los HELPER son un poco distintos a DELPHI,

prueba de la siguiente forma:

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;