მარყუჟები საშუალებას გაძლევთ მრავალჯერ შეასრულოთ კოდის ერთი ან მეტი ხაზი. VBA მხარს უჭერს შემდეგ მარყუჟებს:
For...Next For Every...Next Do... Loop
For კონსტრუქცია. . . შემდეგი. როდესაც გამეორებების რაოდენობა წინასწარ არის ცნობილი, გამოიყენება For loop. . . შემდეგი. ციკლი 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 როგორც Single Dim i როგორც მთელი რიცხვი, n როგორც მთელი რიცხვი Call read("a1", a) : ზარის წაკითხვა("b1" , ბ) : ზარის წაკითხვა ("c1", n) ReDim f(1-დან n - 1-მდე) dt = (b - a) / (n - 1) : t = a გამოძახება ("a2", "i") : გამოძახება ("b2", "t") : გამოძახება ("c2", "f(t)") იყიდება i = 1-მდე 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 ბოლო ქვე
თითოეული კონსტრუქცია. . . შემდეგი
თითოეული მარყუჟისთვის. . . შემდეგი არის For მარყუჟის მსგავსი. . . შემდეგი, მაგრამ ის იმეორებს განცხადებების ჯგუფს თითოეული ელემენტისთვის ობიექტების ნაკრებიდან ან მასივიდან, იმის ნაცვლად, რომ გაიმეოროს განცხადებები მოცემული რაოდენობის ჯერ. განსაკუთრებით სასარგებლოა, როცა არ იცი, რამდენი ელემენტია ნაკრებში.
For Every loop კონსტრუქციის სინტაქსი. . . შემდეგი არის:
თითოეული ელემენტისთვის ჯგუფის განცხადებებში შემდეგი ელემენტი
გაითვალისწინეთ შემდეგი შეზღუდვები ყოველი მარყუჟის გამოყენებისას. . . შემდეგი:
კომპლექტებისთვის, ელემენტის პარამეტრი შეიძლება იყოს მხოლოდ ტიპის ვარიანტის ცვლადი, ობიექტის ტიპის ზოგადი ცვლადი ან ობიექტი, რომელიც ჩამოთვლილია ობიექტის ბრაუზერში.
მასივებისთვის ელემენტის პარამეტრი შეიძლება იყოს მხოლოდ Variant ტიპის ცვლადი
თქვენ არ შეგიძლიათ გამოიყენოთ თითოეული ციკლი. . . შემდეგი მომხმარებლის მიერ განსაზღვრული ტიპის მასივით, რადგან ტიპის ვარიანტის ცვლადი არ შეიძლება შეიცავდეს მომხმარებლის მიერ განსაზღვრულ ტიპის მნიშვნელობას
გააკეთე... მარყუჟის დიზაინი
Do loop გამოიყენება განცხადებების ბლოკის შესასრულებლად შეუზღუდავი რაოდენობის ჯერ. Do კონსტრუქციის რამდენიმე ვარიაცია არსებობს. . . მარყუჟი, მაგრამ თითოეული მათგანი აფასებს პირობით გამოხატულებას, რათა დადგინდეს, როდის უნდა გამოვიდეს ციკლიდან. როგორც If კონსტრუქციის შემთხვევაში. . . მაშინ პირობა უნდა იყოს მნიშვნელობა ან გამონათქვამი, რომელიც ფასდება False (ნულოვანი) ან True (არა-ნულოვანი).
შემდეგ მშენებლობაში, დო . . . მარყუჟის განცხადებები შესრულებულია მანამ, სანამ პირობის მნიშვნელობა არის 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) : ზარის წაკითხვა("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 (მ)) : გამოძახება ("c" & (2 + i), s) i = i + 1 მარყუჟის ბოლო ქვე
Do კონსტრუქციის კიდევ ერთი ვარიაცია. . . Loop ჯერ ასრულებს მარყუჟის სხეულის განცხადებებს და შემდეგ ამოწმებს მდგომარეობას ყოველი შესრულების შემდეგ. ეს ვარიაცია უზრუნველყოფს მარყუჟის სხეულში განცხადებების შესრულებას ერთხელ მაინც:
განაცხადების გაკეთება Loop while პირობა
მარყუჟის კონსტრუქციის დანარჩენი ორი სახეობა წინა მსგავსია, გარდა იმისა, რომ მარყუჟი შესრულებულია, ხოლო პირობა არის false (False):
მარყუჟი საერთოდ არ არის შესრულებული ან შესრულებულია ბევრჯერ:
გააკეთე მდგომარეობამდე
მარყუჟის განცხადებები
მარყუჟი შესრულებულია ერთხელ მაინც:
ოპერატორები
ციკლი მდგომარეობამდე
7.2 წყობილი მარყუჟები.
თქვენ შეგიძლიათ განათავსოთ საკონტროლო სტრუქტურები სხვა საკონტროლო სტრუქტურებში (მაგალითად, If . . . . შემდეგ დაბლოკვა For . . . შემდეგი მარყუჟის შიგნით). საკონტროლო სტრუქტურა, რომელიც მოთავსებულია სხვა საკონტროლო სტრუქტურის შიგნით, ნათქვამია, რომ ბუდირებულია.
VBA-ში საკონტროლო სტრუქტურების ბუდეების სიღრმე შეზღუდული არ არის. კოდის წაკითხვის გასაუმჯობესებლად, ჩვეულებრივი პრაქტიკაა გადაწყვეტილების კონსტრუქციის ან მარყუჟის ნაწილის გადატანა პროგრამაში, როდესაც გამოიყენება წყობილი საკონტროლო სტრუქტურები.
მარყუჟში ერთი ან რამდენიმე სხვა მარყუჟის მობუდვისას საუბარია წყობილ მარყუჟებზე, რომლებიც განასხვავებენ გარე (შემკრავს) და შიდა (ბუდე) მარყუჟებს.
განვიხილოთ A(n,m) მატრიცის Aij ელემენტების მწკრივი მწკრივის შეჯამების მაგალითი.
ქვემაგალითი5() Dim a() As Single, s() As Single Dim n როგორც მთელი რიცხვი, m როგორც მთელი რიცხვი Dim i როგორც მთელი რიცხვი, j როგორც მთელი რიცხვი Call read("a1", n): ზარის წაკითხვა("b1", m ) ReDim a(1-დან n-მდე, 1-დან m-მდე), s(1-დან n-მდე) "მატრიცის წაკითხვა i = 1-დან n-მდე j = 1-დან m-მდე გამოძახება readcell(i + 1, j, a(i, j)) შემდეგი j შემდეგი i "გაანგარიშება i = 1-მდე n s(i) = 0-მდე j = 1-მდე m s(i) = s(i) + a(i, j) შემდეგი j გამოძახება outcell(i + 1, m + 1 , s(i)) შემდეგი i ბოლო ქვე
გაითვალისწინეთ, რომ პირველი Next ხურავს შიდა For მარყუჟს, ხოლო ბოლო Next ხურავს გარე For მარყუჟს. ანალოგიურად, ჩასმული If განცხადებებისთვის, End If განცხადებები ავტომატურად გამოიყენება უახლოეს If განცხადების დახურვისთვის. წყობილი სტრუქტურები დო . . . მარყუჟები მუშაობენ ანალოგიურად: ყველაზე შორს Loop განცხადება შეესაბამება ყველაზე შორეულ Do განცხადებას.
Microsoft Excel-ის სამუშაო ფურცელზე ორგანზომილებიანი მასივის ელემენტების შეყვანისას/გამოტანისას, მოსახერხებელია შეყვანის/გამომავალი პროცედურების გამოყენება:
Sub readcell(i როგორც მთელი რიცხვი, j როგორც მთელი რიცხვი, val როგორც ვარიანტი) val = Leaf1.Cells(i, j). Value End Sub Sub outcell(i როგორც მთელი რიცხვი, j როგორც მთელი რიცხვი, val როგორც ვარიანტი) Leaf1.Cells(i, კ).მნიშვნელობა = val ბოლო ქვე
სადაც I არის მწკრივის ნომერი, j არის სამუშაო ფურცლის სვეტის ნომერი.
საკონტროლო სტრუქტურების დატოვება
Exit განაცხადი საშუალებას გაძლევთ გახვიდეთ პირდაპირ For loop, Do loop, Sub პროცედურა ან Function პროცედურა. Exit განცხადების სინტაქსი მარტივია:
მრიცხველისთვის = დაწყება დასასრულამდე [განცხადების ბლოკი] [განცხადების ბლოკი] შემდეგი გააკეთეთ [(While | სანამ) მდგომარეობა] [განცხადების ბლოკი] [განცხადების ბლოკი] მარყუჟი
გასასვლელი For შიგნით For მარყუჟის შიგნით და Exit Do შიგნით Do loop შეიძლება გამოჩნდეს რამდენჯერმე.
Exit Do განცხადება მუშაობს Do loop სინტაქსის ყველა ვარიაციით.
Exit For და Exit Do განცხადებები გამოიყენება მაშინ, როდესაც აუცილებელია მარყუჟის დაუყოვნებლივ დასრულება, შემდგომი გამეორებების გაგრძელების გარეშე ან ციკლის სხეულში განცხადებების ბლოკის შესრულების გარეშე.
როდესაც იყენებთ Exit განცხადებას ციკლიდან გასასვლელად, ციკლის ცვლადის მნიშვნელობები დამოკიდებულია იმაზე, თუ როგორ მთავრდება ციკლი:
როდესაც ციკლი ნორმალურად მთავრდება, მარყუჟის ცვლადის მნიშვნელობა არის ერთით მეტი მარყუჟების რაოდენობის ზედა ზღვარზე.
როდესაც ციკლი ნაადრევად წყდება, მარყუჟის ცვლადი ინარჩუნებს თავის მნიშვნელობას, რომელიც მან მიიღო ჩვეულებრივი წესების გათვალისწინებით.
როდესაც ციკლი მთავრდება ნაკრების ბოლოს, მარყუჟის ცვლადი არის Nothing, თუ ის ობიექტის ცვლადია, ან Empty, თუ ის არის Variant.
ბოლო განახლება: 10/30/2015
საკონტროლო სტრუქტურების კიდევ ერთი ტიპია მარყუჟები. VB.NET იყენებს რამდენიმე სახის მარყუჟს.
შემდეგი მარყუჟისთვის
ეს ციკლი შესრულებულია რამდენჯერმე და ეს რიცხვი დგინდება მრიცხველის მიერ:
იყიდება i როგორც მთელი რიცხვი = 1-დან 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 ციკლი იმეორებს ელემენტებს კონკრეტულ ჯგუფში, როგორიცაა მასივი ან კოლექცია. დავუშვათ, რომ გვაქვს მთელი რიგის ტიპის გარკვეული მასივი და გვჭირდება ამ მასივის ინიციალიზაცია შემთხვევითი მნიშვნელობებით და შემდეგ ეკრანზე გამოვაჩინოთ მისი ყველა ელემენტი:
"შექმენით ხუთი რიცხვის მასივი Dim nums(4) როგორც მთელი რიცხვი Dim r როგორც ახალი შემთხვევითი() "დაიწყეთ მასივი For i როგორც მთელი რიცხვი = 0 to nums. სიგრძე - 1 nums(i) = r. შემდეგი (100) შემდეგი " ელემენტების მასივის ჩვენება თითოეული i-სთვის, როგორც მთელი რიცხვი რიცხვებში Console.Write("(0)", i) შემდეგი
ინსტრუქციაში For Every, ჩვენ ჯერ ვაზუსტებთ ცვლადს, რომელიც მიიღებს მასივის ელემენტების მნიშვნელობებს. და საკვანძო სიტყვის შემდეგ Inმიუთითეთ ჯგუფი, რომელშიც გსურთ დაალაგოთ ყველა ელემენტი.
ხოლო მარყუჟი
while მარყუჟში ის ახორციელებს მანამ, სანამ გარკვეული პირობა, რომელიც მითითებულია while სიტყვის შემდეგ, დაკმაყოფილებულია:
Dim j როგორც მთელი რიცხვი = 10 while 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 Do სანამ j< 0 Console.WriteLine(j) j -= 1 Loop
თუ თავდაპირველად ციკლში მითითებული პირობა მცდარია, მაშინ ციკლი არ იმუშავებს. მაგრამ ჩვენ შეგვიძლია განვსაზღვროთ შემოწმება მარყუჟის ბოლოს და ამგვარად, ჩვენი ციკლი ერთხელ მაინც იმუშავებს:
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.Next(100) For i როგორც მთელი რიცხვი = 0-დან 100-მდე num -= 1 თუ num< 50 Then Exit For Next Console.WriteLine(num)
არის კიდევ ერთი დავალება - გახვიდეთ არა მარყუჟიდან, არამედ მიმდინარე უღელტეხილიდან ან გამეორებიდან და გადახვიდეთ შემდეგზე. ამისათვის გამოიყენეთ Continue განცხადება, რის შემდეგაც ისინი მიუთითებენ მარყუჟის ტიპზე, საიდანაც კეთდება გასასვლელი, მაგალითად, Continue while:
Dim r როგორც ახალი შემთხვევითი() Dim num როგორც მთელი რიცხვი = r.Next(100) იყიდება i როგორც მთელი რიცხვი = 0-დან 10-მდე num -= 7 თუ num< 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 ხდება false და ციკლი ჩერდება.
გააკეთეთ სანამ C > 0
იგივე პროგრამის ფრაგმენტი შესრულებულია წინაპირობის მარყუჟის გამოყენებით სინტაქსში 2:
ამ შემთხვევაში მარყუჟი შესრულებულია მაშინ, როდესაც პირობა არის False, წინა შემთხვევისგან განსხვავებით, ანუ ის გრძელდება. ადრეპირობის შესრულება C = 0.
მარყუჟის განცხადებები სინტაქსში 3 და 4 ძალიან ჰგავს პირველ ორს, გარდა იმ პირობისა არაფასდება მანამ, სანამ მარყუჟი ერთხელ მაინც არ შესრულდება.
ამ მარყუჟების სინტაქსებში შეგიძლიათ გამოიყენოთ ოპერატორები Exit For და Exit Do ციკლიდან უპირობოდ გასასვლელად, რაც საშუალებას მოგცემთ გადასცეთ კონტროლი მარყუჟის უკან მდებარე ოპერატორს. მაგალითად, პროგრამის შემდეგ ფრაგმენტში, თუ C-ის საწყისი მნიშვნელობა არის >50, მაშინ ციკლი მაშინვე შეჩერდება.
გააკეთეთ სანამ C<= 0
MsgBox "დაწყება. მნიშვნელობა დაშვებულზე მეტია“, „შეყვანის შეცდომა“
while...Wend ციკლი გამოიყენებოდა Visual Basic-ის ადრეულ ვერსიებში. მისი სინტაქსი შემდეგია:
ხოლო<условие>
<Операторы>
Do..Loop-ისგან განსხვავებით, while ..Wend მარყუჟს არ აქვს მეორე ვარიანტი, რომელშიც მდგომარეობის ტესტი ტარდება ციკლის ბოლოს. გარდა ამისა, მას არ აქვს მარყუჟის გასასვლელი განცხადება, როგორიცაა Exit Do.
VBA. ციკლების ორგანიზება.
მარყუჟის განცხადებები გამოიყენება მოქმედების ან მოქმედებების ჯგუფის შესრულების გასამეორებლად რამდენჯერმე. გამეორებების რაოდენობა (მარყუჟის გამეორება) შეიძლება წინასწარ განისაზღვროს ან გამოითვალოს.
VBA მხარს უჭერს ორი სახის მარყუჟის კონსტრუქციას:
- მარყუჟები ფიქსირებული რაოდენობის გამეორებით ( ციკლები მრიცხველით).
- მარყუჟები გამეორებების განუსაზღვრელი რაოდენობით ( პირობითი მარყუჟები).
ყველა ტიპის ციკლისთვის, კონცეფცია გამოიყენებამარყუჟის სხეული A, რომელიც განსაზღვრავს განცხადებების ბლოკს, რომელიც ჩასმულია მარყუჟის დასაწყისსა და დასასრულს შორის. მარყუჟის სხეულში განცხადებების ყოველი გამეორება ეწოდებაგამეორება .
ფიქსირებული ციკლები
VBA უზრუნველყოფს ორ საკონტროლო სტრუქტურას ფიქსირებული მარყუჟის ორგანიზებისთვის: For ... Next (მარყუჟი მრიცხველით) და For Every ... Next (ციკლი ჩამოთვლით).
იყიდება…შემდეგი განცხადება ეს არის ტიპიური ციკლი მრიცხველით, რომელიც ასრულებს გამეორებების მოცემულ რაოდენობას. For … შემდეგი განცხადების სინტაქსი არის:
ამისთვის<счетчик> = <начЗначение>რომ<конЗначение>
<блок операторов>
შემდეგი[<счетчик>]
For … შემდეგი განცხადების გამოყენების მაგალითი.
ჩამონათვალი 1. იყიდება … შემდეგი განცხადება
მიზანი: დაწერეთ პროგრამა, რომელიც მიიღებს ორ რიცხვს მომხმარებლისგან.
ამ ორი რიცხვით მოცემულ დიაპაზონში ამატებს ყველა რიცხვს და შემდეგ
' აჩვენებს მიღებულ თანხას.
ქვე ნიმუში7()
Dim i როგორც მთელი რიცხვის ციკლის მრიცხველი
Dim sStart 'დაწყების მრიცხველის მნიშვნელობა
მრიცხველის ბოლო მნიშვნელობის Dim sEnd
Dim ssum As Long ‘შედეგი ჯამი
sStart = InputBox ("შეიყვანეთ პირველი ნომერი:")
sEnd = InputBox ("შეიყვანეთ მეორე ნომერი:")
ssum = 0
იყიდება i = CINT(sStart) To Cint(sEnd)
ssum = ssum + i
შემდეგი ი
MsgBox „ციფრების ჯამი ” & sStart & ”-დან ” & sEnd & ”-მდე არის: ” & ssum
დასასრული ქვე
თითოეული … შემდეგი მარყუჟის განცხადებამიეკუთვნება ობიექტის ტიპის ოპერატორების კატეგორიას, ე.ი. ძირითადად ეხება კოლექციებსობიექტები, ისევე როგორც მასივები . მარყუჟის სხეული შესრულებულია ფიქსირებული რაოდენობის ჯერ, რაც შეესაბამება მასივის ან კოლექციის ელემენტების რაოდენობას. თითოეული … შემდეგი განცხადების ფორმატი არის:
თითოეული<элемент>In<группа> <блок операторов>შემდეგი[<элемент>]
პირობითი მარყუჟები (განუსაზღვრელი მარყუჟები)
პირობითი მარყუჟები გამოიყენება, როდესაც განმეორებითი მოქმედებები უნდა შესრულდეს მხოლოდ გარკვეულ პირობებში. გამეორებების რაოდენობა არ არის განსაზღვრული და ზოგად შემთხვევაში შეიძლება იყოს ნულის ტოლი (კერძოდ, წინაპირობის მქონე მარყუჟებისთვის). VBA დეველოპერებს სთავაზობს რამდენიმე საკონტროლო სტრუქტურას პირობითი მარყუჟების ორგანიზებისთვის:
- ოთხი ტიპის მარყუჟები Do..Loop, რომლებიც განსხვავდება შემოწმებული მდგომარეობის ტიპით და ამ შემოწმების შესრულების დროით.
- უწყვეტი ხოლო … Wend loop.
Do while... Loop - ტიპიური მარყუჟი წინაპირობით. მდგომარეობა მოწმდება მარყუჟის სხეულის შესრულებამდე. ციკლი აგრძელებს თავის მუშაობას მანამდე<условие>შესრულებულია (ანუ არის True). ვინაიდან შემოწმება შესრულებულია დასაწყისში, მარყუჟის სხეული შეიძლება არასოდეს შესრულდეს. Do while … ციკლის ფორმატი:
გააკეთე სანამ<условие>
<блок операторов>
მარყუჟი
ჩამონათვალი 2. Do while … Loop
მიზანი: დაწერეთ პროგრამა, რომელიც მიიღებს მომხმარებლის შეყვანას
რიცხვების თვითნებური თანმიმდევრობა. შესვლა უნდა შეწყდეს
მხოლოდ მას შემდეგ, რაც შეყვანილი კენტი რიცხვების ჯამი 100-ს გადააჭარბებს.
ქვე ნიმუში8()
Dim OddSum როგორც მთელი რიცხვი
Dim OddStr როგორც სტრიქონი კენტი რიცხვებით
Dim Num 'შეყვანის ნომრების მისაღებად
OddStr = "" 'გამომავალი სტრიქონის ინიციალიზაცია
OddSum = 0 'OddSum ჯამის ინიციალიზაცია
Do while OddSum< 100 ‘начало цикла
Num = InputBox ("შეიყვანეთ ნომერი:")
თუ (Num Mod 2)<>0 მაშინ „თუნდაც პარიტეტი“.
კენტი ჯამი = კენტი ჯამი + რიცხვი კენტი რიცხვების ჯამის დაგროვება
OddStr = OddStr & Num & ”
Დაასრულე თუ
მარყუჟი
"გამოიტანე კენტი რიცხვებით სტრიქონი
MsgBox მოთხოვნა:=”კენტი ნომრები: ” & OddStr
დასასრული ქვე
Do...Loop while განცხადებაორგანიზაციისთვის განკუთვნილიმარყუჟი პოსტკონდიციით. მდგომარეობა მოწმდება მას შემდეგ, რაც მარყუჟის სხეული ერთხელ მაინც შესრულდება. ციკლი გრძელდება მანამ<условие>რჩება ჭეშმარიტი. Do...Loop while ფორმატი:
Კეთება<блок операторов>loop ხოლო<условие>
ჩამონათვალი 3. Loop ერთად postcondition
მიზანი: შექმენით პროგრამა თამაშისთვის "გამოიცანი რიცხვი". პროგრამა უნდა იყოს შემთხვევითი
მომხმარებელმა უნდა შექმნას რიცხვი 1-დან 1000-მდე დიაპაზონში
"გამოიცანი ეს რიცხვი. პროგრამა აჩვენებს მინიშნებას თითოეული შეყვანილი ნომრისთვის.
' "მეტი ან ნაკლები".
ქვე ნიმუში8()
შემთხვევითი რიცხვების გენერატორის ინიციალიზაცია ტაიმერის რანდომიზება
ჩამქრალი msg როგორც სტრიქონი ' შეტყობინების სტრიქონი
Dim SecretNumber როგორც ხანგრძლივი, UserNumber როგორც ვარიანტი
დასაწყისი: SecretNumber = მრგვალი (Rnd * 1000) ' კომპიუტერის გენერირებული ნომერი
მომხმარებლის ნომერი = ცარიელი ' მომხმარებლის მიერ შეყვანილი ნომერი
გააკეთეთ თამაში
აირჩიეთ Case True
Case IsEmpty(UserNumber): msg = "გთხოვთ შეიყვანოთ ნომერი"
Case UserNumber > SecretNumber: msg = "ძალიან ბევრი!"
საქმე მომხმარებლის ნომერი< SecretNumber: msg = “Слишком мало!”
დასრულება აირჩიეთ
UserNumber = InputBox (მოთხოვნა:=msg, სათაური:=”გამოიცანი ნომერი”)
Loop while UserNumber<>საიდუმლო ნომერი
'გამოკვლევა
თუ MsgBox("გსურთ ხელახლა თამაში?", vbYesNo + vbQuestion, "სწორად გამოიცანით!") = vbYes მაშინ
გადასვლა დასაწყებად
Დაასრულე თუ
დასასრული ქვე
გააკეთეთ სანამ … მარყუჟი და გააკეთეთ … მარყუჟი სანამ მარყუჟები არის ადრე განხილული პირობითი მარყუჟების ინვერსიები. ზოგადად, ისინი მუშაობენ ანალოგიურად, გარდა იმისა, რომ მარყუჟის სხეული შესრულებულია ცრუ პირობებში (ე.ი.<условие>= ცრუ). Do სანამ ... მარყუჟის ფორმატი არის:
გააკეთე სანამ<условие> <блок операторов>მარყუჟი
Do … Loop Until-ის ფორმატი არის:
<блок операторов>
მარყუჟი სანამ<условие>
პრაქტიკული დავალება:გადაწერეთ პროგრამები სიაში 10 და 11 ინვერსიული მარყუჟის განცხადებების გამოყენებით.
მიუხედავად იმისა, რომ Loop ... Wend ასევე ვრცელდება პირობით მარყუჟებზე. ეს განცხადება სრულად შეესაბამება Do while … მარყუჟის სტრუქტურას. while … Wend მარყუჟის ფორმატი არის:
ხოლო<условие>
<блок операторов>
ვენდი
ამ განცხადების გამორჩეული თვისებაა მარყუჟის სხეულის იძულებითი შეწყვეტის (შეწყვეტის) შეუძლებლობა (Exit Do განცხადება არ მუშაობს while ... Wend ციკლში).
მარყუჟის შეწყვეტა
Exit განცხადება გამოიყენება გამეორების დასასრულებლად და ციკლიდან გასასვლელად. ეს განცხადება გამოიყენება ნებისმიერ ციკლურ სტრუქტურაში, გარდა სანამ ... Wend. ციკლის გასაწყვეტად Exit-ის გამოყენების ზოგადი სინტაქსია:
<начало_цикла>
[<блок операторов1>]
გასვლა (for | Do)
[<блок операторов2>]
<конец_цикла>
როდესაც Exit განცხადება შესრულებულია, ციკლი წყდება და კონტროლი გადაეცემა განცხადების შემდეგ განცხადებას.<конец_цикла>. მარყუჟის სხეული შეიძლება შეიცავდეს რამდენიმე Exit განცხადებას.
ჩამონათვალი 4. იძულებითი მარყუჟის გასასვლელი
ქვე ნიმუში9()
i = 1-დან 10000000-მდე
თუ i = 10, მაშინ Exit For ' გამოდით ციკლიდან, როდესაც მრიცხველი მიაღწევს 10-ს
შემდეგი
ოპერატორის სინტაქსი:
ამისთვისმრიცხველი= დაწყება თოᲓასასრული[ნაბიჯინაბიჯი]
განცხადება_ბლოკი
შემდეგიმრიცხველი
აქ აღნიშნულია:
ამისთვის – ამისთვის (სავალდებულო VB საკვანძო სიტყვა);
რომ – ადრე (სავალდებულო VB საკვანძო სიტყვა);
განცხადება_ბლოკიდარეკა ერთი ან მეტი ოპერატორი ციკლის სხეული;
მრიცხველი -მთელი ცვლადი, რომელიც ითვლის შესასრულებელი ციკლების რაოდენობას;
დასაწყისი, დასასრული -მრიცხველის საწყისი და საბოლოო მნიშვნელობები;
ნაბიჯი – ნაბიჯი (საკვანძო სიტყვა VB);
ნაბიჯი -მრიცხველის შეცვლის ნაბიჯი; შეიძლება იყოს უარყოფითი; პარამეტრი არჩევითია, რადგან თუ ნაბიჯი არის 1, შეგიძლიათ ნაბიჯი ნაბიჯიქვედა;
შემდეგი - შემდეგი (სავალდებულო VB საკვანძო სიტყვა, მარყუჟის განცხადების ბოლოს ჩანაწერი).
კონტრ ღირებულება (დაწყება, დასასრული)შეიძლება იყოს რიცხვითი მუდმივები ან ცვლადები მთელი ან რეალური ტიპის, შეიძლება იყოს უარყოფითი ან დადებითი რიცხვები. იმისათვის, რომ მარყუჟის სხეული ერთხელ მაინც შესრულდეს, ის უნდა იყოს დაწყება ≤ დასასრული,თუ ნაბიჯი> 0 და დაწყება ≥ დასასრული,თუ ნაბიჯი< 0. როგორც კი აღმოჩნდება მრიცხველი>Დასასრული (თუ დაწყება< Конец), მარყუჟის შესრულება მთავრდება. Თუ დაწყება =Დასასრული,ციკლი შესრულდება ერთხელ;
მაგალითი 9.1 .ფუნქციის შეფასებაი = 2 – 1.5 სინქსიX-ის შეცვლისას დიაპაზონში 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-ით. ჩამოყალიბდება ხარისხის მნიშვნელობა. მრიცხველის გამოყენებით ი. შემდეგ შეგიძლიათ დაწეროთ შემდეგი პროგრამა (ფრაგმენტი):
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);
ფუნქცია შეყვანის ყუთი() აჩვენებს დიალოგურ ფანჯარას დახურვის ღილაკით, მოცემული შეტყობინების, შეყვანის ველით, ღილაკებით კარგი,გაუქმება,სათაური (ან მის გარეშე). თუ შეყვანილია რიცხვი 12 - N მასივის ზომა, მაშინ ჩვენს მაგალითში, პირველი გამოჩენისას, ეს ფანჯარა ასე გამოიყურება:
როგორც ხედავთ, შეტყობინება შეიყვანეთ ელემენტი B(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 ცვლადშიც. და ჩვენ ვუმატებთ 1 ცვლადს K და ვინახავთ ახალ მნიშვნელობას იმავე ცვლადში
პროგრამაალგორითმის ეს ნაწილი ასე გამოიყურება:
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-ის ჯერადი.
დავალების ალგორითმი:
ჩვენ აღვადგენთ მრიცხველს კ. For…Next მარყუჟის ოპერატორის გამოყენებით, ჩვენ გადავხედავთ R(N) მასივის ყველა ელემენტს.
ჩვენ ვამოწმებთ თითოეულ ელემენტს 5-ის სიმრავლისთვის If…Then ოპერატორის გამოყენებით და მასივის ელემენტის გაყოფა Mod-ზე.
თუ ელემენტი არის 5-ის ჯერადი, მაშინ მრიცხველის გამოყენებით, როგორიცაა k=k+ 1, ვქმნით R5(N) მასივის ინდექსებს 1-დან და ვწერთ ამ მეორე მასივში –R5(N).
თუ k არ არის ნულოვანი, გამოიტანეთ arrayR5() ფორმაში.
თუ k არის ნულის ტოლი, გამოვიტანთ: "არ არსებობს ელემენტები, რომლებიც 5-ის ჯერადი არიან".
პროგრამის ფრაგმენტი:
თუ R(i) Mod 5 მაშინ k = k + 1: R5(k) = R(i)
თუ კ<>0 შემდეგ
ბეჭდვა "არ არის ელემენტები, რომლებიც იყოფა 5-ზე"
მარყუჟები შეიძლება მოთავსდეს სხვა მარყუჟებში.
ვაჩვენოთ ნამუშევარი წყობილი მარყუჟები . ქვემოთ, პროგრამა აწყობს i, j და k ციკლის მრიცხველების მნიშვნელობების გამოტანას. i,j,k-ის გამოსვლიდან ირკვევა, თუ როგორ სრულდება წყობილი მარყუჟები.
პირადი ქვე frmCycle_DblClick()
ScaleMode = 4 'ერთეული - სიმბოლოები
i = 1-დან 3-მდე გარე მარყუჟისთვის
ამობეჭდვა "i ="; მე;
j = 1-დან 4-მდე 1-ლი ჩადგმული მარყუჟისთვის
CurrentX = TextWidth ("i = 1") + 5
ბეჭდვა "j="; j;
CurrentX = ტექსტის სიგანე ("i = 1 j = 1") + 7
k = 1-დან 5-მდე 'მე-2 ჩადგმული მარყუჟისთვის
ნაჩვენები ფორმა (ნახ. 1) გვიჩვენებს სამივე მარყუჟის მრიცხველების ჩვენების შედეგებს: გარე მარყუჟი - მრიცხველი i, პირველი ჩასმული მარყუჟი - counterj და მეორე, ყველაზე შიდა მარყუჟი - მრიცხველი. როგორც ვხედავთ, გარე მარყუჟის "ყველაზე ნელი" მრიცხველი(პოი) და "ყველაზე სწრაფი" არის ყველაზე შიდა მარყუჟის მრიცხველი (შესაბამისადკ).
პროგრამა სრულდება frmCicli ფორმაზე მაუსის მარცხენა ღილაკით ორჯერ დაწკაპუნების შემდეგ.
CurrentX, CurrentY - ფორმის თვისებები, რომლებიც განსაზღვრავს საწყისი წერტილის X, Y კოორდინატებს ინფორმაციის გამოსატანად Print მეთოდით (იხ. X და Y ღერძების მდებარეობა ფორმაზე ნახ. 1).
TextWidth() არის ფუნქცია, რომელიც აბრუნებს ფუნქციაში მოცემული ტექსტის სიგანეს, როგორც არგუმენტი ორმაგ ბრჭყალებში.
ჩადგმული მარყუჟები გამოიყენება ორგანზომილებიანი მასივების (მატრიცების) დამუშავებისას. მაგრამ ზოგიერთ დავალებაში, ორგანზომილებიანი მასივის ელემენტების შეყვანისა და გამომავალი გამოკლებით, შეგიძლიათ შემოიფარგლოთ ერთი ციკლით. განვიხილოთ მატრიცული პროგრამირების რამდენიმე მაგალითი.
მაგალითი 9.11. მთელი რიცხვების მატრიცის (ორგანზომილებიანი მასივის) შეყვანა და გამომავალიintA(ნ).
შეგიძლიათ შეიყვანოთ მატრიცა რიგებით და სვეტებით . უფრო ადვილია - სტრიქონ-სტრიქონი, თუ ფორმაში მასივის ელემენტების გამოსავალი დაპროგრამდება მათი შეყვანისთანავე.
მატრიცის შეყვანა და გამომავალისტრიქონი სტრიქონი - ფრაგმენტი 1.
Dim M როგორც მთელი რიცხვი, N როგორც მთელი რიცხვი, i როგორც მთელი, j როგორც მთელი
Dim intA() როგორც მთელი რიცხვი ' გამოაცხადეთ დინამიური მასივი
M = Val(txtN.Text) ' M არის ხაზების რაოდენობა
N = Val(txtN.Text) ' N არის სვეტების რაოდენობა
ReDim intA(M, N) როგორც მთელი რიცხვი, ხელახლა განსაზღვრეთ მასივი
i = 1-დან M-მდე მე ვინარჩუნებ მის მნიშვნელობას ბოლომდე
j-ზე წყობილი ციკლი არ შესრულდება
ბეჭდვა ""; intA(i, j); ხაზ-სტრიქონის გამომავალი
ამობეჭდვა ' გადადით ახალი ხაზის დასაწყისში
მატრიცაში სვეტების მიხედვით შესაყვანად აუცილებელია j-ზე გარე მარყუჟის გაკეთება (სვეტის ნომრების დაყენება), ხოლო i-ზე შიდა მარყუჟის (აწესებს მწკრივების ნომრებს).
მატრიცის შეყვანა და გამომავალისვეტების მიხედვით – ფრაგმენტი 2.
PrY = 2500: CurrentY = PrY ' PrY ადგენს დაწყების Y კოორდინატს
გამოიტანეთ თითოეული სვეტის პირველი ელემენტი ფორმაზე
j = 1-ისთვის N ' j შეინარჩუნებს მის მნიშვნელობას ბოლომდე
'ბუდებული მარყუჟი მე-ზე არ შესრულდება
intA (i, j) = InputBox("შეიყვანეთ ელემენტი intA(" & i & "," & j & ")", _
"მატრიცის შეყვანა intA(" & M & "," & N & ")")
Print Tab(6 * j); intA(i, j) ' ჩვენება სვეტების მიხედვით
CurrentY = PrY ' პირველი ელემენტის საჩვენებლად
შემდეგი სვეტი
პროგრამის ეს მეორე ფრაგმენტი არ იმეორებს პირველ 5 სტრიქონს პირველი ფრაგმენტიდან. Tab(6 * j) ფუნქცია ადგენს გამოტანის დაწყებას ხაზზე (სიმბოლოებით) დაწყებული ფორმის მარცხენა კიდედან. PrY კოორდინატი აქ არის 2500 twips, მაგრამ თქვენ შეგიძლიათ აირჩიოთ სხვა მნიშვნელობა.
მაგალითი 9.12 . მასივის ელემენტების მნიშვნელობების დალაგებავ(ნ) აღმავალი.
მასივების შეკვეთის რამდენიმე ალგორითმი არსებობს. აქ არის ერთი მათგანი: წყობილი მარყუჟების გამოყენებითამისთვის… შემდეგიშეარჩიეთ ელემენტები პირველიდან ბოლომდე და შეადარეთ თითოეული მათგანი მომდევნო ელემენტებთან; თუ აღმოჩნდება, რომ შემდეგი ელემენტი არჩეულზე ნაკლებია, შეცვალეთ ისინი.
პროგრამის ფრაგმენტი, რომელიც ახორციელებს ამ ალგორითმს:
i = 1-დან N - 1-ისთვის
იყიდება j = i + 1 N-მდე
თუ 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)
დაბეჭდეთ „სვეტის ჯამი“; 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 ვარიანტი.
არსებობს მრავალი მათემატიკური პრობლემა, რომლებიც უბრალოდ გადაიჭრება განმეორებით წყობილი მარყუჟის პროგრამირების გზით.
