[[Delphius]]

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. Si alguno le ve el error avise.

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

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!  ¡Si tiene euros mejor! Envíe por
 e-mail...   :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,