Esto si es un reto
 

Hola amigos, espero que podais ayudarme, vereis, tengo un array que va desde 0 hasta z. En lo que estoy trabajando en un código que me de todas las combinaciones posibles de los elementos de array, osea que cuente de 0 hasta zzzzzzzzzzzzz.

Me podeis ayudar??

pues un for de 0 to z ja ja ja :D

je je je o mejor un while del 0 al zzzzzzz...

... como no te expliques mejor.....

Código Delphi [-]
var sueño :char;
begin
for sueño := 'a' to 'z' do
  ups  que sueeeeeeeño

Haber si me explico.

Tengo un array con los siguiente valores:
0 1 2 3 4 5 6 7 8 9 - _ a b c d e f g h i ... z

ok? son 39 valores en total los que tiene el array. La cuestión es hacer un código para que por ejemplo meta en un memo todas las combinaciones posibles entre los valores del array, y como se consiguen todos las combinaciones posibles? Pues empezando por 0 y terminando en zzzzzzzzzzz...zz (39 zetas). Si el array tuviese sólo del 0 al 9 el resultado sería obvio, empezaría en 0 y terminaría en 9999999999.

Espero haberme explicado ;)

Fácil: Factorial del array :D


Se que no es eso pero es por el cachondeo del viernesssssssssssss, por fin es viernes.........................................siiiiiiiiiiiiiiiii

:confused:

Melospliquenn??

esto suena a problema de clase de programación jejeje.

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
const a ='abcdef';
var s:string;
    procedure Rec(p:integer);
    var i:integer;
    begin
      for i:=2 to length(a) do
      begin
          s[p]:=a[i];
          memo1.lines.add(s);
      end;
      if pthen Rec(p+1);
    end;
begin
  s:='aaa';
  memo1.lines.add(s);
  rec(1);
end;

mas compacto aun:

Código Delphi [-]
procedure TForm1.Button2Click(Sender: TObject);
const a ='abcdef';
var s:string;
    procedure rec (i,j:integer);
    begin
          s[i]:=a[j];
          memo1.lines.add(s);
          if i<=length(s) then
             if j=length(a) then rec (i+1,2)
             else rec (i,j+1);
    end;
begin
  s:='aaa';
  rec(1,1);
end;

mmmm alguien recuerda los viejos punteros?

Código Delphi [-]
procedure TForm1.Button3Click(Sender: TObject);
var p,g:PAnsiChar;
    s,a:string;
begin
  s:='aaa';
  a:='abcdef';
  p:=@s[1];
repeat
      g:=@a[1];
      repeat
            Memo1.Lines.add(s);
            p^:=(g+1)^;
            inc(g)
      until g=a[Length(a)];
      inc(p);
until (p>@s[Length(s)]);
end;

se nota que me aburro

Hola ruina.

Me parece que el algoritmo propuesto no da realmente todas las combinaciones... he hecho de manera rápida una función que, valiendose de la recursividad, promete dar todas las combinaciones posibles de un array de caracteres, en un string de una longitud determinada.

Código Delphi [-]
Procedure CombinaArray(cars : Array of char; longitud : Integer; resultado : TStrings);

  Procedure Combinacion(const prefijo : String; NivelesPendientes : Integer);

  Var
    i : Integer;
    res : String;

  Begin
    for i := low(cars) to high(cars) do
    begin
      res := prefijo + Cars[i];
      if NivelesPendientes > 0 Then
        Combinacion(res, NivelesPendientes - 1)
      else
        resultado.Add(res);
    end;
  end;

begin
  combinacion('', longitud - 1);
end;

La forma de uso sería algo como:

Código Delphi [-]
  Memo1.Lines.Clear;
  memo1.Lines.BeginUpdate;
  CombinaArray(['a', 'b', 'c', 'd', 'e', 'f'], 5, memo1.Lines);
  Memo1.Lines.EndUpdate;

Hasta luego.

;)