Program czytający ciąg znaków i informujący, czy jego długość jest liczbą parzystą czy nieparzystą. program parzysta_nieparzysta; {nagłówek, obowiązkowy - "program" oznacza program główny ale} {może być też "unit" jako moduł programu (np: CRT)}

uses crt; {uzywa biblioteki crt (potrzebna do podstawowych operacji)}

var t:string; {deklaracja zmiennych}

begin {początek programu} writeln('Podaj dowolny ciąg znaków i nacisnij ENTER.'); {wyświetlenie napisu na ekranie} readln(t); {pobranie łańcucha} if length(t) mod 2 = 0 then {Sprawdzenie podzielności długości łańcucha przez 2} writeln('Długość jest liczbą parzystą.') {jeśli podzielna} else writeln('Długość jest liczba nieparzystą.'); {w innym przypadku} readln; {pobranie danych, w tym przypadku zapobiega natychmiastowemu zamknięcia się okienka} end. {koniec programu}

Program ruszający gwiazdką na ekranie za pomocą kursorów. Pomysł oparty na kodzie z KŚE 7-8/06. program ruch; uses Crt; var x,y : Integer; kierunek : Char; begin ClrScr; x:=10; y:=10; repeat ClrScr; TextColor(WHITE); GotoXY(X,Y); Write('*'); kierunek:=ReadKey; if kierunek=#0 then begin kierunek:=ReadKey; GotoXY(x,y); Write('*');

if (kierunek=#75) AND (x>1) then x:=x-1; if (kierunek=#77) AND (x1) then y:=y-1; if (kierunek=#80) AND (y<25) then y:=y+1; end;

until kierunek=#27; end.

Program wyszukujący dla dwóch podanych liczb największy wspólny dzielnik. uses crt; var a,b,n:byte; begin clrscr; write('Podaj pierwsza liczbe '); readln(a); write('Podaj druga liczbe '); readln(b); n:=a; while (a mod n<>0) or (b mod n<>0) do n:=n-1; writeln('Najwiekszy wspolny dzielnik liczb ',a,' i ',b,' to ',n:0); readln; end. Program wyszukujący dla dwóch podanych liczb najmniejszą wspólną wielokrotność. uses crt; var a,b,n,x:word; begin clrscr; write('Podaj pierwsza liczbe '); readln(a); write('Podaj druga liczbe '); readln(b); n:=a; while (n mod a<>0) or (n mod b<>0) do n:=n+1; writeln('Najmniejsza wspolna wielokrotnosc liczb ',a,' i ',b,' to ',n:0); readln; end.

Program obliczający silnię podanej liczby. uses crt; var a:byte; function silnia(n:byte):longint; begin if n=0 then silnia:=1 else silnia:=silnia(n-1)*n; end; begin clrscr; write('Podaj liczbe: '); readln(a); silnia(a); write('Silnia tej liczby to ',silnia(a)); readln; end.

Moduł do obsługi grafiki : rysowanie, skalowanie grafiki {$A+,B-,D+,E+,F-,I+,L+,N-,O-,R+,S+,V+} {$M 16384,0,655360} {$N+} UNIT OknaM;

INTERFACE {**************************************************************}

Uses Dos,Crt,Graph,zespolonyM,MathM;

Type SkaliT=(Liniowe,LogRozsz,LogZwez); Type OkiennyT=Record Xmin,Xmax,Dx:real; Ymin,Ymax,Dy:real; XEmin,XEmax,Dxe:integer; YEmin,YEmax,Dye:integer; LiczbaPunktow:LongInt; case TypySkalOsi:skaliT of Liniowe : (Ax,Bx,KrokX,Ay,By,krokY:real); LogRozsz: (LrMin,LrMax,dLr,XlrMin,XlrMax,dXlr,Ayr,Byr,krokYr:real); LogZwez : (LzMin,LzMax,dLz,XlzMin,XlzMax,dXlz,Ayz,Byz,krokYz:real); end; { type okiennyT=Record } Type PixelowyT =Record Xe,Ye:integer; end; {Type ZespolonyT=Record Re,Im:real; end;} Type PunktowyT=Record Ekranu:pixelowyT; Rzeczywisty:zespolonyT; kolor:word; okno:okiennyT; End; { Type PunktowyT=record }

Procedure Kojarz(var okno:okiennyT;xMin,xMax,yMin,yMax:real;TypSkalOsiXY:skaliT; xeMin,xeMax,yeMin,yeMax:integer); Function SkalaXe2X(Xe:integer;okno:okiennyT):real; { xe --> x } Procedure PunktP(x,y:real;okno:okiennyT;color:word); Procedure PunktOblicz(z:zespolonyT;okno:okiennyT;var punktEkranu:pixelowyT); Procedure Pisz(x,y:real;tekst:string;okno:okiennyT); Procedure DajPunkt(NrPunktu:LongInt;Okno:okiennyT;var punkt:punktowyT); Procedure DajPunktSkosnie(NrPunktu:LongInt;Okno:okiennyT;var Punkt:punktowyT); Procedure RysujPunkt(punkt:punktowyT;kolor:word); Procedure Kolo(srodek:zespolonyT;r:real;kolor:word;okno:okiennyT);

IMPLEMENTATION {************************************************************}

Procedure Kojarz(var okno:okiennyT;xMin,xMax,yMin,yMax:real;TypSkalOsiXY:skaliT; xeMin,xeMax,yeMin,yeMax:integer);

begin okno.TypySkalOsi:=TypSkalOsiXY; okno.Xmin:=Xmin; { wspolrzedne przestrzeni } okno.Xmax:=Xmax; { funkcji } okno.Dx:=Xmax-Xmin;

okno.Ymin:=Ymin; okno.Ymax:=Ymax; okno.Dy:=Ymax-Ymin;

okno.XEmin:=XEmin; { wspolrzedne ekranu } okno.XEmax:=XEmax; okno.Dxe:=XEmax-XEmin+1;

okno.YEmin:=YEmin; okno.YEmax:=YEmax; okno.Dye:=YEmax-YEmin+1;

okno.LiczbaPunktow:=Longint(okno.Dxe)*LongInt(okno.Dye); { liczba pixeli ekranu }

case TypSkalOsiXY of

liniowe : begin okno.Ax:=(okno.Dxe)/(okno.dx); { XE=Ax*x+Bx } okno.Bx:=XEmin-(okno.Ax*Xmin); okno.KrokX:=(okno.Dx)/(okno.Dxe);

okno.Ay:=(okno.Dye)/(okno.dy); okno.By:=YEmin-(okno.Ay*Ymin); okno.KrokY:=(okno.Dy)/(okno.dye); end;

LogRozsz: begin { nieliniowa , tj. logarytmiczna skala osi x } okno.LrMin:= 0; { logarytm naturalny } okno.LrMax:=-6; okno.dLr:=okno.LrMax-okno.LrMin;

okno.XlrMin:=exp(okno.LrMin); { Xlr = exp(Lr) } okno.XlrMax:=exp(okno.LrMax); okno.dXlr:=okno.XlrMax-okno.XlrMin;

okno.Ayr:=(okno.Dye)/(okno.dy); { liniowa skala osi y } okno.Byr:=YEmin-(okno.Ayr*Ymin); okno.KrokYr:=(okno.Dy)/(okno.dye); end;

LogZwez : begin okno.LzMin:= -6; okno.LzMax:= 0; okno.dLz:=okno.LzMax-okno.LzMin;

okno.XlzMin:=exp(okno.LzMin); okno.XlzMax:=exp(okno.LzMax); okno.dXlz:=okno.XlzMax-okno.XlzMin;

okno.Ayz:=(okno.Dye)/(okno.dy); { liniowa skala osi y } okno.Byz:=YEmin-(okno.Ayz*Ymin); okno.KrokYz:=(okno.Dy)/(okno.dye); end; end; { case ... } end; { procedury kojarz }

Function SkalaX(X:real;okno:okiennyT):integer; { x --> xe } var xl,l,xe:real; begin With okno do case TypySkalOsi of liniowe : skalaX:=Round(Ax*X+Bx); LogRozsz: begin xl:=xlrMin+(x-xMin)*dXlr/dx; l:=ln(Xl); Xe:=xeMin+(l-lrmin)*dxe/dlr; skalaX:=round(xe); end; LogZwez : begin xl:=xlzMin+(x-xMin)*dXlz/dx; l:=ln(Xl); Xe:=xeMin+(l-lzmin)*dxe/dlz; skalaX:=round(xe); end ; end; end;

Function SkalaXe2X(Xe:integer;okno:okiennyT):real; { xe --> x } var l,xl:real; begin with okno do begin case TypySkalOsi of liniowe : begin SkalaXe2X:=(Xe-Bx)*KrokX; { xe --> x } end; LogRozsz: begin l:=lrMin+(xe-xemin)*dlr/dxe; xl:=exp(l); skalaXe2X:=xmin+(xl-xlrmin)*dx/dxlr; end; LogZwez : begin l:=lzMin+(xe-xemin)*dlz/dxe; xl:=exp(l); skalaXe2X:=xmin+(xl-xlzmin)*dx/dxlz; end; end; { case } end; { with okno } end;

Function InwersjaYE(YE:integer;okno:okiennyT):integer; begin With okno do begin if YE>(Dye/2) then InwersjaYe:=YEmin+(YEmax-YE) else InwersjaYE:=YEmax-(YE-YEmin); end; end;

Function SkalaY(Y:real;okno:okiennyT):integer; { y --> ye }

var Skala:integer;

begin { cialo funkcji skalaY } with okno do case TypySkalOsi of liniowe : begin Skala:=Round(Ay*Y+By); SkalaY:=InwersjaYE(Skala,okno); end;

LogRozsz: begin Skala:=Round(Ayr*Y+Byr); SkalaY:=InwersjaYE(Skala,okno); end;

LogZwez : begin Skala:=Round(Ayz*Y+Byz); SkalaY:=InwersjaYE(Skala,okno); end; end; { case } end; { cialo funkcji skalaY }

Function SkalaYe2Y(Ye:integer;okno:okiennyT):real; { Ye --> Y } begin with okno do begin case TypySkalOsi of liniowe : SkalaYe2Y:=(Ye-By)*KrokY; { ye --> y }

LogRozsz: SkalaYe2Y:=(Ye-Byr)*KrokYr; { ye --> y }

LogZwez : SkalaYe2Y:=(Ye-Byz)*KrokYz; { ye --> y }

end; { case } end; { with okno } end;

Procedure PunktP(x,y:real;okno:okiennyT;color:word);

var XE,YE:integer;

begin with okno do begin XE:=SkalaX(X,okno); { X |--> Xekranu } YE:=SkalaY(Y,okno); { Y |--> Yekranu } PutPixel(XE,YE,color); end; end;

Procedure PunktOblicz(z:zespolonyT;okno:okiennyT;var punktEkranu:pixelowyT);

begin with okno do begin punktEkranu.XE:=SkalaX(z.re,okno); { X |--> Xekranu } punktEkranu.YE:=SkalaY(z.im,okno); { Y |--> Yekranu }

end; end;

Procedure Pisz(x,y:real;tekst:string;okno:okiennyT); var xe,ye:integer; begin xe:=SkalaX(x,okno); ye:=SkalaY(y,okno); OutTextXY(xe,ye,tekst); end;

Procedure DajPunkt(NrPunktu:LongInt;Okno:okiennyT;var Punkt:punktowyT); var l,xl:real; begin With okno do begin Punkt.Ekranu.Xe:=XeMin+integer(NrPunktu mod Dxe); Punkt.Ekranu.Ye:=YeMin+integer(NrPunktu div Dxe); Punkt.Okno:=Okno; case okno.TypySkalOsi of liniowe : begin Punkt.Rzeczywisty.Re:=(Punkt.Ekranu.Xe-Bx)*KrokX; { xe --> x } Punkt.Rzeczywisty.Im:=(Punkt.Ekranu.Ye-By)*KrokY; { ye --> y } end; LogRozsz: begin l:=lrMin+(punkt.ekranu.xe-xemin)*dlr/dxe; xl:=exp(l); punkt.rzeczywisty.re:=xmin+(xl-xlrmin)*dx/dxlr; Punkt.Rzeczywisty.Im:=(Punkt.Ekranu.Ye-Byr)*KrokYr; { ye --> y } ; end; LogZwez : begin l:=lzMin+(punkt.ekranu.xe-xemin)*dlz/dxe; xl:=exp(l); punkt.rzeczywisty.re:=xmin+(xl-xlzmin)*dx/dxlz; Punkt.Rzeczywisty.Im:=(Punkt.Ekranu.Ye-Byz)*KrokYz; { ye --> y } ; end; end; { case } end; { with okno } end; { Procedure DajPunkt }

Procedure DajPunktSkosnie(NrPunktu:LongInt;Okno:okiennyT;var Punkt:punktowyT); begin With okno do begin {if CzyWzglPierw(dxe,dye) then begin } Punkt.Ekranu.Xe:=XeMin+integer(NrPunktu mod Dxe); Punkt.Ekranu.Ye:=YeMin+integer(NrPunktu mod 3); Punkt.Okno:=Okno; case okno.TypySkalOsi of liniowe : begin Punkt.Rzeczywisty.Re:=(Punkt.Ekranu.Xe-Bx)*KrokX; Punkt.Rzeczywisty.Im:=(Punkt.Ekranu.Ye-By)*KrokY; end; LogRozsz: ; LogZwez : ; end; { case } { end { if CzyWzglPierw then} {else DajPunkt(NrPunktu,Okno,Punkt); }

end; { with okno } end; { Procedure DajPunktSkosnie }

Procedure RysujPunkt(Punkt:PunktowyT;kolor:word); var Ye:integer; begin Ye:=InwersjaYe(Punkt.ekranu.Ye,Punkt.okno); PutPixel(Punkt.ekranu.Xe,Ye,kolor); end;

Procedure Kolo(srodek:zespolonyT; r:real; kolor:word; okno:okiennyT); var xe,ye:integer; promien:word; begin xe:=SkalaX(srodek.re,okno); ye:=SkalaY(srodek.im,okno); Promien:=round(r*okno.Ay); SetColor(kolor); SetFillStyle(SolidFill,kolor); FillEllipse(xe,ye,promien,promien);

end;

END. { modulu OknaM } {****************************************************}

program rysuje diagram bifurkacyjny

program rysuje diagram bifurkacyjny funkcji PROGRAM diag321;

{ program rysuje diagram bifurkacyjny y[n+1]=y[n]*y[n]+x, { x: -2.0< x <-1.41 } { y: -2.0< y <2.0 } { nieliniowe , zmienne w 3 oknach skalowanie osi x } { rysuje tez punkty stale nieprzyciagajace !!!!! }

USES {moduly standardowe} Crt,Graph, {moje moduly} GrafM, OknaM, fractalnyM, BmpM;

VAR Okno1,okno2,okno3:OkiennyT; Bok:integer;

BEGIN Opengraf; Bok:=Round(GetMaxx/7);

Kojarz(okno3,-0.200,0.25,-2,2,logRozsz,(6*bok)+2,(7*bok),0,GetMaxY); Diagram(okno3,50,10); {unit FractalnyM}

Kojarz(okno2,-1.401,-0.200,-2,2,logZwez,(3*bok)+1,(6*bok)+1,0,GetMaxY); Diagram(okno2,100,20);

Kojarz(okno1,-2.000,-1.401,-2,2,logRozsz,0,3*bok,0,getMaxY); Diagram(okno1,100,200);

ScreenCopy('b',640,480); Repeat until KeyPressed; CloseGraph;

END.

Zbiory Julia

Zbiory Julia podobne do grafik Eschera

Program Esher_Julia;

{možesz zmieniac: c_re_int, c_im_int skala } { mozna zmieniac skale dla x i y niezaleznie}

{ ekran : E= (XeMin;XeMax)x(YeMinx(YeMax) plaszczyzna z = (xMin:xMax)x(yMin;yMax) skalowanie liniowe pˆaszczyzny Z na ekran dla kazdego punktu plaszczyzny z=x+y*i obliczmy ciag Nmax punktow Zn: Z0=x+y*i; Z(n+1) = (Zn*Zn) + c w zaležnosci od spelnienia warunku okreslamy kolor punktu z efektem jest zbior Julii dla funkcji z*z+c} uses crt,graph, {moje modul} grafM, KolorM, bmpM;

var color:longInt; Xe, {xEkranu,yEkranu = wspolrzedne pixeli} Ye, dXe,dYe:integer; {szerokosc i wysokosc ekranu} KrokX,KrokY:extended; y,x, { z=x+y*i } tx,ty, xTemp :extended; { Z(n+1)=Zn*Zn+c ; c(Cx,Cy) } n,tn:LongInt; { numer kolejnej iteracji= punktu ciagu Zn }

const {c=0+0*i; circle } C_re=-0.0; {wspolczynnik funkcji F(z)=(z*z)+c } C_im=0.0; { c jest liczba zespolona : c=c_re+c_im*i } {target set C_int } C_re_int=-1.1; {wspolczynnik funkcji F(z)=(z*z)+c_int } C_im_int=-0.001; { c jest liczba zespolona : c_int=c_re_int+c_im_int*i }

skala=250.10; {standard 15 ; sproboj: -2.0; 1.0 ; 1000.0; }

xMin=-1.0; xMax=1.0; dx=xMax-xMin;