1
00:00:00,000 --> 00:00:05,960
>> [સંગીત વગાડવાનો]

2
00:00:05,960 --> 00:00:08,540
>> ડો LLOYD: હાય, તેથી ચાલો
સી માં ઓપરેટરો વિશે વાત

3
00:00:08,540 --> 00:00:12,590
તેથી, અમે પહેલાથી જ એક જોઇ છે, હકીકતમાં,
સોંપણી ઓપરેટર સમકક્ષ હોય છે.

4
00:00:12,590 --> 00:00:15,510
તે અમને માત્ર મૂકવા માટે પરવાનગી આપે
એક ચલ એક મૂલ્ય.

5
00:00:15,510 --> 00:00:18,046
તે સોંપણી છે
ઓપરેટર, એક સમાન સાઇન.

6
00:00:18,046 --> 00:00:20,670
ચાલાકી કરવા માટે અને કામ
સી મૂલ્યો અને ચલો સાથે,

7
00:00:20,670 --> 00:00:23,710
અમે ઓપરેટરો એક નંબર હોય
અમારા નિકાલ પર અમે ઉપયોગ કરી શકો છો.

8
00:00:23,710 --> 00:00:25,543
માતાનો પર એક નજર કરીએ
સામાન્ય મુદ્દાઓ કેટલાક

9
00:00:25,543 --> 00:00:27,430
અંકગણિત ઓપરેટરો સાથે શરૂ થાય છે.

10
00:00:27,430 --> 00:00:31,080
તમે અપેક્ષા રાખી શકો છો, અમે કરી શકો છો
સી માં ખૂબ મૂળભૂત ગણિત કામગીરી

11
00:00:31,080 --> 00:00:36,520
અમે ઉમેરવા, સબ્ટ્રેક્ટ, મલ્ટીપ્લાય, અને કરી શકો છો
વત્તા ઉપયોગ વિભાજન નંબરો, ઓછા, સ્ટાર,

12
00:00:36,520 --> 00:00:38,422
અને અનુક્રમે સ્લેશ.

13
00:00:38,422 --> 00:00:40,630
અહીં રેખાઓ એક દંપતિ છે
કોડ જેમાં અમે તે કરવા.

14
00:00:40,630 --> 00:00:44,150
તેથી, અમે પૂર્ણાંક એક્સ વાય વત્તા 1 બરાબર છે.

15
00:00:44,150 --> 00:00:46,460
માતાનો ક્યાંક છે કે ધારે દો
કોડ આ વાક્ય ઉપર

16
00:00:46,460 --> 00:00:49,230
અમે પૂર્ણાંક વાય 10 બરાબર હતું.

17
00:00:49,230 --> 00:00:55,790
X ની કિંમત હું પછી શું છે
કોડ આ પ્રથમ વાક્ય ચલાવવા?

18
00:00:55,790 --> 00:00:56,700
તમે 11 કહે છે?

19
00:00:56,700 --> 00:00:57,910
તમે જમણી છો.

20
00:00:57,910 --> 00:00:58,420
શા માટે છે?

21
00:00:58,420 --> 00:00:59,790
વેલ, વાય 10 હતી.

22
00:00:59,790 --> 00:01:03,215
કેટલાક હું કહી રહ્યો છું પૂર્ણાંક x 10 વત્તા 1 સમકક્ષ હોય છે.

23
00:01:03,215 --> 00:01:04,269
10 વત્તા 1 11 છે.

24
00:01:04,269 --> 00:01:08,540
તેથી, કિંમત 11 નહીં
ચલ x માં સંગ્રહાય છે.

25
00:01:08,540 --> 00:01:09,740
ખૂબ ખરાબ નથી, અધિકાર?

26
00:01:09,740 --> 00:01:14,040
>> કેવી રીતે આ આગામી રેખા વિશે
કોડ? એક્સ એક્સ વખત 5 સમકક્ષ હોય છે.

27
00:01:14,040 --> 00:01:17,700
વેલ, તે પહેલાં અમે ચલાવવામાં
કોડ આ વાક્ય, એક્સ 11 હતી.

28
00:01:17,700 --> 00:01:21,237
તેથી, મૂલ્ય શું છે
X કોડ આ વાક્ય પછી?

29
00:01:21,237 --> 00:01:21,820
બીજી લો.

30
00:01:21,820 --> 00:01:24,710

31
00:01:24,710 --> 00:01:27,620
તેથી, એક્સ એક્સ વખત 5 સમકક્ષ હોય છે.

32
00:01:27,620 --> 00:01:29,850
x 11 હતી.

33
00:01:29,850 --> 00:01:32,970
તેથી, x 11 ગુણ્યા 5 સમકક્ષ હોય છે.

34
00:01:32,970 --> 00:01:34,360
અથવા 55.

35
00:01:34,360 --> 00:01:36,490
તમે 55 જણાવ્યું હતું કે, તો તમે યોગ્ય હશો.

36
00:01:36,490 --> 00:01:41,770
>> હવે, તે થોડો ગૂંચવણમાં મૂકે હોઈ શકે છે, પરંતુ
કે સોંપણી સી જે રીતે કામ કરે સાથે

37
00:01:41,770 --> 00:01:46,030
જમણી બાજુ પર મૂલ્ય નહીં છે
ડાબી પર કિંમત આઈડી.

38
00:01:46,030 --> 00:01:49,090
તેથી, પ્રથમ અમે એક્સ વખત 5 મૂલ્યાંકન.

39
00:01:49,090 --> 00:01:50,800
તેથી, 11 ગુણ્યા 5 55 છે.

40
00:01:50,800 --> 00:01:53,340
અને પછી અમે એક્સ કિંમત સ્ટોર કરે છે.

41
00:01:53,340 --> 00:01:56,100
ત્યાં હતી કે 11
પહેલાં હવે ફરીથી લખાઈ છે.

42
00:01:56,100 --> 00:01:58,280
તેથી એક્સ કિંમત હવે 55 છે.

43
00:01:58,280 --> 00:02:00,820
આશા છે કે એકદમ સરળ છે.

44
00:02:00,820 --> 00:02:04,246
>> તમે કર્યું કે અન્ય ઓપરેટર છે
કદાચ જરૂરી સાંભળ્યું ન

45
00:02:04,246 --> 00:02:06,620
આ કહેવાય છે, પરંતુ તમે કરેલા
ચોક્કસપણે ભૂતકાળમાં સાથે કામ કર્યું હતું

46
00:02:06,620 --> 00:02:09,470
તમે લાંબા તમારા દિવસો યાદ તો
પાછા ગ્રેડ શાળા વિભાગ રીતે.

47
00:02:09,470 --> 00:02:11,270
તે મોડ્યુલસ ઓપરેટર કહેવાય છે.

48
00:02:11,270 --> 00:02:13,620
શું મોડ્યુલસ કરે છે તે છે
તમે બાકીની આપે

49
00:02:13,620 --> 00:02:15,400
તમે એક સાથે બે નંબર વિભાજિત છે.

50
00:02:15,400 --> 00:02:21,750
હું કહી તેથી જો, 13 ભાગ્યા
4, બાકીની શું છે?

51
00:02:21,750 --> 00:02:24,860
અને તે કિંમત ગણવામાં આવશે
આ મોડ્યુલસ ઓપરેટર દ્વારા.

52
00:02:24,860 --> 00:02:28,320
>> તેથી, હું કોડ એક વાક્ય છે
અહીં, પૂર્ણાંક એમ 13 ફેરફારની 4 સમકક્ષ હોય છે.

53
00:02:28,320 --> 00:02:31,960
અને હું એક ટિપ્પણી અહીં કહે છે
કે એમ કિંમત હવે 1 હોય છે.

54
00:02:31,960 --> 00:02:32,750
હું શા માટે કહે છે કે નથી?

55
00:02:32,750 --> 00:02:36,270
વેલ, લાંબા વિભાગ બહાર કરવા માટે, તમારા
વડા તમે એક બીજા માટે મારી સાથે સહન તો.

56
00:02:36,270 --> 00:02:40,070
તેથી, હું 4 13 દ્વારા વિભાજિત છે.

57
00:02:40,070 --> 00:02:44,087
4 13 ત્રણ વખત જાય
1 ની બાકીની સાથે.

58
00:02:44,087 --> 00:02:45,920
તેથી, મૂળભૂત રીતે, બધી
મોડ્યુલસ ઓપરેટર કરે

59
00:02:45,920 --> 00:02:48,600
તે તમને જ્યારે તમને કહે છે
વિભાજન, તમે બાકીની મળે છે.

60
00:02:48,600 --> 00:02:51,420
તમે કે ખરેખર છે લાગે શકે છે
નથી એક ભયંકર ઉપયોગી વસ્તુ છે,

61
00:02:51,420 --> 00:02:54,350
પરંતુ તમે ખરેખર આશ્ચર્ય શકાય છો
કેવી રીતે વારંવાર કે મોડ્યુલસ દ્વારા

62
00:02:54,350 --> 00:02:55,820
ઓપરેટર હાથમાં આવી શકે છે.

63
00:02:55,820 --> 00:02:58,420
>> સમસ્યાઓ એક દંપતિ છે
અમે તેની સાથે વ્યવહાર કે CS50 કરીશ.

64
00:02:58,420 --> 00:03:00,545
તે પણ કરી માટે સારી છે
રેન્ડમ નંબર જેવી વસ્તુઓ.

65
00:03:00,545 --> 00:03:03,850
તેથી, ઉદાહરણ તરીકે જો તમે ક્યારેય કર્યું છે, તો
રેન્ડમ નંબર જનરેટર સાંભળ્યું,

66
00:03:03,850 --> 00:03:06,620
કે તમે એક નંબર આપી રહ્યું છે
0 થી કેટલાક વિશાળ સંખ્યા છે.

67
00:03:06,620 --> 00:03:10,390
પરંતુ કદાચ તમે ખરેખર માત્ર
0 થી 20 નંબર જરૂર છે.

68
00:03:10,390 --> 00:03:13,425
તમે મોડ્યુલસ ઓપરેટર વાપરો તો
કે વિશાળ નંબર પર

69
00:03:13,425 --> 00:03:17,080
આ દ્વારા પેદા નહીં
રેન્ડમ નંબર જનરેટર,

70
00:03:17,080 --> 00:03:20,230
તમે લેવા માટે જઈ રહ્યાં છો ગમે
તે વિશાળ કિંમત, 20 દ્વારા વિભાજીત

71
00:03:20,230 --> 00:03:21,210
અને બાકીની મળે છે.

72
00:03:21,210 --> 00:03:24,050
બાકીની કરી શકો
0 થી 19 કિંમત હોય છે.

73
00:03:24,050 --> 00:03:27,140
તેથી, જો તમે મોડ્યુલસ ઓપરેટર ઉપયોગ
આ વિશાળ સંખ્યા લેવા માટે

74
00:03:27,140 --> 00:03:29,640
અને નીચે કંઈક માં કમી તે
થોડી વધુ અર્થપૂર્ણ.

75
00:03:29,640 --> 00:03:31,764
હું તમને હશો ખૂબ ખાતરી છું
તે બંને વાપરવા માટે સમર્થ

76
00:03:31,764 --> 00:03:34,710
CS50 માં ભવિષ્યમાં અમુક બિંદુએ.

77
00:03:34,710 --> 00:03:37,030
>> તેથી, સી પણ અમને માર્ગ આપે છે
એક અંકગણિત લાગુ કરવા માટે

78
00:03:37,030 --> 00:03:39,910
એક ચલ ઓપરેટર
થોડી વધુ લઘુલિપિ રીતે.

79
00:03:39,910 --> 00:03:44,520
તેથી, જે અગાઉના સ્લાઇડ,
અમે એક્સ એક્સ વખત 5 બરાબર જોયું.

80
00:03:44,520 --> 00:03:45,260
તે કામ કર્યું હતું.

81
00:03:45,260 --> 00:03:47,660
એક્સ વખત 5 પછી એક્સ પાછા સંગ્રહિત નહીં.

82
00:03:47,660 --> 00:03:52,490
તે કરવા માટે ટૂંકા માર્ગ વિચાર છે,
અને તે વાક્યરચના એક્સ વખત 5 બરાબર છે.

83
00:03:52,490 --> 00:03:55,020
તે જ ચોક્કસ વાત છે
કહીને એક્સ એક્સ વખત 5 સમકક્ષ હોય છે.

84
00:03:55,020 --> 00:03:56,824
તે માત્ર થોડી છે
તે શું ટૂંકા માર્ગ.

85
00:03:56,824 --> 00:03:58,740
અને જો તમે કેટલાક જુઓ ત્યારે
વિતરણ કોડ અથવા તમે

86
00:03:58,740 --> 00:04:01,287
કેટલાક નમૂના કોડ જુઓ કે
આ જેવી વસ્તુઓ કરે છે,

87
00:04:01,287 --> 00:04:03,120
માત્ર સાથે પરિચિત હોવા
વાક્યરચના થાય છે.

88
00:04:03,120 --> 00:04:05,980
તમે ચોક્કસપણે નથી
જો તમે કરો તેનો ઉપયોગ છે, પરંતુ,

89
00:04:05,980 --> 00:04:08,235
તે તમારા કોડ બનાવવા શકે છે
થોડી slicker જુઓ.

90
00:04:08,235 --> 00:04:11,360
અને તમે પણ કોઇ ઉપયોગ કરી શકો છો કે જે ખબર
વિવિધ ઓપરેટરો અમે પહેલાથી જ કર્યું છે

91
00:04:11,360 --> 00:04:12,660
પહેલાં બદલે વખત જોવા મળે છે.

92
00:04:12,660 --> 00:04:16,720
તમે એક્સ વત્તા 5, ઓછા બરાબર કહી શકે
5, વખત, ભાગાકાર, અને ફેરફારની સમકક્ષ હોય છે.

93
00:04:16,720 --> 00:04:18,959
તે કામ કરે છે.

94
00:04:18,959 --> 00:04:21,089
>> કંઈક પણ છે
સી કે જેથી સામાન્ય છે

95
00:04:21,089 --> 00:04:24,080
અમે નક્કી કર્યું છે કે
પણ વધુ કે રિફાઇન.

96
00:04:24,080 --> 00:04:26,916
1 દ્વારા એક ચલ incrementing
અથવા 1 એક ચલ decrementing

97
00:04:26,916 --> 00:04:30,040
જેમ કે એક સામાન્ય વસ્તુ ખાસ કરીને છે
અમે વાત ત્યારે વિશે પછી થોડી આંટીઓ

98
00:04:30,040 --> 00:04:35,240
થઈ અમે બદલે નક્કી કર્યું છે કે
, એક્સ વત્તા કંઈક 1 સમકક્ષ કહેતા

99
00:04:35,240 --> 00:04:40,190
અથવા એક્સ એક્સ વત્તા 1 બરાબર, અમે પણ કર્યું
ટૂંકા કે એક્સ વત્તા વત્તા આપ્યો.

100
00:04:40,190 --> 00:04:46,940
તેથી, એક્સ એક્સ વત્તા 1, એક્સ બરાબર વત્તા 1 બરાબર,
અને X વત્તા વત્તા બધા જ વસ્તુ નથી.

101
00:04:46,940 --> 00:04:48,470
તેઓ 1 દ્વારા બધા ઈજાફો એક્સ ઓનલાઇન.

102
00:04:48,470 --> 00:04:50,630
પરંતુ તે incrementing
અને 1 દ્વારા decrementing

103
00:04:50,630 --> 00:04:54,110
અમે હોય છે કે જેથી સામાન્ય છે
વત્તા પ્લસ અને માઈનસ ઓછા

104
00:04:54,110 --> 00:04:59,140
કે અમને લઘુલિપિ માટે પરવાનગી આપે છે
પણ વધુ છે.

105
00:04:59,140 --> 00:05:02,110
>> તેથી, ચાલો બીજા માટે Gears સ્વિચ દો
અને બુલિયન સમીકરણો વિશે વાત કરો.

106
00:05:02,110 --> 00:05:06,340
પણ પ્રકારની હોય છે જે તમામ વિભાજિત
ઓપરેટરો એકંદર શ્રેણી.

107
00:05:06,340 --> 00:05:09,030
પરંતુ બુલિયન સમીકરણો,
અંકગણિત ઓપરેટરો જેમ નહિં પણ,

108
00:05:09,030 --> 00:05:11,860
કિંમતો સરખામણી માટે વપરાય છે.

109
00:05:11,860 --> 00:05:15,550
સી તેથી, ફરી, બધા બુલિયન સમીકરણો
બે શક્ય કિંમતો એક મૂલ્યાંકન

110
00:05:15,550 --> 00:05:16,050
યાદ.

111
00:05:16,050 --> 00:05:17,740
સાચું કે ખોટું.

112
00:05:17,740 --> 00:05:21,880
કે જે આ જ બે કિંમતો છે કે
બુલિયન ચલ પર લાગી શકે છે.

113
00:05:21,880 --> 00:05:25,780
અમે પરિણામો ઉપયોગ કરી શકો છો
બુલિયન અભિવ્યક્તિ

114
00:05:25,780 --> 00:05:27,650
પ્રોગ્રામિંગ ઘણી બધી રીતે છે.

115
00:05:27,650 --> 00:05:29,400
હકીકતમાં, તમે રહેશો
આ તદ્દન ઘણો કરી.

116
00:05:29,400 --> 00:05:32,870
>> ઉદાહરણ તરીકે, અમે નક્કી કરી શકે છે,
વેલ, કેટલાક પરિસ્થિતિ સાચું હોય,

117
00:05:32,870 --> 00:05:34,665
કદાચ હું આ લેવા પડશે
મારી કોડ નીચે શાખા.

118
00:05:34,665 --> 00:05:35,980
એક શરતી છે, તેથી વાત કરવા માટે.

119
00:05:35,980 --> 00:05:37,970
અમે તરત જ તે વિશે જાણવા મળશે.

120
00:05:37,970 --> 00:05:40,560
અથવા કદાચ તરીકે લાંબા સમય સુધી
આ હું માંગો છો, સાચું છે

121
00:05:40,560 --> 00:05:42,790
આ કરી રાખવા માટે
ઉપર અને ઉપર અને ઉપર.

122
00:05:42,790 --> 00:05:43,480
એક લૂપ.

123
00:05:43,480 --> 00:05:48,350
બંને કિસ્સાઓમાં, અમે ઉપયોગ કરી રહ્યાં છો ખબર છે કે
સાચું કે ખોટું એક બુલિયન અભિવ્યક્તિ,

124
00:05:48,350 --> 00:05:52,411
કે નહીં તે નક્કી કરવા માટે
ચોક્કસ પાથ લેવા માટે.

125
00:05:52,411 --> 00:05:54,660
ક્યારેક જ્યારે અમે કામ કરી રહ્યા છીએ
બુલિયન અભિવ્યક્તિઓ સાથે,

126
00:05:54,660 --> 00:05:56,410
અમે પ્રકાર bool ઓફ ચલો ઉપયોગ કરશે.

127
00:05:56,410 --> 00:05:58,461
તમે જાહેર કર્યું છે શકે છે
એક bool, ચલ ટાઇપ

128
00:05:58,461 --> 00:06:00,210
અને તમે ઉપયોગ કરશો તમારા
બુલિયન અભિવ્યક્તિ.

129
00:06:00,210 --> 00:06:02,130
પરંતુ તમે હંમેશા કરવા નથી.

130
00:06:02,130 --> 00:06:06,690
તે, સી, દરેક બિન-0 બહાર વળે તરીકે
કિંમત સાચી કહીને તરીકે જ છે.

131
00:06:06,690 --> 00:06:10,680
તમે જાહેર કર્યું હતું, તો
પ્રકાર બુલિયન ચલ,

132
00:06:10,680 --> 00:06:14,240
અને તે છે, સાચું તે કિંમત સોંપાયેલ
પૂર્ણાંક જાહેર તરીકે જ

133
00:06:14,240 --> 00:06:17,410
અને તે કિંમત સોંપણી
1, 2, 3, અથવા ખરેખર કોઇ કિંમત

134
00:06:17,410 --> 00:06:19,580
0 કરતાં અન્ય બિલકુલ.

135
00:06:19,580 --> 00:06:22,690
સી, કારણ કે દરેક નોન-કિંમત 0 સાચું છે.

136
00:06:22,690 --> 00:06:24,820
0, બીજી બાજુ પર, ખોટું છે.

137
00:06:24,820 --> 00:06:27,162
આ માં આવી શકે છે
ખબર પાછળથી હાથમાં,

138
00:06:27,162 --> 00:06:28,620
પરંતુ માત્ર કંઈક ધ્યાનમાં રાખવા.

139
00:06:28,620 --> 00:06:31,890
અમે હંમેશા ઉપયોગ કરવાની જરૂર નથી
બુલિયન પ્રકાર ચલો ત્યારે અમે

140
00:06:31,890 --> 00:06:34,980
બુલિયન અભિવ્યક્તિઓ સાથે કામ કરે છે.

141
00:06:34,980 --> 00:06:37,890
>> બુલિયન બે મુખ્ય પ્રકારો છે
અમે સાથે કામ કરીશું કે અભિવ્યક્તિઓ.

142
00:06:37,890 --> 00:06:40,640
તર્કસંગત ચાલકો અને
સંબંધ ઓપરેટરો.

143
00:06:40,640 --> 00:06:42,640
ત્યાં છે ભાષા
ભયંકર મહત્વની નથી.

144
00:06:42,640 --> 00:06:44,970
હું તેમને જૂથ છું માત્ર કેવી રીતે ખરેખર છે.

145
00:06:44,970 --> 00:06:49,222
અને તમે ચોક્કસપણે પડશે, હું ઝડપથી લાગે છે,
એક સંબંધ ઓપરેટર છે શું ખ્યાલ

146
00:06:49,222 --> 00:06:51,680
પર આધારિત છે તેઓ શું છે જ્યારે અમે
બીજા તેમને વિશે વાત કરો.

147
00:06:51,680 --> 00:06:54,250
પરંતુ જરૂરી વિશે ચિંતા કરશો નહીં
શબ્દ લોજીકલ ઓપરેટર યાદ

148
00:06:54,250 --> 00:06:55,460
અથવા સંબંધ ઓપરેટર.

149
00:06:55,460 --> 00:07:00,070
હું માત્ર જૂથ તેનો ઉપયોગ કરું છું
તેમને લોજિકલ રીતે.

150
00:07:00,070 --> 00:07:02,620
>> તેથી, ચાલો એક નજર કરીએ
ત્રણ લોજિકલ ઓપરેટરો

151
00:07:02,620 --> 00:07:04,970
અમે ખૂબ જોશો કે
CS50 માં પ્રોગ્રામિંગ બીટ

152
00:07:04,970 --> 00:07:06,710
અને પ્રોગ્રામિંગ વધુ સામાન્ય રીતે.

153
00:07:06,710 --> 00:07:10,470
લોજિકલ અને સાચું છે, તો
માત્ર બંને operands સાચું હોય તો.

154
00:07:10,470 --> 00:07:11,775
નહિંતર ખોટું.

155
00:07:11,775 --> 00:07:12,650
કે જ્યાં અર્થ છે?

156
00:07:12,650 --> 00:07:15,840
તેથી, હું એક છું કહે છે કે દો
મારી પાસે મારા કોડ નિર્દેશ

157
00:07:15,840 --> 00:07:18,310
બે ચલો, એક્સ અને વાય.

158
00:07:18,310 --> 00:07:21,620
અને હું કે નહીં તે નક્કી કરવા માંગો છો
મારા કોડ માં કંઈક કરવા માટે

159
00:07:21,620 --> 00:07:25,780
એક્સ સાચું છે અને વાય સાચું છે, તો પર આધારિત છે.

160
00:07:25,780 --> 00:07:27,730
હું માત્ર જો તે કરવા માંગો છો
તેમને બંને સાચા હોય

161
00:07:27,730 --> 00:07:30,980
અન્યથા હું કે નીચે જવા માટે નથી માંગતા
પાથ તે મને મદદ કરવા માટે નથી જતા હોય છે કારણ કે.

162
00:07:30,980 --> 00:07:37,420
શું હું કહી શકો છો X & તો વાય છે.

163
00:07:37,420 --> 00:07:42,380
તે લોજિકલ બુલિયન હશે
અભિવ્યક્તિ સરખામણી એક્સ અને વાય

164
00:07:42,380 --> 00:07:45,240
અને ચોક્કસ પાથ લેવા
તેમની કિંમતો શું છે તેના પર આધારિત છે.

165
00:07:45,240 --> 00:07:48,400
એક્સ સાચું છે અને તેથી જો, વાય સાચું છે
અહીં આ સત્ય ટેબલ પર આધારિત છે,

166
00:07:48,400 --> 00:07:50,430
માત્ર પછી અમે તે પાથ નીચે જશે.

167
00:07:50,430 --> 00:07:52,940
એક્સ, & વાય છે.

168
00:07:52,940 --> 00:07:58,320
તે માત્ર ત્યારે જ true-- અને માત્ર છે છે
એક્સ સાચું છે અને વાય સાચું છે જો સાચું હોય.

169
00:07:58,320 --> 00:08:00,850
ક્યાં તો એક ખોટું છે, તો
અમે સત્ય ટેબલ જુઓ,

170
00:08:00,850 --> 00:08:02,370
પછી એક્સ અને વાય બંને સાચું નથી.

171
00:08:02,370 --> 00:08:07,660
અને તેથી, એક્સ અને વાય અને ખોટી છે.

172
00:08:07,660 --> 00:08:12,044
>> લોજિકલ અથવા તો જ સાચું છે
ઓછામાં ઓછા એક operand સાચું હોય તો.

173
00:08:12,044 --> 00:08:12,710
નહિંતર ખોટું.

174
00:08:12,710 --> 00:08:15,760
તેથી તાર્કિક અને જરૂરી
એક્સ અને વાય બંને વાત સાચી છે.

175
00:08:15,760 --> 00:08:21,185
લોજિકલ અથવા સાચું કે વાય હોઈ X જરૂરી
વાત સાચી છે અથવા બંને એક્સ અને વાય સાચું હોય છે.

176
00:08:21,185 --> 00:08:23,310
તેથી, ફરી, અમે પ્રકારની શોધવા
પરિસ્થિતિ જાતને

177
00:08:23,310 --> 00:08:26,460
અમે અમારા કોડ જઈ રહ્યાં છો જ્યાં,
અને અમે માર્ગ એક કાંટો સુધી પહોંચી હતી.

178
00:08:26,460 --> 00:08:29,850
અને અમે એક નીચે જવા માંગો છો
વિશેષ માર્ગ એક્સ સાચું છે, તો

179
00:08:29,850 --> 00:08:33,299
અથવા વાય સાચું છે, પરંતુ
જરૂરી હોય તો બંને સાચા છે.

180
00:08:33,299 --> 00:08:35,830
પરંતુ કદાચ જો બંને સાચા છે.

181
00:08:35,830 --> 00:08:38,460
એક્સ સાચું છે અને તેથી જો વાય છે
સાચું, અમે તે પાથ નીચે જવા પડશે.

182
00:08:38,460 --> 00:08:39,066
એક્સ સાચું છે.

183
00:08:39,066 --> 00:08:40,190
તેમાંથી એક છે, અધિકાર વાત સાચી છે?

184
00:08:40,190 --> 00:08:42,080
એક્સ સાચું છે અને વાય સાચું છે.

185
00:08:42,080 --> 00:08:44,910
એક્સ સાચું છે, અને વાય ખોટા હોય તો,
તેમને એક હજુ પણ સાચું છે.

186
00:08:44,910 --> 00:08:48,020
તેથી, એક્સ અથવા વાય હજુ પણ સાચું છે.

187
00:08:48,020 --> 00:08:52,290
X ખોટું છે, અને વાય સાચું હોય, તો
તેમને એક યોગ્ય, હજુ પણ સાચું છે?

188
00:08:52,290 --> 00:08:53,290
વાય આ કિસ્સામાં, સાચું છે.

189
00:08:53,290 --> 00:08:57,950
તેથી, તે એક્સ અથવા વાય સાચું છે કે સાચું છે.

190
00:08:57,950 --> 00:09:02,620
X ખોટું છે અને વાય ખોટું છે તો જ
અમે તે પાથ નીચે ન જાય,

191
00:09:02,620 --> 00:09:04,454
X ન વાય ન સાચું છે કારણ કે.

192
00:09:04,454 --> 00:09:06,370
હવે, તમે જોઈ રહ્યાં છો, તો
સ્ક્રીન પર હમણાં

193
00:09:06,370 --> 00:09:09,062
અને તે શું છે તે આશ્ચર્ય
પ્રતીક લોજિકલ અથવા માટે છે,

194
00:09:09,062 --> 00:09:10,270
તે ઊભી પટ્ટી કહેવાય છે.

195
00:09:10,270 --> 00:09:13,730
અને જો તમે તમારા કીબોર્ડ પર જોઈ
એક મિનિટ માટે, હું હવે કરી રહ્યો છું તરીકે,

196
00:09:13,730 --> 00:09:16,940
તે માત્ર ઉપર સામાન્ય રીતે
કી દાખલ કરો, મોટા ભાગના કીબોર્ડ પર,

197
00:09:16,940 --> 00:09:19,630
બેકસ્લેશ તરીકે જ કી પર.

198
00:09:19,630 --> 00:09:22,790
તે પણ સામાન્ય રીતે સાચું છે
ચોરસ કૌંસ માટે આગામી.

199
00:09:22,790 --> 00:09:27,240
તેથી, તે કી હોઇ શકે છે કે જે તમે
ભૂતકાળમાં ખૂબ ટાઇપ નથી.

200
00:09:27,240 --> 00:09:29,700
પરંતુ, તમે ક્યારેય કરી રહ્યાં છો, તો
લોજિકલ સરખામણીઓ,

201
00:09:29,700 --> 00:09:31,882
અમે કરી આવશે તરીકે
દરમિયાન ઘણો છે, તે છે

202
00:09:31,882 --> 00:09:33,840
ઉપયોગી હોઈ ચાલે
કે કી શોધવા અને ઉપયોગ કરે છે.

203
00:09:33,840 --> 00:09:38,340
તેથી, તે જ કી પર સામાન્ય રીતે છે
બેકસ્લેશ માત્ર ઉપર દાખલ કરો.

204
00:09:38,340 --> 00:09:39,757
>> અંતિમ લોજીકલ ઓપરેટર નથી.

205
00:09:39,757 --> 00:09:41,131
નથી અને ખૂબ સરળ છે.

206
00:09:41,131 --> 00:09:42,830
તે તેના operand ની કિંમત ઉલટુ કરે છે.

207
00:09:42,830 --> 00:09:46,080
એક્સ સાચું છે, તો પછી એક્સ ખોટું છે.

208
00:09:46,080 --> 00:09:49,960
X ખોટું છે, તો પછી એક્સ સાચું છે.

209
00:09:49,960 --> 00:09:53,850
ક્યારેક તમે આ પ્રતીક સાંભળવા મળશે
બેંગ અથવા ઉદ્ગારવાચક તરીકે ઉચ્ચાર

210
00:09:53,850 --> 00:09:55,231
નથી અથવા.

211
00:09:55,231 --> 00:09:56,730
તે ખરેખર ખૂબ બધા જ વાત છે.

212
00:09:56,730 --> 00:10:00,185
કિસ્સામાં તમે તે બોલાતી સાંભળવા અને
તમે તે શું છે તે ખાતરીપૂર્વક જાણતા ન હો

213
00:10:00,185 --> 00:10:02,310
તે માત્ર ઉદ્ગારવાચક છે
બિંદુ, પરંતુ ક્યારેક તે છે

214
00:10:02,310 --> 00:10:04,215
એક દંપતિ અલગ વસ્તુઓ તરીકે ઓળખાય છે.

215
00:10:04,215 --> 00:10:06,340
બધા હક છે, કે જેથી લે
લોજિકલ ઓપરેટરો સંભાળ.

216
00:10:06,340 --> 00:10:08,640
તેથી, ચાલો વિશે વાત કરો
સંબંધ ઓપરેટરો.

217
00:10:08,640 --> 00:10:11,610
ફરીથી, તમે આ સાથે પરિચિત કરશો, તો
પાછા ગ્રેડ શાળા અંકગણિત,

218
00:10:11,610 --> 00:10:13,870
તમે કદાચ પરિચિત છો
સાથે કેવી રીતે આ કાર્ય પહેલેથી જ.

219
00:10:13,870 --> 00:10:15,411
તમે અપેક્ષા કરશો તરીકે આ બરાબર વર્તે.

220
00:10:15,411 --> 00:10:19,800
તેથી ઓછી તે આ સાચું છે, કરતાં
ઉદાહરણ તરીકે, X વાય કરતાં ઓછી હોય.

221
00:10:19,800 --> 00:10:24,380
X 4 છે અને તેથી જો, વાય છે
6, X વાય કરતાં ઓછી છે.

222
00:10:24,380 --> 00:10:26,035
તે સાચું છે.

223
00:10:26,035 --> 00:10:27,910
કરતાં ઓછી અથવા સમાન
ખૂબ જ રીતે કામ કરે છે.

224
00:10:27,910 --> 00:10:33,020
X 4 છે, અને વાય, પછી 4 હોય તો
X વાય કરતાં ઓછી અથવા સમાન છે.

225
00:10:33,020 --> 00:10:35,310
કરતા વધારે. X વાય કરતાં વધારે છે.

226
00:10:35,310 --> 00:10:39,310
અને એક કરતાં વધારે અથવા, x બરાબર
વાય કરતાં વધારે અથવા સમાન હોય છે.

227
00:10:39,310 --> 00:10:41,745
તે સાચું છે, તો પછી તમે પડશે
કે અભિવ્યક્તિ પસાર કરવા માટે,

228
00:10:41,745 --> 00:10:44,490
અને તમે નીચે જઈશ
રસ્તા પર કે પાથ.

229
00:10:44,490 --> 00:10:48,590
X વાય કરતાં વધારે છે, તો તમે એક હોય તો,
અને X, હકીકતમાં, વાય કરતાં વધુ છે,

230
00:10:48,590 --> 00:10:51,670
તમે ગમે કરીશ
કે શરત આધીન છે.

231
00:10:51,670 --> 00:10:54,396
>> અમે નથી કે નોટિસ
કરતાં ઓછા માટે એક પાત્ર

232
00:10:54,396 --> 00:10:57,020
અથવા સમાન તરીકે તમે હોઈ શકે છે
ગણિત પાઠ્યપુસ્તક માંથી સાથે પરિચિત.

233
00:10:57,020 --> 00:10:59,874
તેથી, અમે પ્રતીક કરતાં ઓછી હોય છે
એક સમાન સાઇન દ્વારા અનુસરીને.

234
00:10:59,874 --> 00:11:01,790
એટલે કે, અમે પ્રતિનિધિત્વ કેવી રીતે
એક કરતાં વધારે અથવા બરાબર ઓછો હોય છે.

235
00:11:01,790 --> 00:11:04,490
અને એ જ રીતે, અમે તે કરવું
એક કરતાં વધારે અથવા બરાબર છે.

236
00:11:04,490 --> 00:11:06,698
>> અંતિમ બે સંબંધ
મહત્વપૂર્ણ છે કે ઓપરેટરો

237
00:11:06,698 --> 00:11:09,320
સમાનતા અને અસમાનતા માટે પરીક્ષણ કરવામાં આવે છે.

238
00:11:09,320 --> 00:11:13,380
તેથી, એક્સ સમકક્ષ હોય, વાય બરાબર સાચું છે
એક્સ અને વાય કિંમત જ છે તો.

239
00:11:13,380 --> 00:11:19,610
X 10 છે, અને વાય પછી, 10 હોય તો
X બરાબર વાય સાચું છે સમકક્ષ હોય છે.

240
00:11:19,610 --> 00:11:26,010
X 10 અને વાય એક્સ 11 છે, તો
વાય સાચું નથી બરાબર સમકક્ષ હોય છે.

241
00:11:26,010 --> 00:11:29,680
અમે પણ ઉપયોગ અસમાનતા માટે પરીક્ષણ કરી શકે છે
ઉદ્ગારવાચક બિંદુ અથવા બેંગ નથી અથવા,

242
00:11:29,680 --> 00:11:30,330
ફરી.

243
00:11:30,330 --> 00:11:35,049
જો X તો, y બરાબર નથી
કે, અમે અહીં ઉપયોગ કરી રહ્યાં છો કસોટી છે

244
00:11:35,049 --> 00:11:35,840
અમે જવા માટે સારા હશો.

245
00:11:35,840 --> 00:11:40,340
તેથી, x બરાબર ન હોય તો
વાય, અમે તે પાથ નીચે જવા પડશે.

246
00:11:40,340 --> 00:11:41,441
>> અહીં ખરેખર ખૂબ કાળજી રાખો.

247
00:11:41,441 --> 00:11:44,440
તે ખરેખર સામાન્ય mistake-- છે અને
એક હું ચોક્કસપણે કરવામાં તદ્દન ઘણો જ્યારે

248
00:11:44,440 --> 00:11:47,340
હું started-- મેળવવામાં આવી હતી
આકસ્મિક ભૂલથી

249
00:11:47,340 --> 00:11:51,690
સોંપણી ઓપરેટર, એક બરાબર
સમાનતા સરખામણી ઓપરેટર માટે,

250
00:11:51,690 --> 00:11:52,582
ડબલ સમકક્ષ હોય છે.

251
00:11:52,582 --> 00:11:54,540
તે કેટલાક વિચિત્ર પરિણમી કરીશું
તમારો કોડ વર્તન,

252
00:11:54,540 --> 00:11:56,730
અને સામાન્ય રીતે કમ્પાઇલર કરશે
તમે પ્રયત્ન કરો ત્યારે તે વિશે તમે ચેતવણી

253
00:11:56,730 --> 00:11:59,910
અને તમારો કોડ કમ્પાઇલ, પરંતુ ક્યારેક
તમે તેને ઝલક માટે સમર્થ હોઈ શકે છે.

254
00:11:59,910 --> 00:12:02,770
તે જરૂરી સારી વાત નથી
તમે તેને ઝલક કે, જોકે.

255
00:12:02,770 --> 00:12:04,710
જસ્ટ તમે શું કરી રહ્યા છે, તેથી જો
અસમાનતા ટેસ્ટ,

256
00:12:04,710 --> 00:12:07,970
તમે બે કે નહિ તેની તપાસ કરી રહ્યાં છો
અલગ અલગ ચલો જ કિંમત હોય છે

257
00:12:07,970 --> 00:12:11,980
તેમને અંદર વાપરવા માટે ખાતરી કરો
બરાબર નથી અને એક સમકક્ષ સમકક્ષ હોય છે.

258
00:12:11,980 --> 00:12:15,450
અને તે રીતે તમારા કાર્યક્રમ ચાલશે
તમે માગતા વર્તન હોય છે.

259
00:12:15,450 --> 00:12:18,400
હું ડો લોયડ છું અને આ CS50 છે.

260
00:12:18,400 --> 00:12:20,437