Դինամիկ զանգվածներ Ֆունկցիաներ

ՀԱՅԱՍՏԱՆԻ ՀԱՆՐԱՊԵՏՈՒԹՅԱՆ
ԿՐԹՈՒԹՅԱՆ ԵՎ ԳԻՏՈՒԹՅԱՆ ՆԱԽԱՐԱՐՈՒԹՅՈՒՆ

ՀԱՅԱՍՏԱՆԻ ԱԶԳԱՅԻՆ ՊՈԼԻՏԵԽՆԻԿԱԿԱՆ ՀԱՄԱԼՍԱՐԱՆ
Քոմփյութերային համակարգերի
և ինֆորմատիկայի ֆակուլտետ
Ալգորիթմական լեզուների
և ծրագրավորման ամբիոն
ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ:
ՖՈՒՆԿՑԻԱՆԵՐ
Լաբորատոր աշխատանքների կատարման մեթոդական ցուցումներ
ԵՐԵՎԱՆ
ՃԱՐՏԱՐԱԳԵՏ
2019
1
ՀՏԴ Հրատարակվում է Հայաստանի ազգային
ԳՄԴ պոլիտեխնիկական համալսարանի 28.12.2016թ.
գիտական խորհրդի նիստում հաստատված 2017թ.
հրատարակչական պլանի համաձայն
Գրախոսներ`
Կազմողներ` Ն.Ա. Սահակյան

Ի.Ռ. Սաղաթելյան
Դինամիկ զանգվածներ: Ֆունկցիաներ: Լաբորատոր

աշխատանքների կատարման մեթոդական ցուցումներ/ Կազմ.`
Ն.Ա. Սահակյան, Ի.Ռ. Սաղաթելյան; ՀԱՊՀ.-Եր.: Ճարտարագետ,
2019.-80 էջ:
Մեթոդական ցուցումները նվիրված են դինամիկ զանգվածների օգտագործմանը

ֆունկցիաների հետ աշխատելիս, ինչպես նաև ներառված են խնդիրներ ինքնուրույն
աշխատանքի համար:
Նախատեսված է բակալավրի և մագիստրոսի աստիճան շնորհող կրթական
ծրագրով սովորող ուսանողների համար: Մեթոդականը օգտակար է նաև սկսնակ և
որոշակի փորձ ունեցող ծրագրավորողների համար:
ՀՏԴ
ԳՄԴ
ISBN
 ՃԱՐՏԱՐԱԳԵՏ 2019
 Սահակյան Ն.Ա. 2019
 Սաղաթելյան Ի.Ռ. 2019
2
ԲՈՎԱՆԴԱԿՈՒԹՅՈԻՆ
Ներածություն ............................................................................................... 5
1. ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ ................................................................ 6

1.1. Միաչափ դինամիկ զանգվածներ ....................................................... 6
1.2. Միաչափ զանգվածի տարրերի արագ դասավորում ...................... 7
1.3. Միաչափ զանգվածի մեծագույն եվ փոքրագույն
տարրերի միջեվ ընկած տարրերի քանակը ................................... 10
1.4. Զանգվածից նոր միաչափ միաչափ զանգվածի
ստացումը .............................................................................................. 12
1.5. Խնդիրներ միաչափ դինամիկ զանգվածների
վերաբերյալ ........................................................................................... 13
2. ԵՐԿՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ.............................................. 16

2.1. Երկչափ զանգվածի տարրերի դասավորումը գլխավոր և
օժանդակ անկյունագծերի նկատմամբ ........................................... 18
2.2. Երկչափ զանգվածի տողերի դասավորումը .................................. 20
2.3. Երկչափ զանգվածից նոր միաչափ զանգվածի ստացումը .......... 23
2.4. Խնդիրներ երկչափ դինամիկ զանգվածների վերաբերյալ ........... 28
3. ՖՈՒՆԿՑԻԱՆԵՐԻ ՆԿԱՐԱԳՐՈՒԹՅՈՒՆԸ ..................................... 32

3.1. Ֆունկցիային փոխանցվող պարամետրերի եղանակները .......... 34
3.2.Անվերջ շարքի գումարի հաշվարկ ................................................... 37
3.3. Խնդիրներ: անվերջ շարքերի գումարի հաշվարկ ......................... 43
3.4. Դինամիկ միաչափ զանգվածների փոխանցումը
ֆունկցիային ......................................................................................... 47
3.5. Դինամիկ զանգվածների կիրառմամբ միաչափ զանգվածից նոր
միաչափ զանգվածի ստացումը ......................................................... 49
3.6. Հանձնարարություններ ֆունկցիների կիրառմամբ միաչափ
դինամիկ զանգվածների օգտագործման վերաբերյալ .................. 55
3
3.7. Դինամիկ երկչափ զանգվածների փոխանցումը
ֆունկցիային......................................................................................... 59
3.8. Խնդիրներ ֆունկցիների կիրառմամբ` երկչափ դինամիկ
զանգվածների օգտագործման վերաբերյալ .................................... 73
ԳՐԱԿԱՆՈՒԹՅՈՒՆ ............................................................................. 78
4
Ներածություն
Տրված մեթոդական ցուցումները նվիրված են դինամիկ

զանգվածներին և դրանց օգտագործմանը ֆունկցիաների հետ
աշխատելիս:
Ոչ դինամիկ զանգվածների համար հիշողության մեջ տեղ
է հատկացվում կոմպիլացիայի ժամանակ, այն դեպքում, երբ
դինամիկ զանգվածների համար՝ ծրագրի կատարման ընթաց-
քում: Դինամիկ զանգվածները օգտագործվում են, եթե նախօրոք
հայտնի չէ զանգվածի տարրերի քանակը: Նրանք պահանջում
են դինամիկ հիշողության հատկացում և ազատում: Ոչ դինա-
միկ զանգվածների չափը որոշված է նախօրոք՝ մինչ ծրագրի
կատարումը: Դինամիկ զանգվածների չափը կարող է փոխվել
ծրագրի կատարման ընթացքում:
Այս աշխատանքում ներկայացված են միաչափ և երկչափ
դինամիկ զանգվածների օգտագործմամբ խնդիրների մեկնա-
բանություններով ուղեկցվող օրինակներ, բազմաթիվ առաջադ-
րանքներ: Քննության է ենթարկվել նաև դինամիկ միաչափ
զանգվածի տարրերի արագ դասավորման խնդիրը:
Դիտարկված են ֆունկցիաներին դինամիկ զանգվածների
փոխանցման ծրագրերի օրինակներ, որոնք ընդգրկում են բա-
ցատրական աղյուսակներ և մեկնաբանություններ: Ներկայաց-
ված են՝ անվերջ շարքի գումարի հաշվման խնդրի լուծումը ռե-
կուրենտ բանաձևերի օգնությամբ և համապատասխան առա-
ջադրանքներ:
Մեթոդական աշխատանքը նախատեսված է տվյալ թե-
մայով հետաքրքրվող ուսանողների և դասախոսների համար:
5
1. ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ
1.1. ՄԻԱՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ
Ոչ դինամիկ զանգվածին տրամադրվող հիշողությունը

հատկացվում է թարգմանության փուլում: Դա նշանակում է,
որ ոչ դինամիկ զանգվածը պետք է ունենա հաստատուն չափ:
Ի տարբերություն ոչ դինամիկի, դինամիկ զանգվածի չափը
հաստատուն չէ: Ծրագիրը կարող է ստանալ անհրաժեշտ ծա-
վալով հիշողություն դրա կատարման ժամանակ դինամիկ
(ազատ) հիշողությունից: Չնայած դինամիկ հիշողության չափը
նախապես հայտնի չէ՝ նրա ծավալը, սովորաբար, բավակա-
նաչափ մեծ է: Եթե զանգվածի համար տրամադրված ազատ
հիշողության անհրաժեշտ ծավալը բավարար չէ, կամ վերա-
դարձվում է զրոյական ցուցիչ, կամ ստեղծվում է «արտակարգ
վիճակ»:
Դինամիկ զանգվածները չի կարելի ինիցիալացնել:
Դինամիկ հիշողության տրամադրումը և ազատումը իրա-
կանացվում է new և delete օպերատորների միջոցով:
New օպերատորը օգտագործվում է ստեղծվող զանգվածի
համար դինամիկ հիշողությունում տեղ հատկացնելու նպատա-
կով: Ծրագրի կատարման ժամանակ ստեղծվող դինամիկ զանգ-
վածի չափը կարելի է ներմուծել ստեղնաշարից կամ ստանալ
որևէ հաշվարկի արդյունքում: Առաջին դեպքում դինամիկ միա-
չափ զանգվածի հայտարարումը կարող է ունենալ հետևյալ
տեսքը՝
int n;
cout<<"n="; cin>>n;
int *x=new int[n];
6
new օպերատորը կատարում է երկու գործողություն.
1) նշված տիպի զանգվածի համար տեղ է հատկացնում
դինամիկ հիշողության մեջ
2) վերադարձվում է նրա հասցեն:
Դինամիկ զանգվածի տարրին կարելի է դիմել որպես՝ ոչ
դինամիկ զանգվածի տարրի, օրինակ x[3]: Կարելի է դիմել և
ակնհայտորեն ցույց տալով զանգվածի տարրին դիմելու գործո-
ղությոնները, օրինակ՝ *(x+3): Քանի որ x ցուցիչ-փոփոխականի
մեջ գրված է զանգվածի զրոյական տարրի հասցեն, զանգվածի
երրորդ տարրին դիմելու համար այդ հասցեին պետք է գու-
մարվի 3 շեղումը: Ցուցիչների համար հաստատունի հետ գու-
մարման գործողությունը նկատի է ունենում հասցեավորված
փոփոխականների չափերը, այսինքն՝ կատարվում է x+3*sizeof(int)
գործողությունը: Այնուհետև վերցվում է հաշվված հասցեում
գտնվող զանգվածի տարրի արժեքը * գործողության միջոցով:
delete օպերատորը օգտագործվում է՝ հատկացված դինա-
միկ հիշողությունը ազատելու համար: Ցանկացած չափայնու-
թյամբ դինամիկ զանգվածների համար տրամադրված հիշողու-
թյունը կարելի է ազատել delete [] օպերատորով: Ընդ որում,
ջնջվում է միայն ցուցիչը, իսկ զանգվածի տարրերը մնում են
հիշողության մեջ որպես «աղբ», և new օպերատորի միջոցով
զանգվածի համար տրամադրված դինամիկ հիշողությունը
այլևս օգտագործվել չի կարող:
1.2. ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ ՏԱՐՐԵՐԻ ԱՐԱԳ ԴԱՍԱՎՈՐՈՒՄ
Կազմել ծրագիր, որը կդասավորի իրական տարրերից բաղ-

կացած միաչափ զանգվածը արագ դասավորման եղանակով:
7
Կիրառենք զանգվածի միջին տարրի նկատմամբ բաժան-
ման ալգորիթմը: Բաժանման ալգորիթմը զանգվածը բաժա-
նում է երկու մասի: Զանգվածի ձախ մասում տեղադրվում են
այն տարրերը, որոնք փոքր են զանգվածի միջին տարրից, իսկ
աջ մասում՝ մեծերը: Դա իրականացվում է զանգվածի տար-
րերը երկու կողմից փոխ առ փոխ դիտարկմամբ: Զանգվածի
յուրաքանչյուր տարրը համեմատվում է ընտրված միջին տարրի
հետ: Ոչ ճիշտ մասում գտնվող տարրերը փոխվում են տեղե-
րով: Այդ գործընթացը բերում է նրան, որ միջին տարրը տեղա-
վորվում է իր տեղում, իրենից փոքրերը՝ իրենից ձախ, իսկ մե-
ծերը՝ աջ: Այնուհետև բաժանման ալգորիթմը պետք է կրկնել
առանձին ձախ և աջ կողմերի համար, և այդպես շարունակա-
բար:
Դեռ չդասավորված զանգվածի սահմանների պահպան-
ման համար կարելի է կիրառել սթեք կոչվող տվյալների կա-
ռուցվածք: Ստորև ներկայացված ծրագրում սթեքը իրակա-
նացված է stackr ու stackl զանգվածների միջոցով և sp փոփո-
խականի կիրառմամբ, որը իր մեջ պահում է զանգվածի վեր-
ջին լրացված տարրի համարը: Սթեքում տվյալը գրելու ժամա-
նակ sp փոփոխականի արժեքը մեկով ավելանում է, իսկ սթե-
քից հեռացնելու դեպքում՝ մեկով նվազում:
include <iostream>
using namespace std;
int main()
{const int n=10;
float arr[n],middle,temp;
int *stackl=new int [n];
int *stackr=new int [n];
8
int sp=0;
int i,j,left,right;
cout<<"Vvod arr"<<endl;
for(i=0;i<n;i++)cin>>arr[i];
sp=1; stackl[1]=0; stackr[1]=n-1; // 1
while(sp>0){ // 2
left=stackl[sp]; // 3
right=stackr[sp]; // 4
sp--; // 5
while(left<right){ // 6
i=left; j=right; // 7
middle=arr[(left+right)/2]; // 8
while(i<j){ // 9
while(arr[i]<middle)i++; // 10
while(middle<arr[j])j--; // 11
if(i<=j) {temp=arr[i];arr[i]=arr[j];arr[j]=temp;
i++; j--;}
}
if(i<right) // 12
{ sp++; stackl[sp]=i;stackr[sp]=right;}
right=j; // 13
}
}
for(i=0;i<n; i++)cout<<arr[i]<<" ";
cout<<endl;
delete []stackl;
delete []stackr;
return 0;
}
9
Այս ծրագրի ամեն մի քայլում դասավորվում է զանգվածի
մեկ հատված: Հատվածի ձախ սահմանը պահպանված է left,
իսկ աջը՝ right փոփոխականներում: Սկզբից հատվածի չափը
հավասար է ամբողջ զանգվածի չափին (տող 1): Տող 8-ում
ընտրվում է հատվածի միջին տարրը: Զանգվածում ձախից աջ
տեղաշարժման համար տող 10-ում օգտագործվում է i փո-
փոխականը, իսկ աջից ձախ՝ j փոփոխականը (տող11): Դրանց
սկզբնական արժեքները վերագրվում են տող 7-ում: Երբ որ
երկու հաշվիչների արժեքները կհավասարվեն զանգվածի
կենտրոնական մասում, կկատարվի տող 9-ի ցիկլից անցում
տող 12–ի օպերատորին, որը սթեքի մեջ գրում է զանգվածի
հատվածի աջ մասի սահմանները: Տող 13-ում տեղադրվում են
հատվածի ձախ մասի նոր սահմանները: Եթե դասավորվող
զանգվածի հատվածը արդեն այնքան փոքր է, որ չի պահան-
ջում դասավորում, իրականացվում է ելք տող 6-ի ցիկլից: Դրա-
նից հետո կատարվում է զանգվածի դեռ չդասավորված հատ-
վածի դիտարկումը (տողեր 3, 4): Եթե սթեքը դատարկ է, իրա-
կանացվում է ելք հիմնական ցիկլից (տող 2): Զանգվածը դա-
սավորված է:
1.3. ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ ՄԵԾԱԳՈՒՅՆ ԵՎ ՓՈՔՐԱԳՈՒՅՆ

ՏԱՐՐԵՐԻ ՄԻՋԵՎ ԸՆԿԱԾ ՏԱՐՐԵՐԻ ՔԱՆԱԿԸ
Կազմել ծրագիր, որը կհաշվի միաչափ զանգվածի այն

դրական տարրերի քանակը, որոնք գտնվում են մեծագույն և
փոքրագույն տարրերի միջև:
Քանի որ զանգվածում տարրերի կարգը նախապես հայտնի
չէ, զանգվածի սկզբից կարող են հանդիպել ինչպես մեծագույն,
այնպես էլ փոքրագույն տարրը: Հետևաբար, անհրաժեշտ է
որոշել մեծագույն և փոքրագույն տարրերի ինդեքսներից մեծը:
10
#include <iostream>
int main()
{ int i,n,imax, imin, count;
cout<<"n="; cin>>n;
int *a=new int[n];
for(i=0;i<n;i++)cin>>*(a+i); //1
for(i=imax=imin=0; i<n; i++){
if(*(a+i)>*(a+imax))imax=i;
if(*(a+i)<*(a+imin))imin=i;
}
cout << "\n\t max=" <<a[imax]<<" min="<<a[imin]; //ծրագրի
ստուգում
int ibeg= imax<imin ? imax : imin;
int iend= imax<imin ? imin : imax;
cout << "\n\t ibeg=" <<ibeg<<" iend="<<iend; //ծրագրի
ստուգում
for(count=0, i=ibeg+1; i<iend; i++)
if(*(a+i)>0) count++;
cout<<"\n\t count="<<count<<endl;
delete []a;
return 0;
}
Քանի որ զանգվածի տարրերի քանակը նախապես հանձ-
նարարված չէ, հիշողության ծավալը հատկացվում է օպերա-
տոր 1-ում ծրագրի կատարման ընթացքում new գործողության
միջոցով: Ծրագրում սկզբից գտնվում են մեծագույն և փոքրա-
գույն տարրերի ինդեքսները (imin և imax): Դրանից հետո որոշ-
11
վում են զանգվածի դրական տարրերի դիտարկման սահման-
ները (ibeg և iend): Այնուհետև զրոյացվում է դրական տար-
րերի count հաշվիչը, և հաշվվում է որոշված սահմաններում
գտնվող դրական տարրերի քանակը: Յուրաքանչյուր մեծութ-
յունը որոշելուց հետո ներդրված է ստուգողական արտածում:
1.4. ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻՑ ՆՈՐ ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ

ՍՏԱՑՈՒՄԸ
Կազմել ծրագիր, որը տրված միաչափ զանգվածի դրա-

կան տարրերից կստանա նոր միաչափ զանգված:
#include <iostream>
int main()
{int i,j,k,n;
cout<<"n="; cin>>n;
double *x=new double[n]; //1
for(i=0;i<n;i++)
cin>>*(x+i);
k=0;
for(i=0;i<n;i++) //2
if(*(x+i)>0)k++;
if(k==0){cout<<"Error"; return 1;} //4
double *y=new double[k]; //5
j=0;
for(i=0;i<n;i++)
if(*(x+i)>0){*(y+j)=*(x+i);j++;}
for(i=0;i<j;i++)
cout<<*(y+i)<<" ";
12
delete []x;
delete []y;
return 0;
}
Օպերատոր 1-ում նկարագրված է ցուցիչ իրական մե-
ծության վրա, որին վերագրվում է new գործողության օգնու-
թյամբ դինամիկ հիշողության հատկացման սկզբնական հաս-
ցեն: Օպերատոր 2-ում k հաշվիչի միջոցով որոշվում է զանգ-
վածում առկա դրական տարրերի քանակը: Եթե զանգվածում
բացակայում են դրական տարրեր, օպերատոր 4-ի միջոցով
արտածվում է համապատասխան հաղորդակցություն, և return 1
օպերատորով դադարեցվում է ծրագրի կատարումը:
Եթե զանգվածում կան դրական տարրեր, օպերատոր 5-ի
օգնությամբ անհրաժեշտ ծավալով դինամիկ հիշողություն է
հատկացվում նոր զանգվածի համար՝ նշված հասցեից սկսված:
1.5. ԽՆԴԻՐՆԵՐ ՄԻԱՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ

ՎԵՐԱԲԵՐՅԱԼ
Տարբերակ 1
Տրված իրական տիպի տարրերից բաղկացած միաչափ
զանգվածի համար որոշել՝
1. բացասական տարրերի գումարը,
2. մեծագույն և փոքրագույն տարրերի միջև գտնվող տար-
րերի արտադրյալը,
3. ստանալ նոր զանգված տրված զանգվածի բացասա-
կան տարրերից:
13
Տարբերակ 2
1. դրական տարրերի գումարը,
2. բացարձակ արժեքով մեծագույն և բացարձակ արժեքով
փոքրագույն տարրերի միջև գտնվող տարրերի արտադրյալը,
3. ստանալ նոր զանգված տրված զանգվածի կենտ ին-
դեքս ունեցող տարրերից:
Տարբերակ 3
Տրված ամբողջ տիպի տարրերից բաղկացած միաչափ
1. զույգ ինդեքս ունեցող տարրերի արտադրյալը,
2. առաջին և վերջին զրոյական արժեք ունեցող տարրերի
միջև գտնվող տարրերի գումարը,
3. ստանալ նոր զանգված տրված զանգվածի զույգ ար-
ժեք ունեցող տարրերից:
Տարբերակ 4
1. կենտ ինդեքս ունեցող տարրերի գումարը,
2. առաջին և վերջին բացասական արժեք ունեցող տար-
րերի միջև գտնվող տարրերի միջին թվաբանականը,
3. ստանալ նոր զանգված տրված զանգվածի դրական և
բացասական տարրերից:
Տարբերակ 5
1. մեծագույն տարրը,
14
2. սկզբից մինչև վերջին դրական տարրը գտնվող տար-
րերի գումարը,
3. ստանալ նոր զանգված տրված զանգվածի [a,b] միջա-
կայքին պատկանող տարրերից:
Տարբերակ 6
1. փոքրագույն տարրը,
2. առաջին և վերջին դրական տարրերի միջև գտնվող
տարրերի միջին քառակուսայինը,
3. ստանալ նոր զանգված տրված զանգվածի [a; b] միջա-
կայքից դուրս գտնվող տարրերից:
Տարբերակ 7
Տրված ամբողջ տիպի տարրերից բաղկացած միաչափ
1. միակ մեծագույն տարրի ինդեքսը,
2. առաջին և երկրորդ զրոյական արժեք ունեցող տար-
րերի միջև գտնվող տարրերի արտադրյալը,
3. ստանալ նոր զանգված տրված զանգվածի կենտ
արժեք ունեցող տարրերից:
Տարբերակ 8
1. միակ փոքրագույն տարրի ինդեքսը,
2. առաջին և երկրորդ բացասական արժեք ունեցող
տարրերի միջև գտնվող տարրերի գումարը,
3. ստանալ նոր զանգված տրված զանգվածի այն տար-
րերից, որոնք փոքր են տրված k թվից:
15
Տարբերակ 9
1. բացարձակ արժեքով մեծագույն տարրը,
2. առաջին և երկրորդ դրական տարրերի միջև գտնվող
տարրերի միջին թվաբանականը,
րերից, որոնք մեծ են տրված k թվից:
Տարբերակ 10
Տրված n բնական թիվ պարունակող ամբողջ տիպի տար-
րերից բաղկացած միաչափ զանգվածի համար որոշել՝
1. բացարձակ արժեքով փոքրագույն տարրը,
2. առաջին զրոյական արժեք ունեցող տարրին հաջոր-
դող կենտ տարրերի գումարը,
րերից, որոնք 6-ի բաժանելիս կմնա 1 մնացորդ:
16
2. ԵՐԿՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ
Հիշողության դինամիկ տարածքում կարելի է ստեղծել

երկչափ զանգվածներ (մատրիցներ) new գործողության միջո-
ցով: Երկչափ զանգվածը C++ լեզվում ներկայացված է որպես
միաչափ զանգվածներից բաղկացած զանգված: Ամբողջ զանգ-
վածի համար հիշողություն տրամադրելու ժամանակ տողերի
քանակը կարելի է հանձնարարել փոփոխականի կամ արտա-
հայտության օգնությամբ, բայց սյուների քանակը պետք է լինի
հաստատուն արտահայտություն, այսինքն՝ պետք է ակնհայտ
հանձնարարվի մինչև ծրագրի աշխատանքի սկսվելը:
Երկչափ զանգվածի համար դինամիկ հիշողության տրա-
մադրման ունիվերսալ և անվտանգ ձևը կարելի է ներկայաց-
նել հետևյալ կերպ.
int nrow,ncol;
cin>>nrow>>ncol;
int **a=new int*[nrow]; //1
for(int i=0; i<nrow; i++) //2
a[i]=new int[ncol]; //3
Այս կոդում nrow-ը մատրիցի տողերի, իսկ ncol-ը՝ սյու-
ների քանակն է: Օպերատոր 1-ում հայտարարվում է «int տիպի
ցուցիչի վրա ցուցիչ» (կրկնակի ցուցիչ) և տրամադրվում է հի-
շողություն մատրիցի տողերի ցուցիչների զանգվածի վրա: Օպե-
րատոր 2-ի ցիկլի օգնությամբ հիշողություն է հատկացվում
մատրիցի յուրաքանչյուր տողի համար: Օպերատոր 3-ի միջո-
ցով մատրիցի սյուների չափով հատկացվում է դինամիկ հիշո-
ղություն:
int **a int *a[nrow] int a[nrow][ncol]
17
...
...
...
.
.
.
...
Նկ.2.1. Երկչափ զանգվածին դինամիկ հիշողություն տրամադրելու

սխեման
Դինամիկ մատրիցի հեռացումը հիշողությունից կարելի

է կատարել հետևյալ կերպ.
for(int i=0; i<nrow; i++)
delete []a[i];
delete []a;
Սկզբում ջնջվում է ցուցիչներին կցված միաչափ զանգ-
վածը, իսկ հետո՝ ցուցիչների զանգվածը:
2.1. ԵՐԿՉԱՓ ԶԱՆԳՎԱԾԻ ՏԱՐՐԵՐԻ ԴԱՍԱՎՈՐՈՒՄԸ

ԳԼԽԱՎՈՐ ԵՎ ՕԺԱՆԴԱԿ ԱՆԿՅՈՒՆԱԳԾԵՐԻ ՆԿԱՏՄԱՄԲ
Կազմել ծրագիր, որը տրված քառակուսային իրական

տիպի տարրեր պարունակող երկչափ զանգվածում կհաշվի.
1. գլխավոր անկյունագծից ներքև կամ նրա վրա գտնվող
դրական արժեք ունեցող տարրերի միջին թվաբանականը,
2. օժանդակ անկյունագծից վերև գտնվող այն տարրերի
միջին քառակուսայինը, որոնց ինդեքսների գումարը կենտ է:
#include <iostream>
#include <cmath>
18
int main( )
{int n,i,j,q;
double Mt,s,Mq;
cout<<"n=";cin>>n;
double **x=new double*[n]; //1
for(i=0; i<n; i++) //2
x[i]=new double[n];
for(i=0;i<n;i++) //3
for(j=0;j<n;j++)
cin>>*(*(x+i)+j);
s=q=0;
for(i=0;i<n;i++) //4
for(j=0;j<=i;j++)
if(*(*(x+i)+j)>0)
{s+=*(*(x+i)+j);q++;}
if(q!=0){Mt=s/q;cout<<Mt<<endl;} //5
else cout<<"Error";
s=0; q=0;
for(i=0;i<n-1;i++) //6
for(j=0;j<n-i-1;j++)
if((i+j)%2==1)
{s+=pow(*(*(x+i)+j),2);q++;}
Mq=sqrt(s/q); cout<<Mq<<endl;
for(i=0; i<n; i++) //7
delete []x[i];
delete []x; //8
return 0;
}
19
Օպերատոր 1-ի միջոցով հայտարարվում է double տիպի
վրա կրկնակի ցուցիչ: Օպերատոր 2-ով դինամիկ հիշողութ-
յուն է տրամադրվում մատրիցի յուրաքանչյուր տողի համար:
Օպերատոր 3-ը կրկնակի ցիկլ է, որով ստեղնաշարից ներ-
մուծվում են մատրիցի տարրերը: Օպերատոր 4-ի կրկնակի
ցիկլով որոշվում են տրված մատրիցի գլխավոր անկյունագծից
ներքև կամ նրա վրա գտնվող դրական արժեք ունեցող տար-
րերի գումարը և քանակը: Եթե մատրիցում առկա են այդպիսի
տարրեր, օպերատոր 5-ի միջոցով հաշվվում և արտածվում է
միջին թվաբանականը, հակառակ դեպքում՝ արտածվում է
«Error» հաղորդակցությունը: Մատրիցի օժանդակ անկյունա-
գծից վերև գտնվող և ինդեքսների կենտ գումար ունեցող տար-
րերի միջին քառակուսայինը որոշող և արտածող կրկնակի
ցիկլը, վերագրման և արտածող օպերատորներն ունեն 6-րդ
համարը: Օպերատոր 7-ը ազատում է ցուցիչներին կցված
միաչափ զանգվածները, իսկ 8-ը՝ ցուցիչների զանգվածը:
2.2. ԵՐԿՉԱՓ ԶԱՆԳՎԱԾԻ ՏՈՂԵՐԻ ԴԱՍԱՎՈՐՈՒՄԸ
Կազմել ծրագիր, որը կդասավորի տրված քառակուսային

ամբողջ տիպի տարրեր պարունակող երկչափ զանգվածի
տողերը, ըստ դրանց գումարների աճման կարգի:
Քանի որ մատրիցի չափը հայտնի չէ, օգտագործվում է
դինամիկ երկչափ զանգված: Արդյունքը՝ նույն մատրիցն է, բայց
դասավորված: Դա նշանակում է, որ մատրիցը դասավորվում
է հիշողության նույն տարածքում (in situ): Մատրիցի տողերի
գումարները գրանցվում են միաչափ դինամիկ զանգվածում,
որի տարրերի քանակը հավասար է մատրիցի տողերի քանակին:
Մատրիցի տողերը դասավորելու համար օգտագործել
այսպես կոչված ընտրման եղանակը: Զանգվածում սկզբում
20
ընտրվում է փոքրագույն տարրը, որը փոխվում է տեղերով
զանգվածի առաջին տարրի հետ: Այնուհետև դիտարկվում են
զանգվածի երկրորդ տարրից հետո դասավորված տարրերը, և
դրանցից փոքրագույնը փոխվում է տեղերով երկրորդի հետ,
ու այդպես շարունակ՝ n-1 անգամ:
Ներկայացնենք դասավորման ծրագրի տեսքը.
#include <iostream>
#include <iomanip>
int main( )
{int nrow, ncol;
cin>>nrow>>ncol; //1
int i,j;
double **a=new double *[nrow]; //2
for(i=0; i<nrow; i++)
*(a+i)=new double [ncol];
for(i=0; i<nrow; i++) //3
for(j=0; j<ncol; j++)
cin>>*(*(a+i)+j);
double *sum=new double[nrow]; //4
for(i=0; i<nrow; i++){ //5
*(sum+i)=0;
*(sum+i)+=*(*(a+i)+j);
}
for(i=0; i<nrow; i++){ //6
cout<<setw(4)<<*(*(a+i)+j)<<" ";
21
cout<<"|"<<*(sum+i)<<endl;
}
cout<<endl;
double buf_sum, buf_a;
int nmin;
for(i=0; i<nrow-1; i++){ //7
nmin=i;
for(j=i+1; j<nrow; j++)
if(*(sum+j)<*(sum+nmin)) nmin=j;
buf_sum=*(sum+i); *(sum+i)=*(sum+nmin);
*(sum+nmin)=buf_sum;
for(j=0; j<ncol; j++){
buf_a=*(*(a+i)+j);*(*(a+i)+j)=*(*(a+nmin)+j);*(*(a+nmin)+j)=buf_a;
}
}
for(i=0; i<nrow; i++){ //8
cout<<setw(4)<<*(*(a+i)+j)<<" ";
cout<<endl;
}
for(i=0; i<nrow; i++) //9
delete []a[i];
delete []a;
return 0;
}
Ծրագրում օգտագործված են երկու բուֆերային փոփո-
խական. գումարները արժեքներով փոփոխման համար նախա-
տեսված buf_sum –ը և մատրիցի տարրերը արժեքներով փո-
փոխման համար ՝ buf-_a -ն:
22
Օպերատոր 1-ով ներմուծվում են մատրիցի տողերի և
սյուների քանակները: Իրական double տիպի վրա կրկնակի
ցուցչի հայտարարումը և դինամիկ հիշողության տրամադրումը
մատրիցի յուրաքանչյուր տողի համար իրականացվում է օպե-
րատոր 2-ով: Օպերատոր 3-ը տող առ տող ներմուծում է մատ-
րիցի տարրերը: Տողերի գումարները հիշելու համար նախա-
տեսված sum դինամիկ զանգվածի համար հիշողության մեջ
տեղ է հատկացվում օպերատոր 4-ի օգնությամբ: Այդ զանգ-
վածը ձևավորվում է կրկնակի ցիկլի 5-րդ համարի օպերատո-
րով: Օպերատոր 6-ը կատարում է մատրիցի տարրերի և տո-
ղերի գումարների ստուգարքային արտածում: Ընտրման եղա-
նակով sum զանվածի տարրերի և միաժամանակ մատրիցի
համապատասխան տողի տարրերի դասավորումը իրականաց-
վում է օպերատոր 7-ով: Դասավորված մատրիցի տարրերի
արտածումը կատարում է օպերատոր 8-ը:
2.3. ԵՐԿՉԱՓ ԶԱՆԳՎԱԾԻՑ ՆՈՐ ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ

ՍՏԱՑՈՒՄԸ
Կազմել ծրագիր, որը տրված քառակուսային ամբողջ

տիպի տարրեր պարունակող երկչափ զանգվածից կստանա նոր
միաչափ զանգված, որի յուրաքանչյուր տարրը հավասար է
երկչափ զանգվածի համապատասխան համար ունեցող տողի
զույգ տարրերի գումարին:
Ըստ խնդրի պայմանի, ստացվող միաչափ զանգվածի
տարրերի քանակը հավասար է տրված երկչափ զանգվածի տո-
ղերի քանակին: Հետևաբար, միաչափ զանգվածին դինամիկ
հիշողության մեջ տեղ հատկացնելու համար նրա չափը նա-
խապես հաշվելու անհրաժեշտություն չկա:
23
#include <iostream>
#include <iomanip>
int main( )
{int n,i,j,s;
cout<<"n="; cin>>n; //1
int **x=new int*[n]; //2
for(i=0;i<n; i++) //3
*(x+i)=new int[n];
int *y=new int[n]; //4
for(i=0; i<n; i++) //5
for(j=0; j<n; j++)
cin>>*(*(x+i)+j);
for(i=0; i<n; i++){ //6
s=0;
for(j=0; j<n; j++)
if(*(*(x+i)+j)%2==0)
s+=*(*(x+i)+j);
*(y+i)=s;
}
for(i=0; i<n; i++){ //7
for(j=0; j<n; j++)
cout<<setw(4)<<*(*(x+i)+j)<<" ";
cout<<"| "<<*(y+i)<<endl;
}
cout<<endl;
for(i=0; i<n; i++) //8
delete []x[i];
24
delete []x;
delete[]y; //9
return 0;
}
Օպերատոր 1-ով ներմուծվում է քառակուսային մատրիցի
չափը: Ամբողջական int տիպի վրա կրկնակի ցուցիչ է հայտա-
րարվում օպերատորներ 2-ով: Օպերատոր 3-ով դինամիկ հի-
շողություն է տրամադրվում երկչափ զանգվածի յուրաքանչ-
յուր տողի համար: Օպերատոր 4-ով դինամիկ հիշողություն է
հատկացվում նոր միաչափ զանգվածի համար: Օպերատոր 5-ի
օգնությամբ տող առ տող ներմուծվում են երկչափ զանգվածի
տարրերը: Նոր վեկտորի տարրերը, ըստ խնդրի պայմանի,
ստացվում են օպերատոր 6-ով: Օպերատոր 7-ը արտածում է
և՝ տրված մատրիցի, և՝ ստացված վեկտորի տարրերը: Օպե-
րատոր 8-ի միջոցով ջնջվում են ցուցիչներին կցված միաչափ
զանգվածները, իսկ հետո՝ ցուցիչների զանգվածը: Ստացված
նոր վեկտորի համար տրամադրված հիշողությունը ազատ-
վում է օպերատոր 9-ի օգնությամբ:
Կազմել ծրագիր, որը տրված քառակուսային իրական
տիպի տարրեր պարունակող երկչափ զանգվածից կստանա
նոր միաչափ զանգված, որի տարրերը բաղկացած են երկչափ
զանգվածի [a,b] միջակայքին պատկանող տարրերից:
Այս խնդիրը նախորդից տարբերվում է, հիմնականում
ստացվող միաչափ զանգվածի տարրերի քանակի անորոշու-
թյամբ: Երկչափ զանգվածի բալոր տարրերն էլ կարող են պատ-
կանել տրված [a,b] միջակայքին: Այդ դեպքում ստացվող միա-
չափ զանգվածի չափը կլինի n*n, որտեղ n-ը երկչափ քառա-
կուսային զանգվածի չափն է: Երկչափ զանգվածը կարող է
25
ընդհանրապես չունենալ [a,b] միջակայքին պատկանող տարր,
հետևաբար, նոր զանգված չի կառուցվի, և ծրագրի կատարումը
պետք է դադարեցվի: Վերջապես, կարող է լինել այդ երկու
դեպքերից միջինը: Այդ պատճառով ծրագրի կատարման
սկզբից պետք է որոշվի երկչափ զանգվածի տրված [a,b] միջա-
կայքին պատկանող տարրերի քանակը, ինչից հետո միայն
ստացվող միաչափ զանգվածի համար կարելի է հատակացնել
համապատասխան ծավալի դինամիկ հիշողություն:
#include <iostream>
#include <iomanip>
int main( )
{int n,i,j;
double a,b;
cout<<"a="; cin>>a; //1
cout<<"b=";cin>>b; //1
cout<<"n="; cin>>n; //2
double **x=new double*[n]; //3
for(i=0;i<n; i++) //4
*(x+i)=new double[n];
for(i=0; i<n; i++) //5
for(j=0; j<n; j++)
cin>>*(*(x+i)+j);
int count=0; //6
for(i=0; i<n; i++) //7
for(j=0; j<n; j++)
if(*(*(x+i)+j)>=a && *(*(x+i)+j)<=b)
count++;
26
cout<<"\n\tcount="<<count<<endl; //8
if(count==0){cout<<"Error"; return 1;} //9
double *y=new double[count]; //10
int k=-1;
for(i=0; i<n; i++) //12
for(j=0; j<n; j++)
if(*(*(x+i)+j)>=a && *(*(x+i)+j)<=b)
{k++;*(y+k)=*(*(x+i)+j);}
for(i=0; i<count; i++) //13
cout<<*(y+i)<<" ";
cout<<endl;
for(i=0; i<n; i++) //14
delete []x[i];
delete []x;
delete[]y; //15
return 0;
}
Ծրագրում 1 համարով նշված օպերատորները ներմու-
ծում են տրված միջակայքի սահմանները, ընդ որում a<b: Օպե-
րատոր 2-ը ներմուծում է տրված քառակուսային մատրիցի
չափը: Օպերատոր 3-ը հայտարարում է կրկնակի ցուցիչ double
տիպի վրա: Օպերատոր 4-ով դինամիկ հիշողություն է հատ-
կացվում երկչափ զանգվածի յուրաքանչյուր տողի համար:
Օպերատոր 5-ի օգնությամբ տող առ տող ներմուծվում են երկ-
չափ զանգվածի տարրերը: Օպերատոր 6-ը count հաշվիչն ինի-
ցիալացնում է 0 արժեքով: Օպերատոր 7-ի միջոցով կատար-
վում է երկչափ զանգվածի [a,b] միջակայքին պատկանող տար-
րերի քանակի հաշվարկը: Օպերատոր 8-ը արտածում է ստաց-
27
ված քանակի արժեքը: Եթե երկչափ զանգվածում այդպիսի
տարրերը բացակայում են, օպերատոոր 9-ի օգնությամբ ար-
տածվում է “Error” հաղորդակցությունը, և ծրագրի կատարումը
դադարեցվում է: Հակառակ դեպքում օպերատոր 10-ը անհրա-
ժեշտ ծավալով դինամիկ հիշողություն է տրամադրում ստաց-
վող նոր միաչափ զանգվածի համար: Օպերատոր 12-ի միջո-
ցով կազմվում է միաչափ զանգվածը, որի տարրերը օպերա-
տոր 13-ի օգնությամբ արտածվում են մոնիտորի վրա: Այնու-
հետև օպերատոր 14-ով ջնջվում են ցուցիչներին կցված միա-
չափ զանգվածները, իսկ հետո՝ ցուցիչների զանգվածը: Օպե-
րատոր 15-ն ազատում է ստացված միաչափ զանգվածին
տրամադրված դինամիկ հիշողությունը:
2.4. ԽՆԴԻՐՆԵՐ ԵՐԿՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ

Տարբերակ 11
Տրված իրական տիպի տարրերից բաղկացած քառակու-
սային երկչափ զանգվածի համար՝
1. որոշել գլխավոր անկյունագծից վերև գտնվող դրա-
կան տարրերի միջին քառակուսայինը,
2. դասավորել երկչափ զանգվածի սյուները ըստ դրանց
փոքրագույն արժեքների նվազման կարգի,
3. կազմել նոր միաչափ զանգված, որի տարրերը ստաց-
վում են երկչափ զանգվածի համապատասխան տողից և հա-
վասար են -3-ի, եթե տողի տարրերը դասավորված են աճման
կարգով, հակառակ դեպքում՝3-ի:
28
Տարբերակ 12
Տրված ամբողջ տիպի տարրերից բաղկացած քառակու-
1. որոշել օժանդակ անկյունագծից ներքև գտնվող զույգ
արժեք ունեցող տարրերի միջին թվաբանականը,
2. դասավորել երկչափ զանգվածի տողերը, ըստ դրանց
զույգ արժեք ունեցող տարրերի քանակների աճման կարգի,
վում են երկչափ զանգվածի զույգ արժեք ունեցող տարրերից:
Տարբերակ 13
1. որոշել գլխավոր անկյունագծից ներքև կամ նրա վրա
գտնվող բացասական տարրերի գումարը,
2. դասավորել երկչափ զանգվածի սյուները, ըստ դրանց
մեծագույն արժեքների աճման կարգի,
վասար են տողի առաջին տարրին, եթե այդ տողի մեջ կա գոնե
մեկ բացասական տարր, հակառակ դեպքում՝ տողի վերջին
տարրին:
Տարբերակ 14
սային երկչափ զանգվածի համար ՝
1. որոշել օժանդակ անկյունագծից վերև գտնվող կենտ
արժեք ունեցող տարրերի քանակը,
կենտ արժեք ունեցող տարրերի գումարների նվազման կարգի,
29
վում են երկչափ զանգվածի 7-ին բազմապատիկ արժեք ունե-
ցող տարրերից:
Տարբերակ 15
1. որոշել օժանդակ անկյունագծից ներքև կամ նրա վրա
գտնվող այն տարրերի արտադրյալը, որոնց ամբողջ մասը
բազմապատիկ է 7 ամբողջ թվին,
դրական արժեք ունեցող տարրերի միջին թվաբանականների
չաճման կարգի: Ենթադրվում է, որ երկչափ զանգվածի յուրա-
քանչյուր տող պարունակում է գոնե մեկ դրական արժեք ունե-
ցող տարր,
վում են երկչափ զանգվածի բացասական արժեք ունեցող
տարրերից:
Տարբերակ 16
1. որոշել գխավոր անկյունագծից վերև կամ նրա վրա
գտնվող կենտ այն տարրերի միջին երկրաչափականը, որոնք
բազմապատիկ են տրված k ամբողջ թվին,
զույգ արժեք ունեցող տարրերի միջին քառակուսայինների
չնվազման կարգի: Ենթադրվում է, որ երկչափ զանգվածի յու-
րաքանչյուր սյուն պարունակում է գոնե մեկ զույգ արժեք ունե-
ցող տարր,
30
վասար են տողի տարրերի գումարին, եթե այդ տողի մեջ կա
գոնե մեկ զրոյական տարր, հակառակ դեպքում՝ տողի տար-
րերի արտադրյալին:
Տարբերակ 17
1. որոշել գլխավոր անկյունագծից ներքև գտվող այն տար-
րերի քանակը և գումարը, որոնք պատկանում են տրված [a, b]
միջակայքին,
2. դասավորել երկչափ զանգվածի տողերը, ըստ նրանց
փոքրագույն արժեքների չնվազման կարգի,
վում են երկչափ զանգվածի ոչ զրոյական արժեք ունեցող տար-
րերից:
Տարբերակ 18
1. որոշել գլխավոր և օժանդակ անկյունագծերի կենտ
արժեք ունեցող տարրերի միջին թվաբանականը,
5-ին բազմապամատիկ արժեք ունեցող տարրերի գումարների
նվազման կարգի: Ենթադրվում է, որ երկչափ զանգվածի յու-
րաքանչյուր տողը պարունակում է գոնե մեկ 5-ին բազմապա-
տիկ արժեք ունեցող տարր,
վում են երկչափ զանգվածի համապատասխան սյունից և
31
հավասար են սյան զույգ արժեք ունեցող տարրերի գումարին,
եթե այդ սյան մեջ կա գոնե մեկ 3-ին բազմապատիկ տարր, հա-
կառակ դեպքում՝ սյան կենտ արժեք ունեցողների գումարին:
Տարբերակ 19
սային երկչափ զանգվածի համար ՝
1. որոշել գլխավոր անկյունագծի փոքրագույն տարրը,
դրական արժեքների գումարների աճման կարգի: Ենթադրվում
է, որ երկչափ զանգվածի յուրաքանչյուր սյուն պարունակում է
գոնե մեկ դրական արժեք ունեցող տարր,
վում են երկչափ զանգվածի համապատասխան սյունից և հա-
վասար են սյան այն տարրերի քանակին, որոնց բացարձակ
արժեքները մեծ են տրված k թվից, հակառակ դեպքում՝ հավա-
սար են զրոյի:
Տարբերակ 20
1. որոշել օժանդակ անկյունագծի մեծագույն տարրի
տողի համարը,
բացասական արժեքների քանակների նվազման կարգի: Են-
թադրվում է, որ երկչափ զանգվածի յուրաքանչյուր տող պա-
րունակում է գոնե մեկ բացասական արժեք ունեցող տարր,
վասար են տողի տարրերի արտադրյալին, եթե տողը չի պա-
րունակում զրոյական տարրեր, հակառակ դեպքում՝ հավա-
սար են մեկի:
32
3. ՖՈՒՆԿՑԻԱՆԵՐԻ ՆԿԱՐԱԳՐՈՒԹՅՈՒՆԸ
Ֆունկցիաները C/C++ ծրագրավորման լեզուների կառու-

ցողական բլոկներ են: Ֆունկցիան ամբողջական և ավարտա-
կան գործողություն կատարող օպերատորների խումբ է: Նրան
կարելի է դիմել անունով, ուղարկել արժեք և ստանալ արդ-
յունք: Ֆունկցիան օգտագործելու համար պետք է իմանալ նրա
ինտերֆեյսը, որը որոշվում է նրա վերնագրով: Վերնագրի մեջ
նշվում է ֆունկցիայի անունը, արդյունքի տիպը, փոխանցվող
արգումենտների տիպը և քանակը:
Ֆունկցիան նկարագրելու հիմնական գրելաձևը հետև-
յալն է՝
<վերադարձվող արժեքի տիպ> <անուն> (<արգումենտ-
ների ցուցակ>) //1
{
<ֆունկցիայի մարմին>
}
Գրելաձևի մեջ 1-ը ֆունկցիայի վերնագիրն է: Վերադարձ-
վող արժեքի տիպը որոշում է վերադարձվող փոփոխականի
տիպը: Ֆունկցիան կարող է վերադարձնել ցանկացած տիպի
փոփոխական: Չի կարելի վերադարձնել զանգվածներ: Եթե
ֆունկցիան արժեք չի վերադարձնում, ապա այն void տիպի է:
Չի թույլատրվում մի ֆունկցիայի մարմնում նկարագրել մեկ
այլ ֆունկցիա:
Եթե ֆունկցիան ունի արգումենտներ, նրա վերնագրի
մեջ պետք է նկարագրված լինեն դրանց արժեքները ստացող
փոփոխականները, որոնք կոչվում են ֆորմալ կամ ձևական
պարամետրեր:
Արգումենտների ցուցակի տեսքը հետևյալն է՝
<տիպի անուն> <արգումենտի անուն>
33
Եթե ֆունկցիան վերադարձնում է արժեք, նրա մարմինը
պետք է պարունակի return հրահանգը: Այդ հրահանգը կարող
է ունենալ հետևյալ երկու տեսքից մեկը՝
1. return;
2. return <արտահայտություն>;
Առաջին տեսքը օգտագործվում է այն ֆունկցիաներում,
որոնցից վերադարձը պետք է տեղի ունենա նրա մարմնի ոչ
բոլոր հրահանգները կատարելուց հետո:
Երկրորդ տեսքը օգտագործվում է թարգմանչին տեղե-
կացնելու համար, թե որոշված արժեքը ֆունկցիան ինչ տրա-
մաբանությամբ պետք է վերադարձնի:
Եթե ֆունկցիայի մարմնում return հրահանգը բացակա-
յում է, ապա նրանից վերադարձը դիմող ծրագրին կատար-
վում է ֆունկցիայի մարմնում բոլոր հրահանգները կատարվե-
լուց հետո:
C++ լեզվում բոլոր ֆունկցիաները իրենց առաջին կանչից
առաջ պետք է հայտարարվեն: Նախատիպը հանդիսանում է
ֆունկցիայի հայտարարությունը: Նախատիպն ունի վերնագրի
նման կառուցվածք, բայց պարտադիր ավարտվում է " ; " սիմ-
վոլով: C++ լեզվում, ի տարբերություն C լեզվի, նախատիպերի
առկայությունը համարվում է պարտադիր: Եթե ծրագրում օգ-
տագործվում է նախատիպ, թարգմանիչը կարող է գտնել ան-
համապատասխանություն փոխանցվող և ստացվող պարա-
մետրների թվերի և տիպերի միջև: Պարամետրների անուն-
ները նախատիպերի մեջ նշելը պարտադիր չէ:
Այսպիսով, ֆունկցիաների նախատիպերը հնարավորու-
թյուն են տալիս սխալներ գտնել ծրագրում: Դրանք երաշխա-
վորում են, որ ֆունկցիայի կանչը չի իրականացվի ոչ ճիշտ պա-
րամետրերով:
34
3.1. ՖՈՒՆԿՑԻԱՅԻՆ ՓՈԽԱՆՑՎՈՂ ՊԱՐԱՄԵՏՐԵՐԻ
ԵՂԱՆԱԿՆԵՐԸ
C/C++ ծրագրավորման լեզուներում արգումենտները ֆունկ-

ցիաներին կարելի է ուղարկել հետևյալ եղանակներով:
1. Արժեքով (call by value): Ֆունկցիայի ձևական պարա-
մետրին վերագրվում է արգումենտի պատճենը, որը և վերա-
գրվում է արգումենտների ցուցակում թվարկված ձևական պա-
րամետրին: Այդ դեպքում պարամետրի փոփոխումը ոչ մի ձևով
չի ազդում արգումենտի վրա: Դիտարկենք հետևյալ կոդը:
#include <iostream>
int sqr(int x);
int main()
{
int v, t=10;
v=sqr(t);
cout<<t<<” ”<<v<<endl;
return 0;
}
int sqr(int x)
{x=x*x;
return x;
}
Այս օրինակում sqr() ֆունկցիայի t արգումենտի արժեքը
պատճենվում է x պարամետրի մեջ: Ֆունկցիայում x=x*x գոր-
ծողութունը փոխում է միան x-ի արժեքը և ոչ մի կերպ չի
ազդում t փոփոխականի վրա, որի արժեքը մնում է հավասար
10-ի:
35
2. Ցուցչով (call by reference): Այդ դեպքում արգումենտի
փոխարեն ֆունկցիային փոխանցվում է նրա վրա ցուցիչ: Քանի
որ ֆունկցիան ստանում է արգումենտի հասցեն, նրա կոդը
կարող է փոխել արգումենտի արժեքը ֆունկցիայից դուրս:
Դիտարկենք օրինակ:
#include <iostream>
void swap(int *x, int *y);
int main()
{
int i, j;
i=10;
j=20;
swap(&i, &j); //1
cout<<i<< " "<<j<<endl;
return 0;
}
void swap(int *x, int *y)
{int temp;
temp=*x; //2
*x = *y; //3
*y = temp; //4
}
Օպերատոր 1-ով i և j փոփոխականների հասցեներն
ուղարկվում են swap() ֆունկցիային: Օպերատոր 2-ի միջոցով
temp փոփոխականի մեջ հիշվում է x փոփոխականի հասցեով
գրված արժեքը: Օպերատոր 3-ը y փոփոխականի հասցեով
արժեքը գրանցվում է x փոփոխականի համար նախատեսված
36
հիշողության բջջի մեջ: Օպերատոր 4-ը y փոփոխականի հա-
մար նախատեսված հիշողության մեջ գրում է temp փոփոխա-
կանի արժեքը:
3. Հղումով: C++ ծրագրավորման լեզուն հնարավորու-
թյուն է տալիս օգտագործել ցուցիչներին նման փոփոխական-
ներ, որոնք կոչվում են հղումներ: Հղումը շատ հաճախ կարելի
է դիտարկել որպես փոփոխականի երկրորդ անուն: Հղումների
ամենակարևոր կիրառումը ավտոմատորեն ըստ հղման ձևով
պարամետրերի փոխանցման հնարավորություն ունեցող ֆունկ-
ցիաների ստեղծումն է: Պարամետրի վրա հղումը ստեղծելու
համար նրա անունը պետք է նախորդել &(ամպերսենդ) սիմ-
վոլով: Դիտարկենք նախորդ օրինակը՝ հղումների կիրառմամբ:
#include <iostream>
void swap(int &x, int &y);
int main()
{ int i, j;
i=10;
j=20;
swap(i, j); //1
cout<<i<< " "<<j<<endl;
return 0;
}
void swap(int &x, int &y) //2
{int temp;
temp=x;
x = y;
y = temp;
}
37
Այս կոդում օպերատոր 2-ի մեջ x և y փոփոխականները
դառնում են օպերատոր 1-ում նշված i և j փաստացի ար-
գումենտների երկրորդ անուններ, և դրանց հետ կատարվող
բոլոր գործողությունները ավտոմատորեն տարածվում են
համապատասխան փաստացի պարամետրերի վրա:
3.2. ԱՆՎԵՐՋ ՇԱՐՔԻ ԳՈՒՄԱՐԻ ՀԱՇՎԱՐԿ
Կազմել ծրագիր, որն արգումենտի տրված միջակայքում

Թեյլորի անվերջ շարքի օգնությամբ կհաշվի Ԑ ճշտությամբ Ch
x (հիպերբոլիկ կոսինուս) ֆունկցիայի արժեքը հետևյալ բա-
նաձևով.
x2 x4 x6 x 2n
y=1+ + + + ⋯+ +⋯
2! 4! 6! 2n!
Այդ շարքը զուգամիտում է, եթե |x| < ∞: Պահանջվող
ճշտությունը ստանալու համար անհրաժեշտ է գտնել շարքի
այն անդամների գումարը, որոնց բացարձակ արժեքները մեծ
են Ԑ-ից: Զուգամիտող շարքի համար Cn շարքի անդամի բա-
ցարձակ արժեքը ձգտում է զրոյին n-ի մեծացման ժամանակ:
Ֆունկցիայի հաշվարկը ավարտվելու է, երբ n-ի որոշակի ար-
ժեքի համար |Cn | ≥ ε անհավասարությունը այլևս չի կատար-
վելու:
Խնդիրը լուծելու համար օգտագործենք շարքի հաջորդ
անդամը նախորդից ստանալու ռեկուրենտ բանաձևը՝ Cn+1 =
= Cn × T, որտեղ T-ն բազմապատկիչ է: Հետևաբար.
Cn+1 2n! ∙ x 2(n+1) x2
T= = 2n = ∶
Cn x ∙ (2(n + 1))! (2n + 1)(2n + 2)
38
Բանաձևից երևում է, որ ալգորիթմը պետք է պարունակի
ցիկլ, որի միջոցով շարքի նախորդ անդամից ստացվում է հա-
ջորդը: Մինչև ծրագրի կատարումը հնարավոր չէ իմանալ գու-
մարվող շարքի անդամների քանակը, այսինքն՝ ցիկլի իտերա-
ցիաների թիվը: Քանի որ գոյություն ունեն թվային առանցքի
միայն որևէ միջակայքում զուգամիտող Թեյլորի շարքեր, կա
վտանգ, որ ցիկլը երբեք չի դադարեցնի աշխատանքը: Հետևա-
բար, ծրագրի մեջ ցիկլի իտերացիաների քանակը պետք է
սահմանափակվի: Ակնհայտ է, որ շարքի գումարի հաշվարկը
մեկ արգումենտի համար պետք է կազմակերպվի ֆունկցիայի
միջոցով: Այդ ֆունկցիան որպես արգումենտներ պետք է ստանա
արգումենտի արժեքը և ճշտությունը: Ենթադրենք՝ այդ արգու-
մենտները և վերադարձվող արժեքը պատկանում են double տի-
պին: Հետևաբար, ֆունկցիան կարող է ունենալ հետևյալ տեսքը.
double T_cosh(double x, double eps){
const int MaxIter=500;
double ch=1, y=ch;
for(int n=0; fabs(ch)>eps; n++){
ch *=(x * x) / ((2 * n + 1)*(2 * n + 2));
y += ch;
if(n > MaxIter) {cout<<”Divergent Sequence ”; return 0;}
return y;
}
Սակայն, եթե հաձնարարվեն արգումենտների մեծ քա-
նակ և շատ բարձր ճշտություն, շատ դժվար կլինի ընտրել իտե-
րացիաների կատարումը սահմանափակող թիվը: Ավելի գրա-
գետ է ֆունկցիայի մարմնի մեջ ձևավորել և դուրս բերել գու-
մարի ճիշտ հաշվման ցուցանիշը: Այդ տեսանկյունից ֆունկցիան
կարող է ստանալ հետևյալ տեսքը.
39
double T_cosh(double x, double eps, int &err){
err=0;
double ch=1, y=ch;
for(int n=0; fabs(ch) > eps; n++){
ch *= (x * x) / ((2 * n +1) * (2 * n + 2));
y += ch;
if(n > MaxIter) {err = 1; return 0; }
return y;
}
Ֆունկցիայի վերնագրում պարամետրերի ցուցակի առա-
ջին երկու պարամետրը ֆունկցիային փոխանցվել են ըստ ար-
ժեքի եղանակի: Դա նշանակում է, որ ֆունկցիային փոխանց-
վել են արգումենտների պատճենները, և դրանց արժեքների
փոփոխումը տեսանելի չէ կանչող ֆունկցիայում: Երրորդ պա-
րամետրը փոխանցվել է ըստ հղման եղանակի: Հղումը կարելի
է դիտարկել որպես փոփոխականի երկրորդ անուն: Միևնույն
ժամանակ հղման մեջ ընդգրկված է այդ փոփոխականի հաս-
ցեն: Երբ կատարվում է ֆունկցիայի կանչը, փոխանցվում է հա-
մապատասխան փոփոխականի հասցեն, որի պատճենը և ստա-
նում է ֆունկցիան: Աշխատելով հասցեի պատճենի հետ՝ ֆունկ-
ցիան ստանում է հիշողության այն բջջին դիմելու հնարավորու-
թյուն, որտեղ գրված է փոխանցվող արգումենտը և փոխել նրա
արժեքը:
Արգումենտի փոխանցումը ֆունկցիային ըստ արժեքի
եղանակով ունի մեկ, բայց շատ մեծ թերություն: Հիշողության
մեջ ստեղծվող պատճենները պահանջում են և՝ ժամանակ, և՝
հիշողություն, ինչը, տվյալների մեծ ծավալի դեպքում հանգեց-
40
նում է ոչ ցանկալի արդյունքների: Ֆունկցիային փոխանցման
ավելի անվտանգ ձևն է՝ մուտքային տվյալների փոխանցումը
հղման, իսկ ավելի ճիշտ, հաստատուն հղման միջոցով.
double T_cosh(const double &x, cost double &eps, int &err){
err=0;
double ch=1, y=ch;
ch *= (x * x) / ((2 * n +1) * (2 * n + 2));
y += ch;
return y;
}
Հետևաբար, մուտքային տվյալները պետք է փոխանցվեն
ֆունկցիային կամ՝ ըստ արժեքի, կամ՝ որպես հաստատուն հղում:
Ֆունկցիայի աշխատանքի արդյունքը պետք է հետ բերել կան-
չող ֆունկցիային վերադարձվող արժեքի միջոցով: Եթե անհրա-
ժեշտ է վերադարձնել մեկից ավել արժեք, պետք է օգտագործել
հղումներ:
Դիտարկենք ծրագիրը ամբողջությամբ: Հայտնի է, որ C++
գրադարանի <cmath> ֆայլի մեջ գոյություն ունի cosh(x) ֆունկ-
ցիան, որը հաշվում է հիպերբոլիկ կոսինուսը: Արդյունքները
համեմատելու համար ծրագրում արտածվում է նաև այդ ստան-
դարտ ֆունկցիայի արժեքը:
#include <iostream>
#include <iomanip>
#include <cmath>
41
double T_cosh(const double &x, const double &eps, int
&err);
int main( )
{double Xb, Xe, dX, eps, y;
int err;
cout<<"Xb="; cin>>Xb;
cout<<"Xe="; cin>>Xe;
cout<<"dX="; cin>>dX;
cout<<"eps="; cin>>eps;
for(double x=Xb; x<=Xe; x+=dX)
{y=T_cosh(x, eps, err);
if(err){cout<<"Divergent Sequence"<<setw(20)<<x<<endl;}
else
cout<<x<<setw(20)<<y<<setw(20)<<cosh(x)<<endl;
}
return 0;
}
double T_cosh(const double &x, const double &eps, int &err){
err=0;
double ch=1, y=ch;
ch *= (x * x) / ((2 * n +1) * (2 * n + 2));
y += ch;
}
return y;
}
42
Ներկայացնենք ծրագրի կատարումից ստացված արդ-
յունքները.
Xb=-3
Xe=3
dX=0.5
eps=0.0001
-3 10.0677 10.0677
-2.5 6.13229 6.13229
-2 3.7622 3.7622
-1.5 2.35241 2.35241
-1 1.54308 1.54308
-0.5 1.12763 1.12763
011
0.5 1.12763 1.12763
1 1.54308 1.54308
1.5 2.35241 2.35241
2 3.7622 3.7622
2.5 6.13229 6.13229
3 10.0677 10.0677
Տրված արգումենտը փոխվում է [-3; 3] միջակայքում 0.5
քայլով(1-ին սյուն): Հաշվման ճշտությունը հավասար է 0.0001-ի:
Ներկայացված արդյունքներից երևում է, որ T_cosh() ֆունկցիա-
յով հաշվված արդյունքները (2-րդ սյուն) համընկնում են cosh(x)
ստանդարտ ֆունկցիայով ստացված արդյունքների հետ (3-րդ
սյուն):
43
3.3. ԽՆԴԻՐՆԵՐ: ԱՆՎԵՐՋ ՇԱՐՔԵՐԻ ԳՈՒՄԱՐԻ ՀԱՇՎԱՐԿ
Տարբերակ 21
1. ln x+1
x−1
= 2 ∑∞ 1 1 1
n=0 (2n+1)x2n+1 = 2 ( x + 3x3 +
1
+ ⋯ ) |x| >1
5x5
n
(−1) x2n x2 x4 x6
2. sin x ∑∞
x = n=0 (2n+1)! = 1 − 3! + 5! − 7! − ⋯ x < ∞
| |
Տարբերակ 22
n
(−1) xn 2 3 4
1. e−x = ∑∞
n=0 n!
= 1 − x + x2! − x3! + x4! − ⋯ |x| < ∞
2n+1 3 5
(x−1) (x−1) (x−1)
2. lnx = 2 ∑∞
n=0 2n+1 = 2 (x−1
x+1
+ 3 + 5 +⋯) x > 0
(2n+1)(x+1) 3(x+1) 5(x+1)
Տարբերակ 23
n n+1 2 3 4
(−1) x
1. ln(x + 1) = ∑∞
n=0 n+1 = x − x2 + x3 − x4 + −1 < x ≤ 1
1∙3∙⋯ (2n−1)x 2n+1
x = π2 − (x + ∑∞
n=1 2∙4∙⋯ ∙2n∙(2n+1) ) =
2. arccos 3 5 7 9
= π2 − (x + 2∙3
x
+ 1∙3∙x
2∙4∙5
+ 1∙3∙5∙x
2∙4∙6∙8
+ 1∙3∙5∙7∙x
2∙4∙6∙8∙9
⋯ ) |x| < 1
Տարբերակ 24
n+1 2n+1 3 5
(−1) x
1. arcctg x = π2 + ∑∞
n=0 2n+1
= π2 − x + x3 − x5 + ⋯ |x| ≤ 1
x 2n+1x x x 3 5 7
2. Arth x = ∑∞
n=0 2n+1 = x + 3 + 5 + 7 + ⋯ |x| < 1
Տարբերակ 25
n+1
(−1)
1. arctg x = π2 + ∑∞
n=0 = π2 − 1x + 3x13 − 1
+⋯ x>1
(2n+1)x2n+1 5x5
1
2. Arth x = ∑∞
n=0 (2n+1)x2n+1
= 1x + 3x13 + 5x15 + ⋯ |x| > 1
44
Տարբերակ 26
2n+1 3 5
1. ln 1+x
1−x
= 2 ∑∞ x x x
n=0 2n+1 = 2 (x + 3 + 5 + ⋯ ) |x| < 1
n 2n+1 3 5 7
(−1) x x x x
2. arctg x = ∑∞
n=0 (2n+1) = x − 3 + 5 − 7 + ⋯ |x| ≤ 1
Տարբերակ 27
n 2n
2 (−1) x 4 6 8
1. e−x = ∑∞
n=0 n! = 1 − x2 + x2! − x3! + x4! − ⋯ |x| < ∞
1∙3∙⋯ ∙(2n−1)∙x2n+1
2. arcsin x = x + ∑∞ =
n=1 2∙4∙⋯ ∙2n ∙ (2n+1)
=
x3 1 ∙ 3 ∙ x5 1 ∙ 3 ∙ 5 ∙ x7 1 ∙ 3 ∙ 5 ∙ 7 ∙ x9
= x+ + + + + ⋯ |x| < 1
2∙3 2∙4∙5 2∙4∙6∙7 2∙4∙6∙8∙9
Տարբերակ 28
n+1
(−1)
1. arctg x = − π2 + ∑∞ π 1 1 1
n=0 (2n+1)x2n+1 = − 2 − x + 3x3 − 5x5 + ⋯ x < −1
n n+1 2 3
(−1) (x−1)
2. ln x = ∑∞
n=0 (n+1)
= (x − 1) − (x−1
2
)
+ (x−1
3
)
−⋯ 0<x≤2
Տարբերակ 29
(−1)n xn x2 x3 x4
1. e−x = ∑∞
n=0 = 1−x+ − + − ⋯ |x| < ∞
n! 2! 3! 4!
n+1 2 3
(x−1) x−1 (x−1) (x−1) 1
2. ln x = ∑∞
n=0 n+1 = x + 2 + 3 +⋯ x>2
(n+1)x 2x 3x
Տարբերակ 30
n 2n 2 4 6
(−1) x x x x
1. cos x = ∑∞
n=0 (2n)! = 1 − 2! + 4! − 6! + ⋯ |x| < ∞
x xn x 2 4
2. ln(1 − x) = − ∑∞
n=0 n = − (x + 2 + 4 + ⋯ ) − 1 ≤ x <
45
3.4. ԴԻՆԱՄԻԿ ՄԻԱՉԱՓ ԶԱՆԳՎԱԾՆԵՐԻ ՓՈԽԱՆՑՈՒՄԸ
ՖՈՒՆԿՑԻԱՅԻՆ
Դինամիկ զանգվածի անունը իրենից ներկայացնում է

զանգվածի զրոյական տարրի վրա ցուցիչ: Ոչ դինամիկ զանգ-
վածի անունը ևս ցուցիչ է զրոյական տարրի վրա, բայց այդ ցու-
ցիչը հաստատուն է (նրան արգելվում է նոր արժեք վերագրել):
Հետևաբար, ֆունկցիային զանգվածը փոխանցվում է ցուցիչով:
Զանգված ստացած ֆունկցիան հնարավորություն է ստանում
դիմել զանգվածի յուրաքանչյուր տարրին և փոխել նրա արժեքը:
Զանգվածի տարրերի քանակը պետք է ֆունկցիային փոխանցվի
առանձին պարամետրով, սովորաբար, ըստ արժեքի եղանա-
կով: Դիտարկենք խնդիր:
Տրված են երկու ամբողջ տիպի տարրեր պարունակող և
նույն չափն ունեցող միաչափ զանգված: Որոշել՝ տրված զանգ-
վածներից որն է պարունակում առավել քանակությամբ դրա-
կան տարրեր:
Ակնհայտ է, որ խնդիրը լուծելու համար անհրաժեշտ է
որոշել յուրաքանչյուր զանգվածի դրական տարրերի քանակ-
ները, այսինքն՝ նույն գործողությունները կատարել երկու զանգ-
վածի համար: Հետևաբար, այդ գործողությունների կատարումը
պետք է տեղադրել առանձին ֆունկցիայի մեջ: Մեկ ուրիշ
ֆունկցիա պետք է նախատեսել միաչափ զանգվածի տարրերը
ներմուծելու համար:
#include <iostream>
void input(int *x, int m); //1
int posit(int *x, int m); //2
46
int main( )
{int n;
cout<<"Input the number of elements"<<endl; cin>>n; //3
int *a=new int[n]; //4
int *b=new int[n]; //5
cout<<"Input the first array elements"<<endl;
input(a,n); //6
cout<<"Input the second array elements"<<endl;;
input(b,n); //7
if(posit(a,n)>posit(b,n)) //8
cout<<"In the first array positiv elements greater"<<endl;
else
if(posit(a,n)<posit(b,n))
cout<<"In the second array positiv elements greater"<<endl;
else
cout<<"Positiv elements equal"<<endl;
delete []a; //9
delete []b; //10
return 0;
}
void input(int *x, int m){ //11
for(int i=0;i<m; i++) cin>>*(x+i);
}
int posit( int *x, int m){ //12
int count=0;
for(int i=0;i<m; i++)
if(*(x+i)>0)count++;
return count;
}
47
Միաչափ զանգվածի տարրերի ներմուծման համար նա-
խատեսված է input() ֆունկցիան, իսկ դրական տարրերի քա-
նակը որոշելու՝ posit() ֆունկցիան: Այս ֆունկցիաները օգտա-
գործվում են a և b զանգվածների տարրերը ներմուծելու և դրանց
դրական տարրերի քանակները որոշելու համար: Ֆունկցիա-
ների նախատիպերը ներկայացված են օպերատոր 1 և 2-ով,
իսկ դրանց նկարագրությունները` օպերատորներ 11 և 12-ի մի-
ջոցով: Օպերատոր 3-ը ներմուծում է զանգվածների չափը; Օպե-
րատորներ 4-ը և 5-ը դինամիկ հիշողություն են հատկացնում
տրված a և b միաչափ զանգվածների համար: Այդ զանգվածների
տարրերը ներմուծվում են 6 և 7 օպերատորներով, որոնք իրա-
կանացնում են input() ֆունկցիայի կանչը համապատասխան
զանգվածների համար: Պայմանի օպերատոր 8-ը՝ դիմելով
posit() ֆունկցիային, որոշում և համեմատում է a և b միաչափ
զանգվածների դրական տարրերի քանակները: Միաչափ զանգ-
վածներին տրամադրված դինամիկ հիշողության ազատումը
կատարվում է 9 և 10 օպերատորների միջոցով:
3.5. ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ ԿԻՐԱՌՄԱՄԲ ՄԻԱՉԱՓ

ԶԱՆԳՎԱԾԻՑ ՆՈՐ ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ ՍՏԱՑՈՒՄԸ
Խնդիր 3.6.1: Տրված միաչափ զանգվածից ստանալ նոր

զանգված՝ տրված զանգվածի բոլոր տարրերին գումարելով այդ
զանգվածի մեծագույն տարրի արժեքը: Օգտագործել ֆունկ-
ցիաներ:
Քանի որ միաչափ զագվածի չափը նշված չէ, կկիրառենք
դինամիկ զանգվածներ: Խնդիրը բաժանենք առանձին բաղադ-
րամասերի, որոնցից յուրաքանչյուրը կարելի է ձևակերպել
ֆունկցիայի տեսքով: Աղյուսակ 3.6.1-ում թվարկված են բա-
48
ղադրամասերում կատարվող գործողությունների հաջորդա-
կանությունները և դրանց համապատասխանող ֆունկցիաների
անունները:
Աղյուսակ 3.6.1
1. Գործողությունների հաջորդականություն Ֆունկցիա
2. Զանգվածի չափի ներմուծում, տրված և ստացվող զանգ- main()
վածների համար դինամիկ հիշողության տրամադրում
3. Տրված միաչափ զանգվածի տարրերի ներմուծում input()
4. Մեծագույն տարրի որոշում max_vec()
5. Նոր միաչափ զանգվածի ստացում new_vec()
6. Ստացված զանգվածի տարրերի արտածում output()
7. Երկու զանգվածների համար տրամադրված դինամիկ main()
հիշողության ազատում
Աղյուսակ 3.6.1: Խնդիր 3.6.1-ում կիրառվող ֆունկցիաների

ցուցակը
#include <iostream>
void input(double *x, int n);
double max_vec(double *x, int n);
void new_vec(double *x, int n, double *y,double max);
void output(double *y, int n);
int main( )
{int n;
cout<<"n="; cin>>n;
double *x=new double[n];
double *y=new double[n];
input(x,n);
double max;
max=max_vec(x,n);
49
cout<<"max="<<max<<endl;
new_vec(x,n,y,max);
output(y,n);
delete []x;
delete []y;
return 0;
}
void input(double *x, int n){
for(int i=0;i<n;i++)cin>>*(x+i);
}
double max_vec(double *x, int n){
double max=*x;
for(int i=1;i<n;i++)
if(*(x+i)>max) max=*(x+i);
return max;
}
void new_vec(double *x, int n, double *y, double max){
*(y+i)=*(x+i)+max;
}
void output(double *y, int n){
cout<<*(y+i)<<" ";
cout<<endl;
}
50
Խնդիր 3.6.2: Տրված միաչափ զանգվածից ստանալ նոր
զանգված՝ տրված զանգվածի ամեն մի դրական տարրից հետո
ավելացնելով զրո արժեք ունեցող տարր: Օգտագործել ֆունկ-
ցիաներ:
Այս խնդրում ստացվող միաչափ զանգվածի տարրերի
քանակը կարող է լինել տրված զանգվածի.
 տարրերի քանակին հավասար, եթե այդ զանգվածում
բացակայում են դրական տարրեր,
 տարրերի քանակից երկու անգամ ավել, եթե զանգվածի
բոլոր տարրերը դրական են,
 տարրերի քանակից մեծ, եթե զանգվածում ոչ բոլոր
տարրերն են դրական:
Աղյուսակ 3.6.2-ում թվարկված են ֆունկցիաներում կա-
տարվող գործողությունների հաջորդականությունները և դրանց
համապատասխանող ֆունկցիաների անունները:
2. Զանգվածի չափի նեմուծում և տրված զանգվածների main()
համար դինամիկ հիշողության տրամադրում
3. Տրված միաչափ զանգվածի տարրերի ներմուծում input()
4. Դրական տարրերի քանակի որոշում calc()
5. Ստացվող զանգվածի համար դինամիկ հիշողության main()
հատկացում
6. Նոր միաչափ զանգվածի ստացում: Վերադարձվում է այդ new_vec()
զանգվածի տարրերի քանակը
8. Երկու զանգվածի համար տրամադրված դինամիկ main()
51
Աղյուսակ 3.6.2: Խնդիր 3.6.2-ում կիրառվող ֆունկցիա-
ների ցուցակը
#include <iostream>
void input(double *x, int n);
int calc(double *x, int n);
int new_vec(double *x, int n, double *y);
void output(double *y, int j);
int main( )
{int n,m,j;
cout<<"n="; cin>>n;
double *x=new double[n];
input(x,n);
m=calc(x,n);
double *y=new double[n+m];
j=new_vec(x,n,y);
output(y,j);
delete []x;
delete []y;
return 0;
}
void input(double *x, int n){
for(int i=0;i<n;i++)cin>>*(x+i);
}
int calc(double *x, int n){
int m=0;
if(*(x+i)>0) m++;
52
return m;
}
int new_vec(double *x, int n, double *y){
int i,j=-1;
for(i=0;i<n;i++)
{
j++;*(y+j)=*(x+i);
if(*(x+i)>0)
{j++;*(y+j)=0;}
}
return j;
}
void output(double *y, int j){
for(int i=0;i<=j;i++)
cout<<*(y+i)<<" ";
cout<<endl;
}
3.6. ՀԱՆՁՆԱՐԱՐՈՒԹՅՈՒՆՆԵՐ ՖՈՒՆԿՑԻՆԵՐԻ

ԿԻՐԱՌՄԱՄԲ ՄԻԱՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ
ՕԳՏԱԳՈՐԾՄԱՆ ՎԵՐԱԲԵՐՅԱԼ
Տարբերակ 31
1. Տրված իրական տիպի տարրեր պարունակող երկու
միաչափ զանգվածի համար հաշվել տարրերի միջին թվաբա-
նականների արտադրյալը:
2. Տրված իրական տիպի տարրեր պարունակող միաչափ
զանգվածից ստանալ նոր զանգված՝ տրված զանգվածի բոլոր
դրական տարրերի փոխարեն գրելով դրական տարրերի
53
քանակի արժեքը: Ենթադրվում է, որ զանգվածում կան և՝ դրա-
կան, և՝ բացասական տարրեր:
զանգվածից ստանալ նոր զանգված տրված զանգվածի ամեն
մի երկյակից, սկսած զրոյական տարրից, վերցնելով բացարձակ
արժեքով մեծ արժեք ունեցող տարրը:
Տարբերակ 32
միաչափ զանգվածի համար հաշվել տարրերի միջին քառա-
կուսայինների գումարը:
զանգվածից ստանալ նոր զանգված՝ տրված զանգվածի բոլոր
բացասական տարրերի փոխարեն գրելով դրական տարրերի
գումարի արժեքը (ենթադրվում է, որ զանգվածը պարունա-
կում է և՝ դրական, և՝ բացասական տարրեր):
3. Տրված իրական տիպի տարրեր պարունակող միա-
չափ զանգվածից ստանալ նոր զանգված տրված զանգվածի
դրական տարրերից, եթե զանգվածում կա տրված b թվից փոքր
գոնե մեկ տարր, հակառակ դեպքում՝ բացասական տարրերից:
Ենթադրվում է, որ զանգվածում կան և՝ դրական, և՝ բացասա-
կան տարրեր:
Տարբերակ 33
1. Տրված ամբողջ տիպի տարրեր պարունակող երկու
միաչափ զանգվածի համար հաշվել զույգ արժեք ունեցող տար-
րերի ընդհանուր գումարը:
զանգվածից ստանալ նոր զանգված՝ նրա մեջ տեղերով փոխե-
լով յուրաքանչյուր կենտ ինդեքս ունեցող տարրի և իրեն նա-
54
խորդող զույգ ինդեքս ունեցող տարրի արժեքները (զրոյական
ինդեքսը համարել զույգ):
զանգվածից ստանալ նոր զանգված այն տարրերից, որոնք բա-
ցարձակ արժեքով փոքր են զանգվածի մեծագույն և փոքրա-
գույն տարրերի միջին թվաբանականից:
Տարբերակ 34
միաչափ զանգվածի համար հաշվել կենտ արժեք ունեցող տար-
րերի քանակները:
զանգվածից ստանալ նոր զանգված՝ սկզբում վերցնելով զանգ-
վածի բացասական տարրերը, հետո զրո արժեք ունեցող տար-
րերը, իսկ վերջում՝ դրական տարրերը:
զանգվածից ստանալ նոր զանգված տրված զանգվածի այն
տարրերից, որոնք այդ զանգվածում չունեն իրենց հավասար
տարր: Ենթադրվում է, որ զանգվածում կա գոնե մեկ այդպիսի
տարր:
Տարբերակ 35
միաչափ զանգվածի համար հաշվել՝ առաջին զանգվածի կենտ
արժեք ունեցող և երկրորդ զանգվածի զույգ արժեք ունեցող
տարրերի գումարների տարբերությունը:
վածի բացարձակ արժեքով տրված k թվից մեծ արժեք ունեցող
տարրերը, հետո բացարձակ արժեքով k-ին հավասար արժեք
ունեցող տարրերը, իսկ վերջում՝ փոքրերը:
55
զանգվածից ստանալ նոր զանգված տրված զանգվածի այն
տարրերից, որոնք այդ զանգվածում հանդիպում են ճիշտ երկու
անգամ: Ենթադրվում է, որ զանգվածում կա գոնե մեկ այդպիսի
տարր:
Տարբերակ 36
միաչափ զանգվածի համար հաշվել՝ առաջին զանգվածի տար-
րերի գումարի հարաբերությունը երկրորդ զանգվածի տար-
րերի արտադրյալին (ենթադրվում է, որ երկրորդ զանգվածը չի
պարունակում զրոյին հավասար տարր):
զանգվածից ստանալ նոր զանգված զանգվածի զրոյական տար-
րից սկսած՝ ամեն երրորդ տարրին վերագրելով զրո արժեք, իսկ
մնացած տարրերի արժեքները մեծացնելով զանգվածի մեծա-
գույն տարրի արժեքի չափով:
3. Տրված ամբողջ տիպի տարրեր պարունակող միաչափ
զանգվածից ստանալ նոր զանգված նրա բոլոր տարրերից հետև-
յալ կերպ՝ զույգ արժեք ունեցող յուրաքանչյուր տարրից հետո
տեղադրել այդ նույն զանգվածի զույգ տարրերից մեծագույնի
տարրը: Ենթադրվում է, որ զանգվածում կան և՝ զույգ, և՝ կենտ
արժեք ունեցող տարրեր:
Տարբերակ 37
միաչափ զանգվածի համար հաշվել տրված [a; b] միջակայքին
պատկանող տարրերի ընդհանուր քանակը:
զանգվածից ստանալ նոր զանգված զանգվածի զրոյական տար-
56
րից սկսած՝ ամեն չորրորդ տարրին վերագրելով մեկ արժեք,
իսկ մնացած տարրերի արժեքները փոքրացնելով զանգվածի
փոքրագույն տարրի արժեքի չափով:
զանգվածից ստանալ նոր զանգված նրա բոլոր տարրերից
հետևյալ կերպ՝ կենտ արժեք ունեցող յուրաքանչյուր տարրից
հետո տեղադրել այդ նույն զանգվածի կենտ տարրերից փոք-
րագույնի տարրը: Ենթադրվում է, որ զանգվածում կան և՝ զույգ,
և՝ կենտ արժեք ունեցող տարրեր:
Տարբերակ 38
միաչափ զանգվածի համար հաշվել այն տարրերի ընդհանուր
գումարը, որոնք 5-ի բաժանելիս կմնա 2 մնացորդ:
վածի զույգ տարրերը, հետո զրո արժեք ունեցողները, իսկ վեր-
ջում՝ կենտ արժեք ունեցող տարրերը:
զանգվածից ստանալ նոր զանգված հետևլալ կերպ՝ տրված
զանգվածի զրոյական տարրից սկսած՝ ամեն երրորդ տարրից
հետո ավելացնել զանգվածի դրական տարրերից մեծագույն
արժեք ունեցող տարրը: Ենթադրվում է, որ զանգվածում կան
և՝ դրական, և՝ բացասական տարրեր:
Տարբերակ 39
միաչափ զանգվածի համար հաշվել զանգվածների մեծագույն
տարրերի գումարը:
57
զանգվածից ստանալ նոր զանգված՝ մեծացնելով զանգվածի
կենտ արժեք ունեցող տարրերը կենտ տարրերից մեծագույնի
արժեքով:
զանգվածից ստանալ նոր զանգված հետևյալ կերպ՝ տրված
զանգվածի զրոյական տարրից սկսած՝ ամեն երկրորդ բացա-
սական տարրից հետո ավելացնել զանգվածի բացասական
տարրերից փոքրագույն արժեք ունեցող տարրը: Ենթադրվում
է, որ զանգվածում կան և՝ դրական, և՝ բացասական տարրեր:
Տարբերակ 40
միաչափ զանգվածի համար հաշվել զանգվածների փոքրա-
գույն տարրերի տարբերությունը:
զանգվածից ստանալ նոր զանգված՝ փոքրացնելով զանգվածի
զույգ արժեք ունեցող տարրերը զույգ տարրերից փոքրագույնի
արժեքով:
զանգվածից ստանալ նոր զանգված հետևլալ կերպ՝ տրված
զանգվածի զրոյական տարրից սկսած՝ յուրաքանչյուր բացա-
սական տարրից հետո ավելացնել զանգվածի բացասական
տարրերից փոքրագույն արժեք ունեցող տարրը, իսկ յուրա-
քանչյուր դրական տարրից հետո՝ զանգվածի դրական տար-
րերից մեծագույն արժեք ունեցողը: Ենթադրվում է, որ զանգ-
վածում կան և՝ դրական, և՝ բացասական տարրեր:
58
3.7. ԴԻՆԱՄԻԿ ԵՐԿՉԱՓ ԶԱՆԳՎԱԾՆԵՐԻ ՓՈԽԱՆՑՈՒՄԸ
ՖՈՒՆԿՑԻԱՅԻՆ
Երկչափ զանգվածը C++ լեզվում ներկայացված է որպես

զանգվածներից բաղկացած զանգված: Երկչափ զանգվածի
տարրերը տեղադրված են հիշողության մեջ հաջորդաբար,
մեկը մյուսի հետևից: Զանգվածի տողերը ոչ մի կերպ իրարից
բաժանված չեն: Հիշողության մեջ սկզբից տեղադրված է a[0]
կամ *a միաչափ զանգվածը, որը իրենից ներկայացնում է երկ-
չափ զանգվածի զրոյական տողը, հետո՝ երկչափ զանգվածի
առաջին տողը ներկայացնող a[1] կամ *(a+1) միաչափ զանգ-
վածը և այլն: Այդ միաչափ զանգվածների տարրերի քանակը
հավասար է սյուների քանակին: Եթե ֆունկցիայի արգումենտը
զանգված է, նրան փոխանցվում է զանգվածի հասցեն: Ֆունկ-
ցիան այդ դեպքում ստանում է երկչափ զանգվածի յուրաքանչ-
յուր տարրին դիմելու և յուրաքանչյուր տարրի արժեքը փոխելու
հնարավորություն:
Խնդիր 3.8.1: Տրված իրական տիպի տարրեր պարունա-
կող քառակուսային երկչափ զանգվածի յուրաքանչյուր տողի
փոքրագույն տարրը փոխատեղել այդ տողի գլխավոր անկյու-
նագծի տարրի հետ:
Խնդրի լուծման ալգորիթմը կարելի է ներկայացնել հետև-
յալ կերպ.
 տրված քառակուսային երկչափ զանգվածի չափի ներ-
մուծում,
 երկչափ զանգվածի համար դինամիկ հիշողության հատ-
կացում,
 յուրաքանչյուր տողի փոքրագույն տարրի համարի որո-
շում,
59
 տողի փոքրագույն և գլխավոր անկյունագծի տարրերի
փոխատեղում,
 ստացված երկչափ զանգվածի արտածում,
 դինամիկ հիշողության ազատում:
Վերը նշված գործողությունները և դրանք իրականաց-
նող ֆունկցիաների անունները ներկայացված են աղյուսակ
3.8.1-ում:
2. Զանգվածի չափի ներմուծում և տրված զանգվածների main()
3. Տրված երկչափ զանգվածի տարրերի ներմուծում input()
4. Յուրաքանչյուր տողի համար փոքրագույն տարրի min_num()
համարի որոշում
5. Յուրաքանչյուր տողի համար փոքրագույն և գլխավոր main()
անկյունագծի տարրերի փոխատեղում
7. Երկչափ զանգվածների համար տրամադրված դինամիկ main()

ցուցակը
#include <iostream>
void input(double **x,int n);
void output(double **x,int n);
int min_num(double *x,int n);
int main( )
{int n,i,min_j;
double b;
60
cout<<"n="; cin>>n;
double **x=new double *[n];
for(i=0;i<n;i++)
x[i]=new double[n];
input(x,n);
cout<<endl;
for(i=0;i<n;i++)
{min_j=min_num(*(x+i),n);
cout<<"min="<<*(*(x+i)+min_j)<<endl;
b=*(*(x+i)+i); *(*(x+i)+i)=*(*(x+i)+min_j);
*(*(x+i)+min_j)=b;
}
output(x,n);
for(i=0;i<n;i++)
delete []x[i];
delete []x;
return 0;
}
void input(double **x,int n)
{for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
cin>>*(*(x+i)+j);
}
void output(double **x,int n)
{for(int i=0;i<n;i++){
cout<<*(*(x+i)+j)<<" ";
cout<<endl;
61
}
}
int min_num(double *x,int n)
{ int j,jm=0;
double min=*x;
for(j=1;j<n;j++)
if(*(x+j)<min)
{min=*(x+j);jm=j;}
return jm;
}
կող երկչափ զանգվածից ստանալ նոր միաչափ զանգված, որի
տարրերը հավասար են երկչափ զանգվածի համապատասխան
տողի փոքրագույն տարրին:
Քանի որ նոր միաչափ զանգվածի տարրերը ստացվում
են երկչափ զանգվածի տողերից, տարրերի քանակը հավասար
կլինի երկչափ զանգվածի տողերի քանակին: Տողի փոքրագույն
համարը որոշող ֆունկցիայի արգումենտը միաչափ զանգված
է, որը երկչափ զանգվածի համապատասխան տողն է:
Խնդրիրը կարելի է լուծել հետևյալ ալգորիթմով.
մուծում,
կացում,
 տրված երկչափ զանգվածի տարրերի ներմուծում,
 նոր միաչափ զանգվածի համար դինամիկ հիշողության
տրամադրում,
 յուրաքանչյուր տողի փոքրագույն տարրի համարի որո-
շում,
62
 նոր միաչափ զանգվածի կազմում,
 ստացված միաչափ զանգվածի տարրերի արտածում,
 երկչափ զանգվածի համար տրամադրված դինամիկ
հիշողության ազատում,
 միաչափ զանգվածի համար տրված դինամիկ հիշողու-
թյան ջնջում:
Այդ գործողությունները և իրեն համապատասխանող
ֆունկցիաների անունները նշված են աղյուսակ 3.8.2-ում:
2. Զանգվածի չափի ներմուծում և տրված զանգվածների main()
4. Նոր միաչափ զանգվածի համար դինամիկ հիշողության main()
տրամադրում
5. Յուրաքանչյուր տողի փոքրագույն տարրի համարի որոշում min_num()
6. Նոր միաչափ զանգվածի կազում: main()
7. Ստացված միաչափ զանգվածի տարրերի արտածում output()
8. Տրված երկչափ զանգվածի և նոր միաչափ զանգվածների main()
համար տրամադրված դինամիկ հիշողության ազատում
Աղյուսակ 3.8.2: Խնդիր 38.2-ում կիրառվող ֆունկցիա-

ների ցուցակը
#include <iostream>
void output(double *y,int n);
int min_num(double *x,int n);
int main( )
{int n,i,min_j;
63
cout<<"n="; cin>>n;
for(i=0;i<n;i++)
x[i]=new double[n];
input(x,n);
cout<<endl;
double *y=new double[n];
for(i=0;i<n;i++)
{min_j=min_num(*(x+i),n);
cout<<"min="<<*(*(x+i)+min_j)<<endl;
*(y+i)=*(*(x+i)+min_j);
}
output(y,n);
for(i=0;i<n;i++)
delete []x[i];
delete []x;
delete []y;
return 0;
}
cin>>*(*(x+i)+j);
}
void output(double *y,int n)
cout<<*(y+i)<<" ";
cout<<endl;
64
}
int min_num(double *x,int n)
{ int j,jm=0;
double min=*x;
for(j=1;j<n;j++)
if(*(x+j)<min)
{min=*(x+j);jm=j;}
return jm;
}
կող երկչափ քառակուսային զանգվածից ստանալ նոր միաչափ
զանգված երկչափ զանգվածի գլխավոր անկյունագծից վերև
գտնվող դրական տարրերից:
Այս խնդրի մեջ ստացվող միաչափ զանգվածի տարրերի
քանակը նախապես հայտնի չէ: Հետևաբար, միաչափ զանգվա-
ծին դինամիկ հիշողություն հատկացնելու համար պետք է հաշ-
վել գլխավոր անկյունագծից վերև գտնվող և դրական արժեք
ունեցող տարրերի քանակը: Լուծման գործողությունների հա-
ջորդականությունը հետևյալն է.
մուծում,
կացում,
 տրված երկչափ զանգվածի տարրերի ներմուծում,
 տրված երկչափ զանգվածի գլխավոր անկյունագծից վերև
գտնվող և դրական արժեք ունեցող տարրերի քանակի հաշվում,
 եթե նախորդ կետում թվարկված տարրերը բացակա-
յում են, "No such elements" հաղորդակցության արտածում, և
ծրագրի կատարոման դադարեցում,
65
 նոր միաչափ զանգվածի համար դինամիկ հիշողութ-
յուն հատկացում,
 նոր միաչափ զանգվածի կազմում,
 ստացված միաչափ զանգվածի տարրերի արտածում,
 երկչափ զանգվածի համար տրամադրված դինամիկ
հիշողության ազատում,
 միաչափ զանգվածի համար տրված դինամիկ հիշողու-
թյան ջնջում:
2. Զանգվածի չափի ներմուծում և տրված զանգվածի main()
4. Գլխավոր անկյունագծից վերև գտնվող և դրական արժեք calc()
ունեցող տարրերի քանակի հաշվվում
5. Նոր միաչափ զանգվածի համար դինամիկ հիշողության main()
տրամադրում
6. Նոր միաչափ զանգվածի կազում new_vec()
7. Ստացված միաչափ զանգվածի տարրերի արտածում output()
8. Տրված երկչափ զանգվածի և նոր միաչափ զանգվածների main()
համար տրամադրված դինամիկ հիշողության ազատում

ցուցակը
#include <iostream>
void output(double *y,int m);
int calc(double **x,int n);
void new_vec(double **x,int n, double *y);
66
int main( )
{int n,i,col,m;
cout<<"n="; cin>>n;
for(i=0;i<n;i++)
x[i]=new double[n];
input(x,n);
cout<<endl;
m=calc(x,n);
cout<<"m="<<m<<endl;
if(m==0){cout<<"No such elements"<<endl; return 1;}
double *y=new double[m];
new_vec(x,n,y);
output(y,m);
for(i=0;i<n;i++)
delete []x[i];
delete []x;
delete []y;
return 0;
}
cin>>*(*(x+i)+j);
}
void output(double *y,int m)
{for(int i=0;i<m;i++)
cout<<*(y+i)<<" ";
67
cout<<endl;
}
int calc(double **x,int n)
{int m=0;
for(int i=0;i<n-1;i++)
for(int j=i+1;j<n;j++)
if(*(*(x+i)+j)>0)
m++;
return m;
}
void new_vec(double **x,int n, double *y){
int mc=0;
for(int i=0;i<n-1;i++)
for(int j=i+1;j<n;j++)
if(*(*(x+i)+j)>0)
{*(y+mc)=*(*(x+i)+j);
mc++;}
}
Խնդիր 3.8.4: Տրված ամբողջ տիպի տարրեր պարունա-
կող երկչափ զանգվածի համար որոշել այն տողի համարը, որ-
տեղ գտնվում է հավասար տարրերի ամենաերկար հաջորդա-
կանությունը:
Այստեղ ֆունկցիայի միջոցով հարմար է ներկայացնել
հիմնական խնդրի լուծումը՝ թողնելով main() ֆունկցիային
միայն սկզբնական տվյալների ներմուծումը և արդյունքների
արտածումը:
#include <iostream>
68
int ser_equals(int **a, const int m, const int n);
int main( )
{int m,n,i,j;
cin>>m>>n;
int **a=new int *[m]; //1
for(i=0; i<m; i++) //2
a[i]=new int[m];
for(i=0; i<m; i++) //3
for(j=0; j<n; j++)
cin>>*(*(a+i)+j);
int line=ser_equals(a,m,n); //4
if(line>=0)
cout<<"The longest sequence in the line "<<line<<endl;
else
cout<<"There are no similar sequences of elements";
for(i=0; i<m; i++)
delete []a[i];
delete []a;
return 0;
}
int ser_equals(int **a, const int m, const int n){
int i,j,count,line=-1,maxcount=0;
for(i=0; i<m; i++){ //5
count=0;
for(j=0; j<n-1; j++){
if( *(*(a+i)+j) == *(*(a+i)+(j+1)) )
count++; //6
else{ //7
69
if(count>maxcount){
maxcount=count; line=i;} //8
count=0;
}
}
if(count>maxcount){
maxcount=count; line=i;} //9
}
return line;
}
Օպերատորներ 1 և 2-ի օգնությամբ կատարվում է դինա-
միկ հիշողության հատկացումը տրված երկչափ զանգվածի
համար: Օպերատոր 3-ն իրականացնում է տրված երկչափ
զանգվածի տարրերի ներմուծումը: ser_equals() ֆունկցիան կանչ-
վում է օպերատոր 4-ով: Ֆունկցիայի կատարման ալգորիթմը
ակնհայտ է. յուրաքանչյուր տողի մեջ համեմատվում են հարևան
տարրերը(օպերատոր 6): Եթե այդ տարրերը հավասար են,
մենք գտնվում ենք իրար հավասար տարրերի հաջորդակա-
նության մեջ, հետևաբար, հաջորդականության ընթացիկ երկա-
րությունը մեծանում է: Հավասար տարրերի երկարությունը
գրված է count փոփոխականի մեջ, որի արժեքը զրոյացվում է
ընթացիկ տողի մշակումից առաջ(օպերատոր 5): Եթե հարևան
տարրերը հավասար են, հավասար տարրերի հաջորդականու-
թյան երկարությունը ավելանում է(օպերատոր 6), հակառակ
դեպքում կամ՝ հավասար տարրերի հաջորդականության վերջն
է, կամ՝ տողի այլ տարրին ոչ հավասար տարրն է (օպերատոր 7):
Այնուհետև ընթացիկ տողի հավասար տարրերի հաջորդակա-
նության երկարությունը համեմատվում է նախորդ տողերի
70
հավասար տարրերի հաջորդականություններից մեծի հետ
(օպերատոր 8): Նույն ստուգումը կատարվում է տողի մշակ-
ման ցիկլից հետո տողի վերջում գտվող հավասար տարրերի
հաջորդականության համար, քանի որ այդ դեպքում else օպե-
րատորը չի կատարվում (օպերատոր 9):
Եթե երկչափ զանգվածում ընդհանրապես բացակայում
է հավասար տարրերի հաջորդականությունը, ֆունկցիան վե-
րադարձնում է -1 արժեքը:
3.8. ԽՆԴԻՐՆԵՐ ՖՈՒՆԿՑԻՆԵՐԻ ԿԻՐԱՌՄԱՄԲ` ԵՐԿՉԱՓ

ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ ՕԳՏԱԳՈՐԾՄԱՆ
Տարբերակ 41
1. Տրված իրական տիպի տարրեր պարունակող քառա-
կուսային երկչափ զանգվածի յուրաքանչյուր տողի մեծագույն
տարրը փոխատեղել այդ տողի օժանդակ անկյունագծի տար-
րի հետ:
2. Տրված իրական տիպի տարրեր պարունակող երկչափ
զանգվածից ստանալ նոր միաչափ զանգված, որի տարրերը
հավասար են երկչափ զանգվածի համապատասխան տողի
տարրերի գումարին:
քառակուսային զանգվածից ստանալ նոր միաչափ զանգված
այն տարրերից, որոնք մեծ են երկչափ զանգվածի գլխավոր
անկյունագծից վերև կամ նրա վրա գտնվող դրական տարրերի
միջին թվաբանականից:
71
Տարբերակ 42
զանգվածի յուրաքանչյուր տողի դրական տարրերի գումարը
տեղադրել այդ տողի զրոյական տարրի փոխարեն: Ենթադրվում
է, որ զանգվածի յուրաքանչյուր տողն ունի մեկ զրոյական տարր:
հավասար են երկչափ զանգվածի համապատասխան տողի այն
տարրերի գումարին, որոնք գտնվում են տողի առաջին մեծա-
գույն տարրից հետո:
այն տարրերից, որոնք փոքր են երկչափ զանգվածի օժանդակ
անկյունագծից ներքև կամ նրա վրա գտնվող տարրերի միջին
քառակուսայինից:
Տարբերակ 43
զանգվածի յուրաքանչյուր տողի բացասական տարրերի քա-
նակը տեղադրել այդ տողի վերջին տարրի փոխարեն:
դրական տարրերի քանակին:
այն տարրերից, որոնք փոքր չեն երկչափ զանգվածի օժանդակ
72
անկյունագծից վերև գտնվող տարրերի միջին երկրաչափա-
կանից:
Տարբերակ 44
1. Տրված ամբողջ տիպի տարրեր պարունակող երկչափ
զանգվածի յուրաքանչյուր տողի զույգ արժեք ունեցող տար-
րերից փոքրագույնը տեղադրել այդ տողի բոլոր կենտ արժեք
ունեցող տարրերի տեղում:
կենտ արժեք ունեցող տարրերի արտադրյալին:
այն տարրերից, որոնք մեծ չեն երկչափ զանգվածի գլխավոր
անկյունագծից ներքև գտնվող և կենտ արժեք ունեցող տար-
րերի միջին թվաբանականից:
Տարբերակ 45
զանգվածի յուրաքանչյուր տողի կենտ արժեք ունեցող տար-
րերից մեծագույնը տեղադրել այդ տողի բոլոր զույգ արժեք
ունեցող տարրերի տեղում:
զույգ արժեք ունեցող տարրերի միջին թվաբանականին: Են-
թադրվում է, որ զանգվածի յուրաքանչյուր տողն ունի գոնե
մեկ զույգ տարր:
73
այն տարրերից, որոնք փոքր են երկչափ զանգվածի օժանդակ
անկյունագծից վերև կամ նրա վրա գտնվող և զույգ արժեք
ունեցող տարրերի միջին քառակուսայինից:
Տարբերակ 46
կուսային երկչափ զանգվածի յուրաքանչյուր տողի տարրերի
միջին թվաբանականը տեղադրել այդ տողի գլխավոր անկյու-
նագծից վերև կամ նրա վրա գտնվող տարրերի փոխարեն:
գլխավոր անկյունագծից ներքև կամ նրա վրա գտվող տարրերի
արտադրյալին:
հետևյալ կերպ. երկչափ զանգվածից վերցնել բոլոր կենտ ար-
ժեք ունեցող տարրերը՝ յուրաքանչյուրից հետո ավելացնելով
գլխավոր անկյունագծից վերև գտնվող տարրերից մեծագույնը:
Ենթադրվում է, որ երկչափ զանգվածը պարունակում է գոնե
մեկ կենտ արժեք ունեցող տարր:
Տարբերակ 47
կուսային երկչափ զանգվածի յուրաքանչյուր տողի տարրերի
միջին քառակուսայինը տեղադրել այդ տողում օժանդակ անկ-
յունագծից ներքև գտնվող տարրերի փոխարեն:
74
[a;b] միջակայքին պատկանող տարրերի քանակին:
հետևյալ կերպ. երկչափ զանգվածից վերցնել բոլոր բացասական
տարրերը՝ յուրաքանչյուրից հետո ավելացնելով օժանդակ անկ-
յունագծից վերև գտնվող տարրերից փոքրագույնը: Ենթադրվում
է, որ երկչափ զանգվածը պարունակում է գոնե մեկ բացասա-
կան արժեք ունեցող տարր:
Տարբերակ 48
քառակուսային զանգվածի յուրաքանչյուր տողի 3-ին բազմա-
պատիկ արժեք ունեցող տարրերի քանակը տեղադրել այդ տո-
ղում գլխավոր անկյունագծից ներքև գտնվող տարրերի փոխա-
րեն:
հավասար են երկչափ զանգվածի համապատասխան տողի k
թվից մեծ արժեք ունեցող տարրերի գումարին:
հետևյալ կերպ. երկչափ զանգվածից վերցնել զույգ արժեք ունե-
ցող բոլոր տարրերը՝ յուրաքանչյուրից հետո ավելացնելով
գլխավոր անկյունագծից ներքև կամ նրա վրա գտնվող տար-
75
րերից փոքրագույնը: Ենթադրվում է, որ երկչափ զանգվածը
պարունակում է գոնե մեկ զույգ արժեք ունեցող տարր:
Տարբերակ 49
քառակուսային զանգվածի յուրաքանչյուր տողի 4-ին բազմա-
պատիկ արժեք ունեցող տարրերի գումարը տեղադրել այդ
տողում օժանդակ անկյունագծից ներքև կամ նրա վրա գտնվող
տարրերի փոխարեն:
զույգ տարրերից մեծագույն արժեք ունեցող տարրին: Ենթա-
դրվում է, որ զանգվածի յուրաքանչյուր տողն ունի գոնե մեկ
զույգ տարր:
հետևյալ կերպ. երկչափ զանգվածից վերցնել 3-ին բազմապա-
տիկ արժեք ունեցող բոլոր տարրերը՝ յուրաքանչյուրից հետո
ավելացնելով գլխավոր անկյունագծի տարրերի միջին թվաբա-
նականը: Ենթադրվում է, որ երկչափ զանգվածը պարունակում
է գոնե մեկ 3-ին բազմապատիկ արժեք ունեցող տարր:
Տարբերակ 50
զանգվածի յուրաքանչյուր տողի տրված k թվից մեծ արժեք
ունեցող տարրերի արտադրյալը տեղադրել այդ տողի գլխա-
վոր անկյունագծի տարրի տեղում:
76
զանգվածից ստանալ նոր միաչափ զանված, որի տարրերը
մեծագույն տարրին:
հետևյալ կերպ. երկչափ զանգվածից վերցնել [a;b] միջակայքին
պատկանող բոլոր տարրերը՝ յուրաքանչյուրից հետո ավելաց-
նելով օժանդակ անկյունագծի տարրերի միջին քառակուսայինը:
Ենթադրվում է, որ երկչափ զանգվածը պարունակում է գոնե
մեկ [a;b] միջակայքին պատկանող տարր:
77
ԳՐԱԿԱՆՈՒԹՅՈՒՆ
1. Харви Дейтел, Пол Дейтел: Как программировать на C: Третье

издание. Пер. с англ. - М.:Бином- Пресс, 2002 г. - 1168 с.: ил.
2. Шилдт, Герберт: Полный справочник по C++, 4 издание.:Пер. с
англ.- М. : Издательский дом "Вильямс", 2007.- 800 с. :ил.
3. Страуструп Б. Язык программирования C++. - СПб.: Бином, 1999 -
991 с.
4. Кениг Э., Му Б. Эффективное программирование на C++. Серия C++
In-Depth. Т.2. - М.:Издательский дом "Вильямс", 2002 - 384 с.
5. Павловская Т.А., Щупак Ю.А. C++. Объектно-ориентированное
программирование: Практикум. - СПб.: Питер, 2008. - 265 с. : ил.
6. Элджер Д. C++: библиотека программиста. - СПб.: Питер, 2000 - 320 с.
7. Прата С. : Язык программирования C++. Лекции и упражнения. М. :
6-е издание. : Издательский дом "Вильямс", 2011.
8. Лафоре Р. Объектно-ориентированное программирование в C++.
Классика Computer Science. 4-e издание. - СПб.: Питер, 2003. - 928с.
9. Либерти Д. Освой самостоятельно C++ за 21 день. - М.:
Издательский дом "Вильямс", 2000 - 816 с.
10. Александреску А. Современное проектирование на C++. Серия C++
In-Depth. Т.3. - - М.: Издательский дом "Вильямс", 2002 - 336с.
78
79
Կազմողներ` Նարինե Ալբերտի Սահակյան
Իրինա Ռաֆայելի Սաղաթելյան
ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ:
ՖՈՒՆԿՑԻԱՆԵՐ
Լաբորատոր աշխատանքների կատարման մեթոդական ցուցումներ
Խմբագիր՝ Ն.Ա. Խաչատրյան
80

Դինամիկ զանգվածներ Ֆունկցիաներ

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Դինամիկ զանգվածներ Ֆունկցիաներ

Uploaded by

Copyright:

Available Formats

ՀԱՅԱՍՏԱՆԻ ՀԱՆՐԱՊԵՏՈՒԹՅԱՆ

ԿՐԹՈՒԹՅԱՆ ԵՎ ԳԻՏՈՒԹՅԱՆ ՆԱԽԱՐԱՐՈՒԹՅՈՒՆ

Կազմողներ` Ն.Ա. Սահակյան

Դինամիկ զանգվածներ: Ֆունկցիաներ: Լաբորատոր

Մեթոդական ցուցումները նվիրված են դինամիկ զանգվածների օգտագործմանը

1. ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ ................................................................ 6

2. ԵՐԿՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ.............................................. 16

3. ՖՈՒՆԿՑԻԱՆԵՐԻ ՆԿԱՐԱԳՐՈՒԹՅՈՒՆԸ ..................................... 32

Տրված մեթոդական ցուցումները նվիրված են դինամիկ

1.1. ՄԻԱՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐ

Ոչ դինամիկ զանգվածին տրամադրվող հիշողությունը

1.2. ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ ՏԱՐՐԵՐԻ ԱՐԱԳ ԴԱՍԱՎՈՐՈՒՄ

Կազմել ծրագիր, որը կդասավորի իրական տարրերից բաղ-

1.3. ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ ՄԵԾԱԳՈՒՅՆ ԵՎ ՓՈՔՐԱԳՈՒՅՆ

Կազմել ծրագիր, որը կհաշվի միաչափ զանգվածի այն

1.4. ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻՑ ՆՈՐ ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ

Կազմել ծրագիր, որը տրված միաչափ զանգվածի դրա-

1.5. ԽՆԴԻՐՆԵՐ ՄԻԱՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ

Հիշողության դինամիկ տարածքում կարելի է ստեղծել

int **a int *a[nrow] int a[nrow][ncol]

Նկ.2.1. Երկչափ զանգվածին դինամիկ հիշողություն տրամադրելու

Դինամիկ մատրիցի հեռացումը հիշողությունից կարելի

2.1. ԵՐԿՉԱՓ ԶԱՆԳՎԱԾԻ ՏԱՐՐԵՐԻ ԴԱՍԱՎՈՐՈՒՄԸ

Կազմել ծրագիր, որը տրված քառակուսային իրական

2.2. ԵՐԿՉԱՓ ԶԱՆԳՎԱԾԻ ՏՈՂԵՐԻ ԴԱՍԱՎՈՐՈՒՄԸ

Կազմել ծրագիր, որը կդասավորի տրված քառակուսային

2.3. ԵՐԿՉԱՓ ԶԱՆԳՎԱԾԻՑ ՆՈՐ ՄԻԱՉԱՓ ԶԱՆԳՎԱԾԻ

Կազմել ծրագիր, որը տրված քառակուսային ամբողջ

2.4. ԽՆԴԻՐՆԵՐ ԵՐԿՉԱՓ ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ

Ֆունկցիաները C/C++ ծրագրավորման լեզուների կառու-

C/C++ ծրագրավորման լեզուներում արգումենտները ֆունկ-

3.2. ԱՆՎԵՐՋ ՇԱՐՔԻ ԳՈՒՄԱՐԻ ՀԱՇՎԱՐԿ

Կազմել ծրագիր, որն արգումենտի տրված միջակայքում

Դինամիկ զանգվածի անունը իրենից ներկայացնում է

3.5. ԴԻՆԱՄԻԿ ԶԱՆԳՎԱԾՆԵՐԻ ԿԻՐԱՌՄԱՄԲ ՄԻԱՉԱՓ

Խնդիր 3.6.1: Տրված միաչափ զանգվածից ստանալ նոր

Աղյուսակ 3.6.1: Խնդիր 3.6.1-ում կիրառվող ֆունկցիաների

3.6. ՀԱՆՁՆԱՐԱՐՈՒԹՅՈՒՆՆԵՐ ՖՈՒՆԿՑԻՆԵՐԻ

Երկչափ զանգվածը C++ լեզվում ներկայացված է որպես

Աղյուսակ 3.8.1: Խնդիր 3.8.1-ում կիրառվող ֆունկցիաների

Աղյուսակ 3.8.2: Խնդիր 38.2-ում կիրառվող ֆունկցիա-

Աղյուսակ 3.8.3: Խնդիր 3.8.3-ում կիրառվող ֆունկցիաների

3.8. ԽՆԴԻՐՆԵՐ ՖՈՒՆԿՑԻՆԵՐԻ ԿԻՐԱՌՄԱՄԲ` ԵՐԿՉԱՓ

1. Харви Дейтел, Пол Дейтел: Как программировать на C: Третье

Խմբագիր՝ Ն.Ա. Խաչատրյան

You might also like