C++

[Ruzanna Stepanyan]

ու արդեն երկրորդ անգամ

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

շատ լավ, շնորհակալ եմ, բայց մի զայրացեք պարոն գայլ ձեզնից ցածր եմ քանի քայլ

[Ruzanna Stepanyan]

Զարմանում եմ ինչ գործ ունի C++ դպրոցում ու ընդհանրապես ինչի են պարտադրում դպրոցականին ծրագրավորում?
միայն տարրական համակարգչային գիտելիքներ են պետք ու վերջ

բոլորը չեն անցնում , անցնում են միայն բնագիտամաթեմատիկական հոսքի երեխաները

[Ruzanna Stepanyan]

int n, i, j;
double x[n], tmp;

հաստատ այ սրա վրա ա սխալ տվել

բայց ես x[n]-ի փոխարեն գրեցի x[10], բայց էլի չի ստացվում

[zulu]

			for (j=i; j=1; j--)
			{
				x[j]=x[j-1];
			}

for-ի մեջ էլ պետք ա ստուգել j>=1, այլ ոչ թե j=1

Sent from my GT-P7310 using Tapatalk HD

[Ruzanna Stepanyan]

for-ի մեջ էլ պետք ա ստուգել j>=1, այլ ոչ թե j=1

Sent from my GT-P7310 using Tapatalk HD

Մեկա չի ստացվում

[DavitH]

Խնդրում եմ մի հատ կբացատրեք այս խնդիրը ոնց լուծեմ, մենակ թե խնդրում եմ քայլերով, եթե հնարավոր է: Նախապես շնորհակալ եմ:

n հատ տարր պարունակող միաչափ զանգվածը կարգավորել ըստ նվազման:

Ավելի կարճ ու հասկանալի լուծում

ինչքան հիշում եմ պղպջակների ալգորիթմ ա կոչվում


#include <iostream>
using namespace std;
void main()
{
int i, j;
double x[10], tmp;


//զանգվածի ներմուծում
for (i=0; i<10; i++)
{
cin>>x[i];
cout<<endl;
}
for (i=1; i<n; i++)
{
for(j=i+1;j<n;j++)
{
if(x[i] < x[j])
{
tmp = a[j];
x[j]= x[i];
x[i]= tmp;
}
}
}



//հիմա տպենք ու տեսնենք որ նվազման կարգով ա
for (i=0; i<10; i++)
{
cout << x[i] << " ";

}
}

[Varzor]

թեմայից շեղվում ենք բայց ոչինչ
Այ ստեղ էլ ես համամիտ չեմ քո հետ Մաթեմատիկան մի համեմատի ծրագրավորման հետ դրանք տարբեր բաներ են ու տարբեր նշանակություն ունեն
մաթեմատիկան էտ բոլորին ա պետք իսկ c++ ոչ բոլորին

Հաստատ քեզ հետ համամիտ չեմ: Միգուցե բոլորին պետք է թվաբանությունը, բայց ոչ մաթեմատիկան` շատ լայն հասկացողություն է:
Նույն կերպ բոլորին պետք չի կենսաբանությունը կամ քիմիան, կամ ֆիզիկան, օտար լեզուն, ինչու չէ նաև հայոց լեզուն: Բայց անցնում են չէ դրանք?
Միջնակարգ կրթական հաստատությունը ակադեմիական կրթության առումով լուծում է 3 խնդիր.
1. Տարրական գիտելիքների ուսուցանում: Գիտելիքներ, որոնք անհրաժեշտ են քաղաքացիներին մինիմալ առումով` թվաբանություն, տառա և գրաճանաչություն:
2. Ընդհանուր կրթական ոլորտի վերաբերյալ համառոտ տեղեկացվածություն և համառոտ գիտելիքների ձեռքբերում:
3. Ելնելով ընդհանուր տեղեկացվածության մակարդակից կողմնորոշում և նախապատրաստում ԲՈՒՀ-ական կամ մասնագիտական այլ կրթություն ստանալու համար:

Ոնց տեսնում են 2-րդ խնդիրը ամենածավալունն է ու կախված է ժամանակի և միջավայրի պահանջներից: Ու էս առումով դպրոցում C++ դաավանդումը կոնկրետ ինձ համար լիովին համարժեք է անօրգանական քիմիայի կամ ասենք աստղագիտության դասավանդմանը` ծրագրավորումը նույնպես մասնագիտություն է և գիտության մի ճյուղ, որի մասին ընդհանուր և հիմնարար գտելիքներ պետք է ապահովի դպրոցը:
Բնականաբար այդ առարկան, որպես ավելի բարդ և կոնցեպտուալ, պետք է անցնեն բարձր դասարաններում, և ցանկալի է ըստ աշակերտի ընտրության: Որովհետև եթե աշակերտը մաթեմատիկայից կաղում է, ապա նրան տանջել ծրագրավորումով ուղղակի մարդկային մոտեցում չէ

[Varzor]

Ավելի կարճ ու հասկանալի լուծում

 •

• 

 Սեղմել՝ ցույց տալու համար

ինչքան հիշում եմ պղպջակների ալգորիթմ ա կոչվում


#include <iostream>
using namespace std;
void main()
{
int i, j;
double x[10], tmp;


//զանգվածի ներմուծում
for (i=0; i<10; i++)
{
cin>>x[i];
cout<<endl;
}
for (i=1; i<n; i++)
{
for(j=i+1;j<n;j++)
{
if(x[i] < x[j])
{
tmp = a[j];
x[j]= x[i];
x[i]= tmp;
}
}
}



//հիմա տպենք ու տեսնենք որ նվազման կարգով ա
for (i=0; i<10; i++)
{
cout << x[i] << " ";

}
}

Լավ լուծում է, կոդը գրելու տեսանկյունից կարճ է, բայց քայլերի տեսանկյունից կարճ չէ` համեմատությունների քանակը շատ է:
Համ էլ մի երկու վրիպում կա.
1. n-ի ներմուծումը չկա
2. քանի որ for (i=1; i<n; i++), ապա for(j=i+1;j<n;j++)` համեմատությունը սկսվում է արդեն 2-րդ տարրից ու հետևաբար առաջին տարրի ստուգում չի կատարվում
3. tmp = a[j] - a զանգվածը հայտարարված չէ:

[Ruzanna Stepanyan]

Ես լուծեցի հետևյալ ձևով.

using namespace std;
void main()
{
int x[10], i, j, k, n, max;
cout<<"mutqagreq zangavtsi chapy"<<endl;
do{cin>>n;}while(1>n||n>10);
for(i=0; i<n; i++)
{
cout<<"x["<<i<<"]=";
cin>>x[i];
}
for(i=0; i<n-1; i++)
{
max=x[i];
k=i;
for(j=i+1; j<n; j++)
if(x[j]>max)
{
max=x[j];
k=j;
}
x[k]=x[i];
x[i]=max;
}
for(i=0; i<n; i++)
cout<<x[i];
}

[DavitH]

Լավ լուծում է, կոդը գրելու տեսանկյունից կարճ է, բայց քայլերի տեսանկյունից կարճ չէ` համեմատությունների քանակը շատ է:
Համ էլ մի երկու վրիպում կա.
1. n-ի ներմուծումը չկա
2. քանի որ for (i=1; i<n; i++), ապա for(j=i+1;j<n;j++)` համեմատությունը սկսվում է արդեն 2-րդ տարրից ու հետևաբար առաջին տարրի ստուգում չի կատարվում
3. tmp = a[j] - a զանգվածը հայտարարված չէ:

ինձ թվում ա պարզ պիտի լինի որ էտ a չպիտի լիներ այլ x
երկեորդն ել ինչի եմ տարրը առաջինից համեմատում ինձ պետք չի տենց դրա համար էլ for(j=i+1;j<n;j++) սենց եմ գրել
n-ի համար էլ մոռացել եմ հանեմ պիտի 10 լինի
էս ստից վրիպակները կան որորվհետև միանգամից ստեղ եմ գրում կամպիլյացիա չեմ անում

համենայն դեպս ես էս լուծումն եմ ընդունում քոնը շատ խուճուճ ա ու ոնց որ թե երկուսի կարգն ել n քառակուսի ա

[DavitH]

Ես լուծեցի հետևյալ ձևով.

using namespace std;
void main()
{
int x[10], i, j, k, n, max;
cout<<"mutqagreq zangavtsi chapy"<<endl;
do{cin>>n;}while(1>n||n>10);
for(i=0; i<n; i++)
{
cout<<"x["<<i<<"]=";
cin>>x[i];
}
for(i=0; i<n-1; i++)
{
max=x[i];
k=i;
for(j=i+1; j<n; j++)
if(x[j]>max)
{
max=x[j];
k=j;
}
x[k]=x[i];
x[i]=max;
}
for(i=0; i<n; i++)
cout<<x[i];
}

լուծման միտքը նույնն ա ինչ որ իմ մոտ

էս տիպի խնդիրները սկսնակ ծրագրավորողների համար դասական օրինակներ են

ձեզ խորհուրդ կտամ ուսումնասիրեք, եթե իհարկե արդեն չեք կարդացել, «Как программировать на C++ - Дейтел Х., Дейтел П.» գրիքը

[Varzor]

Ես լուծեցի հետևյալ ձևով.

using namespace std;
void main()
{
int x[10], i, j, k, n, max;
cout<<"mutqagreq zangavtsi chapy"<<endl;
do{cin>>n;}while(1>n||n>10);
for(i=0; i<n; i++)
{
cout<<"x["<<i<<"]=";
cin>>x[i];
}
for(i=0; i<n-1; i++)
{
max=x[i];
k=i;
for(j=i+1; j<n; j++)
if(x[j]>max)
{
max=x[j];
k=j;
}
x[k]=x[i];
x[i]=max;
}
for(i=0; i<n; i++)
cout<<x[i];
}

Նույն ալգորիթմն է, ինչ DavitH-ի առաջարկածը, ուղղակի մի քանի հրաման ավել, որոնք որ կարելի է չգրել: Բացի այդ փոփոխականների նկարագրությունը չի համապատասանում խնդրի դրվածքին` խնդրի պայմանում նշված չէ, որ զանգվածի տարրերը ամբողջ թվեր են:
Մասնավորապես տարրերի տեղափոխությունը կատարվում է պայմանից դուրս, ապա կատարվում են ավելորդ քայլեր:
Նույն ծրագիրը կարելի է որոշ ձևափոխությունների ենթարկել և օպտիմիզացնել Ու էդ դեպքում կստացվի DavitH-ի գրած կոդը, որոշ սուբյեկտիվ տարբերություններով:

[Varzor]

ինձ թվում ա պարզ պիտի լինի որ էտ a չպիտի լիներ այլ x
երկեորդն ել ինչի եմ տարրը առաջինից համեմատում ինձ պետք չի տենց դրա համար էլ for(j=i+1;j<n;j++) սենց եմ գրել
n-ի համար էլ մոռացել եմ հանեմ պիտի 10 լինի
էս ստից վրիպակները կան որորվհետև միանգամից ստեղ եմ գրում կամպիլյացիա չեմ անում
համենայն դեպս ես էս լուծումն եմ ընդունում քոնը շատ խուճուճ ա ու ոնց որ թե երկուսի կարգն ել n քառակուսի ա

Դե բնականաբար առանց կոմպիլյացիայի գրելուց, մանավանդ որ ռեգուլյար էդ գործով չես զբաղվում, սխալներն անխուսափելի են
Ախր ոնց էս ասում, որ առաջինից պետք չի? Չպիտի առաջին տարրը համեմատես 2-րդ ի հետ? Քո ասածով բոլորը կարող ես տեղերով փոխել, բացի առաջինից: իսկ ինչ գիտես, որ առաջինը ամենամեծ տարրն է ու ճիշտ իր տեղում է գտնվում?
Իսկ ինչ վերաբերվում է իմ տարբերակի "խուճուճ" լինելուն, ապա էդ տարբերակը մի քանի նախադասությամբ նկարագրել եմ ու հեչ էլ խուճուճ չի, բայց պրոցեսորի կողմից ավելի արագ պիտի կատարվի, քանի որ քո տված ալգորիթմում զանգվածի ամեն տարր համեմատվում է իրեն հաջորդող բոլոր տարրերի հետ, իսկ իմ բերած տարբերակում զանգվածի ամեն տարր համեմատվում է միայն առաջին տարրի և իր նախորդ տարրի հետ:
Եթե մենակ պայմամնների ստուգման քանակը հաշվենք, ապա իմ մոտ դա վատագույն դեպքում 2n է, սիկ քո տարբերակում n*(n+1)/2~n²/2: Մեծ n-ների պարագայում ուղղակի անհամեմատելի է` 2n<<n²/2
Բայց ասեմ, որ քո բերած ալգորիթմը համարվում է դասականը, իսկ իմ բերած տարբերակը դասական չի, ուղղակի ռեսուրսների տեսանկյունից օպտիմիզացված է

[DavitH]

Դե բնականաբար առանց կոմպիլյացիայի գրելուց, մանավանդ որ ռեգուլյար էդ գործով չես զբաղվում, սխալներն անխուսափելի են
Ախր ոնց էս ասում, որ առաջինից պետք չի? Չպիտի առաջին տարրը համեմատես 2-րդ ի հետ? Քո ասածով բոլորը կարող ես տեղերով փոխել, բացի առաջինից: իսկ ինչ գիտես, որ առաջինը ամենամեծ տարրն է ու ճիշտ իր տեղում է գտնվում?
Իսկ ինչ վերաբերվում է իմ տարբերակի "խուճուճ" լինելուն, ապա էդ տարբերակը մի քանի նախադասությամբ նկարագրել եմ ու հեչ էլ խուճուճ չի, բայց պրոցեսորի կողմից ավելի արագ պիտի կատարվի, քանի որ քո տված ալգորիթմում զանգվածի ամեն տարր համեմատվում է իրեն հաջորդող բոլոր տարրերի հետ, իսկ իմ բերած տարբերակում զանգվածի ամեն տարր համեմատվում է միայն առաջին տարրի և իր նախորդ տարրի հետ:
Եթե մենակ պայմամնների ստուգման քանակը հաշվենք, ապա իմ մոտ դա վատագույն դեպքում 2n է, սիկ քո տարբերակում n*(n+1)/2~n²/2: Մեծ n-ների պարագայում ուղղակի անհամեմատելի է` 2n<<n²/2
Բայց ասեմ, որ քո բերած ալգորիթմը համարվում է դասականը, իսկ իմ բերած տարբերակը դասական չի, ուղղակի ռեսուրսների տեսանկյունից օպտիմիզացված է

for (i=1; i<n; i++)
{
for(j=i+1;j<n;j++)
{
if(x[i] < x[j])
{
tmp = a[j];
x[j]= x[i];
x[i]= tmp;
}
}
}

էէէ ախր ուշադիր չես եղել է
տես վերցնում եմ ամենասկզբից
առաջինըx[i] ու երկրորդը x[j]
դրա համար j -ն սկսում եմ i+1 որ իքը իրա հետ չհամեմատեմ


գիտեմ որ դասական տարբերակ ա դրա համար միշտ առաջինը էս եմ ասում արագության հարցում էլ դեմ չեմ ճիշտ ես ասում քոնը արագ ա

[Ruzanna Stepanyan]

Հարգելիներս,

շատ շնորհակալ եմ, որ որ արձագանքում եք ու օգնում եք ինձ, բայց իմ ինքնագործունեության արդյուքում գրած խնդրի թերությունների պատճառը այն էր, որ դուք շատ սիրուն քննակրկում եք ծավալել իմ խնդրի շուրջ, բայց վերջնական ինչ որ տարբերակ, որը կաշխատի ու ինձ կօգնի, էդպես էլ չտվեցիք: Իհարկե շնորհակալ եմ, որ օգնում եք, կարող էիք էսքանն էլ չանել:

Չնայած ես որոշել եմ հանուն իմ աշակերտների խորանալ ու լավ սովորել , բայց երբ գրում եք բացատրությունը, խնդրում եմ խղճացեք ինձ, ու մի քիչ հասարակ տերմիններով բացատրեք, եթե իհարկե ժամանակ ունեք կամ ուզում եք ինձ օգնել: