ประเภทของรอบ

วนซ้ำด้วยพารามิเตอร์ สำหรับ

วนซ้ำโดยมีเงื่อนไขเบื้องต้น

วงจร ในขณะที่ โดยมีเงื่อนไขเบื้องต้น

วงจร ทำซ้ำ - จนกระทั่ง ด้วยสภาวะภายหลัง

วนซ้ำโดยมีเงื่อนไขเบื้องต้นใน Pascal - WHILE

ตัวดำเนินการวนซ้ำที่มีเงื่อนไขเบื้องต้นจะดำเนินการโดยไม่ทราบจำนวนครั้ง การวนซ้ำจะสิ้นสุดลงหากนิพจน์เชิงตรรกะหรือผลลัพธ์กลายเป็นเท็จ

เพราะความจงรักภักดี การแสดงออกทางตรรกะมีการตรวจสอบตั้งแต่ต้น เนื้อความของลูปอาจไม่ถูกดำเนินการแม้แต่ครั้งเดียว

โครงสร้างห่วง ในขณะที่

บล็อก - แผนภาพวงจร ในขณะที่

ตัวดำเนินการ

เงื่อนไข

ตัวอย่าง

ภารกิจ: เขียนโปรแกรมที่คำนวณผลรวมของเลขคู่ทั้งหมดจนถึง 50

writeln("ผลรวมคือ: ",ผลรวม);

งาน

เขียนโปรแกรมที่ค้นหา n!.

วนซ้ำกับ postcondition ในภาษา Pascal – REPEAT-UNTIL

โอเปอเรเตอร์นี้คล้ายกับโอเปอเรเตอร์ลูปที่มีเงื่อนไขเบื้องต้น แต่แตกต่างตรงที่เงื่อนไขจะถูกตรวจสอบหลังจากดำเนินการเนื้อความ (การกระทำ) ของลูป เพื่อให้แน่ใจว่ามีการดำเนินการอย่างน้อยหนึ่งครั้ง ไม่เหมือนลูปที่แยกวิเคราะห์ก่อนหน้านี้

โปรดทราบว่า โอเปอเรเตอร์นี้วงจรหมายถึงการมีอยู่ของตัวดำเนินการหลายตัวในเนื้อความของวงจร นั่นคือสามารถดำเนินการได้หลายอย่าง ดังนั้นคำว่าบริการ เริ่ม และ จบ ไม่ต้องการ.

โครงสร้างห่วง

ทำซ้ำจนกระทั่ง

บล็อก - แผนภาพวงจร ทำซ้ำจนกระทั่ง

ตัวดำเนินการ

เงื่อนไข

ตัวอย่าง

ภารกิจ: เขียนโปรแกรมหาผลรวมของตัวเลขตัวแรกและตัวสุดท้ายของตัวเลข

a,b,c,d:จำนวนเต็ม;

writeln("ใส่ตัวเลข");

writeln('ผลรวมของตัวเลขตัวแรกและตัวสุดท้ายคือ:'c);

งาน

เขียนโปรแกรมกำหนดว่าจำนวนเฉพาะเป็นจำนวนเฉพาะหรือไม่

วนซ้ำด้วยพารามิเตอร์ใน Pascal - FOR

วงจร สำหรับ กำหนดเงื่อนไขที่โปรแกรมจะทำงานก่อนที่จะถูกดำเนินการ สมมติว่าคุณต้องวนซ้ำโปรแกรม n ครั้ง จากนั้นจึงทำได้อย่างง่ายดายโดยใช้การวนซ้ำนี้

วงจรยู สำหรับ มีคุณสมบัติเป็นลักษณะ - ตัวนับซึ่งโดยปกติจะกำหนดด้วยตัวอักษร i หรือ j

ในลูป สามารถระบุตัวนับได้โดยตรง (service word ถึง ) และในลำดับย้อนกลับ (คำที่ใช้งานได้ ลงไป ).

โครงสร้างห่วง สำหรับ

สำหรับ i:= n1 ถึง n2 DO

แบบฟอร์มการบันทึกครั้งที่ 1

สำหรับ i:= n2 ลงไป n1 DO

แบบฟอร์มการบันทึกครั้งที่ 2

บล็อก - แผนภาพวงจร สำหรับ

ผม:= n1 … n2

ตัวห่วง

ตัวอย่าง

ภารกิจ: เขียนโปรแกรมที่คำนวณกำลัง n ของจำนวนที่กำหนด

a, n, i, pr: จำนวนเต็ม;

writeln('กรอกตัวเลข');

writeln('ใส่กำลังของตัวเลข');

สำหรับฉัน:= 1 ถึง n ทำ

writeln('กำลังของตัวเลขคือ',pr);

งาน

เขียนโปรแกรมโดยหาตัวเลข P = (1-1/2)(1-1/3)*…*(1-1/n)

N ถูกป้อนจากแป้นพิมพ์

วนซ้ำด้วยเงื่อนไขเบื้องต้น หากไม่ทราบจำนวนการทำซ้ำล่วงหน้า แต่ระบุโดยเงื่อนไขเท่านั้น และการดำเนินการที่ต้องดำเนินการหลังจากตรวจสอบเงื่อนไขแล้วเท่านั้น ให้ใช้การวนซ้ำพร้อมเงื่อนไขเบื้องต้น นิพจน์เชิงตรรกะถูกใช้เป็นเงื่อนไข ส่วนเนื้อความของลูปคือตัวดำเนินการแบบง่ายหรือแบบผสม ก่อนการดำเนินการกับเนื้อความของลูปแต่ละครั้ง จะมีการตรวจสอบเงื่อนไข หากผลลัพธ์เป็น "จริง" จากนั้นเนื้อความของลูปจะถูกดำเนินการอีกครั้ง หากเป็น "เท็จ" แสดงว่าการวนซ้ำจะออกจากการทำงาน ในบล็อกไดอะแกรม ใน Pascal เริ่มต้นสิ้นสุด; เงื่อนไข เนื้อความของลูป ไม่มี แบบฝึกหัด เริ่มต้นของลูป สิ้นสุดของลูป ใช่ ขณะทำ

วนซ้ำด้วยเงื่อนไขภายหลัง หากไม่ทราบจำนวนการทำซ้ำล่วงหน้า แต่ระบุโดยเงื่อนไขเท่านั้น และการกระทำที่ต้องทำก่อนตรวจสอบเงื่อนไข ให้ใช้การวนซ้ำด้วยเงื่อนไขภายหลัง นิพจน์เชิงตรรกะถูกใช้เป็นเงื่อนไข ส่วนเนื้อความของลูปคือตัวดำเนินการแบบง่ายหรือแบบผสม หลังจากการดำเนินการกับเนื้อความของลูปแต่ละครั้ง จะมีการตรวจสอบเงื่อนไข หากผลลัพธ์เป็น "เท็จ" เนื้อความของลูปจะถูกดำเนินการอีกครั้ง หากเป็น "จริง" แสดงว่าการวนซ้ำออกจากการทำงาน ในแผนภาพบล็อก ใน Pascal Repeat Condition Loop Body ใช่ ไม่ ฝึกจนถึง ;

วนซ้ำด้วยพารามิเตอร์ ในกรณีที่ทราบจำนวนการทำซ้ำล่วงหน้า จะใช้การวนซ้ำพร้อมพารามิเตอร์ ตัวแปรที่ระบุจำนวนการทำซ้ำเรียกว่าพารามิเตอร์ลูปหรือตัวแปรควบคุม หลังจากการดำเนินการแต่ละครั้งของเนื้อหาลูป ตัวแปรควบคุมจะเพิ่มขึ้นหรือลดลง การวนซ้ำจะถูกดำเนินการจนกว่าจะเกินหรือน้อยกว่าขีดจำกัด ในแผนภาพบล็อกใน Pascal X คือตัวแปรควบคุม (พารามิเตอร์วงจร) A คือค่าเริ่มต้นของ X, B คือค่าสุดท้ายของ X C คือขั้นตอนของการเปลี่ยนแปลง X ในขั้นตอนนี้คุณสามารถใช้ได้เท่านั้น: “to” = 1; “downto” = -1 X:=A,B,C การฝึกวนร่างกายสำหรับ X:=A ถึง B เริ่มต้นสิ้นสุด;

ตัวอย่างของปัญหาการใช้ลูปที่มีเงื่อนไขเบื้องต้น เพิ่มเลข 3 ให้เป็นกำลังที่กำหนด ภารกิจ: อัลกอริธึมทางวาจา: คูณตัวเลข X โดยเริ่มแรกเท่ากับ 1 จำนวนครั้งที่กำหนด (H) ด้วย 3 เริ่ม H BHBH X: =1 X:=X*3 สิ้นสุด X ป้อนองศาที่กำหนด ค่าเริ่มต้น “B” ตัวนับองศา B=B+1 คูณด้วย 3 การเพิ่มตัวนับ การแสดงผลค่าผลลัพธ์ Programm Stepen; ตัวแปร H,B,X:จำนวนเต็ม; เริ่มเขียน(ปริญญา?); อ่าน(H); เอ็กซ์:=1; ข:=1; ในขณะที่บี

H X:=1 X:=X*3 สิ้นสุด X ป้อนกำลังที่กำหนด ค่าเริ่มต้น" title="ตัวอย่างงานที่ใช้ลูปโดยมีเงื่อนไขภายหลัง เพิ่มเลข 3 ให้เป็นกำลังที่กำหนด TASK: อัลกอริธึมทางวาจา: ทวีคูณ ตัวเลข X เริ่มต้นเท่ากับ 1 จำนวนครั้งที่กำหนด (H) สำหรับ 3. เริ่มต้น N B>=H X:=1 X:=X*3 สิ้นสุด X ป้อนระดับที่กำหนด ค่าเริ่มต้น" class="link_thumb"> 8 !}ตัวอย่างของปัญหาในการใช้ลูปที่มีเงื่อนไขหลัง เพิ่มเลข 3 ให้เป็นกำลังที่กำหนด ภารกิจ: อัลกอริธึมทางวาจา: คูณตัวเลข X โดยเริ่มแรกเท่ากับ 1 ซึ่งเป็นจำนวนครั้งที่ระบุ (H) ด้วย 3 เริ่ม H B>=H X :=1 X:=X*3 สิ้นสุด X เข้าสู่ระดับที่กำหนด ค่าเริ่มต้น “B” ตัวนับระดับ B=B+1 คูณด้วย 3 การเพิ่มตัวนับ เอาท์พุตมูลค่าผลลัพธ์ Programm Stepen; ตัวแปร H,B,X:จำนวนเต็ม; เริ่มเขียน(ปริญญา?); อ่าน(H); เอ็กซ์:=1; ข:=0; ทำซ้ำ X:=X*3; ข:=ข+1; จนกระทั่ง B>=H; Writeln(ผลลัพธ์,X); จบ. ไม่ใช่ ใช่ คำอธิบายแผนภาพบล็อกทฤษฎีปาสคาล B:=0 =H X:=1 X:=X*3 end X เข้าสู่ระดับที่กำหนด ค่าเริ่มต้น"> =H X:=1 X:=X*3 end X เข้าสู่ระดับที่กำหนด ค่าเริ่มต้น "B" ตัวนับองศา B=B +1 คูณด้วย 3 เพิ่มตัวนับเอาท์พุทค่าผลลัพธ์ โปรแกรม Stepen; Var H,B,X:integer; Begin Writeln(Degree?); Readln(H); X:=1; B:=0; ทำซ้ำ X:= X*3; B: =B+1; จนถึง B>=H; Writeln (ผลลัพธ์,X); สิ้นสุด ไม่ ใช่ ทฤษฎี Pascal Block Diagram คำอธิบาย B:=0"> =H X:=1 X:=X*3 end X ป้อนระดับที่กำหนด ค่าเริ่มต้น" title=" ตัวอย่างปัญหาโดยใช้ลูปที่มีเงื่อนไขภายหลัง เพิ่มเลข 3 ให้เป็นกำลังที่กำหนด ภารกิจ: อัลกอริธึมทางวาจา: คูณตัวเลข X เริ่มต้นเท่ากับ 1 ของตัวเลขที่กำหนด จำนวนครั้ง (H) คูณ 3 เริ่มต้น N B>=H X: =1 X:=X*3 สิ้นสุด X เข้าสู่ระดับที่กำหนด ค่าเริ่มต้น"> title="ตัวอย่างของปัญหาในการใช้ลูปที่มีเงื่อนไขหลัง เพิ่มเลข 3 ให้เป็นกำลังที่กำหนด ภารกิจ: อัลกอริธึมทางวาจา: คูณตัวเลข X โดยเริ่มแรกเท่ากับ 1 ซึ่งเป็นจำนวนครั้งที่ระบุ (H) ด้วย 3 เริ่ม H B>=H X :=1 X:=X*3 end X ป้อนระดับที่กำหนด ค่าเริ่มต้น"> !}

ตัวอย่างของงานที่ใช้ลูปพร้อมพารามิเตอร์ เพิ่มเลข 3 ให้เป็นกำลังที่กำหนด ภารกิจ: อัลกอริธึมทางวาจา: คูณตัวเลข X โดยเริ่มแรกเท่ากับ 1 ซึ่งเป็นจำนวนครั้งที่ระบุ (H) ด้วย 3 เริ่ม H X:=1 X:=X*3 สิ้นสุด X ป้อนกำลังที่กำหนด ค่าเริ่มต้น X=1 พารามิเตอร์จาก 1 ถึง N คูณด้วย 3 เอาต์พุตของค่าผลลัพธ์ โปรแกรม Stepen; ตัวแปร H,B,X:จำนวนเต็ม; เริ่มเขียน(ปริญญา?); อ่าน(H); เอ็กซ์:=1; สำหรับ B:=1 ถึง H ให้เริ่มต้น X:=X*3; จบ; Writeln(ผลลัพธ์,X); จบ. B:=1,H,1 คำอธิบายแผนภาพบล็อกทฤษฎีปาสคาล

ภารกิจ: เมื่อเริ่มฝึกแล้ว นักกีฬาวิ่ง 10 กม. ในวันแรก ทุกวันเขาเพิ่มบรรทัดฐานรายวัน 10% ของบรรทัดฐานของวันก่อนหน้า ระยะทางรวมที่นักกีฬาจะครอบคลุมใน 7 วันคือเท่าไร? ตัวแปรอินพุต: ตัวแปรเอาต์พุต: S – เส้นทางทั้งหมด d – จำนวนวัน Sd – ระยะทางสำหรับวันปัจจุบัน

คำถามท้ายเรื่องสำหรับการควบคุม: 1. ตัวดำเนินการใดใน Pascal กำหนดลูปที่มีเงื่อนไขเบื้องต้น 2. จะระบุขั้นตอน “1” และ “-1” ในพารามิเตอร์ในลูปได้อย่างไร 3. สาขาใดที่ลูปที่มีเงื่อนไขภายหลังตามมา? 4. มีพารามิเตอร์เงื่อนไขหรือไม่ 5. สิ่งที่สามารถเป็นเนื้อหาของลูปได้ 6. เมื่อใดที่ลูปพร้อมพารามิเตอร์ที่ใช้

สไลด์ 2

วางแผน

แนวคิดของลูป คำสั่ง Loop สำหรับ Loop While Loop Repeat Literature

สไลด์ 3

วรรณกรรม

คาสเตอร์นอฟ เอเอฟ, เอฟสตราโตวา จี.เอ. ภาษาโปรแกรมปาสคาล: บทช่วยสอนสำหรับมหาวิทยาลัย - Cherepovets: สถาบันการศึกษาของรัฐสำหรับการศึกษาวิชาชีพชั้นสูง ChSU, 2010. - 117 น. - บรรณานุกรม: หน้า 114. หนังสือเรียนอิเล็กทรอนิกส์เกี่ยวกับภาษาการเขียนโปรแกรม Pascal /http://pascal.guti.ru Plan

สไลด์ 4

แนวคิดของวัฏจักร

อัลกอริทึมในการแก้ปัญหาหลายอย่างเป็นแบบวนรอบเพื่อให้ได้ผลลัพธ์ ลำดับเฉพาะการดำเนินการจะดำเนินการหลายครั้ง ตัวอย่างเช่น โปรแกรมควบคุมความรู้แสดงคำถาม ยอมรับคำตอบ เพิ่มเครื่องหมายสำหรับคำตอบของคะแนนรวม จากนั้นทำซ้ำการกระทำเหล่านี้จนกว่าผู้เรียนจะตอบคำถามทั้งหมด หรือเช่นหากต้องการค้นหานามสกุลที่ต้องการในรายการคุณควรตรวจสอบนามสกุลแรกในรายการเพื่อดูว่าตรงกับนามสกุลที่ค้นหาจากนั้นนามสกุลที่สองที่สามเป็นต้น จนกว่าจะพบนามสกุลที่ต้องการหรือถึงจุดสิ้นสุดของรายการ

สไลด์ 5

อัลกอริธึมที่มีกลุ่มของคำสั่งที่ถูกดำเนินการหลายครั้งเรียกว่าวงจร กลุ่มของคำสั่งที่ซ้ำกันเรียกว่าส่วนเนื้อหาของลูป ในภาษาปาสคาล สามารถใช้คำสั่งลูป For, While และ Repeat ได้ วางแผน

สไลด์ 6

สำหรับโอเปอเรเตอร์แบบวนซ้ำ

ตัวดำเนินการ For loop จะใช้หากจำเป็นต้องดำเนินการเนื้อความของ loop หลายครั้ง และทราบจำนวนครั้งของการทำซ้ำล่วงหน้า

สไลด์ 7

รูปแบบที่ 1 ของการเขียนตัวดำเนินการ For loop

รูปแบบที่ 1 ของการเขียนตัวดำเนินการ For ใน ปริทัศน์มีลักษณะดังนี้: ForCounter:=Start_valuetoFinal_valuedoOperator; โดยที่ For, to, do เป็นคำฟังก์ชัน ตัวนับคือตัวแปรลำดับ (โดยปกติจะเป็นจำนวนเต็ม) ที่กำหนดจำนวนครั้งที่การวนซ้ำจะเกิดซ้ำ จำนวนการซ้ำคำนวณโดยใช้สูตร: Final_value – Initial_value+1 End_Value ต้องมากกว่าหรือเท่ากับ Start_Value

สไลด์ 8

หากเนื้อความของลูปประกอบด้วยตัวดำเนินการหลายตัว รูปแบบที่ 1 ของการเขียนตัวดำเนินการ For จะมีลักษณะดังนี้: ForCounter:=Start_valuetoFinal_valuedo Begin (เนื้อความของห่วง) สิ้นสุด;

สไลด์ 9

มาดูอัลกอริทึมของ For loop ในรูปแบบแรกของการเขียนกัน ตัวนับถูกกำหนดเป็นค่าเริ่มต้น_ มีการตรวจสอบเงื่อนไข: ค่าตัวนับมากกว่าค่า End_value หรือไม่ หากเงื่อนไขเป็นจริง (ใช่) การวนซ้ำจะสิ้นสุด หากเงื่อนไขเป็นเท็จ (ไม่ใช่) เนื้อความของลูปจะถูกดำเนินการ จากนั้นค่าตัวนับจะเพิ่มขึ้นหนึ่งค่า และตรวจสอบเงื่อนไขอีกครั้ง เช่น ข้อ 2.

สไลด์ 10

รูปแบบที่ 2 ของการเขียนตัวดำเนินการ For loop

รูปแบบที่ 2 ของการเขียนตัวดำเนินการ For โดยทั่วไปมีลักษณะดังนี้: For Counter:=Start_valuedowntoFinal_valuedoOperator; โดยที่: สำหรับ, downto, do เป็นคำที่ทำหน้าที่ ตัวนับคือตัวแปรลำดับ (โดยปกติจะเป็นจำนวนเต็ม) ที่กำหนดจำนวนครั้งที่การวนซ้ำจะเกิดซ้ำ จำนวนการซ้ำคำนวณโดยใช้สูตร: Start_value–Final_value+1 Start_Value ต้องมากกว่าหรือเท่ากับ End_Value

สไลด์ 11

หากเนื้อความของลูปประกอบด้วยตัวดำเนินการหลายตัว รูปแบบที่ 2 ของการเขียนตัวดำเนินการ For จะมีลักษณะดังนี้: ForCounter:=Start_valuedowntoFinal_valuedo Begin //Loop body End;

สไลด์ 12

ลองพิจารณาอัลกอริทึมของ For loop ในรูปแบบที่สองของสัญลักษณ์: ตัวนับถูกกำหนดเป็นค่า Initial_ มีการตรวจสอบเงื่อนไข: ค่าตัวนับน้อยกว่าค่า End_value หรือไม่ หากเงื่อนไขเป็นจริง (ใช่) การวนซ้ำจะสิ้นสุด หากเงื่อนไขเป็นเท็จ (ไม่ใช่) เนื้อความของลูปจะถูกดำเนินการ ค่าตัวนับจะลดลงหนึ่งค่า และตรวจสอบเงื่อนไขอีกครั้ง เช่น ข้อ 2.

สไลด์ 13

สำหรับโอเปอเรเตอร์แบบวนซ้ำ

โปรแกรมEx1; var i, n:จำนวนเต็ม; (i – ตัวนับ, n – จำนวนดาวที่ต้องการ) s:string;(s – สตริงดาวที่สร้างขึ้น) เริ่มต้น Writeln("ป้อนจำนวนดาว"); (สอบถามจำนวนดาว) Readln(n); (ผู้ใช้กรอกจำนวนดาว n) s:=""; (การสร้างสตริงเครื่องหมายดอกจันเริ่มต้นด้วยสตริงว่าง) (สตริงถูกสร้างขึ้นโดยใช้ For loop ค่า default_value ของตัวนับคือ 1 ค่า Final_value คือจำนวนดาวที่ต้องการ n) fori:= 1 ถึง n do s :=s+"*"; (ในแต่ละขั้นตอนของลูปจะมีเครื่องหมายดอกจันติดอยู่ที่บรรทัด) Writeln(s) (บรรทัดถูกพิมพ์) Readln; จบ. ตัวอย่างแผน: โปรแกรมสร้างกลุ่มดาว จำนวนดาวในบรรทัดจะถูกกำหนดโดยผู้ใช้

สไลด์ 14

ในขณะที่วนซ้ำ

ลูป While ถูกใช้เมื่อไม่ทราบจำนวนการทำซ้ำของเนื้อหาลูปในระหว่างการพัฒนาโปรแกรม และสามารถระบุได้เฉพาะในขณะที่โปรแกรมกำลังทำงานอยู่เท่านั้น โดยทั่วไป คำสั่ง While จะถูกเขียนดังนี้: While Condition doOperator; โดยที่ While คือคำที่ทำหน้าที่ เงื่อนไขคือนิพจน์เชิงตรรกะที่กำหนดความต่อเนื่องของการวนซ้ำ

สไลด์ 15

หากเนื้อหาของลูปประกอบด้วยหลายคำสั่ง ดังนั้นการวนรอบ While จะถูกเขียนดังนี้: WhileCondition do Begin //Loop body End;

สไลด์ 16

มาดูอัลกอริทึมของ While loop: มีการตรวจสอบเงื่อนไขแล้ว หากเงื่อนไขเป็นจริง เนื้อความของลูปจะถูกดำเนินการ หลังจากนั้นจะมีการตรวจสอบเงื่อนไขอีกครั้ง หากเงื่อนไขเป็นเท็จ การวนซ้ำก็จะสิ้นสุดลง

สไลด์ 17

ดังนั้น While คือลูปที่มีเงื่อนไขเบื้องต้นหรือลูป "While" (เนื้อความของลูปจะถูกดำเนินการในขณะที่เงื่อนไขเป็นจริง) ถ้าเงื่อนไขเป็นเท็จในการผ่านครั้งแรกของลูป เนื้อความของลูปจะไม่ถูกดำเนินการแม้แต่ครั้งเดียว หากเงื่อนไขไม่เคยกลายเป็นเท็จ การวนซ้ำจะเกิดซ้ำไปเรื่อยๆ เช่น การวนซ้ำจะเกิดขึ้น

สไลด์ 18

โปรแกรมEx2; varAccount: จริง; (ขนาดบัญชี) เดือน: จำนวนเต็ม; (จำนวนเดือนที่ผ่านไปนับตั้งแต่เปิดบัญชี) เริ่มต้นบัญชี:=1000; (ฝาก 1,000 รูเบิลเข้าบัญชี) เดือน:=0; (บัญชีเพิ่งเปิด) ในขณะที่บัญชี

สไลด์ 19

ทำซ้ำวงจร

ลูปทำซ้ำ เช่นเดียวกับลูป While ถูกใช้ในโปรแกรมหากจำเป็นต้องดำเนินการกับเนื้อความของลูปหลายๆ ครั้ง แต่ไม่ทราบจำนวนการทำซ้ำล่วงหน้า โดยทั่วไป ลูปทำซ้ำจะถูกเขียนดังนี้: ทำซ้ำ //เนื้อความของลูปจนกระทั่งเงื่อนไข; โดยที่ซ้ำ, จนกระทั่งเป็นคำฟังก์ชัน เงื่อนไขคือนิพจน์บูลีนที่กำหนดจุดสิ้นสุดของการวนซ้ำ

สไลด์ 20

ลองพิจารณาอัลกอริทึมของลูปทำซ้ำ: เนื้อความของลูปที่อยู่ระหว่างคำสงวนทำซ้ำและจนกระทั่งถูกดำเนินการ มีการตรวจสอบสภาพ หากเงื่อนไขเป็นจริง การวนซ้ำจะสิ้นสุดลง หากเงื่อนไขเป็นเท็จ เนื้อความของลูปจะถูกดำเนินการอีกครั้ง

สไลด์ 21

ดังนั้น Repet จึงเป็นลูปที่มีเงื่อนไขภายหลังหรือลูป "Before" (เนื้อความของลูปจะถูกดำเนินการจนกว่าเงื่อนไขจะเป็นจริง) ดังนั้นเนื้อความของลูปจึงถูกดำเนินการอย่างน้อยหนึ่งครั้ง ถ้าเงื่อนไขไม่เคยเป็นจริง การวนซ้ำจะไม่มีที่สิ้นสุด

สไลด์ 22

โปรแกรมEx3; var เวลา: จำนวนเต็ม; (เวลาหาร) เซลล์: จำนวนเต็ม;(จำนวนเซลล์) เริ่มต้นเวลา:=0;(เซลล์ยังไม่ได้เริ่มการแบ่ง) เซลล์:=1;(หนึ่งเซลล์) ทำซ้ำเวลา:=Time+3;(ในอีกสามชั่วโมงข้างหน้า ) เซลล์: =เซลล์*2;(จำนวนเซลล์เพิ่มขึ้น 2 เท่า) จนกระทั่งเซลล์>24; (จนกระทั่งเงื่อนไข “จำนวนเซลล์มากกว่า 24” เป็นจริง) Writeln(Time); (ส่งออกผลลัพธ์) Readln; จบ. ตัวอย่างแผน: อะมีบาเซลล์เดียวแบ่งออกเป็น 2 เซลล์ทุกๆ 3 ชั่วโมง กำหนดจำนวนเซลล์ที่จะเกิน 24 ในเวลาต่อมากี่ชั่วโมง

ดูสไลด์ทั้งหมด

กลับไปข้างหน้า

ความสนใจ! ดูตัวอย่างสไลด์นี้มีวัตถุประสงค์เพื่อให้ข้อมูลเท่านั้นและอาจไม่ได้แสดงถึงคุณลักษณะทั้งหมดของการนำเสนอ ถ้าคุณสนใจ งานนี้กรุณาดาวน์โหลดเวอร์ชันเต็ม

เป้า:ศึกษาโครงสร้างอัลกอริทึมของวัฏจักร การสร้างแบบจำลองและอัลกอริทึมสำหรับการแก้ปัญหาเชิงปฏิบัติ

ในระหว่างเรียน

I. การอัพเดตความรู้

• ทบทวนแนวคิดของอัลกอริทึมและโครงสร้างพื้นฐานของภาษาอัลกอริทึม
• สามารถพัฒนาได้ แบบจำลองทางคณิตศาสตร์อัลกอริทึมและบล็อกไดอะแกรมสำหรับการแก้ปัญหา
• มีความเข้าใจในภาษาการเขียนโปรแกรมและวัตถุประสงค์
• สามารถทำงานในสภาพแวดล้อมการเขียนโปรแกรมได้
• รู้โครงสร้างของโปรแกรม
• สามารถเขียนนิพจน์ที่มีปริมาณเชิงตัวเลขและเชิงสัญลักษณ์ได้
• รู้โครงสร้างของผู้ปฏิบัติงานและคุณลักษณะของงาน
• สามารถใช้โอเปอเรเตอร์ในการเขียนโปรแกรมที่มีโครงสร้างเชิงเส้นและแบบแยกสาขาได้
• สามารถสร้างและรันโปรแกรมบนคอมพิวเตอร์เพื่อทำการดีบักได้

ครั้งที่สอง เนื้อหาทางทฤษฎีของบทเรียน

ปัญหาในทางปฏิบัติส่วนใหญ่จำเป็นต้องมีการกระทำเดิมซ้ำๆ กัน นั่นคือ การใช้ตัวดำเนินการตั้งแต่หนึ่งตัวขึ้นไปซ้ำ (การนำเสนอ)

สมมติว่าคุณต้องป้อนและประมวลผลลำดับตัวเลข หากมีเพียงห้าตัวเลข คุณสามารถสร้างอัลกอริทึมเชิงเส้นได้ หากมีมากกว่าหนึ่งพันรายการก็เป็นไปได้ที่จะเขียนอัลกอริธึมเชิงเส้น แต่มันน่าเบื่อและไร้เหตุผลมาก หากไม่ทราบจำนวนตัวเลขในขณะที่พัฒนาอัลกอริทึม แสดงว่าอัลกอริทึมเชิงเส้นนั้นเป็นไปไม่ได้โดยพื้นฐาน

ตัวอย่างอื่น. หากต้องการค้นหานามสกุลของบุคคลในรายการ คุณต้องตรวจสอบชื่อนามสกุลในรายการ จากนั้นจึงตรวจสอบนามสกุลที่สอง สาม ฯลฯ จนกว่าจะเจออันที่ต้องการหรือถึงจุดสิ้นสุดของรายการ คุณสามารถเอาชนะความยากลำบากดังกล่าวได้ด้วยความช่วยเหลือของวงจร

วงจรคือส่วนของอัลกอริธึม (โปรแกรม) ที่ถูกดำเนินการซ้ำๆ ดังนั้น อัลกอริธึมแบบวนรอบจึงเป็นอัลกอริธึมที่มีวัฏจักร

วัฏจักรมีสองประเภท: โดยไม่ทราบจำนวนการทำซ้ำ และไม่ทราบจำนวนการทำซ้ำ ในทั้งสองกรณี นี่หมายถึงจำนวนการทำซ้ำในขั้นตอนการพัฒนาอัลกอริทึม

โครงสร้างวงจรมี 3 ประเภท:

• วนซ้ำโดยมีเงื่อนไขเบื้องต้น
• วนซ้ำกับเงื่อนไขหลัง;
• วนซ้ำด้วยพารามิเตอร์

มิฉะนั้น โครงสร้างเหล่านี้จะเรียกว่าวัฏจักร เช่น "ขณะ" "ก่อน" "สำหรับ"

รูปแบบกราฟิกของข้อมูลการบันทึกของโครงสร้างอัลกอริทึม:

วนซ้ำด้วยเงื่อนไขเบื้องต้น (aka loop ลาก่อน) มีรูปแบบ:

เงื่อนไข – การแสดงออกของประเภทตรรกะ

การวนซ้ำอาจไม่ถูกดำเนินการแม้แต่ครั้งเดียวหากค่าของนิพจน์เชิงตรรกะกลายเป็นเท็จทันที

ชุดคำสั่งระหว่าง start และ end จะถูกดำเนินการจนถึง ในขณะที่เงื่อนไขเป็นจริง .

สำหรับการที่ เพื่อให้วงจรสิ้นสุดลงจำเป็นที่ลำดับคำสั่งระหว่าง BEGIN และ END จะเปลี่ยนค่าของตัวแปรที่รวมอยู่ในนั้น เงื่อนไข.

วนซ้ำด้วยเงื่อนไขภายหลัง (aka loop ก่อน) มีรูปแบบ:

เงื่อนไข – การแสดงออกของประเภทตรรกะ

บันทึก:

ลำดับคำสั่งระหว่างทำซ้ำ และจนกระทั่ง จะสำเร็จเสมอไป อย่างน้อยหนึ่งครั้ง;

เพื่อให้การวนซ้ำเสร็จสมบูรณ์จำเป็นต้องมีลำดับของคำสั่งระหว่างทำซ้ำ และจนกระทั่ง เปลี่ยนค่าของตัวแปรที่รวมอยู่ในนิพจน์เงื่อนไข

คำสั่งทำซ้ำ เช่นเดียวกับคำสั่ง while จะถูกใช้ในโปรแกรมหากจำเป็นต้องทำการคำนวณซ้ำ (ลูป) แต่ไม่ทราบจำนวนการทำซ้ำล่วงหน้า และถูกกำหนดโดยความคืบหน้าของการคำนวณเอง

วนซ้ำด้วยพารามิเตอร์ (aka loop สำหรับ)มีรูปแบบ:

ฉัน – พารามิเตอร์รอบ;
a – ค่าเริ่มต้นของวงจร;
b – ค่าสุดท้ายของวงจร
h – ขั้นตอนการเปลี่ยนพารามิเตอร์

โครงสร้างของวัฏจักรนี้เรียกอย่างอื่น วนรอบฉันครั้ง.

คำสั่งนี้ดำเนินการในลักษณะนี้: พารามิเตอร์ i ถูกตั้งค่าเป็นค่าเริ่มต้น a เปรียบเทียบกับค่าสุดท้าย b และหากน้อยกว่าหรือเท่ากับค่าสุดท้าย b ชุดคำสั่งจะถูกดำเนินการ พารามิเตอร์ถูกกำหนดให้เป็นค่าของพารามิเตอร์ก่อนหน้าเพิ่มขึ้น ชม.– ขั้นตอนของการเปลี่ยนแปลงพารามิเตอร์และเปรียบเทียบกับค่าสุดท้าย b อีกครั้ง

ในภาษาการเขียนโปรแกรม Pascal ขั้นตอนการเปลี่ยนแปลงพารามิเตอร์สามารถเท่ากับหนึ่งหรือลบหนึ่งได้

หากมีคำสั่งเดียวระหว่าง start และ end ก็ไม่จำเป็นต้องเขียนวงเล็บโอเปอเรเตอร์ กฎนี้ใช้ได้กับลูปเช่น "While" และ "For"

ลองดูตัวอย่างการแก้ปัญหาโดยใช้โครงสร้างเหล่านี้

ตัวอย่าง.

คำนวณผลคูณของตัวเลขตั้งแต่ 1 ถึง 5 โดยใช้ตัวเลือกการวนซ้ำต่างๆ

แบบจำลองทางคณิตศาสตร์:

Р= 1·2·3·4·5=120

มาเขียนอัลกอริทึมในรูปแบบของบล็อกไดอะแกรม

เพื่อตรวจสอบความถูกต้องของอัลกอริธึม ให้กรอกข้อมูลในตารางการติดตาม

ขั้นตอน	การดำเนินการ	ร	ฉัน	การตรวจสอบสภาพ
1	ป:=1	1
2	ฉัน:=1;	1	1
3	ฉัน<=5 ป:=ป*ผม ผม:=ผม+1	1	1	1<=5, да (истина)
4	ฉัน<=5 ป:=ป*ผม ผม:=ผม+1	2	2	2<=5, да (истина)
5	ฉัน<=5 ป:=ป*ผม ผม:=ผม+1	6	3	3<=5, да (истина)
6	ฉัน<=5 ป:=ป*ผม ผม:=ผม+1	24	4	4<=5, да (истина)
7	ฉัน<=5 ป:=ป*ผม ผม:=ผม+1	120	5	5<=5, да (истина)
8	ฉัน<=5 ป:=ป*ผม ผม:=ผม+1			6<=5, нет (ложь)

การตรวจสอบเงื่อนไขเกิดขึ้นในหลายขั้นตอน: การตรวจสอบเงื่อนไขและการดำเนินการคำสั่งบนสาขาใดสาขาหนึ่ง ดังนั้นตารางการติดตามจะไม่บันทึกคำสั่งอัลกอริธึม แต่เป็นการดำเนินการแต่ละรายการที่คอมพิวเตอร์ดำเนินการในแต่ละขั้นตอน

ขั้นตอนแรก: P ได้รับการกำหนดให้มีค่าเป็นหนึ่ง

ขั้นตอนที่สอง: ฉันได้รับมอบหมายค่าหนึ่ง

ขั้นตอนที่สาม: เมื่อ i เท่ากับ 1 เราก็ตรวจดูว่าเงื่อนไข 1 น้อยกว่าหรือเท่ากับ 5 ใช่แล้ว เงื่อนไขเป็นจริง คือ ให้ P มีค่า 1 คูณ 1 ก็จะได้ 2 สำหรับ i: หนึ่งบวกหนึ่งเท่ากับสอง

ขั้นตอนที่สี่:เมื่อ i เท่ากับ 2 เราก็ตรวจดูว่าเงื่อนไข 2 น้อยกว่าหรือเท่ากับ 5 ใช่แล้ว เงื่อนไขเป็นจริง คือ ให้ P มีค่า 2 คูณ 1 จะเป็น 2 สำหรับ i: 2 บวก 1 มันจะเป็นสาม

ขั้นตอนที่ห้า:โดยที่ i เท่ากับ 3 เราก็ตรวจดูว่าเงื่อนไข 3 น้อยกว่าหรือเท่ากับ 5 ใช่แล้ว เงื่อนไขเป็นจริง แปลว่า P มีค่าเป็น 2 คูณ 3 ก็จะได้เป็น 6 สำหรับ i: สามบวกหนึ่งเท่ากับสี่

ขั้นตอนที่หก:โดยที่ i เท่ากับ 4 เราก็ตรวจดูว่าเงื่อนไขที่ 4 น้อยกว่าหรือเท่ากับ 5 ใช่แล้ว เงื่อนไขเป็นจริง แปลว่า P มีค่าเท่ากับ 6 คูณ 4 ก็จะเท่ากับ 24 สำหรับฉัน: สี่บวกหนึ่งเท่ากับห้า

ขั้นตอนที่เจ็ด:โดย i เท่ากับ 5 เราก็ตรวจดูว่าเงื่อนไข 5 น้อยกว่าหรือเท่ากับ 5 ใช่แล้ว เงื่อนไขเป็นจริง คือ ให้ P มีค่าเป็น 24 คูณ 5 ก็จะได้เป็น 120 สำหรับฉัน: ห้าบวกหนึ่งเป็นหก

ขั้นตอนที่แปด:เมื่อ i เท่ากับ 6 เราก็เช็คว่าเงื่อนไข 6 น้อยกว่าหรือเท่ากับ 5 ไม่ใช่ เงื่อนไขเป็นเท็จ แล้วเราก็ออกจาก loop แล้วผลที่ได้คือค่าสุดท้ายเท่ากับ 120 .

โปรแกรม PR1;
ตัวแปร i: จำนวนเต็ม;
เริ่ม
ป:=1;
ฉัน:=1;
ขณะที่ฉัน<=5 do
เริ่ม
ป:=P*ฉัน;
ฉัน:=ฉัน+1;
จบ;
เขียน('P=', P);
จบ.

สำหรับการวนซ้ำที่มีเงื่อนไขภายหลัง เราจะสร้างบล็อกไดอะแกรมและตารางการติดตาม (สไลด์16)

เป็นผลให้เราได้ค่าสุดท้ายเท่ากับหนึ่งร้อยยี่สิบในขั้นตอนที่เจ็ด

และสำหรับไซเคิลที่มีพารามิเตอร์ เราจะสร้างบล็อกไดอะแกรมและตารางการติดตาม (สไลด์ 17)

เป็นผลให้เราได้ค่าสุดท้ายเท่ากับหนึ่งร้อยยี่สิบในขั้นตอนที่หก

งาน:

แสดงตัวเลขตั้งแต่ 1 ถึง 5 ใน:

1. สั่งตรง;
2. ในลำดับย้อนกลับ

แบบจำลองทางคณิตศาสตร์:

1. 1 2 3 4 5;
2. 5 4 3 2 1.

แผนภาพบล็อกและโปรแกรมสำหรับการแก้ปัญหาจะแสดงสำหรับตัวเลขในลำดับไปข้างหน้าและย้อนกลับ

(สไลด์ 21)

ให้เราเขียนอัลกอริธึมที่พิจารณาในภาษาการเขียนโปรแกรม Pascal

(สไลด์ 22)

สาม. สรุปบทเรียน

ดังนั้นเราจึงพิจารณาคำถามต่อไปนี้:

1. วงจรโครงสร้างอัลกอริทึม
2. ประเภทของโครงสร้างอัลกอริทึม:
   1. วนซ้ำโดยมีเงื่อนไขเบื้องต้น
   2. วนซ้ำกับเงื่อนไขหลัง;
   3. วนซ้ำด้วยพารามิเตอร์
3. เราพิจารณาวิธีการบันทึกโครงสร้างเหล่านี้
4. เราดูตัวอย่างการแก้ปัญหาโดยใช้โครงสร้างเหล่านี้