Generación de Código Alfanúmerico Automatico
 

Hola Amigos,

Vamos a ver si me explico para no liarnos y a ver si me podeis echar una mano.

Tengo que implmentar un pequeño programa para que un codigo alfanumérico de 14 dígitos se autoincremente de forma automática. Es decir, si el código es LX345J8ON9913 el siguiente codigo sea LX345J8ON9914 y así sucesivamente. ¿Sabeis si hay un programa con prestaciones similares y donde puedo descargarlos? ¿Alguna sugerencia para su implementación?

Gracias y un saludo a todos.

Bueno, depende de cómo funcione ese código alfanumérico. El ejemplo que has puesto se entiende, pero, ¿y si el código es 1234567890AAA9? ¿Qué pasaría? ¿Se convertiría en 1234567890AAB0? ¿O en 1234567890AAAA? Dinos, cómo funciona con las letras, por favor. Gracias.


Salu2.

P.D.: También sería bueno saber si tienen una cierta estructura (tantas letras, tantos números en ciertas posiciones) o si es completamente mezclado.

Hola ixMike,

Gracias por tu ayuda. Con respecto a tus dudas, del ejemplo que te mostré el siguiente codigo generado será el primero de los ejemplos.

En cuanto a la estructura, no hay ninguna secuencia determinada, solamente es una combinación de numeros y letras mezclados.

Gracias nuevamente por tu ayuda.

Pero sigo sin saber, ¿después del 9 va un 0, un 1 o una A? ¿y después de una Z? ¿Va un 0, un 1 o una A?

Hola ixMike,

En respuesta a tu pregunta, después de un 9 irá un 0, incrementándo el número o letra del lado izquierdo. Por ejemplo, si tenemos 1234567890AAA9 el siguiente será 1234567890AAB0.

Si llegamos al caso de la combinación 1234567890AAZ9 el siguiente sería 1234567890ABA0, y así sucesivamente.

Espero que ahora me haya explicado mejor.

Gracias y un saludo

ok, ya se entiende :)

Prueba con algo así:

Código Delphi [-]
var //variables globales
  codigo: array[1..14] of char;
//nota: así podrás usar la variable como un string.

procedure Incrementar(pos: integer);
begin
if (codigo[pos] in ['0'..'8']) or (codigo[pos] in ['A'..'Y']) then codigo[pos]:=Ord(codigo[pos]+1) else
if codigo[pos]='9' then
  begin
  codigo[pos]:='0';
  incrementar(pos-1);
  end
else if codigo[pos]='Z' then
  begin
  codigo[pos]:='A';
  incrementar(pos-1);
  end;
end;

Nótese que tú sólo tendrás que llamar a la función con el parámetro 14 (el último caracter). Lo del parámetro es para la recursividad, y así optimizar el código.

Espero que te sirva.



Salu2. :)


Edito: tenía un "bug" donde la fución Ord. Solucionado (gracias Delphius por probarlo).

Me parece que esta mal como lo están planteando....y si el código termina en letra???

Me parece podría definirse un número de base 24, es decir la secuencia posibles valores para cualquier dígito vendría dada por:

01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ

pero aqui tenemos las siguientes variantes:

despues de 0 sigue A y despues de Z sigue 0
despues de Z sigue A y despues de 0 sigue 1

tendrías que escoger cuales van a ser las reglas a aplicar ya que como puedes ver solo es posible aplicar 2 a la vez

Yo creo que tal cual está planteado las letras son independientes de los números. Y así lo he planteado yo en mi código.

En otras palabras: las letras son siempre letras y los números siempre números.

Así, a A9 sigue B0 y a 3Z sigue 4A.

Al menos así lo he entendido, según la explicación.


Salu2.

Por curiosidad, ¿qué sigue a Z9?, ¿A0, AA0, 1A0? ¿otra distinta?

yo diría que:

-como el código es de 14 dígitos, a 00000000000000Z9 sigue 000000000001A0.
-como el que has puesto es de sólo dos, pues un reset a A0 o se añade otro dígito, 1A0, o también AA0, ya que el dígito anterior no estaba...

de todas formas, en un código de 14 iniciado previamente de alguna forma no se creará tanta confución (claro, a no ser que sea 9Z9Z9Z9Z9Z9Z9Z :D:D)

Disculpen que meta más leña al fuego... pero hay que preguntarlo ahora:
¿Se contempla la Ñ?

Esto lo digo porque muchas veces cuando hablan de letras, y más cuando involucra al abecedario entero, se olvidan que el castellaño tiene una letra más.:(

Saludos,

Mi código no comptempla la Ñ :(

A ver... no estamos liando. Y es normal que suceda porque no esta bien aclarada la regla.

1. Leer caracter N-ésimo:
2. Evaluar caracter:
2.1. Si es numero:
2.1.1. incrementar valor según módulo 10.
2.1.2. Si caracter es ahora 9:
2.1.3. Volver a paso 1 siendo el caracter (N-1)-ésimo.
2.2. Si es letra:
2.2.1. incrementar valor caracter.
2.2.2. Si caracter es ahora Z:
2.2.3. Volver a paso 1 siendo el caracter (N-1)-ésimo.

¿Voy bien?
Ahora mi pregunta es ¿que hacer cuando se llega al final de la cadena y si el valor es 9 o Z?

De cualquier modo... no está bien dicho la cosa.

Pues precisamente a eso me refiero. Tanto tu como Azid no han contemplado la Ñ. ¿La usamos?

luxus, debes definir concretamente como son las reglas para que el algoritmo funcione como debe.

Saludos,

Si queremos que sea portable, no se debe contemplar, muy a pesar de cervantes :p:p

Ya se me van a quemar vivo pero para mi (y para muchos) la Ñ no es letra, como tampoco lo es "Ch" y "Ll".

Tal vez no se la use mucho... pero para mi tiene uso. Es una letra... si figura en el diccionario... pues ¡aceptarla!

En fin, no me hagas caso.... hoy he estado un poco cabrón:D
Es muy cierto que la Ñ se la pasan de largo, y es por ese motivo que yo la incluyo.
Pero aqui, para "práctica" podemos obviarla. Vale.

Quería preguntarte... como lo estás entendiendo a esto?
Pues mo me hice lio:o

EDITO:
¿ Y luxus va a dar presencia, o explicar mejor el asunto? Porque hace 4 horas estuvo presente y si al menos hubiera dicho una mínima explicación hubiera sido mejor. Porque al modo en lo veo, pareciera que le estamos haciendo la tarea.

Saludos

No es que pareciera... es que lo es :D

uy, uy.. discusión lingüística... ¡me apunto! :D

Bueno, lo primero, es que uno no puede decir "esto me parece... esto no me parece...". Hay definiciones para cada cosa. Entre esas cosas, la de letra.

Si leéis el enlace (primera acepción) ya queda indiscutible que la ñ es una letra. Pero, ¿qué pasa con "ch" y "ll"? Según la segunda acepción, tradicionalmente también son letras. Pero claro, tradicionalmente... ¿y ahora? Desde luego, tienen su propia pronunciación, pero claro, requieren de más de un signo gráfico para representarlas, es decir, más de una letra. Che y elle son cada una un fonema con dos letras. ¿Por qué no?

Ya se prodía mirar más allá, con esto del Unicode y los CodePoint, pero a fin de cuentas, eso no son más que "artimañas" para simplificar (informáticamente hablando) las cosas.


Y para no desvirtualizar el hilo... ¡luxus, ¿dónde c0~@ te has metido?! Que nos tienes en intríngulis. ¿Metemos la eñe o no? ¿Los números se mezclan con las letras o no?...



Salu2.

Bueno... creo que no hace falta nombrar lo que sabemos... si luxus no pone de su parte... pues... no creo que le encontremos solución, por ahora yo voy a seguir adivinando:

NOTA: comienzo a contar de derecha a izquierda. Doy por supuesto que los carateres son dependientes exclusivamente del anterior. Y que debe incrementar su valor independiente de si es un número o una letra.

1. ¿Que sucede cuando el primer caracter es un 9?
1.1. Se convertiría en un 0 (cero). bien... y ¿ahora?
1.2. ...el caracter a su izquierda debe "incrementarse". Perfecto, y si es ¿9?

2. ¿Que sucede cuando el primer caracter es Z?
2.1. Se convertiría en A. ¿y ahora?
2.2. ... el caracter a su izquierda debe "incrementarse". Perfecto, y si es ¿Z?

Estas dos situaciones, me llevan a:

3. ¿Que sucede cuando el último caracter es un 9?
3.1. Lo incrementamos. Perfecto... se obtuvo un 0 (cero). ¿Que hacemos?
3.1.1. Reemplazamos ese cero por A, dando inicio a las letras. O bien,
3.1.2. No hacemos nada.

4. ¿Que sucede cuando el último caracter es Z?
4.1. Lo incrementamos. Perfecto... se obtuvo A. ¿Que hacemos?
4.1.1. No hacemos nada.

A lo que voy es que la regla, necesariamente debe ser posicional y no sólo del caracter. Voy a pedir que luxus defina concretamente como vienen las reglas. ¡Que hable! ¿O es que este hilo deberá quedar sin solución?

Saludos,

a ver si entendi lo que explicas, necesitas recursividad, algo como esto:

declara unas variables globales:

Código Delphi [-]
nLista: array[1..14] of integer;
    procedure Incrementar(cCadena: String);
    procedure Aumentar(nIndice:Integer);

luego este es el codigo, le pasa la cadena como parametro al procedimiento incrementar y te devolvera una cadena incrementada segun la regla de la A-Z y 0-9

Código SQL [-]
procedure TForm1.Incrementar(cCadena: String);
var
   nCaracter: String;
   nIdx: Integer;
begin
   //Carga el vector de enteros
   for nIdx := 1 to 14 do
   begin
      nCaracter := Copy(cCadena, nIdx, 1);
      nLista[nIdx] := Ord(nCaracter[1]);
   end;

   //Recorre el vector aumentando las cifras
   Aumentar(14);

   //Arma de nuevo la cadena
   cCadena := '';
   for nIdx := 1 to 14 do
   begin
      nCaracter := Char(nLista[nIdx]);
      cCadena := cCadena + nCaracter;
   end;

end;

procedure TForm1.Aumentar(nIndice: Integer);
begin
   //si llego al principio se sale
   if nIndice <= 0 then
      Exit;
   //Aumenta un caracter en la posicion deseada
   nLista[nIndice] := nLista[nIndice] + 1;
   //Si es 91 quiere decir que viene de la Z, lo devuelve al 65 = A, incrementa el anterior
   if nLista[nIndice] = 91 then
   begin
      nLista[nIndice] := 65;
      Aumentar(nIndice - 1);
   end
   //Si es 58 quiere decir que viene del 9, lo devuelve al 48 = 0, incrementa el anterior
   else if nLista[nIndice] = 58 then
   begin
      nLista[nIndice] := 48;
      Aumentar(nIndice - 1);
   end;
end;

Yo creo que luxus nos ha dejado a todos hechos un lío con su secuencia. Como bien menciona Delphius en sus reglas, al parecer no se han preparado antes de elaborar el programa. Estamos ante un problema de secuencias sui-generis, ya que no había visto algo similar antes.

¿Es un sistema posicional? ¿Las letras pueden volverse números? en fin por decir solo unas interrogantes.

Bueno, y porque no usar los conceptos de las conversiones Binarias, decimales, octales, hexadecimales, pues nos hacemos de una nueva Base36. :)

Código Delphi [-]
unit UBase36;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons, Math;

type
  TForm1 = class(TForm)
    BitBtn1: TBitBtn;
    Label2: TLabel;
    Edit1: TEdit;
    procedure BitBtn1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

const
  // Generamos nuestro vector de valores de '0' a 'Z'
  Base36 : Array[0..35] of char = ('0','1','2','3','4','5','6','7','8',
                                   '9','A','B','C','D','E','F','G','H',
                                   'I','J','K','L','M','N','O','P','Q',
                                   'R','S','T','U','V','W','X','Y','Z');

var
  Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.BitBtn1Click(Sender: TObject);
var
  Suma,Numero: Extended;
  PosCaracter,Indice: Integer;

  function ConvABase36(N:Extended):String;
  var
    Cadena: string;
    Dividendo,Resultado,Residuo: Extended;

  begin
    Cadena := '';
    Dividendo := N;
    REPEAT
      // 1. Se divide el numero entre 36
      Resultado := Dividendo / 36; 
     // 2. Se resta el resultado y parte entera del resultado y se multiplica por 36
      Residuo := (Resultado - Trunc(Resultado)) * 36; 
      // Se agrega el caracter correspondiente al residuo obtenido
      Cadena := Base36[Trunc(Residuo)]+ Cadena;
      Dividendo := Resultado;
    UNTIL Resultado < 36;
    //Se agrega el caracter del último valor (dividendo) a la cadena
    Result := Base36[Trunc(Dividendo)]+Cadena;
  end;

  function ConvADecimal(B36:string):Extended;

    function GetIndex(Value: Char): Integer;
    begin
      Result := Byte(Value) - 48;
      if Result > 9 then Dec(Result, 7);
    end;

  begin
    Indice := 0;
    PosCaracter := length(B36);
    REPEAT
       Suma := Suma + GetIndex(B36[PosCaracter]) * Power(36,Indice);
       Indice := Indice + 1;
       Dec(PosCaracter);
    UNTIL Indice = (length(B36)-1);
    Result := Suma;
  end;

begin
  //Usar solo cadenas de hasta 12 digitos :(, (por ahora :))
  //Estoy usando un signo ~ antes de la cadena por cuestiones de indices :(
  Numero := ConvADecimal('~'+Edit1.Text)+1; //Directamente sumo uno al valor decimal
  Label2.Caption := ConvABase36(Numero); //Se convierte el numero a Base36
end;

end.

Ahora, podemos sumar a cualquier cadena que nos coloquen, por ejemplo LX345J8ON99.

Nota: No se porque, pero solo suma correctamente hasta 12 digitos, pues bien, habría que mejorar este código.

Salud OS

Buenas!

Aqui vengo yo... con un código revolucionario. No usa recursividad, pero debido a no se... solo funciona correctamente si se pasa cadena en mayusculas. Por más que le meta ansiuppercase(), no funciona. :mad::( Si alguno le ve el error avise.

Bueno no más espera, aqui suelto al bicho. Guarda que muerde:D

EDITO:Realizado en D6.

Código Delphi [-]
unit UCode;

{
 UCode.pas
 Version: 1.quien_sabe
 Autor: Delphius, Clubdelphi
 Idioma del código: Inglés ¿Sino cual :P?

 Descripción:
 (¡No seas vago/a lee!)

 Esta unidad fue elaborara para diseñar un nuevo código a partir de un
 incremento cíciclo. (No se me ocurrió mejor brillante palabra :P)
 La idea de este algoritmo es que dependiendo de si los caracteres son
 números o letras se incremente cíclicamente el valor.

 Después de romper mucho cerebro :S logré percatarme de que:
 1. No es necesario ser recursivo.
 2. No es necesario hacer un pre-análisis para saber el nuevo valor.
 3. Sólo se debe continuar incrementando si es necesario. ¡La consigna indica
    de que se necesita el siguiente. No que debe incrementarse todos los ca-
    racteres!

 Este algoritmo se detiene una vez que no han detectado cambios.
 Un cambio es producido únicamente cuando es necesario incrementar el siguiente
 caracter a su izquierda, y por tanto sólo se produce cuando el caracter ana-
 lizado sea un 9 o Z.

 Se dice que es cíclico debido a que:
 Sig(9) = 0, Sig(0) = 1.
 Sig(Z) = A, Sig(A) = B.

 La confección del algoritmo no está basada en los valores ASCII, sino en la
 ubicación dentro de un vector. Lo cual favorece implementar el ciclo mediante
 la función MOD. Por tanto la fórmula se reduce a un:

 Posic_NuevoChar = (Posic_ViejoChar + 1)  mod Longitud(Vector)

 Teniendo esto en mente se consigue una nueva ventaja. Es fácilmente adaptable
 a la ampliación del vector, logrando así añadir, borrar o alterar la posición
 de los caracteres.
 El vector se llama ALPHA y funciona del siguiente modo:
 * Las diez primeras posiciones pertenecen a los números. REQUISITO: el cero
   debe estar en la décima posición.
 * Las restantes posiciones son letras (o si se desea, caracteres extraños).
   REQUISITO: la 11va posición será para el primer valor del ciclo de letras.

 La unidad cuenta con dos funciones:
 NewCode: Recibe el código (string) y devuelve el siguiente (string).
 EvaluateRule: determina el valor del incremento y predice si se necesita se-
               guir analizando.

 El usuario final sólo necesita llamar a NewCode. EvaluateRule es llamada in-
 ternamente por NewCode.

 Ejemplo de uso:

 Edit2.Text := NewCode(Edit1.Text);

 Así mismo la unidad cuenta con una constante que define la cantidad de carac-
 teres que conforma al código (MAX_LEN). Su valor es 14. Modificando esta
 constante se permite variar el tamaño. Por esto, NewCode emitirá una excep-
 ción si recibe un texto que no sea de igual tamaño que MAX_LEN.

 NOTAS FINALES:
 1. El código no está preparado para chequear caracteres fuera del vector ALPHA
 2. Al ser un algoritmo cíciclo si se recibe como parámetro el valor extremo en
    la secuencia, se obtiene el primer valor. Ejemplos:

    1) NewCode(ZZZ..Z) = AAA..A
    2) NewCode(999..9) = 000..0
    3) NewCode(Z9Z9..Z9) = A0A0..A0
    4) NewCode(9Z9Z..9Z) = 0A0A..0A

 3. Si no es esto lo que se busca... ¡Que hable ahora o calle para siempre!

 BUGS:
 1. Se ha encontrado hasta el momento un sólo bug... no funciona correctamente
    si se ingresa minúsculas! Se ha probado tanto ingresando una preventiva
    con AnsiUpperCase, pero igualmente el código falla. Mostrando el texto
    en minusculas y sustituyendo el valor 13vo por 1. ¡RARO!

 ¿Copyleft? No se... ya estoy dudando... :P
 Se reciben sugerencias! ¡Y cerebro nuevo! :D ¡Si tiene euros mejor! Envíe por
 e-mail... :D :( :P ;)

 Muchas gracias por leer este rollo!
 ¿Ya puedo ir a dormir? :S

}

interface

uses
 SysUtils;

const
  MAX_LEN = 14;
  ALPHA = '1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ';

function NewCode(Code: string): string;


implementation

function EvaluateRule(Character: char; var Changes: boolean): char;
var Posic, MaxChar: integer;
begin
  Posic := Pos(Character,ALPHA);

  // Comprobamos si habrá nuevos cambios.
  // Se producirán cambios en el caracter siguiente a evaluar
  // siempre y cuando el caracter sea 9 o Z
  Changes := (Posic = 9) OR (Posic = Length(ALPHA));

  // incrementamos el valor. De cualquier manera se incrementa el caracter!
  inc(Posic);
  if Posic = (Length(ALPHA) + 1)
     then MaxChar := 10
     else if Posic = 11
             then MaxChar := -10
             else MaxChar := 0;

  // MaxChar nos servirá para movernos entre los números o las letras
  result :=  ALPHA[(Posic mod Length(ALPHA)) + MaxChar];
end;

function NewCode(Code: string): string;
var i,len: integer;
    AuxCode: string;
    FindChanges: boolean;
begin
  len := Length(Code);
  if Len <> MAX_LEN
     then raise Exception.Create('El código no es de MAX_LEN caracteres!');

  i := MAX_LEN + 1;
  FindChanges := False;
  //SetLength(AuxCode,MAX_LEN);
  AuxCode := Copy(Code,1,MAX_LEN);
  AuxCode := AnsiUpperCase(AuxCode);

  repeat
    i := i - 1;
    AuxCode[i] := EvaluateRule(Code[i],FindChanges); // ¿es aquí el bug?
  until NOT FindChanges;

  result := AuxCode;
end;

end.

Y/o por las dudas, lo adjunto.

Saludos,

¿Esto no viene en la otra guía de estilo?.

"No aparezcas en dos semanas, estaremos encantados de seguir soucionando tu problema " :D

Saludos

Pues yo ya tomé a este algoritmo como mi enemigo. Y si le deseamos encontrar el lado bueno, se a vuelto divertido debido a las diversas maneras de comprender a los extraños pedidos del ausente luxus... y en estos días se van a ver florecer coloridos códigos (tal vez muy distintos unos a otros) porque se que esto a atrapado a muchos y los hizo filosofar como a mi.

Saludos,

Nada que, mas parece que estamos en un concurso "a ver quien le atina :D:D:D

Salud OS