Escrevi esse script em meu primeiro período na faculdade, com o objetivo de melhorar minha lógica. Acredito que só tenha utilidade acadêmica. O script recebe 10 números e o salvo em um vetor, ele o organiza utilizando somente o vetor de 10 posições não usando variáveis para contagem ou para auxiliar a troca de posição.

• Download ordena.pas
• Enviar nova versão

Esconder código-fonte

program orde;
{
 Feito por Edmar Wantuil Silva Júnior
 Em 2009
 Programa recebe 10 números e coloca em ordem crescente, sem usar variáveis para contagem ou auxilio
 Lembrando que assim esse algoritmo poupa o uso da memória ram, mas infelizmente faz maior uso do processador,
 ou seja esse algoritmo é melhor executado em redes por poupar algumas transferências desnecessárias, já para execução
 local o melhor que consegui foi usar apenas duas variáveis para contagem.
 Existe alguns BUGS como o de números negativos que fica ao contrario, mas esse algoritmo é apenas para
 testar a possibilidade de colocar um vetor em ordem seja ela crescente ou decrescente, mudando de uma
 para outra apenas mudando de < para > ou virse-versa no if do segundo while, usando somente o vetor que
 recebera os números sem aumentar o numero de posições ou usar variáveis para auxilio.}
uses crt;
var
  {Um único vetor de 10 posições}
  num: array[1..10] of integer;
    begin
        num[10]:= num[10] + 1;
        {Recebe numero no vetor ate a posição 9, com contagem na posição 10}
        while 10 > num[10] do
            begin
                write('Entre com o numero do indice ', num[10],': ');
                readln(num[(num[10])]);
                {Multiplica o numero por 100 para ganhar duas casas decimais}
                num[num[10]]:= num[num[10]] * 100;
                num[10]:= num[10] + 1;
           end;
        {Recebe o numero na posição 10}
        write('Entre com o numero do indice 10: ');
        readln(num[10]);
        num[10]:= num[10] * 100;
        {
       Começa a contagem usando a primeira e a ultima posição para contagem 1 e 10,
       elas são mais indicadas para isso devido a suas distancias evitando possíveis BUGS
       causados pelo colisão dos contadores
      }
        num[ 1]:= num[ 1] + 1;
        num[10]:= num[10] + 1;
        {Tira o MOD de 100 da posição 10 pra deixar apenas a contagem}
      while 11 > (num[10] mod 100) do
            begin
                while 10 > (num[ 1] mod 100) do
                    {Roda o algoritimo 9 vezes * 10 vezes da contagem anterior roda 90 vezes}
            begin
                        if (num[(num[ 1] mod 100)]) > (num[(num[ 1] mod 100) + 1]) then
                            begin
                           {Nesse momento o numero muda de posição 'se verdade' sem usar variável auxiliar baseado em
                    X:= X + Y
                    Y:= X - Y
                    X:= X - Y}
                   {Soma as duas posições salvado o resultado no primeiro}
                   num[(num[ 1] mod 100)    ]:=   num[num[ 1] mod 100] + num[(num[ 1] mod 100) + 1];
                            {Esse 'se' preserva o contador salvo na ultima posição, tirando o DIV DE 100,
                     para trabalhar apenas com o valor de entrada do usuário, posteriormente multiplica
                     100 e soma o contador se a contagem estiver em 9}
                    if 9 = (num[ 1] mod 100) then
                        num[(num[ 1] mod 100) + 1]:=  ((((num[num[ 1] mod 100]) div 100) - ((num[(num[ 1] mod 100) + 1]) div 100)) * 100) + ((num[(num[ 1] mod 100) + 1]) mod 100)
                                else
                        num[(num[ 1] mod 100) + 1]:=  ((((num[num[ 1] mod 100]) div 100) - ((num[(num[ 1] mod 100) + 1]) div 100)) * 100);
                    {Esse 'se' faz o mesmo que o ultimo mas salva a contagem salva na primeira
                     posição se a contagem e estiver em 1}
                    if 1 = (num[ 1] mod 100) then
                        num[(num[ 1] mod 100)    ]:=  ((((num[num[ 1] mod 100]) div 100) - ((num[(num[ 1] mod 100) + 1]) div 100)) * 100) + (num[(num [ 1] mod 100)] mod 100)
                    else
                        num[(num[ 1] mod 100)    ]:=  ((((num[num[ 1] mod 100]) div 100) - ((num[(num[ 1] mod 100) + 1]) div 100)) * 100);
                            end;
                     num[ 1]:= num[ 1] + 1;
                    end;
                 num[ 1]:= num[ 1] - 9;  
                 num[10]:= num[10] + 1;  
            end;
        num[10]:= num[10] - 10;
      {Volta os números originais e os exibe na tela, menos o numero salvo na ultima posição,
       pois esse será usado para contagem}
      while 10 > (num[10]  mod 100) do
          begin
              num[(num[10] mod 100)]:= num[(num[10] mod 100)] div 100;
              write(num[(num[10] mod 100)],' ');
              num[10]:= num[10] + 1;
        end;
      {Volta ao original e exige o numero do indice 10}
      num[10]:= num[10] div 100;
      write(num[10]);    
        readkey;
    end.

Árvore binária

Controle de video locadoras

Estrutura de dados - lista

Metodo main ABP

Joguinho Tetris

Nenhum comentário foi encontrado.