Cursul nr. 5

INSTRUCŢIUNI

Algoritmi

• Generalităţi

• Reprezentarea algoritmilor

Instrucţiunea expresie

Instrucţiunea compusă (blocul de instrucţiuni)

Instrucţiuni de selecţie (decizie) if, if-else

Instrucţiunea de selecţie multiplă switch

Instrucţiuni de ciclare (repetitive)

• Instrucţiunea de ciclare cu test iniţial (while)

• Instrucţiunea de ciclare cu test final (do-while)

• Instrucţiunea de ciclare cu contor (for)

Instrucţiuni de salt

• Instrucţiunea break

• Instrucţiunea continue

• Instrucţiunea return

• Funcţia exit()

• Instrucţiunea de salt necondiţionat goto

Algoritmi

Calculatorul prelucrează datele de intrare printr-o succesiune

de acţiuni pentru a obţine datele de ieşire.

Succesiunea de prelucrări este descrisă prin program.

Fiecare prelucrare este rezultatul uneia sau mai multor

instrucţiuni.

Ordinea de efectuare a prelucrărilor este importantă, ea

respectând un anumit algoritm.

Înainte să înveţi orice limbaj de programare, trebuie să înveţi

să gândeşti algoritmic !

Algoritmi

Algoritmul este o metodă generală de rezolvare a unei

probleme, metodă care se poate implementa în programe prin

intermediul unui limbaj de programare.

Algoritmul poate fi gândit ca o succesiune de acţiuni ce se

pot aplica pentru obţinerea unui rezultat.

Algoritmii se caracterizează prin:

generalitate

finitudine

unicitate

realizabilitate

eficienţa

Algoritmi

Etapele urmate de la enunţul problemei de rezolvat până la

obţinerea produsului software final (programul):

stabilirea caietului de sarcini (enunţul problemei)

elaborarea algoritmilor – se face pe baza analizei

problemei

exprimarea algoritmilor – se face prin intermediul unui

limbaj de programare

validarea algoritmilor – confirmarea corectitudinii

algoritmului

analiza algoritmilor

testarea programului – depanarea şi trasarea

(determinarea memoriei necesare şi a timpului de calcul

Algoritmi

Reprezentarea algoritmilor

reprezentarea în limbaj natural – acest mod de

reprezentare nu presupune o pregătire specială, dar

pentru probleme complexe poate introduce neclarităţi;

reprezentarea prin scheme logice – este o reprezentare

grafică în care fiecare etapă este reprezentată printr-un

bloc, blocurile fiind înlănţuite prin segmente orientate,

ordinea lor respectând logica problemei;

reprezentarea în limbaj pseudocod – limbajul pseudocod

este apropiat de codificarea din Pascal sau C, permite o

reprezentare clară şi concisă;

reprezentarea prin tabele de decizie – metoda e specifică

problemelor cu număr mare de alternative, ele apelând la

logica booleană inventariază toate acţiunile posibile prin

combinarea condiţiilor precizate.

Algoritmi

Limbaj pseudocod

Un limbaj pseudocod se reprezintă sub forma de text si se

bazează pe nişte aşa-numite cuvinte cheie. Fiecare cuvânt

cheie identifica in mod unic un anumit tip de acţiune.

Acţiunile algoritmului se reprezintă in pseudocod prin

instrucţiuni.

Ansamblul cuvintelor cheie împreună cu regulile care

trebuie respectate in folosirea lor, alcătuieşte ceea ce

numim sintaxa limbajului-pseudocod

Există o mare diversitate de limbaje-pseudocod. Practic,

fiecare programator îşi poate proiecta propriul pseudocod,

definind cuvintele cheie ale acestuia şi impunând nişte

aşa-numite reguli de sintaxa.

Algoritmi

Exemplu de folosire a limbajului pseudocod

ALGORITMUL ECGRDOI ESTE: { Algoritmul : Rezolvarea }

{ ecuaţiei de gradul doi }

CITEŞTE a,b,c; { a,b,c = Coeficienţii ecuaţiei }

FIE delta:=b*b-4*a*c;

DACĂ delta<0 ATUNCI ind:=0; { rădăcini complexe }

r:=radical din (-delta);

x1:=-b/(a+a);

x2:=r/(a+a);

ALTFEL ind:=1; { rădăcini reale }

r:=radical din delta;

x1:=(-b-r)/(a+a);

x2:=(-b+r)/(a+a);

SFDACĂ

TIPĂREŞTE ind, x1,x2;

SFALGORITM

Algoritmi

Scheme logice

Un limbaj pseudocod se reprezintă sub forma de text si se

bazează pe nişte aşa-numite cuvinte cheie. Fiecare cuvânt

cheie identifica in mod unic un anumit tip de acţiune.

Acţiunile algoritmului se reprezintă in pseudocod prin

instrucţiuni.

Ansamblul cuvintelor cheie împreună cu regulile care

trebuie respectate in folosirea lor, alcătuieşte ceea ce

numim sintaxa limbajului-pseudocod

Există o mare diversitate de limbaje-pseudocod. Practic,

fiecare programator îşi poate proiecta propriul pseudocod,

definind cuvintele cheie ale acestuia şi impunând nişte

aşa-numite reguli de sintaxa.

Algoritmi

Scheme logice

Blocuri de control – delimitează începutul şi sfârşitul schemei logice.

pentru scheme program

pentru scheme de detaliere

pentru scheme de subprogram:

(Prin nume se precizează numele

rutinei, iar parametrii formali

precizează datele care vor fi

prelucrate de aceasta.)

Blocuri de intrare/ieşire – precizează datele de intrare, respectiv cele

de ieşire ale algoritmului.

bloc comun celor două tipuri de

operaţii

blocuri distincte pentru

operaţiile de intrare/ieşire.

Algoritmi

Blocuri de atribuire – precizează

expresia de evaluat şi variabila căreia i

se atribuie rezultatul.

Blocuri de decizie – marchează punctele

de ramificare a programului şi expresia

condiţională care determină evoluţia

algoritmului în continuare.

Blocuri de blocuri – inserează în

algoritm un subprogram predefinit,

precizând numele acestuia.

Blocuri de apel rutine – apelul unei

rutine pentru care se precizează numele

acesteia şi valorile transmise pentru

parametri.

Blocuri de conectare – se folosesc pentru algoritmi complecşi, pentru sporirea

lizibilităţii algoritmului.

Conectare în pagină – pentru evitarea

intersectărilor arcelor ce unesc blocurile.

Conectare între pagini – se folosesc

atunci când algoritmul nu se poate

încadra pe o singură pagină.

Algoritmi

Pentru realizarea schemelor logice, în anii ’70, s-au impus

principiile programării structurate. Acestea au dus la o

puternică dezvoltare a limbajelor de programare.

Prin aplicarea principiilor programării structurate, se obţine:

claritate în citirea programelor;

depanarea uşoară a programelor;

generalitatea programelor şi uşurinţă în refolosirea

codului scris.

Structurile de control care stau la baza programării

structurate sunt:

structura secvenţială;

structura alternativă;

structura repetitivă.

Algoritmi

Structura secvenţială

Structură pseudo-alternativă Structură alternativă simplă

Structură alternativă multiplă

Algoritmi

Structură repetitivă cu test

iniţial

Structură repetitivă cu test

final

Structură repetitivă cu contor

Instrucţiuni

Instrucţiunea expresie - se încheie cu punct şi virgulă (;)

Sintaxa instrucţiunii: < expresie > ;

int i, j;

float r;

//…

i = 10;

j = i * 5;

r = (float) i / j + 1.5 ;

Instrucţiunea compusă (blocul de instrucţiuni)

Sintaxa instrucţiunii: {

lista_declaratii;

lista_instructiuni;

}

{

int i, j;

float r;

//…

i = 10;

j = i * 5;

r = (float) i / j + 1.5 ;

}

Instrucţiuni

Instrucţiuni de selecţie (decizie) if, if-else

if (condiţie) (1)

instrucţiune_1;

sau

if (condiţie) (2)

instrucţiune_1;

else

instrucţiune_2;

int a, b, max;

//...

if (a<0)

a = -a;

//...

if (a > b)

max = a;

else

max = b;

Instrucţiuni

Instrucţiuni de selecţie multiplă - switch

switch (expresie)

{

case const1: lista_instructiuni;

<break;>

case const2: lista_instructiuni;

<break;>

…..

<default> lista_instructiuni;

}

#include <stdio.h>

void main()

{ int a, b; // variabile folosite pentru citirea celor doi întregi char op;

char op; // variabila op este folosită pentru citirea ca şi caracter a tipului de operaţie dorit

printf("Introdu doua valori intregi:");

printf("\na="); scanf("%d", &a);

printf("\nb="); scanf("%d", &b);

printf("Introdu operator aritmetic, simplu, binar (+, -,*, /, %):");

fflush(stdin);

scanf("%c", &op); // citirea se face în format caracter

switch (op)

{

case '+': printf("\n Operatia de adunare - rezultat: %d", a+b);

break;

case '-': printf("\n Operatia de scadere - rezultat: %d", a-b);

break;

case '*': printf("\n Operatia de inmultire - rezultat: %d", a*b);

break;

case '/': printf("\n Operatia de impartire - rezultat: %d", a/b);

break;

case '%': printf("\n Operatia de impartire intreaga - rest: %d", a%b);

break;

default: printf("\nOperatie ilegala!");

}

}

Instrucţiuni

Instrucţiuni repetitive

Instrucţiunea de ciclare cu test

iniţial (while)

Instrucţiunea de ciclare cu test

final (do-while)

Instrucţiunea de ciclare cu contor

(for)

Sintaxa instrucţiunii:

while (expresie)

instrucţiune;

do

instructiune;

while (expresie);

for( expr1; expr2; expr3)

instrucţiune;

int i;

i = 5;

while (i)

{

printf(”\ni=%d”, i );

i--;

}

int i;

i = 5;

do

{

printf(”\ni=%d”, i );

i--;

}

while (i);

int i;

for( i = 5 ; i >=0 ; i- -)

printf(”\ni=%d”, i );

Instrucţiuni

Instrucţiunea de salt break

Sintaxa sa este:

break;

Instrucţiunea break se foloseşte: în interiorul instrucţiunii switch pentru a întrerupe execuţia acesteia

în instrucţiunile de ciclare (while, do-while, for) pentru a determina ieşirea forţată din acestea.

#define N 100

int i;

for( i=1 ; i<=N ; i++)

{

if (!(i%7))

{ printf("\ni = %d - divizibil cu 7", i);

getch();

break; // datorita folosirii instrucţiunii break, ciclul for se

// va întrerupe când i devine divizibil cu 7 şi nu când i

// ajunge la valoarea 100; ca urmare, o sa se afişeze

// doar primele 7 valori şi se iese din for;

}

printf("\ni=%d", i); // la ieşirea din ciclul for, I va avea valoarea 7

}

Instrucţiuni

Instrucţiunea de salt continue

Sintaxa sa este:

continue;

Instrucţiunea break se foloseşte: în interiorul instrucţiunii switch pentru a întrerupe execuţia acesteia

în instrucţiunile de ciclare (while, do-while, for) pentru a determina ieşirea forţată din acestea.

int i;

for( i=1; i <= 100 ; i++)

{

if (!(i%7))

{ printf("\ni = %d - divizibil cu 7", i);

getch();

continue; // datorita lui continue, se va ignora linia următoare si se trece

// la următoarea iteraţie a lui for, ca urmare, se vor afişa toate

// valorile, de la 1 la 100, pentru cele divizibile cu 7 afişarea

// fiind diferită faţă de celelalte valori

}

printf("\ni=%d",i);

}

Instrucţiuni

Funcţia exit()

definită în fişierele header standard stdlib.h şi process.h

întrerupe execuţia întregului program şi revenirea în sistemul de operare

sintaxa sa este:

void exit(int);

int functie(void) // antetul funcţiei precizează tipul valorii întoarse

{

int a;

// ...

return (a/2); // tipul expresiei returnate e identic cu cel al funcţiei

}

Instrucţiunea return

Formele admise pentru instrucţiunea return sunt:

Sintaxa sa este:

return;

sau

return expresie;

sau

return (expresie);

void functie(void)

{

int a;

// ...

exit(0);

}

Instrucţiuni

Instrucţiunea de salt necondiţionat goto

Instrucţiunea goto are ca efect saltul la eticheta specificată.

Sintaxa sa este:

goto nume_et;

Eticheta nume_et este specificată folosind sintaxa:

nume_et :

int a;

Et1:

scanf(“%d”, &a);

if (a<=0)

goto Et1;