મુશ્કેલીઓને કેવી રીતે દૂર કરવી તે કેવી રીતે શીખવવું, અને તે જ સમયે ચક્ર લખો

હકીકત એ છે કે અમે મૂળભૂત વિષયોમાંથી એક વિશે વાત કરીશું છતાં, આ લેખ અનુભવી વ્યાવસાયિકો માટે લખાયેલ છે. ધ્યેય એ બતાવવાનો છે કે નવા નિશાળીયા પ્રોગ્રામિંગમાં શું ગેરસમજો ધરાવે છે. પ્રેક્ટિસ કરતા વિકાસકર્તાઓ માટે, આ સમસ્યાઓ લાંબા સમયથી હલ થઈ ગઈ છે, ભૂલી ગઈ છે અથવા બિલકુલ ધ્યાનમાં લેવામાં આવી નથી. જો તમને અચાનક આ વિષય સાથે કોઈને મદદ કરવાની જરૂર હોય તો લેખ હાથમાં આવી શકે છે. આ લેખ શિલ્ડ, સ્ટ્રોસ્ટ્રપ, ઓકુલોવ દ્વારા પ્રોગ્રામિંગ પરના વિવિધ પુસ્તકોની સામગ્રી સાથે સમાનતા દોરે છે.

સાયકલ વિશેનો વિષય પસંદ કરવામાં આવ્યો હતો કારણ કે પ્રોગ્રામિંગમાં નિપુણતા મેળવતી વખતે ઘણા લોકોને તેમાંથી બાકાત રાખવામાં આવે છે.

આ તકનીક નબળા વિદ્યાર્થીઓ માટે બનાવવામાં આવી છે. એક નિયમ તરીકે, મજબૂત લોકો આ વિષય પર અટકી જતા નથી અને તેમના માટે વિશેષ તકનીકો સાથે આવવાની જરૂર નથી. લેખનો ગૌણ ધ્યેય આ તકનીકને "બધા વિદ્યાર્થીઓ માટે કાર્ય કરે છે, પરંતુ માત્ર એક શિક્ષક" વર્ગમાંથી "બધા વિદ્યાર્થીઓ, બધા શિક્ષકો માટે કાર્ય" વર્ગમાં ખસેડવાનો છે. હું સંપૂર્ણ મૌલિકતાનો દાવો કરતો નથી. જો તમે પહેલેથી જ આ વિષય શીખવવા માટે સમાન પદ્ધતિનો ઉપયોગ કરી રહ્યાં છો, તો કૃપા કરીને લખો કે તમારું સંસ્કરણ કેવી રીતે અલગ છે. જો તમે તેનો ઉપયોગ કરવાનું નક્કી કરો છો, તો અમને જણાવો કે તે કેવી રીતે થયું. જો કોઈ પુસ્તકમાં સમાન તકનીકનું વર્ણન કરવામાં આવ્યું હોય, તો કૃપા કરીને નામ લખો.

મેં આ ટેકનિક પર 4 વર્ષ સુધી કામ કર્યું, વિવિધ સ્તરની તાલીમના વિદ્યાર્થીઓ સાથે વ્યક્તિગત રીતે અભ્યાસ કર્યો. કુલ મળીને લગભગ પચાસ વિદ્યાર્થીઓ અને બે હજાર કલાકના વર્ગો છે. શરૂઆતમાં, વિદ્યાર્થીઓ હંમેશા આ વિષય પર અટકી ગયા અને ચાલ્યા ગયા. દરેક વિદ્યાર્થી પછી, પદ્ધતિ અને સામગ્રીને સમાયોજિત કરવામાં આવી હતી. છેલ્લા એક વર્ષથી, વિદ્યાર્થીઓ હવે આ વિષય પર અટક્યા નથી, તેથી મેં મારા તારણો શેર કરવાનું નક્કી કર્યું.

શા માટે આટલા બધા પત્રો? સાયકલ ખૂબ પ્રાથમિક છે!

મેં ઉપર લખ્યું તેમ, વિકાસકર્તાઓ અને મજબૂત વિદ્યાર્થીઓ માટે પ્રેક્ટિસ કરવા માટે, લૂપ્સની વિભાવનાની જટિલતાને ઓછો અંદાજ આપી શકાય છે. ઉદાહરણ તરીકે, તમે લાંબુ પ્રવચન આપી શકો છો, માથું હલાવતા જોઈ શકો છો અને બુદ્ધિશાળી આંખો જોઈ શકો છો. પરંતુ જ્યારે કોઈપણ સમસ્યાનો ઉકેલ લાવવાનો પ્રયાસ કરવામાં આવે છે, ત્યારે મૂર્ખ અને અકલ્પનીય સમસ્યાઓ શરૂ થાય છે. વ્યાખ્યાન પછી, વિદ્યાર્થીઓને કદાચ આંશિક સમજ હતી. પરિસ્થિતિ એ હકીકતને કારણે વકરી છે કે વિદ્યાર્થીઓ પોતે જ અવાજ કરી શકતા નથી કે તેમનો ભ્રમ શું છે.
એક દિવસ મને સમજાયું કે વિદ્યાર્થીઓ મારા ઉદાહરણોને હાયરોગ્લિફ્સ તરીકે સમજે છે. એટલે કે, ટેક્સ્ટના અવિભાજ્ય ટુકડાઓની જેમ જેમાં તમારે કેટલાક "જાદુઈ" અક્ષર ઉમેરવાની જરૂર છે અને તે કામ કરશે.
કેટલીકવાર મેં નોંધ્યું છે કે વિદ્યાર્થીઓ એવું વિચારે છે કે તમારે ચોક્કસ સમસ્યાને ઉકેલવાની જરૂર છે કંઈક બીજું એક ડિઝાઇન કે જે મેં હજી સુધી કવર કરી નથી. જોકે સોલ્યુશન માટે ઉદાહરણમાં થોડો ફેરફાર કરવાની જરૂર હતી.

તેથી હું વિચાર સાથે આવ્યો કે ધ્યાન અભિવ્યક્તિના વાક્યરચના પર ન હોવું જોઈએ, પરંતુ લૂપ્સનો ઉપયોગ કરીને પુનરાવર્તિત કોડને રિફેક્ટર કરવાના વિચાર પર હોવું જોઈએ. એકવાર વિદ્યાર્થીઓ આ વિચારમાં નિપુણતા મેળવી લે, પછી કોઈપણ વાક્યરચના થોડી પ્રેક્ટિસ સાથે સુધારી શકાય છે.

હું કોને અને શા માટે શીખવીશ?

કોઈ પ્રવેશ પરીક્ષાઓ ન હોવાથી, વર્ગોમાં મજબૂત અને ખૂબ નબળા બંને વિદ્યાર્થીઓનો સમાવેશ થઈ શકે છે. તમે લેખમાં મારા વિદ્યાર્થીઓ વિશે વધુ વાંચી શકો છો સાંજના અભ્યાસક્રમના વિદ્યાર્થીઓનું ચિત્ર
મેં એ સુનિશ્ચિત કરવાનો પ્રયત્ન કર્યો કે પ્રોગ્રામિંગ શીખવા માગતા દરેક વ્યક્તિ તેને શીખી શકે.
મારા વર્ગો વ્યક્તિગત રીતે યોજવામાં આવે છે અને વિદ્યાર્થી દરેક માટે પોતાના પૈસા ચૂકવે છે. એવું લાગે છે કે વિદ્યાર્થીઓ ખર્ચને શ્રેષ્ઠ બનાવશે અને ન્યૂનતમ માંગ કરશે. જો કે, લોકો જીવંત શિક્ષક સાથે રૂબરૂ વર્ગોમાં જાય છે તે જ્ઞાન માટે નહીં, પરંતુ તેઓ જે શીખ્યા છે તેના આત્મવિશ્વાસ માટે, પ્રગતિની લાગણી માટે અને નિષ્ણાત (શિક્ષક) પાસેથી મંજૂરી માટે. જો વિદ્યાર્થીઓ તેમના અભ્યાસમાં પ્રગતિ અનુભવતા નથી, તો તેઓ છોડી દેશે. સામાન્ય રીતે, વર્ગોની રચના કરી શકાય છે જેથી વિદ્યાર્થીઓ પરિચિત માળખાઓની સંખ્યામાં વધારો કરવામાં પ્રગતિ અનુભવે. એટલે કે, પહેલા અમે વિગતવાર અભ્યાસ કરીએ છીએ, પછી અમે અભ્યાસ કરીએ છીએ, પછી કરીએ છીએ, અને હવે અમારી પાસે એક હજાર અને એક રાત્રિનો અભ્યાસક્રમ તૈયાર છે, જેમાં એકલા બે મહિના માટે ચક્રનો અભ્યાસ કરવામાં આવે છે, અને અંતે - એક વિદ્યાર્થી જેણે લખ્યું શ્રુતલેખન હેઠળ પ્રમાણભૂત પુસ્તકાલય. જો કે, વ્યવહારિક સમસ્યાઓ ઉકેલવા માટે, તમારે માત્ર સામગ્રીના જ્ઞાનની જ નહીં, પણ તેની એપ્લિકેશનમાં અને નવી માહિતીની શોધમાં સ્વતંત્રતાની પણ જરૂર છે. તેથી, રૂબરૂ અભ્યાસક્રમો માટે, મને લાગે છે કે સાચો સિદ્ધાંત લઘુત્તમ શીખવવાનો અને ઘોંઘાટ અને સંબંધિત વિષયોના સ્વતંત્ર અભ્યાસને પ્રોત્સાહિત કરવાનો છે. લૂપ્સના વિષયમાં, હું જ્યારે કન્સ્ટ્રક્ટને ન્યૂનતમ ગણું છું. તમે તેના પરથી સિદ્ધાંત સમજી શકો છો. સિદ્ધાંતને જાણીને, તમે તમારી જાતને માટે અને કરવા-જતી વખતે બંનેમાં નિપુણતા મેળવી શકો છો.

નબળા વિદ્યાર્થીઓ દ્વારા સામગ્રીમાં નિપુણતા પ્રાપ્ત કરવા માટે, વાક્યરચનાનું વર્ણન કરવું પૂરતું નથી. વધુ સરળ પરંતુ વૈવિધ્યસભર કાર્યો આપવા અને ઉદાહરણોનું વધુ વિગતવાર વર્ણન કરવું જરૂરી છે. આખરે, વિકાસની ઝડપ વિદ્યાર્થીની અભિવ્યક્તિને રૂપાંતરિત કરવાની અને પેટર્ન શોધવાની ક્ષમતા દ્વારા મર્યાદિત છે. સ્માર્ટ વિદ્યાર્થીઓ માટે, મોટા ભાગની સોંપણીઓ કંટાળાજનક હશે. તેમની સાથે અભ્યાસ કરતી વખતે, તમારે 100% સમસ્યાઓ હલ કરવાનો આગ્રહ રાખવાની જરૂર નથી. મારી સામગ્રી અહીં જોઈ શકાય છે મારું ગીથબ. સાચું છે, ભંડાર વધુ એક લડાયકના ગ્રિમોયર જેવું છે - મારા સિવાય કોઈ સમજી શકશે નહીં કે ક્યાં છે, અને જો તમે તપાસમાં નિષ્ફળ જાઓ છો, તો તમે પાગલ થઈ શકો છો

પદ્ધતિ પ્રેક્ટિસ લક્ષી છે

સિદ્ધાંતને સમસ્યા ઉકેલવાના ઉદાહરણનો ઉપયોગ કરીને સમજાવવામાં આવે છે. પ્રોગ્રામિંગ ક્લાસના ફંડામેન્ટલ્સમાં જ્યાં શાખાઓ અને લૂપ્સ શીખવવામાં આવે છે, એક વિષય પર આખા કલાક માટે ઉપયોગી લેક્ચર આપવું શક્ય નથી. ખ્યાલ સમજાવવા માટે 15-20 મિનિટ પૂરતી છે. વ્યવહારુ કાર્યો કરતી વખતે મુખ્ય મુશ્કેલીઓ ઊભી થાય છે.
શરૂઆતના શિક્ષકો એક વ્યાખ્યાનમાં ઓપરેટરો, શાખાઓ, લૂપ્સ અને એરેને ખખડાવી શકે છે. પરંતુ તેમના વિદ્યાર્થીઓને આ માહિતીને આત્મસાત કરવામાં સમસ્યાનો સામનો કરવો પડશે.
માત્ર સામગ્રી જણાવવી જ નહીં, પણ શ્રોતાઓ તેને સમજે તેની ખાતરી કરવી પણ જરૂરી છે.

વિષયમાં નિપુણતા મેળવવાની હકીકત એ નક્કી કરવામાં આવે છે કે વિદ્યાર્થી કેવી રીતે સ્વતંત્ર કાર્યનો સામનો કરે છે.
જો કોઈ વિદ્યાર્થી શિક્ષકની મદદ વિના કોઈ વિષય પર સમસ્યા હલ કરવામાં વ્યવસ્થાપિત હોય, તો તે વિષયમાં નિપુણતા પ્રાપ્ત થઈ ગઈ છે. સ્વ-પરીક્ષણને સુનિશ્ચિત કરવા માટે, દરેક કાર્યનું વર્ણન પરીક્ષણ દૃશ્યો સાથે કોષ્ટકમાં કરવામાં આવ્યું છે. કાર્યોનો સ્પષ્ટ ક્રમ છે. કાર્યો છોડવાની ભલામણ કરવામાં આવતી નથી. જો વર્તમાન કાર્ય ખૂબ મુશ્કેલ છે, તો પછીના કાર્ય પર આગળ વધવું નકામું છે. તે વધુ જટિલ છે. જેથી વિદ્યાર્થી વર્તમાન જટિલ કાર્યમાં નિપુણતા મેળવી શકે, પ્રથમ સમસ્યાના ઉદાહરણનો ઉપયોગ કરીને તેને ઘણી તકનીકો સમજાવવામાં આવે છે. વાસ્તવમાં, વિષયની સંપૂર્ણ સામગ્રી મુશ્કેલીઓને દૂર કરવા માટેની તકનીકો પર નીચે આવે છે. સાયકલની આડઅસર વધુ છે.

પ્રથમ કાર્ય હંમેશા એક ઉદાહરણ છે. બીજો થોડો અલગ પડે છે અને શિક્ષકની દેખરેખ હેઠળ પ્રથમ પછી તરત જ "સ્વતંત્ર રીતે" કરવામાં આવે છે. તમામ અનુગામી કાર્યોનો હેતુ વિવિધ નાની વસ્તુઓ પર ધ્યાન આપવાનો છે જે ખોટી માન્યતાઓનું કારણ બની શકે છે.

ઉદાહરણની સમજૂતી એ એક સંવાદ છે જેમાં વિદ્યાર્થીએ સામગ્રીના એક ભાગમાં નિપુણતા મેળવી છે તેની ખાતરી કરવા માટે પ્રચાર અને ક્રોસ-વેલિડેશનને પાછા બોલાવવાની જરૂર છે.

હું મામૂલી બનીશ અને કહીશ કે આ વિષય પરનું પ્રથમ ઉદાહરણ ખૂબ મહત્વનું છે. જો તમારી પાસે વ્યાપક સ્વતંત્ર કાર્ય માટે સામગ્રી છે, તો પ્રથમ ઉદાહરણની ભૂલો સુધારી શકાય છે. જો ઉદાહરણ સિવાય બીજું કંઈ ન હોય, તો સંભવતઃ વિદ્યાર્થી વિષયમાં માસ્ટર નહીં કરે.

જ્યારે કે માટે?

વિવાદાસ્પદ મુદ્દાઓ પૈકી એક ઉદાહરણ માટે બાંધકામની પસંદગી છે: જ્યારે અથવા માટે. એકવાર, મારા એક પ્રેક્ટિસિંગ ડેવલપર મિત્રે, જેમાં કોઈ શિક્ષણનો અનુભવ નથી, તેણે મને સમજાવવામાં એક કલાક પસાર કર્યો કે ફોર લૂપ સમજવા માટે સૌથી સરળ છે. દલીલો "તેમાંની દરેક વસ્તુ સ્પષ્ટ છે અને તેની જગ્યાએ મૂકવામાં આવી છે" સુધી ઉકળે છે. જો કે, વાસ્તવિક નવા નિશાળીયા માટે મુશ્કેલીઓનું મૂળ કારણ ચક્રનો વિચાર છે, અને તેનું લેખન નહીં. જો કોઈ વ્યક્તિ આ વિચારને સમજી શકતો નથી, તો તેને વાક્યરચના કરવામાં મુશ્કેલી પડશે. જલદી વિચાર સમજાય છે, કોડ ડિઝાઇનની સમસ્યાઓ તેમના પોતાના પર અદૃશ્ય થઈ જાય છે.

મારી સામગ્રીમાં, લૂપ્સની થીમ બ્રાન્ચિંગની થીમને અનુસરે છે. જો અને જ્યારે ની બાહ્ય સમાનતા આપણને સીધી સામ્યતા દોરવા દે છે: "જ્યારે હેડરમાંની સ્થિતિ સાચી હોય, ત્યારે શરીર ચલાવવામાં આવે છે." ચક્રની એકમાત્ર વિશિષ્ટતા એ છે કે શરીરને ઘણી વખત ચલાવવામાં આવે છે.

મારી બીજી દલીલ એ છે કે જ્યારે માટે કરતાં ઓછા ફોર્મેટિંગની જરૂર છે. ઓછા ફોર્મેટિંગનો અર્થ અલ્પવિરામ અને કૌંસ સાથે ઓછી મૂર્ખ ભૂલો છે. પ્રારંભિક લોકોએ હજુ સુધી વાક્યરચના ભૂલોને આપમેળે ટાળવા માટે પૂરતી સચેતતા અને સાવચેતી વિકસાવી નથી.
ત્રીજી દલીલ ઘણા સારા પુસ્તકોમાં પ્રથમ દલીલ તરીકે સમજાવવામાં આવી છે.

જો વિદ્યાર્થી સરળતાથી અભિવ્યક્તિનું રૂપાંતર કરી શકે છે, તો તમે પાસ થવા વિશે વાત કરી શકો છો. પછી વિદ્યાર્થી તેને સૌથી વધુ પસંદ કરે છે તે પસંદ કરશે. જો પરિવર્તન મુશ્કેલીઓનું કારણ બને છે, તો તમારું ધ્યાન વિચલિત ન કરવું વધુ સારું છે. જ્યારે વિદ્યાર્થીને પહેલા બધું ઉકેલવા દો. એકવાર તમે લૂપ્સના વિષયમાં નિપુણતા મેળવી લો તે પછી, તમે જ્યારે માટે રૂપાંતર કરવાની પ્રેક્ટિસ કરવા માટે ઉકેલોને ફરીથી લખી શકો છો.
પોસ્ટ-કન્ડિશન લૂપ્સ એક ખૂબ જ દુર્લભ જાનવર છે. હું તેના પર બિલકુલ સમય વિતાવતો નથી. જો કોઈ વિદ્યાર્થીએ પેટર્નને ઓળખવા અને અભિવ્યક્તિને બદલવાના વિચારોમાં નિપુણતા મેળવી હોય, તો તે મારી મદદ વિના તેને શોધી શકે છે.

મજબૂત વિદ્યાર્થીઓને પ્રથમ ઉદાહરણ દર્શાવતી વખતે, હું એ હકીકત તરફ ધ્યાન દોરું છું કે પ્રથમ ઉદાહરણમાં માત્ર સોલ્યુશન જ નહીં, પરંતુ પરિણામ તરફ દોરી ગયેલી ક્રિયાઓની સમગ્ર સાંકળને પણ રેકોર્ડ કરવી મહત્વપૂર્ણ છે. આળસુ વિદ્યાર્થીઓ લેખનની અવગણના કરી શકે છે અને માત્ર અંતિમ અલ્ગોરિધમની નકલ કરી શકે છે. તેમને ખાતરી કરવાની જરૂર છે કે એક દિવસ મુશ્કેલ કાર્ય તેમના માર્ગે આવશે. તેને હલ કરવા માટે, તમારે આ ઉદાહરણની જેમ પગલાંઓનું પાલન કરવાની જરૂર પડશે. તેથી જ તમામ તબક્કાઓ રેકોર્ડ કરવા મહત્વપૂર્ણ છે. નીચેની સમસ્યાઓમાં ઉકેલના અંતિમ સંસ્કરણને છોડી દેવાનું શક્ય બનશે.

ઓટોમેશનનો મુખ્ય વિચાર એ છે કે આપણે કોઈ વ્યક્તિ માટે નિયમિત કામ કરવા માટે કમ્પ્યુટરને સોંપીએ છીએ. મૂળભૂત તકનીકોમાંની એક લૂપ્સ લખવાની છે. જ્યારે પ્રોગ્રામમાં એક પંક્તિમાં ઘણી સમાન પુનરાવર્તિત ક્રિયાઓ લખવામાં આવે ત્યારે તેનો ઉપયોગ થાય છે.

ગર્ભિત કરતાં સ્પષ્ટ સારું છે

પ્રથમ લૂપિંગ કાર્યમાં સમાન વાક્યને ઘણી વખત પ્રદર્શિત કરવા માટે તે એક સારો વિચાર છે. દાખ્લા તરીકે:

હુરે, તે કામ કરે છે!
હુરે, તે કામ કરે છે!
હુરે, તે કામ કરે છે!
હુરે, તે કામ કરે છે!
હુરે, તે કામ કરે છે!
હુરે, તે કામ કરે છે!
હુરે, તે કામ કરે છે!
હુરે, તે કામ કરે છે!

આ વિકલ્પ ખરાબ છે કારણ કે આઉટપુટમાં કાઉન્ટર વેલ્યુ દેખાતી નથી. આ નવા નિશાળીયા માટે એક સમસ્યા છે. તેણીને ઓછો અંદાજ ન આપો. શરૂઆતમાં, આ કાર્ય પ્રથમ હતું, અને ચડતા ક્રમમાં સંખ્યાઓની શ્રેણી મેળવવાનું કાર્ય બીજું હતું. વધારાના શબ્દો "સાયકલ એન ટાઇમ્સ" અને "સાઇકલ થી એ બી સુધી" રજૂ કરવા જરૂરી હતા, જે અનિવાર્યપણે સમાન વસ્તુ છે. બિનજરૂરી સંસ્થાઓ ન બનાવવા માટે, મેં સંખ્યાઓની શ્રેણીના આઉટપુટ સાથે માત્ર એક ઉદાહરણ બતાવવાનું નક્કી કર્યું. થોડા લોકો તેમના માથામાં કાઉન્ટર કેવી રીતે રાખવું અને તૈયારી વિના તેમના માથામાં પ્રોગ્રામની વર્તણૂક કેવી રીતે બનાવવી તે શીખવાનું સંચાલન કરે છે. કેટલાક વિદ્યાર્થીઓ પ્રથમ ચક્રના વિષય પર માનસિક મોડેલિંગનો સામનો કરે છે.
થોડી પ્રેક્ટિસ કર્યા પછી, હું સ્વતંત્ર રીતે ઉકેલવા માટે સમાન ટેક્સ્ટનું પુનરાવર્તન કરવાનું કાર્ય આપું છું. જો તમે પહેલા દૃશ્યમાન કાઉન્ટર અને પછી અદ્રશ્ય કાઉન્ટર આપો, તો વિદ્યાર્થીઓને ઓછી સમસ્યાઓ થશે. કેટલીકવાર "સ્ક્રીન પર કાઉન્ટર લખશો નહીં" નો સંકેત પૂરતો છે.

અન્ય લોકો તેને કેવી રીતે સમજાવે છે?

ઇન્ટરનેટ પરની મોટાભાગની શૈક્ષણિક સામગ્રીમાં, ચક્રની વાક્યરચના "લેક્ચર" ના ભાગ રૂપે આપવામાં આવે છે. ઉદાહરણ તરીકે, 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 પુસ્તક પ્રિન્સિપલ્સ એન્ડ પ્રેક્ટિસ યુઝિંગ 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("Заключение");

કોડમાં "એક વેરિયેબલની પેટર્ન વ્યક્ત કરો" તકનીક લાગુ કર્યા પછી, તમને સમાન ક્રિયાઓના ઘણા જૂથો મળે છે જે એક પંક્તિમાં જાય છે. હવે પુનરાવર્તિત ક્રિયાઓને ચક્ર સાથે બદલી શકાય છે.

જ્યાં તમારે લૂપ્સનો ઉપયોગ કરવાની જરૂર હોય તે સમસ્યાને ઉકેલવાનો ક્રમ નીચેના પગલાંઓનો સમાવેશ કરે છે:

1. ઘણા અલગ આદેશો સાથે "હેડ-ઓન" ઉકેલો
2. એક પેટર્ન શોધો
3. ચલની પેટર્ન વ્યક્ત કરો
4. એક ચક્ર તરીકે ડિઝાઇન

આગળ, નવી શરતો રજૂ કરવામાં આવે છે જેથી વિદ્યાર્થી પોતાને "હું બધું સમજું છું, પરંતુ હું તે કહી શકતો નથી" ની પરિસ્થિતિમાં ન આવે:
— કાઉન્ટર એ હંમેશા એક ચલ છે જે લૂપમાં પગલાંઓની સંખ્યાને ટ્રૅક કરવા માટે જરૂરી છે. સામાન્ય રીતે પૂર્ણાંક કે જે અવરોધ સાથે સરખાવવામાં આવે છે.
— કાઉન્ટર સ્ટેપ — કાઉન્ટર ફેરફારોની પેટર્નનું વર્ણન.
- અવરોધ - સંખ્યા અથવા ચલ જેની સાથે કાઉન્ટરની તુલના કરવામાં આવે છે જેથી અલ્ગોરિધમ અંતિમ હોય. કાઉન્ટર મૂલ્ય મર્યાદા સુધી પહોંચવા બદલાય છે.
— લૂપ બોડી — આદેશોનો સમૂહ જે પુનરાવર્તિત થશે. જ્યારે તેઓ કહે છે કે "આદેશ લૂપની અંદર લખાયેલ છે," ત્યારે તેનો અર્થ શરીર થાય છે.
— લૂપ પુનરાવૃત્તિ — લૂપ બોડીનું વન-ટાઇમ એક્ઝેક્યુશન.
— લૂપ શરત — એક તાર્કિક અભિવ્યક્તિ કે જે નિર્ધારિત કરે છે કે શું અન્ય પુનરાવર્તન ચલાવવામાં આવશે. (અહીં બ્રાન્ચિંગ સ્ટ્રક્ચર્સ સાથે મૂંઝવણ હોઈ શકે છે)
તમારે એ હકીકત માટે તૈયાર રહેવાની જરૂર છે કે શરૂઆતમાં વિદ્યાર્થીઓ અન્ય હેતુઓ માટે શરતોનો ઉપયોગ કરશે. આ મજબૂત અને નબળા બંનેને લાગુ પડે છે. સામાન્ય ભાષા સ્થાપિત કરવી એ એક કળા છે. હવે હું સંક્ષિપ્તમાં લખીશ: તમારે "<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 જો તમને લખાણમાં ભૂલો અથવા ભૂલો જણાય, તો કૃપા કરીને મને જણાવો. આ ટેક્સ્ટનો ભાગ પસંદ કરીને અને Mac પર "⌘ + Enter" અને ક્લાસિક કીબોર્ડ પર "Ctrl / Enter" દબાવીને અથવા ખાનગી સંદેશાઓ દ્વારા કરી શકાય છે. જો આ વિકલ્પો ઉપલબ્ધ ન હોય, તો ટિપ્પણીઓમાં ભૂલો વિશે લખો. આભાર!

ફક્ત નોંધાયેલા વપરાશકર્તાઓ જ સર્વેમાં ભાગ લઈ શકે છે. સાઇન ઇન કરો, મહેરબાની કરીને.

કર્મ વિના વાચકો માટે મતદાન

• 20,0%હું વ્યવસાયિક રીતે શીખું છું, +12

• 10,0%હું વ્યવસાયિક રીતે શીખવું છું, -11

• 70,0%હું શીખવતો નથી, +17

• 0,0%હું શીખવતો નથી, -10

• 0,0%અન્ય0

10 વપરાશકર્તાઓએ મતદાન કર્યું. 5 વપરાશકર્તાઓ દૂર રહ્યા.

સોર્સ: www.habr.com