ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?'] ", 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?', ' [\'ਹੈਲੋ, ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?\', "ਮੈਂ ਸਿਰਫ਼ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਹਾਂ, ਇਸ ਲਈ ਮੇਰੇ ਕੋਲ ਭਾਵਨਾਵਾਂ ਜਾਂ ਭਾਵਨਾਵਾਂ ਨਹੀਂ ਹਨ। ਮੈਂ ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਉੱਤਰ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਹਾਂ।ਮੈਂ ਆਪਣੀ ਪੂਰੀ ਸਮਰੱਥਾ ਨਾਲ ਅੱਜ ਤੁਹਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ? ", \'ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਹੈਲੋ ਸੰਸਾਰ ਲਿਖ ਸਕਦੇ ਹੋ?\' ', 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?', ' [\'ਹੈਲੋ, ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?\', "ਮੈਂ ਸਿਰਫ਼ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਹਾਂ, ਇਸ ਲਈ ਮੇਰੇ ਕੋਲ ਭਾਵਨਾਵਾਂ ਜਾਂ ਭਾਵਨਾਵਾਂ ਨਹੀਂ ਹਨ। ਮੈਂ ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਉੱਤਰ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਹਾਂ।ਮੈਂ ਆਪਣੀ ਸਮਰੱਥਾ ਅਨੁਸਾਰ ਅੱਜ ਤੁਹਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ?, \'ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਹੈਲੋ ਵਰਲਡ ਲਿਖ ਸਕਦੇ ਹੋ?\', \'ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ "ਹੈਲੋ, ਵਰਲਡ!" ਪ੍ਰੋਗਰਾਮ ਹੈ।C: \\n\\n "\'\\n#include <stdio.h> \\n\\nint ਮੈਨ () {\\n ਪ੍ਰਿੰਟਫ (" ਹੈਲੋ, ਵਰਲਡ!\\\\n "); \\n ਰਿਟਰਨ 0; \\n} \\n\\n"\' \\n\\n ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ \'stdio.h\' ਹੈਡਰ ਫਾਈਲ ਸ਼ਾਮਲ ਹੈ,ਜੋ ਤੁਹਾਨੂੰ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਪ੍ਰਿੰਟਐੱਫ ()\' ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। \'ਮੁੱਖ ()\' ਫੰਕਸ਼ਨ ਪ੍ਰੋਗਰਾਮ ਦਾ ਪ੍ਰਵੇਸ਼ ਬਿੰਦੂ ਹੈ, ਅਤੇ\'ਪ੍ਰਿੰਟ ਐੱਫ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਗ੍ਰੀਟਿੰਗ ਨੂੰ ਸਕ੍ਰੀਨ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \',\' ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਸਟੈਡਿਨ ਤੋਂ ਇਨਪੁਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਇਸ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ?ਵੱਡੇ ਅੱਖਰ? \'] ', 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?', ' [\'ਹੈਲੋ, ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?\', "ਮੈਂ ਸਿਰਫ਼ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਹਾਂ, ਇਸ ਲਈ ਮੇਰੇ ਕੋਲ ਭਾਵਨਾਵਾਂ ਜਾਂ ਭਾਵਨਾਵਾਂ ਨਹੀਂ ਹਨ। ਮੈਂ ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਉੱਤਰ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਹਾਂ।ਮੈਂ ਆਪਣੀ ਸਮਰੱਥਾ ਅਨੁਸਾਰ ਅੱਜ ਤੁਹਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ?, \'ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਹੈਲੋ ਵਰਲਡ ਲਿਖ ਸਕਦੇ ਹੋ?\', \'ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ "ਹੈਲੋ, ਵਰਲਡ!" ਪ੍ਰੋਗਰਾਮ ਹੈ।C: \\n\\n "\'\\n#include <stdio.h> \\n\\nint ਮੈਨ () {\\n ਪ੍ਰਿੰਟਫ (" ਹੈਲੋ, ਵਰਲਡ!\\\\n "); \\n ਰਿਟਰਨ 0; \\n} \\n\\n"\' \\n\\n ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ \'stdio.h\' ਹੈਡਰ ਫਾਈਲ ਸ਼ਾਮਲ ਹੈ,ਜੋ ਤੁਹਾਨੂੰ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਪ੍ਰਿੰਟਐੱਫ ()\' ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। \'ਮੁੱਖ ()\' ਫੰਕਸ਼ਨ ਪ੍ਰੋਗਰਾਮ ਦਾ ਪ੍ਰਵੇਸ਼ ਬਿੰਦੂ ਹੈ, ਅਤੇ\'ਪ੍ਰਿੰਟ ਐੱਫ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਗ੍ਰੀਟਿੰਗ ਨੂੰ ਸਕ੍ਰੀਨ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \',\' ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਸਟੈਡਿਨ ਤੋਂ ਇਨਪੁਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਇਸ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ?ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ? \',\' ਜ਼ਰੂਰ! ਇੱਥੇ C ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ (stdin) ਤੋਂ ਇੰਪੁੱਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈਃ \\n\\n \'\\n#include<stdio.h>\\n#include <ctype.h> \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\n ਜਦੋਂ ਕਿ (c = ਗੇਟਚਰ ()! = EOF) {\\n ਜੇਕਰ (ਇਸਾਲਫਾ (c)) {\\n ਪੁਟਚਰ (ਟਾਪਰ (c)); \\n} \\n ਰਿਟਰਨ0; \\n} \\n\\n "\'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਨੂੰ ਪਡ਼੍ਹਨ ਲਈ\' ਗੇਟਚਰ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ\' ਇਸਾਲਫ਼ਾ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਕਿ ਕੀਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ। ਜੇਕਰ ਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਸਟੈਂਡਰਡ ਵਿੱਚ ਛਾਪਣ ਤੋਂ ਪਹਿਲਾਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।\'ਪੁੱਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਉਟਪੁੱਟ। \',\' ਇਸ ਲਈ, ਜੇ ਮੈਂ ਲਿਖਦਾ ਹਾਂ "ਹੈਲੋ ਉੱਥੇ, ਨੰਬਰ 4!" ਤਾਂ ਆਉਟਪੁੱਟ ਕੀ ਹੋਵੇਗਾ? \' ', 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?', ' [\'ਹੈਲੋ, ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?\', "ਮੈਂ ਸਿਰਫ਼ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਹਾਂ, ਇਸ ਲਈ ਮੇਰੇ ਕੋਲ ਭਾਵਨਾਵਾਂ ਜਾਂ ਭਾਵਨਾਵਾਂ ਨਹੀਂ ਹਨ। ਮੈਂ ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਉੱਤਰ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਹਾਂ।ਮੈਂ ਆਪਣੀ ਸਮਰੱਥਾ ਅਨੁਸਾਰ ਅੱਜ ਤੁਹਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ?, \'ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਹੈਲੋ ਵਰਲਡ ਲਿਖ ਸਕਦੇ ਹੋ?\', \'ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ "ਹੈਲੋ, ਵਰਲਡ!" ਪ੍ਰੋਗਰਾਮ ਹੈ।C: \\n\\n "\'\\n#include <stdio.h> \\n\\nint ਮੈਨ () {\\n ਪ੍ਰਿੰਟਫ (" ਹੈਲੋ, ਵਰਲਡ!\\\\n "); \\n ਰਿਟਰਨ 0; \\n} \\n\\n"\' \\n\\n ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ \'stdio.h\' ਹੈਡਰ ਫਾਈਲ ਸ਼ਾਮਲ ਹੈ,ਜੋ ਤੁਹਾਨੂੰ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਪ੍ਰਿੰਟਐੱਫ ()\' ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। \'ਮੁੱਖ ()\' ਫੰਕਸ਼ਨ ਪ੍ਰੋਗਰਾਮ ਦਾ ਪ੍ਰਵੇਸ਼ ਬਿੰਦੂ ਹੈ, ਅਤੇ\'ਪ੍ਰਿੰਟ ਐੱਫ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਗ੍ਰੀਟਿੰਗ ਨੂੰ ਸਕ੍ਰੀਨ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \',\' ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਸਟੈਡਿਨ ਤੋਂ ਇਨਪੁਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਇਸ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ?ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ? \',\' ਜ਼ਰੂਰ! ਇੱਥੇ C ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ (stdin) ਤੋਂ ਇੰਪੁੱਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈਃ \\n\\n \'\\n#include<stdio.h>\\n#include <ctype.h> \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\n ਜਦੋਂ ਕਿ (c = ਗੇਟਚਰ ()! = EOF) {\\n ਜੇਕਰ (ਇਸਾਲਫਾ (c)) {\\n ਪੁਟਚਰ (ਟਾਪਰ (c)); \\n} \\n ਰਿਟਰਨ0; \\n} \\n\\n "\'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਨੂੰ ਪਡ਼੍ਹਨ ਲਈ\' ਗੇਟਚਰ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ\' ਇਸਾਲਫ਼ਾ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਕਿ ਕੀਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ। ਜੇਕਰ ਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਸਟੈਂਡਰਡ ਵਿੱਚ ਛਾਪਣ ਤੋਂ ਪਹਿਲਾਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।\'ਪੁੱਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਉਟਪੁੱਟ। \',\' ਇਸ ਲਈ, ਜੇ ਮੈਂ ਲਿਖਦਾ ਹਾਂ "ਹੈਲੋ ਉੱਥੇ, ਨੰਬਰ 4!" ਤਾਂ ਆਉਟਪੁੱਟ ਕੀ ਹੋਵੇਗਾ? \',\' ਜੇ ਤੁਸੀਂ ਉੱਥੇ ਹੈਲੋ ਲਿਖਦੇ ਹੋ, \'ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ, ਆਉਟਪੁੱਟ "ਹੈਲੋ ਦੇਅਰ, ਨੰਬਰ 4!" ਹੋਵੇਗਾ। \\n\\n ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਪਡ਼੍ਹਦਾ ਹੈ ਅਤੇਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਜੇਕਰ ਇਹ ਇੱਕ ਅੱਖਰ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਇੰਪੁੱਟ "h" ਨੂੰ "H" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, "e" ਨੂੰ "E" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਆਦਿ।ਅੱਖਰ "ਈ" ਅਤੇ "ਐਲ" ਨੂੰ ਦੋ ਵਾਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।ਹੈਰਾਨ ਕਰਨ ਵਾਲਾ ਨਿਸ਼ਾਨ? \'] ', 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?', ' [\'ਹੈਲੋ, ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?\', "ਮੈਂ ਸਿਰਫ਼ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਹਾਂ, ਇਸ ਲਈ ਮੇਰੇ ਕੋਲ ਭਾਵਨਾਵਾਂ ਜਾਂ ਭਾਵਨਾਵਾਂ ਨਹੀਂ ਹਨ। ਮੈਂ ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਉੱਤਰ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਹਾਂ।ਮੈਂ ਆਪਣੀ ਸਮਰੱਥਾ ਅਨੁਸਾਰ ਅੱਜ ਤੁਹਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ?, \'ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਹੈਲੋ ਵਰਲਡ ਲਿਖ ਸਕਦੇ ਹੋ?\', \'ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ "ਹੈਲੋ, ਵਰਲਡ!" ਪ੍ਰੋਗਰਾਮ ਹੈ।C: \\n\\n "\'\\n#include <stdio.h> \\n\\nint ਮੈਨ () {\\n ਪ੍ਰਿੰਟਫ (" ਹੈਲੋ, ਵਰਲਡ!\\\\n "); \\n ਰਿਟਰਨ 0; \\n} \\n\\n"\' \\n\\n ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ \'stdio.h\' ਹੈਡਰ ਫਾਈਲ ਸ਼ਾਮਲ ਹੈ,ਜੋ ਤੁਹਾਨੂੰ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਪ੍ਰਿੰਟਐੱਫ ()\' ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। \'ਮੁੱਖ ()\' ਫੰਕਸ਼ਨ ਪ੍ਰੋਗਰਾਮ ਦਾ ਪ੍ਰਵੇਸ਼ ਬਿੰਦੂ ਹੈ, ਅਤੇ\'ਪ੍ਰਿੰਟ ਐੱਫ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਗ੍ਰੀਟਿੰਗ ਨੂੰ ਸਕ੍ਰੀਨ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \',\' ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਸਟੈਡਿਨ ਤੋਂ ਇਨਪੁਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਇਸ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ?ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ? \',\' ਜ਼ਰੂਰ! ਇੱਥੇ C ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ (stdin) ਤੋਂ ਇੰਪੁੱਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈਃ \\n\\n \'\\n#include<stdio.h>\\n#include <ctype.h> \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\n ਜਦੋਂ ਕਿ (c = ਗੇਟਚਰ ()! = EOF) {\\n ਜੇਕਰ (ਇਸਾਲਫਾ (c)) {\\n ਪੁਟਚਰ (ਟਾਪਰ (c)); \\n} \\n ਰਿਟਰਨ0; \\n} \\n\\n "\'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਨੂੰ ਪਡ਼੍ਹਨ ਲਈ\' ਗੇਟਚਰ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ\' ਇਸਾਲਫ਼ਾ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਕਿ ਕੀਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ। ਜੇਕਰ ਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਸਟੈਂਡਰਡ ਵਿੱਚ ਛਾਪਣ ਤੋਂ ਪਹਿਲਾਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।\'ਪੁੱਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਉਟਪੁੱਟ। \',\' ਇਸ ਲਈ, ਜੇ ਮੈਂ ਲਿਖਦਾ ਹਾਂ "ਹੈਲੋ ਉੱਥੇ, ਨੰਬਰ 4!" ਤਾਂ ਆਉਟਪੁੱਟ ਕੀ ਹੋਵੇਗਾ? \',\' ਜੇ ਤੁਸੀਂ ਉੱਥੇ ਹੈਲੋ ਲਿਖਦੇ ਹੋ, \'ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ, ਆਉਟਪੁੱਟ "ਹੈਲੋ ਦੇਅਰ, ਨੰਬਰ 4!" ਹੋਵੇਗਾ। \\n\\n ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਪਡ਼੍ਹਦਾ ਹੈ ਅਤੇਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਜੇਕਰ ਇਹ ਇੱਕ ਅੱਖਰ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਇੰਪੁੱਟ "h" ਨੂੰ "H" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, "e" ਨੂੰ "E" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਆਦਿ।ਅੱਖਰ "ਈ" ਅਤੇ "ਐਲ" ਨੂੰ ਦੋ ਵਾਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।\',\' ਜੇਕਰ ਤੁਸੀਂ "4" ਲਿਖਦੇ ਹੋ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਹੈਰਾਨੀ ਚਿੰਨ੍ਹ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਆਉਟਪੁੱਟ "4!" ਹੋਵੇਗਾ।ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ, ਇਸ ਲਈ ਇਹ "4" ਨੂੰ ਪਡ਼੍ਹੇਗਾ ਅਤੇ ਫਿਰ ਅਗਲੇ ਅੱਖਰ ਵੱਲ ਵਧੇਗਾ, ਜੋ ਕਿ ਹੈਰਾਨੀ ਦਾ ਨਿਸ਼ਾਨ ਹੈ।ਹੈਰਾਨੀ ਚਿੰਨ੍ਹ ਇੱਕ ਅੱਖਰ ਨਹੀਂ ਹੈ, ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਨਹੀਂ ਬਦਲਿਆ ਜਾਵੇਗਾ। \\n\\nਯਦਿ ਤੁਸੀਂ ਇਨਪੁਟ ਦੇ ਰੂਪ ਵਿੱਚ "ਹੈਲੋ, ਨੰਬਰ 4!" ਲਿਖਣਾ ਸੀ, ਤਾਂ ਆਉਟਪੁੱਟ"ਹੈਲੋ ਦੇਅਰ, ਨੰਬਰ 4!" ਹੋਵੇਗਾ। "ਈ" ਅਤੇ "ਐਲ" ਅੱਖਰਾਂ ਨੂੰ ਦੋ ਵਾਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ \'ਟੌਪਰ ()\' ਦੁਆਰਾ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।ਫੰਕਸ਼ਨ। ਨੰਬਰ "4" ਅਤੇ "4" ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਨਹੀਂ ਬਦਲਿਆ ਜਾਵੇਗਾ। "", ਠੀਕ ਹੈ, ਪਰ ਅਸੀਂ ਸਿਰਫ \'ਪੁਟਚਰ\' ਨੂੰ ਕਾਲ ਕਰ ਰਹੇ ਹਾਂ ਜਦੋਂ ਅੱਖਰ \'ਇਸਾਲਫ਼ਾ\' ਹੋਵੇ।ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਗੈਰ-ਵਰਣਮਾਲਾ ਅੱਖਰ, ਜਿਵੇਂ ਕਿ 4 ਅਤੇ! ਬਿਲਕੁਲ ਨਹੀਂ ਛਾਪੇ ਜਾਣਗੇ? ', 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?', ' [\'ਹੈਲੋ, ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?\', "ਮੈਂ ਸਿਰਫ਼ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਹਾਂ, ਇਸ ਲਈ ਮੇਰੇ ਕੋਲ ਭਾਵਨਾਵਾਂ ਜਾਂ ਭਾਵਨਾਵਾਂ ਨਹੀਂ ਹਨ। ਮੈਂ ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਉੱਤਰ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਹਾਂ।ਮੈਂ ਆਪਣੀ ਸਮਰੱਥਾ ਅਨੁਸਾਰ ਅੱਜ ਤੁਹਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ?, \'ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਹੈਲੋ ਵਰਲਡ ਲਿਖ ਸਕਦੇ ਹੋ?\', \'ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ "ਹੈਲੋ, ਵਰਲਡ!" ਪ੍ਰੋਗਰਾਮ ਹੈ।C: \\n\\n "\'\\n#include <stdio.h> \\n\\nint ਮੈਨ () {\\n ਪ੍ਰਿੰਟਫ (" ਹੈਲੋ, ਵਰਲਡ!\\\\n "); \\n ਰਿਟਰਨ 0; \\n} \\n\\n"\' \\n\\n ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ \'stdio.h\' ਹੈਡਰ ਫਾਈਲ ਸ਼ਾਮਲ ਹੈ,ਜੋ ਤੁਹਾਨੂੰ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਪ੍ਰਿੰਟਐੱਫ ()\' ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। \'ਮੁੱਖ ()\' ਫੰਕਸ਼ਨ ਪ੍ਰੋਗਰਾਮ ਦਾ ਪ੍ਰਵੇਸ਼ ਬਿੰਦੂ ਹੈ, ਅਤੇ\'ਪ੍ਰਿੰਟ ਐੱਫ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਗ੍ਰੀਟਿੰਗ ਨੂੰ ਸਕ੍ਰੀਨ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \',\' ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਸਟੈਡਿਨ ਤੋਂ ਇਨਪੁਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਇਸ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ?ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ? \',\' ਜ਼ਰੂਰ! ਇੱਥੇ C ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ (stdin) ਤੋਂ ਇੰਪੁੱਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈਃ \\n\\n \'\\n#include<stdio.h>\\n#include <ctype.h> \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\n ਜਦੋਂ ਕਿ (c = ਗੇਟਚਰ ()! = EOF) {\\n ਜੇਕਰ (ਇਸਾਲਫਾ (c)) {\\n ਪੁਟਚਰ (ਟਾਪਰ (c)); \\n} \\n ਰਿਟਰਨ0; \\n} \\n\\n "\'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਨੂੰ ਪਡ਼੍ਹਨ ਲਈ\' ਗੇਟਚਰ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ\' ਇਸਾਲਫ਼ਾ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਕਿ ਕੀਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ। ਜੇਕਰ ਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਸਟੈਂਡਰਡ ਵਿੱਚ ਛਾਪਣ ਤੋਂ ਪਹਿਲਾਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।\'ਪੁੱਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਉਟਪੁੱਟ। \',\' ਇਸ ਲਈ, ਜੇ ਮੈਂ ਲਿਖਦਾ ਹਾਂ "ਹੈਲੋ ਉੱਥੇ, ਨੰਬਰ 4!" ਤਾਂ ਆਉਟਪੁੱਟ ਕੀ ਹੋਵੇਗਾ? \',\' ਜੇ ਤੁਸੀਂ ਉੱਥੇ ਹੈਲੋ ਲਿਖਦੇ ਹੋ, \'ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ, ਆਉਟਪੁੱਟ "ਹੈਲੋ ਦੇਅਰ, ਨੰਬਰ 4!" ਹੋਵੇਗਾ। \\n\\n ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਪਡ਼੍ਹਦਾ ਹੈ ਅਤੇਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਜੇਕਰ ਇਹ ਇੱਕ ਅੱਖਰ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਇੰਪੁੱਟ "h" ਨੂੰ "H" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, "e" ਨੂੰ "E" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਆਦਿ।ਅੱਖਰ "ਈ" ਅਤੇ "ਐਲ" ਨੂੰ ਦੋ ਵਾਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।\',\' ਜੇਕਰ ਤੁਸੀਂ "4" ਲਿਖਦੇ ਹੋ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਹੈਰਾਨੀ ਚਿੰਨ੍ਹ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਆਉਟਪੁੱਟ "4!" ਹੋਵੇਗਾ।ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ, ਇਸ ਲਈ ਇਹ "4" ਨੂੰ ਪਡ਼੍ਹੇਗਾ ਅਤੇ ਫਿਰ ਅਗਲੇ ਅੱਖਰ ਵੱਲ ਵਧੇਗਾ, ਜੋ ਕਿ ਹੈਰਾਨੀ ਦਾ ਨਿਸ਼ਾਨ ਹੈ।ਹੈਰਾਨੀ ਚਿੰਨ੍ਹ ਇੱਕ ਅੱਖਰ ਨਹੀਂ ਹੈ, ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਨਹੀਂ ਬਦਲਿਆ ਜਾਵੇਗਾ। \\n\\nਯਦਿ ਤੁਸੀਂ ਇਨਪੁਟ ਦੇ ਰੂਪ ਵਿੱਚ "ਹੈਲੋ, ਨੰਬਰ 4!" ਲਿਖਣਾ ਸੀ, ਤਾਂ ਆਉਟਪੁੱਟ"ਹੈਲੋ ਦੇਅਰ, ਨੰਬਰ 4!" ਹੋਵੇਗਾ। "ਈ" ਅਤੇ "ਐਲ" ਅੱਖਰਾਂ ਨੂੰ ਦੋ ਵਾਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ \'ਟੌਪਰ ()\' ਦੁਆਰਾ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।ਫੰਕਸ਼ਨ। ਨੰਬਰ "4" ਅਤੇ "4" ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਨਹੀਂ ਬਦਲਿਆ ਜਾਵੇਗਾ। "", ਠੀਕ ਹੈ, ਪਰ ਅਸੀਂ ਸਿਰਫ \'ਪੁਟਚਰ\' ਨੂੰ ਕਾਲ ਕਰ ਰਹੇ ਹਾਂ ਜਦੋਂ ਅੱਖਰ \'ਇਸਾਲਫ਼ਾ\' ਹੋਵੇ।ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਗੈਰ-ਵਰਣਮਾਲਾ ਅੱਖਰ, ਜਿਵੇਂ ਕਿ 4 ਅਤੇ! ਬਿਲਕੁਲ ਨਹੀਂ ਛਾਪੇ ਜਾਣਗੇ? ", \'ਤੁਸੀਂ ਸਹੀ ਹੋ ਕਿ ਪ੍ਰੋਗਰਾਮ ਸਿਰਫ\' ਪੁੱਟਚਰ () \'ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਜਦੋਂਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ, ਇਸ ਲਈ ਗੈਰ-ਵਰਣਮਾਲਾ ਅੱਖਰ ਜਿਵੇਂ ਕਿ "4" ਅਤੇ "!" ਪ੍ਰਿੰਟ ਨਹੀਂ ਕੀਤੇ ਜਾਣਗੇ। \\n\\n ਜੇਕਰ ਤੁਸੀਂ ਸਾਰੇ ਅੱਖਰ ਪ੍ਰਿੰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨਗੈਰ-ਵਰਣਮਾਲਾ ਅੱਖਰ, ਤੁਸੀਂ ਸਾਰੇ ਅੱਖਰਾਂ ਲਈ \'ਪੁੱਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਸੋਧ ਸਕਦੇ ਹੋ, ਚਾਹੇ ਉਹ ਅੱਖਰ ਹੋਣ ਜਾਂਨਹੀਂ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਦਿੱਤੀ ਗਈ ਹੈ ਕਿ ਤੁਸੀਂ ਅਜਿਹਾ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੋਧ ਸਕਦੇ ਹੋਃ \\n\\n "\'\\n#include <stdio.h\\n#include <ctype.h> \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\nਜਦੋਂ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦਾ ਸੋਧਿਆ ਹੋਇਆ ਸੰਸਕਰਣ ਇਸ ਲਈ \'ਪੁੱਟਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਹਰੇਕ ਅੱਖਰ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਪਡ਼੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਇਸ ਗੱਲ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਕਿ ਇਹ ਇੱਕ ਅੱਖਰ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਅੱਖਰ "ਈ" ਅਤੇ ਨੰਬਰ "4" ਦੋਵੇਂਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਵੇਗਾ, ਨਾਲ ਹੀ ਹੈਰਾਨ ਕਰਨ ਵਾਲਾ ਨਿਸ਼ਾਨ. \',\' ਪਰ ਇਹ ਹੁਣ ਵਰਣਮਾਲਾ ਅੱਖਰਾਂ ਨੂੰ ਵੱਡਾ ਨਹੀਂ ਕਰਦਾ... \'] ', 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?', ' [\'ਹੈਲੋ, ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?\', "ਮੈਂ ਸਿਰਫ਼ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਹਾਂ, ਇਸ ਲਈ ਮੇਰੇ ਕੋਲ ਭਾਵਨਾਵਾਂ ਜਾਂ ਭਾਵਨਾਵਾਂ ਨਹੀਂ ਹਨ। ਮੈਂ ਤੁਹਾਡੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਉੱਤਰ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਹਾਂ।ਮੈਂ ਆਪਣੀ ਸਮਰੱਥਾ ਅਨੁਸਾਰ ਅੱਜ ਤੁਹਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ?, \'ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਹੈਲੋ ਵਰਲਡ ਲਿਖ ਸਕਦੇ ਹੋ?\', \'ਜ਼ਰੂਰ! ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ "ਹੈਲੋ, ਵਰਲਡ!" ਪ੍ਰੋਗਰਾਮ ਹੈ।C: \\n\\n "\'\\n#include <stdio.h> \\n\\nint ਮੈਨ () {\\n ਪ੍ਰਿੰਟਫ (" ਹੈਲੋ, ਵਰਲਡ!\\\\n "); \\n ਰਿਟਰਨ 0; \\n} \\n\\n"\' \\n\\n ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ \'stdio.h\' ਹੈਡਰ ਫਾਈਲ ਸ਼ਾਮਲ ਹੈ,ਜੋ ਤੁਹਾਨੂੰ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ \'ਪ੍ਰਿੰਟਐੱਫ ()\' ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। \'ਮੁੱਖ ()\' ਫੰਕਸ਼ਨ ਪ੍ਰੋਗਰਾਮ ਦਾ ਪ੍ਰਵੇਸ਼ ਬਿੰਦੂ ਹੈ, ਅਤੇ\'ਪ੍ਰਿੰਟ ਐੱਫ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਗ੍ਰੀਟਿੰਗ ਨੂੰ ਸਕ੍ਰੀਨ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \',\' ਕੀ ਤੁਸੀਂ ਸੀ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਸਟੈਡਿਨ ਤੋਂ ਇਨਪੁਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਇਸ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ?ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ? \',\' ਜ਼ਰੂਰ! ਇੱਥੇ C ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ (stdin) ਤੋਂ ਇੰਪੁੱਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈਃ \\n\\n \'\\n#include<stdio.h>\\n#include <ctype.h> \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\n ਜਦੋਂ ਕਿ (c = ਗੇਟਚਰ ()! = EOF) {\\n ਜੇਕਰ (ਇਸਾਲਫਾ (c)) {\\n ਪੁਟਚਰ (ਟਾਪਰ (c)); \\n} \\n ਰਿਟਰਨ0; \\n} \\n\\n "\'\\n\\n ਇਹ ਪ੍ਰੋਗਰਾਮ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਨੂੰ ਪਡ਼੍ਹਨ ਲਈ\' ਗੇਟਚਰ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ\' ਇਸਾਲਫ਼ਾ () \'ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਕਿ ਕੀਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ। ਜੇਕਰ ਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਸਟੈਂਡਰਡ ਵਿੱਚ ਛਾਪਣ ਤੋਂ ਪਹਿਲਾਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।\'ਪੁੱਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਉਟਪੁੱਟ। \',\' ਇਸ ਲਈ, ਜੇ ਮੈਂ ਲਿਖਦਾ ਹਾਂ "ਹੈਲੋ ਉੱਥੇ, ਨੰਬਰ 4!" ਤਾਂ ਆਉਟਪੁੱਟ ਕੀ ਹੋਵੇਗਾ? \',\' ਜੇ ਤੁਸੀਂ ਉੱਥੇ ਹੈਲੋ ਲਿਖਦੇ ਹੋ, \'ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ, ਆਉਟਪੁੱਟ "ਹੈਲੋ ਦੇਅਰ, ਨੰਬਰ 4!" ਹੋਵੇਗਾ। \\n\\n ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ ਪਡ਼੍ਹਦਾ ਹੈ ਅਤੇਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਜੇਕਰ ਇਹ ਇੱਕ ਅੱਖਰ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਇੰਪੁੱਟ "h" ਨੂੰ "H" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, "e" ਨੂੰ "E" ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਆਦਿ।ਅੱਖਰ "ਈ" ਅਤੇ "ਐਲ" ਨੂੰ ਦੋ ਵਾਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।\',\' ਜੇਕਰ ਤੁਸੀਂ "4" ਲਿਖਦੇ ਹੋ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਹੈਰਾਨੀ ਚਿੰਨ੍ਹ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਆਉਟਪੁੱਟ "4!" ਹੋਵੇਗਾ।ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਇੱਕ ਅੱਖਰ, ਇਸ ਲਈ ਇਹ "4" ਨੂੰ ਪਡ਼੍ਹੇਗਾ ਅਤੇ ਫਿਰ ਅਗਲੇ ਅੱਖਰ ਵੱਲ ਵਧੇਗਾ, ਜੋ ਕਿ ਹੈਰਾਨੀ ਦਾ ਨਿਸ਼ਾਨ ਹੈ।ਹੈਰਾਨੀ ਚਿੰਨ੍ਹ ਇੱਕ ਅੱਖਰ ਨਹੀਂ ਹੈ, ਇਸ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਨਹੀਂ ਬਦਲਿਆ ਜਾਵੇਗਾ। \\n\\nਯਦਿ ਤੁਸੀਂ ਇਨਪੁਟ ਦੇ ਰੂਪ ਵਿੱਚ "ਹੈਲੋ, ਨੰਬਰ 4!" ਲਿਖਣਾ ਸੀ, ਤਾਂ ਆਉਟਪੁੱਟ"ਹੈਲੋ ਦੇਅਰ, ਨੰਬਰ 4!" ਹੋਵੇਗਾ। "ਈ" ਅਤੇ "ਐਲ" ਅੱਖਰਾਂ ਨੂੰ ਦੋ ਵਾਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ \'ਟੌਪਰ ()\' ਦੁਆਰਾ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।ਫੰਕਸ਼ਨ। ਨੰਬਰ "4" ਅਤੇ "4" ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਵਿੱਚ ਨਹੀਂ ਬਦਲਿਆ ਜਾਵੇਗਾ। "", ਠੀਕ ਹੈ, ਪਰ ਅਸੀਂ ਸਿਰਫ \'ਪੁਟਚਰ\' ਨੂੰ ਕਾਲ ਕਰ ਰਹੇ ਹਾਂ ਜਦੋਂ ਅੱਖਰ \'ਇਸਾਲਫ਼ਾ\' ਹੋਵੇ।ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਗੈਰ-ਵਰਣਮਾਲਾ ਅੱਖਰ, ਜਿਵੇਂ ਕਿ 4 ਅਤੇ! ਬਿਲਕੁਲ ਨਹੀਂ ਛਾਪੇ ਜਾਣਗੇ? ", \'ਤੁਸੀਂ ਸਹੀ ਹੋ ਕਿ ਪ੍ਰੋਗਰਾਮ ਸਿਰਫ\' ਪੁੱਟਚਰ () \'ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਜਦੋਂਅੱਖਰ ਇੱਕ ਅੱਖਰ ਹੈ, ਇਸ ਲਈ ਗੈਰ-ਵਰਣਮਾਲਾ ਅੱਖਰ ਜਿਵੇਂ ਕਿ "4" ਅਤੇ "!" ਪ੍ਰਿੰਟ ਨਹੀਂ ਕੀਤੇ ਜਾਣਗੇ। \\n\\n ਜੇਕਰ ਤੁਸੀਂ ਸਾਰੇ ਅੱਖਰ ਪ੍ਰਿੰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨਗੈਰ-ਵਰਣਮਾਲਾ ਅੱਖਰ, ਤੁਸੀਂ ਸਾਰੇ ਅੱਖਰਾਂ ਲਈ \'ਪੁੱਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਸੋਧ ਸਕਦੇ ਹੋ, ਚਾਹੇ ਉਹ ਅੱਖਰ ਹੋਣ ਜਾਂਨਹੀਂ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਦਿੱਤੀ ਗਈ ਹੈ ਕਿ ਤੁਸੀਂ ਅਜਿਹਾ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੋਧ ਸਕਦੇ ਹੋਃ \\n\\n "\'\\n#include <stdio.h\\n#include <ctype.h> \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\nਜਦੋਂ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦਾ ਸੋਧਿਆ ਹੋਇਆ ਸੰਸਕਰਣ ਇਸ ਲਈ \'ਪੁੱਟਚਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਹਰੇਕ ਅੱਖਰ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਪਡ਼੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਇਸ ਗੱਲ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਕਿ ਇਹ ਇੱਕ ਅੱਖਰ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਅੱਖਰ "ਈ" ਅਤੇ ਨੰਬਰ "4" ਦੋਵੇਂ\',\' ਪਰ ਇਹ ਹੁਣ ਵਰਣਮਾਲਾ ਅੱਖਰਾਂ ਨੂੰ ਵੱਡਾ ਨਹੀਂ ਕਰਦਾ... \',\' ਤੁਸੀਂ ਸਹੀ ਹੋ ਕਿ ਸੋਧਿਆ ਹੋਇਆ ਚਿੰਨ੍ਹਪ੍ਰੋਗਰਾਮ ਦਾ ਸੰਸਕਰਣ ਵਰਣਮਾਲਾ ਅੱਖਰਾਂ ਨੂੰ ਹੁਣ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਨਹੀਂ ਰੱਖਦਾ। ਜੇ ਤੁਸੀਂ ਅੱਖਰਾਂ ਨੂੰ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸੰਸ਼ੋਧਿਤ ਕਰ ਸਕਦੇ ਹੋਸਾਰੇ ਅੱਖਰਾਂ ਲਈ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਨਾ ਕਿ ਸਿਰਫ਼ ਵਰਣਮਾਲਾ ਲਈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਸ਼ੋਧਿਤ ਕਰ ਸਕਦੇ ਹੋ।ਇਹਃ \\n\\n "\'\\n#include <stdio.h>\\n#include <ctype.h \\n\\nint ਮੈਨ () {\\n ਇੰਟ c; \\n ਜਦੋਂ ਕਿ ((c = ਗੇਟਚਰ ()! = EOF) {\\n ਪੁਟਚਰ (ਟਾਪਰ (c)); \\n} \\n ਰਿਟਰਨਪ੍ਰੋਗਰਾਮ ਦਾ ਇਹ ਸੋਧਿਆ ਹੋਇਆ ਸੰਸਕਰਣ ਹਰੇਕ ਅੱਖਰ ਲਈ \'ਟੌਪਰ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਤੋਂ ਪਡ਼੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਕੋਈ ਵੀ ਹੋਵੇਭਾਵੇਂ ਇਹ ਇੱਕ ਅੱਖਰ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਅੱਖਰ "ਈ" ਅਤੇ ਨੰਬਰ "4" ਦੋਵੇਂ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਛਾਪੇ ਜਾਣਗੇ, ਨਾਲ ਹੀ ਹੈਰਾਨੀ ਵੀ।ਮਾਰਕ. \',\' ਇਹ ਸਹੀ ਹੱਲ ਹੈ! \'] ', 'ਹੈਲੋ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ? \n ']