Programare I

Indrumar Laborator

Nota laborator = Prezenta + Activitate laborator + Partial + Examen

Prezenta

Prezenta la laboratorul de Programare 1 este foarte importanta! Puntajul pentru prezenta se

calculeaza astfel:

Nr.
Prezente 0 1 2 3 4 5 6 7 8 9 10 11 12
Punctaj -30 -25 -20 -15 -10 -5 0 5 10 13 15 18 20

Activitate laborator

In fiecare ora de laborator este propusa cate o problema. Rezolvarea acesteia in timpul
laboratorului duce la obtinerea a unui punct (1p). Se pot obtine maximum 12 de puncte. Primul
si ultimul laborator nu se considera.

Partial

Prezenta este obligatorie. Acesta are loc in saptamana a 7-a sau a 8-a. Daca partialul nu este
promovat aceasta se poate repeta in ultima saptamana.

Partialul consta din rezolvarea (pe calculator) a unei probleme asemanatoare cu cele propuse si
rezolvate in prima parte a semestrului. Notarea se face cu punctaj intre 0 si 35. Trebuie sa se
obtina minum 20 puncte pentru a considera ca partialul a fost promovat.

Examen

Este obligatoriu. Neprezentarea la examenul de laborator echivaleaza cu nepromovarea

laboratorului si implicit a materiei.

Examenul consta din rezolvarea (pe calculator) a unei probleme asemanatoare cu cele propuse si
rezolvate in timpul semestrului. Notarea se face cu punctaj intre 0 si 45. Trebuie sa se obtina
minum 25 de puncte pentru a considera ca examenul a fost promovat.

Punctaj laborator = (Punctaj prezente) + (Activitate laborator) + (Punctaj partial) +

(Punctaj examen laborator) + Bonus
Asadar, punctajul maxim poate fi:

Punctaj laborator max = 20 + 12 + 35 + 45 = 112

Nota laborator = Punctaj laborator / 10.

Pentru promovarea laboratorului este necesara obtinerea unei punctaj mai mare de 50 de
puncte (corespunzatoare notei 5). Atentie! 45 de puncte nu inseamna nota 5 !

Situatia la laborator este disponibila la adresa http://upm.adrianroman.ro/prog1/note.xls

Laborator 1

Introducere

Terminologie:

Program – o serie de instructiuni pe care calculatorul le executa

Limbaje de programare – Cod masina, Limbaj de asamblare si Limbaje de nivel inalt.

Cod masina: programele si datele sunt introduse in calculator folosind succesiuni de zero
si unu. Codul masina este limbajul pe care il intelege calculatorul. Indiferent de limbajul
folosit pentru programare, in cele din urma toate programele si datele sunt traduse in cod
masina.

Limbaj de asamblare: Este un limbaj de programare in care se programeaza mai usor

decat in cod masina. Programele nu sunt mai scurte, doar mai usor de scris. Pentru
fiecare comanda din cod masina exista o comanda in limbajul de asamblare. Dupa ce
programul este scris trebuie compilat pentru a se traduce limbajul de asamblare in cod
masina. Compilatorul se cheama Assembler.

Limbaje de nivel inalt: Cuprind limbaje ca Fortran (Formula Translator), COBOL

(Common Business Oriented Language), BASIC (Beginner’s All purpose Symbolic
Instruction Code), Pascal, C, Ada, C# si multe altele. Programele sunt mult mai scurte.
Fiecare instructiune este convertita in mai multe intructiuni cod masina. Convertirea se
face in 3 pasi: preprocesare, compilare and link-are.

Programul scris intr-un EDITOR al limbajului de programare se numeste cod sursa. Un

program compilat se numeste cod obiect iar programul link-at cod executabil. De
exemplu: Prg.CPP, Prg.OBJ, and Prg.EXE

Sintaxa: Reguli de construire a unor comenzi valide intr-un limbaj de progrmare. Daca
un program are erori de sintaxa atunci el nu se va compila si vor rezulta erori de
compilare.

Erori de rulare si de logica: O eroare de rulare apare atunci cand un program nu poate
executa ceea ce i s-a cerut. De exemplu, deschiderea unui fiser care nu exista. Erorile de
logica sunt cel mai dificil de detectat si rezolvat; sunt cauzate de erori de logica din partea
programatorului. De exemplu, sa presupunem ca dorim sa scriem un program care sa
ofere o reducere daca se realizeaza cumparaturi in valoare mai mare de 1000 de RON, dar
programul rezultat ofera reducerea pentru valori mai mici de 1000 de RON.

C/C++: Limbajul C (Dennis Ritchie) reprezinta o modificare a unui limbaj numit BCPL
(Ken Thompson). Limbajul C a fost scris pentru programarea in sistemul de operare Unix
care continua sa fie foarte popular in mediul universitar. Limbajul C++ (Bjarne
Stroustrup) reprezinta versiunea orientata obiect a limbajului C.
 Constanta: un element de tip data care nu isi schimba valoarea pe parcursul executiei
programului.

Primul program C: Deschiderea editorului si scrierea programului. Apoi compilarea si

rularea programului.

/********************************
Program 1-1
Program Hello World
Obiectiv: studirea structurii unui program C
********************************/
#include <iostream> //directiva preprocesor
using namespace std; //spune compilatorului ca anumite obiecte se
gasesc in namespace-ul standard
int main () //functia principala
{
cout << "Primul meu program in C! Bravo!\n";
getchar(); //asteapta apararea unei taste. De testat programul si fara
aceasta linie
return 0;
}

Se salveaza programul pe hard disk prin accesarea meniului File -> Save cu numele
Hello.cpp.
Un program C este o colectie de una sau mai multe functii. Acest program are doar o
functie care se numeste main. Functia main este necesara in toate programele scrise in
limbajul C. Daca exista mai multe functii in program, functia main este cea care le
lanseaza.
Descrirea programului: Liniile care incep cu /* si se termina cu */ sunt comentarii.
Compilatorul ignora aceste linii. Comentariile sunt necesare pentru a descrie rolul
comenzilor in cadrul programului. // pot fi folosite pentru a comenta o linie.
Directiva preprocesor: Limbajul C foloseste anumite functii aflate in diverse
module/librarii pentru operatiile de intrare si iesire. Programul scrie o linie pe ecran.
Ecranul reprezinta iesirea standard iar tastatura intrarea standard. Semnul # arata ca
restul liniei reprezinta o instructiune/directive pentru processor.
#include <iostream.h> spune compilatorului sa adauge codul care se gaseste in fisierul
iostream.h la inceputul acestui program.
Functiile: int main () este o functie. O functie primeste unul sau mai multi
parametrii(argumente) de la functia care o apeleaza si poate sa nu intoarca nimic sau
poate sa intorca un singur rezultat. Cuvantul int inainte de numele functie (main) arata ca
functia intoarce un intreg catre modulul apelant. Modulul care apeleaza functia main este
sistemul de operare. Acest program intoarce zero sistemului de operare, indicand o
executie normal a programului. Parantezele () de dupa numele functiei arata ca functia nu
primeste nici un parametru de la modulul apelant.
Inceputul si sfarsitul blocului de instructiuni: Inceputul blocului de intructiuni este
indicat de { iar sfarsitul de }.
Separarea comenzilor: O linie de comanda este separata de o alta prin punct si virgula ;

cout si cin: cout afiseaza pe ecran iar cin primeste caractere de la tastatura. Caracterele
<< sau >> arata directia fluxului de date. In programul de mai sus, " Primul meu
program in C! Bravo!\n”, reprezinta datele care sunt trimise catre ecran. Observati ca
textul este inclus intre ghilimele. Ultimele doua caractere \n fac ca cursorul sa coboare o
linie.

Comanda return: return 0, intoarce zero catre sistemul de operare, indicand ca

programul s-a executat normal.

Recomandari:
http://www.youtube.com/watch?v=jTSvthW34GU
http://www.youtube.com/watch?v=b00HsZvg-V0

Tema 1-1 – Nepunctata

1. Instalarea unui editor si compilator de C (Recomandat Borland C – folosit la curs - si

Microsoft Visual C++ Express - http://www.microsoft.com/express/vcsharp/Default.aspx
- sau Microsoft Visual Studio .NET – existent in laborator)
2. Rularea programelor de mai sus

Anexa – Cum sa ruleaza un program in C folosind Microsoft Visual C++ Express

1. Porniti Microsoft Visual C++ Express

2. Veti vedea urmatoarea fereastra:
3. Apasati New si Project. In partea stanga dati click pe Win 32 console application.
Introduceti un nume pentru program, de exemplu Hello. Atentie la locatia unde se
salveaza programul.
4. Click pe OK, apoi click Next. In urmtoarea fereastra click Empty project and
apasati Finish.

5. Urmatorul pas este important: click dreapta pe fisierele sursa in Solution Explorer
si click pe Add new item.
6. Click in partea stanga pe C++ file. Alegeti un nume si click Add.

7. Scrieti programul.
Laborator 2

Algoritmi, scheme logice, pseudocod

Exemplul 2-1

Se citesc 2 valori numerice reale, care reprezintă dimensiunile (lungimea şi lăţimea unui
dreptunghi). Să se calculeze şi să se afişeze aria dreptunghiului.

ALGORITM aflare_arie_drept
INCEPUT
START CITEŞTE L,l
aria <- L*l
AFIŞEAZA aria

CITESTE L,l SFARŞIT

CITEŞTE L, l

aria <- L * l Implementare: #include <iostream>

using namespace std;

void main( )
AFISEAZA aria { double L, l;
AFIŞEAZĂ aria
cout<<"Lungime="; cin>>L;
cout<<"Laţime="; cin>>l;
double aria = L * l;
STOP cout << "Aria="<< aria;
}
STOP

Exemplul 2-2

Se citesc 2 valori reale. Să se afiseze valoarea maximului dintre cele 2 numere.

ALGORITM max_2_nr
INCEPUT Sau:
ALGORITM max_2_nr
CITESTE a, b
DACA a >= b ÎNCEPUT
ATUNCI max<-a CITEŞTE a, b
ALTFEL max<-b DACA a >= b
AFISEAZA max ATUNCI AFISEAZA a
SFARŞIT ALTFEL
Implementare în limbajul C++: AFISEAZA b
#include <iostream> SFARŞIT
#include <iostream>
using namespace std; using namespace std;

void main( ) void main( )

{ float a, b, max; { float a, b;
cout<<"a="; cin>>a; cout<<"a=";cin>>a;
cout<<"b="; cin>>b; cout<<"b="; cin>>b;
if (a >= b) if (a >= b)
max = a; cout<<"Maximul este:"<<a;
else max = b; else
cout<<"Maximul este:"<<max;} cout<<"Maximul este:"<<b; }
Exercitiu 2-1

Proiectaţi un algoritm care să rezolve o ecuaţie de gradul I (de forma ax + b = 0), unde
a,b sunt numere reale. Discuţie după coeficienţi.

Exercitiu propus 2-1

Proiectaţi un algoritm care să testeze dacă un număr întreg dat este număr prim.
Laborator 3

Tipuri de date

Tipul unei date determină dimensiunea zonei de memorie ocupate şi valorile pe care le
poate lua.

Tipurile datelor se pot grupa în tipuri fundamentale şi tipuri derivate.

Tipurile de date fundamentale cuprind tipurile aritmetice de bază şi tipul void. Există
patru tipuri aritmetice de bază, specificate prin cuvintele cheie: char, int, float şi double.
Gama de valori poate fi extinsă prin modificatori de tip desemnaţi prin cuvintele cheie:
signed, unsigned, short, long. Tipurile întregi ce se obţin prin combinarea tipurilor de
bază cu modificatorii de tip sunt prezentate mai jos:

Tipuri de date intregi

Tipuri de date in virgula mobila

Tipul fundamental void indică absenţa oricărei valori şi se utilizează în următoarele
situaţii: declaraţia unei funcţii fără parametri sau care nu returnează un rezultat, tipul
pointer generic şi conversii de tip cu operatorul cast pentru pointeri.

Iată câteva exemple de expresii care returnează ca valoare spaţiul de memorie ocupat de
date de diferite tipuri:

sizeof (long int); // expresia returnează valoarea 4

sizeof (unsigned char) // expresia returnează valoarea 1
sizeof (long double) // expresia returnează valoarea 10

Variabile

Declaraţii de variabile

Toate variabilele trebuie declarate înainte de a fi folosite.

Sintaxa unei declaraţii de variabilă impune specificarea tipului, având forma generală:
tip_var nume_var;

tip_var este un specificator de tip de date oarecare, standard, pointer sau definit de
utilizator.

unsigned int n; // declararea variabilei n de tip unsigned int

Se pot face declaraţii de variabile cu iniţializare utilizând sintaxa:

tip_var nume_var= valoare_initiala;

sau se pot declara mai multe variabile de acelaşi tip utilizând sintaxa:

tip_var nume_var1<=val_initiala1>,< nume_var2<= val_initiala2>>,...;

double real=2.5; // declararea variabilei real de tip double,

//iniţializată cu valoarea 2.5
char c1, c2=‟a‟, ch; // declararea a trei variabile de tip char, c1, c2
//şi ch, variabila c2
// fiind iniţializată cu valoarea „a‟

Exemplul 3-1

Programul 3-1 exemplifica diverse operatii aritmetice.

/********************************
Program 1-2
Program Operatii artimetice
Obiectiv: studirea operatiilor in C
********************************/
#include <iostream> //directive preprocesor
using namespace std;
int main () //functie principala
{
int i,j,k,l, m,n;
float a,b,c;
//intregi
cout << "Operatii cu intregi\n \n";
i = 6 + 3;
l = 6.5;
m = 3.5;
j = l + m;
k = 10 /3;
n = 10 % 3;
cout << "6 + 3 = " << i << "\n";
cout << "l = 6.5, m = 3.5 --------->l + m = " << j << "\n";
cout << "10 / 3 = " << k << "\n";
cout << "10 % 3 = " << n << "\n";
//operatii cu numere reale si operatii mixte
a = 10 / 3;
b = 10.0 / 3.0;
c = 10.0 /3;
cout << "10 / 3 = " << a << "\n";
cout << "10.0 / 3.0 = " << b << "\n";
cout << "10.0 / 3 = " << c << "\n";
getchar();
return 0;

Daca l=6.5 si m =3.5 atunci l+m ar trebui sa fie 10, de ce este 9? Se atribuie aceste
numere unor variable de tip intreg, ceea ce duce la pierderea partii fractionale adica
raman 6 si 3, iar rezulatul este 9.
De ce 10/3 da 3? Aceasta operatie se numeste impartire intreaga. Urmatoarea operatie 10
% 3 are ca rezultat 1, care reprezinta restul impartirii.

Exercitiul 3-1

Sa se scrie un program care sa afiseze media a trei note pentru un student. Notele se vor
citi de la tastatura.

Exemplu:

Se citeste: 9 9.5 10
Se afiseaza: Media este 9.5

Exercitiu propus 3-1

Sa se citeasca cu atentie informatiile despre tipurile de date din C si despre variabile. Sa se refaca
Exemplul 3-1 si Exercitiul 3-1.

Exercitiu propus 3-2

Sa se scrie un program C care sa determine cifra miilor, sutelor, zecilor si unitatilor dintr-un
numar citit de la tastatura.

Exemplu: daca se introduce numarul 7513 rezultatul programului va trebuie sa fie:

7 mii
5 sute
1 zeci
3 unitati
Laborator 4

Instructiuni decizionale

Cand instructiunile dintr-un program sunt executate una dupa alta in mod secvential se
spune ca programul are o structura liniara. De multe ori insa programele presupun luarea
unor decizii. De exemplu, daca scriem un program care sa trimita emailuri persoanelor
care au nume incepand cu litera A, atunci va trebui sa se verifice nume persoanelor si
daca corespund criteriului stabilit atunci se ia decizia de a trimite email-ul.

Exemplu 4-1 prezinta un exemplu simplu de program care calculeaza media a 3 note
citite de la tastatura si afiseaza daca studentul/elevul a obtinut medie de trecere.

/****************************************
Exemplu 4-1
*****************************************/
#include <iostream>
using namespace std;
int main ()
{
int n1, n2, n3;
double medie;
cout << "Introduceti 3 note : ";
cin >> n1 >> n2 >> n3;
medie = (n1 + n2 + n3)/3.0;
cout << "Media este : " <<medie <<endl;
if (medie >= 5.0) cout << "Studentul a promovat!";
else cout << "Studentul a picat!";

cin.ignore();
getchar();
return 0;
}

Decizia a fost luat-o folosind instructiunea if-else:

if (medie >= 5.0) cout << "Studentul a promovat!";
else cout << "Studentul a picat!";

Putem adauga instructiuni suplimentare pentru if sau pentru else sau pentru ambele cum
se vede mai jos:

if (medie >=5.0)
{
cout << "Studentul a promovat!\n";
cout << "Studentul va avea o vara linistita.";
}
else
{
cout << "Studentul a picat!\n";
cout << "Studentul va trebui sa se prezinte si in sesiunea de toamna!";
}
Operatori relationali

Simbolurile folosite >= sunt numiti operatori relationali. Exista urmatorii operatori
relationali:
 == egal cu
 > mai mare decat
 < mai mic decat
 != diferit de
 >= mai mare sau egal
 <= mai mic sau egal.

Rezultatul unei operatii relationale este false (fals) sau true (adevarat). Variabilele care
contin valori de tip true/false se numesc variabile bool.

Sa rescriem programul 3-1 astfel incat sa aiba loc o decizie intre mai multe alternative:

/****************************************
Exemplu 4-2
*****************************************/
#include <iostream>
using namespace std;
int main ()
{
int n1, n2, n3;
double medie;
cout << "Introduceti 3 note : ";
cin >> n1 >> n2 >> n3;
medie = (n1 + n2 + n3)/3.0;
cout << "Media este : " <<medie <<endl;

if (medie >= 9.0) cout << "Rezultat excelent!";

else
if (medie >= 8.0) cout << "Foarte bine!";
else
if (medie >= 7.0) cout << "Multumitor!";
else
if (medie >= 6.0) cout << "Satisfacator!";
else
if (medie >= 5.0) cout << "Slab!";
else
if (medie < 5.0) cout << "Nesatisfacator!";

cin.ignore();
getchar();
return 0;
}

Operatori logici

Operatori logici sunt folositi cu cand se lucreaza cu valori Boolean-e sau ca rezultat al unor
operatii relationale. Operatorii logici sunt:
 AND (&&)
  OR (||)
 NOT(!)

Sa presupunem ca media este 9.5.Sa evaluam urmatoarea instructiune:

if (medie >= 9.0 && medie <=10.0)

cout << "Rezultat excelent!";

Prima expresie, medie >=9.0, este adevarata. A doua expresie, medie <=10.0, este si ea
adevarata. In concluzie, expresia medie>=9.0 && medie <=10.0 este si ea adevarata si se
va afisa “Rezultat excelent!”

Instructiunea switch

Exista o alternativa la instructiunile if/else multiple si aceasta este comanda switch.

switch (optiune)
{
case 1:
cout << "A fost selectata optiunea 1";
break;
case 2:
cout << "A fost selectata optiunea 2";
break;
case 3:
cout << "A fost selectata optiunea 3";
break;
default:
cout << "Optiune invalida";
}

Important! Comanda switch nu poate fi folosita decat pentru valori de tip intreg sau
char.

/****************************************
Exemplu 4-3
*****************************************/
#include <iostream>
using namespace std;
int main ()
{
int n1, n2, n3;
int optiune;
cout << "Introduceti 3 valori : ";
cin >> n1 >> n2 >> n3;
cout << "Alegeti o operatie: 1. Adunare 2. Inmultire 3. Medie" <<endl;
cin >> optiune;

switch (optiune)
{
case 1:
cout << "Adunare: " << n1+n2+n3;
break;
 case 2:
cout << "Inmultire: " << n1*n2*n3;
break;
case 3:
cout << "Medie: " << (n1+n2+n3)/3.0;
break;
default:
cout << "Optiune invalida";
}

cin.ignore();
getchar();
return 0;
}

Exercitiul 4-1

Sa se scrie un program care sa citeasca 3 valori de la tastatura si sa afiseze in functie de

optiunea selectata: media aritmetica, media armonica, media geometrica si media
patratica. Programul va functiona similar cu Exemplul 4-3.

Formulele se gasesc aici: http://ro.wikipedia.org/wiki/Categorie:Medii

Observatie: se va folosi functia sqrt din libraria math.h.

Exercitiu Propus 4-1

Sa se scrie un program C care sa afiseze numele unei luni pentru un numar de la 1 la 12 citit de
la tastatura. Sa se foloseasca mai intai if/else si apoi instructiunea switch.

Exemplu: daca se introduce numarul 4 rezultatul programului va trebuie sa fie:

Aprilie
Laborator 5

Instructiuni de ciclare (iterare/buclare)

Sa presupunem ca dorim sa afisam numerele de la 1 la 100 pe ecran. Acest lucru se poate

face prin scrierea instructiunii cout de 100 de ori, dar, evident, acest lucru nu este foarte
eficient si rapid. Ce s-ar intampla daca am dori sa afisam numere pana la 10000 ?

Daca analizam problema mai in amanunt observam ca fiecare numar este, de fapt,
numarul anterior la care se adauga 1. Asadar, problema se reduce la a aduna 1 la numarul
precendent si de il afisa pana se atinge valoarea 100.

Sa vedem care ar fi pasii care ar trebui parcursi:

Numarul ia valoarea 1.
Se afiseaza numarul
Se adauga 1 la numar
Se repeta cele 2 instructiuni.
Cand numarul este egal cu 101 atunci Stop.

Intr-o forma mai adecvata unui program acesti pasi ar fi:

Numar = 1
Atat timp Numar este mai mic sau egal cu 100
{
afiseaza Numar
incrementeaza Numar
}

Asadar se executa urmatorii pasi:

1. Se initializeaza variabila
2. Se verifica conditia de intrare in bucla/ciclu. Conditia trebuie sa fie adevarata
pentru a se intra in bucla. Daca conditia este falsa, nu se intra in bucla.
3. Se executa corpul buclei (apare intre {})
4. Se schimba valoarea variabilei si se verifica din nou conditia de intrare in bucla.

Exemplul 5-1
/******************************************
Afiseaza numerele de la 1 la 100 pe ecran
Obiectiv - invatarea instructiunii while
*****************************************/
#include <iostream>
using namespace std;
int main()
{
int number;
 number = 1;
while (number <= 100)
{
cout << number << " "; //afiseaza numarul
number ++; //incremeteaza number
}
getchar();
return (0);
}

Instructiunea while este controlata de variabila number, deoarece dorim ca bucla sa se

execute de un numar exact de ori.

Instructiunea while poate fi controlata si o “santinela” asa cum se vede in Exemplul 5-2.

/******************************************
Accepta si afiseaza nume
Obiectiv – exemplificarea instructiunii while cu santinela
*****************************************/
#include <iostream>
#include <string>
using namespace std;
int main()
{
string name;
cout << "Enter a name ";
cin >> name;
while (name !="quit")
{
cout << "Hello, " << name <<"\n";
cout << "Enter another name or type 'quit' to exit ";
cin >> name ;
}
getchar();
return (0);
}

Ce se intampla daca dorim sa acceptam introducerea de nume pana cand se introduce

“quit” dar nu mai mult de 5 nume?

Exemplul 5-2A

/******************************************
Accepta si afiseaza nume
Obiectiv – exemplificarea instructiunii while cu santinela
*****************************************/
#include <iostream>
using namespace std;
int main()
{
string name;
int count;
count = 1;
cout << "Enter a name_ ";
cin >> name;
while (name !="quit" && count <= 5)
{
count ++;
cout << "Hello, " << name <<"\n";
cout << "Enter another name or type 'quit' to exit_ ";
cin >> name ;
}
count --;
cout << count << " names were entered " << "\n";
getchar();
return (0);
}

Instructiunea for

Instructiunea for este asemanatoare ca si functionalitate cu instructiunea while folosita in

Exemplul 5-1, in care bucla se executa de un numar fix de ori.

Exemplul 5-3

/******************************************
Afiseaza numerele de la 1 la 100 pe ecran
Obiectiv - instructiunea for
*****************************************/
#include <iostream>
using namespace std;
int main()
{
int number;
for (number =1; number <= 100; number++)
{
cout << number << " "; //afiseaza numarul si un spatiu
}
getchar();
return 0;
}

Exemplele 5-1 si 5-3 au acelasi rezultat singura diferenta reprezentand-o modul de

implementare.

Exemplul 5-3A

/*************************************************************
Afisarea numerelor pare de la 2 pana la 100
Obiectiv – instructiunea for
**************************************************************/
#include <iostream>
int main()
{
int number;
for (number =2; number <= 100; number=number+2)
{
cout << number << " "; //display number and put some spaces
}
getchar();
return (0);
}

Instructiunea do..while

Do..while este o instructiune de ciclare cu conditie de oprire. Astfel, corpul buclei se

executa cel putin o data. Conditia se afla dupa corpul buclei.

Exemplul 5-4

#include <iostream>
using namespace std;
int main()
{
int number;
number = 1;
do
{
cout << number << " ";
number ++;
}
while (number <=100);
getchar();
return (0);
}

Exercitiul 5-1

Sa se scrie un program care sa citeasca 20 de numere de la tastatura si sa afiseze media

aritmetica. Sa se foloseasca mai intai while si apoi for.

Exercitiu propus 5-1

Sa se scrie un program C care sa calculeze salarul unei persoane care lucreaza un numar
oarecare de zile.

Exemplu:

Introduceti numele salariatului --> Maria

Introduceti venit/ora --> 10
Introduceti numarul de zile lucrat --> 4.
Indroduceti numarul de ore lucrat in ziua 1 --> 8
Indroduceti numarul de ore lucrat in ziua 2 --> 7
Indroduceti numarul de ore lucrat in ziua 3 --> 9
Indroduceti numarul de ore lucrat in ziua 4 --> 10

Numele salariatului: Maria

Numarul total de ore lucrate : 34
Salar : 340
Laborator 6

Exercitii

1. Să se citească de la tastatură un număr real. Daca acesta se află în intervalul [-1000, 1000], să
se afiseze 1, dacă nu, să se afiseze -1.
2. Să se calculeze valoarea funcţiei f(x), ştiind că x este un număr real introdus de la tastatură:
- 6x + 20 , dacă x  [-  , -7 ]
f(x) = x + 30 , dacă x  (-7, 0]
x , dacă x>0
3. Se citeşte un caracter reprezentând un operator aritmetic binar simplu. În funcţie de caracterul
citit, se afişează numele operaţiei pe care acesta o poate realiza.
4. Să se calculeze suma şi produsul primelor n numere naturale, n fiind introdus de la tastatură.
Se vor exemplifica modalităţile de implementare cu ajutorul instrucţiunilor do-while,
n n
while, şi for. (Se observă că: S=  k , P =  k ).
k 1 k 1
5. Să se citească un numar natural n. Să se scrie un program care afişează dacă numărul n citit
reprezintă sau nu, un an bisect (anii bisecţi sunt multipli de 4, exceptând multiplii de 100, dar
incluzând multiplii de 400).
6. Să se citească un şir de numere reale, până la întâlnirea numărului 900. Să se afişeze maximul
numerelor citite.
7. Să se citească un şir de numere reale, până la întâlnirea numarului 800 şi să se afişeze
valoarea minimă introdusă, suma şi produsul elementelor şirului.
8. Să se scrie un program care calculează şi afişează maximul a 3 numere reale (a, b şi c) citite
de la tastatură.
9. Să se afişeze literele mari ale alfabetului şi codurile aferente acestora în ordine crescătoare,
iar literele mici şi codurile aferente în ordine descrescătoare. Afişarea se va face cu pauză
după fiecare ecran.
10. Să se calculeze seria următoare cu o eroare mai mică decât EPS (EPS introdus de la

xk
tastatură): 1+  , x  [0,1], x citit de la tastatură. Vom aduna la sumă încă un termen cât
k 1 k
timp diferenţa dintre suma calculată la pasul curent şi cea calculată la pasul anterior este mai
mare sau egală cu EPS.
Laborator 7

Instructiuni de ciclare cu post-testare si instructiuni intercalate

Do-While

In cazul instructiunii do-while testarea conditiei de continuare are loc dupa blocul de
intructiuni. De exemplu, pentru validarea unor date de intrare putem folosi:

do
citire date de la tastura
while datele de intrare sunt corecte

Exemplul 7-1

#include <iostream>
using namespace std;
int main()
{
int monthNum;
do
{
cout <<"Introduceti o luna (numar intre 1 si 12) -- >";
cin >> monthNum;
if (monthNum <1 || monthNum >12) cout <<"Eroare! Luna introdusa
nu este corecta!\n";
}
while (monthNum <1 || monthNum >12);
return 0;
}

Instructiuni de ciclare intercalate

Exemplul 7-2 – Tabla inmultirii cu 2

#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
int tableFor =2;
int multiplier=1;
while (multiplier <=12)
{
cout << setw(3)<<tableFor << " x " <<setw(3)<< multiplier
<< " = " << setw(4)<<tableFor * multiplier <<endl;
multiplier ++;
}
getchar();
return 0;
}
Urmatorul exemplu afiseaza tabla inmultirii pentru toate numerele intre 2 si 10.

Exemplul 7-3

#include <iostream>
#include<iomanip>
using namespace std;
int main()
{
int tableFor =2;
int multiplier=1;
while (tableFor <= 10)
{
while (multiplier <=12)
{
cout << setw(3)<<tableFor << " x " <<setw(3)<<
multiplier << " = " << setw(4)<<tableFor * multiplier
<<endl;
multiplier ++;
}
cout << endl;
multiplier =1; //se reseteaza pentru urmtoarea iteratie
tableFor++;
}
getchar();
return 0;
}

Acelasi program se poate scrie folosind instructiunea for:

#include <iostream>
#include<iomanip>
using namespace std;
int main()
{
int tableFor;
int multiplier;
for (tableFor = 2;tableFor <=10;tableFor++)
{
for (multiplier =1; multiplier <= 12; multiplier++)
cout << setw(3)<<tableFor << " x " <<setw(3)<<
multiplier << " = " << setw(4)<<tableFor * multiplier
<<endl;
cout << endl;
}
getchar();
return 0;
}

Exercitiul 7-1

Sa se scrie un program care sa citeasca o matrice de n*m (unde n si m se citesc de la

tastatura) si sa calculeze suma tuturor elementelor matricei.
Introduceti numarul de linii (n)  2
Introduceti numarul de coloane (m)  3
Introduceti elementul de pe pozitia (1,1)  1
Introduceti elementul de pe pozitia (1,2)  0
Introduceti elementul de pe pozitia (1,3)  4
Introduceti elementul de pe pozitia (2,1)  2
Introduceti elementul de pe pozitia (2,2)  3
Introduceti elementul de pe pozitia (2,3)  1
Suma elementelor este: 11

Exercitiu propus 7-1

Sa se scrie un program C care sa calculeze costul salarial (= suma tuturor salariilor) pentru mai
multor persoane care lucreaza un numar oarecare de zile.

Exemplu:

Introduceti numarul de persoane --> 3

Introduceti numele salariatului 1 --> Maria

Introduceti venit/ora --> 10
Introduceti numarul de zile lucrat --> 4.
Indroduceti numarul de ore lucrat in ziua 1 --> 8
Indroduceti numarul de ore lucrat in ziua 2 --> 7
Indroduceti numarul de ore lucrat in ziua 3 --> 9
Indroduceti numarul de ore lucrat in ziua 4 --> 10

Introduceti numele salariatului 2 --> Dan

Introduceti venit/ora --> 11
Introduceti numarul de zile lucrat --> 3.
Indroduceti numarul de ore lucrat in ziua 1 --> 5
Indroduceti numarul de ore lucrat in ziua 2 --> 7
Indroduceti numarul de ore lucrat in ziua 3 --> 11

Introduceti numele salariatului 3 --> Anca

Introduceti venit/ora --> 9
Introduceti numarul de zile lucrat --> 4.
Indroduceti numarul de ore lucrat in ziua 1 --> 4
Indroduceti numarul de ore lucrat in ziua 2 --> 9
Indroduceti numarul de ore lucrat in ziua 3 --> 8
Indroduceti numarul de ore lucrat in ziua 4 --> 8

Numarul total de ore lucrate : 86

Cost salarial : 854
Laborator 8

Functii

Atunci cand scriem un program, in orice limbaj de programare, e bine sa il impartim pe

module, iar fiecare modul sa indeplineasca o anumita functie. Un modul/functie bine scris
poate fi folosit de mai multe ori in cadrul aceluiasi program sau in programe diferite.

Exemplul 8-1

/***************************************
Program: Apelare functie
**************************************/
#include <iostream>
using namespace std;

float celsius(float); //prototipul functiei

int main ()
{
float c, f; //Grade Celsius and Fahrenheit
cout << "Introduceti temperature in grade Fahrenheit ";
cin >> f;
c = celsius(f); //apelarea functiei
cout << "Asta inseamna " << c << " grade Celsius!\n" ;
cout << “Apasati Enter pentru a se iesi din program!”;
getchar();
return 0;
}

float celsius (float f) //declararea functiei

{
return ((f-32)*5/9);
}

Pentru a putea folosi o functie, mai intai, trebuie declarat prototipul acesteia. Acesta se
gaseste intotdeauna inaintea functiei main. Prototipul contine urmatoarele informatii: (1)
numele functiei, (2) tipul de data retunat de functie, (3) numarul, tipul si ordinea
parametrilor functiei.

Declararea functiei (adica ceea ce face functia) se face dupa main.

Exercitiu propus

Sa se scrie un program cu o functie care sa calculeze a la puterea b unde a si b se citesc de la

tarstatura si sunt numere intregi.
Laborator 9

Functii (II)

Domeniul de valabilitate al variabilelor

Intr-un program pot exista mai multe variabile cu acelasi nume in diferite functii. Exista
cateva reguli de care trebuie sa tinem seama in astfel de situatii pentru a intelege
domeniul de valabilitate al fiecarei variabile.

Exemplul 9-2

/*****************************
Program: Domeniul de valabilitate
*****************************/
#include <iostream>
using namespace std;

void schimbarex (int);

int main ()
{
int x;
x = 5;
cout << "In main, valoarea lui x inainte de prima apelare ----> "
<< x <<"\n";
schimbarex (x);
cout << " In main, valoarea lui x dupa prima apelare -----> " <<
x <<"\n";
x = 1;
cout << " In main, valoarea lui x inainte de a doua apelare ---->
" << x <<"\n";
schimbarex (x);
cout << " In main, valoarea lui x dupa a doua apelare -----> " <<
x <<"\n";
return 0;
}

void schimbarex (int x)

{
cout << " in functie, valoarea lui x la intrare este----> " << x
<< "\n";
x = x+10;
cout << " in functie, valoarea lui x la iesire este---> " << x <<
"\n";
}

Cand rulam acest program observam ca lui x i se atribuie mai intai valoarea 5 si ca
aceasta valoare este trecuta in functia schimbarex. Variabila x este modificata in functie
si devine 15. Totusi, dupa ce functia este executa, tot ce s-a intamplat in functia
schimbarex este sters si x are valoarea 5. La fel se intampla si pentru a doua apelare a
functiei.
Cand o functie este apelata si copii ale parametrilor sunt transmisi in functie se cheama ca
transmiterea parametrilor se face prin valoare (call-by-value). O alta posibilitate o
reprezinta apelarea functiei prin referinta (call-by-reference) in care se transmite adresa
variabilei nu doar o copie a valorii acesteia.

Variabile globale

O variabila care poate fi accesata de toate functiile unui program se numeste variabila
globala.

Exemplul 9-3

/*****************************************
Program: Variabile globale
******************************************/
#include <iostream>
using namespace std;

int x;

void getvalue ();

int main ()
{
x = 1;
getvalue();
cout << "Valoarea lui x este: " << x <<"\n";
return 0;
}

void getvalue()
{
cout << "Introduceti o valoare pentru x ";
cin >> x;
}

Observatie: daca modificam o variabila globala intr-o functie, acest lucru se va reflecta
si in alte functii in care se foloseste variabila respectiva. De aceea, folosirea variabilelor
globale trebuie, pe cat posibil evitata.

Variabile locale

Sa presupunem ca avem o variabila globala x si ca declaram o variabila x intr-o functie.

Care variabila se modifica daca atribuim o valoare lui x?

Exemplul 9-4

/*****************************
Program: Variabile locale
*****************************/
#include <iostream>
using namespace std;

int x;

void getvalue ();

int main ()
{
x =1;
getvalue();
cout << "Valoarea lui x este: " << x <<"\n";
return 0;
}

void getvalue()
{
int x;
cout << "Introduceti o valoare pentru x ";
cin >> x;
}

Asadar, in acest program avem o variabila global x si o variabila locala tot x. Atunci cand
atribuim lui x o valoare in functia getvalue (unde x este variabila locala), valoarea
variabilei globale x nu se modifica.

Exercitiul 9-1

Sa se scrie si sa se apeleze of functie care verifica daca un numar este par sau impar.

Exercitiul 9-2

Sa se scrie si sa se apeleze o functie care calculeaza divizorii unui numar citit de la

tastatura.

Exercitiu propus

Sa se scrie un program C cu 2 functii, una care citeste 2 valori de tip intreg, iar cea de a doua
care interschimba cele doua valori daca prima valoare este mai mare decat cea de a doua.

Exemplu:

Introduceti 2 valori 90 80
Valorile sunt --> 90 80
Dupa interschimbare --> 80 90

Introduceti 2 valori 40 50
Valorile sunt --> 40 50
Interschimbarea nu este necesara.
Laborator 10

Functii (III)

O functie este un subprogram care executa o actiune specifica. O functie poate primi
zero, unul sau mai multi parametrii si poate intoarce una sau nici o valoare.

Sa consideram urmatorul prototip de functie:

float calcMedie (int nota1, int nota2, int nota3)

Functia calcMedie primeste 3 parametrii de intrare si returneaza o valoare. Parametrii

sunt transmisi prin valoare (call-by-value) ceea ce inseamna ca copii ale variabilelor
originale sunt trecute in cadrul functiei. Chiar daca valorile acestor variabile sunt
schimbate in cadrul functiei, variabilele originale raman neschimbate.

Daca o functie nu intoarce nici un rezultat acest lucru este specificat prin cuvantul
rezervat void.

De retinut este faptul ca functia exista doar atat timp cat se executa. Dupa ce se termina
executia functiei, aceasta si toate variabilele folosite in functie nu vor mai exista.

Pentru a apela functia se poate scrie urmatoarea instructiune:

medie = calcMedie(nota1, nota2, nota3);

Din moment ce functia returneaza o valoare de tip float, putem salva valoarea returnata in
variabila medie. Mai simplu, rezultatul poate fi afisat pe ecran folosind intructiunea:

cout << calcMedie(nota1, nota2, nota3);

Este de multe ori necesar folosim functii care sa citeasca valorile mai multor variabile si
sa le returneze in programul principal. Folosind transferul prin valoare (call-by-value)
acest lucru nu este posibil.

In loc de aceasta, transferul parametrilor se poate face prin referinta. In acest caz, in loc
ca functia sa intoarca un rezultat, scrie in variabilele care au fost trimse in functie (prin
referinta) . In exemplul urmator, chiar daca functia nu returneaza o valoare, apelarea
functiei are ca rezultat modificarea valorii celor trei parametrii:

void citesteNote (int &nota1, int &nota2, int &nota3)

Sa presupunem ca dorim sa scriem un program care sa calculeze media a trei note.

Programul poate avea trei functii: citesteNote, calcMedie si afisare.
Exemplul 10-1

/*************************************
Program ce calculeaza media a trei note
**************************************/
#include <iostream>
using namespace std;

void citesteNote (int&, int&,int&); //prototipuri

float calcMedie (int, int, int );
void afisare (int, int, int, float);

int main ()
{
float medie;
int nota1, nota2, nota3;
citesteNote(nota1, nota2, nota3);
medie = calcMedie(nota1, nota2, nota3);
afisare(nota1, nota2, nota3, medie);
getchar();
getchar();
return 0;
}
void citesteNote (int &c, int &b, int &a) // schimbare de nume a
variabilelor
{
cout << "Introduceti prima nota ----------> ";
cin >> c;
cout << "Introduceti a doua nota -----------> ";
cin >> b;
cout << "Introduceti a treia nota ---------- > ";
cin >> a;
}
float calcMedie (int unu, int doi, int trei) // schimbare de nume a
variabilelor
{
int total;
float a;
total = unu+doi+trei;
a = (total)/3.0;
return a;
}

void afisare (int nota1, int nota2, int nota3, float medie)
{
cout << "\nCele trei note sunt: " << nota1 << " " <<nota2 << " "
<< nota3;
cout << "\nMedia este " << medie <<endl;
}
Exemplul 10-2

/*************************************
Program ce calculeaza media a trei note
**************************************/
#include <iostream>
using namespace std;

void citesteNote (int&, int&,int&); //pro

float calcMedie (int a, int b, int c)
{
return (a+b+c)/3.0;
};
void afisare (int, int, int, float);

int main ()
{
float medie;
int nota1, nota2, nota3;
citesteNote(nota1, nota2, nota3);
medie = calcMedie(nota1, nota2, nota3);
afisare(nota1, nota2, nota3, medie);
getchar();
getchar();
return 0;
}
void citesteNote (int &c, int &b, int &a) // schimbare de nume a
variabilelor
{
cout << "Introduceti prima nota ----------> ";
cin >> c;
cout << "Introduceti a doua nota -----------> ";
cin >> b;
cout << "Introduceti a treia nota ---------- > ";
cin >> a;
}

void afisare (int nota1, int nota2, int nota3, float medie)
{
cout << "\nCele trei note sunt: " << nota1 << " " <<nota2 << " "
<< nota3;
cout << "\nMedia este " << medie <<endl;
}

Supraincarcarea functiilor

Este posibil ca o functie care calculeaza media unor numere reale si sa returneze o
valoare reala si sa calculeze media a unor numere intregi si sa returneze o valoare
intreaga. Pentru a realize acest lucru trebuie sa declaram 2 functii cu acelasi nume dar cu
parametri diferiti. Aceste functii se numesc functii supraincarcate (overloaded). Atunci
cand o functie supraincarcata este apelata, compilatorul alege functia potrivita in functie
de parametrii cu care se apeleaza functia.
Exemplul 10-3

#include <iostream>
using namespace std;

double calcMed(int, int, int);

double calcMed(double,double,double);
double calcMed(double,double,double,double);

int main ()
{
double medie;
//se apeleaza calcMed cu trei parametrii de tip intreg
medie = calcMed(80,82,95);
cout << "\n S-a apelat functia cu trei intregi. Media este: "
<<medie;
//se apeleaza calcMed cu trei parametrii de tip double
medie = calcMed(82.5,89.4,95.88);
cout << "\n S-a apelat functia cu trei valori de tip double.
Media este: " <<medie;
//se apeleaza calcMed cu patru parametrii de tip double
medie = calcMed(82.5,89.4,95.88, 99.89);
cout << "\n S-a apelat functia cu patru valori de tip double.
Media este: " <<medie;
getchar();
return 0;
}

double calcMed(int a, int b, int c)

{
return (a+b+c)/3.0;
}
double calcMed(double a, double b, double c)
{
return (a+b+c)/3.0;
}
double calcMed(double a, double b, double c, double d)
{
return (a+b+c+d)/4.0;
}

Exercitiu 10-1

Sa se scrie un program cu o functie supraincarcata care sa calculeze media armonica

(http://en.wikipedia.org/wiki/Harmonic_mean ) pentru valori de tip intreg si pentru valori
de tip float.

Exercitiu 10-2

Sa se scrie un program cu o functie supraincarcata care sa calculeze media patratica

(http://en.wikipedia.org/wiki/Quadratic_mean) pentru valori de tip intreg, float si double.
Exercitiu propus

Sa se scrie un program care implementeaza functia putere si sa se apeleze atat pentru

valori de tip intreg cat si pentru valori de tip float.

Exemplu de apelare:

int x = putere (2,3); // x va lua valoarea 8

float y = putere (2.1, 2) // y va lua valoarea 4.2

Exercitii facultative

1. Sa se corecteze erorile de compilare din urmatorul program:

#include <iostream>
using namespace std;

double calcMed(int, int, int)

int main ()
{
double medie;
medie = calcMed(80,82,95);
cout << "\nMedia este: " <<medie;
getchar();
return 0;
}

double calcMed(int a, int b, int c)

{
return (a+b+c)/3.0;
}

2. Sa se corecteze erorile de compilare din urmatorul program:

#include <iostream>
using namespace std;

double calcMed(int, int, int);

int main ()
{
double medie;
medie = calcMed(80,82,95);
cout << "\nMedia este: " <<medie;
getchar();
}

double calcMed(int a, int b, int c)

{
 return (a+b+c)/3.0;
}

3. Sa se corecteze erorile de compilare din urmatorul program:

#include <iostream>
using namespace std;

double calcMed(int, int, int);

int main ()
{
double medie;
medie = calcMed(80.5,82,95);
cout << "\nMedia este: " <<medie;
getchar();
return 0;
}

double calcMed(int a, int b, int c)

{
return (a+d+c)/3.0;
}

4. Sa se adauge la urmatorul programul corectat in cadrul exercitiilor 1,2 si 3 o

functie care calculeaza produsul celor 3 valori.
5. Sa se modifice functia de la exercitiul 4 astfel incat sa se faca produsul celor 3
valori numai daca toate sunt pozitive.
6. Sa se scrie un program care citeste un numar intreg pozitiv de la tastatura si il
transforma intr-un numar binar. Citirea numarului si transformarea sa se faca in
cadrul unor functii.
Laborator 11

Siruri (Arrays)
Un sir (array) este folosit pentru a stoca si procesa o colectie de date de acelasi
tip. E important de retinut ca un sir poate lucra doar cu date de acelasi tip; un sir nu poate
stoca date de tipuri diferite (asa cum este cazul pentru structuri). Un sir mai poate fi
numit “lista”.

Declararea sirurilor

Un sir este de fapt o lista statica pentru care trebuie sa specificam din momentul
declararii dimensiunea. Pentru a declara un sir care sa poata stoca 90 de valori de tip
intreg vom scrie:

int sir[90];

Desi am declarat sirul ca avand dimensiune de 90, nu este neaparat sa stocam 90 de

valori. Putem de exemplu sa stocam doar 50 sau 60. Dar, in sirul declarat nu putem stoca
mai mult de 90 de valori.

Exemplul 11-1

#include <iostream>
using namespace std;
int note[90]; //sirul este declarat global.
int getnote (void);
int main ()
{
int n, i; // n este numarul de note
n = getnote(); //se citesc notele si se intoarce in n numarul de
// note citite
for (i=1; i<=n; i++)
cout<<note[i]<<endl; //afisarea notelor.
getchar();
getchar();
return(0);
}
int getnote()
{
int n=1;
cout << "Introduceti un numar si apasati Enter. Pentru a iesi
introduceti un numar negativ!\n";
cout << "Introduceti nota# " << n << " ";
cin >> note[n];
while (note[n] >= 0)
{
n++;
cout << "Introduceti nota# " << n <<" ";
cin >> note[n];
 }
return n-1;
}

Folosirea sirurilor ca parametrii

Un sir poate fi trimis ca si parametru in cadrul unei functii. Mai intai, prototipul
functiei trebuie sa indice ca parametru trimis este un sir/array, fara sa se specifice
dimensiunea sirului. Functia este declarata in mod similar.

Exemplul 11-2

#include <iostream>
using namespace std;

int getnote (int note[]); //prototipul functiei

int main ()
{
int note[90];
int n, i; // n este numarul de note
n = getnote(note); //se citesc notele si se intoarce in n numarul
de note citite
for (i=1; i<=n; i++)
cout<<note[i]<<endl; //afisarea notelor.
getchar();
getchar();
return(0);
}
int getnote(int note[])
{
int n=1;
cout << "Introduceti un numar si apasati Enter. Pentru a iesi
introduceti un numar negativ!\n";
cout << "Introduceti nota# " << n << " ";
cin >> note[n];
while (note[n] >= 0)
{
n++;
cout << "Introduceti nota# " << n <<" ";
cin >> note[n];
}
return n-1;
}

Este important de subliniat ca trecerea parametrului note nu se face nici prin

valoare (call-by-value), nici prin referinta (call-by-reference), ci intr-un mod care este
specific sirurilor. Asadar atunci cand se trimite sirul ca parametru, nu se face o copie a
sirului si nici nu se trimite cate o referinta pentru fiecare pozitie din sir. In loc de acestea
se trimite locatia de memorie a primului element din sir. De aceea, nu este necesar sa se
trimita dimensiunea sirului.
Exemplul 11-3

In exemplele care urmeaza vom scrie un program care sa calculeze deviatia standard
(http://en.wikipedia.org/wiki/Standard_deviation). Aceasta se realizeaza in urmatorii
pasi:
1. Se calculeaza media tututor elementelor sirului.
2. Se calculeaza diferenta fata de medie a tuturor elementelor sirului.
3. Se ridica la patrat diferentele.
4. Se calculeaza suma valorilor calculate la punctul 3.
5. Se imparte suma la numarul de elemente minus unul.
6. Se calculeaza radical din din valoarea rezultata la punctul 5.

1. Se calculeaza media tututor elementelor sirului.

#include <iostream>
using namespace std;
int getnote (int note[]);
float calcMedie (int note[], int);
void afisare(int, int note[], float);

int main ()
{
int note[90];
int n;
float medie;
n = getnote(note);
medie = calcMedie(note, n);
afisare(n,note,medie);
return(0);
}

int getnote(int note[])

{
int n=1;
cout << "Introduceti un numar si apasati Enter. Pentru a iesi
introduceti un numar negativ!\n";
cout << "Introduceti nota# " << n << " ";
cin >> note[n];
while (note[n] >= 0)
{
n++;
cout << "Introduceti nota# " << n <<" ";
cin >> note[n];
}
return n-1;
}

float calcMedie(int note[], int n)

{
int sum=0;
 int i;
float m;
for (i=1; i <=n; i++) sum += note[i];
m = float(float(sum)/n);
return m;
}

void afisare (int n, int note[], float medie)

{
int i;
cout << n<< " note au fost introduse. Acestea sunt: \n";
for (i=1; i<=n; i++)
cout<<note[i]<<endl;
cout << "Media este: "<<medie <<endl;
}

Exemplul 11-4

2. Se calculeaza diferenta fata de medie a tuturor elementelor sirului.

3. Se ridica la patrat diferentele.
4. Se calculeaza suma valorilor calculate la punctul 3.
5. Se imparte suma la numarul de elemente minus unul.
6. Se calculeaza radical din din valoarea rezultata la punctul 5.

#include <iostream>
#include <iomanip>
#include <math.h>
using namespace std;
int getnote (int note[]);
float calcMedie (int note[], int);
float sumPatrate (int, int note[], float dif[], float difPtr[],float);
float stdDeviere(int, float);
void tabel(int, int note[], float dif[], float difPtr[], float, float);

int main ()
{
int note[90];
float dif[90], difPtr[90];
int n;
float medie, sumPtr, stDev;
n = getnote(note);
medie = calcMedie(note, n);
sumPtr = sumPatrate (n, note,dif,difPtr,medie);
stDev = stdDeviere(n, sumPtr);
tabel(n, note, dif,difPtr, medie, stDev);

getchar();
getchar();
return(0);
}

int getnote(int note[])

{
int n=1;
 cout << "Introduceti un numar si apasati Enter. Pentru a iesi
introduceti un numar negativ!\n";
cout << "Introduceti nota# " << n << " ";
cin >> note[n];
while (note[n] >= 0)
{
n++;
cout << "Introduceti nota# " << n <<" ";
cin >> note[n];
}
return n-1;
}

float calcMedie(int note[], int n)

{
int sum=0;
int i;
float m;
for (i=1; i <=n; i++) sum += note[i];
m = float(float(sum)/n);
return m;
}

float sumPatrate (int n, int note[], float dif[], float difPtr[],float

medie)
{
int i; float ss=0.0;
for (i=1; i <=n; i++)
{
dif[i] = note[i]- medie;
difPtr[i] = dif[i] * dif[i];
ss += difPtr[i];
}
return ss;
}

float stdDeviere(int n, float sumPtr)

{
float var;
var = sumPtr/(n-1);
return (float(sqrt(var)));
}

void tabel(int n, int note[], float dif[], float difPtr[], float medie,
float stDev)
{
int i; float ss=0;
cout << "\nDeviatia standard pentru " << n<<" note. Media:
"<<medie
<<endl;
cout <<"---------------------------------------------------\n";
cout <<setw(10) <<"Note"<<setw(10) <<"Dev" <<setw(10) << "Dev
Ptr"
<<" Suma dev2)\n";
cout <<"-----------------------------------------------------\n";
 for (i = 1; i<=n; i++)
{
ss += difPtr[i];
cout << setw(10) << setprecision(2) << note[i]
<< setw(10) << setprecision(2) << dif[i]
<< setw(10) << setprecision(2) << difPtr[i]
<< setw(10) << setprecision(2) << ss << endl;
}
cout <<"-----------------------------------------------------\n";
cout <<"Deviatia standard "<< setprecision(2) <<stDev <<endl;
}

Exercitiu 11-1

Sa se scrie un program care sa citeasca 10 valori de tip intreg de la tastatura. Sa se afiseza

indexul/pozitia elementului din sir cu valoarea cea mai mare.

Exercitiu 11-2

Sa se scrie un program care sa citeasca 10 valori de tip intreg de la tastatura si o valoare

suplimentara V. Programul trebuie sa verifice daca valoarea V exista printre elementele
sirului, iar daca exista sa se mute toate elementele din dreapta elementului spre stanga cu
o pozitie.

Exercitiu propus 11-1

Sa se scrie un program care tranforma un numar intre 0 si 20000 in cuvinte. Programul

trebuie sa foloseasca siruri in care sa se pastreze cuvinte ca “unu”, “doi”, “trei”, etc.

Exemplu:

Sa se introduca un numar mai mic de 20000: 18975

Numarul este: 18975

In cuvinte: optsprezece mii noua sute sapte zeci si cinci.

Exercitii facultative

1. De citit: http://www.augustcouncil.com/~tgibson/tutorial/arr.html
2. Sa se scrie un program care sa citeasca 10 valori de tip intreg de la tastatura. Sa se
afiseze elementele mai mari de 5.
3. Sa se scrie un program care sa citeasca 10 valori de tip intreg de la tastatura si o
valoare suplimentara V. Programul trebuie sa verifice daca valoarea V exista
printre elementele sirului si sa afiseze rezultatul.
4. Sa se scrie un program care sa citeasca 10 valori de tip intreg. Sa se sorteze sirul
si sa se afiseze.
Laborator 12

Sortare
Una din cele mai importante proprietati pe care le are un sir (array) este ca acesta
poate fi sortat. Sortarea este procesul prin care fiecare valoare din sir este arajant / asezat
in ordine crescatoare sau descrescatoare.
Sortarea se poate programa in multe moduri, din acestea studiem sortarea prin
selectie si bubble sort.
In programul de mai jos (12-1), sortare se face prin doua bucle, prima in functia
sortare, iar cea de a doua in gasireMinim.

Exemplul 12-1 – Sortare prin selectie

#include <iostream>
using namespace std;
int citireNote (int note[]);
int gasireMinim(int note[],int, int);
void sortare(int note[], int);
void afisare(int note[], int);

int main ()
{
int note[90];
int ultim; // numarul de note citite.
ultim = citireNote(note); //se citesc notele
cout <<"\nSirul nesortat este:\n";
afisare(note,ultim);
sortare(note, ultim);
cout <<"\nSirul sortat este:\n";
afisare(note,ultim);
getchar();
getchar();
return(0);
}

int citireNote(int note[])

{
int ultim=1;
cout << "Sa se introducs notele.\n";
cout << "Nota# " << ultim << " ";
cin >> note[ultim];
while (note[ultim] >= 0)
{
ultim++;
cout << "Nota# " << ultim <<" ";
cin >> note[ultim];
}
return ultim-1;
}

int gasireMinim(int note[],int prim, int n)

{
int i, min=prim;
for (i=min; i<=n; i++)
if (note[i] < note[min]) min=i;
return min;
}

void sortare(int note[], int ultim)

{
int index;
int tmp, i;
for (i=1; i<ultim; i++)
{
index = gasireMinim(note, i, ultim);
tmp = note[i];
note[i] = note[index];
note[index]= tmp;
}
}

void afisare(int note[], int n)

{
int i;
for (i=1; i<=n; i++)
cout << note[i] <<endl;
}

Algoritmul de sortare prin selectie are cateva dezavantaje, unul din acestea fiind
faptul ca nu se detecteaza daca sirul este gata sortat inainte de incepe operatiunea de
sortare.
O alta metoda de a sorta un sir o reprezinta bubble sort. Acest algoritm presupune
compararea a doua elemente vecine din cadrul sirului si interschimbarea lor daca este
cazul.

Exemplul 12-2 – Bubble sort

#include <iostream>
using namespace std;
int citireNote (int note[]);
void sortare(int note[], int);
void afisare(int note[], int);

int main ()
{
int note[90];
int ultim; // numarul de note citite.
ultim = citireNote(note); //se citesc notele
cout <<"\nSirul nesortat este:\n";
afisare(note,ultim);
sortare(note, ultim);
cout <<"\nSirul sortat este:\n";
afisare(note,ultim);
getchar();
getchar();
return(0);
}

int citireNote(int note[])

{
int ultim=1;
cout << "Sa se introducs notele.\n";
cout << "Nota# " << ultim << " ";
cin >> note[ultim];
while (note[ultim] >= 0)
{
ultim++;
cout << "Nota# " << ultim <<" ";
cin >> note[ultim];
}
return ultim-1;
}

int gasireMinim(int note[],int prim, int n)

{
int i, min=prim;
for (i=min; i<=n; i++)
if (note[i] < note[min]) min=i;
return min;
}

void sortare(int note[], int n)

{
int i, tmp;
bool cont;
do
{
cont = false;
for (i = 1; i <n; i++)
{
if (note[i] > note [i+1])
{
tmp = note[i];
note[i] = note[i+1];
note[i+1] = tmp;
cont = true;
}
}
n = n-1;
}while (cont);
}

void afisare(int note[], int n)

{
int i;
for (i=1; i<=n; i++)
cout << note[i] <<endl;
}

Exercitiul 12-1
Sa se rescrie procedura de sortarea de la Exemplul 12-2 astfel incat sa se foloseasca doua
instructiuni for.

Exercitiul 12-2

Sa se modifice Exemplul 12-2 astfel incat sa se sorteze date de tip string.

Exercitiu 12-1

Sa se scrie un program stocheaza (citeste de la tastatura) intr-un sir/array numele unor

studenti si in altul notele corespunzatoare pentru o materie oarecare. Sa se sorteze sirul cu
numele studentilor si sa se modifice sirul notelor astfel incat sa se pastreze corespondenta
student-nota.

Exemplu:

Se citesc:

Popescu Ion – 10
Ionescu Pop – 7
Oprea Vasile - 9

Sirul studentilor inainte de sortare este: Popescu Ion, Ionescu Pop,

Oprea Vasile
Sirul notelor inainte de sortare este: 10, 7, 9

Sirul studentilor dupa sortare este: Ionescu Pop, Oprea Vasile, Popescu
Ion
Sirul notelor inainte de sortare este: 7, 9, 10
Laborator 13

Recapitulare

Exercitii

1. Sa se corecteze erorile de compilare din urmatorul program:

#include <iostream>
using namespace std;

double calcMed(int, int, int)

int main ()
{
double medie;
medie = calcMed(80,82,95);
cout << "\nMedia este: " <<medie;
getchar();
return 0;
}

double calcMed(int a, int b, int c)

{
return (a+b+c)/3.0;
}

2. Sa se scrie o functie care sa primeasca un parametru de tip intreg si care sa

intoarca “true” daca numarul este prim si “false” daca acesta nu este. Numarul
introdus trebuie sa fie intre 1 si 1000.
3. Sa se scrie un program care afiseaza o piramida.

Introduceti inaltimea piramidei: 4

**
****
******
********

4. Să se scrie un program care citeşte câte două numere, până la întâlnirea perechii
de numere 0, 0 şi afişează, de fiecare dată, cel mai mare divizor comun al
acestora, folosind o funcţie care îl calculează.
5. Se introduce de la tastatura un număr întreg. Să se afişeze toţi divizorii numărului
introdus. Se va folosi o funcţie de calcul a celui mai mare divizor comun a 2
numere.
6. Scrieţi o funcţie găseşte_cifra care returnează valoarea cifrei aflate pe poziţia k în
cadrul numărului n, începând de la dreapta (n şi k vor fi argumentele funcţiei).
7. Să se scrie un program care generează toate numerele palindrom, mai mici decât o
valoare dată, LIM. Un număr palindrom are cifrele simetrice egale (prima cu
 ultima, a doua cu penultima, etc). Se va folosi o funcţie care testează dacă un
număr este palindrom.
8. Sunt urmatoarele programe echivalente?

#include <iostream>
using namespace std;

int main()
{
int count = 1;
for (; count <= 5 ; count++)
{
int count = 1;
cout << count << "\n";
}
return 0;
}

#include <iostream>
using namespace std;

int main()
{
int count = 1;
while (count <= 5)
{
int count = 1;
cout << count << "\n";
count++;
}
return 0;