Kolos PPK

{Autor: Dawid Mocek}

Kolos PPK

1)
Przeczytać na wikipedii ;-)
{ czyli w skrocie:
 nie.jest to spowodowane tym że komputer posługuje ssystem binarnym 0 i 1 wiec nie jest w stanie dokladnie okreslić liczby typu real. Liczba R1 moze np wynosc 1.3000000 natomiast R2 moze wynosic 1.299999   lub 1.30000001 a one nie są sobie równe
}
2) procedure wypelnj(var: tablica)
var
    i :integer;
    idx : integer;
begin
     idx := 0;
     for i:=2 to N do begin
       if i mod 2 = 0 then begin
         tablica[idx] := i;
         idx := idx + 1;
       end;

     end;
end;

3)
var
  i:integer;

begin


      readln(i);
repeat
     writeln(i);
      i:= i+1;
until(i > 10) ;
readln;
end.

{ Poprawione: musi zostac dodany warunek if przed petla poniewaz reapet until wykoona petle conajmniej raz }

4)
type
  tPoryRoku = (Wiosna, Lato, Jesien, Zima );

5)
for i:=0 to 100 do begin
    writeln(i);
  end;
{ poprawione:
http://borlandpascal.wikia.com/wiki/Script:Is_prime
}
6)
var  tablica:array[-5..131] of integer;

7)
type
  ptrtablica = ^real;
var
    tablica: ptrtablica;
    rozmiar: integer;
begin
      rozmiar :=10;

      getmem(tablica, sizeof(real) * rozmiar);
      freemem(tablica, sizeof(real) *rozmiar);
      tablica := nil;

      readln;
end.

LUB

var
    tablica: array of real;
    rozmiar: integer;
begin
{
http://wiki.freepascal.org/Dynamic_array
Assigning nil to a dynamic array variable automatically frees the memory where the pointer pointed to. It's identical to SetLength(MyVariable, 0).

}
      rozmiar :=10;
      SetLength(tablica, rozmiar);
      tablica:=nil;

end.

8)
type
  osoba =record
    Imie: string[15];
    Nazwisko: string[25];

  end;

var
    zm: osoba;
    plik: file;
begin
     zm:= InicjalizujZm();

      assign(plik, 'plik.a');
      reset(plik, 1);
      write(plik, zm);
      close(plik);

end.
{ Poprawione
    zm:= InicjalizujZm();

     // to nie jest istotnie wazne jaka rozszerzenie ma plik binarny
      assign(plik, 'D:\plik.a');
      reset(plik, 1);
      BlockWrite(plik, zm.Nazwisko, sizeof(osoba.Nazwisko));
      BlockWrite(plik, zm.Imie, sizeof(osoba.Imie));
      close(plik);

      readln;
}
9)
var
  a:real;
  b:^real;


########################## LISTA ########################################
{
 Author: Dawid Mocek
}

type
  PElem = ^TElem;
  TElem = record
    d: integer;
    next: PElem;
  end;

{Sprawdza czy element nalezy  do zbioru}
function sprawdz(Z:PElem; V:integer ): Boolean;
var
 wynik : boolean;
begin
     wynik := false;
   while Z <> nil do begin
     if V = Z^.d then begin
     wynik := true;
     end;
    Z := Z^.next;
  end;

sprawdz := wynik;

end;

{
wstawienie elementu do zbioru - ten var tu jest POTRZEBNY - jak mam zmieniać cos
w liscie jak nie dostaje jej adresu tylko beznadziejną kopie(no chyba że to globalna zmienna a nie stworzona na heap`ie) ?
}
procedure wstaw(var Z:PElem; V:Integer);
var
 nowy : PElem;
begin
     // Szukamy elementu V w zbiorze - jesli nie znalezlismy takiego samego dodajemy nowy element
     if sprawdz(Z, V) <> true  then begin
       new(nowy);
       nowy^.d := V;
       nowy^.next:= Z;
       Z := nowy;
     end;
end;


function suma(Z1:PElem;  Z2: PElem) : PElem;
var
    nowa_lista : PElem;
begin
   nowa_lista := nil;

  // iterujemy po pierwszej liscie
  while Z1 <> nil do begin
    // dodajmy do nowej
     wstaw(nowa_lista, Z1^.d);
     Z1 := Z1^.next;
  end;

  // iterujemy po drugiej liscie
  while Z2 <> nil do begin
    // dodajemy no nowej
    wstaw(nowa_lista, Z2^.d);
    Z2 := Z2^.next;
  end;

  // zwracamy nowa liste
  suma := nowa_lista;

end;

{ czyli z zbioru Z1 wypierdzielamy wszystko co jest takiego smaego w zbiorze Z2 }
function roznica(Z1, Z2: PElem): PElem;
var
    nowa_lista: PElem;
begin
  nowa_lista := nil;
  while (Z1 <> nil)  do begin
        if sprawdz(Z2, Z1^.d) = false then begin
           wstaw(nowa_lista, Z1^.d);
         end
         else begin
              while(Z2 <> nil ) and (Z2^.d <>  Z1^.d) do begin
                  wstaw(nowa_lista, Z2^.d);
                  Z2 := Z2^.next;
              end;
        end;

  Z1 := Z1^.next;
  end;

  roznica:=nowa_lista;

end;

{ Nie wiem o co chodzi w przecieciu ?
function przeciecie(Z1, Z2: PElem):PElem;
begin
end;
}

procedure zniszczliste(var Z:PElem);
var
    current : PElem;
begin
   current := Z;
    while current <> nil  do begin
    current := current^.next;
    Dispose(Z);
    Z := current;
 end;
end;

procedure drukujliste(Z:PElem);
begin
  if Z <> nil then begin
     while Z <> nil do begin
         writeln(Z^.d);
         Z := Z^.next;
      end;
   end;
end;

var
 elementy1 : PElem;
 elementy2 : PElem;
 elementy12 : PElem;
 roznica_zbiorow : PElem;
begin
     elementy1 := nil;
     elementy2 := nil;
     elementy12 := nil;
     roznica_zbiorow := nil;

     wstaw(elementy1, 100);
     wstaw(elementy1, 102);
     wstaw(elementy1, 104);


     wstaw(elementy2, 104); // to nie powinno  znajdowac w nowym zbiorze - roznicy
     wstaw(elementy2, 253);
     wstaw(elementy2, 254);

     writeln('lista 1:');
     drukujliste(elementy1);

     writeln('lista 2:');
     drukujliste(elementy2);

     elementy12 := suma(elementy1, elementy2);
     writeln('lista 1 i 2:');
     drukujliste(elementy12);

     writeln('lista 1 - lista 2:');
     roznica_zbiorow := roznica(elementy1, elementy2);
     drukujliste(roznica_zbiorow);

     zniszczliste(elementy1);
     zniszczliste(elementy2);
     zniszczliste(elementy12);
     zniszczliste(roznica_zbiorow);

readln;
end.