Fórum Ajuda com relação de números #499247

27/10/2014

0

Delphi

Boa tarde.

Estou precisando de ajuda para resolver um problema. Eu tenho a seguinte relação de números em uma arquivo txt e estou carregando em um memo ou listbox:

3,4,5,8,10,11,23,25,27,31,37,43,44,45,49
1,2,4,5,6,9,12,13,17,19,25,27,30,31,40
1,2,4,5,6,7,8,9,10,11,12,13,14,15,44,45
etc...

Reparem que a primeira linha tem os números em sequencia; 4,5 - 25,27. A linha dois também tem a mesma sequencia; 4,5 - 25,27.

A linha dois tem a sequencia 1,2,4,5,6 - 12,13. A linha três também tem a mesma sequencia 1,2,4,5,6 - 12,13.

A linha três tem a sequencia 44,45. A primeira linha também tem a mesma sequencia 44,45.

Não sei se expliquei direito, mas o que eu preciso é percorre uma lista de números e identificar se existem números repetidos, ou seja, se na linha X existe o número 1 e na linha Y também existe ele vai separar essas duas linhas para que eu saiba que nelas existem números iguais. Porém deve ser de forma sequencial conforme exemplo acima.

Se por acaso existir o número 20 em uma linha e 20 em outra, porém se o numero seguinte for 21 em uma linha e 22 na outra, ele não vai separar essa linhas pois não houve repetição de sequencia(20,21 - 20,22) e essa sequencia pode ser 2 e 2, 3 e 3, 4 e 4 sucessivamente. E como também citado no exemplo, pode haver mais de uma sequencia repetida entre linhas.

Não se ficou claro, mas como fazer isso?
Pedro

Pedro

Responder

Posts

28/10/2014

Renato Rubinho

Buenos,

Dois loops.
- Para cada número encontrado na linha 1, procura-o na linha 2.
- Se encontrar, identifica qual o próximo número de cada linha e, se forem iguais, guarda numa variável a sequencia encontrada.
- Ao final, mostra os resultados encontrados

procedure TFrmatendepedido.Button1Click(Sender: TObject);
var
  iPosVirg1: integer;
  iPosVirg2: integer;
  jPosVirg1: integer;
  jPosVirg2: integer;
  sLinha1  : string;
  sLinha2  : string;
  sResult  : string;
  sNum1    : string;
  sNum2    : string;
  sNum3    : string;
  sNum4    : string;
begin
  sLinha1 := ',3,4,5,8,10,11,23,25,27,31,37,43,44,45,49,';
  sLinha2 := ',1,2,4,5,6,9,12,13,17,19,25,27,30,31,40,';

  sResult := '';

  iPosVirg1 := 1;
  iPosVirg2 := Length(sLinha1);

  while iPosVirg2 > iPosVirg1 do
  begin
    // Encontra o número a ser verificado
    iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
    sNum1     := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

    // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
    iPosVirg1 := iPosVirg2;
    iPosVirg2 := Length(sLinha1);

    jPosVirg1 := 1;
    jPosVirg2 := Length(sLinha2);

    while jPosVirg2 > jPosVirg1 do
    begin
      jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
      sNum2     := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

      // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
      jPosVirg1 := jPosVirg2;
      jPosVirg2 := Length(sLinha2);

      // Se os números são iguais, valida o próximo
      if sNum1 = sNum2 then
      begin
        sNum3 := Trim(Copy(sLinha1,iPosVirg1 + 1,(iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1))))-iPosVirg1-1));
        sNum4 := Trim(Copy(sLinha2,jPosVirg1 + 1,(jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2))))-jPosVirg1-1));

        if ( sNum3 = sNum4 ) and ( Trim(sNum3) <> '' ) and ( Trim(sNum4) <> '' ) then
          sResult := sResult + sNum1 + ',' + sNum3 + ' ';
      end;
    end;
  end;

  ShowMessage(sResult);
end;


Abraççç
Responder

Gostei + 0

28/10/2014

Pedro

Boa tarde rrubinho.

Cara obrigado pela ajuda mas ainda não testei. Abusando da sua boa vontade me passa mais alguma dica.

No caso essas linhas são indeterminadas e não apenas duas. Eu vou importar essa lista de arquivos txt e cada uma tem quantidade diferente de linhas, tem arquivo com mais de mil linhas rsrsr

No caso eu tinha pensado em uma lógica mais ou menos assim como você falou mas não sei como fazer. Eu pensei no seguinte:

Ler o primeiro número da primeira linha e procurar por ele em todas as outras linhas. Se encontrar em alguma então ele faria a leitura do prox. número e se encontrar faria o mesmo com os seguintes, até encontrar sequencias 2-2, 3-3, 4-4 etc...

Mas como tem que ler cada numero um por um em cada uma das linhas, vai virar uma laço muito grande e nem tenho ideia de como resolver.
Responder

Gostei + 0

28/10/2014

Renato Rubinho

Imaginei que fosse isso.
Por isso fiz o exemplo com as duas variáveis sLinha1 e sLinha2.

Faz um loop das linhas do seu arquivo texto.
Para cada passo do loop, armazene na sLinha1 o conteúdo da linha posicionada.
Dentro deste loop principal, faça um segundo loop das linhas dos arquivos e, para cada passo deste segundo loop, armazene o conteúdo da linha no sLinha2.

Utilize o código que passei dentro do segundo loop após preencher a sLinha2 que ele irá processar para cada linha a validação das demais linhas. Ou crie uma função com o código que passei e chame-a passando as linhas a serem verificadas.

Obs: Não se esqueça de ignorar a validação no segundo loop para a linha que estiver posicionado no primeiro.

Posta o resultado para ficar como dica para outras pessoas que precisarem.

Abraççç,
Renato
Responder

Gostei + 0

28/10/2014

Pedro

Então Renato, para testar o código eu apenas copiei e colei e não fiz nenhuma adaptação ao que eu preciso.

Na forma como você exemplificou, fazendo a comparação entre as duas linhas ele encontra 4,5 - 25,27. Certinho encontrou a ocorrência. Aí para testar mais a fundo eu alterei o valor da variável sLinha2 e ficou assim:

sLinha1 := '3,4,5,8,10,11,23,25,27,31,37,43,44,45,49,';
sLinha2 := '1,2,4,5,6,9,12,13,17,19,25,27,44,45,49,';

Então dentro daquilo que preciso eu deveria receber o retorno: 4,5 - 25,27 - 44,45,49. Porém retornou dessa forma 4,5 - 25,27 - 44,45 - 45,49, ou seja, uma sequencia de dois em dois. O resultado em questão teria que vir 4,5 - 25,27 - 44,45,49 assim como tambem poderia ser um resultado 1,1 - 2,2,2 - 3,3,3,3 ou 1,1,1 - 2,2,2,2,2. Não necessariamente de dois em dois números.

Por exemplo cada linha vai ter uns 15 números, se tiver duas linhas exatamente iguais então ele vai retornar a sequencia 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15.
Responder

Gostei + 0

29/10/2014

Renato Rubinho

Nas outras explicações você havia colocado exemplo de 2 apenas.
To enrolado agora, mas ao invés do último if, troquei por while e repliquei o incremento de posição das linhas para validar em sequência quantos existirem.
Ficou grosseiro, mas aparentemente funcionou.
Veja se é isso e caso o resultado esteja correto, veja de talvez fazer uma função recursiva que deve ter um resultado melhor.

procedure TFrmatendepedido.Button1Click(Sender: TObject);
var
  iPosVirg1: integer;
  iPosVirg2: integer;
  jPosVirg1: integer;
  jPosVirg2: integer;
  sLinha1  : string;
  sLinha2  : string;
  sResult  : string;
  sResult2 : string;
  sNum1    : string;
  sNum2    : string;
  sNum3    : string;
  sNum4    : string;
  bAux1    : boolean;
begin
  sLinha1 := ',3,4,5,8,10,11,23,25,27,31,37,43,44,45,49,54,54,54,';
  sLinha2 := ',1,2,4,5,6,9,12,13,17,19,25,27,30,31,40,54,54,54,';

  sResult := '';
 
  iPosVirg1 := 1;
  iPosVirg2 := Length(sLinha1);
 
  while iPosVirg2 > iPosVirg1 do
  begin
    // Encontra o número a ser verificado
    iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
    sNum1     := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

    // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
    iPosVirg1 := iPosVirg2;
    iPosVirg2 := Length(sLinha1);

    jPosVirg1 := 1;
    jPosVirg2 := Length(sLinha2);

    while jPosVirg2 > jPosVirg1 do
    begin
      jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
      sNum2     := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

      // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
      jPosVirg1 := jPosVirg2;
      jPosVirg2 := Length(sLinha2);

      // Se os números são iguais, valida o próximo
      sResult2 := sNum1;
      bAux1    := False;
      while sNum1 = sNum2 do
      begin
        sNum3 := Trim(Copy(sLinha1,iPosVirg1 + 1,(iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1))))-iPosVirg1-1));
        sNum4 := Trim(Copy(sLinha2,jPosVirg1 + 1,(jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2))))-jPosVirg1-1));

        if ( sNum3 = sNum4 ) and ( Trim(sNum3) <> '' ) and ( Trim(sNum4) <> '' ) then
        begin
          sResult2 := sResult2 + ',' + sNum3;
          bAux1    := True;

          // Encontra o número a ser verificado
          iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
          sNum1     := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

          // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
          iPosVirg1 := iPosVirg2;
          iPosVirg2 := Length(sLinha1);

          jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
          sNum2     := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

          // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
          jPosVirg1 := jPosVirg2;
          jPosVirg2 := Length(sLinha2);
        end
        else
          sNum2 := '';
      end;

      if bAux1 then
        sResult := sResult + sResult2 + ' ';
    end;
  end;

  ShowMessage(sResult);
end;


Abraççç,
Renato
Responder

Gostei + 0

30/10/2014

Pedro

Renato, era isso mesmo. Funcionou Blz!

Muito obrigado mesmo.

Agora vou adaptar ao meu projeto, qualquer dúvida eu posto aqui e mais uma vez muito obrigado mesmo.
Responder

Gostei + 0

31/10/2014

Pedro

Tentei adaptar o código mas não esta dando nenhum resultado, ou seja, eu clico no botão e não acontece nada.

veja:


procedure TForm1.Button2Click(Sender: TObject);
var
iPosVirg1: integer;
iPosVirg2: integer;
jPosVirg1: integer;
jPosVirg2: integer;
sLinha1 : string;
sLinha2 : string;
sResult : string;
sResult2 : string;
sNum1 : string;
sNum2 : string;
sNum3 : string;
sNum4 : string;
bAux1 : boolean;
arq : TextFile;
linha : string;
i : Integer;

begin
i := 1;

AssignFile(arq, 'C:\teste\teste.txt');
Reset(arq);

while not eof(arq) do
begin
readln(arq, linha);
sLinha1 := linha;
i := i + 1;

while not eof(arq) do
begin
readln(arq, linha[i]);
sLinha2 := linha;

sResult := '';

iPosVirg1 := 1;
iPosVirg2 := Length(sLinha1);

while iPosVirg2 > iPosVirg1 do
begin
// Encontra o número a ser verificado
iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
sNum1 := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

// Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
iPosVirg1 := iPosVirg2;
iPosVirg2 := Length(sLinha1);

jPosVirg1 := 1;
jPosVirg2 := Length(sLinha2);

while jPosVirg2 > jPosVirg1 do
begin
jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
sNum2 := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

// Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
jPosVirg1 := jPosVirg2;
jPosVirg2 := Length(sLinha2);

// Se os números são iguais, valida o próximo
sResult2 := sNum1;
bAux1 := False;
while sNum1 = sNum2 do
begin
sNum3 := Trim(Copy(sLinha1,iPosVirg1 + 1,(iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1))))-iPosVirg1-1));
sNum4 := Trim(Copy(sLinha2,jPosVirg1 + 1,(jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2))))-jPosVirg1-1));

if ( sNum3 = sNum4 ) and ( Trim(sNum3) <> '' ) and ( Trim(sNum4) <> '' ) then
begin
sResult2 := sResult2 + ',' + sNum3;
bAux1 := True;

// Encontra o número a ser verificado
iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
sNum1 := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

// Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
iPosVirg1 := iPosVirg2;
iPosVirg2 := Length(sLinha1);

jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
sNum2 := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

// Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
jPosVirg1 := jPosVirg2;
jPosVirg2 := Length(sLinha2);
end
else
sNum2 := '';
end;

if bAux1 then
sResult := sResult + sResult2 + ' ';
end;
end;
end;
end;
ShowMessage(sResult);
CloseFile(arq);
end;
Responder

Gostei + 0

03/11/2014

Renato Rubinho

Buenas,

1. Você usava a mesma variável de arquivo para os dois loops, controlando o segundo loop com a variável "i", mas não zerava ela num novo passo do primeiro loop. Alterei para uma variável por loop.
2. Zerava o sResult dentro do loop apagando algo que tivesse sido preenchido em loops anteriores. Zerei o sResult fora do primeiro loop.
3. Coloquei #13 após o resultado gravado para separar os grupos encontrados.

Falta colocar tratamento para ignorar a própria linha do primeiro loop no segundo.

procedure TFrmPrincipal.Button1Click(Sender: TObject);
var
iPosVirg1: integer;
iPosVirg2: integer;
jPosVirg1: integer;
jPosVirg2: integer;
sLinha1 : string;
sLinha2 : string;
sResult : string;
sResult2 : string;
sNum1 : string;
sNum2 : string;
sNum3 : string;
sNum4 : string;
bAux1 : boolean;
arq : TextFile;
arq2 : TextFile;
linha : string;

begin
  AssignFile(arq, 'C:\temp\teste.txt');
  Reset(arq);
  AssignFile(arq2, 'C:\temp\teste.txt');

  sResult := '';

  while not eof(arq) do
  begin
    readln(arq, linha);
    sLinha1 := linha;
    Reset(arq2);

    while not eof(arq2) do
    begin
      readln(arq2, linha);
      sLinha2 := linha;

      iPosVirg1 := 1;
      iPosVirg2 := Length(sLinha1);

      while iPosVirg2 > iPosVirg1 do
      begin
        // Encontra o número a ser verificado
        iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
        sNum1 := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

        // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
        iPosVirg1 := iPosVirg2;
        iPosVirg2 := Length(sLinha1);

        jPosVirg1 := 1;
        jPosVirg2 := Length(sLinha2);

        while jPosVirg2 > jPosVirg1 do
        begin
          jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
          sNum2 := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

          // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
          jPosVirg1 := jPosVirg2;
          jPosVirg2 := Length(sLinha2);

          // Se os números são iguais, valida o próximo
          sResult2 := sNum1;
          bAux1 := False;
          while sNum1 = sNum2 do
          begin
            sNum3 := Trim(Copy(sLinha1,iPosVirg1 + 1,(iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1))))-iPosVirg1-1));
            sNum4 := Trim(Copy(sLinha2,jPosVirg1 + 1,(jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2))))-jPosVirg1-1));

            if ( sNum3 = sNum4 ) and ( Trim(sNum3) <> '' ) and ( Trim(sNum4) <> '' ) then
            begin
              sResult2 := sResult2 + ',' + sNum3;
              bAux1 := True;

              // Encontra o número a ser verificado
              iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
              sNum1 := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

              // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
              iPosVirg1 := iPosVirg2;
              iPosVirg2 := Length(sLinha1);

              jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
              sNum2 := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

              // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
              jPosVirg1 := jPosVirg2;
              jPosVirg2 := Length(sLinha2);
            end
            else
              sNum2 := '';
          end;

          if bAux1 then
            sResult := sResult + sResult2 + #13;
        end;
      end;
    end;
  end;

  CloseFile(arq);
  CloseFile(arq2);
  ShowMessage(sResult);
end;
Responder

Gostei + 0

04/11/2014

Pedro

Boa tarde Renato.

Então, copiei e colei esse código que você postou mas continua do mesmo jeito; sem acontecer nada.

No caso a variável (i) eu coloquei justamente para ignorar a linha lida no primeiro loop do segundo. Ela inicia valendo 1 e em cada passagem no primeiro loop incrementa +1 assim indica em que linha do arquivo a função readln deve começar a ler no segundo loop. Não sei se expliquei direito, mas como sou iniciante não sei como colocar isso no código.

No caso existe uma forma de fazer o readln ler a partir de uma determinada linha?
Responder

Gostei + 0

04/11/2014

Renato Rubinho

Buenas,

Não uso TextFile... rsrs.. Dá uma olhada no Help ou no Sr. Google como utilizar melhor.
Copiei o texto em um botão num projeto em branco e funcionou.
No meu exemplo salvei o arquivo em C:\Temp\teste.txt , diferente do seu que estava em c:\teste\teste.txt, deve ser isso.

Conteúdo do arquivo c:\temp\teste.txt:

,3,4,5,8,10,11,23,25,27,31,37,43,44,45,49,54,54,54,
,1,2,4,5,6,9,12,13,17,19,25,27,30,31,40,54,54,54,

Abraççç
Responder

Gostei + 0

04/11/2014

Pedro

Então Renato,

Acho que estou estou quase lá com a sua ajuda. Fiz alguns testes...

No caso precisei criar outra variável linha 2 então mudei o seguinte:

while not eof(arq2) do
begin
readln(arq2, linha);
sLinha2 := linha;

para

while not eof(arq2) do
begin
readln(arq2, linha2);
sLinha2 := linha2;

Tentei de tudo e não consegui trabalhar apenas com a leitura do TXT então fiz uma "gambiarra", carreguei o mesmo em dois memos.

Aí fiz o laço para ler o primeiro e depois ler o segundo excluindo a linha posicionada no primeiro laço e demais linhas já lidas no primeiro laço. Ficou assim:


x := 0;
sResult := '';

for I := 0 to Memo1.Lines.Count do
begin
sLinha1 := Memo1.Lines[i];
x := x + 1;

for y := x to Memo2.Lines.Count do
begin
sLinha2 := Memo2.Lines[y];

Dessa forma ele retorna, mas tem um detalhe: se eu retirar a vírgula do início e fim de cada linha, não acontece nada quando clico no botão. Mas se mantenho a vírgula retorna as sequencias.

O engraçado é que tanto no primeiro exemplo que você me passou quanto neste último, ao invés de ler o arquivo eu usei as duas variáveis sLinha1 e sLinha2 já com os valores definidos, igualzinho o primeiro exemplo e tanto com a vírgula no início e fim quanto sem elas ele retorna a sequencia. Agora se a sequencia vem do laço, lendo o TXT se tirar as vírgulas(início e fim) não funciona.

Por que será? E qual seria a importância de ter as vírgulas no início e fim? Penso porque o os arquivos txt não vão ter elas.
Responder

Gostei + 0

04/11/2014

Pedro

Esqueci... esse é o meu arquivo texte.txt

,3,4,5,8,10,11,23,25,27,31,37,43,44,45,49,51,55,57,
,1,2,4,5,6,9,12,13,17,19,25,27,31,37,43,44,55,57,
,5,9,10,11,12,13,15,16,17,19,25,27,31,37,43,44,48,60,
Responder

Gostei + 0

07/03/2015

Pedro

rrubinho blz?

Sua ajuda resolveu meu problema. Agora me dá outro dica de como faço para procurar apenas números repetidos.
Responder

Gostei + 0

09/03/2015

Renato Rubinho

Pedro,

Mal lembrava da dessa lógica.
Segue um ajuste trazendo apenas os repetidos e ignorando a validação da própria linha.

procedure TForm1.Button1Click(Sender: TObject);
var
iPosVirg1: integer;
iPosVirg2: integer;
jPosVirg1: integer;
jPosVirg2: integer;
iLinha1 : integer;
iLinha2 : integer;
sLinha1 : string;
sLinha2 : string;
sResult : string;
sResult2 : string;
sNum1 : string;
sNum2 : string;
sNum3 : string;
sNum4 : string;
bAux1 : boolean;
arq : TextFile;
arq2 : TextFile;
linha : string;

begin
  AssignFile(arq, 'C:\temp\teste.txt');
  Reset(arq);
  AssignFile(arq2, 'C:\temp\teste.txt');

  sResult := '';
  // Novo - 09/03/2015
  iLinha1 := -1;
  // #

  while not eof(arq) do
  begin
    Inc(iLinha1);
    readln(arq, linha);
    sLinha1 := linha;
    Reset(arq2);
    // Novo - 09/03/2015
    iLinha2 := -1;
    // #

    while not eof(arq2) do
    begin
      Inc(iLinha2);

      readln(arq2, linha);
      sLinha2 := linha;

      // Novo - 09/03/2015
      if iLinha1 = iLinha2 then
      begin
        Next;
        Continue;
      end;
      // #

      iPosVirg1 := 1;
      iPosVirg2 := Length(sLinha1);

      while iPosVirg2 > iPosVirg1 do
      begin
        // Encontra o número a ser verificado
        iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
        sNum1 := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

        // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
        iPosVirg1 := iPosVirg2;
        iPosVirg2 := Length(sLinha1);
 
        jPosVirg1 := 1;
        jPosVirg2 := Length(sLinha2);
 
        while jPosVirg2 > jPosVirg1 do
        begin
          jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
          sNum2 := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

          // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
          jPosVirg1 := jPosVirg2;
          jPosVirg2 := Length(sLinha2);

          // Novo - 09/03/2015
          if sNum1 = sNum2 then
            sResult := sResult + sNum2 + #13;
          // #

          { Antigo - 09/03/2015
          // Se os números são iguais, valida o próximo
          sResult2 := sNum1;
          bAux1 := False;

          while sNum1 = sNum2 do
          begin
            sNum3 := Trim(Copy(sLinha1,iPosVirg1 + 1,(iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1))))-iPosVirg1-1));
            sNum4 := Trim(Copy(sLinha2,jPosVirg1 + 1,(jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2))))-jPosVirg1-1));

            if ( sNum3 = sNum4 ) and ( Trim(sNum3) <> '' ) and ( Trim(sNum4) <> '' ) then
            begin
              sResult2 := sResult2 + ',' + sNum3;
              bAux1 := True;

              // Encontra o número a ser verificado
              iPosVirg2 := iPosVirg1 + Pos(',',Copy(sLinha1,iPosVirg1+1,Length(sLinha1)));
              sNum1 := Trim(Copy(sLinha1,iPosVirg1 + 1,iPosVirg2-iPosVirg1-1));

              // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
              iPosVirg1 := iPosVirg2;
              iPosVirg2 := Length(sLinha1);

              jPosVirg2 := jPosVirg1 + Pos(',',Copy(sLinha2,jPosVirg1+1,Length(sLinha2)));
              sNum2 := Trim(Copy(sLinha2,jPosVirg1 + 1,jPosVirg2-jPosVirg1-1));

              // Após identificar, atualiza a posição da vírgula atual com a última vírgula encontrada
              jPosVirg1 := jPosVirg2;
              jPosVirg2 := Length(sLinha2);
            end
            else
              sNum2 := '';
          end;

          if bAux1 then
            sResult := sResult + sResult2 + #13;
          }
        end;
      end;
    end;
  end;
 
  CloseFile(arq);
  CloseFile(arq2);
  ShowMessage(sResult);
end;
Responder

Gostei + 0

11/03/2015

Pedro

rrubinho,

Mas uma vez obrigado pela sua boa vontade em me ajudar. Vou testar o código e posto o resultado, mas acho que pelo o que vc falou que fez vai dar certo, vou adaptar ao que tenho e ver o acontece.

Na lógica anterior que vc me ajudou eu estava pegando um arquivo com várias linhas e comparando todas elas, agora to querendo fazer é o seguinte:

Pegar dois arquivos com várias linhas(cominações numéricas), e compara-los; a primeira linha do primeiro arquivo como todas do segundo, depois a segunda linha do primeiro com todas do segundo etc. Conforme ele termina de comparar uma linha do primeiro ele vai montando uma nova linha com os números que ele venha a encontrar e assim gerar um terceiro arquivo com várias linhas.
Responder

Gostei + 0

Mais tópicos

Utilizamos cookies para fornecer uma melhor experiência para nossos usuários, consulte nossa política de privacidade.

Aceitar