generar numero de 9 cifras aleatorio que nunca se repita
 

Hola a todos.

Necesito generar un codigo de cliente, de 9 cifras, pero que aparte de ser alatorio, pero nunca correlativos, nunca genere el mismo, es decir que tenga en cuenta alguna variable, como la fecha, no se.

Necesitaria generar gran cantidad de numeros. Luego si paro el proceso y sigo generando, que nunca se repitan con los ya generados.

gracias de antemano.

Espero que te sirva...
 

Hola coletaun, en los foros se ha hablado mucho de esto. Y en algunas ocasiones yo he participado. Mirate estos hilos:

Hilo 1
Hilo 2

Te pueden ser de utilidad. Ahora... tu dices que quieres generar números de 9 cifras. Eso es sencillo, en el Hilo 1 vas a encontrar un pst mio en el que he dejado un código. Hay varios algoritmos (no me acuerdo si esos estaban en POO, o eran simples funciones). En todos ellos, para generar un número de cierta cantidad de cifras sólo basta con asignmar al valor del módulo (m) un valor más. Por ejemplo: para 4 cifras: 10000. Para 9 cifras: 1000000000.
Pero recuerda que si usas los algoritmos que yo puse... vas a tener que modificarlos un poco para que almacene los anteriores generados con el fin de chequear si se repiten.

Espero que te sirva.
Saludos,

Bueno, ahí va una de mis ideas de bombero :D

El siguiente método nos sirve para generar números aleatorios, pero que no se repiten. Lo único malo es que solo permite generar 99999 números distintos. Lo bueno en cambio es que solo tenemos que guardar un valor de una vez a otra para asegurarnos de que no se repite ningún numero, en vez de guardar una lista completa de los que ya salieron.

El método es simple, generamos un numero aleatorio de de cuatro cifras y entrelazamos sus dígitos con los dígitos de otro numero consecutivo de 5 cifras. De esta forma el numero sigue siendo aleatorio, pero el numero consecutivo nos asegura que nunca se va a repetir.

Es decir:

Código Delphi [-]
function Entrelazar(i,j: integer): string;
begin
  Result:= '';
  while (i > 0) or (j > 0) do
  begin
    Result:= Format('%d%d',[i mod 10, j mod 10]) + Result;
    i:= i div 10;
    j:= j div 10;
  end;
  while Length(Result) < 9 do
    Result:= '0' + Result;
  Result:= Copy(Result,1,9);
end;

// Obtenemos el valor guardado de i
i:= i + 1;
ShowMessage(Entrelazar(Random(9999),i));
// Guardamos el valor de i

El valor que tenemos que guardar de una vez a otra, lo podemos guardar en un archivo, en el registro de windows, en una base de datos, etc ...

Interesante método de resolverlo seoane. Ha decir verdad, me resulta elegante.

Ahora bien... tu código dice:

Código Delphi [-]
function Entrelazar(i,j: integer): string;
begin
  Result:= '';
  while (i > 0) or (j > 0) do
  begin
    Result:= Format('%d%d',[i mod 10, j mod 10]) + Result;
    i:= i div 10;
    j:= j div 10;
  end;
  while Length(Result) < 9 do
    Result:= '0' + Result;
  Result:= Copy(Result,1,9);
end;

// Obtenemos el valor guardado de i
i:= i + 1;
ShowMessage(Mezclar(Random(9999),i));
// Guardamos el valor de i

Primeramente llamas Entrelazar y luego Mezclar:confused:
Pero la idea es buena... y tal vez mis algoritmos GNA sean demasiados para lo que coletaun necesita. Sobre todo si previamente hay que modificar mi/s algoritmo/s para que "recuerde" y además hay que calcular un valor correcto de los parámetros para garantizar que la serie no se repita.

Tal vez con el tiempo... si la cantidad de clientes aumenta (y asi parece ser... pues por algo necesita de números de 9 digitos) habría que modificar un poco tu codigo para que funcione.

Igulmente hay que ver que nos dice coletaun de esto...
Saludos,

Jeje, corregido Delphius me lié con el nombre de las funciones :D

No hay problema... como dijo Alf
 

No hay problema... a cualquiera le puede suceder. Yo no me daría cuenta, de no ser porque leo dos o tres veces cada mensaje (para aseguarme de que entiendo lo que leo) y además... al ser otro tema que me gusta (modelos y simulaciones... que esta muy de la mano con esto) con más razón le presto atención.:)

Saludos,

Metodos congruenciales y cuadrados
 

Hola Coletaun, creo que eso es un tema de modelos y simulacion que me enseñaron en la universidad, lo que buscas es un modelo con una semilla y otros parametros que no me acuerdo que logren generar numeros aleatoreos que no degeneren, bueno para esto existen los metodos de los cuadrado medios (que no es recomendable porque degeneran rapidamente), pero puedes usar el congruencial mixto multiplicativo (si es que sabes escoger los parámetros correctos).

Se dice que un valor (semilla y algunos parametros) degeneran rápidamente, cuando los valores ingresados hacen que despues de un ciclo corto de #s aleatoreos se vuelvan a repetir de nuevo la secuencia, por ejemplo:

6,9,11,343,23,6,9,11...

te das cuenta por ejemplo si tuvieras esta seria con los parametros que ingresaras y te sale esta serie, se puede observar que se repite rapidamente, por lo tanto se degenera rapidamente.

Esto siempre pasa si usas el metodo de los cuadrados medios.
Pero si usas los valores correctos con el congruencial mixto multiplicativo no pasaria esto.

Por si acaso estos números no deben llamarse aleatoreos (ya que eso lo logras con tecnicas realmente al azar como el metodo de montecarlo, o utilizando la tabla de ibm utilizada para obtener numeros aleatoreos reales, ya que los números que te botan los metodos mencionados arriba se denomina pseudoaleatoreos, pero para los programas o sistemas se utilizan estos numeros pseudoaleatoreos

Si deseas saber sobre este tema de generación de números aleatoreos entra a la pagina de mi universidad:

www.sistemas.unmsm.edu.pe

en el lado derecho hay un ftp -> ciclo 2006-II ->Modelos y Simulacion y finalmente te bajas el archivo "Clase07NumAlea.ppt" que explica ese tema, si quieres explayarte mas buscas en google.

Espero te sirva

Saludos cordiales:)

En la página del Dr Alan Miller pueden encontrar info sobre números aleatorios, en fortran, pero se puede traducir a pascal o hacer una dll.
Allí también hay links a varios sitios interesantes.

saludos

fer21unmsm, de eso precisamente me refiero cuando le indico a coletaun sobre mis algoritmos que puede conseguir en el hilo 1 que mencioné.

Y ahora que me acuerdo... no debería modificar ninguna parte del código. Si emplea el algoritmo Mixer() que detallo a continuación:

Código Delphi [-]
function Mixer(Seed_X0, a, b, m, Series: int64; var List: TStringList): integer;
{************************************************
 Genera una serie de números aletorios siguiendo
 el método congruencial mixto.
 * Parámetros *
 Seed_X0: valor semilla ( Corresponde a X0)
 a: factor multiplicativo
 b: factor aditivo
 m: módulo
 Series: cantidad de números a generar
 List: array de strings con los resultados
 ************************************************}
 var Ant,Sig:int64;
     i:integer;
 begin
 // realizamos unas preventivas:
 result := Preventive2(Seed_X0,a,m,Series);
 if result <> PROCESS
    then exit;
 Ant := 0;
  // borramos el contenido de la lista
 List.Clear;
 for i:=0 to Series-1 do
   begin
     if i = 0
        then begin
             List.Add(Format(RS_RESULT,[i,Seed_X0]));
             Ant := Seed_X0;
             end
        else begin
             Sig := (((a * Ant) + b) mod m);
             // agregar a la lista
             List.Add(Format(RS_RESULT,[i,Sig]));
             Ant := Sig;
             end;
   end;
 result := GENERATE;
 end; {Mixer}

Siendo Preventive2:

Código Delphi [-]
function Preventive2(Seed_X0,a,m,Series:int64): integer;
{************************************************
 Esta función permite chequear algunos valores
 iniciales para:
 * Multiplicative
 * Mixer
 * Parámetros *
 Seed_X0: valor semilla (Corresponde a X0)
 a: factor multiplicativo
 m: módulo
 Series: cantidad de números a generar
 ************************************************}
 begin
 if Seed_X0 = 0
    then begin
         result := SEED_X0_ZERO;
         exit;
         end;
 if a = 0
    then begin
         result := A_ZERO;
         exit;
         end;
 if m = 0
    then begin
         result := M_ZERO;
         exit;
         end;
 if Series < 1
    then begin
         result := INCORRECT_SERIES;
         exit;
         end;
 result := PROCESS;
 end; {Preventive2}

Las declaraciones en mayúsculas como M_ZERO son constantes y no vienen al caso ponerlas... que ya es intituivo.

Con los parámetros indicados, conseguirá su propósito No es necesario alterarlo... en List quedarán registrados los valores que necesite:cool:.

De seguro que en el enlace que mencionas va a cosneguir información académica y la explicación del algoritmo. Junto con el axioma adecuado para elegir los valores.

Si... es cierto... deberían llamarlos asi. Pero para simplificar las cosas... y evitar alguna confusión de parte de coletaun. Sería meyor decirles aleatorios. Y recuerda fer21unmsm, estos métodos están basados en la teoría de los grandes números... y hay tests adecuados para verifivar si pueden considerarse "aletorios". Yo hice mis pruebas a todos mis algoritmos, con diversos valores y la pasaron en un 100%:D.

Robert01, habría que ofreces en el enlace que detallas. Y no deberían descartarse...

A ver que dice coletaun de esto: si le sirve... o definitivamente lo hemos asustado con esto de los generadores multiplicativos... tests y teoria de los grandes números.:rolleyes:

Saludos,

Muchas gracias a todos
 

Con toda esta información, me documentaré y vere la mejor solucción. Diré que lo creía algo mas trivial de lo que realmente es lo de la secuencia de números aleatorios y la no repetición de los mismos.

Muchas gracias a todos por su interes, de verdad. Voy a ponerme manos a la obra.