ວິທີການສອນວິທີການເອົາຊະນະຄວາມຫຍຸ້ງຍາກ, ແລະໃນເວລາດຽວກັນຂຽນຮອບວຽນ

ເຖິງວ່າຈະມີຄວາມຈິງທີ່ວ່າພວກເຮົາຈະສົນທະນາກ່ຽວກັບຫນຶ່ງໃນຫົວຂໍ້ພື້ນຖານ, ບົດຄວາມນີ້ຖືກຂຽນສໍາລັບຜູ້ຊ່ຽວຊານທີ່ມີປະສົບການ. ເປົ້າຫມາຍແມ່ນເພື່ອສະແດງໃຫ້ເຫັນສິ່ງທີ່ຜູ້ເລີ່ມຕົ້ນມີຄວາມເຂົ້າໃຈຜິດໃນການດໍາເນີນໂຄງການ. ສໍາລັບນັກພັດທະນາປະຕິບັດ, ບັນຫາເຫຼົ່ານີ້ໄດ້ຮັບການແກ້ໄຂຍາວ, ລືມຫຼືບໍ່ໄດ້ສັງເກດເຫັນທັງຫມົດ. ບົດຄວາມອາດຈະເປັນປະໂຫຍດຖ້າຫາກວ່າທ່ານທັນທີທັນໃດຈໍາເປັນຕ້ອງໄດ້ຊ່ວຍເຫຼືອຄົນທີ່ມີຫົວຂໍ້ນີ້. ບົດຄວາມໄດ້ແຕ້ມຂະຫນານກັບເອກະສານຈາກປື້ມຕ່າງໆກ່ຽວກັບການດໍາເນີນໂຄງການໂດຍ Schildt, Stroustrup, Okulov.

ຫົວຂໍ້ກ່ຽວກັບວົງຈອນໄດ້ຖືກເລືອກເພາະວ່າຂ້ອນຂ້າງຫຼາຍຂອງປະຊາຊົນໄດ້ຖືກຍົກເວັ້ນຈາກມັນໃນເວລາທີ່ mastering programming.

ເຕັກນິກນີ້ຖືກອອກແບບມາສໍາລັບນັກຮຽນທີ່ອ່ອນແອ. ຕາມກົດລະບຽບ, ຄົນທີ່ເຂັ້ມແຂງບໍ່ຕິດຢູ່ໃນຫົວຂໍ້ນີ້ແລະບໍ່ຈໍາເປັນຕ້ອງມີເຕັກນິກພິເສດສໍາລັບພວກເຂົາ. ເປົ້າ​ຫມາຍ​ມັດ​ທະ​ຍົມ​ຂອງ​ບົດ​ຄວາມ​ແມ່ນ​ເພື່ອ​ຍ້າຍ​ເຕັກ​ນິກ​ການ​ນີ້​ຈາກ "ເຮັດ​ວຽກ​ສໍາ​ລັບ​ນັກ​ສຶກ​ສາ​ທັງ​ຫມົດ​, ແຕ່​ມີ​ຄູ​ອາ​ຈານ​ພຽງ​ແຕ່​ຫນຶ່ງ​" ຫ້ອງ​ຮຽນ "ເຮັດ​ວຽກ​ສໍາ​ລັບ​ນັກ​ຮຽນ​ທັງ​ຫມົດ​, ຄູ​ອາ​ຈານ​ທັງ​ຫມົດ​"​. ຂ້ອຍບໍ່ອ້າງຄວາມເປັນຕົ້ນສະບັບຢ່າງແທ້ຈິງ. ຖ້າທ່ານກໍາລັງໃຊ້ວິທີການທີ່ຄ້າຍຄືກັນເພື່ອສອນຫົວຂໍ້ນີ້, ກະລຸນາຂຽນວ່າສະບັບຂອງເຈົ້າແຕກຕ່າງກັນແນວໃດ. ຖ້າທ່ານຕັດສິນໃຈໃຊ້ມັນ, ບອກພວກເຮົາວ່າມັນໄປແນວໃດ. ຖ້າເຕັກນິກທີ່ຄ້າຍຄືກັນຖືກອະທິບາຍໄວ້ໃນປຶ້ມ, ກະລຸນາຂຽນຊື່.

ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ເຮັດ​ວຽກ​ກ່ຽວ​ກັບ​ເຕັກ​ນິກ​ການ​ນີ້​ສໍາ​ລັບ 4 ປີ​, ການ​ສຶກ​ສາ​ສ່ວນ​ບຸກ​ຄົນ​ກັບ​ນັກ​ສຶກ​ສາ​ຂອງ​ລະ​ດັບ​ການ​ຝຶກ​ອົບ​ຮົມ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​. ໃນຈໍານວນທັງຫມົດມີນັກຮຽນປະມານຫ້າສິບຄົນແລະສອງພັນຊົ່ວໂມງຂອງຫ້ອງຮຽນ. ໃນຕອນທໍາອິດ, ນັກສຶກສາສະເຫມີຕິດຢູ່ໃນຫົວຂໍ້ນີ້ແລະປະໄວ້. ຫຼັງຈາກນັກຮຽນແຕ່ລະຄົນ, ວິທີການແລະອຸປະກອນໄດ້ຖືກດັດແປງ. ໃນໄລຍະປີທີ່ຜ່ານມາ, ນັກຮຽນບໍ່ໄດ້ຕິດຢູ່ໃນຫົວຂໍ້ນີ້ອີກຕໍ່ໄປ, ດັ່ງນັ້ນຂ້ອຍຈຶ່ງຕັດສິນໃຈແບ່ງປັນການຄົ້ນພົບຂອງຂ້ອຍ.

ເປັນ​ຫຍັງ​ຫຼາຍ​ຕົວ​ອັກ​ສອນ​? ຮອບວຽນແມ່ນປະຖົມຫຼາຍ!

ດັ່ງທີ່ຂ້າພະເຈົ້າຂຽນໄວ້ຂ້າງເທິງ, ສໍາລັບການປະຕິບັດນັກພັດທະນາແລະນັກຮຽນທີ່ເຂັ້ມແຂງ, ຄວາມສັບສົນຂອງແນວຄວາມຄິດຂອງ loops ສາມາດຖືກຄາດຄະເນໄດ້. ຕົວຢ່າງ, ເຈົ້າສາມາດບັນຍາຍຍາວ, ເບິ່ງຫົວຫົວ ແລະຕາອັດສະລິຍະ. ແຕ່ເມື່ອພະຍາຍາມແກ້ໄຂບັນຫາໃດກໍ່ຕາມ, ບັນຫາ stupor ແລະ inexplicable ເລີ່ມຕົ້ນ. ຫຼັງ​ຈາກ​ການ​ບັນ​ຍາຍ​, ນັກ​ສຶກ​ສາ​ອາດ​ຈະ​ມີ​ຄວາມ​ເຂົ້າ​ໃຈ​ພຽງ​ແຕ່​ບາງ​ສ່ວນ​. ສະຖານະການແມ່ນຮ້າຍແຮງຂຶ້ນໂດຍຄວາມຈິງທີ່ວ່ານັກຮຽນເອງບໍ່ສາມາດເວົ້າໄດ້ວ່າຄວາມຫຼົງໄຫຼຂອງພວກເຂົາແມ່ນຫຍັງ.
ມື້ຫນຶ່ງຂ້າພະເຈົ້າຮັບຮູ້ວ່ານັກສຶກສາຮັບຮູ້ຕົວຢ່າງຂອງຂ້າພະເຈົ້າເປັນ hieroglyphs. ນັ້ນແມ່ນ, ຄືກັບຂໍ້ຄວາມທີ່ບໍ່ສາມາດແບ່ງອອກໄດ້, ເຊິ່ງທ່ານຈໍາເປັນຕ້ອງເພີ່ມຕົວອັກສອນ "magic" ແລະມັນຈະເຮັດວຽກ.
ບາງຄັ້ງຂ້າພະເຈົ້າສັງເກດເຫັນວ່ານັກຮຽນຄິດວ່າເພື່ອແກ້ໄຂບັນຫາສະເພາະທີ່ທ່ານຕ້ອງການ ອັນ​ອື່ນ ການອອກແບບທີ່ຂ້ອຍຍັງບໍ່ທັນໄດ້ກວມເອົາເທື່ອ. ເຖິງແມ່ນວ່າການແກ້ໄຂຕ້ອງການພຽງແຕ່ການດັດແກ້ເລັກນ້ອຍຂອງຕົວຢ່າງ.

ດັ່ງນັ້ນຂ້າພະເຈົ້າໄດ້ມາກັບຄວາມຄິດທີ່ວ່າຈຸດສຸມບໍ່ຄວນຢູ່ໃນ syntax ຂອງການສະແດງອອກ, ແຕ່ກ່ຽວກັບຄວາມຄິດຂອງ refactoring ລະຫັດຊ້ໍາຊ້ອນໂດຍໃຊ້ loops. ເມື່ອນັກຮຽນຮູ້ຄວາມຄິດນີ້ແລ້ວ, syntax ໃດກໍ່ສາມາດໄດ້ຮັບການປັບປຸງດ້ວຍການປະຕິບັດພຽງເລັກນ້ອຍ.

ຂ້ອຍສອນໃຜ ແລະເປັນຫຍັງ?

ເນື່ອງຈາກບໍ່ມີການສອບເສັງເຂົ້າ, ຫ້ອງຮຽນສາມາດປະກອບມີນັກຮຽນທີ່ເຂັ້ມແຂງແລະອ່ອນແອຫຼາຍ. ທ່ານສາມາດອ່ານເພີ່ມເຕີມກ່ຽວກັບນັກຮຽນຂອງຂ້ອຍໃນບົດຄວາມ ຮູບຂອງນັກສຶກສາຫຼັກສູດຕອນແລງ
ຂ້າພະເຈົ້າໄດ້ພະຍາຍາມເພື່ອຮັບປະກັນວ່າທຸກຄົນທີ່ຕ້ອງການຮຽນຮູ້ການຂຽນໂປລແກລມສາມາດຮຽນຮູ້ມັນໄດ້.
ຫ້ອງຮຽນຂອງຂ້ອຍແມ່ນຈັດຂຶ້ນເປັນສ່ວນບຸກຄົນແລະນັກຮຽນຈ່າຍເງິນຂອງຕົນເອງສໍາລັບແຕ່ລະຄົນ. ມັນເບິ່ງຄືວ່ານັກຮຽນຈະເພີ່ມປະສິດທິພາບຄ່າໃຊ້ຈ່າຍແລະຕ້ອງການຕໍາ່ສຸດທີ່. ແນວໃດກໍ່ຕາມ, ຄົນໄປຮຽນແບບປະເຊີນໜ້າກັບຄູສອນສົດ ບໍ່ແມ່ນເພື່ອຄວາມຮູ້ຕົວມັນເອງ, ແຕ່ເພື່ອຄວາມໝັ້ນໃຈໃນສິ່ງທີ່ໄດ້ຮຽນມາ, ເພື່ອຄວາມຮູ້ສຶກຂອງຄວາມກ້າວໜ້າ ແລະ ຂໍການອະນຸມັດຈາກຜູ້ຊ່ຽວຊານ (ອາຈານ). ຖ້ານັກຮຽນບໍ່ຮູ້ສຶກເຖິງຄວາມກ້າວຫນ້າໃນການຮຽນຮູ້, ເຂົາເຈົ້າຈະອອກໄປ. ໂດຍທົ່ວໄປ, ຫ້ອງຮຽນສາມາດມີໂຄງສ້າງເພື່ອໃຫ້ນັກຮຽນຮູ້ສຶກວ່າມີຄວາມກ້າວຫນ້າໃນການເພີ່ມຈໍານວນໂຄງສ້າງທີ່ຄຸ້ນເຄີຍ. ນັ້ນແມ່ນ, ທໍາອິດພວກເຮົາສຶກສາໃນຂະນະທີ່ລາຍລະອຽດ, ຫຼັງຈາກນັ້ນພວກເຮົາສຶກສາສໍາລັບ, ຫຼັງຈາກນັ້ນເຮັດໃນຂະນະທີ່, ແລະໃນປັດຈຸບັນພວກເຮົາມີຫຼັກສູດຫນຶ່ງພັນຄືນພ້ອມ, ເຊິ່ງໃນຮອບວຽນດຽວແມ່ນຮຽນສອງເດືອນ, ແລະໃນທີ່ສຸດ - ນັກຮຽນທີ່ຂຽນ. ຫ້ອງສະຫມຸດມາດຕະຖານພາຍໃຕ້ການສັ່ງ. ຢ່າງໃດກໍຕາມ, ເພື່ອແກ້ໄຂບັນຫາການປະຕິບັດ, ທ່ານຕ້ອງການບໍ່ພຽງແຕ່ຄວາມຮູ້ຂອງອຸປະກອນການ, ແຕ່ຍັງເປັນເອກະລາດໃນຄໍາຮ້ອງສະຫມັກຂອງຕົນແລະໃນການຊອກຫາຂໍ້ມູນໃຫມ່. ດັ່ງນັ້ນ, ສໍາລັບຫຼັກສູດປະເຊີນຫນ້າ, ຂ້າພະເຈົ້າຄິດວ່າຫຼັກການທີ່ຖືກຕ້ອງແມ່ນການສອນຕໍາ່ສຸດທີ່ແລະຊຸກຍູ້ໃຫ້ມີການສຶກສາເອກະລາດຂອງ nuances ແລະຫົວຂໍ້ທີ່ກ່ຽວຂ້ອງ. ໃນຫົວຂໍ້ຂອງ loops, ຂ້າພະເຈົ້າພິຈາລະນາໃນຂະນະທີ່ການກໍ່ສ້າງເປັນຕໍາ່ສຸດທີ່. ເຈົ້າສາມາດເຂົ້າໃຈຫຼັກການຈາກມັນ. ໂດຍຮູ້ຫຼັກການ, ເຈົ້າສາມາດເປັນເຈົ້າການທັງສໍາລັບແລະເຮັດໃນຂະນະທີ່ຕົວທ່ານເອງ.

ເພື່ອບັນລຸຄວາມຊໍານິຊໍານານຂອງເອກະສານໂດຍນັກຮຽນທີ່ອ່ອນແອ, ການອະທິບາຍ syntax ແມ່ນບໍ່ພຽງພໍ. ມັນເປັນສິ່ງຈໍາເປັນທີ່ຈະໃຫ້ວຽກງານທີ່ງ່າຍດາຍກວ່າແຕ່ແຕກຕ່າງກັນແລະອະທິບາຍຕົວຢ່າງໃນລາຍລະອຽດເພີ່ມເຕີມ. ໃນ​ທີ່​ສຸດ, ຄວາມ​ໄວ​ຂອງ​ການ​ພັດ​ທະ​ນາ​ແມ່ນ​ຈໍາ​ກັດ​ໂດຍ​ຄວາມ​ສາ​ມາດ​ຂອງ​ນັກ​ສຶກ​ສາ​ໃນ​ການ​ຫັນ​ປ່ຽນ​ການ​ສະ​ແດງ​ອອກ​ແລະ​ການ​ຄົ້ນ​ຫາ​ສໍາ​ລັບ​ຮູບ​ແບບ. ສຳລັບນັກຮຽນທີ່ສະຫຼາດ, ວຽກສ່ວນໃຫຍ່ຈະໜ້າເບື່ອ. ໃນ​ເວ​ລາ​ທີ່​ສຶກ​ສາ​ກັບ​ເຂົາ​ເຈົ້າ​, ທ່ານ​ບໍ່​ຈໍາ​ເປັນ​ຕ້ອງ​ຮຽກ​ຮ້ອງ​ໃຫ້​ມີ​ການ​ແກ້​ໄຂ 100​% ຂອງ​ບັນ​ຫາ​. ເອກະສານຂອງຂ້ອຍສາມາດເບິ່ງໄດ້ທີ່ github ຂອງຂ້ອຍ. ແທ້ຈິງແລ້ວ, ຄັງເກັບມ້ຽນແມ່ນຄ້າຍຄືກັບ grimoire ຂອງ warlock - ບໍ່ມີໃຜນອກ ເໜືອ ຈາກຂ້ອຍຈະເຂົ້າໃຈວ່າແມ່ນຫຍັງຢູ່ໃສ, ແລະຖ້າທ່ານລົ້ມເຫລວ, ເຈົ້າສາມາດບ້າໄດ້.

ວິທີການແມ່ນປະຕິບັດ, ຮັດກຸມ

ທິດສະດີໄດ້ຖືກອະທິບາຍໂດຍໃຊ້ຕົວຢ່າງຂອງການແກ້ໄຂບັນຫາ. ໃນພື້ນຖານຂອງຫ້ອງຮຽນການຂຽນໂປລແກລມທີ່ສາຂາແລະ loops ຖືກສອນ, ມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະໃຫ້ຄໍາບັນຍາຍທີ່ເປັນປະໂຫຍດໃນຫົວຂໍ້ຫນຶ່ງສໍາລັບຊົ່ວໂມງທັງຫມົດ. 15-20 ນາທີແມ່ນພຽງພໍທີ່ຈະອະທິບາຍແນວຄວາມຄິດ. ຄວາມຫຍຸ້ງຍາກຕົ້ນຕໍແມ່ນເກີດຂື້ນໃນເວລາປະຕິບັດວຽກງານຕົວຈິງ.
ຄູສອນເລີ່ມຕົ້ນສາມາດ rattle off operator, ສາຂາ, loops, ແລະ arrays ໃນຫນຶ່ງບັນຍາຍ. ແຕ່ນັກຮຽນຂອງພວກເຂົາຈະປະເຊີນກັບບັນຫາຂອງການລວບລວມຂໍ້ມູນນີ້.
ມັນເປັນສິ່ງຈໍາເປັນບໍ່ພຽງແຕ່ບອກເອກະສານ, ແຕ່ຍັງໃຫ້ແນ່ໃຈວ່າຜູ້ຟັງເຂົ້າໃຈມັນ.

ຄວາມຈິງຂອງການສ້າງຫົວຂໍ້ໃດຫນຶ່ງແມ່ນຖືກກໍານົດໂດຍວິທີທີ່ນັກຮຽນຮັບມືກັບວຽກງານທີ່ເປັນເອກະລາດ.
ຖ້ານັກຮຽນສາມາດແກ້ໄຂບັນຫາກ່ຽວກັບຫົວຂໍ້ໃດຫນຶ່ງໂດຍບໍ່ມີການຊ່ວຍເຫຼືອຂອງຄູສອນ, ຫຼັງຈາກນັ້ນຫົວຂໍ້ໄດ້ຖືກ mastered. ເພື່ອຮັບປະກັນການທົດສອບດ້ວຍຕົນເອງ, ແຕ່ລະວຽກງານແມ່ນໄດ້ອະທິບາຍຢູ່ໃນຕາຕະລາງທີ່ມີສະຖານະການທົດສອບ. ວຽກງານມີຄໍາສັ່ງທີ່ຊັດເຈນ. ບໍ່ແນະນຳໃຫ້ຂ້າມໜ້າວຽກ. ຖ້າວຽກງານໃນປະຈຸບັນມີຄວາມຫຍຸ້ງຍາກເກີນໄປ, ຫຼັງຈາກນັ້ນການກ້າວໄປສູ່ວຽກງານຕໍ່ໄປແມ່ນບໍ່ມີປະໂຫຍດ. ມັນກໍ່ສັບສົນຫຼາຍ. ເພື່ອໃຫ້ນັກຮຽນສາມາດປະຕິບັດວຽກງານທີ່ສັບສົນໃນປະຈຸບັນ, ເຕັກນິກຫຼາຍຢ່າງໄດ້ຖືກອະທິບາຍໃຫ້ລາວໃຊ້ຕົວຢ່າງຂອງບັນຫາທໍາອິດ. ຕົວຈິງແລ້ວ, ເນື້ອໃນທັງຫມົດຂອງຫົວຂໍ້ແມ່ນມາຈາກເຕັກນິກການເອົາຊະນະຄວາມຫຍຸ້ງຍາກ. ຮອບວຽນມີຜົນຂ້າງຄຽງຫຼາຍກວ່າ.

ວຽກງານທໍາອິດແມ່ນສະເຫມີເປັນຕົວຢ່າງ. ອັນທີສອງແຕກຕ່າງກັນເລັກນ້ອຍແລະຖືກປະຕິບັດ "ເປັນເອກະລາດ" ທັນທີຫຼັງຈາກຄັ້ງທໍາອິດພາຍໃຕ້ການຊີ້ນໍາຂອງຄູສອນ. ທຸກໆວຽກງານຕໍ່ມາແມ່ນແນໃສ່ເອົາໃຈໃສ່ກັບສິ່ງເລັກນ້ອຍຕ່າງໆທີ່ສາມາດເຮັດໃຫ້ເກີດຄວາມເຂົ້າໃຈຜິດ.

ຄໍາອະທິບາຍຂອງຕົວຢ່າງແມ່ນການສົນທະນາທີ່ນັກຮຽນຕ້ອງການໂທຫາການຂະຫຍາຍພັນແລະການກວດສອບຂ້າມຄືນເພື່ອໃຫ້ແນ່ໃຈວ່າລາວໄດ້ຊໍານິຊໍານານບາງສ່ວນຂອງເອກະສານ.

ຂ້າພະເຈົ້າຈະ banal ແລະເວົ້າວ່າຕົວຢ່າງທໍາອິດໃນຫົວຂໍ້ແມ່ນມີຄວາມສໍາຄັນຫຼາຍ. ຖ້າທ່ານມີອຸປະກອນການສໍາລັບວຽກງານເອກະລາດຢ່າງກວ້າງຂວາງ, ການລະເວັ້ນຂອງຕົວຢ່າງທໍາອິດສາມາດແກ້ໄຂໄດ້. ຖ້າບໍ່ມີຫຍັງນອກເໜືອໄປຈາກຕົວຢ່າງ, ນັກຮຽນສ່ວນຫຼາຍຈະບໍ່ເປັນເຈົ້າການໃນຫົວຂໍ້.

ໃນຂະນະທີ່ຫຼືສໍາລັບ?

ຫນຶ່ງໃນບັນຫາທີ່ມີການໂຕ້ຖຽງແມ່ນທາງເລືອກຂອງການກໍ່ສ້າງສໍາລັບຕົວຢ່າງ: ໃນຂະນະທີ່ຫຼືສໍາລັບ. ຄັ້ງໜຶ່ງ, ໝູ່ນັກພັດທະນາຂອງຂ້ອຍທີ່ຝຶກຊ້ອມທີ່ບໍ່ມີປະສົບການສອນໄດ້ໃຊ້ເວລາໜຶ່ງຊົ່ວໂມງເຮັດໃຫ້ຂ້ອຍຮູ້ວ່າ for loop ແມ່ນເຂົ້າໃຈງ່າຍທີ່ສຸດ. ການໂຕ້ຖຽງໄດ້ຕົ້ມລົງໄປວ່າ "ທຸກສິ່ງທຸກຢ່າງຢູ່ໃນມັນຈະແຈ້ງແລະວາງໄວ້ໃນບ່ອນຂອງມັນ." ຢ່າງໃດກໍ່ຕາມ, ສາເຫດຂອງຄວາມຫຍຸ້ງຍາກສໍາລັບຜູ້ເລີ່ມຕົ້ນທີ່ແທ້ຈິງແມ່ນຄວາມຄິດຂອງວົງຈອນຕົວມັນເອງ, ແລະບໍ່ແມ່ນການຂຽນຂອງມັນ. ຖ້າຄົນບໍ່ເຂົ້າໃຈຄວາມຄິດນີ້, ລາວຈະມີຄວາມຫຍຸ້ງຍາກກັບ syntax. ທັນທີທີ່ຄວາມຄິດໄດ້ຖືກຮັບຮູ້, ບັນຫາຂອງການອອກແບບລະຫັດຫາຍໄປດ້ວຍຕົນເອງ.

ໃນວັດສະດຸຂອງຂ້ອຍ, ຫົວຂໍ້ຂອງ loops ປະຕິບັດຕາມຫົວຂໍ້ຂອງການແຕກງ່າ. ຄວາມຄ້າຍຄືກັນພາຍນອກຂອງຖ້າແລະໃນຂະນະທີ່ອະນຸຍາດໃຫ້ພວກເຮົາແຕ້ມການປຽບທຽບໂດຍກົງ: "ເມື່ອເງື່ອນໄຂໃນຫົວເປັນຄວາມຈິງ, ຫຼັງຈາກນັ້ນຮ່າງກາຍຈະຖືກປະຕິບັດ." peculiarity ພຽງແຕ່ຂອງວົງຈອນແມ່ນວ່າຮ່າງກາຍໄດ້ຖືກປະຕິບັດຫຼາຍຄັ້ງ.

ການໂຕ້ຖຽງທີສອງຂອງຂ້ອຍແມ່ນວ່າໃນຂະນະທີ່ຮຽກຮ້ອງໃຫ້ມີຮູບແບບຫນ້ອຍກວ່າສໍາລັບ. ການຈັດຮູບແບບໜ້ອຍລົງໝາຍເຖິງຄວາມຜິດພາດທີ່ໂງ່ໜ້ອຍລົງກັບເຄື່ອງໝາຍຈຸດ ແລະວົງເລັບທີ່ຂາດຫາຍໄປ. ຜູ້ເລີ່ມຕົ້ນຍັງບໍ່ທັນໄດ້ພັດທະນາຄວາມເອົາໃຈໃສ່ແລະຄວາມລະມັດລະວັງພຽງພໍເພື່ອຫຼີກເວັ້ນຄວາມຜິດພາດຂອງ syntax ໂດຍອັດຕະໂນມັດ.
ການໂຕ້ຖຽງທີສາມແມ່ນໄດ້ຖືກອະທິບາຍໄວ້ໃນຫນັງສືທີ່ດີຈໍານວນຫຼາຍເປັນການໂຕ້ຖຽງທໍາອິດ.

ຖ້ານັກຮຽນສາມາດຫັນປ່ຽນການສະແດງອອກໄດ້ງ່າຍ, ຫຼັງຈາກນັ້ນທ່ານສາມາດເວົ້າກ່ຽວກັບການຖ່າຍທອດ. ຫຼັງຈາກນັ້ນ, ນັກຮຽນຈະເລືອກສິ່ງທີ່ລາວມັກທີ່ສຸດ. ຖ້າການຫັນປ່ຽນເຮັດໃຫ້ເກີດຄວາມຫຍຸ້ງຍາກ, ມັນດີກວ່າທີ່ຈະບໍ່ລົບກວນຄວາມສົນໃຈຂອງເຈົ້າ. ໃຫ້ນັກຮຽນທໍາອິດແກ້ໄຂທຸກຢ່າງໂດຍໃຊ້ໃນຂະນະທີ່. ເມື່ອທ່ານໄດ້ mastered ຫົວຂໍ້ຂອງ loops, ທ່ານສາມາດ rewrite ວິທີແກ້ໄຂເພື່ອປະຕິບັດການແປງໃນຂະນະທີ່ເປັນ.
ວົງຫຼັງເງື່ອນໄຂເປັນສັດທີ່ຫາຍາກຫຼາຍ. ຂ້ອຍບໍ່ໃຊ້ເວລາກັບມັນເລີຍ. ຖ້ານັກຮຽນໄດ້ຊໍານິຊໍານານແນວຄວາມຄິດຂອງການກໍານົດຮູບແບບແລະການຫັນປ່ຽນການສະແດງອອກ, ລາວສາມາດຄິດໄດ້ໂດຍບໍ່ມີການຊ່ວຍເຫຼືອຂອງຂ້ອຍ.

ໃນເວລາທີ່ສະແດງໃຫ້ເຫັນຕົວຢ່າງທໍາອິດກັບນັກຮຽນທີ່ເຂັ້ມແຂງ, ຂ້າພະເຈົ້າເອົາໃຈໃສ່ຄວາມຈິງທີ່ວ່າໃນຕົວຢ່າງທໍາອິດມັນເປັນສິ່ງສໍາຄັນທີ່ຈະບັນທຶກບໍ່ພຽງແຕ່ການແກ້ໄຂ, ແຕ່ຍັງລະບົບຕ່ອງໂສ້ທັງຫມົດຂອງການປະຕິບັດທີ່ນໍາໄປສູ່ຜົນໄດ້ຮັບ. ນັກຮຽນຂີ້ຄ້ານສາມາດລະເລີຍການຂຽນແລະຄັດລອກພຽງແຕ່ສູດການຄິດໄລ່ສຸດທ້າຍ. ພວກ​ເຂົາ​ເຈົ້າ​ຈໍາ​ເປັນ​ຕ້ອງ​ເຊື່ອ​ວ່າ​ມື້​ຫນຶ່ງ​ວຽກ​ງານ​ທີ່​ຫຍຸ້ງ​ຍາກ​ຈະ​ມາ​ເຖິງ​ຂອງ​ເຂົາ​ເຈົ້າ​. ເພື່ອແກ້ໄຂມັນ, ທ່ານຈະຕ້ອງປະຕິບັດຕາມຂັ້ນຕອນເຊັ່ນໃນຕົວຢ່າງນີ້. ນັ້ນແມ່ນເຫດຜົນທີ່ວ່າມັນເປັນສິ່ງສໍາຄັນທີ່ຈະບັນທຶກທຸກຂັ້ນຕອນ. ໃນບັນຫາຕໍ່ໄປນີ້ມັນຈະເປັນໄປໄດ້ທີ່ຈະປ່ອຍໃຫ້ພຽງແຕ່ສະບັບສຸດທ້າຍຂອງການແກ້ໄຂ.

ແນວຄວາມຄິດຕົ້ນຕໍຂອງການອັດຕະໂນມັດແມ່ນວ່າພວກເຮົາມອບໃຫ້ຄອມພິວເຕີເຮັດວຽກປົກກະຕິສໍາລັບບຸກຄົນ. ຫນຶ່ງໃນເຕັກນິກພື້ນຖານແມ່ນການຂຽນ loops. ມັນຖືກນໍາໃຊ້ໃນເວລາທີ່ການດໍາເນີນການຊ້ໍາກັນຫຼາຍອັນຖືກຂຽນຢູ່ໃນໂຄງການຕິດຕໍ່ກັນ.

ຊັດເຈນແມ່ນດີກ່ວາ implicit

ມັນອາດຈະເບິ່ງຄືວ່າເປັນຄວາມຄິດທີ່ດີທີ່ຈະສະແດງປະໂຫຍກດຽວກັນຫຼາຍຄັ້ງໃນວຽກງານ looping ທໍາອິດ. ຍົກ​ຕົວ​ຢ່າງ:

Hurray, ມັນເຮັດວຽກ!
Hurray, ມັນເຮັດວຽກ!
Hurray, ມັນເຮັດວຽກ!
Hurray, ມັນເຮັດວຽກ!
Hurray, ມັນເຮັດວຽກ!
Hurray, ມັນເຮັດວຽກ!
Hurray, ມັນເຮັດວຽກ!
Hurray, ມັນເຮັດວຽກ!

ຕົວເລືອກນີ້ແມ່ນບໍ່ດີເພາະວ່າຄ່າ counter ບໍ່ເຫັນຢູ່ໃນຜົນຜະລິດ. ນີ້ແມ່ນບັນຫາສໍາລັບຜູ້ເລີ່ມຕົ້ນ. ຢ່າປະມາດນາງ. ໃນຕອນທໍາອິດ, ວຽກງານນີ້ແມ່ນຄັ້ງທໍາອິດ, ແລະວຽກງານຂອງການໄດ້ຮັບຊຸດຂອງຕົວເລກໃນລໍາດັບຕັ້ງຂຶ້ນແມ່ນຄັ້ງທີສອງ. ມັນເປັນສິ່ງຈໍາເປັນທີ່ຈະແນະນໍາຄໍາສັບເພີ່ມເຕີມ "ຮອບວຽນ N ເວລາ" ແລະ "ວົງຈອນຈາກ A ຫາ B", ເຊິ່ງເປັນສິ່ງຈໍາເປັນອັນດຽວກັນ. ໃນຄໍາສັ່ງທີ່ຈະບໍ່ສ້າງຫນ່ວຍງານທີ່ບໍ່ຈໍາເປັນ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈທີ່ຈະສະແດງພຽງແຕ່ຕົວຢ່າງທີ່ມີຜົນຜະລິດຂອງຕົວເລກ. ມີຄົນຈໍານວນຫນ້ອຍຈັດການທີ່ຈະຮຽນຮູ້ວິທີການຖືເຄື່ອງນັບຢູ່ໃນຫົວຂອງພວກເຂົາແລະສ້າງແບບຈໍາລອງພຶດຕິກໍາຂອງໂປຼແກຼມໃນຫົວຂອງພວກເຂົາໂດຍບໍ່ມີການກະກຽມ. ນັກຮຽນບາງຄົນທໍາອິດພົບກັບການສ້າງແບບຈໍາລອງທາງຈິດໃນຫົວຂໍ້ຂອງຮອບວຽນ.
ຫຼັງຈາກການປະຕິບັດບາງຢ່າງ, ຂ້າພະເຈົ້າໃຫ້ວຽກງານຂອງການເຮັດຊ້ໍາຂໍ້ຄວາມດຽວກັນເພື່ອແກ້ໄຂຢ່າງເປັນເອກະລາດ. ຖ້າທ່ານໃຫ້ເຄົາເຕີທີ່ເບິ່ງເຫັນກ່ອນແລະຫຼັງຈາກນັ້ນອັນທີ່ເບິ່ງບໍ່ເຫັນ, ນັກຮຽນຈະມີບັນຫາຫນ້ອຍລົງ. ບາງຄັ້ງ ຄຳ ແນະ ນຳ "ຢ່າຂຽນຕົວນັບໃນ ໜ້າ ຈໍ" ແມ່ນພຽງພໍ.

ຄົນອື່ນອະທິບາຍແນວໃດ?

ໃນອຸປະກອນການສຶກສາສ່ວນໃຫຍ່ໃນອິນເຕີເນັດ, syntax ຂອງວົງຈອນແມ່ນໃຫ້ເປັນສ່ວນຫນຶ່ງຂອງ "ການບັນຍາຍ". ຕົວຢ່າງ, ໃນ developer.mozilla.org (ປະຈຸບັນ), ໂຄງສ້າງອື່ນໆຈໍານວນຫນຶ່ງໄດ້ຖືກອະທິບາຍພ້ອມກັບ while loop. ໃນກໍລະນີນີ້, ມີພຽງແຕ່ການອອກແບບດ້ວຍຕົນເອງເທົ່ານັ້ນທີ່ໄດ້ຮັບໃນຮູບແບບຂອງແມ່ແບບ. ຜົນໄດ້ຮັບຂອງການເປີດຕົວຂອງພວກເຂົາຖືກອະທິບາຍໃນຄໍາສັບຕ່າງໆ, ແຕ່ບໍ່ມີຕົວຢ່າງ. ໃນຄວາມຄິດເຫັນຂອງຂ້ອຍ, ການນໍາສະເຫນີຫົວຂໍ້ດັ່ງກ່າວໄດ້ຄູນຜົນປະໂຫຍດຂອງວັດສະດຸດັ່ງກ່າວໂດຍສູນ. ນັກຮຽນສາມາດຂຽນລະຫັດຄືນໃຫມ່ແລະດໍາເນີນການດ້ວຍຕົນເອງ, ແຕ່ລາວຍັງຕ້ອງການມາດຕະຖານສໍາລັບການປຽບທຽບ. ເຈົ້າເຂົ້າໃຈໄດ້ແນວໃດວ່າຕົວຢ່າງຖືກຂຽນຄືນຢ່າງຖືກຕ້ອງຖ້າບໍ່ມີຫຍັງທີ່ຈະປຽບທຽບຜົນໄດ້ຮັບ?
ເມື່ອມີພຽງແມ່ແບບເທົ່ານັ້ນ, ໂດຍບໍ່ມີຕົວຢ່າງ, ມັນຈະກາຍເປັນຄວາມຫຍຸ້ງຍາກຫຼາຍສໍາລັບນັກຮຽນ. ວິທີການເຂົ້າໃຈວ່າຊິ້ນສ່ວນລະຫັດຖືກຈັດໃສ່ຢ່າງຖືກຕ້ອງໃນແມ່ແບບ? ທ່ານສາມາດພະຍາຍາມຂຽນ ຢ່າງໃດ, ແລະຫຼັງຈາກນັ້ນດໍາເນີນການ. ແຕ່ຖ້າບໍ່ມີມາດຕະຖານທີ່ຈະປຽບທຽບຜົນໄດ້ຮັບ, ຫຼັງຈາກນັ້ນການເປີດຕົວຈະບໍ່ຊ່ວຍໄດ້.

ໃນຫຼັກສູດ C ++ ກ່ຽວກັບ Intuitive, syntax loop ໄດ້ຖືກຝັງຢູ່ໃນຫນ້າທີສາມຂອງ Lecture 4 ກ່ຽວກັບຫົວຂໍ້ "operators". ເມື່ອອະທິບາຍ syntax ຂອງ loops, ເນັ້ນຫນັກເປັນພິເສດກ່ຽວກັບຄໍາວ່າ "operator". ຄໍາສັບໄດ້ຖືກນໍາສະເຫນີເປັນຊຸດຂອງຂໍ້ເທັດຈິງເຊັ່ນ: "ສັນຍາລັກ; this is a statement", "{} is a compound statement", " the body of the loop must be a statement". ຂ້ອຍບໍ່ມັກວິທີການນີ້ເພາະວ່າມັນເບິ່ງຄືວ່າຈະເຊື່ອງຄວາມສໍາພັນທີ່ສໍາຄັນຢູ່ຫລັງຫນຶ່ງໄລຍະ. ການແຍກວິເຄາະແຫຼ່ງລະຫັດຂອງໂປຣແກຣມເປັນຂໍ້ກໍານົດໃນລະດັບນີ້ແມ່ນຈໍາເປັນໂດຍຜູ້ພັດທະນາຄອມພີວເຕີເພື່ອປະຕິບັດການກໍານົດພາສາ, ແຕ່ບໍ່ແມ່ນໂດຍນັກຮຽນເປັນການປະມານທໍາອິດ. ຜູ້ມາໃໝ່ໃນການຂຽນໂປຼແກຼມບໍ່ຄ່ອຍມີຄວາມພິຖີພິຖັນພໍທີ່ຈະເອົາໃຈໃສ່ຢ່າງໃກ້ສິດດັ່ງກ່າວ. ມັນເປັນຄົນທີ່ຫາຍາກທີ່ຈື່ແລະເຂົ້າໃຈຄໍາສັບໃຫມ່ຄັ້ງທໍາອິດ. ເກືອບບໍ່ມີໃຜສາມາດນຳໃຊ້ຄຳສັບທີ່ພວກເຂົາຫາກໍ່ຮຽນມາໄດ້ຢ່າງຖືກຕ້ອງ. ດັ່ງນັ້ນ, ນັກຮຽນໄດ້ຮັບຄວາມຜິດພາດຫຼາຍເຊັ່ນ "ຂ້ອຍຂຽນໃນຂະນະທີ່ (a<7);{, ແຕ່ໂຄງການບໍ່ເຮັດວຽກ."
ໃນຄວາມຄິດເຫັນຂອງຂ້ອຍ, ໃນຕອນເລີ່ມຕົ້ນມັນກໍ່ດີກວ່າທີ່ຈະໃຫ້ syntax ຂອງການກໍ່ສ້າງທັນທີດ້ວຍວົງເລັບ. ທາງເລືອກທີ່ບໍ່ມີວົງເລັບຄວນຖືກອະທິບາຍພຽງແຕ່ຖ້ານັກຮຽນມີຄໍາຖາມສະເພາະ: "ເປັນຫຍັງບໍ່ມີວົງເລັບແລະມັນເຮັດວຽກ."

ໃນປຶ້ມ "Fundamentals of Programming" ຂອງ Okulov ປີ 2012, ການແນະນໍາກ່ຽວກັບ loops ເລີ່ມຕົ້ນດ້ວຍຮູບແບບ, ຫຼັງຈາກນັ້ນໃຫ້ຄໍາແນະນໍາສໍາລັບການນໍາໃຊ້ຂອງມັນ, ແລະຫຼັງຈາກນັ້ນທັນທີໄປຫາພາກທົດລອງຂອງບົດຮຽນ. ຂ້າພະເຈົ້າເຂົ້າໃຈດີວ່າປຶ້ມດັ່ງກ່າວຖືກຂຽນຂຶ້ນສໍາລັບນັກຮຽນທີ່ມີຄວາມສາມາດໜ້ອຍທີ່ບໍ່ຄ່ອຍໄດ້ມາຫ້ອງຮຽນຂອງຂ້ອຍ.

ໃນຫນັງສືທີ່ນິຍົມ, ຜົນໄດ້ຮັບຂອງຊິ້ນສ່ວນລະຫັດແມ່ນຂຽນຢູ່ສະເຫມີ. ຕົວຢ່າງ, Shildt's “Java 8. The Complete Guide” 2015 edition. ຫນ້າທໍາອິດ, ແມ່ແບບແມ່ນໃຫ້, ຫຼັງຈາກນັ້ນໂຄງການຕົວຢ່າງແລະທັນທີຫຼັງຈາກມັນ - ຜົນໄດ້ຮັບຂອງການປະຕິບັດ.

ຕົວຢ່າງ, ພິຈາລະນາໄລຍະຫນຶ່ງທີ່ເຮັດການປີ້ນກັບກັນ
ການນັບຖອຍຫຼັງເລີ່ມຕົ້ນຈາກ 10, ແລະແນ່ນອນ 10 ເສັ້ນຂອງ "ມາດຕະການ" ຈະຖືກສະແດງ:

//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}

ເມື່ອດໍາເນີນການ, ໂປລແກລມນີ້ອອກສິບ "ຮອບວຽນ" ດັ່ງຕໍ່ໄປນີ້:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1

ວິທີການອະທິບາຍແມ່ແບບ, ໂຄງການຕົວຢ່າງແລະຜົນໄດ້ຮັບຂອງໂຄງການຍັງຖືກນໍາໃຊ້ໃນປື້ມ "Javascript ສໍາລັບເດັກນ້ອຍ" ແລະໃນຫຼັກສູດ js ໃນ w3schools.com. ຮູບແບບຫນ້າເວັບເຖິງແມ່ນວ່າອະນຸຍາດໃຫ້ຕົວຢ່າງນີ້ໂຕ້ຕອບ.

ຫຼັກການ ແລະການປະຕິບັດການນຳໃຊ້ C++ ຂອງປຶ້ມປີ 2016 ຂອງ Stroustrup ໄດ້ໄປຕື່ມອີກ. ຂັ້ນ​ຕອນ​ທໍາ​ອິດ​ແມ່ນ​ການ​ອະ​ທິ​ບາຍ​ວ່າ​ຜົນ​ທີ່​ຄວນ​ຈະ​ໄດ້​ຮັບ​, ແລະ​ຫຼັງ​ຈາກ​ນັ້ນ​ຂໍ້​ຄວາມ​ຂອງ​ໂຄງ​ການ​ໄດ້​ຖືກ​ສະ​ແດງ​ໃຫ້​ເຫັນ​. ຍິ່ງໄປກວ່ານັ້ນ, ພວກເຂົາເຈົ້າໃຊ້ເວລາບໍ່ພຽງແຕ່ໂຄງການແບບສຸ່ມເປັນຕົວຢ່າງ, ແຕ່ໃຫ້ທັດສະນະເຂົ້າໄປໃນປະຫວັດສາດ. ນີ້ຊ່ວຍດຶງດູດຄວາມສົນໃຈກັບມັນ: “ເບິ່ງ, ນີ້ບໍ່ແມ່ນພຽງແຕ່ບາງຂໍ້ຄວາມທີ່ບໍ່ມີປະໂຫຍດ. ເຈົ້າເຫັນບາງສິ່ງບາງຢ່າງທີ່ມີຄວາມຫມາຍ."

ໃນຖານະເປັນຕົວຢ່າງຂອງການເຮັດຊ້ໍາອີກ, ພິຈາລະນາໂຄງການທໍາອິດທີ່ປະຕິບັດຢູ່ໃນເຄື່ອງໂປຼແກຼມທີ່ເກັບໄວ້ (EDSAC). ມັນຖືກຂຽນໂດຍ David Wheeler ທີ່ຫ້ອງທົດລອງຄອມພິວເຕີຂອງມະຫາວິທະຍາໄລ Cambridge, ປະເທດອັງກິດໃນວັນທີ 6 ພຶດສະພາ 1949. ໂຄງ​ການ​ນີ້​ຄິດ​ໄລ່​ແລະ​ພິມ​ບັນ​ຊີ​ລາຍ​ການ​ທີ່​ງ່າຍ​ດາຍ​ຂອງ​ມົນ​ທົນ​.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
ທີ່ນີ້, ແຕ່ລະແຖວມີຕົວເລກຕາມດ້ວຍຕົວອັກສອນແຖບ ('t') ແລະສີ່ຫຼ່ຽມຂອງຕົວເລກນັ້ນ. ເວີຊັ່ນ C++ ຂອງໂຄງການນີ້ມີລັກສະນະດັ່ງນີ້:

//Вычисляем и распечатываем таблицу квадратов чисел 0-99
int main()
{
    int i = 0; // Начинаем с нуля
    while(i < 100){
        cout << i << 't' << square(i) << 'n';
        ++i;
    }
}

ຫນ້າສົນໃຈ, ຮູບແບບ syntax ບໍ່ໄດ້ຖືກອະທິບາຍຢູ່ໃນຫນັງສືເຫຼັ້ມນີ້. Stroustrup ໃນຄູ່ມືຂອງຄູສອນ (translation) ເນັ້ນຫນັກວ່າມັນເຄົາລົບສະຕິປັນຍາຂອງນັກຮຽນຂອງຕົນ. ບາງທີຄວາມສາມາດໃນການກໍານົດຮູບແບບໃນຫຼາຍໆຕົວຢ່າງແມ່ນຖືວ່າເປັນການສະແດງອອກຂອງປັນຍາດັ່ງກ່າວ.

ດັ່ງທີ່ຂ້ອຍອະທິບາຍຕົນເອງ

ວິທີການຂອງ Stroustrup: ການອະທິບາຍຜົນໄດ້ຮັບ, ຫຼັງຈາກນັ້ນການແກ້ໄຂບັນຫາ, ແລະຫຼັງຈາກນັ້ນການວິເຄາະເອກະລາດໂດຍນັກຮຽນ - ເບິ່ງຄືວ່າເປັນຄວາມຄິດທີ່ສຸດ. ດັ່ງນັ້ນ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈເອົາມັນເປັນພື້ນຖານ, ແຕ່ບອກມັນໂດຍໃຊ້ຕົວຢ່າງປະຫວັດສາດຫນ້ອຍ - ວຽກງານທີ່ມາຈາກ "ຕາຕະລາງເນື້ອໃນ". ມັນປະກອບເປັນສະມໍທີ່ສາມາດຮັບຮູ້ໄດ້ເພື່ອໃຫ້ທ່ານສາມາດເວົ້າວ່າ "ຈື່ຈໍາວຽກງານກ່ຽວກັບຕາຕະລາງເນື້ອໃນ" ແລະເພື່ອໃຫ້ນັກຮຽນຈື່ໄດ້ແນ່ນອນ. ໃນຕົວຢ່າງຂອງຂ້ອຍ, ຂ້າພະເຈົ້າໄດ້ພະຍາຍາມປ້ອງກັນສອງຄວາມເຂົ້າໃຈຜິດທົ່ວໄປທີ່ສຸດ. ຕໍ່ໄປຂ້າພະເຈົ້າຈະຂຽນກ່ຽວກັບພວກເຂົາໃນລາຍລະອຽດເພີ່ມເຕີມ.

ໃນວຽກງານນີ້, ພວກເຮົາໄດ້ແນະນໍາເຕັກນິກການແກ້ໄຂບັນຫາສະລັບສັບຊ້ອນ. ການ​ຕັດ​ສິນ​ໃຈ​ເບື້ອງ​ຕົ້ນ​ຈໍາ​ເປັນ​ຕ້ອງ​ໄດ້​ຮັບ​ການ​ສ້າງ​ຕັ້ງ​ຕົ້ນ​ສະ​ບັບ​ແລະ​ງ່າຍ​ດາຍ​. ດີ, ຫຼັງຈາກນັ້ນທ່ານສາມາດຄິດກ່ຽວກັບວິທີການປັບປຸງການແກ້ໄຂນີ້.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение

ອີງຕາມການສັງເກດຂອງຂ້ອຍ, ວິທີການ "ຕົວຢ່າງ - ຕົວຢ່າງ - ຜົນໄດ້ຮັບ" ໃນການປະສົມປະສານຕ່າງໆຍັງຄົງນໍາໄປສູ່ຄວາມຈິງທີ່ວ່ານັກຮຽນຮັບຮູ້ຮອບວຽນເປັນ hieroglyph. ນີ້ສະແດງໃຫ້ເຫັນຕົວເອງໃນຄວາມຈິງທີ່ວ່າພວກເຂົາບໍ່ເຂົ້າໃຈວ່າເປັນຫຍັງມີເງື່ອນໄຂທີ່ຈະຂຽນຢູ່ທີ່ນັ້ນ, ວິທີການເລືອກລະຫວ່າງ i++ ແລະ i - ແລະສິ່ງທີ່ເບິ່ງຄືວ່າຈະແຈ້ງອື່ນໆ. ເພື່ອຫຼີກເວັ້ນການເຂົ້າໃຈຜິດເຫຼົ່ານີ້, ວິທີການເວົ້າກ່ຽວກັບຮອບວຽນຄວນເນັ້ນຫນັກເຖິງຄວາມຫມາຍຂອງການເຮັດຊ້ໍາກັນແລະພຽງແຕ່ຫຼັງຈາກນັ້ນເຮັດໃຫ້ພວກເຂົາຢ່າງເປັນທາງການໂດຍໃຊ້ໂຄງສ້າງ. ດັ່ງນັ້ນ, ກ່ອນທີ່ຈະໃຫ້ syntax ຂອງ loop, ທ່ານຈໍາເປັນຕ້ອງແກ້ໄຂບັນຫາ. ການແກ້ໄຂເບື້ອງຕົ້ນຂອງບັນຫາຕາຕະລາງເນື້ອໃນເບິ່ງຄືວ່ານີ້:

Console.WriteLine("Введение");
Console.WriteLine("Глава 1");
Console.WriteLine("Глава 2");
Console.WriteLine("Глава 3");
Console.WriteLine("Глава 4");
Console.WriteLine("Глава 5");
Console.WriteLine("Глава 6");
Console.WriteLine("Глава 7");
Console.WriteLine("Заключение");

ມັນສາມາດປັບປຸງໄດ້ແນວໃດ?
ແທນທີ່ການກະ ທຳ ທີ່ໂດດດ່ຽວດ້ວຍວົງຈອນ.
ການກະທຳອັນໃດຊ້ຳໆຕິດຕໍ່ກັນໂດຍບໍ່ປ່ຽນແປງ?
ບໍ່ມີຢູ່ໃນຊິ້ນນີ້. ຢ່າງໃດກໍຕາມ, ຄໍາສັ່ງສໍາລັບການສະແດງຄໍາວ່າ "ບົດ" ທີ່ມີຕົວເລກແມ່ນຄ້າຍຄືກັນກັບກັນແລະກັນ.
ດັ່ງນັ້ນ, ຂັ້ນຕອນຕໍ່ໄປແມ່ນການຊອກຫາຄວາມແຕກຕ່າງລະຫວ່າງຊິ້ນສ່ວນ. ມັນເປັນພຽງແຕ່ໃນວຽກງານນີ້ທີ່ທຸກສິ່ງທຸກຢ່າງຈະແຈ້ງ, ຫຼັງຈາກນັ້ນບໍ່ແມ່ນຄໍາສັ່ງດຽວຈະຖືກຊ້ໍາ, ແຕ່ຕັນຂອງລະຫັດ 5 ແຖວຫຼືຫຼາຍກວ່ານັ້ນ. ທ່ານຈະຕ້ອງຄົ້ນຫາບໍ່ພຽງແຕ່ຢູ່ໃນບັນຊີລາຍຊື່ຂອງຄໍາສັ່ງ, ແຕ່ໃນການກໍ່ສ້າງສາຂາຫຼື loop.
ໃນຕົວຢ່າງ, ຄວາມແຕກຕ່າງລະຫວ່າງຄໍາສັ່ງແມ່ນຢູ່ໃນຕົວເລກຫຼັງຈາກຄໍາວ່າ "ບົດ".
ເມື່ອຄວາມແຕກຕ່າງໄດ້ຖືກພົບເຫັນ, ທ່ານຈໍາເປັນຕ້ອງເຂົ້າໃຈຮູບແບບການປ່ຽນແປງ. ຊິ້ນສ່ວນທີ່ແຕກຕ່າງກັນແມ່ນຕົວເລກ? ມັນເພີ່ມຂຶ້ນຢ່າງຕໍ່ເນື່ອງຫຼືຫຼຸດລົງ? ຄ່າຂອງຕົວເລກປ່ຽນແປງແນວໃດລະຫວ່າງສອງທີມຂ້າງຄຽງ?
ໃນຕົວຢ່າງ, ຕົວເລກຫຼັງຈາກຄໍາວ່າ "ບົດ" ເພີ່ມຂຶ້ນ 1. ຄວາມແຕກຕ່າງແມ່ນພົບເຫັນ, ຮູບແບບໄດ້ຖືກເປີດເຜີຍ. ຕອນນີ້ທ່ານສາມາດປ່ຽນຊິ້ນສ່ວນທີ່ແຕກຕ່າງກັບຕົວແປໄດ້.
ທ່ານຈໍາເປັນຕ້ອງປະກາດຕົວແປດັ່ງກ່າວກ່ອນຄັ້ງທໍາອິດຂອງຊິ້ນທີ່ຊ້ໍາກັນ. ຕົວແປດັ່ງກ່າວມັກຈະເອີ້ນວ່າ I ຫຼື j ຫຼືສິ່ງທີ່ລະອຽດກວ່າ. ມູນຄ່າເບື້ອງຕົ້ນຂອງມັນຕ້ອງເທົ່າກັບຄ່າທໍາອິດທີ່ສະແດງຢູ່ໃນຫນ້າຈໍ. ໃນຕົວຢ່າງ, ຄ່າທໍາອິດແມ່ນ 1.
ຄວນເອົາຄ່າເບື້ອງຕົ້ນອັນໃດເພື່ອສະແດງຊຸດຂອງຕົວເລກ “100, 101, 102, 103, 104, 105”?
ຕົວເລກທໍາອິດໃນຊຸດນີ້ແມ່ນ 100.
ຫຼັງຈາກແຕ່ລະຄໍາສັ່ງຜົນຜະລິດ, ທ່ານຈໍາເປັນຕ້ອງເພີ່ມມູນຄ່າຂອງຕົວແປນີ້ໂດຍ 1. ຫນ່ວຍນີ້ແມ່ນຂັ້ນຕອນການປ່ຽນແປງ.
ຂັ້ນຕອນໃດທີ່ຈະຢູ່ໃນຊຸດຂອງຕົວເລກ "100, 102, 104, 106"?
ຂັ້ນຕອນທີ 2 ໃນແຖວນີ້.
ຫຼັງຈາກປ່ຽນຊິ້ນສ່ວນທີ່ແຕກຕ່າງກັບຕົວແປ, ລະຫັດຈະມີລັກສະນະດັ່ງນີ້:

Console.WriteLine("Введение");
int i;
i = 0;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");

ຫຼັງຈາກນໍາໃຊ້ເຕັກນິກ "ສະແດງຮູບແບບຂອງຕົວແປ" ໃນລະຫັດ, ທ່ານໄດ້ຮັບຫຼາຍກຸ່ມຂອງການປະຕິບັດທີ່ຄ້າຍຄືກັນທີ່ຕິດຕໍ່ກັນ. ດຽວນີ້ການກະທຳຊ້ຳໆສາມາດຖືກແທນທີ່ດ້ວຍ loop.

ລໍາດັບຂອງການແກ້ໄຂບັນຫາທີ່ທ່ານຈໍາເປັນຕ້ອງໃຊ້ loops ປະກອບດ້ວຍຂັ້ນຕອນດັ່ງຕໍ່ໄປນີ້:

1. ແກ້ໄຂ "ຫົວ" ດ້ວຍຄໍາສັ່ງແຍກຕ່າງຫາກຫຼາຍ
2. ຊອກຫາຮູບແບບ
3. ສະແດງຮູບແບບຂອງຕົວແປ
4. ອອກແບບເປັນວົງຈອນ

ຕໍ່ໄປ, ຂໍ້ກໍານົດໃຫມ່ໄດ້ຖືກນໍາສະເຫນີເພື່ອໃຫ້ນັກຮຽນບໍ່ພົບຕົວເອງໃນສະຖານະການ "ຂ້ອຍເຂົ້າໃຈທຸກຢ່າງ, ແຕ່ຂ້ອຍບໍ່ສາມາດເວົ້າມັນໄດ້":
— ຕົວນັບແມ່ນຕົວແປສະເໝີທີ່ຈຳເປັນເພື່ອຕິດຕາມຈຳນວນຂັ້ນຕອນໃນວົງຮອບ. ໂດຍປົກກະຕິເປັນຈຳນວນເຕັມທີ່ສົມທຽບກັບຂໍ້ຈຳກັດ.
— counter step — ລາຍ​ລະ​ອຽດ​ຂອງ​ຮູບ​ແບບ​ການ​ປ່ຽນ​ແປງ counter.
- ຂໍ້ຈໍາກັດ - ຕົວເລກຫຼືຕົວແປທີ່ຕົວນັບຖືກປຽບທຽບເພື່ອໃຫ້ສູດການຄິດໄລ່ສຸດທ້າຍ. ຄ່າ counter ປ່ຽນແປງໄປໃກ້ຂີດຈຳກັດ.
— loop body — ຊຸດ​ຂອງ​ຄໍາ​ສັ່ງ​ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ຊ​້​ໍາ​. ເມື່ອພວກເຂົາເວົ້າວ່າ "ຄໍາສັ່ງຖືກຂຽນຢູ່ໃນວົງ,", ພວກເຂົາຫມາຍເຖິງຮ່າງກາຍ.
— ການ​ເຮັດ​ຊ້ຳ​ຮອບ — ການ​ປະ​ຕິ​ບັດ​ຄັ້ງ​ດຽວ​ຂອງ​ຮ່າງ​ກາຍ loop ໄດ້.
— ເງື່ອນ​ໄຂ loop — ເປັນ​ການ​ສະ​ແດງ​ອອກ​ຢ່າງ​ມີ​ເຫດ​ຜົນ​ທີ່​ກໍາ​ນົດ​ວ່າ​ຈະ​ມີ​ການ​ເຮັດ​ຊ້ຳ​ອີກ​ເທື່ອ​ຫນຶ່ງ​. (ອາດ​ຈະ​ມີ​ຄວາມ​ສັບ​ສົນ​ກັບ​ໂຄງ​ສ້າງ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຢູ່​ທີ່​ນີ້​)
ທ່ານຈໍາເປັນຕ້ອງກຽມພ້ອມສໍາລັບຄວາມຈິງທີ່ວ່າໃນຄັ້ງທໍາອິດນັກຮຽນຈະໃຊ້ຄໍາສັບຕ່າງໆເພື່ອຈຸດປະສົງອື່ນໆ. ນີ້ໃຊ້ກັບທັງຄົນທີ່ເຂັ້ມແຂງແລະຜູ້ອ່ອນແອ. ການສ້າງພາສາທົ່ວໄປແມ່ນສິນລະປະ. ຕອນນີ້ຂ້ອຍຈະຂຽນສັ້ນໆ: ເຈົ້າຈໍາເປັນຕ້ອງຕັ້ງຫນ້າວຽກ "ເນັ້ນໃສ່ຊິ້ນສ່ວນລະຫັດດ້ວຍ <term>" ແລະໃຊ້ຄໍາສັບເຫຼົ່ານີ້ຢ່າງຖືກຕ້ອງໃນການສົນທະນາ.
ຫຼັງຈາກການຫັນປ່ຽນດ້ວຍ loop, fragment ແມ່ນໄດ້ຮັບ:

Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
    Console.WriteLine("Глава " + i);
    i = i + 1;
}
Console.WriteLine("Заключение");

ຄວາມເຂົ້າໃຈຜິດຕົ້ນຕໍ

ຄວາມເຂົ້າໃຈຜິດອັນໜຶ່ງທີ່ເປັນທີ່ນິຍົມກັນລະຫວ່າງນັກຮຽນກໍຄືວ່າເຂົາເຈົ້າວາງການກະທຳພາຍໃນຊ່ອງທີ່ຕ້ອງເຮັດພຽງຄັ້ງດຽວເທົ່ານັ້ນ. ຕົວຢ່າງເຊັ່ນນີ້:

;
int i = 0;
while (i < 7) {
    Console.WriteLine("Введение")
    Console.WriteLine("Глава " + i);
    i = i + 1;
    Console.WriteLine("Заключение");
}

ນັກສຶກສາແລ່ນເຂົ້າໄປໃນບັນຫານີ້ຕະຫຼອດເວລາ, ທັງໃນຕອນເລີ່ມຕົ້ນແລະບັນຫາທີ່ສັບສົນຫຼາຍ.
ຄໍາ​ແນະ​ນໍາ​ທີ່​ສໍາ​ຄັນ​ໃນ​ກໍ​ລະ​ນີ​ນີ້​:

ທ່ານຄວນຂຽນຄໍາສັ່ງອີກເທື່ອຫນຶ່ງ: ຄັ້ງຫນຶ່ງຫຼືຫຼາຍຄັ້ງ?

ຄໍາສັ່ງສໍາລັບການພິມຄໍາວ່າ "ແນະນໍາ" ແລະ "ສະຫຼຸບ" ແລະການປະກາດແລະການເລີ່ມຕົ້ນຂອງຕົວແປ i ແມ່ນບໍ່ຄືກັບການກະທໍາທີ່ຊ້ໍາກັນອື່ນໆ. ພວກມັນຖືກປະຕິບັດພຽງແຕ່ຄັ້ງດຽວ, ຊຶ່ງຫມາຍຄວາມວ່າພວກເຂົາຕ້ອງໄດ້ຮັບການຂຽນຢູ່ນອກຮ່າງກາຍຂອງ loop.

ທັງສາມຂັ້ນຕອນຂອງການແກ້ໄຂຄວນຢູ່ໃນລະຫັດເພື່ອໃຫ້ທ່ານສາມາດອ້າງເຖິງພວກມັນຕໍ່ມາໃນກໍລະນີມີຄວາມຫຍຸ້ງຍາກ. ມັນພຽງພໍທີ່ຈະສະແດງຄວາມຄິດເຫັນສອງທາງເລືອກທໍາອິດເພື່ອບໍ່ໃຫ້ແຊກແຊງ.
ນັກຮຽນຄວນເອົາໃຈໃສ່ຕໍ່ຂໍ້ເທັດຈິງຕໍ່ໄປນີ້:
— ໃນ​ສະ​ພາບ​ການ loop ເປັນ, counter ແລະ limit ປົກກະຕິແລ້ວແມ່ນປຽບທຽບ. ຕົວນັບສາມາດປ່ຽນແປງຢູ່ໃນຮ່າງກາຍຂອງ loop ໄດ້, ແຕ່ຂອບເຂດຈໍາກັດບໍ່ສາມາດ. ເພື່ອທໍາລາຍກົດລະບຽບນີ້, ທ່ານຈໍາເປັນຕ້ອງສ້າງເຫດຜົນທີ່ຫນ້າສົນໃຈ.
— ຄໍາ​ສັ່ງ​ສໍາ​ລັບ​ການ​ສະ​ແດງ​ຄໍາ​ວ່າ "ການ​ນໍາ​ສະ​ເຫນີ​" ແລະ "ສະ​ຫຼຸບ​" ແມ່ນ​ຢູ່​ນອກ​ຮ່າງ​ກາຍ​ຂອງ loop ໄດ້​. ພວກເຮົາຈໍາເປັນຕ້ອງປະຕິບັດໃຫ້ເຂົາເຈົ້າ 1 ເທື່ອ. "ການແນະນໍາ" - ກ່ອນທີ່ຈະເຮັດຊ້ໍາການກະທໍາ, "ສະຫຼຸບ" - ຫຼັງຈາກ.
ໃນຂະບວນການລວມຫົວຂໍ້ນີ້, ຊໍານິຊໍານານຕໍ່ໄປ, ເຊັ່ນດຽວກັນກັບການຮັບມືກັບຄວາມຫຍຸ້ງຍາກ, ມັນເປັນປະໂຫຍດສໍາລັບນັກຮຽນທີ່ເຂັ້ມແຂງທີ່ຈະຖາມຄໍາຖາມ: "ການດໍາເນີນການນີ້ຈໍາເປັນຕ້ອງປະຕິບັດຫຼາຍປານໃດ? ຫນຶ່ງຫຼືຫຼາຍ?

ການພັດທະນາທັກສະເພີ່ມເຕີມ

ໃນ​ຂະ​ບວນ​ການ​ຂອງ​ການ​ສຶກ​ສາ​ຮອບ​ວຽນ​, ນັກ​ສຶກ​ສາ​ຍັງ​ພັດ​ທະ​ນາ​ສີ​ມື​ແຮງ​ງານ​ການ​ວິ​ນິດ​ໄສ​ແລະ​ການ​ແກ້​ໄຂ​ບັນ​ຫາ​. ເພື່ອປະຕິບັດການວິນິດໄສ, ນັກຮຽນຕ້ອງນໍາສະເຫນີຜົນໄດ້ຮັບທີ່ຕ້ອງການແລະປຽບທຽບກັບຜົນໄດ້ຮັບຕົວຈິງ. ການແກ້ໄຂແມ່ນຂຶ້ນກັບຄວາມແຕກຕ່າງລະຫວ່າງພວກມັນ.
ເນື່ອງຈາກນັກຮຽນຢູ່ໃນຂັ້ນຕອນນີ້ຍັງມີຄວາມຄິດຫນ້ອຍກ່ຽວກັບຜົນໄດ້ຮັບ "ທີ່ຕ້ອງການ", ພວກເຂົາສາມາດສຸມໃສ່ຂໍ້ມູນການທົດສອບ. ຕາມກົດລະບຽບ, ບໍ່ມີໃຜຢູ່ໃນຂັ້ນຕອນນີ້ຍັງເຂົ້າໃຈສິ່ງທີ່ສາມາດຜິດພາດແລະວິທີການຈັດການກັບມັນ. ດັ່ງນັ້ນ, ຂ້າພະເຈົ້າຂຽນໃນປື້ມບັນທຶກລາຍລະອຽດກ່ຽວກັບບັນຫາປົກກະຕິແລະຫຼາຍວິທີທີ່ຈະແກ້ໄຂພວກມັນ. ການເລືອກທີ່ເຫມາະສົມທີ່ສຸດແມ່ນວຽກງານຂອງນັກຮຽນເອງ.
ບັນທຶກແມ່ນຈໍາເປັນເພື່ອຖາມວ່າ "ສິ່ງທີ່ຄາດວ່າຈະເກີດຂຶ້ນບໍ?", "ສະຖານະການເຫຼົ່ານີ້ເກີດຂຶ້ນໃນປັດຈຸບັນ?", "ການແກ້ໄຂບັນຫາທີ່ນໍາໃຊ້ໄດ້ຊ່ວຍບໍ?"

1. ຈໍານວນການປະຕິບັດແມ່ນ 1 ຫນ້ອຍຫຼືຫຼາຍກວ່າທີ່ຄາດໄວ້. ວິທີແກ້ໄຂ:
   - ເພີ່ມ​ມູນ​ຄ່າ​ເບື້ອງ​ຕົ້ນ​ຂອງ​ຕົວ​ນັບ​ໂດຍ 1​.
   — ປ່ຽນຕົວປະຕິບັດການປຽບທຽບທີ່ເຄັ່ງຄັດ (< ຫຼື >) ດ້ວຍຕົວປະຕິບັດການທີ່ບໍ່ເຄັ່ງຄັດ (<= ຫຼື >=).
   - ປ່ຽນ​ຄ່າ​ຈໍາ​ກັດ​ເປັນ 1​.
2. ການປະຕິບັດໃນ loop ແມ່ນປະຕິບັດໂດຍບໍ່ມີການຢຸດເຊົາ, ບໍ່ມີກໍານົດ. ວິທີແກ້ໄຂ:
   — ເພີ່ມ​ຄໍາ​ສັ່ງ counter change ຖ້າ​ຫາກ​ວ່າ​ມັນ​ຫາຍ​ໄປ​.
   — ແກ້​ໄຂ​ຄໍາ​ສັ່ງ​ການ​ປ່ຽນ​ແປງ​ຕ້ານ​ດັ່ງ​ນັ້ນ​ຄ່າ​ຂອງ​ມັນ​ກາຍ​ເປັນ​ໃກ້​ກັບ​ກໍາ​ນົດ​.
   — ເອົາ​ຄໍາ​ສັ່ງ​ການ​ປ່ຽນ​ແປງ​ຂໍ້​ຈໍາ​ກັດ​ຖ້າ​ຫາກ​ວ່າ​ມັນ​ຢູ່​ໃນ​ຮ່າງ​ກາຍ​ຂອງ loop ໄດ້​.
3. ຈໍານວນຂອງການປະຕິບັດໃນ loop ແມ່ນຫຼາຍກ່ວາ 1 ຫນ້ອຍຫຼືຫຼາຍກວ່າທີ່ຄາດໄວ້. ການປະຕິບັດໃນ loop ບໍ່ໄດ້ຖືກປະຕິບັດເຖິງແມ່ນວ່າຫນຶ່ງຄັ້ງ. ທໍາອິດທ່ານຈໍາເປັນຕ້ອງຊອກຫາຄ່າທີ່ແທ້ຈິງຂອງຕົວແປພຽງແຕ່ກ່ອນທີ່ຈະ loop ເລີ່ມຕົ້ນ. ວິທີແກ້ໄຂ:
   — ປ່ຽນຄ່າເບື້ອງຕົ້ນຂອງຂໍ້ຈຳກັດ
   — ການ​ປ່ຽນ​ແປງ​ມູນ​ຄ່າ​ເບື້ອງ​ຕົ້ນ​ຂອງ​ຕົວ​ນັບ​

ບັນຫາທີ 3 ມັກຈະກ່ຽວຂ້ອງກັບການໃຊ້ຕົວແປທີ່ບໍ່ຖືກຕ້ອງ ຫຼື ບໍ່ຕັ້ງຕົວປ່ຽນໃໝ່ເປັນສູນ.

ຫຼັງຈາກຄໍາອະທິບາຍນີ້, ນັກຮຽນອາດຈະຍັງມີຄວາມເຂົ້າໃຈຜິດຕ່າງໆກ່ຽວກັບວິທີການ loops ເຮັດວຽກ.
ເພື່ອກໍາຈັດສິ່ງທົ່ວໄປທີ່ສຸດ, ຂ້ອຍໃຫ້ເຈົ້າເຮັດວຽກຕໍ່ໄປນີ້:

1. ໃນນັ້ນ, ຂີດຈຳກັດ, ຄ່າຕົວນັບເບື້ອງຕົ້ນ, ຫຼືຂັ້ນຕອນການນັບຖືກໃສ່ໂດຍຜູ້ໃຊ້.
2. ໃນ​ນັ້ນ​ຄ່າ​ນັບ​ຕ້ອງ​ໄດ້​ຮັບ​ການ​ນໍາ​ໃຊ້​ໃນ​ການ​ສະ​ແດງ​ອອກ​ເລກ​ຄະ​ນິດ​ບາງ​. ຄວນໃຊ້ຕົວນັບໃນການສະແດງອອກຮາກ ຫຼືຕົວຫານເພື່ອໃຫ້ຄວາມແຕກຕ່າງບໍ່ແມ່ນເສັ້ນຊື່.
3. ໃນ​ທີ່​ຄ່າ counter ບໍ່​ໄດ້​ສະ​ແດງ​ຢູ່​ໃນ​ຫນ້າ​ຈໍ​ໃນ​ຂະ​ນະ​ທີ່ loop ແມ່ນ​ແລ່ນ​. ສໍາລັບຕົວຢ່າງ, ການສະແດງຈໍານວນທີ່ຕ້ອງການຂອງຊິ້ນຂໍ້ຄວາມດຽວກັນຫຼືແຕ້ມຮູບທີ່ມີກາຟິກເຕົ່າ.
4. ໃນທີ່ທ່ານຈໍາເປັນຕ້ອງປະຕິບັດການດໍາເນີນການຊ້ໍາຊ້ອນ, ແລະຫຼັງຈາກນັ້ນອື່ນໆ.
5. ໃນທີ່ທ່ານຈໍາເປັນຕ້ອງປະຕິບັດການປະຕິບັດອື່ນໆກ່ອນແລະຫຼັງຈາກເຮັດຊ້ໍາອີກ

ສໍາລັບແຕ່ລະວຽກງານ, ທ່ານຈໍາເປັນຕ້ອງໃຫ້ຂໍ້ມູນການທົດສອບແລະຜົນໄດ້ຮັບທີ່ຄາດໄວ້.

ເພື່ອເຂົ້າໃຈວ່າທ່ານສາມາດເຄື່ອນຍ້າຍໄດ້ໄວເທົ່າໃດ, ທ່ານຈໍາເປັນຕ້ອງອ່ານຂໍ້ກໍານົດຂອງບັນຫາເຫຼົ່ານີ້ແລະຖາມວ່າ: "ພວກມັນແຕກຕ່າງຈາກຕົວຢ່າງແນວໃດ?", "ສິ່ງທີ່ຕ້ອງການປ່ຽນໃນຕົວຢ່າງເພື່ອແກ້ໄຂພວກມັນ?" ຖ້ານັກຮຽນຕອບຢ່າງມີຄວາມຫມາຍ, ໃຫ້ລາວແກ້ໄຂຢ່າງຫນ້ອຍຫນຶ່ງຄັ້ງໃນຫ້ອງຮຽນ, ແລະສ່ວນທີ່ເຫຼືອຢູ່ເຮືອນຂອງຕົນເອງ. ຖ້າການແກ້ໄຂປະສົບຜົນສໍາເລັດ, ຫຼັງຈາກນັ້ນພວກເຮົາສາມາດເລີ່ມຕົ້ນການອະທິບາຍເງື່ອນໄຂພາຍໃນ loops.
ຖ້າທ່ານມີບັນຫາໃນການແກ້ໄຂບັນຫາດ້ວຍຕົນເອງ, ທ່ານຈໍາເປັນຕ້ອງເຮັດວຽກຜ່ານທຸກສິ່ງທຸກຢ່າງໃນຫ້ອງຮຽນ. ເພື່ອຫຼີກເວັ້ນການແກ້ໄຂບັນຫາທີ່ຖືກລະນຶກເຖິງການແຕ້ມຮູບນົກຮູກ, ຂ້າພະເຈົ້າແນະນໍາໃຫ້ທໍາອິດແກ້ໄຂບັນຫາໃນທາງທີ່ບໍ່ແມ່ນທົ່ວໄປ. ນັ້ນແມ່ນ, ດັ່ງນັ້ນການແກ້ໄຂຜ່ານການທົດສອບຄັ້ງທໍາອິດແລະບໍ່ໃຊ້ການກໍ່ສ້າງ loop. ດີ, ຫຼັງຈາກນັ້ນ, ນໍາໃຊ້ການຫັນປ່ຽນເພື່ອບັນລຸວິທະຍາໄລຂອງການແກ້ໄຂ.

Loops ແລະສາຂາ

ໃນຄວາມຄິດເຫັນຂອງຂ້ອຍ, ມັນເປັນປະໂຫຍດທີ່ຈະໃຫ້ຫົວຂໍ້ "ຮອບວຽນພາຍໃນສາຂາ" ແຍກຕ່າງຫາກ. ດັ່ງນັ້ນຕໍ່ມາເຈົ້າສາມາດເຫັນຄວາມແຕກຕ່າງລະຫວ່າງການກວດສອບເງື່ອນໄຂຫຼາຍຄັ້ງແລະກວດເບິ່ງມັນຫນຶ່ງຄັ້ງ.
ວຽກ​ງານ​ສໍາ​ລັບ​ການ​ລວມ​ຈະ​ແມ່ນ​ກ່ຽວ​ກັບ​ການ​ອອກ​ຕົວ​ເລກ​ຈາກ A ຫາ B​, ເຊິ່ງ​ແມ່ນ​ເຂົ້າ​ໂດຍ​ຜູ້​ໃຊ້​:
- ສະ​ເຫມີ​ໄປ​ໃນ​ລໍາ​ດັບ​ຕັ້ງ​ຂຶ້ນ​.
- ຕັ້ງຊັນຂຶ້ນ ຫຼື ລົງຕາມຄ່າຂອງ A ແລະ B.

ຫົວຂໍ້ຂອງ "ສາຂາພາຍໃນ loops" ຄວນຈະຖືກຍ້າຍໄປພຽງແຕ່ຫຼັງຈາກນັກຮຽນໄດ້ຊໍານິຊໍານານເຕັກນິກ: "ການປ່ຽນຮູບແບບທີ່ມີຕົວແປ" ແລະ "ການທົດແທນການປະຕິບັດຊ້ໍາຊ້ອນດ້ວຍວົງຈອນ."
ເຫດຜົນຕົ້ນຕໍສໍາລັບການນໍາໃຊ້ສາຂາພາຍໃນ loops ແມ່ນຜິດປົກກະຕິໃນຮູບແບບ. ໃນກາງມັນແຕກຂື້ນກັບຂໍ້ມູນເບື້ອງຕົ້ນ.
ສໍາລັບນັກຮຽນຜູ້ທີ່ສາມາດຊອກຫາວິທີແກ້ໄຂໂດຍການລວມເອົາເຕັກນິກທີ່ງ່າຍດາຍ, ມັນພຽງພໍທີ່ຈະເວົ້າວ່າ "ສາຂາສາມາດຂຽນໄດ້ພາຍໃນ loops" ແລະໃຫ້ບັນຫາ "ຕົວຢ່າງ" ຢ່າງສົມບູນເພື່ອແກ້ໄຂຢ່າງເປັນເອກະລາດ.
ຕົວຢ່າງໜ້າວຽກ:

ຜູ້ໃຊ້ໃສ່ຕົວເລກ X. ສະແດງຕົວເລກຈາກ 0 ຫາ 9 ໃນຖັນ ແລະໃສ່ເຄື່ອງໝາຍ '+' ກົງກັນຂ້າມກັບຕົວເລກທີ່ເທົ່າກັບ X.

ຖ້າ 0 ຖືກໃສ່0+
1
2
3
4
5
6
7
8
9

ຖ້າ 6 ຖືກໃສ່0
1
2
3
4
5
6+
7
8
9

ຖ້າ 9 ຖືກໃສ່0
1
2
3
4
5
6
7
8
9+

ຖ້າ 777 ຖືກໃສ່0
1
2
3
4
5
6
7
8
9

ຖ້າຄໍາອະທິບາຍສັ້ນໆບໍ່ພຽງພໍທີ່ຈະຂຽນດ້ວຍ loop, ຫຼັງຈາກນັ້ນທ່ານຈໍາເປັນຕ້ອງບັນລຸການແກ້ໄຂທົ່ວໄປຕໍ່ກັບບັນຫາດຽວກັນໂດຍບໍ່ມີ loop.
ທ່ານຈະໄດ້ຮັບຫນຶ່ງໃນສອງທາງເລືອກ:
ຕ້ອງການ

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine(0 + "+");
} else {
    Console.WriteLine(0);
}
if (x==1) {
    Console.WriteLine(1 + "+");
} else {
    Console.WriteLine(1);
}
if (x==2) {
    Console.WriteLine(2 + "+");
} else {
    Console.WriteLine(2);
}
if (x==3) {
    Console.WriteLine(3 + "+");
} else {
    Console.WriteLine(3);
}
if (x==4) {
    Console.WriteLine(4 + "+");
} else {
    Console.WriteLine(4);
}
if (x==5) {
    Console.WriteLine(5 + "+");
} else {
    Console.WriteLine(5);
}
if (x==6) {
    Console.WriteLine(6 + "+");
} else {
    Console.WriteLine(6);
}
if (x==7) {
    Console.WriteLine(7 + "+");
} else {
    Console.WriteLine(7);
}
if (x==8) {
    Console.WriteLine(8 + "+");
} else {
    Console.WriteLine(8);
}
if (x==9) {
    Console.WriteLine(9 + "+");
} else {
    Console.WriteLine(9);
}

ເປັນໄປໄດ້

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine("0+n1n2n3n4n5n6n7n8n9");
}
if (x==1) {
    Console.WriteLine("0n1+n2n3n4n5n6n7n8n9");
}
if (x==2) {
    Console.WriteLine("0n1n2+n3n4n5n6n7n8n9");
}
if (x==3) {
    Console.WriteLine("0n1n2n3+n4n5n6n7n8n9");
}
if (x==4) {
    Console.WriteLine("0n1n2n3n4+n5n6n7n8n9");
}
if (x==5) {
    Console.WriteLine("0n1n2n3n4n5+n6n7n8n9");
}
if (x==6) {
    Console.WriteLine("0n1n2n3n4n5n6+n7n8n9");
}
if (x==7) {
    Console.WriteLine("0n1n2n3n4n5n6n7+n8n9");
}
if (x==8) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8+n9");
}
if (x==9) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8n9+");
}

ຂ້າພະເຈົ້າໃຫ້ວຽກງານທີ່ຄ້າຍຄືກັນລ່ວງຫນ້າ, ໃນຂະນະທີ່ສຶກສາຫົວຂໍ້ຂອງສາຂາ.
ຖ້ານັກຮຽນມີທາງເລືອກ "ເປັນໄປໄດ້", ເຈົ້າຈໍາເປັນຕ້ອງບອກພວກເຂົາວ່າມີຫຼາຍວິທີແກ້ໄຂບັນຫາດຽວກັນ. ຢ່າງໃດກໍຕາມ, ພວກເຂົາເຈົ້າມີຄວາມແຕກຕ່າງກັນໃນການຕໍ່ຕ້ານກັບການປ່ຽນແປງຄວາມຕ້ອງການ. ຖາມຄໍາຖາມ: "ຈໍານວນສະຖານທີ່ໃນລະຫັດຈະຕ້ອງຖືກແກ້ໄຂຖ້າຂ້ອຍຕ້ອງເພີ່ມຕົວເລກອື່ນ?" ໃນສະບັບ "ເປັນໄປໄດ້", ທ່ານຈະຕ້ອງເພີ່ມຫນຶ່ງສາຂາແລະເພີ່ມຈໍານວນໃຫມ່ໃນ 10 ບ່ອນອື່ນ. ໃນ "ຕ້ອງການ" ມັນພຽງພໍທີ່ຈະເພີ່ມສາຂາດຽວເທົ່ານັ້ນ.
ກໍານົດວຽກງານທີ່ຈະຜະລິດທາງເລືອກ "ຕ້ອງການ", ຫຼັງຈາກນັ້ນຊອກຫາຮູບແບບໃນລະຫັດ, ປະຕິບັດການປ່ຽນແທນຕົວແປແລະຂຽນ loop.
ຖ້າທ່ານມີຄວາມຄິດກ່ຽວກັບວິທີການແກ້ໄຂບັນຫານີ້ໂດຍບໍ່ມີການ loop ໃນບາງວິທີອື່ນ, ກະລຸນາຂຽນໃນຄໍາເຫັນ.

Loops ພາຍໃນ Loops

ໃນຫົວຂໍ້ນີ້, ທ່ານຈໍາເປັນຕ້ອງໄດ້ເອົາໃຈໃສ່ດັ່ງຕໍ່ໄປນີ້:
— ຕົວນັບສໍາລັບ loops ພາຍໃນແລະນອກຈະຕ້ອງເປັນຕົວແປທີ່ແຕກຕ່າງກັນ.
— ຕົວນັບສໍາລັບ loop ພາຍໃນຈະຕ້ອງຖືກຕັ້ງໃຫມ່ຫຼາຍຄັ້ງ (ນັ້ນແມ່ນ, ໃນຮ່າງກາຍຂອງ loop ນອກ).
— ໃນ​ວຽກ​ງານ​ອອກ​ຂໍ້​ຄວາມ​, ຄັ້ງ​ທໍາ​ອິດ​ທ່ານ​ບໍ່​ສາ​ມາດ​ຂຽນ​ຕົວ​ອັກ​ສອນ​ຫນຶ່ງ​ໃນ​ຫຼາຍ​ແຖວ​, ແລະ​ຫຼັງ​ຈາກ​ນັ້ນ​ຄັ້ງ​ທີ​ສອງ​. ກ່ອນອື່ນ ໝົດ ທ່ານຕ້ອງພິມຕົວອັກສອນທັງ ໝົດ ຂອງແຖວ ທຳ ອິດ, ຈາກນັ້ນຕົວອັກສອນທັງ ໝົດ ທີສອງ, ແລະອື່ນໆ.

ມັນດີທີ່ສຸດທີ່ຈະເລີ່ມຕົ້ນການອະທິບາຍຫົວຂໍ້ຂອງ loops ພາຍໃນ loops ໂດຍການອະທິບາຍຄວາມສໍາຄັນຂອງການປັບ counter ກັບສູນ.
ຕົວຢ່າງໜ້າວຽກ:

ຜູ້ໃຊ້ໃສ່ສອງຕົວເລກ: R ແລະ T. ພິມສອງແຖວຂອງຕົວອັກສອນ "#". ແຖວທຳອິດຄວນມີຕົວອັກສອນ R. ສາຍທີສອງປະກອບດ້ວຍ T ຕ່ອນ. ຖ້າຕົວເລກໃດເປັນລົບ, ສະແດງຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດ.

R=5, T=11#####
# ເອື້ອຍ

R=20, T=3######################
###

R=-1, T=6ຄ່າ R ຕ້ອງບໍ່ແມ່ນຄ່າລົບ

R=6, T=-2ຄ່າ T ຕ້ອງບໍ່ແມ່ນຄ່າລົບ

ແນ່ນອນ, ບັນຫານີ້ຍັງມີຢ່າງຫນ້ອຍສອງວິທີແກ້ໄຂ.
ຕ້ອງການ

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
i = 0;
while (i < T)
{
    Console.Write("#");
    i = i + 1;
}

ເປັນໄປໄດ້ #1

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
int j = 0;
j = 0;
while (j < T)
{
    Console.Write("#");
    j = j + 1;
}

ຄວາມແຕກຕ່າງແມ່ນວ່າໃນການແກ້ໄຂ "ເປັນໄປໄດ້", ຕົວແປທີສອງຖືກນໍາໃຊ້ເພື່ອຜະລິດເສັ້ນທີສອງ. ທ່ານຄວນຮຽກຮ້ອງໃຫ້ໃຊ້ຕົວແປດຽວກັນສໍາລັບທັງສອງ loops. ຂໍ້ຈໍາກັດນີ້ສາມາດສົມເຫດສົມຜົນໂດຍຄວາມຈິງທີ່ວ່າການແກ້ໄຂດ້ວຍຕົວຕ້ານການຫນຶ່ງສໍາລັບສອງຮອບຈະເປັນຕົວຢ່າງຂອງຄໍາວ່າ "Counter reset". ການເຂົ້າໃຈຄໍາສັບນີ້ແມ່ນມີຄວາມຈໍາເປັນໃນເວລາທີ່ແກ້ໄຂບັນຫາຕໍ່ໄປນີ້. ເປັນການປະນີປະນອມ, ທ່ານສາມາດປະຫຍັດທັງສອງວິທີແກ້ໄຂກັບບັນຫາ.

ບັນຫາປົກກະຕິຂອງການໃຊ້ຕົວແປຕົວນັບໜຶ່ງສຳລັບສອງ loops ປະກົດເປັນແບບນີ້:
R=5, T=11#####
######

ຈໍານວນຕົວອັກສອນໃນແຖວທີສອງບໍ່ກົງກັນກັບຄ່າຂອງ T. ຖ້າທ່ານຕ້ອງການຄວາມຊ່ວຍເຫຼືອກັບບັນຫານີ້, ທ່ານຈໍາເປັນຕ້ອງໄດ້ເບິ່ງເຂົ້າໄປໃນບັນທຶກກ່ຽວກັບບັນຫາປົກກະຕິທີ່ມີ loops. ນີ້ແມ່ນອາການ #3. ມັນຖືກວິນິດໄສຖ້າທ່ານເພີ່ມຜົນຜະລິດມູນຄ່າ counter ທັນທີກ່ອນທີ່ຈະຮອບທີສອງ. ແກ້ໄຂໂດຍການຣີເຊັດ. ແຕ່ມັນກໍ່ດີກວ່າທີ່ຈະບໍ່ບອກເລື່ອງນີ້ທັນທີ. ນັກຮຽນຕ້ອງພະຍາຍາມສ້າງສົມມຸດຕິຖານຢ່າງໜ້ອຍໜຶ່ງບົດ.

ແນ່ນອນ, ມີວິທີແກ້ໄຂອື່ນ. ແຕ່ຂ້ອຍບໍ່ເຄີຍເຫັນມັນໃນບັນດານັກຮຽນ. ໃນຂັ້ນຕອນຂອງການສຶກສາຮອບວຽນ, ເລື່ອງກ່ຽວກັບມັນຈະລົບກວນຄວາມສົນໃຈ. ທ່ານສາມາດກັບມາຫາມັນໄດ້ໃນພາຍຫຼັງເມື່ອຮຽນຮູ້ກ່ຽວກັບຟັງຊັນສະຕຣິງ.
ເປັນໄປໄດ້ #2

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
Console.WriteLine(new String('#', R));
Console.WriteLine(new String('#', T));

ໜ້າວຽກທີ່ຕ້ອງການຕໍ່ໄປ:

ສະແດງຕົວເລກຈາກ 0 ຫາ 9. ແຕ່ລະຕົວເລກຄວນຈະຢູ່ໃນເສັ້ນຂອງຕົນເອງ. ຈໍານວນຕົວເລກໃນແຖວ (W) ຖືກປ້ອນຈາກແປ້ນພິມ.

W=10
1
2
3
4
5
6
7
8
9

W=100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999

ຖ້ານັກຮຽນໄດ້ mastered ເຕັກນິກການທົດແທນຕົວແປ, ຫຼັງຈາກນັ້ນລາວຈະຮັບມືກັບຂ້ອນຂ້າງໄວ. ບັນຫາທີ່ເປັນໄປໄດ້ອີກເທື່ອຫນຶ່ງຈະຢູ່ໃນການຕັ້ງຄ່າຕົວແປຄືນໃຫມ່. ຖ້າທ່ານບໍ່ສາມາດຈັດການກັບການປ່ຽນແປງໄດ້, ມັນຫມາຍຄວາມວ່າທ່ານຮີບຮ້ອນແລະຕ້ອງການແກ້ໄຂບັນຫາທີ່ງ່າຍດາຍກວ່າ.

ຂອບໃຈສໍາລັບຄວາມສົນໃຈຂອງທ່ານ. ມັກແລະຕິດຕາມຊ່ອງ.

PS ຖ້າ​ຫາກ​ທ່ານ​ພົບ​ເຫັນ typos ຫຼື​ຄວາມ​ຜິດ​ພາດ​ໃນ​ຂໍ້​ຄວາມ​, ກະ​ລຸ​ນາ​ແຈ້ງ​ໃຫ້​ຂ້າ​ພະ​ເຈົ້າ​ຮູ້​. ນີ້ສາມາດເຮັດໄດ້ໂດຍການເລືອກສ່ວນຫນຶ່ງຂອງຂໍ້ຄວາມແລະກົດ "⌘ + Enter" ໃນ Mac, ແລະ "Ctrl / Enter" ໃນແປ້ນພິມຄລາສສິກ, ຫຼືຜ່ານຂໍ້ຄວາມສ່ວນຕົວ. ຖ້າທາງເລືອກເຫຼົ່ານີ້ບໍ່ມີ, ໃຫ້ຂຽນກ່ຽວກັບຂໍ້ຜິດພາດໃນຄໍາເຫັນ. ຂອບ​ໃຈ!

ພຽງແຕ່ຜູ້ໃຊ້ລົງທະບຽນສາມາດເຂົ້າຮ່ວມໃນການສໍາຫຼວດ. ເຂົ້າ​ສູ່​ລະ​ບົບກະລຸນາ.

ແບບສໍາຫຼວດສໍາລັບຜູ້ອ່ານທີ່ບໍ່ມີ karma

• 20,0%ຂ້ອຍສອນແບບມືອາຊີບ, +12

• 10,0%ຂ້ອຍສອນແບບມືອາຊີບ, -11

• 70,0%ຂ້ອຍບໍ່ສອນ, +17

• 0,0%ຂ້ອຍບໍ່ສອນ, -10

• 0,0%ອື່ນໆ0

10 ຜູ້ໃຊ້ລົງຄະແນນສຽງ. 5 ຜູ້ໃຊ້ງົດ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com