Java/C2/Nested-if/Punjabi

Time	Narration
00:02	ਜਾਵਾ ਵਿੱਚ Nested - If ਅਤੇ Ternary Operator ਦੇ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਤੁਹਾਡਾ ਸਵਾਗਤ ਹੈ ।
00:07	ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੇ ਅੰਤ ਤੱਕ , ਤੁਸੀ ਇਸ ਵਿੱਚ ਸਮਰੱਥਾਵਾਨ ਹੋਵੋਗੇ Nested - If ਸਟੇਟਮੇਂਟਸ ਅਤੇ Ternary ਆਪਰੇਟਰਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਵਿੱਚ । ਤੇ ਇੱਕ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਉਨ੍ਹਾਂ ਦਾ ਪ੍ਰਯੋਗ ਕਰਨ ਵਿੱਚ ।
00:17	ਇਸ ਟਿਊਟੋਰਿਅਲ ਲਈ ਅਸੀ ਪ੍ਰਯੋਗ ਕਰਾਂਗੇ : Ubuntu v 11 . 10 , JDK 1 . 6 , ਅਤੇ EclipseIDE 3 . 7 . 0
00:27	ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਸੱਮਝਣ ਦੇ ਲਈ , ਤੁਹਾਨੂੰ ਗਿਆਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ,
00:29	relational ਅਤੇ logical ਆਪਰੇਟਰਸ ਦਾ
00:33	ਅਤੇ if . . . else ਕੰਟਰੋਲ ਫਲੋ ਸਟੇਟਮੇਂਟਸ ਦੀ ਵਰਤੋ ਦਾ ।
00:36	ਜੇਕਰ ਅਜਿਹਾ ਨਹੀਂ ਹੈ , ਤਾਂ ਉਚਿਤ ਟਿਊਟੋਰਿਅਲ ਲਈ ਕ੍ਰਿਪਾ ਸਾਡੀ ਇਸ ਵੇਬਸਾਈਟ ਉੱਤੇ ਜਾਓ
00:41	Nested if ਸਟੇਟਮੇਂਟਸ , ਇੱਕ If ਸਟੇਟਮੇਂਟ ਦੇ ਅੰਦਰ ਦੂਜੀ if ਸਟੇਟਮੇਂਟ , nested - if ਸਟੇਟਮੇਂਟ ਕਹਾਉਂਦੀ ਹੈ ।
00:49	ਹੁਣ Nested - If ਸਟੇਟਮੇਂਟ ਲਿਖਣ ਲਈ ਸਿੰਟੈਕਸ ਨੂੰ ਵੇਖਦੇ ਹਾਂ ।
00:53	ਇਸ ਹਾਲਤ ਵਿੱਚ , ਜੇਕਰ ਕੰਡੀਸ਼ਨ 1ਟਰੂ ਹੈ , ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਕੰਡੀਸ਼ਨ 2 ਲਈ ਜਾਂਚ ਕਰਦਾ ਹੈ ।
00:59	ਕੰਡੀਸ਼ਨ 2 ਦੂੱਜੇ If ਸਟੇਟਮੇਂਟ ਦਾ ਪ੍ਰਯੋਗ ਕਰਕੇ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ ।
01:03	ਜੇਕਰ ਕੰਡੀਸ਼ਨ 2 ਟਰੂ ਹੈ , ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਸਟੇਟਮੇਂਟ ਜਾਂ ਬਲਾਕ 1 ਨੂੰ ਚ੍ਲੋਉਂਦਾ ਹੈ ।
01:09	ਨਹੀਂ ਤਾਂ , ਇਹ ਸਟੇਟਮੇਂਟ ਜਾਂ ਬਲਾਕ 2 ਨੂੰ ਚ੍ਲੋਉਂਦਾ ਹੈ ।
01:13	ਜੇਕਰ ਕੰਡੀਸ਼ਨ 1 ਫਾਲਸ ਹੈ , ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਕੰਡੀਸ਼ਨ 2 ਦੀ ਜਾਂਚ ਨਹੀਂ ਕਰੇਗਾ ।
01:18	ਇਸਦੇ ਬਜਾਏ ਸਿੱਧੇ else ਸਟੇਟਮੇਂਟ ਯਾਨੀ ਬਲਾਕ 3 ਉੱਤੇ ਪਹੁੰਚ ਜਾਵੇਗਾ ।
01:24	ਹੁਣ ਇਸਨੂੰ ਬਿਹਤਰ ਸੱਮਝਣ ਲਈ ਇੱਕ ਉਦਾਹਰਣ ਲੈਂਦੇ ਹਾਂ
01:28	ਸਾਡੇ ਕੋਲ ਬਾਕੀ ਕੋਡ ਲਈ ਜ਼ਰੂਰੀ eclipse IDE ਅਤੇ skeleton ਹੈ ।
01:32	ਅਸੀਂ ਇੱਕ ਕਲਾਸ NestedIfDemo ਬਣਾ ਲਿਆ ਹੈ ਅਤੇ ਇਸਨੂੰ ਮੇਨ ਮੇਥਡ ਵਿੱਚ ਜੋੜ ਦਿੱਤਾ ਹੈ ।
01:37	ਅਸੀ ਜਾਂਚ ਕਰਾਂਗੇ ਕਿ ਦਿੱਤੀ ਗਈ ਗਿਣਤੀ ਇੱਕ ਈਵਨ ਗਿਣਤੀ ਹੈ ਜਾਂ ਇੱਕ odd ਗਿਣਤੀ ਹੈ ।
01:42	ਅਸੀ ਇੱਕ nested - if ਦੀ ਵਰਤੋ ਕਰਕੇ ਰਿਣਾਤਮਕ ਸੰਖਿਆਵਾਂਨੂੰ ਵੀ ਹੈਂਡਲ ਕਰਾਂਗੇ ।
01:46	ਇਸ ਲਈ ਮੇਨ ਮੇਥਡ ਵਿੱਚ ਟਾਈਪ ਕਰੋ
01:49	int n = minus 5 ;
01:54	ਅਸੀਂ ਰਿਣਾਤਮਕ ਗਿਣਤੀ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵੈਰਿਏਬਲ n ਬਣਾ ਲਿਆ ਹੈ ।
01:58	ਹੁਣ ਅਸੀ if ਕੰਡੀਸ਼ਨ ਲਿਖਾਗੇ ।
02:01	ਅਗਲੀ ਲਕੀਰ ਵਿੱਚ ਟਾਈਪ ਕਰੋ, if ( n < 0 )
02:07	ਕਰਲੀ ਬਰੈਕੇਟ ਖੋਲੋ । ਐਂਟਰ ਦਬਾਓ ।
02:10	System . out . println ਬਰੈਕੇਟਸ ਅਤੇ ਡਬਲ ਕੋਟਸ ਦੇ ਅੰਦਰ Negative number ( “ਰਿਣਾਤਮਕ ਗਿਣਤੀ” )  ;
02:22	ਅਸੀ ਪਹਿਲਾਂ ਵੇਖਦੇ ਹਾਂ ਕਿ ਗਿਣਤੀ ਇੱਕ ਰਿਣਾਤਮਕ ਗਿਣਤੀ ਹੈ ।
02:25	ਜੇਕਰ ਹਾਂ ਤਾਂ ਅਸੀ ਈਵਨ ਅਤੇ odd ਲਈ ਜਾਂਚ ਨਹੀਂ ਕਰਾਂਗੇ ।
02:29	ਜੇਕਰ ਗਿਣਤੀ ਰਿਣਾਤਮਕ ਨਹੀਂ ਹੈ , ਤਾਂ ਅਸੀ ਈਵਨ ਅਤੇ odd ਲਈ ਜਾਂਚ ਕਰਾਂਗੇ ।
02:34	ਅਗਲੀ ਲਕੀਰ ਵਿੱਚ ਟਾਈਪ ਕਰੋ । else { } ਐਂਟਰ ਦਬਾਓ
02:42	ਹੁਣ ਜੇਕਰ execution , else ਭਾਗ ਉੱਤੇ ਆ ਗਿਆ ਹੈ ।
02:45	ਇਸਦਾ ਮਤਲੱਬ ਹੈ ਕਿ ਗਿਣਤੀ ਗੈਰ - ਰਿਣਾਤਮਕ ਹੈ ।
02:48	ਸੋ ਅਸੀ ਇਸ else ਭਾਗ ਦੇ ਅੰਦਰ ਈਵਨ ਜਾਂ ਔਡ ਲਈ ਜਾਂਚ ਕਰਾਂਗੇ ।
02:52	ਟਾਈਪ ਕਰੋ if ( n modules 2 double equal to 0 ) { ਐਂਟਰ ਦਬਾਓ
03:03	System . out . println ( “even number” )  ; } else { ਐਂਟਰ ਦਬਾਓ ਟਾਈਪ ਕਰੋ System . out . println ( “odd number” )  ; }
03:29	ਸੋ ਅਸੀ ਯਕੀਨੀ ਕਰਾਂਗੇ ਕਿ ਔਡ ਜਾਂ ਈਵਨ ਸੰਖਿਆਵਾਂਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਰਿਣਾਤਮਕਸੰਖਿਆਵਾਂਉੱਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ।
03:34	ਹੁਣ ਅਸੀ ਚੱਲਣ ਵਾਲਾ ਕੋਡ ਵੇਖਦੇ ਹਾਂ ।
03:37	ਫਾਇਲ ਨੂੰ ਸੇਵ ਅਤੇ ਰਨ ਕਰੋ । ਜਿਵੇਂ ਕਿ ਅਸੀ ਵੇਖ ਸੱਕਦੇ ਹਾਂ , ਸਾਨੂੰ ਆਉਟਪੁਟ ਦੇ ਰੂਪ ਵਿੱਚ “ਰਿਣਾਤਮਕ ਗਿਣਤੀ” ( Negative Number ) ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ ।
03:43	ਹੁਣ ਇੱਕ ਧਨਾਤਮਕ ਗਿਣਤੀ ਲੈਂਦੇ ਹਨ ।
03:46	n = - 5 ਨੂੰ n = 5 ਵਿਚ ਬਦਲੋ ।
03:53	ਹੁਣ ਫਾਇਲ ਨੂੰ ਸੇਵ ਅਤੇ ਰਨ ਕਰੋ ।
03:57	ਜਿਵੇਂ ਕਿ ਅਸੀ ਵੇਖ ਸੱਕਦੇ ਹਾਂ , ਆਉਟਪੁਟ ਆਸ਼ਾ ਅਨੁਸਾਰ ਔੱਡ ਗਿਣਤੀ ( odd number ) ਹੈ । ਇੱਕ ਈਵਨ ਗਿਣਤੀ ( even number ) ਲੈਂਦੇ ਹਾਂ ।
04:04	n = 5 ਨੂੰ n = 10 ਵਿਚ ਬਦਲੋ ।
04:09	ਹੁਣ ਫਾਇਲ ਨੂੰ ਸੇਵ ਅਤੇ ਰਨ ਕਰੋ ।
04:12	ਜਿਵੇਂ ਕਿ ਅਸੀ ਵੇਖ ਸੱਕਦੇ ਹਾਂ , ਆਉਟਪੁਟ ਆਸ਼ਾਨੁਰੂਪ “ਈਵਨ ” ਗਿਣਤੀ ( even number ) ਹੈ ।
04:17	ਇੱਕ if ਸਟੇਟਮੇਂਟ ਦੇ ਅੰਦਰ ਦੂੱਜੇ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਦੀ ਇਹ ਪਰਿਕ੍ਰੀਆ , nested - if ਕਾਹੋਉਂਦੀ ਹੈ ।
04:22	nesting ਕਰਨ ਦੀ ਕੋਈ ਸੀਮਾ ਨਹੀਂ ਹੈ ।
04:25	ਪਰ nesting ਦਾ ਤਿੰਨ ਸਤਰਾਂ ਤੋਂ ਅੱਗੇ ਨਾ ਵਧਨਾ ਇੱਕ ਚੰਗੀ ਪਰਿਕ੍ਰੀਆ ਹੈ ।
04:31	ਹੁਣ ਅਸੀ ternary operator ਨੂੰ ਵੇਖਾਂਗੇ ।
04:33	ਪਹਿਲਾਂ ਮੈਂ ਮੇਨ ਮੇਥਡ ਨੂੰ ਹਟਾਉਦਾ ਹਾਂ ।
04:37	ਅਸੀ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਕਹਾਂਗੇ ਜੋ ਗਿਣਤੀ ਨੂੰ 2 ਨਾਲ ਵੰਡਦਾ ਹੈ ।
04:40	ਇਹ ਇੱਕ ਬਹੁਤ ਛੋਟਾ ਪ੍ਰੋਗਰਾਮ ਹੈ ਪਰ ਸਮੱਸਿਆ ਔਡ ਸੰਖਿਆਵਾਂਨੂੰ ਵੰਡਣ ਵਿੱਚ ਆਉਂਦੀ ਹੈ ।
04:45	ਜਦੋਂ 7 , 2 ਨਾਲ ਵੰਡਿਆ ਕੀਤਾ ਜਾਂਦਾ ਹੈ , ਤਾਂ ਸਾਨੂੰ 3 ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ ।
04:48	ਪਰ ਕੀ ਹੁੰਦਾ ਹੈ , ਜਦੋਂ ਅਸੀ ਨਤੀਜੇ ਨੂੰ ਰਾਉਂਡ ਆਫ ਕਰੋ ।
04:50	ਜਿਸਦਾ ਮਤਲੱਬ ਹੈ , ਜਦੋਂ 7 ਨੂੰ 2 ਨਾਲ ਵੰਡਦੇ ਹਾਂ , ਤਾਂ ਸਾਨੂੰ 4 ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ, 3 ਨਹੀਂ ।
04:56	ਸਧਾਰਣ ਸ਼ਬਦਾਂ ਵਿੱਚ , ਅਸੀ ਅਗਲੀ ਗਿਣਤੀ ਲੈਂਦੇ ਹਾਂ ।
04:59	ਅਸੀ ਵੇਖ ਸੱਕਦੇ ਹਨ ਕਿ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਪ੍ਰੋਗਰਾਮ ਕਿਵੇਂ ਲਿਖਦੇ ਹਾਂ ?
05:01	ਮੇਨ ਮੇਥਡ ਦੇ ਅੰਦਰ ਵੇਖੋ ਅਤੇ ਟਾਈਪ ਕਰੋ int n , nHalf
05:08	ਅਸੀ n ਵਿੱਚ ਗਿਣਤੀ ਅਤੇ nHalf ਵਿੱਚ ਅੱਧੀ ਗਿਣਤੀ ਨੂੰ ਸਟੋਰ ਕਰਾਂਗੇ ।
05:13	ਅਗਲੀ ਲਾਇਨ ਵਿੱਚ ਟਾਈਪ ਕਰੋ n = 5 ;
05:18	ਅਗਲੀ ਲਕੀਰ ਵਿੱਚ ਟਾਈਪ ਕਰੋ if ( n  % 2 = = 0 ) { ਐਂਟਰ ਦਬਾਓ
05:28	ਟਾਈਪ ਕਰੋ nHalf = n / 2 ; } else { nHalf = ( n + 1 ) / 2 ; }
05:50	ਅਸੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਗਿਣਤੀ ਈਵਨ ਹੈ ਜਾਂ ਔਡ ਅਤੇ ਉਸਦੇ ਅਨੁਸਾਰ ਵਿਭਾਜਨ ਕਰਦੇ ਹਾਂ ।
05:55	ਹੁਣ ਚਾਲ੍ਲ੍ਲੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਦੇਖਣ ਲਈ ਇੱਕ ਪ੍ਰਿੰਟ ਸਟੇਟਮੇਂਟ ਜੋੜ ਦੇ ਹਾਂ ।
05:59	ਸੋ ਟਾਈਪ ਕਰੋ System . out . println ( nHalf )  ;
06:11	ਹੁਣ ਫਾਇਲ ਨੂੰ ਸੇਵ ਅਤੇ ਰਨ ਕਰੋ
06:14	ਅਸੀ ਵੇਖ ਸੱਕਦੇ ਹਾਂ ਕੀ ਸਾਡਾ ਉਦੇਸ਼ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ । ਸਾਨੂੰ ਆਉਟਪੁਟ ਵਿੱਚ 3 ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ ਅਤੇ 2 ਨਹੀਂ ।
06:21	ਪਰ ਜੇਕਰ ਅਸੀ ਧਿਆਨ ਦਿੰਦੇ ਹਾਂ , ਤਾਂ ਸਭ ਕੁੱਝ ਜੋ ਅਸੀ ਕਰਦੇ ਹਾਂ , ਇੱਕ ਕੰਡੀਸ਼ਨ ਦੇ ਆਧਾਰ ਉੱਤੇ ਵੈਰਿਏਬਲ ਦੀ ਵੈਲਿਊ ਸੇਟ ਕਰਨਾ ਹੈ ।
06:27	ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਲਾਜਿਕ ਤੋਂ ਜਿਆਦਾ ਸਿੰਟੈਕਸ ਹੈ ।
06:31	ਇਹ ਤੱਦ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ternary ਆਪਰੇਟਰ ਕੋਡ ਨੂੰ ਸਧਾਰਣ ਬਣਾਉਂਦਾ ਹੈ ।
06:35	Ternary ਆਪਰੇਟਰ ਇੱਕ ਕੰਡੀਸ਼ਨਲ ਆਪਰੇਟਰ ਹੈ ਜੋ nested - if ਦੇ ਸਮਾਨ ਨਤੀਜਾ ਦਿੰਦਾ ਹੈ ।
06:40	ਇਹ ਇੱਕ ਲਘੂ ਸਿੰਟੈਕਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਕਵੇਸ਼ਚਨ ਮਾਰਕ ( ਪ੍ਰਸ਼ਨਚਿੰਨ ) ਦੁਆਰਾ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ ।
06:45	ਇਹ ਇੱਕ ਵਾਰ ਵਿੱਚ ਤਿੰਨ ਆਪਰੇਂਡਸ ਲੈਂਦਾ ਹੈ ।
06:48	Ternary ਆਪਰੇਟਰ ਦੇ ਸਿੰਟੈਕਸ ਦੇ ਬਾਰੇ ਵਿੱਚ ਸਿਖਦੇ ਹਾਂ ।
06:53	expression ਉਹ ਕੰਡੀਸ਼ਨ ਹੈ ਜਿਸਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਣੀ ਹੈ ।
06:56	ਜੇਕਰ ਕੰਡੀਸ਼ਨ ਟਰੂ ਹੈ ਤਾਂ ਆਪਰੇਂਡ 1 ਵੈਰਿਏਬਲ ਨਤੀਜੇ ਦੀ ਵੈਲਿਊ ਹੈ ।
07:03	ਜੇਕਰ ਕੰਡੀਸ਼ਨ ਫਾਲਸ ਹੈ ਤਾਂ ਆਪਰੇਂਡ 2 ਉਹ ਵੈਲਿਊ ਹੈ ।
07:09	ਹੁਣ ਇਸਨੂੰ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਪ੍ਰਯੋਗ ਕਰਦੇ ਹਾਂ ।
07:12	ਪਹਿਲਾਂ ਅਸੀ if - else ਸਟੇਟਮੇਂਟ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ ।
07:17	ਟਾਈਪ ਕਰੋ nHalf = n  % 2 = = 0  ? n / 2 : ( n + 1 ) / 2 semi - colon
07:41	ਇਹ ਸਟੇਟਮੇਂਟ ਆਉਂਦੀ ਹੈ ,
07:43	ਜੇਕਰ n ਈਵਨ ਹੈ , nHalf n ਬਾਈ 2 ਹੈ , ਨਹੀਂ ਤਾਂ , ਇਹ n ਪਲਸ 1 ਬਾਈ 2 ਹੈ ।
07:50	ਹੁਣ ਇਸਨੂੰ ਪ੍ਰਯੋਗ ਕਰਕੇ ਵੇਖਦੇ ਹਾਂ ।
07:52	ਫਾਇਲ ਨੂੰ ਸੇਵ ਅਤੇ ਰਨ ਕਰੋ । Ctrl S ਅਤੇ Ctrl F11 ਕੀਜ ਦਬਾਓ ।
07:59	ਜਿਵੇਂ ਕਿ ਅਸੀ ਵੇਖ ਸੱਕਦੇ ਹਾਂ , ਆਉਟਪੁਟ ਆਸ਼ਾ ਅਨੁਸਾਰ ਹੈ ।
08:02	ਇਸ ਪ੍ਰਕਾਰ , ternary ਆਪਰੇਟਰ ਕੋਡ ਵਿੱਚ ਕਲਟਰ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ ਅਤੇ ਪੜਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ ।
08:09	ਅਸੀ ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੀ ਅੰਤ ਉੱਤੇ ਪਹੁੰਚ ਗਏ ਹਾਂ ।
08:11	ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਸਿੱਖਿਆ:
08:13	Nested - If ਸਟੇਟਮੇਂਟ ਅਤੇ Ternary ਆਪਰੇਟਰ ਦੇ ਬਾਰੇ
08:15	ਇੱਕ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ Nested - If ਸਟੇਟਮੇਂਟ ਅਤੇ Ternary ਆਪਰੇਟਰ ਦੀ ਵਰਤੋ ਦੇ ਬਾਰੇ
08:22	ਹੁਣ ਇਸ ਉੱਤੇ ਇੱਕ ਅਸਾਇਨਮੈਂਟ ਲੈਂਦੇ ਹਾਂ।
08:23	Nested - If ਅਤੇ Ternary ਆਪਰੇਟਰ । ਇਸ ਉੱਤੇ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ ।
08:28	nested - if ਦਾ ਵਰਤੋ ਕਰਕੇ ਜਾਂਚ ਕਰੋ ਕਿ ਇਹ ਗਿਣਤੀ ਬਰਾਬਰ ਹੈ ਜਾਂ ਨਹੀਂ ਅਤੇ 11 ਦਾ ਮਲਟੀਪਲ ਹੈ ਜਾਂ ਨਹੀਂ ।
08:34	ਆਪਰੇਟਰ ਦਾ ਪ੍ਰਯੋਗ ਕਰਕੇ ਦਿੱਤੀਆਂ ਗਈਆਂ ਦੋ ਸੰਖਿਆਵਾਂ ਦੇ ਵਿੱਚੋ ਵੱਡੀ ਗਿਣਤੀ ਦੀ ਪਹਿਚਾਣ ਕਰੋ ।
08:40	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੇਕਟ ਦੇ ਬਾਰੇ ਵਿੱਚ ਜਿਆਦਾ ਜਾਣਨ ਦੇ ਲਈ , ਇਸ ਲਿੰਕ ਉੱਤੇ ਉੱਤੇ ਉਪਲੱਬਧ ਵੀਡੀਓ ਵੇਖੋ ।
08:45	ਇਹ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੇਕਟ ਨੂੰ ਸਾਰਾਂਸ਼ਿਤ ਕਰਦਾ ਹੈ । ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਚੰਗੀ ਬੈਂਡਵਿਡਥ ਨਹੀਂ ਹੈ , ਤਾਂ ਤੁਸੀ ਇਸਨੂੰ ਡਾਉਨਲੋਡ ਕਰਕੇ ਵੇਖ ਸੱਕਦੇ ਹੋ ।
08:52	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੇਕਟ ਟੀਮ ,
08:54	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਵਰਤੋ ਕਰਕੇ ਵਰਕਸ਼ਾਪਾਂ ਲਗਾਉਂਦੀ ਹੈ ਅਤੇ
08:57	ਜੋ ਆਨਲਾਇਨ ਟੈਸਟ ਪਾਸ ਕਰਦੇ ਹਨ , ਉਨ੍ਹਾਂਨੂੰ ਪ੍ਰਮਾਣ - ਪੱਤਰ ਵੀ ਦਿੰਦੇ ਹਨ । ਜਿਆਦਾ ਜਾਣਕਾਰੀ ਦੇ ਲਈ , ਕ੍ਰਿਪਾ contact AT spoken HYPHEN tutorial DOT org ਉੱਤੇ ਲਿਖੋ ।
09:07	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੇਕਟ , ਟਾਕ - ਟੂ - ਅ - ਟੀਚਰ ਪ੍ਰੋਜੇਕਟ ਦਾ ਹਿੱਸਾ ਹੈ ਅਤੇ
09:11	ਇਹ ਭਾਰਤ ਸਰਕਾਰ ਦੀ MHRD ਦੇ "ਰਾਸ਼ਟਰੀ ਸਾਖਰਤਾ ਮਿਸ਼ਨ ਥ੍ਰੋ ICT " ਰਾਹੀਂ ਸੁਪੋਰਟ ਕੀਤਾ ਗਿਆ ਹੈ।
09:17	ਇਸ ਮਿਸ਼ਨ ਉੱਤੇ ਜਿਆਦਾ ਜਾਣਕਾਰੀ spoken HYPHEN tutorial DOT org SLASH NMEICT HYPHEN Intro ਉੱਤੇ ਉਪਲੱਬਧ ਹੈ
09:26	ਇਹ ਸਕਰਿਪਟ ਹਰਮੀਤ ਸੰਧੂ ਦੁਆਰਾ ਅਨੁਵਾਦਿਤ ਹੈ । ਆਈ ਆਈ ਟੀ ਬੋਮ੍ਬੇ ਵਲੋਂ ਮੈਂ ਹੁਣ ਤੁਹਾਡੇ ਤੋਂ ਵਿਦਾ ਲੈਂਦਾ ਹਾਂ । ਧੰਨਵਾਦ

Contributors and Content Editors

Harmeet, PoojaMoolya