Zjednodužšení algoritmu – Pascal – Fórum – Programujte.com

Dobrý den,
mám tu jeden velice základní algoritmus, abych na něm ilustroval jiný problém, který teď řeším. Nejedná se ani tak o problém, protože algoritmus je funkční, ale spíše o to, že bych ho chtěl zjednodušit.
Úkol tohoto algoritmu je následující: V poli jsou uložena čísla. Já chci vlžit na konec pole další číslo, ale pouze za předpokladu, že se v poli
číslo už nevyskytuje.

{I = pomocná proměnná začínající na 1
P = [array of byte]}
while ( I < 100 ) AND ( P[I] <> 10 )  {Procházím pole až dokonce, nebo dokud nnenaleznu prvek s hodnotou 10}
do inc(I);                            {Pořád zvyšuju I, abych se dostal nakonec}
      if( P[I] <> 10 ) then begin     {Pokud je prvek různý od 10ti, znamená to, že jsem na konci pole a mohu tedy prvek přidat}
        P[I+1]:=10;
      end;

na algoritmu se mi nelíbí, že je v něm 2x podmínka ( P[I] <> 10 ). Nenapadá někoho, jak by mohl jít tento už tak velice jednoduchý algoritmus ještě zjednoduši?

#1 tomas.ch
množiny se dobře implementují pomocí bitového pole... zjištění, zda se tam prvek již nachází se dá potom zjistit v konstantním čase...

Ano...bohužel se zde jedná o ilustrativní příklad, který se ve skutečnosti týká lineárního dynemického seznamu, pouze jsem sem data prepsal do pole pro zjednodusení...opravdu hledám pouze způsob, jak zjednodusit danou podmínku...tzn, prepsat to nejak tak, aby byla podmínka jenom jedna...

Je asi tezko to vysvetlit na nejakem abstraktnim prikladu, proto dam konkretni priklad, ktery se snazim zjednodusit sem:

program prog;
type UkSeznam = ^Seznam;
      Seznam = record
        Data: string;
        Dalsi: UkSeznam;
      end;
     
  function Ukol(A: string; B: char): UkSeznam;
  var Pom, Poz: UkSeznam;
  begin
    Ukol:=nil;
    while( POS(B, A) <> 0 ) do begin
      new(Pom);
      Pom^.Data:= COPY(A, 1, POS(B, A));
      Pom^.Dalsi:= nil;   
      if ( Ukol = nil ) then begin Ukol:=Pom; end
      else begin
        Poz:= Ukol;
        while( Poz^.Dalsi <> nil ) do Poz:=Poz^.Dalsi;
        Poz^.Dalsi:=Pom;
      end;
      DELETE(A, 1, POS(B, A));        
    end;
    if not ( POS(B, A) <> 0 ) then begin
      Poz:= Ukol;
      new(Pom);
      Pom^.Data:= A;
      Pom^.Dalsi:= nil;
      while( Poz^.Dalsi <> nil ) do Poz:=Poz^.Dalsi;
      Poz^.Dalsi:=Pom;
    end;   
  end;
 
  procedure Vypis(S: UkSeznam);
  var Pom: UkSeznam;
  begin
    Pom:=S;
    while ( Pom <> nil ) do begin
      Writeln(Pom^.Data);
      Pom:=Pom^.Dalsi; 
    end;
  end;
 
var S: UkSeznam; 
begin

  Vypis(Ukol('Ahoj jak se vede', ' '));

end.

Kod je zbytecne roztahany...to ano...Ale chci se pri jeho optimalizaci zamerovat na dilci casti, tedy momentalne se snazim odstranit zdvojenou podminku ( POS(B, A) <> 0 ) Protože se mi nelíbí, že je tam dvakrát... Ještě dodám zadání dané úlohy: Napište funkci, která dostane v prvním parametru znakový řetězec a v druhém parametru jeden znak, jenž bude chápán jako oddělovač úseků zadaného řetězce. Funkce "rozseká" zadaný řetězec na části podle zadaného oddělovače a nabude hodnoty ukazatele na lineární jednosměrný seznam těchto částí. Je toto už pochopitelnější o co mi jde?

Když už ten text umazáváš, tak stačí hlídat, jestli jsi smazal všechno. A při tom přidávání si můžeš pamatovat poslední prvek a nemusíš procházet celý seznam.

function Ukol(A: String; B: Char): UkSeznam;
var
  p: integer;
  tok: string;
  prvni, posledni, pom: UkSeznam;
begin
  prvni := nil;

  while length(a) > 0 do begin
    p := pos(b, a);
    if p = 0 then p := length(a) + 1;
    tok := copy(a, 1, p - 1);
    delete(a, 1, p);

    new(pom);
    pom^.data := tok;
    pom^.dalsi := nil;

    if prvni = nil then prvni := pom
    else posledni^.dalsi := pom;
    posledni := pom;
  end;

  Ukol := prvni;
end;