მარყუჟის ოპერატორები. მარყუჟის ოპერატორები შესავალი მთლიან არითმეტიკაში

ს.ა. გრიგორევი

ციკლური ალგორითმების განსახორციელებლად, მაშინ. ალგორითმები, რომლებიც ცვლის მრავალჯერ განმეორებულ ოპერაციებს, ქმნიან სპეციალურ მარყუჟის ოპერატორებს. პასკალს აქვს სამი სახის მარყუჟი: FOR, WHILE და REPEAT. FOR loop ოპერატორი იწერება ფორმით:

ცვლილებისთვის:=cob მნიშვნელობა ბოლო მნიშვნელობისთვის DO

ოპერატორი/ბლოკი

ცვლილებისთვის:=cob მნიშვნელობა DOWNTO ბოლო მნიშვნელობის DO

ოპერატორი/ბლოკი.

აქ ცვლილება არის რიგითი ტიპის ცვლილება, რომელსაც ასეთ კონტექსტში ეწოდება ცვლილების ციკლი, კობ მნიშვნელობები და საბოლოო მნიშვნელობები - იგივე ტიპის გამონათქვამები (ბრალდება, როგორც მომავალში, სრულიად განსხვავებული ტიპის ცვლილებებისთვის). FOR ციკლი მთავრდება მიმდინარე ბრძანებით: ალტერნატიულ ციკლს ეძლევა საწყისი მნიშვნელობები, რის შემდეგაც ციკლის სხეული (ოპერატორი ან ბლოკი, რომელიც მოდის DO-ს შემდეგ) მთავრდება. ორი რამ ერთდროულად ქმნის ერთ ციკლს. შემდეგ ალტერნატიული ციკლი ენიჭება დაწყების (FOR...TO ციკლისთვის) ან წინა (FOR...DOWNTO ციკლისთვის) მნიშვნელობას (ფუნქციით Succ და Pred) და ციკლის დაწყებას ენიჭება. . ეს გრძელდება მანამ, სანამ ცვლილების ციკლის მნიშვნელობა არ გახდება მეტი (FOR...TO) ან ნაკლები (FOR...DOWNTO) საბოლოო მნიშვნელობაზე. FOR ციკლი შეიძლება არ გამოვიდეს ყოველ ჯერზე, თუ კიდეების მნიშვნელობა აღემატება საბოლოო მნიშვნელობას FOR...TO ციკლში ან ნაკლებია ბოლო მნიშვნელობაზე FOR...DOWNTO ციკლში. მოდით დავწეროთ ორი განაცხადი FOR მარყუჟზე: გამოვთვალოთ ნატურალური რიცხვების კვადრატების ჯამი 1-დან N-მდე.

CONST: რეალური = 0; N = 22;

BEGIN FOR i:=1 დან N DO s:=s+SQR(i); WRITELN("sum=",s); ᲓᲐᲡᲐᲡᲠᲣᲚᲘ.

ეკრანზე გამოსახულია სიმბოლოები 32-დან 255-მდე რიცხვებით

BEGIN FOR c:=" " TO #255 DO WRITE(c); WRITELN; ᲓᲐᲡᲐᲡᲠᲣᲚᲘ.

ციკლის კიდევ ერთი ტიპი - WHILE ციკლი - იწერება ფორმით:

WHILE ლოგიკური გამოხატულება DO ოპერატორი/ბლოკი

აქ არის ლოგიკური გამოხატულება - იქნება ეს ლოგიკური ტიპის გამოხატულება. ციკლი ასე მთავრდება: გამოითვლება ლოგიკური გამონათქვამები და თუ მართალია, ციკლის სხეული სრულდება, წინააღმდეგ შემთხვევაში ციკლი მთავრდება. ცხადია, WHILE ციკლი შეიძლება არ გამოვიდეს ყოველ ჯერზე, მაგრამ ის ასევე დასრულდება უსასრულო რაოდენობის ჯერ (დანარჩენ დროს გამოჩნდება, რომ პროგრამა არის ციკლში). მოდით ჩამოვწეროთ ორი წინა ბრძანება, vikoryst და WHILE ციკლი:

დაიწყე მანამ, სანამ მე<=N DO BEGIN s:=s+SQR(i); INC(i); END;

WRITELN("sum=",s);

BEGIN c:=Pred(" ");

სანამ გ<#255 DO BEGIN c:=Succ(c); WRITE(c); END;

დიახ, იფიქრეთ იმაზე, თუ რატომ არის პროგრამა

სანამ გ<=#255 DO BEGIN WRITE(c); c:=Succ(c); END;

როგორც ჩანს, ფიქსირდება.

მესამე ტიპის ციკლი - REPEAT - იწერება სახით:

REPEAT ოპერატორები ლოგიკურ გამოხატულებამდე;

ვინაიდან REPEAT მარყუჟის ტექსტი შეიცავს ერთზე მეტ განცხადებას, არ არის საჭირო ბლოკის შექმნა, რადგან თავად REPEAT და UNTIL საკვანძო სიტყვებს აქვთ ლოგიკური რკალი. თქვენ არ შეგიძლიათ ";"-ის დაყენება UNTIL-ის წინ. REPEAT ციკლი სრულდება ასე: ჯერ სრულდება მარყუჟის სხეული, შემდეგ გამოითვლება ლოგიკური გამოხატულება და თუ ეს სიმართლეა, ციკლი მთავრდება. ამ გზით, REPEAT ციკლი სრულდება ერთხელ მაინც და ისევე, როგორც WHILE, ადვილია ციკლი. მოდით დავწეროთ ჩვენი აპლიკაციები REPEAT ციკლის გამოყენებით:

CONST i: სიტყვა = 1; რეალური = 0; N = 22;

BEGIN REPEAT s:=s+SQR(i); INC(i) UNTIL i>N;

WRITELN("sum=",s);

BEGIN c:=Pred(" ");

REPEAT c:=Succ(c); ჩაწერეთ(გ) c=#255-მდე;

ამ დაკვირვებებიდან გამომდინარე, აშკარაა, რომ ნებისმიერი ციკლური ალგორითმი შეიძლება დაიწეროს ნებისმიერი ტიპის ციკლში, ყველა მათგანი ურთიერთშემცვლელია და შერჩეულია პროგრამისტის მიერ მათი გემოვნების მიხედვით და შეიძლება რეკომენდებული იყოს იმ შემთხვევებში, როდესაც არსებობს დიდი რაოდენობით ციკლები შორიდან, vikorist FOR loop.

პასკალის ფილმის დარჩენილ ვერსიაში გამოჩნდა BREAK და CONTINUE პროცედურები C ფილმის break და continue ოპერატორების მსგავსი. BREAK პროცედურა ტარდება ციკლის ბოლომდე, რაც არის ზუსტად ის. CONTINUE პროცედურის გაგრძელება იწვევს საბოლოო გადასვლას ციკლის დასაწყისში. მოდით ჩამოვწეროთ ჩვენი დუნდულები, vikoryst და BREAK:

CONST i: სიტყვა = 1; s: რეალური = 0; N = 22;

დაიწყეთ სანამ ჭეშმარიტი დაიწყეთ

s:=s+SQR(i); INC(i); IF i>N მაშინ შესვენება; ᲓᲐᲡᲐᲡᲠᲣᲚᲘ;

WRITELN("sum=",s);

BEGIN c:=Pred(" ");

REPEAT c:=Succ(c); WRITE(c); თუ c=#255, მაშინ გატეხეთ ტყუილამდე;

იმისათვის, რომ გავიგოთ CONTINUE პროცედურის გამოყენება, მოდით გადავხედოთ სხვა ამოცანას შემდეგი ნაბიჯისთვის: ეკრანზე გამოვაჩინოთ ყველა სიმბოლო 32-დან 255-მდე, რომლებიც არ არის რუსული ასოებით.

IF (c>="A") და (გ<="Я")OR(c>= "ა") და (გ<="п")OR

(c>="p") და (გ<="я") THEN CONTINUE;

თუმცა, დანარჩენი პრობლემა, ცხადია, შეიძლება უფრო მარტივი გზით იყოს ნათქვამი:

დაიწყეთ c:=" "#255-მდე დაიწყეთ

თუ არა ((c>="A") და (გ<="Я")OR(c>= "ა") და (გ<="п")OR

(c>="p") და (გ<="я")) THEN WRITE(c);


ჩართეთ main() ( int i=0; /*i=0, არა ერთი*/ do i++; while (getchar()!='R'); printf("სიმბოლო R %dth",i); ) წარმოდგენილი პროგრამა ზემოთ ახლა იწერება do-while ციკლში. პროგრამის შედეგი იგივე იქნება. ოპერატორი მარყუჟისთვის აღწერა: for (viraz 1; viraz 2; viraz 3) ოპერატორი; მოქმედება: მრგვალ მკლავებს სამი ნაკეცი აქვს. მათგან პირველი, ვინც ემსახურება...

1-დან 9-მდე. for ოპერატორის კიდევ ერთი ვარიანტია გაუთავებელი მარყუჟი. ასეთი მარყუჟის ორგანიზებისთვის შეგიძლიათ გამოიყენოთ ცარიელი მენტალური განცხადება, ხოლო ციკლიდან გასასვლელად გამოიყენეთ დამატებითი მენტალური განცხადება და შესვენების განცხადება. მაგალითი: for (;;) ( ... ... break; ... ) ფრაგმენტები, რომლებიც შეესაბამება C# ენის სინტაქსს, შეიძლება იყოს ცარიელი, ხოლო for ოპერატორის სხეული ასევე შეიძლება იყოს ცარიელი. Ისე...

და ბუდობის ციკლები შიდაა. როგორც გარე, ასევე შიდა ციკლების ორგანიზების წესები იგივეა, რაც მარტივი ციკლისთვის. დავალება 3. ინტერვალზე იპოვეთ ნატურალური რიცხვი შრომისმოყვარეობის მაქსიმალური ჯამიდან. პროპონირებული პრობლემა შეიძლება კლასიფიცირდეს, როგორც "ინტეგრალური არითმეტიკის ამოცანა", სადაც არგუმენტები, შედეგები და შუალედური მნიშვნელობები შეიძლება კლასიფიცირდეს, როგორც მთელი რიცხვი. სლაიდი მიუთითებს რა არის...

ეს ნიშნავს, თუ როგორ იცვლება ციკლის პარამეტრი. for განცხადებაში თავდაპირველად გონება მოწმდება და თუ გონების მნიშვნელობა არის „true“, მაშინ შეყვანილია მარყუჟის სხეული (განცხადებების ბლოკი ან მარტივი ოპერატორი). ზავდანნია No3. „მასივები და ქვეპროგრამები“ მესამე დავალების შედეგი არის პროგრამა დაწერილი სხვადასხვა ქვეპროგრამით - მინიმუმ 2 პროცედურა და 1 ფუნქცია. ზავდანნია...

აღჭურვილობა: პერსონალური კომპიუტერი, C# ფილმების შემდგენელი.

მეტა: გაიცანით მარყუჟის ოპერატორები და ისწავლეთ მათი დანერგვა C# პროგრამებში.

ციკლური ძირითადი სტრუქტურა ინტეგრირებულია აქტიური ოპერატორის მრავალჯერადი საქმიანობის ორგანიზაციაში. მარყუჟის ოპერატორი მოიცავს<заголовок цикла>і<тело цикла>. სათაური მიუთითებს რამდენჯერ განმეორდება ციკლი, ხოლო სხეული მიუთითებს განმეორებით განცხადებებს.

დანერგილია მარყუჟის ოპერატორების სამი ტიპი.

(1) ხოლო მარყუჟი

ხოლო<условие>

<тело цикла>

უმოვა ლოგიკური ტიპის უფრო ლოგიკური გამოხატულებაა.

ციკლის სხეული არ არის ოპერატორი, მაგრამ ოპერატორების თანმიმდევრობა მოთავსებულია ოპერატორის მკლავებში ( ). ალგორითმი vikonannya ხოლო მარყუჟისთვის

1. გონების ღირებულება გამოითვლება.

2. თუ გონება მართალია, მაშინ ციკლს ემატება სხეულის ოპერატორები და მეორდება 1 ციკლი.

3. როგორც კი უმოვა გაიწმინდება, ციკლი მთავრდება და კანის ოპერატორი გადადის შემდეგ ეტაპზე.

(2) Do while ციკლი

<телоцикла>

ხოლო (<условие>);


უმოვა ლოგიკური ტიპის ცე ვირაზია.

ციკლის სხეული არის ოპერატორი, ხოლო ოპერატორების თანმიმდევრობა გამოყოფილია სიმბოლოთი ";".

ალგორითმი do while მარყუჟისთვის

1. ციკლს ემატება სხეულის ოპერატორები.

2. გონების ღირებულება გამოითვლება.

3. რადგან გონება ჰიბნაა, გაკვეთილი 1 მეორდება.

4. როგორც უმოვა პომილკოვა, ციკლი მთავრდება და შემდეგ ოპერატორზე გადასვლა იწყება.

პატივისცემა.

1. Dowhile ოპერატორი, გარდა while ოპერატორისა, ვალდებულია დასრულდეს ერთჯერადად.

2. შეგიძლიათ ციკლიდან გასვლა go ოპერატორის გამოყენებით, მაგრამ ეს არ შეესაბამება სტრუქტურირებული პროგრამირების პრინციპებს.

3. თუ მარყუჟის სხეულის ოპერატორები არ გაერთიანდებიან ჭეშმარიტების გონებისა და გონების მნიშვნელობებში while მარყუჟის დასრულებამდე და დოჰილ მარყუჟის დასრულების შემდეგ, მარყუჟი უსასრულოდ დასრულდება ( "მარყუჟის" ეფექტი).

(3) განცხადებისთვის

ოპერატორი for არის ყველაზე დახვეწილი გზა მარყუჟის ორგანიზებისთვის. ეს არის მიმდინარე ფორმატი:

(ვირაზ 1; ვირაზ 2; ვირაზ 3) სხეულისთვის

Viraz 1 დამოკიდებულია ციკლის კონტროლირებადი ცვლილებების cob მნიშვნელობის დადგენაზე. Viraz 2 - ეს არის ვირუსი, რომელიც ნიშნავს ტვინს, რომლის სხეულისთვისაც ციკლი უნდა იყოს. Viraz 3 ნიშნავს ცვლადების ცვლილებას, რომლებიც აკონტროლებენ ციკლს კანისა და სხეულის ციკლის შემდეგ.

ოპერატორის დიაგრამა:

1. ვირაზ 1 გამოითვლება.

2. ვირაზ 2 გამოითვლება.

3. თუ გამოხატვის 2-ის მნიშვნელობა ნულის ტოლია (true), ციკლის სხეული დასრულებულია, გამოითვლება გამოხატულება 3 და მიმდინარეობს გადასვლა მე-2 წერტილზე, რადგან გამოხატულება 2 უდრის ნულს (მცდარი), მაშინ ბალანსი გადაეცემა ოპერატორს, შემდეგ განცხადების მიყოლის შესახებ.

მართალია, გონების ხელახალი შეფასება ციკლის დასაწყისშია. ეს ნიშნავს, რომ ციკლის სხეული შეიძლება არ დასრულდეს ყოველ ჯერზე, რადგან გონება მაშინვე დასრულდება.

ამისთვის (i=1; i<10; i++)

ამ შემთხვევაში, ყველა განაცხადი გამოითვლება რიცხვების კვადრატებით 1-დან 9-მდე.

for ოპერატორის კიდევ ერთი ვარიანტი არის გაუთავებელი მარყუჟი. ასეთი მარყუჟის ორგანიზებისთვის შეგიძლიათ გამოიყენოთ ცარიელი მენტალური განცხადება, ხოლო ციკლიდან გასასვლელად გამოიყენეთ დამატებითი მენტალური განცხადება და შესვენების განცხადება.


C# ენის სინტაქსის გამო, ოპერატორი შეიძლება იყოს ცარიელი, ხოლო for განაცხადის სხეული ასევე შეიძლება იყოს ცარიელი. ოპერატორის ეს ფორმა შეიძლება გამოყენებულ იქნას poshuku-სთვის.

ამისთვის (i=0; t[i]<10 ; i++) ;

ამ აპლიკაციაში ცვლილების ციკლი i იღებს t მასივის პირველი ელემენტის რიცხვის მნიშვნელობას, მნიშვნელობა 10-ზე მეტი. ციკლის პარამეტრის ტიპი, დასასრული და დასასრული მნიშვნელობა არის ბრალია. მაშინ დასაშვებია ნებისმიერი სკალარული ტიპის მასალა. იყოს ერთგვარი რიგითი ტიპი. ასეთი ტიპების უპიროვნო მნიშვნელობის დადგენის ბრძანება იძლევა ნებისმიერი მნიშვნელობის წინ და უკან გადაწევის საშუალებას.

ციკლის სხეული არის ოპერატორი, ხოლო ოპერატორების თანმიმდევრობა მოთავსებულია ოპერატორის მკლავებში ( ).

პატივისცემა

1. for ციკლი მთლიანად უნდა იქნას აცილებული იმ შემთხვევებში, როდესაც ციკლის განმეორების მაჩვენებელი ნათელია.

2. ციკლის პარამეტრის მნიშვნელობა არ შეიძლება შეიცვალოს ციკლის შუა პერიოდში და უცვლელი რჩება ციკლიდან გასვლისას.

3. თქვენ შეგიძლიათ გახვიდეთ ციკლიდან ჯერ goto განაცხადის გამოყენებით, მაგრამ ეს არ შეესაბამება სტრუქტურირებული პროგრამირების პრინციპებს.

ლაბორატორიული რობოტი 3 მოიცავს 4 დავალებას.

1. მნიშვნელობათა თანმიმდევრობის დამუშავება.

თანმიმდევრობის დამუშავებისას ელემენტები არ ახსოვს, მაგრამ გროვდება შესვლის შემდეგ.

მოცემულია ნატურალური რიცხვი n და მთელი რიცხვები A1, A2, ..., An. გაარკვიეთ, რამდენად გაამახვილებთ ყურადღებას თანმიმდევრობაზე, როგორც დადებითად, ასევე უარყოფითად. თუ ყველა პირობა უდრის ნულს, მაშინ გვითხარით ამის შესახებ.

მოდით შევხედოთ Main() პროცედურის კოდს

Console.WriteLine("Enter n");

N = Console.ReadLine();

n = Convert.ToInt32(N);

ხოლო ((a == 0) && (i< n))

Console.WriteLine ("Enter a");

A = Console.ReadLine();

a = Convert.ToInt32(A);

Console.WriteLine("AllElements 0");

Console.WriteLine("პირველი არა null ელემენტი უარყოფითია");

Console.WriteLine("პირველი არა null ელემენტი დადებითია");

Console.ReadLine();

2. განაწილება, როგორც მოცემული ფუნქციის მნიშვნელობების ცხრილი.

გამოთვალეთ ფუნქციის მნიშვნელობები:

a=1,1.1,1.2,...,1+0.1n და დაყავით მნიშვნელობა ათწილადის შემდეგ ორი ათწილადით, როგორც ცხრილში.

N = Console.ReadLine();

n = Convert.ToInt32(N);

ამისთვის (i = 1; i< n + 1; i++)

f = ((a - 3) * a + 2) / Math.Sqrt (2 * a * a * a - 1);

Console.WriteLine("*(0)*(1)", a, f);

Console.WriteLine("********************************");

Console.ReadLine();

3. დამატებითი შემოწირულობების (სპოილერების) მოცემული რაოდენობის თანხის (შექმნის) გაანგარიშება, თითოეული ფუნქციით მისი ინდექსის (რიცხვის) მიხედვით.

აქტიური x და მთელი რიცხვი n (n>0) ამოცანების გამოთვლა

მოდით შევხედოთ Main() პროცედურის კოდს:


ორმაგი x, s, h, f;

Console.WriteLine ("შეიყვანეთ ელემენტების რაოდენობა");

N = Console.ReadLine();

n = Convert.ToInt32(N);

Console.WriteLine ("შეიყვანეთ x მნიშვნელობა");

X = Console.ReadLine();

x = Convert.ToDouble(X);

for(i = 0; i< n; i++)

f = f * (2 * n) * (2 * n + 1);

Console.WriteLine("Summa=(0)",s);

Console.ReadLine();

გთხოვთ გაითვალისწინოთ, რომ კანის ზედაპირზე ჩერგოვი დოდანოკი გამოითვლება იგივე მნიშვნელობით, რაც წინა დოდანოკი. ეს არის სასარგებლო მეთოდი x n, (-1) n, (sin x) n, sin x n და ა.შ. ტიპის მნიშვნელობების გაანგარიშებისას.

4. განმეორებითი ციკლის დაწყება შორიდან უცნობი რაოდენობის ნაბიჯებით. განახორციელეთ ნიუტონის მეთოდი არაუარყოფითი x-ის k საფეხურის ფესვთან მიახლოების პოვნის შესახებ.

მოდით y0 – კუბიდან ფესვთან ახლოს. ჩვენ თანმიმდევრულად ამოვიღებთ მნიშვნელობებს:


y1=y0-(y0 k - x)/(k*y0 k-1),

y2=y1-(y1 k - x)/(k*y1 k-1),

y3=y2-(y2k-x)/(k*y2k-1) და ა.შ.

პროცესი გაგრძელდება მანამ, სანამ მოდულის სხვაობა ორ ზედიზედ მოდულს შორის არ იქნება მითითებულ მნიშვნელობაზე e. მნიშვნელობა ახლოს იქნება k x საფეხურის ფესვთან სიზუსტით e. ძვირფასო, კანზე მხოლოდ ორი დარჩენილი სიახლოვე გვჭირდება. მოდით შევხედოთ Main() ფუნქციის კოდს:

სტრიქონი K, X, EPS;

ორმაგი x, d = 1, y, eps;

Console.WriteLine ("Enter step");

K = Console.ReadLine();

k = Convert.ToInt32(K);

Console.WriteLine("შეიყვანეთ პირველი ელემენტის მნიშვნელობა");

X = Console.ReadLine();

x = Convert.ToDouble(X);

Console.WriteLine ("შეიყვანეთ epsilon მნიშვნელობა");

EPS = Console.ReadLine();

eps = Convert.ToDouble(EPS);

ხოლო (მათ.Abs(d)>eps)

d=(x/მათ. ექსპ((k-1)*მათ.Log10(y))-y)/k;

Console.WriteLine("უახლოესი ფესვი (0)", d);

Console.ReadLine();

უფლება სამართავი რობოტი No2

ვარიანტი 1

1. მოცემულია რიცხვი a1,...,аn,an+1,...;а1>0, შუა a2,а3,... є მინდა კიდევ ერთი უარყოფითი. ნება მიეცით a1, ..., წევრს, გადალახოს პირველი უარყოფითი. შემცირება min(a1+a2,a2+a3,...,an-1+an).

2. მოცემულია ნატურალური რიცხვი n. გამოთვალეთ ჯამი და გაანაწილეთ

3. მოცემულია აქტიური რიცხვები a და b (a

4. გამოთვალეთ თანხა რიგისთვის

და განიტვირთე. გათვლებს აბრალებენ მათ გონებას

ვარიანტი 2

1. მოცემულია ნატურალური რიცხვები n, a 1, ..., a n. გამოთვალეთ a-ს წევრების რაოდენობა a 1-მდე, ..., a n-მდე, რომელიც არის რიცხვების კვადრატი.

2. მოცემულია ნატურალური რიცხვი n, ნატურალური რიცხვი - x. გამოთვალეთ:

3. აირჩიეთ Z ფუნქციის მნიშვნელობები და გამოყავით X i, Z i სვეტები

მეცნიერება მთელი რიცხვების არითმეტიკის შესახებ

განმეორების ბრძანება ან ციკლი არის მოქმედებების ორგანიზების ფორმა, რომელშიც თავად მოქმედებების თანმიმდევრობა მეორდება მანამ, სანამ გარკვეული ლოგიკური დასკვნის მნიშვნელობა შენარჩუნდება. ლოგიკური გამოხატვის მნიშვნელობის შეცვლისას ემატება გამეორებები (ციკლი მთავრდება).

ციკლის ორგანიზებისთვის, თქვენ უნდა შეხვიდეთ შემდეგ ქმედებებზე:

Cob ციკლის დაწყებამდე დააყენეთ cob პარამეტრის მნიშვნელობა;

ციკლის შუაში, შეცვალეთ პარამეტრი ციკლში მინიჭების ოპერატორის გამოყენებით;

შეამოწმეთ ციკლის გამეორება ან დასრულება;

კერუვატის ციკლი, ტობტო. გადადით შემდეგ კობზე, თუ არ არის დასრულება, ან გამოდით ციკლიდან სხვაგვარად.

იყოფა ციკლები გამეორებების მოცემული რაოდენობით (ციკლი პარამეტრით) და გამეორებები (მშობიარობის შემდგომ პერიოდში).

განმეორებითი ნომრის მქონე ციკლში, პარამეტრი იცვლება მითითებულ დიაპაზონში.

თუ ციკლი იცვლება უბრალოდ ციკლის პარამეტრის შეცვლით; თუ ინდექსის მქონე ცვლადი იცვლება ციკლში, ცვლილების მნიშვნელობის ინდექსი არის ციკლის პარამეტრი.

ციკლის ორგანიზებისთვის გარკვეული რაოდენობის გამეორებით, პასკალი იყენებს for განცხადებას.

დამხმარე ოპერატორის უკან ორგანიზებული ციკლის სტრუქტურა ასე გამოიყურება:

I:= A To B Do დასაწყისი<операторы>Დასასრული;

I:= A DownTo B Do დასაწყისი<операторы>Დასასრული;

აქ I არის პარამეტრი, რომელიც იცვლება ციკლში; A, B - რიგითი ტიპის გამონათქვამები, რომლებიც მიუთითებენ ციკლის პარამეტრის ბოლოდან ბოლომდე. ციკლის პარამეტრის ნომრის შეცვლის ვადა 1-ზე მეტია, რადგან ციკლის სათაური შეიცავს To (ისე რომ ციკლის პარამეტრის რეალური მნიშვნელობა გამოითვლება დამატებითი ფუნქციისთვის succ); i -1 - DownTo-სთვის (გამოთვლები მიჰყვება დამატებით ფუნქციას pred).

გამოითვლება ციკლის თანმიმდევრობა 1 შეტევის ციკლით: გამოითვლება ციკლის დასასრულის და დასრულების პარამეტრის მნიშვნელობები; პარამეტრი I იღებს cob მნიშვნელობას; თუ I ნაკლებია ან ტოლია საბოლოო მნიშვნელობაზე, ემატება ციკლის სხეული; პარამეტრის მნიშვნელობა იზრდება ციკლში, შემდეგ. I:=succ(I); შეამოწმე შენი გონება მე<=B (для отрицательного шага условие I>=B) და მომდევნო საუკუნისთვის ციკლი მეორდება. ციკლიდან გასვლა ხდება თუ I>B (I B (ან A

თუ მარყუჟის ოპერატორში cob ან ბოლო პარამეტრით, პარამეტრის მნიშვნელობები მითითებულია მონაცვლეობით ან ვირაზაებით, ამ ალტერნატიული პასუხისმგებლობის მნიშვნელობები პროგრამაში ენიჭება მარყუჟის ოპერატორს. არ შეცვალოთ ციკლის პარამეტრები ციკლის შუაში, რომლის საწყისი და საბოლოო მნიშვნელობები ექვემდებარება დამატებით ოპერატორებს დამატებული ან შეყვანილი.

Zavdannya 1. მოცემული ბუნებრივი n, deisne x. გამოთვალეთ

მოდით დავშალოთ პრობლემის გადაჭრის ალგორითმი:

1) შეიყვანეთ მონაცემები - დამატებითი დოკუმენტების რაოდენობა n და ნომერი x;

2) მივანიჭოთ ცვლადი, რომელშიც შენახულია ნაბიჯი sin x, მნიშვნელობა 1; S:= 0;

3) ციკლის პარამეტრს მივანიჭოთ მნიშვნელობა 1;

4) თუ ციკლის პარამეტრის მნიშვნელობა n-ზე ნაკლებია, გადადით შემდეგ წერტილზე, წინააღმდეგ შემთხვევაში ნაბიჯი 9;

5) გამოთვალეთ ნახაზის ნაბიჯი sin x;

6) დაამატეთ გამოთვლილი თანხა;

7) ციკლის პარამეტრის გაზრდა 1-ით;

8) გადადით მე-4 საფეხურზე;

9) თანხის გადარიცხვა S sum-ში;

(სინ x ნაბიჯების ჯამის გამოსათვლელი პროგრამა)

Var S, X, Pr: რეალური; N, I: მთელი რიცხვი;

Write("შეიყვანეთ დამატებების რაოდენობა x: "); ReadLn(N, X);

Pr: = 1; (ეს ცვლილება ინახავს ცოდვის ბოლო ეტაპებს x)

I:= 1-დან N-მდე

Pr: Pr * Sin(X); (ეშმაკის ნაბიჯის ცოდვა (x))

WriteLn ("ძვირი თანხა", S: 7: 4)

პარამეტრით ციკლი ხშირად გამოიყენება მასივის დამუშავების პროგრამების შესაქმნელად.

Შენიშვნა. როგორც ზემოაღნიშნულიდან ჩანს, ტერიტორია, სადაც ციკლი დაყენებულია პარამეტრით პასკალის ენაზე, მკვეთრად არის შემოსაზღვრული: დემარკაცია დაკავშირებულია ციკლის პარამეტრის ცვლილების ხანგრძლივობასთან, ციკლის პარამეტრის ტიპთან, მისი საწყისი და საბოლოო ღირებულება. ზოგიერთ ენას, მაგალითად, Basic-ს, არ აქვს ასეთი საზღვრები.

იგივეა ციკლი პარამეტრით Iterative loops და უნივერსალური პირობა. განმეორებითი მარყუჟების ორგანიზებისთვის, მენტალური მარყუჟის ოპერატორები მეორდება სანამ არ გამოიყენებენ.

ეს ოპერატორები არ ადგენენ კანონს პარამეტრის ციკლზე გადასვლის შესახებ; ციკლის დაწყებამდე აუცილებელია პარამეტრის საწყისი მნიშვნელობის დაყენება მინიჭებული დამატებითი ოპერატორის უკან, ხოლო ციკლის შუაში შეცვალოს პარამეტრის ზუსტი მნიშვნელობა. .

ციკლის სტრუქტურების ტიპები:

ხოლო B Do Begin<операторы>Დასასრული;

გაიმეორეთ<операторы>C-მდე;

აქ B, C არის ლოგიკური გამონათქვამები.

ოპერატორისთვის მარყუჟში ცვლადი, ლოგიკური პირობის მნიშვნელობა მოწმდება, თუ ეს არის True, მაშინ ოპერატორებს, რომლებიც მარყუჟამდე მოდიან, მოჰყვება შემდეგი ნაბიჯი, ხოლო ოპერატორს, რომელიც მოდის მარყუჟის შემდეგ, მოჰყვება შემდგომი დაკვირვება.

პოსტუმოვიდან ციკლი ერთხელ მაინც მთავრდება. შემდეგ მოწმდება ლოგიკური პირობის მნიშვნელობა, თუ ის False-ია, მაშინ წყდება დებულებები, რომლებიც ჩართულია მარყუჟამდე, წინააღმდეგ შემთხვევაში ციკლი გადის.

თქვენ შეგიძლიათ შეხვიდეთ ციკლში მხოლოდ ერთი კობისთვის, ანუ. შეუძლებელია ციკლის შუაში შესვლა დამატებით ოპერატორთან, რომელიც აკონტროლებს მას, რადგან ამჯერად ციკლის პარამეტრი არ არის მინიჭებული.

ბრძანება 2. გაარკვიეთ მიმდევრობის წევრის ყველაზე დაბალი რიცხვი, რომელზეც გონება მთავრდება |an-an-1|

დავალების შესრულებისას აუცილებელია ვიცოდეთ an და an-1 ფრაგმენტები, რომლებიც ინახება ANew და AOld ცვლადებში.

Var Eps, AOld, ANew: Real; N: მთელი რიცხვი;

Write ("შეიყვანეთ Epsilon ნომერი"); ReadLn(Eps);

AOld:= 0; ANew:= ArcTan(AOld) + 1;

WriteLn (AOld: 8:5); WriteLn (ახალი: 8:5);

ხოლო Abs(ANew - AOld) >= Eps Do

ANew:= ArcTan(AOld) + 1;

WriteLn (ახალი: 8:5);

WriteLn ("გადახვევის ნომერი", N)

ერთი ციკლის შუაში შეიძლება იყოს ერთი ან რამდენიმე სხვა. ამ შემთხვევაში, გაგრილების ციკლს ეწოდება გარე, ხოლო ჩასმის ციკლს ეწოდება შიდა. როგორც გარე, ასევე შიდა ციკლების ორგანიზების წესები იგივეა, რაც მარტივი ციკლისთვის.

დავალება 3. ინტერვალზე იპოვეთ ნატურალური რიცხვი შრომისმოყვარეობის მაქსიმალური ჯამიდან.

პროპონირებული პრობლემა შეიძლება კლასიფიცირდეს, როგორც "ინტეგრალური არითმეტიკის ამოცანა", სადაც არგუმენტები, შედეგები და შუალედური მნიშვნელობები შეიძლება კლასიფიცირდეს, როგორც მთელი რიცხვი. გთხოვთ გაითვალისწინოთ, რომ ასეთი ქარხნები ხშირად იყენებენ DIV და MOD ოპერაციებს; ყველაზე ტიპიური მონაცემი არის რიცხვების ჩანაწერის ციფრების რაოდენობა.

პრობლემის გადაჭრის ალგორითმი:

1) შეიყვანეთ ნომერი n;

2) ცვლილებები ინვესტორებისგან მაქსიმალური თანხის დაზოგვის მიზნით

მნიშვნელობა 1 (1 რიცხვის ჯამი);

3) დაიმახსოვრეთ ნომერი მაქსიმალური თანხიდან;

4) მიანიჭეთ მნიშვნელობა 2 ციკლის I პარამეტრს;

5) თუ I მეტია n-ზე, გადადით მე-13 წერტილზე, წინააღმდეგ შემთხვევაში - შემდეგ წერტილზე;

6) შეცვალეთ მნიშვნელობა 0-ით მოვალეთაგან ფულის დაზოგვისთვის;

7) K ციკლისთვის პარამეტრს მიანიჭეთ მნიშვნელობა 1;

8) თუ K უფრო დიდია I/2-ზე, გადადით მე-11 წერტილზე, წინააღმდეგ შემთხვევაში - შემტევ წერტილამდე;

9) თუ I იყოფა K-ზე გადაჭარბების გარეშე, დაუმატეთ K დილერების საერთო რაოდენობას;

10) გაზარდეთ K 1-ით და გადადით მე-8 საფეხურზე;

11) მოვალეთა ამჟამინდელი ოდენობის გათანაბრება მაქსიმუმთან, ვინაიდან მაქსიმალური ნაკლებია,

დაიმახსოვრეთ ახალი მნიშვნელობა, რომელიც ამ თანხის წარმომადგენელია;

12) გაზარდეთ I 1-ით და გადადით მე-5 საფეხურზე;

13) შეიყვანეთ მოვალეთა მაქსიმალური ოდენობის რაოდენობა და ეს თანხა;

პროგრამა Sum_Del;

Var N, I, Sum_Max, Sum, K, Ch: მთელი რიცხვი;

Write("შეიყვანეთ ნომერი N:"); ReadLn(N);

ჯამი_მაქს: = 1; (მოვალეების მაქსიმალური რაოდენობა)

ჩ: = 1; (რიცხვი მოვალეთა მაქსიმალური ჯამით)

I:= 2-ის გასაკეთებლად (ეს ციკლი არის რამდენიმე რიცხვისთვის)

K:= 1 To I Div 2 + 1 Do (ამ ციკლში ვიცით მოვალეთა ჯამი)

თუ I Mod K = 0 მაშინ (თუ I იყოფა K-ზე, მაშინ K არის I-ის გამყოფი)

თუ Sum > Sum_Max მაშინ იწყება Sum_Max:=ჯამ; ჩ: = ვამთავრებ;

WriteLn(" აქციების მაქსიმალური რაოდენობა", Sum_Max, "შესაძლო ნომერი", Ch)

Zavdannya 4. მოცემულია ნატურალური რიცხვი n. ამ თარიღის ყველა უმარტივესი დავალიანების აღმოფხვრა.

(პროგრამა ამ თარიღის უმარტივესი აქტივობების ხაზგასასმელად)

Var N, I, Vsp: მთელი რიცხვი;

Log_Per, Priznak: Boolean;

Write("შეიყვანეთ ნატურალური რიცხვი:");

პრიზნაკი:= მართალია; (ნიშანი, რომ ნომერი არ არის შეყვანილი, ეპატიება)

(სანამ მარყუჟის პარამეტრი არ გადააადგილებს მოცემული რიცხვის კვადრატულ ფესვს,

გავაგრძელოთ უბრალო ბიზნესმენების ძებნა)

I:= 2-მდე Round(Sqrt(N)) Do

თუ N Mod I = 0 მაშინ

პრიზნაკი:= მცდარი; (შეყვანილი ნომერი არ არის є პატიება)

Log_Per:=False; (ლოგიკური ცვლილება, რომელიც იღებს მნიშვნელობას True,

თუ იყო მეწილეები I, ქვეშევრდომები 1-დან და მე)

თუ (I Mod Vsp = 0) და (I<>Vsp) შემდეგ Log_Per: = True;

სანამ (Vsp > I Div 2 + 1) ან Log_Per;

თუ არა (Log_Per) მაშინ ჩაწერეთLn(I) (თუ რიცხვი I უფრო მარტივია, მეორე)

თუ პრიზნაკი, მაშინ დაწერეLn(N)

მკითხველს ვურჩევთ დამოუკიდებლად გამოეხმაუროს წარდგენილ გადაწყვეტილებებს.

მარყუჟის ოპერატორი

აღჭურვილობა: პერსონალური კომპიუტერი, C# ფილმების შემდგენელი.

მეტა: გაიცანით მარყუჟის ოპერატორები და ისწავლეთ მათი დანერგვა C# პროგრამებში.

ციკლური ძირითადი სტრუქტურა ინტეგრირებულია აქტიური ოპერატორის მრავალჯერადი საქმიანობის ორგანიზაციაში. მარყუჟის ოპერატორი მოიცავს<заголовок цикла>і<тело цикла>. სათაური მიუთითებს რამდენჯერ განმეორდება ციკლი, ხოლო სხეული მიუთითებს განმეორებით განცხადებებს.

დანერგილია მარყუჟის ოპერატორების სამი ტიპი.

(1) ხოლო მარყუჟი

ხოლო<условие>

<тело цикла>

უმოვა ლოგიკური ტიპის უფრო ლოგიკური გამოხატულებაა.

ციკლის სხეული არის ოპერატორი, ხოლო ოპერატორების თანმიმდევრობა მოთავსებულია ოპერატორის მკლავებში ( ). ალგორითმი vikonannya ხოლო მარყუჟისთვის

1. გონების ღირებულება გამოითვლება.

2. თუ გონება მართალია, მაშინ ციკლს ემატება სხეულის ოპერატორები და მეორდება 1 ციკლი.

3. როგორც უმოვა პომილკოვა ამბობს, ციკლი მთავრდება და შემდეგზე გადასვლა იწყება, სანამ ოპერატორი იწყება.

(2) Do while ციკლი

<тело цикла>

ხოლო (<условие>);


უმოვა ლოგიკური ტიპის ცე ვირაზია.

ციკლის სხეული არის ოპერატორი, ხოლო ოპერატორების თანმიმდევრობა გამოყოფილია სიმბოლოთი ";".

ალგორითმი do while მარყუჟისთვის

1. ციკლს ემატება სხეულის ოპერატორები.

2. გონების ღირებულება გამოითვლება.

3. რადგან გონება ჰიბნაა, გაკვეთილი 1 მეორდება.

4. როგორც უმოვა პომილკოვა, ციკლი მთავრდება და შემდეგ ოპერატორზე გადასვლა იწყება.

პატივისცემა.

1. do while ოპერატორი ენიჭება while ოპერატორს.

2. შეგიძლიათ ციკლიდან გასვლა go ოპერატორის გამოყენებით, მაგრამ ეს არ შეესაბამება სტრუქტურირებული პროგრამირების პრინციპებს.

3. თუ მარყუჟის სხეულის ოპერატორები არ ერწყმის გონებისა და გონების მნიშვნელობებს მარყუჟის დასრულებამდე, ხოლო მარყუჟის შემდეგ do while, მაშინ ციკლი მთავრდება შეუფერხებლად („მარყუჟის“ ეფექტი).

(3) განცხადებისთვის

ოპერატორი for არის ყველაზე დახვეწილი გზა მარყუჟის ორგანიზებისთვის. ეს არის მიმდინარე ფორმატი:

(ვირაზ 1; ვირაზ 2; ვირაზ 3) სხეულისთვის

Viraz 1 დამოკიდებულია ციკლის კონტროლირებადი ცვლილებების cob მნიშვნელობის დადგენაზე. Viraz 2 - ეს არის ვირუსი, რომელიც ნიშნავს ტვინს, რომლის სხეულისთვისაც ციკლი უნდა იყოს. Viraz 3 ნიშნავს ცვლადების ცვლილებას, რომლებიც აკონტროლებენ ციკლს კანისა და სხეულის ციკლის შემდეგ.

ოპერატორის დიაგრამა:

1. ვირაზ 1 გამოითვლება.

2. ვირაზ 2 გამოითვლება.

3. თუ გამოხატვის 2-ის მნიშვნელობა ნულის ტოლია (true), ციკლის სხეული დასრულებულია, გამოითვლება გამოხატულება 3 და მიმდინარეობს გადასვლა მე-2 წერტილზე, რადგან გამოხატულება 2 უდრის ნულს (მცდარი), მაშინ ბალანსი გადაეცემა ოპერატორს, შემდეგ განცხადების მიყოლის შესახებ.

მართალია, გონების ხელახალი შეფასება ციკლის დასაწყისშია. ეს ნიშნავს, რომ ციკლის სხეული შეიძლება არ დასრულდეს ყოველ ჯერზე, რადგან გონება მაშინვე დასრულდება.

ამისთვის (i=1; i<10; i++)

ამ შემთხვევაში, ყველა განაცხადი გამოითვლება რიცხვების კვადრატებით 1-დან 9-მდე.

for ოპერატორის კიდევ ერთი ვარიანტი არის გაუთავებელი მარყუჟი. ასეთი მარყუჟის ორგანიზებისთვის შეგიძლიათ გამოიყენოთ ცარიელი მენტალური განცხადება, ხოლო ციკლიდან გასასვლელად გამოიყენეთ დამატებითი მენტალური განცხადება და შესვენების განცხადება.


C# ენის სინტაქსის გამო, ოპერატორი შეიძლება იყოს ცარიელი, ხოლო for განაცხადის სხეული ასევე შეიძლება იყოს ცარიელი. ოპერატორის ეს ფორმა შეიძლება გამოყენებულ იქნას poshuku-სთვის.

ამისთვის (i=0; t[i]<10 ; i++) ;

ამ აპლიკაციაში ცვლილების ციკლი i იღებს t მასივის პირველი ელემენტის რიცხვის მნიშვნელობას, მნიშვნელობა 10-ზე მეტი. ციკლის პარამეტრის ტიპი, დასასრული და დასასრული მნიშვნელობა არის ბრალია. მაშინ დასაშვებია ნებისმიერი სკალარული ტიპის მასალა. იყოს ერთგვარი რიგითი ტიპი. ასეთი ტიპების უპიროვნო მნიშვნელობის დადგენის ბრძანება იძლევა ნებისმიერი მნიშვნელობის წინ და უკან გადაწევის საშუალებას.

ციკლის სხეული არის ოპერატორი, ხოლო ოპერატორების თანმიმდევრობა მოთავსებულია ოპერატორის მკლავებში ( ).

პატივისცემა

1. for ციკლი მთლიანად უნდა იქნას აცილებული იმ შემთხვევებში, როდესაც ციკლის განმეორების მაჩვენებელი ნათელია.

2. ციკლის პარამეტრის მნიშვნელობა არ შეიძლება შეიცვალოს ციკლის შუა პერიოდში და უცვლელი რჩება ციკლიდან გასვლისას.

3. თქვენ შეგიძლიათ გახვიდეთ ციკლიდან ჯერ goto განაცხადის გამოყენებით, მაგრამ ეს არ შეესაბამება სტრუქტურირებული პროგრამირების პრინციპებს.

ლაბორატორიული რობოტი 3 მოიცავს 4 დავალებას.

1. მნიშვნელობათა თანმიმდევრობის დამუშავება.

თანმიმდევრობის დამუშავებისას ელემენტები არ ახსოვს, მაგრამ გროვდება შესვლის შემდეგ.

მოცემულია ნატურალური რიცხვი n და მთელი რიცხვები A1, A2, ..., An. გაარკვიეთ, რამდენად გაამახვილებთ ყურადღებას თანმიმდევრობაზე, როგორც დადებითად, ასევე უარყოფითად. თუ ყველა პირობა უდრის ნულს, მაშინ გვითხარით ამის შესახებ.

მოდით შევხედოთ Main() პროცედურის კოდს

Console.WriteLine("Enter n");

N = Console.ReadLine();

n = Convert.ToInt32(N);

ხოლო ((a == 0) && (i< n))

Console.WriteLine ("Enter a");

A = Console.ReadLine();

a = Convert.ToInt32(A);

Console.WriteLine ("ყველა ელემენტი დაყენებულია 0-ზე");

Console.WriteLine("პირველი არა null ელემენტი უარყოფითია");

Console.WriteLine("პირველი არა null ელემენტი დადებითია");

Console.ReadLine();


ჩართეთ main() ( int i=0; /*i=0, არა ერთი*/ do i++; while (getchar()!='R'); printf("სიმბოლო R %dth",i); ) წარმოდგენილი პროგრამა ზემოთ ახლა იწერება do-while ციკლში. პროგრამის შედეგი იგივე იქნება. ოპერატორი მარყუჟისთვის აღწერა: for (viraz 1; viraz 2; viraz 3) ოპერატორი; მოქმედება: მრგვალ მკლავებს სამი ნაკეცი აქვს. მათგან პირველი, ვინც ემსახურება...

თუ მარყუჟის ოპერატორში cob ან ბოლო პარამეტრით, პარამეტრის მნიშვნელობები მითითებულია მონაცვლეობით ან ვირაზაებით, ამ ალტერნატიული პასუხისმგებლობის მნიშვნელობები პროგრამაში ენიჭება მარყუჟის ოპერატორს. არ შეცვალოთ ციკლის პარამეტრები ციკლის შუაში, რომლის საწყისი და საბოლოო მნიშვნელობები ექვემდებარება დამატებით ოპერატორებს დამატებული ან შეყვანილი. Zavdannya 1. მოცემული ბუნებრივი n, deisne x. გამოთვალეთ როზრობიმო...

და ბუდობის ციკლები შიდაა. როგორც გარე, ასევე შიდა ციკლების ორგანიზების წესები იგივეა, რაც მარტივი ციკლისთვის. დავალება 3. ინტერვალზე იპოვეთ ნატურალური რიცხვი შრომისმოყვარეობის მაქსიმალური ჯამიდან. პროპონირებული პრობლემა შეიძლება კლასიფიცირდეს, როგორც "ინტეგრალური არითმეტიკის ამოცანა", სადაც არგუმენტები, შედეგები და შუალედური მნიშვნელობები შეიძლება კლასიფიცირდეს, როგორც მთელი რიცხვი. სლაიდი მიუთითებს რა არის...

ეს ნიშნავს, თუ როგორ იცვლება ციკლის პარამეტრი. for განცხადებაში თავდაპირველად გონება მოწმდება და თუ გონების მნიშვნელობა არის „true“, მაშინ შეყვანილია მარყუჟის სხეული (განცხადებების ბლოკი ან მარტივი ოპერატორი). ზავდანნია No3. „მასივები და ქვეპროგრამები“ მესამე დავალების შედეგი არის პროგრამა დაწერილი სხვადასხვა ქვეპროგრამით - მინიმუმ 2 პროცედურა და 1 ფუნქცია. ზავდანნია...

ოპერატორი არის პროგრამის განუყოფელი ელემენტი, რომელიც საშუალებას გაძლევთ შეწყვიტოთ ალგორითმული მოქმედებები. ოპერატორის პასუხისმგებლობა სხვა ელემენტებთან მიმართებაში არის ის, რაც ექვემდებარება ყველა ქმედების პატივისცემას. mov Pascal-ში ოპერატორები შედგება სამსახურებრივი სიტყვებისგან. ოპერატორები, რომლებიც გამოიყენება პროგრამებში, გამოყოფილია ერთმანეთისგან და პროგრამის სხვა ელემენტებისაგან სიმბოლოთი (;). Ულვაში ოპერატორის ფილმი პასკალიშეიძლება გონებრივად დაიშალოს ორი ჯგუფი:

  1. ბოდიში;
  2. სტრუქტურირებული.

აპატიეთ ოპერატორებს- ესენი არიან ოპერატორები, რომლებიც შურს იძიებენ სხვა ოპერატორებზე. მათთვის გასაგებია:

  • დავალების ოპერატორი (:=);
  • პროცედურის განცხადება;
  • goto ოპერატორი (GOTO).

სტრუქტურირებული განცხადებები- ეს არის ოპერატორები, რომლებიც ცვლიან სხვა ოპერატორებს. მათთვის გასაგებია:

  • საწყობის ოპერატორი;
  • გონების ოპერატორები (IF, CASE);
  • მარყუჟის ოპერატორი (FOR, WHILE, REPEAT);
  • შეძენის ოპერატორი (WITH).

აპატიეთ ოპერატორებს

პროცედურის ოპერატორი

პროცედურის ოპერატორიემსახურება როგორც Wiklik პროცედურას.

ფორმატი: [პროცედურის_სახელი] (ვიკის პარამეტრების სია);

პროცედურის განაცხადი შედგება პროცედურის იდენტიფიკატორისგან, რასაც მოჰყვება დაწკაპუნების პარამეტრების სია გაფართოების ჯგუფში. პასკალს აქვს პროცედურები პარამეტრების გარეშე. ამ ვარიანტს, ისევე როგორც ზარს, აქვს ყოველდღიური პარამეტრების სია. ამ განყოფილებაში აღწერილი მოქმედებების გააქტიურებამდე უნდა შესრულდეს შემდეგი პროცედურის ოპერატორი. Movi Pascal-ს აქვს ორი სახის პროცედურა:

  • სტანდარტები, როგორც აღწერილია თავად ენაში და ენის თვისება;
  • კორისტუვაჩის პროცედურები, რომელსაც კორისტუვაჩი ასრულებს.

სტანდარტული პროცედურების გამოსაყენებლად, თქვენ უნდა დაუკავშირდეთ მოდულის (ბიბლიოთეკის) სახელს USES განყოფილებას, სადაც აღწერილია ეს პროცედურა. მთელი რიგი პროცედურები, რომლებიც განთავსებულია SYSTEM მოდულში, ავტომატურად უკავშირდება პროგრამებს და მათი დაკავშირება USES განყოფილებაში არ არის საჭირო. პასკალის ფილმის სტანდარტული პროცედურებია READ, WRITE, REWRITE, CLOSE, RESET.

READ ([file_change], [input_list])

READ (x, y)

პროცედურები (არასტანდარტული) პროცედურისთვის უნდა შეიქმნას პროგრამაში მათი გამოყენებამდე და შეიძლება იხილოთ თავად პროგრამის აღწერილობის განყოფილებაში, ან მოდულის პროგრამული ერთეულის გარეთ. თუ პროცედურა მოდულშია, ამ მოდულის სახელი უნდა შეიყვანოთ USES დამატებაში.

GOTO ოპერატორი

ფორმატი: GOTO [იარლიყი];

GOTO არის დაცული სიტყვა პასკალური ენისთვის. [Tag] არის საკმარისი იდენტიფიკატორი, რომელიც საშუალებას გაძლევთ მონიშნოთ კონკრეტული პროგრამის ოპერატორი და შემდეგ გაგზავნოთ იგი ახალზე. mov Pascal-ში ნებადართულია ტეგები შეიცავდეს მთელ რიცხვებს ნიშნების გარეშე. ეტიკეტი გადაადგილდება ოპერატორის ნიშანამდე და ემატება ახალს (:). ერთი ოპერატორი შეიძლება დაინიშნოს მრავალი ტეგით. სუნი უბრალოდ ძლიერდება ერთმანეთის მიყოლებით (:). პირველ რიგში, აირჩიეთ ეტიკეტი ოპერატორის განყოფილებაში და თქვენ უნდა აღწეროთ იგი LABEL განყოფილებაში (აღწერის განყოფილება).

GOTO მოქმედება გადასცემს პროცედურას დანიშნულ ოპერატორს. ნიშნების შეცვლისას, კვალი მიჰყვება შემდეგ წესებს:

  • პასუხისმგებლობის ნიშანი აღწერილია აღწერილობის განყოფილებაში და დანაშაულის ყველა ნიშანი არის ვიკორისტანი;
  • ვინაიდან სიმბოლოები გამოიყენება მთელი რიცხვების წარმოსაჩენად, მათი იგნორირება შეუძლებელია.

სტრუქტურირებული პროგრამირების ტექნოლოგიის პრინციპების საწინააღმდეგოდ. ამჟამინდელ ენობრივ პროგრამებს არ აქვთ ასეთი ოპერატორი საწყობში და არ არის საჭირო ასეთი შემცვლელი. გარდა ამისა, თანამედროვე კომპიუტერებში გამოიყენება კონვეიერის ე.წ. თუ პროგრამას ჰყავს გიჟური გარდამავალი ოპერატორი, ასეთი ოპერატორი არღვევს მთელ კონვეიერს, ბრაზიანად ქმნის მას თავიდან, რაც არსებითად ზრდის გამოთვლით პროცესს.

სტრუქტურირებული განცხადებები

IF ოპერატორები

მენტალურ ოპერატორს პროგრამა იყენებს ალგორითმული სტრუქტურის - დე-განლაგების განსახორციელებლად. ამ სტრუქტურაში გამოთვლითი პროცესი შეიძლება მიმდინარეობდეს ერთ-ერთი შესაძლო მიმართულებით. ვიბრაცია პირდაპირ იწვევს ნებისმიერი სახის გონების შეცვლას. არსებობს ორი სახის გასწორების სტრუქტურა: ჩანგალი და შემოვლითი სტრუქტურა.

პასკალის ენაზე, გონებრივი ოპერატორი IF სასარგებლოა გლუვი გამოთვლითი პროცესის ორგანიზებისთვის.

ფორმატი: IF [ლოგიკური_გამოხატვა] შემდეგ [ოპერატორი_1]; სხვა [ოპერატორი_2];

IF, მაშინ, Else არის მომსახურების სიტყვები. [operator_1], [operator_2] - მარტივი ოპერაციები პასკალის ენაზე. სხვა ნაწილი სულაც არ არის რთული (ეს შეიძლება იყოს ყოველდღიური).

IF განცხადება მოქმედებს ამ გზით: ლოგიკური განცხადების შედეგი დაუყოვნებლივ მოწმდება. თუ შედეგი არის TRUE, მაშინ ემატება [statement_1], რომელიც მოჰყვება შემდეგ სერვისის სიტყვას და [statement_2] გამოტოვებულია. თუ შედეგი არის FALSE, მაშინ [statement_1] გამოტოვებულია და [statement_2] ემატება.

ვინაიდან Else ნაწილი არის დღე, IF განცხადება იღებს ახალ ფორმას:

IF [ლოგიკური გამოხატულება] შემდეგ [ოპერატორი];

ამ შემთხვევაში, თუ შედეგი არის TRUE, მაშინ [ოპერატორს] მოსდევს FALSE, შემდეგ განცხადება გადაეცემა ოპერატორს, რომელიც მიჰყვება IF ოპერატორს.

є 2 რიცხვი A და B. იპოვეთ მაქსიმალური რიცხვი.

საწყობის ოპერატორი

საწყობის ოპერატორი - პროგრამაში დამატებითი ოპერაციების თანმიმდევრობა მოთავსებულია ე.წ. ოპერატორის სახელურში (Begin-End).

ფორმატი: დასაწყისი [ოპერატორი]; Დასასრული;

საწყობის ოპერატორებს უფლება აქვთ წარმოადგინონ ოპერატორთა ჯგუფი ერთ ოპერატორად.

CASE შერჩევის ოპერატორი

მრავალი გამოთვლების განხორციელების მიზნები, ვინაიდან IF ოპერატორს შეუძლია განახორციელოს მხოლოდ ორი პირდაპირი გზა გაანგარიშების პროცესში, მისი გამოყენება მრავალჯერადი გამოთვლების განსახორციელებლად ყოველთვის არ არის ადვილი. მრავალჯერადი დაშლა ხორციელდება CASE ოპერატორის მიერ.

ფორმატი: CASE [select_key] OF

[მუდმივი_არჩევა_1]: [ოპერატორი_1];

[მუდმივი_არჩევა_2]: [ოპერატორი_2];

[მუდმივი_შერჩევის_N]: [ოპერატორი_N];

ELSE [ოპერატორი];

CASE, OF, ELSE, END – მომსახურების სიტყვები. [selection_key] - ერთ-ერთი რიგითი ტიპის პარამეტრი. [Constant_selection] - იგივე ტიპის მუდმივები, როგორც შერჩევის გასაღები, შერჩევის განსახორციელებლად. [Operator_1(N)] არის ძირითადი ოპერატორი. ELSE შეიძლება იყოს დღის განმავლობაში.

შერჩევის ოპერატორი მუშაობს ასე: ოპერატორის ფუნქციონირებამდე განისაზღვრება შერჩევის გასაღების პარამეტრის მნიშვნელობა. ეს პარამეტრი შეიძლება შეიცვალოს პროგრამაში ან სხვა გზით. მაშინ შერჩევის გასაღების პარამეტრი თანმიმდევრულად უდრის შერჩევის მუდმივას. როდესაც საკვანძო მნიშვნელობა არჩეულია ერთ-ერთი მუდმივიდან, არჩეულია ოპერატორი, რომელიც მიჰყვება ამ მუდმივას და ყველა სხვა ოპერატორი იგნორირებულია. თუ გასაღები არ არის არჩეული ერთ-ერთი მუდმივიდან, არჩეულია ოპერატორი, რომელიც მიჰყვება Else-ს. ხშირად Else არ არის სავალდებულო და გასაღების ვარიაციიდან გამომდინარე, თითოეული მუდმივი არჩევანი იგივეა, რაც Else, კონტროლი გადაეცემა ოპერატორს CASE განცხადების შემდეგ.

CASE განცხადებას არ აქვს IF განცხადების აშკარა გონებრივი შეცვლა. ამავდროულად, იმპლიციურად, გასწორების ოპერაცია სრულდება. CASE შემოაქვს დისონანსს Pascal-ის პროგრამაში, ოპერატორის მონაცემთა ფრაგმენტები მთავრდება სერვისული სიტყვით End, რომელსაც არ აქვს დაწყვილებული Begin.

შეადგინეთ ალგორითმი და პროგრამა, რომელიც მოდელირებს სინათლის სინათლის მუშაობას. ღია ფერის ფერების პირველი ასოს სიმბოლოს შეყვანისას პროგრამამ უნდა აჩვენოს შეტყობინებები შესაბამისი ფერისა და მოქმედების შესახებ.

პროგრამა მუშაობს ასე: კლავიატურიდან წაკითხვის პროცედურის გამოყენებით, შეიყვანეთ ასო სიმბოლო სინათლის ფერში. თუ შეყვანილია ასო 'z', რომელიც მიუთითებს მწვანე ფერზე, მაშინ CASE განცხადებაში მნიშვნელობა შეყვანილია შერჩევის სიაში, იპოვეთ შერჩევის მუდმივი 'z' და გამოჩნდება შეტყობინება "მწვანე ფერი, ფერი დაშვებულია". ასოების 'k' და 'g' შეყვანისას გამოჩნდება მსგავსი შეტყობინებები. ნებისმიერი სხვა სიმბოლოს შეყვანისას გამოჩნდება შეტყობინება "შუქი არ მუშაობს", რადგან გამოიყენება CASE განაცხადის სხვა ნაწილი.

მარყუჟის განცხადებები

ციკლური ალგორითმული სტრუქტურა ისეთი სტრუქტურაა, სადაც მოქმედებები რამდენჯერმე მეორდება. პროგრამას აქვს ორი ტიპის ციკლური სტრუქტურა: მარყუჟი პარამეტრით და განმეორებითი ციკლი.

პარამეტრის მქონე ციკლს აქვს შემდეგი სახელი ციკლის პარამეტრებისთვის: X, X n, X k, ∆X. ნებისმიერ ციკლს, რომელსაც აქვს პარამეტრი, ეწოდება რეგულარული ციკლი. დამახასიათებელი ბრინჯი არის ის, რომლის ციკლებისა და გამეორებების რაოდენობა შეიძლება გამოითვალოს ციკლის დასრულებამდე.

განმეორებით ციკლში შეუძლებელია მარყუჟების რაოდენობის დათვლა ბოლომდე. ციკლის დასრულების შემდეგ, ციკლის გონებრივი გაგრძელება მთავრდება.

პასკალს ჰყავს სამი ოპერატორი, რომლებიც ახორციელებენ ციკლური გამოთვლის სტრუქტურებს:

  • პირადი FOR ოპერატორი. არ არის საჭირო მარყუჟის დანერგვა პარამეტრით, ან შეიძლება გამოყენებულ იქნას განმეორებითი ციკლის განსახორციელებლად;
  • მარყუჟის ოპერატორი გონების შეცვლასთან ერთად WHILE;
  • გონებრივი მარყუჟის ოპერატორი REPEAT.

დანარჩენი ორი ორიენტირებულია განმეორებითი მარყუჟის განხორციელებაზე, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ისინი პარამეტრით მარყუჟის განხორციელების ნაცვლად.

ოპერატორისთვის

ფორმატი: FOR [loop_parameter] := [n_z_p_ts] რათა [k_z_p_ts] გავაკეთოთ [ოპერატორი];

FOR, To, Do არის სამსახურებრივი სიტყვები. [ციკლის_პარამეტრი] - ციკლის პარამეტრი. [n_z_p_ts] – ციკლის პარამეტრის საწყისი მნიშვნელობა. [k_z_p_ts] – ციკლის პარამეტრის ბოლო მნიშვნელობა. [ოპერატორი] კმაყოფილი ოპერატორია.

ციკლის პარამეტრი შეიძლება იყოს რიგითი ტიპის. ციკლის პარამეტრის საწყისი და დასასრული მნიშვნელობები შეიძლება იყოს იგივე ტიპის, როგორც ციკლის პარამეტრი.

მოდით შევხედოთ ოპერატორის მუშაობას ამ ალგორითმის გამოყენებით:

პირველ ეტაპზე, პარამეტრის მნიშვნელობა მიიღება [n_z_p_ts] ციკლისთვის, შემდეგ პარამეტრი მოწმდება ციკლისთვის ნაკლები ან მეტი [k_z_p_ts]. ეს არის ციკლის გონებრივი გაგრძელება. შეწყვეტის შემდეგ ციკლი აგრძელებს შესრულებას და [ოპერატორი] წყდება, რის შემდეგაც ციკლის პარამეტრი იზრდება (იცვლება) ერთით. შემდეგ, ახალი მნიშვნელობებით, ციკლის პარამეტრი შემოწმდება ციკლის გასაგრძელებლად. როგორც მეორდება, ისე მეორდება. როგორც კი გონება არ იცვლება, ციკლი აგრძელებს თავის მუშაობას.

For ოპერატორი აშკარად განსხვავდება სხვა პროგრამირების ენების მსგავსი ოპერატორებისგან. მოვალეობები შემდეგია:

  • For ოპერატორის სხეული. ოპერატორს შეუძლია ყოველ ჯერზე გასვლა, გონების შემოწმებისას და ციკლის დასრულებამდე გაგრძელებისას;
  • ციკლის მუდმივი და მოწინავე 1 პარამეტრის შეცვლის ხანგრძლივობა;
  • For განცხადებაში მარყუჟის სხეული არის ერთი ოპერატორი. ამ შემთხვევაში, როდესაც ციკლის სხეულის მოქმედება მოიცავს ერთზე მეტ მარტივ ოპერატორს, ოპერატორები უნდა გარდაიქმნას ერთ საწყობის ოპერატორად ოპერატორის სახელურების გამოყენებით (BEGIN-END);
  • მარყუჟის პარამეტრი შეიძლება შეიცვალოს რიგითი ტიპით.

FOR ოპერატორის ვიკის მაგალითი:რუბლის დოლარად გადაქცევის ცხრილის შედგენა.

WHILE ოპერატორი (მარყუჟის ოპერატორი აზროვნების შეცვლით)

ფორმატი: WHILE [umova] Do [ოპერატორი];

WHILE, Do – სამსახურის სიტყვები. [Umova] არის გამოხატვის ლოგიკური ტიპი. [ოპერატორი] - მეორადი ოპერატორი.

;

ოპერატორი while მოქმედებს შემდეგ ეტაპზე: ლოგიკური გონების შედეგი მოწმდება რობოტის დასაწყისში. თუ შედეგი მართალია, მაშინ ოპერატორი გარდაიქმნება, რის შემდეგაც იგი ამოწმებს გონებას პარამეტრების ახალი მნიშვნელობებით ლოგიკურ გონებაში. თუ შედეგი ტყუილია, ციკლი დასრულებულია.

With მუშაობისას თქვენ უნდა გაზარდოთ თქვენი ავტორიტეტის პატივისცემა:

  • umovy, vykoristani y ხოლო, є umovoy ციკლის გაგრძელება;
  • ციკლის განმავლობაში იცვლება ტვინის პარამეტრის მნიშვნელობა, რომელიც შედის ვირუსში;
  • მიუხედავად იმისა, რომ მარყუჟი შეიძლება არ დასრულდეს ყოველ ჯერზე, რადგან გონება ამოწმებს ციკლის დინებას, სანამ სხეული არ დასრულდება.

REPEAT ოპერატორი (მარყუჟის ოპერატორი)

ფორმატი: გამეორება [სხეულის_ციკლი]; სანამ [umova];

REPEAT ოპერატორი მუშაობს შემდეგ ეტაპზე: სხეულის ოპერატორები თავდაპირველად ემატება ციკლს, რის შემდეგაც შედეგი მოწმდება ლოგიკური გონებით. სისულელეების შედეგად ხდება ძირითადი სხეულის ოპერატორების უკუქცევა ციკლზე. თუ შედეგი მართალია, ოპერატორი ასრულებს სამუშაოს.

Repeat ოპერატორს აქვს შემდეგი მახასიათებლები:

  • Repeat-ში მოწმდება ციკლის გონებრივი დასრულება და ციკლის დასრულებისთანავე ციკლი გამოიყენება რობოტზე;
  • ციკლის სხეული სრულდება ერთხელ მაინც;
  • ციკლის განმავლობაში იცვლება გონების შემოწმების პარამეტრი;
  • ციკლის სხეულის ოპერატორებს არ სჭირდებათ ოპერატორის მკლავებში მოთავსება (BEGIN-END), ამ შემთხვევაში ოპერატორის იარაღის როლი ენიჭება Repeat და Until.

გამოთვალეთ y=sin(x), სადაც xn=10, xk=100, მნიშვნელობა უდრის 10-ს.

აპლიკაცია © 2022 მობილური და კომპიუტერული გაჯეტები