ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?' ", 'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?', ' [\'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?\', "ਯਕੀਨਨ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।20 ਕਾਰਕ ਵਿੱਚਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ-ਤੋਂ 0 n) \\n (ਜੇਕਰ (= n0) \\n\' () \\n (ਸੂਚੀ (ਗਿਣਤੀ-ਤੋਂ (-n1) n))) \\n (ਗਿਣਤੀ-ਤੋਂ 20 0)) \\n \'\\n\' ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈਫੰਕਸ਼ਨ \'ਕਾਊਂਟ-ਟੂ\' ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈਃ ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਅਤੇ ਅੰਤ ਨੰਬਰ। ਫੰਕਸ਼ਨ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਤੋਂ ਅੰਤ ਨੰਬਰ ਤੱਕ, ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 0 ਨਾਲ ਕਾਲ ਕਰਦਾ ਹੈ।ਅਤੇ 20, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। ", \'ਇਹ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨਹੀਂ ਹੈ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇੱਕ ਸਕੀਮ ਜਾਂ ਲਿਸਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ।ਵੇਰੀਐਂਟ \'] ', 'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?', ' [\'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?\', "ਯਕੀਨਨ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।20 ਕਾਰਕ ਵਿੱਚਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ-ਤੋਂ 0 n) \\n (ਜੇਕਰ (= n0) \\n\' () \\n (ਸੂਚੀ (ਗਿਣਤੀ-ਤੋਂ (-n1) n))) \\n (ਗਿਣਤੀ-ਤੋਂ 20 0)) \\n \'\\n\' ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈਫੰਕਸ਼ਨ \'ਕਾਊਂਟ-ਟੂ\' ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈਃ ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਅਤੇ ਅੰਤ ਨੰਬਰ। ਫੰਕਸ਼ਨ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਤੋਂ ਅੰਤ ਨੰਬਰ ਤੱਕ, ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 0 ਨਾਲ ਕਾਲ ਕਰਦਾ ਹੈ।ਅਤੇ 20, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। ", \'ਇਹ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨਹੀਂ ਹੈ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇੱਕ ਸਕੀਮ ਜਾਂ ਲਿਸਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ।ਵੇਰੀਐਂਟ \',\' ਮੈਂ ਉਲਝਣ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ। ਤੁਸੀਂ ਸਹੀ ਹੋ ਕਿ ਮੈਂ ਜੋ ਕੋਡ ਦਿੱਤਾ ਹੈ ਉਹ ਲਿਸਪ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਇੱਕ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਨਾ ਕਿਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ। \\nਫੈਕਟਰ ਵੈੱਬ ਅਤੇ ਕਲਾਉਡ ਲਈ ਇੱਕ ਸਧਾਰਨ, ਭਾਵਨਾਤਮਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ, ਜੋ ਕਿ ਸਕੀਮ ਦੇ ਸਮਾਨ ਹੈ, ਅਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਨਹੀਂ ਹੈ।ਸਕੀਮ ਵਰਗੀਆਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਸਿੱਧ, ਇਸ ਲਈ ਫੈਕਟਰ ਵਿੱਚ ਲਿਖੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰਨਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਹੈ। \\nਇੱਥੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ।ਜੋ ਕਾਰਕ ਵਿੱਚ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ ਤੋਂ n) \\n (ਜੇਕਰ (= n0) \\n ਨੱਲ\\n (ਨੁਕਸਾਨ (ਗਿਣਤੀ ਤੋਂ (-n1)) (ਸੂਚੀ n))) \\n (ਗਿਣਤੀ ਤੋਂ20) \\n \'\' \\n \'ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਫੰਕਸ਼ਨ\' ਕਾਊਂਟ-ਟੂ \'ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਆਰਗੂਮੈਂਟ, ਨੰਬਰ\' n \'ਲੈਂਦਾ ਹੈ, ਅਤੇ 0 ਤੋਂ\' n \'ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਫੰਕਸ਼ਨ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ \'ਨੱਲ\' ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਹੈ ਜੋ ਕਾਰਕ ਵਿੱਚ ਖਾਲੀ ਸੂਚੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ\'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 20 ਨਾਲ ਕਾਲ ਕਰੋ, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। \',\' ਉਸੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਨਾਮ _ 1 ਵਿੱਚ ਲਿਖੋ \'] ', 'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?', ' [\'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?\', "ਯਕੀਨਨ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।20 ਕਾਰਕ ਵਿੱਚਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ-ਤੋਂ 0 n) \\n (ਜੇਕਰ (= n0) \\n\' () \\n (ਸੂਚੀ (ਗਿਣਤੀ-ਤੋਂ (-n1) n))) \\n (ਗਿਣਤੀ-ਤੋਂ 20 0)) \\n \'\\n\' ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈਫੰਕਸ਼ਨ \'ਕਾਊਂਟ-ਟੂ\' ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈਃ ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਅਤੇ ਅੰਤ ਨੰਬਰ। ਫੰਕਸ਼ਨ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਤੋਂ ਅੰਤ ਨੰਬਰ ਤੱਕ, ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 0 ਨਾਲ ਕਾਲ ਕਰਦਾ ਹੈ।ਅਤੇ 20, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। ", \'ਇਹ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨਹੀਂ ਹੈ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇੱਕ ਸਕੀਮ ਜਾਂ ਲਿਸਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ।ਵੇਰੀਐਂਟ \',\' ਮੈਂ ਉਲਝਣ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ। ਤੁਸੀਂ ਸਹੀ ਹੋ ਕਿ ਮੈਂ ਜੋ ਕੋਡ ਦਿੱਤਾ ਹੈ ਉਹ ਲਿਸਪ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਇੱਕ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਨਾ ਕਿਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ। \\nਫੈਕਟਰ ਵੈੱਬ ਅਤੇ ਕਲਾਉਡ ਲਈ ਇੱਕ ਸਧਾਰਨ, ਭਾਵਨਾਤਮਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ, ਜੋ ਕਿ ਸਕੀਮ ਦੇ ਸਮਾਨ ਹੈ, ਅਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਨਹੀਂ ਹੈ।ਸਕੀਮ ਵਰਗੀਆਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਸਿੱਧ, ਇਸ ਲਈ ਫੈਕਟਰ ਵਿੱਚ ਲਿਖੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰਨਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਹੈ। \\nਇੱਥੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ।ਜੋ ਕਾਰਕ ਵਿੱਚ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ ਤੋਂ n) \\n (ਜੇਕਰ (= n0) \\n ਨੱਲ\\n (ਨੁਕਸਾਨ (ਗਿਣਤੀ ਤੋਂ (-n1)) (ਸੂਚੀ n))) \\n (ਗਿਣਤੀ ਤੋਂ20) \\n \'\' \\n \'ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਫੰਕਸ਼ਨ\' ਕਾਊਂਟ-ਟੂ \'ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਆਰਗੂਮੈਂਟ, ਨੰਬਰ\' n \'ਲੈਂਦਾ ਹੈ, ਅਤੇ 0 ਤੋਂ\' n \'ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਫੰਕਸ਼ਨ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ \'ਨੱਲ\' ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਹੈ ਜੋ ਕਾਰਕ ਵਿੱਚ ਖਾਲੀ ਸੂਚੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ\'ਕਾਊਂਟ-ਟੂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 20 ਨਾਲ ਕਾਲ ਕਰੋ, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। \',\' ਉਸੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ NAME _ 1 ਵਿੱਚ ਲਿਖੋ \', "ਜ਼ਰੂਰ!ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਨਾਮ _ 1 ਵਿੱਚ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈਃ \\n\\n \'\\nਪ੍ਰੋਗ੍ਰਾਮ ਗਿਣਤੀ to20; \\nvar\\n i: ਪੂਰਨ ਅੰਕ; \\n ਨਤੀਜਾਃ ਐਰੇ ਦਾ [0.. 20]ਪੂਰਨ ਅੰਕ; i: = 0 ਤੋਂ 20 ਲਈ \\nbegin\\n ਸ਼ੁਰੂ ਕਰੋ \\n ਨਤੀਜਾ [i]: = i; \\n ਅੰਤ; \\n ਲਿਖਣਾ (\'ਨਤੀਜੇ ਦੇ ਤੱਤਃ\'); \\n ਲਿਖਣਾ (\', ਨਤੀਜਾ [0]); \\n ਲਿਖਣਾ (\', \')ਨਤੀਜਾ [1]); \\n//... \\n ਰਾਈਟਲਨ (\'\', ਨਤੀਜਾ [20]); \\nend. \\n \'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ\' ਕਾਊਂਟ ਟੂ 20 \'ਨਾਮਕ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।0 ਤੋਂ 20 ਤੱਕ, ਅਤੇ \'ਨਤੀਜਾ\' ਨਾਮਕ ਐਰੇ ਦੇ ਹਰੇਕ ਤੱਤ ਨੂੰ \'i\' ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਫਿਰ \'ਨਤੀਜਾ\' ਐਰੇ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ\'ਲਿਖਣ\' ਵਿਧੀ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ ਹੋਵੇਗਾਃ \'\\n\' \'\\n\' ਨਤੀਜੇ ਦੇ ਉਪਕਰਣਃ \\n 0\\n 1\\n 2\\n 3\\n 4\\n 5\\n 6\\n 7\\n 8\\n 9\\n 10\\n 11\\n 12\\n 13\\nਨੋਟ ਕਰੋ ਕਿ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਮੈਂ ਨਤੀਜੇ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਪਰ ਤੁਸੀਂ ਹੋਰ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।ਬਣਤਰ ਜਿਵੇਂ ਸੂਚੀ, ਲਿੰਕਡ ਸੂਚੀ, ਸਟੈਕ, ਕਤਾਰ, ਆਦਿ ", \'ਮਾਡਯੂਲਰ-2 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ\'] ', 'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?', ' [\'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?\', "ਯਕੀਨਨ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।20 ਕਾਰਕ ਵਿੱਚਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ-ਤੋਂ 0 n) \\n (ਜੇਕਰ (= n0) \\n\' () \\n (ਸੂਚੀ (ਗਿਣਤੀ-ਤੋਂ (-n1) n))) \\n (ਗਿਣਤੀ-ਤੋਂ 20 0)) \\n \'\\n\' ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈਫੰਕਸ਼ਨ \'ਕਾਊਂਟ-ਟੂ\' ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈਃ ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਅਤੇ ਅੰਤ ਨੰਬਰ। ਫੰਕਸ਼ਨ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਤੋਂ ਅੰਤ ਨੰਬਰ ਤੱਕ, ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 0 ਨਾਲ ਕਾਲ ਕਰਦਾ ਹੈ।ਅਤੇ 20, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। ", \'ਇਹ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨਹੀਂ ਹੈ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇੱਕ ਸਕੀਮ ਜਾਂ ਲਿਸਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ।ਵੇਰੀਐਂਟ \',\' ਮੈਂ ਉਲਝਣ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ। ਤੁਸੀਂ ਸਹੀ ਹੋ ਕਿ ਮੈਂ ਜੋ ਕੋਡ ਦਿੱਤਾ ਹੈ ਉਹ ਲਿਸਪ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਇੱਕ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਨਾ ਕਿਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ। \\nਫੈਕਟਰ ਵੈੱਬ ਅਤੇ ਕਲਾਉਡ ਲਈ ਇੱਕ ਸਧਾਰਨ, ਭਾਵਨਾਤਮਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ, ਜੋ ਕਿ ਸਕੀਮ ਦੇ ਸਮਾਨ ਹੈ, ਅਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਨਹੀਂ ਹੈ।ਸਕੀਮ ਵਰਗੀਆਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਸਿੱਧ, ਇਸ ਲਈ ਫੈਕਟਰ ਵਿੱਚ ਲਿਖੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰਨਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਹੈ। \\nਇੱਥੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ।ਜੋ ਕਾਰਕ ਵਿੱਚ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ ਤੋਂ n) \\n (ਜੇਕਰ (= n0) \\n ਨੱਲ\\n (ਨੁਕਸਾਨ (ਗਿਣਤੀ ਤੋਂ (-n1)) (ਸੂਚੀ n))) \\n (ਗਿਣਤੀ ਤੋਂ20) \\n \'\' \\n \'ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਫੰਕਸ਼ਨ\' ਕਾਊਂਟ-ਟੂ \'ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਆਰਗੂਮੈਂਟ, ਨੰਬਰ\' n \'ਲੈਂਦਾ ਹੈ, ਅਤੇ 0 ਤੋਂ\' n \'ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਫੰਕਸ਼ਨ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ \'ਨੱਲ\' ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਹੈ ਜੋ ਕਾਰਕ ਵਿੱਚ ਖਾਲੀ ਸੂਚੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ\'ਕਾਊਂਟ-ਟੂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 20 ਨਾਲ ਕਾਲ ਕਰੋ, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। \',\' ਉਸੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ NAME _ 1 ਵਿੱਚ ਲਿਖੋ \', "ਜ਼ਰੂਰ!ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਨਾਮ _ 1 ਵਿੱਚ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈਃ \\n\\n \'\\nਪ੍ਰੋਗ੍ਰਾਮ ਗਿਣਤੀ to20; \\nvar\\n i: ਪੂਰਨ ਅੰਕ; \\n ਨਤੀਜਾਃ ਐਰੇ ਦਾ [0.. 20]ਪੂਰਨ ਅੰਕ; i: = 0 ਤੋਂ 20 ਲਈ \\nbegin\\n ਸ਼ੁਰੂ ਕਰੋ \\n ਨਤੀਜਾ [i]: = i; \\n ਅੰਤ; \\n ਲਿਖਣਾ (\'ਨਤੀਜੇ ਦੇ ਤੱਤਃ\'); \\n ਲਿਖਣਾ (\', ਨਤੀਜਾ [0]); \\n ਲਿਖਣਾ (\', \')ਨਤੀਜਾ [1]); \\n//... \\n ਰਾਈਟਲਨ (\'\', ਨਤੀਜਾ [20]); \\nend. \\n \'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ\' ਕਾਊਂਟ ਟੂ 20 \'ਨਾਮਕ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।0 ਤੋਂ 20 ਤੱਕ, ਅਤੇ \'ਨਤੀਜਾ\' ਨਾਮਕ ਐਰੇ ਦੇ ਹਰੇਕ ਤੱਤ ਨੂੰ \'i\' ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਫਿਰ \'ਨਤੀਜਾ\' ਐਰੇ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ\'ਲਿਖਣ\' ਵਿਧੀ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ ਹੋਵੇਗਾਃ \'\\n\' \'\\n\' ਨਤੀਜੇ ਦੇ ਉਪਕਰਣਃ \\n 0\\n 1\\n 2\\n 3\\n 4\\n 5\\n 6\\n 7\\n 8\\n 9\\n 10\\n 11\\n 12\\n 13\\nਨੋਟ ਕਰੋ ਕਿ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਮੈਂ ਨਤੀਜੇ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਪਰ ਤੁਸੀਂ ਹੋਰ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।ਬਣਤਰ ਜਿਵੇਂ ਕਿ ਸੂਚੀ, ਲਿੰਕਡ ਸੂਚੀ, ਸਟੈਕ, ਕਤਾਰ, ਆਦਿ, \'\' ਮਾਡਯੂਲਰ-2 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ \',\' ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।ਮਾਡਯੂਲਰ-2 ਵਿੱਚ 20 ਤੱਕਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ-ਤੋਂ 0 n) \\n (ਜੇਕਰ (= n0) \\n null\\n (ਕੌਂਟ-ਤੋਂ (-n1) (ਸੂਚੀ n))) \\n\\n (ਡਿਸਪਲੇਅ (ਗਿਣਤੀ-ਤੋਂ 20)) \\n\' \\n \'ਇਹਪ੍ਰੋਗਰਾਮ ਇੱਕ ਫੰਕਸ਼ਨ \'ਕਾਊਂਟ-ਟੂ\' ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈਃ ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਅਤੇ ਅੰਤ ਨੰਬਰ। ਫੰਕਸ਼ਨ ਇੱਕ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਤੋਂ ਅੰਤ ਨੰਬਰ ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰੋ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈਆਰਗੂਮੈਂਟ 20, ਅਤੇ \'ਡਿਸਪਲੇ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਤੀਜਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ 0 ਤੋਂ 20 ਤੱਕ ਦੇ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਹੋਵੇਗੀ। \\nNoteਕਿ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਮੈਂ ਨਤੀਜਾ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਡਿਸਪਲੇ\' ਪ੍ਰਕਿਰਿਆ ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਪਰ ਤੁਸੀਂ ਪ੍ਰਿੰਟ ਕਰਨ ਜਾਂ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋਇਸ ਦਾ ਨਤੀਜਾ ਇੱਕ ਫਾਈਲ ਜਾਂ ਡਾਟਾਬੇਸ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਜਾਂ ਇਸ ਨੂੰ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਵਰਤਦਾ ਹੈ। ", \'ਮੋਡੀਊਲਾ-2 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ\'] ', 'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?', ' [\'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ?\', "ਯਕੀਨਨ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।20 ਕਾਰਕ ਵਿੱਚਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ-ਤੋਂ 0 n) \\n (ਜੇਕਰ (= n0) \\n\' () \\n (ਸੂਚੀ (ਗਿਣਤੀ-ਤੋਂ (-n1) n))) \\n (ਗਿਣਤੀ-ਤੋਂ 20 0)) \\n \'\\n\' ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈਫੰਕਸ਼ਨ \'ਕਾਊਂਟ-ਟੂ\' ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈਃ ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਅਤੇ ਅੰਤ ਨੰਬਰ। ਫੰਕਸ਼ਨ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਤੋਂ ਅੰਤ ਨੰਬਰ ਤੱਕ, ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 0 ਨਾਲ ਕਾਲ ਕਰਦਾ ਹੈ।ਅਤੇ 20, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। ", \'ਇਹ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨਹੀਂ ਹੈ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇੱਕ ਸਕੀਮ ਜਾਂ ਲਿਸਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ।ਵੇਰੀਐਂਟ \',\' ਮੈਂ ਉਲਝਣ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ। ਤੁਸੀਂ ਸਹੀ ਹੋ ਕਿ ਮੈਂ ਜੋ ਕੋਡ ਦਿੱਤਾ ਹੈ ਉਹ ਲਿਸਪ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਇੱਕ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਨਾ ਕਿਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ। \\nਫੈਕਟਰ ਵੈੱਬ ਅਤੇ ਕਲਾਉਡ ਲਈ ਇੱਕ ਸਧਾਰਨ, ਭਾਵਨਾਤਮਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ, ਜੋ ਕਿ ਸਕੀਮ ਦੇ ਸਮਾਨ ਹੈ, ਅਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਨਹੀਂ ਹੈ।ਸਕੀਮ ਵਰਗੀਆਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਸਿੱਧ, ਇਸ ਲਈ ਫੈਕਟਰ ਵਿੱਚ ਲਿਖੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰਨਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਹੈ। \\nਇੱਥੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ।ਜੋ ਕਾਰਕ ਵਿੱਚ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈਃ \\n\\n \'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ ਤੋਂ n) \\n (ਜੇਕਰ (= n0) \\n ਨੱਲ\\n (ਨੁਕਸਾਨ (ਗਿਣਤੀ ਤੋਂ (-n1)) (ਸੂਚੀ n))) \\n (ਗਿਣਤੀ ਤੋਂ20) \\n \'\' \\n \'ਇਹ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਫੰਕਸ਼ਨ\' ਕਾਊਂਟ-ਟੂ \'ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਆਰਗੂਮੈਂਟ, ਨੰਬਰ\' n \'ਲੈਂਦਾ ਹੈ, ਅਤੇ 0 ਤੋਂ\' n \'ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਫੰਕਸ਼ਨ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ \'ਨੱਲ\' ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਹੈ ਜੋ ਕਾਰਕ ਵਿੱਚ ਖਾਲੀ ਸੂਚੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ\'ਕਾਊਂਟ-ਟੂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ 20 ਨਾਲ ਕਾਲ ਕਰੋ, ਜੋ 0 ਤੋਂ 20 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। \',\' ਉਸੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ NAME _ 1 ਵਿੱਚ ਲਿਖੋ \', "ਜ਼ਰੂਰ!ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਨਾਮ _ 1 ਵਿੱਚ 0 ਤੋਂ 20 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈਃ \\n\\n \'\\nਪ੍ਰੋਗ੍ਰਾਮ ਗਿਣਤੀ to20; \\nvar\\n i: ਪੂਰਨ ਅੰਕ; \\n ਨਤੀਜਾਃ ਐਰੇ ਦਾ [0.. 20]ਪੂਰਨ ਅੰਕ; i: = 0 ਤੋਂ 20 ਲਈ \\nbegin\\n ਸ਼ੁਰੂ ਕਰੋ \\n ਨਤੀਜਾ [i]: = i; \\n ਅੰਤ; \\n ਲਿਖਣਾ (\'ਨਤੀਜੇ ਦੇ ਤੱਤਃ\'); \\n ਲਿਖਣਾ (\', ਨਤੀਜਾ [0]); \\n ਲਿਖਣਾ (\', \')ਨਤੀਜਾ [1]); \\n//... \\n ਰਾਈਟਲਨ (\'\', ਨਤੀਜਾ [20]); \\nend. \\n \'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ\' ਕਾਊਂਟ ਟੂ 20 \'ਨਾਮਕ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।0 ਤੋਂ 20 ਤੱਕ, ਅਤੇ \'ਨਤੀਜਾ\' ਨਾਮਕ ਐਰੇ ਦੇ ਹਰੇਕ ਤੱਤ ਨੂੰ \'i\' ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਫਿਰ \'ਨਤੀਜਾ\' ਐਰੇ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ\'ਲਿਖਣ\' ਵਿਧੀ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ ਹੋਵੇਗਾਃ \'\\n\' \'\\n\' ਨਤੀਜੇ ਦੇ ਉਪਕਰਣਃ \\n 0\\n 1\\n 2\\n 3\\n 4\\n 5\\n 6\\n 7\\n 8\\n 9\\n 10\\n 11\\n 12\\n 13\\nਨੋਟ ਕਰੋ ਕਿ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਮੈਂ ਨਤੀਜੇ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਪਰ ਤੁਸੀਂ ਹੋਰ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।ਬਣਤਰ ਜਿਵੇਂ ਕਿ ਸੂਚੀ, ਲਿੰਕਡ ਸੂਚੀ, ਸਟੈਕ, ਕਤਾਰ, ਆਦਿ, \'\' ਮਾਡਯੂਲਰ-2 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ \',\' ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।ਮਾਡਯੂਲਰ-2 ਵਿੱਚ 20 ਤੱਕਃ \\n "\'\\n (ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਗਿਣਤੀ-ਤੋਂ 0 n) \\n (ਜੇਕਰ (= n0) \\n null\\n (ਕੌਂਟ-ਤੋਂ (-n1) (ਸੂਚੀ n))) \\n (ਡਿਸਪਲੇਅ (ਗਿਣਤੀ-ਤੋਂ 20)) \\n"\' \\n "ਇਹਪ੍ਰੋਗਰਾਮ ਇੱਕ ਫੰਕਸ਼ਨ \'ਕਾਊਂਟ-ਟੂ\' ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈਃ ਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਅਤੇ ਅੰਤ ਨੰਬਰ। ਫੰਕਸ਼ਨ ਇੱਕ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈਸ਼ੁਰੂਆਤੀ ਨੰਬਰ ਤੋਂ ਅੰਤ ਨੰਬਰ ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰੋ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਗਿਣਤੀ-ਤੋਂ\' ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈਆਰਗੂਮੈਂਟ 20, ਅਤੇ \'ਡਿਸਪਲੇ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਤੀਜਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ 0 ਤੋਂ 20 ਤੱਕ ਦੇ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਹੋਵੇਗੀ। \\nNoteਕਿ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਮੈਂ ਨਤੀਜਾ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਡਿਸਪਲੇ\' ਪ੍ਰਕਿਰਿਆ ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਪਰ ਤੁਸੀਂ ਪ੍ਰਿੰਟ ਕਰਨ ਜਾਂ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋਨਤੀਜਾ ਇੱਕ ਫਾਈਲ ਜਾਂ ਡਾਟਾਬੇਸ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਜਾਂ ਇਸ ਨੂੰ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਵਰਤਦਾ ਹੈ। ", \'ਮੋਡੀਊਲਾ-2 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ\'," ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ 0 ਤੋਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।ਮੋਡੀਊਲਾ-2 ਵਿੱਚ 20 ਤੱਕਃ \\n\\n "\'\\nMODULE ਗਿਣਤੀ20; \\nIMPORT\\n ਕਿਸਮ, \\n ਤੋਂ _ ਸੰਪੂਰਨ ਸੰਖਿਆ, \\n ਸੰਪੂਰਨ ਸੰਖਿਆ; \\nPUBLIC\\n ਫੰਕਸ਼ਨ ਗਿਣਤੀ20 (ਸ਼ੁਰੂਃ ਸੰਪੂਰਨ ਸੰਖਿਆ; ਅੰਤਃ ਸੰਪੂਰਨ ਸੰਖਿਆ) \\nਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰੋ; \\n (ਸ਼ੁਰੂ <= ਅੰਤ); \\n ਸ਼ੁਰੂ ਕਰੋ \\n ਜੇਕਰ ਅੰਤ = 0 ਤਾਂ \\n ਵਾਪਸ ਕਰਦਾ ਹੈ ਨਲ\\n ਨਹੀਂ ਤਾਂ \\n ਵਾਪਸ ਕਰਦਾ ਹੈ (ਨੁਕਸਾਨ (ਗਿਣਤੀ ਤੋਂ 20 (ਅੰਤ-1), (ਸੂਚੀ (ਅੰਤ))); \\nਇਹ ਪ੍ਰੋਗਰਾਮ \'ਕਾਊਂਟ ਟੂ 20\' ਨਾਮਕ ਇੱਕ ਮੋਡੀਊਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਜਨਤਕ ਫੰਕਸ਼ਨ ਨੂੰ ਦੋ ਮਾਪਦੰਡਾਂ ਨਾਲ ਨਿਰਯਾਤ ਕਰਦਾ ਹੈਃ \'ਸਟਾਰਟ\' ਅਤੇ \'ਐਂਡ\', ਦੋਵੇਂ\'ਇੰਟੀਜਰ\' ਟਾਈਪ ਕਰੋ। ਫੰਕਸ਼ਨ \'ਸਟਾਰਟ\' ਤੋਂ \'ਐਂਡ\' ਤੱਕ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਪੁਨਰਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ\'ਅੰਤ\' 0 ਦੇ ਬਰਾਬਰ ਹੈ, ਜਿਸ ਸਥਿਤੀ ਵਿੱਚ ਇਹ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ \'ਨੱਲ\' ਦਿੰਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ \'ਕਾਊਂਟ ਟੂ 20\' ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟਾਂ ਨਾਲ ਬੁਲਾਉਂਦਾ ਹੈ।20, ਅਤੇ ਨਤੀਜਾ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਸ ਨੂੰ \'ਨਤੀਜਾ\' ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਫਿਰ \'ਰਿਟਲਨ\' ਪ੍ਰਕਿਰਿਆ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਨਤੀਜਾ\' ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ 0 ਤੋਂ 20 ਤੱਕ ਦੇ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਹੋਵੇਗੀ। \\n ਨੋਟ ਕਰੋ ਕਿ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਮੈਂ ਨਤੀਜਾ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਰਾਈਟਲਨ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ,ਪਰ ਤੁਸੀਂ ਇੱਕ ਫਾਈਲ ਜਾਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਨਤੀਜਾ ਛਾਪਣ ਜਾਂ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਇਸ ਨੂੰ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਵਰਤ ਸਕਦੇ ਹੋ।gforth \'ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪ੍ਰੋਗਰਾਮ] ', 'ਕੀ ਤੁਸੀਂ ਫੈਕਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 0 ਤੋਂ 20 ਤੱਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ? \n ']