C++

[Varzor]

Եթե p[j]= p+j*sixeof(int) նկատի ունես որպես բազմապատկում, ապա ես դա չեմ համարում սովորական բազմապատկում, որովհետև sizeof(int) սովորաբար 4 է, հետևաբար կոմպիլյատորը պարտավոր է օպտիմիզացնել (j * 4) գործողությունը և այն վերածել (j << 2) շատ ավելի արագ բիտային գործողության: Իսկ ցուցիչը չի կարող նկատելի չափով դանդաղեցնել, որովհետև դրսի ցիկլի մեջ է գտնվում, իսկ ամբողջ ժամանակը ծախսվում է ներսի ցիկլի վրա, այնպես որ ցուցիչի վրա ծախսված ժամանակը կկազմի ամբողջ ժամանակի մոտավորապես 0.01% մասը: Ամեն դեպքում ես հարցը տալիս նկատի ունեի ավելի սարքային պատճառներ` պրոցեսորի աշխատելու մեխանիզմը և այլն, որովհետև զուտ տրամաբանական տեսանկյունից նայելիս 2րդ տարբերակում միայն արագանալու միտում եմ տեսնում:

Լիովին քեզ հասկանում եմ: Բայց կոմպիլյատորի օպտիմիզացիան կապ չունի ստեղ, քանի որ վերածվում է ASSEMBLER-ի, որի պարագայում էլ ցանկացած գործողոթւոյւն բիտային է, այդ թվում և բազմապատկումը: Ստանդարտ երկուական բազմապատկումը գումար-տեղաշարջ հաջորդականությամբ է կատարվում` բիտերի մակարդակով: Այո, ճիշտ ես պիտի որ ցուցիչի հետ կատարվող օպերացիաները շատ մեծ ժամանակ չխլեն, բայց այդ օպերացիաները խիստ կախված են կողմնակի հանգամանքներից: Հիշողությունում տեղի պիտի հատկացվի ցուցիչին: Ըստ ծրագրի դու դա անում ես ամեն անգամ դրան հայտարարելով ցիլկի առաջին մակարդակում: Նախ այդ հիշողուոյւնը պիտի լինի, որ տրամադրվի, երկրորդն էլ կախված է, ինչպես նշեցիր պրողեցորի կառուցվածքից` ինչպես է կառավարվում հիշողության հասցեների տիրույթը:
Բացի այդ, շատ ճիշտ էիր նկատել, պրոցեսորի քեշը մեծ նշանակություն ունի:Եթե ամբողջ զանգվածը և ցուցչներն էլ հետը տեղավորվում են պրոցեսորի քեշում, ապա գործողությունները մի քանի անգամ ավելի արագ կկատարվեն:
Բայց արի հաշվենք` m-ը 10000x10000 հատ int է` այսինքն` 100մլն հատ int, 4 բիտով կանի 400մլն բիտ` մոտ 48ՄԲ, իսկ այդպիսի քեշ չունեն ներկայիս պրոցեսորները: Սա կոպիտ հաշվարկ էր, հաշվի պետք առնել նաև այն, որ ներկայիս պրոցեսորում հասցեավորումը 64բիտով է գնում, նույնիսկ 32 բիտանոց OՀ դեպքում: Այստեղ չմ հաշվում ծրագրի մնացած փոփոխություններն ու գործողությունների հրամաննեը (դե սրանք տուֆտա փոքր թվեր են, դրա համար):
Ուստի այսպես, թե այնպես խնդիր լուծման ընթացքում օգտագործվելու է համակարգային հիշողությունը` RAM-ը: Ու կախված պրոցեսորի վրա ընթացող այլ պրոցեսներից, հիշողության փեյջինգի մեխանիզմից, հիշողության կառուցվածքից և լիքը այլ բաներից էդ խնդրի լուծումը կարող է տարբեր ժամանակներ խլել: Սակայն 10000 անգամ ցուցիչի հայտարարումն ու արժեքի գրանցումը արդեն իսկ պիտի իր ազդեցությունը տա:

Քո մոտ ինչքան ա դանդաղում? Մոտավորապես ինչքան ա հարաբերակցությունը ցուցիչով ու առանց դրա? Խրոնոմետրաժ արել ես?

[soultaker]

Լիովին քեզ հասկանում եմ: Բայց կոմպիլյատորի օպտիմիզացիան կապ չունի ստեղ, քանի որ վերածվում է ASSEMBLER-ի, որի պարագայում էլ ցանկացած գործողոթւոյւն բիտային է, այդ թվում և բազմապատկումը: Ստանդարտ երկուական բազմապատկումը գումար-տեղաշարջ հաջորդականությամբ է կատարվում` բիտերի մակարդակով: Այո, ճիշտ ես պիտի որ ցուցիչի հետ կատարվող օպերացիաները շատ մեծ ժամանակ չխլեն, բայց այդ օպերացիաները խիստ կախված են կողմնակի հանգամանքներից: Հիշողությունում տեղի պիտի հատկացվի ցուցիչին: Ըստ ծրագրի դու դա անում ես ամեն անգամ դրան հայտարարելով ցիլկի առաջին մակարդակում: Նախ այդ հիշողուոյւնը պիտի լինի, որ տրամադրվի, երկրորդն էլ կախված է, ինչպես նշեցիր պրողեցորի կառուցվածքից` ինչպես է կառավարվում հիշողության հասցեների տիրույթը:
Բացի այդ, շատ ճիշտ էիր նկատել, պրոցեսորի քեշը մեծ նշանակություն ունի:Եթե ամբողջ զանգվածը և ցուցչներն էլ հետը տեղավորվում են պրոցեսորի քեշում, ապա գործողությունները մի քանի անգամ ավելի արագ կկատարվեն:
Բայց արի հաշվենք` m-ը 10000x10000 հատ int է` այսինքն` 100մլն հատ int, 4 բիտով կանի 400մլն բիտ` մոտ 48ՄԲ, իսկ այդպիսի քեշ չունեն ներկայիս պրոցեսորները: Սա կոպիտ հաշվարկ էր, հաշվի պետք առնել նաև այն, որ ներկայիս պրոցեսորում հասցեավորումը 64բիտով է գնում, նույնիսկ 32 բիտանոց OՀ դեպքում: Այստեղ չմ հաշվում ծրագրի մնացած փոփոխություններն ու գործողությունների հրամաննեը (դե սրանք տուֆտա փոքր թվեր են, դրա համար):
Ուստի այսպես, թե այնպես խնդիր լուծման ընթացքում օգտագործվելու է համակարգային հիշողությունը` RAM-ը: Ու կախված պրոցեսորի վրա ընթացող այլ պրոցեսներից, հիշողության փեյջինգի մեխանիզմից, հիշողության կառուցվածքից և լիքը այլ բաներից էդ խնդրի լուծումը կարող է տարբեր ժամանակներ խլել: Սակայն 10000 անգամ ցուցիչի հայտարարումն ու արժեքի գրանցումը արդեն իսկ պիտի իր ազդեցությունը տա:

Քո մոտ ինչքան ա դանդաղում? Մոտավորապես ինչքան ա հարաբերակցությունը ցուցիչով ու առանց դրա? Խրոնոմետրաժ արել ես?

Դե ես փորձել եմ այն դեպքում երբ որ ցուցիչը մի անգամ է հայտարարվում վերևում, այնպես որ հիշողություն վերցնել/ջնջելու խնդիրը դուրս է գալիս, բայց դրանից ժամանակային առումով ոչինչ չի փոխվում: Եթե ասեմբլերի մակարդակով նայենք` ցիկլի մեջ փոփոխական(այս դեպքում` ցուցիչը) հայտարարելու դեպքում ինչքան գիտեմ ուղղակի ստեկի մեջ է գցում, ջնջելուց` հանում, որը ուղղակի ստեկի վերջը պահող ռեգիստրի գումարում/հանում է: Ինչ վերաբերվում է ժամանակի փոփոխությանը` կարելի է ասել երկու դեպքում էլ աշխատում է նույն կերպ, երկրորդ դեպքում առաջինից ավելի արագ չի աշխատում, իսկ թե ավելի դանդաղ է թե չէ` հաստատ չեմ կարող ասել, իդեալական պայմաններում չի չափվել, բայց եթե տարբերություն կա, ուրեմն շատ չնչին է, շատ ավելի փոքր սպասելի դրական փոփոխության համեմատ: Երկու թվերի բազմապատկումը ծանր գործողություն է տրամաբանական առումով, որովհետև երկու 32 բիտանոց թվեր բազմապատկելիս կարելի է ասել, որ կատարվում է մոտ 32 * 32 = 1024 բիտերի զույգերի գործողություն: Այդ ամենը պիտի որ կատարվի մի քանի տակտով ընդամենը, կախված համակարգչի արխիտեկտուրայից, բայց ամեն դեպքում բազմապատկումը պիտի ավելի ծանր լինի, քան գումարման/հանման/բիտային գործողությունները (բիտային գործողություն ասելով նկատի ունեմ C++ի & | ^ << >> ~ գործողությունները): Ընդհանրապես եթե հարցը գնում է օպտիմիզացիայի մասին, ապա սկզբում սովորաբար արագացնում են ամենադանդաղ մասը (bottleneck), որը տվյալ դեպքում ներսի ցիկլի միջի գրածն է, որը ըստ տրամաբանության ավելի քիչ գործողություններ է պարունակում (այսինքն երկրորդ դեպքում i * 10000 արժեքը արդեն պահված է հասցեի փոփոխականի մեջ և օգտագործվում է ամեն անգամ նորից հաշվելու փոխարեն): Նման այլ դեպքեր հանդիպել են, երբ սպասված արագացումը տեղի ունենալու փոխարեն նույնիսկ ավելի դանդաղել է, ուղղակի այս պահին այդ մի դեպքն եմ հիշում: Հիմնականում դրա բացատրությունը հակված եմ փնտրելու կոմպիլյատորի օպտիմիզացիաների մեջ, որոնք անում են բավականին անսպասելի բաներ (օրինակ` ցիկլով հաշվել 1 .. 2 000 000 000 թվերի գումարը, որոշ կոմպիլյատորներ միացրած օպտիմիզացիայի դեպքում գեներացնում են այնպիսի ծրագիր, որը արդյունքը տպում է ակնթարթորեն, 0.1 վայրկյանից շուտ, մինչդեռ առանց օպտիմիզացիայի` 1 վայրկյանից ավել):

[Varzor]

Եթե ասեմբլերի մակարդակով նայենք` ցիկլի մեջ փոփոխական(այս դեպքում` ցուցիչը) հայտարարելու դեպքում ինչքան գիտեմ ուղղակի ստեկի մեջ է գցում, ջնջելուց` հանում, որը ուղղակի ստեկի վերջը պահող ռեգիստրի գումարում/հանում է:

Այո, ստեկում է պահում, բայց այդ ստեկը կարող է լինել ոչ թե պրոցեսորի քեշում, այդ գաղափարը կոչվում է "ծրագրի ստեկ"` կարող է գտնվել նաև RAM-ում: Բացի դրանից կոմպիլյատերից էլ է կախված, ՕՀ-ից էլ, թե տվյալ ծրագրին որքան ստեկ կհատկացնի: Օրինակ` 32բիտանոց ծրագրերին ՎԻնդավոզը երբեք 2ԳԲ-ից ավել RAM չի հատկացնում, նույնիսկ եթե ՕՀ-ն 64 բիտանոց է ու RAM-ն էլ 1TB: Միայն հատուկ մեծ ստեկով (կամ ընդլայնվող ստեկով) ծրագրերին է տալիս 2ԳԲ-ից ավել հիշողություն:
Բայց դե արի Դեյտելի ու Ստրաուստրուպի պես ավտարիտետնի տղերքին հավատանք ու համարենք, որ ցուցիչով, թե առանց դրա` նույն բանն է ու իրար համարժեք: Համենայն դեպս ինձ հասկանալի է, թե ինչու է այդպես:

Երկու թվերի բազմապատկումը ծանր գործողություն է տրամաբանական առումով, որովհետև երկու 32 բիտանոց թվեր բազմապատկելիս կարելի է ասել, որ կատարվում է մոտ 32 * 32 = 1024 բիտերի զույգերի գործողություն: Այդ ամենը պիտի որ կատարվի մի քանի տակտով ընդամենը, կախված համակարգչի արխիտեկտուրայից, բայց ամեն դեպքում բազմապատկումը պիտի ավելի ծանր լինի, քան գումարման/հանման/բիտային գործողությունները (բիտային գործողություն ասելով նկատի ունեմ C++ի & | ^ << >> ~ գործողությունները):

Դե երկուական հանրահաշվի տեսանկյունից ճիշտ ես, բայց էլ. տեխնիկական տեսանկյունից` 2 հատ 32 բիտանոց թվերիգումարումն իրենցի ներկայացնում է 32 գումարում, 32 տեղաշարժ` 64 գործողություն: Հաշվի առնոլեվ ներկայիս պրոցեսորների կառուցվածքը` 8 տակտ: Իսկ քո ասած բիտայի գործողությունները տեսականորեն են արագ: Կախված նրանից, թե կոմպիլյատորը դրանք ինչպես կօպտիմիզացնի ու տրանսլյատորն ինչպես կթարգմանի, կարող են ստացվել տարբեր արդյունքներ: Բայց էլի եմ ասում: Ամբողջ թվերի տեսանկյունից, նույնիսկ առավելագույնս օպտիմիզացված` x86-ի վրա տարբերություն չկա: Ընդհանրապես ամբողջ թվերի հետ աշխատելը շատ հեշտ ու արագ է դարձել պրոցեսորների համար, դրա համար էլ պրոցեսորի արտադրողականությունը չափում են FLOPS-ով` սահող ստորակետով թվերի հետ կատարվող օպերացիաներով:

Հիմնականում դրա բացատրությունը հակված եմ փնտրելու կոմպիլյատորի օպտիմիզացիաների մեջ, որոնք անում են բավականին անսպասելի բաներ (օրինակ` ցիկլով հաշվել 1 .. 2 000 000 000 թվերի գումարը, որոշ կոմպիլյատորներ միացրած օպտիմիզացիայի դեպքում գեներացնում են այնպիսի ծրագիր, որը արդյունքը տպում է ակնթարթորեն, 0.1 վայրկյանից շուտ, մինչդեռ առանց օպտիմիզացիայի` 1 վայրկյանից ավել):

Հաստատ համամիտ եմ այն մտքի հետ, որ կոմպիլյատորից շատ բան է կախված: օրինակ Borland-ի կոմպիլյատորնեը միշտ էլ աչքի են ընկել օպտիմալ աշխատանով և համարվել են RAPID: Հենց դրա համար էլ Delphi-ի ինժեներին տարան, որ C#-ի մոնցեպցիաները մշակի:
Դրա հետ կապված մի դեպք հիշեցի: 2000-ականների սկզբին ինտերնետով մի մարդ վաճառում էր Word97-ը, որը Disassembler էր արել, օպտիմիզացրել ու 3 անգամ ավելի արագ էր դրաձրել

[Ruzanna Stepanyan]

խնդրում եմ մի հատ նայեք, թե ինչն եմ սխալ արել, որ քանակը հաշվում է, իսկ արտադրյալը նույնիսկ ցույց չի տալիս էկրանին

Հաշվել և արտածել տրված n տարր պարունակող միաչափ այն տարրերի քանակը և արտադրյալը , որոնք պատկանում են տրված [a;b] միջակայքին

#include <iostream>
using namespace std;
void main()
{
int x[10], p,i,n,a,b, qanak;
cout<<"a=";
cin>>a;
cout<<"b=";
cin>>b;
do
{cin>>n;}
while(1>n||n>10);
for(i=0; i<n; i++)
{
cout<<"x["<<i<<"]=";
cin>>x[i];
}
p=1;
qanak=0;

for(i=1; i<n; i++)
if((x[i]>=a)&&(x[i]<=b))
{
p=p*x[i];
qanak++;
}
else
cout<<"p="<<p<<endl;
cout<<"qanak="<<qanak<<endl;

}

[Varzor]

խնդրում եմ մի հատ նայեք, թե ինչն եմ սխալ արել, որ քանակը հաշվում է, իսկ արտադրյալը նույնիսկ ցույց չի տալիս էկրանին

Հաշվել և արտածել տրված n տարր պարունակող միաչափ այն տարրերի քանակը և արտադրյալը , որոնք պատկանում են տրված [a;b] միջակայքին

#include <iostream>
using namespace std;
void main()
{
int x[10], p,i,n,a,b, qanak;
cout<<"a=";
cin>>a;
cout<<"b=";
cin>>b;
do
{cin>>n;}
while(1>n||n>10);
for(i=0; i<n; i++)
{
cout<<"x["<<i<<"]=";
cin>>x[i];
}
p=1;
qanak=0;

for(i=1; i<n; i++)
if((x[i]>=a)&&(x[i]<=b))
{
p=p*x[i];
qanak++;
}
else
cout<<"p="<<p<<endl;
cout<<"qanak="<<qanak<<endl;
}

Ընդգծածս հատվածում սխալ կա`else-ն պետք չի: Հակառակ պայմանի գործողություն քո խնդրում չկա:

[Ruzanna Stepanyan]

Ընդգծածս հատվածում սխալ կա`else-ն պետք չի: Հակառակ պայմանի գործողություն քո խնդրում չկա:

Մերսի շատ պատասխանի համար
ես էդպես էլ էի փորձել, բայց էդ դեպքում արտադրյալը ճիշտ ա հաշվում, իսկ քանակը միշտ գրում ա , որ հավասար ա 1-ի: Մի հատ կնայեք ինչն ա սխալ

[Varzor]

Մերսի շատ պատասխանի համար
ես էդպես էլ էի փորձել, բայց էդ դեպքում արտադրյալը ճիշտ ա հաշվում, իսկ քանակը միշտ գրում ա , որ հավասար ա 1-ի: Մի հատ կնայեք ինչն ա սխալ

Մի բան էլ ասեմ.
1. Զանգվածի էլեմենտների հաշվարկի ցիկլում գրի i=0
Քանակի պահը պիտի ճիշտ հաշվի, եթե ընենց ես գրում ոնց որ ստեղ ես դրել: Ուղղակի փոխի i=0 ու else-ն հանի:
Մեկ էլ ներմուծելուց պիտի ուշադիր լինես, որ a-ն միշտ փոքր լինի b-ից:

[Ruzanna Stepanyan]

Մի բան էլ ասեմ.
1. Զանգվածի էլեմենտների հաշվարկի ցիկլում գրի i=0
Քանակի պահը պիտի ճիշտ հաշվի, եթե ընենց ես գրում ոնց որ ստեղ ես դրել: Ուղղակի փոխի i=0 ու else-ն հանի:

իսկ ինչի ենք գրում 1, նախորդ խնդիրնեերում գրել էի 0, բայց ֆրումում ինձ խորհուրդ տվեցին գրել 1:

[Varzor]

իսկ ինչի ենք գրում 1, նախորդ խնդիրնեերում գրել էի 0, բայց ֆրումում ինձ խորհուրդ տվեցին գրել 1:

Նախորդ խնդիրներում min/max խնդիր էիր լուծում, որի ժամանակ որպես սկզբնական min/max տարր ընդունում էիր զանգվածի առաջին տարրը: Ու հետագա համեմատություններրի ժամանակ իմաստ չուներ, որ ինքն իրա հետ համեմատեիր, դրա համար էլ ցիկլը սկսում էիր 2-րդ տարրից` ինդեքսը 1-ից:
Իսկ այս խնդրում զանգվածի բոլոր տարրերն էլ կարող են պատկանել [a;b]միջակայքին ուստի պիտի սկսես 0-ինդեքսից` 1-ին տարրից:

[Ruzanna Stepanyan]

Նախորդ խնդիրներում min/max խնդիր էիր լուծում, որի ժամանակ որպես սկզբնական min/max տարր ընդունում էիր զանգվածի առաջին տարրը: Ու հետագա համեմատություններրի ժամանակ իմաստ չուներ, որ ինքն իրա հետ համեմատեիր, դրա համար էլ ցիկլը սկսում էիր 2-րդ տարրից` ինդեքսը 1-ից:
Իսկ այս խնդրում զանգվածի բոլոր տարրերն էլ կարող են պատկանել [a;b]միջակայքին ուստի պիտի սկսես 0-ինդեքսից` 1-ին տարրից:

հաաա ճիշտ ա

բայց մեկա քանակը չի հաշվում, միշտ հավասար ա 1-ի

[Varzor]

հաաա ճիշտ ա

բայց մեկա քանակը չի հաշվում, միշտ հավասար ա 1-ի

մի հատ վերջի հատվածը սենց գրի.
for(i=0; i<n; i++)
{
if((x[i]>=a)&&(x[i]<=b))
{
p=p*x[i];
qanak+=1;
}
}
cout<<"p="<<p<<endl;
cout<<"qanak="<<qanak<<endl;

[Ruzanna Stepanyan]

ստավեց, մերսի շատ

կբացատրեք ինչի էդպես գրելուց ստավեց, իսկ նախորդ տարբերակը չէր ստացվում, խնդրում եմ

[Varzor]

ստավեց, մերսի շատ

կբացատրեք ինչի էդպես գրելուց ստավեց, իսկ նախորդ տարբերակը չէր ստացվում, խնդրում եմ

{} փակագծերը For-ի համար պակասում էին:

[armen9494]

խնդրում եմ մի հատ նայեք, թե ինչն եմ սխալ արել, որ քանակը հաշվում է, իսկ արտադրյալը նույնիսկ ցույց չի տալիս էկրանին

Հաշվել և արտածել տրված n տարր պարունակող միաչափ այն տարրերի քանակը և արտադրյալը , որոնք պատկանում են տրված [a;b] միջակայքին

#include <iostream>
using namespace std;
void main()
{
int x[10], p,i,n,a,b, qanak;
cout<<"a=";
cin>>a;
cout<<"b=";
cin>>b;
do
{cin>>n;}
while(1>n||n>10);
for(i=0; i<n; i++)
{
cout<<"x["<<i<<"]=";
cin>>x[i];
}
p=1;
qanak=0;

for(i=1; i<n; i++)
if((x[i]>=a)&&(x[i]<=b))
{
p=p*x[i];
qanak++;
}
else
cout<<"p="<<p<<endl;
cout<<"qanak="<<qanak<<endl;

}

Դե քանի որ արդեն խնդիրը լուծեցիք, մի բան ասեմ, որ կարծում եմ պետք կգա: Խոսքը a-ի և b-ի ներմուծման մասին է:
Ուրեմն քանի որ չկարողանաք b-ն a-ից փոքր ներմուծել, կարող եք դրա վրա էլ սահմանափակում դնել, նշածս մասի փոխարեն գրելով այսպես՝
do
cout<<"a=";
cin>>a;
cout<<"b=";
cin>>b;
while ( b>=a);

[Hermsbir]

Ո՞վ կարող է լուծել հետևյալ խնդիրը:

Տրված է 1 հատ 15 տարեկան կենդանի: Այդ կենդանին այնպիսին է,որ ապրում է 35 տարի, իսկ սեռահասունացումը տեղի է ունենում 15 տարեկանում: Սկսած 15 տարեկանից կենդանին ամեն տարի ունենում է 1 ձագ : Բազմանալու համար կենդանուն զույգ չի պահանջվում: Գրել ծրագիր, որը պահանջի տարիների քանակ և դուրս բերի, թե այդքան տարի հետո քանի կենդանի կլինի: Ծրագիրը պետք է աշխատի մեծ թվերի համար (~800-1000 տարի):