ఇబ్బందులను ఎలా అధిగమించాలో నేర్పడం మరియు అదే సమయంలో చక్రాలను వ్రాయడం ఎలా

మేము ప్రాథమిక అంశాలలో ఒకదాని గురించి మాట్లాడతాము అనే వాస్తవం ఉన్నప్పటికీ, ఈ వ్యాసం అనుభవజ్ఞులైన నిపుణుల కోసం వ్రాయబడింది. ప్రోగ్రామింగ్‌లో ప్రారంభకులకు ఎలాంటి అపోహలు ఉన్నాయో చూపించడమే లక్ష్యం. ప్రాక్టీస్ డెవలపర్‌ల కోసం, ఈ సమస్యలు చాలా కాలంగా పరిష్కరించబడ్డాయి, మర్చిపోయి లేదా గుర్తించబడలేదు. మీరు అకస్మాత్తుగా ఈ అంశంలో ఎవరికైనా సహాయం చేయవలసి వస్తే వ్యాసం ఉపయోగకరంగా ఉండవచ్చు. వ్యాసం షిల్డ్ట్, స్ట్రౌస్ట్రప్, ఓకులోవ్ ద్వారా ప్రోగ్రామింగ్‌పై వివిధ పుస్తకాల నుండి మెటీరియల్‌తో సమాంతరంగా ఉంటుంది.

ప్రోగ్రామింగ్ మాస్టరింగ్ చేసేటప్పుడు చాలా మంది వ్యక్తులు దాని నుండి మినహాయించబడినందున సైకిల్స్ గురించి టాపిక్ ఎంచుకోబడింది.

ఈ సాంకేతికత బలహీన విద్యార్థుల కోసం రూపొందించబడింది. నియమం ప్రకారం, బలమైన వ్యక్తులు ఈ అంశంపై చిక్కుకోరు మరియు వారికి ప్రత్యేక సాంకేతికతలతో ముందుకు రావలసిన అవసరం లేదు. వ్యాసం యొక్క ద్వితీయ లక్ష్యం ఈ సాంకేతికతను "అందరు విద్యార్థుల కోసం పని చేస్తుంది, కానీ ఒక ఉపాధ్యాయుడు మాత్రమే" తరగతి నుండి "అందరికీ విద్యార్థులు, ఉపాధ్యాయులందరికీ పని" తరగతికి తరలించడం. నేను సంపూర్ణ వాస్తవికతను క్లెయిమ్ చేయను. ఈ అంశాన్ని బోధించడానికి మీరు ఇప్పటికే ఇదే పద్ధతిని ఉపయోగిస్తుంటే, దయచేసి మీ వెర్షన్ ఎలా విభిన్నంగా ఉందో రాయండి. మీరు దీన్ని ఉపయోగించాలని నిర్ణయించుకుంటే, అది ఎలా జరిగిందో మాకు చెప్పండి. ఇలాంటి సాంకేతికత ఏదైనా పుస్తకంలో వివరించబడితే, దయచేసి పేరు రాయండి.

నేను ఈ టెక్నిక్‌పై 4 సంవత్సరాలు పనిచేశాను, వివిధ స్థాయిల శిక్షణా విద్యార్థులతో వ్యక్తిగతంగా చదువుతున్నాను. మొత్తం యాభై మంది విద్యార్థులు మరియు రెండు వేల గంటల తరగతులు ఉన్నాయి. మొదట, విద్యార్థులు ఎల్లప్పుడూ ఈ అంశంపై ఇరుక్కుపోయి వెళ్లిపోయారు. ప్రతి విద్యార్థి తర్వాత, పద్దతి మరియు పదార్థాలు సర్దుబాటు చేయబడ్డాయి. గత సంవత్సరంలో, విద్యార్థులు ఈ అంశంపై చిక్కుకోలేదు, కాబట్టి నేను నా ఫలితాలను పంచుకోవాలని నిర్ణయించుకున్నాను.

నేను ఎవరికి మరియు ఎందుకు బోధిస్తాను?

ప్రవేశ పరీక్షలు లేనందున, తరగతులు బలమైన మరియు చాలా బలహీనమైన విద్యార్థులను చేర్చవచ్చు. మీరు వ్యాసంలో నా విద్యార్థుల గురించి మరింత చదువుకోవచ్చు సాయంత్రం కోర్సు విద్యార్థుల పోర్ట్రెయిట్
ప్రోగ్రామింగ్ నేర్చుకోవాలనుకునే ప్రతి ఒక్కరూ దానిని నేర్చుకునేలా నేను ప్రయత్నించాను.
నా తరగతులు ఒక్కొక్కటిగా జరుగుతాయి మరియు విద్యార్థి ప్రతిదానికి తన స్వంత డబ్బును చెల్లిస్తాడు. విద్యార్థులు ఖర్చులను ఆప్టిమైజ్ చేస్తారని మరియు కనిష్టంగా డిమాండ్ చేస్తారని అనిపిస్తుంది. అయినప్పటికీ, ప్రజలు ప్రత్యక్ష ఉపాధ్యాయునితో ముఖాముఖి తరగతులకు వెళ్తారు జ్ఞానం కోసం కాదు, కానీ వారు నేర్చుకున్నదానిపై విశ్వాసం కోసం, పురోగతి అనుభూతి కోసం మరియు నిపుణుడి (ఉపాధ్యాయుడు) ఆమోదం కోసం. విద్యార్థులు తమ అభ్యాసంలో పురోగతిని అనుభవించకపోతే, వారు వదిలివేస్తారు. సాధారణంగా, తరగతులను నిర్మించవచ్చు, తద్వారా విద్యార్థులు సుపరిచితమైన నిర్మాణాల సంఖ్యను పెంచడంలో పురోగతిని అనుభవిస్తారు. అంటే, మొదట మనం వివరంగా చదువుకుంటాము, తరువాత చదువుతాము, తరువాత చేస్తాం, మరియు ఇప్పుడు మనకు వెయ్యి మరియు ఒక రాత్రి కోర్సు సిద్ధంగా ఉంది, దీనిలో సైకిల్స్ మాత్రమే రెండు నెలలు అధ్యయనం చేయబడతాయి మరియు చివరికి - వ్రాసిన విద్యార్థి డిక్టేషన్ కింద ఒక ప్రామాణిక లైబ్రరీ. అయితే, ఆచరణాత్మక సమస్యలను పరిష్కరించడానికి, మీరు పదార్థం యొక్క జ్ఞానం మాత్రమే కాకుండా, దాని అప్లికేషన్ మరియు కొత్త సమాచారం కోసం శోధించడంలో స్వాతంత్ర్యం కూడా అవసరం. అందువల్ల, ముఖాముఖి కోర్సుల కోసం, కనిష్టంగా బోధించడం మరియు సూక్ష్మ నైపుణ్యాలు మరియు సంబంధిత అంశాల స్వతంత్ర అధ్యయనాన్ని ప్రోత్సహించడం సరైన సూత్రం అని నేను భావిస్తున్నాను. లూప్‌ల అంశంలో, అయితే నిర్మాణాన్ని నేను కనిష్టంగా పరిగణించాను. మీరు దాని నుండి సూత్రాన్ని అర్థం చేసుకోవచ్చు. సూత్రాన్ని తెలుసుకోవడం, మీరు మీ కోసం మరియు చేసే సమయంలో రెండింటిలోనూ నైపుణ్యం సాధించవచ్చు.

బలహీనమైన విద్యార్థుల ద్వారా పదార్థంపై పట్టు సాధించడానికి, వాక్యనిర్మాణాన్ని వివరించడం సరిపోదు. మరింత సరళమైన కానీ వైవిధ్యమైన పనులను ఇవ్వడం మరియు ఉదాహరణలను మరింత వివరంగా వివరించడం అవసరం. అంతిమంగా, వ్యక్తీకరణలను మార్చగల మరియు నమూనాల కోసం శోధించే విద్యార్థి సామర్థ్యం ద్వారా అభివృద్ధి వేగం పరిమితం చేయబడింది. తెలివైన విద్యార్థులకు, చాలా అసైన్‌మెంట్‌లు బోరింగ్‌గా ఉంటాయి. వారితో చదువుతున్నప్పుడు, మీరు 100% సమస్యలను పరిష్కరించాలని పట్టుబట్టవలసిన అవసరం లేదు. నా మెటీరియల్‌ని ఇక్కడ చూడవచ్చు నా గితుబ్. నిజమే, రిపోజిటరీ వార్‌లాక్ యొక్క గ్రిమోయిర్ లాంటిది - ఎక్కడ ఉందో నాకు తప్ప మరెవరూ అర్థం చేసుకోలేరు మరియు మీరు చెక్‌లో విఫలమైతే, మీరు వెర్రితలాడవచ్చు

పద్దతి సాధన-ఆధారితమైనది

సమస్యను పరిష్కరించే ఉదాహరణను ఉపయోగించి సిద్ధాంతం వివరించబడింది. బ్రాంచ్‌లు మరియు లూప్‌లు బోధించబడే ప్రోగ్రామింగ్ క్లాస్ యొక్క ఫండమెంటల్స్‌లో, ఒక అంశంపై మొత్తం గంటపాటు ఉపయోగకరమైన ఉపన్యాసం ఇవ్వడం సాధ్యం కాదు. భావనను వివరించడానికి 15-20 నిమిషాలు సరిపోతుంది. ఆచరణాత్మక పనులను చేసేటప్పుడు ప్రధాన ఇబ్బందులు తలెత్తుతాయి.
ప్రారంభ ఉపాధ్యాయులు ఒక ఉపన్యాసంలో ఆపరేటర్‌లు, శాఖలు, లూప్‌లు మరియు శ్రేణులను కొట్టగలరు. కానీ వారి విద్యార్థులు ఈ సమాచారాన్ని సమీకరించే సమస్యను ఎదుర్కొంటారు.
మెటీరియల్ చెప్పడమే కాదు, శ్రోతలకు అర్థమయ్యేలా చూసుకోవడం కూడా అవసరం.

విద్యార్థి స్వతంత్ర పనిని ఎలా ఎదుర్కోవాలో టాపిక్ మాస్టరింగ్ వాస్తవం నిర్ణయించబడుతుంది.
ఉపాధ్యాయుని సహాయం లేకుండా విద్యార్థి ఒక అంశంపై సమస్యను పరిష్కరించగలిగితే, ఆ అంశం ప్రావీణ్యం పొందింది. స్వీయ-పరీక్షను నిర్ధారించడానికి, ప్రతి పని పరీక్ష దృశ్యాలతో పట్టికలో వివరించబడింది. పనులు స్పష్టమైన క్రమాన్ని కలిగి ఉంటాయి. పనులను దాటవేయడం సిఫారసు చేయబడలేదు. ప్రస్తుత పని చాలా కష్టంగా ఉంటే, తదుపరి పనికి వెళ్లడం పనికిరానిది. ఇది మరింత సంక్లిష్టమైనది. విద్యార్థి ప్రస్తుత సంక్లిష్టమైన పనిని నేర్చుకోవటానికి, మొదటి సమస్య యొక్క ఉదాహరణను ఉపయోగించి అతనికి అనేక పద్ధతులు వివరించబడ్డాయి. వాస్తవానికి, టాపిక్ యొక్క మొత్తం కంటెంట్ ఇబ్బందులను అధిగమించడానికి సాంకేతికతలకు వస్తుంది. సైకిల్స్ వల్ల సైడ్ ఎఫెక్ట్ ఎక్కువ.

మొదటి పని ఎల్లప్పుడూ ఒక ఉదాహరణ. రెండవది కొద్దిగా భిన్నంగా ఉంటుంది మరియు ఉపాధ్యాయుని పర్యవేక్షణలో మొదటి తర్వాత వెంటనే "స్వతంత్రంగా" నిర్వహించబడుతుంది. అన్ని తదుపరి పనులు అపోహలకు కారణమయ్యే వివిధ చిన్న విషయాలపై దృష్టి పెట్టడం లక్ష్యంగా పెట్టుకున్నాయి.

ఉదాహరణ యొక్క వివరణ అనేది ఒక సంభాషణ, దీనిలో విద్యార్థి మెటీరియల్‌లో కొంత భాగాన్ని ప్రావీణ్యం పొందాడని నిర్ధారించుకోవడానికి ప్రచారం మరియు క్రాస్ ధ్రువీకరణను తిరిగి కాల్ చేయాలి.

నేను సామాన్యంగా ఉంటాను మరియు అంశంపై మొదటి ఉదాహరణ చాలా ముఖ్యమైనదని చెబుతాను. మీరు విస్తృతమైన స్వతంత్ర పని కోసం పదార్థాన్ని కలిగి ఉంటే, మొదటి ఉదాహరణ యొక్క లోపాలను సరిదిద్దవచ్చు. ఉదాహరణ తప్ప మరేమీ లేకుంటే, విద్యార్థి ఎక్కువగా టాపిక్‌లో ప్రావీణ్యం పొందలేడు.

అయితే లేదా?

వివాదాస్పద సమస్యలలో ఒకటి ఉదాహరణకు నిర్మాణ ఎంపిక: అయితే లేదా కోసం. ఒకసారి, బోధనా అనుభవం లేని నా ప్రాక్టీస్ చేస్తున్న డెవలపర్ స్నేహితుడు, ఫర్ లూప్ అర్థం చేసుకోవడం చాలా సులభం అని నన్ను ఒప్పించడానికి ఒక గంట గడిపాడు. "దానిలో ప్రతిదీ స్పష్టంగా ఉంది మరియు దాని స్థానంలో ఉంచబడింది" అనే వాదనలు ఉడకబెట్టబడ్డాయి. ఏదేమైనా, నిజమైన ప్రారంభకులకు ఇబ్బందులకు మూల కారణం చక్రం యొక్క ఆలోచన, మరియు దాని రచన కాదు. ఒక వ్యక్తి ఈ ఆలోచనను అర్థం చేసుకోకపోతే, అతను వాక్యనిర్మాణంలో ఇబ్బంది పడతాడు. ఆలోచన గ్రహించిన వెంటనే, కోడ్ రూపకల్పన యొక్క సమస్యలు వారి స్వంతంగా అదృశ్యమవుతాయి.

నా మెటీరియల్‌లలో, లూప్‌ల థీమ్ బ్రాంచింగ్ థీమ్‌ను అనుసరిస్తుంది. అయితే మరియు అయితే యొక్క బాహ్య సారూప్యత ప్రత్యక్ష సారూప్యతను గీయడానికి అనుమతిస్తుంది: "హెడర్‌లోని షరతు నిజం అయినప్పుడు, శరీరం అమలు చేయబడుతుంది." చక్రం యొక్క ఏకైక ప్రత్యేకత ఏమిటంటే శరీరం చాలాసార్లు అమలు చేయబడుతుంది.

నా రెండవ వాదన ఏమిటంటే, అయితే కోసం కంటే తక్కువ ఫార్మాటింగ్ అవసరం. తక్కువ ఫార్మాటింగ్ అంటే తప్పిపోయిన కామాలు మరియు కుండలీకరణాలతో తక్కువ తెలివితక్కువ తప్పులు. సింటాక్స్ లోపాలను స్వయంచాలకంగా నివారించడానికి బిగినర్స్ ఇంకా తగినంత శ్రద్ద మరియు సూక్ష్మతని అభివృద్ధి చేయలేదు.
మూడవ వాదన మొదటి వాదనగా చాలా మంచి పుస్తకాలలో వివరించబడింది.

విద్యార్థి వ్యక్తీకరణలను సులభంగా మార్చగలిగితే, మీరు ఉత్తీర్ణత గురించి మాట్లాడవచ్చు. విద్యార్థి తనకు బాగా నచ్చినదాన్ని ఎంచుకుంటాడు. పరివర్తనాలు ఇబ్బందులను కలిగిస్తే, మీ దృష్టిని మరల్చకుండా ఉండటం మంచిది. విద్యార్థి మొదట అయితే సమయంలో ఉపయోగించి ప్రతిదీ పరిష్కరించనివ్వండి. మీరు లూప్‌ల టాపిక్‌పై ప్రావీణ్యం సంపాదించిన తర్వాత, మీరు పరివర్తన సాధన కోసం పరిష్కారాలను తిరిగి వ్రాయవచ్చు.
పోస్ట్ కండిషన్ లూప్‌లు చాలా అరుదైన మృగం. నేను దాని కోసం అస్సలు సమయాన్ని వెచ్చించను. ఒక విద్యార్థి నమూనాలను గుర్తించడం మరియు వ్యక్తీకరణలను మార్చడం వంటి ఆలోచనలను కలిగి ఉంటే, అతను నా సహాయం లేకుండానే దాన్ని గుర్తించగలడు.

బలమైన విద్యార్థులకు మొదటి ఉదాహరణను ప్రదర్శించేటప్పుడు, మొదటి ఉదాహరణలో పరిష్కారాన్ని మాత్రమే కాకుండా, ఫలితానికి దారితీసిన మొత్తం చర్యల గొలుసును కూడా రికార్డ్ చేయడం ముఖ్యం అనే వాస్తవాన్ని నేను దృష్టిని ఆకర్షిస్తున్నాను. సోమరి విద్యార్థులు రచనను నిర్లక్ష్యం చేయవచ్చు మరియు చివరి అల్గారిథమ్‌ను మాత్రమే కాపీ చేయవచ్చు. ఏదో ఒక రోజు కష్టమైన పని తమ దారిలోకి వస్తుందని వారికి నమ్మకం కలిగించాలి. దాన్ని పరిష్కరించడానికి, మీరు ఈ ఉదాహరణలో ఉన్న దశలను అనుసరించాలి. అందుకే అన్ని దశలను రికార్డ్ చేయడం ముఖ్యం. కింది సమస్యలలో పరిష్కారం యొక్క తుది సంస్కరణను మాత్రమే వదిలివేయడం సాధ్యమవుతుంది.

ఆటోమేషన్ యొక్క ప్రధాన ఆలోచన ఏమిటంటే, ఒక వ్యక్తి కోసం సాధారణ పని చేయడానికి మేము కంప్యూటర్‌ను అప్పగిస్తాము. ప్రాథమిక పద్ధతుల్లో ఒకటి లూప్‌లను రాయడం. ఒక ప్రోగ్రామ్‌లో వరుసగా ఒకే విధమైన పునరావృత చర్యలు వ్రాయబడినప్పుడు ఇది ఉపయోగించబడుతుంది.

మొదటి లూపింగ్ టాస్క్‌లో ఒకే పదబంధాన్ని అనేకసార్లు ప్రదర్శించడం మంచి ఆలోచనగా అనిపించవచ్చు. ఉదాహరణకి:

హుర్రే, ఇది పనిచేస్తుంది!
హుర్రే, ఇది పనిచేస్తుంది!
హుర్రే, ఇది పనిచేస్తుంది!
హుర్రే, ఇది పనిచేస్తుంది!
హుర్రే, ఇది పనిచేస్తుంది!
హుర్రే, ఇది పనిచేస్తుంది!
హుర్రే, ఇది పనిచేస్తుంది!
హుర్రే, ఇది పనిచేస్తుంది!

అవుట్‌పుట్‌లో కౌంటర్ విలువ కనిపించనందున ఈ ఐచ్ఛికం చెడ్డది. ఇది ప్రారంభకులకు సమస్య. ఆమెను తక్కువ అంచనా వేయకండి. మొదట, ఈ పని మొదటిది, మరియు ఆరోహణ క్రమంలో సంఖ్యల శ్రేణిని పొందడం రెండవది. "సైకిల్ N సార్లు" మరియు "A నుండి B వరకు చక్రం" అనే అదనపు పదాలను ప్రవేశపెట్టడం అవసరం, ఇవి తప్పనిసరిగా ఒకే విషయం. అనవసరమైన ఎంటిటీలను సృష్టించకుండా ఉండటానికి, నేను సంఖ్యల శ్రేణి యొక్క అవుట్‌పుట్‌తో ఒక ఉదాహరణను మాత్రమే చూపించాలని నిర్ణయించుకున్నాను. కొంతమంది వ్యక్తులు తమ తలపై కౌంటర్‌ను ఎలా పట్టుకోవాలో మరియు ప్రిపరేషన్ లేకుండా వారి తలపై ప్రోగ్రామ్ యొక్క ప్రవర్తనను ఎలా రూపొందించాలో నేర్చుకుంటారు. కొంతమంది విద్యార్థులు మొదట సైకిల్స్ అనే అంశంపై మానసిక నమూనాను ఎదుర్కొంటారు.
కొంత అభ్యాసం తర్వాత, స్వతంత్రంగా పరిష్కరించడానికి అదే వచనాన్ని పునరావృతం చేసే పనిని నేను ఇస్తాను. మీరు ముందుగా కనిపించే కౌంటర్‌ను ఇచ్చి, ఆపై కనిపించని కౌంటర్‌ను ఇస్తే, విద్యార్థులకు సమస్యలు తక్కువగా ఉంటాయి. కొన్నిసార్లు సూచన "తెరపై కౌంటర్ వ్రాయవద్దు" సరిపోతుంది.

ఇతరులు దానిని ఎలా వివరిస్తారు?

ఇంటర్నెట్‌లోని చాలా విద్యా విషయాలలో, సైకిల్ యొక్క వాక్యనిర్మాణం "ఉపన్యాసం"లో భాగంగా ఇవ్వబడింది. ఉదాహరణకు, developer.mozilla.orgలో (ప్రస్తుతం), అయితే లూప్‌తో పాటు అనేక ఇతర నిర్మాణాలు వివరించబడ్డాయి. ఈ సందర్భంలో, నమూనాలు మాత్రమే టెంప్లేట్ల రూపంలో ఇవ్వబడ్డాయి. వారి ప్రయోగ ఫలితం పదాలలో వివరించబడింది, కానీ దృష్టాంతం లేదు. నా అభిప్రాయం ప్రకారం, టాపిక్ యొక్క అటువంటి ప్రదర్శన అటువంటి పదార్థాల ఉపయోగాన్ని సున్నాతో గుణిస్తుంది. విద్యార్థి కోడ్‌ను తిరిగి వ్రాయవచ్చు మరియు దానిని స్వయంగా అమలు చేయవచ్చు, కానీ అతనికి పోలిక కోసం ఇప్పటికీ ఒక ప్రమాణం అవసరం. ఫలితాన్ని పోల్చడానికి ఏమీ లేకుంటే ఒక ఉదాహరణ సరిగ్గా తిరిగి వ్రాయబడిందని మీరు ఎలా అర్థం చేసుకోవాలి?
ఉదాహరణ లేకుండా కేవలం ఒక టెంప్లేట్ ఇచ్చినప్పుడు, అది విద్యార్థికి మరింత కష్టమవుతుంది. కోడ్ శకలాలు టెంప్లేట్‌లో సరిగ్గా ఉంచబడ్డాయని ఎలా అర్థం చేసుకోవాలి? మీరు వ్రాయడానికి ప్రయత్నించవచ్చు ఏదో విధంగా, ఆపై అమలు చేయండి. కానీ ఫలితాన్ని పోల్చడానికి ప్రమాణం లేకపోతే, లాంచ్ చేయడం కూడా సహాయపడదు.

Intuitiveపై 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 పుస్తకం ప్రిన్సిపల్స్ అండ్ ప్రాక్టీస్ యూజింగ్ సి++ మరింత ముందుకు సాగింది. ఏ ఫలితాన్ని పొందాలో వివరించడం మొదటి దశ, మరియు ఆ తర్వాత ప్రోగ్రామ్ యొక్క టెక్స్ట్ చూపబడుతుంది. అంతేకాకుండా, వారు యాదృచ్ఛిక ప్రోగ్రామ్‌ను ఉదాహరణగా తీసుకోరు, కానీ చరిత్రలో విహారయాత్రను ఇస్తారు. ఇది దృష్టిని ఆకర్షించడానికి సహాయపడుతుంది: “చూడండి, ఇది కేవలం పనికిరాని వచనం కాదు. మీరు అర్ధవంతమైనదాన్ని చూస్తారు."

పునరావృతానికి ఉదాహరణగా, నిల్వ చేయబడిన ప్రోగ్రామ్ మెషీన్ (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కి మార్చండి.
2. లూప్‌లోని చర్యలు నిరవధికంగా ఆపకుండా నిర్వహించబడతాయి. పరిష్కారాలు:
   — అది తప్పిపోయినట్లయితే కౌంటర్ మార్పు ఆదేశాన్ని జోడించండి.
   - కౌంటర్ మార్పు ఆదేశాన్ని పరిష్కరించండి, తద్వారా దాని విలువ పరిమితికి దగ్గరగా ఉంటుంది.
   — లూప్ బాడీలో ఉన్నట్లయితే పరిమితి మార్పు ఆదేశాన్ని తీసివేయండి.
3. లూప్‌లోని చర్యల సంఖ్య ఊహించిన దాని కంటే 1 కంటే ఎక్కువ లేదా ఎక్కువ. లూప్‌లోని చర్య ఒక్కసారి కూడా అమలు కాలేదు. మొదట మీరు లూప్ ప్రారంభమయ్యే ముందు వేరియబుల్స్ యొక్క వాస్తవ విలువలను కనుగొనాలి. పరిష్కారాలు:
   - నిర్బంధం యొక్క ప్రారంభ విలువను మార్చండి
   - కౌంటర్ యొక్క ప్రారంభ విలువను మార్చండి

సమస్య 3 సాధారణంగా తప్పు వేరియబుల్‌ని ఉపయోగించడం లేదా కౌంటర్‌ని సున్నాకి రీసెట్ చేయకపోవడం వంటివి ఉంటాయి.

ఈ వివరణ తర్వాత, విద్యార్థికి ఇప్పటికీ లూప్‌లు ఎలా పనిచేస్తాయనే దానిపై అనేక అపోహలు ఉండవచ్చు.
అత్యంత సాధారణమైన వాటిని తొలగించడానికి, నేను మీకు ఈ క్రింది పనులను ఇస్తాను:

1. దీనిలో పరిమితి, ప్రారంభ కౌంటర్ విలువ లేదా కౌంటర్ దశ వినియోగదారు ద్వారా నమోదు చేయబడుతుంది.
2. ఇందులో కౌంటర్ విలువ తప్పనిసరిగా కొన్ని అంకగణిత వ్యక్తీకరణలో ఉపయోగించాలి. రాడికల్ ఎక్స్‌ప్రెషన్‌లో లేదా హారంలో కౌంటర్‌ను ఉపయోగించడం మంచిది, తద్వారా వ్యత్యాసం నాన్‌లీనియర్‌గా ఉంటుంది.
3. దీనిలో లూప్ నడుస్తున్నప్పుడు కౌంటర్ విలువ స్క్రీన్‌పై ప్రదర్శించబడదు. ఉదాహరణకు, అవసరమైన సంఖ్యలో ఒకేలాంటి వచన శకలాలు ప్రదర్శించడం లేదా తాబేలు గ్రాఫిక్‌లతో బొమ్మను గీయడం.
4. దీనిలో మీరు మొదట కొన్ని పునరావృత చర్యలను చేయాలి, ఆపై ఇతరులు.
5. దీనిలో మీరు పునరావృతం చేయడానికి ముందు మరియు తర్వాత ఇతర చర్యలను చేయవలసి ఉంటుంది

ప్రతి పని కోసం మీరు పరీక్ష డేటా మరియు ఆశించిన ఫలితాన్ని అందించాలి.

మీరు ఎంత త్వరగా తరలించగలరో అర్థం చేసుకోవడానికి, మీరు ఈ సమస్యల నిబంధనలను చదవాలి మరియు ఇలా అడగాలి: "అవి ఉదాహరణ నుండి ఎలా భిన్నంగా ఉంటాయి?", "వాటిని పరిష్కరించడానికి ఉదాహరణలో ఏమి మార్చాలి?" విద్యార్థి అర్థవంతంగా సమాధానం ఇస్తే, అతను తరగతిలో కనీసం ఒకదానిని పరిష్కరించనివ్వండి మరియు మిగిలిన వాటిని ఇంట్లో స్వయంగా పరిష్కరించండి. పరిష్కారం విజయవంతమైతే, మేము లూప్‌ల లోపల పరిస్థితులను వివరించడం ప్రారంభించవచ్చు.
మీ స్వంతంగా సమస్యలను పరిష్కరించడంలో మీకు సమస్యలు ఉంటే, మీరు తరగతిలోని ప్రతిదాని ద్వారా పని చేయాలి. గుడ్లగూబను గీయడం గుర్తుకు తెచ్చే సమస్యను పరిష్కరించకుండా ఉండటానికి, మొదట సమస్యను విశ్వవ్యాప్తం కాని విధంగా పరిష్కరించాలని నేను సిఫార్సు చేస్తున్నాను. అంటే, పరిష్కారం మొదటి పరీక్షలో ఉత్తీర్ణత సాధించింది మరియు లూప్ నిర్మాణాన్ని ఉపయోగించదు. బాగా, అప్పుడు పరిష్కారం యొక్క సార్వత్రికతను సాధించడానికి పరివర్తనలను వర్తించండి.

ఉచ్చులు మరియు శాఖలు

నా అభిప్రాయం ప్రకారం, "శాఖల లోపల చక్రాలు" అనే అంశాన్ని విడిగా ఇవ్వడం ఉపయోగకరంగా ఉంటుంది. తద్వారా మీరు కండిషన్‌ను అనేకసార్లు తనిఖీ చేయడం మరియు ఒకసారి తనిఖీ చేయడం మధ్య వ్యత్యాసాన్ని చూడవచ్చు.
ఏకీకరణకు సంబంధించిన పనులు 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 అక్షరాలు ఉండాలి. రెండవ పంక్తిలో T ముక్కలు ఉన్నాయి. ఏదైనా సంఖ్య ప్రతికూలంగా ఉంటే, దోష సందేశాన్ని ప్రదర్శించండి.

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

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

R=-1, T=6R విలువ తప్పనిసరిగా ప్రతికూలంగా ఉండకూడదు

R=6, T=-2T విలువ తప్పనిసరిగా ప్రతికూలంగా ఉండకూడదు

సహజంగానే, ఈ సమస్యకు కనీసం రెండు పరిష్కారాలు కూడా ఉన్నాయి.
కావలసిన

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#####
######

రెండవ పంక్తిలోని అక్షరాల సంఖ్య T విలువకు అనుగుణంగా లేదు. ఈ సమస్యతో మీకు సహాయం అవసరమైతే, మీరు లూప్‌లతో విలక్షణమైన సమస్యల గురించి గమనికలను పరిశీలించాలి. ఇది లక్షణం #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