Ruby/C3/for-and-each-Looping-Statements/Punjabi
From Script | Spoken-Tutorial
“Time” | “Narration” | |
00:01 | ਸਤਿ ਸ਼੍ਰੀ ਅਕਾਲ ਦੋਸਤੋ, Ruby ਵਿੱਚ for ਅਤੇ each loops ਦੇ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਤੁਹਾਡਾ ਸਾਰਿਆ ਦਾ ਸਵਾਗਤ ਹੈ । | |
00:05 | ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਸਿੱਖਾਂਗੇ | |
00:07 | ਸ਼ਬਦ loop ਦਾ ਮਤਲੱਬ Ruby ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਲੂਪਸ | |
00:11 | for ਲੂਪ ਦੀ ਵਰਤੋਂ ਅਤੇ each ਲੂਪਿੰਗ ਕੰਸਟਰਕਟ ਦੀ ਵਰਤੋਂ | |
00:14 | ਇੱਥੇ ਅਸੀਂ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ | |
00:16 | ਉਬੰਟੁ ਵਰਜ਼ਨ 12.04 | |
00:19 | Ruby 1.9.3 | |
00:22 | ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਜਾਣਨ ਦੇ ਲਈ, ਤੁਹਾਡੇ ਕੋਲ ਇੰਟਨੈੱਟ ਦਾ ਕਨੈਕਸ਼ਨ ਹੋਣਾ ਜਰੂਰੀ ਹੈ । | |
00:25 | ਤੁਹਾਨੂੰ ਲਿਨਕਸ ਕਮਾਂਡਸ, ਟਰਮੀਨਲ ਅਤੇ ਟੈਕਸਟ – ਐਡੀਟਰ ਦਾ ਗਿਆਨ ਹੋਣਾ ਜ਼ਰੂਰੀ ਹੈ । | |
00:30 | ਜੇ ਨਹੀਂ, ਤਾਂ ਸੰਬੰਧਿਤ ਟਿਊਟੋਰਿਅਲਸ ਦੇ ਲਈ, ਕ੍ਰਿਪਾ ਕਰਕੇ ਸਾਡੀ ਵੈੱਬਸਾਈਟ ‘ਤੇ ਜਾਓ । | |
00:34 | ਹੁਣ ਮੈਂ ਸਮਝਾਉਂਦਾ ਹਾਂ ਕਿ Ruby ਵਿੱਚ loop ਦੀ ਤਰ੍ਹਾਂ ਕੀ ਸ਼ਾਮਿਲ ਹੈ । | |
00:38 | loop, ਕਮਾਂਡ ਜਾਂ ਕਮਾਂਡਸ ਦਾ ਸੈੱਟ ਹੈ ਜੋ ਨਿਸ਼ਚਿਤ ਤੌਰ ‘ਤੇ ਚੱਲਦਾ ਹੈ । | |
00:44 | Ruby ਹੇਠ ਲਿਖੇ ਮੁੱਖ ਸਟੇਟਮੈਂਟ ਰੱਖਦਾ ਹੈ | |
00:47 | for each | |
00:49 | while until | |
00:50 | ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਸਿੱਖਾਂਗੇ ਕਿ for ਅਤੇ each ਲੂਪਿੰਗ ਕੰਸਟਰਕਟ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ । | |
00:55 | ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਕ੍ਰਿਪਾ ਕਰਕੇ ਆਪਣੀ ਹੋਮ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਫੋਲਡਰਸ ਬਣਾਓ । | |
01:02 | ttt, ruby hyphen tutorial, looping hyphen statement | |
01:07 | ਕ੍ਰਿਪਾ ਕਰਕੇ ਇੱਥੇ ਸਾਰੇ ਦੱਸੇ ਗਏ ਫੋਲਡਰਸ ਬਣਾਓ । | |
01:11 | ਹੁਣ ਅਸੀਂ ਜ਼ਰੂਰੀ ਫੋਲਡਰਸ ਬਣਾ ਲਏ ਹਨ । | |
01:13 | ਅੱਗੇ ਵੱਧਦੇ ਹਾਂ । | |
01:15 | Ruby ਵਿੱਚ for ਲੂਪ ਦੀ ਸ਼ੈਲੀ, ਦਿੱਤੇ ਗਏ ਦੀ ਤਰ੍ਹਾਂ ਹੈ । | |
01:19 | for variable in a collection of objects | |
01:22 | ruby code | |
01:23 | end | |
01:25 | ਇਸ ਨੂੰ ਇੱਕ ਉਦਾਹਰਣ ਨਾਲ ਸਿੱਖਦੇ ਹਾਂ । | |
01:28 | gedit ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਫਾਇਲ ਬਣਾਉਂਦੇ ਹਾਂ ਜਿਵੇਂ ਸ਼ੁਰੂਆਤੀ ਪੱਧਰ ਦੇ Ruby ਟਿਊਟੋਰਿਅਲਸ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ । | |
01:32 | ਅਤੇ ਇਸ ਨੂੰ for hyphen loop dot rb ਨਾਮ ਦਿਓ । | |
01:36 | ਮੇਰੇ ਕੋਲ ਪਹਿਲਾਂ ਤੋਂ ਹੀ for ਲੂਪ ਦੀ ਕਾਰਜਕਾਰੀ ਉਦਾਹਰਣ ਹੈ । | |
01:39 | ਇਸ ਉਦਾਹਰਣ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੇ ਲਈ ਤੁਸੀਂ ਕੋਡ ਟਾਈਪ ਕਰ ਸਕਦੇ ਹੋ । | |
01:44 | ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ ਮੈਂ ਇੱਕ for ਲੂਪ ਐਲਾਨ ਕੀਤਾ ਹੈ । | |
01:47 | ਸਾਡੇ ਕੋਲ 1 ਤੋਂ 20 ਤੱਕ ਨੰਬਰਸ ਦਾ ਸੈੱਟ ਹੈ । | |
01:50 | ਅਸੀਂ, for ਲੂਪ ਵਿੱਚ ਇੱਕ ਵੈਰੀਏਬਲ i ਐਲਾਨ ਕਰਦੇ ਹਾਂ । | |
01:55 | 1 ਤੋਂ 20 ਤੱਕ ਨੰਬਰਸ ਦੇ ਸੈੱਟ ਵਿੱਚ i ਨੂੰ ਪਹਿਲੇ ਐਲੀਮੈਂਟ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ । | |
02:00 | for ਲੂਪ ਦੇ ਐਲਾਨ ਦੇ ਕਾਰਨ ਇਹ ਕੋਡ 1 ਤੋਂ 20 ਤੱਕ ਹਰੇਕ ਨੰਬਰ ‘ਤੇ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ । | |
02:07 | for ਲੂਪ ਵਿੱਚ ਐਲਾਨ puts ਮੈਥਡ ਆਉਟਪੁਟ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੁੰਦਾ ਹੈ । | |
02:14 | ਹੁਣ ਟਰਮੀਨਲ ਖੋਲੋ ਅਤੇ ਟਾਈਪ ਕਰੋ । | |
02:17 | ruby space for hyphen loop dot rb ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ । | |
02:22 | ਆਉਟਪੁਟ 1 ਤੋਂ 20 ਦੇ ਨੰਬਰਸ ਦੀ array ਹੋਵੇਗੀ । | |
02:26 | ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਇੰਕਲੂਸਿਵ ਰੇਂਜ ਦੇ ਲਈ for ਲੂਪ ਐਲਾਨ ਕੀਤਾ ਹੈ । | |
02:31 | ਇਸ ਵਿੱਚ 1 ਤੋਂ 20 ਤੱਕ ਦੇ ਨੰਬਰਸ ਸ਼ਾਮਿਲ ਹਨ । | |
02:35 | ਅੱਗੇ, ਅਸੀਂ ਨਾਨ - ਇੰਕਲੂਸਿਵ ਰੇਂਜ ਦੇ ਲਈ for ਲੂਪ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਵੇਖਾਂਗੇ । | |
02:41 | ਕੋਡ ਦਾ ਅਗਲਾ ਭਾਗ ਟਾਈਪ ਕਰਨਾ ਜਾਰੀ ਰੱਖੋ । | |
02:44 | ਨਾਨ - ਇੰਕਲੂਸਿਵ ਦਾ ਮਤਲੱਬ ਇਹ ਆਬਜੈਕਟਸ ਦੇ ਸਮੂਹ ਵਿੱਚ ਆਖਰੀ ਐਲੀਮੈਂਟ ਸ਼ਾਮਿਲ ਨਹੀਂ ਕਰੇਗਾ । | |
02:49 | ਇੱਥੇ for ਲੂਪ, 1 ਤੋਂ 20 ਤੱਕ ਦੀ ਨਾਨ - ਇੰਕਲੂਸਿਵ ਰੇਂਜ ਦੇ ਲਾਗੂ ਹੋਇਆ ਹੈ । | |
02:55 | ਤੁਸੀਂ ਜਲਦੀ ਹੀ ਵੇਖੋਗੇ ਕਿ ਨੰਬਰ 20 ਆਉਟਪੁਟ ਵਿੱਚ ਪ੍ਰਿੰਟ ਨਹੀਂ ਹੋਵੇਗਾ । | |
02:59 | ਆਖਰੀ ਅੰਕ ਸ਼ਾਮਿਲ ਨਹੀਂ ਹੋਇਆ ਹੈ, ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਨੰਬਰਸ ਦੇ ਵਿੱਚ ਤਿੰਨ ਡਾਟਸ ਹਨ । | |
03:04 | ਹੁਣ ਟਰਮੀਨਲ ਖੋਲੋ ਅਤੇ ਟਾਈਪ ਕਰੋ ruby space for hyphen loop dot rb. | |
03:13 | ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ । | |
03:17 | ਆਉਟਪੁਟ ਹੁਣ ਵੀ ਨੰਬਰਸ ਦੀ array ਹੋਵੇਗੀ, ਪਰ ਨੰਬਰ 20 ਸ਼ਾਮਿਲ ਨਹੀਂ ਹੋਵੇਗਾ । | |
03:22 | ਹੁਣ, ਤੁਸੀਂ ਆਪਣਾ for ਲੂਪ ਲਿਖਣ ਦੇ ਲਈ ਸਮਰੱਥ ਹੋਣੇ ਚਾਹੀਦੇ ਹੋ । | |
03:27 | Ruby ਵਿੱਚ each ਲੂਪ ਦੀ ਸ਼ੈਲੀ ਹੇਠ ਲਿਖੇ ਦੀ ਤਰ੍ਹਾਂ ਹੈ: | |
03:31 | a collection of objects dot each do item . | |
03:36 | Ruby ਕੋਡ end | |
03:38 | ਇਸ ਨੂੰ ਇੱਕ ਉਦਾਹਰਣ ਨਾਲ ਸਮਝਦੇ ਹਾਂ । | |
03:42 | gedit ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਫਾਇਲ ਬਣਾਓ, ਜਿਵੇਂ ਕਿ Ruby ਦੇ ਸ਼ੁਰੂਆਤੀ ਪੱਧਰ ਦੇ ਟਿਊਟੋਰਿਅਲਸ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ । | |
03:46 | ਅਤੇ ਇਸ ਨੂੰ ਨਾਮ ਦਿਓ each hyphen loop dot rb | |
03:50 | ਮੇਰੇ ਕੋਲ each ਲੂਪ ਦੀ ਇੱਕ ਕਾਰਜਕਾਰੀ ਉਦਾਹਰਣ ਹੈ । | |
03:53 | ਇਸ ਉਦਾਹਰਣ ਨੂੰ ਸਮਝਦੇ ਸਮੇਂ ਤੁਸੀਂ ਕੋਡ ਵੀ ਟਾਈਪ ਕਰ ਸਕਦੇ ਹੋ । | |
03:58 | ਮੈਂ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ ਇੱਕ each ਲੂਪ ਐਲਾਨ ਕੀਤਾ ਹੈ । | |
04:03 | ਸਾਡੇ ਕੋਲ 1 ਤੋਂ 20 ਤੱਕ ਨੰਬਰਸ ਦਾ ਸੈੱਟ ਹੈ । | |
04:06 | each ਲੂਪ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਵੈਰੀਏਬਲ i ਐਲਾਨ ਕਰਦੇ ਹਾਂ । | |
04:11 | 1 ਤੋਂ 20 ਤੱਕ ਨੰਬਰਸ ਦੇ ਸੈੱਟ ਵਿੱਚ i ਨੂੰ ਪਹਿਲੇ ਐਲੀਮੈਂਟਰੀ ਤੋਂ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ । | |
04:17 | each ਲੂਪ ਦੇ ਐਲਾਨ ਦੇ ਕਾਰਨ ਇਹ ਕੋਡ 1 ਤੋਂ 20 ਤੱਕ ਹਰੇਕ ਨੰਬਰ ‘ਤੇ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ । | |
04:23 | each ਵਿੱਚ puts ਮੈਥਡ ਐਲਾਨ ਕੀਤਾ ਹੈ, ਜੋ ਆਉਟਪੁਟ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੁੰਦਾ ਹੈ । | |
04:30 | ਹੁਣ ਟਰਮੀਨਲ ਨੂੰ ਖੋਲੋ ਅਤੇ ਟਾਈਪ ਕਰੋ ruby space each hyphen loop dot rb. | |
04:39 | ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ । | |
04:43 | ਆਉਟਪੁਟ 1 ਤੋਂ 20 ਦੇ ਨੰਬਰਸ ਦੀ array ਹੋਵੇਗੀ । | |
04:46 | ਉੱਪਰ ਦਿੱਤੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਅਸੀਂ ਇੰਕਲੂਸਿਵ ਰੇਂਜ ਦੇ ਲਈ ਇੱਕ each ਲੂਪ ਐਲਾਨ ਕੀਤਾ ਹੈ । | |
04:51 | ਇਸ ਵਿੱਚ 1 ਤੋਂ 20 ਤੱਕ ਸਾਰੇ ਨੰਬਰਸ ਸ਼ਾਮਿਲ ਹਨ । | |
04:54 | ਅੱਗੇ, ਅਸੀਂ ਨਾਨ - ਇੰਕਲੂਸਿਵ ਰੇਂਜ ਦੇ ਲਈ each ਲੂਪ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਵੇਖਾਂਗੇ । | |
05:00 | ਕੋਡ ਦੇ ਇਸ ਭਾਗ ਨੂੰ ਟਾਈਪ ਕਰਨਾ ਜਾਰੀ ਰੱਖੋ । | |
05:04 | ਨਾਨ - ਇੰਕਲੂਸਿਵ ਦਾ ਅਰਥ ਹੈ, ਕਿ ਇਹ ਆਬਜੈਕਟਸ ਦੇ ਸੰਗ੍ਰਿਹ ਵਿੱਚ ਆਖਰੀ ਐਲੀਮੈਂਟ ਨੂੰ ਸ਼ਾਮਿਲ ਨਹੀਂ ਕਰੇਗਾ । | |
05:10 | ਇੱਥੇ each ਲੂਪ, ਨੰਬਰਸ 1 ਤੋਂ 20 ਤੱਕ ਦੀ ਨਾਨ - ਇੰਕਲੂਸਿਵ ਰੇਂਜ ਦੇ ਲਈ ਲਾਗੂ ਹੋਇਆ ਹੈ । | |
05:16 | ਜਲਦੀ ਹੀ ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਨੰਬਰ 20 ਆਉਟਪੁਟ ਵਿੱਚ ਦਿਖਾਈ ਨਹੀਂ ਦੇਵੇਗਾ । | |
05:20 | ਜਦੋਂ ਨੰਬਰਸ ਦੇ ਵਿੱਚ 3 ਡਾਟਸ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਆਖਰੀ ਡਿਜਿਟ ਸ਼ਾਮਿਲ ਨਹੀਂ ਹੁੰਦਾ ਹੈ । | |
05:25 | ਹੁਣ ਟਰਮੀਨਲ ਖੋਲੋ ਅਤੇ ਟਾਈਪ ਕਰੋ ruby space each hyphen loop dot rb. | |
05:34 | ਅਤੇ ਆਉਟਪੁਟ ਵੇਖੋ । | |
05:39 | ਹੁਣ, ਤੁਸੀਂ ਸਮਰੱਥ ਰੂਪ ਤੋਂ ਆਪਣਾ each ਲੂਪ ਲਿਖਣ ਵਿੱਚ ਸਮਰੱਥ ਹੋਣੇ ਚਾਹੀਦੇ ਹੋ । | |
05:44 | ਅਸੀਂ ਕਿਵੇਂ ਨਿਰਧਾਰਤ ਕਰੀਏ ਕਿ ਕਿਹੜਾ ਲੂਪਿੰਗ ਕੰਸਟਰਕਟ ਚੁਣਨਾ ਹੈ ? | |
05:48 | for ਲੂਪ ਕੰਸਟਰਕਟ ਨੂੰ ਫਿਰ ਤੋਂ ਕਾਲ ਕਰਦੇ ਹਾਂ । | |
05:53 | ਪਹਿਲੀ ਉਦਾਹਰਣ ਵਿੱਚ, for ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸੀਂ 1 ਤੋਂ 20 ਤੱਕ ਨੰਬਰਸ ਦੇ ਸੈੱਟ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹਾਂ । | |
05:59 | ਆਪਣੇ ਟਰਮੀਨਲ ਵਿੱਚ ruby space for hyphen loop dot rb ਨੂੰ ਚਲਾਓ, ਆਉਟਪੁਟ ਵੇਖੋ । | |
06:08 | ਹੁਣ gedit ਵਿੱਚ ਕੋਡ ਵੇਖਦੇ ਹਾਂ । | |
06:11 | ਜਦੋਂ ਤੁਸੀਂ for ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ Ruby ਪਿੱਛੋਂ ਤੋਂ each ਮੈਥਡ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ । | |
06:16 | ਅਤੇ ਸਮਾਨ ਆਉਟਪੁਟ ਦੇ ਲਈ, each ਜਾਂ for ਕਿਸੇ ਨੂੰ ਕਾਲ ਕਰੋ, | |
06:21 | ਹਾਲਾਂਕਿ for ਵੀ, each ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ: ਇਸਦੇ ਬਜਾਏ each ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਿਹਤਰ ਹੈ । | |
06:28 | ਇਹ ਸਾਨੂੰ ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੇ ਅਖੀਰ ਵਿੱਚ ਲੈ ਕੇ ਜਾਂਦਾ ਹੈ । | |
06:30 | ਇਸ ਦਾ ਸਾਰ ਕਰਦੇ ਹਾਂ । | |
06:32 | ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਸਿੱਖਿਆ for ਲੂਪ ਦੀ ਵਰਤੋਂ | |
06:35 | each ਕੰਸਟਰਕਟ ਦੀ ਵਰਤੋਂ | |
06:38 | for ਦੇ ਬਜਾਏ each ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਕਾਰਨ | |
06:41 | ਉੱਪਰ ਦਿੱਤਿਆਂ ਵਿੱਚੋਂ ਲੂਪਿੰਗ ਕੰਸਟਰਕਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਉਦਾਹਰਣ | |
06:45 | ਇੱਕ ਨਿਰਧਾਰਤ ਕੰਮ ਦੀ ਤਰ੍ਹਾਂ | |
06:47 | ਉਚਿਤ ਲੂਪ ਕੰਸਟਰਕਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ruby ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ । | |
06:50 | 1 ਤੋਂ 20 ਤੱਕ ਨੰਬਰਸ ਦੇ ਸੈੱਟ ਤੋਂ ਇਵਨ (even) ਨੰਬਰਸ ਦੀ ਆਉਟਪੁਟ ਬਣਾਓ । | |
06:56 | ਹੇਠ ਲਿਖੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਵੀਡੀਓ ਨੂੰ ਵੇਖੋ । | |
07:00 | ਇਹ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਦਾ ਸਾਰ ਕਰਦਾ ਹੈ । | |
07:03 | ਚੰਗੀ ਬੈਂਡਵਿਡਥ ਨਾ ਮਿਲਣ ‘ਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਡਾਊਂਨਲੋਡ ਕਰਕੇ ਵੀ ਵੇਖ ਸਕਦੇ ਹੋ । | |
07:08 | ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟੀਮ: | |
07:11 | ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟੀਮ, ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਰਕਸ਼ਾਪਾਂ ਚਲਾਉਂਦੀ ਹੈ । | |
07:14 | ਆਨਲਾਇਨ ਟੈਸਟ ਪਾਸ ਕਰਨ ਵਾਲਿਆ ਨੂੰ ਪ੍ਰਮਾਣ ਪੱਤਰ ਵੀ ਦਿੰਦੇ ਹਨ । | |
07:18 | ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਦੇ ਲਈ, ਕ੍ਰਿਪਾ ਕਰਕੇ contact@spoken-tutorial.org ‘ਤੇ ਲਿਖੋ । | |
07:23 | ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟਾਕ-ਟੂ-ਅ ਟੀਚਰ ਪ੍ਰੋਜੈਕਟ ਦਾ ਹਿੱਸਾ ਹੈ । | |
07:26 | ਇਹ ਭਾਰਤ ਸਰਕਾਰ ਦੇ ਐਮਐਚਆਰਡੀ ਦੇ “ਆਈਸੀਟੀ ਵਲੋਂ ਰਾਸ਼ਟਰੀ ਸਾਖਰਤਾ ਮਿਸ਼ਨ” ਦੁਆਰਾ ਪ੍ਰਮਾਣਿਤ ਹੈ । | |
07:33 | ਇਸ ‘ਤੇ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਹੈ । http://spoken-tutorial.org/NMEICT-Intro | |
07:41 | ਆਈ.ਆਈ.ਟੀ ਬੰਬੇ ਤੋਂ ਮੈਂ ਨਵਦੀਪ ਤੁਹਾਡੇ ਤੋਂ ਇਜਾਜ਼ਤ ਲੈਂਦਾ ਹਾਂ । ਸਾਡੇ ਨਾਲ ਜੁੜਨ ਲਈ ਧੰਨਵਾਦ । | } |