Loops-ը թույլ է տալիս մի քանի անգամ կատարել մեկ կամ մի քանի տող կոդի: VBA-ն աջակցում է հետևյալ հանգույցներին.
For...Next For Every...Next Do... Loop
For կոնստրուկցիան. . . հաջորդ. Երբ կրկնությունների քանակը նախապես հայտնի է, օգտագործվում է For հանգույց: . . հաջորդ. For հանգույցն օգտագործում է փոփոխական, որը կոչվում է ցիկլ փոփոխական կամ ցիկլ հաշվիչ, որը յուրաքանչյուր անգամ կրկնվում է, երբ ավելանում կամ նվազում է որոշակի քանակով: Այս կառուցվածքի շարահյուսությունը հետևյալն է.
Հաշվիչի համար = սկիզբ Ավարտել Հաջորդ հայտարարությունները
Հաշվիչը (հաշվիչը), սկիզբը (ցիկլի սկիզբը), ավարտը (ցիկլի ավարտը) և աճը (աճը) թվային են:
Նշում. Աճման պարամետրը կարող է լինել ինչպես դրական, այնպես էլ բացասական: Եթե այն դրական է, սկզբի պարամետրը պետք է լինի ավարտի պարամետրից փոքր կամ հավասար, հակառակ դեպքում հանգույցը չի գործարկվի: Եթե աճի պարամետրը բացասական է, ապա սկզբի պարամետրը պետք է մեծ կամ հավասար լինի ավարտի պարամետրի արժեքին, որպեսզի գործարկվի օղակի մարմինը: Եթե «Քայլ» պարամետրը սահմանված չէ, ապա ավելացման պարամետրի լռելյայն արժեքը 1 է:
VBA-ն իրականացնում է For հանգույցը հետևյալ հաջորդականությամբ.
1. Սահմանում է հանգույցի փոփոխական հաշվիչը սկսելու համար:
2. Համեմատում է հանգույցի փոփոխական հաշվիչի արժեքը և վերջի պարամետրի արժեքը: Եթե հաշվիչի փոփոխականն ավելի մեծ է, VBA-ն ավարտում է օղակը: (Եթե աճող պարամետրի արժեքը բացասական է, ապա VBA-ն ավարտում է հանգույցը, եթե հանգույցի փոփոխական հաշվիչի արժեքը փոքր է վերջի պարամետրի արժեքից):
3. Կատարում է հանգույցի մարմնի հայտարարությունների հայտարարությունները:
4. Մեծացնում է ցիկլ փոփոխական հաշվիչի արժեքը 1-ով կամ ավելացման պարամետրի արժեքով, եթե տրված է մեկը:
5. Կրկնել 2-ից 4-րդ քայլերը:
Դիտարկենք օրինակ. Հաշվեք f(t) ֆունկցիայի արժեքը.
տրված է a, b, n, եթե t-ը a-ից b-ի փոխվում է Dt=(b-a)/(n-1) հավելումներով:
Ենթաօրինակ 3() Dim f() Որպես Single Dim a As Single, b As Single, t As Single, dt As Single Dim i Որպես ամբողջ թիվ, n Որպես ամբողջ թվով Կանչի ընթերցում ("a1", a) : Կանչի ընթերցում ("b1" , բ) . Զանգի ընթերցում ("c1", n) ReDim f(1-ից մինչև n - 1) dt = (b - a) / (n - 1) : t = a Զանգիր ("a2", "i") Call out("b2", "t") : Call out("c2", "f(t)") For i = 1 To n - 1 t = t + dt Եթե t<= -1 Then f(i) = -1 ElseIf t >1 Ապա f(i) = 1 Այլապես f(i) = t Ավարտել Եթե Կանչել ("a" & (2 + i), i) : Կանչել ("b" & (2 + i), t) : Զանգել out("c" & (2 + i), f(i)) Հաջորդ i End Sub
Յուրաքանչյուրի համար կառուցվածքը: . . Հաջորդը
Յուրաքանչյուր օղակի համար: . . Հաջորդը նման է For հանգույցի: . . Հաջորդը, բայց այն կրկնում է մի խումբ հայտարարություններ յուրաքանչյուր տարրի համար օբյեկտների մի շարքից կամ զանգվածից՝ հայտարարությունները մի քանի անգամ կրկնելու փոխարեն: Այն հատկապես օգտակար է, երբ չգիտես, թե քանի տարր կա հավաքածուի մեջ:
For Every Loop կառուցվածքի շարահյուսությունը: . . Հաջորդը.
Յուրաքանչյուր տարրի համար Խմբի հայտարարություններում Հաջորդ տարրը
«Յուրաքանչյուրի համար» օղակ օգտագործելիս նկատի ունեցեք հետևյալ սահմանափակումները: . . Հաջորդը:
Կոմպլեկտների համար տարրի պարամետրը կարող է լինել միայն տիպի տարբերակի փոփոխական, տիպի օբյեկտի ընդհանուր փոփոխական կամ Object Browser-ում թվարկված օբյեկտ։
Զանգվածների համար տարրի պարամետրը կարող է լինել միայն Variant տեսակի փոփոխական
Դուք չեք կարող օգտագործել «Յուրաքանչյուրի համար» օղակ: . . Հաջորդը օգտագործողի կողմից սահմանված տիպի զանգվածով, քանի որ տիպի տարբերակի փոփոխականը չի կարող պարունակել օգտագործողի կողմից սահմանված տիպի արժեք
Do...Loop դիզայն
Do հանգույցն օգտագործվում է հայտարարությունների բլոկը անսահմանափակ թվով անգամներ կատարելու համար: Կան Do կառուցվածքի մի քանի տարբերակներ: . . Loop, բայց նրանցից յուրաքանչյուրը գնահատում է պայմանական արտահայտություն՝ որոշելու, թե երբ պետք է դուրս գալ հանգույցից: Ինչպես If կառուցման դեպքում։ . . Այնուհետև պայմանը պետք է լինի արժեք կամ արտահայտություն, որը գնահատվում է False (զրո) կամ True (ոչ զրոյական):
Հետևյալ շինարարության մեջ Do . . . Օղակի հայտարարությունները կատարվում են այնքան ժամանակ, քանի դեռ պայմանի արժեքը True (True) է.
Do while Condition Loop-ի հայտարարություններ
Այս հանգույցն իրականացնելիս VBA-ն նախ ստուգում է պայմանը: Եթե պայմանը False է, ապա այն բաց է թողնում հանգույցի բոլոր հայտարարությունները: Եթե դա True է, VBA-ն կատարում է հանգույցի հայտարարությունները, նորից վերադառնում է Do while ցուցումին և նորից ստուգում պայմանը։
Հետևաբար, այս կոնստրուկտով ներկայացված օղակը կարող է իրականացվել ցանկացած թվով անգամ, քանի դեռ պայմանի արժեքը զրո կամ True չէ: Նկատի ունեցեք, որ օղակի մարմնի հայտարարությունները երբեք չեն կատարվում, եթե առաջին անգամ պայմանը ստուգվում է, պարզվում է, որ այն կեղծ է (False):
Դիտարկենք օրինակ. Հաշվի՛ր շարքի գումարը
տրված ճշգրտությամբ։
Ենթաօրինակ 4() Dim e As Single, x As Single, s As Single Dim M As Single, p As Single, i As Single Call read("a1", x) : Call read("b1", e) s = 0 : i = 1: m = 1: p = -1 Զանգահարեք ("a2", "i") : Կանչեք ("b2", "m") : Կանչեք ("c2", "s") Կատարեք մինչ Abs(m) >= e p = -p * x m = p / i s = s + m Call out("a" & (2 + i), i) : Call out("b" & (2 + i), Abs (m)) : Զանգահարեք ("c" & (2 + i), s) i = i + 1 Loop End Sub
Do կառուցվածքի մեկ այլ տարբերակ: . . Loop-ը նախ կատարում է հանգույցի մարմնի հայտարարությունները, այնուհետև յուրաքանչյուր կատարումից հետո ստուգում է վիճակը: Այս փոփոխությունը ապահովում է, որ հանգույցի մարմնի հայտարարությունները կատարվեն առնվազն մեկ անգամ.
Կատարեք հայտարարություններ Loop while պայման
Օղակի կառուցվածքի մյուս երկու տեսակները նման են նախորդներին, բացառությամբ, որ հանգույցը կատարվում է, մինչդեռ պայմանը false է (False).
Օղակը ընդհանրապես չի կատարվում կամ կատարվում է բազմիցս.
Կատարեք մինչև պայմանը
Օղակային հայտարարություններ
Օղակը կատարվում է առնվազն մեկ անգամ.
օպերատորներ
Օղակ Մինչև պայմանը
7.2 Ներդիր օղակներ.
Դուք կարող եք վերահսկիչ կառույցներ տեղադրել այլ հսկիչ կառույցների ներսում (օրինակ, եթե... Հետո արգելափակել For... Հաջորդ հանգույցի ներսում): Վերահսկիչ կառույցը, որը տեղադրված է մեկ այլ հսկիչ կառուցվածքի ներսում, ասում են, որ բույն է:
VBA-ում հսկիչ կառույցների բնադրման խորությունը սահմանափակված չէ: Կոդի ընթեռնելիությունը բարելավելու համար սովորական պրակտիկա է որոշման կառուցվածքի կամ հանգույցի մարմինը տեղափոխել ծրագրում, երբ օգտագործվում են վերահսկման ներդիր կառուցվածքներ:
Օղակի մեջ մեկ կամ մի քանի այլ օղակներ բնադրելիս խոսվում է բույնի օղակների մասին, որոնք տարբերում են արտաքին (փակող) և ներքին (ներդիր) օղակները։
Դիտարկենք A(n,m) մատրիցի Aij տարրերը տող առ տող գումարելու օրինակ:
Ենթակետ 5() Dim a() As Single, s() As Single Dim n Որպես ամբողջ թիվ, m Որպես Ամբողջ Թիվ Dim i Որպես Ամբողջ Թիվ, j Որպես Ամբողջ Թվով Կանչը կարդացվել է("a1", n): Կանչել կարդալ("b1", m ) ReDim a(1 To n, 1 To m), s(1 To n) «Կարդացեք մատրիցը i = 1 To n For j = 1 To m Զանգահարեք readcell(i + 1, j, a(i, j)) Հաջորդ j Հաջորդ i "Հաշվարկ For i = 1 To n s(i) = 0 For j = 1 To m s(i) = s(i) + a(i, j) Հաջորդ j Call outcell(i + 1, m + 1): , s(i)) Հաջորդ i Վերջ Ենթ
Նկատի ունեցեք, որ առաջին Next-ը փակում է ներքին For օղակը, իսկ վերջին Nextը փակում է արտաքին For օղակը: Նմանապես, nested If հայտարարությունների համար, End If հայտարարությունները ինքնաբերաբար կիրառվում են մոտակա If դրույթը փակելու համար: Բնադրված կառույցներ Do . . . Օղակներն աշխատում են նույն կերպ. ամենահեռավոր Loop-ը համապատասխանում է Do-ի ամենահեռավոր հայտարարությանը:
Microsoft Excel-ի աշխատաթերթի վրա երկչափ զանգվածի տարրերի մուտքագրման/արտադրման դեպքում հարմար է օգտագործել մուտքային/ելքային ընթացակարգեր.
Sub readcell(i Որպես ամբողջ թիվ, j Որպես ամբողջ թիվ, val Որպես տարբերակ) val = Leaf1.Cells(i, j).Արժեքի վերջ Ենթաբջջ (i Որպես ամբողջ թիվ, j Որպես ամբողջ թիվ, val Որպես տարբերակ) Leaf1.Cells(i, ժ) Արժեք = val Վերջ Ենթ
որտեղ I-ը տողի համարն է, j-ն աշխատաթերթի սյունակի համարն է:
Վերահսկիչ կառույցներից դուրս գալը
Exit հայտարարությունը թույլ է տալիս անմիջապես դուրս գալ For հանգույցից, Do հանգույցից, Sub պրոցեդուրայից կամ Function ընթացակարգից: Exit հայտարարության շարահյուսությունը պարզ է.
Հաշվիչի համար = սկիզբ Ավարտել [statement block] [statement block] Հաջորդը Կատարեք [(While | Մինչև) պայման] [statement block] [statement block] Loop
Ելք For-ի ներսում For-ի շրջանակում և Exit Do-ի ներսում Do-ի շրջանակում կարող են հայտնվել մի քանի անգամ:
Exit Do հայտարարությունը աշխատում է Do հանգույցի շարահյուսության բոլոր տատանումների հետ:
Exit For և Exit Do հայտարարություններն օգտագործվում են, երբ անհրաժեշտ է անհապաղ ավարտել հանգույցը՝ առանց հետագա կրկնությունները շարունակելու կամ ցիկլ մարմնում հայտարարությունների բլոկի կատարմանը սպասելու:
Օղակից դուրս գալու համար Exit հայտարարությունը օգտագործելիս, հանգույց փոփոխականի արժեքը կախված է նրանից, թե ինչպես է ավարտվում հանգույցը.
Երբ հանգույցը սովորաբար ավարտվում է, հանգույցի փոփոխականի արժեքը մեկով ավելի է, քան օղակների քանակի վերին սահմանը:
Երբ հանգույցը վաղաժամ ավարտվում է, հանգույց փոփոխականը պահպանում է իր արժեքը, որը ստացել է՝ հաշվի առնելով սովորական կանոնները.
Երբ հանգույցն ավարտվում է բազմության վերջում, հանգույցի փոփոխականը ոչինչ է, եթե այն օբյեկտի փոփոխական է, կամ դատարկ է, եթե այն Տարբերակ է:
Վերջին թարմացումը՝ 10/30/2015
Վերահսկիչ կառույցների մեկ այլ տեսակ օղակներն են: VB.NET-ն օգտագործում է մի քանի տեսակի օղակներ:
For...Next Loop
Այս հանգույցը կատարվում է որոշակի քանակությամբ անգամ, և այս թիվը սահմանվում է հաշվիչի կողմից.
For i As Integer = 1 To 9 Console.WriteLine(«(0)-ի քառակուսին (1) է», i, i * i) Հաջորդը
Այստեղ i փոփոխականը խաղում է հաշվիչի դեր։ Խոսքից հետո Դեպիմենք դնում ենք հաշվիչի առավելագույն արժեքը: Յուրաքանչյուր ցիկլով հաշվիչի արժեքը ավելանում է մեկով: Եվ այս արժեքը համեմատվում է հետո արժեքի հետ Դեպի. Եթե այս երկու արժեքները հավասար են, ապա հանգույցն ավարտվում է:
Օղակների հետ աշխատելիս յուրաքանչյուր անցումով կարող ենք մեծացնել հաշվիչի արժեքը ոչ միայն մեկով, այլ ընդհանրապես ցանկացած թվով։ Դա անելու համար դուք կամ պետք է օգտագործեք հիմնաբառը քայլև դրանից հետո նշեք հանգույցի քայլը, որով կմեծանա հաշվիչի արժեքը, կամ կարող եք մեծացնել հաշվիչը անմիջապես օղակում.
i-ի համար Որպես ամբողջ թիվ = 1-ից -9 Քայլ -1 j-ի համար որպես ամբողջ թիվ = 1-ից մինչև 9-ը Console.WriteLine(«i-ի և j-ի արտադրյալը (0) է», i * j) j += 1 Հաջորդ Հաջորդը
Նկատի ունեցեք, որ առաջին հանգույցում որպես քայլ ընտրվում է բացասական արժեք, և յուրաքանչյուր անցումով հաշվիչի արժեքը նվազում է մեկով: Ներքին օղակում j հաշվիչը ավելանում է 2-ով յուրաքանչյուր անցումի վրա, քանի որ այն լռելյայնորեն ավելանում է մեկով, իսկ մենք բացահայտորեն ավելացնում ենք այն մեկով օղակում: Արդյունքում ներքին օղակը աշխատում է հինգ անգամ, իսկ արտաքինը՝ ինը, այսինքն՝ փաստորեն ստացվում է 45 ցիկլ։
Յուրաքանչյուր...Հաջորդ հանգույցի համար
For Every հանգույցը կրկնվում է որոշակի խմբի տարրերի վրա, օրինակ՝ զանգվածի կամ հավաքածուի: Ենթադրենք, մենք ունենք Integer տիպի ինչ-որ զանգված, և մենք պետք է նախաստորագրենք այս զանգվածը պատահական արժեքներով և այնուհետև ցուցադրենք դրա բոլոր տարրերը էկրանին.
«Ստեղծեք հինգ թվերի զանգված Dim nums(4) As Integer Dim r As New Random() «initialize the array For i As Integer = 0 To nums.Length - 1 nums(i) = r.Next(100) Next" Ցուցադրել տարրերի զանգվածը Յուրաքանչյուր i-ի համար որպես ամբողջ թիվ թվերով Console.Write("(0)", i) Հաջորդը
For Every հայտարարության մեջ մենք նախ նշում ենք փոփոխական, որը կընդունի զանգվածի տարրերի արժեքները: Իսկ բանալի բառից հետո ՄեջՆշեք այն խումբը, որում ցանկանում եք տեսակավորել բոլոր տարրերը:
մինչդեռ հանգույց
while հանգույցում այն գործում է այնքան ժամանակ, քանի դեռ որոշակի պայման, որը նշված է while բառից հետո, բավարարվում է.
Dim j Որպես ամբողջ թիվ = 10 Մինչդեռ j > 0 Console.WriteLine(j) j -= 1 End while
Կատարեք հանգույց
Do հանգույցը, ինչպես while հանգույցը, գործում է այնքան ժամանակ, քանի դեռ բավարարված է որոշակի պայման: Այնուամենայնիվ, այն ունի տարբեր ձևեր. Այսպիսով, հետևյալ օրինակում նախ ստուգվում է պայմանը, այնուհետև գործարկվում է հանգույցում սահմանված կոդի բլոկը.
Dim j Որպես ամբողջ թիվ = 10 Do while j > 0 Console.WriteLine(j) j -= 1 Loop
Այս դեպքում օղակը կատարվում է, մինչդեռ j-ի արժեքը զրոյից մեծ է: Բայց կա մեկ այլ մուտք, որտեղ բառի փոխարեն օգտագործվում է while բառը մինչև, և հանգույցն իրականացվում է այնքան ժամանակ, մինչև բավարարվի որոշակի պայման, այսինքն՝ մինչև j-ի արժեքը զրոյից փոքր դառնա.
Dim j Որպես ամբողջ թիվ = 10 Արեք մինչև j< 0 Console.WriteLine(j) j -= 1 Loop
Եթե սկզբում հանգույցում նշված պայմանը false է, ապա հանգույցը չի աշխատի: Բայց մենք կարող ենք սահմանել ստուգում օղակի վերջում, և այդպիսով մեր հանգույցը կաշխատի առնվազն մեկ անգամ.
Dim j Որպես ամբողջ թիվ = -1 Do Console.WriteLine(j) j -= 1 հանգույց մինչև j< 0 "либо Do Console.WriteLine(j) j -= 1 Loop While j > 0
Շարունակել և դուրս գալ հայտարարություններից
Հաճախ անհրաժեշտություն է առաջանում ոչ թե սպասել ցիկլի ավարտին, այլ անմիջապես դուրս գալ ցիկլից, եթե բավարարված է որոշակի պայման։ Դա անելու համար օգտագործեք օպերատորը ելք, որին հաջորդում է հանգույցի տեսակը, որից պետք է դուրս գալ, օրինակ՝ Exit Do (Exit while):
Dim r Որպես նոր պատահական () Dim num Որպես ամբողջ թիվ = r. Հաջորդ (100) i-ի համար որպես ամբողջ թիվ = 0-ից մինչև 100 num -= 1 Եթե համարը< 50 Then Exit For Next Console.WriteLine(num)
Կա ևս մեկ խնդիր՝ դուրս գալ ոչ թե օղակից, այլ ընթացիկ անցումից կամ կրկնությունից և անցնել հաջորդին: Դա անելու համար օգտագործեք Continue հայտարարությունը, որից հետո նրանք նշում են օղակի տեսակը, որից կատարվում է ելքը, օրինակ՝ Continue while:
Dim r Որպես նոր պատահական () Dim num Որպես ամբողջ թիվ = r. Հաջորդ (100) i-ի համար որպես ամբողջ թիվ = 0-ից մինչև 10 num -= 7 Եթե համարը< 50 AndAlso num >25 Այնուհետև Continue For End If Console.WriteLine(num) Հաջորդը
Այս դեպքում, օղակի յուրաքանչյուր անցումում մենք հանում ենք 7 թիվը num-ից և այնուհետև տեսնում ենք, թե արդյոք num թիվը պատկանում է 25-ից մինչև 50 միջակայքին: Իսկ եթե այդպես է, մենք անցնում ենք օղակի նոր կրկնման, և եթե ոչ, մենք այն ցուցադրում ենք էկրանին:
Լաբորատոր աշխատանք ծրագրավորման հիմունքների վերաբերյալ
2.1. Անալիտիկորեն ներկայացված գործառույթների աղյուսակավորում
և զուգակցվում մոտակայքում
Օբյեկտիվ
· Տեսական գիտելիքների համախմբում ճյուղային և ցիկլային կառույցների կազմակերպման հիմունքների վերաբերյալ.
· Visual Basic համակարգում ճյուղավորվող և ցիկլային կառուցվածքների կիրառմամբ ծրագրավորման գործնական հմտությունների ձեռքբերում:
VB-ում կան երեք տեսակի հանգույց հայտարարություններ.
հաշվման ցիկլ. Համար… Դեպի… Հաջորդը
Օղակներ նախապայմաններով՝ Do while...Loop, Do Until...Loop, while…WEnd
Օղակներ հետպայմաններով՝ Do...Loop while, Do...Loop Until.
Հաշվիչ ցիկլ - թույլ է տալիս շրջել մի շարք հայտարարությունների միջով որոշակի քանակությամբ անգամներ: Դրա շարահյուսությունը հետևյալն է.
Համար հաշվիչ = ՍկսելԴեպի վերջ
[օպերատորներ]
[օպերատորներ]
Հաջորդ[ հաշվիչ]
Պարամետր հաշվիչթվային փոփոխական է (ամբողջ, իրական կամ Ամսաթիվ, Տարբերակ, Արժույթ), որը ավտոմատ կերպով ավելանում է յուրաքանչյուր կրկնությունից հետո: Սկզբնական արժեքը հաշվիչպարամետրին հավասար Սկսել,իսկ վերջնական պարամետրն է վերջ.Եթե նշված չէ, ապա քայլը համարվում է հավասար 1-ի, քայլի արժեքը կարող է փոխվել: Դա կարող է լինել դրական կամ բացասական թիվ:
Կան չորս շարահյուսական կառուցվածքներ Do….Loop:
Do...Loop հիմնաբառերի միջև եղած հայտարարությունները կատարվում են որոշակի քանակությամբ անգամ՝ կախված պայմանից: Օրինակ, ծրագրի հետևյալ հատվածում, երբ C = 100, պայմանը կկատարվի, և հանգույցը կմտնի: Օղակի ներսում ընթացակարգը կանչվում է, և C-ի արժեքը նվազում է 1-ով: Այնուհետև պայմանը կրկին ստուգվում է (C > 0) և հանգույցի հայտարարությունները կատարվում են բազմիցս (դրանք ընդհանուր առմամբ կկատարվեն 100 անգամ), մինչև C = 0. Երբ C > 0 պայմանը դառնում է կեղծ, և հանգույցը դադարում է:
Կատարեք մինչ C > 0
Ծրագրի նույն հատվածը, որն իրականացվում է 2-րդ շարահյուսության նախապայմանի հանգույցի միջոցով.
Այս դեպքում օղակը կատարվում է, մինչդեռ պայմանը False է, ի տարբերություն նախորդ դեպքի, այսինքն՝ այն շարունակվում է։ նախքան C = 0 պայմանի կատարում:
3-րդ և 4-րդ շարահյուսության հանգույցի հայտարարությունները շատ նման են առաջին երկուսին, բացառությամբ այն պայմանի ոչգնահատվում է այնքան ժամանակ, քանի դեռ հանգույցը չի գործել առնվազն մեկ անգամ:
Այս օղակների շարահյուսություններում դուք կարող եք օգտագործել Exit For և Exit Do օպերատորները հանգույցից անվերապահորեն դուրս գալու համար, ինչը թույլ է տալիս կառավարումը փոխանցել օղակի հետևում գտնվող օպերատորին: Օրինակ, ծրագրի հետևյալ հատվածում, եթե C-ի սկզբնական արժեքը >50 է, ապա հանգույցն անմիջապես կդադարի:
Կատարեք մինչև Ք<= 0
MsgBox «Սկսել. արժեքը թույլատրելիից մեծ է», «Մուտքի սխալ»
Մինչև...Վենդ հանգույցն օգտագործվել է Visual Basic-ի վաղ տարբերակներում: Դրա շարահյուսությունը հետևյալն է.
Մինչդեռ<условие>
<Операторы>
Ի տարբերություն Do..Loop-ի, while ..Wend հանգույցը չունի երկրորդ տարբերակ, որի դեպքում վիճակի թեստը կատարվում է օղակի վերջում։ Բացի այդ, այն չունի հանգույց ելքի հայտարարություն, ինչպիսին Exit Do-ն է:
VBA. Ցիկլերի կազմակերպում.
Loop-ի հայտարարությունները օգտագործվում են որոշակի քանակությամբ գործողությունների կամ գործողությունների խմբի կատարումը կրկնելու համար: Կրկնությունների քանակը (հանգույցի կրկնությունները) կարող են նախապես սահմանվել կամ հաշվարկվել:
VBA-ն աջակցում է երկու տեսակի հանգույցային կառուցվածքների.
- Օղակներ ֆիքսված թվով կրկնություններով ( ցիկլեր հաշվիչով).
- Օղակներ անորոշ թվով կրկնություններով ( պայմանական օղակներ).
Բոլոր տեսակի ցիկլերի համար օգտագործվում է հայեցակարգըհանգույց մարմին A, որը սահմանում է հայտարարությունների բլոկ, որը փակված է հանգույցի սկզբի և ավարտի հայտարարությունների միջև: Հանգույցի մարմնում հայտարարությունների յուրաքանչյուր կրկնություն կոչվում էկրկնություն.
Հաստատուն ցիկլեր
VBA-ն ապահովում է ֆիքսված հանգույց կազմակերպելու երկու հսկիչ կառուցվածք՝ For ... Next (հանգույց հաշվիչով) և For Every ... Next (հանգույց՝ թվարկումով):
Համար…Հաջորդ հայտարարությունը դա տիպիկ օղակ է հաշվիչով, որը կատարում է որոշակի թվով կրկնություններ: For … Հաջորդ հայտարարության շարահյուսությունը հետևյալն է.
Համար<счетчик> = <начЗначение>Դա<конЗначение>
<блок операторов>
Հաջորդ[<счетчик>]
For … Հաջորդ հայտարարության օգտագործման օրինակ:
Ցուցակում 1. … Հաջորդ հայտարարության համար
ՆՊԱՏԱԿԸ. Գրեք ծրագիր, որն օգտատերից ստանում է երկու թիվ:
Ավելացնում է այդ երկու թվերի կողմից տրված տիրույթի բոլոր թվերը և հետո
Ցուցադրում է ստացված գումարը:
Ենթատեսակ 7()
Dim i As Integer ‘loop counter
Dim sStart «սկսել հաշվիչի արժեքը
Dim sEnd ' հաշվչի վերջի արժեքը
Dim sSum As Long ‘արդյունք գումար
sStart = InputBox («Մուտքագրեք առաջին համարը:»)
sEnd = InputBox («Մուտքագրեք երկրորդ համարը:»)
sSum = 0
For i = CINT(sStart) To CINT(sEnd)
sSum = sSum + i
Հաջորդ i
MsgBox «« & sStart & » -ից մինչև « & sEnd & » թվերի գումարը հետևյալն է.
վերջ ենթ
Յուրաքանչյուր … Հաջորդ հանգույցի հայտարարության համարպատկանում է օբյեկտի տիպի օպերատորների կատեգորիային, այսինքն. վերաբերում է հիմնականում հավաքածուներինառարկաներ, ինչպես նաև զանգվածներ . Օղակի մարմինը կատարվում է ֆիքսված թվով անգամներ, որոնք համապատասխանում են զանգվածի կամ հավաքածուի տարրերի քանակին: Յուրաքանչյուր … Հաջորդ հայտարարության ձևաչափն է.
Յուրաքանչյուրի համար<элемент>Մեջ<группа> <блок операторов>Հաջորդ[<элемент>]
Պայմանական օղակներ (անորոշ օղակներ)
Պայմանական օղակները օգտագործվում են, երբ կրկնվող գործողությունները պետք է կատարվեն միայն որոշակի պայմաններում: Կրկնումների թիվը սահմանված չէ և ընդհանուր դեպքում կարող է հավասար լինել զրոյի (մասնավորապես՝ նախապայման ունեցող օղակների համար)։ VBA-ն ծրագրավորողներին առաջարկում է մի քանի հսկիչ կառույցներ՝ պայմանական օղակներ կազմակերպելու համար.
- Չորս տեսակի օղակներ Do..Loop, որոնք տարբերվում են ստուգվող պայմանի տեսակից և այս ստուգման կատարման ժամանակից:
- Անխափան Մինչ… Wend հանգույց:
Do while... Loop – Տիպիկ հանգույց նախապայմանով. Վիճակը ստուգվում է մինչև հանգույցի մարմինը գործարկվելը: Ցիկլը շարունակում է իր աշխատանքը մինչև այն<условие>կատարվում է (այսինքն՝ ճշմարիտ է): Քանի որ ստուգումը կատարվում է սկզբում, հանգույցի մարմինը երբեք չի կարող կատարվել: Do while… Loop:
Կատարեք Մինչդեռ<условие>
<блок операторов>
հանգույց
Ցուցակում 2. Կատարեք Մինչև… Հանգիստ
ՆՊԱՏԱԿ. Գրեք ծրագիր, որն ընդունում է օգտվողի մուտքը
Թվերի կամայական հաջորդականություն. Մուտքը պետք է դադարեցվի
Միայն այն բանից հետո, երբ մուտքագրված կենտ թվերի գումարը գերազանցի 100-ը։
Ենթ նմուշ 8()
Dim OddSum որպես ամբողջ թիվ
Dim OddStr Որպես կենտ թվերով տող
Dim Num 'մուտքագրված թվերն ընդունելու համար
OddStr = "" 'ելքային տողի սկզբնավորում
OddSum = 0 'OddSum գումարի սկզբնավորում
Do while OddSum< 100 ‘начало цикла
Num = InputBox («Մուտքագրեք համարը.»)
Եթե (Num Mod 2)<>0 Հետո «նույնիսկ հավասարություն
OddSum = OddSum + Num «կենտ թվերի գումարի կուտակում
OddStr = OddStr & Num & ”
Վերջ, եթե
հանգույց
«արտադրել կենտ թվերով տող
MsgBox հուշում:=”Կենտ թվեր՝ ” & OddStr
վերջ ենթ
Do...Loop while հայտարարությունընախատեսված կազմակերպման համարհանգույց հետպայմանով. Վիճակը ստուգվում է օղակի մարմինը առնվազն մեկ անգամ գործարկելուց հետո: Ցիկլը շարունակվում է մինչև<условие>մնում է ճշմարիտ. Do...Loop while ձևաչափը՝
Արեք<блок операторов>հանգույց իսկ<условие>
Ցուցակ 3. Օղակ հետպայմանով
ՆՊԱՏԱԿ. Կազմեք ծրագիր «Գուշակիր համարը» խաղի համար: Ծրագիրը պետք է պատահական լինի
Օգտագործողը պետք է 1-ից 1000 միջակայքում թվեր գեներացնի
«Գուշակիր այս թիվը։ Ծրագիրը ցուցադրում է ակնարկ յուրաքանչյուր մուտքագրված համարի համար:
' "Շատ թե քիչ".
Ենթ նմուշ 8()
Պատահական թվերի գեներատորի սկզբնավորումը Randomize Timer
Dim msg As String «հաղորդագրությունների տող
Dim Secret Number այնքան երկար, User Number As Variant
Սկիզբ՝ SecretNumber = Round (Rnd * 1000) ‘համակարգչից ստեղծված համար
UserNumber = Դատարկ՝ օգտագործողի կողմից մուտքագրված համարը
Կատարել խաղախաղ
Ընտրեք Case True
Case IsEmpty(UserNumber): msg = "Խնդրում ենք մուտքագրել թիվ"
Case UserNumber > SecretNumber. msg = «Շատ շատ»:
Գործի օգտագործողի համարը< SecretNumber: msg = “Слишком мало!”
Ավարտել Ընտրել
UserNumber = InputBox (prompt:=msg, Title:=”Guest the Number”)
Loop while UserNumber<>գաղտնի համարը
«փորձաքննություն
Եթե MsgBox («Ուզու՞մ եք նորից խաղալ», vbYesNo + vbQuestion, «Ճիշտ եք գուշակել») = vbԱյո, ապա
Գնալ Սկսել
Վերջ, եթե
վերջ ենթ
Կատարել մինչև … Loop և Do … Loop Until Loops նախկինում դիտարկված պայմանական օղակների շրջումներ են: Ընդհանուր առմամբ, նրանք աշխատում են նույն կերպ, բացառությամբ, որ հանգույցի մարմինը կատարվում է կեղծ պայմանով (այսինքն.<условие>= Սխալ): Do Until ... Loop-ի ձևաչափն է.
Արեք մինչև<условие> <блок операторов>հանգույց
Do… Loop Until-ի ձևաչափը հետևյալն է.
<блок операторов>
Օղակ Մինչև<условие>
Գործնական առաջադրանք.Վերագրեք ծրագրերը 10 և 11 ցուցակներում՝ օգտագործելով շրջված հանգույցի հայտարարությունները:
Մինչ Loop ... Wend վերաբերում է նաև պայմանական օղակներին: Այս հայտարարությունը լիովին համապատասխանում է Do while … Loop կառուցվածքին: Մինչ… Wend հանգույցի ձևաչափը հետևյալն է.
Մինչդեռ<условие>
<блок операторов>
Վենդ
Այս հայտարարության տարբերակիչ առանձնահատկությունը հանգույցի մարմնի հարկադիր դադարեցման (ընդհատման) անհնարինությունն է (Exit Do հայտարարությունը չի աշխատում while ... Wend հանգույցում):
Օղակի ընդհատում
Exit հայտարարությունը օգտագործվում է կրկնությունը ավարտելու և հանգույցից դուրս գալու համար: Այս հայտարարությունը կիրառելի է ցանկացած ցիկլային կառուցվածքում, բացառությամբ Մինչև ... Wend-ի: Օղակը կոտրելու համար Exit-ի օգտագործման ընդհանուր շարահյուսությունը հետևյալն է.
<начало_цикла>
[<блок операторов1>]
Ելք (For | Do)
[<блок операторов2>]
<конец_цикла>
Երբ Exit հայտարարությունը կատարվում է, հանգույցն ընդհատվում է, և վերահսկողությունը փոխանցվում է հայտարարությանը հաջորդող հայտարարությանը:<конец_цикла>. Օղակի մարմինը կարող է պարունակել մի քանի Exit հայտարարություններ:
Ցուցակ 4. Հարկադիր օղակի ելք
Ենթ նմուշ 9()
i = 1-ից 10000000-ի համար
Եթե i = 10, ապա Exit For ' դուրս եկեք օղակից, երբ հաշվիչը հասնում է 10-ի
Հաջորդը
Օպերատորի շարահյուսություն.
ՀամարՀաշվիչ= Սկսել ՏoՎերջ[քայլՔայլ]
Statement_Block
ՀաջորդըՀաշվիչ
Այստեղ նշված է.
Համար – համար (պարտադիր VB բանալի բառ);
Դեպի – նախքան (պարտադիր VB բանալի բառ);
Statement_Blockզանգել են մեկ կամ մի քանի օպերատորներ ցիկլի մարմին;
Հաշվիչ -ամբողջ թվով փոփոխական, որը հաշվում է կատարվող ցիկլերի քանակը.
Սկիզբ, վերջ -հաշվիչի նախնական և վերջնական արժեքները.
քայլ – քայլ (հիմնաբառ VB);
Քայլ -հաշվիչի փոփոխության քայլ; կարող է բացասական լինել; պարամետրը կամընտիր է, քանի որ եթե քայլը 1 է, կարող եք Քայլ Քայլավելի ցածր;
Հաջորդը - հաջորդը (պարտադիր VB բանալի բառ, հանգույցի վերջի հայտարարության գրառում):
Հակարժեք (Սկիզբ, ավարտ)կարող է լինել Թվային հաստատունները կամ փոփոխականները ամբողջ կամ իրական տիպի կարող են լինել բացասական կամ դրական թվեր: Որպեսզի հանգույցի մարմինը կատարվի առնվազն մեկ անգամ, այն պետք է լինի Սկիզբ ≤ Ավարտ,եթե Քայլ> 0 և Սկիզբ ≥ Ավարտ,եթե Քայլ< 0. Հենց պարզվի, որ Հաշվիչ>Վերջ (եթե Սկսել< Конец), հանգույցի կատարումն ավարտվում է: Եթե Սկսել =Վերջ,հանգույցը կկատարվի մեկ անգամ;
Օրինակ 9.1 .Գործառույթների գնահատումՅ = 2 – 1.5 sinxX-ը միջակայքում 0,2 աստիճանով փոխելու դեպքում:
Y-ի հաշվարկման և X արգումենտի և Y ֆունկցիայի դուրսբերման ծրագրի մի հատված.
X = 0-ից 2.4-ի համար Քայլ 0.2
Y = 2 - 1,5 * Sin (X)
Հասկանալու համար, թե ինչպես է աշխատում այս օղակը, ահա մի ծրագիր նմանատիպ օղակի համար, որը ստեղծվել է օգտագործելով օպերատորգնալ, պիտակներ, օպերատորԵթե… Հետո.
M1:X=X+0.2
Եթե X<= 2.4 Then
Y = 2 - 1,5 * Sin (X)
Եկեք վերլուծենք, թե ինչպես է աշխատում այս ծրագիրը: Առաջին Y հաշվարկը ոչ ստանդարտ է, ասես, դուրս է գալիս հանգույցից: Օղակը սկսվում է GoToM1 կառավարման առաջին փոխանցումից հետո M1 պիտակին: M1 պիտակավորված տողում X արգումենտն ավելանում է 0,2 քայլով և անմիջապես ստուգվում է, թե արդյոք X-ի նոր արժեքը չի գերազանցում վերջնական 2,4 արժեքը: Եթե այն չի գերազանցում, ապա Y-ի հաշվարկը կրկնվում է այս նոր X-ով: Այնուհետև նորից գործարկվում է GoToM1 օպերատորը` փոխանցելով կառավարումը M1 պիտակով գծին: Y-ի հաշվարկման այս կրկնությունները (ցիկլերը) կավարտվեն հենց որ X-ը գերազանցի 2.4-ը:
Այժմ Եթե ծրագիրը համեմատելի է For…Next օղակի հետ:
X = 0-ից 2.4-ի համար Քայլ 0.2
փոխարինում է երկու տողով
M1:X=X+0.2
Եթե X<= 2.4 Then
Դա կոդի վերջին երկու տողերն են, որոնք կատարվում են For օղակում, բայց մենք դա չենք տեսնում: Մենք դրանք կոդավորեցինք cFor տողով... GoTo M1 կոդի տողը կոդավորված է Next X բառով (բառացի՝ հաջորդ X): Սա հանգեցնում է կոմպակտ դիզայնի:
For…Next հանգույցն օգտագործելիս դուք պետք է սովորեք, թե ինչպես օգտագործել հանգույցի հաշվիչը՝ տարբեր խնդիրներ լուծելիս: Պարզելու համար, թե ինչպես կարող եք օգտագործել հաշվիչը խնդիրը լուծելու համար, դուք պետք է վերլուծել խնդրի հայտարարությունը, գտնել խնդրի որոշ պարամետրերի փոփոխության օրինաչափություններ:
Օրինակ 9.2 . Շարքի տարրերի գումարի որոշում.
Ծրագրի հատված.
S = 0 ‘S-ը շարքի գումարն է
i = 1-ից մինչև 16 ‘-ի համար i-ը կոտորակի հայտարարն է
S = S + 1/i ‘ կուտակային գումար
Տպել «S="; S ‘ S գումարի ելքը ձևին
i հաշվիչի յուրաքանչյուր արժեքի համար 1/i արտահայտությունը հաջորդաբար կազմում է շարքի տարրերը՝ սկսած 1-ից։
Օրինակ 9.3
.
Մի շարք տարրերի գումարի հաշվարկ 
.
Ծրագրի հատված.
S = 0 ‘S-ը շարքի գումարն է
i = 1-ից 18-ի համար i - համարիչ
S = S + i/(i + 1) ' հայտարարը համարիչից մեծ է 1-ով
Տպել «S="; S ‘ S գումարի ելքը ձևին
Օրինակ 9.4 . Գումարի հաշվարկ՝ 5 + 8 + 11 + ... + 32 + 35
Ծրագրի հատված.
S = 0 ‘S-ը շարքի գումարն է
i = 5-ից 35-ի համար Քայլ 3 ‘ ստանալ թվաբանություն _
առաջընթաց հայտարար 3-ով
Տպել «S="; Ս
Օրինակ 9.5. Տրված x-ի գումարի հաշվարկը.
Խնդրի վերլուծությունը ցույց է տալիս, որ X-ի աստիճանը փոխվում է 1-ից մինչև 10: Այս դեպքում X-ի գործակցի համարիչը աստիճանից մեծ է 1-ով, իսկ հայտարարը 2-ով: Կձևավորվի աստիճանի արժեքը: օգտագործելով հաշվիչ i. Այնուհետև կարող եք գրել հետևյալ ծրագիրը (հատված).
S = 1 ‘S-ը շարքի գումարն է
i = 1-ից 10-ի համար որպես i հաշվիչ, աստիճանը փոխվում է X-ում
S = S + (-1)^i*(i + 1)*x^i / (i + 2)
Տպել «S="; Ս
ՑիկլերՀամար… Հաջորդըօգտագործվում էմուտքագրում, ելք ևզանգվածի մշակում .
Օրինակ 9.6. Զանգվածի տարրերի արժեքների մուտքագրում և ելք B(Ն).
Ծրագրի հատված.
Բաց թողնել N արժեքի վերագրումը փոփոխականին, _
մուտքագրված ձևի վրա տեքստային դաշտում txtN:
B(i) = InputBox ("Մուտքագրեք տարրը B(" & i & ")", _
«Մուտքային զանգված B(» & N & «)»))
տպել ""; B (i);
Գործառույթ InputBox() ցուցադրում է երկխոսության տուփ փակման կոճակով, տվյալ հաղորդագրությամբ, մուտքագրման դաշտով, կոճակներով լավ,Չեղարկել,վերնագիր (կամ առանց դրա): Եթե մուտքագրված է 12 թիվը՝ N զանգվածի չափը, ապա մեր օրինակում, առաջին հայտնվելիս, այս պատուհանը նման կլինի.
Ինչպես տեսնում եք, հաղորդագրությունը Մուտքագրեք տարրը B(1)հուշում է ձեզ տեքստային վանդակում մուտքագրել 1-ին տարրի արժեքը: Այս պատուհանը կհայտնվի 12 անգամ, քանի որ զանգվածը պարունակում է 12 տարր: Սա հետևում է ձևի վերնագրից: Հուշում B(i) տարրի ինդեքսը տատանվում է 1-ից մինչև 12:
Եթե ձևի վրա պահանջվում է ցուցադրել միայն B(N) զանգվածի տարրերի արժեքները, ապա հանգույցի մարմինը բաղկացած կլինի մեկ հայտարարությունից.
Զանգվածի տարրերը դրանց վրա որոշակի գործողություններ կատարելու համար դիտելը նույնպես տեղի է ունենում For…Next հանգույցի օպերատորի միջոցով:
Եկեք բերենք միաչափ զանգվածների մշակման օրինակներ.
Օրինակ 9.7 . B զանգվածում առավելագույն տարրի որոշումըՄ).
Բացառելով նախնական տվյալների մուտքագրումը և արդյունքների ելքը, մենք համառոտ նկարագրում ենք ալգորիթմը.
Հայտարարենք Bmax փոփոխականը, որում մուտքագրենք զանգվածի առաջին տարրի արժեքը, իսկ Imax փոփոխականը, որին վերագրենք 1՝ զանգվածի առաջին տարրի ինդեքսը։
Օղակում, օգտագործելով For…Next օպերատորը, մենք նայում ենք զանգվածի բոլոր տարրերին՝ սկսած 2-րդից: Օգտագործելով If…Then օպերատորը, մենք համեմատում ենք դրանց արժեքները Bmax փոփոխականում պահվող արժեքի հետ:
Եթե պարզվում է, որ զանգվածի տարրի արժեքը մեծ է Bmax-ից, ապա Bmax-ին վերագրվում է այս տարրի արժեքը, իսկ Imax-ի արժեքը այս զանգվածի տարրի ինդեքսն է։
Շրջանակի ավարտից հետո Bmax փոփոխականը կպարունակի առավելագույն տարրի արժեքը, իսկ Imax-ը՝ իր ինդեքսը (թիվը):
Ալգորիթմի այս մասի ծրագիրը.
Bmax = B(1): Imax = 1
Եթե B(i) > Bmax Ապա Bmax = B(i): Imax = i
Օրինակ 9.8. Դրական զանգվածի տարրերի գումարի, արտադրյալի և քանակի որոշումԴ(Մ).
Փոփոխականներ: S, P, K դրական տարրերի գումարը, արտադրյալը և թիվը համապատասխանաբար:
Ալգորիթմայս սահմանումը.
Մենք զրո ենք վերագրում S և K փոփոխականին, վերագրում ենք 1 P փոփոխականին: Որպես կանոն, այն փոփոխականները, որտեղ կուտակված է գումարը, այստեղ այն S և k է, զրոյացվում են ցիկլից առաջ, իսկ այն փոփոխականները, որոնցում արտադրանքը հաշվարկվում է, նշանակվում է 1.
Օգտագործելով For…Next օղակը, մենք անցնում ենք զանգվածի բոլոր տարրերը և ստուգում, թե արդյոք դրանք դրական են (D(i) > 0):
Եթե պարզվում է, որ տարրը դրական է, ապա դրա արժեքը ավելացնում ենք S գումարի արժեքին և նոր գումարը պահում նույն փոփոխականում։ Մենք P փոփոխականը բազմապատկում ենք տարրի դրական արժեքով և այն պահում ենք նաև P փոփոխականում։ Իսկ K փոփոխականին ավելացնում ենք 1 և նոր արժեքը պահում նույն փոփոխականում
ԾրագիրԱլգորիթմի այս հատվածն ունի հետևյալ տեսքը.
S=0՝ P=1՝ K=0
Եթե D(i) > 0 Ապա
S = S + D(i) ‘ ահա թե ինչպես է գումարի կուտակումը _
Զանգվածի տարրերի դրական արժեքները D(i)
P = P*D(i) «դրականի արտադրյալի սահմանում
«զանգվածի տարրեր
K = K + 1 ‘ այս օպերատորը կոչվում է COUNTER, ահա այն
- որոշում է զանգվածի դրական տարրերի քանակը
Օրինակ 9.9. Կենտ զանգվածի տարրերի գումարի, արտադրյալի, թվի և միջինի որոշումԴ(Մ).
Ներկայացնում ենք նման սահմանման ծրագրի մի հատված.
S=0՝ P=1՝ K=0
Եթե D(i) Mod 2<>0 Հետո
Ssr = S/k ‘ կենտ տարրերի միջինի հաշվարկ
Համեմատեք ծրագրի այս հատվածը օրինակ 9.8-ի ծրագրի հետ: Այս ծրագիրը գրեթե ամբողջությամբ կրկնում է նախորդը։ Փոխվել է միայն If դրույթի պայմանը: Վիճակ D(i) Mod 2<>0 նշանակում է, որ մենք փնտրում ենք D(i) զանգվածի տարրեր, որոնք նույնիսկ չեն բաժանվում 2-ի, այսինքն՝ կենտ տարրերի: Եթե ստուգենք D(i) Mod 2 = 0 պայմանը, ապա կընտրենք զանգվածի զույգ տարրեր։
Ինչպես գիտեք, բաժանում ՊՆարդյունքում տալիս է ամբողջ թվերով բաժանման մնացորդը։ Օրինակ, d= 34Mod4 օպերատորը կատարելուց հետո d փոփոխականը հավասար կլինի 2-ի: Հետևաբար, 4-ի բազմապատիկ զանգվածի տարրեր ընտրելու համար անհրաժեշտ է ստուգել D(i) Mod 4 = 0 պայմանը: լինել նման, եթե մենք փնտրում ենք այլ թվերի բազմապատիկ տարրեր: 4-ի փոխարեն գրվելու են այս մյուս թվերը։
Օրինակ 9.10. Զանգվածի տարրեր գրելըՌ(Ն) բաժանվում է 5-ի մեկ այլ զանգվածի և ցուցադրում նոր զանգվածը ձևի վրա:
Մյուս զանգվածը կնշանակվի, օրինակ, R5(N): Այս նոր զանգվածի չափը պետք է ընդունվի նույնը, ինչ սկզբնականը, քանի որ սահմանային դեպքում բոլոր տարրերը կարող են լինել 5-ի բազմապատիկ:
Առաջադրանքի ալգորիթմ.
Մենք զրոյացնում ենք հաշվիչը k. Օգտագործելով For…Next հանգույց օպերատորը, մենք նայում ենք R(N) զանգվածի բոլոր տարրերին:
Մենք ստուգում ենք յուրաքանչյուր տարր 5-ի բազմակիության համար՝ օգտագործելով If…Then օպերատորը և զանգվածի տարրը բաժանելով Mod-ի:
Եթե տարրը 5-ի բազմապատիկ է, ապա օգտագործելով k=k+ 1-ի նման հաշվիչը, 1-ից սկսած ձևավորում ենք R5(N) զանգվածի ինդեքսները և գրում այս մյուս զանգվածում՝ R5(N):
Եթե k-ն զրոյական չէ, ապա ելքագրեք arrayR5() ձևը:
Եթե k-ը հավասար է զրոյի, մենք ելնում ենք. «Չկան 5-ի բազմապատիկ տարրեր»:
Ծրագրի հատված.
Եթե R(i) Mod 5 Ապա k = k + 1: R5(k) = R(i)
Եթե կ<>0 Հետո
Տպել «5-ի բաժանվող տարրեր չկան»
Օղակները կարող են տեղադրվել այլ օղակների մեջ:
Եկեք ցուցադրենք աշխատանքը nened loops . Ստորև ծրագիրը կազմակերպում է i, j և k ցիկլի հաշվիչների արժեքների ելքը: i,j,k-ի ելքից պարզ է դառնում, թե ինչպես են կատարվում ներդիր օղակները։
Մասնավոր ենթաբաժին frmCycle_DblClick()
ScaleMode = 4 'միավոր - խորհրդանիշներ
i = 1-ից 3 ‘արտաքին հանգույցի համար
Տպել «i =»; ես;
j = 1-ից 4 «1-ին ներդիր հանգույցի համար
CurrentX = TextWidth («i = 1») + 5
Տպել «j="; ժ;
CurrentX = TextWidth («i = 1 j = 1») + 7
k = 1-ից մինչև 5 ‘2-րդ ներդիր հանգույցի համար
Ցուցադրված ձևը (նկ. 1) ցույց է տալիս բոլոր երեք օղակների հաշվիչների ցուցադրման արդյունքները՝ արտաքին հանգույց՝ հաշվիչ i, առաջին ներդիր օղակը՝ counterj և երկրորդ, ամենաներքին օղակը՝ հաշվիչը։ Ինչպես տեսնում ենք, արտաքին հանգույցի «ամենադանդաղ» հաշվիչը(poi), և «Ամենաարագը» ամենաներքին օղակի հաշվիչն է (ըստկ).
Ծրագիրը կատարվում է frmCicli ձևի վրա մկնիկի ձախ կոճակով կրկնակի սեղմելուց հետո:
CurrentX, CurrentY - ձևի հատկություններ, որոնք նշում են սկզբնական կետի X, Y կոորդինատները Տպման մեթոդով տեղեկատվության ելքի համար (տես X և Y առանցքների գտնվելու վայրը նկ. 1-ի ձևի վրա):
TextWidth()-ը ֆունկցիա է, որը վերադարձնում է ֆունկցիայի մեջ տրված տեքստի լայնությունը որպես արգումենտ կրկնակի չակերտներով։
Ներդրված օղակները օգտագործվում են երկչափ զանգվածներ (մատրիցաներ) մշակելիս։ Բայց որոշ առաջադրանքներում, բացառելով երկչափ զանգվածի տարրերի մուտքն ու ելքը, կարող եք սահմանափակվել մեկ ցիկլով: Դիտարկենք մատրիցային ծրագրավորման որոշ օրինակներ:
Օրինակ 9.11. Ամբողջ թվերի մատրիցայի (երկչափ զանգված) մուտքագրում և ելքինտԱ(Ն).
Դուք կարող եք մուտքագրել մատրիցա ըստ տողերի և սյունակների . Ավելի հեշտ է՝ տող առ տող, եթե զանգվածի տարրերի ելքը դեպի ձև կծրագրավորվի դրանց մուտքագրումից անմիջապես հետո։
Մատրիցային մուտքագրում և ելքտող առ տող - հատված 1.
Dim M Որպես ամբողջ թիվ, N որպես ամբողջ թիվ, i որպես ամբողջ թիվ, j որպես ամբողջ թիվ
Dim intA() Որպես Integer ‘ հայտարարում է դինամիկ զանգված
M = Val(txtN.Text) ‘M-ը տողերի թիվն է
N = Val(txtN.Text) ‘ N-ը սյունակների թիվն է
ReDim intA(M, N) Որպես Integer «վերորոշեք զանգվածը
i = 1 To M-ի համար ես կպահպանեմ դրա արժեքը մինչև ամբողջովին
j-ի վրա տեղադրված հանգույցը չի կատարվի
տպել ""; intA (i, j); «տող առ տող ելք
Տպել՝ ցատկել նոր տողի սկիզբ
Մատրիցը ըստ սյունակների մուտքագրելու համար անհրաժեշտ է j-ի վրա արտաքին օղակը (սահմանում է սյունակների համարները), իսկ ներքին օղակը i-ի վրա (սահմանում է տողերի համարները):
Մատրիցային մուտքագրում և ելքըստ սյունակների – հատված 2.
PrY = 2500. CurrentY = PrY ' PrY սահմանում է մեկնարկի Y կոորդինատը
«ձևի վրա թողարկեք յուրաքանչյուր սյունակի առաջին տարրը
j = 1-ի համար To N ‘ j-ը կպահի իր արժեքը մինչև ամբողջությամբ
«nested loop on i-ի վրա չի կատարվի
intA (i, j) = InputBox ("Մուտքագրեք տարրը intA(" & i & "," & j & ")", _
«Մատրիցային մուտքագրում intA (» & M & «», & N & «)»)
Տպել ներդիր (6 * j); intA(i, j) ‘ ցուցադրել ըստ սյունակների
CurrentY = PrY ' առաջին տարրը ցուցադրելու համար
«Հաջորդ սյունակ
Ծրագրի այս երկրորդ հատվածը չի կրկնում առաջին հատվածի առաջին 5 տողերը։ Tab(6 * j) ֆունկցիան սահմանում է ելքի սկիզբը տողի վրա (նիշերով)՝ սկսած ձևի ձախ եզրից: PrY կոորդինատն այստեղ 2500 twips է, բայց դուք կարող եք ընտրել մեկ այլ արժեք:
Օրինակ 9.12 . Զանգվածի տարրերի արժեքների պատվիրումՎ(Ն) Աճող.
Զանգվածներ պատվիրելու մի քանի ալգորիթմներ կան։ Ահա դրանցից մեկը. օգտագործելով ներդիր օղակներՀամար… Հաջորդըընտրել տարրեր առաջինից մինչև նախավերջին և համեմատել դրանցից յուրաքանչյուրը հաջորդ տարրերի հետ. եթե պարզվի, որ հաջորդ տարրը ընտրվածից փոքր է, փոխեք դրանք:
Ծրագրի մի հատված, որն իրականացնում է այս ալգորիթմը.
i = 1-ից N - 1-ի համար
j = i + 1-ի համար Ն
Եթե V(j)< V(i) Then P = V(i): V(i) = V(j): V(j) = P
Եկեք բացատրենք ծրագրի այս հատվածը.
i հաշվիչով արտաքին օղակի օգնությամբ ընտրում ենք V(i) տարրը՝ հաջորդ տարրերի հետ համեմատելու համար։ j հաշվիչով ներքին օղակը համեմատության համար ընտրում է V(j)-ի հաջորդ տարրերը: j-ի սկզբնական արժեքը i + 1 է: Սա հետևյալի առաջին տարրն է:
V(i) և V(j) տարրերի արժեքները փոխանակելու համար մենք ներկայացնում ենք մի քանի փոփոխական P, որի մեջ ժամանակավորապես «թաքցնում ենք» զանգվածի տարրերից մեկի արժեքը (ծրագրում սա V(i է): )): Այնուհետև V(i) տարրին վերագրվում է V(j) տարրի արժեքը, իսկ V(j) տարրին վերագրվում է V(i) արժեքը, որը պահվում է P փոփոխականում: Եթե մենք «թաքցնենք» V(j) արժեքը P-ում, ապա արժեքի փոխանակման կոդը կլինի հետևյալը. P = V(j): V(j) = V(i): V(i) = P: արդյունքը չի փոխվի.
Դեպի դասավորել զանգվածը նվազման կարգով, բավական է ստուգման պայմանը գրել V(j) > V(i) ձևով, այսինքն՝ անհավասարության նշանը փոխել մեկ այլով։
Եթե զանգվածը թվային չէ, այլ տողային է, և զանգվածի տարրերը լցված են ազգանուններով, ապա օրինակ 9.12-ի ծրագրի միջոցով կարող եք տեսակավորել ազգանունների ցանկը այբբենական կարգով։ Բանն այն է, որ համակարգչում օգտագործվող այբուբենի տառերի համար անհավասարությունները ճիշտ են՝ Ա< Б < В < Г….< Я и т. д., поскольку числовые коды букв алфавита последовательно увеличиваются, начиная с А и до конца алфавита. Это же справедливо и для букв английского алфавита.
Օրինակ 9.13 . Մատրիցայի կենտ սյունակների համար դրական տարրերի գումարի հաշվարկՖ(Մ, Ն) և ձևաթղթի վրա ցուցադրելով գումարները:
Ծրագրի ալգորիթմ.
Օգտագործելով 2 քայլով արտաքին օղակ, մենք կազմում ենք մատրիցայի կենտ սյունակների ինդեքսը՝ սկսած առաջին սյունակից։
Մենք զրոյացնում ենք S գումարը, որում կկուտակվի դրական տարրերի գումարը։
Ներքին օղակում մենք ստուգում ենք զանգվածի տարրի նշանը։
Եթե զանգվածի տարրը դրական է (> 0), ապա հաշվարկեք S գումարը:
Ներքին օղակի ավարտից հետո ձևաթղթին դուրս բերեք S գումարը:
Հատված ծրագրերը:
j = 1-ի համար դեպի N Քայլ 2
Եթե F(i, j) > 0, ապա S = S + F(i, j)
Տպել «Սյունակի գումարը»; ժ; ":"; S ' j-ը սյունակի համարն է:
Ներդրված օղակները թույլ են տալիս կազմակերպել տարբերակների թվարկում և լուծել խնդիրները, որոնք հնարավոր չէ լուծել վերլուծական եղանակով: Թվարկման արդյունքում ստացվում են լուծումներ, որոնցից ընտրվում են խնդրի պայմանին համապատասխանող մեկը կամ մի քանիսը։
Օրինակ 9.14. Առկա է 1801 ռուբլի։ Քանի՞ շոկոլադ կարելի է գնել 31 ռուբլով: և 18 ռուբլով ռուլետ՝ ամբողջ գումարը ամբողջությամբ ծախսելու համար։
Ծրագիր:
Գումար = 1801
Բոլոր շոկոլադները = Գումար \ 31: Բոլոր բլիթները = Գումար \ 18
i = 1-ի համար բոլոր շոկոլադներին
j = 1-ի համար AllBulki-ին
Գին = i * 31 + j * 18 ‘ընդհանուր գնման գին
Եթե Գինը = 1801 Ապա
Տպել «Շոկոլադ. ես; Ներդիր (19); «Բուլոկ:»; ժ
Եկեք բացատրենք այն ծրագիրը, որտեղ մենք օգտագործում ենք ռուսերեն անվանվող փոփոխականներ:
Նախ, մենք որոշում ենք, թե որն է միայն շոկոլադների կամ միայն ռուլետների առավելագույն քանակը, որոնք կարելի է գնել ամբողջ գումարով: VseChocolate-ի և VseBulki-ի ստացված արժեքներն օգտագործվում են որոնումների քանակը սահմանափակելու համար շոկոլադների և ռուլետների քանակով: Շոկոլադների քանակի (i) և ռուլետների (j) քանակի յուրաքանչյուր արժեքի համար մենք որոշում ենք դրանց գնման ընդհանուր գինը: Եթե հաշվարկված Գինը 1801 է, ապա ընտրված տարբերակը խնդրի լուծումներից մեկն է։
Tab() ֆունկցիան սահմանում է, թե ձևի եզրից որ դիրքում կցուցադրվեն այս գործառույթին հաջորդող տեղեկատվությունը: Եթե Tab(19), ապա 19-րդ հորիզոնականից։
Ծրագիրը ցուցադրում է գնման 3 հնարավոր տարբերակ.
Շոկոլադներ 7, ռուլետներ 88
Շոկոլադներ 25, ռուլետներ 57
Շոկոլադներ 43, ռուլետներ 26
Եթե ուզում եք միանշանակ պատասխան տալ, պետք է լրացուցիչ պայման ձեւակերպեք. Օրինակ՝ «ավելի քիչ բլիթ են գնել, քան շոկոլադ»։ Այդ դեպքում միակ լուծումը կլինի 3-րդ տարբերակը։
Կան բազմաթիվ մաթեմատիկական խնդիրներ, որոնք պարզապես լուծվում են ներդիր հանգույցի ծրագրավորման միջոցով կրկնելով:
