ਮੁਸ਼ਕਲਾਂ ਨੂੰ ਕਿਵੇਂ ਦੂਰ ਕਰਨਾ ਹੈ, ਅਤੇ ਉਸੇ ਸਮੇਂ ਚੱਕਰ ਲਿਖਣਾ ਕਿਵੇਂ ਸਿਖਾਉਣਾ ਹੈ

ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਅਸੀਂ ਬੁਨਿਆਦੀ ਵਿਸ਼ਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ, ਇਹ ਲੇਖ ਤਜਰਬੇਕਾਰ ਪੇਸ਼ੇਵਰਾਂ ਲਈ ਲਿਖਿਆ ਗਿਆ ਹੈ. ਟੀਚਾ ਇਹ ਦਿਖਾਉਣਾ ਹੈ ਕਿ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਕਿਹੜੀਆਂ ਗਲਤ ਧਾਰਨਾਵਾਂ ਹਨ। ਅਭਿਆਸ ਕਰਨ ਵਾਲੇ ਡਿਵੈਲਪਰਾਂ ਲਈ, ਇਹ ਸਮੱਸਿਆਵਾਂ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਹੱਲ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ, ਭੁੱਲ ਗਈਆਂ ਹਨ ਜਾਂ ਬਿਲਕੁਲ ਵੀ ਧਿਆਨ ਨਹੀਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ. ਜੇਕਰ ਤੁਹਾਨੂੰ ਅਚਾਨਕ ਇਸ ਵਿਸ਼ੇ ਵਿੱਚ ਕਿਸੇ ਦੀ ਮਦਦ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇ ਤਾਂ ਲੇਖ ਕੰਮ ਆ ਸਕਦਾ ਹੈ। ਲੇਖ ਸ਼ਿਲਡਟ, ਸਟ੍ਰੌਸਟ੍ਰਪ, ਓਕੁਲੋਵ ਦੁਆਰਾ ਪ੍ਰੋਗਰਾਮਿੰਗ 'ਤੇ ਵੱਖ-ਵੱਖ ਕਿਤਾਬਾਂ ਤੋਂ ਸਮੱਗਰੀ ਦੇ ਸਮਾਨਤਾਵਾਂ ਖਿੱਚਦਾ ਹੈ।

ਸਾਈਕਲਾਂ ਬਾਰੇ ਵਿਸ਼ਾ ਚੁਣਿਆ ਗਿਆ ਸੀ ਕਿਉਂਕਿ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਵੇਲੇ ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਨੂੰ ਇਸ ਤੋਂ ਬਾਹਰ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।

ਇਹ ਤਕਨੀਕ ਕਮਜ਼ੋਰ ਵਿਦਿਆਰਥੀਆਂ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ। ਇੱਕ ਨਿਯਮ ਦੇ ਤੌਰ 'ਤੇ, ਮਜ਼ਬੂਤ ​​​​ਲੋਕ ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਫਸਦੇ ਨਹੀਂ ਹਨ ਅਤੇ ਉਹਨਾਂ ਲਈ ਵਿਸ਼ੇਸ਼ ਤਕਨੀਕਾਂ ਨਾਲ ਆਉਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ. ਲੇਖ ਦਾ ਸੈਕੰਡਰੀ ਟੀਚਾ ਇਸ ਤਕਨੀਕ ਨੂੰ "ਸਾਰੇ ਵਿਦਿਆਰਥੀਆਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਸਿਰਫ਼ ਇੱਕ ਅਧਿਆਪਕ" ਕਲਾਸ ਤੋਂ "ਸਾਰੇ ਵਿਦਿਆਰਥੀਆਂ, ਸਾਰੇ ਅਧਿਆਪਕਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ" ਕਲਾਸ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨਾ ਹੈ। ਮੈਂ ਪੂਰਨ ਮੌਲਿਕਤਾ ਦਾ ਦਾਅਵਾ ਨਹੀਂ ਕਰਦਾ। ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਵਿਸ਼ੇ ਨੂੰ ਸਿਖਾਉਣ ਲਈ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਸਮਾਨ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਲਿਖੋ ਕਿ ਤੁਹਾਡਾ ਸੰਸਕਰਣ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ ਵਰਤਣ ਦਾ ਫੈਸਲਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਾਨੂੰ ਦੱਸੋ ਕਿ ਇਹ ਕਿਵੇਂ ਚੱਲਿਆ। ਜੇਕਰ ਕਿਸੇ ਕਿਤਾਬ ਵਿੱਚ ਅਜਿਹੀ ਤਕਨੀਕ ਦਾ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਨਾਮ ਲਿਖੋ।

ਮੈਂ ਇਸ ਤਕਨੀਕ 'ਤੇ 4 ਸਾਲਾਂ ਲਈ ਕੰਮ ਕੀਤਾ, ਵੱਖ-ਵੱਖ ਪੱਧਰਾਂ ਦੀ ਸਿਖਲਾਈ ਦੇ ਵਿਦਿਆਰਥੀਆਂ ਨਾਲ ਵਿਅਕਤੀਗਤ ਤੌਰ 'ਤੇ ਅਧਿਐਨ ਕੀਤਾ। ਕੁੱਲ ਮਿਲਾ ਕੇ ਪੰਜਾਹ ਦੇ ਕਰੀਬ ਵਿਦਿਆਰਥੀ ਅਤੇ ਦੋ ਹਜ਼ਾਰ ਘੰਟੇ ਦੀਆਂ ਕਲਾਸਾਂ ਹਨ। ਪਹਿਲਾਂ ਤਾਂ ਵਿਦਿਆਰਥੀ ਹਮੇਸ਼ਾ ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਅੜ ਗਏ ਅਤੇ ਛੱਡ ਗਏ। ਹਰੇਕ ਵਿਦਿਆਰਥੀ ਤੋਂ ਬਾਅਦ, ਵਿਧੀ ਅਤੇ ਸਮੱਗਰੀ ਨੂੰ ਵਿਵਸਥਿਤ ਕੀਤਾ ਗਿਆ ਸੀ. ਪਿਛਲੇ ਸਾਲ ਤੋਂ, ਵਿਦਿਆਰਥੀ ਹੁਣ ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਨਹੀਂ ਫਸੇ ਹੋਏ ਹਨ, ਇਸ ਲਈ ਮੈਂ ਆਪਣੀਆਂ ਖੋਜਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ।

ਮੈਂ ਕੌਣ ਅਤੇ ਕਿਉਂ ਸਿਖਾਵਾਂ?

ਕਿਉਂਕਿ ਇੱਥੇ ਕੋਈ ਦਾਖਲਾ ਪ੍ਰੀਖਿਆਵਾਂ ਨਹੀਂ ਹਨ, ਕਲਾਸਾਂ ਵਿੱਚ ਮਜ਼ਬੂਤ ​​ਅਤੇ ਬਹੁਤ ਕਮਜ਼ੋਰ ਵਿਦਿਆਰਥੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ। ਤੁਸੀਂ ਲੇਖ ਵਿੱਚ ਮੇਰੇ ਵਿਦਿਆਰਥੀਆਂ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਸ਼ਾਮ ਦੇ ਕੋਰਸ ਦੇ ਵਿਦਿਆਰਥੀਆਂ ਦੀ ਤਸਵੀਰ
ਮੈਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਕਿ ਹਰ ਕੋਈ ਜੋ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਿੱਖਣਾ ਚਾਹੁੰਦਾ ਹੈ ਉਹ ਇਸਨੂੰ ਸਿੱਖ ਸਕੇ।
ਮੇਰੀਆਂ ਕਲਾਸਾਂ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਆਯੋਜਿਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਵਿਦਿਆਰਥੀ ਹਰੇਕ ਲਈ ਆਪਣੇ ਪੈਸੇ ਅਦਾ ਕਰਦਾ ਹੈ। ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਵਿਦਿਆਰਥੀ ਲਾਗਤਾਂ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਗੇ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਦੀ ਮੰਗ ਕਰਨਗੇ। ਹਾਲਾਂਕਿ, ਲੋਕ ਇੱਕ ਲਾਈਵ ਅਧਿਆਪਕ ਨਾਲ ਆਹਮੋ-ਸਾਹਮਣੇ ਕਲਾਸਾਂ ਵਿੱਚ ਜਾਂਦੇ ਹਨ ਆਪਣੇ ਆਪ ਗਿਆਨ ਲਈ ਨਹੀਂ, ਬਲਕਿ ਉਹਨਾਂ ਨੇ ਜੋ ਸਿੱਖਿਆ ਹੈ ਉਸ ਦੇ ਭਰੋਸੇ ਲਈ, ਤਰੱਕੀ ਦੀ ਭਾਵਨਾ ਅਤੇ ਮਾਹਰ (ਅਧਿਆਪਕ) ਤੋਂ ਪ੍ਰਵਾਨਗੀ ਲਈ। ਜੇ ਵਿਦਿਆਰਥੀ ਆਪਣੀ ਪੜ੍ਹਾਈ ਵਿੱਚ ਤਰੱਕੀ ਮਹਿਸੂਸ ਨਹੀਂ ਕਰਦੇ, ਤਾਂ ਉਹ ਛੱਡ ਦੇਣਗੇ। ਆਮ ਤੌਰ 'ਤੇ, ਕਲਾਸਾਂ ਦਾ ਢਾਂਚਾ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ ਵਿਦਿਆਰਥੀ ਜਾਣੇ-ਪਛਾਣੇ ਢਾਂਚੇ ਦੀ ਗਿਣਤੀ ਨੂੰ ਵਧਾਉਣ ਵਿੱਚ ਤਰੱਕੀ ਮਹਿਸੂਸ ਕਰ ਸਕਣ। ਭਾਵ, ਪਹਿਲਾਂ ਅਸੀਂ ਵਿਸਥਾਰ ਨਾਲ ਅਧਿਐਨ ਕਰਦੇ ਹਾਂ, ਫਿਰ ਅਸੀਂ ਅਧਿਐਨ ਕਰਦੇ ਹਾਂ, ਫਿਰ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਹੁਣ ਸਾਡੇ ਕੋਲ ਇੱਕ ਹਜ਼ਾਰ ਅਤੇ ਇੱਕ ਰਾਤ ਦਾ ਕੋਰਸ ਤਿਆਰ ਹੈ, ਜਿਸ ਵਿੱਚ ਦੋ ਮਹੀਨਿਆਂ ਲਈ ਇਕੱਲੇ ਚੱਕਰਾਂ ਦਾ ਅਧਿਐਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਅੰਤ ਵਿੱਚ - ਇੱਕ ਵਿਦਿਆਰਥੀ ਜਿਸ ਨੇ ਲਿਖਿਆ ਡਿਕਸ਼ਨ ਅਧੀਨ ਇੱਕ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ। ਹਾਲਾਂਕਿ, ਵਿਹਾਰਕ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਨਾ ਸਿਰਫ਼ ਸਮੱਗਰੀ ਦਾ ਗਿਆਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਸਗੋਂ ਇਸਦੀ ਵਰਤੋਂ ਅਤੇ ਨਵੀਂ ਜਾਣਕਾਰੀ ਦੀ ਖੋਜ ਵਿੱਚ ਵੀ ਸੁਤੰਤਰਤਾ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਲਈ, ਫੇਸ-ਟੂ-ਫੇਸ ਕੋਰਸਾਂ ਲਈ, ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਸਹੀ ਸਿਧਾਂਤ ਘੱਟੋ-ਘੱਟ ਸਿਖਾਉਣਾ ਅਤੇ ਸੂਖਮਤਾਵਾਂ ਅਤੇ ਸੰਬੰਧਿਤ ਵਿਸ਼ਿਆਂ ਦੇ ਸੁਤੰਤਰ ਅਧਿਐਨ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਨਾ ਹੈ। ਲੂਪਸ ਦੇ ਵਿਸ਼ੇ ਵਿੱਚ, ਮੈਂ ਜਦਕਿ ਨਿਰਮਾਣ ਨੂੰ ਨਿਊਨਤਮ ਮੰਨਦਾ ਹਾਂ। ਤੁਸੀਂ ਇਸ ਤੋਂ ਸਿਧਾਂਤ ਨੂੰ ਸਮਝ ਸਕਦੇ ਹੋ। ਸਿਧਾਂਤ ਨੂੰ ਜਾਣਦਿਆਂ, ਤੁਸੀਂ ਆਪਣੇ ਲਈ ਅਤੇ ਕਰਦੇ ਸਮੇਂ ਦੋਵਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰ ਸਕਦੇ ਹੋ।

ਕਮਜ਼ੋਰ ਵਿਦਿਆਰਥੀਆਂ ਦੁਆਰਾ ਸਮੱਗਰੀ ਦੀ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਲਈ, ਸੰਟੈਕਸ ਦਾ ਵਰਣਨ ਕਰਨਾ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ। ਵਧੇਰੇ ਸਰਲ ਪਰ ਵਿਭਿੰਨ ਕਾਰਜ ਦੇਣ ਅਤੇ ਉਦਾਹਰਨਾਂ ਨੂੰ ਵਧੇਰੇ ਵਿਸਥਾਰ ਨਾਲ ਵਰਣਨ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਵਿਕਾਸ ਦੀ ਗਤੀ ਵਿਦਿਆਰਥੀ ਦੀ ਸਮੀਕਰਨਾਂ ਨੂੰ ਬਦਲਣ ਅਤੇ ਪੈਟਰਨਾਂ ਦੀ ਖੋਜ ਕਰਨ ਦੀ ਯੋਗਤਾ ਦੁਆਰਾ ਸੀਮਿਤ ਹੁੰਦੀ ਹੈ। ਹੁਸ਼ਿਆਰ ਵਿਦਿਆਰਥੀਆਂ ਲਈ, ਜ਼ਿਆਦਾਤਰ ਅਸਾਈਨਮੈਂਟ ਬੋਰਿੰਗ ਹੋਣਗੀਆਂ। ਉਹਨਾਂ ਨਾਲ ਅਧਿਐਨ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਨੂੰ 100% ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ 'ਤੇ ਜ਼ੋਰ ਦੇਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਮੇਰੀ ਸਮੱਗਰੀ ਨੂੰ 'ਤੇ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਮੇਰਾ github. ਇਹ ਸੱਚ ਹੈ ਕਿ ਰਿਪੋਜ਼ਟਰੀ ਇੱਕ ਜੰਗਬਾਜ਼ ਦੇ ਗ੍ਰੀਮੋਇਰ ਵਰਗੀ ਹੈ - ਮੇਰੇ ਤੋਂ ਇਲਾਵਾ ਕੋਈ ਨਹੀਂ ਸਮਝੇਗਾ ਕਿ ਕਿੱਥੇ ਹੈ, ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਜਾਂਚ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪਾਗਲ ਹੋ ਸਕਦੇ ਹੋ

ਵਿਧੀ ਅਭਿਆਸ-ਅਧਾਰਿਤ ਹੈ

ਥਿਊਰੀ ਨੂੰ ਕਿਸੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਮਝਾਇਆ ਗਿਆ ਹੈ। ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਲਾਸ ਦੇ ਬੁਨਿਆਦੀ ਸਿਧਾਂਤਾਂ ਵਿੱਚ ਜਿੱਥੇ ਸ਼ਾਖਾਵਾਂ ਅਤੇ ਲੂਪ ਸਿਖਾਏ ਜਾਂਦੇ ਹਨ, ਇੱਕ ਪੂਰੇ ਘੰਟੇ ਲਈ ਇੱਕ ਵਿਸ਼ੇ 'ਤੇ ਇੱਕ ਉਪਯੋਗੀ ਭਾਸ਼ਣ ਦੇਣਾ ਸੰਭਵ ਨਹੀਂ ਹੈ। ਸੰਕਲਪ ਨੂੰ ਸਮਝਾਉਣ ਲਈ 15-20 ਮਿੰਟ ਕਾਫ਼ੀ ਹਨ। ਪ੍ਰੈਕਟੀਕਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਮੁੱਖ ਮੁਸ਼ਕਲਾਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ.
ਸ਼ੁਰੂਆਤੀ ਅਧਿਆਪਕ ਇੱਕ ਲੈਕਚਰ ਵਿੱਚ ਆਪਰੇਟਰਾਂ, ਸ਼ਾਖਾਵਾਂ, ਲੂਪਾਂ ਅਤੇ ਐਰੇ ਨੂੰ ਬੰਦ ਕਰ ਸਕਦੇ ਹਨ। ਪਰ ਉਹਨਾਂ ਦੇ ਵਿਦਿਆਰਥੀਆਂ ਨੂੰ ਇਸ ਜਾਣਕਾਰੀ ਨੂੰ ਗ੍ਰਹਿਣ ਕਰਨ ਵਿੱਚ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਵੇਗਾ।
ਸਿਰਫ਼ ਸਮੱਗਰੀ ਨੂੰ ਦੱਸਣਾ ਹੀ ਨਹੀਂ, ਸਗੋਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਵੀ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਸੁਣਨ ਵਾਲੇ ਇਸ ਨੂੰ ਸਮਝ ਸਕਣ।

ਕਿਸੇ ਵਿਸ਼ੇ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਦਾ ਤੱਥ ਇਸ ਗੱਲ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿ ਵਿਦਿਆਰਥੀ ਸੁਤੰਤਰ ਕੰਮ ਨਾਲ ਕਿਵੇਂ ਨਜਿੱਠਦਾ ਹੈ।
ਜੇ ਕੋਈ ਵਿਦਿਆਰਥੀ ਕਿਸੇ ਅਧਿਆਪਕ ਦੀ ਮਦਦ ਤੋਂ ਬਿਨਾਂ ਕਿਸੇ ਵਿਸ਼ੇ 'ਤੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਵਿਚ ਕਾਮਯਾਬ ਹੋ ਗਿਆ, ਤਾਂ ਉਸ ਵਿਸ਼ੇ 'ਤੇ ਮੁਹਾਰਤ ਹਾਸਲ ਕੀਤੀ ਗਈ ਹੈ। ਸਵੈ-ਜਾਂਚ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ, ਹਰੇਕ ਕੰਮ ਨੂੰ ਟੈਸਟ ਦ੍ਰਿਸ਼ਾਂ ਦੇ ਨਾਲ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੰਮਾਂ ਦਾ ਸਪਸ਼ਟ ਕ੍ਰਮ ਹੈ। ਕੰਮ ਛੱਡਣ ਦੀ ਸਿਫਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ। ਜੇਕਰ ਮੌਜੂਦਾ ਕੰਮ ਬਹੁਤ ਔਖਾ ਹੈ, ਤਾਂ ਅਗਲੇ ਕੰਮ 'ਤੇ ਜਾਣਾ ਬੇਕਾਰ ਹੈ। ਇਹ ਹੋਰ ਵੀ ਗੁੰਝਲਦਾਰ ਹੈ। ਤਾਂ ਜੋ ਵਿਦਿਆਰਥੀ ਮੌਜੂਦਾ ਗੁੰਝਲਦਾਰ ਕੰਮ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰ ਸਕੇ, ਪਹਿਲੀ ਸਮੱਸਿਆ ਦੀ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਸਨੂੰ ਕਈ ਤਕਨੀਕਾਂ ਸਮਝਾਈਆਂ ਗਈਆਂ ਹਨ। ਅਸਲ ਵਿੱਚ, ਵਿਸ਼ੇ ਦੀ ਸਮੁੱਚੀ ਸਮੱਗਰੀ ਮੁਸ਼ਕਲਾਂ ਨੂੰ ਦੂਰ ਕਰਨ ਦੀਆਂ ਤਕਨੀਕਾਂ 'ਤੇ ਆਉਂਦੀ ਹੈ। ਚੱਕਰ ਇੱਕ ਪਾਸੇ ਦੇ ਪ੍ਰਭਾਵ ਦੇ ਹੋਰ ਹਨ.

ਪਹਿਲਾ ਕੰਮ ਹਮੇਸ਼ਾ ਇੱਕ ਉਦਾਹਰਣ ਹੁੰਦਾ ਹੈ. ਦੂਜਾ ਥੋੜ੍ਹਾ ਵੱਖਰਾ ਹੈ ਅਤੇ ਇੱਕ ਅਧਿਆਪਕ ਦੀ ਨਿਗਰਾਨੀ ਹੇਠ ਪਹਿਲੇ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ "ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ" ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸਾਰੇ ਬਾਅਦ ਦੇ ਕੰਮਾਂ ਦਾ ਉਦੇਸ਼ ਵੱਖ-ਵੱਖ ਛੋਟੀਆਂ ਚੀਜ਼ਾਂ ਵੱਲ ਧਿਆਨ ਦੇਣਾ ਹੈ ਜੋ ਗਲਤ ਧਾਰਨਾਵਾਂ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀਆਂ ਹਨ।

ਉਦਾਹਰਨ ਦੀ ਵਿਆਖਿਆ ਇੱਕ ਸੰਵਾਦ ਹੈ ਜਿਸ ਵਿੱਚ ਵਿਦਿਆਰਥੀ ਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਉਸ ਨੇ ਸਮੱਗਰੀ ਦੇ ਇੱਕ ਹਿੱਸੇ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰ ਲਈ ਹੈ, ਨੂੰ ਵਾਪਸ ਪ੍ਰਸਾਰ ਅਤੇ ਕ੍ਰਾਸ-ਵੈਧੀਕਰਨ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਮੈਂ ਬੇਨਲ ਹੋਵਾਂਗਾ ਅਤੇ ਕਹਾਂਗਾ ਕਿ ਵਿਸ਼ੇ 'ਤੇ ਪਹਿਲੀ ਉਦਾਹਰਣ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ. ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਵਿਆਪਕ ਸੁਤੰਤਰ ਕੰਮ ਲਈ ਸਮੱਗਰੀ ਹੈ, ਤਾਂ ਪਹਿਲੀ ਉਦਾਹਰਣ ਦੀਆਂ ਭੁੱਲਾਂ ਨੂੰ ਠੀਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਜੇ ਉਦਾਹਰਨ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਕੁਝ ਨਹੀਂ ਹੈ, ਤਾਂ ਵਿਦਿਆਰਥੀ ਇਸ ਵਿਸ਼ੇ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਨਹੀਂ ਕਰੇਗਾ।

ਜਦਕਿ ਜਾਂ ਲਈ?

ਵਿਵਾਦਪੂਰਨ ਮੁੱਦਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਉਦਾਹਰਨ ਲਈ ਉਸਾਰੀ ਦੀ ਚੋਣ ਹੈ: ਜਦੋਂ ਜਾਂ ਲਈ. ਇੱਕ ਵਾਰ, ਮੇਰੇ ਇੱਕ ਅਭਿਆਸੀ ਡਿਵੈਲਪਰ ਦੋਸਤ ਨੇ ਜਿਸ ਵਿੱਚ ਕੋਈ ਅਧਿਆਪਨ ਅਨੁਭਵ ਨਹੀਂ ਸੀ, ਨੇ ਇੱਕ ਘੰਟਾ ਮੈਨੂੰ ਇਹ ਯਕੀਨ ਦਿਵਾਉਣ ਵਿੱਚ ਬਿਤਾਇਆ ਕਿ ਲੂਪ ਨੂੰ ਸਮਝਣਾ ਸਭ ਤੋਂ ਆਸਾਨ ਸੀ। ਦਲੀਲਾਂ "ਇਸ ਵਿੱਚ ਸਭ ਕੁਝ ਸਪਸ਼ਟ ਅਤੇ ਆਪਣੀ ਥਾਂ ਤੇ ਰੱਖਿਆ ਗਿਆ ਹੈ" ਤੱਕ ਉਬਲਿਆ। ਹਾਲਾਂਕਿ, ਅਸਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਮੁਸ਼ਕਲਾਂ ਦਾ ਮੂਲ ਕਾਰਨ ਚੱਕਰ ਦਾ ਵਿਚਾਰ ਹੈ, ਨਾ ਕਿ ਇਸਦੀ ਲਿਖਤ। ਜੇਕਰ ਕੋਈ ਵਿਅਕਤੀ ਇਸ ਵਿਚਾਰ ਨੂੰ ਨਹੀਂ ਸਮਝਦਾ, ਤਾਂ ਉਸ ਨੂੰ ਸੰਟੈਕਸ ਵਿੱਚ ਮੁਸ਼ਕਲ ਆਵੇਗੀ। ਜਿਵੇਂ ਹੀ ਵਿਚਾਰ ਨੂੰ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ, ਕੋਡ ਡਿਜ਼ਾਈਨ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਆਪਣੇ ਆਪ ਅਲੋਪ ਹੋ ਜਾਂਦੀਆਂ ਹਨ.

ਮੇਰੀ ਸਮੱਗਰੀ ਵਿੱਚ, ਲੂਪਸ ਦੀ ਥੀਮ ਬ੍ਰਾਂਚਿੰਗ ਦੇ ਥੀਮ ਦੀ ਪਾਲਣਾ ਕਰਦੀ ਹੈ। if ਅਤੇ while ਦੀ ਬਾਹਰੀ ਸਮਾਨਤਾ ਸਾਨੂੰ ਇੱਕ ਸਿੱਧੀ ਸਮਾਨਤਾ ਖਿੱਚਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ: "ਜਦੋਂ ਸਿਰਲੇਖ ਵਿੱਚ ਸਥਿਤੀ ਸਹੀ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਸਰੀਰ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।" ਚੱਕਰ ਦੀ ਇਕੋ ਇਕ ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ ਸਰੀਰ ਨੂੰ ਕਈ ਵਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ.

ਮੇਰੀ ਦੂਜੀ ਦਲੀਲ ਇਹ ਹੈ ਕਿ ਜਦੋਂ ਕਿ for ਨਾਲੋਂ ਘੱਟ ਫਾਰਮੈਟਿੰਗ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ. ਘੱਟ ਫਾਰਮੈਟਿੰਗ ਦਾ ਮਤਲਬ ਹੈ ਗੁੰਮ ਕਾਮਿਆਂ ਅਤੇ ਬਰੈਕਟਾਂ ਨਾਲ ਘੱਟ ਮੂਰਖ ਗਲਤੀਆਂ। ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਨੇ ਅਜੇ ਤੱਕ ਸੰਟੈਕਸ ਦੀਆਂ ਗਲਤੀਆਂ ਤੋਂ ਆਪਣੇ ਆਪ ਬਚਣ ਲਈ ਕਾਫ਼ੀ ਧਿਆਨ ਅਤੇ ਸੂਝ-ਬੂਝ ਦਾ ਵਿਕਾਸ ਨਹੀਂ ਕੀਤਾ ਹੈ।
ਤੀਜੀ ਦਲੀਲ ਨੂੰ ਕਈ ਚੰਗੀਆਂ ਕਿਤਾਬਾਂ ਵਿੱਚ ਪਹਿਲੀ ਦਲੀਲ ਵਜੋਂ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

ਜੇਕਰ ਵਿਦਿਆਰਥੀ ਆਸਾਨੀ ਨਾਲ ਸਮੀਕਰਨਾਂ ਨੂੰ ਬਦਲ ਸਕਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਪਾਸ ਹੋਣ ਬਾਰੇ ਗੱਲ ਕਰ ਸਕਦੇ ਹੋ। ਵਿਦਿਆਰਥੀ ਫਿਰ ਚੁਣੇਗਾ ਕਿ ਉਸਨੂੰ ਕੀ ਪਸੰਦ ਹੈ। ਜੇ ਪਰਿਵਰਤਨ ਮੁਸ਼ਕਲਾਂ ਦਾ ਕਾਰਨ ਬਣਦੇ ਹਨ, ਤਾਂ ਤੁਹਾਡਾ ਧਿਆਨ ਭਟਕਾਉਣਾ ਬਿਹਤਰ ਨਹੀਂ ਹੈ। ਵਿਦਿਆਰਥੀ ਨੂੰ ਪਹਿਲਾਂ ਵਰਤਦੇ ਹੋਏ ਸਭ ਕੁਝ ਹੱਲ ਕਰਨ ਦਿਓ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਲੂਪਸ ਦੇ ਵਿਸ਼ੇ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕਨਵਰਟ ਕਰਨ ਦਾ ਅਭਿਆਸ ਕਰਨ ਲਈ ਹੱਲਾਂ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖ ਸਕਦੇ ਹੋ।
ਪੋਸਟ ਕੰਡੀਸ਼ਨ ਲੂਪਸ ਇੱਕ ਬਹੁਤ ਹੀ ਦੁਰਲੱਭ ਜਾਨਵਰ ਹਨ। ਮੈਂ ਇਸ 'ਤੇ ਬਿਲਕੁਲ ਵੀ ਸਮਾਂ ਨਹੀਂ ਖਰਚਦਾ। ਜੇਕਰ ਕਿਸੇ ਵਿਦਿਆਰਥੀ ਨੇ ਪੈਟਰਨਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਅਤੇ ਸਮੀਕਰਨਾਂ ਨੂੰ ਬਦਲਣ ਦੇ ਵਿਚਾਰਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕੀਤੀ ਹੈ, ਤਾਂ ਉਹ ਮੇਰੀ ਮਦਦ ਤੋਂ ਬਿਨਾਂ ਇਸਦਾ ਪਤਾ ਲਗਾ ਸਕਦਾ ਹੈ।

ਮਜ਼ਬੂਤ ​​​​ਵਿਦਿਆਰਥੀਆਂ ਨੂੰ ਪਹਿਲੀ ਉਦਾਹਰਣ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੇ ਸਮੇਂ, ਮੈਂ ਇਸ ਤੱਥ ਵੱਲ ਧਿਆਨ ਖਿੱਚਦਾ ਹਾਂ ਕਿ ਪਹਿਲੀ ਉਦਾਹਰਨ ਵਿੱਚ ਨਾ ਸਿਰਫ਼ ਹੱਲ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਸਗੋਂ ਉਹਨਾਂ ਕਿਰਿਆਵਾਂ ਦੀ ਪੂਰੀ ਲੜੀ ਨੂੰ ਵੀ ਦਰਜ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ ਜਿਸ ਨਾਲ ਨਤੀਜਾ ਨਿਕਲਿਆ। ਆਲਸੀ ਵਿਦਿਆਰਥੀ ਲਿਖਤ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਸਿਰਫ਼ ਅੰਤਿਮ ਐਲਗੋਰਿਦਮ ਦੀ ਨਕਲ ਕਰ ਸਕਦੇ ਹਨ। ਉਨ੍ਹਾਂ ਨੂੰ ਯਕੀਨ ਦਿਵਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਇੱਕ ਦਿਨ ਉਨ੍ਹਾਂ ਦੇ ਰਾਹ ਇੱਕ ਮੁਸ਼ਕਲ ਕੰਮ ਆਵੇਗਾ। ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇਸ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਇਸ ਲਈ ਸਾਰੇ ਪੜਾਵਾਂ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ. ਹੇਠ ਲਿਖੀਆਂ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਹੱਲ ਦੇ ਕੇਵਲ ਅੰਤਮ ਸੰਸਕਰਣ ਨੂੰ ਛੱਡਣਾ ਸੰਭਵ ਹੋਵੇਗਾ.

ਆਟੋਮੇਸ਼ਨ ਦਾ ਮੁੱਖ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਅਸੀਂ ਇੱਕ ਵਿਅਕਤੀ ਲਈ ਰੁਟੀਨ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਕੰਪਿਊਟਰ ਨੂੰ ਸੌਂਪਦੇ ਹਾਂ। ਬੁਨਿਆਦੀ ਤਕਨੀਕਾਂ ਵਿੱਚੋਂ ਇੱਕ ਲੂਪ ਲਿਖਣਾ ਹੈ। ਇਹ ਉਦੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੱਕ ਕਤਾਰ ਵਿੱਚ ਕਈ ਸਮਾਨ ਦੁਹਰਾਉਣ ਵਾਲੀਆਂ ਕਿਰਿਆਵਾਂ ਲਿਖੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਪਹਿਲੇ ਲੂਪਿੰਗ ਟਾਸਕ ਵਿੱਚ ਇੱਕੋ ਵਾਕਾਂਸ਼ ਨੂੰ ਕਈ ਵਾਰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਜਾਪਦਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ:

ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!
ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!
ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!
ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!
ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!
ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!
ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!
ਹੁਰੇ, ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ!

ਇਹ ਵਿਕਲਪ ਖਰਾਬ ਹੈ ਕਿਉਂਕਿ ਕਾਊਂਟਰ ਮੁੱਲ ਆਉਟਪੁੱਟ ਵਿੱਚ ਦਿਖਾਈ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। ਇਹ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਇੱਕ ਸਮੱਸਿਆ ਹੈ। ਉਸਨੂੰ ਘੱਟ ਨਾ ਸਮਝੋ। ਪਹਿਲਾਂ, ਇਹ ਕੰਮ ਪਹਿਲਾ ਸੀ, ਅਤੇ ਚੜ੍ਹਦੇ ਕ੍ਰਮ ਵਿੱਚ ਸੰਖਿਆਵਾਂ ਦੀ ਲੜੀ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਕੰਮ ਦੂਜਾ ਸੀ। ਵਾਧੂ ਸ਼ਬਦ "ਚੱਕਰ N ਵਾਰ" ਅਤੇ "A ਤੋਂ B ਤੱਕ ਚੱਕਰ" ਨੂੰ ਪੇਸ਼ ਕਰਨਾ ਜ਼ਰੂਰੀ ਸੀ, ਜੋ ਕਿ ਅਸਲ ਵਿੱਚ ਇੱਕੋ ਚੀਜ਼ ਹਨ। ਬੇਲੋੜੀਆਂ ਸੰਸਥਾਵਾਂ ਨਾ ਬਣਾਉਣ ਲਈ, ਮੈਂ ਸੰਖਿਆਵਾਂ ਦੀ ਲੜੀ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਨਾਲ ਸਿਰਫ ਇੱਕ ਉਦਾਹਰਣ ਦਿਖਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਬਹੁਤ ਘੱਟ ਲੋਕ ਇਹ ਸਿੱਖਣ ਦਾ ਪ੍ਰਬੰਧ ਕਰਦੇ ਹਨ ਕਿ ਉਹਨਾਂ ਦੇ ਸਿਰ ਵਿੱਚ ਕਾਊਂਟਰ ਕਿਵੇਂ ਰੱਖਣਾ ਹੈ ਅਤੇ ਬਿਨਾਂ ਤਿਆਰੀ ਦੇ ਉਹਨਾਂ ਦੇ ਸਿਰ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵਿਵਹਾਰ ਦਾ ਮਾਡਲ ਕਿਵੇਂ ਕਰਨਾ ਹੈ। ਕੁਝ ਵਿਦਿਆਰਥੀ ਪਹਿਲਾਂ ਸਾਈਕਲ ਦੇ ਵਿਸ਼ੇ 'ਤੇ ਮਾਨਸਿਕ ਮਾਡਲਿੰਗ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਨ।
ਕੁਝ ਅਭਿਆਸ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਹੱਲ ਕਰਨ ਲਈ ਉਸੇ ਟੈਕਸਟ ਨੂੰ ਦੁਹਰਾਉਣ ਦਾ ਕੰਮ ਦਿੰਦਾ ਹਾਂ। ਜੇਕਰ ਤੁਸੀਂ ਪਹਿਲਾਂ ਇੱਕ ਦ੍ਰਿਸ਼ਮਾਨ ਕਾਊਂਟਰ ਅਤੇ ਫਿਰ ਇੱਕ ਅਦਿੱਖ ਕਾਊਂਟਰ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਵਿਦਿਆਰਥੀਆਂ ਨੂੰ ਘੱਟ ਸਮੱਸਿਆਵਾਂ ਹੋਣਗੀਆਂ। ਕਈ ਵਾਰ "ਸਕਰੀਨ 'ਤੇ ਕਾਊਂਟਰ ਨਾ ਲਿਖੋ" ਦਾ ਇਸ਼ਾਰਾ ਕਾਫੀ ਹੁੰਦਾ ਹੈ।

ਦੂਸਰੇ ਇਸਨੂੰ ਕਿਵੇਂ ਸਮਝਾਉਂਦੇ ਹਨ?

ਇੰਟਰਨੈੱਟ 'ਤੇ ਜ਼ਿਆਦਾਤਰ ਵਿਦਿਅਕ ਸਮੱਗਰੀਆਂ ਵਿੱਚ, ਚੱਕਰ ਦਾ ਸੰਟੈਕਸ ਇੱਕ "ਲੈਕਚਰ" ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, developer.mozilla.org 'ਤੇ (ਵਰਤਮਾਨ ਵਿੱਚ), ਜਦਕਿ ਲੂਪ ਦੇ ਨਾਲ ਕਈ ਹੋਰ ਉਸਾਰੀਆਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ, ਸਿਰਫ ਡਿਜ਼ਾਈਨ ਖੁਦ ਹੀ ਟੈਂਪਲੇਟ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਹਨ. ਉਹਨਾਂ ਦੀ ਸ਼ੁਰੂਆਤ ਦਾ ਨਤੀਜਾ ਸ਼ਬਦਾਂ ਵਿੱਚ ਬਿਆਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਰ ਕੋਈ ਦ੍ਰਿਸ਼ਟਾਂਤ ਨਹੀਂ ਹੈ. ਮੇਰੀ ਰਾਏ ਵਿੱਚ, ਵਿਸ਼ੇ ਦੀ ਅਜਿਹੀ ਪੇਸ਼ਕਾਰੀ ਅਜਿਹੀ ਸਮੱਗਰੀ ਦੀ ਉਪਯੋਗਤਾ ਨੂੰ ਜ਼ੀਰੋ ਨਾਲ ਗੁਣਾ ਕਰਦੀ ਹੈ. ਵਿਦਿਆਰਥੀ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਚਲਾ ਸਕਦਾ ਹੈ, ਪਰ ਉਸਨੂੰ ਅਜੇ ਵੀ ਤੁਲਨਾ ਲਈ ਇੱਕ ਮਿਆਰ ਦੀ ਲੋੜ ਹੈ। ਤੁਸੀਂ ਕਿਵੇਂ ਸਮਝ ਸਕਦੇ ਹੋ ਕਿ ਇੱਕ ਉਦਾਹਰਣ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਦੁਬਾਰਾ ਲਿਖਿਆ ਗਿਆ ਹੈ ਜੇਕਰ ਨਤੀਜੇ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਕੁਝ ਨਹੀਂ ਹੈ?
ਜਦੋਂ ਸਿਰਫ਼ ਇੱਕ ਨਮੂਨਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਬਿਨਾਂ ਉਦਾਹਰਨ ਦੇ, ਇਹ ਵਿਦਿਆਰਥੀ ਲਈ ਹੋਰ ਵੀ ਮੁਸ਼ਕਲ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਹ ਕਿਵੇਂ ਸਮਝਣਾ ਹੈ ਕਿ ਕੋਡ ਦੇ ਟੁਕੜੇ ਟੈਂਪਲੇਟ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਰੱਖੇ ਗਏ ਹਨ? ਤੁਸੀਂ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ ਕਿਸੇ ਤਰ੍ਹਾਂ, ਅਤੇ ਫਿਰ ਚਲਾਓ. ਪਰ ਜੇਕਰ ਨਤੀਜੇ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਕੋਈ ਮਿਆਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਲਾਂਚ ਕਰਨਾ ਵੀ ਮਦਦ ਨਹੀਂ ਕਰੇਗਾ.

Intuitive 'ਤੇ C++ ਕੋਰਸ ਵਿੱਚ, ਲੂਪ ਸੰਟੈਕਸ ਲੈਕਚਰ 4 ਦੇ ਤੀਜੇ ਪੰਨੇ ਵਿੱਚ "ਓਪਰੇਟਰਾਂ" ਵਿਸ਼ੇ 'ਤੇ ਦੱਬਿਆ ਹੋਇਆ ਹੈ। ਲੂਪਸ ਦੇ ਸੰਟੈਕਸ ਦੀ ਵਿਆਖਿਆ ਕਰਦੇ ਸਮੇਂ, "ਓਪਰੇਟਰ" ਸ਼ਬਦ 'ਤੇ ਵਿਸ਼ੇਸ਼ ਜ਼ੋਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਸ਼ਬਦ ਨੂੰ ਤੱਥਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਦੇ ਰੂਪ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਵੇਂ ਕਿ “ਪ੍ਰਤੀਕ; ਇਹ ਇੱਕ ਕਥਨ ਹੈ", "{} ਇੱਕ ਮਿਸ਼ਰਿਤ ਬਿਆਨ ਹੈ", "ਲੂਪ ਦਾ ਮੁੱਖ ਭਾਗ ਇੱਕ ਬਿਆਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ"। ਮੈਨੂੰ ਇਹ ਪਹੁੰਚ ਪਸੰਦ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਮਿਆਦ ਦੇ ਪਿੱਛੇ ਮਹੱਤਵਪੂਰਨ ਸਬੰਧਾਂ ਨੂੰ ਲੁਕਾਉਂਦਾ ਜਾਪਦਾ ਹੈ। ਕਿਸੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਸਰੋਤ ਕੋਡ ਨੂੰ ਇਸ ਪੱਧਰ 'ਤੇ ਸ਼ਬਦਾਂ ਵਿੱਚ ਪਾਰਸ ਕਰਨਾ ਕੰਪਾਈਲਰ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਭਾਸ਼ਾ ਨਿਰਧਾਰਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਲੋੜੀਂਦਾ ਹੈ, ਪਰ ਵਿਦਿਆਰਥੀਆਂ ਦੁਆਰਾ ਪਹਿਲੇ ਅਨੁਮਾਨ ਵਜੋਂ ਨਹੀਂ। ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਈ ਨਵੇਂ ਆਉਣ ਵਾਲੇ ਸ਼ਾਇਦ ਹੀ ਸ਼ਰਤਾਂ ਵੱਲ ਇੰਨਾ ਧਿਆਨ ਦੇਣ ਲਈ ਇੰਨੇ ਸਾਵਧਾਨ ਹੁੰਦੇ ਹਨ। ਇਹ ਇੱਕ ਦੁਰਲੱਭ ਵਿਅਕਤੀ ਹੈ ਜੋ ਪਹਿਲੀ ਵਾਰ ਨਵੇਂ ਸ਼ਬਦਾਂ ਨੂੰ ਯਾਦ ਕਰਦਾ ਹੈ ਅਤੇ ਸਮਝਦਾ ਹੈ। ਲਗਭਗ ਕੋਈ ਵੀ ਉਸ ਸ਼ਬਦ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਲਾਗੂ ਨਹੀਂ ਕਰ ਸਕਦਾ ਜੋ ਉਸਨੇ ਹੁਣੇ ਸਿੱਖਿਆ ਹੈ। ਇਸ ਲਈ, ਵਿਦਿਆਰਥੀਆਂ ਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਗਲਤੀਆਂ ਮਿਲਦੀਆਂ ਹਨ ਜਿਵੇਂ ਕਿ "ਮੈਂ ਲਿਖਿਆ ਸੀ ਜਦੋਂ(a<7);{, ਪਰ ਪ੍ਰੋਗਰਾਮ ਕੰਮ ਨਹੀਂ ਕਰਦਾ।"
ਮੇਰੀ ਰਾਏ ਵਿੱਚ, ਸ਼ੁਰੂ ਵਿੱਚ, ਕੰਸਟਰਕਸ਼ਨ ਦੇ ਸੰਟੈਕਸ ਨੂੰ ਤੁਰੰਤ ਬਰੈਕਟ ਦੇ ਨਾਲ ਦੇਣਾ ਬਿਹਤਰ ਹੈ. ਬਰੈਕਟਾਂ ਤੋਂ ਬਿਨਾਂ ਵਿਕਲਪ ਦੀ ਵਿਆਖਿਆ ਤਾਂ ਹੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਜੇਕਰ ਵਿਦਿਆਰਥੀ ਦਾ ਕੋਈ ਖਾਸ ਸਵਾਲ ਹੈ: "ਕੋਈ ਬਰੈਕਟ ਕਿਉਂ ਨਹੀਂ ਹੈ ਅਤੇ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ।"

ਓਕੁਲੋਵ ਦੀ 2012 ਦੀ ਕਿਤਾਬ "ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਬੁਨਿਆਦੀ" ਵਿੱਚ, ਲੂਪਸ ਦੀ ਇੱਕ ਜਾਣ-ਪਛਾਣ ਪੈਟਰਨ ਲਈ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਇਸਦੀ ਵਰਤੋਂ ਲਈ ਸਿਫ਼ਾਰਿਸ਼ਾਂ ਦਿੰਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਤੁਰੰਤ ਪਾਠ ਦੇ ਪ੍ਰਯੋਗਾਤਮਕ ਭਾਗ ਵਿੱਚ ਜਾਂਦੀ ਹੈ। ਮੈਂ ਸਮਝਦਾ/ਸਮਝਦੀ ਹਾਂ ਕਿ ਇਹ ਕਿਤਾਬ ਬਹੁਤ ਹੀ ਕਾਬਲ ਵਿਦਿਆਰਥੀਆਂ ਦੀ ਘੱਟ ਗਿਣਤੀ ਲਈ ਲਿਖੀ ਗਈ ਸੀ ਜੋ ਮੇਰੀਆਂ ਕਲਾਸਾਂ ਵਿੱਚ ਘੱਟ ਹੀ ਆਉਂਦੇ ਹਨ।

ਪ੍ਰਸਿੱਧ ਕਿਤਾਬਾਂ ਵਿੱਚ, ਕੋਡ ਦੇ ਟੁਕੜਿਆਂ ਦਾ ਨਤੀਜਾ ਹਮੇਸ਼ਾ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਸ਼ਿਲਡਟ ਦਾ “ਜਾਵਾ 8. ਦਿ ਕੰਪਲੀਟ ਗਾਈਡ” 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

ਇੱਕ ਟੈਮਪਲੇਟ, ਇੱਕ ਉਦਾਹਰਨ ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਨਤੀਜੇ ਦਾ ਵਰਣਨ ਕਰਨ ਦੀ ਪਹੁੰਚ ਨੂੰ "ਬੱਚਿਆਂ ਲਈ Javascript" ਕਿਤਾਬ ਵਿੱਚ ਅਤੇ w3schools.com 'ਤੇ js ਕੋਰਸ ਵਿੱਚ ਵੀ ਵਰਤਿਆ ਗਿਆ ਹੈ। ਵੈਬ ਪੇਜ ਫਾਰਮੈਟ ਵੀ ਇਸ ਉਦਾਹਰਨ ਨੂੰ ਇੰਟਰਐਕਟਿਵ ਹੋਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

Stroustrup ਦੀ 2016 ਦੀ ਕਿਤਾਬ Principles and Practice Using 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;
    }
}

ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ ਇਸ ਕਿਤਾਬ ਵਿੱਚ ਵਾਕ-ਵਿਚਾਰ ਪੈਟਰਨ ਦਾ ਵਰਣਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ। ਇੰਸਟ੍ਰਕਟਰ ਦੇ ਮੈਨੂਅਲ ਵਿੱਚ ਸਟ੍ਰੌਸਟ੍ਰਪ (ਅਨੁਵਾਦ) ਇਸ ਗੱਲ 'ਤੇ ਜ਼ੋਰ ਦਿੰਦਾ ਹੈ ਕਿ ਇਹ ਆਪਣੇ ਵਿਦਿਆਰਥੀਆਂ ਦੀ ਬੁੱਧੀ ਦਾ ਆਦਰ ਕਰਦਾ ਹੈ। ਸ਼ਾਇਦ ਕਈ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਇੱਕ ਪੈਟਰਨ ਦੀ ਪਛਾਣ ਕਰਨ ਦੀ ਯੋਗਤਾ ਨੂੰ ਅਜਿਹੀ ਬੁੱਧੀ ਦਾ ਪ੍ਰਗਟਾਵਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ.

Stroustrup ਦੀ ਪਹੁੰਚ: ਨਤੀਜੇ ਦਾ ਵਰਣਨ ਕਰਨਾ, ਫਿਰ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨਾ, ਅਤੇ ਫਿਰ ਵਿਦਿਆਰਥੀ ਦੁਆਰਾ ਇੱਕ ਸੁਤੰਤਰ ਵਿਸ਼ਲੇਸ਼ਣ - ਸਭ ਤੋਂ ਵੱਧ ਵਿਚਾਰਸ਼ੀਲ ਲੱਗਦਾ ਹੈ। ਇਸ ਲਈ, ਮੈਂ ਇਸਨੂੰ ਇੱਕ ਅਧਾਰ ਵਜੋਂ ਲੈਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਪਰ ਇੱਕ ਘੱਟ ਇਤਿਹਾਸਕ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਦੱਸਦਾ ਹਾਂ - ਇੱਕ "ਸਮੱਗਰੀ ਦੀ ਸਾਰਣੀ" ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਕੰਮ। ਇਹ ਇੱਕ ਪਛਾਣਨਯੋਗ ਐਂਕਰ ਬਣਾਉਂਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਫਿਰ ਕਹਿ ਸਕੋ "ਸਮੱਗਰੀ ਦੀ ਸਾਰਣੀ ਬਾਰੇ ਕੰਮ ਨੂੰ ਯਾਦ ਰੱਖੋ" ਅਤੇ ਤਾਂ ਜੋ ਵਿਦਿਆਰਥੀ ਇਸਨੂੰ ਬਿਲਕੁਲ ਯਾਦ ਰੱਖਣ। ਮੇਰੀ ਉਦਾਹਰਣ ਵਿੱਚ, ਮੈਂ ਦੋ ਹੋਰ ਸਭ ਤੋਂ ਆਮ ਗਲਤ ਧਾਰਨਾਵਾਂ ਨੂੰ ਰੋਕਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ। ਅੱਗੇ ਮੈਂ ਉਹਨਾਂ ਬਾਰੇ ਵਿਸਥਾਰ ਨਾਲ ਲਿਖਾਂਗਾ।

ਇਸ ਕਾਰਜ ਵਿੱਚ ਸਾਨੂੰ ਗੁੰਝਲਦਾਰ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀਆਂ ਤਕਨੀਕਾਂ ਨਾਲ ਜਾਣੂ ਕਰਵਾਇਆ ਗਿਆ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਫੈਸਲੇ ਨੂੰ ਮੁੱਢਲਾ ਅਤੇ ਸਰਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਠੀਕ ਹੈ, ਫਿਰ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਸੋਚ ਸਕਦੇ ਹੋ ਕਿ ਇਸ ਹੱਲ ਨੂੰ ਕਿਵੇਂ ਸੁਧਾਰਿਆ ਜਾਵੇ.
Введение
Глава 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 ਅੱਖਰ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਦੂਜੀ ਲਾਈਨ ਵਿੱਚ ਟੀ ਦੇ ਟੁਕੜੇ ਹਨ। ਜੇਕਰ ਕੋਈ ਸੰਖਿਆ ਨਕਾਰਾਤਮਕ ਹੈ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ।

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) ਵਿੱਚ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਦਰਜ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਡਬਲਯੂ = 10
1
2
3
4
5
6
7
8
9

ਡਬਲਯੂ = 100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999

ਜੇ ਇੱਕ ਵਿਦਿਆਰਥੀ ਨੇ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਬਦਲਣ ਦੀ ਤਕਨੀਕ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕੀਤੀ ਹੈ, ਤਾਂ ਉਹ ਬਹੁਤ ਤੇਜ਼ੀ ਨਾਲ ਮੁਕਾਬਲਾ ਕਰੇਗਾ। ਇੱਕ ਸੰਭਾਵੀ ਸਮੱਸਿਆ ਦੁਬਾਰਾ ਵੇਰੀਏਬਲ ਨੂੰ ਰੀਸੈਟ ਕਰਨ ਵਿੱਚ ਹੋਵੇਗੀ। ਜੇਕਰ ਤੁਸੀਂ ਪਰਿਵਰਤਨ ਨੂੰ ਸੰਭਾਲ ਨਹੀਂ ਸਕਦੇ, ਤਾਂ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਕਾਹਲੀ ਵਿੱਚ ਸੀ ਅਤੇ ਤੁਹਾਨੂੰ ਸਰਲ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ. ਚੈਨਲ ਨੂੰ like ਅਤੇ subscribe ਕਰੋ।

ਪੀ.ਐੱਸ. ਜੇਕਰ ਤੁਹਾਨੂੰ ਟੈਕਸਟ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਗਲਤੀਆਂ ਮਿਲਦੀਆਂ ਹਨ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਮੈਨੂੰ ਦੱਸੋ। ਇਹ ਟੈਕਸਟ ਦੇ ਹਿੱਸੇ ਨੂੰ ਚੁਣ ਕੇ ਅਤੇ "Ctrl / ⌘ + Enter" ਦਬਾ ਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ Ctrl / ⌘ ਹੈ, ਜਾਂ ਨਿੱਜੀ ਸੁਨੇਹਿਆਂ ਦੁਆਰਾ। ਜੇਕਰ ਦੋਵੇਂ ਵਿਕਲਪ ਉਪਲਬਧ ਨਹੀਂ ਹਨ, ਤਾਂ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਗਲਤੀਆਂ ਬਾਰੇ ਲਿਖੋ। ਤੁਹਾਡਾ ਧੰਨਵਾਦ!

ਸਿਰਫ਼ ਰਜਿਸਟਰਡ ਉਪਭੋਗਤਾ ਹੀ ਸਰਵੇਖਣ ਵਿੱਚ ਹਿੱਸਾ ਲੈ ਸਕਦੇ ਹਨ। ਸਾਈਨ - ਇਨ, ਤੁਹਾਡਾ ਸੁਆਗਤ ਹੈ.

ਕਰਮ ਤੋਂ ਬਿਨਾਂ ਪਾਠਕਾਂ ਲਈ ਪੋਲ

• 20,0%ਮੈਂ ਪੇਸ਼ੇਵਰ ਤੌਰ 'ਤੇ ਪੜ੍ਹਾਉਂਦਾ ਹਾਂ, +11

• 20,0%ਮੈਂ ਪੇਸ਼ੇਵਰ ਤੌਰ 'ਤੇ ਸਿਖਾਉਂਦਾ ਹਾਂ, -11

• 60,0%ਮੈਂ ਨਹੀਂ ਸਿਖਾਉਂਦਾ, +13

• 0,0%ਮੈਂ ਨਹੀਂ ਸਿਖਾਉਂਦਾ, -10

• 0,0%ਹੋਰ0

5 ਉਪਭੋਗਤਾਵਾਂ ਨੇ ਵੋਟ ਕੀਤਾ। 5 ਉਪਭੋਗਤਾ ਬਚੇ ਹੋਏ ਹਨ।

ਸਰੋਤ: www.habr.com