Wstęp
do programowania
Wykład 3
instrukcje
Wstęp
do programowania
Wykład 3
instrukcje
Instrukcja warunkowa
if - then - else
Występuje w trzech wersjach:
jeśli
warunek
to
instrukcja1
w_przeciwnym_wypadku
instrukcja2
if
warunek
then
instrukcja1
else
i
nstrukcja2;
warunek
instrukcja1
FAŁSZ
PRAWDA
warunek
instrukcja1
False
True
instrukcja2
instrukcja2
Instrukcja warunkowa (wyboru)
if - then - else
warunek
- Wyrażenie logiczne przyjmujące wartość prawdy lub fałszu (przyjmuje
typ logiczny
BOOLEAN)
Przykłady
if a>5 then b:=a-5
if (a>0) and (a<=10) then x:=5
else
b:=a+5
else
z:=15
if (dzielnik<>0) then wynik:=dzielna/dzielnik
else writeln(' nie można dzielić przez zero !!!');
if (dzielnik<>0) then
begin
wynik:=dzielna/dzielnik;
writeln(' dzielenie wykonano');
end
else writeln(' nie można dzieli przez zero !');
Instrukcja warunkowa (wyboru)
program prog01;
{$APPTYPE CONSOLE}
uses SysUtils;
var liczba : byte;
//-------------------------------
begin
write('Proszę liczbę całkowitą : ');
readln(liczba);
if liczba > 100 then
writeln('Liczba jest większa niż 100')
else
writeln('Liczba jest mniejsza lub równa 100');
Readln;
Instrukcja warunkowa
if - then
jeśli
warunek
to
instrukcja
if
warunek
then
instrukcja
Np..
if
zn in [’1’..’9’]
then
writeln(’zn jest cyfrą’);
if
not x in [’1’..’9’]
then
writeln(’x nie jest cyfrą’);
if
a=b
then begin
writeln(’a i b są takie same’ );
obwod:=4*a;
end;
warunek
instrukcja
FAŁSZ
PRAWDA
warunek
instrukcja
False
True
instrukcja warunkowa daje
zazwyczaj możliwość wyboru
wariantów
program instr_if1;
{$APPTYPE CONSOLE}
Uses SysUtils;
var a,b,c,max : Single;
begin
write('Podaj a '); readln(a);
write('Podaj b '); readln(b);
write('Podaj c '); readln(c);
if a>=b then if a>=c then max:=a
else max:=c
else if b>=c then max:=b
else max:=c;
write('Mmax(a,b,c) = ',max:4:1); Readln;
end.
Program progr3;
{$APPTYPE CONSOLE}
uses SysUtils;
var
ocena: byte;
begin
write(' Podaj ocenę ');
readln(ocena);
if ocena=6 then writeln('celujący')
else if ocena=5 then writeln('bardzo dobry')
else if ocena=4 then writeln('dobry')
else if ocena=3 then writeln('dostateczny')
else if ocena=2 then writeln('mierny')
else if ocena=1 then writeln('niedostateczny')
else writeln('Błędne dane');
readln;
End.
Instrukcja wyboru
case - of
Występujące w tej instrukcji wyrażenie nazywane jest
selektorem.
Jego wartość musi być typu porządkowego.
Sekwencja instrukcji wyboru zbudowana jest z ciągu
instrukcji.
Każda z nich jest poprzedzona jedną lub kilkoma stałymi
wyboru oddzielanymi przecinkami po których występuje
dwukropek. Stałe wyboru przyjmują jedną z dwóch
postaci.
Instrukcja wyboru
case - of
case
of
wybór: ciąg instrukcji
else
wyrażenie
ciąg instrukcji
end
case
wyrażenie
of
wybór: ciąg inst
rukcji
end;
case
wyrażenie
of
wybór: ciąg inst
rukcji
else
instrukcja
end
Instrukcja wyboru case - of
program instr_case1;
{$APPTYPE CONSOLE}
uses SysUtils;
var znak : char;
begin
write('Proszę wpisać dowolny znak : ');
readln(znak);
case znak of
'0' .. '9' : writeln('wpisano cyfrę !');
'A' .. 'Z' : writeln('napisano dużą literę !');
'a' .. 'z' : writeln('napisano małą literę !');
'=' : writeln('napisano znak równości!');
'-' : writeln('napisano znak minus');
else
write('napisano inny znak ')
end;
readln
end.
Instrukcja wyboru case - of
program instr_case2;
{ program wczytuje ocenę jako cyfrę i podaje jej słowną interpretację}
{$APPTYPE CONSOLE}
uses sysUtils;
var ocena:byte;
begin
write(' Podaj ocene ');
readln(ocena);
case ocena of
6: writeln('celujący');
5: writeln('bardzo dobry');
4: writeln('dobry');
3: writeln('dostateczny');
2: writeln('mierny');
1: writeln('niedostateczny')
End;
readln
end.
Program Kalkulator;
{ program na uzycie instr CASE i operatorów arytmet}
{$APPTYPE CONSOLE}
uses sysUtils;
var
Liczba1, Liczba2, Wynik : Double;
Dzialanie : char;
BEGIN
Write('Podaj pierwsza liczbe: ');
Readln(Liczba1); //czytanie liczb z klawiatury }
Write('Podaj druga liczbe: ');
Readln(Liczba2);
Write('Rodzaj dzialania (+ - * /): ');
Readln(Dzialanie);
{czytanie znak dzialania }
Case Dzialanie OF
{ jakie dzialanie ? }
'+' : Wynik:=Liczba1+Liczba2; { dodawanie }
'-' : Wynik:=Liczba1-Liczba2; { odejmowanie }
'*' : Wynik:=Liczba1*Liczba2; { mnozenie }
'/' : Wynik:=Liczba1/Liczba2;
ELSE Writeln('Bledny symbol dzialania');
END; { Case }
Writeln('wynik=',wynik:4:1);
readln;
END.
Instrukcje pętli
Pętla - inaczej instrukcja cykliczna powodująca, że pewna
sekwencja działań będzie wielokrotnie powtarzana
Pętle służą do iteracyjnego wykonywania pewnych
kroków
Zazwyczaj mamy dostępne dwa rodzaje pętli:
pętle wykonujące się określoną liczbę razy
pętle wykonujące się do momentu spełnienia
pewnego warunku
Pętle wykonujące się określoną liczbę razy
for - to - do (instrukcja „dla”)
Musimy z góry znać liczbę powtórzeń pętli
W pętli funkcjonuje pewna zmienna, zwana licznikiem pętli,
„pamiętająca” ile razy pętla została wykonana
for
licznik_petli := początek
to
koniec
do
zawartość_pętli;
for
licznik_petli := koniec
downto
początek
do
zawartość_pętli;
licznik pętli należy wcześniej zadeklarować (zmienna typu
porządkowego, np. integer)
przy pętlach „do tyłu” pierwszą podajemy wartość
większą
jeśli zawartość pętli to kilka instrukcji, to grupujemy je za
pomocą
begin ... end
Pętla for - to - do
for
to
downto
Licznik_pętli := wyrażenie1
instrukcja
wyrażenie2
do
Pętla for - to - do
-
Wartość początkowa = Wartości końcowej
Instrukcja „dla” zostanie wykonana tylko jeden raz, po czym przerywa swoją pracę.
-
Wartość początkowa < Wartości końcowej
-
Instrukcja „dla” zostanie wykonywana tak długo, aż
wartość początkowa osiągnie
-
wartość równą wartości końcowej.
-
Wartość początkowa > Wartości końcowej
-
Instrukcja „dla” nie zostaje wykonana ani razu.
Pętla for - to - do
program prog6;
{$APPTYPE CONSOLE}
var
liczba : integer;
silnia, licznik : longint;
begin
write(' Podaj liczbę całkowitą aby obliczyć wartość silni ? ');
readln(liczba);
silnia:=1;
for licznik:=1 to liczba do silnia:=silnia*licznik;
writeln(' Wartość silni dla ',liczba : 6,' wynosi ', silnia)
end.
-
Pętle których wykonanie zależy od warunku
Pętla wykonuje się:
„dopóki” zachodzi pewien warunek
lub
„aż do momentu” zajścia pewnego warunku
W pętlach wykonujących się dopóki zachodzi
pewien warunek:
warunek sprawdzamy przed pierwszym
wykonaniem instrukcji wewnątrz pętli, a więc pętla
może nie być wykonana ani razu
W pętlach wykonujących się aż do momentu
zajścia pewnego warunku
warunek sprawdzamy PO pierwszym wykonaniu
instrukcji wewnątrz pętli, a więc pętla będzie
wykonana przynajmniej 1 raz
Pętla ”dopóki” –
„dopóki zachodzi warunek wykonuj instrukcje..”
instrukcja
warunek
Fałsz
Prawda
while
do
instrukcja
wyrażenie logiczne
Instrukcja „dopóki”
Schemat pętli „dopóki”
while
warunek
do
instrukcje;
Pętal „
while
”
jeśli zawartość pętli „
while
” to kilka instrukcji,
to grupujemy je za pomocą
begin ... End
Cechy pętli
while
służy do organizacji obliczeń, które będą wykonywane
tak długo jak wyrażenie znajdujące się po słowie „
while
” jest prawdą.
1) warunek logiczny pętli sprawdzany jest na początku
2) instrukcja jest wykonywana tak długo dopóki warunek
logiczny przyjmuje wartość True
3) jeśli warunek jest fałszem przy pierwszym sprawdzeniu
to instrukcja nie będzie wykonana ani razu
4) każdorazowe wykonanie instrukcji nazywa się iteracją
5) Jeżeli warunek logiczny nigdy
nie przyjmuje
wartość True
to pętla będzie wykonywana w nieskończoność!!! (
błąd
)
Pętla while
Przykłady
Wypisz dziesięć liczb począwszy od 0
program prog7;
{$APPTYPE CONSOLE}
uses SysUtils;
var
x : integer;
begin
x:=0;
while x<10 do
begin
writeln(x);
x:=x+1;
end;
readln
end.
Pętla while
Przykłady
Oblicz ile trzeba dodać kolejnych liczb naturalnych aby ich suma była
większa od podanej liczby
program prog8;
program Project1;
{$APPTYPE CONSOLE}
var n,licznik,suma : SmallInt;
begin
write(' Podaj liczbę całkowitą ? ');
readln(n);
licznik:=0;
suma:=0;
while suma<=n do
begin
licznik:=licznik+1;
suma:=suma+licznik;
end;
writeln(' liczba kolejnych liczb ', licznik);
Pętla while
Przykłady Algorytm Euklides
Oblicz NWD –największy wspólny dzielnik
program prog1_NWD;
{$APPTYPE CONSOLE}
var n,m: SmallInt;
begin
write(' Podaj liczbę całkowitą n: ');
readln(n);
write(' Podaj liczbę całkowitą m: ');
readln(m);
while m <> n do
if m > n then m:= m-n
else n:=n-m;
writeln(' NWD wynosi: ', n);
readln;
end.
n,m
start
stop
Pętla while
Przykłady Algorytm Euklides
Oblicz NWD –największy wspólny dzielnik
program prog92_NWD;
{$APPTYPE CONSOLE}
var n,m,k : integer;
begin
readln(n,m);
k:=m;
while (n mod k<>0) or (m mod
k<>0) do k:=k-1;
writeln(k);
reaDLN;
end.
start
k=k-1
n mod k <>0
Lub m mod k <>0
N
T
n,m
k=m
NWD=k
stop
Pętla „powtarzaj
powtarzaj ... do czasu zajścia warunku”
Repeat
instrukcje
until
warunek
;
instrukcja
warunek
Fałsz
Prawda
repeat
until
instrukcja
wyrażenie logiczne
Schemat pętli „powtarzaj aż do”
Pętla „powtarzaj
powtarzaj ... do czasu zajścia warunku”
Repeat
instrukcje
until
warunek
;
1) warunek logiczny pętli sprawdzany jest na końcu
2) ciąg instrukcji jest wykonywany tak długo aż warunek logiczny
przyjmuje wartość False
3) ciąg instrukcji będzie zawsze wykonany przynajmniej raz
4) Wyjście z instrukcji jest następuje aż warunek logiczny przyjmuje
wartość True
5) Aby zapewnić wyjście z pętli
trzeba zadbać aby warunek choć raz
osiągnął wartość True
Repeat until
program prog10;
{$APPTYPE CONSOLE}
var
i, k : integer;
n, x :Double;
begin
write(' Podaj podstawę n: ');
readln(n);
write(' Podaj wykładnik k: ');
readln(k);
x:=1;
i:=1;
repeat
x:= x*n;
i:= i+1;
until i>k;
writeln(' k-
ta potęga liczby n
wynosi: ', x);
Readln;
end.
Repeat until
Program Sumuje wyrazy szeregu 1/k z zadaną
dokładnością eps
program prog11;
const eps=0.0001;
Var
n :word
suma, x, :Double;
begin
suma:=0;
n:=1
repeat
x:= 1/n;
suma:=suma+x;
n:=n+1
unitl x < eps;
writelm(
'
k-
ta potęga liczby n wynosi:
'
, suma);
Readln;
end.
Repeat until
Program czyta znaki
klawiatury i podaje ich
kod
Oraz czyta tylko liczby
Program prog12a;
{$APPTYPE CONSOLE}
var zn: char;
begin
repeat
readln(zn);
writeln(zn,' ',byte(zn));
until zn =#13;
writeln('był Enter' );
readln;
end.
//Program nie czyta liczb
Program prog12b;
{$APPTYPE CONSOLE}
var zn: char;
begin
repeat
readln(zn);
writeln(zn,'
',byte(zn));
until (zn>='0')and(zn<='9');
writeln('była liczba' );
readln;
end.
Repeat until
Złe użycie petli
Program prog13;
var zn: char;
k, x: byte;
begin
k:=5;
repeat
writeln(k);
k:=k-1;
until
k > 5;
//warunek nigdy nie spełniony
k:=5; x:=0;
repeat
writeln(k);
x:=x+1/k;
until
k < 0;
//warunek nigdy nie
spełniony
readln;
end.
Program czyta tylko liczby
Program czytja_cyfry ;
{$APPTYPE CONSOLE}
var zn: char;
begin
repeat
readln(zn);
writeln(zn,' ',byte(zn));
until not
((zn>='0')and(zn<='9'));
writeln(‘ nie była liczba' );
readln;
end.
Repeat until
NWD: kolejna wersja
–szybka
Program prog14_NWD;
{$APPTYPE CONSOLE}
var n,m,k : integer;
begin
Write('n=');readln(n);
Write('m=');Readln(m);
If n<m then
begin
k:=m; m:=n; n:=k
end;
repeat
k:= n mod m;
n:=m;
m:=k
until k=0;
write('NWD=',n);
Readln;
end.
start
stop
Którą pętlę użyć
program p17;
const n=7;
var s, licznik: Longint;
begin
s:=1;
licznik:=1;
repeat
s := s*licznik;
licznik := licznik+1;
until licznik>n;
write(
'
silnia=
'
, s);
end.
program p16;
const n=7;
var s,licznik:longint;
begin
s := 1;
for licznik:=2 to x do
s:=s*licznik;
write(
'
silnia=
'
, s);
end.
program p18;
const n=7;
var s,licznik:longint;
begin
s:=1;
licznik:=2;
while licznik<=n do
begin
s := s*licznik;
licznik := licznik+1
end;
write(
'
silnia=
'
, s);
end.
• Jeśli instrukcja ma być wykonana określoną liczbę razy wybierz for
• Jeśli warunkiem przerwania pętli jest wyrażenie logiczne i instrukcja ma być
wykonana przynajmniej raz wybierz repeat
• Jeśli warunkiem przerwania pętli jest wyrażenie logiczne i nic nie wiadomo o
pierwszym wykonaniu wybierz while
• Jeśli masz wątpliwości wybierz while
while
wyrażenie
do
begin
Instr1;
if
warunek
then
continue
;
Instr2;
Instr3;
end;
while
wyrażenie
do
begin
Instr1;
if
warunek
then
break
;
Instr2;
Instr3
end;
Instr4;
W jaki zmienić realizację pętli
- procedury standardowe Continue i Break
- jeżeli wartość wyrażenia
warunek
będzie prawdą
to wszystkie instrukcje w danej iteracji występujące
po wywołaniu procedury
continue
zostaną pominięte;
następnie rozpoczyna się kolejny krok instrukcji pętli
.
-jeżeli wartość wyrażenia
warunek
będzie
prawdą to nastąpi natychmiastowe
przerwanie procesu iteracji;
następną wykonaną instrukcją będzie
pierwsza instrukcja poza pętlą Instr4.
Procedury
continue i break
mogą być wywoływane tylko wewnątrz pętli.
Mogą być użyte wewnątrz każdej instrukcji złożonej występującej
w pętlach for, repeat oraz while.
Użycie tych procedur poza instrukcjami pętli spowoduje błąd kompilacji.