Difference between revisions of "C-and-C++/C2/Relational-Operators/Gujarati"

From Script | Spoken-Tutorial
Jump to: navigation, search
(Created page with ' {| border=1 || ''Time''' || '''Narration''' |- | 00:02 | '''C''' અને '''C++''' માં રીલેશનલ ઓપરેટર્સ પરના સ્પોકન …')
 
Line 354: Line 354:
 
|-
 
|-
 
| 06:12
 
| 06:12
−
| Also we have the '''using '''statement here.  
+
| આપણી પાસે અહીં '''using''' સ્ટેટમેન્ટ પણ છે.
  
 
|-
 
|-
 
| 06:16
 
| 06:16
−
|  The output statement in C++ is '''cout'''.
+
|  C++ માં આઉટપુટ સ્ટેટમેન્ટ '''cout''' છે.
  
 
|-
 
|-
 
| 06:19
 
| 06:19
−
| And the input statement in C++ is''' cin.'''
+
| અને C++ માં ઇનપુટ સ્ટેટમેન્ટ '''cin''' છે.
  
 
|-
 
|-
 
| 06:22
 
| 06:22
−
| So, apart from these differences, the two codes are very similar.
+
| તેથી, આ તફાવતો સિવાય, બે કોડ ખૂબ જ સમાન છે.
  
 
|-
 
|-
 
|06:27
 
|06:27
−
| Click on save.
+
| save.
  
 
|-
 
|-

Revision as of 17:33, 29 July 2013

Time' Narration
00:02 C અને C++ માં રીલેશનલ ઓપરેટર્સ પરના સ્પોકન ટ્યુટોરીયલમાં તમારું સ્વાગત છે.
00:07 આ ટ્યુટોરીયલમાં આપણે શીખીશું:
00;09 રીલેશનલ ઓપરેટર્સ જેવા કે,
00:12 લેસ ધેન : ઉ.દા. a < b
00:15 ગ્રેટર ધેન : ઉ.દા. a > b
00:18 લેસ ધેન ઓર ઇકવલ ટુ : ઉ.દા. a <= b
00:23 ગ્રેટર ધેન ઓર ઇકવલ ટુ : ઉ.દા. a >= b
00:28 ઇકવલ ટુ : ઉ.દા. a == b
00:31 નોટ ઇકવલ ટુ : ઉ.દા. a != b
00:38 આ ટ્યુટોરીયલ રેકોર્ડ કરવા માટે, ઓપરેટિંગ સિસ્ટમ તરીકે હું ઉબુન્ટુ 11.10,
00:43 ઉબુન્ટુમાં gcc અને g++ કમ્પાઇલર આવૃત્તિ 4 .6.1 નો ઉપયોગ કરી રહ્યી છું.
00:50 ચાલો પરિચય સાથે શરૂ કરીએ.
00:53 રીલેશનલ ઓપરેટરો ઈન્ટીજર અને ફ્લોટિંગ પોઇન્ટ નંબરોની તુલના કરવા માટે વપરાય છે.
00:58 એક્સપ્રેશન જે રીલેશનલ ઓપરેટરોનો ઉપયોગ કરે છે તે false માટે 0 અને true માટે 1 return કરે છે.

Return વેલ્યુઝ:

0 જયારે False હોય,

1 જયારે True હોય.

01:04 હવે હું એક C પ્રોગ્રામની મદદ સાથે રીલેશનલ ઓપરેટરોનું નિદર્શન કરીશ.
01:10 મેં પહેલેથી જ પ્રોગ્રામ બનાવ્યો છે.
01:11 તો, હું એડિટર ખોલીશ અને કોડ સમજાવીશ.
01:16 પ્રથમ આપણે બે વેરિયેબલો જાહેર કરીશું, a અને b.
01:21 આ printf સ્ટેટમેન્ટ યુઝરને a અને b ની વેલ્યુ દાખલ કરવા માટે પૂછે છે.
01:27 આ scanf સ્ટેટમેન્ટ વેરિયેબલો a અને b માટે ઇનપુટ લે છે.
01:33 હવે આપણી પાસે ગ્રેટર ધેન ઓપરેટર છે.
01:35 આ ઓપરેટર ઓપરેટરની બીજી બાજુ પરના બે ઓપેરેન્ડને સરખાવે છે.
01:39 તે ફોલ્સ રીટર્ન કરશે જો a એ b કરતાં મોટું છે.
01:44 ઉપરોક્ત કન્ડીશન સાચી હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે.
01:48 જો ઉપરોક્ત કન્ડીશન ખોટી છે તો તે છોડવામાં આવશે.
01:51 પછી કન્ટ્રોલ આગામી સ્ટેટમેન્ટ ઉપર જશે.
01:54 હવે આપણી પાસે લેસ ધેન ઓપરેટર છે.
01:56 આ પણ ઓપેરેન્દ્સ સરખાવે છે.
01:58 તે true રીટર્ન કરશે જયારે a એ b કરતા નાનું હોય.
02:03 ઉપરોક્ત કન્ડીશન સાચી હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે.
02:07 નહી તો છોડવામાં આવશે.
02:09 ચાલો અહીં સુધી કોડ એક્ઝીક્યુટ કરીએ.
02:13 પ્રથમ નીચેનાને કમેન્ટ કરો. ટાઇપ કરો, /* */
02:24 Save ઉપર ક્લિક કરો.
02:26 મેં ફાઈલને relational.c તરીકે સંગ્રહી છે.
02:30 Ctrl, Alt અને T કી એકસાથે દબાવી ટર્મિનલ વિન્ડો ખોલો.
02:36 કમ્પાઈલ કરવા માટે, ટર્મિનલ ઉપર આ કમાંડ ટાઇપ કરો gcc relational.c -o rel
02:50 Enter ડબાઓ.
02:52 એક્ઝીક્યુટ કરવા માટે ટાઇપ કરો, ./rel, Enter ડબાઓ.


02:58 મેં a માટે 8 અને b માટે 3 દાખલ કર્યું છે.
03:02 આઉટપુટ પ્રદર્શિત થયું છે:
03:04 8 is greater than 3.
03:07 તમે અલગ અલગ વેલ્યુઝ સાથે આ કોડ એક્ઝીક્યુટ કરી પ્રયાસ કરી શકો છો.
03:12 કોડ ઉપર પાછા આવો.
03:14 અહીંથી કમેન્ટ રદ કરો અને અહીં મૂકો.
03:24 હવે આપણી પાસે લેસ ધેન ઇકવલ ટુ ઓપરેટર છે.
03:29 આ ઓપરેટર ઓપરેટરની બીજી બાજુ પરના બે ઓપેરેન્દ્સ સરખાવે છે.
03:33 તે true રીટર્ન કરશે જો a એ b કરતા નાનું અથવા બરાબર હોય.
03:39 ઉપરોક્ત કન્ડીશન સાચી હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે.
03:43 જો ઉપરોક્ત કન્ડીશન ખોટી હશે તો તે છોડવામાં આવશે.
03:46 કંટ્રોલ પછી આગળના સ્ટેટમેંટ પર થશે.
03:50 આગળ ગ્રેટર ધેન ઓર ઇકવલ ટુ ઓપરેટર છે.
03:53 તે a અને b સરખાવે છે અને true રીટર્ન કરે છે જો a એ b કરતાં મોટું અથવા બરાબર હોય.
04:01 જો કન્ડીશન true હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે.
04:05 હવે ચાલો કોડ અહીં સુધી એક્ઝીક્યુટ કરીએ.
04:08 Save ઉપર ક્લિક કરો.
04:10 ટર્મિનલ ઉપર ફરી જાઓ.
04:12 પહેલા મુજબ કમ્પાઈલ અને એક્ઝીક્યુટ કરો.
04:17 હું a માટે 8 અને b માટે 3 દાખલ કરીશ.
04:23 આઉટપુટ પ્રદર્શિત થાય છે:
04:25 8 is greater than or equal to 3
04:30 હવે બાકીના કોડ ઉપર પાછા આવો.
04:33 અહીં અને અહીંથી મલ્ટી લાઈન કમેન્ટ રદ કરો.
04:43 આપણી પાસે હવે ઇકવલ ટુ ઓપરેટર છે.
04:47 તે ડબલ ઇકવલ ટુ (==) ચિહ્નો દ્વારા સૂચિત થયેલ છે.
04:50 આ ઓપરેટર true રીટર્ન કરે છે જયારે બંને ઓપેરેન્દ્સ એક બીજા સાથે સમાન હોય.
04:57 આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે જયારે a એ b સમાન હશે.
05:01 જો નહિં, તો કંટ્રોલ આગળના સ્ટેટમેન્ટ પર જશે.
05:06 તેવી જ રીતે, આપણી પાસે નોટ ઇકવલ ટુ ઓપરેટર છે.
05:09 આ ઓપરેટર true રીટર્ન કરશે જયારે ઓપેરેન્દ્સ એક બીજા સાથે સમાન નથી.
05:15 આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે જયારે a એ b સમાન નથી.
05:21 પ્રોગ્રામના અંતે આવીએ.

Return 0;

05:24 Save ઉપર ક્લિક કરો.
05:26 ટર્મિનલ ઉપર ફરી જાઓ.
05:28 પેહલા મુજબ કમ્પાઈલ અને એક્ઝીક્યુટ કરો.
05:33 a માટે 8 અને b માટે 3 દાખલ કરો.
05:39 આઉટપુટ સ્ક્રીન પર દર્શાવવામાં આવે છે:
05:41 8 is not equal to 3
05:45 તો, આપણે જોયું કે રીલેશનલ ઓપરેટરો કેવી રીતે કાર્ય કરે છે.
05:48 ઇનપુટ્સના અલગ સમૂહ સાથે આ કોડ એક્ઝીક્યુટ કરવાનો પ્રયાસ કરો.
05:52 હવે, C++ માં આ સમાન પ્રોગ્રામ લખવો સરળ છે.
05:56 સિન્ટેક્ષમાં થોડો તફાવત છે.
06:00 મેં પહેલેથી જ C++ માં પ્રોગ્રામ લખ્યો છે.
06:04 રીલેશનલ ઓપરેટરો માટે C++ માં કોડ છે.
06:09 નોંધ લો કે હેડર અલગ છે.
06:12 આપણી પાસે અહીં using સ્ટેટમેન્ટ પણ છે.
06:16 C++ માં આઉટપુટ સ્ટેટમેન્ટ cout છે.
06:19 અને C++ માં ઇનપુટ સ્ટેટમેન્ટ cin છે.
06:22 તેથી, આ તફાવતો સિવાય, બે કોડ ખૂબ જ સમાન છે.
06:27 save.
06:29 Please make sure the file is saved with the extension .cpp
06:33 I have saved my file as relational.cpp
06:38 Let's compile the code.
06:40 Open the terminal and type g++ relational.cpp -o rel1
06:51 To execute Type './ rel1, Press Enter.


06:57 I enter a as 8 and b as 3.
07:01 The output is displayed:
07:03 We see that the output is same as the one in C code.
07:08 Now let us see an error which we can come across.
07:11 Come back to the program
07:13 Suppose here we replace the double equal to sign with the single equal to.
07:20 Click on Save.
07:21 Come back to the terminal.
07:24 Compile and execute as before.
07:34 Here we see it is showing 3 is equal to 3.
07.38 Come back to our program
07:40 This is because here we have an assignment operator.
07:44 So value of b is assigned to a.
07:47 Now Let us fix this error.
07:49 Type an equal to sign.
07:52 Click on Save
07:55 Switch back to the terminal
07:56 compile and execute as before.
08:04 The output is now correct.
08:06 Let's summarize the tutorial.
08:09 In this tutorial, we learnt
08:10 Relational operators like
08:12 Less than: eg. a b
08:18 Less than or equal to: eg. a<=b
08:23 Greater than or equal to: eg. a>=b
08:27 Equal to: eg. a==b
08:30 Not equal to: eg. a!=b
08:34 As an assignment
08:35 Write a program that takes the marks of three students as input.
08:40 Compare the marks to see which student has scored the highest.
08:44 Check also if two or more students have scored equal marks.
08:49 Watch the video available at the following link
08:51 It summarises the Spoken Tutorial project
08:54 If you do not have good bandwidth, you can download and watch it


08:58 The Spoken Tutorial Project Team
09:00 Conducts workshops using spoken tutorials
09:03 Gives certificates for those who pass an online test
09:06 For more details, please write to contact at spoken hyphen tutorial dot org


09:14 Spoken Tutorial Project is a part of the Talk to a Teacher project
09:18 It is supported by the National Mission on Education through ICT, MHRD, Government of India
09:24 More information on this Mission is available at
09:27 spoken hyphen tutorial dot org slash NMEICT hyphen Intro


09:35 This is Ritwik Joshi from IIT Bombay.

Thank you for joining.

Contributors and Content Editors

Krupali, Pratik kamble

Retrieved from "https://script.spoken-tutorial.org/index.php?title=C-and-C%2B%2B/C2/Relational-Operators/Gujarati&oldid=5409"