Pascal խնդիրներ

[Rudik_100]

Program a170;
var x:array[1..10] of integer;
i,n,j,l,k,s,t:integer;
begin read(n);

for i:=1 to n do read (x[i]);
s:=0;
for i:=2 to n do t:=0;
for j:=2 to x[i]-1 do if x[i] mod j = 0 then begin t:=1; if t=0 then l:=j;
for i:=n to 2 do t:=0;
for j:=2 to x[i]-1 i do if x[i] mod j = 0 then t::=1 else if t:=0 then k:=j;
write(s:=(k+1)+(l-1));
end;
end.

[Varzor]

Տրված է n բնական թիվը և n տարր պարունակող միաչափ զանգվածը: Հաշվել զանգվածի առաջին պարզ տարրին նախորդող և վերջին պարզ տարրին հաջորդող տարրերի գումարը: Ենթադրվում է տրված վեկտորի առաջին և վերջին տարրերը պարզ չեն:
Կցորդ 53706
Program a170;
var x:array[1..10] of integer;
i,n,j,l,k,s,t:integer;
begin read(n);

for i:=1 to n do read (x[i]);
s:=0;
for i:=1 to n do t:=0;
for j:=2 to x[i]-1 do if x[i] mod j = 0 then begin t:=1; if t=0 then l:=x[i];
write(l=x[i]);
end;
ՈՒզում եմ իմանամ ալգորիթմը եթե ճիշտ է...ծրագիրը ոնց կազմեմ

end.

Կցածդ նկարում ալգորիթմը անավարտ է` գումարի հաշվման մասը բացակայում է, բացի այդ տրամաբանական ու կառուցվածքային սխալներ կան, մասնավորապես թվի պարզության որոշման մասում:
Ծրագիրն էլ սխալ ես գրել:

[Varzor]

դե նախ եթե ասում է, որ "ենթադրվում է տրված վեկտորի առաջին և վերջին տարրերը պարզ չեն", ապա նրանց կարելի է ցիկլի մեջ չվերցնել: (ցիկլը առաջին տեղը սարքի 2,n-1 , իսկ երկրորդ տեղը n-1,2)
Ընդեղ երկու անգամն էլ որ գտնում ես պարզ թիվը ցիկլից միանգամից դուրս արի (break արա): Կարմիրով էդ մասը ուղղել եմ: Ալգորիթմը ոնց որ թե վերջացրած չէր, էդքան մասը ուղղել եմ, իմ կարծիքով ճիշտ եմ արել: Մեկ էլ հիշի ոչ թե x[i]-ն այլ հենց [i]-ն, որովհետև դու x[i]-ի հետ ոչ մի բան չես անելու, ինքը քեզ պետք չի գալու, քեզ իրա դիրքն ա պետք:
Էն կանաչ գույնով արածներս պարտադիր չեն, բայց ցանկալի են, քանի որ հենց ինքը մի անգամ T=1 գործողությունը արեց, նշանակում ա հասկացավ, որ թիվը պարզ չի, էլ ի՞նչ իմաստ ունի ստուգել մնացածի համար, դրա համար ըտեղից էլ break արա:
հիմա դու L-ի մեջ ունես առաջին պարզ թվի դիրքը, իսկ K-ի մեջ վերջին: Փորձի շարունակես, հիմա երկու ցիկլ էլի պիտի անես, որոնց մեջ հաշվես գումարը:

Կարամ նաև մի ավելի օպտիմալ տարբերակ առաջարկեմ.
ներմուծելուց հետո մի s փոփոխական վերցրու (s=x[1] ): Նորից 2,n-1 ցիկլ արա, որի մեջ նորից ստուգի պարզ թիվ լինելը: Եթե թիվը պարզ չի, ապա թող s=s+x[i] անի, հակառակ դեպքում (եթե պարզ ա) դուրս գա ցիկլից:
Ցիկլից դուրս գալուց հետո դու կունենաս s-ի մեջ մինչև առաջին պարզ թիվը եղած տարրերի գումարը:
Հետո s=s+x[n] արա: Ու նորից ցիկլ բացի (n-1, 2) ու նույն բանը արա, ինչ նախորդ ցիկլում:
Ի դեպ՝ էն s=s+x[n] կարող ես չանել, բայց սկզբում s=x[1]-ի փոխարեն պիտի գրես s=x[1]+x[n] , ուղղակի սկզբում ըտենց գրեցի, որ պարզ լինի, սաղ չխառնվի իրար:

Արմեն ջան, դու էլ բլոկ-սխեմայում մի փոքր բացթողում ես արել
Բացի դրանից պարզ թվի որոշման մասն ունի երկրորդ (ավելի ճիշտ համարվող) տարբերակ` առանց ցիկլի բլոկի, պայմանի միջոցով, որ ծրագրում դառնա Repeat կամ While

[armen9494]

Program a170;
var x:array[1..10] of integer;
i,n,j,l,k,s,t:integer;
begin read(n);

for i:=1 to n do read (x[i]);
s:=0;
for i:=2 to n do t:=0;
for j:=2 to x[i]-1 do if x[i] mod j = 0 then begin t:=1; if t=0 then l:=j;
for i:=n to 2 do t:=0;
for j:=2 to x[i]-1 i do if x[i] mod j = 0 then t::=1 else if t:=0 then k:=j;
write(s:=(k+1)+(l-1));
end;
end.

Խորհուրդ կտամ մինչև ստեղ դնելը մի անգամ դիր Պասկալի մեջ ու տես, թե ոնց ա աշխատում: Ընդեղ մի երկու հատ կետերի ու ստորակետերի սխալներ կան, բայց կարծում եմ էդ էդքան կարևոր չի, որ գրես ընդեղ, ինքդ էլ կհասկանաս:
Ամենակարևոր բաներից մեկն ասեմ, ընդեղ բլոկ սխեմայի մեջ ուշադրություն չէի դարձրել, հիմա նկատեցի, խոսքը n-ի ներմուծման մասին ա: Քանի որ դու հայտարարում ես, որ վեկտորդ պիտի 10 տարր ունենա, ուրեմն պիտի նաև ապահովես, որ n-դ լինի ընկած [1,10] միջակայքում: Եվ քանի որ քո ծրագրում գոնե 4 թիվ պիտի լինի, էդ միջակայքը կդառնա [4,10]: Ծրագրում էդ կլինի սենց՝
repeat read(n) until (n>=4) and (n<=10);
եթե ուզում ես, կարող եմ բլոկ սխեման էլ էդ մասը գծել:

Հա, մեկ էլ write(s:=(k+1)+(l-1)); սա Պասկալում անիմաստություն ա, դու չես կարող արտածման ֆունկցիայի մեջ վերագրում անես: Դու կարո՞ղ ա c++ գիտես, որովհետև ընդեղ ա էս կարգի բաներ թույլատրվում:

Հլը կարող ենք չվռազել, ոնց որ Վարզորը ավելի լավ առաջարկ ունի:

[armen9494]

Արմեն ջան, դու էլ բլոկ-սխեմայում մի փոքր բացթողում ես արել
Բացի դրանից պարզ թվի որոշման մասն ունի երկրորդ (ավելի ճիշտ համարվող) տարբերակ` առանց ցիկլի բլոկի, պայմանի միջոցով, որ ծրագրում դառնա Repeat կամ While

Հնարավոր ա, դրա համար էլ գրեցի իմ կարծիքով ճիշտ եմ արել
Պարզ թվի պահով եթե չեմ սխալվում մի ձև կար, որ բաժանելով գալիս էինք մինչև էդ թվի կեսը, եթե մինչ այդ չեղավ, ուրեմն էլ չէր լինի: Եթե ճիշտ եմ հիշում, սենց ինչ-որ տարբերակ կար, բայց ես սրա բացատրությունը չգիտեմ, դրա համար չեմ գրել, հնարավոր ա նաև որ սխալվում եմ:

[Varzor]

Հնարավոր ա, դրա համար էլ գրեցի իմ կարծիքով ճիշտ եմ արել
Պարզ թվի պահով եթե չեմ սխալվում մի ձև կար, որ բաժանելով գալիս էինք մինչև էդ թվի կեսը, եթե մինչ այդ չեղավ, ուրեմն էլ չէր լինի: Եթե ճիշտ եմ հիշում, սենց ինչ-որ տարբերակ կար, բայց ես սրա բացատրությունը չգիտեմ, դրա համար չեմ գրել, հնարավոր ա նաև որ սխալվում եմ:

Այո, "մինչև կեսը" տարբերակը կա` դա ճիշտ է ու մաթեմատիկորեն հիմնավորված: Բացի այդ դասական տարբերակով դա չեն անում for ցիկլի միջոցով, այլ կիրառում են Whileև Repeat օպերատորները:

[armen9494]

Այո, "մինչև կեսը" տարբերակը կա` դա ճիշտ է ու մաթեմատիկորեն հիմնավորված: Բացի այդ դասական տարբերակով դա չեն անում for ցիկլի միջոցով, այլ կիրառում են Whileև Repeat օպերատորները:

իսկ for-ի ի՞նչն ա "վատ"

[Varzor]

իսկ for-ի ի՞նչն ա "վատ"

Վատի մասին չի խոսքը, խոսքը դասական ալգորիթմի մասին է: Զուտ բառերով էլ որ նկարագրում ես ալգորիթմը ու հետո թարգմանում բլոկ-սխեմայի` ցիկլի բլոկ չես ունենում:

[armen9494]

Վատի մասին չի խոսքը, խոսքը դասական ալգորիթմի մասին է: Զուտ բառերով էլ որ նկարագրում ես ալգորիթմը ու հետո թարգմանում բլոկ-սխեմայի` ցիկլի բլոկ չես ունենում:

Հասկացա ասածդ ինչ ա, ճիշտ ա, էդ դեպքու մի "առավելություն" էլ ունես՝ break չես օգտագործում: Ինձ չի թվում, որ դա մի եսիմինչ առավելություն ա, բայց երևի թե առանց դրա ավելի գրագետ ա: Չնայած էն դեպքում էլ կարաս break չօգտագործես, բայց դե ինչ որայա

[Varzor]

Հասկացա ասածդ ինչ ա, ճիշտ ա, էդ դեպքու մի "առավելություն" էլ ունես՝ break չես օգտագործում: Ինձ չի թվում, որ դա մի եսիմինչ առավելություն ա, բայց երևի թե առանց դրա ավելի գրագետ ա: Չնայած էն դեպքում էլ կարաս break չօգտագործես, բայց դե ինչ որայա

Բացի այդ պրոցեսորի տակտերի օգտագործման տեսանկյունից ավելի օպտիմալ է համարվում: Վախտին կոմպերը այսքան արագագործ չէին
Ըստ էության For I:=M to N Do Begn .... End; կոնստրուկցիան իրենից ներկայացնում է հետևյալ կոնստրուկտիվ հաջորդականությունը.

I:=M
Repeat
Begin
....
I:=I+1
End;
Until I<=N;

Սա էլ իր հերթին կառուցված է մոտավորապես այսպե
I:=M
Label: 10 If I < =N Then
Begin
....
I:=I+1
GoTo 10;
End;

Այս վերջին տարբերակն էլ հենց համարվում է ալգորիթմի դասական նկարագրությունը: Սակայն ծրագրավորման մեջ ձևավորված է մի ավանդույթ` անպայման անցման հրամաններից անհրաժեշտ է հնարավորինս խուսափել:

[armen9494]

Բացի այդ պրոցեսորի տակտերի օգտագործման տեսանկյունից ավելի օպտիմալ է համարվում: Վախտին կոմպերը այսքան արագագործ չէին
Ըստ էության For I:=M to N Do Begn .... End; կոնստրուկցիան իրենից ներկայացնում է հետևյալ կոնստրուկտիվ հաջորդականությունը.

I:=M
Repeat
Begin
....
I:=I+1
End;
Until I<=N;

Սա էլ իր հերթին կառուցված է մոտավորապես այսպես
I:=M
Label: 10 If I < =N Then
Begin
....
I:=I+1
GoTo 10;
End;

Այս վերջին տարբերակն էլ հենց համարվում է ալգորիթմի դասական նկարագրությունը: Սակայն ծրագրավորման մեջ ձևավորված է մի ավանդույթ` անպայման անցման հրամաններից անհրաժեշտ է հնարավորինս խուսափել:

Ճիշտն ասած՝ չգիտեի որ For-ը ավելի դանդաղ է աշխատում, քան նախապայմանով կամ հետպայմանով ցիկլը: Ճիշտն ասած էս վերջերս մի քիչ "քթի մազ" եմ դառել էդ արագության հարցով, միշտ ամեն մի խնդիր գրելիս առաջնային պայմաններից ա արագագործությունը (ծավալը երկրորդային ա): Վատը էն ա, որ շատ գործողությունների արագություններ (որը որից է արագ) չկան ոչ մի տեղ նշված (համենայն դեպս ես չեմ հանդիպել):
Այ էդ անցման հրամաններից խուսափելու ավանդույթը ըտենց էլ չսիրեցի, շատ տեղեր կա, որ կարաս շատ հեշտ goto-ով անես, բայց դա "թույլատրված չէ":
Ասում են, մթոմ դժվար գտնելու հետ է կապված, բայց դե ես չեմ կարծում, որ խնդիրը դրանում լինի:

[Varzor]

Ճիշտն ասած՝ չգիտեի որ For-ը ավելի դանդաղ է աշխատում, քան նախապայմանով կամ հետպայմանով ցիկլը: Ճիշտն ասած էս վերջերս մի քիչ "քթի մազ" եմ դառել էդ արագության հարցով, միշտ ամեն մի խնդիր գրելիս առաջնային պայմաններից ա արագագործությունը (ծավալը երկրորդային ա): Վատը էն ա, որ շատ գործողությունների արագություններ (որը որից է արագ) չկան ոչ մի տեղ նշված (համենայն դեպս ես չեմ հանդիպել):
Այ էդ անցման հրամաններից խուսափելու ավանդույթը ըտենց էլ չսիրեցի, շատ տեղեր կա, որ կարաս շատ հեշտ goto-ով անես, բայց դա "թույլատրված չէ":
Ասում են, մթոմ դժվար գտնելու հետ է կապված, բայց դե ես չեմ կարծում, որ խնդիրը դրանում լինի:

Հա, FOR-ը ավելի դանդաղ է աշխատում` չափումներ ենք արել
Արագ-դանդաղ կատարվելը կարելի է որոշել` ASSEMBLER-ի կոդը բացում ես ու որքան ավելի շատ տողեր կան մեջը, այդքան ավելի շատ գործողություններ են ատարվում` ավելի շատ պրոցեսորի տակտեր է օգտագործվում:
Իրոք` ոչ մի տեղ գրված չի, քանի որ դա կախված է կոնկրետ կոմպիլյատորից ու մենակ դրա հեղինակը կիմանա:
Շատ տեղեր կա, որ առանց GoTO ուղղակի անհնար է:
Խնդիրը կայանում էր հետևյալում.
յուրաքանչյուր ծրագրի համար համակարգչի հիշողությունում բացվում է ստեկ, որի մեջ էլ գրանցվում են փոփոխականները, կատարվող գործողությունները և այլն: GoTo-ի պարագայում լինում էին դեպքեր, որ ուղղակի կատարվող կոդի հատվածը դուրս էր մնում ստեկից ու կախվում էր: Հիմա այլևս տենց բա չկա: Սա տեխնիկական մասն է, բայց կա նաև մաթեմատիկական մասը: Եթե օգտագործել ես անպայման անցման հրամանը, ապա դա նշանակում է, որ օգտագործածդ ալգորիթմը մեծ հավանականությամբ վերանայման կարիք ունի` ինչ որ պայմանով կարելի էր բավարարվել:

Դե դժվար գտնելն էլ զուտ սուբեկտիվ գործոններից է` եթե label-ից GoTo հատվածը երկար է, եթե ծրագրի կոդում կան բազմաթիվ ցիկլեր: Պատկերացնում ես քանի հատ Label պիտի գրվի? ու եթե ասենք նախոր label-ը մի 1500 տող վերևում է, ապա դրա համարը հանկարծ չկրկնելու համար ստիպված ես լինում բարձրանալ վերև ու նայել

[MrKaren]

   Իրականացնել   տրված  ռեկուրենտ  առնչությունները ,  կառուցել  ստացված  մեծությունների գրաֆիկները :

ԱԼԳՈՐԻԹՄ-1

     1. α2=d1/c1 , α3=(d2-β2*b2)/Δ2 , αi+1=(di+βi*φi)/Δ i                         i=3, n-2

     2. β2=e1/c1 , βi-1=ei/ Δ i                                                                   i=2, n-3

     3. γ2=f1/c1 , γ 3=(f2+ γ2*b2)/ Δ 2 , γi+1=(fi-γi-1*ai-γi*φi)/Δi               i=3, n-1 
 
     4. Δ2=c2-α2*b2 ,  Δi=ci-βi-1*ai+αi*φi                                                 i=3 ,n-1
 
     5. φi=αi-1*ai-bi                                                                                 i=3, n-1

     6. yn-1=γn

     7. yn-2=αn-1*yn-1+γn-1

     8. yi=αi+1*yi+1-βi+1*yi+2+γi+1                                                     i=n-3, 1 




3    
   
       c1=29+12h/r12 ,   ci=30      i =2,n-2,   cn-1=29+h/rn-1                           Q=0.24

       ai=1-h/ri  i=3,n-1,   bi=8(2-h/ri)      i=2,n-1                                            a=0.513

       di=8(2+h/ri) i=1,n-2,   ei=1+h/ri   i=1,n-3                                              c=0.00025

        fi=48Qh2/πa2c2,  i=1,n-1 ,  ri=a+ih ,   i=1,n-1 ,    h=c/n 
 

Սենց բան հանդիպել է՞

Վերևում պահանջը սխալ է....

[armen9494]

Հա, FOR-ը ավելի դանդաղ է աշխատում` չափումներ ենք արել
Արագ-դանդաղ կատարվելը կարելի է որոշել` ASSEMBLER-ի կոդը բացում ես ու որքան ավելի շատ տողեր կան մեջը, այդքան ավելի շատ գործողություններ են ատարվում` ավելի շատ պրոցեսորի տակտեր է օգտագործվում:
Իրոք` ոչ մի տեղ գրված չի, քանի որ դա կախված է կոնկրետ կոմպիլյատորից ու մենակ դրա հեղինակը կիմանա:
Շատ տեղեր կա, որ առանց GoTO ուղղակի անհնար է:

իսկ մեզ ասում էին, որ յուրաքանչյուր GoTo կարելի է փոխարինել while-երով և /կամ/ repeat-երով:

Դե դժվար գտնելն էլ զուտ սուբեկտիվ գործոններից է` եթե label-ից GoTo հատվածը երկար է, եթե ծրագրի կոդում կան բազմաթիվ ցիկլեր: Պատկերացնում ես քանի հատ Label պիտի գրվի? ու եթե ասենք նախոր label-ը մի 1500 տող վերևում է, ապա դրա համարը հանկարծ չկրկնելու համար ստիպված ես լինում բարձրանալ վերև ու նայել

դե էդ էդքան էլ լուրջ խնդիր չեմ համարում, օգտագործելիս յուրաքանչյուր goto-ի կողքը կոմմենտի ձևով կարող ես գրել, թե որ տողում է label-ը:

[Varzor]

իսկ մեզ ասում էին, որ յուրաքանչյուր GoTo կարելի է փոխարինել while-երով և /կամ/ repeat-երով:

Այո, իհարկէ ցանկացած goto կարելի է փոխարինել ցիկլով ուղղակի դրանք կլինեն անիմաստ ցիկլիկ հրամաններ: Նույն հաջողությամբ կարելի է ամբողջ թվերով a:=b*c ի փոխարեն գրել a:=0; FOR i:=1 to b do a:=a+c; Էլի կաշխատի, սակայն քլունգ տարբերակ է:
Կոնկրետ օրինակ բերեմ?

դե էդ էդքան էլ լուրջ խնդիր չեմ համարում, օգտագործելիս յուրաքանչյուր goto-ի կողքը կոմմենտի ձևով կարող ես գրել, թե որ տողում է label-ը:

Դե արդեն իսկ գրել էի, որ դա սուբյեկտիվ պատճառ է: Մարդ կա տասնյակ հազարավոր ծրագրային կոդ է հիշում ()