MARIUS TOMESCU CARMEN FIFOR

Programarea calculatoarelor
Introducere n C#



Editura Universitii Aurel !laicu" Arad
# $%&% #

Prefa
C# este un limbaj de programare de nivel nalt, orientat obiect, care face parte din tehnologia
software .Net, i repreint un pas important n evoluia limbajelor de programare. !ulte firme
recurg la limbajul C# n procesele de implementare i devoltare software deoarece ofer un foarte
bun suport pentru tehnologiile de v"rf.
Cursul de fa cuprinde at"t noiunile de ba ale limbajului C#, c"t i unele elemente de nivel
mediu i avansat. Cursul poate fi un instrument util pentru nsuirea i consolidarea cunotinelor
pentru oricine dorete s neleag i s fie iniiat ntr#un limbaj de programare. $rimele ase
capitole cuprind noiuni de ba ale limbajului C#% tipuri de date i instruciuni elementare, care au
rolul de a iniia studentul n limbajul de programare C# aduc"ndu#l la un nivel mediu, noiuni
introductive despre clase i folosirea fiierelor. &ltimul capitol '$()*+,!, (,-)+./0,1 are
un rol important n pregtire. 2n acest capitol sunt preentate i e3plicate n detaliu programe de
nivel mediu spre comple3, cu scopul de a clarifica noiunile fundamentale de programare C#,
e3plicaii menite a forma o g"ndire algoritmic riguroas.
4perm ca te3tul acestui curs s ofere o introducere plcut n programarea calculatoarelor i
limbajul C#. /m ncercat s preentm fiecare noiune ntr#o manier accesibil i interesant.
4copul acestui curs este de a va nva noiunile de ba ale programrii n C# i de realia
trecerea studentului de la un cunosctor al limbajului C# la un programator C#.
Cursul se adresea n primul r"nd studenilor din anul 5, celor care studia un curs
elementar sau academic de algoritmi, structuri de date i limbaje de programare.
Octombrie 2010 Autorii
CUPRINS
CAPITOLUL I. INTRODUCERE N LIMBAJUL C# ................... 7
6.6 Conceptele de ba ale limbajului C# ............................................................ 7
6.8 4tructura unui program C# ............................................................................. 7
6.9 !etodele unui clase ........................................................................................ :
6.; Comentarii .................................................................................................... 6<
6.= >eclaraii ...................................................................................................... 66
6.? *locuri de instruciuni .................................................................................. 66
6.7 5dentificatori ................................................................................................. 66
6.@ Cuvinte cheie ................................................................................................ 68
6.: 0ipuri de date ............................................................................................... 69
6.6< .ariabile ..................................................................................................... 6;
CAPITOLUL II. EXPRESII I OPERATORI .............................. 17
8.6 ,3presii ......................................................................................................... 67
8.8 )peratori aritmetici ...................................................................................... 67
8.9 )peratori de atribuire ................................................................................... 67
8.; )peratori relaionali ..................................................................................... 8<
8.= )peratori logici. )peratori logici la nivel de bii ......................................... 8<
8.? )peratorul condiional A% .............................................................................. 86
CAPITOLUL III. INSTRUCIUNI ................................................ !
9.8 5nstruciunea switch ...................................................................................... 89
9.9 5nstruciunea for ........................................................................................... 8;
9.; 5nstruciunea do#while .................................................................................. 8=
9.= 5nstruciunea while ....................................................................................... 8?
9.? 5nstruciunea foreach .................................................................................... 8?
9.@ 5nstruciunea continue .................................................................................. 9<
9.: 5nstruciunea goto ........................................................................................ 9<
9.6< 5nstruciunea return ..................................................................................... 98
CAPITOLUL I". TIPURI DE#INITE DE UTILI$ATOR .......... !!
;.6 0ipul enumerare ........................................................................................... 99
;.8 0ipul tablou ................................................................................................. 9;
;.9 Conversii numerice. ...................................................................................... 9?
CAPITOLUL ". CLASE % NOIUNI DE BA$& ......................... !'
=.6 Clasele. Noiuni de ba ............................................................................... 9:
=.8 C"mpuri ....................................................................................................... ;<
=.9 !etode ......................................................................................................... ;6
=.; Crearea variabilelor i instanelor unei clase ................................................ =9
=.= !embrii unei instane ................................................................................... =;
=.? !odificatori de acces .................................................................................. =;
=.7 /ccesul privat sau public ............................................................................. ==
CAPITOLUL "I. PROBLEME RE$OL"ATE ............................. ('
?.6 /+B)(50!5 ,+,!,N0/(5 ..................................................................... =:
?.8 .,C0)(5 ..................................................................................................... :<
?.9 !/0(5C5 ................................................................................................... 669
BIBLIO)RA#IE ............................................................................. 1(
CAPITOLUL I. INTRODUCERE N LIMBAJUL C#
1.1 C*+,e-.e/e 0e 1a2 a/e /341a56/63 C#
Ciecare nou limbaj de programare este influenat ntr#o anumit msur de limbaje de
programare deja e3istente. C# deriv direct din dou dintre cele mai de succes limbaje de
programare pe plan mondial i anume C 'inventat de ctre >ennis (itchie n anii D7<, rul"nd iniial
pe sistemul de operare &ni31 i CEE 'inventat de ctre *jarne 4troustrup n 6:7: pe baa limbajului
C, noutatea fundamental fiind introducerea programrii orientate spre obiecte1. >e asemenea, se
nrudete cu un alt limbaj mai nou i deopotriv de succes i anume limbajul Fava 'devoltat de
ctre firma 4un !icrosGstems ncep"nd cu anul 6::6, av"nd o sinta3 i o filoofie derivate din CE
E, contribuia fundamental fiind portabilitatea programelor, necesar odat cu devoltarea
diverselor sisteme de operare i a 5nternetului1.
Chiar dac Fava a reolvat cu succes multe din problemele legate de portabilitate n 5nternet,
C# a venit s reolve una din facilitile care i lipseau i anume interoperabilitatea limbajelor de
programare diferite, denumit i programare n limbaj mixt. /ceasta repreint posibilitatea
codului scris ntr#un anumit limbaj s lucree mpreun cu codul scris ntr#un alt limbaj, necesar n
special la crearea sistemelor software distribuite, de mari dimensiuni.
C# este un limbaj de programare orientat#obiect conceput de !icrosoft la sf"ritul anilor
D:<. /cesta fost conceput ca un concurent pentru limbajul Fava. C# este un derivat al limbajului de
programare CEE i a fost devoltat de o echip restr"ns de ingineri de la !icrosoft, echip din care
s#a evideniat /nders Hejlsberg 'autorul limbajului 0urbo $ascal i membru al echipei care a
proiectat *orland >elphi1. +imbajul C# este simplu, cu circa @< de cuvinte cheie, i 68 tipuri de
date predefinite. ,l permite programarea structurat, modular i orientat obiect, conform
preceptelor moderne ale programrii profesioniste.
+imbajul de programare C# a fost proiectat pe baa e3perienelor acumulate din celelalte
limbaje de programare. 2ntregul limbaj C# se baea pe conceptul de obiecte. 2n esen, structura
unui program scris n C# este g"ndit pe mai multe niveluri, aa cum se arat n figura urmtoare.
#376ra 1. +.r86+ -r*7ra4 C# 9*4 a9ea ,*0 0e -r*7ra4 :+ ,are ;e 0ef3+e;, metode< ,are ;6+. 3+,/6;e :+ clase<
,are /a r=+06/ /*r ;6+. 3+,/6;e :+ nume de spaii.
1. S.r6,.6ra 6+63 -r*7ra4 C#
&n program scris ntr#un limbaj de programare const din instruciuni n limba engle,
denumite cod surs. ) instruciune a unui limbaj de programare repreint o comand dat
7
calculatorului. 0otalitatea instruciunilor care descriu cum se reolv o anumit problem se
numete program. 4tructura unui program scris n limbajul C# este descris n figura urmtoare%
#376ra . S.r6,.6ra 6+63 -r*7ra4 ;,r3; :+ /341a56/ C#
&rmtorul program C# afiea pe ecran mesajul IHello Jorld KL%
#376ra !. E>e4-/6 0e -r*7ra4 C#
&n program C# este format din una sau mai multe clase, grupate ntr#un ;-a36 0e +64e
?+a4e;-a,e@. &n ;-a36 0e +64e este o colecie de clase care au asociat un nume. /cesta poate
cuprinde mai multe clase cu nume diferite av"nd funcionaliti nrudite. >ou clase pot avea
acelai nume cu condiia ca ele s fie definite n nume de spaii diferite. 2n cadrul aceluiai nume de
spaiu poate aprea definiia unui alt nume de spaiu, ca n care avem de#a face cu spaii de nume
imbricate. ) ,/a; poate fi identificat prin numele complet 'nume precedat de numele spaiului sau
spaiilor de nume din care face parte clasa respectiv, cu separatorul punct1. 2n e3emplul nostru,
4imple.$rogram este numele cu specificaie complet a clasei $rogram.
Codul i datele scrise n limbajul C# trebuie incluse ntr#o ,/a;. Nu se pot defini variabile i
nu se pot scrie declaraii nafara claselor. ) ,/a; este format din date i metode 'funcii1. 0oate
clasele deriv din clasa de ba denumit object. /pelarea unei metode n cadrul clasei n care a
fost definit aceasta presupune specificarea numelui metodei. /pelul unei metode definite n
interiorul unei clase poate fi invocat i din interiorul altei clase, ca n care este necesar
specificarea clasei i apoi a metodei separate prin punct. >ac n plus, clasa aparine unui spaiu de
@
nume neinclus n fiierul curent, atunci este necesar preciarea tuturor componentelor numelui%
spaiu.clas.metod sau spaiu.spaiu.clas.metod, etc.
2n programul nostru de mai sus se afl dou spaii de nume% unul definit 'S34-/e1 i unul
e3tern inclus prin directiva 6;3+7 SA;.e4B. C*+;*/e.Cr3.eL3+e repreint apelul metodei
Cr3.eL3+e definit n clasa C*+;*/e. Cum n spaiul de nume curent este definit doar clasa
Pr*7ra4, deducem c definiia clasei C*+;*/e trebuie s se gseasc n spaiul SA;.e4. /ltfel spus,
denumirea complet ar fi SA;.e4.C*+;*/e.Cr3.eL3+e, ceea ce ns, printre altele, ar fi incomod de
redactat dac apare adesea ntr#un program.
2n caul n care mai muli programatori lucrea la realiarea unei aplicaii comple3e, e3ist
posibilitatea de a segmenta aplicaia n mai multe fiiere numite a;;e41/3e;. 2ntr#un a;;e41/A se
pot implementa mai multe spaii de nume, iar pari ale unui aceeai spaiu de nume se pot regsi n
mai multe a;;e41/A86r3. $entru o aplicaie consol, ca i pentru o aplicaie Jindows de altfel, este
obligatoriu ca una 'i numai una1 dintre clasele aplicaiei s conin un D-6+,. 0e 3+.rareE ?e+.rA
-*3+.@< i anume 4e.*0a ?f6+,3a@ Ma3+.
4 comentm programul de mai sus%
/3+3a 1F spune compilatorului c acest program utiliea tipuri de date i clase incluse n spaiul
de nume SA;.e4. 2n caul nostru se va folosi clasa C*+;*/e.
/3+3a !% se declar un nou spaiu de nume, numit S34-/e. Noul spaiu de nume ncepe la acolada
deschis din linia ; i e3tinde p"n la acolada nchis din linia 68. )rice tip declarat n aceast
seciune este membru al spaiului de nume S34-/e.
/3+3a (F orice program C# este alctuit din una sau mai multe clase. 2n aceast linie este declarat
un nou tip de clas, denumit Pr*7ra4. )rice 4e41r33 declarai ntre acoladele care ncep n
linia ? i se termin n linia 66 sunt membrii care alctuiesc aceast clas.
/3+3a 7F n aceast linie este declarat 4e.*0a ?f6+,3a@ Ma3+ ca membru al clasei Pr*7ra4. 2n
acest program, metoda 'funcia1 Ma3+ este doar un membru al clasei Pr*7ra4. Ma3+ este o
funcie special utiliat de compilator ca D-6+,.6/ 0e 3+.rareE n program.
/3+3a 'F Conine doar o singur declaraie simplM aceast linie constituie NcorpulL f6+,3e3
Ma3+. /ceast declaraie folosete clasa numit C*+;*/e, amintit mai sus, care aparine
spaiului de nume SA;.e4 i este folosit pentru *-era33/e 0e 3+.rareG3eH3re. /ici se apelea
metoda Cr3.eL3+e din aceast clas, pentru afiarea mesajului dorit pe ecran. Cr folosirea
directivei din linia 6 # 6;3+7 SA;.e4 O compilatorul nu are de unde s tie unde se gsete clasa
C*+;*/e.
1.! Me.*0e/e 6+63 ,/a;e
) 4e.*0 este un bloc de cod format dintr#o serie de instruciuni care conduc la realiarea
unei aciuni. ) metod este asemntoare cu f6+,33/e< -r*,e06r3/e sau ;61r6.3+e/e din limbajul C,
CEE sau $ascal cu anumite e3cepii. ) 4e.*0 este o f6+,3e coninut nuntrul unei clase.
Me.*0a Ma3+?@
)rice aplicaie scris n limbajul C# trebuie s conin o metod numit Ma3+?@< care
repreint -6+,.6/ 0e 3+.rare :+ a-/3,a3e. 2n acest e3emplu metoda !ain'1 nu preia nici un
:
argument din linia de comand i nu returnea e3plicit un indicator de stare a terminrii
programului. 0oate liniile de cod care formea corpul metodei !ain'1 vor fi e3ecutate automat
atunci c"nd programul este rulat.
C/a;a C*+;*/e
Clasa C*+;*/e aparine de spaiul de nume SA;.e4. Cele dou metode 'funcii de afiare pe
ecran1 Cr3.e i Cr3.eL3+e afiea pe consol 'ecran1 argumentele din parante. 2n caul metodei
Cr3.eL3+e, dup afiare se trece la linie nou. &rmtoarea linie de cod este un e3emplu al utilirii
metodei Jrite%
Console.Write("Acesta este un text.");
P
Output string
Codul scris mai sus produce urmtoarea ieire pe ecran% Acesta este un text.
&n alt e3emplu este urmtorul cod, care afiea pe ecran trei iruri de caractere%
System.Console.Write ("This is text1.");
System.Console.Write ("This is text2.");
System.Console.Write ("This is text3.");
/cest cod produce urmtoarea ieire%
This is text1. This is text2. This is text3.
4inta3a metodei Cr3.e i Cr3.eL3+e este urmtoarea%
Console.WriteLine(FormatString, SubVal0, SubVal1, SubVal2, ... );
>ac e3ist mai muli parametrii, acetia sunt separai prin virgul. $rimul parametru trebuie
s fie ntotdeauna un ir de caractere i este denumit H3r 0e f*r4a.are ?f*r4a. ;.r3+7@. Qirul de
formatare poate conine 4ar,a.*r3 0e ;61;.3.63e ?;61;.3.6.3*+ 4arIer;@. &n marcator de
substituie marchea poiia n formatul irului unde o valoare se substituie atunci c"nd irul este
afiat pe ecran. &n marcator este un numr natural cuprins ntre acolade, i care repreint poiia
numeric a valorii care urmea a fi substituit i care ncepe de la <. $arametrii care urmea dup
irul de formatare se numesc 9a/*r3 0e ;61;.3.63e ?;61;.3.6.3*+ 9a/6e;@.
&rmtorul cod conine doi marcatori de substituie, numrul < i 6, i dou valori de care
urmea a fi substituite, 9 i ?.
Substitution markers
P P
Console.WriteLine("Doua exemple de intregi sunt {0} si {1}.", 3, 6);
R R
Format string Substitution values
/cest cod produce pe ecran% Doua exemple de intregi sunt 3 si 6.
&n marcator nu trebuie s refere o valoare de la o poiie mai lung dec"t lista valorilor ce
trebuie substituite, n ca contrar se produce o eroare. &rmtorul e3emplu reflect aceast situaie%
Pozi'ia 0 Poziia 1
P P
Console.WriteLine("Doi intregi: {0} si {2}.", 3, 6); // Eroare!
R
Nu exist poziia 2.
1.J C*4e+.ar33
Comentariile sunt buci de te3t care sunt e3cluse de la compilarea programului i care
servesc la introducerea n program a unor e3plicaii referitoare la pri ale acestuia.
6<
,*4e+.ar36 -e 6+ r=+0 prin folosirea SS 0ot ce urmea dup caracterele SS sunt
considerate, din acel loc, p"n la sf"ritul r"ndului drept comentariu%
// Acesta este un comentariu pe un singur rnd
,*4e+.ar36 -e 4a3 46/.e r=+06r3 prin folosirea ST i TS )rice te3t cuprins ntre
simbolurile menionate mai sus se consider a fi comentariu. 4imbolurile ST repreint nceputul
comentariului, iar TS sf"ritul respectivului comentariu%
/* Acesta este un
comentariu care se
ntinde pe mai multe rnduri */
1.( De,/ara33
) declaraie simpl este o instruciune n cod surs care descrie un tip de date sau care i
spune programului s e3ecute o aciune. ) instruciune simpl se termin cu caracterul punct i
virgul NML.
&rmtorul e3emplu de cod cuprinde dou instruciuni simple. $rima instruciune definete
variabila cu numele Nvar6L i o iniialiea cu valoarea =. / doua instruciune afiea valoarea
variabilei Nvar6L pe ecran%
int var1 = 5;
System.Console.WriteLine("Valoarea lui var1 este {0}", var1);
1.K B/*,6r3 0e 3+;.r6,36+3
&n bloc de instruciuni cuprinde < sau mai multe instruciuni cuprinse ntre acolade UV.
,3emplu%
{
int var1 = 5;
System.Console.WriteLine("Valoarea lui var1 este {0}", var1);
}
&n bloc este folosit de obicei acolo unde mai multe instruciuni definesc o aciune. &n bloc
de instruciuni +6 se termin cu punct i virgul NML.
Terminating ;
P Terminating ;
{int var2 = 5; P
System.Console.WriteLine("The value of var1 is {0}", var1);
}
R No terminating ;
1.7 I0e+.3f3,a.*r3
$rin nume dat unei variabile, clase, metode etc. nelegem o succesiune de caractere care
ndeplinete urmtoarele reguli%
numele trebuie s nceap cu o liter sau cu unul dintre caracterele LWL i LXLM
primul caracter poate fi urmat numai de litere, cifre sau un caracter de subliniereM
numele care repreint cuvinte cheie nu pot fi folosite n alt scop dec"t acela pentru care au fost
definiteM
cuvintele cheie pot fi folosite n alt scop numai dac sunt precedate de XM
66
dou nume sunt distincte dac difer prin cel puin un caracter 'fie el i liter mic ce difer de
aceeai liter majuscul1M
C*+9e+33 -e+.r6 +64eF
n caul numelor claselor, metodelor, a proprietilor, enumerrilor, interfeelor, spaiilor de
nume, fiecare cuv"nt care compune numele ncepe cu majusculM
n caul numelor variabilelor dac numele este compus din mai multe cuvinte, primul ncepe cu
minuscul, celelalte cu majuscul.
4imbolurile le3icale repreent"nd constante, regulile de formare a e3presiilor, separatorii de
liste, delimitatorii de instruciuni, de blocuri de instruciuni, de iruri de caractere etc. sunt n mare
aceiai ca i n caul limbajului CEE.
Se,9e+e e;,a-e
4ecvenele escape permit specificarea caracterelor care nu au repreentare grafic i
repreentarea unor caractere speciale precum bacYslash, apostrof, etc.
4ecvenele escape predefinite n C# sunt%
O Zb % *acYspace '*41
O Zt % 0ab oriontal 'H01
O Zn % +inie noua '+C1
O Zf % $agina noua 'CC1
O Zr % 5nceput de r"nd 'C(1
O Z[ % Bhilimele
O ZD % /postrof
O ZZ % *acYslash
L3.era/3 L,*-3e /a 3+037*E
&n astfel de literal ncepe cu caracterul X urmat de un ir de caractere cuprins ntre
ghilimele. 4pecificul acestui literal const n faptul c acesta va putea fi repreentat e3act aa cum
este scris, inclusiv dac se ntinde pe mai multe r"nduri. $entru a afia I va trebui folosit LL
'ghilimele duble1.
,3emplu%
Console.Write (@Ne
place
informatica mult);
$e ecran va aprea%
Ne
place
informatica mult
1.M C693+.e ,Ne3e
/cestea sunt cuvinte speciale care au o semnificaie bine definit i care nu pot fi folosite
dec"t n scopul pentru care au fost create.
abstract const e3tern int out short tGpeof
as continue false interface override sieof uint
base decimal finallG internal params stacYalloc ulong
bool default fi3ed is private static unchecYed
breaY delegate float locY protected string unsafe
68
bGte do for long public struct ushort
case double foreach namespace readonlG switch using
catch else goto new ref this virtual
char enum if null return throw void
checYed event implicit object sbGte true volatile
class e3plicit in operator sealed trG while
#376ra J. C693+.e/e ,Ne3e 03+ C#
1.' T3-6r3 0e 0a.e
2n limbajul de programare C# e3ist dou tipuri de date% .3-6r3 9a/*are H3 .3-6r3 refer3+.
T3-6r3/e 9a/*are includ tipurile simple 'char, int, float, etc1, tipurile enumerare i structur acestea
conin"nd direct datele referite i sunt alocate pe stiv sau inline ntr#o struct. T3-6r3/e refer3+
includ tipurile clas, interfa, delegat i tablou, toate av"nd proprietatea c variabilele de acest tip
stochea referine ctre obiecte. 0oate tipurile de date sunt derivate 'direct sau nu1 din tipul
4Gstem.)bject.
T3-6r3 -re0ef3+3.e
+imbajul C# conine un set de 6= tipuri predefinite, pentru care nu este necesar includerea
vreunui spaiu de nume via directiva using% string, object, tipurile ntregi cu semn i fr semn,
tipuri numerice n virgul mobil, tipurile bool i decimal.
0ipul string este folosit pentru manipularea irurilor de caractere codificate &nicodeM
coninutul obiectelor de tip string nu se poate modifica.
Clasa object este rdcina ierarhiei de clase din .N,0, la care orice tip 'inclusiv un tip
valoare1 poate fi convertit.
0ipul bool este folosit pentru a repreenta valorile logice true i false.
0ipul char este folosit pentru a repreenta caractere &nicode, repreentate pe 6? bii.
0ipul decimal este folosit pentru calcule n care erorile determinate de repreentarea n
virgul mobil sunt inacceptabile, de e3emplu n calcule monetare, el pun"nd la dispoiie 8@ de
cifre ecimale semnificative. $entru a semnala c un literal n virgul mobil este de tip decimal, se
va pune la sf"ritul acestuia litera m sau !.
,3emplu% decimal dcm\689.;=?mM
$entru a semnala c un literal n virgul mobil este de tip float, se va pune la sf"ritul
acestuia litera f sau C, altfel se va subnelege c este de tip double i ar putea aprea erori.
,3emplu% float flt\9;=.?7@CM
De+643r
e
E>-/3,a3e "a/*r3 re-re2e+.a.e
sbGte ntreg cu semn pe @ bii #68@ ] 687
bGte ntreg fr semn pe @ bii < ] 8==
short ntreg cu semn pe 6? bii #987?@ ]987?7
ushort ntreg fr semn pe 6? bii < ] ?==9=
int ntreg cu semn pe 98 bii
#8.6;7.;@9.?;@ ]
8.6;7.;@9.?;7
uint ntreg fr semn pe 98 bii < ] ;.8:;.:?7.8:=
long ntreg cu semn pe ?; bii
#:.889.978.<9?.@=;.77=.@<@ ]
:.889.978.<9?.@=;.77=.@<7
ulong ntreg fr semn pe ?; bii < ]
69
6@.;;?.7;;.<79.7<:.==6.?6=
float real cu preciie simpl 6.=36<
#;=
] 9.;36<
9@
double real cu preciie dubl =36<
#98;
] 6.736<
9<@
bool logic true, false
char caracter &nicode &E<<<< ] &Effff
decimal
68@ de bii, valoare real cu preciie de 8@ de
ecimale semnificative
^6.<36<
#8@
] ^7.:36<
8@
object clasa de ba din care deriv toate tipurile 4Gstem.)bject
string secven de caractere &nicode 4Gstem.4tring
dGnamic tip folosit pentru assemblG#urile din limbaje dinamice
#376ra (. T3-6r3 -re0ef3+3.e :+ C#
Ciecare tip de date din C# i are corespondentul n tipul .Net 'tipurile din spaiul de nume
4Gstem1.
T3-6r3 0ef3+3.e 0e 6.3/32a.*r
0ipurile care pot fi definite de utiliatori sunt de ? feluri. ) parte dintre acestea vor fi
discutate n paginile urmtoare.
classM
structM
arraGM
enumM
delegateM
interface.
1.1O "ar3a13/e
&n limbaj de programare trebuie s permit programului s stochee i s manipulee date.
2n timpul e3ecuiei unui program, datele sunt temporal stocate n memorie. ) variabil este un
nume dat unei locaii de memorie folosit de un tip particular de date n timpul e3ecuiei
programului. /stfel, fiecrei variabile i se asocia un tip de dat i o valoare. C# prevede patru
categorii de variabile, fiecare dintre acestea vor fi discutate n detaliu%
.ariabile localeM
C"mpuriM
$arametriiM
,lemente de tablou.
De,/ararea 9ar3a13/e/*r. 2n C# variabilele sunt declarate astfel%
<nume_tip_dat> <nume_aria!il>;
,3emplu%
0ip Nume variabil

int var2;
Codul de program de mai sus reerv o arie de ; bGtes'octei1 n memoria (/!,
pentru stocarea valorii unei valori de tip ntreg, care va fi referit n program cu ajutorul
identificatorului Nvar8L. .ariabilele pot fi iniialiate la declarare sau mai t"riu%
!ool is"ead# $ true;
float percenta%e $ &'.&&( aera%e $ )*.+;
6;
c,ar di%it $ -'-;
>up declararea tipului unei variabile, aceasta poate fi iniialiat cu o valoare. 5niialiarea
unei variabile se face cu ajutorul semnului egal 'N\L1 plasat ntre numele variabilei i valoarea
acesteia, aa cum se arat n continuare%
iniialiare
P
int ar. $ /';
.ariabilele locale neiniialiate au valori nedefinite i prin urmare nu pot fi folosite p"n
c"nd nu au atribuit o valoare. 2ncercarea de a utilia o variabil neiniialiat va produce o eroare
la compilare.
De,/ararea 4a3 46/.*r 9ar3a13/e 0e a,e/aH3 .3-. 4e pot declara mai multe variabile ntr#o
declaraie. 0oate variabilele dintr#o declaraie de variabile, trebuie s fie de acelai tip. Numele
variabilelor trebuie separate prin virgul iniialiarea acestora se poate face cu ajutorul semnului
N\L. 2n urmtorul cod de program se declar se declar, mai multe variabile de tip ntreg i respectiv
real%
00 1eclaraii de aria!ile 2 cu iniiali3are 4i fr
int ar* $ '( ar)( ar5 $ *;
dou!le ar6( ar' $ 6.5.;
0ip 0ip diferit
7 7
int ar&( float ar+; 008rror9
&ltima declaraie este invalid deoarece sunt declarate dou variabile de tipuri diferite, n
aceeai instruciune.
U.3/32area 9a/*r33 6+e3 9ar3a13/e. Numele unei variabile repreint valoarea stocat de variabil. 4e
poate utilia valoarea prin folosirea numelui variabilei. >e e3emplu, valoarea variabilei var este
luat din memorie i plasat n poiia numelui variabilei, astfel%
Console.Write:ine(;<=>;( ar);
2n C# 'la fel ca i n celelalte limbaje de programare moderne1, variabilele trebuie declarate
naintea folosirii acestora. &rmtorul cod de program va da eroare la compilare, deoarece variabila
NnumrL nu este iniialiat%
static oid ?ain()
<
int numr;
00numr $ /&;
Console.Write:ine(numr); 00 error
>
2n caul n care se vor terge cele dou SS care preced comentariul din linia ;, codul poate fi
compilat fr eroare.
) variabil de un tip valoare conine efectiv o valoare. C"nd se declar o variabil de un tip
valoare, compilatorul aloc n stiv numrul de octei corespuntori tipului, iar programatorul
lucrea direct cu aceast on de memorie.
) variabil de tip referin este o referin care, atunci c"nd nu este null, refer un obiect de
tipul specificat, alocat n memoria heap.
6=
1.11 C*+;.a+.e. Constantele sunt variabile a cror valoare, odat definit, nu poate fi schimbat
de ctre program.
Constantele sunt declarate astfel% const dou!le @A $ *./).;
6?
CAPITOLUL II. EXPRESII I OPERATORI
.1 E>-re;33
,3presiile repreint niruiri de operatori i operani. )peranii pot fi% literali 'constante1,
variabile, apeluri de metode, elemente de tablou, etc.
O-era.*r3
. O-era.*r3 ar3.4e.3,3
O-era+0
De;,r3ere
E /dunare
# 4cdere
T 2nmulire
S 2mprire
_ (estul sau modulo
EE /dunare cu 6
## 4cdere cu 6
N*.a33 -ref3>a.e ;a6 -*;.f3>a.e
4e d urmtoarea linie de cod% int num/ $ /=;
&rmtoarele instruciuni sunt echivalente%
num/BB;
num/ $ num/ B /;
num/ B$ /;
/mbii operatori EE i O pot fi utiliai n form prefi3at sau postfi3at.
2n forma prefixat,
num/ $ *;
num. $ BBnum/; 00 num/ $ )( num. $ )
compilatorul va incrementa prima dat variabila num6 cu 6 i apoi va atribuii aceast valoare
variabilei num.(
2n forma postfixat,
num2 = num1++; // num1 = 4, num2 = 3
compilatorul prima dat va atribuii valoarea variabilei num/ la variabila num. i apoi incrementea
variabila num/ cu 6.
.! O-era.*r3 0e a.r3163re
O-era+0 De;,r3ere
\ /tribuire simpl
E\ /tribuire aditiv
#\ /tribuire substractiv
T\ /tribuire multiplicativ
S\ /tribuire cu mprire
_\ /tribuire cu modulo
) atribuire compus are forma% )ar> op$ <eCpr> i este echivalent cu%
67
<ar> $ <ar> op <eCpr>( iar op poate fi unul din operatorii% T, S, _, E, #, ``, aa, b, c, d
,3emplu%
int i$=;
i B$ /5; ec,ialent cu i $ i B /5;
,3emplu%
usin% D#stem;
class Eormattin%Num!ers
<
static oid ?ain()
<
int al $ /=;
al B$ /=;
Console.Write:ine(;al B$/= este <=>;( al); 00al $ .=
al F$ 5;
Console.Write:ine(;al F$5 este <=>;( al); 00al $ /5
al G$ /=;
Console.Write:ine(;al G$/= este <=>;( al); 00al $ /5=
al 0$ *;
Console.Write:ine(;al 0$* este <=>;( al); 00al $ 5=
al H$ &;
Console.Write:ine(;al H$& este <=>;( al); 00al $ .
Console."ead:ine();
>
>
C3.3rea 0a.e/*r 0e /a .a;.a.6r H3 ;,r3erea 0a.e/*r /a ,*+;*/
Citirea unui ir de caractere de la tastatur se face cu metodele C*+;*/e.Rea0?@ sau
C*+;*/e.Rea0L3+e?@. /fiarea datelor pe ecran se face cu metodele C*+;*/e.Cr3.e?@ sau
C*+;*/e.Cr3.eL3+e?@. >iferena dintre cele dou const n trecerea la linie nou n caul metodelor
care se termin cu N+ineL.
,3emplu%
usin% D#stem;
namespace ConsoleIpplication
<
class @ro%ram
<
pu!lic static oid ?ain()
<
float a( !;
strin% sir;
Console.Write(;1ati aloarea pentru aria!ila a$;);
sir $ Console."ead:ine(); a $ float.@arse(sir);
Console.Write(;1ati aloarea pentru aria!ila !$;);
sir $ Console."ead:ine(); ! $ float.@arse(sir);
Console.Write(;Duma dintre a$<=> 4i !$</> este <.>;( a( !( aB!);
Console."ead:ine();
>
>
>
,3emplul de mai sus se poate scrie i astfel%
6@
usin% D#stem;
namespace ConsoleIpplication
<
class @ro%ram
<
pu!lic static oid ?ain()
<
float a( !;
Console.Write(;1ati aloarea pentru aria!ila a$;);
a $ float.@arse(Console."ead:ine());
Console.Write(;1ati aloarea pentru aria!ila !$;);
! $ float.@arse(Console."ead:ine());
Console.Write(;Duma dintre a$<=> 4i !$</> este <.>;( a( !( aB!);
Console."ead:ine();
>
>
>
$entru tipurile numerice, metoda T*S.r3+7 produce o repreentare ir de caractere a unui
numr. ,a poate fi folosit i cu c"iva parametrii, care permit diverse formatri ale afirii valorii
numerice ca i ir de caractere.
2n C# e3ist predefinite o mulime de modaliti pentru formatarea afirii valorilor
numerice. +ista complet a acestora se poate gsi la adresele de 5nternet%
http%SSmsdn.microsoft.comSen#usSlibrarGSdwhawG:Y.asp3
http%SSmsdn.microsoft.comSen#usSlibrarGS<c@::aY@.asp3
$ractic este vorba de nite specificatori de format, repreentai de obicei de o liter, ns pot
fi i cifre sau alte caractere '# _ . ,1.
>e e3emplu, specificatorul de format c 'sau C1 va face ca valoarea numeric afiat s
conin i un simbol monetar.
decimal alue $ /.*.)56m;
Console.Write:ine(alue.JoDtrin%(;C.;));
.a afia% K/.*.)6
Complementara metodei T*S.r3+7 este metoda Par;e. !etoda $arse se folosete astfel%
aria!il $ tipul_aria!ilei.@arse(input_strin%);
unde tipul_aria!ilei poate fi oricare tip de date predefinit n C#.
,3emplu%
int L $ int.@arse(;/.*)5;);
dou!le dd $ dou!le.@arse(; F/(.*).56'& ;);
Console.Write:ine(;L$<=> dd$</>;( L( dd);
,3emplu%
usin% D#stem;
class @ro%ram
<
static oid ?ain()
<
int a $ 55===;
int ! $ 6'6;
dou!le c $ 555.);
6:
dou!le d $ 5=&'=.//55;
strin% a/ $ a.JoDtrin%();
strin% a. $ a.JoDtrin%();
Console.Write:ine(a/ B ; ; B a.); 00 55=== 55===
strin% !/ $ !.JoDtrin%();
strin% !. $ !.JoDtrin%();
Console.Write:ine(!/ B ; ; B !.); 00 6'6 6'6
strin% c/ $ c.JoDtrin%();
strin% c. $ c.JoDtrin%();
Console.Write:ine(c/ B ; ; B c.); 00 555.) 555.)
strin% d/ $ d.JoDtrin%();
strin% d. $ d.JoDtrin%();
Console.Write:ine(d/ B ; ; B d.); 00 5=&'=.//55 5=&'=.//55
Console."ead:ine();
>
>
.J O-era.*r3 re/a3*+a/3
O-era+0 De;,r3ere
\\
0estarea egalitii
K\ 0estarea inegalitii
a 4trict mai mare
` 4trict mai mic
a\ !ai mare sau egal
`\ !ai mic sau egal
,3emplu%
usin% D#stem;
class Mperatori"elationali
<
static oid ?ain()
<
int / $ 5( . $ 6;
Console.Write:ine(;<=>$$</> este <.>;( /( .( /$$.); 00false
Console.Write:ine(;<=>9$</> este <.>;( /( .( /9$.); 00true
Console.Write:ine(;<=>></> este <.>;( /( .( />.); 00false
Console.Write:ine(;<=><</> este <.>;( /( .( /<.); 00true
Console.Write:ine(;<=><$</> este <.>;( /( .( /<$.); 00true
Console.Write:ine(;<=>>$</> este <.>;( /( .( />$.); 00false
Console."ead:ine();
>
>
.( O-era.*r3 /*73,3. O-era.*r3 /*73,3 /a +39e/ 0e 133
O-era+0 De;,r3ere
b /N> ntre bii
c )( ntre bii
d e)( ntre bii
f N)0 pe bii
K N)0 logic
bb /N> logic
cc )( logic
8<
O-era.*r3 /*73,3 D;,6r.,3r,63.a3EF PP< QQ
/ceti operatori se numesc NscurtcircuitaiL deoarece n caul lui bb, dac primul operand
este fals, reultatul evalurii e3presiei este automat fals, fr a mai verifica valoarea celui de#al
doilea operand. 2n caul lui cc, dac primul operand este adevrat, reultatul evalurii e3presiei este
automat adevrat, fr a mai verifica valoarea celui de#al doilea operand. Neevalu"nd al doilea
operand se c"tig timp la e3ecuie.
,3emplu%
usin% D#stem;
class Mperatori:o%ici
<
static oid ?ain()
<
int i $ 6( N $ /.;
!ool firstOar $ i > * PP N < /=;
Console.Write:ine(;<=>>* PP </></= este <.>;( i( N( firstOar);
00 firstOar a aea aloarea false
!ool secondOar $ i > * QQ N < /=;
Console.Write:ine(;<=>>* QQ </></= este <=>;( i( N( secondOar);
00 secondOar a aea aloarea true
Console."ead:ine();
>
>
.K O-era.*r6/ ,*+033*+a/ RF
/cesta este un operator care necesit trei operani 'operator teriar1. Corma general a
acestuia este% condiie R eCpresie/ S eCpresie.
(olul acestui operator este de a evalua o condiie i n funcie de valoarea de adevr a
acesteia s e3ecute 'dac este adevrat1 eCpresie/ sau eCpresie. 'dac este fals1.
,3emplu%
int i( C$*( #$);
i $ C < # R /= S .= ;
,fect% >ac 3`G atunci i va lua valoarea 6<, altfel va lua valoarea 8<.
Pre,e0e+a ?-r3*r3.a.ea@ *-era.*r3/*r
2n caurile c"nd avem e3presii cu mai muli operatori este util s cunoatem ordinea n care
acetia vor fi evaluai, mai ales c"nd nu sunt folosite parantee. 2n tabelul de mai jos sunt operatorii,
de la cea mai mare prioritate spre cea mai mic i asociativitatea c"nd sunt operatori cu aceeai
prioritate.
O-era.*r A;*,3a.393.a.e
()TU.
BB(postfiC) FF(postfiC)
c,ecLed neV si3eof unc,ecLed
st"nga spre dreapta
BB(prefiC) FF(prefiC)
B(unar) F(unar) (cast)
9 W
dreapta spre st"nga
86
G 0 H
st"nga spre dreapta
B F
st"nga spre dreapta
<< >>
st"nga spre dreapta
< < > >$ is
st"nga spre dreapta
$$ 9$
st"nga spre dreapta
P
st"nga spre dreapta
X
st"nga spre dreapta
Q
st"nga spre dreapta
PP
st"nga spre dreapta
QQ
st"nga spre dreapta
RS
dreapta spre st"nga
$ B$ F$
G$ 0$ H$ P$
X$ Q$ <$ >>$
dreapta spre st"nga
88
CAPITOLUL III. INSTRUCIUNI
I+;.r6,36+3 ,*+033*+a/e
!.1 I+;.r6,36+ea if-else
5nstruciunea if e3ecut o instruciune n funcie de valoarea de adevr a unei e3presii
logice. 4tructura instruciunii ifYelse este urmtoarea%
if (eCpresie_!oolean)
instruciune sau !loc de instruciuni /;
Telse
instruciune sau !loc de instruciuni .;U
Claua else este opional.
,3emplu%
int a$/=;
if (a<=)
Console.Write (Ne%ati);
else
Console.Write (@o3iti);
!. I+;.r6,36+ea switch
2n caul unei instruciuni sVitc,, e3presia care se evaluea trebuie s fie de tipul 'sau
convertibil implicit la tipul1 s!#te( !#te( s,ort( us,ort( lon%( ulon%( c,ar( strin% sau
o enumerare baat pe unul dintre aceste tipuri. >ac valoarea e3presiei se regsete printre valorile
specificate la clauele case, atunci instruciunea corespuntoare va fi e3ecutatM dac nu, atunci
instruciunea de la claua default va fi e3ecutat 'dac ea e3ist1.
switch (eCpresie)
case etic,eta/S instruciune sau !loc de instruciuni;
instruciunea break sau goto;
.
.
case etic,etaNS instruciune sau !loc de instruciuni;
instruciunea break sau goto;
TdefaultU
instruciune sau !loc de instruciuni;
instruciunea break sau goto;
) etichet repreint o e3presie constant.
2n faa de proiectare a limbajului C#, !icrosoft a decis s mpiedice trecerea automat la
urmtoarea ramur case n lipsa instruciunii breaY 'o facilitate uual n C i CEE1M din acest motiv,
lipsa instruciunii !reaL pe o ramur case va genera eroare la compilare 'e3cept"nd caul c"nd
ramura case nu conine instruciuni1. 0recerea de la o ramur case la alta poate fi ns simulat cu
instruciunea goto% ...
) instruciune poate s i lipseasc i n acest ca se va e3ecuta instruciunea de la caseOul
urmtor, sau de la default. 4eciunea default poate s lipseasc. >ac o instruciune este nevid,
89
atunci obligatoriu va avea la sf"rit o instruciune !reaL sau %oto case eCpresieConstanta sau
%oto default.
4pre deosebire de C i CEE, e interis s se foloseasc trecerea automat de la o etichet la
alta, continuarea se face folosind e3plicit instruciunea %oto.
,3emplu%
usin% D#stem;
class JestDVitc,
<
static oid ?ain()
<
int nota$&;
sVitc, (nota) <
case )S Console.Write (Nepromoat); !reaL;
case &S Console.Write (?ediu); !reaL;
case /=S Console.Write (Eoarte !ine); !reaL;
>
Console."ead:ine();
>
>
I+;.r6,36+3 0e ,3,/are
!.! I+;.r6,36+ea for
Cormatul instruciunii este%
for(eCpresie_de_iniiali3are; condiie; incrementare0decrementare)
instruciune sau !loc de instruciuni;
,3emplu%
for(int i$/; i<$/=; iBB)
<
Console.Write:ine(;An acest ciclu aloarea lui i este <=>.;( i);
>
0oate cele trei argumente ale instruciunii for sunt opionale.
,3emple%
for(; ;)
for( ; i</=; iBB)
for(int i$*; ; iFF)
for( ; i>5; )
$ot e3ista forme al instruciunii for care folosesc mai multe contoare, separate ntre ele prin
virgul, dup cum se poate vedea n e3emplul de mai jos%
for(i$=( N$/=; i<N; iBB( NFF)
>ac se declar o variabil n eCpresia_de_iniiali3are, atunci ciclul ei de via este
doar n corpul instruciunii for(
,3emplu%
usin% D#stem;
namespace eCemplu_for
<
class 8CempluEor
<
static oid ?ain()
8;
<
for (int i $ /; i <$ /=; iBB)
Console.Write:ine(;Oaloarea lui i esteS <=>.;( i);
Console."ead:ine();
iBB; 00 eroare 99
>
>
>
4e pot utilia instruciunile !reaL i continue n orice instruciune de ciclare. /cestea
schimb e3ecuia normal a ciclului. 5nstruciunea !reaL termin ciclul i transfer e3ecuia n
afara ciclului.
,3emplu%
for(int i$/; i<$/=; iBB)
<
if(i>5)
<
!reaL;
>
Console.Write:ine(;Oaloarea lui i in acest ciclu esteS<=>.;( i);
>
>ac dup instruciunea !reaL mai e3ist cel puin o instruciune, atunci compilatorul va
genera o avertiare.
,3emplu%
for(int i$*; i</=; iBB)
<
!reaL; 00Varnin%( Console.Write:ine (i); is unreac,a!le code
Console.Write:ine(i);
>
5nstruciunea continue ignor partea de instruciuni rmas din iteraia curent i trece la
urmtoarea iteraie.
,3emplu%
for(int i$/; i<$); iBB)
<
if(i$$.)
< continue; >
Console.Write:ine(;Oaloarea lui i esteS<=>.;( i);
>
(eultatul%
Oaloarea lui i in acest ciclu esteS/.
Oaloarea lui i in acest ciclu esteS*.
Oaloarea lui i in acest ciclu esteS).
!.J I+;.r6,36+ea do-while
4tructura acestei instruciuni este%
do
instruciune sau !loc de instruciuni
V,ile(condiie);
8=
4e vor e3ecuta instruciunile de dup do, dup care se verific condiia. 5nstruciunea de
ciclare continu at"ta timp c"t condiia este adevrat 'true1. &rmtorul program afiea ntregii de
la 6 la 6< pe ecran%
usin% D#stem;
namespace eCemplu_1o <
class 1o8Cample <
static oid ?ain() <
int i $ /;
do <
Console.Write:ine(;Oaloarea lui i este <=>.;( i);
iBB;
> V,ile (i <$ /=);
Console."ead:ine();
>
>
>
2n caul instruciunii doFV,ile, instruciunile din corpul acesteia se e3ecut cel puin odat.
!.( I+;.r6,36+ea while
5nstruciunea while este similar cu instruciunea do-while< cu e3cepia c verificarea
condiiei se face naintea e3ecuiei codului din corpul instruciunii. Corma general a instruciunii
este%
while(condiie)
instruciune sau !loc de instruciuni
,3emplu%
usin% D#stem;
namespace eCemplu_W,ile <
class W,ile8Cample <
static oid ?ain() <
int i $ /;
V,ile (i <$ /=)
<
Console.Write:ine(;Oaloaea lui i este <=>.;( i);
iBB;
>
Console."ead:ine();
>
>
>
!.K I+;.r6,36+ea foreach
5nstruciunea foreac, este un alt tip de instruciune de ciclare, care enumer elementele
dintr#o colecie sau matrice 'arraG1, e3ecut"nd o instruciune pentru fiecare element. ,lementul care
se e3trage este de tip read#onlG, neput"nd fi transmis ca parametru i nici aplicat un operator care
sa#i schimbe valoarea.
4tructura de ba a instruciunii foreac, este%
foreac,(<tip_colecie> <nume_aria!il> in <arra# sau colecie>)
<instruciune sau !loc de instruciuni>
8?
,3emplu%
intTU t $ </( .( *>;
foreac, (int C in t)
<
Console.Write:ine(C);
>
,3emplu%
strin%TU fructe$<?ar( Ciresa( @ortocala>;
foreac, (strin% fruct in fructe)
<
Console.Write(<=> ( fruct);
>
,3emplu%
static oid ?ain()
<
00 declararea 4i iniiali3area unui 4ir de Zntre%i
int TU inte%ers $ <*( '( .( /)( 65>;
00 iterarea elementelor din 4ir 4i tiprirea lor pe ecran
foreac,(int i in inte%ers)
<
Console.Write:ine(i);
>
>
2n instruciunea *oreac+,int i in integers-, se specific tipul elementelor din colecie 'int n
acest ca1. 4e declar variabila i care va conine, la fiecare iteraie, valoarea fiecrui element al
coleciei.
)bservaii%
.ariabila utiliat pentru a memora, la fiecare iteraie, valoarea unui element al coleciei, 'i
n caul de mai sus1 este de tip read onlG, deci nu se pot schimba valorile elementelor coleciei
prin intermediul ei. /cest fapt nseamn c instruciunea foreac, nu permite schimbarea
valori elementelor coleciei sau tabloului, ci doar parcurgerea acesteiaSacestuia.
Colecia poate s fie orice instan a unei clase care implementea interfaa
4Gstem.Collections.5,numerable.
clasa string este, de asemenea, o colecie de caractere.
static oid ?ain()
<
strin% name $ ;IleCandru Cel ?are;;
foreac,(c,ar c, in name)
<
Console.Write:ine(c,);
>
>
87
I+;.r6,36+3 0e ;a/.
!.7 I+;.r6,36+ea break
5nstruciunea !reaL permite ieirea forat dintr#un ciclu de tip sVitc,( V,ile( do2
V,ile( for sau foreac,.
,3emplu de folosire a instruciunii !reaL ntr#un ciclu for:
usin% D#stem;
class Anstr[reaL <
static oid ?ain() <
for (int i $ /; i <$ /==; iBB)
<
if (i $$ 5) !reaL;
Console.Write:ine(i);
>
Console."ead:ine();
>
>
,3emplu de folosire a instruciunii .rea/ ntr#un ciclu s0itc+(
usin% D#stem;
class DVitc, <
static oid ?ain() <
Console.Write(;Ile%eti un numar (/( .( or *)S ;);
strin% s $ Console."ead:ine();
int n $ Ant*..@arse(s);
sVitc, (n)
<
case /S
Console.Write:ine(;Oaloarea este <=>;( /);
!reaL;
case .S
Console.Write:ine(;Oaloarea este <=>;( .);
!reaL;
case *S
Console.Write:ine(;Oaloarea este <=>;( *);
!reaL;
defaultS
Console.Write:ine(;Delectie %resita.;);
!reaL;
>
>
>
,3emplu de folosire a instruciunii break ntr#un ciclu for.
usin% D#stem;
class ?ainClass
<
pu!lic static oid ?ain()
<
00 se a folosi !reaL pentru a ie4i din ciclu
8@
for (int i $ F/=; i <$ /=; iBB)
<
if (i > =) !reaL; 00ciclul se termin c\nd i e po3iti
Console.Write(i B ; ;);
>
Console.Write:ine(;]ata;);
Console."ead:ine();
>
>
,3emplu de folosire a instruciunii !reaL ntr#un ciclu doFV,ile.
usin% D#stem;
class ?ainClass
<
pu!lic static oid ?ain()
<
int i;
i $ F/=;
do
<
if (i > =)
!reaL;
Console.Write(i B ; ;);
iBB;
> V,ile (i <$ /=);
Console.Write:ine(;]ata;);
Console."ead:ine();
>
>
,3emplu de folosire a instruciunii !reaL ntr#un ciclu foreac,.
usin% D#stem;
class ?ainClass
<
pu!lic static oid ?ain()
<
int sum $ =;
intTU numere $ neV intT/=U;
for (int i $ =; i < /=; iBB)
numereTiU $ i;
foreac, (int C in numere)
<
Console.Write:ine(;Oaloarea esteS ; B C);
sum B$ C;
if (C $$ ))
!reaL; 00 cand C$) se iese din ciclu
>
Console.Write:ine(;Duma primelor 5 elementeS ; B sum);
>
>
8:
!.M I+;.r6,36+ea continue
5nstruciunea continue ignor partea rmas din iteraia curent i pornete urmtoarea
iteraie, ntr#o instruciune de ciclare de tip sVitc,( V,ile( doFV,ile( for sau foreac,(
,3emplu de folosire a instruciunii continue, pentru afiarea numerelor pare dintre < i 6<<.
usin% D#stem;
class ?ainClass
<
pu!lic static oid ?ain()
<
00 afisea3a numerele impare din interalul =( /==
for (int i $ =; i <$ /==; iBB)
<
if ((i H .) 9$ =)
continue; 00 iterate
Console.Write:ine(i);
>
Console."ead:ine();
>
>
!.' I+;.r6,36+ea goto
/ceast instruciune permite saltul la o anumit instruciune. /re 9 forme%
%oto etic,eta;
%oto case eCpresieconstanta;
%oto default;
Cerina este ca eticheta la care se face saltul s fie definit n cadrul funciei curente i saltul
s nu se fac n interiorul unor blocuri de instruciuni, deoarece nu se poate reface ntotdeauna
conte3tul acelui bloc. 4e recomand evitarea utilirii intense a acestei instruciuni, n ca contrar se
poate ajunge la fenomenul de Lspagetti codeL. 'a se vedea articolul clasic al lui ,dsgerJ. >ijYstra,
LBo 0o 4tatement Considered HarmfulL%
htt p%SSwww.acm.orgSclassicsSoct:=S 1.
,3emplu de folosire a instruciunii %oto, n caul instruciunii sVitc,.
usin% D#stem;
class DVitc,]oto
<
pu!lic static oid ?ain()
<
for (int i $ /; i < 5; iBB)
<
sVitc, (i)
<
case /S
Console.Write:ine(;An case /;);
%oto case *;
case .S
Console.Write:ine(;An case .;);
%oto case /;
9<
case *S
Console.Write:ine(;An case *;);
%oto default;
defaultS
Console.Write:ine(;An default;);
!reaL;
>
Console.Write:ine();
>
>
>
,3emplu de folosire a instruciunii %oto, n caul instruciunii for.
usin% D#stem;
class ?ainClass
<
pu!lic static oid ?ain()
<
for (int i $ =; i < /=; iBB)
<
Console.Write:ine(;i; B i);
if (i $$ *)
%oto stop;
>
stopS
Console.Write:ine(;Dtopped9;);
>
>
,3emplu de folosire a instruciunii %oto, n caul instruciunii V,ile.
usin% D#stem;
class ?ainClass
<
static oid ?ain()
<
int a $ =;
V,ile (a < /=)
<
if (a $$ 5)
%oto cleanup;
aBB;
>
cleanupS
Console.Write:ine(a);
Console."ead:ine();
>
>
,3emplu de folosire a instruciunii %oto, n caul instruciunii if.
usin% D#stem;
class ?ainClass <
pu!lic static oid ?ain() <
int total $ =;
int counter $ =;
96
m#:a!elS
counterBB;
total B$ counter;
if (counter < 5)
<
D#stem.Console.Write:ine(counter);
%oto m#:a!el;
>
Console."ead:ine();
>
>
!.1O I+;.r6,36+ea return
5nstruciunea return termin e3ecuia metodei n care aceasta apare, i returnea controlul
metodei apelante. 5nstruciunea return poate returna, opional, o valoare. >ac metoda care conine
instruciunea return este de tip oid, atunci instruciunea return poate fi omis.
Corma general a instruciunii este%
return TeCpressionU;
unde eCpression este valoarea returnat de metod. Nu este utiliat cu metode de tip oid(
2n e3emplul urmtor, metoda I() returnea variabila Irea ca valoare de tip 1ou!leS
usin% D#stem;
class "eturnJest
<
static dou!le CalculateIrea(int r)
<
dou!le area;
area $ r G r G ?at,.@A;
return area;
>
pu!lic static oid ?ain()
<
int ra3a $ 5;
Console.Write:ine(;Iria e <=S=.==>;( CalculateIrea(ra3a));
Console."ead:ine();
>
>
I+0e+.area -r*7ra4e/*r
+imbajul C# este independent de format, n sensul c nu are importan unde sunt
poiionate instruciunile unele n raport cu celelalte. >e#a lungul timpului ns a fost devoltat i
adoptat la scar larg un sistem de indentare comun, care permite apoi citirea programelor mult mai
uor. /cest sistem presupune trecerea la un nou nivel de indentare dup fiecare acolad deschis i
revenirea la nivelul de indentare anterior la nchiderea acoladei. ,3ist de asemenea unele
instruciuni care necesit o indentare suplimentar. 4e recomand ca programatorii s adopte acest
stil de scriere a programelor.
98
CAPITOLUL I". TIPURI DE#INITE DE UTILI$ATOR
J.1 T3-6/ e+64erare
0ipul enumerare este un tip definit de utiliator. 0ipul enumerare este un tip valoare,
construit pentru a permite declararea constantelor nrudite, ntr#o manier clar i sigur din punct
de vedere al tipului. &n e3emplu este%
enum 1a#s <Dat( Dun( ?on( Jue( Wed( J,u( Eri>;
2n aceast enumerare Dat este <, Dun este 6,1 ,lementele enumerrii pot fi iniialiate
suprascriind valorile implicite, astfel%
enum 1a#s <Dat$/( Dun( ?on( Jue( Wed( J,u( Eri>;
2n acest ca, secvena de elemente este forat s porneasc de la 6 n loc de <.
Ciecare tip enumerare care este folosit are un tipWdat pentru elementele sale. >ac nu se
specific nici un tip_dat, atunci se presupune implicit tipul int. 4pecificarea unui tip_dat
'care poate fi orice tip e3cept"nd tipul c,ar, se face prin enunarea tipului_dat dup numele
enumerrii. >eclararea unui tip enumerare este de forma%
enum TNume_tipU TS Jip_datU
<
Tidentificator/UT$aloareU(
...
TidentificatornUT$aloareU>
,3emplu%
enum ?#8num S !#te
<
triun%,i(
cerc
>
.aloarea fiecrei variabile poate fi specificat e3plicit%
enum Oalues
<
a $ )5(
! $ .*(
c $ a B !
>
,3emplu%
usin% D#stem;
namespace tipul8num <
class @ro%ram <
enum lunileInului
<
Aanuarie $ /(
Ee!ruarie( ?artie( Iprilie( ?ai( Aunie( Aulie(
Iu%ust( Deptem!rie( Mctom!rie( Noiem!rie( 1ecem!rie
>
static oid ?ain()
<
Console.Write:ine(;:una ?ai este a <=>;( (int)lunileInului.?ai B ;Fa luna din
an.;);
99
Console.Write:ine(;:una Iu%ust este a <=>;( (int)lunileInului.Iu%ust B ;Fa
luna din an.;);
Oaloarea lui i in acest ciclu esteSConsole."ead:ine();
>
>
>
>e observat c un element din lista de enumerri poate fi accesat astfel%
Nume8num.Nume8lement
0ipurile enumerare pot fi convertite ctre tipul lor de ba i napoi, folosind o conversie
e3plicit 'cast1%
enum Oalues
<
a $ /(
! $ 5(
c $ *
>
class Jest
<
pu!lic static oid ?ain()
<
Oalues $ (Oalues)*;
int ial $ (int);
>
>
,3emplu
usin% D#stem;
pu!lic class 8numJest
<
enum 1a#s <Dat$/( Dun( ?on( Jue( Wed( J,u( Eri>;
static oid ?ain()
<
int C $ (int)1a#s.Dun;
int # $ (int)1a#s.Eri;
Console.Write:ine(;Dun $ <=>;( C);
Console.Write:ine(;Eri $ <=>;( #);
Console."ead:ine();
>
>
J. T3-6/ .a1/*6
0ipul tablou '/rraG1 repreint o colecie de valori de acelai tip. 0ipul /rraG este un tip
referin, fiecare arraG este un obiect motenit din clasa de ba 4Gstem./rraG.
0ipul /rraG se declar astfel% <tip_dat>TU <nume_aria!il>;
$rin aceast declaraie nu se aloc spaiu pentru memorare.
$entru a putea reine date n structura de tip tablou, este necesar o operaie de instaniere%
nume $ neV tip_datTNumar8lementeU;
9;
4e reamintete c instanierea este procesul de creare a unui obiect i iniialiarea sa cu date
specifice.
>eclararea, instanierea i chiar iniialiarea tabloului se pot face n aceeai instruciune.
,3emplu%
intTU $ neV intTU </(.(*>; sau
intTU $ </(.(*>; 00neV este implicit
>imensiunea unui tablou trebuie fi3at i definit naintea utilirii acestuia%
int si3e $ /=;
intTU inte%ers $ neV intTsi3eU;
)pional, un tablou se poate declara i iniialia n pai separai%
intTU inte%ers;
inte%ers $ neV intT/=U;
,3emplu de declarare i iniialiare a unui vector cu cinci elemente%
int TU inte%ers $ </( .( *( )( 5>;
A,,e;area 9a/*r3/*r ;.*,a.e :+.r86+ .a1/*6.
$entru a accesa elementele unui tablou, se folosete operatorul de inde3are gint inde3h. .om
folosi acest inde3 pentru a indica elementul din tablou pe care vrem sa#l accesm. ,ste important de
reinut ca valoarea inde3ului n C# pornete de la <.
&rmtorul cod de program demonstrea cum poate fi accesat al treilea element al unui
tablou%
int TU intIrra# $ <5( /=( /5( .=>;
int N $ intIrra#T.U;
&rmtorul cod de program preint declararea, iniialiarea i parcurgerea unui tablou%
usin% D#stem;
namespace ^tili3areJa!lou
<
class 1emoIrra#
<
00 demonstrea3 utili3area arra#s Zn C_
static oid ?ain()
<
00 declararea 4i iniiali3area unui arra# de Zntre%i
intTU inte%ers $ < *( '( .( /)( 65 >;
00 parcur%erea ta!loului 4i afi4area fiecrui element pe ecran
for (int i $ =; i < 5; iBB)
Console.Write:ine(inte%ersTiU);
Console."ead:ine();
>
>
>
2n caul tablourilor cu mai multe dimensiuni se face distincie ntre tablouri regulate i
tablouri neregulate 'tablouri de tablouri1.
>eclararea n caul tablourilor regulate bidimensionale se face astfel% Ti23dat4567 nume8
5nstanierea% nume $ neV Jip_datT:inii(ColoaneU;
9=
/cces9 nume5indice&6indice$7
,3emple%
int567 mat : ne0 int567 ;;&6$6<=6;>6?6@=6;A6B6C==8 sau
int567 mat : ;;&6$6<=6;>6?6@=6;A6B6C==8
>eclarare n caul tablourilor neregulate bidimensionale% Ti25757 nume8
5ntaniere%
nume : ne0 Ti25NrDinii76578
nume5%7:ne0 Ti25NrColoane&7
(((
nume5NrDinii#&7:ne0 Ti25NrColoaneDinii#&7
/cces9 nume5indice&75indice$7
,3emple%
int5757 mat : ne0 int5757 ;
ne0 int5<7 ;&6$6<=6
ne0 int5$7 ;>6?=6
ne0 int5>7 ;A6B6C6&=
=8
sau
int5757 mat:;ne0 int5<7 ;&6$6<=6ne0 int5$7 ;>6?=6ne0 int5>7 ;A6B6C6&==8
J.! C*+9er;33 +64er3,e.
2n C# e3ist dou tipuri de conversii numerice%
implicite
e3plicite.
C*+9er;3a 34-/3,3. se efectuea 'automat1 doar dac nu este afectat valoarea convertit.
,3emplu%
usin% D#stem;
namespace Conersii
<
class @ro%ram
<
static oid ?ain()
<
!#te a $ /*; 00 !#te Zntre% fr semn pe & !ii
!#te ! $ .=;
lon% c; 00Zntre% cu semn pe 6) !ii
c $ a B !; 00 conersie
Console.Write:ine(c);
>
>
>
(egulile de conversie implicit sunt descrise de tabelul urmtor%
9?
D3+ +
sbGte short, int, long, float, double, decimal
bGte short, ushort, int, uint, long, ulong, float, double, decimal
short int, long, float, double, decimal
ushor
t
int, uint, long, ulong, float, double, decimal
int long, float, double, decimal
uint long, ulong, float, double, decimal
long float, double, decimal
char ushort, int, uint, long, ulong, float, double, decimal
float double
ulong float, double, decimal
C*+9er;3a e>-/3,3. se realiea prin intermediul unei e3presii ,a;., atunci c"nd nu e3ist
posibilitatea unei conversii implicite.
2n urma rulrii programului%
usin% D#stem;
namespace Conersii/
<
class @ro%ram
<
static oid ?ain(strin%TU ar%s)
<
int a $ 5;
int ! $ .;
float c;
c $ (float)a 0 !; 00operatorul cast
Console.Write:ine(;<=>0</>$<.>;( a( !( c);
Console."ead:ine();
>
>
>
se obine%
=S8 \ 8.=
2n caul n care nu s#ar fi folosit operatorul cast reultatul, evident eronat, ar fi fost% =S8\8.
(egulile de conversie e3plicit sunt descrise de tabelul urmtor%
D3+ +
sbGte bGte, ushort, uint, ulong, char
bGte sbGte, char
short sbGte, bGte, ushort, uint, ulong, char
ushort sbGte, bGte, short, char
int sbGte, bGte, short, ushort, uint, ulong, char
uint sbGte,bGte, short, ushort, int, char
long sbGte, bGte, short, ushort, int, uint, ulong, char
ulong sbGte, bGte, short, ushort, int, uint, long, char
char sbGte, bGte, short
float sbGte, bGte, short, ushort, int, uint, long, ulong, char, decimal
double sbGte, bGte, short, ushort, int, uint, long, ulong, char, float, decimal
decimal sbGte, bGte, short, ushort, int, uint, long, ulong, char, float, double
C*+9er;33 :+.re +64ere H3r6r3 0e ,ara,.ere.
97
2n limbajul C# e3ist posibilitatea efecturii de conversii ntre numere iruri de caractere.
$entru conversia invers, adic 03+ H3r 0e ,ara,.ere :+ +64r, sinta3a este%
4ir `int int.@arse(4ir) sau Ant*..@arse(4ir)
4ir `lon% lon%.@arse(4ir) sau Ant6).@arse(4ir)
4ir `dou!le dou!le.@arse(4ir) sau 1ou!le.@arse(4ir)
4ir `float float.@arse(4ir) sau Eloat.@arse(4ir)
)bservaie% 2n caul n care irul de caractere nu repreint un numr valid, conversia din ir n
numr va eua.
,3emplu%
usin% D#stem;
namespace Conersii
<
class @ro%ram
<
static oid ?ain()
<
strin% s;
const int a $ /*;
const lon% ! $ /=====;
const float c $ ../5E;
dou!le d $ *./)/5;
Console.Write:ine(;CMNO8"DAAan;);
Console.Write:ine(;JA@atOI:. atDJ"AN];);
Console.Write:ine(;bbbbbbbbbbb;);
s $ ;; B a;
Console.Write:ine(;intat<=> at</>;(a(s);
s $ ;; B !;
Console.Write:ine(;lon%at<=> at</>;(!(s);
s $ ;; B c;
Console.Write:ine(;floatat<=> at</>;(c(s);
s $ ;; B d;
Console.Write:ine(;dou!leat<=> at</>;(d(s);
Console.Write:ine(;anDJ"AN]atOI: atJA@;);
Console.Write:ine(;bbbbbbbbbbb;);
int a/;
a/ $ int.@arse(;/*;);
Console.Write:ine(;<=>at</>atint;(;/*;(a/);
lon% !.;
!. $ lon%.@arse(;/===;);
Console.Write:ine(;<=>at</>atlon%;(;/===;(!.);
float c.;
c. $ float.@arse(;.(/5;);
Console.Write:ine(;<=>at</>atfloat;(;.(/5;(c.);
dou!le d.;
d. $ dou!le.@arse(;*./)/5;);
Console.Write:ine(;<=>at</>atdou!le;(;*./)/5;(d.);
Console."ead:ine();
>
>
>
9@
CAPITOLUL ". CLASE % NOIUNI DE BA$&
(.1 C/a;e/e. N*36+3 0e 1a2
0ipul clas 'class1 este cel mai important dintre tipurile definite de utiliator, n C#. Clasele
sunt tipuri referin definite de utiliator i repreint o mulime ncapsulat de date i funcii
dependente logic, care n general modelea obiecte din lumea real sau conceptual.
Clasa grupea datele i metodele 'funciile1 de prelucrare a acestora ntr#un modul, unindu#le astfel
ntr#o entitate mult mai natural. >ei tehnica se numete [$rogramare )rientat )biect[, conceptul
de baa al ei este NclasaL. Clasa, pe l"ng faptul c abstractiea foarte mult analiaSsintea
problemei, are proprietatea de generalitate, ea desemn"nd o mulime de obiecte care mpart o serie
de proprieti.
Clasa [floare[, de e3emplu, desemnea toate plantele care au flori, precum clasa [Cruct[
desemnea toate obiectele pe care noi le identificam ca fiind fructe. *ineneles, n implementarea
efectiv a programului nu se lucrea cu entiti abstracte, precum clasele ci se lucrea cu obiecte,
care sunt [instanieri[ ale claselor. /ltfel spus, plec"nd de la e3emplul de mai sus, dac se
construiete un program care s lucree cu clasa fructe, el nu va prelucra entitatea [fruct[ ci va lucra
cu entiti concrete ale clasei [fruct[, adic [afin[, [cirea[, [meur[, etc.
nstanierea 'trecerea de la clas la obiect1 nseamn atribuirea unor proprieti specifice
clasei, astfel nc"t aceasta s indice un obiect anume, care se diferenia de toate celelalte obiecte
din clas printr#o serie de atribute. >ac clasa NfructL conine caracteristicile% on, gust, i culoare,
atunci vom considera fructul [meur[ se gsete n onele mpdurite, de culoare ro i gust
dulce#acrior. Cructul NmeurL individualiea clasa NfructL, astfel c ajungem la un ca concret,
care este obiectul.
) instan a unui tip de date abstract este o LconcretiareL a tipului respectiv, format din
valori efective ale datelor. ) instan a unui tip obiectual poart numele de obiect.
Me41r33 6+e3 ,/a;e sunt mprii n urmtoarele categorii%
i constante
i c"mpuri
i metode
i proprieti
i evenimente
i inde3atori
i operatori
i constructori 'de instan1
i destructor
i constructor static
i tipuri
) clas este o structur de date care poate stoca date i e3ecuta cod de program. 2n continuare
sunt descrii%
9:
!embrii de tip dat "#ata members$% care stochea date asociate clasei sau instane ale
clasei. !embrii de tip dat, modelea, n general, atributele lumii reale, pe care clasa vrea s o
repreinte.
!embrii de tip funcie "&unction members$, care e3ecut cod de program. !embrii de tip
funcie modelea, n general, funcii i aciuni ale obiectelor din lumea real, pe care clasa vrea
s le repreinte.
&n program care rulea este o mulime de obiecte care interacionea unul cu cellalt.
De,/ararea ,/a;e/*r. >eclararea unei clase definete caracteristicile i metodele unei noi clase.
/ceasta nu creea o instan a clasei, dar creea un ablon pe baa cruia se vor crea instanele
clasei. &rmtorul e3emplu folosete sinta3a minim pentru crearea unei clase%
,69=+. ,Ne3e +64e/e ,/a;e3
E E
class 8CerciiuClas
<
1eclaraii1e?em!rii
>
2ntre cele dou acolade sunt declarai membrii clasei care formea, n acelai timp, corpul
clasei. !embrii unei clase pot fi declarai n orice ordine n interiorul corpului clasei.
(. C=4-6r3
C"mpurile'fields1 i metodele'methods1 fac parte din tipurile cele mai importante de
membrii ai unei clase.
&n ,=4- este o variabil care aparine unei clase. /cesta poate fi de orice tip% predefinit sau
definit de utiliator. /semenea variabilelor, c"mpurile stochea date, i au urmtoarele
caracteristici%
4inta3a minimal pentru declararea unui c"mp este%
tip
E
J#pe Adentifier;
F
Nume c"mp
>e e3emplu, urmtoarea clas conine declaraia c"mpului C"mpul!eu, care poate stoca o
valoare ntreag%
class ?#Class
< tip
E
int C\mpul?eu;
F
> Nume tip
I+33a/32area e>-/3,3. H3 34-/3,3. a ,=4-6r3/*r
2ntruc"t un c"mp este un tip de variabil, sinta3a pentru iniialiarea unui c"mp este aceeai
cu cea de la variabile.
;<
class ?#Class
<
int E/ $ /';
> c
5niialiarea c"mpului
$entru fiecare c"mp declarat se va asigna o valoare implicit astfel%
numeric% <
bool% false
char% jZ<D
enum% <
referin% null
,3emplu%
class ?#Class
<
int E/; 00 Aniiali3at cu = 2 tip aloare
strin% E.; 00 Aniiali3at cu null 2 tip referin
int E* $ .5; 00 Aniiali3at cu .5
strin% E) $ ;a!cd;; 00 Aniiali3at cu ;a!cd;
>
/celai e3emplu poate fi scris i%
class ?#Class
<
int E/( E* $ .5;
strin% E.( E) $ ;a!cd;;
>
&n astfel de c"mp se poate folosi fie prin specificarea numelui su, fie printr#o calificare
baat pe numele clasei sau al unui obiect.
,3emplu%
usin% D#stem;
class Iccess
<
00Oaria!ile declarate Znafara funciei ?ain.
int C $ /==;
int # $ .==;
pu!lic static oid ?ain()
<
00crearea o!iectului
Iccess a $ neV Iccess();
00apelul aria!ilelor instaniate
Console.Write:ine(a.C);
Console.Write:ine(a.#);
Console."ead:ine();
>
>
(.! Me.*0e
O 4e.*0 este un nume de bloc de cod e3ecutabil care poate fi e3ecutat din diferite pri ale
unui program, chiar i din alte programe. /tunci c"nd o metod este apelat 'invocat1, aceasta
;6
e3ecut codul din corpul su, dup care red controlul mai departe programului din care a fost
apelat. &nele metode returnea o valoare n poiia n care au fost apelate. !etodele corespund
funciilor membre din CEE. 4inta3a minim necesar declaraiei unei metode include urmtoarele
componente%
0ipul returnat ''eturn t(pe1% tipul valorii returnate de metod. 2n caul n care metoda nu
returnea o valoare, tipul returnat este 9*30M
Numele 'name1% repreint numele metodeiM
+ista parametrilor ')arameter list1% aceasta const din cel puin un set de parantee deschise
N'1L. >ac e3ist parametrii acetia sunt preentai ntre paranteeM
Corpul metodei '!ethod bodG1% conine cod e3ecutabil inclus ntre dou acolade NUVL.
,3emplu%
class DimpleClass
<
Jipul returnat :ista de parametrii
7 7
oid @rintNums ( )
<
Console.Write:ine(;/;);
Console.Write:ine(;.;);
>
>
(.!.1 S.r6,.6ra 6+e3 4e.*0e
2n esen o metod este un bloc de cod care are un nume i care poate fi apelat prin acesta.
4e pot transmite date ntr#o metod i se pot prelua date de la o metod. ) metod este un membru
de tip funcie al clasei n care este definit. )rice metod este compus din dou pri%
antetul metodei n care se specific caracteristicile metodei cum sunt%
o dac metoda returnea o valoare iar n ca afirmativ care este tipul acesteia,
o numele metodei,
o ce tip de date sunt transmise metodei.
corpul metodei care conine secvene de instruciuni 'cod e3ecutabil1. ,3ecuia instruciunilor
pornete de la prima i se continu secvenial prin corpul metodei.
#376ra K. S.r6,.6ra 6+e3 4e.*0e
4tructura antetului unei metode este%
int ?#?et,od ( int intpar/( strin% strpar/ )
c c c
0ipul Numele +ista de parametrii
returnat metodei
;8
(.!. "ar3a13/e /*,a/e
/semenea c"mpurilor, variabilele locale pot stoca date. 2n timp ce c"mpurile unui obiect
stochea, de obicei, starea unui obiect, variabilele locale sunt folosite pentru calcule locale sau
tranitorii.
&rmtoarele linii de cod repreint sinta3a declaraiei unei variabile locale%
Numele variabilei 5niialiarea opional
E E
J#pe Adentifier $ Oalue;

e3istena unei variabile locale este limitat la blocul n care a fost declarat, i la blocurile
coninute n acesta.
variabil local poate fi declarat n orice poiie n corpul unei metode.
&rmtorul e3emplu ilustrea declararea i utiliarea a dou variabile locale. $rima este de tip
ntreg iar a doua de tip clas 4omeClass%
static oid ?ain( )
<
int m#Ant $ /5;
DomeClass sc $ neV DomeClass();
...
>
&rmtorul tabel face o comparaie ntre variabilele locale i instana c"mpurilor.
I+;.a+a 6+63 ,=4- "ar3a13/a /*,a/
T34-6/ 0e
93a
,3ist n momentul crerii instanei.
2ncetea s mai e3iste atunci c"nd
nu mai este accesat
,3ist din momentul n care este
declarat. 2ncetea n momentul n care
ntregul bloc a fost e3ecutat.
I+33a/32are
34-/3,3.
,ste iniialiat cu valoarea implicit
a tipului
Nu sunt iniialiate implicit.
$*+a 0e
;.*,are
0oate c"mpurile unei clase sunt
stocate n memoria de tip heap,
indiferent de tipul acestora.
0ipul valoare este stocat n memoria
stacY iar tipul referin este stocat n
stacY i datele n heap.
(.!.! C69=+.6/ ,Ne3e var
2ncep"nd cu versiunea C# 9.< se poate utilia cuv"ntul cheie ar n locul declaraiei tipului
unei variabile locale, aa cum se vede n e3emplul urmtor%
static oid ?ain( )
<
int total $ /5;
?#8CcellentClass mec $ neV ?#8CcellentClass();
...
>
este echivalent cu%
static oid ?ain( )
<de#Vord
7
ar total $ /5;
ar mec $ neV ?#8CcellentClass();
...
;9
>
C"teva condiii importante n utiliarea cuv"ntului cheie ar sunt%
poate fi folosit doar la declararea variabilelor locale O nu poate fi folosit la declararea
c"mpurilor unei claseM
poate fi folosit numai atunci c"nd declararea variabilelor locale include i iniialiarea acestoraM
odat ce compilatorul a determinat tipul variabilelor, acesta nu mai poate fi schimbat.
"32313/3.a.ea 9ar3a13/e/*r /*,a/e :+ 3+.er3*r6/ 1/*,6r3/*r 341r3,a.e
Corpul metodelor poate conine mai multe blocuri imbricate. .ariabilele locale pot fi
declarate n interiorul blocurilor imbricate, i asemenea tuturor variabilelor locale, timpul acestora
de via este limitat la blocul n care au fost definite i la blocurile coninute n acesta.
C*+;.a+.e/e /*,a/e
Ciclul de via al constantelor locale este asigurat de aceleai reguli ca la variabilele locale.
4inta3a declaraiei constantelor locale este%
cuv"nt cheie
7
const J#pe Adentifier $ Oalue;
c
iniialiarea este obligatorie
(.!.J A-e/6/ 6+e3 4e.*0e
4e pot apela alte metode din corpul unei metode. ) metod se poate apela utili"nd numele
acesteia mpreun cu lista de parametrii.
2n urmtorul e3emplu n clasa ?#Class este declarat metoda @rint1ateIndJime care este
apelat n interiorul metodei ?ain.
class ?#Class
<
oid @rint1ateIndJime( ) 00 1eclararea metodei.
<
1ateJime dt $ 1ateJime.NoV; 00 1et. datei 4i a orei curente.
Console.Write:ine(;<=>;( dt); 00 Ifi4area acesteia.
>
static oid ?ain() 00 1eclararea metodei principale.
<
?#Class mc $ neV ?#Class();
mc.@rint1ateIndJime( ); 00 Ipelarea metodei.
> c c
> numele metodei lista vid de parametrii
(.!.( "a/*area re.6r+a. 0e * 4e.*0
) metod poate returna o valoare atunci c"nd este apelat. .aloarea returnat este inserat n
codul apelant n instruciunea n care este apelat metoda.
$entru a putea returna o valoare, trebuie declarat tipul acesteia naintea numelui metodei 'la
declararea metodei1M
>ac o metod nu returnea o valoare, ea trebuie declarat de tip oid 'vid1
;;
&rmtorul cod declar dou metode. $rima returnea o valoare ntreag iar cea de#a doua o
valoare vid.
0ipul returnat
7
int ]eteour() < ... >
oid 1ispla#eour() < ... >
c
Nu este returnat nici o valoare.
) metod care are returnea o valoare nevid trebuie s conin urmtoarea form a
instruciunii return9
return 8Cpression; 00 "eturnarea unei alori.
c
Cuv"nt cheie
,3emplu%
0ip returnat
7
int ]eteour( )
<
int a$/;
int !$.;
return aB!;
> c
5nstruciunea return
) metod poate returna un obiect definit de programator. >e e3emplu, urmtorul cod
returnea un obiect de tip ?#Class.
0ipul returnat FF ?#Class
7
?#Class met,od*( )
<
?#Class mc $ neV ?#Class();
...
return mc; 00 returnea3 un o!iect de tip ?#Class.
>
5nstruciunea return folosit i la metodele ce returnea tipul oid.
>intr#o metod ce returnea tipul vid, se poate iei simplu prin utiliarea instruciunii
return fr parametrii% return;
/ceast form a instruciunii return poate fi folosit numai cu metodele declarate oid.
,3ecuia instruciunilor din corpul unei metode declarate oid, se oprete atunci c"nd este nt"lnit
instruciunea return(
EGem2lu9
0ipul returnat
7
oid Dome?et,od()
<
...
if ( @rima_condiie ) 00 1ac ...
return; 00 controlul pro%ramului este returnat codului apelant.
...
;=
if ( I_doua_condiie ) 00 1ac ...
return; 00 controlul pro%ramului este returnat codului apelant.
...
> 00 controlul pro%ramului este returnat codului apelant.
&rmtorul cod este un alt e3emplu de utiliare a instruciunii return ntr#o metod
declarat oid%
class ?#Class
<
(eturnea tipul void
7
oid Jime^pdate()
<
1ateJime dt $ 1ateJime.NoV; 00 M!inerea datei 4i orei curente.
if (dt.eour < /.) 00 1ac ora este mai mic dec\t /.(
return; 00 atunci return.
c
(eturn la metoda apelant.
Console.Write:ine(;At-s afternoon9;); 00 Iltfel( afi4ea3 mesaN.
>
static oid ?ain()
<
?#Class mc $ neV ?#Class(); 00 Crea3 o instan a clasei.
mc.Jime^pdate(); 00 Ipele3 metoda.
>
>
(.!.K Para4e.r33 6+e3 4e.*0e
Para4e.r33 f*r4a/3 sunt variabile locale declarate in lista de parametrii a metodei. &rmtoarea
declaraie de metod ilustrea sinta3a declaraiei de parametrii%
pu!lic oid @rintDum( int C( float # )
< ... > c
1eclararea parametrilor formali
>eoarece parametrii formali sunt variabile locale, acetia au un tip i un nume.
$arametrii formali sunt definii nafara corpului metodei i iniialiai naintea e3ecuiei corpului
metodei, e3cepie fc"nd un anumit tip de parametrii care vor fi discutai n capitolele
urmtoare.
Numrul parametrilor formali poate fi oric"t, declaraiile acestora fiind desprite prin virgul.
$arametrii formali sunt folosii n corpul metodei, la fel ca i variabilele locale. 2n e3emplul
urmtor, declaraia metodei @rintDum folosete doi parametrii formali, C( 3 i variabila
local Dum, toate de tip int.
pu!lic oid @rintDum( int C( int # )
<
int Dum $ C B #;
Console.Write:ine(;NeVsflas,S <=> B </> is <.>;( C( #( Dum);
>
;?
Para4e.r33 a,.6a/3
/tunci c"nd programul apelea o metod, valorile parametrilor formali trebuie iniialiai
naintea e3ecuiei codului metodei.
,3presiile sau variabilele 'c"mpurile1 folosite la iniialiarea parametrilor formali se numesc
parametrii actuali.
$arametrii actuali sunt plasai n lista de parametrii ai metodei invocate.
,3emplul urmtor ilustrea invocarea metodei @rintDum, care are doi parametrii actuali de tip
intS
@rintDum( 5( DomeAnt );
c c
,3presie .ariabil de tip int
/tunci c"nd o metod este apelat, valoarea fiecrui parametru actual este utiliat pentru
iniialiarea parametrului formal corespuntor. Cigura urmtoare e3plic relaia dintre parametrii
actuali i cei formali.
#376ra 7. Re/a3a 03+.re -ara4e.r33 a,.6a/3 H3 ,e3 f*r4a/3
/tunci c"nd este apelat o metod, trebuie ndeplinite urmtoarele condiii%
Numrul parametrilor actuali trebuie s fie e3act cu numrul parametrilor formali, cu o singur
e3cepie care va fi discutat n capitolele urmtoare.
Ciecare parametru actual trebuie s aib acelai tip cu parametrul formal corespuntor.
,3emple%
class ?#Class -ara4e.r33 f*r4a/3
< 7 7
pu!lic int Dum(int C( int #) 00 1eclararea metodei.
<
return C B #; 00 "eturnea3 suma.
>
-ara4e.r33 f*r4a/3
7 7
pu!lic float I%(float Anput/( float Anput.) 00 1eclararea metodei.
<
return (Anput/ B Anput.) 0 ..=E; 00 "eturnea3 media.
>
;7
>
class Class/
<
static oid ?ain()
<
?#Class ?#J $ neV ?#Class();
int DomeAnt $ 6;
Console.Write:ine(;NeVsflas,S DumS <=> and </> is <.>;(5(
DomeAnt( ?#J.Dum( 5(DomeAnt )); 00 Anocarea metodei.
c
-ara4e.r33 a,.6a/3
Console.Write:ine(;NeVsflas,S I%S <=> and </> is <.>;(5( DomeAnt(
?#J.I%( 5( DomeAnt )); 00 Anocarea metodei.
> c
> -ara4e.r33 a,.6a/3
Codul de mai nainte produce urmtoarea ieire%
NeVsflas,S DumS 5 and 6 is //
NeVsflas,S I%S 5 and 6 is 5.5
Para4e.r33 0e .3- 9a/*are
/cesta este un tip implicit de parametri numii i parametrii valoare. /tunci c"nd se
folosesc parametrii valoare, datele sunt transmise metodei prin copierea valorilor parametrilor
actuali n parametrii formali. /tunci c"nd o metod este apelat, sistemul parcurge paii urmtori%
/loc spaiu n stiv 'stacY1 pentru parametrii formali
Copia parametrii actuali n parametrii formali
&n parametru actual al unui parametru valoare poate fi, pe l"ng variabil local, o e3presie
a crui tip se potrivete cu tipul parametrului valoare.
,3emplu%
float func/( float Oal ) 00 1eclararea metodei.
< ... > c
dat de tip float
<
float N $ ..6E;
float L $ 5./E;
variabil de tip float
7
float fOalue/ $ func/( L ); 00 Ipelul metodei
float fOalue. $ func/( (L B N) 0 * ); 00 Ipelul metodei
... c
,3presie care evaluea un tip real
&rmtorul cod de program preint o metod denumit ?#?et,od, care are doi parametrii% o
variabil de tip ?#Class i o variabil de tip intS
class ?#Class
<
;@
pu!lic int Oal $ .=; 00 Aniiali3ea3 c\mpul Oal cu .=.
>
class @ro%ram
-ara4e.r33 f*r4a/3
< 7 7
static oid ?#?et,od( ?#Class f/( int f. )
<
f/.Oal $ f/.Oal B 5; 00 Idun 5 la c\mpul parametrului f/.
f. $ f. B 5; 00 Idun 5 la al doilea parametru.
>
static oid ?ain( )
<
?#Class I/ $ neV ?#Class();
int I. $ /=;
?#?et,od( I/( I. ); 00 Ipelul metodei.
> c c
> -ara4e.r33 a,.6a/3
Para4e.r33 refer3+
/l doilea tip de parametrii folosii n lista de parametrii ai unei metode sunt parametrii referin.
/tunci c"nd se utiliea un parametru referin, trebuie folosit modificatorul ref at"t n
declaraia metodei c"t i n invocarea acesteia.
$arametrii actuali trebuie s fie variabile 'nu sunt admise valori sau e3presii valorice1 care
trebuie s fie iniialiate nainte s fie folosite ca parametrii actuali. >ac parametrii actuali sunt
variabile de tip referin, atunci acestora trebuie s li se atribuie, fiecreia, o referin sau
referina nul 'null1.
,3emplul urmtor ilustrea sinta3a declarrii i a invocrii unei metode cu parametrii referin.
3+,/60e 4*03f3,a.*r6/ ref
7
oid ?#?et,od( ref int al ) 00 1eclararea metodei
< ... >
int # $ /; 00 Oaria!ila pentru parametrul actual
?#?et,od ( ref # ); 00 Ipelul metodei
c
3+,/60e 4*03f3,a.*r6/ ref
?#?et,od ( ref *B5 ); 00 8rror9
c
.re163e 6.3/32a. * 9ar3a13/
/a cum am vut, n caul parametrilor valoare sistemul aloc memorie n stiv 'stacY1
pentru parametrii formali. $entru parametrii referin e3ist urmtoarele caracteristici%
Nu se aloc memorie n stiv pentru parametrii formali.
2n schimb, numele parametrilor formali acionea ca un alias pentru variabilele considerate
parametrii actuali, referind aceeai locaie de memorie.
2ntruc"t numele parametrilor formali i numele parametrilor actuali refer aceeai locaie de
memorie, este evident c orice schimbare fcut parametrilor formali, n timpul e3ecuiei codului
metodei respective, va avea efect dup e3ecuia metodei, asupra variabilelor desemnate ca
parametrii actuali.
;:
,3emplu%
class ?#Class
< pu!lic int Oal $ .=; > 00 Aniiali3area c\mpului cu aloarea .=.
class @ro%ram
<
4*03f3,a.*r6/ ref 4*03f3,a.*r6/ ref
7 7
static oid ?#?et,od(ref ?#Class f/( ref int f.)
<
f/.Oal $ f/.Oal B 5; 00 Idun 5 la c\mpul parametrului f/.
f. $ f. B 5; 00 Idun 5 la al doilea parametru.
>
static oid ?ain()
<
?#Class I/ $ neV ?#Class();
int I. $ /=;
?#?et,od(ref I/( ref I.); 00 Ipelul metodei.
> c c
> 4*03f3,a.*r3 ref
Para4e.r33 0e 3eH3re
$arametrii de ieire sunt folosii pentru a transmite date dinuntrul unui metode, n codul
apelant. $arametrii de ieire sunt asemntori cu parametrii referin, i au urmtoarele
caracteristici%
/tunci c"nd se utiliea un parametru de ieire, trebuie folosit modificatorul out at"t n
declaraia metodei c"t i n invocarea acesteia.
$arametrii actuali trebuie s fie variabile 'nu sunt admise valori sau e3presii valorice1.
2n e3emplul urmtor este declarat metoda ?#?et,od, care are un singur parametru de
ieire%
4*03f3,a.*r6/ out
7
oid ?#?et,od( out int al ) 00 1eclaraia metodei
< ... >
...
int # $ /; 00 aria!ila utili3at ca parametru actual
?#?et,od ( out # ); 00 Ipelul metodei
c
4*03f3,a.*r6/ out
/semenea parametrilor referin, parametrii formali ai parametrilor de ieire acionea ca
aliasuri pentru parametrii actuali. Numele parametrilor formali i numele parametrilor actuali refer,
fiecare n parte, aceeai locaie de memorie. ,ste evident faptul c orice aciune asupra parametrilor
formali fcut n interiorul corpului metodei, va avea acelai efect asupra parametrilor actuali. 4pre
deosebire de parametrii referin, parametrii de ieire au urmtoarele caracteristici%
=<
&nui parametru de ieire trebuie s i se atribuie o valoare, n corpul metodei, nainte ca
acesta s fie folosit. /ceasta nseamn c valoarea iniial a parametrilor actuali este irelevant
i, din aceast cau, nu trebuie atribuite valori parametrilor actuali naintea apelului metodei.
Ciecare parametru de ieire trebuie iniialiat.
>eoarece parametrii de ieire trebuie iniialiai n corpul metodei, este inutil s fie
transmise date 'prin parametrii actuali1 n corpul metodei. &tiliarea unui parametru de ieire
naintea iniialirii acestuia produce eroare.
,3emplu%
pu!lic oid Idd.( out int outOalue )
<
int / $ outOalue B .; 008roare9^tili3area unui param de ie4ire
Znaintea iniiali3rii acestuia produce eroare.
>
,3emplu%
class ?#Class
< pu!lic int Oal $ .=; > 00 Aniiali3area c\mpului cu aloarea .=.
class @ro%ram <
static oid ?#?et,od(out ?#Class f/( out int f.( out int f*)<
f/ $ neV ?#Class(); 00 Crearea unui o!iect al clasei.
f/.Oal $ .5; 00 Itri!uirea unui alori c\mpului clasei.
00 f. $ f. B 5; 00 8roare 99
f. $ /5;
00 eroare 9 parametrul f* nu este initiali3at
>
static oid ?ain() <
?#Class I/ $ null;
int I.( I*;
?#?et,od(out I/( out I.( out I*); 00 Ipelul metodei.
>
>
Para4e.r33 0e .3- 9e,.*r
Caracteristicile importante ale parametrilor de tip vector sunt%
$oate e3ista numai un parametru de tip vector n lista de parametrii.
>ac e3ist unul, acesta trebuie s fie ultimul parametru din list.
$entru a declara un parametru de tip vector trebuie%
&tiliat modificatorul params naintea tipului de date.
0rebuie plasat un set de parantee drepte goale dup tipul de date.
/ntetul metodei preentate n continuare preint sinta3a pentru declararea unui parametru
de tip vector de ntregi.
9e,.*r 0e :+.re73
7
oid :istAnts( params intTU inOals )
< ... c c
4*03f3,a.*r +64e/e -ara4e.r6/63
=6
>
A-e/6/ 6+e3 4e.*0e ,e ,*+3+e -ara4e.r33 0e .3- 9e,.*r.
&n parametru actual de tip vector poate fi transmis unei metode n dou moduri%
6. $rintr#o list de elemente de tipul specificat n declararea metodei, separate prin virgul%
:istAnts( /=( .=( *= ); /ceast form se mai numete i forma e3pandat.
8. $rintr#o variabil de tip vector%
intTU intIrra# $ </( .( *>;
:istAnts( intIrra# );
/a cum se observ din e3emplele date, la apelul metodei nu se utiliea modificatorul
params.
2n e3emplul urmtor se observ c apelul metodei :istAnts poate fi fcut cu un numr
variabil de elemente.
oid :istAnts( params intTU inOals ) < ... > 00 1eclararea metodei
...
:istAnts( ); 00 = parametrii actuali
:istAnts( /( .( * ); 00 * parametrii actuali
:istAnts( )( 5( 6( ' ); 00 ) parametrii actuali
:istAnts( &( +( /=( //( /. ); 00 5 parametrii actuali
/tunci c"nd se apelea o metod cu parametru vector n forma e3pandat, compilatorul
face urmtoarele lucruri%
5a lista parametrilor actuali i o utiliea la crearea i iniialiarea unui vector n memoria heap.
!emorea referina ctre vector, n stiv n locaia parametrului formal.
>ac nu e3ist nu e3ist parametrii actuali n poiia corespuntoare parametrului formal de
tip vector, compilatorul creea un vector cu ero elemente.
,3emplu%
class ?#Class -ara4e.r33 0e .3- 9e,.*r
< 7
pu!lic oid :istAnts( params intTU inOals )
<
if ( (inOals 9$ null) PP (inOals.:en%t, 9$ =))
for (int i $ =; i < inOals.:en%t,; iBB)
<
inOalsTiU $ inOalsTiU G /=;
Console.Write:ine(;<=> ;( inOalsTiU);
>
>
>
class @ro%ram
<
static oid ?ain()
<
int first $ 5( second $ 6( t,ird $ ';
?#Class mc $ neV ?#Class();
mc.:istAnts( first( second( t,ird );
c
-ara4e.r33 a,.6a/3
=8
Console.Write:ine(;<=>( </>( <.>;( first( second( t,ird);
>
>
0abel cu sumarul tipurilor de parametrii
T3-6/
-ara4e.r6/63
M*03f3,a.*r
U.3/32a. /a
0e,/arare
U.3/32a. /a
3+9*,are
I4-/e4e+.are
.aloare Nu
Compilatorul copia parametrii actuali
in parametrii formali
(eferin ref >a >a
$arametrii formali devin alias ai
parametrilor actuali
>e ieire out >a >a
$arametrii formali devin alias ai
parametrilor actuali
>e tip vector params >a Nu
,ste permis transmiterea ctre metod a
unui numr variabil de parametrii
actuali.
(.J Crearea 9ar3a13/e/*r H3 3+;.a+e/*r 6+e3 ,/a;e
>eclararea unei clase este un ablon din care instanele clasei sunt create.
Clasele sunt tipuri referin, i prin urmare necesit memorie at"t pentru referina la date c"t i
pentru datele actuale.
(eferina la date este stocat ntr#o variabil de tip class. /stfel, pentru a crea o instan a clasei,
trebuie, pentru nceput, declarat o variabil de tip clas. >ac variabila nu este iniialiat,
valoarea sa este nedefinit.
A/*,area 4e4*r3e3 -e+.r6 0a.e
>eclararea unei variabile de tip clas aloc memorie pentru stocarea referinei, nu i pentru
datele actuale ale obiectului instaniat din clas. $entru a aloca memorie datelor actuale, trebuie
utiliat operatorul de instaniere new.
)peratorul neV aloc i iniialiea memorie pentru o instan a unui tip specificat. /cest
operator aloc memorie din memoria de tip stacY i memoria de tip heap, n funcie de tipul
variabilei. &tiliarea operatorului de instaniere new pentru crearea unui obiect const din%
Numele variabilei de tip clasM
4emnul N\LM
Cuv"ntul cheie neVM
Numele tipului de instan pentru care se aloc memorieM
$aranteele deschise care pot sau nu s conin parametrii.
Cuv"nt cheie parantee deschise
E E
Nume_aria!il $ neV J#peName( )
F
numele tipului
>ac alocarea memoriei este pentru un tip referin, e3presia de creare a unui obiect
returnea o referin ctre locaia de memorie de tip heap, unde este alocat i iniialiat instana.
1ealer t,e1ealer; 00 1eclararea aria!ilei pentru referin.
t,e1ealer $ neV 1ealer(); 00 Ilocarea memoriei pentru clasa o!iect.
=9
F
,3presia de creare a unui obiect
>eclararea unei variabile de tip clas i iniialiarea ei se pot face ntr#o singur declaraie%
>eclararea variabilei
E (
1ealer t,e1ealer $ neV 1ealer(); 00 1eclarare 4i iniiali3are (instanierea).
F
5niialiare 'instaniere1 cu sinta3a de creare a unui obiect
(.( Me41r33 6+e3 3+;.a+e
>eclararea unei clase produce un ablon din care se vor putea crea instane ale clasei
respective.
Me41r33 3+;.a+e3 ?nstance members1% Ciecare instan a unei clase este o entitate separat care
are propriul set de date membre, distincte fa de alt instan a aceleai clase. /cestea 'datele
membre1 sunt denumite 4e41r33 3+;.a+e3 ?instance members1, deoarece sunt asociai instanei
unei clase. &rmtorul e3emplu ilustrea un program cu trei instane ale clasei @la#er.
class 1ealer < ... > 00declararea clasei 1ealer
class @la#er < 00declararea clasei @la#er
strin% Name; 00 c\mp
...
>
class @ro%ram <
static oid ?ain()
<
1ealer t,e1ealer $ neV 1ealer();
@la#er pla#er/ $ neV @la#er();
@la#er pla#er. $ neV @la#er();
@la#er pla#er* $ neV @la#er();
...
>
>
(.K M*03f3,a.*r3 0e a,,e;
>in interiorul unei clase, orice funcie membru poate accesa oricare alt membru al clasei,
simplu prin numele membrului.
!odificatorul de acces 'access modifier1 este o parte opional din declaraia unui membru,
care specific care pri din program au acces la membru. !odificatorul de acces este plasat
naintea declaraiei unui membru. &rmtoarele sinta3e sunt folosite pentru c"mpuri i metode%
Cields%
Iccess?odifier J#pe Adentifier;
!ethods%
Iccess?odifier "eturnJ#pe ?et,odName ()
<
...
>
/cestor membri li se pot ataa urmtorii cinci modificatorii de acces%
=;
private
public
protected
internal
protected internal
(.7 A,,e;6/ -r39a. ;a6 -61/3,
!embrii care au specificatorul de acces priate sunt accesibili doar n clasa n care au
fost declarai O alte clase nu au acces la ei. /ccesul de tip priate este specificatorul implicit.
/stfel, dac un membru este declarat fr un modificator de acces, acesta este un membru privat.
>e e3emplu, urmtoarele dou declaraii specific membrii privai de tip ntreg%
int ?#Ant/; 00 1eclarare implicit
priate int ?#Ant.; 00 1eclarare eCplicit
c
!odificator de acces
!embrii care au specificatorul de acces public sunt accesibili tuturor obiectelor din
program.
!odificator de acces
E
pu!lic int ?#Ant;
,3emplu de accesare a membrilor unei clase%
class C/
<
int E/; 00 C\mp implicit priat
priate int E.; 00 C\mp declarat eCplicit priat
pu!lic int E*; 00 C\mp declarat pu!lic
oid 1oCalc() 00 ?etod implicit priat
<
...
>
pu!lic int ]etOal() 00 ?etod declarat pu!lic
<
...
>
>
,3emplu%
usin% D#stem;
class Iccess
<
00Oaria!ile declarate Znafara funciei ?ain.
int C $ /==;
int # $ .==;
>
class pro%ram
<
pu!lic static oid ?ain()
<
==
00Crearea unui o!iect
Iccess a $ neV Iccess();
00Ipelul instantei aria!ilelor
Console.Write:ine(a.C); 00 8roare( C nu e declarat pu!lic
Console.Write:ine(a.#); 00 8roare( # nu e declarat pu!lic
Console."ead:ine();
>
>
A,,e;area 4e41r3/*r 03+ 3+.er3*r6/ 6+e3 ,/a;e
!embrii unei clase pot fi accesai din interiorul acesteia utili"nd numele lor.
2n urmtorul e3emplu metodele unei clase accesea c"mpuri i alte metode ale aceleiai
clase%
class 1a#sJemp
<
00 C\mpuri
priate int ei%, $ '5;
priate int :oV $ )5;
00 ?etode
priate int ]etei%,()
<
return ei%,; 00 Iccess priate field
>
priate int ]et:oV()
<
return :oV; 00 Iccess priate field
>
pu!lic float Iera%e ()
<
return (]etei%,() B ]et:oV()) 0 .; 00 Iccesarea metodelor priate
> c c
> /ccesarea metodelor private
A,,e;area 4e41r3/*r 6+e3 ,/a;e 03+ afara a,e;.e3a
$entru a accesa din afara unei clase membrii publici ai acesteia, acetia trebuie apelai cu
numele variabilei de tip clas separat cu punct de numele membrului.
1a#sJemp m#1t $ neV 1a#sJemp(); 00 Crearea unui o!iect al clasei.
float fOalue $ m#1t.Iera%e(); 00 Iccesul din afara clasei.
F F
numele variabilei numele membrului
&rmtorul cod declar dou clase% 1a#sJemp i @ro%ram. >ou c"mpuri ale clasei
1a#sJemp sunt declarate public, prin urmare acestea vor putea fi accesate din afara clasei. 2n corpul
metodei !ain sunt create o variabil i un obiect al clasei 1a#sJemp, dup care sunt atribuite valori
c"mpurilor obiectului.
usin% D#stem;
class 1a#sJemp 00 declararea clasei 1a#sJemp
<
pu!lic int ei%, $ '5;
pu!lic int :oV $ )5;
>
class @ro%ram 00 declararea clasei @ro%ram.
<
=?
static oid ?ain()
<
1a#sJemp temp $ neV 1a#sJemp(); 00 crearea unui o!iect.
temp.ei%, $ &5; 00 atri!uire de alori c\mpurilor.
temp.:oV $ 6=;
Console.Write:ine(;ei%,S <=>;( temp.ei%, ); 00 citirea alorii unui c\mp.
Console.Write:ine(;:oVS <=>;( temp.:oV );
Console."ead:ine();
>
>
&rmtorul cod creea dou instane i stochea referina acestora n variabilele cu numele
t6 i t8%
usin% D#stem;
class 1a#sJemp 00 declararea unei clase.
<
pu!lic int ei%,( :oV; 00 declararea c\mpurilor.
pu!lic int Iera%e() 00 declararea unei metode.
<
return (ei%, B :oV) 0 .;
>
>
class @ro%ram
<
static oid ?ain()
<
1a#sJemp t/ $ neV 1a#sJemp();
1a#sJemp t. $ neV 1a#sJemp();
00 scriere de alori Zn c\mpurile fiecrei instane.
t/.ei%, $ '6; t/.:oV $ 5';
t..ei%, $ '5; t..:oV $ 5*;
00 citirea alorilor cZmpurilor fiecrei instane
Console.Write:ine(;t/S <=>( </>( <.>;( t/.ei%,( t/.:oV( t/.Iera%e() );
Console.Write:ine(;t.S <=>( </>( <.>;( t..ei%,( t..:oV( t..Iera%e() );
>
>
=7
=@
CAPITOLUL "I. PROBLEME RE$OL"ATE
K.1 AL)ORITMI ELEMENTARI
1. nterschimbai coninutul a dou numere de tip ntreg citite de la tastatur.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/
<
class @ro%ram
<
static oid ?ain()
<
int a( !( auC;
Console.Write(;Antroduceti primul numr a$ ;);
a $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti al doilea numr !$ ;);
! $ int.@arse(Console."ead:ine());
Console.Write:ine(;a$<=>( !$</>;( a( !);
auC $ a; a $ !; ! $ auC;
00o alta ersiune de intersc,im!are fara aria!ila suplimentara
00 a $ a F !; ! $ a B !; a $ ! F a;
Console.Write(;1upa intersc,im!are a$<=>( !$</>;(a(!);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
# pe prima linie n corpul funciei principale se declar trei variabile ntregi% a, b i aux M
# se foloseste de dou ori perechea de funcii *onsole.+rite"$, int.)arse"*onsole.'ead-ine"$$
pentru a afia un mesaj pe ecran i apoi pentru a citi cele dou valori ntregi de la tastatur, care vor
fi depuse n variabilele a, respectiv bM deoarece numerele citite de la tastatur se introduc n valori
de tip int, funcia de citire de la tastatur *onsole.'ead-ine"$ trebuie nsoit de transformarea
intrrii de tip 4tring n int cu ajutorul funciei int.)arse"$M
# urmea trei instruciuni de atribuire, care mpreun formea Nmetoda celor trei pahare[M
# se afiea reultatul, folosind un apel de funcie *onsole.+rite"$M observm c se va tipri pe
ecran at"t ir de caractere c"t i dou secvene de tipul UkV, care la tiprire se vor nlocui cu
valorile din variabilele a, respectiv bM
# urmea un apel al funciei *onsole.'ead.e("$ care va ine ecranul de )utput viibil p"n la
apsarea unei taste. 2n lipsa ei, acesta dispare imediat dup afiarea reultatelor.
Efe,.
$rimul numr% 6=
/l doilea numr% 86
>up interschimbare% a\86 b\6=
=:
. / se re0olve ecuaia de gradul de forma ax1b20% cu coeficieni numere reale.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.
<
class @ro%ram
<
static oid ?ain()
<
float a( !( C;
Console.Write(;Antroduceti a$;);
a $ float.@arse(Console."ead:ine());
Console.Write(;Antroduceti !$;);
! $ float.@arse(Console."ead:ine());
if (a $$ =)
if (! $$ =) Console.Write:ine(;8cuatie nedeterm;);
else
Console.Write:ine(;8cuatie imposi!ila;);
else
<
C $ F ! 0 a;
Console.Write:ine(;Dolutia este C$<=>;(C);
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
2n vederea realirii unei reolvri riguroase, nainte de a afla soluia banal 3\#bSa,
trebuiesc fcute nite teste asupra valorilor a i b. /stfel dac a\< i b\< avem de a face cu o
ecuaie nedeterminat, iar dac a\< i bl< avem de a face cu o ecuaie imposibil. /cestea sunt
cauri particulare care trebuiesc tratate. 2n caul n care al< se poate e3trage soluia dup formula
cunoscut 3\#bSa, iar aceast soluie este tiprit i pe ecran cu ajutorul funciei
*onsole.+rite-ine"$. $entru a avea instrumentele necesare calculului, n prim fa se vor citi de la
tastatur valorile reale a i b, dup care se trece la gsirea soluiei. 4e observ ca pentru
raionamentul enunat mai sus, au fost folosite n program dou instruciuni if3else cu ajutorul crora
se testea valorile lui a i b.
!. / se re0olve o ecuaie de gradul de forma ax
2
1bx1c20% cu coeficieni numere reale.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*
<
class @ro%ram
<
static oid ?ain()
<
float a( !( c( delta;
dou!le C/( C.;
?<
Console.Write(;Antroduceti a$;);
a $ float.@arse(Console."ead:ine());
Console.Write(;Antroduceti !$;);
! $ float.@arse(Console."ead:ine());
Console.Write(;Antroduceti c$;);
c $ float.@arse(Console."ead:ine());
if (a $$ =)
if (! $$ =)
if (c$$=) Console.Write:ine(;8cuatie nedet.;);
else Console.Write:ine(;8cuatie imposi!ila;);
else
<
C/ $ Fc 0 !;
Console.Write:ine(;8cuatia este de %radul / cu C/$<=>;( C/);
>
else
<
delta $ ! G ! F ) G a G c;
if (delta < =)
Console.Write:ine(;8c. are solutii compleCe;);
else
<
if (delta $$ =)
<
C/ $ C. $ F! 0 (. G a);
Console.Write:ine (;C/$C.$<=>;( C/);
>
else
<
C/ $ (F! B ?at,.Dfrt(delta)) 0 (. G a);
C. $ (F! F ?at,.Dfrt(delta)) 0 (. G a);
Console.Write:ine(;Dolutiile sunt C/$<=>( C.$</>;( C/(
C.);
>
>
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
2n vederea realirii unei reolvri riguroase, nainte de a afla soluia banal dat de formula
3
6,8
\'#b^ 1S'8Ta1, unde m\b
8
#;ac, trebuiesc fcute nite teste asupra valorilor a, b, c.
4e detectea urmtoarele situaii%
# dac a\<, b\<, c\< avem de#a face cu o ecuaie nedeterminat
# dac a\<, b\<, cl< aveam de#a face cu o ecuaie imposibil
# dac a\<, bl<, iar c are orice valoare, avem de#a face cu o ecuaie de gradul 5, situaie n care
e3ist o singur soluie 3\#cSb
/cestea sunt cauri particulare care trebuiesc tratate.
# dac al<, iar b i c au orice valoare, avem de#a face cu o ecuaie de gradul 55, situaie n care se
poate trece la calculul lui m. &rmea acum o alt discuie dup valoarea lui m.
/stfel% # dac m`< avem de#a face cu soluii comple3e 'pe care n aceast reolvare nu le vom mai
?6
calcula ci vom afia doar un mesaj1
# dac m\< ecuaia are dou soluii egale% 3
6,8
\#bS'8Ta1
# dac ma< ecuaia are dou soluii diferite%
3
6,8
\'#b^ 1S'8Ta1
4e observ c pentru raionamentul enunat mai sus, au fost folosite n program trei
instruciuni if3else imbricate 'if inclus n alt if1 cu ajutorul crora se testea valorile lui a, b i c.
$uin atenie trebuie acordat e3presiilor #bS'8Ta1 i '#b^ 1S'8Ta1 deoarece lipsa
paranteelor din aceste e3presii poate duce la reultate greite. ,rorile pot aprea din cau c n
aceste e3presii apar operatorii T i S care au aceeai prioritate. /stfel, n lipsa vreunei parantee ei s#
ar e3ecuta n ordinea n care apar n e3presie, lucru care nu este de dorit n acest ca.
J. /criei un program care prime4te la intrare un numr de secunde 4i ntoarce numrul maxim de
ore% de minute% de secunde care este echivalent ca timp.
,3emplu% 79@; secunde este echivalent cu 8 ore, 9 minute i ; secunde.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)
<
class @ro%ram
<
static oid ?ain()
<
int secunde( ,( m( s;
Console.Write(;Antroduceti numrul de secunde S ;);
secunde $ int.@arse(Console."ead:ine());
m $ secunde 0 6=;
s $ secunde H 6=;
, $ m 0 6=;
m $ m H 6=;
Console.Write(;<=> secunde;(secunde);
Console.Write(;repre3 <=> ore( </> minute 4i <.> secunde;( ,( m( s);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/ceast problem este una simpl care implic c"teva calcule. /stfel, n prima fa se
calculea c"te minute repreint secundele date de problem. (estul mpririi secundelor iniiale
la ?< repreint c"te secunde nu pot forma un minut ntreg 's1. !inutele obinute se mpart i ele la
?< pentru a afla c"te ore repreint acele minute 'h1. (estul mpririi minutelor la ?< repreint
c"te minute nu pot forma o or ntreag 'm1.
(. /criei un program care simulea0 un calculator electronic pentru numere ntregi5 se introduc
dou numere ntregi 4i o operaie care poate fi 1% 3% 6% ,% repre0ent7nd adunarea% scderea%
nmulirea 4i c7tul.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication5 <
class @ro%ram
<
?8
static oid ?ain()
<
int a(!(re3 $ =;
c,ar op;
s,ort oL $ /;
Console.Write(;@rimul numr S ;);
a $ int.@arse(Console."ead:ine());
Console.Write(;Il doilea numr S ;);
! $ int.@arse(Console."ead:ine());
Console.Write(;Mperatia dorita (B F G 0) S ;);
op $ c,ar.@arse(Console."ead:ine());
sVitc, (op)
<
case -B-S re3 $ a B !; !reaL;
case -F-S re3 $ a F !; !reaL;
case -G-S re3 $ a G !; !reaL;
case -0-S
if (! 9$ =) re3 $ a 0 !;
else
<
Console.Write:ine(;Ampartire la =9;);
Console."eadde#();
return;
>
!reaL;
defaultS oL $ =; !reaL;
>
if (oL $$ /) Console.Write:ine(;<=> </> <.> $ <*>;( a( op( !( re3);
else Console.Write:ine(;Mperator inalid;);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
# se declar numerele ntregi a, b i re0 de tip int, repreent"nd operanii i reultatulM
# se declar caracterul op de tip char, repreent"nd operaia care se va e3ecutaM
# se declar variabila o8 de tip short, care va rm"ne l dac operaia se termin cu succes, altfel i se
va atribui < M
# av"nd n vedere ca va trebui s comparm valoarea reinut de variabila op cu mai multe valori,
folosim instruciunea de selecie s9itch. /vem ; ramuri case, una pentru fiecare din valorile E, #,
T, S i ramura default pentru caurile n care op are orice alt valoare nafara celor ; enumerate
anterior, moment n care oY ia valoarea <.
2n caul n care op are una din valorile E, #, T, se efectuea operaia corespuntoare, iar
reultatul se depune n variabila re0. 2n caul n care op are valoarea S, prima dat se va testa cu
ajutorul unei instruciuni if, valoarea celui de#al doilea operand, deoarece dac el este <, mprirea
nu se poate realia, ca n care se va afia pe ecran un mesaj corespuntor. >ac valoarea lui b este
diferit de <, se procedea ca i n caul operaiilor E, #, T.
+a final, n cadrul unei instruciuni if se testea valoarea variabilei o8. >ac o8 a rmas l,
atunci se va afia operaia efectuat mpreuna cu reultatul, altfel se va tipri un mesaj c operatorul
introdus de la tastatur nu este unul valid.
?9
Efe,.
Ca 6%
$rimul numr% 6=
/l doilea numr% 87
)peratia dorita 'E # T S1% E
6= E 87 \ ;8
Ca 8%
$rimul numr% 89
/l doilea numr% <
)peratia dorita 'E, #, T, S1% S
5mpartire la < K
Ca 9%
$rimul numr% 9@
/l doilea numr% 8
)peratia dorita 'E, #, T, S1% b
)perator invalidK
K. :nmulirea a dou numere naturale prin adunri repetate.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication6
<
class @ro%ram
<
static oid ?ain()
<
int a( !( produs$=;
Console.Write(;Antroduceti a$;);
a $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti !$;);
! $ int.@arse(Console."ead:ine());
for (int i $ /; i <$ !; iBB)
produs B$ a;
Console.Write:ine(;<=> G </> $ <.>;( a( !( produs);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
4e tie nc din clasele elementare c nmulirea nseamn de fapt nite adunri repetate.
/stfel, aTb nseamn a adunat de b ori sau b adunat de a ori.
>eoarece se tie c a trebuie adunat de e3act b ori pentru a se obine reultatul dorit, se
utiliea instruciunea for care are un numr determinat de pai 'de c"te ori se repet un set de
instruciuni1. .aloarea a se adun se b ori n variabila p% care la final va conine reultatul cutat
'a6b1. .ariabila produs este iniialiat cu < dup care i se va aduga n cadrul instruciunii for c"te
un a.
?;
7. :mprirea a dou numere prin scderi repetate.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication'
<
class @ro%ram
<
static oid ?ain()
<
int a( !( a/ $ =( c$=( r$=;
Console.Write(;Antroduceti a$;);
a $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti !$;);
! $ int.@arse(Console."ead:ine());
a/ $ a;
V,ile (a/ >$ !)
<
a/ F$ !; 00a/$a/F!;
cBB;
>
r $ a/;
Console.Write:ine(;<=>S</>$<.> rest <*>;( a( !( c( r);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
4e tie nc din clasele elementare c mprirea nseamn de fapt nite scderi repetate.
/stfel, a%b nseamn b sc0ut de c ori i este posibil s e3iste i un restg<, b#6h. Nu se tie de c"te
ori se va scdea b din a, acest lucru se va afla doar la final, de asemenea i eventualul rest. 2n acest
sens, pentru a repeta scderea se va utilia o instruciune repetitiv cu numr necunoscut de pai i
anume 9hile. Condiia ca scderea s se mai repete este ca a;2b. >e fiecare dat c"nd se mai face
o scdere se va incrementa variabila c, care n final va repreenta c"tul. .aloarea care rm"ne n
final n a repreint restul.
.ariabilele c i r se iniialiea cu <, urm"nd ca la final s conin c"tul 'obinut n cadrul
ciclului 9hile1 i restul mpririi. >eoarece valoarea lui a se alterea n timpul calculului, dac se
dorete se poate face o copie a sa nainte de a intra n ciclul 9hile.
M. / se ghiceasc un numr ntreg din intervalul 1 < 100.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication&
<
class @ro%ram
<
static oid ?ain()
<
"andom sol $ neV "andom();00%eneram un numr
int solutie $ sol.NeCt(/==);00aleator ca 4i solutie
int n;
do
?=
<
Console.Write(;1ati un numr intre = 4i /==S ;);
n $ int.@arse(Console."ead:ine());
if (n < solutie)
Console.Write:ine(;Numrul e prea mic9;);
else if (n $$ solutie)
<
Console.Write:ine();
Console.Write:ine(;["IOM9 Iti %,icit9;);
>
else Console.Write:ine(;Numrul e prea mare9;);
>
V,ile (n 9$ solutie);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/cesta este un e3emplu de utiliare a instruciunii repetitive do39hile cu numr
nedeterminat de pai. 4e setea din program o valoare din intervalul <#6<< 'n variabila soluie1
care urmea s fie ghicit de ctre utiliator pe baa indicaiilor mai mare sau mai mic pe care le
va primi. $entru generarea numerelor aleatoare s#a creat un obiect sol din clasa 'andom dup care
s#a generat un numr aleator din intervalul <#6<< cu ajutorul metodei =ext, valoare care a fost
atribuit variabilei soluie.
/t"ta timp c"t soluia nu este ghicit, dac se introduce de la tastatur o valoare mai mic
dec"t soluia se va afia mesajul >=umrul e prea mic?% altfel se va afia mesajul >=umrul e prea
mare?, iar dac se ghicete se va afia mesajul >@'AAOB Ati ghicit B? i programul se ncheie.

'. / se calcule0e nB21626C6D6n "factorialul lui n$% pentru un n natural citit de la tastatur.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication+
<
class @ro%ram
<
static oid ?ain()
<
s,ort n( i;
lon% fact$/;
Console.Write(;Antroduceti n$;);
n$int.@arse(Console."ead:ine());
for (i $ /; i <$ n; iBB)
fact G$ i; 00fact $ fact G i;
Console.Write:ine(;<=>9 $ </>;( n( fact);
Console."eadde#();
>
>
>
??
A+a/32a -r*7ra46/63
nK nseamn nmulirea tuturor numerelor naturale de la 6 p"n la n. /ceasta nseamn c
trebuiesc parcurse toate valorile de la 6 la n i trebuiesc nmulite. $entru aceasta este potrivit
instruciunea for cu limitele 6 i n. +a fiecare pas al lui for o valoare i din intervalul g6,nh va fi
nmulit la fact.
.ariabila fact este iniialiat cu 6 i la final, n urma nmulirilor repetate va conine
valoarea factorialului lui n. >eoarece factorialul are o cretere foarte rapid, variabila fact a fost
declarat de tip long 'cel mai mare interval de numere ntregi din C#1.
1O. *alculai suma cifrelor unui numr natural dat cu maximum E cifre.
Ra3*+a4e+.
$entru a reolva aceast problem trebuie s ne folosim de IunelteleL de care dispunem p"n
n acest moment. $roblema care se pune este cum s obinem cifrele individuale ale numrului dat.
) modalitate simpl i usor de implementat este de a ncepe IrupereaL numrului n cifre ncep"nd
cu cea mai din dreapta 'cea mai nesemnificativ1, fapt care se poate realia calcul"nd restul
mpririi la 6< a numrului dat. 2n acest fel se face primul pas. 0rebuiesc ns obinute toate cifrele
numrului, n vederea nsumrii lor. /cest lucru l vom realia n acelai mod n care am obinut
prima cifr i anume% dup obinerea primei cifre, vom mpri numrul dat la 6<M aceast operaie
va avea ca i efect IpierdereaL ultimei cifre din numrul iniial. 2n continuare, pentru numrul nou
obinut calculm restul mpririi la 6< i vom obine ca i mai sus, ultima cifr a sa, pe care o vom
aduga#o la sum. >ac mergem puin napoi vom observa c aceast a dou cifr obinut
repreint de fapt penultima cifr a numrului iniial. .om continua acest raionament de mprire
a numerelor i de adugare a ultimei cifre la suma p"n c"nd la o mprire la 6< vom obine c"tul <.
2n acel moment vom ti suma tuturor cifrelor numrului iniial.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/= <
class @ro%ram
<
static oid ?ain()
<
int n( m( suma $ =;
Console.Write(;1ati un numr de maCim + cifre S ;);
n $ int.@arse(Console."ead:ine());
m $ n;
V,ile (m 9$ =)
<
suma B$ m H /=; 00 suma$sumaBmH/=;
m 0$ /=; 00 m$m0/=;
>
Console.Write:ine(;Duma cifrelor lui <=> este </>;( n( suma);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
# pe prima linie sunt declarate variabilele m i n de tip ntreg i variabila s, n care vom calcula
suma cifrelor lui n 'observam iniialiarea acesteia de la declarare cu <, deoarece nsumarea cifrelor
?7
se va face pornind de la <1M
# citirea de la tastatur numrului nM
# lui m i se atribuie variabila n, pentru a nu pierde valoarea nM aceasta este o tehnica utiliata
ntotdeauna c"nd avem de modificat valoarea reinut de o variabila, ns nu dorim sa pierdem
valoarea iniial. >ac nu am folosi atribuirea m\n, am mprit variabila n la 6< p"n c"nd
valoarea acesteia ar deveni < i evident nu am mai ti care a fost valoarea iniial. &tili"nd nsa
atribuirea m\n, valoarea lui n rm"ne nealterata.
# urmea o instruciune 9hile care conine dou instruciuni de atribuire compus 'n prima se
adaug la s ultima cifr a lui m, iar n a dou se trunchia m de ultima cifr1M aceste instruciuni se
repet p"n c"nd m va avea valoarea < M
# se afiea reultatul folosind o funcie *onsole.+rite-ine"$M se vor afia valorile reinute de
variabilele n i s.
Efe,.
5ntroducei numrul% 8;7
4uma cifrelor lui 8;7 este 69.
E>e4-/6 0e f6+,3*+are -a; ,6 -a; a -r*7ra46/63
4a consideram ca n\8;7
&rmrind linie cu linie programul de mai sus vom obine%
s\<
>ai un numr de ma3im : cifre% 8;7
m\8;7
m\8;7 K\ <
s\sE8;7_6< s\<E7\7
m\mS6< m\8;
m\8; K\ <
s\sE8;_6< s\7E;\66
m\mS6< m\8
m\8 K\ <
s\sE8_6< s\66E8\69
m\mS6< m\<
m\< \a s\69
4uma cifrelor lui 8;7 este 69.
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/=!
<
class @ro%ram
<
static int suma(int nr)
<
int s $ =;
V,ile (nr 9$ =)
<
s B$ nr H /=;
nr 0$ /=;
>
return s;
?@
>
static oid ?ain()
<
int n;
Console.Write(;1ati un numr de maCim + cifre S ;);
n $ int.@arse(Console."ead:ine());
Console.Write:ine(;Duma cifrelor lui <=> este </>;( n( suma(n));
Console."eadde#();
>
>
>
11. / se scrie un program care s calcule0e Fcifra de control? a unui numr natural. Aceasta se
obine nsum7nd cifrele numrului 4i dac suma obinut este ;210 se repet algoritmul p7n
c7nd se obine o sum format dintr3o singur cifr "deci un numr G10$.
,3% n\::@:@7: n s\:E:E@E:E@E7E:\=: n s\=E:\6; n ;\6E;\(
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication// <
class @ro%ram
<
static int suma(int nr)
<
int s $ =;
V,ile (nr 9$ =)
<
s B$ nr H /=;
nr 0$ /=;
>
return s;
>
static oid ?ain()
<
int n( control;
Console.Write(;1ati un numr de maCim + cifre S ;);
n $ int.@arse(Console."ead:ine());
do
<
Console.Write(; F> ;);
control $ suma(n);
Console.Write(control);
n $ control;
> V,ile (control >$ /=);
Console.Write:ine(;anCifra de control a nr de mai sus este <=>;(
control);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
se citete numrul n de la tastatur
pornind de la numrul iniial, cu ajutorul instruciunii 9hile, se calculea suma cifrelor
?:
numrului at"ta timp c"t ea este a\6<M dac este a\6< se va calcula suma cifrelor pentru acest
nou numr. Calculul de oprete n momentul n care suma obinut este `6<, iar aceasta va
repreenta Icifra de controlL a numrului iniial
funcia suma calculea suma cifrelor unui numr primit ca i parametru i returnea valoarea
obinut
1. /e cite4te de la tastatur un numr natural n9. / se afi4e0e toate numerele de n cifre care
adunate cu rsturnatul lor dau un ptrat perfect.
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/. <
class @ro%ram
<
static int rasturnat(int nr)
<
int r $ =;
V,ile (nr 9$ =)
<
r $ (rG/=)Bnr H /=;
nr $ nr0/=;
>
return r;
>
static oid ?ain()
<
int sum( rsum( n( i( start( stop;
Console.Write(;Cate cifreR ;);
n $ int.@arse(Console."ead:ine());
start$(int)?at,.@oV(/=( nF/);
stop$(int)?at,.@oV(/=( n);
for (i $ start; i < stop; iBB)
<
sum $ i B rasturnat(i);
rsum $ (int)?at,.Dfrt(sum);
if ( (rsumGrsum) $$ sum)
Console.Write:ine(;<=> B </> $ <.> este patrat perfectS
<*>X.;( i(rasturnat(i)(sum(rsum);
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
4e citete de la tastatur numrul de cifre n. Conform acestuia, verificrile se vor face pe
intervalul de valori g6<
n#6
,6<
n
#6h ',3% n\9 g6<<, :::h1. $entru a ridica pe 6< la o putere se
folosete metoda !ath.)o9, creia i se mai aplic suplimentar i operatorul de cast "int$ deoarece
reultatul returnat de metoda !ath.)o9 este de tip double i nu ar fi posibil atribuirea unei astfel
de valori la o variabil de tip int.
7<
Cu ajutorul instruciunii for se parcurg toate valorile de la 6<
n#6
la 6<
n
#6. Ciecare din ele se
adun cu rsturnatul lor. (sturnatul se obine cu ajutorul unei funcii care este asemntoare cu cea
de obinere a sumei cifrelor unui numr.
$entru a testa dac suma dintre un numr i rsturnatul su este ptrat perfect se procedea
astfel% 4e calculea n variabila rsum radicalul sumei cu ajutorul metodei !ath./Hrt, creia i se mai
aplic suplimentar i operatorul de cast "int$ deoarece reultatul returnat de metoda !ath./Hrt este
de tip double i nu ar fi posibil atribuirea unei astfel de valori la o variabil de tip int. 4e testea
apoi dac ptratul acestei valori este egal cu suma dintre numr i rsturnatul su ',3 6% i\9;?,
rasturnat'i1\?;9, sum\:@:, rsum\96, rsumTrsum\:?6 :@:, deci nu are loc egalitateaM ,3 8% i\6?;,
rasturnat'i1\;?6, sum\?8=, rsum\8=, rsumTrsum\?8?\?8=, deci are loc egalitatea1.
1!. /e citeste de la tastatur un 4ir de numere ntregi p7n la citirea lui 0. / se afi4e0e valoarea
minim 4i maxim citit 4i media lor aritmetica "fr vectori$.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/*
<
class @ro%ram
<
static oid ?ain(strin%TU ar%s)
<
int nr( min( maC( tot$/;
float sum( ma;
Console.Write:ine(;De or citi numere pana la intr. lui =;);
Console.Write(;1ati un numrS ;);
nr $ int.@arse(Console."ead:ine());
min $ maC $ nr;
sum $ nr;
do
<
if (nr < min)
min $ nr;
if (nr > maC)
maC $ nr;
Console.Write(;1ati un numrS ;);
nr $ int.@arse(Console."ead:ine());
sum $ sum B nr;
totBB;
> V,ile (nr 9$ =);
totFF;
ma $ sum 0 tot;
Console.Write(;min$<=>( maC$</>( media aritm.$<.>;( min( maC( ma);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
2n prima fa se citete de la tastatur primul numr i se iniialiea minimul, ma3imul i
suma numerelor cu aceast valoare. $entru ca la final s se poat calcula media aritmetic a
numerelor introduse, se folosete variabile tot care iniial are valoarea 6 i care se va incrementa cu
6 la citirea fiecrui nou numr.
76
2n cadrul unei instruciuni repetitive do39hile se vor citi numere de la tastatur p"n la
introducerea lui <. Cu fiecare numr nou citit se fac c"teva operaii% se compar cu minimul curent
i dac este mai mic dec"t acesta se actualiea minimul, se compar cu ma3imul curent i dac
este mai mare dec"t acesta se actualiea ma3imul, se adun la suma numerelor.
>up ce s#a citit de la tastatur valoarea <, se decrementea cu 6 valoarea variabilei tot
pentru a e3clude ultima valoare citit care era < i care nu mai ia parte la calcule, dup care se
calculea media aritmetic, mprind suma numerelor citite la totalul lor. 4e observ c variabila
sum a fost declarat de tip float dei ea conine suma unor numere ntregi. 4#a apelat la acest
artificiu deoarece dac era declarat de tip int i la final efectuam operaia sum S tot, aceasta
implic"nd numere ntregi, ddea tot un numr ntreg ',3% 87S=\=, dei media aritmetic era =.;1.
Colosind ns variabila sum de tip float, reultatul operaiei sum S tot va fi i el de tip float, adic
e3act ceea ce avem nevoie.
+a final se afiea valoare minim, ma3im i media aritmetic.
4e sublinia n enun ca reolvarea s nu implice vectori, deoarece se observ c ei nu sunt
necesari pentru a memora toate valorile introduse de la tastatur. ,ste suficient o variabil simpl
cu ajutorul creia se va citi c"te o valoare, se fac operaiile necesare, dup care poate stoca o nou
valoare, cea veche nemaifiind necesar.
1J. &iind date dou numere naturale n 4i m% s se forme0e un nou numr care s conin cifrele
maxime de pe fiecare po0iie din n 4i m. ,3% n\8?6@, m\9;=? n 9?=@
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/)
<
class @ro%ram
<
static oid ?ain()
<
int n( m( maC $ =( p/= $ /( cifra;
Console.Write(;Antroduceti primul numrS ;);
n $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti al doilea numrS ;);
m $ int.@arse(Console."ead:ine());
V,ile (n 9$ = QQ m 9$ =)
<
if (n H /= > m H /=)
cifra $ n H /=;
else
cifra $ m H /=;
maC $ maC B cifra G p/=;
p/= G$ /=;
n 0$ /=;
m 0$ /=;
>
Console.Write:ine(;Noul numr este S <=>;( maC);
Console."eadde#();
>
>
>
78
)bservaie %
if ((nH/=)>(mH/=))
cifra $ nH/=;
else cifra$(nH/=)>(mH/=) R nH/= S mH/=;
cifra $ mH/=;
A+a/32a -r*7ra46/63
/ceast problem deriv i ea din problema aflrii cifrelor unui numr natural. (eolvarea
acestei probleme merge pe ideea de a descompune n paralel cele dou numere n i m, p"n c"nd
ambele devin < 'e posibil ca acest lucru s se nt"mple n momente diferite dac cele dou numere
nu au acelai numr de cifre1.
Cifrele de pe aceeai poiie obinute din cele dou numere se compar i care este mai mare
va face parte din numrul care se dorete s se obin.
Noul numr max se obine printr#un procedeu invers celui de obinere a cifrelor unui numr,
n sensul c de data aceasta c"te o cifr ma3im obinut de la cele dou numere iniiale se
nmulete cu 6< la o anumit putere corespuntoare poiiei cifrei n numrul max 'prima cifr #
cea mai din dreapta # se nmulete cu 6<
<
, a dou cifr cu 6<
6
, a treia cu 6<
8
, .a.m.d.1 i se
nsumea. 2nmulirea cu 6< la o putere corespuntoare ajut a plasa o cifr n poiia care trebuie
n numrul care se dorete s se obin max.
4e observ c nu s#a folosit metoda !ath.)o9, ci s#a aplicat o metoda optimiat din punct
de vedere al calculelor, folosind variabila p10 n construirea valorii 6<
putere
. .ariabila p10 are la
nceput valoarea 6 i pe parcurs, prin nmulire cu 6< va avea valoarea 6<
6
, 6<
8
, etc. /ceasta este o
variant mai bun dec"t a folosi metoda !ath.)o9, care pentru a calcula 6<
putere
folosete mai mult
de o nmulire, pe c"nd varianta utiliat n acest program folosete numai una, av"nd deja calculat
de la pasul anterior 6<
putere#6
.
,3emplu % n\8?6@, m\9;=?
'@,?1 n @T6<
<
E
'6,=1 n =T6<
6
E n @E=<E?<<E9<<<\9?=@
'?,;1 n ?T6<
8
E
'8,91n 9T6<
9
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/)!
<
class @ro%ram
<
static int cifre_maCime(int n/( int n.)
<
int n* $ =( cifra( p/= $ /;
V,ile (n/ 9$ = QQ n. 9$ =)
<
if (n/ H /= > n. H /=)
cifra $ n/ H /=;
else
cifra $ n. H /=;
n* B$ cifra G p/=;
p/= G$ /=;
n/ 0$ /=;
n. 0$ /=;
>
return n*;
>
79
static oid ?ain()
<
int n/( n.;
Console.Write(;Antroduceti primul numrS ;);
n/ $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti al doilea numrS ;);
n. $ int.@arse(Console."ead:ine());
Console.Write:ine(;Numrul format este <=>;( cifre_maCime(n/( n.));
Console."eadde#();
>
>
>
1(. / se determine c.m.m.d.c. a dou numere naturale. "2 variante$
.arianta 6%
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/5
<
class @ro%ram
<
static oid ?ain()
<
int nr/( nr.( n( m;
Console.Write(;Antroduceti primul numrS ;);
nr/ $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti al doilea numrS ;);
nr. $ int.@arse(Console."ead:ine());
n $ nr/; m $ nr.;
V,ile (nr/ 9$ nr.)
if (nr/ > nr.)
nr/ F$ nr.;
else
nr. F$ nr/;
Console.Write:ine(;C.m.m.d.c.(<=>(</>) $ <.>;( n( m( nr/);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/ceasta este o metod foarte simplu de aplicat i de reinut n aflarea c.m.m.d.c. a dou
numere, ns probabil necesit mai multe calcule dec"t ali algoritmi.
5deea acestui algoritm este urmtoarea% at"ta timp c"t cele dou numere date sunt diferite,
din cel mai mare se scade cel mai mic, iar prin acest procedeu la un moment dat cele dou numere
vor deveni egale. /cea valoare final pe care o au ambele numere repreint c.m.m.d.c. al lor.
/v"nd n vedere faptul c ambele numere vor fi alterate n acest calcul, pentru a nu pierde
valoarea lor iniial, nainte de instruciunea 9hile se poate face c"te o copie a lor cu care s se
lucree mai departe.
7;
.arianta 8%
Algoritmul lui Iuclid
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/5! <
class @ro%ram <
static oid ?ain()
<
int nr/( nr.( temp( r( n( m;
Console.Write(;Antroduceti primul numrS ;);
nr/ $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti al doilea numrS ;);
nr. $ int.@arse(Console."ead:ine());
n $ nr/; m $ nr.;
if (nr/ < nr.)
<
temp $ nr/;
nr/ $ nr.;
nr/ $ temp;
>
do
<
r $ nr/ H nr.;
nr/ $ nr.;
nr. $ r;
> V,ile (r 9$ =);
Console.Write:ine(;C.m.m.d.c.(<=>(</>) $ <.>;( n( m( nr/);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/cesta este un algoritm destul de celebru de determinare a c.m.m.d.c a dou numere
naturale. 5deea pe care se baea ns este puin mai dificil dec"t cea a primului algoritm
preentat, ns cel mai probabil c necesit mai puin calcul.
$rima dat se citesc cele dou numere i se asigur c primul dintre ele este cel mai mare.
5deea algoritmului lui ,uclid este de a ncepe prin a mpri numrul mai mare din perechea
de numere date, la cel mai mic. >ac restul obinut este diferit de <, se repet mprirea, de data
aceasta mprindu#se mpritorul la restul de la mprirea anterioar. /cest mecanism se repet
p"n c"nd se obine restul <. 2n acel moment este aflat c.m.m.d.c., iar el este penultimul rest obinut
'nenul1.
2n caul n care se obine din start restul < nseamn c numrul mai mic din cele dou
repreint c.m.m.d.c.
,3 % '?<, 8=1\=
?< % 8=\8 rest 6=
8= % 6=\6 rest 6<
6= % 6<\6 rest (
6< % =\8 rest <
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/5c <
7=
class @ro%ram <
static int cmmdc(int n/( int n.)
<
int r;
do
<
r $ n/ H n.;
n/ $ n.;
n. $ r;
> V,ile (r 9$ =);
return n/;
>
static oid ?ain()
<
int a( !( temp;
Console.Write(;Antroduceti primul numrS ;);
a $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti al doilea numrS ;);
! $ int.@arse(Console."ead:ine());
if (a < !)
<
temp $ a;
a $ !;
! $ temp;
>
Console.Write:ine(;C.m.m.d.c.(<=>(</>) $ <.>;( a( !( cmmdc(a( !));
Console."eadde#();
>
>
>
1K. / se afi4e0e toi divi0orii "proprii$ comuni a dou numere naturale.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/6
<
class @ro%ram
<
static oid ?ain()
<
int m( n( c;
Console.Write(;Antroduceti primul numrS ;);
m $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti al doilea numrS ;);
n $ int.@arse(Console."ead:ine());
if (m >$ n) c $ n 0 .;
else c $ m 0 .;
Console.Write:ine(;1ii3orii comuni pentru <=> 4i </>;( m( n);
for (int i $ .; i <$ c; iBB)
if ((n H i $$ =) PP (m H i $$ =))
Console.Write(i B ; ;);
Console."eadde#();
>
>
>
7?
A+a/32a -r*7ra46/63
C"nd se pune problema determinrii diviorilor unui numr n, la nceput se pune ntrebarea%
n ce mulime de valori de va face cutarea diviorilorA &n rspuns ar putea fi intervalul g6, nh. 2n
caul n care nu dorim i diviorii impropri '6 i numrul nsui1 ar rm"ne intervalul g8, n#6h. 2n
situaia aceasta ns ar trebui s ne punem ntrebarea% care este cel mai mare divior propriu al unui
numr nA Cr prea multe dificulti ar trebui s realim c aceast valoare este la jumtatea
numrului, deoarece aceasta nmulit cu 8 ar da numrul n. >e la jumtate ncolo, orice valoare am
nmuli cu 8, va trece de valoarea lui n, deci nu mai are cum s fie divior al lui n. /stfel, deducem
c diviorii proprii i vom cuta n intervalul g8, nS8h.
2n problema de fa, av"nd de#a face cu diviorii a dou numere, din nou trebuie luat o
deciie asupra intervalului n care se vor cuta diviorii comuni. /r putea aprea mai multe variante
de rspuns, ns cea corect este de a cuta n intervalul de la 8 p"n la jumtatea numrului mai
mic din cele dou. >e ce p"n la jumtatea numrului mai micA >eoarece dac de e3emplu s#ar
merge p"n la jumtatea numrului mai mare, valorile de la jumtatea numrului mai mic p"n la
jumtatea celui mai mare sigur nu vor mai putea fi diviori ai numrului mai mic din considerentele
enunate n paragraful anterior.
>ivior comun nseamn o valoare la care se mpart e3act ambele numere. >e fiecare dat
c"nd va fi gsit o astfel de valoare, ea va fi afiat pe ecran.
,3 % n\?< n intervalul de cutare g8, 9<h
m\;8n intervalul de cutare g8, 86h
>ac s#ar mai cuta diviori comuni n intervalul g88, 9<h nu s#ar mai gsi nici unul,
deoarece orice valoare a\88 nu mai poate fi divior propriu al lui ;8. >in acest motiv, diviorii
comuni ai celor dou numere se caut p"n la jumtatea celui mai mic dintre ele.
$entru a decide care dintre numerele n i m este mai mare s#a utiliat instruciunea
c $ m>$n R n0. S m0.;
/ceasta este echivalent cu o instruciune if3else%
if (m>$n)
c $ n0.;
else
c $ m0.;
4#a optat pentru operatorul de deciie A% mai mult din motive de economie de scriere dec"t
din alte considerente. /stfel, dac ma\n reultatul evalurii va fi nS8 care apoi i se atribuie lui c,
altfel va fi mS8 care se va atribui lui c.

17. / se determine toate numerele ?perfecte? mai mici dec7t 10000. Jn numr este perfect dac
este egal cu suma tuturor divi0orilor si "inclusiv 1$.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/'
<
class @ro%ram
<
static oid ?ain()
<
int nr( i( s;
Console.Write:ine(;Nr perfecte < /==== suntS;);
for (nr $ ); nr <$ /====; nrBB)
<
s $ =;
77
for (i $ /; i <$ nr 0 .; iBB)
if (nr H i $$ =)
s B$ i;
if (s $$ nr)
Console.Write:ine(nr);
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/cest program necesit aflarea tuturor diviorilor unui numr 'inclusiv 61 i nsumarea lor.
Cu ajutorul unei instruciuni for se vor testa toate numere naturale de la ; 'cel mai mic numr
natural care are diviori proprii1 p"n la 6<<<<. 4#a discutat n problema anterioar modul de aflare
a tuturor diviorilor unui numr natural. 2n caul n care suma diviorilor este egal cu numrul
analiat, acesta va fi tiprit pe ecran.
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/'!
<
class @ro%ram
<
static int suma_di(int nr)
<
int s $ /( i;
for (i $ .; i <$ nr 0 .; iBB)
if (nr H i $$ =)
s B$ i;
return s;
>
static oid ?ain()
<
int n( i;
Console.Write(;Antroduceti numrul n$ ;);
n $ int.@arse(Console."ead:ine());
Console.Write:ine(;Numerele perfecte mai mici decat <=> sunt;( n);
for (i $ ); i <$ n; iBB)
if (suma_di(i) $$ i)
Console.Write:ine(i);
Console."eadde#();
>
>
>
1M. Kestai dac un numr natural dat este prim. ")rin numr prim nelegem orice numr natural
care se mparte doar la 1 4i la el nsu4iL se considera ca 2 este cel mai mic numr prim$.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/& <
7@
class @ro%ram
<
static oid ?ain()
<
int i( n( rad_n;
!ool prim $ true;
Console.Write(;Antroduceti n $ ;);
n $ int.@arse(Console."ead:ine());
rad_n $ (int)?at,.Dfrt(n);
for (i $ .; i <$ rad_n; iBB) 00for (i$.; iGi<$n; iBB)
if (n H i $$ =)
<
prim $ false;
!reaL;
>
if (prim)
Console.Write:ine(;Numrul <=> este prim;( n);
else
Console.Write:ine(;Numrul <=> nu este prim;( n);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
# n scopul verificrii dac un anumit numr este prim, va trebui sa testam dac se mparte la vreun
alt numr nafara de 6 i el nsui. $roblema care se pune este n ce interval vom cuta posibilele
valori la care s#ar putea mpri numrul. 4#ar putea propune variantele de intervale g8, n#6h sau
g8, nS8h, nsa varianta optima este de a cuta n intervalul g8, n h. /stfel, se vor parcurge cu
ajutorul unei instruciuni for toate numerele naturale cuprinse ntre 8 i n M dac n se divide cu
vreunul dintre ele 'restul mpririi lui n la i este <1, atunci se oprete forat instruciunea for cu
ajutorul instruciunii brea8 i variabila prim ia valoarea false. >ac s#a terminat normal
instruciunea for nseamn c numrul n este prim, deoarece nu s#a gsit nici un divior, iar
variabila prim are valoarea trueM
# se observ c nainte de instruciunea for, am depus valoarea lui n n variabila radMn. 4copul
acestei atribuiri este de a evita calculul radicalului la fiecare pas de for. >e reinut c aceast
operaie este util de aplicat oric"nd apare un calcul care nu se modific 'constant1, ntr#o
instruciune repetitiv. /stfel, el poate fi efectuat o singur dat, nainte de a intra n instruciunea
repetitiv.
# cu ajutorul unei instruciuni if testm valoarea variabilei prim, astfel dac ea este true se va afia
mesajul ca n este numr prim i altfel se va afia mesajul ca n nu este numr prim.
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/&! <
class @ro%ram
<
static !ool test_prim(int n)
<
int i( rad_n;
!ool prim $ true;
rad_n $ (int)?at,.Dfrt(n);
7:
for (i $ .; i <$ rad_n; iBB) 00for (i$.; iGi<$n; iBB)
if (n H i $$ =)
<
prim $ false;
!reaL;
>
return prim;
>
static oid ?ain()
<
int n;
Console.Write(;Antroduceti n $ ;);
n $ int.@arse(Console."ead:ine());
if (test_prim(n))
Console.Write:ine(;Numrul <=> este prim;( n);
else
Console.Write:ine(;Numrul <=> nu este prim;( n);
Console."eadde#();
>
>
>
1'. /e cite4te de la tastatur un numr natural x mai mare dec7t 2. / se gseasc p 4i H numere
prime astfel nc7t pGxGH% iar diferena H3p este minim.
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication/+ <
class @ro%ram <
static !ool test_prim(int n)
<
int i( rad_n;
!ool prim $ true;
rad_n $ (int)?at,.Dfrt(n);
for (i $ .; i <$ rad_n; iBB) 00for (i$.; iGi<$n; iBB)
if (n H i $$ =)
<
prim $ false;
!reaL;
>
return prim;
>
static oid ?ain()
<
int C( p( f;
!ool prim;
Console.Write(;Antroduceti C $ ;);
C $ int.@arse(Console."ead:ine());
p $ C;
do
<
pFF;
prim $ test_prim(p);
> V,ile (prim $$ false);
f $ C;
do <
fBB;
@<
prim $ test_prim(f);
> V,ile (prim $$ false);
Console.Write(;Doluia %sitaS<=><</><<.> ;( p( C( f);
Console.Write(;iar <=>F</>$<.>;( f( p( f F p);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/ceasta problem presupune de fapt gsirea primului numr prim mai mic dec"t x i a
primului numr prim mai mare dec"t x. 2n felul acesta diferena H3p va fi minim.
2n acest sens, se pornete prima dat de la valoarea x31 i se testea n jos cu ajutorul unei
instruciuni repetitive do39hile toate valorile p"n c"nd se va gsi primul numr prim. /cela va fi
numrul p. >up aceea, se pornete de la valoarea x11 tot cu o instruciune repetitiv do39hile i se
testea n sus toate valorile p"n c"nd se va gsi primul numr prim. /cela va fi numrul H.
!odul de testare a unui numr dac este prim este acelai cu cel de la problema anterioar.
O. /e cite4te de la tastatur un numr natural par. / se decid dac acesta poate fi scris ca 4i
suma de dou numere prime 4i s se afi4e0e toate soluiile gsite "se va considera c 4i 1 este
numr prim$. 'Conjectura lui Boldbach% I)rice numr par mai mare dec"t 8 este suma a dou
numere prime.L1
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.= <
class @ro%ram <
static !ool test_prim(int n)
<
int i( rad_n;
!ool prim $ true;
rad_n $ (int)?at,.Dfrt(n);
for (i $ .; i <$ rad_n; iBB) 00for (i$.; iGi<$n; iBB)
if (n H i $$ =)
<
prim $ false;
!reaL;
>
return prim;
>
static oid ?ain()
<
int nr( nr/( nr. $ =;
!ool prim;
Console.Write(;Antroduceti nrS ;);
nr $ int.@arse(Console."ead:ine());
for (nr/ $ /; nr/ <$ nr 0 .; nr/ $ nr/ B .)
<
prim $ test_prim(nr/);
if (prim $$ true)
<
nr. $ nr F nr/;
prim $ test_prim(nr.);
@6
>
if (prim $$ true) 00nr$nr/Bnr. 4i nr/( nr. sunt prime
Console.Write:ine(;DolutieS<=>B</>;(nr/(nr.);
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
2n cadrul acestei probleme, n ncercarea de a scrie numrul nr ca i sum de dou numere
prime se vor cuta valori n intervalul g6, nrS8h. >ac se gsete un numr prim nr1 din acest
interval, se va testa apoi dac i nr22nr3nr1 este i el prim. >ac da, aceasta nseamn ca
nr\n6Enr8, iar nr1 i nr2 sunt prime. /ceast pereche se va tipri pe ecran. nr1 se caut n
intervalul g6, nrS8h deoarece dac se trece de jumtatea numrului, se vor obine perechi duplicate.
>e asemenea, valorile lui nr1 n cadrul instruciunii for merg din 8 n 8, deoarece se merge doar pe
valori impare.
,3 % >ac nr\8?, atunci s#ar obine soluia nr6\9, nr8\89 dar i nr6\89, nr8\9.
!odul de testare a unui numr dac este prim este acelai cu cel de la problema 6@.
1. /e cite4te de la tastatur un numr natural. / se decid dac acesta poate fi scris ca 4i sum
de dou patrate 4i s se afi4e0e toate soluiile gsite.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication./ <
class @ro%ram
<
static oid ?ain()
<
int n( i( N( t/( t.( rad_n( sol$=;
Console.Write(;Antroduceti numrul n$;);
n $ int.@arse(Console."ead:ine());
rad_n $ (int)?at,.Dfrt(n);
for (i $ /; i <$ rad_n; iBB)
<
t/ $ i G i;
N $ (int)?at,.Dfrt(n F i G i);
t. $ N G N;
if ((t/ <$ t.) PP (n $$ t/ B t.))
<
Console.Write:ine(;DolutieS <=>$</>G<.>B<*>G<)>;( n( i( i(
N( N);
solBB;
>
>
Console.Write(;Iu fost %asite <=> solutii;( sol);
Console."eadde#();
>
>
>
@8
A+a/32a -r*7ra46/63
$entru un n citit de la tastatur se testea toate valorile din intervalul g6, n h pentru a
vedea dac poate fi ndeplinit condiia din enun. /stfel, pentru fiecare valoare i din acest interval
se calculea j\ i i n T . 2n caul n care n\iTiEjTj nseamn c a fost gsit soluia 'i, j$.
5ntervalul de testare este g6, n h deoarece dac i\ n , atunci iTi\n, deci nu se mai poate gsi un al
doilea numr poitiv j pentru care iTiEjTj\n.
$entru a ne verifica, 'i, j$ este soluie a problemei deoarece +\iTiEjTj\ iTiE i i n T T
i i n T \iTiEn#iTi\+. 4#a mai adugat i testul dac t6`\t8 pentru a evita generarea de soluii
identice. ,3% '8, =1, '=, 81
+a final se afiea numrul total de soluii gasite 'care poate fi i <1.
,3emplu % n\8:, ig6, =h
i\6, iTi\6, n#iTi\8@, j\ 8@ \=, iTiEjTj\K M
i\8, iTi\;, n#iTi\8=, j\ 8= \=, iTiEjTj\MSM n '8, =1
...
. / se afi4e0e primele n perechi de numere prime care sunt consecutive n mulimea numerelor
impare.
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.. <
class @ro%ram <
static !ool test_prim(int n)
<
int i( rad_n;
!ool prim $ true;
rad_n $ (int)?at,.Dfrt(n);
for (i $ .; i <$ rad_n; iBB) 00for (i$.; iGi<$n; iBB)
if (n H i $$ =)
<
prim $ false;
!reaL;
>
return prim;
>
static oid ?ain()
<
int n( i( c;
Console.Write(;Antroduceti numrul de perec,i n$;);
n $ int.@arse(Console."ead:ine());
c $ =; i $ *;
V,ile (c < n)
<
if (test_prim(i) PP test_prim(i B .))
< 00 i( iB. sunt prime
Console.Write:ine(;<=>( </>;( i( i B .);
cBB;
>
i $ i B .;
> 00V,ile
Console."eadde#();
>
@9
>
>
A+a/32a -r*7ra46/63
4oluiile acestei probleme se vor cuta ncep"nd cu numrul 9, dup care se va merge din 8
n 8. /stfel se vor testa perechile de valori '9, =1, '=, 71, '7, :1, .a.m.d. $rima dat se testea prima
valoare a perechii. >ac este numr prim se trece la testarea celei de#a doua valori 'egal cu prima
valoare E 81. >ac i ea este numr prim nseamn c a fost gsit o soluie, care se tiprete pe
ecran. >e fiecare dat c"nd se gsete o soluie, se va incrementa un contor c, pentru a se ti c"nd
vor fi gsite cele n perechi cutate. !ecanismul de testare dac un numr este prim este acelai cu
cel de la problema 86.
)ptimiare %
V,ile (c < n)
<
if (test_prim(i))
if (test_prim(i B .))
< 00 i( iB. sunt prime
00Console.Write:ine(;<=>( </>;( i( i B .);
cBB;
i $ i B .;
>
else i $ i B );
else i $ i B .;
>
>ac n perechea 'i% i121, i12 nu este numr prim, atunci nu se va mai testa perechea 'i12%
i1N1, ci se va trece direct la testarea perechii 'i1N% i1O1. ,3% '7, :1% i\7 este nr prim, iE8\: nu este
nr prim nu se va mai testa perechea ':, 661, ci se va trece la testarea perechii '66, 691. 2n felul
acesta am economisit de la testare o pereche de valori i implicit am c"tigat puin timp la rularea
programului, ceea ce pentru un n suficient de mare poate s devin un timp simitor.
!. / se descompun un numr natural n n factori primi. ,3% 9?<\8
9
T9
8
T=
6
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.*
<
class @ro%ram
<
static oid ?ain()
<
int n( m( i( putere;
Console.Write(;Antroduceti numrul n $ ;);
n $ int.@arse(Console."ead:ine());
Console.Write(;<=> $ ;( n);
m $ n;
for (i $ .; i <$ n 0 .; iBB)
<
if (m H i $$ =)
<
putere $ =;
V,ile (m H i $$ =)
<
putereBB;
@;
m $ m 0 i;
>
Console.Write(;<=>X</> G ;( i( putere);
>
if (m $$ /)
!reaL;
>
Console.Write(;/;);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/ceast problem i propune s afle toi diviorii primi ai unui numr natural n i puterea la
care intr acei diviori n descompunerea lui n. 2n acest sens, se vor cuta toi diviorii lui n n
intervalul g8, nS8h. >e fiecare dat c"nd este gsit un divior, se va calcula puterea la care intr acel
divior n descompunerea lui n, mprind n mod repetat acel divior la n p"n c"nd acest lucru nu
mai este posibil. Noul numr n va fi n#ul iniial mprit la diviorul gsit la puterea ma3im ce intr
n descompunerea lui n, dup care se va trece s se testee o nou valoare. Calculul se va opri n
momentul n care n devine 6.
,3 % n\9?<
$rimul divior gsit este 8. 4e mparte n la 8 p"n c"nd acest lucru nu mai este posibil%
9?<%8\6@<%8\:<%8\;=. Noul n cu care se va lucra mai departe va fi ;=, i s#a aflat c 8
9
intr n
descompunerea n#ului iniial.
4e va trece la testarea lui 9. >eoarece 9 este divior al lui ;= se trece la aflarea puterii la care
intr 9 n descompunerea lui n% ;=%9\6=%9\=. Noul n cu care se va lucra mai departe va fi =, i s#a
aflat c 9
8
intr n descompunerea n#ului iniial.
4e va trece la testarea lui ;, dar acesta nu este divior al lui =.
4e va trece la testarea lui =. >eoarece = este divior al lui = se trece la aflarea puterii la care
intr = n descompunerea lui n% =%=\6. 4#a aflat c =
6
intr n descompunerea n#ului iniial. /cum n
a devenit 6, moment n care calculul se oprete.
>in reolvarea acestei probleme se observ c atunci c"nd este gsit un divior, acesta nu
este testat dac este prim sau nu. >e ceA >eoarece nu se lucrea tot timpul cu n iniial, ci de la o
testare a unui divior la alta, n a fost mprit la diviorii si gsii p"n la un moment dat.
/stfel, n e3emplul de mai sus, 9?< a fost mprit la 8
9
, iar pe mai departe nu s#a mai lucrat
cu 9?<, ci cu 9?<%8
9
\;=. /cest fapt influenea semnificativ mersul reolvrii, deoarece numrul
iniial fiind mprit la puterea ma3im posibil a lui 8, pe mai departe nici un multiplu al lui 8 nu
va mai fi gsit ca i divior al unui nou n. $e c"nd dac s#ar fi lucrat tot cu n iniial, at"t ; c"t i @ ar
fi fost gsii ca i diviori ai lui 9?<, ca n care era necesar i testul de primalitate. 2n modul n care
este g"ndit aceast reolvare, orice numr se va testa i este gsit ca i divior, sigur este prim,
deoarece toi posibilii si diviori au fost deja testai, iar numrul iniial a fost mprit deja la ei.
(evenind la numrul 9?<, diviorii si sunt% 8, 9, ;, =, ?, @, :, 6<, 68, 6=, 6@, 8<, 8;, 9<, 9?,
;<, ;=, ?<, 68<, 6@<.
@=
2n momentul n care 8 a fost gsit ca divior al lui 9?<, iar apoi 9?< a fost mprit la 8
9
i s#a
obinut ;=, toi multiplii lui 8 cad de la analiare, adic rm"n de testat doar diviorii 9, =, :, 6=, ;=.
2n momentul n care 9 a fost gsit ca divior al lui ;=, iar apoi ;= a fost mprit la 9
8
i s#a
obinut =, toi multiplii lui 9 cad de la analiare, adic rm"n de testat doar diviorii =, 6=, ;=.
2n momentul n care = a fost gsit ca divior al lui =, iar apoi = a fost mprit la =
6
i s#a obinut 6,
calculul se ncheie, iar concluia este c 9?<\8
9
T9
8
T=
6
.
J. /e citesc de la tastatur n numere naturale 4i un numr prim p. /e cere s se gseasc un
numr 8 maxim astfel nc7t produsul celor n numere s se divid cu p
8
% fr a calcula produsul.
,3% >ac p\8, iar cele ; numere sunt% 6<\8
6
T=, @\8
9
, 9\8
<
T9, 8@\8
8
T7 n Y\?
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.) <
class @ro%ram
<
static oid ?ain()
<
int n( nr( p( L $ =( i;
Console.Write(;1ati numrul total de numere n$;);
n $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti numrul prim p$;);
p $ int.@arse(Console."ead:ine());
for (i $ /; i <$ n; iBB)
<
Console.Write(;Antroduceti un nrS ;);
nr $ int.@arse(Console."ead:ine());
V,ile (nr H p $$ =)
<
LBB;
nr $ nr 0 p;
>
>
Console.Write(;L maCim$<=>;( L);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
(eolvarea acestei probleme merge pe ideea c puterea la care se divide p n cadrul
produsului celor n numere este aceeai cu puterile lui p nsumate de la cele n numere pe r"nd.
2n e3emplul dat 6<T@T9T8@\?78<, iar aceast valoare se divide cu 8
?
. 4e poate observa ns
i fr a face produsul c 6<T@T9T8@\8
6
T= T8
9
T8
<
T9 T8
8
T7 \8
?
Tk
,ste de fapt de evitat pe c"t posibil calcularea produsului deoarece la un moment dat s#ar
putea obine o valoare care s depeasc cea mai mare valoare ntreag predefinit n C# '8
?;
1 .
>ac ns nu se realiea produsul, aceast problem este eliminat.
(eolvarea acestei probleme const n a citi pe r"nd cele n numere i a verifica puterea lui p
care intr n descompunerea fiecruia dintre ele. /ceste puteri se nsumea, iar reultatul obinut
este e3act acel 8 ma3im care se caut.
@?
(. /e citesc n numere naturale de la tastatur. / se determine n c7te 0erouri se va termina
produsul acestora% fr a calcula efectiv produsul. ,3% 68, 9=, 9<, 7= n 9 erouri
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.5
<
class @ro%ram
<
static oid ?ain()
<
int n( nr( p. $ =( p5 $ =( i( 3ero;
Console.Write(;Antroduceti numrul de elemente n$;);
n $ int.@arse(Console."ead:ine());
for (i $ /; i <$ n; iBB)
<
Console.Write(;Antroduceti un numr nr$;);
nr $ int.@arse(Console."ead:ine());
if (nr H . $$ =)
V,ile (nr H . $$ =)
<
p.BB;
nr 0$ .;
>
if (nr H 5 $$ =)
V,ile (nr H 5 $$ =)
<
p5BB;
nr 0$ 5;
>
>
if (p. < p5)
3ero $ p.;
else
3ero $ p5;
Console.Write:ine(;@rodusul celor <=> numere se termina Zn </>
3erouri;( n( 3ero);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
(eolvarea acestei probleme seamn cu cea de la problema 8;.4e merge pe aceeai idee c
nu este necesar 'i nici recomandat1 de a calcula produsul tuturor celor n numere pentru a afla
reultatul cutat. >e data aceasta ns, pentru fiecare numr din cele n se va studia cu 8 la ce putere
se divide i cu = la ce putere se divide, deoarece fiecare < n care se termin produsul numerelor
nseamn o putere a lui 6<, iar 6<\8T=.
0oate puterile lui 8 i = care apar n descompunerea celor n numere se nsumea, iar la final
care dintre cele dou valori este mai mic repreint numrul de erouri n care se termin produsul
celor n numere.
@7
,3%68T9=T9<T7=\8
8
T9 T=
6
T7 T8
6
T=
6
T9 T=
8
T9 \8
9
T=
;
Tk\8
9
T=
9
Tk\ 6<
9
Tk\6<<<Tk 4e deduce astfel
c produsul celor ; numere se termin n 9 erouri. 'n descompunere se obinuse 8
9
i =
;
, 9`; n
6<
9
, deci 9 erouri1.
Cu funcie %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.5!
<
class @ro%ram
<
static int putere(int p( int C)
<
int putere_p $ =;
V,ile (C H p $$ =)
<
C 0$ p;
putere_pBB;
>
return putere_p;
>
static oid ?ain()
<
int C( p.$=( p5$=;
Console.Write (;Antroduceti un numrS ;);
C$int.@arse(Console."ead:ine());
V,ile (C9$=)
<
p.B$putere(.(C);
p5B$putere(5(C);
Console.Write(;Antroduceti un numrS ;);
C $ int.@arse(Console."ead:ine());
>
Console.Write:ine (;@rodusul se diide cu . la puterea <=>;( p.);
Console.Write:ine(;@rodusul se diide cu 5 la puterea <=>;( p5);
if (p. >$ p5) Console.Write:ine(;@rodusul se diide cu /= la puterea
<=>;( p5);
else Console.Write:ine(;@rodusul se diide cu /= la puterea <=>;(
p.);
Console."eadde#();
>
>
>
K. /a se calcule0e n
m
efectu7nd mai puin de m31 nmuliri. "Atenie la valorile n 4i m% ca re0ultatul
s nu dep4easc cel mai mare ntreg definit n *P$
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.6 <
class @ro%ram
<
static oid ?ain()
<
lon% prod;
@@
int n( m( p( i( op$=;
Console.Write(;Antroduceti n$;);
n $ int.@arse(Console."ead:ine());
Console.Write(;Antroduceti m$;);
m $ int.@arse(Console."ead:ine());
prod $ n;
p $ /;
V,ile ((p G .) <$ m)
<
prod G$ prod;
p G$ .;
opBB;
>
if (p < m)
for (i $ p B /; i <$ m; iBB)
<
prod G$ n;
opBB;
>
Console.Write:ine(;<=>X</>$<.> din <*> operatii;( n( m( prod( op);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
(eolvarea acestei probleme merge pe ideea de a ridica la putere n urmtorul mod% nTn\n
8
,
n
8
Tn
8
\n
;
, n
;
Tn
;
\n
@
,etc. at"ta timp c"t acest lucru este posibil. C"nd nu mai este posibil se va
continua nmulirea simpl cu c"te un n. ,3% m\8< n n
8<
se calculea astfel% nTn\n
8
, n
8
Tn
8
\n
;
,
n
;
Tn
;
\n
@
, n
@
Tn
@
\n
6?
M nu se mai poate continua n acest mod, deci p"n la 8< se va nmuli cu c"te un
n% n
6?
TnTnTnTn\n
8<
. 4e observ c fa de a nmuli n de 8< de ori, s#au fcut mai puine nmuliri
's#au fcut doar 7 nmuliri1.
@:
K. "ECTORI
7. #at fiind un tablou unidimensional "vector$ cu numere ntregi% determinai minimul 4i maximul
din acest tablou.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.'
<
class @ro%ram
<
static oid ?ain()
<
int n( i;
int ?AN( ?Ig;
Console.Write(;1ati dimensiunea ectorului IS n$;);
n $ int.@arse(Console."ead:ine());
intTU a $ neV intTnU;
Console.Write:ine(;1ati elementele ectoruluiS ;);
for (i $ =; i < n; iBB)
<
Console.Write(;IT<=>U$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
?AN $ ?Ig $ aT=U;
for (i $ /; i < n; iBB)
<
if (aTiU < ?AN)
?AN $ aTiU;
if (aTiU > ?Ig)
?Ig $ aTiU;
>
Console.Write:ine(;?inimul din ta!lou este <=>;( ?AN);
Console.Write:ine(;?aCimul din ta!lou este <=>;( ?Ig);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/ceast problem determin n paralel at"t valoarea minim dintr#un vector, c"t i cea
ma3im.
!ecanismul de determinare a valorii minime % se ia o variabil != care este iniialiat cu
prima valoare din tablou. 4e parcurge apoi tabloul de la a doua poiie p"n la ultima i se compar
fiecare valoare cu cea din !=. >e c"te ori se nt"lnete o valoare mai mic dec"t !=, acea valoare
se atribuie lui !=. /stfel, la final, variabila != va conine cea mai mic valoare din tablou, deci
valoarea minim.
!ecanismul de determinare a valorii ma3ime % se ia o variabil !AQ care este iniialiat cu prima
valoare din tablou. 4e parcurge apoi tabloul de la a doua poiie p"n la ultima i se compar fiecare
valoare cu cea din !AQ. >e c"te ori se nt"lnete o valoare mai mare dec"t !AQ, acea valoare se
atribuie lui !AQ. /stfel, la final, variabila !AQ va conine cea mai mare valoare din tablou, deci
valoarea ma3im.
:<
M. / se determine primii n termeni ai irului lui Fibonacci.
5storic % Cunoscut i ca +eonardo din $isa, Cibonacci a trit n secolul e555 i este considerat a fi
unul din cei mai talentai matematicieni din ,vul !ediu. &nii consider c Cibonacci este cel care a
nlocuit sistemul de cifre romane cu cele arabe.
Rirul lui &ibonacci este o secven recursiv de numere, n care fiecare numr se obine din
suma precedentelor dou din ir. $rimele dou valori se dau i sunt 6 i 6. 4ecvena numerelor lui
Cibonacci a fascinat de#a lungul istoriei pe foarte muli oameni de tiin, matematicieni, fiicieni,
biologi, i continu s o fac chiar i n preent.
Cormula de recuren% C<\6, C6\6, C
i
\C
i#6
EC
i#8
, ia\8
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.& <
class @ro%ram
<
static oid ?ain()
<
int i(n(fn(fn_/(fn_.;
Console.Write (;1ati nr. de termeni ai siruluiS ;);
n $ int.@arse(Console."ead:ine());
fn_/$/; fn_.$/;
Console.Write:ine(;Ei!o(=)$/;);
Console.Write:ine(;Ei!o(/)$/;);
for (i $ .; i < n; iBB)
<
fn $ fn_/ B fn_.;
fn_. $ fn_/;
fn_/ $ fn;
Console.Write:ine(;Ei!o(<=>)$</>;( i( fn);
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/cest program devolt formula de recuren descris mai sus. /stfel, primii doi termeni,
fnM1 i fnM2 sunt iniialiai cu 6. /poi se intr n ciclul for care va calcula termenii irului de la 8
p"n la n. >eoarece aceast reolvare nu folosete tablouri, tot calculul se realiea cu ajutorul
variabilelor fnM1, fnM2 i fn.
.ariabila fn repreint termenul de ordinul i, iar fnM1 i fnM2 sunt predecesorii si de gradul
6 i 8. $entru urmtorul pas, fnM2 devine vechiul fnM1, iar fnM1 devine fn.
Tra+;f*r4area 6+63 +64r 03+ 1a2a 0e +64era3e 1O :+.r8* a/. 1a2 bF numrul n baa 6< se
mparte la b p"n c"nd se obine c"tul <. 2n acel moment toate resturile obinute n urma acestor
mpriri, luate de la ultimul p"n la primul, vor repreenta numrul n baa b.
,3 % ==
6<
\66<666
8
==%8\87%8\69%8\?%8\9%8\6%8\<
=; 8? 68 ? 8 <
6 6 6 < 6 6
:6
Tra+;f*r4area 6+63 +64r 03+.r8* 1a2 b :+ 1a2a 1OF 4e iau toate cifrele numrului n baa b
ncep"nd cu cea mai din dreapta 'considerat poiia <1, se nmulesc cu b
poiia
i se adun toate
aceste valori. Ceea ce se obine repreint numrul n baa 6<.
,3 % 66<666
8
\==
6<
6T8
=
E6T8
;
E<T8
9
E6T8
8
E6T8
6
E6T8
<
\98E6?E;E8E6\==
,3 % 689
@
\@9
6<
6T@
8
E8T@
6
E9T@
<
\?;E6?E9\@9
Ba2e 0e +64era3e TS11. ) ba b din intervalul g8, 6<h utiliea cifre din intervalul g<, b#6h.
*aa 6< utiliea toate cifrele de la < la :, iar alte cifre nu mai e3ist. /stfel, pentru a repreenta
valori n bae de numeraie mai mari dec"t 6< sunt necesare i alte simboluri. /ceste simboluri vor
fi litere ale alfabetului, ncep"nd cu litera /. 2n felul acesta, baa 6? care este cea mai adesea
folosit din baele mai mari dec"t 6<, pe l"ng cifrele de la < la : va mai folosi i literele
alfabetului, de la / la C. &ual spus, IcifraL 6< va fi repreentat de litera /,..., IcifraL 6= va fi
repreentat de litera C.
0recerea din baa 6< ntr#o ba a\6< se face dup acelai mecanism enunat mai sus.
4imilar, trecerea dintr#o ba a\6< n baa 6< se face dup acelai mecanism enunat mai sus.
,3 % 7<8
6<
\8*,
6?
7<8%6?\;9%6?\8%6?\<
?@@ 98 <
6; 66 8
,3 % 8*,
6?
S7<8
6<
8T6?
8
E*T6?
6
E,T6?
<
\8T6?
8
E66T6?
6
E6;T6?
<
S=68E67?E6;\7<8
'. / se transforme un numr natural din ba0a 10 n ba0a 2.
,3% 8=
6<
\66<<6
8
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication.+
<
class @ro%ram
<
static oid ?ain()
<
int nr( cifre$=( i;
intTU cif!in $ neV intT.=U;
Console.Write (;1ati un numr Zn !a3a /=S ;);
nr $ int.@arse(Console."ead:ine());
V,ile (nr9$=)
<
cif!inTcifreU$nrH.;
nr$nr0.;
cifreBB;
>
Console.Write (;"epre3entarea Zn !a3a . a nrS ;(nr);
:8
for (i$cifreF/; i>$=; iFF)
Console.Write (cif!inTiU);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
Conform teoriei enunate mai sus, pentru a obine numrul din baa 6< n baa 8, nr se
mparte la 8 p"n c"nd se ajunge la <. Ciecare rest obinut se adaug n tabloul cifbin. +a final, acest
tablou va conine cifrele n baa 8 ale numrului dat, i se va tipri de la capt spre nceput, tot
conform teoriei care spune c numrul n baa b repreint resturile obinute n urma mpririlor
repetate la b, scrise de la ultimul spre primul.
!O. / se transforme un numr natural din ba0a 10 n ba0a 1O.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*= <
class @ro%ram
<
static oid ?ain()
<
int nr( cifre$=( c$/( i;
c,ar TU cif,eC $ neV c,ar T.=U;
Console.Write (;1ati un numr Zn !a3a /=S ;);
nr$int.@arse(Console."ead:ine());
V,ile (nr9$=)
<
c$nrH/6;
if (c <$ +)
cif,eCTcifreU $ (c,ar)(c B )&);
else
cif,eCTcifreU $ (c,ar)(c B 55);
nr$nr0/6;
cifreBB;
>
Console.Write (;"epre3entarea Zn !a3a /6 esteS ;);
for (i$cifreF/; i>$=; iFF)
Console.Write (cif,eCTiU);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
Conform teoriei enunate mai sus, pentru a obine numrul din baa 6< n baa 6?, nr se
mparte la 6? p"n c"nd se ajunge la <. Ciecare rest obinut se adaug n tabloul cifhex. 0recerea n
baa 6? repreint un ca mai special, deoarece intervin i IcifreL formate din litere. 2n acest sens,
pentru a memora resturile obinute nu se mai poate folosi un tablou de int, ci unul de char. >at fiind
acest fapt, numerele obinute ca i resturi n urma mpririlor trebuiesc transformate n caractere.
:9
Caracterele sunt privite din punctul de vedere al codului lor &nicode. >e e3emplu, codul &nicode al
cifrelor <#: se afl n intervalul ;@#=7. /stfel, pentru a transforma cifra < n caracterul D<D 'care are
codul &nicode ;@1, va trebui s adunm ;@. >ac se vor obine resturile 6<#6=, acestea vor trebui
transformate n caracterele j/D#jCD. Codul &nicode al literelor j/D#jCD se afl n intervalul ?=#7<.
/stfel, pentru a transforma numrul 6< n caracterul D/D 'care are codul &nicode ?=1, va trebui s
adunm ==.
+a final, acest tablou va conine cifrele n baa 6? ale numrului dat, i se va tipri de la
capt spre nceput, tot conform teoriei care spune c numrul n baa b repreint resturile obinute
n urma mpririlor repetate la b, scrise de la ultimul spre primul.
)bservaie% 2n C# e3ist i o variant mult mai simpl de a obine repreentarea n baa 6? a unei
valori ntregi i anume folosind funcia Ko/tring cu parametrul LeL astfel%
int nr;
Console.Write (;1ati un numr Zn !a3a /=S ;);
nr$int.@arse(Console."ead:ine());
Console.Write (;Numarul in !a3a /6S ;Bnr.JoDtrin%(;g;));
!1. / se transforme un numr natural din ba0a 10 n ba0a bS2% ET.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*/ <
class @ro%ram <
static oid ?ain()
<
int nr( cifre$=( i( !;
intTU cif!a3a$neV intT.=U;
Console.Write (;1ati un numr Zn !a3a /=S ;);
nr$int.@arse(Console."ead:ine());
Console.Write (;1ati !a3a de conersie(.F+)S ;);
!$int.@arse(Console."ead:ine());
V,ile (nr9$=)
<
cif!a3aTcifreU$nrH!;
nr$nr0!;
cifreBB;
>
Console.Write (;"epre3. Zn !a3a <=> a nr. esteS ;( !);
for (i$cifreF/; i>$=; iFF)
Console.Write (cif!a3aTiU);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
Conform teoriei enunate mai sus, pentru a obine numrul din baa 6< n baa b, nr se
mparte la b p"n c"nd se ajunge la <. Ciecare rest obinut se adaug n tabloul cifba0a. +a final,
acest tablou va conine cifrele n baa b ale numrului dat, i se va tipri de la capt spre nceput, tot
conform teoriei care spune c numrul n baa b repreint resturile obinute n urma mpririlor
repetate la b, scrise de la ultimul spre primul.
:;
!. / se transforme un numr natural din ba0a 2 n ba0a 10.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*.
<
class @ro%ram
<
static oid ?ain()
<
int cifre( p.$/( n!/=$=( i( c;
Console.Write (;C\te cifre are numrul Zn !a3a .S ;);
cifre$int.@arse(Console."ead:ine());
Console.Write:ine (;1ati pe rand cifrele numrului Zn !a3a .
incepand din dreaptaS ;);
for (i$/; i<$cifre; iBB)
<
Console.Write (;Cifra <=> S ;(i);
c$int.@arse(Console."ead:ine());
n!/=B$cGp.;
p.$p.G.;
>
Console.Write:ine (;"epre3. Zn !a3a /= a numrului <=> este ;(
n!/=);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
4e citesc pe r"nd de la tastatur toate cifrele numrului n baa 8, ncep"nd cu cea mai din
dreapta 'considerat poiia <1, se nmulesc cu 8
poiia
i se adun toate aceste valori. Ceea ce se
obine repreint numrul n baa 6<.
!!. / se transforme un numr natural din ba0a 1O n ba0a 10.
usin% D#stem;
namespace ConsoleIpplication** <
class @ro%ram
<
static oid ?ain()
<
int cifre( p/6 $ /( n!/= $ =;
strin% numr;
Console.Write(;1ati cifrele de la dreapta la stan%aS;);
numr $ Console."ead:ine();
Console.Write(;"epre3. in !a3a /= a nr. esteS ;);
foreac, (c,ar c!/6 in numr)
<
if (((c,ar)c!/6 >$ 65) PP ((c,ar)c!/6 <$ '=))
n!/= B$ (c!/6 F 55) G p/6;
if (((c,ar)c!/6 >$ )&) PP ((c,ar)c!/6 <$ 5'))
n!/= B$ (c!/6 F )&) G p/6;
p/6 $ p/6 G /6;
>
:=
Console.Write(n!/=);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
4e citesc pe r"nd de la tastatur toate cifrele numrului n baa 6?, ncep"nd cu cea mai din
dreapta 'considerat poiia <1, ns se citesc ca i caractere datorit posibilelor litere care pot
aprea. $entru a putea face calculul mai departe, aceste caractere trebuiesc transformate n numerele
<#6=. >ac este vorba de o cifr, nseamn c are codul &nicode n intervalul ;@#=7, deci pentru a
obine cifra corespuntoare va trebui s scdem ;@. >ac este vorba de o liter, nseamn c are
codul &nicode n intervalul ?=#7<, deci pentru a obine numrul corespuntor va trebui s scdem
==. Numerele astfel obinute se nmulesc cu 6?
poiia
i se adun toate aceste valori. Ceea ce se
obine repreint numrul n baa 6<.
!J. / se transforme un numr natural din ba0a bS2% ET n ba0a 10.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*)
<
class @ro%ram
<
static oid ?ain()
<
int !( cifre( p!$/( n!/=$=( i( c;
Console.Write (;1ati !a3a (.F+)S ;);
!$int.@arse(Console."ead:ine());
Console.Write (;C\te cifre are nr Zn !a3a <=> R ;( !);
cifre$int.@arse(Console."ead:ine());
Console.Write:ine (;1ati pe rand cifrele numrului Zn !a3a <=>
incepand din dreaptaS ;( !);
for (i$/; i<$cifre; iBB)
<
Console.Write (;Cifra <=> S ;(i);
c$int.@arse(Console."ead:ine());
n!/=B$cGp!;
p!$p!G!;
>
Console.Write:ine (;"epre3. Zn !a3a /= a numrului este <=>;( n!/=);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
4e citesc pe r"nd de la tastatur toate cifrele numrului n baa b, ncep"nd cu cea mai din
dreapta 'considerat poiia <1, se nmulesc cu b
poiia
'care se calculea progresiv n variabila pb1
i se adun toate aceste valori. Ceea ce se obine este stocat n variabila nb10 i repreint numrul
n baa 6<.
:?
!(. &iind dat un vector de numere ntregi% s se determine cea mai lung secven de numere
consecutive aflate n ordine cresctoare.
,3% 6 9 ? : = ; J K M 11 17 6= n cea mai lung secven cresctoare este% 8 ; ? @ 66 67
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*5
<
class @ro%ram <
static oid ?ain(strin%TU ar%s) <
int n( i( lun%$=( lun%_maC( po3_start( po3_maC;
Console.Write(;Cate elemente are ectorul R ;);
n $ int.@arse(Console."ead:ine());
intTU a $ neV intTnU;
Console.Write:ine(;1ati elementele ectorului S;);
for (i $ =; i < n; iBB)
<
Console.Write(;aT<=>U$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
Console.Write(;OectorulS ;);
for (i $ =; i < n; iBB)
Console.Write(;<=> ;( aTiU);
lun%_maC $ =;
po3_maC$=;
for (i $ =; i < nF/; iBB)
<
po3_start $ i;
lun% $ /;
V,ile (i<nF/)
<
if (aTiU < aTi B /U)
<
lun%BB;
iBB;
>
else !reaL;
>
if (lun% > lun%_maC)
<
lun%_maC $ lun%;
po3_maC $ po3_start;
>
>
Console.Write:ine();
Console.Write(;Cea mai lun%a sec crescatoare ;);
Console.Write:ine (;se afla intre po3itiile <=>F</>;( po3_maC(
po3_maCBlun%_maCF/);
Console.Write (;si are <=> elementeS ;(lun%_maC);
for (i $ po3_maC; i < po3_maCBlun%_maC; iBB)
Console.Write(;<=> ;( aTiU);
Console."eadde#();
>
>
>
:7
A+a/32a -r*7ra46/63
2n vederea reolvrii problemei, se folosesc urmtoarele variabile de tip int%
# lung care repreint lungimea secvenei curente
# lungMmax care repreint cea mai lung secven i care e posibil s fie actualiat de mai
multe ori pe parcursul traversrii vectorului
# po0Mstart care repreint poiia din vector la care ncepe secvena curent
# po0Mmax care repreint poiia din vector la care ncepe cea mai lung secven
$aii reolvrii sunt urmtorii%
# dup ce se citete vectorul de la tastatur, ncepem s l traversm cu ajutorul unei
instruciuni for ncep"nd cu poiia <
# variabila po0Mstart este iniialiat cu poiia curent din vector, iar lung este iniialiat cu
6
# n cadrul unei instruciuni 9hile, at"ta timp c"t nu se ajunge la sf"ritul vectorului, iar
valorile sunt n ordine cresctoare, se merge mai departe n vector i se incrementea variabila
lung
# n momentul n care ordinea cresctoare nu se mai pstrea, se compar lungimea secvenei
gsite 'lung1 cu cea mai lung secven de p"n atunci 'lungMmax1 i dac este caul, se
actualiea lungMmax i po0Mmax
# la final se afiea elementele din vector care fac parte din cea mai lung secven
cresctoare.
!K. /e d un vector de numere ntregi "po0itive 4i negative$. / se transforme vectorul astfel nc7t
toate valorile negative s fie plasate la nceput% iar valorile po0itive dupa ele.
,3% 8 9 #6 = #9 #; 7 : 6< #= n 8 9 6< = : 7 #; #9 #6 #=
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*6
<
class @ro%ram
<
static oid ?ain(strin%TU ar%s)
<
int n( i( N( auC;
Console.Write (;1ati nS ;);
n$int.@arse(Console."ead:ine());
intTU a$neV intTnB/U;
for (i $ /; i <$ n; iBB)
aTiU $ int.@arse(Console."ead:ine());
i $ /;
N $ n;
V,ile (i<N)
<
if ((aTiU > =) PP (aTNU > =))
NFF;
if ((aTiU < =) PP (aTNU < =))
iBB;
if ((aTiU < =) PP (aTNU > =))
<
iBB;
:@
NFF;
>
if ((aTiU > =) PP (aTNU < =))
<
auC $ aTiU;
aTiU $ aTNU;
aTNU $ auC;
iBB;
NFF;
>
>
for (i $ /; i <$ n; iBB)
Console.Write(;<=> ;( aTiU);
Console."ead:ine();
>
>
>
A+a/32a -r*7ra46/63
4e va parcurge vectorul dinspre ambele capete cu ajutorul a doua contoare i i j 'i creste, j
scade1, at"ta timp c"t i`j. >ac se gsete o pereche 'poitiv, negativ1 valorile se schimb ntre ele
i ambele contoare se modific. Celelalte cauri posibile presupun diverse modificri ale celor dou
contoare% dac agiha< si agjha< atunci j##M dac agih`< i agjh`< atunci iEEM dac agih`< si agjha<
atunci iEE, j##. +a final se afiea vectorul reultat.
!7. &iind dat polinomul de gradul n cu coeficieni reali )"Q$2a
n
Q
n
1a
n31
Q
n31
1...1a
1
Q1a
0
% s se
calcule0e )"x$% unde x este un numr real dat.
,3% $'e1\9ed8#eE6, 3\8, $'81\66
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*'
<
class @ro%ram
<
static oid ?ain()
<
int n( i;
float C( p $ =;
strin% semn$;;;
floatTU c $ neV floatT.=U;
Console.Write(;1ati %radul polinomuluiS ;);
n $ int.@arse(Console."ead:ine());
for (i $ n; i >$ =; iFF)
<
Console.Write(;coeficient pt CX<=>$;( i);
cTiU $ float.@arse(Console."ead:ine());
>
Console.Write(;@(g)$ ;);
for (i $ n; i >$ /; iFF)
if (cTiU 9$ =)
<
::
if (cTiU >$ = PP i < n)
semn $ ;B;;
if (cTiU $$ /)
Console.Write(semn B ;gX<=>;( i);
else if (cTiU $$ F/)
Console.Write(semn B ;FgX<=>;( i);
else
Console.Write(semn B ;<=>GgX</>;(cTiU(i);
semn $ ;;;
>
if (cT=U > =)
Console.Write(;B<=>;( cT=U);
else if (cT=U < =)
Console.Write(cT=U);
Console.Write:ine();
Console.Write(;Antroduceti aloarea lui C$;);
C $ float.@arse(Console."ead:ine());
for (i $ =; i <$ n; iBB)
p $ p B cTiU G (float)?at,.@oV(C(i);
Console.Write:ine(;@(<=>) $ </>;( C( p);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
>up citirea gradului polinomului n variabila n, se citesc coeficienii polinomului n tabloul
c. .alorile se pun n tablou de la poiia n p"n la poiia <, pentru a respecta forma natural a
coeficienilor unui polinom 'se ncepe de la gradul cel mai mare1.
>up aceasta se citete valoarea lui x i se poate merge mai departe la calcularea lui $'31.
$entru a face aceasta, ca i la matematic, se nlocuiete peste tot necunoscuta e cu valoarea
concret x i se nmulete cu coeficienii polinomului. !ai trebuiesc fcute i ridicri la putere, iar
pentru aceasta s#a optat pentru funcia predefinit n C#, !ath.)o9. /ceasta primete ca i
parametrii baa i e3ponentul. 4e vor calcula pe r"nd perechi a
i
Q
i
i se vor nsuma.
4e observ c pentru afiarea polinomului s#au folosit c"teva elemente care s permit o
afiare c"t mai apropiat de varianta matematic. 2n caul n care un coeficient este <, termenul
corespuntor din polinom nu mai este tiprit.
4e putea opta i pentru a construi progresiv puterile lui x i a nu mai utilia funcia
!ath.)o9.
$entru aceasta, bucata de cod%
for (i$n; i>$=; iFF)
p $ p B cTiU G (float)?at,.@oV(C( i);
se nlocuia cu%
int pC$/;
for (i$=; i<$n; iBB) <
p $ p B cTiU G pC;
pC G$ C;
>
)bservaie% $entru !ath.)o9 s#a folosit operatorul de conversie e3plicit 'float1, deoarece aceast
metod returnea double i ar fi fost un conflict ntre tipurile de date, p fiind de tip float.
6<<
!M. &iind dat polinomul de gradul n cu coeficieni reali )"Q$% s se calcule0e )"x$"x3b$% unde b este
un numr real dat.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*& <
class @ro%ram <
static oid ?ain() <
int n( i( !;
strin% semn $ ;;;
Console.Write(;1ati %radul polinomuluiS ;);
n $ int.@arse(Console."ead:ine());
intTU a $ neV intTnB/U;
intTU a! $ neV intTnB.U;
Console.Write:ine(;Antroduceti coeficientii lui g;);
for (i $ n; i >$ =; iFF) <
Console.Write(;Coeficient pt CX<=>$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
Console.Write(;@(g)$ ;);
for (i $ n; i >$ /; iFF)
if (aTiU 9$ =)
<
if (aTiU >$ = PP i < n)
semn $ ;B;;
if (aTiU$$/)
Console.Write(semn B ;gX<=>;( i);
else if (aTiU$$F/)
Console.Write(semn B ;FgX<=>;( i);
else
Console.Write(semnB;<=>GgX</>;( aTiU( i);
semn $ ;;;
>
if (aT=U > =)
Console.Write(;B<=>;( aT=U);
else if (aT=U < =)
Console.Write(aT=U);
Console.Write:ine();
Console.Write(;1ati aloarea pentru !S ;);
! $ int.@arse(Console."ead:ine());
a!Tn B /U $ aTnU;
for (i $ n; i >$ /; iFF)
a!TiU $ aTi F /U F ! G aTiU;
a!T=U $ F! G aT=U;
Console.Write(;@(g)(gF<=>)$;( !);
for (i $ n B /; i >$ /; iFF)
if (a!TiU 9$ =)
<
if (a!TiU >$ = PP i <$ n)
semn $ ;B;;
if (a!TiU $$ /)
Console.Write(semn B ;gX<=>;( i);
else if (a!TiU $$ F/)
Console.Write(semn B ;FgX<=>;( i);
6<6
else
Console.Write(semnB;<=>GgX</>;( a!TiU( i);
semn $ ;;;
>
if (a!T=U > =)
Console.Write(;B<=>;( a!T=U);
else if (a!T=U < =)
Console.Write(a!T=U);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
$'31'3#b1\3'a
n
e
n
Ea
n#6
e
n#6
E...Ea
6
eEa
<
1#b'a
n
e
n
Ea
n#6
e
n#6
E...Ea
6
eEa
<
1\ a
n
e
nE6
Ea
n#6
e
n
E...Ea
6
e
8
Ea
<
e#
ba
n
e
n
#ba
n#6
e
n#6
E...#ba
6
e#ba
<
\ a
n
e
nE6
E'a
n#6
#ba
n
1 e
n
E...E'a
6
#ba
8
1e
8
E'a
<
#ba
6
1e#ba
<
\
\ a
n
e
nE6
E

n
i
i
i i
Q ba a
6
6
1 '
#ba
<
4e observ c noul polinom care se va obine n urma produsului are gradul n11, iar
coeficienii si sunt cei dedui mai sus. Coeficienii de la 6 la n se vor calcula dup formula%
coeficientul termenului de grad i este a
i#6
#ba
i
. Coeficientul de grad n11 este a
n
, iar coeficientul de
grad < este #ba
<
.
$entru afiarea polinomului s#au folosit c"teva elemente care s permit o afiare c"t mai
apropiat de varianta matematic. 2n caul n care un coeficient este <, termenul corespuntor din
polinom nu mai este tiprit.
!'. / se calcule0e derivata de ordin nt7i a unui polinom de grad n cu coeficieni ntregi%
repre0entat cu ajutorul unui vector.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication*+ <
class @ro%ram <
static oid ?ain()
<
int n( i;
strin% semn $ ;;;
Console.Write(;1ati %radul polinomuluiS ;);
n $ int.@arse(Console."ead:ine());
intTU a $ neV intTnB/U;
intTU ad $ neV intTnU;
Console.Write:ine(;Antroduceti coeficientii lui C;);
for (i $ n; i >$ =; iFF)
<
Console.Write(;Coeficientul pt CX<=>$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
Console.Write(;@(g)$;);
for (i $ n; i >$ =; iFF)
if (aTiU 9$ =)
<
if (aTiU >$ = PP i < n)
semn $ ;B;;
if (i 9$ =)
6<8
Console.Write(semnB; <=>GgX</>;( aTiU( i);
else
Console.Write(semn B ; ; B aTiU);
semn $ ;;;
>
Console.Write:ine();
for (i $ n; i >$ /; iFF)
adTi F /U $ aTiU G (i);
Console.Write(;@-(g)$;);
for (i $ n F /; i >$ =; iFF)
if (adTiU 9$ =)
<
if (adTiU >$ = PP i < n F /) semn $ ;B;;
if (i 9$ =)
Console.Write(semnB; <=>GgX</>;(adTiU(i);
else
Console.Write(semn B ; ; B adTiU);
semn $ ;;;
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
>ac $'e1\a
n
e
n
Ea
n#6
e
n#6
E...Ea
6
eEa
< ,
atunci
$D'e1\ na
n
e
n#6
E'n#61a
n#6
e
n#8
E...Ea
6
$olinomul care va repreenta derivata de ordin nt"i a lui $'e1 are gradul n31, iar coeficienii
si se calculea dup formula% coeficientul de grad i este egal cu coeficientul de grad i11 din
polinomul iniial, nmulit cu i11.
$entru afiarea polinomului s#au folosit c"teva elemente care s permit o afiare c"t mai
apropiat de varianta matematic. 2n caul n care un coeficient este <, termenul corespuntor din
polinom nu mai este tiprit.
JO. / se adauge un element n interiorul unui vector de numere reale% fr a suprascrie elementele
deja existente.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)=
<
class @ro%ram
<
static oid ?ain()
<
int n( i( po3( ;
Console.Write(;1ati dimensiunea ta!louluiS ;);
n $ int.@arse(Console."ead:ine());
floatTU a $ neV floatTn B /U;
Console.Write:ine(;1ati elementele ta!louluiS;);
for (i $ =; i < n; iBB)
<
Console.Write(;IT<=>U$;( i B /);
aTiU $ float.@arse(Console."ead:ine());
6<9
>
Console.Write(;@o3itia pe care se face inserarea (/F<=> )S ;(n);
po3 $ int.@arse(Console."ead:ine());
po3FF;
if ((po3 >$ =) PP (po3 < n)) 00 test aliditate
<
Console.Write(;1ati aloarea de inseratS ;);
$ int.@arse(Console."ead:ine());
for (i $ n F /; i >$ po3; iFF)
aTi B /U $ aTiU;
aTpo3U $ ;
Console.Write:ine(;Oectorul dup inserareS;);
for (i $ =; i <$ n; iBB)
Console.Write(;<=> ;( aTiU);
>
else
Console.Write(;@o3itie ineCistenta9;);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
$entru a insera un element pe poiia po0 ntr#un vector care deja conine elemente, este
necesar ca prima dat s se eliberee poiia po0 pentru a nu se scrie peste elementul deja e3istent
acolo. >eoarece captul din st"nga al vectorului este fi3, elementele de la poiia po0 p"n la capt
vor trebui mutate cu o poiie spre dreapta. >eplasarea teoretic se poate face de la po0 la n sau de la
n la po0. $ractic ns, deplasarea de la po0 la n nu funcionea corect, deoarece dac se scrie
elementul de pe poiia po0 pe poiia po011, atunci elementul care era pe poiia po011 se pierde.
2n schimb, dac se ncepe de la poiia n, acest element este mutat pe poiia n11 unde nainte nu
e3ista nimic, iar pe mai departe, elementul de pe poiia n31 este mutat pe poiia n, ns acum nu
mai este o problem, deoarece elementul de pe poiia n a fost deja scris pe poiia n11, .a.m.d. 2n
momentul c"nd toate elementele de la poiia po0 p"n la n au fost deplasate spre dreapta cu o
poiie, se poate citi noua valoare care se va plasa n vector pe poiia po0.
2nainte de inserare este important s se fac un test pentru a verifica dac poiia introdus
de la tastatur este valid.
J1. / se 4tearg un element din interiorul unui vector de numere reale 4i s se acopere spaiul
rmas gol prin deplasarea spre st7nga a tuturor elementelor din dreapta sa.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)/ <
class @ro%ram <
static oid ?ain()
<
int n( i( po3;
Console.Write(;1ati dimensiunea ta!louluiS ;);
n $ int.@arse(Console."ead:ine());
floatTU a $ neV floatTnU;
Console.Write:ine(;Antroduceti elementeleS;);
for (i $ =; i < n; iBB)
<
6<;
Console.Write(;IT<=>U$;( i B /);
aTiU $ float.@arse(Console."ead:ine());
>
Console.Write(;@o3itia de pe care se face ster%erea (/F<=>)S ;(n);
po3 $ int.@arse(Console."ead:ine());
po3FF;
if ((po3 >$ =) PP (po3 < n)) 00 test aliditate
<
for (i $ po3 B /; i < n; iBB)
aTi F /U $ aTiU;
nFF;
Console.Write(;Oectorul dup ster%ereS ;);
for (i $ =; i < n; iBB)
Console.Write(;<=> ;( aTiU);
>
else
Console.Write(;@o3itie ineCistenta9;);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
2n momentul c"nd se terge un element de pe o poiie po0 dintr#un vector, rm"ne un loc
gol care ar trebui acoperit. $entru a#l acoperi se vor deplasa toate elementele de la poiia po011
p"n la n cu o poiie spre st"nga. >e observat i faptul c n urma tergerii unui element, vectorul
va avea n31 elemente.
2nainte de tergere este important s se fac un test pentru a verifica dac poiia introdus
de la tastatur este valid.
J. / se simule0e ciurul lui Eratostene "algoritm cu ajutorul cruia pot fi determinate numerele
prime mai mici dec7t un numr dat$ intr3un vector de n numere naturale.
5storic% Beograful i astronomul grec ,ratostene din Cirena a avut ideea de a transforma
proprietatea numerelor prime de a nu fi multiplii nici unuia din numerele mai mici dec"t ele, ntr#un
criteriu de selecie 'cernere1 astfel% din irul primelor n numere naturale se elimin pe r"nd multiplii
lui 8, 9, = etc., elementele rmase fiind cele prime. /stfel, 8 fiind prim, din ir se elimin multiplii
lui 8 adic ;, ?, @ etc. &rmtorul numr rmas neeliminat la pasul anterior este 9, deci 9 este prim i
se vor elimina numerele :, 6=, 86, etc. 'multiplii pari ai lui 9 fiind deja eliminai1. Qi aa mai
departe, p"n la determinarea tuturor numerelor prime mai mici dec"t un numr dat.
.arianta 6 %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication). <
class @ro%ram <
static oid ?ain()
<
int n( i( N;
Console.Write (;1ati nS ;);
n$int.@arse(Console."ead:ine());
intTU c $ neV intTnB/U;
for (i$.; i<$n; iBB)
cTiU$i;
6<=
for (i$.; i<$?at,.Dfrt(n); iBB)
if (cTiU9$=)
<
N$.;
V,ile (iGN<$n)
<
cTiGNU$=;
NBB;
>
>
for (i$.; i<$n; iBB)
if (cTiU9$=)
Console.Write (;<=> ;( cTiU);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/ceast variant de simulare a ciurului lui Iratostene cu ajutorul unui vector presupune
plasarea n vector a tuturor valorilor de la 8 la n. >up aceasta se va trece la IcernereaL valorilor
care nu sunt prime. ICernereaL se face astfel% se parcurg toate valorile de la 8 la n i se elimin
toi multiplii lor din vector. ,liminarea const de fapt n setarea pe < a valorii acelor multiplii. Ceea
ce rm"ne n final n tablou i este diferit de <, repreint toate numerele prime mai mici dec"t n,
care se vor tipri i pe ecran.
>e ce se merge doar p"n la n A >eoarece n momentul n care s#a ajuns la n , toate
valorile de la n p"n la n au fost deja eliminate sau sunt numere prime.
>emonstraie% )rice valoare 3a n , dac nu este numr prim, nseamn c are cel puin 8 diviori.
4e tie ns c niciunul din diviori nu poate fi ` n , deoarece deja toi multiplii valorilor ` n au
fost deja eliminai. /r rm"ne varianta n care ambii diviori sunt a n , ns deoarece n T n
\n, produsul oricror dou valori a n va da o valoare an. >eci nu e3ist doi diviori ai lui 3,
ambii mai mari dec"t n . (eult de aici c orice valoare mai mare dec"t n neeliminat este
sigur numr prim.

.arianta 8 %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication).!
<
class @ro%ram
<
static oid ?ain()
<
int n( i( N;
Console.Write (;1ati nS ;);
n$int.@arse(Console."ead:ine());
intTU c $ neV int TnB/U;
for (i$.; i<$n; iBB)
cTiU$/;
for (i$.; i<$?at,.Dfrt(n); iBB)
6<?
if (cTiU9$=)
<
N$.;
V,ile (iGN<$n)
<
cTiGNU$=;
NBB;
>
>
for (i$.; i<$n; iBB)
if (cTiU9$=) Console.Write (;<=> ;( i);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
/ceast variant de simulare a ciurului lui Iratostene cu ajutorul unui vector presupune
plasarea n vector pe toate poiiile, a valorii 6. ICernereaL valorilor care nu sunt prime se face de
data aceasta pe baa indicelui de poiie n tablou a elementelor 'e3% indicele 8 este considerat ca
fiind numrul 81. 4e face n felul acesta o anume economie n memorarea de valori n tablou.
ICernereaL se face astfel% se parcurg toate poiiile de la 8 la n i se setea toi multiplii
lor din vector pe <. 5ndicii elementelor rmase n final n tablou i diferite de <, repreint toate
numerele prime mai mici dec"t n, care se vor tipri i pe ecran.
J!. / se verifice dac un vector de ntregi citit de la tastatur ndepline4te condiia de mulime "nu
are valori duplicate$. :n ca0 contrar% s se transforme n mulime "se vor 4terge valorile
duplicate$.
,3emplu% .ectorul % 6 8 9 6 ; = 6 8 ? 8 7 9 @ : nu este mulime.
2n urma transformrii el va deveni % 6 8 9 ; = ? 7 @ :
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)* <
class @ro%ram
<
static oid ?ain(strin%TU ar%s)
<
int n( i( N( L;
Console.Write(;Cate elemente are ectorul R ;);
n$int.@arse(Console."ead:ine());
intTU a$neV intTnU;
Console.Write:ine(;1ati elementele ectorului S;);
for (i $ =; i < n; iBB)
<
Console.Write(;aT<=>U$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
Console.Write(;OectorulS ;);
for (i $ =; i < n; iBB)
6<7
Console.Write(;<=> ;( aTiU);
for (i $ =; i < nF/; iBB)
for (N$iB/; N<n; NBB)
if (aTiU $$ aTNU)
<
if (N 9$ n F /)
for (L $ N B /; L < n; LBB)
aTL F /U $ aTLU;
nFF;
NFF;
>
Console.Write:ine();
Console.Write(;Oectorul multimeS ;);
for (i $ =; i < n; iBB)
Console.Write(;<=> ;( aTiU);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
0estul de mulime se face astfel% se parcurge vectorul cu un contor i. )ric"nd se ajunge la o
poiie i, cu ajutorul unei a doua instruciuni for se parcurge bucata de vector gi11% nh. 2n caul n
care aSiT2aSjT nseamn ca s#a gsit o pereche de valori duplicate i cea de pe poiia j este tears
din vector conform algoritmului de la problema ;6. >up ce va fi parcurs ntregul vector, vom avea
toate valorile duplicate eliminate, deci vectorul ndeplinete condiia de mulime i este afiat.
JJ. /e dau dou mulimi de numere ntregi memorate cu ajutorul vectorilor. / se calcule0e
reuniunea celor dou mulimi.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication))
<
class @ro%ram
<
static oid ?ain()
<
int n( m( i( N( po3( %sit;
Console.Write(;Numrul de elem ale primei multimiS ;);
n $ int.@arse(Console."ead:ine());
Console.Write(;Numrul de elem ale celei deFa doua multimiS ;);
m $ int.@arse(Console."ead:ine());
intTU a $ neV intTnBmU;
intTU ! $ neV intTmU;
Console.Write:ine(;1ati elementele multimii /S;);
for (i $ =; i < n; iBB)
<
Console.Write(;aT<=>U$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;1ati elementele multimii .S;);
6<@
for (i $ =; i < m; iBB)
<
Console.Write(;!T<=>U$;( i);
!TiU $ int.@arse(Console."ead:ine());
>
po3 $ n;
for (N $ =; N < m; NBB)
<
%sit $ =;
for (i $ =; i < n; iBB)
if (!TNU $$ aTiU)
<
%sit $ /;
!reaL;
>
if (%sit $$ =)
<
aTpo3U $ !TNU;
po3BB;
>
>
Irra#.Dort(a);
Console.Write:ine(;"e3ultatul reuniuniiS ;);
n $ po3;
for (i $ =; i < n; iBB)
Console.Write(;<=> ;( aTiU);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
Conform cunotinelor de la matematic se tie c reuniunea a dou mulimi nseamn o
nou mulime care repreint punerea n comun a valorilor celor dou mulimi. 4e tie de asemenea
c ntr#o mulime nu pot aprea valori duplicate. $rogramul de mai sus folosete doi vectori a i b
pentru repreentarea mulimilor.
(euniunea se realiea astfel% se adaug la captul vectorului a toate valorile din b care
nc nu e3ist n a. $entru a face aceasta, fiecare element din vectorul b este cutat n vectorul a.
>ac este gsit se trece peste el, iar dac nu este gsit se adaug la sf"ritul lui a.
>eoarece dimensiunea iniial a lui a se va modifica pe cum se adaug elemente din b,
pentru a cuta elementele din b e3clusiv printre cele din a, se va reine ntr#o variabil suplimentar
po0 numrul curent de elemente din a. .ariabila po0 se va modific pe parcursul prelucrrii, dar
cutarea elementelor din b n a se face tot timpul p"n la poiia n, care este numrul iniial de
elemente din a.
,3 % a% 6 9 ; ?M n\;
b% 8 ; = :M m\;
po\;
# se caut valoarea 8 n aM nu se gsete n se adaug la sf"ritul lui aM po0\= n a% 6 9 ; ? 8
# se caut valoarea ; n a, p"n la poiia n\;M este gsit, deci nu se adaug la a
# se caut valoarea = n a, p"n la poiia n\;M nu se gsete n se adaug la sf"ritul lui aM po0\? n
a% 6 9 ; ? 8 =
# se caut valoarea : n a, p"n la poiia n\;M nu se gsete n se adaug la sf"ritul lui aM po0\7 n
6<:
a% 6 9 ; ? 8 = :
4e tiprete la final vectorul reuniune a, care are acum po0 elemente.
J(. / se calcule0e intersecia a dou mulimi de numere reale repre0entate cu ajutorul vectorilor.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)5 <
class @ro%ram <
static oid ?ain()
<
int n( m( f( i( N( po3;
!ool mida $ true;
Console.Write(;Numrul de elem ale primei multimiS ;);
n $ int.@arse(Console."ead:ine());
Console.Write(;Numrul de elem ale celei deFa doua multimiS ;);
m $ int.@arse(Console."ead:ine());
intTU a $ neV intTnU;
intTU ! $ neV intTmU;
f $ ?at,.?in(n( m);
intTU c $ neV intTfU;
Console.Write:ine(;1ati elementele multimii /;);
for (i $ =; i < n; iBB) <
Console.Write(;aT<=>U$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;1ati elementele multimii .;);
for (i $ =; i < m; iBB) <
Console.Write(;!T<=>U$;( i);
!TiU $ int.@arse(Console."ead:ine());
>
po3 $ =;
for (i $ =; i < n; iBB)
for (N $ =; N < m; NBB)
if (aTiU $$ !TNU)
<
cTpo3U $ aTiU;
po3BB;
mida $ false;
!reaL;
>
Console.Write(;"e3ultatul intersectieiS ;);
if (mida$$false)
for (i $ =; i < po3; iBB)
Console.Write(;<=> ;( cTiU);
else
Console.Write:ine(;multimea ida;);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
Conform cunotinelor de la matematic se tie c intersecia a dou mulimi nseamn o
66<
nou mulime care conine toate elementele comune ale celor dou mulimi. 4e tie de asemenea c
ntr#o mulime nu pot aprea valori duplicate.
$rogramul de mai sus folosete doi vectori a i b pentru repreentarea mulimilor, iar
intersecia se va depune n vectorul c.
5ntersecia se realiea astfel% se parcurge vectorul a element cu element. Ciecare element
din a este cutat n vectorul b. >ac este gsit, se adaug acest element la vectorul c, dac nu, se
trece mai departe n a. Cutarea se face cu ajutorul a dou instruciuni for imbricate, primul for
merg"nd pe elementele vectorului a, iar al doilea for merge pe elementele vectorului b.
4e tiprete la final vectorul intersecie c, care are po0 elemente.
.ectorul c va avea cel mult dimensiunea celei mai mici mulimi, dintre a i b. >in acest
motiv, numrul de elemente ale lui c a fost stabilit la !ath.!in"n% m$. ',3% a are = elemente, b are @
elemente n c are ma3im = elemente1.
4#a folosit variabila mvida de tip bool care dac mulimea c nu are nici un element are
valoarea false. ,a este util pentru a ti la final dac avem ce s afim.
JK. / se calcule0e diferena A,@ a dou mulimi A% @ de numere reale repre0entate cu ajutorul
vectorilor "diferena semnific elementele care sunt n A 4i nu sunt 4i n @$.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)6 <
class @ro%ram
<
static oid ?ain()
<
int n( m( i( N( po3;
!ool mida $ true( %asit;
Console.Write(;Numrul de elem ale primei multimiS ;);
n $ int.@arse(Console."ead:ine());
Console.Write(;Numrul de elem ale celei deFa doua multimiS ;);
m $ int.@arse(Console."ead:ine());
intTU a $ neV intTnU;
intTU ! $ neV intTmU;
intTU c $ neV intTnU;
Console.Write:ine(;1ati elementele multimii /;);
for (i $ =; i < n; iBB)
<
Console.Write(;aT<=>U$;( i);
aTiU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;1ati elementele multimii .;);
for (i $ =; i < m; iBB)
<
Console.Write(;!T<=>U$;( i);
!TiU $ int.@arse(Console."ead:ine());
>
po3 $ =;
for (i $ =; i < n; iBB)
<
%asit$false;
for (N $ =; N < m; NBB)
if (aTiU $$ !TNU)
<
666
%asit $ true;
!reaL;
>
if (%asit$$false)
<
cTpo3U $ aTiU;
mida$false;
po3BB;
>
>
Console.Write(;I 0 [$ ;);
if (mida$$false)
for (i $ =; i < po3; iBB)
Console.Write(;<=> ;( cTiU);
else
Console.Write(;multimea ida;);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
Conform cunotinelor de la matematic se tie c diferena a dou mulimi /S* nseamn o
nou mulime care conine toate elementele din / care nu se afl i n *.
$rogramul de mai sus folosete doi vectori a i b pentru repreentarea mulimilor, iar
diferena se va depune n vectorul c.
>iferena se realiea astfel% se parcurge vectorul a element cu element. Ciecare element
din a este cutat n vectorul b. >ac nu este gsit, se adaug acest element la vectorul c, iar dac da,
se trece mai departe n a. Cutarea se face cu ajutorul a dou instruciuni for imbricate, primul for
merg"nd pe elementele vectorului a, iar al doilea for merge pe elementele vectorului b.
4e tiprete la final vectorul diferen c, care are po0 elemente. .ectorul c a fost definit ca
av"nd ma3im n elemente, at"tea c"te are i vectorul a.
4#a folosit variabila mvida de tip bool care dac mulimea c nu are nici un element are
valoarea false. ,a este util pentru a ti la final dac avem ce s afim.
668
K.! MATRICI
J7. / se construiasc transpusa unei matrice oarecare de elemente reale.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)'
<
class @ro%ram
<
static oid ?ain()
<
int i( N( m( n;
Console.Write(;1ati nr de linii ale matricii m$;);
m $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de coloane ale matricii n$;);
n $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( nU;
intT(U ta $ neV intTn( mU;
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
<
Console.Write(;aT<=>(</>U$;( i( N);
aTi( NU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;8lementele matricii S ;);
for (i $ =; i < m; iBB)
<
for (N $ =; N < n; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
for (i $ =; i < n; iBB)
for (N $ =; N < m; NBB)
taTi( NU $ aTN( iU;
Console.Write:ine(;8lementele matricii transpuseS ;);
00 Jranspusa are n linii 4i m coloane
for (i $ =; i < n; iBB)
<
for (N $ =; N < m; NBB)
Console.Write(taTi( NU B ; ;);
Console.Write:ine();
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
4e tie de la matematic faptul c transpusa unei matrici nseamn inversarea liniilor cu
coloanele. /stfel o matrice de dimensiuni 'm3n1 va avea transpusa de dimensiuni 'n3m1.
2n acest program, transpusa se construiete parcurg"nd toat matricea a i folosind o a doua
matrice ta n care se depun valorile matricei iniiale inversat, adic ceea ce era pe linii n cea
iniial se depune pe coloane n a doua% taSiTSjT2aSjTSiT 'linia j din a se pune pe coloana j din ta, iar
coloana i din a se pune pe linia i n ta1 i la final se afiea matricea ta.
669
JM. / se interschimbe dou linii "coloane$ dintr3o matrice oarecare de elemente reale.
5nterschimbarea a 8 linii %
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)&
<
class @ro%ram
<
static oid ?ain()
<
int i( N( m( n( auC( l/( l.;
Console.Write(;1ati nr de linii ale matricii m$;);
m $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de coloane ale matricii n$;);
n $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( nU;
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
<
Console.Write(;aT<=>(</>U$;( i( N);
aTi( NU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;8lementele matricii S;);
for (i $ =; i < m; iBB)
<
for (N $ =; N < n; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
Console.Write(;Andicele liniei de sc,im!at (/F<=>)S;(m);
l/ $ int.@arse(Console."ead:ine()); l/FF;
Console.Write(;Andicele liniei cu care se sc,im!a (/F<=>)S ;( m);
l. $ int.@arse(Console."ead:ine()); l.FF;
for (i $ =; i < n; iBB)
<
auC $ aTl/( iU;
aTl/( iU $ aTl.( iU;
aTl.( iU $ auC;
>
Console.Write:ine(;?atricea dup intersc,im!area liniilorS);
for (i $ =; i < m; iBB)
<
for (N $ =; N < n; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
Console."eadde#();
>
>
>
66;
A+a/32a -r*7ra46/63
5nterschimbarea unui linii a matricei cu o alta presupune parcurgerea celor dou linii n
paralel i interschimbarea a c"te unei perechi de valori de pe aceeai coloan, lucru care se
realiea cu Imetoda celor trei pahareL preentat n problema 6. /ici Imetoda celor trei pahareL
este folosit n bucata de cod%
for (i$=; i<n; iBB) <
auC$aTl/UTiU;
aTl/UTiU$aTl.UTiU;
aTl.UTiU$auC;
>
2n felul acesta, elementul de pe linia l1, coloana i se va schimba cu elementul de pe linia l2,
coloana i, iar i merge de la prima p"n la ultima coloan de pe o linie, practic pe toat linia.
+a final se afiea din nou matricea pentru a se observa interschimbarea liniilor.
$entru un plus de corectitudine, programul ar trebui s testee validitatea indicilor celor
dou linii de interschimbat care se citesc de la tastatur.
J'. / se calcule0e valoarea maxim dintr3o matrice oarecare de elemente reale 4i s se afi4e0e
toate po0iiile din matrice unde se gse4te aceasta.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication)+
<
class @ro%ram
<
static oid ?ain()
<
int m( n( i( N( maC;
Console.Write(;1ati nr de linii ale matricei m$;);
m $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de coloane ale matricei n$;);
n $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( nU;
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
<
Console.Write(;aT<=>(</>U$;( i( N);
aTi( NU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;?atricea introdusaS;);
for (i $ =; i < m; iBB)
<
for (N $ =; N < n; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
maC $ aT=( =U;
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
if (aTi( NU > maC) maC $ aTi( NU;
Console.Write:ine(;?aCimul$ <=> 4i se afla pe po3itiile S ;( maC);
66=
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
if (aTi( NU $$ maC)
Console.Write:ine(;(<=>(</>) ;( iB/(NB/);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
(eolvarea acestei probleme seamn cu cea a gsirii valorii ma3ime dintr#un vector. Qi aici
se ia o variabil max care este iniialiat cu prima valoare din matrice 'valoarea de pe prima linie i
prima coloan1. 4e parcurge apoi toat matricea i se compar fiecare valoare cu cea din max. >e
c"te ori se nt"lnete o valoare mai mare dec"t max, acea valoare se atribuie lui max. /stfel, la final,
variabila max va conine cea mai mare valoare din matrice, deci valoarea ma3im.
$entru a afia toate poiiile din matrice unde se gsete valoarea ma3im trebuie parcurs
din nou toat matricea i fiecare element al ei este comparat cu ma3imul. >ac sunt egale, se
tiprete linia i coloana acelui element.
(O. / se calcule0e valoarea minim dintr3o matrice oarecare de elemente reale 4i s se afi4e0e
numrul de apariii a acestei valori n matrice.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication5=
<
class @ro%ram
<
static oid ?ain()
<
int m( n( i( N( min( c $ =;
Console.Write(;1ati nr de linii ale matricei S ;);
m $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de coloane ale matricei S;);
n $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( nU;
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
<
Console.Write(;aT<=>(</>U$;( i( N);
aTi( NU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;?atricea introdusaS;);
for (i $ =; i < m; iBB)
<
for (N $ =; N < n; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
min $ aT=( =U;
66?
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
<
if (aTi( NU < min)
<
min $ aTi( NU;
c $ /;
>
if (aTi( NU $$ min)
cBB;
>
Console.Write(;?inimul$<=> 4i apare Zn matrice de </> ori;( min( c);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
(eolvarea acestei probleme seamn cu cea a gsirii valorii minime dintr#un vector. Qi aici
se ia o variabil min care este iniialiat cu prima valoare din matrice 'valoarea de pe prima linie i
prima coloan1. 4e parcurge apoi toat matricea i se compar fiecare valoare cu cea din min. >e
c"te ori se nt"lnete o valoare mai mic dec"t min, acea valoare se atribuie lui min. /stfel, la final,
variabila min va conine cea mai mic valoare din matrice, deci valoarea minim.
$entru a afia numrul de apariii al valorii minime n matrice e3ist cel puin dou
variante % 61 dup aflarea minimului s se mai parcurg o dat toat matricea i s se numere de c"te
ori este nt"lnit valoarea minim sau 81 numrul de apariii s se calculee odat cu calculul valorii
minime, astfel % iniial numrul de apariii c este setat pe 6. >ac este gsit n matrice o valoare
egal cu minimul temporar, se incrementea numrul de apariii. >ac minimul este modificat, se
iniialiea din nou numrul de apariii cu 6.
(1. / se calcule0e suma elementelor de pe diagonala principal dintr3o matrice ptratic de
elemente ntregi.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication5/ <
class @ro%ram
<
static oid ?ain()
<
int m( i( N( suma $ =;
Console.Write(;1ati nr de linii0coloane ale matricei patraticeS;);
m $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( mU;
for (i $ =; i < m; iBB)
for (N $ =; N < m; NBB)
<
Console.Write(;aT<=>(</>U$;( i( N);
aTi( NU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;?atricea introdusaS ;);
for (i $ =; i < m; iBB)
667
<
for (N $ =; N < m; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
for (i $ =; i < m; iBB)
suma $ suma B aTi( iU;
Console.Write(;Duma elem. de pe dia%. principala $ <=>;( suma);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
0oate elementele de pe diagonala principal a unei matrice ptratice au proprietatea c
indicele liniei este acelai indicele coloanei. /stfel, se vor nsuma toate elementele din matrice de
forma a
i,i
, unde i merge pe toate liniile 'coloanele1 matricei.
(. / se calcule0e suma elementelor de pe diagonala secundara dintr3o matrice ptratic de
elemente ntregi.
Pr*7ra4
,, declararea% citirea 4i tiprirea matricei ca 4i la problema U1.
,,calcul suma5
for (i $ =; i < m; iBB)
suma $ suma B aTi( m F i F /U;
Console.Write(;Duma elementelor de pe dia%onala secundara$<=>;(
suma);
A+a/32a -r*7ra46/63
0oate elementele de pe diagonala secundar a unei matrice ptratice de dimensiune m au
proprietatea c indicele coloanei este egal cu m#indicele liniei pe care se afl. /stfel, la modul
general, se vor nsuma toate elementele din matrice de forma a
i,m#i#6
, unde i merge pe toate liniile
'coloanele1 matricei.
>e e3emplu, ntr#o matrice ptratic de dimensiune ;, elementele de pe diagonala secundar au
indicii 'dac numerotarea ncepe de la <1% '<, 91, '6, 81, '8, 61, '8, <1.
(!. / se calcule0e suma elementelor din triunghiul de deasupra diagonalei principale dintr3o
matrice ptratic de elemente ntregi.
Pr*7ra4
,, declararea% citirea 4i tiprirea matricei ca 4i la problema U1.
,,calcul suma5
for (i $ =; i < m F /; iBB)
for (N $ i B /; N < m; NBB)
suma $ suma B aTi(NU;
Console.Write(;Duma elem. de deasupra dia% principale $ <=>;( suma);

A+a/32a -r*7ra46/63
,lementele de deasupra diagonalei principale a unei matrici ptratice de dimensiune m au
66@
proprietatea c se afl pe liniile 'dac numerotarea ncepe de la <1 i<..m#8, iar pe aceste linii se
afl pe coloanele jiE6..m#6. 2n acest sens, sunt necesare dou instruciuni for care s parcurg
liniile i coloanele corespuntoare i s nsumee valorile.
(J. / se calcule0e suma elementelor din triunghiul de sub diagonala principala dintr3o matrice
ptratic de elemente ntregi.
Pr*7ra4
,, declararea% citirea 4i tiprirea matricei ca 4i la problema U1.
,,calcul suma5
for (i $ /; i < m; iBB)
for (N $ =; N < i; NBB)
suma $ suma B aTi(NU;
Console.Write(;Duma elem. de su! dia%. principala $ <=>;( suma);
A+a/32a -r*7ra46/63
,lementele de sub diagonala principal a unei matrice ptratice de dimensiune m au
proprietatea c se afl pe liniile 'dac numerotarea ncepe de la <1 i6..m#6, iar pe aceste linii se
afl pe coloanele j<..i#6. 2n acest sens, sunt necesare dou instruciuni for care s parcurg liniile
i coloanele corespuntoare i s nsumee valorile.
((. / se calcule0e suma elementelor din triunghiul de deasupra diagonalei secundare dintr3o
matrice ptratic de elemente ntregi.
Pr*7ra4
,, declararea% citirea 4i tiprirea matricei ca 4i la problema U1.
,,calcul suma5
for (i $ =; i < m F /; iBB)
for (N $ =; N < m F i F /; NBB)
suma $ suma B aTi( NU;
Console.Write(;Duma elem de deasupra dia%. secundare $ <=>;( suma);

A+a/32a -r*7ra46/63
,lementele de deasupra diagonalei secundare a unei matrici ptratice de dimensiune m au
proprietatea c se afl pe liniile 'dac numerotarea ncepe de la <1 i<..m#8, iar pe aceste linii se
afl pe coloanele j<..m#i#8. 2n acest sens, sunt necesare dou instruciuni for care s parcurg
liniile i coloanele corespuntoare i s nsumee valorile.
(K. / se calcule0e suma elementelor din triunghiul de sub diagonala secundara dintr3o matrice
ptratic de elemente ntregi.
Pr*7ra4
,, declararea% citirea 4i tiprirea matricei ca 4i la problema U1.
,,calcul suma5
for (i $ /; i < m; iBB)
for (N $ m F i; N < m; NBB)
suma $ suma B aTi( NU;
Console.Write(;Duma elem de su! dia%. secundara $ <=>;( suma);

A+a/32a -r*7ra46/63
,lementele de sub diagonala secundar a unei matrice ptratice de dimensiune m au
proprietatea c se afl pe liniile 'dac numerotarea ncepe de la <1 i6..m#6, iar pe aceste linii se
afl pe coloanele jm#i..m#6. 2n acest sens, sunt necesare dou instruciuni for care s parcurg
66:
liniile i coloanele corespuntoare i s nsumee valorile.
(7. / se verifice care dintre liniile unei matrice oarecare de elemente ntregi este simetric
"elementele egal deprtate de capetele liniei sunt egale$.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication6)
<
class @ro%ram
<
static oid ?ain()
<
int m( n( i( N;
!ool e%ale;
Console.Write(;1ati nr de linii ale matricei m$;);
m $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de coloane ale matricei n$;);
n $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( nU;
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
<
Console.Write(;aT<=>(</>U$;( i( N);
aTi( NU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;?atricea introdusaS ;);
for (i $ =; i < m; iBB)
<
for (N $ =; N < n; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
for (i $ =; i < m; iBB)
<
e%ale $ true;
for (N $ =; N < n 0 .; NBB)
if (aTi( NU 9$ aTi( n F N F /U)
e%ale $ false;
if (e%ale $$ true)
Console.Write:ine(;:inia <=> este simetrica;( iB/);
>
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
$entru a determina dac o linie dintr#o matrice este simetric, se parcurge acea linie p"n la
jumtate i se compar pe r"nd fiecare element din prima jumtate a liniei cu simetricul su din
cealalt jumtate 'dac numerotarea ncepe de la < i e vorba de poiia j din prima jumtate dintr#
un total de n elemente, atunci simetricul su este n3j311.
68<
$entru a reolva problema, se parcurg toate liniile matricei, i pentru fiecare linie se aplic
raionamentul enunat mai sus. 4e va ncepe de fiecare dat prin a presupune c linia este simetric.
>ac cumva n linie este gsit o pereche de valori simetrice care nu sunt egale, concluia va fi c
linia respectiv nu este simetric.
(M. / se calcule0e produsul dintre o matrice 4i un vector de elemente ntregi.
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication5& <
class @ro%ram <
static oid ?ain()
<
int m( n( i( N;
Console.Write(;1ati nr de linii ale matricei m$;);
m $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de coloane ale matricei n$;);
n $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( nU;
intTU ! $ neV intTnU;
intTU c $ neV intTmU;
for (i $ =; i < m; iBB)
for (N $ =; N < n; NBB)
<
Console.Write(;aT<=>(</>U$;( i( N);
aTi( NU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;1ati elementele ectoruluiS;);
for (i $ =; i < n; iBB) <
Console.Write(;!T<=>U$;( i);
!TiU $ int.@arse(Console."ead:ine());
>
Console.Write:ine(;?atricea introdusaS;);
for (i $ =; i < m; iBB)
<
for (N $ =; N < n; NBB)
Console.Write(aTi( NU B ; ;);
Console.Write:ine();
>
Console.Write:ine(;Oectorul introdusS ;);
for (i $ =; i < n; iBB)
Console.Write:ine(!TiU B ; ;);
for (i $ =; i < m; iBB)
<
cTiU $ =;
for (N $ =; N < n; NBB)
cTiU B$ aTi( NU G !TNU;
>
Console.Write:ine();
Console.Write:ine(;"e3ultatul produsului matrice C ectorS ;);
for (i $ =; i < m; iBB)
Console.Write:ine(cTiU B ; ;);
Console."eadde#();
>
>
>
686
A+a/32a -r*7ra46/63
$rodusul dintre o matrice i un vector se poate face prin nmulirea vectorului la dreapta sau
la st"nga matricei. /cest program face nmulirea la dreapta. $entru ca nmulirea s fie posibil,
matricea trebuie s aib dimensiunea 'mxn1, iar vectorul trebuie s aib n elemente. (eultatul
nmulirii va fi un vector cu m elemente.
2n program este folosit matricea a de dimensiune 'mxn1 care urmea a fi nmulit cu
vectorul b de dimensiune 'n1, iar reultatul se va depune n vectorul c de dimensiune 'm1. .ectorul
c se calculea dup formula% c
i
\a
i,j
Tb
j
, j<..n#6, iar i<..m#6. 4e observ c n program au fost
necesare dou instruciuni for, pentru a parcurge cu i liniile matricei i cu j coloanele. $entru fiecare
linie i din matrice va e3ista c"te un c
i
. +a final se afiea vectorul reultat c.
('. / se calcule0e produsul a dou matrice de elemente ntregi de forma "m%n$ 4i "n%p$.
Cu funcii%
Pr*7ra4
usin% D#stem;
namespace ConsoleIpplication5+
<
class @ro%ram
<
static oid citire(intT(U matrice( int l( int c)
<
int i( N;
for (i $ =; i < l; iBB)
for (N $ =; N < c; NBB)
<
Console.Write(;T<=>(</>U$;( i( N);
matriceTi( NU $ int.@arse(Console."ead:ine());
>
>
static oid tiparire(intT(U matrice( int l( int c)
<
int i( N;
for (i $ =; i < l; iBB)
<
for (N $ =; N < c; NBB)
Console.Write(matriceTi( NU B ; ;);
Console.Write:ine();
>
>
static oid ?ain()
<
int m( n( p( i( N( L;
Console.Write(;1ati nr de linii ale matricei IS m$;);
m $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de col ale matricei IS n$;);
n $ int.@arse(Console."ead:ine());
Console.Write(;1ati nr de col. ale matricei [S p$;);
p $ int.@arse(Console."ead:ine());
intT(U a $ neV intTm( nU;
intT(U ! $ neV intTn( pU;
intT(U c $ neV intTm( pU;
Console.Write:ine();
Console.Write:ine(;1ati elementele matricei IS;);
688
citire(a( m( n);
Console.Write:ine();
Console.Write:ine(;1ati elementele matricei [S;);
citire(!( n( p);
Console.Write:ine();
Console.Write:ine(;?atricea IS;);
tiparire(a( m( n);
Console.Write:ine();
Console.Write:ine(;?atricea [S;);
tiparire(!( n( p);
Console.Write:ine();
00produsul
for (i $ =; i < m; iBB)
for (N $ =; N < p; NBB)
<
cTi( NU $ =;
for (L $ =; L < n; LBB)
cTi( NU B$ aTi( LU G !TL( NU;
>
Console.Write:ine(;?atricea produs I C [S;);
tiparire(c( m( p);
Console."eadde#();
>
>
>
A+a/32a -r*7ra46/63
$entru ca produsul celor dou matrice s fie posibil, este necesar ca prima s aib
dimensiunea 'm3n1, iar cea de#a doua dimensiunea 'n3p1. Cu alte cuvinte, numrul de coloane al
primei s fie egal cu numrul de coloane al celei de#a doua. (eultatul nmulirii este tot o matrice,
de dimensiune 'm3p1.
2n program este folosit matricea a de dimensiune 'm3n1 care urmea a fi nmulit cu
matricea b de dimensiune 'n3p1, iar reultatul se va depune n matricea c de dimensiune 'm3p1.
.alorile lui c se calculea dup formula% c
i,j
\

=
6
<
, ,
T
n
8
j 8 8 i
b a
, iar i<..m#6, iar j<..n#6.
4e observ c n program au fost necesare trei instruciuni for, una pentru a parcurge cu i
liniile matricei a% una pentru a parcurge cu j coloanele lui b i una pentru a parcurge cu 8 coloanele
lui a. +a final se afiea reultatul nmulirii aflat n matricea c.
4#a construit o funcie pentru citirea unei matrice i una pentru afiarea unei matrice, pentru
a nu repeta de mai multe ori acelai cod n funcia !ain'1.
689
68;
BIBLIO)RA#IE
6. Feff Cerguson, *rian $atterson, Fason *eres, $ierre *outouin, and !eeta Bupta # C# *ible,
8<<8, JileG $ublishing.
8. >aniel 4olis# 5llustrated C# 8<<=, /press, 8<<?.
9. Herbert 4childt # C#% / begginerDs Buide, !cBraw#Hill CompanG, 8<<6
;. Cara (asheed # $rogrammers Heaven% C# 4chool, 4Gnchron >ata, 8<<?.
=. Charles $etold # $rogramming !icrosoft Jindows with C# '!icrosoft1, 8<<8.
?. /ndG Harris # !icrosoft C# $rogramming for the /bsolute *eginner, Course 0echnologG,
8<<8.
7. !ichael !cmillan # >ata 4tructures /nd /lgorithms &sing C#, Cambridge &niversitG $ress,
8<<7.
@. FacY $urdum *eginning # C# 9.<, JileG $ublishing, 5nc., 8<<7.
:. Carmen Cifor O 5ntroducere n programare. +imbajul C O teorie i probleme reolvate, ,d. &niv.
I/urel .laicuL /rad, 8<<7
$.).).
6. BradG *ooch, (obert /. !aYsimchuY, !ichael J. ,ngle, *obbi F. poung, $h.>. Fim Conallen,
qelli /. Houston # )bject#)riented /nalGsis and >esign with /pplications, 0hird ,dition,
$earson ,ducation, 5nc., 8<<7.
S*f.Uare
.isual 4tudio 8<6< ,3press ,ditions # http%SSwww.microsoft.comS,3pressS
.isual 4tudio $rofessional # http%SSmsdn.microsoft.comSenusSvstudioSproductsSaa7<<@96.asp3
68=