🥇ತೊಂದರೆಗಳನ್ನು ಹೇಗೆ ಜಯಿಸುವುದು ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಚಕ್ರಗಳನ್ನು ಬರೆಯುವುದು ಹೇಗೆ ಎಂದು ಕಲಿಸುವುದು ಹೇಗೆ

ನಾವು ಮೂಲಭೂತ ವಿಷಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಕುರಿತು ಮಾತನಾಡುತ್ತೇವೆ ಎಂಬ ವಾಸ್ತವದ ಹೊರತಾಗಿಯೂ, ಈ ಲೇಖನವನ್ನು ಅನುಭವಿ ವೃತ್ತಿಪರರಿಗಾಗಿ ಬರೆಯಲಾಗಿದೆ. ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಆರಂಭಿಕರು ಯಾವ ತಪ್ಪು ಕಲ್ಪನೆಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ ಎಂಬುದನ್ನು ತೋರಿಸುವುದು ಗುರಿಯಾಗಿದೆ. ಅಭಿವರ್ಧಕರನ್ನು ಅಭ್ಯಾಸ ಮಾಡಲು, ಈ ಸಮಸ್ಯೆಗಳನ್ನು ದೀರ್ಘಕಾಲದವರೆಗೆ ಪರಿಹರಿಸಲಾಗಿದೆ, ಮರೆತುಹೋಗಿದೆ ಅಥವಾ ಗಮನಿಸುವುದಿಲ್ಲ. ಈ ವಿಷಯದ ಬಗ್ಗೆ ನೀವು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಯಾರಿಗಾದರೂ ಸಹಾಯ ಮಾಡಬೇಕಾದರೆ ಲೇಖನವು ಸೂಕ್ತವಾಗಿ ಬರಬಹುದು. ಲೇಖನವು ಸ್ಕಿಲ್ಡ್ಟ್, ಸ್ಟ್ರಾಸ್ಟ್ರಪ್, ಒಕುಲೋವ್ ಅವರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕುರಿತು ವಿವಿಧ ಪುಸ್ತಕಗಳಿಂದ ವಸ್ತುಗಳೊಂದಿಗೆ ಸಮಾನಾಂತರಗಳನ್ನು ಸೆಳೆಯುತ್ತದೆ.

ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವಾಗ ಸಾಕಷ್ಟು ಜನರು ಅದರಿಂದ ಹೊರಗಿಡಲ್ಪಟ್ಟ ಕಾರಣ ಚಕ್ರಗಳ ಬಗ್ಗೆ ವಿಷಯವನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ.

ಈ ತಂತ್ರವನ್ನು ದುರ್ಬಲ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ನಿಯಮದಂತೆ, ಬಲವಾದ ಜನರು ಈ ವಿಷಯದ ಮೇಲೆ ಸಿಲುಕಿಕೊಳ್ಳುವುದಿಲ್ಲ ಮತ್ತು ಅವರಿಗೆ ವಿಶೇಷ ತಂತ್ರಗಳೊಂದಿಗೆ ಬರಲು ಅಗತ್ಯವಿಲ್ಲ. ಲೇಖನದ ದ್ವಿತೀಯ ಗುರಿಯು ಈ ತಂತ್ರವನ್ನು "ಎಲ್ಲಾ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಆದರೆ ಒಂದೇ ಶಿಕ್ಷಕ" ವರ್ಗದಿಂದ "ಎಲ್ಲಾ ವಿದ್ಯಾರ್ಥಿಗಳು, ಎಲ್ಲಾ ಶಿಕ್ಷಕರಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ" ವರ್ಗಕ್ಕೆ ವರ್ಗಾಯಿಸುವುದು. ನಾನು ಸಂಪೂರ್ಣ ಸ್ವಂತಿಕೆಯನ್ನು ಹೇಳಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಈ ವಿಷಯವನ್ನು ಕಲಿಸಲು ನೀವು ಈಗಾಗಲೇ ಇದೇ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ದಯವಿಟ್ಟು ನಿಮ್ಮ ಆವೃತ್ತಿಯು ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ ಎಂಬುದನ್ನು ಬರೆಯಿರಿ. ನೀವು ಅದನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದರೆ, ಅದು ಹೇಗೆ ಹೋಯಿತು ಎಂದು ನಮಗೆ ತಿಳಿಸಿ. ಇದೇ ರೀತಿಯ ತಂತ್ರವನ್ನು ಪುಸ್ತಕದಲ್ಲಿ ವಿವರಿಸಿದ್ದರೆ, ದಯವಿಟ್ಟು ಹೆಸರನ್ನು ಬರೆಯಿರಿ.

ನಾನು ಈ ತಂತ್ರದಲ್ಲಿ 4 ವರ್ಷಗಳ ಕಾಲ ಕೆಲಸ ಮಾಡಿದ್ದೇನೆ, ವಿವಿಧ ಹಂತದ ತರಬೇತಿಯ ವಿದ್ಯಾರ್ಥಿಗಳೊಂದಿಗೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಅಧ್ಯಯನ ಮಾಡುತ್ತಿದ್ದೇನೆ. ಒಟ್ಟಾರೆಯಾಗಿ ಸುಮಾರು ಐವತ್ತು ವಿದ್ಯಾರ್ಥಿಗಳು ಮತ್ತು ಎರಡು ಸಾವಿರ ಗಂಟೆಗಳ ತರಗತಿಗಳು ಇವೆ. ಮೊದಲಿಗೆ, ವಿದ್ಯಾರ್ಥಿಗಳು ಯಾವಾಗಲೂ ಈ ವಿಷಯದ ಮೇಲೆ ಸಿಲುಕಿಕೊಂಡರು ಮತ್ತು ಬಿಡುತ್ತಾರೆ. ಪ್ರತಿ ವಿದ್ಯಾರ್ಥಿಯ ನಂತರ, ವಿಧಾನ ಮತ್ತು ವಸ್ತುಗಳನ್ನು ಸರಿಹೊಂದಿಸಲಾಗುತ್ತದೆ. ಕಳೆದ ವರ್ಷದಲ್ಲಿ, ವಿದ್ಯಾರ್ಥಿಗಳು ಇನ್ನು ಮುಂದೆ ಈ ವಿಷಯದ ಮೇಲೆ ಅಂಟಿಕೊಂಡಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ನನ್ನ ಸಂಶೋಧನೆಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ನಿರ್ಧರಿಸಿದೆ.

ನಾನು ಯಾರು ಮತ್ತು ಏಕೆ ಕಲಿಸುತ್ತೇನೆ?

ಯಾವುದೇ ಪ್ರವೇಶ ಪರೀಕ್ಷೆಗಳಿಲ್ಲದ ಕಾರಣ, ತರಗತಿಗಳು ಪ್ರಬಲ ಮತ್ತು ದುರ್ಬಲ ವಿದ್ಯಾರ್ಥಿಗಳನ್ನು ಸೇರಿಸಿಕೊಳ್ಳಬಹುದು. ಲೇಖನದಲ್ಲಿ ನನ್ನ ವಿದ್ಯಾರ್ಥಿಗಳ ಬಗ್ಗೆ ನೀವು ಇನ್ನಷ್ಟು ಓದಬಹುದು ಸಂಜೆ ಕೋರ್ಸ್ ವಿದ್ಯಾರ್ಥಿಗಳ ಭಾವಚಿತ್ರ
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕಲಿಯಲು ಬಯಸುವ ಪ್ರತಿಯೊಬ್ಬರೂ ಅದನ್ನು ಕಲಿಯಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾನು ಶ್ರಮಿಸಿದೆ.
ನನ್ನ ತರಗತಿಗಳು ಪ್ರತ್ಯೇಕವಾಗಿ ನಡೆಯುತ್ತವೆ ಮತ್ತು ಪ್ರತಿಯೊಂದಕ್ಕೂ ವಿದ್ಯಾರ್ಥಿ ತನ್ನ ಸ್ವಂತ ಹಣವನ್ನು ಪಾವತಿಸುತ್ತಾನೆ. ವಿದ್ಯಾರ್ಥಿಗಳು ವೆಚ್ಚವನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತಾರೆ ಮತ್ತು ಕನಿಷ್ಠವನ್ನು ಬೇಡಿಕೆ ಮಾಡುತ್ತಾರೆ ಎಂದು ತೋರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಜನರು ಲೈವ್ ಶಿಕ್ಷಕರೊಂದಿಗೆ ಮುಖಾಮುಖಿ ತರಗತಿಗಳಿಗೆ ಹೋಗುವುದು ಜ್ಞಾನಕ್ಕಾಗಿ ಅಲ್ಲ, ಆದರೆ ಅವರು ಕಲಿತ ವಿಷಯಗಳ ಆತ್ಮವಿಶ್ವಾಸಕ್ಕಾಗಿ, ಪ್ರಗತಿಯ ಭಾವನೆಗಾಗಿ ಮತ್ತು ತಜ್ಞರ (ಶಿಕ್ಷಕರ) ಅನುಮೋದನೆಗಾಗಿ. ವಿದ್ಯಾರ್ಥಿಗಳು ತಮ್ಮ ಕಲಿಕೆಯಲ್ಲಿ ಪ್ರಗತಿ ಕಾಣದಿದ್ದರೆ, ಅವರು ಬಿಡುತ್ತಾರೆ. ಸಾಮಾನ್ಯವಾಗಿ, ತರಗತಿಗಳನ್ನು ರಚಿಸಬಹುದು ಇದರಿಂದ ವಿದ್ಯಾರ್ಥಿಗಳು ಪರಿಚಿತ ರಚನೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸುವಲ್ಲಿ ಪ್ರಗತಿಯನ್ನು ಅನುಭವಿಸುತ್ತಾರೆ. ಅಂದರೆ, ಮೊದಲು ನಾವು ವಿವರವಾಗಿ ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ, ನಂತರ ನಾವು ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ, ನಂತರ ಮಾಡುತ್ತೇವೆ, ಮತ್ತು ಈಗ ನಾವು ಸಾವಿರ ಮತ್ತು ಒಂದು ರಾತ್ರಿ ಕೋರ್ಸ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ಚಕ್ರಗಳನ್ನು ಮಾತ್ರ ಎರಡು ತಿಂಗಳು ಅಧ್ಯಯನ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ - ಬರೆದ ವಿದ್ಯಾರ್ಥಿ ಆದೇಶದ ಅಡಿಯಲ್ಲಿ ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯ. ಆದಾಗ್ಯೂ, ಪ್ರಾಯೋಗಿಕ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು, ನಿಮಗೆ ವಸ್ತುವಿನ ಜ್ಞಾನ ಮಾತ್ರವಲ್ಲ, ಅದರ ಅನ್ವಯದಲ್ಲಿ ಮತ್ತು ಹೊಸ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕುವಲ್ಲಿ ಸ್ವಾತಂತ್ರ್ಯವೂ ಬೇಕಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಮುಖಾಮುಖಿ ಕೋರ್ಸ್‌ಗಳಿಗೆ, ಕನಿಷ್ಠವನ್ನು ಕಲಿಸುವುದು ಮತ್ತು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳು ಮತ್ತು ಸಂಬಂಧಿತ ವಿಷಯಗಳ ಸ್ವತಂತ್ರ ಅಧ್ಯಯನವನ್ನು ಪ್ರೋತ್ಸಾಹಿಸುವುದು ಸರಿಯಾದ ತತ್ವ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಲೂಪ್‌ಗಳ ವಿಷಯದಲ್ಲಿ, ನಿರ್ಮಾಣವನ್ನು ಕನಿಷ್ಠ ಎಂದು ನಾನು ಪರಿಗಣಿಸುತ್ತೇನೆ. ಅದರಿಂದ ನೀವು ತತ್ವವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು. ತತ್ತ್ವವನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದರಿಂದ, ನೀವು ನಿಮಗಾಗಿ ಮತ್ತು ಮಾಡುವಾಗ ಎರಡನ್ನೂ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಬಹುದು.

ದುರ್ಬಲ ವಿದ್ಯಾರ್ಥಿಗಳಿಂದ ವಸ್ತುವಿನ ಪಾಂಡಿತ್ಯವನ್ನು ಸಾಧಿಸಲು, ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ವಿವರಿಸುವುದು ಸಾಕಾಗುವುದಿಲ್ಲ. ಹೆಚ್ಚು ಸರಳವಾದ ಆದರೆ ವೈವಿಧ್ಯಮಯ ಕಾರ್ಯಗಳನ್ನು ನೀಡುವುದು ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿವರಿಸುವುದು ಅವಶ್ಯಕ. ಅಂತಿಮವಾಗಿ, ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಪರಿವರ್ತಿಸುವ ಮತ್ತು ಮಾದರಿಗಳನ್ನು ಹುಡುಕುವ ವಿದ್ಯಾರ್ಥಿಯ ಸಾಮರ್ಥ್ಯದಿಂದ ಅಭಿವೃದ್ಧಿಯ ವೇಗವು ಸೀಮಿತವಾಗಿದೆ. ಸ್ಮಾರ್ಟ್ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ, ಹೆಚ್ಚಿನ ಕಾರ್ಯಯೋಜನೆಯು ನೀರಸವಾಗಿರುತ್ತದೆ. ಅವರೊಂದಿಗೆ ಅಧ್ಯಯನ ಮಾಡುವಾಗ, ನೀವು 100% ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಒತ್ತಾಯಿಸಬೇಕಾಗಿಲ್ಲ. ನನ್ನ ವಸ್ತುವನ್ನು ಇಲ್ಲಿ ವೀಕ್ಷಿಸಬಹುದು ನನ್ನ ಗಿಥಬ್. ನಿಜ, ರೆಪೊಸಿಟರಿಯು ವಾರ್ಲಾಕ್‌ನ ಗ್ರಿಮೊಯಿರ್‌ನಂತಿದೆ - ಎಲ್ಲಿದೆ ಎಂದು ನನ್ನನ್ನು ಹೊರತುಪಡಿಸಿ ಯಾರಿಗೂ ಅರ್ಥವಾಗುವುದಿಲ್ಲ ಮತ್ತು ನೀವು ಚೆಕ್ ಅನ್ನು ವಿಫಲಗೊಳಿಸಿದರೆ, ನೀವು ಹುಚ್ಚರಾಗಬಹುದು

ವಿಧಾನವು ಅಭ್ಯಾಸ-ಆಧಾರಿತವಾಗಿದೆ

ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಿದ್ಧಾಂತವನ್ನು ವಿವರಿಸಲಾಗಿದೆ. ಶಾಖೆಗಳು ಮತ್ತು ಲೂಪ್‌ಗಳನ್ನು ಕಲಿಸುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ತರಗತಿಯ ಮೂಲಭೂತ ಅಂಶಗಳಲ್ಲಿ, ಒಂದು ವಿಷಯದ ಮೇಲೆ ಇಡೀ ಗಂಟೆಯವರೆಗೆ ಉಪಯುಕ್ತ ಉಪನ್ಯಾಸವನ್ನು ನೀಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಪರಿಕಲ್ಪನೆಯನ್ನು ವಿವರಿಸಲು 15-20 ನಿಮಿಷಗಳು ಸಾಕು. ಪ್ರಾಯೋಗಿಕ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಮುಖ್ಯ ತೊಂದರೆಗಳು ಉಂಟಾಗುತ್ತವೆ.
ಪ್ರಾರಂಭಿಕ ಶಿಕ್ಷಕರು ಒಂದು ಉಪನ್ಯಾಸದಲ್ಲಿ ಆಪರೇಟರ್‌ಗಳು, ಶಾಖೆಗಳು, ಲೂಪ್‌ಗಳು ಮತ್ತು ಅರೇಗಳನ್ನು ರ್ಯಾಟಲ್ ಮಾಡಬಹುದು. ಆದರೆ ಅವರ ವಿದ್ಯಾರ್ಥಿಗಳು ಈ ಮಾಹಿತಿಯನ್ನು ಒಟ್ಟುಗೂಡಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸುತ್ತಾರೆ.
ವಸ್ತುವನ್ನು ಹೇಳುವುದು ಮಾತ್ರವಲ್ಲ, ಕೇಳುಗರು ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತಾರೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಸಹ ಅಗತ್ಯವಾಗಿದೆ.

ವಿದ್ಯಾರ್ಥಿ ಸ್ವತಂತ್ರ ಕೆಲಸವನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸುತ್ತಾನೆ ಎಂಬುದರ ಮೂಲಕ ವಿಷಯವನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವ ಅಂಶವನ್ನು ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ.
ಶಿಕ್ಷಕರ ಸಹಾಯವಿಲ್ಲದೆ ವಿದ್ಯಾರ್ಥಿಯು ವಿಷಯದ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವಲ್ಲಿ ಯಶಸ್ವಿಯಾದರೆ, ವಿಷಯವು ಮಾಸ್ಟರಿಂಗ್ ಆಗಿದೆ. ಸ್ವಯಂ ಪರೀಕ್ಷೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ಪ್ರತಿ ಕಾರ್ಯವನ್ನು ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶಗಳೊಂದಿಗೆ ಕೋಷ್ಟಕದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. ಕಾರ್ಯಗಳು ಸ್ಪಷ್ಟ ಕ್ರಮವನ್ನು ಹೊಂದಿವೆ. ಕಾರ್ಯಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವುದನ್ನು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ. ಪ್ರಸ್ತುತ ಕಾರ್ಯವು ತುಂಬಾ ಕಷ್ಟಕರವಾಗಿದ್ದರೆ, ಮುಂದಿನದಕ್ಕೆ ಹೋಗುವುದು ನಿಷ್ಪ್ರಯೋಜಕವಾಗಿದೆ. ಇದು ಇನ್ನಷ್ಟು ಜಟಿಲವಾಗಿದೆ. ಆದ್ದರಿಂದ ವಿದ್ಯಾರ್ಥಿಯು ಪ್ರಸ್ತುತ ಸಂಕೀರ್ಣ ಕಾರ್ಯವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಬಹುದು, ಮೊದಲ ಸಮಸ್ಯೆಯ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಹಲವಾರು ತಂತ್ರಗಳನ್ನು ಅವನಿಗೆ ವಿವರಿಸಲಾಗುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ, ವಿಷಯದ ಸಂಪೂರ್ಣ ವಿಷಯವು ತೊಂದರೆಗಳನ್ನು ನಿವಾರಿಸುವ ತಂತ್ರಗಳಿಗೆ ಬರುತ್ತದೆ. ಸೈಕಲ್‌ಗಳು ಹೆಚ್ಚು ಅಡ್ಡ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ.

ಮೊದಲ ಕಾರ್ಯವು ಯಾವಾಗಲೂ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ. ಎರಡನೆಯದು ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿರುತ್ತದೆ ಮತ್ತು ಶಿಕ್ಷಕರ ಮೇಲ್ವಿಚಾರಣೆಯಲ್ಲಿ ಮೊದಲನೆಯ ನಂತರ ತಕ್ಷಣವೇ "ಸ್ವತಂತ್ರವಾಗಿ" ನಡೆಸಲಾಗುತ್ತದೆ. ಎಲ್ಲಾ ನಂತರದ ಕಾರ್ಯಗಳು ತಪ್ಪು ಕಲ್ಪನೆಗಳನ್ನು ಉಂಟುಮಾಡುವ ವಿವಿಧ ಸಣ್ಣ ವಿಷಯಗಳಿಗೆ ಗಮನ ಕೊಡುವ ಗುರಿಯನ್ನು ಹೊಂದಿವೆ.

ಉದಾಹರಣೆಯ ವಿವರಣೆಯು ಸಂಭಾಷಣೆಯಾಗಿದ್ದು, ಇದರಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಯು ವಸ್ತುವಿನ ಒಂದು ಭಾಗವನ್ನು ಕರಗತ ಮಾಡಿಕೊಂಡಿದ್ದಾನೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪ್ರಸರಣ ಮತ್ತು ಅಡ್ಡ-ಮೌಲ್ಯಮಾಪನವನ್ನು ಮರಳಿ ಕರೆಯಬೇಕಾಗುತ್ತದೆ.

ನಾನು ನೀರಸವಾಗಿರುತ್ತೇನೆ ಮತ್ತು ವಿಷಯದ ಬಗ್ಗೆ ಮೊದಲ ಉದಾಹರಣೆ ಬಹಳ ಮುಖ್ಯ ಎಂದು ಹೇಳುತ್ತೇನೆ. ನೀವು ವ್ಯಾಪಕವಾದ ಸ್ವತಂತ್ರ ಕೆಲಸಕ್ಕಾಗಿ ವಸ್ತುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಮೊದಲ ಉದಾಹರಣೆಯ ಲೋಪಗಳನ್ನು ಸರಿಪಡಿಸಬಹುದು. ಉದಾಹರಣೆಯ ಹೊರತಾಗಿ ಬೇರೇನೂ ಇಲ್ಲದಿದ್ದರೆ, ವಿದ್ಯಾರ್ಥಿಯು ವಿಷಯವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ.

ಯಾವಾಗ ಅಥವಾ?

ವಿವಾದಾತ್ಮಕ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಗಾಗಿ ನಿರ್ಮಾಣದ ಆಯ್ಕೆಯಾಗಿದೆ: ಹಾಗೆಯೇ ಅಥವಾ. ಒಮ್ಮೆ, ಯಾವುದೇ ಬೋಧನಾ ಅನುಭವವಿಲ್ಲದ ನನ್ನ ಅಭ್ಯಾಸದ ಡೆವಲಪರ್ ಸ್ನೇಹಿತ, ಫಾರ್ ಲೂಪ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗಿದೆ ಎಂದು ನನಗೆ ಮನವರಿಕೆ ಮಾಡಲು ಒಂದು ಗಂಟೆ ಕಳೆದರು. ವಾದಗಳು "ಅದರಲ್ಲಿರುವ ಎಲ್ಲವೂ ಸ್ಪಷ್ಟವಾಗಿದೆ ಮತ್ತು ಅದರ ಸ್ಥಳದಲ್ಲಿ ಇಡಲಾಗಿದೆ" ಎಂದು ಕುದಿಯುತ್ತವೆ. ಆದಾಗ್ಯೂ, ನಿಜವಾದ ಆರಂಭಿಕರಿಗಾಗಿ ತೊಂದರೆಗಳ ಮೂಲ ಕಾರಣ ಚಕ್ರದ ಕಲ್ಪನೆಯೇ ಮತ್ತು ಅದರ ಬರವಣಿಗೆಯಲ್ಲ. ಒಬ್ಬ ವ್ಯಕ್ತಿಯು ಈ ಕಲ್ಪನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳದಿದ್ದರೆ, ಅವನು ಸಿಂಟ್ಯಾಕ್ಸ್ನೊಂದಿಗೆ ಕಷ್ಟಪಡುತ್ತಾನೆ. ಕಲ್ಪನೆಯನ್ನು ಅರಿತುಕೊಂಡ ತಕ್ಷಣ, ಕೋಡ್ ವಿನ್ಯಾಸದ ಸಮಸ್ಯೆಗಳು ತಮ್ಮದೇ ಆದ ಮೇಲೆ ಕಣ್ಮರೆಯಾಗುತ್ತವೆ.

ನನ್ನ ವಸ್ತುಗಳಲ್ಲಿ, ಕುಣಿಕೆಗಳ ಥೀಮ್ ಕವಲೊಡೆಯುವ ಥೀಮ್ ಅನ್ನು ಅನುಸರಿಸುತ್ತದೆ. if ಮತ್ತು while ನ ಬಾಹ್ಯ ಹೋಲಿಕೆಯು ನಮಗೆ ನೇರ ಸಾದೃಶ್ಯವನ್ನು ಸೆಳೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ: "ಹೆಡರ್‌ನಲ್ಲಿನ ಸ್ಥಿತಿಯು ನಿಜವಾಗಿದ್ದಾಗ, ದೇಹವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ." ಚಕ್ರದ ಏಕೈಕ ವಿಶಿಷ್ಟತೆಯೆಂದರೆ ದೇಹವನ್ನು ಹಲವು ಬಾರಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ನನ್ನ ಎರಡನೇ ವಾದವೆಂದರೆ ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ಗಿಂತ ಕಡಿಮೆ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅಗತ್ಯವಿರುತ್ತದೆ. ಕಡಿಮೆ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಎಂದರೆ ಕಾಣೆಯಾದ ಅಲ್ಪವಿರಾಮ ಮತ್ತು ಆವರಣಗಳೊಂದಿಗೆ ಕಡಿಮೆ ಸ್ಟುಪಿಡ್ ತಪ್ಪುಗಳು. ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ತಪ್ಪಿಸಲು ಆರಂಭಿಕರು ಇನ್ನೂ ಸಾಕಷ್ಟು ಗಮನ ಮತ್ತು ಸೂಕ್ಷ್ಮತೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿಲ್ಲ.
ಮೂರನೆಯ ವಾದವನ್ನು ಮೊದಲ ವಾದವಾಗಿ ಅನೇಕ ಉತ್ತಮ ಪುಸ್ತಕಗಳಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ.

ವಿದ್ಯಾರ್ಥಿಯು ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಸುಲಭವಾಗಿ ಪರಿವರ್ತಿಸಬಹುದಾದರೆ, ನಂತರ ನೀವು ಹಾದುಹೋಗುವ ಬಗ್ಗೆ ಮಾತನಾಡಬಹುದು. ವಿದ್ಯಾರ್ಥಿಯು ತನಗೆ ಹೆಚ್ಚು ಇಷ್ಟವಾದುದನ್ನು ಆರಿಸಿಕೊಳ್ಳುತ್ತಾನೆ. ರೂಪಾಂತರಗಳು ತೊಂದರೆಗಳನ್ನು ಉಂಟುಮಾಡಿದರೆ, ನಿಮ್ಮ ಗಮನವನ್ನು ಬೇರೆಡೆಗೆ ತಿರುಗಿಸದಿರುವುದು ಉತ್ತಮ. ವಿದ್ಯಾರ್ಥಿಯು ಮೊದಲು ಸಮಯವನ್ನು ಬಳಸಿಕೊಂಡು ಎಲ್ಲವನ್ನೂ ಪರಿಹರಿಸಲಿ. ಒಮ್ಮೆ ನೀವು ಲೂಪ್‌ಗಳ ವಿಷಯವನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡಿದ ನಂತರ, ಪರಿವರ್ತಿಸುವುದನ್ನು ಅಭ್ಯಾಸ ಮಾಡಲು ನೀವು ಪರಿಹಾರಗಳನ್ನು ಪುನಃ ಬರೆಯಬಹುದು.
ಪೋಸ್ಟ್ ಕಂಡಿಶನ್ ಕುಣಿಕೆಗಳು ಬಹಳ ಅಪರೂಪದ ಪ್ರಾಣಿಯಾಗಿದೆ. ನಾನು ಅದರಲ್ಲಿ ಯಾವುದೇ ಸಮಯವನ್ನು ಕಳೆಯುವುದಿಲ್ಲ. ವಿದ್ಯಾರ್ಥಿಯು ಮಾದರಿಗಳನ್ನು ಗುರುತಿಸುವ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಪರಿವರ್ತಿಸುವ ವಿಚಾರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಂಡಿದ್ದರೆ, ನನ್ನ ಸಹಾಯವಿಲ್ಲದೆ ಅವನು ಅದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು.

ಬಲವಾದ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಮೊದಲ ಉದಾಹರಣೆಯನ್ನು ಪ್ರದರ್ಶಿಸುವಾಗ, ಮೊದಲ ಉದಾಹರಣೆಯಲ್ಲಿ ಪರಿಹಾರವನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಫಲಿತಾಂಶಕ್ಕೆ ಕಾರಣವಾದ ಕ್ರಿಯೆಗಳ ಸಂಪೂರ್ಣ ಸರಪಳಿಯನ್ನೂ ದಾಖಲಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ ಎಂಬ ಅಂಶಕ್ಕೆ ನಾನು ಗಮನ ಸೆಳೆಯುತ್ತೇನೆ. ಸೋಮಾರಿಯಾದ ವಿದ್ಯಾರ್ಥಿಗಳು ಬರವಣಿಗೆಯನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು ಮತ್ತು ಅಂತಿಮ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಮಾತ್ರ ನಕಲಿಸಬಹುದು. ಮುಂದೊಂದು ದಿನ ಕಷ್ಟದ ಕೆಲಸವೊಂದು ಎದುರಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಮನವರಿಕೆ ಮಾಡಿಕೊಡಬೇಕು. ಅದನ್ನು ಪರಿಹರಿಸಲು, ಈ ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆ ನೀವು ಹಂತಗಳನ್ನು ಅನುಸರಿಸಬೇಕು. ಅದಕ್ಕಾಗಿಯೇ ಎಲ್ಲಾ ಹಂತಗಳನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಕೆಳಗಿನ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಪರಿಹಾರದ ಅಂತಿಮ ಆವೃತ್ತಿಯನ್ನು ಮಾತ್ರ ಬಿಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಮುಖ್ಯ ಆಲೋಚನೆಯೆಂದರೆ, ಒಬ್ಬ ವ್ಯಕ್ತಿಗೆ ದಿನನಿತ್ಯದ ಕೆಲಸವನ್ನು ಮಾಡಲು ನಾವು ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ಒಪ್ಪಿಸುತ್ತೇವೆ. ಮೂಲ ತಂತ್ರಗಳಲ್ಲಿ ಒಂದು ಲೂಪ್ಗಳನ್ನು ಬರೆಯುವುದು. ಹಲವಾರು ಒಂದೇ ಪುನರಾವರ್ತಿತ ಕ್ರಿಯೆಗಳನ್ನು ಸತತವಾಗಿ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಬರೆಯುವಾಗ ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಮೊದಲ ಲೂಪಿಂಗ್ ಕಾರ್ಯದಲ್ಲಿ ಒಂದೇ ಪದಗುಚ್ಛವನ್ನು ಅನೇಕ ಬಾರಿ ಪ್ರದರ್ಶಿಸುವುದು ಒಳ್ಳೆಯದು ಎಂದು ತೋರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!
ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!
ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!
ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!
ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!
ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!
ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!
ಹುರ್ರೇ, ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ!

ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಕೌಂಟರ್ ಮೌಲ್ಯವು ಗೋಚರಿಸದ ಕಾರಣ ಈ ಆಯ್ಕೆಯು ಕೆಟ್ಟದಾಗಿದೆ. ಆರಂಭಿಕರಿಗಾಗಿ ಇದು ಸಮಸ್ಯೆಯಾಗಿದೆ. ಅವಳನ್ನು ಕಡಿಮೆ ಅಂದಾಜು ಮಾಡಬೇಡಿ. ಮೊದಲಿಗೆ, ಈ ಕಾರ್ಯವು ಮೊದಲನೆಯದು, ಮತ್ತು ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಸರಣಿಯನ್ನು ಪಡೆಯುವ ಕಾರ್ಯವು ಎರಡನೆಯದು. "ಸೈಕಲ್ ಎನ್ ಟೈಮ್ಸ್" ಮತ್ತು "ಎ ಯಿಂದ ಬಿ ವರೆಗೆ ಸೈಕಲ್" ಎಂಬ ಹೆಚ್ಚುವರಿ ಪದಗಳನ್ನು ಪರಿಚಯಿಸುವುದು ಅಗತ್ಯವಾಗಿತ್ತು, ಇದು ಮೂಲಭೂತವಾಗಿ ಒಂದೇ ವಿಷಯವಾಗಿದೆ. ಅನಗತ್ಯ ಘಟಕಗಳನ್ನು ರಚಿಸದಿರಲು, ಸಂಖ್ಯೆಗಳ ಸರಣಿಯ ಔಟ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಉದಾಹರಣೆಯನ್ನು ಮಾತ್ರ ತೋರಿಸಲು ನಾನು ನಿರ್ಧರಿಸಿದೆ. ಕೆಲವು ಜನರು ತಮ್ಮ ತಲೆಯಲ್ಲಿ ಕೌಂಟರ್ ಅನ್ನು ಹೇಗೆ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬೇಕು ಮತ್ತು ಪೂರ್ವಸಿದ್ಧತೆಯಿಲ್ಲದೆ ತಮ್ಮ ತಲೆಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಂನ ನಡವಳಿಕೆಯನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ಕಲಿಯುತ್ತಾರೆ. ಕೆಲವು ವಿದ್ಯಾರ್ಥಿಗಳು ಸೈಕಲ್‌ಗಳ ವಿಷಯದ ಕುರಿತು ಮಾನಸಿಕ ಮಾದರಿಯನ್ನು ಮೊದಲು ಎದುರಿಸುತ್ತಾರೆ.
ಕೆಲವು ಅಭ್ಯಾಸದ ನಂತರ, ಸ್ವತಂತ್ರವಾಗಿ ಪರಿಹರಿಸಲು ಅದೇ ಪಠ್ಯವನ್ನು ಪುನರಾವರ್ತಿಸುವ ಕೆಲಸವನ್ನು ನಾನು ನೀಡುತ್ತೇನೆ. ನೀವು ಮೊದಲು ಗೋಚರಿಸುವ ಕೌಂಟರ್ ಅನ್ನು ನೀಡಿದರೆ ಮತ್ತು ನಂತರ ಅದೃಶ್ಯವನ್ನು ನೀಡಿದರೆ, ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಕಡಿಮೆ ಸಮಸ್ಯೆಗಳು ಉಂಟಾಗುತ್ತವೆ. ಕೆಲವೊಮ್ಮೆ "ಪರದೆಯ ಮೇಲೆ ಕೌಂಟರ್ ಬರೆಯಬೇಡಿ" ಎಂಬ ಸುಳಿವು ಸಾಕು.

ಇತರರು ಅದನ್ನು ಹೇಗೆ ವಿವರಿಸುತ್ತಾರೆ?

ಅಂತರ್ಜಾಲದಲ್ಲಿನ ಹೆಚ್ಚಿನ ಶೈಕ್ಷಣಿಕ ಸಾಮಗ್ರಿಗಳಲ್ಲಿ, ಚಕ್ರದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು "ಉಪನ್ಯಾಸ" ದ ಭಾಗವಾಗಿ ನೀಡಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, developer.mozilla.org ನಲ್ಲಿ (ಪ್ರಸ್ತುತ), ಲೂಪ್ ಜೊತೆಗೆ ಹಲವಾರು ಇತರ ರಚನೆಗಳನ್ನು ವಿವರಿಸಲಾಗಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿನ್ಯಾಸಗಳನ್ನು ಮಾತ್ರ ಟೆಂಪ್ಲೆಟ್ಗಳ ರೂಪದಲ್ಲಿ ನೀಡಲಾಗುತ್ತದೆ. ಅವರ ಉಡಾವಣೆಯ ಫಲಿತಾಂಶವನ್ನು ಪದಗಳಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ, ಆದರೆ ಯಾವುದೇ ವಿವರಣೆಯಿಲ್ಲ. ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, ವಿಷಯದ ಅಂತಹ ಪ್ರಸ್ತುತಿಯು ಅಂತಹ ವಸ್ತುಗಳ ಉಪಯುಕ್ತತೆಯನ್ನು ಶೂನ್ಯದಿಂದ ಗುಣಿಸುತ್ತದೆ. ವಿದ್ಯಾರ್ಥಿಯು ಕೋಡ್ ಅನ್ನು ಪುನಃ ಬರೆಯಬಹುದು ಮತ್ತು ಅದನ್ನು ಸ್ವತಃ ಚಲಾಯಿಸಬಹುದು, ಆದರೆ ಹೋಲಿಕೆಗಾಗಿ ಅವನಿಗೆ ಇನ್ನೂ ಒಂದು ಮಾನದಂಡದ ಅಗತ್ಯವಿದೆ. ಫಲಿತಾಂಶವನ್ನು ಹೋಲಿಸಲು ಏನೂ ಇಲ್ಲದಿದ್ದರೆ ಉದಾಹರಣೆಯನ್ನು ಸರಿಯಾಗಿ ಪುನಃ ಬರೆಯಲಾಗಿದೆ ಎಂದು ನೀವು ಹೇಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು?
ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಮಾತ್ರ ನೀಡಿದಾಗ, ಉದಾಹರಣೆಯಿಲ್ಲದೆ, ಅದು ವಿದ್ಯಾರ್ಥಿಗೆ ಇನ್ನಷ್ಟು ಕಷ್ಟಕರವಾಗುತ್ತದೆ. ಟೆಂಪ್ಲೇಟ್‌ನಲ್ಲಿ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಸರಿಯಾಗಿ ಇರಿಸಲಾಗಿದೆ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಹೇಗೆ? ನೀವು ಬರೆಯಲು ಪ್ರಯತ್ನಿಸಬಹುದು ಹೇಗೋ, ತದನಂತರ ರನ್. ಆದರೆ ಫಲಿತಾಂಶವನ್ನು ಹೋಲಿಸಲು ಯಾವುದೇ ಮಾನದಂಡವಿಲ್ಲದಿದ್ದರೆ, ನಂತರ ಉಡಾವಣೆಯು ಸಹಾಯ ಮಾಡುವುದಿಲ್ಲ.

ಇಂಟ್ಯೂಟಿವ್‌ನಲ್ಲಿನ C ++ ಕೋರ್ಸ್‌ನಲ್ಲಿ, ಲೂಪ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು "ಆಪರೇಟರ್‌ಗಳು" ಎಂಬ ವಿಷಯದ ಕುರಿತು ಉಪನ್ಯಾಸ 4 ರ ಮೂರನೇ ಪುಟದಲ್ಲಿ ಸಮಾಧಿ ಮಾಡಲಾಗಿದೆ. ಲೂಪ್ಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ವಿವರಿಸುವಾಗ, "ಆಪರೇಟರ್" ಎಂಬ ಪದದ ಮೇಲೆ ವಿಶೇಷ ಒತ್ತು ನೀಡಲಾಗುತ್ತದೆ. ಈ ಪದವನ್ನು "ಚಿಹ್ನೆ" ನಂತಹ ಸತ್ಯಗಳ ಗುಂಪಾಗಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ; ಇದು ಹೇಳಿಕೆ", "{} ಒಂದು ಸಂಯುಕ್ತ ಹೇಳಿಕೆ", "ಲೂಪ್‌ನ ದೇಹವು ಒಂದು ಹೇಳಿಕೆಯಾಗಿರಬೇಕು". ನಾನು ಈ ವಿಧಾನವನ್ನು ಇಷ್ಟಪಡುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಇದು ಒಂದು ಪದದ ಹಿಂದೆ ಪ್ರಮುಖ ಸಂಬಂಧಗಳನ್ನು ಮರೆಮಾಡುತ್ತದೆ. ಈ ಹಂತದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂನ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಪದಗಳಾಗಿ ಪಾರ್ಸಿಂಗ್ ಮಾಡುವುದು ಭಾಷೆಯ ವಿವರಣೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಂಪೈಲರ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅಗತ್ಯವಿದೆ, ಆದರೆ ವಿದ್ಯಾರ್ಥಿಗಳು ಮೊದಲ ಅಂದಾಜು ಅಲ್ಲ. ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಹೊಸಬರು ಅಪರೂಪವಾಗಿ ನಿಯಮಗಳಿಗೆ ಅಂತಹ ನಿಕಟ ಗಮನವನ್ನು ನೀಡುವಷ್ಟು ಸೂಕ್ಷ್ಮವಾಗಿರುತ್ತಾರೆ. ಹೊಸ ಪದಗಳನ್ನು ಮೊದಲ ಬಾರಿಗೆ ನೆನಪಿಸಿಕೊಳ್ಳುವ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಅಪರೂಪದ ವ್ಯಕ್ತಿ. ಅವರು ಕಲಿತ ಪದವನ್ನು ಬಹುತೇಕ ಯಾರೂ ಸರಿಯಾಗಿ ಅನ್ವಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದ್ದರಿಂದ, ವಿದ್ಯಾರ್ಥಿಗಳು "ನಾನು ಬರೆದಿರುವಾಗ (a<7);{, ಆದರೆ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ" ನಂತಹ ಬಹಳಷ್ಟು ದೋಷಗಳನ್ನು ಪಡೆಯುತ್ತಾರೆ.
ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, ಆರಂಭದಲ್ಲಿ ನಿರ್ಮಾಣದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಆವರಣದೊಂದಿಗೆ ತಕ್ಷಣವೇ ನೀಡುವುದು ಉತ್ತಮ. ವಿದ್ಯಾರ್ಥಿಯು ನಿರ್ದಿಷ್ಟ ಪ್ರಶ್ನೆಯನ್ನು ಹೊಂದಿದ್ದರೆ ಮಾತ್ರ ಆವರಣಗಳಿಲ್ಲದ ಆಯ್ಕೆಯನ್ನು ವಿವರಿಸಬೇಕು: "ಯಾಕೆ ಆವರಣಗಳಿಲ್ಲ ಮತ್ತು ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ."

ಒಕುಲೋವ್ ಅವರ 2012 ರ ಪುಸ್ತಕ "ಫಂಡಮೆಂಟಲ್ಸ್ ಆಫ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್" ನಲ್ಲಿ, ಲೂಪ್‌ಗಳ ಪರಿಚಯವು ಫಾರ್ ಪ್ಯಾಟರ್ನ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ನಂತರ ಅದರ ಬಳಕೆಗೆ ಶಿಫಾರಸುಗಳನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ನಂತರ ತಕ್ಷಣವೇ ಪಾಠದ ಪ್ರಾಯೋಗಿಕ ವಿಭಾಗಕ್ಕೆ ಹೋಗುತ್ತದೆ. ನನ್ನ ತರಗತಿಗಳಿಗೆ ಅಪರೂಪವಾಗಿ ಬರುವ ಅತ್ಯಂತ ಸಮರ್ಥ ವಿದ್ಯಾರ್ಥಿಗಳಿಗಾಗಿ ಈ ಪುಸ್ತಕವನ್ನು ಬರೆಯಲಾಗಿದೆ ಎಂದು ನಾನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೇನೆ.

ಜನಪ್ರಿಯ ಪುಸ್ತಕಗಳಲ್ಲಿ, ಕೋಡ್ ತುಣುಕುಗಳ ಫಲಿತಾಂಶವನ್ನು ಯಾವಾಗಲೂ ಬರೆಯಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, Shildt "Java 8. The Complete Guide," 2015 ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿದೆ. ಮೊದಲಿಗೆ, ಒಂದು ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ನೀಡಲಾಗುತ್ತದೆ, ನಂತರ ಒಂದು ಉದಾಹರಣೆ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ತಕ್ಷಣವೇ ಅದರ ನಂತರ - ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶ.

ಉದಾಹರಣೆಯಾಗಿ, ರಿವರ್ಸ್ ಮಾಡುವ ಸ್ವಲ್ಪ ಲೂಪ್ ಅನ್ನು ಪರಿಗಣಿಸಿ
ಕೌಂಟ್‌ಡೌನ್ 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

ಟೆಂಪ್ಲೇಟ್, ಉದಾಹರಣೆ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಕಾರ್ಯಕ್ರಮದ ಫಲಿತಾಂಶವನ್ನು ವಿವರಿಸುವ ವಿಧಾನವನ್ನು "ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫಾರ್ ಕಿಡ್ಸ್" ಪುಸ್ತಕದಲ್ಲಿ ಮತ್ತು w3schools.com ನಲ್ಲಿನ js ಕೋರ್ಸ್‌ನಲ್ಲಿ ಸಹ ಬಳಸಲಾಗುತ್ತದೆ. ವೆಬ್ ಪುಟದ ಸ್ವರೂಪವು ಈ ಉದಾಹರಣೆಯನ್ನು ಸಂವಾದಾತ್ಮಕವಾಗಿರಲು ಸಹ ಅನುಮತಿಸುತ್ತದೆ.

ಸ್ಟ್ರಾಸ್ಟ್ರಪ್‌ನ 2016 ರ ಪುಸ್ತಕ ತತ್ವಗಳು ಮತ್ತು C++ ಅನ್ನು ಬಳಸುವ ಅಭ್ಯಾಸವು ಇನ್ನೂ ಮುಂದೆ ಸಾಗಿದೆ. ಯಾವ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಬೇಕು ಎಂಬುದನ್ನು ವಿವರಿಸುವುದು ಮೊದಲ ಹಂತವಾಗಿದೆ, ಮತ್ತು ಅದರ ನಂತರ ಕಾರ್ಯಕ್ರಮದ ಪಠ್ಯವನ್ನು ತೋರಿಸಲಾಗುತ್ತದೆ. ಇದಲ್ಲದೆ, ಅವರು ಕೇವಲ ಯಾದೃಚ್ಛಿಕ ಕಾರ್ಯಕ್ರಮವನ್ನು ಉದಾಹರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ, ಆದರೆ ಇತಿಹಾಸಕ್ಕೆ ವಿಹಾರವನ್ನು ನೀಡುತ್ತಾರೆ. ಇದು ಗಮನ ಸೆಳೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ: “ನೋಡಿ, ಇದು ಕೇವಲ ಕೆಲವು ಅನುಪಯುಕ್ತ ಪಠ್ಯವಲ್ಲ. ನೀವು ಅರ್ಥಪೂರ್ಣವಾದದ್ದನ್ನು ನೋಡುತ್ತೀರಿ. ”

ಪುನರಾವರ್ತನೆಯ ಉದಾಹರಣೆಯಾಗಿ, ಸಂಗ್ರಹಿಸಿದ ಪ್ರೋಗ್ರಾಂ ಯಂತ್ರದಲ್ಲಿ (EDSAC) ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಮೊದಲ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಇದನ್ನು ಮೇ 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;
    }
}

ಕುತೂಹಲಕಾರಿಯಾಗಿ, ಸಿಂಟ್ಯಾಕ್ಸ್ ಮಾದರಿಯನ್ನು ಈ ಪುಸ್ತಕದಲ್ಲಿ ವಿವರಿಸಲಾಗಿಲ್ಲ. ಬೋಧಕರ ಕೈಪಿಡಿಯಲ್ಲಿ ಸ್ಟ್ರಾಸ್ಟ್ರಪ್ (ಅನುವಾದ) ಇದು ತನ್ನ ವಿದ್ಯಾರ್ಥಿಗಳ ಬುದ್ಧಿವಂತಿಕೆಯನ್ನು ಗೌರವಿಸುತ್ತದೆ ಎಂದು ಒತ್ತಿಹೇಳುತ್ತದೆ. ಬಹುಶಃ ಹಲವಾರು ಉದಾಹರಣೆಗಳಲ್ಲಿ ಮಾದರಿಯನ್ನು ಗುರುತಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಅಂತಹ ಬುದ್ಧಿವಂತಿಕೆಯ ಅಭಿವ್ಯಕ್ತಿ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.

ಸ್ಟ್ರಾಸ್ಟ್ರಪ್ನ ವಿಧಾನ: ಫಲಿತಾಂಶವನ್ನು ವಿವರಿಸುವುದು, ನಂತರ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದು, ಮತ್ತು ನಂತರ ವಿದ್ಯಾರ್ಥಿಯಿಂದ ಸ್ವತಂತ್ರ ವಿಶ್ಲೇಷಣೆ - ಅತ್ಯಂತ ಚಿಂತನಶೀಲವಾಗಿದೆ. ಆದ್ದರಿಂದ, ನಾನು ಅದನ್ನು ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲು ನಿರ್ಧರಿಸಿದೆ, ಆದರೆ ಕಡಿಮೆ ಐತಿಹಾಸಿಕ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿ ಹೇಳುತ್ತೇನೆ - "ವಿಷಯಗಳ ಕೋಷ್ಟಕ" ವನ್ನು ಪಡೆಯುವ ಕಾರ್ಯ. ಇದು ಗುರುತಿಸಬಹುದಾದ ಆಂಕರ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ ಇದರಿಂದ ನೀವು "ವಿಷಯಗಳ ಕೋಷ್ಟಕದ ಬಗ್ಗೆ ಕಾರ್ಯವನ್ನು ನೆನಪಿಡಿ" ಎಂದು ಹೇಳಬಹುದು ಮತ್ತು ವಿದ್ಯಾರ್ಥಿಗಳು ಇದನ್ನು ನಿಖರವಾಗಿ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ. ನನ್ನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾನು ಎರಡು ಸಾಮಾನ್ಯ ತಪ್ಪುಗ್ರಹಿಕೆಗಳನ್ನು ತಡೆಯಲು ಪ್ರಯತ್ನಿಸಿದೆ. ಮುಂದೆ ನಾನು ಅವರ ಬಗ್ಗೆ ಹೆಚ್ಚು ವಿವರವಾಗಿ ಬರೆಯುತ್ತೇನೆ.

ಈ ಕಾರ್ಯದಲ್ಲಿ ನಾವು ಸಂಕೀರ್ಣ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ ತಂತ್ರಗಳನ್ನು ಪರಿಚಯಿಸಿದ್ದೇವೆ. ಆರಂಭಿಕ ನಿರ್ಧಾರವನ್ನು ಪ್ರಾಚೀನ ಮತ್ತು ಸರಳವಾಗಿ ಮಾಡಬೇಕಾಗಿದೆ. ಸರಿ, ಈ ಪರಿಹಾರವನ್ನು ಹೇಗೆ ಸುಧಾರಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನೀವು ಯೋಚಿಸಬಹುದು.
Введение Глава 1 Глава 2 Глава 3 Глава 4 Глава 5 Глава 6 Глава 7 Заключение

ನನ್ನ ಅವಲೋಕನಗಳ ಪ್ರಕಾರ, ವಿವಿಧ ಸಂಯೋಜನೆಗಳಲ್ಲಿನ "ಟೆಂಪ್ಲೇಟ್-ಉದಾಹರಣೆ-ಫಲಿತಾಂಶ" ವಿಧಾನವು ಇನ್ನೂ ವಿದ್ಯಾರ್ಥಿಗಳು ಚಕ್ರವನ್ನು ಚಿತ್ರಲಿಪಿಯಾಗಿ ಗ್ರಹಿಸುವ ಅಂಶಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಅಲ್ಲಿ ಬರೆಯಲು ಷರತ್ತು ಏಕೆ ಇತ್ತು, i++ ಮತ್ತು i— ಮತ್ತು ಇತರ ತೋರಿಕೆಯಲ್ಲಿ ಸ್ಪಷ್ಟವಾದ ವಿಷಯಗಳ ನಡುವೆ ಹೇಗೆ ಆಯ್ಕೆ ಮಾಡುವುದು ಎಂದು ಅವರಿಗೆ ಅರ್ಥವಾಗಲಿಲ್ಲ ಎಂಬ ಅಂಶದಲ್ಲಿ ಇದು ಸ್ವತಃ ಸ್ಪಷ್ಟವಾಗಿ ಗೋಚರಿಸುತ್ತದೆ. ಈ ತಪ್ಪುಗ್ರಹಿಕೆಗಳನ್ನು ತಪ್ಪಿಸಲು, ಚಕ್ರಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವ ವಿಧಾನವು ಒಂದೇ ರೀತಿಯ ಕ್ರಿಯೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವ ಅರ್ಥವನ್ನು ಒತ್ತಿಹೇಳಬೇಕು ಮತ್ತು ನಂತರ ಮಾತ್ರ ರಚನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅವುಗಳನ್ನು ಔಪಚಾರಿಕಗೊಳಿಸಬೇಕು. ಆದ್ದರಿಂದ, ಲೂಪ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ನೀಡುವ ಮೊದಲು, ನೀವು ಸಮಸ್ಯೆಯನ್ನು ನೇರವಾಗಿ ಪರಿಹರಿಸಬೇಕಾಗಿದೆ. ಪರಿವಿಡಿ ಸಮಸ್ಯೆಗೆ ಪ್ರಾಚೀನ ಪರಿಹಾರವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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 ಸಾಲುಗಳು ಅಥವಾ ಹೆಚ್ಚಿನ ಕೋಡ್‌ಗಳ ಬ್ಲಾಕ್‌ಗಳು. ನೀವು ಆಜ್ಞೆಗಳ ಪಟ್ಟಿಯಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ ಶಾಖೆ ಅಥವಾ ಲೂಪ್ ನಿರ್ಮಾಣಗಳಲ್ಲಿ ಹುಡುಕಬೇಕಾಗುತ್ತದೆ.
ಉದಾಹರಣೆಯಲ್ಲಿ, ಆಜ್ಞೆಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವು "ಅಧ್ಯಾಯ" ಪದದ ನಂತರದ ಸಂಖ್ಯೆಯಲ್ಲಿದೆ.
ವ್ಯತ್ಯಾಸವನ್ನು ಕಂಡುಕೊಂಡ ನಂತರ, ನೀವು ಬದಲಾವಣೆಯ ಮಾದರಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ವಿಭಿನ್ನ ತುಣುಕು ಸಂಖ್ಯೆಯೇ? ಇದು ನಿರಂತರವಾಗಿ ಹೆಚ್ಚುತ್ತಿದೆಯೇ ಅಥವಾ ಕಡಿಮೆಯಾಗುತ್ತಿದೆಯೇ? ಎರಡು ತಂಡಗಳ ನಡುವೆ ಅಕ್ಕಪಕ್ಕದಲ್ಲಿ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯವು ಹೇಗೆ ಬದಲಾಗುತ್ತದೆ?
ಉದಾಹರಣೆಯಲ್ಲಿ, "ಅಧ್ಯಾಯ" ಪದದ ನಂತರದ ಸಂಖ್ಯೆಯು 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("Заключение");

ಕೋಡ್‌ನಲ್ಲಿ "ವೇರಿಯಬಲ್ ಮಾದರಿಯನ್ನು ವ್ಯಕ್ತಪಡಿಸಿ" ತಂತ್ರವನ್ನು ಅನ್ವಯಿಸಿದ ನಂತರ, ನೀವು ಸತತವಾಗಿ ಹೋಗುವ ಒಂದೇ ರೀತಿಯ ಕ್ರಿಯೆಗಳ ಹಲವಾರು ಗುಂಪುಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಈಗ ಪುನರಾವರ್ತಿತ ಕ್ರಿಯೆಗಳನ್ನು ಚಕ್ರದೊಂದಿಗೆ ಬದಲಾಯಿಸಬಹುದು.

ಚಕ್ರದ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಅನುಕ್ರಮವನ್ನು ಈ ಕೆಳಗಿನ ಹಂತಗಳಿಗೆ ಕಡಿಮೆ ಮಾಡಲಾಗಿದೆ:
* ಅನೇಕ ಪ್ರತ್ಯೇಕ ಆಜ್ಞೆಗಳೊಂದಿಗೆ "ಹೆಡ್-ಆನ್" ಅನ್ನು ಪರಿಹರಿಸಿ
* ಮಾದರಿಯನ್ನು ಹುಡುಕಿ
* ವೇರಿಯಬಲ್ ಮಾದರಿಯನ್ನು ವ್ಯಕ್ತಪಡಿಸಿ
* ಚಕ್ರದಂತೆ ಜೋಡಿಸಿ

ಮುಂದೆ, ಹೊಸ ಪದಗಳನ್ನು ಪರಿಚಯಿಸಲಾಗಿದೆ ಆದ್ದರಿಂದ ವಿದ್ಯಾರ್ಥಿಯು "ನಾನು ಎಲ್ಲವನ್ನೂ ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೇನೆ, ಆದರೆ ನಾನು ಅದನ್ನು ಹೇಳಲಾರೆ" ಎಂಬ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ತನ್ನನ್ನು ಕಂಡುಕೊಳ್ಳುವುದಿಲ್ಲ:
- ಕೌಂಟರ್ ಯಾವಾಗಲೂ ವೇರಿಯಬಲ್ ಆಗಿದ್ದು ಅದು ಲೂಪ್‌ನಲ್ಲಿನ ಹಂತಗಳ ಸಂಖ್ಯೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ವಿಶಿಷ್ಟವಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ನಿರ್ಬಂಧಕ್ಕೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ.
- ಕೌಂಟರ್ ಸ್ಟೆಪ್ - ಕೌಂಟರ್ ಬದಲಾವಣೆಗಳ ಮಾದರಿಯ ವಿವರಣೆ.
- ನಿರ್ಬಂಧ - ಕೌಂಟರ್ ಅನ್ನು ಹೋಲಿಸಿದ ಸಂಖ್ಯೆ ಅಥವಾ ವೇರಿಯೇಬಲ್ ಆದ್ದರಿಂದ ಅಲ್ಗಾರಿದಮ್ ಅಂತಿಮವಾಗಿರುತ್ತದೆ. ಕೌಂಟರ್ ಮೌಲ್ಯವು ಮಿತಿಯನ್ನು ಸಮೀಪಿಸಲು ಬದಲಾಗುತ್ತದೆ.
- ಲೂಪ್ ಬಾಡಿ - ಪುನರಾವರ್ತಿತ ಆಜ್ಞೆಗಳ ಒಂದು ಸೆಟ್. "ಕಮಾಂಡ್ ಅನ್ನು ಲೂಪ್ ಒಳಗೆ ಬರೆಯಲಾಗಿದೆ" ಎಂದು ಅವರು ಹೇಳಿದಾಗ ಅವರು ದೇಹವನ್ನು ಅರ್ಥೈಸುತ್ತಾರೆ.
- ಲೂಪ್ ಪುನರಾವರ್ತನೆ - ಲೂಪ್ ದೇಹದ ಒಂದು-ಬಾರಿ ಮರಣದಂಡನೆ.
- ಲೂಪ್ ಸ್ಥಿತಿ - ಮತ್ತೊಂದು ಪುನರಾವರ್ತನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕೆ ಎಂದು ನಿರ್ಧರಿಸುವ ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿ. (ಇಲ್ಲಿ ಕವಲೊಡೆಯುವ ರಚನೆಗಳೊಂದಿಗೆ ಗೊಂದಲವಿರಬಹುದು)
ಮೊದಲಿಗೆ ವಿದ್ಯಾರ್ಥಿಗಳು ಇತರ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಪದಗಳನ್ನು ಬಳಸುತ್ತಾರೆ ಎಂಬ ಅಂಶಕ್ಕೆ ನೀವು ಸಿದ್ಧರಾಗಿರಬೇಕು. ಇದು ಬಲಶಾಲಿ ಮತ್ತು ದುರ್ಬಲ ಇಬ್ಬರಿಗೂ ಅನ್ವಯಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ಭಾಷೆಯನ್ನು ಸ್ಥಾಪಿಸುವುದು ಒಂದು ಕಲೆ. ಈಗ ನಾನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಬರೆಯುತ್ತೇನೆ: ನೀವು "ಕೋಡ್ ತುಣುಕನ್ನು <term> ನೊಂದಿಗೆ ಹೈಲೈಟ್ ಮಾಡಿ" ಕಾರ್ಯವನ್ನು ಹೊಂದಿಸಬೇಕು ಮತ್ತು ಸಂಭಾಷಣೆಯಲ್ಲಿ ಈ ಪದಗಳನ್ನು ನೀವೇ ಸರಿಯಾಗಿ ಬಳಸಿ.
ಲೂಪ್ನೊಂದಿಗೆ ರೂಪಾಂತರದ ನಂತರ, ತುಣುಕನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ:

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 ಅನ್ನು ಘೋಷಿಸಲು ಮತ್ತು ಪ್ರಾರಂಭಿಸಲು ಆಜ್ಞೆಗಳು ಇತರ ಪುನರಾವರ್ತಿತ ಕ್ರಿಯೆಗಳಂತೆ ಅಲ್ಲ. ಅವುಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ಅವುಗಳನ್ನು ಲೂಪ್ ದೇಹದ ಹೊರಗೆ ಬರೆಯಬೇಕಾಗಿದೆ.

ಪರಿಹಾರದ ಎಲ್ಲಾ ಮೂರು ಹಂತಗಳು ಕೋಡ್‌ನಲ್ಲಿ ಉಳಿಯಬೇಕು ಇದರಿಂದ ನೀವು ನಂತರ ತೊಂದರೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಅವುಗಳನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು. ಅವರು ಮಧ್ಯಪ್ರವೇಶಿಸದಂತೆ ಮೊದಲ ಎರಡು ಆಯ್ಕೆಗಳನ್ನು ಕಾಮೆಂಟ್ ಮಾಡಲು ಸಾಕು.
ಈ ಕೆಳಗಿನ ಸಂಗತಿಗಳಿಗೆ ವಿದ್ಯಾರ್ಥಿಯ ಗಮನವನ್ನು ಸೆಳೆಯಬೇಕು:
- ಲೂಪ್ ಸ್ಥಿತಿಯಲ್ಲಿ, ಕೌಂಟರ್ ಮತ್ತು ಮಿತಿಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಕೌಂಟರ್ ಲೂಪ್ನ ದೇಹದಲ್ಲಿ ಬದಲಾಗಬಹುದು, ಆದರೆ ಮಿತಿ ಸಾಧ್ಯವಿಲ್ಲ. ಈ ನಿಯಮವನ್ನು ಮುರಿಯಲು, ನೀವು ಬಲವಾದ ಕಾರಣಗಳನ್ನು ರೂಪಿಸಬೇಕಾಗಿದೆ.
- "ಪರಿಚಯ" ಮತ್ತು "ತೀರ್ಮಾನ" ಪದಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಆಜ್ಞೆಗಳು ಲೂಪ್ನ ದೇಹದ ಹೊರಗೆ ಇದೆ. ನಾವು ಅವುಗಳನ್ನು 1 ಬಾರಿ ನಿರ್ವಹಿಸಬೇಕಾಗಿದೆ. "ಪರಿಚಯ" - ಕ್ರಿಯೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವ ಮೊದಲು, "ತೀರ್ಮಾನ" - ನಂತರ.
ಈ ವಿಷಯವನ್ನು ಕ್ರೋಢೀಕರಿಸುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಮುಂದಿನದನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವಲ್ಲಿ, ಹಾಗೆಯೇ ತೊಂದರೆಗಳನ್ನು ಎದುರಿಸುವಾಗ, ಬಲವಾದ ವಿದ್ಯಾರ್ಥಿಗಳು ಸಹ ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ: "ಈ ಕ್ರಿಯೆಯನ್ನು ಎಷ್ಟು ಬಾರಿ ನಿರ್ವಹಿಸಬೇಕು? ಒಂದು ಅಥವಾ ಅನೇಕ?

ಹೆಚ್ಚುವರಿ ಕೌಶಲ್ಯಗಳ ಅಭಿವೃದ್ಧಿ

ಚಕ್ರಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ವಿದ್ಯಾರ್ಥಿಗಳು ಸಮಸ್ಯೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಮತ್ತು ಪರಿಹರಿಸುವ ಕೌಶಲ್ಯವನ್ನು ಸಹ ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಾರೆ. ರೋಗನಿರ್ಣಯವನ್ನು ಕೈಗೊಳ್ಳಲು, ವಿದ್ಯಾರ್ಥಿಯು ಬಯಸಿದ ಫಲಿತಾಂಶವನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು ನಿಜವಾದ ಫಲಿತಾಂಶದೊಂದಿಗೆ ಹೋಲಿಸಬೇಕು. ಸರಿಪಡಿಸುವ ಕ್ರಮಗಳು ಅವುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.
ಈ ಹಂತದಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳು ಇನ್ನೂ "ಬಯಸಿದ" ಫಲಿತಾಂಶದ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ಅವರು ಪರೀಕ್ಷಾ ಡೇಟಾದ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಬಹುದು. ನಿಯಮದಂತೆ, ಈ ಹಂತದಲ್ಲಿ ಯಾರೂ ಇನ್ನೂ ಏನು ತಪ್ಪಾಗಬಹುದು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಎದುರಿಸಬೇಕೆಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ, ನಾನು ನೋಟ್ಬುಕ್ನಲ್ಲಿ ವಿಶಿಷ್ಟ ಸಮಸ್ಯೆಗಳ ವಿವರಣೆಯನ್ನು ಮತ್ತು ಅವುಗಳನ್ನು ಪರಿಹರಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ಬರೆಯುತ್ತೇನೆ. ಹೆಚ್ಚು ಸೂಕ್ತವಾದದನ್ನು ಆರಿಸುವುದು ವಿದ್ಯಾರ್ಥಿಯ ಕಾರ್ಯವಾಗಿದೆ.
“ನಿರೀಕ್ಷಿಸಿದ್ದು ಏನಾಯಿತು?”, “ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಯಾವುದು ಈಗ ಸಂಭವಿಸಿದೆ?”, “ಅನ್ವಯಿಕ ಪರಿಹಾರವು ಸಹಾಯ ಮಾಡಿದೆಯೇ?” ಎಂದು ಕೇಳಲು ದಾಖಲೆಯ ಅಗತ್ಯವಿದೆ.

ಕ್ರಿಯೆಗಳ ಸಂಖ್ಯೆಯು ನಿರೀಕ್ಷೆಗಿಂತ 1 ಕಡಿಮೆ ಅಥವಾ ಹೆಚ್ಚು. ಪರಿಹಾರಗಳು:
- ಕೌಂಟರ್‌ನ ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಿ.
- ಕಟ್ಟುನಿಟ್ಟಾದ ಹೋಲಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು (< ಅಥವಾ >) ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಲ್ಲದ (<= ಅಥವಾ >=) ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ.
- ಮಿತಿ ಮೌಲ್ಯವನ್ನು 1 ಕ್ಕೆ ಬದಲಾಯಿಸಿ.
ಲೂಪ್‌ನಲ್ಲಿನ ಕ್ರಿಯೆಗಳನ್ನು ನಿಲ್ಲಿಸದೆ, ಅನಿರ್ದಿಷ್ಟವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಪರಿಹಾರಗಳು:
- ಒಂದು ಕೌಂಟರ್ ಬದಲಾವಣೆ ಆಜ್ಞೆಯನ್ನು ಅದು ಕಾಣೆಯಾಗಿದ್ದರೆ ಸೇರಿಸಿ.
- ಕೌಂಟರ್ ಬದಲಾವಣೆ ಆಜ್ಞೆಯನ್ನು ಸರಿಪಡಿಸಿ ಇದರಿಂದ ಅದರ ಮೌಲ್ಯವು ಮಿತಿಗೆ ಹತ್ತಿರವಾಗುತ್ತದೆ.
- ಲೂಪ್‌ನ ದೇಹದಲ್ಲಿದ್ದರೆ ನಿರ್ಬಂಧ ಬದಲಾವಣೆ ಆಜ್ಞೆಯನ್ನು ತೆಗೆದುಹಾಕಿ.
ಲೂಪ್‌ನಲ್ಲಿನ ಕ್ರಿಯೆಗಳ ಸಂಖ್ಯೆಯು ನಿರೀಕ್ಷೆಗಿಂತ 1 ಕ್ಕಿಂತ ಕಡಿಮೆ ಅಥವಾ ಹೆಚ್ಚು. ಲೂಪ್‌ನಲ್ಲಿನ ಕ್ರಿಯೆಯನ್ನು ಒಮ್ಮೆಯೂ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿಲ್ಲ. ಮೊದಲು ನೀವು ಲೂಪ್ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು ವೇರಿಯೇಬಲ್‌ಗಳ ನಿಜವಾದ ಮೌಲ್ಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು. ಪರಿಹಾರಗಳು:
- ನಿರ್ಬಂಧದ ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿ
- ಕೌಂಟರ್ನ ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿ

ಸಮಸ್ಯೆ 3 ಸಾಮಾನ್ಯವಾಗಿ ತಪ್ಪು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಅಥವಾ ಕೌಂಟರ್ ಅನ್ನು ಶೂನ್ಯಕ್ಕೆ ಮರುಹೊಂದಿಸುವುದಿಲ್ಲ.

ಈ ವಿವರಣೆಯ ನಂತರ, ಲೂಪ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಕುರಿತು ವಿದ್ಯಾರ್ಥಿಯು ಇನ್ನೂ ಹಲವಾರು ತಪ್ಪುಗ್ರಹಿಕೆಗಳನ್ನು ಹೊಂದಿರಬಹುದು.
ಸಾಮಾನ್ಯವಾದವುಗಳನ್ನು ತೊಡೆದುಹಾಕಲು, ನಾನು ನಿಮಗೆ ಈ ಕೆಳಗಿನ ಕಾರ್ಯಗಳನ್ನು ನೀಡುತ್ತೇನೆ:

ಇದರಲ್ಲಿ ಬಳಕೆದಾರರಿಂದ ಮಿತಿ, ಆರಂಭಿಕ ಕೌಂಟರ್ ಮೌಲ್ಯ ಅಥವಾ ಕೌಂಟರ್ ಹಂತವನ್ನು ನಮೂದಿಸಲಾಗುತ್ತದೆ.
ಇದರಲ್ಲಿ ಕೌಂಟರ್ ಮೌಲ್ಯವನ್ನು ಕೆಲವು ಅಂಕಗಣಿತದ ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ ಬಳಸಬೇಕು. ಆಮೂಲಾಗ್ರ ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ ಅಥವಾ ಛೇದದಲ್ಲಿ ಕೌಂಟರ್ ಅನ್ನು ಬಳಸಲು ಸಲಹೆ ನೀಡಲಾಗುತ್ತದೆ ಇದರಿಂದ ವ್ಯತ್ಯಾಸವು ರೇಖಾತ್ಮಕವಲ್ಲ.
ಇದರಲ್ಲಿ ಲೂಪ್ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಕೌಂಟರ್ ಮೌಲ್ಯವನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಅಗತ್ಯವಿರುವ ಸಂಖ್ಯೆಯ ಒಂದೇ ರೀತಿಯ ಪಠ್ಯ ತುಣುಕುಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವುದು ಅಥವಾ ಆಮೆ ಗ್ರಾಫಿಕ್ಸ್‌ನೊಂದಿಗೆ ಆಕೃತಿಯನ್ನು ಚಿತ್ರಿಸುವುದು.
ಇದರಲ್ಲಿ ನೀವು ಮೊದಲು ಕೆಲವು ಪುನರಾವರ್ತಿತ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ನಂತರ ಇತರರು.
ಇದರಲ್ಲಿ ನೀವು ಪುನರಾವರ್ತಿಸುವ ಮೊದಲು ಮತ್ತು ನಂತರ ಇತರ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಬೇಕಾಗುತ್ತದೆ

ಪ್ರತಿ ಕಾರ್ಯಕ್ಕಾಗಿ ನೀವು ಪರೀಕ್ಷಾ ಡೇಟಾ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ಒದಗಿಸಬೇಕಾಗುತ್ತದೆ.

ನೀವು ಎಷ್ಟು ಬೇಗನೆ ಚಲಿಸಬಹುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನೀವು ಈ ಸಮಸ್ಯೆಗಳ ನಿಯಮಗಳನ್ನು ಓದಬೇಕು ಮತ್ತು ಕೇಳಬೇಕು: "ಅವು ಉದಾಹರಣೆಯಿಂದ ಹೇಗೆ ಭಿನ್ನವಾಗಿವೆ?", "ಅವುಗಳನ್ನು ಪರಿಹರಿಸಲು ಉದಾಹರಣೆಯಲ್ಲಿ ಏನು ಬದಲಾಯಿಸಬೇಕು?" ವಿದ್ಯಾರ್ಥಿಯು ಅರ್ಥಪೂರ್ಣವಾಗಿ ಉತ್ತರಿಸಿದರೆ, ಅವನು ತರಗತಿಯಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದನ್ನಾದರೂ ಪರಿಹರಿಸಲಿ, ಮತ್ತು ಉಳಿದವುಗಳನ್ನು ಮನೆಯಲ್ಲಿಯೇ ಪರಿಹರಿಸಿ. ಪರಿಹಾರವು ಯಶಸ್ವಿಯಾದರೆ, ನಾವು ಲೂಪ್‌ಗಳೊಳಗಿನ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ವಿವರಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು.
ನಿಮ್ಮದೇ ಆದ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವಲ್ಲಿ ನಿಮಗೆ ಸಮಸ್ಯೆಗಳಿದ್ದರೆ, ನೀವು ತರಗತಿಯಲ್ಲಿ ಎಲ್ಲದರ ಮೂಲಕ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಗೂಬೆಯನ್ನು ಚಿತ್ರಿಸುವುದನ್ನು ನೆನಪಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು, ಸಾರ್ವತ್ರಿಕವಲ್ಲದ ರೀತಿಯಲ್ಲಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾನು ಮೊದಲು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ಅಂದರೆ, ಪರಿಹಾರವು ಮೊದಲ ಪರೀಕ್ಷೆಯನ್ನು ಹಾದುಹೋಗುತ್ತದೆ ಮತ್ತು ಲೂಪ್ ನಿರ್ಮಾಣವನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಸರಿ, ನಂತರ ಪರಿಹಾರದ ಸಾರ್ವತ್ರಿಕತೆಯನ್ನು ಸಾಧಿಸಲು ರೂಪಾಂತರಗಳನ್ನು ಅನ್ವಯಿಸಿ.

ಕುಣಿಕೆಗಳು ಮತ್ತು ಶಾಖೆಗಳು

ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, "ಶಾಖೆಗಳೊಳಗಿನ ಚಕ್ರಗಳು" ಎಂಬ ವಿಷಯವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನೀಡಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಆದ್ದರಿಂದ ನಂತರ ನೀವು ಸ್ಥಿತಿಯನ್ನು ಹಲವಾರು ಬಾರಿ ಪರಿಶೀಲಿಸುವ ಮತ್ತು ಒಮ್ಮೆ ಪರಿಶೀಲಿಸುವ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡಬಹುದು.
ಬಲವರ್ಧನೆಯ ಕಾರ್ಯಗಳು A ನಿಂದ B ಗೆ ಸಂಖ್ಯೆಗಳನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುವುದರ ಬಗ್ಗೆ ಇರುತ್ತದೆ, ಅದನ್ನು ಬಳಕೆದಾರರು ನಮೂದಿಸಿದ್ದಾರೆ:
- ಯಾವಾಗಲೂ ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ.
- A ಮತ್ತು B ಮೌಲ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿ ಆರೋಹಣ ಅಥವಾ ಅವರೋಹಣ.

ವಿದ್ಯಾರ್ಥಿಯು ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಂಡ ನಂತರವೇ "ಲೂಪ್‌ಗಳೊಳಗೆ ಕವಲೊಡೆಯುವುದು" ಎಂಬ ವಿಷಯವನ್ನು ಮುಂದುವರಿಸಬೇಕು: "ಮಾದರಿಯನ್ನು ವೇರಿಯಬಲ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದು" ಮತ್ತು "ಚಕ್ರದೊಂದಿಗೆ ಪುನರಾವರ್ತಿತ ಕ್ರಿಯೆಗಳನ್ನು ಬದಲಾಯಿಸುವುದು."
ಕುಣಿಕೆಗಳ ಒಳಗೆ ಶಾಖೆಗಳನ್ನು ಬಳಸುವ ಮುಖ್ಯ ಕಾರಣವೆಂದರೆ ಮಾದರಿಯಲ್ಲಿನ ವೈಪರೀತ್ಯಗಳು. ಮಧ್ಯದಲ್ಲಿ ಇದು ಆರಂಭಿಕ ಡೇಟಾವನ್ನು ಅವಲಂಬಿಸಿ ಒಡೆಯುತ್ತದೆ.
ಸರಳ ತಂತ್ರಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಪರಿಹಾರವನ್ನು ಹುಡುಕಲು ಸಾಧ್ಯವಾಗುವ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ, "ಕವಲೊಡೆಯುವಿಕೆಯನ್ನು ಕುಣಿಕೆಗಳ ಒಳಗೆ ಬರೆಯಬಹುದು" ಎಂದು ಹೇಳಲು ಸಾಕು ಮತ್ತು ಸ್ವತಂತ್ರವಾಗಿ ಪರಿಹರಿಸಲು ಸಮಸ್ಯೆಯನ್ನು "ಉದಾಹರಣೆಗೆ" ಸಂಪೂರ್ಣವಾಗಿ ನೀಡಿ.
ಉದಾಹರಣೆ ಕಾರ್ಯ:

ಬಳಕೆದಾರರು 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

ಲೂಪ್ನೊಂದಿಗೆ ಬರೆಯಲು ಸಂಕ್ಷಿಪ್ತ ವಿವರಣೆಯು ಸಾಕಾಗುವುದಿಲ್ಲವಾದರೆ, ನೀವು ಲೂಪ್ ಇಲ್ಲದೆ ಅದೇ ಸಮಸ್ಯೆಗೆ ಸಾರ್ವತ್ರಿಕ ಪರಿಹಾರವನ್ನು ಸಾಧಿಸಬೇಕು.
ನೀವು ಎರಡು ಆಯ್ಕೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಪಡೆಯುತ್ತೀರಿ:
ಬಯಸಿದೆ

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 ಇತರ ಸ್ಥಳಗಳಲ್ಲಿ ಹೊಸ ಸಂಖ್ಯೆಯನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ. "ಬಯಸಿದ" ನಲ್ಲಿ ಕೇವಲ ಒಂದು ಶಾಖೆಯನ್ನು ಸೇರಿಸಲು ಸಾಕು.
"ಬಯಸಿದ" ಆಯ್ಕೆಯನ್ನು ಪುನರುತ್ಪಾದಿಸಲು ಕಾರ್ಯವನ್ನು ಹೊಂದಿಸಿ, ನಂತರ ಕೋಡ್ನಲ್ಲಿ ಮಾದರಿಯನ್ನು ಹುಡುಕಿ, ವೇರಿಯಬಲ್ ಬದಲಿಯನ್ನು ನಿರ್ವಹಿಸಿ ಮತ್ತು ಲೂಪ್ ಅನ್ನು ಬರೆಯಿರಿ.
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಲೂಪ್ ಇಲ್ಲದೆ ಈ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನೀವು ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿದ್ದರೆ, ದಯವಿಟ್ಟು ಕಾಮೆಂಟ್ಗಳಲ್ಲಿ ಬರೆಯಿರಿ.

ಲೂಪ್ಸ್ ಒಳಗೆ ಕುಣಿಕೆಗಳು

ಈ ವಿಷಯದಲ್ಲಿ ನೀವು ಈ ಕೆಳಗಿನವುಗಳಿಗೆ ಗಮನ ಕೊಡಬೇಕು:
- ಒಳ ಮತ್ತು ಹೊರ ಕುಣಿಕೆಗಳ ಕೌಂಟರ್‌ಗಳು ವಿಭಿನ್ನ ಅಸ್ಥಿರಗಳಾಗಿರಬೇಕು.
- ಒಳಗಿನ ಲೂಪ್‌ನ ಕೌಂಟರ್ ಅನ್ನು ಹಲವು ಬಾರಿ ಮರುಹೊಂದಿಸಬೇಕು (ಅಂದರೆ, ಹೊರಗಿನ ಲೂಪ್‌ನ ದೇಹದಲ್ಲಿ).
- ಪಠ್ಯ ಔಟ್‌ಪುಟ್ ಕಾರ್ಯಗಳಲ್ಲಿ, ನೀವು ಮೊದಲು ಒಂದು ಅಕ್ಷರವನ್ನು ಹಲವಾರು ಸಾಲುಗಳಲ್ಲಿ ಬರೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ, ಮತ್ತು ನಂತರ ಎರಡನೆಯದು. ನೀವು ಮೊದಲು ಮೊದಲ ಸಾಲಿನ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಮುದ್ರಿಸಬೇಕು, ನಂತರ ಎರಡನೆಯ ಎಲ್ಲಾ ಅಕ್ಷರಗಳು, ಇತ್ಯಾದಿ.

ಕೌಂಟರ್ ಅನ್ನು ಶೂನ್ಯಕ್ಕೆ ಮರುಹೊಂದಿಸುವ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ವಿವರಿಸುವ ಮೂಲಕ ಲೂಪ್‌ಗಳೊಳಗಿನ ಲೂಪ್‌ಗಳ ವಿಷಯವನ್ನು ವಿವರಿಸಲು ಪ್ರಾರಂಭಿಸುವುದು ಉತ್ತಮ.
ಉದಾಹರಣೆ ಕಾರ್ಯ:

ಬಳಕೆದಾರರು ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ನಮೂದಿಸುತ್ತಾರೆ: R ಮತ್ತು T. "#" ಅಕ್ಷರಗಳ ಎರಡು ಸಾಲುಗಳನ್ನು ಮುದ್ರಿಸಿ. ಮೊದಲ ಸಾಲಿನಲ್ಲಿ R ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿರಬೇಕು. ಎರಡನೇ ಸಾಲಿನಲ್ಲಿ ಟಿ ತುಣುಕುಗಳಿವೆ. ಯಾವುದೇ ಸಂಖ್ಯೆಯು ನಕಾರಾತ್ಮಕವಾಗಿದ್ದರೆ, ದೋಷ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಿ.

R=5, T=11#####
############

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

R=-1, T=6R ಮೌಲ್ಯವು ಋಣಾತ್ಮಕವಾಗಿರಬಾರದು

R=6, T=-2ಟಿ ಮೌಲ್ಯವು ಋಣಾತ್ಮಕವಾಗಿರಬಾರದು

ನಿಸ್ಸಂಶಯವಾಗಿ, ಈ ಸಮಸ್ಯೆಯು ಕನಿಷ್ಠ ಎರಡು ಪರಿಹಾರಗಳನ್ನು ಹೊಂದಿದೆ.
ಬಯಸಿದೆ

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;
}

ವ್ಯತ್ಯಾಸವೆಂದರೆ "ಸಂಭವನೀಯ" ಪರಿಹಾರದಲ್ಲಿ, ಎರಡನೇ ಸಾಲಿನ ಔಟ್ಪುಟ್ ಮಾಡಲು ಎರಡನೇ ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸಲಾಗಿದೆ. ಎರಡೂ ಲೂಪ್‌ಗಳಿಗೆ ಒಂದೇ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸಲು ನೀವು ಒತ್ತಾಯಿಸಬೇಕು. ಎರಡು ಚಕ್ರಗಳಿಗೆ ಒಂದು ಕೌಂಟರ್ನೊಂದಿಗೆ ಪರಿಹಾರವು "ಕೌಂಟರ್ ರೀಸೆಟ್" ಎಂಬ ಪದದ ವಿವರಣೆಯಾಗಿದೆ ಎಂಬ ಅಂಶದಿಂದ ಈ ಮಿತಿಯನ್ನು ಸಮರ್ಥಿಸಬಹುದು. ಕೆಳಗಿನ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವಾಗ ಈ ಪದವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅವಶ್ಯಕ. ರಾಜಿಯಾಗಿ, ನೀವು ಸಮಸ್ಯೆಗೆ ಎರಡೂ ಪರಿಹಾರಗಳನ್ನು ಉಳಿಸಬಹುದು.

ಎರಡು ಲೂಪ್‌ಗಳಿಗೆ ಒಂದು ಕೌಂಟರ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುವಲ್ಲಿ ವಿಶಿಷ್ಟವಾದ ಸಮಸ್ಯೆಯು ಈ ರೀತಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ:
R=5, T=11#####
# # # # # #

ಎರಡನೇ ಸಾಲಿನಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯು ಟಿ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ. ಈ ಸಮಸ್ಯೆಗೆ ನಿಮಗೆ ಸಹಾಯ ಬೇಕಾದರೆ, ನಂತರ ನೀವು ಲೂಪ್ಗಳೊಂದಿಗಿನ ವಿಶಿಷ್ಟ ಸಮಸ್ಯೆಗಳ ಬಗ್ಗೆ ಟಿಪ್ಪಣಿಗಳನ್ನು ನೋಡಬೇಕು. ಇದು ಲಕ್ಷಣ #3. ಎರಡನೇ ಚಕ್ರದ ಮೊದಲು ನೀವು ಕೌಂಟರ್ ಮೌಲ್ಯದ ಔಟ್‌ಪುಟ್ ಅನ್ನು ತಕ್ಷಣವೇ ಸೇರಿಸಿದರೆ ಅದು ರೋಗನಿರ್ಣಯವಾಗುತ್ತದೆ. ಮರುಹೊಂದಿಸುವ ಮೂಲಕ ಸರಿಪಡಿಸಲಾಗಿದೆ. ಆದರೆ ಇದನ್ನು ಈಗಿನಿಂದಲೇ ಹೇಳದಿರುವುದು ಉತ್ತಮ. ವಿದ್ಯಾರ್ಥಿಯು ಕನಿಷ್ಟ ಒಂದು ಊಹೆಯನ್ನು ರೂಪಿಸಲು ಪ್ರಯತ್ನಿಸಬೇಕು.

ಸಹಜವಾಗಿ, ಇನ್ನೊಂದು ಪರಿಹಾರವಿದೆ. ಆದರೆ ನಾನು ಅದನ್ನು ವಿದ್ಯಾರ್ಥಿಗಳ ನಡುವೆ ನೋಡಿಲ್ಲ. ಚಕ್ರಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುವ ಹಂತದಲ್ಲಿ, ಅದರ ಕಥೆಯು ಗಮನವನ್ನು ಬೇರೆಡೆ ಸೆಳೆಯುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯಗಳ ಬಗ್ಗೆ ಕಲಿಯುವಾಗ ನೀವು ನಂತರ ಹಿಂತಿರುಗಬಹುದು.
ಸಂಭವನೀಯ #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

ವಿದ್ಯಾರ್ಥಿಯು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬದಲಿಸುವ ತಂತ್ರವನ್ನು ಕರಗತ ಮಾಡಿಕೊಂಡಿದ್ದರೆ, ಅವನು ಬೇಗನೆ ನಿಭಾಯಿಸುತ್ತಾನೆ. ವೇರಿಯಬಲ್ ಅನ್ನು ಮರುಹೊಂದಿಸುವಲ್ಲಿ ಸಂಭವನೀಯ ಸಮಸ್ಯೆ ಮತ್ತೊಮ್ಮೆ ಇರುತ್ತದೆ. ನೀವು ರೂಪಾಂತರವನ್ನು ನಿಭಾಯಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ನೀವು ಅವಸರದಲ್ಲಿದ್ದೀರಿ ಮತ್ತು ಸರಳವಾದ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬೇಕಾಗಿದೆ ಎಂದರ್ಥ.

ನಿಮ್ಮ ಗಮನಕ್ಕೆ ಧನ್ಯವಾದಗಳು. ಚಾನಲ್ ಅನ್ನು ಲೈಕ್ ಮಾಡಿ ಮತ್ತು ಚಂದಾದಾರರಾಗಿ.

PS ಪಠ್ಯದಲ್ಲಿ ನೀವು ಮುದ್ರಣದೋಷಗಳು ಅಥವಾ ದೋಷಗಳನ್ನು ಕಂಡುಕೊಂಡರೆ, ದಯವಿಟ್ಟು ನನಗೆ ತಿಳಿಸಿ. ನೀವು Ctrl / ⌘ ಹೊಂದಿದ್ದರೆ ಅಥವಾ ಖಾಸಗಿ ಸಂದೇಶಗಳ ಮೂಲಕ ಪಠ್ಯದ ಭಾಗವನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಮೂಲಕ ಮತ್ತು "Ctrl / ⌘ + Enter" ಅನ್ನು ಒತ್ತುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು. ಎರಡೂ ಆಯ್ಕೆಗಳು ಲಭ್ಯವಿಲ್ಲದಿದ್ದರೆ, ಕಾಮೆಂಟ್ಗಳಲ್ಲಿ ದೋಷಗಳ ಬಗ್ಗೆ ಬರೆಯಿರಿ. ಧನ್ಯವಾದ!

ನೋಂದಾಯಿತ ಬಳಕೆದಾರರು ಮಾತ್ರ ಸಮೀಕ್ಷೆಯಲ್ಲಿ ಭಾಗವಹಿಸಬಹುದು. ಸೈನ್ ಇನ್ ಮಾಡಿ, ದಯವಿಟ್ಟು.

ಕರ್ಮವಿಲ್ಲದ ಓದುಗರಿಗಾಗಿ ಸಮೀಕ್ಷೆ

20,0%ನಾನು ವೃತ್ತಿಪರವಾಗಿ ಕಲಿಸುತ್ತೇನೆ, +11
20,0%ನಾನು ವೃತ್ತಿಪರವಾಗಿ ಕಲಿಸುತ್ತೇನೆ, -11
60,0%ನಾನು ಕಲಿಸುವುದಿಲ್ಲ, +13
0,0%ನಾನು ಕಲಿಸುವುದಿಲ್ಲ, -10
0,0%ಇತರೆ0

5 ಬಳಕೆದಾರರು ಮತ ಹಾಕಿದ್ದಾರೆ. 5 ಬಳಕೆದಾರರು ದೂರ ಉಳಿದಿದ್ದಾರೆ.

ಮೂಲ: www.habr.com

ತೊಂದರೆಗಳನ್ನು ಜಯಿಸಲು ಹೇಗೆ ಕಲಿಸುವುದು, ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಚಕ್ರಗಳನ್ನು ಬರೆಯುವುದು ಹೇಗೆ