1
00:00:01,984 --> 00:00:07,450
[Powered by Google Translate] [ELECTRONIC સ્થિર અવાજ]

2
00:00:07,450 --> 00:00:11,320
રોબ: ઠીક છે, તેથી અમે તમને હમણાં જ લાવવામાં શું CS50 સ્પેસીસ છે.

3
00:00:11,320 --> 00:00:12,325
અલી: રાહ જુઓ, પાછળ રાહ છે.

4
00:00:12,325 --> 00:00:13,175
વિભાગમાં આપનું સ્વાગત છે!

5
00:00:13,175 --> 00:00:13,860
રોબ: સ્વાગત વિભાગમાં!

6
00:00:13,860 --> 00:00:14,742
અલી: યે!

7
00:00:14,742 --> 00:00:16,840
રોબ: Supersection!

8
00:00:16,840 --> 00:00:18,610
અલી: હું અલી છું અને આ રોબ છે.

9
00:00:18,610 --> 00:00:20,680
ઠીક છે, હવે અમે સ્પેસીસ સમજાવવું પડશે.

10
00:00:20,680 --> 00:00:23,650
રોબ: તેથી અમે તમને હમણાં જ લાવવામાં શું CS50 સ્પેસીસ છે.

11
00:00:23,650 --> 00:00:29,260
તમે આ તમારા વિભાગોમાં ઘણો આ સત્ર ઉપયોગ કરી શકશો.

12
00:00:29,260 --> 00:00:32,110
મૂળભૂત રીતે, અમે પહેલાથી જ પડ્યું તમે ઉપકરણ ડાઉનલોડ કરો.

13
00:00:32,110 --> 00:00:38,630
અને તમે CS50 સ્પેસીસ ઓફ વેબ ઓજાર સાથે વાત ઈન્ટરફેસ તરીકે વિચાર કરી શકો છો

14
00:00:38,630 --> 00:00:40,670
કે અમે કેટલાક સર્વર પર ક્યાંક હોય છે.

15
00:00:40,670 --> 00:00:42,990
તેથી તમે આ ઈન્ટરફેસમાં તમારી કોડ સ્કોર શકે છે, અને અમે પડશે

16
00:00:42,990 --> 00:00:44,180
કેવી રીતે વસ્તુઓ કરવું.

17
00:00:44,180 --> 00:00:48,200
તમે પણ વિભાગમાં અન્ય લોકોની કોડ જોવા કરી શકો છો, અને -

18
00:00:48,200 --> 00:00:51,920
અલી: અને કેટલાક લોકો મળ્યા છે, તમે બાજુ પર લોકો ગપસપ કરી શકો છો.

19
00:00:51,920 --> 00:00:54,230
અને અમે તમામ તેમાં દેખાશે, પણ તેથી, તે આકર્ષક છે.

20
00:00:54,230 --> 00:00:55,655
માં આવે છે, આવે છે અને બેસી.

21
00:00:55,655 --> 00:00:57,060
બેઠક લે છે.

22
00:00:57,060 --> 00:00:57,840
>> રોબ: તેથી, વિભાગો છે -

23
00:00:57,840 --> 00:00:59,380
અલી: ના, ના, તમે ગાય્સ આવી શકો છો.

24
00:00:59,380 --> 00:01:03,356
રોબ: વિભાગો વધુ ઇન્ટરેક્ટિવ આ સત્ર હશે આવે છે.

25
00:01:03,356 --> 00:01:04,180
અલી: ઓહ, તેઓ જેવા છે -

26
00:01:04,180 --> 00:01:05,840
ઓહ.

27
00:01:05,840 --> 00:01:07,530
ઠીક છે કૂલ.

28
00:01:07,530 --> 00:01:15,630
તેથી જો તમે ગાય્સ માત્ર માં આવી રહ્યા છે, તો તમે આ લિંક પર જાઓ, જો હું વિચાર કરી શકે છે

29
00:01:15,630 --> 00:01:20,190
ત્યાં, જમણી ત્યાં.

30
00:01:20,190 --> 00:01:22,780
અમે ખરેખર તે લખી શકતું નથી, કારણ કે ત્યાં બોર્ડ જગ્યા નથી, પરંતુ આ લિંક

31
00:01:22,780 --> 00:01:27,160
અહીં, તમારા કમ્પ્યુટર્સ પર જાઓ અને તમે CS50 દાખલ કરશો

32
00:01:27,160 --> 00:01:29,810
જગ્યાઓ છે, જેમાં એક સરસ વસ્તુ છે.

33
00:01:32,460 --> 00:01:33,830
ઠીક છે.

34
00:01:33,830 --> 00:01:35,370
શું તમે એક સમસ્યા છે?

35
00:01:35,370 --> 00:01:39,930
રોબ: તેથી તમે સમસ્યાઓ શોધી શકો છો -

36
00:01:39,930 --> 00:01:42,720
અમે આ ક્યાંક લખી કરવાનો પ્રયત્ન કરવાની જરૂર છે.

37
00:01:42,720 --> 00:01:50,040
તેથી જો તમે cs50.net/psets પર જાઓ અને આ હેકર supersection છે -

38
00:01:50,040 --> 00:01:55,870
અને તમે એક pset ના હેકર આવૃત્તિ માં જવા માટે, સ્પષ્ટીકરણ જોવા

39
00:01:55,870 --> 00:01:57,620
ક્યાંક નીચે પૃષ્ઠ પર -

40
00:02:01,940 --> 00:02:04,280
>> અલી: તેથી મૂળભૂત છે, જ્યારે રોબ looking, અમે શું કરીએ શું જઈ રહ્યાં છો

41
00:02:04,280 --> 00:02:06,650
કલમ આજે છે ત્યાં સમસ્યાઓ એક વિભાગ છે -

42
00:02:06,650 --> 00:02:07,600
રોબ: - આઠ પાનું છે.

43
00:02:07,600 --> 00:02:09,300
અલી: - કહેવાય સમસ્યાઓ વિભાગ -

44
00:02:09,300 --> 00:02:10,280
પ્રશ્નો વિભાગ: Rob.

45
00:02:10,280 --> 00:02:11,630
અલી: માફ કરશો, પ્રશ્નો વિભાગ છે.

46
00:02:11,630 --> 00:02:14,450
અને તે છે અમે શું કરીએ પર જાઓ જઈ રહ્યાં છો -

47
00:02:14,450 --> 00:02:16,370
તે છે, આપણે શું પર આજે જાઓ વિભાગમાં જઈ રહ્યાં છો.

48
00:02:16,370 --> 00:02:20,010
અને અમે તેને CS50 સ્પેસીસ પર કોડ જઈ રહ્યાં છો, અને આસ્થાપૂર્વક કે કામ કરશે.

49
00:02:20,010 --> 00:02:22,210
અને અમે હમણાં જ તેમના મારફતે વાત કરી શકો છો.

50
00:02:22,210 --> 00:02:24,510
અને તમે ગાય્સ પ્રશ્નો પૂછી જ્યારે તમે લાગે છે -

51
00:02:24,510 --> 00:02:27,890
>> રોબ: તેથી આ સૌથી psets સાથે એક સામાન્ય વાત હોય રહ્યો છે.

52
00:02:27,890 --> 00:02:31,000
હું આ એક સાથે લાગે છે, તે કહે છે કે તમે આ પ્રશ્નો હાથથી સાઇન ન હોય

53
00:02:31,000 --> 00:02:36,780
પરંતુ વિચાર એ છે કે આ પ્રશ્નો pset પર મૂકવા આવે છે, અને તમે આવી શકે

54
00:02:36,780 --> 00:02:39,790
માટે તે પ્રશ્નો હોય વિભાગમાં જવાબ આપ્યો.

55
00:02:39,790 --> 00:02:42,730
અથવા જો તમે વિભાગમાં આવતી નથી, તમે તેને તમારા પોતાના પર જવાબ આપવા અથવા મેળવી શકો છો

56
00:02:42,730 --> 00:02:44,250
ઓફિસ કલાકો કે કંઈક અંતે મદદ કરે છે.

57
00:02:44,250 --> 00:02:47,540
પરંતુ આ પ્રશ્નો છે કે જે તમને સમસ્યા સેટ માટે PReP અપેક્ષા છે.

58
00:02:47,540 --> 00:02:50,910
અને હેકર આવૃત્તિ પર, ઘણાં બધા પ્રશ્નો માત્ર વિશે હોઈ શકે છે

59
00:02:50,910 --> 00:02:54,170
તમારી વર્તમાન સીએસ જ્ઞાન વિસ્તરી રહી છે.

60
00:02:54,170 --> 00:02:55,370
અલી: હા, ખૂબ ખૂબ.

61
00:02:55,370 --> 00:02:57,950
>> ઠીક છે, જેથી CS50 સ્પેસીસ પર દરેક છે?

62
00:02:57,950 --> 00:02:59,457
હાય, સાઇન થવું

63
00:02:59,457 --> 00:03:00,828
1 વક્તા: અમે URL ને જોઈ શકે છે વધુ એક વખત?

64
00:03:04,030 --> 00:03:07,000
રોબ: અરે વાહ, આ સરળ હોઈ એકવાર તમે તમારા વિભાગોમાં ખરેખર છે નહીં, અને

65
00:03:07,000 --> 00:03:10,760
તમારા ટીએફ તમે પહેલાંથી URL ને માત્ર ઇમેઇલ કરી શકો છો.

66
00:03:10,760 --> 00:03:11,870
અલી: યે, એક બેઠક લે છે.

67
00:03:11,870 --> 00:03:13,170
ત્યાં બેઠકો અહીં છે.

68
00:03:13,170 --> 00:03:14,420
આગળના કે ખરાબ નથી.

69
00:03:17,112 --> 00:03:18,362
શું?

70
00:03:20,650 --> 00:03:23,590
તેથી, CS50 સ્પેસ, અમે ત્યાં રહ્યાં છો.

71
00:03:23,590 --> 00:03:26,760
શું કોઇને કોઇ પ્રશ્નો હોય તો પહેલાં અમે પ્રવેશ મેળવવા - શું?

72
00:03:26,760 --> 00:03:28,060
રોબ: ત્યાં પણ કોઈ પણ ઘડી નથી.

73
00:03:28,060 --> 00:03:29,270
[અશ્રાવ્ય]

74
00:03:29,270 --> 00:03:31,540
અલી: માફ કરશો.

75
00:03:31,540 --> 00:03:32,950
તમે તમારા fingernails ઉપયોગ કરી શકે છે?

76
00:03:32,950 --> 00:03:38,210
અમે એક હાઇ ટેક ખૂબ વર્ગ માટેની ઓછા ટેક ખૂબ રૂમમાં છો.

77
00:03:38,210 --> 00:03:40,795
ઠીક છે, સારી દરેકને પ્રકારની છે?

78
00:03:40,795 --> 00:03:44,310
શું કોઇને તેના વિશે હજુ પણ પ્રશ્ન હોય તો?

79
00:03:44,310 --> 00:03:48,540
હું પહેલા કહ્યું હતું કે, અમે પ્રશ્નો ના વિભાગ મારફત જઇ રહ્યા છીએ

80
00:03:48,540 --> 00:03:51,340
આ pset સ્પષ્ટીકરણો.

81
00:03:51,340 --> 00:03:53,490
તેથી ત્યાં માત્ર સમસ્યાઓ થોડા છે કે અમે જઈ રહ્યાં છો

82
00:03:53,490 --> 00:03:57,490
CS50 સ્પેસીસ માં કોડ.

83
00:03:57,490 --> 00:03:58,740
દરેકને સારો?

84
00:04:01,010 --> 00:04:01,360
ઠીક છે.

85
00:04:01,360 --> 00:04:02,312
ગુડ?

86
00:04:02,312 --> 00:04:04,260
રોબ: શું તમે લેપટોપ છે?

87
00:04:04,260 --> 00:04:05,150
અલી: તમે લુકાસ સાથે અટકી શકે છે.

88
00:04:05,150 --> 00:04:06,960
તેઓ સાચા બેઠક છે તમે આગળ.

89
00:04:06,960 --> 00:04:10,030
બોન્ડીંગ સમય.

90
00:04:10,030 --> 00:04:10,990
>> રોબ: તેથી, પ્રથમ સમસ્યા સાથે શરૂ?

91
00:04:10,990 --> 00:04:11,260
અલી: યાહ.

92
00:04:11,260 --> 00:04:11,820
અમે શરૂ કરી શકો છો.

93
00:04:11,820 --> 00:04:12,390
શું તમે મને માંગો છો -

94
00:04:12,390 --> 00:04:13,700
હું જઈ શકે છે.

95
00:04:13,700 --> 00:04:16,666
તેથી, અમે pset સ્પેક્સ પર જાઓ પડશે.

96
00:04:16,666 --> 00:04:17,640
ઓહ, તે શા માટે છે -

97
00:04:17,640 --> 00:04:18,890
રોબ: નિયંત્રણ.

98
00:04:21,769 --> 00:04:25,770
અલી: ઠીક છે, તેથી અમે જવાબ જવા છે આ બધી વસ્તુઓ તેમજ?

99
00:04:25,770 --> 00:04:26,190
રોબ: ઓહ, હા.

100
00:04:26,190 --> 00:04:27,280
તેથી -

101
00:04:27,280 --> 00:04:29,675
અલી: ઓહ, દરેક વોચ માતાનો રોબ અભિનિત શોર્ટ્સ હતી?

102
00:04:32,430 --> 00:04:33,360
ઠીક છે કૂલ.

103
00:04:33,360 --> 00:04:36,870
રોબ: અરે વાહ, હું નથી માનતો કે અમે જરૂરી તો તમને અપેક્ષિત

104
00:04:36,870 --> 00:04:40,650
આ વિભાગમાં આવતા પહેલાં જોયેલી, પરંતુ અમે તે અંગે ચર્ચા કરી શકો છો

105
00:04:40,650 --> 00:04:43,870
અગાઉથી સમસ્યાઓ છે, કારણ કે તેઓ પ્રશ્નો વસ્તુઓ વિભાગ હેઠળ છે.

106
00:04:43,870 --> 00:04:46,480
તેથી જો તમે તેને જોયો છે, ચિંતા ન કરશો.

107
00:04:46,480 --> 00:04:48,630
જે લોકો પાસે પ્રયાસ અને જવાબ આપી શકો છો.

108
00:04:48,630 --> 00:04:53,875
>> તેથી, પ્રથમ પ્રશ્ન, જે પૂર્વ પ્રોસેસર, # કેવી રીતે સમાવેશ કરે છે

109
00:04:53,875 --> 00:04:56,080
સંબંધિત છે?

110
00:04:56,080 --> 00:04:58,440
તેથી તે કોઈપણ માટે જવાબ નથી?

111
00:04:58,440 --> 00:04:59,320
અલી: તમે ગાય્સ તે વાત બહાર કરી શકે છે.

112
00:04:59,320 --> 00:05:00,308
ખાતરી કરો કે, આગળ જાઓ.

113
00:05:00,308 --> 00:05:03,766
2 વક્તા: સમાવેશ # અમુક કોડ પૂર્વ લેખિત છે, અને બદલે

114
00:05:03,766 --> 00:05:08,706
તે નકલ કરવાનો અને તમારા કાર્યક્રમ માં પેસ્ટ, ફક્ત કહેતા દ્વારા તેને સમાવેશ થાય છે,

115
00:05:08,706 --> 00:05:14,140
પૂર્વ-પ્રોસેસર જાણે છે કે તે ત્યાં છે અને તે તેને ઉમેરવું જોઈએ

116
00:05:14,140 --> 00:05:17,520
પાછળથી અથવા તે પહેલાં જે કંઈપણ થાય છે.

117
00:05:17,520 --> 00:05:18,466
અલી: અરે વાહ, અદ્ભુત.

118
00:05:18,466 --> 00:05:19,440
સરસ.

119
00:05:19,440 --> 00:05:23,820
રોબ: તેથી પૂર્વ પ્રોસેસર, જ્યારે તમે ખરેખર કાર્યક્રમ સંકલન કરી રહ્યા છો આ છે

120
00:05:23,820 --> 00:05:25,230
પ્રથમ પગલું.

121
00:05:25,230 --> 00:05:27,620
સંકલન ચાર મોટી પગલાંઓ બને.

122
00:05:27,620 --> 00:05:31,120
તેથી પ્રોસેસર પૂર્વ પ્રથમ મોટું એક છે, અને તે આ વ્યક્તિ કે જાય છે

123
00:05:31,120 --> 00:05:33,510
અને દ્વારા આ હેશ પ્રતીકો બધા માટે જુએ છે.

124
00:05:33,510 --> 00:05:36,610
અને કોઈપણ લીટી કે જે હેશ સાથે શરૂ થાય છે, પ્રોસેસર પૂર્વ તે જુએ છે અને જુએ છે

125
00:05:36,610 --> 00:05:37,880
જો તે પ્રક્રિયા કરી શકો છો.

126
00:05:37,880 --> 00:05:43,800
તેથી # સમાવેશ થાય છે પૂર્વ પ્રોસેસર કહે છે કે અમુક cs50.h જોવા માટે

127
00:05:43,800 --> 00:05:47,830
ફાઇલ અને માત્ર કૉપિ કરો અને આ ફાઈલમાં તેના સમાવિષ્ટો પેસ્ટ કરો.

128
00:05:47,830 --> 00:05:50,970
તેથી તમે ખરેખર # કંઈપણ તમે ઇચ્છો સમાવેશ કરી શકે છે, પરંતુ મોટે ભાગે તે જ હશે

129
00:05:50,970 --> 00:05:53,700
ક. ફાઈલો છે.

130
00:05:53,700 --> 00:05:55,820
અમે # હજુ સુધી વ્યાખ્યાયિત ન મેળવેલ છે, આથી તે તો કોઈ વાંધો નથી.

131
00:05:55,820 --> 00:05:57,620
અલી: અરે વાહ, આપણે એક કે સારા છો.

132
00:05:57,620 --> 00:05:59,450
શું કોઇને કે વિશે કોઇ પ્રશ્નો હોય તો?

133
00:05:59,450 --> 00:06:01,090
અમે સારા?

134
00:06:01,090 --> 00:06:02,430
આગામી પ્રશ્ન.

135
00:06:02,430 --> 00:06:07,096
>> 3 વક્તા: ટૂંકા, ત્યાં લગભગ કંઈક હતું કેચ છે.?

136
00:06:07,096 --> 00:06:09,110
એટલે કે સંબંધિત અથવા તે અપ્રસ્તુત?

137
00:06:09,110 --> 00:06:11,210
રોબ. પ્રોસેસર પૂર્વ સાથે કેચ વિશે?

138
00:06:11,210 --> 00:06:13,990
3 વક્તા: અરે વાહ, અથવા હું કંઈક કરી તેને અપ?

139
00:06:13,990 --> 00:06:18,290
રોબ: તેથી ટૂંકા દર્શાવે થઈ આ ફાઇલ પહેલેથી પ્રક્રિયા અને

140
00:06:18,290 --> 00:06:24,240
. તેને બીજી કેચ ફાઈલ માટે outputting, તેથી તમે આ ફાઈલ પહેલાથી પ્રક્રિયા કરી શકો છો -

141
00:06:24,240 --> 00:06:30,000
જ્યારે તમે જેમ ચલાવો, હેલ્લો બનાવવા અથવા રણકાર hello.c, તમે બધા કરી રહ્યા છે

142
00:06:30,000 --> 00:06:31,730
એક મોટું પગલું માં સંકલન.

143
00:06:31,730 --> 00:06:34,780
પરંતુ તમે તેને બાહ્ય રીતે તેની અલગ પગલાંઓ માં કરી શકો છો.

144
00:06:34,780 --> 00:06:36,950
તેથી પ્રથમ તમે તેને પૂર્વ પ્રક્રિયા કરી શકો છો.

145
00:06:36,950 --> 00:06:42,260
પછી તો પછી તમે ભેગા થઈ શકે, કમ્પાઇલ અને પછી તમે લિંક કરી શકે છે.

146
00:06:42,260 --> 00:06:43,620
અમે તે અન્ય ચામાં મળશે.

147
00:06:43,620 --> 00:06:47,410
પરંતુ પૂર્વ પ્રક્રિયા, તમે પહેલાથી પ્રક્રિયા તે પ્રકારની, અને પછી તેને જાય પ્રવેશ

148
00:06:47,410 --> 00:06:49,270
અન્ય કો. ફાઇલ.

149
00:06:49,270 --> 00:06:51,430
કારણ કે પૂર્વ પ્રક્રિયા ખરેખર કંઈપણ ફેરફાર થતો નથી.

150
00:06:51,430 --> 00:06:52,800
તે માત્ર નકલ અને પેસ્ટ સમૂહ છે.

151
00:06:52,800 --> 00:06:56,760
તમે જાતે જ તેની નકલ કરો અને પેસ્ટ કરો જાતે કરી શકે છે.

152
00:06:56,760 --> 00:06:59,630
અલી. અને સ્પષ્ટ કરવા માટે, ફાઈલ કો એક સી ફાઈલ છે, તેથી તે

153
00:06:59,630 --> 00:07:00,930
સી કોડ માં લખાયેલ છે.

154
00:07:00,930 --> 00:07:03,300
તેથી તે સી કોડ માંથી સી કોડ બનશે.

155
00:07:03,300 --> 00:07:05,210
તમે ફક્ત પાઉન્ડ સાથે રહ્યાં છો વધુ કોડ ઉમેરી રહ્યા છે.

156
00:07:05,210 --> 00:07:08,575
રોબ: જ્યારે તમે તેને પૂર્વ પ્રક્રિયા, તે હજુ પણ માન્ય સી ફાઈલ છે.

157
00:07:08,575 --> 00:07:09,940
3 વક્તા: ઠીક છે.

158
00:07:09,940 --> 00:07:10,540
ગુડ પ્રશ્ન: અલી.

159
00:07:10,540 --> 00:07:11,370
હું જ ગમે છે.

160
00:07:11,370 --> 00:07:12,755
ઠીક છે, આગામી પ્રશ્ન.

161
00:07:17,870 --> 00:07:19,660
>> આ કમ્પાઈલર શું છે?

162
00:07:19,660 --> 00:07:20,824
કોઈપણ?

163
00:07:20,824 --> 00:07:21,286
હા.

164
00:07:21,286 --> 00:07:24,650
4 વક્તા: તે વિધાનસભા માં કોડ પૂર્વ પ્રક્રિયા બદલે છે.

165
00:07:24,650 --> 00:07:25,110
અલી: પરફેક્ટ.

166
00:07:25,110 --> 00:07:25,390
રોબ: હા.

167
00:07:25,390 --> 00:07:25,720
અલી: સરસ.

168
00:07:25,720 --> 00:07:28,270
રોબ: તેથી કે જે કમ્પાઇલર શું ખાસ કરી છે

169
00:07:28,270 --> 00:07:30,740
જ્યારે અમે રણકાર ઉપયોગ કરી રહ્યાં છો.

170
00:07:30,740 --> 00:07:35,100
એક ખૂબ જ સામાન્ય અર્થમાં, કમ્પાઇલર એક ભાષામાં કોડ લેતી જેમ જ છે

171
00:07:35,100 --> 00:07:37,070
અને તેને બીજી ભાષા બની રહ્યા છે.

172
00:07:37,070 --> 00:07:38,370
તેથી સી -

173
00:07:38,370 --> 00:07:43,750
અથવા, સાથે સાથે, રણકાર કોડ લઈ રહ્યું છે કે સી માં છે અને તે વિધાનસભા માટે રૂપાંતરિત.

174
00:07:43,750 --> 00:07:46,560
અને તમે તમામ વિધાનસભા અંતે સમજી કરવાનો પ્રયત્ન નથી.

175
00:07:46,560 --> 00:07:49,830
પરંતુ તે ભાષા છે કે જે તેને દેવાનો છે માં છે.

176
00:07:49,830 --> 00:07:50,230
>> અલી: ઠીક છે.

177
00:07:50,230 --> 00:07:52,920
અને પછી કરવાનું એસેમ્બ્લર શું છે?

178
00:07:52,920 --> 00:07:54,270
કોઈપણ?

179
00:07:54,270 --> 00:07:56,810
5 વક્તા: બાઈનરી [અશ્રાવ્ય]

180
00:07:56,810 --> 00:07:57,260
અલી: માફ કરશો, શું?

181
00:07:57,260 --> 00:07:58,760
5 વક્તા: બાઈનરી [અશ્રાવ્ય]

182
00:07:58,760 --> 00:07:59,260
રોબ: હા.

183
00:07:59,260 --> 00:07:59,880
અલી: હા.

184
00:07:59,880 --> 00:08:01,960
તેથી એસેમ્બ્લર: - રોબ

185
00:08:01,960 --> 00:08:05,830
વિધાનસભા કોડ ખરેખર છે, ખરેખર તમારા કમ્પ્યુટર શું સમજી શકે બંધ,

186
00:08:05,830 --> 00:08:09,390
યાદ પરંતુ તે તદ્દન લખાણ સમજતું નથી

187
00:08:09,390 --> 00:08:10,630
કે વિધાનસભા કોડ છે.

188
00:08:10,630 --> 00:08:14,570
તમે તેને સીધા 1 સે અને 0s રૂપાંતર કરવાની જરૂર છે.

189
00:08:14,570 --> 00:08:17,000
તે સીધું ભાષાંતર પ્રક્રિયા જેવું છે.

190
00:08:17,000 --> 00:08:19,450
અમે હમણાં જ તમને એક ટેબલ આપી શકે છે કે જે દરેક નકશા શું

191
00:08:19,450 --> 00:08:21,880
વિધાનસભા સૂચના થાય છે.

192
00:08:21,880 --> 00:08:24,340
પરંતુ એસેમ્બ્લર માત્ર તમારા માટે છે આ ભાષાંતર કરી.

193
00:08:24,340 --> 00:08:28,790
તે 1 સે અને 0s માં વિધાનસભા કોડ રૂપાંતરિત છે.

194
00:08:28,790 --> 00:08:30,870
>> અલી: અને પછી, છેલ્લા એક માટે, તે એક linker છે?

195
00:08:30,870 --> 00:08:35,070
અને કેવી રીતે lcs50-નથી સંબંધિત છે?

196
00:08:35,070 --> 00:08:37,010
કોઈપણ?

197
00:08:37,010 --> 00:08:41,440
રોબ: આ ખૂબ સખત અને ઓછામાં ઓછા એક કમ્પાઇલર વિડિઓ સમજાવાયેલ છે.

198
00:08:41,440 --> 00:08:48,980
અલી: જરૂરી કોઇપણ આદેશ જોયા-lcs50 યાદ?

199
00:08:48,980 --> 00:08:50,690
6 વક્તા: જ્યારે તમે બનાવવા માટે ગયા હતા.

200
00:08:50,690 --> 00:08:51,980
અલી: તે કરી છે.

201
00:08:51,980 --> 00:08:55,780
અરે વાહ, ઠંડી, ઠીક છે.

202
00:08:55,780 --> 00:09:02,024
ત્યાં છે કોઇ ધારી શકે છે અથવા અસ્પષ્ટ - હા જાઓ.

203
00:09:02,024 --> 00:09:06,370
7 વક્તા: મને ખાતરી છે કે, નથી કારણ કે તમારી ટૂંકા ખરેખર હતી [અશ્રાવ્ય], પરંતુ તે

204
00:09:06,370 --> 00:09:12,244
દરેક લાઇબ્રેરી સાથે અલગ ફાઇલો કરવાનું છે અને પછી મૂકવા અંગે કશુંક

205
00:09:12,244 --> 00:09:13,620
એક પુસ્તકાલય બધી મળીને તેમને?

206
00:09:13,620 --> 00:09:14,400
રોબ: હા.

207
00:09:14,400 --> 00:09:23,000
તેથી જ્યારે તમે hello.c હોય, તો તે ખરેખર સરળ કાર્યક્રમ છે.

208
00:09:23,000 --> 00:09:25,570
તમે ખરેખર માત્ર રહ્યાં છો તેને એક વસ્તુ કરી.

209
00:09:25,570 --> 00:09:27,400
પરંતુ જ્યારે તમે અન્ય કાર્યક્રમો માં વિચાર -

210
00:09:27,400 --> 00:09:31,700
અને હું માનું ત્યારે પણ તમે તમારા કાર્યક્રમોમાં GetString, તો તમે શરૂ કરવાની જરૂર છે

211
00:09:31,700 --> 00:09:33,830
અન્ય ફાઇલો સમાવેશ થાય છે.

212
00:09:33,830 --> 00:09:38,000
તેથી CS50 પુસ્તકાલય એક જેમ કે ફાઈલ છીએ, જેમાં આપણે અમલીકરણો હોય છે

213
00:09:38,000 --> 00:09:40,750
GetString અને GetInt અને તે તમામ બાબતો.

214
00:09:40,750 --> 00:09:45,540
તેથી linker કરે છે શું છે તેની આસપાસ જાય આ બધી મારફતે શોધી

215
00:09:45,540 --> 00:09:49,400
ફાઇલો, જ્યાં વિધેયો વ્યાખ્યાયિત કરવામાં આવે છે જોયા, ખાતરી કરો કે બનાવે છે જ્યારે હું કૉલ

216
00:09:49,400 --> 00:09:52,440
GetString ક્યાંક, તે GetString જાણે અર્થ એ થાય કે તે છે

217
00:09:52,440 --> 00:09:54,910
આ CS50 પુસ્તકાલયમાં પર GetString.

218
00:09:54,910 --> 00:09:58,895
તેથી linker માત્ર આ તમામ ફાઇલો, તેમને એકસાથે smashes, અને હવે લે છે

219
00:09:58,895 --> 00:10:01,020
તમે એક એક્ઝેક્યુટેબલ છે.

220
00:10:01,020 --> 00:10:05,600
જેથી ધ્યાનમાં રાખો, જો તમે CS50 પુસ્તકાલય ઉપયોગ કરી રહ્યાં છો, તો તમે બંને જરૂર

221
00:10:05,600 --> 00:10:10,370
# ટોચ પર સમાવેશ થાય છે, અને પછી પણ તમારા મેક આદેશ તમને તરીકે,

222
00:10:10,370 --> 00:10:12,630
જણાવ્યું હતું કે, તમે-lcs50 હોય છે.

223
00:10:12,630 --> 00:10:15,720
જેથી તમે માત્ર એક હોઈ શકે નહિં.

224
00:10:15,720 --> 00:10:18,294
તેથી કે જે હમણાં જ ભવિષ્યના સંદર્ભ માટે ધ્યાનમાં રાખવા કશુંક.

225
00:10:18,294 --> 00:10:22,550
>> 8 વક્તા: તેથી દો, કહો કે ત્યાં અન્ય પુસ્તકાલય cs51.h જેવી હતી, અમે કરશે

226
00:10:22,550 --> 00:10:26,780
પણ વધારાની lcs51 માટે છે?

227
00:10:26,780 --> 00:10:32,390
રોબ છે: માત્ર કારણ આ lcs50 સંપૂર્ણપણે કામ કરે છે કારણ કે અમે તે સેટ હોય

228
00:10:32,390 --> 00:10:35,800
તમારા ઉપકરણો ચોક્કસ જગ્યાએ કે જેથી તે જાણે છે શું છે

229
00:10:35,800 --> 00:10:38,550
Lcs50-સાધનો.

230
00:10:38,550 --> 00:10:43,240
અમે હમણાં જ તમને એક cs50.c ફાઈલ આપી શકે છે, અને પછી તમે તેને કમ્પાઇલ, એવું કહીને કરી શકે છે

231
00:10:43,240 --> 00:10:49,050
રણકાર hello.c cs50.c, અને પછી તેને મૂકીને તમારા એક્ઝેક્યુટેબલ બનાવશે

232
00:10:49,050 --> 00:10:50,350
તે બન્ને સાથે ફાઈલો છે.

233
00:10:50,350 --> 00:10:56,520
તે જાણે છે કે lcs50-કેટલાક ડિરેક્ટરી કે અમે સ્પષ્ટ માં ઉપર cs50.c અર્થ થાય છે

234
00:10:56,520 --> 00:10:58,350
તમારા સાધનો.

235
00:10:58,350 --> 00:11:04,290
તેથી જો તમે cs51.c માત્ર કહેતા-lcs51 દ્વારા સ્પષ્ટ કરવા માગતા હતા,

236
00:11:04,290 --> 00:11:06,760
તો પછી અમે પણ તેને તે ડિરેક્ટરીમાં મુકવાની જરૂર છે જેથી તે માટે જ્યાં જાણે કરશે

237
00:11:06,760 --> 00:11:08,636
તે માટે જુઓ.

238
00:11:08,636 --> 00:11:10,510
અલી: તમારા પ્રશ્ન શું હતો?

239
00:11:10,510 --> 00:11:13,975
>> 7 વક્તા: તમે CS50 આ લિંક કેમ હોય

240
00:11:13,975 --> 00:11:18,940
જો - wasn't તે નકલ / પ્રથમ પગલું છે જ્યારે તમે આ પૂર્વ પ્રક્રિયા પર પેસ્ટ?

241
00:11:18,940 --> 00:11:19,700
અલી: શું તમે તેને લેવા માંગો છો?

242
00:11:19,700 --> 00:11:20,880
રોબ: શ્યોર.

243
00:11:20,880 --> 00:11:28,028
તેથી cs50.h ફાઈલ cs50.c સી ફાઈલ અલગ છે.

244
00:11:28,028 --> 00:11:33,652
શું તમે માટે વર્ગ માં પ્રોટોટાઇપ વિધેય મેળવેલ?

245
00:11:33,652 --> 00:11:34,350
ઠીક છે.

246
00:11:34,350 --> 00:11:40,255
જેથી મૂળભૂત છે, cs50.h ફાઈલ માત્ર કૉપિ કરો અને પેસ્ટ કરો રહ્યું છે -

247
00:11:40,255 --> 00:11:44,040
અલી: શું તમે જાણીએ છીએ સહીઓ શું છે?

248
00:11:44,040 --> 00:11:46,580
ઠીક છે, જેથી ઘટનાએ, જો તમે જોવા -

249
00:11:46,580 --> 00:11:50,530
રોબ: લેટ્સ ડોળ કરવો cs50.h ત્યાં નથી.

250
00:11:50,530 --> 00:11:52,960
હવે આ ફાઈલ -

251
00:11:52,960 --> 00:11:56,090
તમે ઓ શબ્દમાળા = GetString કરી રહ્યા છીએ.

252
00:11:56,090 --> 00:11:59,350
પરંતુ જ્યારે અમે કોડ આ બોલ પર મેળવેલ કર્યું છે, તો તે લાંબા વિચાર શું છે

253
00:11:59,350 --> 00:12:00,230
GetString છે.

254
00:12:00,230 --> 00:12:02,600
તે જાણે છે કે તે કાર્ય છે, કારણ કે તમે તેને બોલાવવા કરી રહ્યાં છો.

255
00:12:02,600 --> 00:12:06,500
પરંતુ તે ખબર નથી કે તે ખરેખર એક શબ્દમાળા પાછા માનવામાં આવે છે.

256
00:12:06,500 --> 00:12:14,530
આની જેમ હું જણાવ્યું હતું કે, શબ્દમાળા ઓ = GetInt, આ બાદ કોઇ પણ અર્થમાં નથી,

257
00:12:14,530 --> 00:12:17,530
તમે શબ્દમાળા માટે પૂર્ણાંક સાઇન ઇન કરી રહ્યા છો.

258
00:12:17,530 --> 00:12:22,270
પરંતુ તે જાણે છે કે GetString અર્થમાં બનાવવા નથી કરતું નથી, કારણ કે તે નહિં થાય

259
00:12:22,270 --> 00:12:24,380
ખબર છે કે GetString શબ્દમાળા આપે છે.

260
00:12:24,380 --> 00:12:28,220
તેથી cs50.h કહે આ કંઈક છે.

261
00:12:33,070 --> 00:12:37,750
અલી: તેથી રોબ લખી રહ્યા છે શું છે, તે રીતે એક વચન છે કે તે ચાલી રહ્યું છે

262
00:12:37,750 --> 00:12:41,280
આ GetString કહેવાય કાર્ય છે.

263
00:12:41,280 --> 00:12:45,250
રોબ: આ છે કે જે બધી cs50.h છે નકલ છે અને અહીં પેસ્ટ, તેમજ

264
00:12:45,250 --> 00:12:47,620
GetInt અને તે તમામ બાબતો છે.

265
00:12:47,620 --> 00:12:51,520
અને આ માત્ર કહે છે કે GetString શબ્દમાળા પાછા નથી.

266
00:12:51,520 --> 00:12:54,830
તમે જાણો છો તે કેવી રીતે હજુ સુધી અમલમાં છે, પરંતુ જ્યારે અમે આ વાક્ય વિચાર હવે,

267
00:12:54,830 --> 00:12:57,760
તે જાણે છે કે તે યોગ્ય રીતે શબ્દમાળા આપે છે.

268
00:12:57,760 --> 00:13:03,022
>> 9 વક્તા: તેથી જો આપણે # સમાવેશ થાય છે <cs50.h> વસ્તુ સાથે છે અને તેની જગ્યાએ નથી સંતાપ નહોતી

269
00:13:03,022 --> 00:13:07,130
ફક્ત જેના માટે તે પ્રોટોટાઇપ લખ્યું હતું કે અમે ખરેખર વાપરવા માટે જવું છે?

270
00:13:07,130 --> 00:13:07,330
રોબ: યાહ.

271
00:13:07,330 --> 00:13:08,870
તેથી આપણે આ ચલાવો.

272
00:13:08,870 --> 00:13:09,110
9 વક્તા: તે શું છે?

273
00:13:09,110 --> 00:13:13,670
તેથી, મૂળભૂત રીતે, તે CS50 માટે-l માત્ર કારણ કે આમ થશે -.

274
00:13:13,670 --> 00:13:14,740
રોબ: - અભિવ્યક્તિ.

275
00:13:14,740 --> 00:13:19,370
અલી: હા, કારણ કે જેમ તમે કહ્યું હતું કે, તે મેક ફાઈલમાં છે.

276
00:13:19,370 --> 00:13:24,040
રોબ: cs50.h પણ typedef શબ્દમાળાને ઘરનાં પરચૂરણ કામો * બને છે.

277
00:13:24,040 --> 00:13:26,950
તમે સંપૂર્ણપણે અવગણવા કે શું હવે અર્થ છે કરી શકો છો.

278
00:13:26,950 --> 00:13:31,430
પરંતુ તે પણ cs50.h. સમાવવામાં કંઈક છે

279
00:13:31,430 --> 00:13:34,230
તેથી હવે વસ્તુઓ સંપૂર્ણ દંડ કામ કર્યું હતું.

280
00:13:34,230 --> 00:13:40,770
તે બરાબર ચાલે છે તે જ હતો જ્યારે અમે માત્ર હતી

281
00:13:40,770 --> 00:13:45,120
આ # સમાવેશ થાય છે.

282
00:13:45,120 --> 00:13:49,200
અને તેથી સહિત cs50.h ઓવર સમાવેશ વસ્તુઓ તમને જરૂર થાય છે -

283
00:13:49,200 --> 00:13:53,080
જેમ, તમે આ કાર્યક્રમ માં GetInt ઉપયોગ નથી, પણ તે તો કોઈ વાંધો નથી.

284
00:13:53,080 --> 00:13:55,010
તે માત્ર તેને અવગણો પડશે.

285
00:13:55,010 --> 00:14:02,400
અલી: અને પછી જ્યારે તમે અહીં ઉપર-lcs50 કરવું અને જમણી અહીં, શું ચાલી રહ્યું છે

286
00:14:02,400 --> 00:14:05,290
પર છે કે તે વાસ્તવિક implementable કોડ રહી છે.

287
00:14:05,290 --> 00:14:07,530
તેથી કે જ્યાં તે ખરેખર છે, આમ -

288
00:14:07,530 --> 00:14:09,090
GetString માટે કોડ લખ્યું.

289
00:14:09,090 --> 00:14:11,180
તેથી તે માત્ર એક હવે વચન નથી.

290
00:14:11,180 --> 00:14:16,520
તે વાસ્તવમાં પસાર થઇ છે અને શબ્દમાળા અને તે તમામ સામગ્રી લેતી.

291
00:14:16,520 --> 00:14:17,600
અર્થમાં બનાવીએ?

292
00:14:17,600 --> 00:14:22,640
પ્રશ્નો? અધિકાર છે.

293
00:14:22,640 --> 00:14:24,466
કૂલ દાળો.

294
00:14:24,466 --> 00:14:27,630
>> રોબ: હવે આપણે વાસ્તવિક કોડ ખસેડી શકો છો.

295
00:14:27,630 --> 00:14:28,780
અલી: ઠીક છે.

296
00:14:28,780 --> 00:14:33,340
તેથી અહીં પ્રથમ સમસ્યા છે.

297
00:14:33,340 --> 00:14:36,910
તેથી તે કહે છે કે કાર્યક્રમ કે જે લોઅરકેસ માટે વપરાશકર્તા પૂછે લખી

298
00:14:36,910 --> 00:14:40,540
અક્ષર અને પછી તેને bitwise ઉપયોગ કર્યા વગર મોટા ફેરવે છે

299
00:14:40,540 --> 00:14:43,590
કામગીરી તરીકે નમૂના નીચે આઉટપુટ દીઠ.

300
00:14:43,590 --> 00:14:48,780
આમ તમે જોઈ શકે છે, તો તમે /. A.out સાથે કાર્યક્રમ ચલાવો, અને પછી તમે છો

301
00:14:48,780 --> 00:14:53,320
માટે લોઅરકેસ માં મૂકી જવાનું, અને પછી તમારા કાર્યક્રમ બહાર મૂડી આપવી જોઇએ

302
00:14:53,320 --> 00:15:00,590
એ તો તમે ગાય્સ બધા શા માટે નથી તે નથી CS50 સ્પેસીસ પર શોટ આપી?

303
00:15:00,590 --> 00:15:03,360
તેથી તમે ગાય્સ બધા અહીં જઈ શકો છો.

304
00:15:03,360 --> 00:15:06,650
અને તમે અહીં તમામ કોડ કાઢી શકો છો.

305
00:15:06,650 --> 00:15:12,140
અને પછી તમે આગળ વધો અને આ વસ્તુ કોડિંગ શરૂ કરી શકો છો.

306
00:15:12,140 --> 00:15:14,590
રોબ: તમે કદાચ GetChar, કે વાપરવા માંગો પડશે

307
00:15:14,590 --> 00:15:16,190
આ CS50 પુસ્તકાલય પણ સામેલ છે.

308
00:15:16,190 --> 00:15:18,770
અલી: હું માનું તે વધુ સારું છે જો તમે ઉપરની ભાગ બચાવી શકે છે.

309
00:15:21,452 --> 00:15:23,805
જેથી તમે માત્ર મધ્યમાં સામગ્રી બદલી શકો છો.

310
00:15:28,710 --> 00:15:29,070
આગળ વધો અને કામ કરે છે.

311
00:15:29,070 --> 00:15:30,530
એકબીજા સાથે કામ મુક્ત લાગે છે.

312
00:15:30,530 --> 00:15:32,360
રોબ: અને તમે પ્રશ્નો પૂછી જો તમે કરી શકો છો -

313
00:15:32,360 --> 00:15:33,450
>> 10 વક્તા: એક bitwise કામગીરી શું છે?

314
00:15:33,450 --> 00:15:35,100
રોબ: તેથી, આ સમસ્યા માટે કે અવગણો.

315
00:15:35,100 --> 00:15:36,330
અલી: જો તમે તે જાણતા નથી, કે સારી છે.

316
00:15:36,330 --> 00:15:38,300
રોબ: અમે તે પછીની સમસ્યા ઉપયોગ જઈ રહ્યાં છો.

317
00:15:38,300 --> 00:15:40,750
પરંતુ જો તમે જાણતા નથી એક bitwise ઓપરેટર શું છે, કે દંડ છે.

318
00:15:40,750 --> 00:15:43,575
10 વક્તા: તે ASCII કોડ દેવાનો જેમ કે છે?

319
00:15:43,575 --> 00:15:44,050
અલી: નંબર

320
00:15:44,050 --> 00:15:44,750
રોબ: નંબર

321
00:15:44,750 --> 00:15:46,220
તમે આ સમસ્યા માટે આ કરી શકે.

322
00:15:46,220 --> 00:15:48,280
10 વક્તા: કે જે તમને કેવી રીતે કરવું?

323
00:15:48,280 --> 00:15:52,460
તેથી ફક્ત જો હું ક્યાંક લખી હતી -

324
00:15:52,460 --> 00:15:54,670
અલી: કે સાથે લખી કંઈક.

325
00:15:54,670 --> 00:15:56,780
રોબ: હું કરી શકે આ માં ફક્ત પ્રકાર પ્રકારની.

326
00:15:56,780 --> 00:15:59,045
અલી: ટોચ પર બાંધો.

327
00:15:59,045 --> 00:16:01,390
રોબ: ઓહ, હું માઇકને પર બેઠી છું.

328
00:16:01,390 --> 00:16:10,860
>> તેથી, અમે વ્યાખ્યાન માં જોયું કે મૂડી માટે ASCII કિંમત એ 65 છે.

329
00:16:10,860 --> 00:16:13,670
અને મૂડી બી 66 પ્રયત્ન કરશે, અને એમ.

330
00:16:13,670 --> 00:16:20,860
તેથી તમે 'એ' શાબ્દિક શકો છો 65 નંબર થાય છે.

331
00:16:20,860 --> 00:16:24,600
જેમ, આ 65 કિંમત છે.

332
00:16:24,600 --> 00:16:30,950
'એ' - હું પૂર્ણાંક એક્સ = 100 કંઈક કરી શકો છો. અને હવે એક્સ કિંમત હશે

333
00:16:30,950 --> 00:16:33,810
100 - 65.

334
00:16:33,810 --> 00:16:36,708
અલી: તમે કે ચલાવો અને દર્શાવે છે કે શકે છે.

335
00:16:36,708 --> 00:16:38,420
ઓહ. કદાચ નથી

336
00:16:38,420 --> 00:16:38,600
કશો વાંધો નહીં.

337
00:16:38,600 --> 00:16:40,970
રોબ: હું તેને છાપી હતી.

338
00:16:40,970 --> 00:16:43,730
10 વક્તા: તમે તેને કેવી રીતે બંધ કરવું અક્ષર પર પાછા?

339
00:16:43,730 --> 00:16:46,800
અલી: તેથી જો તમે don't -

340
00:16:46,800 --> 00:16:51,450
તમે તેને ઘરનાં પરચૂરણ કામો એક પ્રયત્ન કરવા માટે દબાણ સમકક્ષ.

341
00:16:51,450 --> 00:16:53,630
રોબ: તેથી ત્યાં એક છે -

342
00:16:53,630 --> 00:16:58,440
ચાર રચે છે અને પૂર્ણાંક વચ્ચે તફાવત કદની બાબતમાં માત્ર છે.

343
00:16:58,440 --> 00:17:01,230
તેથી પૂર્ણાંક માટે વસ્તુઓ પ્રતિનિધિત્વ અપ કરવાનો પ્રયત્ન થાય છે

344
00:17:01,230 --> 00:17:02,600
માટે, પસંદ, અબજ ચાર.

345
00:17:02,600 --> 00:17:05,839
એ ઘરનાં પરચૂરણ કામો માત્ર છે વસ્તુઓ 255 સુધી પ્રતિનિધિત્વ કરવાનો.

346
00:17:05,839 --> 00:17:08,390
પરંતુ તેમની વચ્ચે કોઈ તફાવત આ કરતાં અન્ય છે.

347
00:17:08,390 --> 00:17:12,339
તેથી તમે કેચ = 65 ઘરનાં પરચૂરણ કામો કહેવું કરી શકો છો.

348
00:17:12,339 --> 00:17:24,204
જણાવ્યું છે કે ઘરનાં પરચૂરણ કામો કેચ સમકક્ષ 'એ' માટે સમકક્ષ છે.

349
00:17:24,204 --> 00:17:25,210
અલી: ઓહ, નો.

350
00:17:25,210 --> 00:17:26,710
વાસ્તવમાં તે વસ્તુઓ સાચવી નથી.

351
00:17:26,710 --> 00:17:28,130
રોબ: ના, તો તમે તે નથી કરી શકો છો.

352
00:17:28,130 --> 00:17:31,610
અલી: તે માત્ર છે -

353
00:17:31,610 --> 00:17:34,920
[GROANS]

354
00:17:34,920 --> 00:17:40,700
>> રોબ: ઠીક છે, જેથી અલી માત્ર લખ્યું હતું કે કયા કાર્યક્રમ જે પ્રથમ 100 છાપે હતી -

355
00:17:40,700 --> 00:17:46,290
પૂર્ણાંક તરીકે 'એ', જે 35 હતી અમે અપેક્ષા, 100 બાદ તે ASCII કારણ કે

356
00:17:46,290 --> 00:17:48,580
એક બજારમૂલ્ય 65 છે.

357
00:17:48,580 --> 00:17:54,100
ત્યાર બાદ તેણી છપાયેલ% C, જે તે ચાર રચે તરીકે અર્થઘટન અર્થ છે મદદથી.

358
00:17:54,100 --> 00:17:57,050
100 તેથી - એક 35 છે.

359
00:17:57,050 --> 00:18:00,990
એક પાત્ર તરીકે કે ઈન્ટરપ્રીટ કરવા માટે હેશ પ્રતીક બને છે.

360
00:18:00,990 --> 00:18:06,160
જો તમે asciitable.com અથવા જે જોવા, તમે જોશો કે 35 છે

361
00:18:06,160 --> 00:18:07,410
હેશ પ્રતીક.

362
00:18:09,940 --> 00:18:12,700
અલી: ઠીક છે, આ સમસ્યા અંગે કોઇ અન્ય સ્પષ્ટિકરણ?

363
00:18:16,000 --> 00:18:18,180
ઠીક છે, તમે ગાય્સ આગળ વધીશું અને તે પછી કરી શકો છો.

364
00:18:18,180 --> 00:18:20,330
પ્રશ્નો પૂછો અથવા એકબીજા સાથે વાત નિઃસંકોચ.

365
00:18:20,330 --> 00:18:24,390
અથવા જો તમે પહેલેથી જ પૂર્ણ કરી લો, તમે આરામ કરી શકો છો.

366
00:18:24,390 --> 00:18:29,640
>> LUCAS: તેઓ જ વર્ગ છે, જેથી તમામ લોઅરકેસ અક્ષરો અને છો

367
00:18:29,640 --> 00:18:32,923
પણ મોટા ક્રમમાં પણ છે, કારણ કે તે માટે ઉપયોગી કશુંક

368
00:18:32,923 --> 00:18:33,990
સમસ્યા.

369
00:18:33,990 --> 00:18:35,620
અલી: ગુડ બિંદુ, લુકાસ.

370
00:18:35,620 --> 00:18:37,430
તેથી, તમે ગાય્સ તમામ નહોતી કે શું?

371
00:18:37,430 --> 00:18:37,640
11 વક્તા: હા.

372
00:18:37,640 --> 00:18:39,535
કે તમે કેવી રીતે કરવું તે યોગ્ય?

373
00:18:39,535 --> 00:18:39,960
અલી: અધિકાર.

374
00:18:39,960 --> 00:18:40,415
રોબ: યાહ.

375
00:18:40,415 --> 00:18:47,270
11 વક્તા: [અશ્રાવ્ય]

376
00:18:47,270 --> 00:18:48,330
અલી: અધિકાર બધા.

377
00:18:48,330 --> 00:18:49,350
રોબ: પ્રશ્ન શું પુછે છે?

378
00:18:49,350 --> 00:18:50,590
જસ્ટ કન્વર્ટ કરવા માટે -

379
00:18:50,590 --> 00:18:52,560
અલી છે: અપરકેસ માટે લોઅરકેસ કન્વર્ટ કરો.

380
00:18:52,560 --> 00:18:53,100
આ તે છે.

381
00:18:53,100 --> 00:18:54,700
રોબ: ઠીક છે.

382
00:18:54,700 --> 00:18:56,180
અલી: અમે તે લખવા જોઇએ?

383
00:18:56,180 --> 00:18:59,340
હું માનું અમે અંતે બીજાના જોવા મળશે.

384
00:18:59,340 --> 00:19:07,140
રોબ: તેથી જેઓ અટકી શકે, માટે માર્ગ -

385
00:19:07,140 --> 00:19:15,160
જો મને ઘરનાં પરચૂરણ કામો કો હોય છે, અને આપણે કહેવું તે અક્ષર બને ડી

386
00:19:15,160 --> 00:19:20,760
તેથી હવે હું કેવી રીતે આકૃતિ મૂળાક્ષર સી પત્ર શું છે?

387
00:19:20,760 --> 00:19:25,620
ડી નથી પરંતુ, હું તેનો અર્થ, ડી માટે મૂળાક્ષરના ચોથા પત્ર બને છે.

388
00:19:25,620 --> 00:19:28,910
અને જો આપણે 0 થી ગણતરી શરૂ કરવા માટે, પછી તે મૂળાક્ષર ત્રીજા પત્ર છે.

389
00:19:28,910 --> 00:19:36,240
તેથી જો એક 0 છે, બી 1, સી 2 એ 3 ડી છે, હું કેવી રીતે પૂર્ણાંક સ્થિતિ આકૃતિ કરી શકો છો -

390
00:19:36,240 --> 00:19:40,780
મૂળાક્ષરમાંથી સી સ્થિતિ શું છે?

391
00:19:40,780 --> 00:19:42,333
શું કોઇને કોઇ વિચારો હશે?

392
00:19:42,333 --> 00:19:45,440
અલી: મને લાગે છે કે તેઓ તમામ કોડિંગ કરી રહ્યાં છો.

393
00:19:45,440 --> 00:19:46,440
રોબ: શું પ્રથમ વિશે શું?

394
00:19:46,440 --> 00:19:48,608
12 વક્તા: તેથી ગમે એ છે, પ્રથમ સબ્ટ્રેક્ટ?

395
00:19:48,608 --> 00:19:49,030
રોબ: યાહ.

396
00:19:49,030 --> 00:19:49,950
અલી: અરે વાહ, અદ્ભુત.

397
00:19:49,950 --> 00:19:51,765
તેથી તમે મૂડી ડી કરી શકે -

398
00:19:51,765 --> 00:19:52,840
ઓહ, માફ કરશો.

399
00:19:52,840 --> 00:19:55,620
તમે અક્ષર લો અને તમે પ્રથમ એક સબ્ટ્રેક્ટ છે, તમે જણાવ્યું હતું.

400
00:19:55,620 --> 00:20:03,940
રોબ: તેથી જો ડી 68 કંઈક છે, અને અમે એ, સબ્ટ્રેક્ટ જે 65 છે, તો પછી અમે વિચાર

401
00:20:03,940 --> 00:20:07,130
3, અમને જણાવ્યાં કે ડી મૂળાક્ષરમાંથી ત્રીજા પત્ર છે

402
00:20:07,130 --> 00:20:09,290
0 થી શરુ થતા હોય.

403
00:20:09,290 --> 00:20:11,310
તેથી કે જે તમને વાપરી શકો છો.

404
00:20:11,310 --> 00:20:13,830
હવે અમે મૂળાક્ષર શું દ્રષ્ટિએ, પત્ર ખબર

405
00:20:13,830 --> 00:20:16,060
મૂડી પત્રો, અથવા -

406
00:20:16,060 --> 00:20:18,330
અમે નાના અક્ષરો વડે મિશ્રિત માટે તે જ વસ્તુ કરવા માટે શું કરી શકે છે આકૃતિ

407
00:20:18,330 --> 00:20:20,170
સ્થિતિ અમે સાઇન છો લોઅરકેસ

408
00:20:20,170 --> 00:20:25,690
અને અમે ઉપયોગ કરી શકો છો કે પછી કન્વર્ટ કરવા માટે કે ઉપયોગ કરીને મોટા માટે

409
00:20:25,690 --> 00:20:26,970
ખૂબ સમાન વિચાર.

410
00:20:31,470 --> 00:20:32,670
સૂચનો માટે કહો?

411
00:20:32,670 --> 00:20:35,810
>> અલી: તમે ગાય્સ શું - રાહ, મને ખબર નથી જ્યાં સુધી તમે કેવી રીતે ગાય્સ છે.

412
00:20:35,810 --> 00:20:40,060
શું તમે પૂર્ણ મોટા ભાગના, તો તમે હજુ પણ કામ કરી રહ્યા છે, તો તમે અટવાઇ જાય?

413
00:20:40,060 --> 00:20:42,020
તમે ગાય્સ બહાર પોકાર કરી શકો છો -

414
00:20:42,020 --> 00:20:42,330
અટકી.

415
00:20:42,330 --> 00:20:43,210
એક વ્યક્તિ અટકી છે.

416
00:20:43,210 --> 00:20:43,560
સરસ.

417
00:20:43,560 --> 00:20:44,700
હું ભરાઇ ગયેલો પણ કરતા હોય છે.

418
00:20:44,700 --> 00:20:45,415
13 વક્તા: હું પૂર્ણ છું.

419
00:20:45,415 --> 00:20:46,410
અલી: તમે કરી રહ્યાં છો?

420
00:20:46,410 --> 00:20:47,480
ઠીક છે.

421
00:20:47,480 --> 00:20:47,935
થઈ ગયું.

422
00:20:47,935 --> 00:20:49,300
13 વક્તા: [અશ્રાવ્ય]

423
00:20:49,300 --> 00:20:50,600
અલી: યાહ કૂલ.

424
00:20:50,600 --> 00:20:53,720
શું તમે ચકાસણી કે તે લોઅરકેસ ફોર્મ છે?

425
00:20:53,720 --> 00:20:56,730
ઠીક છે કૂલ.

426
00:20:56,730 --> 00:20:59,882
જ્યાં અન્ય લોકો છે?

427
00:20:59,882 --> 00:21:06,140
શું આ સંકેત તમે તમારી જાતને અલગ ચોંટતા માટે, મદદ?

428
00:21:06,140 --> 00:21:09,778
14 વક્તા: જવાબ નથી ખરેખર પરંતુ માત્ર કારણ કે, મને ખબર નથી, હું નથી

429
00:21:09,778 --> 00:21:11,590
તે હજુ સુધી પાચન.

430
00:21:11,590 --> 00:21:12,640
અલી: ઠીક કૂલ.

431
00:21:12,640 --> 00:21:13,431
શું તમે પ્રયાસ કરવા માંગો છો -

432
00:21:13,431 --> 00:21:16,140
અથવા તમે જાઓ અને વાત કરવા માંગો છો?

433
00:21:16,140 --> 00:21:18,590
>> રોબ: હું કહેવા જવાનો હતો છે શું -

434
00:21:18,590 --> 00:21:19,890
તેથી આ મદદથી.

435
00:21:19,890 --> 00:21:22,650
શું તમે સમજી અમે કેવી રીતે મેળવી મૂળાક્ષર સ્થિતિ શું

436
00:21:22,650 --> 00:21:24,820
આ પત્રમાં છે?

437
00:21:24,820 --> 00:21:30,616
14 વક્તા: ઠીક છે, તેથી જ્યારે તમે એક અવતરણ વસ્તુઓ મૂકી

438
00:21:30,616 --> 00:21:35,030
કે જે નંબર આપે છે?

439
00:21:35,030 --> 00:21:37,100
રોબ: હા.

440
00:21:37,100 --> 00:21:40,840
તે ASCII કિંમત તેને રજૂ કરે છે અનુવાદિત કરવામાં આવશે.

441
00:21:40,840 --> 00:21:43,350
તો તમે તે ASCII ટેબલ અથવા તે ગમે પર જાઓ કરવા માંગો છો?

442
00:21:46,456 --> 00:21:47,840
અલી: જસ્ટ આ એક?

443
00:21:47,840 --> 00:21:49,970
રોબ: હા.

444
00:21:49,970 --> 00:21:55,270
તેથી જ્યારે તમે આ પ્રતીકો કોઈપણ મૂકવા માટે, ઘણાં અવગણીને -

445
00:21:55,270 --> 00:21:56,450
અલી: [અશ્રાવ્ય]

446
00:21:56,450 --> 00:21:57,620
રોબ: ઓહ, કર્સર મદદથી.

447
00:21:57,620 --> 00:21:58,380
અલી: યાહ.

448
00:21:58,380 --> 00:21:59,690
કે આકર્ષક હતું.

449
00:21:59,690 --> 00:22:04,050
રોબ: તેથી, ડાબી, જે ખાસ પ્રતીકો છે આ મુદ્દાઓ અવગણીને -

450
00:22:04,050 --> 00:22:08,520
જો તમે એક જ અવતરણચિહ્નો આ પ્રતીકો કોઈપણ મૂકી, પછી તે થશે

451
00:22:08,520 --> 00:22:11,620
ડાબી પર આ કિંમત માટે અનુવાદ.

452
00:22:11,620 --> 00:22:13,660
અલી: આ તે માટે રેખાંશ નંબર છે.

453
00:22:13,660 --> 00:22:19,710
તે 65, બી 66 સાથે એક મેચ જેવું છે, અને તમે નોટિસ કરીશું કે તેઓ તમામ છો

454
00:22:19,710 --> 00:22:21,540
મૂળાક્ષર ક્રમ છે, કે જે તફાવત બનાવે છે.

455
00:22:21,540 --> 00:22:27,110
તેથી, તરીકે રોબ કહે છે, તે પહેલાં, તે કોડ માં, અમે ના અંતર ગણતરી કરવામાં આવી હતી

456
00:22:27,110 --> 00:22:29,610
પ્રથમ પત્ર, દીઠ સે.

457
00:22:29,610 --> 00:22:32,820
અને તે જ હોઈ શકે છે, પછી ભલે તે અપરકેસ અથવા લોઅરકેસ કરીશું.

458
00:22:32,820 --> 00:22:38,390
રોબ: તેથી જ્યારે અમે 65 એ, ઓછા ડી, 68 હતી, અમે 3 મેળવો.

459
00:22:38,390 --> 00:22:42,370
કારણ કે ડી મૂળાક્ષરમાંથી માં ત્રણ સ્થાનો છે.

460
00:22:42,370 --> 00:22:46,680
અલી: તેથી તે પછી તમે કેવી રીતે અનુવાદિત છે કે ઉપર થોડું ડી શોધવા માટે બનાવવા માટે છે?

461
00:22:46,680 --> 00:22:47,240
રોબ: યાહ.

462
00:22:47,240 --> 00:22:52,230
તેથી જો હું 3 હવે, હું જાણું છું કે હું જે ત્રણ અક્ષરો જવા માંગો છો -

463
00:22:52,230 --> 00:22:54,830
અમે નાના જઈને કરી હવે થાય છે, પરંતુ આપણે કહેવું કે હું ત્રણ જવા માંગો છો

464
00:22:54,830 --> 00:22:58,610
વસ્તુઓના લોઅરકેસ બાજુ માં પોઝિશન્સ.

465
00:22:58,610 --> 00:23:01,400
કેવી રીતે હું આ કરી શકે?

466
00:23:01,400 --> 00:23:04,240
મને ખબર છે કે એક 97 છે લોઅરકેસ.

467
00:23:04,240 --> 00:23:07,535
કેવી રીતે હું લોઅરકેસ અક્ષરો માં નથી ત્રણ સ્થાનો શોધવા?

468
00:23:10,461 --> 00:23:11,934
>> 15 વક્તા: હું એક પ્રશ્ન ખરેખર હોય છે.

469
00:23:11,934 --> 00:23:12,425
અલી: અરે વાહ, આગળ જાઓ.

470
00:23:12,425 --> 00:23:14,880
15 વક્તા: તેથી આ માટે, તે ખરેખર જો હું આ સ્થિતિ જાણવા વાંધો નથી,

471
00:23:14,880 --> 00:23:16,360
ગમે, હું આ ટેબલ જરૂર નથી.

472
00:23:16,360 --> 00:23:16,840
રોબ: ના.

473
00:23:16,840 --> 00:23:19,380
તમે આ નંબરો કોઈપણ ઉપયોગ ક્યારેય જરૂર રહેશે નહીં.

474
00:23:19,380 --> 00:23:23,670
અને આ તમારી કાર્યક્રમો એક મહત્વપૂર્ણ બિંદુ છે તમે ક્યારેય હાર્ડ જોઈએ કે

475
00:23:23,670 --> 00:23:25,500
આ સ્થિરાંકો કોઈપણ કોડ.

476
00:23:25,500 --> 00:23:31,190
'એ' નો ઉપયોગ કરો. 65 અથવા 97 ક્યારેય ઉપયોગ કરે છે.

477
00:23:31,190 --> 00:23:34,370
અલી: આ જાદુ નંબરો કહેવાય છે, અને તેઓ ખરેખર ગૂંચવણમાં છીએ.

478
00:23:34,370 --> 00:23:37,080
જેમ કે, જ્યારે તમે એક કોડ ડીબગ કરી રહ્યાં છો, તમે યાદ નથી તેવા

479
00:23:37,080 --> 00:23:38,020
તમે તેમને માટે વપરાય છે.

480
00:23:38,020 --> 00:23:40,770
અને અમને તમારો કોડ વર્ગીકરણ માટે, અમે ખરેખર ખબર નહિ શું

481
00:23:40,770 --> 00:23:41,750
તમે તેમના માટે ઉપયોગ કરી રહ્યાં છો.

482
00:23:41,750 --> 00:23:44,815
તેથી તે વધુ સારું છે, જો તમે વાસ્તવમાં તે અક્ષરો ઉપયોગ જેથી તે બનાવે છે

483
00:23:44,815 --> 00:23:46,065
વધુ લોકોને સમજણ.

484
00:23:49,460 --> 00:23:51,160
ઠીક છે, કોઈ અન્ય પ્રશ્નો છે?

485
00:23:51,160 --> 00:23:52,975
વધુ લોકોને થાય છે, અથવા -

486
00:23:56,243 --> 00:23:57,493
હું માનું અમે તપાસ કરી શકે છે.

487
00:23:59,870 --> 00:24:02,410
તે ખૂબ જ ડરતાં કે તમે લોકોને કોડ જોઈ શકો છો.

488
00:24:02,410 --> 00:24:04,970
રોબ: યાહ.

489
00:24:04,970 --> 00:24:06,410
અમે તે અહીં નથી.

490
00:24:06,410 --> 00:24:08,380
અમે લોકો નામો નહિં જાણતા હોય, તો ક્યાં તો નથી.

491
00:24:08,380 --> 00:24:10,940
અલી: ઓહ હા, સાથે સાથે તે વધુ સારી રીતે બનાવે છે, તેથી અમે વધુ unbiased હશો

492
00:24:10,940 --> 00:24:14,820
ને બદલે માત્ર રેન્ડમ કોઈને ચૂંટતા.

493
00:24:14,820 --> 00:24:15,360
ચિંતા કરશો નહીં.

494
00:24:15,360 --> 00:24:16,265
મેં તે શું કરશે.

495
00:24:16,265 --> 00:24:20,396
ક્યારેય મન - જો તમે લગભગ રેન્ડમ વસ્તુઓ હોય છે.

496
00:24:20,396 --> 00:24:20,870
ઠીક છે.

497
00:24:20,870 --> 00:24:22,556
લોકો કેવી રીતે કરી રહ્યા છો?

498
00:24:22,556 --> 00:24:26,950
>> 17 વક્તા: તેથી નવમી રેખા બહાર, એક અક્ષર છાપો જોઈએ?

499
00:24:26,950 --> 00:24:27,430
રોબ: હા.

500
00:24:27,430 --> 00:24:27,910
અલી: યાહ.

501
00:24:27,910 --> 00:24:30,770
તેથી જો તમે જાઓ -

502
00:24:30,770 --> 00:24:32,200
રોબ: ઓહ, કે નથી કરી શકો છો.

503
00:24:32,200 --> 00:24:35,400
અલી: તમે જોશો કે તે હેશ પ્રતીક મુદ્રિત.

504
00:24:35,400 --> 00:24:37,180
17 વક્તા: ઓહ, ઠીક છે.

505
00:24:37,180 --> 00:24:41,290
રોબ: હું માનું બીજી રીતે તમે વસ્તુઓ જોવા શકે છે અમે બે છાપવા કરી રહ્યાં છો

506
00:24:41,290 --> 00:24:42,540
અક્ષરો.

507
00:24:44,500 --> 00:24:47,740
એક પ્રથમ અમે છાપવા રહ્યાં છો તે અક્ષર એ છે

508
00:24:47,740 --> 00:24:51,610
આગામી એક અમે છાપવા કરી રહ્યાં છો 65 માત્ર છે.

509
00:24:51,610 --> 00:24:54,450
તે કદાચ આ માટે મને અંતે કિકિયારી પડશે.

510
00:24:54,450 --> 00:25:00,060
તેથી જો આપણે ફક્ત આ ચલાવો, તો તમારે ધ્યાન પડશે કે તે એક વાર બંને છાપે છે.

511
00:25:00,060 --> 00:25:02,070
કારણ કે અમે તે જ વસ્તુ કહીએ છીએ.

512
00:25:02,070 --> 00:25:07,840
અમે તેને કહીએ છીએ એ પત્ર એ છાપો અને પછી અમે તેને છાપી માટે પૂછી રહ્યાં છો તે

513
00:25:07,840 --> 00:25:13,820
65 નંબર એક અક્ષર છે, જે આ જ વસ્તુ છે અર્થઘટન.

514
00:25:13,820 --> 00:25:15,100
અલી: શું તમે કહી કંઈક છે?

515
00:25:15,100 --> 00:25:18,150
ઓહ, માત્ર મજાક કરું છું, માફ કરશો.

516
00:25:18,150 --> 00:25:20,640
બધા હક, લોકો કેવી રીતે છે -

517
00:25:20,640 --> 00:25:22,280
રોબ: અમે માત્ર તે લઈ જવામાં કરી શકો છો.

518
00:25:22,280 --> 00:25:25,250
>> અલી: ઠીક છે, તેથી તમે કેવી રીતે શરૂ કરું?

519
00:25:25,250 --> 00:25:26,500
કોઈપણ?

520
00:25:28,030 --> 00:25:34,486
સંકેત તરીકે, અમે typers ના લોકો પાસેથી કંઈક મેળવી છે.

521
00:25:34,486 --> 00:25:36,850
18 વક્તા: [અશ્રાવ્ય]

522
00:25:36,850 --> 00:25:38,290
અલી: ઓહ હા, પ્રોમ્પ્ટ સંપૂર્ણ.

523
00:25:38,290 --> 00:25:40,660
તેથી અમે લખો કરીશું -

524
00:25:40,660 --> 00:25:41,670
અમે શું લખો છો?

525
00:25:41,670 --> 00:25:43,660
કોઈપણ?

526
00:25:43,660 --> 00:25:46,480
અથવા હું હમણાં જ તે લખો જોઈએ?

527
00:25:46,480 --> 00:25:47,530
- શું આપણે વાસ્તવમાં લખીને

528
00:25:47,530 --> 00:25:48,430
રોબ: શ્યોર.

529
00:25:48,430 --> 00:25:50,990
અલી: તેથી અમે તેને પૂછવા printf લખો કરીશું, જેથી અમે પ્રયત્ન કરી શકો છો

530
00:25:50,990 --> 00:25:54,810
ગમે તો, મને એક અક્ષર આપે છે.

531
00:25:54,810 --> 00:25:55,710
ઠીક છે, અને તે પછી શું?

532
00:25:55,710 --> 00:25:56,664
તે શા માટે કરી છે?

533
00:25:56,664 --> 00:25:57,620
રોબ: મને ખબર નથી.

534
00:25:57,620 --> 00:26:00,070
અલી: ઠીક છે.

535
00:26:00,070 --> 00:26:03,680
તેથી હવે અમે તેમને કહેવાની કરી રહ્યાં છો અમને અક્ષર આપે છે.

536
00:26:03,680 --> 00:26:07,064
પરંતુ તે પછી તમે ખરેખર કેવી રીતે નથી કે પાત્ર મળી શકે?

537
00:26:07,064 --> 00:26:10,060
19 વક્તા: ઉપયોગની GetString.

538
00:26:10,060 --> 00:26:12,040
અલી: GetString?

539
00:26:12,040 --> 00:26:12,850
GetChar?

540
00:26:12,850 --> 00:26:17,038
ઠીક છે, તેથી શું શબ્દમાળા અને ઘરનાં પરચૂરણ કામો વચ્ચે તફાવત છે?

541
00:26:17,038 --> 00:26:20,020
19 વક્તા: સ્ટ્રીંગ્સ શ્રેણીબદ્ધ અક્ષરો ઝાકઝમાળ જેવા હોય છે.

542
00:26:20,020 --> 00:26:21,910
>> અલી: સરસ, હા.

543
00:26:21,910 --> 00:26:25,550
જેથી આ સમસ્યા છે, અમે માત્ર એક સમયે એક અક્ષર ધ્યાનમાં જરૂર છે, તેથી

544
00:26:25,550 --> 00:26:28,400
અમે માત્ર કે દાખલા તરીકે GetChar કરવા જઇ રહ્યા છો.

545
00:26:28,400 --> 00:26:32,400
રોબ: અમે કાર્ય અમલમાં જો આપણે ઇચ્છતા કે જે સમગ્ર શબ્દમાળા લીધો શકે

546
00:26:32,400 --> 00:26:35,750
અને શબ્દમાળા પર ગયા અને મોટા અને તમામ લોઅરકેસ બદલી

547
00:26:35,750 --> 00:26:37,380
માટે લોઅરકેસ અપરકેસ.

548
00:26:37,380 --> 00:26:39,170
પરંતુ અહીં, અમે માત્ર એક પાત્ર માટે કરી રહ્યા છો તમે પૂછવા.

549
00:26:39,170 --> 00:26:42,800
અલી: તેથી હવે અમે અક્ષર અહીં હોય છે, પરંતુ તે પછી અમે તેને સંગ્રહો જરૂર છે.

550
00:26:42,800 --> 00:26:45,070
તેથી તો અમે ઘરનાં પરચૂરણ કામો કેચ ઉમેરીશું - શું?

551
00:26:45,070 --> 00:26:46,070
20 વક્તા: વેરિયેબલ વ્યાખ્યાયિત કરો.

552
00:26:46,070 --> 00:26:48,100
અલી: અરે વાહ, બરાબર.

553
00:26:48,100 --> 00:26:49,585
જેથી અમે અમારા પાત્ર હોય છે.

554
00:26:49,585 --> 00:26:51,766
રોબ: મને લાગે છે કે તમે પણ હોઈ શકે -

555
00:26:51,766 --> 00:26:55,630
તમે માત્ર ત્રણ જગ્યાઓ છો છે, કેમ કે તે તમને yelling છે.

556
00:26:55,630 --> 00:27:01,300
>> અલી: ઠીક છે, ઠંડી, હવે કે અમે સેટ tabbing છે, આગળ શું થશે?

557
00:27:01,300 --> 00:27:02,550
આગામી પગલું શું છે?

558
00:27:05,590 --> 00:27:08,870
રોબ: અમારા કાર્યક્રમ શું કરવું જોઈએ શું છે માટે એક નાના અક્ષર ફેરફાર

559
00:27:08,870 --> 00:27:10,130
અક્ષરમોટાંઅક્ષરો.

560
00:27:10,130 --> 00:27:15,478
તો શું હું હેશ પ્રતીક દાખલ થાય છે?

561
00:27:15,478 --> 00:27:16,314
એટલે કે -

562
00:27:16,314 --> 00:27:16,732
અલી: તે એક સારો સંકેત છે.

563
00:27:16,732 --> 00:27:18,270
અમે તેને ઘણો ઉપયોગ કરે છે.

564
00:27:18,270 --> 00:27:21,937
રોબ: ઈઝ કે માન્ય મેં એક મોટા ફોર્મ રૂપાંતરિત કરી શકે છે?

565
00:27:21,937 --> 00:27:23,070
21 વક્તા: નંબર

566
00:27:23,070 --> 00:27:24,070
અલી: નંબર

567
00:27:24,070 --> 00:27:24,900
અમે તે તપાસ કરીશું.

568
00:27:24,900 --> 00:27:34,950
તેથી અમે એક હોઈ શકે નિવેદન જેથી ચકાસણી જો કેચ કરતા વધારે છે, જો

569
00:27:34,950 --> 00:27:37,410
અથવા 'લોઅરકેસ a'સમાન -

570
00:27:37,410 --> 00:27:45,490
તેથી જો આપણે ચાર્ટ જુઓ, તમે નોટિસ પડશે કે તે અહીં વચ્ચે હોવું જોઈએ,

571
00:27:45,490 --> 00:27:47,670
97, અને લોઅરકેસ એક છે.

572
00:27:47,670 --> 00:27:52,110
અને આ કોઈપણ હોઈ શકે છે, અને વૃદ્ધિના આધારે તમામ માર્ગ નહીં.

573
00:27:52,110 --> 00:27:55,200
અને પછી ત્યાં 122 અંતે z છે.

574
00:27:55,200 --> 00:27:58,215
અને તે આ બે કિંમતો વચ્ચે આવતા હોય છે.

575
00:27:58,215 --> 00:27:59,700
એ નથી કે સૂઝ છે?

576
00:27:59,700 --> 00:28:04,130
રોબ: તેથી જો કેચ 97 અને 122 વચ્ચે નથી -

577
00:28:04,130 --> 00:28:09,960
અથવા તમે તે નંબરો ઉપયોગ ક્યારેય જરૂર જોઇએ - જો કો 'એ' અને વચ્ચે નથી

578
00:28:09,960 --> 00:28:15,110
'Z,' પછી તે અમને મોટા માટે માન્ય અક્ષર નથી.

579
00:28:15,110 --> 00:28:18,590
અલી: તેથી કોડ સ્વરૂપ છે, અમે કહીએ છીએ કે જો કો કરતાં વધારે અથવા એક સમાન છે

580
00:28:18,590 --> 00:28:19,640
કેસ લોઅરકેસ -

581
00:28:19,640 --> 00:28:21,270
સંક્ષોભજનક જીત, કેવી રીતે છે કે જે તમને કહ્યું નહોતું?

582
00:28:21,270 --> 00:28:26,900
ઠીક છે, કરતાં વધારે અથવા લોઅરકેસ 'એ' ને સમાન હોય છે, અને તે માટે ઉપર હોવો જોઈએ

583
00:28:26,900 --> 00:28:32,250
આ લોઅરકેસ 'z.' તેથી તે કરતાં ઓછી અથવા સમાન માટે 'z' લોઅરકેસ પ્રયત્ન છે.

584
00:28:32,250 --> 00:28:35,300
અમે ખાતરી કરો કે તે બે વચ્ચે છે બનાવી રહ્યા છો.

585
00:28:35,300 --> 00:28:38,540
તો પછી અમે અમારી ખુશ કોડ સાથે ચાલુ રાખી શકો છો.

586
00:28:41,992 --> 00:28:43,360
શું?

587
00:28:43,360 --> 00:28:46,860
રોબ: તેથી હું figured અમે માત્ર પૂછવા રાખવા માંગો છો, તો અમે એક ન હોય તો શું

588
00:28:46,860 --> 00:28:48,250
પત્ર લોઅરકેસ.

589
00:28:48,250 --> 00:28:51,130
અલી: ઓહ, હું કે પરિચિત ન હતો.

590
00:28:51,130 --> 00:28:52,820
માફ કરશો.

591
00:28:52,820 --> 00:28:58,100
>> ઠીક છે, તેથી જો આપણે કરવા જઈ રહ્યાં છો તરીકે રોબ કહે છે, અને ખાતરી કરો કે -

592
00:28:58,100 --> 00:29:02,068
અમે તેમને પૂછ્યા રાખો, પછી કરી શકો છો કે અમે શું કરીશું?

593
00:29:02,068 --> 00:29:02,994
22 વક્તા: [અશ્રાવ્ય]

594
00:29:02,994 --> 00:29:03,530
રોબ: યાહ.

595
00:29:03,530 --> 00:29:05,630
અમે લૂપ અમુક પ્રકારની ઉપયોગ કરવો જોઈએ.

596
00:29:05,630 --> 00:29:12,900
કારણ કે વપરાશકર્તા એ અમાપ જથ્થો સમયમાં અમાન્ય કંઈક દાખલ કરી શકો છો.

597
00:29:12,900 --> 00:29:14,990
તેથી તમે જ્યારે લૂપ વાપરી શકો છો.

598
00:29:14,990 --> 00:29:18,870
ડુ-જ્યારે લૂપ હેતુ -

599
00:29:18,870 --> 00:29:21,340
શાબ્દિક, તમારા સમગ્ર જીવનમાં ફક્ત એક જ વખત તમે ક્યારેય શું ઉપયોગ કરશે

600
00:29:21,340 --> 00:29:24,780
જ્યારે આંટીઓ છે જ્યારે તમે વપરાશકર્તા ઈનપુટ માટે કહીએ છીએ.

601
00:29:24,780 --> 00:29:28,260
તેથી હકીકત અમે વપરાશકર્તા ઈનપુટ માટે પૂછી રહ્યાં છો તે અહીં સૂચક છે કે અમે જોઈએ છે

602
00:29:28,260 --> 00:29:29,660
ડુ-જ્યારે લૂપ વાપરો.

603
00:29:29,660 --> 00:29:30,780
અને તે શા માટે છે?

604
00:29:30,780 --> 00:29:34,270
કારણ કે આમ-જ્યારે લૂપ હંમેશા ઓછામાં ઓછું એક વાર બને છે.

605
00:29:34,270 --> 00:29:40,260
તેથી જ્યારે તમે વપરાશકર્તા ઈનપુટ માટે પૂછી રહ્યાં છો તે, તમે ઇચ્છો કે ઓછામાં ઓછા એક વખત થાય છે.

606
00:29:40,260 --> 00:29:42,750
અને પછી જો વસ્તુઓ સફળ રહ્યા હતા, તમે જઈને રાખી શકો છો.

607
00:29:42,750 --> 00:29:45,130
જો નહિં, તો પાછા જાઓ અને ફરીથી પૂછો.

608
00:29:45,130 --> 00:29:48,950
>> અલી: તેથી અન્ય શબ્દોમાં, અમે કલમ કરો.

609
00:29:48,950 --> 00:29:51,130
અને તેથી આ તે કહેવાની છે કંઈક.

610
00:29:51,130 --> 00:29:53,890
તેથી printf -

611
00:29:53,890 --> 00:29:57,490
સ્ટેટમેન્ટ માટે, પ્રોમ્પ્ટ પર, અને પણ અક્ષર વિચાર, અથવા પ્રયાસ છાપો

612
00:29:57,490 --> 00:29:58,780
એક પાત્ર છે.

613
00:29:58,780 --> 00:30:03,410
અને પછી અમે તપાસ જો તે ખરેખર તે યોગ્ય રીતે કર્યું છે.

614
00:30:03,410 --> 00:30:07,730
તેથી તો અમે શરતો ઉમેરો, તો પછી અમે જ્યારે કહે છે, અને પછી અમે હોય

615
00:30:07,730 --> 00:30:08,980
શરતી વિધાન.

616
00:30:11,600 --> 00:30:14,730
રોબ: પરંતુ હવે અમે વિચાર ટ્રેન ઉલટી છે.

617
00:30:14,730 --> 00:30:18,940
હવે અમે મૂળ જો કૈચ આ શ્રેણી છે કહેતા હતા, તે માન્ય છે.

618
00:30:18,940 --> 00:30:23,340
હવે અમે તે વિપરીત અને કહે છે જો કૈચ આ શ્રેણીમાં નથી માંગો છો, અમે તો પછી

619
00:30:23,340 --> 00:30:25,020
માટે વસ્તુઓ ફરીથી કરવા બેકઅપ કરવાની જરૂર છે.

620
00:30:25,020 --> 00:30:25,900
અલી: ઓહ, હા.

621
00:30:25,900 --> 00:30:31,720
રોબ: તેથી જ્યારે આ સત્ય નથી, અમે પાછા જાઓ અને માંગો છો

622
00:30:31,720 --> 00:30:34,470
અન્ય અક્ષર માટે પૂછો.

623
00:30:34,470 --> 00:30:36,880
નથી દરેકને કે જુઓ છો?

624
00:30:36,880 --> 00:30:38,830
આ પ્રશ્નો?

625
00:30:38,830 --> 00:30:39,400
ઠીક છે.

626
00:30:39,400 --> 00:30:43,480
>> તેથી હવે અમે કોઈ માન્ય અક્ષર કે અમે મોટા કરી શકો છો.

627
00:30:43,480 --> 00:30:47,150
અલી: તેથી પછી તે uppercasing માટે આગામી પગલું?

628
00:30:49,994 --> 00:30:51,890
23 વક્તા: 32 ઉમેરો.

629
00:30:51,890 --> 00:30:52,600
અલી: તમે ઉમેરો -

630
00:30:52,600 --> 00:30:54,150
માફ કરશો, શું?

631
00:30:54,150 --> 00:30:56,580
23 વક્તા: તમે ફક્ત 32 ઉમેરી શકતા નથી?

632
00:30:56,580 --> 00:31:02,360
રોબ: તેથી હા નથી, જાદુ સંખ્યાની દ્રષ્ટિએ.

633
00:31:02,360 --> 00:31:04,610
તમે માત્ર એક જ ક્વોટ સામગ્રી મદદથી જોઈએ.

634
00:31:04,610 --> 00:31:06,450
23 વક્તા: ઠીક છે, સારી -

635
00:31:06,450 --> 00:31:07,250
રોબ: પણ તમે 32 મેળવી શકો છો -

636
00:31:07,250 --> 00:31:11,870
અલી: તમે કેવી રીતે મેળવી તેણે 32 નંબર હું અનુમાન છે, આપણે શું કહી રહ્યાં છે.

637
00:31:11,870 --> 00:31:18,060
23 વક્તા: [અશ્રાવ્ય]

638
00:31:18,060 --> 00:31:22,158
રોબ: તેથી અમે સંખ્યા 32 ની સાથે આવી શકે -

639
00:31:22,158 --> 00:31:24,468
23 વક્તા: [અશ્રાવ્ય]

640
00:31:24,468 --> 00:31:24,930
રોબ: યાહ.

641
00:31:24,930 --> 00:31:28,540
પરંતુ જો આપણે તેને બે પગલાંઓ કરતા જઈ રહ્યાં છો તો અમે પહેલાં જ કર્યું

642
00:31:28,540 --> 00:31:29,950
સ્થિતિ સામગ્રી.

643
00:31:29,950 --> 00:31:36,910
તેથી મૂળાક્ષરો કે સી બને માં પોઝિશન કેચ બાદ લોઅરકેસ છે

644
00:31:36,910 --> 00:31:42,360
'એ'. તેથી જો આપણે એક લોઅરકેસ 'ડી' દાખલ કરેલું છે, પદ થી 3 પ્રયત્ન રહ્યું છે.

645
00:31:42,360 --> 00:31:46,490
અને હવે અમે વસ્તુઓના મોટા વિસ્તાર વસ્તુઓ લેવા માંગો છો.

646
00:31:46,490 --> 00:31:55,376
તેથી હવે અમારી નવી કેચ માટે મૂડી 'એ' પ્લસ સ્થિતિમાં હોઇ રહ્યું છે.

647
00:31:55,376 --> 00:32:00,090
તેથી લોકો જોઈ કેવી રીતે કરે છે કે અમને લાવે -

648
00:32:00,090 --> 00:32:04,140
અમે નાના શ્રેણીમાંથી ખસેડીએ છીએ, ચોક્કસ ઊંડાઈ અમે તે માં હતા

649
00:32:04,140 --> 00:32:07,650
શ્રેણી, અને મોટા શ્રેણીમાં નીચે રહ્યું છે, અને તે દૂર સુધી જવાની

650
00:32:07,650 --> 00:32:10,610
તે ફરીથી છે, કે જે એ જ પાત્ર રહ્યું છે, પણ હવે

651
00:32:10,610 --> 00:32:12,550
uppercased.

652
00:32:12,550 --> 00:32:16,490
અલી: અને લોકો કે કેવી રીતે દ્વારા પણ અસમંજસની હતા માટે તેમને માત્ર 32 જણાવ્યું હતું કે,

653
00:32:16,490 --> 00:32:20,390
મૂળભૂત રીતે તે એક નિવેદનમાં માં આ બંને સંયુક્ત.

654
00:32:20,390 --> 00:32:24,550
તેથી આ લખવા માટે કહેવું તમે હમણાં જ પ્રકારની કરી શકો છો એક સમકક્ષ માર્ગ

655
00:32:24,550 --> 00:32:28,190
અવેજી સ્થિતિ છે, કો બાદ 'એક' અને તે અહીં મૂકો.

656
00:32:28,190 --> 00:32:31,330
તેથી તેમણે શું કર્યું, હું don't -

657
00:32:31,330 --> 00:32:44,510
ઘરનાં પરચૂરણ કામો newc = મોટા 'એ' પ્લસ કેચ બાદ 'એ' લોઅરકેસ. અને કારણ કે બીજગણિત છે,

658
00:32:44,510 --> 00:32:47,090
તમે તેમને ખસેડવા આસપાસ કરી શકો છો.

659
00:32:47,090 --> 00:32:52,960
તમે પણ કહે છે કે તમે તેને ખસેડવા આસપાસ જેથી ઘરનાં પરચૂરણ કામો newc = મોટા 'એ' કરી શકે છે

660
00:32:52,960 --> 00:32:55,620
બાદ 'એ' પ્લસ કો લોઅરકેસ.

661
00:32:55,620 --> 00:32:58,650
અને આ તો, તમે જો અમે ચાર્ટ પર જાઓ નોટિસ પડશે.

662
00:33:01,160 --> 00:33:06,300
અમે મોટા એ 65 છે અને 97 છે લોઅરકેસ છે.

663
00:33:06,300 --> 00:33:09,800
જેથી 65 - 97 -32 છે.

664
00:33:09,800 --> 00:33:10,020
>> હાય.

665
00:33:10,020 --> 00:33:10,930
બેઠક લે છે.

666
00:33:10,930 --> 00:33:12,180
ઓહ.

667
00:33:16,240 --> 00:33:17,980
તમે અહીં બેસીને કરી શકો છો.

668
00:33:17,980 --> 00:33:20,805
સરસ, ઠીક, અદ્ભુત.

669
00:33:20,805 --> 00:33:22,390
વિભાગમાં આપનું સ્વાગત છે.

670
00:33:22,390 --> 00:33:25,110
તમે ધ્યાન પડશે કે તફાવત 32 છે.

671
00:33:25,110 --> 00:33:28,150
જેથી જ્યાં તેમણે જે નંબર મેળવ્યો.

672
00:33:28,150 --> 00:33:32,140
પરંતુ તે છે, રોબ કહે નથી, શ્રેષ્ઠ કરવું તે રીતે, કારણ કે તે વિચિત્ર છે

673
00:33:32,140 --> 00:33:35,260
જાદુ નંબર ગૂંચવણ.

674
00:33:35,260 --> 00:33:38,710
રોબ: તમે મૂડી ઉપયોગ એક બાદ એક લોઅરકેસ કરીશું.

675
00:33:38,710 --> 00:33:43,045
તમે હમણાં જ સીધા 32 ઉપયોગ કરવો ન જોઈએ.

676
00:33:43,045 --> 00:33:45,020
24 વક્તા કે કેમ છે, ફરી?

677
00:33:45,020 --> 00:33:49,860
તમે શા માટે તેનો ઉપયોગ 32 ન જોઈએ?

678
00:33:49,860 --> 00:33:55,630
અલી: જો અમે તેને આપી હતી, તે ઘરનાં પરચૂરણ કામો હશે newc -32 = + c.

679
00:33:55,630 --> 00:34:00,030
અને જો તમે તેને બાકીના કોઈપણ જોઈ નથી, જો આ બધા ગઇ છે, અને તમે

680
00:34:00,030 --> 00:34:04,720
ફક્ત આ એક વાક્ય જુઓ, પછી તમે કેવી રીતે ખબર નથી નકારાત્મક 32 શું છે?

681
00:34:04,720 --> 00:34:07,000
તે સ્થળ બહાર માત્ર છે.

682
00:34:07,000 --> 00:34:10,360
રોબ: તેથી તમારા કાર્યક્રમ દંડ સંપૂર્ણપણે કામ કરશે.

683
00:34:10,360 --> 00:34:12,960
તે માત્ર એક શૈલી વાત છે.

684
00:34:12,960 --> 00:34:17,760
કોઇકે માં જવું અને તમારો કોડ વાંચન, તેઓ 32 શું અર્થ એ નથી જેવા છો?

685
00:34:17,760 --> 00:34:18,889
કદાચ તેઓ don't -

686
00:34:18,889 --> 00:34:22,090
હું કદાચ તરત જ જે 32 થી બને નથી ખ્યાલ આવશે

687
00:34:22,090 --> 00:34:25,100
એક નાના અક્ષર અને એક મોટા અક્ષર વચ્ચે તફાવત હોવા છતાં,

688
00:34:25,100 --> 00:34:26,510
અમે આગામી સમસ્યા કે હકીકત ઉપયોગ જઈ રહ્યાં છો.

689
00:34:30,210 --> 00:34:31,610
32 છે -

690
00:34:31,610 --> 00:34:38,579
તમે તેને 32 કહેતા ઉપર એક ટિપ્પણી મૂકો શકે વચ્ચે તફાવત છે

691
00:34:38,579 --> 00:34:45,290
'એ' અને 'એક.' પરંતુ તે સમયે, 'એ' અને 'એ', અને તમે શા માટે માત્ર ઉપયોગ ન

692
00:34:45,290 --> 00:34:47,469
તો જરૂર નથી ટિપ્પણી.

693
00:34:47,469 --> 00:34:52,739
>> અલી: તે માત્ર તેની રીતે ઘણો ક્લીનર, શૈલી મુજબની છે.

694
00:34:52,739 --> 00:34:54,590
અને તેથી, કારણ કે તમે ફક્ત શરૂ કરી રહ્યાં છો પ્રોગ્રામિંગ -

695
00:34:54,590 --> 00:34:57,775
મન ક્યારેય - અથવા હું, કારણ કે તમે હેકર EDI છો ન ધારી.

696
00:34:57,775 --> 00:34:59,420
તે માત્ર એક સારો હોય રસ્તો છે -

697
00:34:59,420 --> 00:35:01,230
તે સારું સારું શૈલી ધરાવે છે.

698
00:35:01,230 --> 00:35:02,850
તેને સરળ માટે અન્ય લોકોને વાંચવા માટે છે.

699
00:35:02,850 --> 00:35:06,560
રોબ: તમે તે ASCII ટેબલ યાદ ક્યારેય જરૂર છે, ક્યારેય કરીશું.

700
00:35:06,560 --> 00:35:09,505
તમે માત્ર એક જ ક્વોટ અક્ષરો ઉપયોગ કરવાનો પ્રયત્ન કરીશું.

701
00:35:12,390 --> 00:35:12,730
પ્રશ્નો?

702
00:35:12,730 --> 00:35:13,980
અલી: સારા દરેક વ્યક્તિને?

703
00:35:16,020 --> 00:35:16,430
રોબ: ઠીક છે.

704
00:35:16,430 --> 00:35:23,320
જેથી આગામી સમસ્યા નોંધપાત્ર છે.

705
00:35:23,320 --> 00:35:24,660
જેથી આગામી સમસ્યા અમને પૂછે છે -

706
00:35:27,880 --> 00:35:31,570
અલી: આગામી સમસ્યા અમને માટે પૂછે છે તે જ વસ્તુ કરવા પરંતુ વાપરવા માટે

707
00:35:31,570 --> 00:35:32,640
bitwise ઓપરેટરો.

708
00:35:32,640 --> 00:35:35,170
રોબ: અલબત્ત, આપણે bitwise ઓપરેટરો હજુ સુધી જોઇ ન હોય.

709
00:35:35,170 --> 00:35:38,874
તેથી અમે હવે તે અંગે ચર્ચા કરીશું.

710
00:35:38,874 --> 00:35:39,540
અલી: BE ઉત્સાહિત.

711
00:35:39,540 --> 00:35:41,490
તેઓ સુપર મજા છો.

712
00:35:41,490 --> 00:35:47,927
>> રોબ: તેથી એક્સ વત્તા વાય બાદ, સમય વિભાજન જેવા નિયમિત ઓપરેટરો.

713
00:35:47,927 --> 00:35:50,850
અલી: તે આ પ્રોમ્પ્ટ માં લખો.

714
00:35:50,850 --> 00:35:55,420
રોબ: ત્યાં પણ%, જો તમે તેને જોઇ ન હોય, જે તમને દ્વારા ઉપયોગ કરી શકો છો

715
00:35:55,420 --> 00:35:57,130
પ્રતીક ટકા.

716
00:35:57,130 --> 00:35:59,090
પરંતુ અમે તે આ સમસ્યા માટે ઉપયોગ કરશે.

717
00:35:59,090 --> 00:36:01,400
અમે bitwise ઓપરેટર્સનો ઉપયોગ કરવા માંગો છો.

718
00:36:01,400 --> 00:36:06,250
હવે યાદ રાખો, અમે તેને એક વ્યાખ્યાન માં લાવવામાં આવ્યા હતા.

719
00:36:06,250 --> 00:36:10,760
મને ખાતરી છે કે જો અમે તે આગળ દ્વિસંગી ચર્ચા કરી છે નથી.

720
00:36:10,760 --> 00:36:13,710
યાદ પરંતુ તે દરેક એક નંબર રજૂ થાય છે -

721
00:36:13,710 --> 00:36:14,540
સારી બધું, -

722
00:36:14,540 --> 00:36:17,860
છે અને બાઈનરી માં 1 સે 0s માં રજૂ કરે છે.

723
00:36:17,860 --> 00:36:27,320
જેથી અર્થ એ છે કે જ્યારે હું 8 નંબર કહે, હું જાણું છું કે કે થવું

724
00:36:27,320 --> 00:36:30,240
જેમ, 1000.

725
00:36:30,240 --> 00:36:35,530
શું bitwise ઓપરેટરો અમને હોય છે આ બીટ્સ પર કામ કરવું -

726
00:36:35,530 --> 00:36:37,000
હોય છે આ બીટ્સ પર સીધા ચાલે છે.

727
00:36:40,160 --> 00:36:42,490
હવે હું લાંબા સમય સુધી આઠ દ્રષ્ટિએ વ્યવહાર છું.

728
00:36:42,490 --> 00:36:45,930
હું 1000 ની દ્રષ્ટિએ વ્યવહાર છું, અને હું તે સાથે વસ્તુઓ કરવા માંગો છો

729
00:36:45,930 --> 00:36:47,670
વ્યક્તિગત બિટ્સ.

730
00:36:47,670 --> 00:36:52,520
તેથી અલિ bitwise ઓપરેટરો લખ્યું છે અહીં, પણ that's -

731
00:36:55,060 --> 00:36:58,020
આ 8 નંબર અમે અમારા એક ઉદાહરણ સંખ્યાની તરીકે વાપરવા પડશે.

732
00:36:58,020 --> 00:37:02,980
અને બાઈનરી રજૂઆત 1000 છે.

733
00:37:02,980 --> 00:37:06,520
અમે બીજા નંબર, 5 ઉપયોગ કરીશું -

734
00:37:06,520 --> 00:37:12,070
ખરેખર આપણે 9 અને 5 વાપરો.

735
00:37:12,070 --> 00:37:15,778
અને 5 દ્વિસંગી પ્રતિનિધિત્વ 00 છે -

736
00:37:15,778 --> 00:37:18,380
0101.

737
00:37:18,380 --> 00:37:19,480
અલી કે પર કોઈ દરેકને છે?

738
00:37:19,480 --> 00:37:21,040
બાઈનરી સામગ્રી?

739
00:37:21,040 --> 00:37:23,740
તે પ્રથમ વ્યાખ્યાન હતું?

740
00:37:23,740 --> 00:37:29,070
>> રોબ: તેથી પણ જો તમે સંપૂર્ણ ટોચ પર નથી વસ્તુઓ કેવી રૂપાંતરિત કરવી

741
00:37:29,070 --> 00:37:31,700
દ્વિસંગી છે, કે જે સંપૂર્ણપણે મહત્વનું આ સમસ્યા માટે નથી.

742
00:37:31,700 --> 00:37:36,560
અમે તેનો ઉપયોગ કરવામાં આવશે, પરંતુ તમે ઘણી તકો બહાર આકૃતિ માટે કેવી રીતે પડશે

743
00:37:36,560 --> 00:37:39,250
ઝડપથી દ્વિસંગી માં વસ્તુઓ કરો.

744
00:37:39,250 --> 00:37:43,820
તેથી 9 અને 5 વાપરી રહ્યા હોય, હવે અમે અમારા bitwise ઓપરેટરો છે.

745
00:37:43,820 --> 00:37:48,620
ઓહ, અને પણ, 9 અને 5, જો તે પૂર્ણાંક છે, પછી ખરેખર તે 32 બીટ છે,

746
00:37:48,620 --> 00:37:53,150
જેનો અર્થ છે કે અમે 0, 0, 0 0, સમય ઘણો જેવા હોય છે, ત્યારબાદ

747
00:37:53,150 --> 00:37:55,330
101 ખૂબ જ અંત.

748
00:37:55,330 --> 00:37:58,530
કે જે હમણાં જ કારણે છે, કોઈ બાબત તમે શું પૂર્ણાંકો માં, 32 બિટ્સ.

749
00:37:58,530 --> 00:38:01,570
જસ્ટ કારણ કે અમે માત્ર ચાર બિટ્સ જરૂર 9 પ્રતિનિધિત્વ અર્થ એ નથી છો તો અમે નથી

750
00:38:01,570 --> 00:38:05,500
અપ માત્ર 0s માટે અન્ય 27 બિટ્સ મદદથી.

751
00:38:05,500 --> 00:38:10,110
અલી: જસ્ટ સ્પષ્ટ કરવા માટે, આ નંબરો કે જે 0 અથવા 1 એક છે એક બીટ છે.

752
00:38:10,110 --> 00:38:11,830
આ એક 4 બિટ્સ છે.

753
00:38:11,830 --> 00:38:14,320
જેથી રોબ જણાવ્યું હતું કે મશીનો તેમને 32 માં સંગ્રહે.

754
00:38:14,320 --> 00:38:19,430
તેથી તે પછી તેઓ 32 ક્યાંતો 0 અથવા 1 એક હશે.

755
00:38:19,430 --> 00:38:22,190
કૂલ?

756
00:38:22,190 --> 00:38:23,610
રોબ છે: bitwise ઓપરેટરો.

757
00:38:23,610 --> 00:38:27,310
પ્રથમ એક કે અમે સાથે કામ કરશો, ચાલો કરવું &.

758
00:38:27,310 --> 00:38:31,260
તેથી જો અમે 9 અને 5.

759
00:38:31,260 --> 00:38:38,310
તેથી અને શું કરે છે ક્રમેક્રમે છે, તે બે નંબર ની બિટ્સ સરખાવે

760
00:38:38,310 --> 00:38:44,860
અને જો નંબરો બંને 1 છે, તો પછી તેને 1 એક આપશે.

761
00:38:44,860 --> 00:38:50,870
જો એક 0 છે અને 1 અન્ય એક અથવા બંને 0s છે, પછી તે એક 0 આપે છે.

762
00:38:50,870 --> 00:38:53,060
જેથી તમે તેને તમારા લોજિકલ ANDs તરીકે વિચાર કરી શકો છો.

763
00:38:53,060 --> 00:38:59,270
જેમ તમે સાચું અને સાચી સાચી પરત કરવાની જરૂર છે, પરંતુ સાચા અને ખોટા ખોટા છે.

764
00:38:59,270 --> 00:39:02,390
તેથી તે જ વાત છે, પરંતુ હવે અમે તેની સાથે માત્ર બિટ્સ સાથે કામ કરીએ છીએ.

765
00:39:02,390 --> 00:39:04,910
>> અલી: તેથી જો તમે આ જોવા માટે, તમે 1 પડશે -

766
00:39:04,910 --> 00:39:08,490
તમે તેમને વાક્ય અપ પડશે જેથી તે 1 અને 0 હશો.

767
00:39:08,490 --> 00:39:11,036
શું તમે ગાય્સ લાગે છે કે હશે - શું કે મૂલ્યાંકન માટે છે?

768
00:39:11,036 --> 00:39:11,770
25 વક્તા: 1.

769
00:39:11,770 --> 00:39:12,270
અલી: સરસ.

770
00:39:12,270 --> 00:39:16,850
અથવા નં.

771
00:39:16,850 --> 00:39:18,830
માફ કરશો.

772
00:39:18,830 --> 00:39:21,290
એટલે તે અર્થમાં બનાવે છે?

773
00:39:21,290 --> 00:39:23,200
જેથી સામૂહિક જવાબ શું છે તે ફરીથી?

774
00:39:23,200 --> 00:39:24,750
માફ કરશો.

775
00:39:24,750 --> 00:39:27,530
તેથી જો આપણે 1 અને 0 હોય, તો પછી તમે શું વિચાર છે?

776
00:39:27,530 --> 00:39:30,260
રોબ: તેથી તમે કેવી રીતે તમે કહી લાગે છે અને બહાર અવાજ.

777
00:39:30,260 --> 00:39:37,550
જો તમે બે બિટ્સ હોય, એક્સ અને વાય તમે એક્સ અને વાય 1 પ્રયત્ન કરવાની જરૂર છે તે માટે મદદ કરવા માટે

778
00:39:37,550 --> 00:39:40,770
સાચી માટે મૂલ્યાંકન - અથવા, જેથી માટે તે 1 થી મૂલ્યાંકન માટે.

779
00:39:40,770 --> 00:39:45,650
જો એક્સ અથવા વાય 0 છે, પછી તે ખોટા અથવા 0 થી મૂલ્યાંકન.

780
00:39:45,650 --> 00:39:49,165
LUCAS: તે સારું છે પણ યાદ રાખો કે 1 સાચું છે અને 0 ખોટું છે.

781
00:39:49,165 --> 00:39:51,684
તેથી જો તમે સાચા અને ખોટા હોય, તો તેને ખોટી છે.

782
00:39:51,684 --> 00:39:53,570
પરંતુ તે પછી, અને સાચું સત્ય, સત્ય છે.

783
00:39:53,570 --> 00:39:55,040
ફોલ્સ એન્ડ ફોલ્સ, ફોલ્સ.

784
00:39:55,040 --> 00:39:57,650
અલી: અમે સાચા અને ખોટા છે.

785
00:39:57,650 --> 00:39:58,530
1 તેથી અને 0.

786
00:39:58,530 --> 00:40:00,380
તેથી પછી ફરી, માફ કરશો, એક વધુ સમય?

787
00:40:00,380 --> 00:40:02,210
25 વક્તા: તે 0 રહેશે.

788
00:40:02,210 --> 00:40:03,560
યાહ કૂલ.

789
00:40:03,560 --> 00:40:05,400
અને પછી અમે 0 અને 1 હોય -

790
00:40:05,400 --> 00:40:06,260
25 વક્તા: [અશ્રાવ્ય]

791
00:40:06,260 --> 00:40:06,680
અલી: યાહ.

792
00:40:06,680 --> 00:40:09,790
તેથી તમે હંમેશા તેમને સ્વેપ માં કરી શકો છો -

793
00:40:09,790 --> 00:40:12,150
પછી જો તમે 0 અને 0 છે?

794
00:40:12,150 --> 00:40:12,618
4 વક્તા: 1?

795
00:40:12,618 --> 00:40:14,490
0?

796
00:40:14,490 --> 00:40:16,230
રોબ: તેથી 0 છે.

797
00:40:16,230 --> 00:40:18,870
તે નથી કે બંને નંબરો માટે જ હોય ​​છે.

798
00:40:18,870 --> 00:40:22,030
તે છે કે બંને નંબરો માટે 1 પ્રયત્ન કરવાની જરૂર છે.

799
00:40:22,030 --> 00:40:26,150
અલી: તેથી બંને વાત સાચી છે તે વાત સાચી છે.

800
00:40:26,150 --> 00:40:26,950
જેથી 0 છે.

801
00:40:26,950 --> 00:40:30,540
અને પછી તમે 1 1% છે, જે હોય છે?

802
00:40:30,540 --> 00:40:32,640
રોબ: આ ખૂબ સારા નંબરો છે.

803
00:40:32,640 --> 00:40:34,362
તેઓ તમામ શક્ય હોય -

804
00:40:34,362 --> 00:40:36,210
અલી: સારા કામ, સંક્ષોભજનક જીત.

805
00:40:36,210 --> 00:40:37,080
ઠીક છે કૂલ.

806
00:40:37,080 --> 00:40:39,220
જેથી દરેકને નથી અર્થમાં છે?

807
00:40:39,220 --> 00:40:41,770
>> રોબ: તેથી હવે અમે કરીશ |.

808
00:40:41,770 --> 00:40:51,650
અને આ ખૂબ જ સમાન હોવા રહ્યું છે, પણ હવે તેના બદલે એક્સ અને વાય માટે જરૂર

809
00:40:51,650 --> 00:40:54,880
ક્રમમાં 1 પ્રયત્ન માટે એક મૂલ્યાંકન કરવા માટે, તેને હવે ફક્ત એક્સ અથવા

810
00:40:54,880 --> 00:40:56,360
વાય માટે 1 પ્રયત્ન કરવાની જરૂર છે.

811
00:40:56,360 --> 00:40:59,580
અલી: 1 તેથી | 0 થી મૂલ્યાંકન -

812
00:40:59,580 --> 00:41:00,270
CLASS: 1.

813
00:41:00,270 --> 00:41:01,690
અલી: સરસ.

814
00:41:01,690 --> 00:41:03,710
0 | | 1 થી મૂલ્યાંકન -

815
00:41:03,710 --> 00:41:04,420
CLASS: 1.

816
00:41:04,420 --> 00:41:06,726
અલી: સરસ, અને પછી 0 | | 0 -

817
00:41:06,726 --> 00:41:07,600
CLASS: 0.

818
00:41:07,600 --> 00:41:09,320
અલી: અરે વાહ, અને 1 પછી | 1 -

819
00:41:09,320 --> 00:41:10,180
CLASS: 1.

820
00:41:10,180 --> 00:41:12,090
અલી: સરસ.

821
00:41:12,090 --> 00:41:14,060
જેથી બે bitwise ઓપરેટરો જેવું છે.

822
00:41:14,060 --> 00:41:15,430
ઓસમ.

823
00:41:15,430 --> 00:41:16,440
રોબ: તેથી હવે અમે ^ કરવું પડશે.

824
00:41:16,440 --> 00:41:18,470
અલી: અમે તેમને તમામ કરવું જોઈએ?

825
00:41:18,470 --> 00:41:20,620
રોબ: અરે વાહ, કારણ કે મને લાગે છે કે અમે તેનો ઉપયોગ જઈ રહ્યાં છો -

826
00:41:20,620 --> 00:41:22,340
તેમને બધા મદદથી.

827
00:41:22,340 --> 00:41:23,150
અલી: ઠીક છે.

828
00:41:23,150 --> 00:41:23,570
તેથી -

829
00:41:23,570 --> 00:41:25,540
રોબ: હું માનું અમે જરૂર નથી.

830
00:41:25,540 --> 00:41:31,830
અલી: તેથી ^ કામો કે તમે એક ચોક્કસ સત્ય અને એક ખોટા હોય છે.

831
00:41:31,830 --> 00:41:34,330
^ અનન્ય અર્થ એ થાય કે.

832
00:41:34,330 --> 00:41:36,650
તેથી હવે તે નથી -

833
00:41:36,650 --> 00:41:41,220
જો એક્સ અને વાય બંને 1 હોય, તો તે હવે ખોટું.

834
00:41:41,220 --> 00:41:46,920
કે ^ વચ્ચે તફાવત છે અને | છે કે, OR તમે કરી શકો છો, જો એક્સ છે

835
00:41:46,920 --> 00:41:49,440
સાચું કે વાય સાચું છે, તો પછી અમે સારા છીએ.

836
00:41:49,440 --> 00:41:55,176
ના, ^ કહે જો એક્સ સાચું છે, વાય ખોટા જ હોવી જોઈએ, અથવા અન્ય તે વાત સાચી નથી.

837
00:41:55,176 --> 00:41:56,814
શું તમે એક પ્રશ્ન છે?

838
00:41:56,814 --> 00:42:00,526
>> 26 વક્તા: [અશ્રાવ્ય]

839
00:42:00,526 --> 00:42:00,990
અલી: યાહ.

840
00:42:00,990 --> 00:42:01,830
તે સમાન પ્રકારની છે.

841
00:42:01,830 --> 00:42:07,320
રોબ: અરે વાહ, જેથી કરીને તમે જ્યારે કે હાર્ડવેર નીચા સ્તર સામગ્રી મેળવવા, આ છે

842
00:42:07,320 --> 00:42:10,870
કામગીરી પ્રકારો તમારી સાથે વ્યવહાર કરી રહ્યા છો.

843
00:42:10,870 --> 00:42:13,200
હાર્ડવેર સ્તરે, તમે માત્ર બિટ્સ સાથે કામ કરશે.

844
00:42:13,200 --> 00:42:14,950
તમે નંબરો સાથે વ્યવહાર નથી.

845
00:42:18,030 --> 00:42:23,502
અલી: ઠીક છે, ^ માટે હોય તો, અથવા તમે 1 હોય 0 ^, શું છે કે જે મૂલ્યાંકન કરવું જોઈએ?

846
00:42:23,502 --> 00:42:24,840
CLASS: 1.

847
00:42:24,840 --> 00:42:25,480
અલી: સરસ.

848
00:42:25,480 --> 00:42:26,010
જો તમારી પાસે

849
00:42:26,010 --> 00:42:28,370
0 ^ 1? CLASS: 1.

850
00:42:28,370 --> 00:42:29,490
અલી: સરસ.

851
00:42:29,490 --> 00:42:32,050
0 ^ 0?

852
00:42:32,050 --> 00:42:32,470
સરસ.

853
00:42:32,470 --> 00:42:33,460
અને 1 પછી 1 ^?

854
00:42:33,460 --> 00:42:35,050
CLASS: 0.

855
00:42:35,050 --> 00:42:37,710
અલી: સરસ, અદ્ભુત.

856
00:42:37,710 --> 00:42:38,620
આગામી એક -

857
00:42:38,620 --> 00:42:40,520
રોબ: મને લાગે છે કે આ બધા માટે અમે સાથે કામ હોય છે.

858
00:42:40,520 --> 00:42:41,490
અમે ફક્ત આ કરીશ.

859
00:42:41,490 --> 00:42:43,242
આ ફક્ત એક જ વખત આપણે કરવા પડશે: - અલી

860
00:42:43,242 --> 00:42:44,912
રોબ: ઓહ, કે છેલ્લા સમસ્યા માટે પ્રયત્ન કરશે.

861
00:42:44,912 --> 00:42:47,070
27 વક્તા: રાહ જુઓ, ફરી એક વાર?

862
00:42:47,070 --> 00:42:47,940
અલી: માફ કરશો, તમારો પ્રશ્ન શું હતો?

863
00:42:47,940 --> 00:42:49,564
>> 27 વક્તા: તમે એક વાર ફરી સમજાવવું કરી શકું?

864
00:42:49,564 --> 00:42:50,100
આ ^?

865
00:42:50,100 --> 00:42:51,490
27 વક્તા: Exclus - હા.

866
00:42:51,490 --> 00:42:55,800
અલી: તેથી શું અનન્ય અથવા અર્થ એ છે કે ત્યાં માત્ર પ્રયત્ન છે

867
00:42:55,800 --> 00:43:02,970
એક સાચા અને ખોટા એક છે, તેથી એક 1 અને એક 0, વિરુદ્ધ સાથે અથવા તો, તમારી પાસે શકો છો -

868
00:43:02,970 --> 00:43:06,170
તેમાંના એક છે તે વાત સાચી છે, અથવા બંને સાચા તે માટે હોઇ શકે છે,

869
00:43:06,170 --> 00:43:07,130
સાચી માટે મૂલ્યાંકન.

870
00:43:07,130 --> 00:43:10,030
27 વક્તા: તેથી 0 અને 0 ખોટા હશે.

871
00:43:10,030 --> 00:43:10,450
અલી: યાહ.

872
00:43:10,450 --> 00:43:11,780
પરંતુ જો તમે 1 છે |

873
00:43:11,780 --> 00:43:14,290
1, જે સાચા માટે મૂલ્યાંકન કરશે.

874
00:43:14,290 --> 00:43:18,210
પરંતુ જો તમે 1 1 ^ છે, કારણ કે અમે કર્યું, કે જે ખોટા મૂલ્યાંકન.

875
00:43:18,210 --> 00:43:21,220
કારણ કે તે સંપૂર્ણપણે નથી, એક સાચા છે.

876
00:43:21,220 --> 00:43:26,930
રોબ: આ હોઈ શકે છે અથવા શકે છે, પણ શકે અને ન મદદરૂપ પરંતુ નોટિસ કે ^ છે

877
00:43:26,930 --> 00:43:28,890
| માત્ર લેવાનું સમાન

878
00:43:28,890 --> 00:43:30,290
ઓછા એન્ડ.

879
00:43:30,290 --> 00:43:32,250
અને તમે ખરેખર તે આ રીતે વિચાર કરી શકો છો.

880
00:43:32,250 --> 00:43:37,290
^ માત્ર બધું છે મળીને ORing પરંતુ બિટ્સ કોઇ લેવા જ્યાં

881
00:43:37,290 --> 00:43:38,610
બંને સાચા હતા.

882
00:43:38,610 --> 00:43:41,620
તેથી અને બધું જ્યાં બંને સાચા હતા આપે છે.

883
00:43:41,620 --> 00:43:45,850
| બધું જ્યાં એક અથવા બંને સાચા હતા આપે છે.

884
00:43:45,850 --> 00:43:51,050
જેથી આઉટ બાદબાકી | તમે ^ આપે છે.

885
00:43:51,050 --> 00:43:52,040
અલી: કોઈપણ પ્રશ્ન છે?

886
00:43:52,040 --> 00:43:53,290
આ ઘણી માહિતી હતી.

887
00:43:55,980 --> 00:43:57,510
સારા દરેક વ્યક્તિને?

888
00:43:57,510 --> 00:44:00,360
>> રોબ: અમે આગામી મુદ્દાઓ પર આગામી સમસ્યા માટે જઈ શકે છે સ્લેશ,

889
00:44:00,360 --> 00:44:01,680
સમય શું છે?

890
00:44:01,680 --> 00:44:04,010
તેઓ આ આગામી સમસ્યા સુધી જરૂર નથી.

891
00:44:04,010 --> 00:44:07,830
અલી: મને લાગે છે કે તે આ એક હતી.

892
00:44:07,830 --> 00:44:08,830
રોબ: તે નથી.

893
00:44:08,830 --> 00:44:10,085
અલી: તમને ખાતરી છે?

894
00:44:10,085 --> 00:44:11,300
રોબ: હા, હું હકારાત્મક છું.

895
00:44:11,300 --> 00:44:12,970
અલી: અમે આગામી સમસ્યા કરી કેમ ન શરૂ કરી શકું?

896
00:44:15,710 --> 00:44:19,790
સમસ્યા એ છે, ફરી, તે માટે મોટા લોઅરકેસ થી બદલવા માટે, અને આ

897
00:44:19,790 --> 00:44:21,720
માટે bitwise ઓપરેટર્સનો ઉપયોગ સમય.

898
00:44:21,720 --> 00:44:22,970
રોબ: તેથી અમે કરશે -

899
00:44:25,290 --> 00:44:29,670
આપણે ના 'એ', મૂડી 'એ' બાઈનરી રજૂઆત સાથે શરૂ કરવા માટે,

900
00:44:29,670 --> 00:44:31,750
જે 65 છે.

901
00:44:31,750 --> 00:44:36,150
તેથી દ્વિસંગી માં -

902
00:44:39,960 --> 00:44:47,900
જેથી 'એ' = 65 છે, કે જે બાઈનરી માં =, -

903
00:44:47,900 --> 00:44:51,380
હું 0s સંખ્યા અપ વાસણ કરવા જઇ રહ્યો છું - કે.

904
00:44:51,380 --> 00:44:53,670
અલી: તેથી કરે છે કે દરેકને અર્થમાં છે?

905
00:44:53,670 --> 00:44:57,620
તેથી, 1, કોઈ 2s, કોઈ 4s, કોઈ 8, કોઈ -

906
00:45:00,238 --> 00:45:07,075
આ બોલ પર કોઈ 16s, કોઈ 32s, અને તે પછી 64 એક.

907
00:45:07,075 --> 00:45:08,685
રોબ: અરે વાહ, મને લાગે છે કે એક પણ અનેક 0s છે.

908
00:45:08,685 --> 00:45:09,600
અલી: માફ કરશો.

909
00:45:09,600 --> 00:45:13,410
>> રોબ: ઠીક છે, તેથી અમે 64 સેટ હોય છે, અને અમે 1 સેટ હોય છે, અને તે સંયુક્ત

910
00:45:13,410 --> 00:45:16,030
સાથે મળીને, અમે 65 મેળવો.

911
00:45:16,030 --> 00:45:17,470
અલી: કૂલ દાળો?

912
00:45:17,470 --> 00:45:19,640
રોબ: તેથી હવે, 'a'લોઅરકેસ -

913
00:45:22,220 --> 00:45:24,260
97 નોટિસ -

914
00:45:24,260 --> 00:45:26,370
97 અને 65 ની વચ્ચે તફાવત શું છે?

915
00:45:26,370 --> 00:45:27,530
28 વક્તા: 32.

916
00:45:27,530 --> 00:45:28,130
રોબ: યાહ.

917
00:45:28,130 --> 00:45:35,920
તેથી તે 32 છે, જે તેના પોતાના બીટ છે તેથી, જે 110001 જ હશે.

918
00:45:35,920 --> 00:45:41,200
અને આ માટે તમામ શક્ય અક્ષરો માટે સાચી હોવી રહ્યું છે.

919
00:45:41,200 --> 00:45:49,800
તેથી જો આપણે 'ડી', જે 68 પ્રયત્ન રહ્યું છે લાગે છે, કે જે 1000011 જ હશે.

920
00:45:49,800 --> 00:45:56,310
અને પછી લોઅરકેસ 'ડી' માટે 68 વત્તા 32, કે જે 100 છે જે છે રહ્યું છે

921
00:45:56,310 --> 00:46:00,010
આ જ વસ્તુ છે કે જે આ હતી, માત્ર ફ્લિપિંગ જઈને

922
00:46:00,010 --> 00:46:04,300
32 ફરીથી તેથી, 1100011.

923
00:46:04,300 --> 00:46:08,610
તેથી એક મોટા અને નાના અક્ષર વચ્ચે તફાવત માત્ર ફ્લિપિંગ છે

924
00:46:08,610 --> 00:46:10,170
સ્થિતિ 32-bit કે.

925
00:46:10,170 --> 00:46:17,670
29 વક્તા: તે 1000100 નથી?

926
00:46:17,670 --> 00:46:19,670
રોબ: પ્રતીક્ષા, તે 100 છે -

927
00:46:19,670 --> 00:46:20,480
હું ખોટું કર્યું.

928
00:46:20,480 --> 00:46:21,730
આ સાચું નથી.

929
00:46:28,710 --> 00:46:31,150
હું વિચારતી હતી કે તે 3 એક તફાવત હતો, તેથી તે પછી મેં હમણાં જ અટકી

930
00:46:31,150 --> 00:46:33,970
અંતે 3 દ્વિસંગી.

931
00:46:33,970 --> 00:46:36,710
આ અધિકાર પ્રયત્ન કરીશું.

932
00:46:36,710 --> 00:46:37,150
અલી: આભાર.

933
00:46:37,150 --> 00:46:38,080
કે પોઇન્ટ આઉટ માટે સારી.

934
00:46:38,080 --> 00:46:40,320
કે તીક્ષ્ણ હતા.

935
00:46:40,320 --> 00:46:43,450
બધા હક છે, કે જે લોકો સ્પષ્ટ?

936
00:46:43,450 --> 00:46:45,700
>> રોબ છે: મોટા અને નાના આવૃત્તિ વચ્ચે તફાવત છે

937
00:46:45,700 --> 00:46:49,250
હંમેશા માત્ર 32 જ હશે, અને તેથી તે હંમેશા એક બીટ જ હશે

938
00:46:49,250 --> 00:46:51,840
કે બંને વચ્ચે ફેરફાર ઘસવું જરૂરી છે.

939
00:46:51,840 --> 00:46:54,330
અલી: જેથી કિસ્સામાં, મૂડી A અને વચ્ચે તફાવત જાણીને

940
00:46:54,330 --> 00:46:57,130
આ લોઅરકેસ એક સારી બાબત છે.

941
00:46:57,130 --> 00:47:01,950
, તમારો કોડ નથી પરંતુ સરળ ઓછામાં ઓછા, તે સારી છે.

942
00:47:01,950 --> 00:47:05,880
તેથી તમે ગાય્સ આગળ વધો અને કોડ શકો છો કે સ્પેસીસ હવે.

943
00:47:05,880 --> 00:47:08,580
અથવા આપણે માત્ર ચર્ચા કરવી જોઈએ?

944
00:47:08,580 --> 00:47:09,760
રોબ: અમે ફક્ત ચર્ચા કરી શકો છો.

945
00:47:09,760 --> 00:47:10,680
મને ખબર નથી.

946
00:47:10,680 --> 00:47:11,680
તમે ગાય્સ પ્રયાસ કરી શકો છો.

947
00:47:11,680 --> 00:47:13,560
ઘડીભર પોતાની જાતને નો સમાવેશ વાત કરો.

948
00:47:13,560 --> 00:47:16,390
અમે તમને તે કોડ તક આપીશું.

949
00:47:16,390 --> 00:47:17,640
[અવાજો INTERPOSING]

950
00:47:19,785 --> 00:47:22,695
અલી: - સરસ છે

951
00:47:22,695 --> 00:47:26,590
30 વક્તા: આ હેકર કોમેડી જેવી છે.

952
00:47:26,590 --> 00:47:31,060
અલી: અરે વાહ, અમે માત્ર સમાચાર કહેવાની કરી રહ્યાં છો, તે પસાર થઇ.

953
00:47:31,060 --> 00:47:32,310
>> રોબ: અને અમે પાછા આવ્યા.

954
00:47:34,950 --> 00:47:35,405
અલી: તે વિચિત્ર પ્રકારની છે.

955
00:47:35,405 --> 00:47:38,720
હું જેમ અમે CS50 સમાચાર સ્ટેશન હોવા જોઈએ લાગે છે અને અમે કરી શકે

956
00:47:38,720 --> 00:47:41,500
વાસ્તવમાં આ જેવા બેસો.

957
00:47:41,500 --> 00:47:43,500
હેકર ન્યૂઝ: રોબ.

958
00:47:43,500 --> 00:47:46,848
અલી: હેકર 50 ન્યૂઝ.

959
00:47:46,848 --> 00:47:49,210
અલી: કોઈપણ પ્રશ્નો પૂછી જો તમે ભેળસેળ કરી રહ્યાં છો સંકોચ ન અનુભવો.

960
00:47:52,280 --> 00:47:53,980
રોબ: કોઇપણ અટકી છે?

961
00:47:53,980 --> 00:47:57,160
અલી: અરે વાહ, કે જે સારી વાત છે.

962
00:47:57,160 --> 00:47:58,590
અલી: રાહ જુઓ, તમે તમારા ખુરશી માં અટવાઇ જાય?

963
00:47:58,590 --> 00:48:01,010
ઓહ.

964
00:48:01,010 --> 00:48:02,260
હું થોડો સંબંધિત હતી.

965
00:48:06,670 --> 00:48:12,150
રોબ: કારણ કે હું હમણાં જ લાગ્યું કે અમે માંગો છો જવું છે

966
00:48:12,150 --> 00:48:13,300
અન્ય bitwise ઓપરેટર.

967
00:48:13,300 --> 00:48:16,985
હવે, ચાલો માત્ર લોઅરકેસ મોટા રૂપાંતરિત કરો.

968
00:48:23,280 --> 00:48:25,220
અલી: માફ કરશો, દરેકને કે જાહેરાત વિચાર કરી?

969
00:48:25,220 --> 00:48:27,755
અમે મોટા સુધી જવું લોઅરકેસ રહ્યા છીએ.

970
00:48:27,755 --> 00:48:30,990
રોબ: પછી અમે નાના ચર્ચા કરવા માટે કે પછી તરત જ મોટા પડશે.

971
00:48:33,820 --> 00:48:36,650
ઓહ, નો.

972
00:48:36,650 --> 00:48:39,560
અમે આ એક ભૂલ, હું માનું છું, છે, કે જે અમે પ્રયત્ન કર્યો છે માટે ક્યારેય હોય છે.

973
00:48:39,560 --> 00:48:44,140
જે માત્ર કે ઘરનાં પરચૂરણ કામો કરવા માટે c લૂપની બહાર જાહેર કરવાની જરૂર છે, કારણ કે

974
00:48:44,140 --> 00:48:45,805
તેના અવકાશ લૂપમાં પ્રતિબંધિત છે.

975
00:48:49,200 --> 00:48:53,060
32 વક્તા: આ કિસ્સામાં, તે ખોટું કરવા માટે નંબર ઉપયોગ કરો છો?

976
00:48:53,060 --> 00:48:56,930
રોબ: EH, તો તમે જરૂર નથી.

977
00:48:56,930 --> 00:49:02,040
જો હું તમને ખાતરી આપી કે મૂડી 'A'- અથવા, લોઅરકેસ' એ 'બાદ મૂડી' એ '

978
00:49:02,040 --> 00:49:09,340
હતી બરાબર એક બીટ, પણ તમે 32 તે ખબર નથી -

979
00:49:09,340 --> 00:49:13,160
વસ્તુઓ માત્ર તેમજ કામ જો તે 16 બીટ કે ઘસવું હતા હોત - અથવા

980
00:49:13,160 --> 00:49:14,610
ના, હું માનું તે wouldn't -

981
00:49:14,610 --> 00:49:18,270
અથવા 64-bit ઘસવું, કદાચ આવી હતી.

982
00:49:18,270 --> 00:49:23,230
પરંતુ તમે 32 ઉપયોગ ન કરવો જોઈએ.

983
00:49:23,230 --> 00:49:26,141
તમે તેના બદલે 'એ' બાદ મૂડી 'એ' લોઅરકેસ ઉપયોગ કરી શકે છે.

984
00:49:26,141 --> 00:49:29,340
>> 32 વક્તા: ઠીક છે.

985
00:49:29,340 --> 00:49:32,996
જો તમને લાગે છે કે તમે ખૂબ જ લખી રહ્યાં કરી શકો છો છે તો તમે તેને વ્યાખ્યાયિત કરી શકો છો

986
00:49:32,996 --> 00:49:33,435
ટોચ પર.

987
00:49:33,435 --> 00:49:41,830
તેથી તમે હોઇ શકે છે, જેમ કે પૂર્ણાંક તફાવત = 'એ' બાદ મૂડી 'એ' લોઅરકેસ. અને

988
00:49:41,830 --> 00:49:43,980
પછી તમે તફાવત બદલે ટાઈપ કરી શકો છો.

989
00:49:43,980 --> 00:49:45,110
માન્ય છે.

990
00:49:45,110 --> 00:49:48,002
પરંતુ માત્ર 32 નંબરનો ઉપયોગ કરીને પ્રકારની છે -

991
00:49:48,002 --> 00:49:51,104
33 વક્તા: હોવા છતાં તે હકીકત છે કે તે 32 બીટ છે કારણે છે?

992
00:49:51,104 --> 00:49:52,570
અલી: યાહ.

993
00:49:52,570 --> 00:49:54,960
રોબ: ત્યાં હોઈ શકે છે -

994
00:49:54,960 --> 00:49:57,780
માત્ર એક જ ગેરંટી અમે તમને કરવાની જરૂર છે કે વચ્ચે તફાવત

995
00:49:57,780 --> 00:49:59,480
લોઅરકેસ અને મોટા એક બીટ છે.

996
00:49:59,480 --> 00:50:04,670
તે મહત્વનું નથી જોઈએ કે તે 32 બીટ કે ઘસવું છે બને છે.

997
00:50:04,670 --> 00:50:06,610
સમય વિચારણાઓ માટે, અમે આ બોલ જવાનું શરૂ કરીશું.

998
00:50:09,170 --> 00:50:10,370
તે ઠીક છે જો તમે કરવાનું પૂર્ણ કર્યું નથી.

999
00:50:10,370 --> 00:50:13,090
તે વિશે ચિંતા કરશો નહીં.

1000
00:50:13,090 --> 00:50:16,260
રોબ: ધારી રહ્યા છીએ કો એક મૂડી પત્ર છે -

1001
00:50:16,260 --> 00:50:18,030
અમે ધારી કો એક મૂડી પત્ર છે નથી.

1002
00:50:18,030 --> 00:50:20,750
અમે જાણીએ છીએ કેચ આ વખતે લૂપ બાદ મૂડી પત્ર છે -

1003
00:50:20,750 --> 00:50:22,160
આમ-જ્યારે લૂપ.

1004
00:50:22,160 --> 00:50:28,590
તેથી તેનો અર્થ એ કે તે 'એ' કંઈક આના જેવું દેખાય. તેથી જો અમે આ લાવવા માંગો છો

1005
00:50:28,590 --> 00:50:32,895
, આ 'એ' માટે 'એ' આપણે શું કરવું જોઇએ?

1006
00:50:36,890 --> 00:50:41,920
તેથી અમે અને કેવી રીતે કન્વર્ટ કરશો થોડી વિમાનની મુસાફરી?

1007
00:50:48,040 --> 00:50:49,450
અલી: અમે તે કેવી રીતે વિમાનની મુસાફરી કરી શકું?

1008
00:50:49,450 --> 00:50:53,010
>> રોબ: તેથી આપણે જાણીએ છીએ અમે 32 બીટ વિમાનની મુસાફરી કરવા માંગો છો.

1009
00:50:53,010 --> 00:50:59,722
જેથી 'એ' બાદ 'એ' કરવા કરશે, અથવા અમે 32 લખી શકે છે, પરંતુ -

1010
00:50:59,722 --> 00:51:03,090
તે રફૂ કરવું હોય, તો તે અન્ય આસપાસ રસ્તો છે.

1011
00:51:03,090 --> 00:51:07,250
અલી: ઠીક છે જેથી રોબ અહીં કે જે નંબર ગણતરી છે, જાદુ 32 નંબર.

1012
00:51:07,250 --> 00:51:12,000
તેથી તેમણે બહાર શોધવા છે જ્યાં કે બીટ ફ્લિપ વિસ્તાર હશે.

1013
00:51:12,000 --> 00:51:14,810
અને પછી આપણે શું જ્યાં પ્રશ્ન ગુણ છે મૂકી શકું?

1014
00:51:14,810 --> 00:51:16,740
રોબ: અમે તે બીટ કેવી રીતે વિમાનની મુસાફરી કરી શકું?

1015
00:51:16,740 --> 00:51:22,784
આ મોટા અક્ષર સંદર્ભમાં, તે 0 છે, અને અમે 1 એક બનવું છે.

1016
00:51:22,784 --> 00:51:23,660
34 વક્તા: |.

1017
00:51:23,660 --> 00:51:24,910
રોબ: યાહ.

1018
00:51:28,780 --> 00:51:38,190
તેથી આ અમને કહી રહ્યાં છે અમે 'એ' લે છે. અમે તેના 0 સાથે ORing કરી રહ્યા છીએ -

1019
00:51:38,190 --> 00:51:40,750
1000 -

1020
00:51:40,750 --> 00:51:44,720
અને તે = છે.

1021
00:51:44,720 --> 00:51:45,930
અલી: શું કે દરેકને અર્થમાં છે?

1022
00:51:45,930 --> 00:51:48,812
અમે તેના મારફતે બીટ બીટ કરી શકો છો જાઓ જો તમે કરવા માંગો છો.

1023
00:51:52,030 --> 00:51:56,300
35 વક્તા: તમે [અશ્રાવ્ય]

1024
00:51:56,300 --> 00:51:57,590
અલી: જયાં બાદ ચિહ્ન છે?

1025
00:51:57,590 --> 00:51:58,500
રોબ: ઓહ, તમે અહીં અર્થ આ છે?

1026
00:51:58,500 --> 00:51:59,070
અલી: ઓહ, હા.

1027
00:51:59,070 --> 00:52:00,140
રોબ: તેથી હું માનું આ અમને છે.

1028
00:52:00,140 --> 00:52:05,670
અમે 32 કહેવું છે, અને હવે અમે શકે માત્ર bitwise ઓપરેટરો ઉપયોગ કરી રહ્યા છો.

1029
00:52:05,670 --> 00:52:07,010
અલી: અમે જાદુ નંબરો ગમતું નથી.

1030
00:52:07,010 --> 00:52:10,460
અમે તે નથી જઈ રહ્યાં છો.

1031
00:52:10,460 --> 00:52:13,592
પણ મને લાગે છે કે અમે માત્ર એક bitwise ઓપરેટર ઉપયોગ કરવો જોઈએ -

1032
00:52:13,592 --> 00:52:19,042
36 વક્તા: જો તમે એક ^ વાપરવા માટે, તમે 32 મળશે?

1033
00:52:19,042 --> 00:52:19,980
37 વક્તા: અરે વાહ, મને લાગે છે કે -

1034
00:52:19,980 --> 00:52:21,090
રોબ: યાહ તમે કરશે.

1035
00:52:21,090 --> 00:52:23,320
અલી: આ રીતે તમે જવા માટે આ કરી શકે છે

1036
00:52:23,320 --> 00:52:25,370
મૂડી માંથી લોઅરકેસ છે.

1037
00:52:25,370 --> 00:52:31,130
>> હવે કોઈને મને જણાવો કે રોબ અને હું પ્રોમ્પ્ટ બદલાયેલ છે અને અમે ગયા કેવી રીતે કરી શકો છો

1038
00:52:31,130 --> 00:52:34,040
મોટા લોઅરકેસ છે, બદલે માટે લોઅરકેસ

1039
00:52:34,040 --> 00:52:37,810
અપરકેસ તરીકે અમે પહેલાં હતી?

1040
00:52:37,810 --> 00:52:44,520
શું કોઇને કોઇ વિચારો હશે કે શા માટે વધુ મુશ્કેલ હોઈ શકે છે?

1041
00:52:44,520 --> 00:52:44,880
રોબ: તેથી અમે છો -

1042
00:52:44,880 --> 00:52:46,178
અલી: અરે વાહ, આગળ જાઓ.

1043
00:52:46,178 --> 00:52:49,640
38 વક્તા છે: | ઓપરેટર જ હતી ખરેખર ઉમેરવા માટે સારું.

1044
00:52:49,640 --> 00:52:51,200
અલી: અરે વાહ, બરાબર.

1045
00:52:51,200 --> 00:52:58,320
રોબ: તેથી અમે લોઅરકેસ માં કરવું કેસ મોટા માંગો છો તે છે,

1046
00:52:58,320 --> 00:53:00,175
આ 'a'કન્વર્ટ -

1047
00:53:08,540 --> 00:53:14,820
તેથી અમે કેટલાક સંખ્યામાં અહીં મૂકો અને કેટલાક ઓપરેટર ઉપયોગ જેથી તે આવે કરવા માંગો છો

1048
00:53:14,820 --> 00:53:21,910
અમે મૂડી એ માટે અમે હજી પણ કદાચ કરી રહ્યાં છો 32 કોઈક વાપરી રહ્યા હોય, પરંતુ હવે શું કરવું કેવી રીતે

1049
00:53:21,910 --> 00:53:25,280
આ વિચાર માટે આ બહાર આવે?

1050
00:53:40,910 --> 00:53:42,750
કૈચ તેથી -

1051
00:53:42,750 --> 00:53:44,000
ઓહ, હું હજી પણ તે ખૂબ માંગો છો -

1052
00:53:46,940 --> 00:53:51,055
અલી: તેથી હવે જો આપણે લોઅરકેસ માંથી રૂપાંતરિત કરી રહ્યા છીએ ફરીથી મોટા, અમે પછી

1053
00:53:51,055 --> 00:53:55,170
આ ^ કામગીરી કરવા માટે, તમે જેમ ગાય્સ જણાવ્યું હતું.

1054
00:53:55,170 --> 00:53:57,650
રોબ: અન્ય રીતે તમે વસ્તુઓ કરી શકે છે.

1055
00:53:57,650 --> 00:54:01,680
આ bitwise ઓપરેટરો ઘણાં અંત ખૂબ જ સરળતાથી દ્રષ્ટિએ વ્યાખ્યાયિત છે

1056
00:54:01,680 --> 00:54:03,460
અન્ય bitwise ઓપરેટરો છે.

1057
00:54:03,460 --> 00:54:11,150
તેથી હું અથવા ^ ઉપયોગ ન થવાનું હતું, પરંતુ ^ સંપૂર્ણ દંડ કામ કર્યું હતું.

1058
00:54:11,150 --> 00:54:17,910
>> અલી: ઠીક છે, તેથી અમે છેલ્લા સમસ્યા છે, કે જે મૂળભૂત છે જવા જઈ રહ્યાં છો -

1059
00:54:17,910 --> 00:54:22,390
છેલ્લા સમસ્યા માટે દ્વિસંગી માં કંઈક રૂપાંતર છે.

1060
00:54:22,390 --> 00:54:26,350
તેથી, ઉદાહરણ તરીકે, તમે 50 હોય છે, અને તે પછી તમે તે બદલવા માટે

1061
00:54:26,350 --> 00:54:31,400
દ્વિસંગી છે, જે 110010 છે.

1062
00:54:31,400 --> 00:54:36,010
અને મને લાગે છે કે તમે ગાય્ઝ બધા વ્યાખ્યાન દ્વિસંગી વિશે જાણવાની.

1063
00:54:36,010 --> 00:54:39,270
અને તમે પણ તે કોઈ પણ અગ્રણી 0s મૂકી નથી તેવું માનવામાં આવે છે.

1064
00:54:39,270 --> 00:54:41,460
રોબ: હવે તમે તે ભાગ અવગણી શકો છો.

1065
00:54:41,460 --> 00:54:45,250
પ્રથમ પાસ, તો તમે તેને આવું છે કે અગ્રણી 0s શકો છો.

1066
00:54:45,250 --> 00:54:49,200
અને પછી અમે એ કોઈ અગ્રણી 0s હોય સુધારવા માટે, જો આપણે સમય હોઈ શકે છે.

1067
00:54:49,200 --> 00:54:50,630
અલી: તેથી તે વિશે ચિંતા કરશો નહિ.

1068
00:54:50,630 --> 00:54:52,620
માત્ર દ્વિસંગી માં વિચાર કરવાનો પ્રયાસ કરો.

1069
00:54:55,880 --> 00:54:59,855
સારી શરૂ કરવા સ્થળ હશે -

1070
00:54:59,855 --> 00:55:02,010
રોબ: અમે પૂર્ણાંક માટે પૂછો જરૂર છે.

1071
00:55:02,010 --> 00:55:03,150
અલી: ઓહ હા, તે એક સારો એક છે.

1072
00:55:03,150 --> 00:55:04,170
અમે તે સાથે શરૂ કરી શકો છો.

1073
00:55:04,170 --> 00:55:06,870
તેથી તમે પ્રોમ્પ્ટ બદલી શકો છો.

1074
00:55:06,870 --> 00:55:08,840
તેથી તેના બદલે એક અક્ષર છે, હવે અમે પૂર્ણાંકો સાથે વ્યવહાર કરી રહ્યા છો.

1075
00:55:13,670 --> 00:55:14,920
કૂલ?

1076
00:55:20,630 --> 00:55:25,300
>> રોબ: અને હવે શું છે અમારા ડુ-જ્યારે શરત હશે?

1077
00:55:25,300 --> 00:55:27,750
તે એક પૂર્ણાંક બિન નકારાત્મક માટે પુછે છે.

1078
00:55:31,080 --> 00:55:34,280
અલી: જ્યારે અમે કંઈક બીજું તો વપરાશકર્તાને પૂછવાની રાખવા માંગો છો?

1079
00:55:34,280 --> 00:55:35,950
જ્યારે તે 0 કરતાં નાની છે.

1080
00:55:35,950 --> 00:55:36,760
અલી: અધિકાર.

1081
00:55:36,760 --> 00:55:38,010
રોબ: જ્યારે હું 0 કરતાં ઓછી છે.

1082
00:55:41,090 --> 00:55:45,120
અલી: હવે તો અમે તેને રૂપાંતરિત કરવા માંગો છો.

1083
00:55:45,120 --> 00:55:48,150
શું તમે ગાય્સ શું કરવું કોઇ વિચારો હશે?

1084
00:55:48,150 --> 00:55:49,400
કોઈપણ inklings?

1085
00:55:53,610 --> 00:55:54,984
યાહ.

1086
00:55:54,984 --> 00:55:57,344
39 વક્તા: શું અમે તેને કન્વર્ટ હોય, અથવા અમારી માત્ર કેટલાક 0s અને 1 સે છાપી શકો છો

1087
00:55:57,344 --> 00:55:58,760
કે જમણા નંબર હશે?

1088
00:55:58,760 --> 00:56:02,070
તમે લૂપ માટે કરી શકે છે અને 2 સત્તાઓ દ્વારા બહાર ગણતરી?

1089
00:56:02,070 --> 00:56:03,320
રોબ: હા.

1090
00:56:05,750 --> 00:56:08,425
તમે મને તેના બાઈનરી રૂપાંતરિત કરવાની જરૂર નથી -

1091
00:56:08,425 --> 00:56:13,720
i ની દ્વિસંગી પ્રતિનિધિત્વ i ની અંદર ન ફિટ થશે.

1092
00:56:13,720 --> 00:56:19,090
તમારે માત્ર i ની દ્વિસંગી પ્રતિનિધિત્વ પ્રિન્ટ કરવાની જરૂર છે.

1093
00:56:19,090 --> 00:56:21,010
અલી: અન્ય શબ્દોમાં, તમે બે સત્તાઓ દ્વારા જવાની જરૂર નથી.

1094
00:56:21,010 --> 00:56:23,710
રોબ: કારણ કે હું પહેલેથી જ દ્વિસંગીઓ તરીકે સંગ્રહિત કરવામાં આવી રહી છે, તેથી તમે જરૂર નથી

1095
00:56:23,710 --> 00:56:25,110
તે બાઈનરી રૂપાંતરિત કરો.

1096
00:56:25,110 --> 00:56:27,260
ફક્ત તેની દ્વિસંગી પર જાઓ, અને તે છાપો.

1097
00:56:30,080 --> 00:56:32,140
અને તમે bitwise ઉપયોગ કરવાની જરૂર જઈ રહ્યાં છો, કારણ કે તમે જોવા માંગો છો

1098
00:56:32,140 --> 00:56:33,390
વાસ્તવિક બિટ્સ.

1099
00:56:37,060 --> 00:56:38,600
તમે bitwise ઉપયોગ કરવાની જરૂર નથી, પરંતુ આમ કરો.

1100
00:56:44,130 --> 00:56:47,160
અને તે ખરેખર છે -

1101
00:56:47,160 --> 00:56:50,200
તમે બે સત્તાઓ 2 દ્વારા ગુણાકાર કરીને કરી શકો છો.

1102
00:56:50,200 --> 00:56:55,120
અમે એક છેલ્લા બે દ્વિસંગી bitwise ઓપરેટર પર જઈશ,

1103
00:56:55,120 --> 00:56:56,410
જે આ એક છે.

1104
00:56:56,410 --> 00:56:58,730
તેથી જ્યારે તમે લઇ -

1105
00:56:58,730 --> 00:57:00,083
>> અલી: તમે બંને પસાર કરી શકું?

1106
00:57:00,083 --> 00:57:01,440
રોબ: યાહ.

1107
00:57:01,440 --> 00:57:03,050
તેથી આપણે 9 સાથે જાઓ.

1108
00:57:03,050 --> 00:57:05,210
તેથી 9 ડાબી 1 પાળી -

1109
00:57:05,210 --> 00:57:12,220
પાળી અર્થ બાકી શું માત્ર ડાબી છે બધા બિટ્સ ખસેડવા અને 0 દાખલ કરો.

1110
00:57:12,220 --> 00:57:15,530
તેથી અમે 9 તમામ બિટ્સ ડાબી એક તરફ સ્થળાંતર કરી રહ્યા છીએ

1111
00:57:15,530 --> 00:57:20,240
સ્થિતિ છે, જે અમને આપે છે -

1112
00:57:26,530 --> 00:57:31,570
તેથી નોટિસ અમે બદલ્યા હતા બધું એક છોડી, અને પર 0 શામેલ

1113
00:57:31,570 --> 00:57:32,730
જમણી બાજુ.

1114
00:57:32,730 --> 00:57:36,755
જો અમે ખસેડાયેલો હતી બે દ્વારા છોડી, અમે બે દ્વારા છોડી બધું પાળી કરશે,

1115
00:57:36,755 --> 00:57:41,950
અને બે ગાબડા ભરો 0s દાખલ કરો.

1116
00:57:41,950 --> 00:57:43,200
પ્રશ્ન?

1117
00:57:44,890 --> 00:57:47,510
અલી: તેથી તે પછી યોગ્ય પાળી સમાન વસ્તુ કરે છે.

1118
00:57:47,510 --> 00:57:53,190
જો તમે 9 અધિકાર 1 પાળી હોય તો પછી તમે માત્ર પર કરી રહ્યાં છો તે બધું ખસેડીને

1119
00:57:53,190 --> 00:57:57,890
જમણી, તો તમે આંકડાના, જેથી 100 ને બદલે ગુમાવી બેસે છે.

1120
00:57:57,890 --> 00:58:04,142
રોબ: તેથી તમે તેને દંડ કે તમે થોડી કે બધી પ્રયત્ન થયું ગુમાવી છે

1121
00:58:04,142 --> 00:58:05,200
જમણી રીત.

1122
00:58:05,200 --> 00:58:08,850
ત્યાં અધિકાર પાળી વિવિધ પ્રકારના હોય છે, પરંતુ મૂળભૂત રીતે તમે વિચાર કરી શકો છો

1123
00:58:08,850 --> 00:58:11,410
અધિકાર 2 દ્વારા માત્ર ભાગાકાર તરીકે પાળી.

1124
00:58:11,410 --> 00:58:14,430
અને તમે ડાબી પાળી અને 2 દ્વારા ગુણાકાર તરીકે વિચાર કરી શકો છો.

1125
00:58:14,430 --> 00:58:16,490
તેથી તમે આ રૂપાંતર જો -

1126
00:58:16,490 --> 00:58:22,350
જો તમે 9 1 પાળી છે, કે જે 10010 સમાન છે રૂપાંતરિત, જો તમે વાસ્તવમાં ગયા

1127
00:58:22,350 --> 00:58:25,100
બાઈનરી દ્વારા અને બહાર figured છે કે શું હતું, તે માત્ર 18 હશે.

1128
00:58:25,100 --> 00:58:26,880
અમે હમણાં જ 2 દ્વારા વધવું.

1129
00:58:26,880 --> 00:58:30,982
1001 ડાબી 2 પાળી માટે 36 પ્રયત્ન રહ્યું છે.

1130
00:58:30,982 --> 00:58:32,400
અમે 4 દ્વારા વધવું.

1131
00:58:41,740 --> 00:58:45,360
ઠીક છે, ઠંડી, આથી તે આ માટે એક સરળ bitwise ઓપરેટર છે.

1132
00:58:52,570 --> 00:58:53,330
વધુ ગૂંચવણ?

1133
00:58:53,330 --> 00:58:54,870
શું તમે ગાય્સ તેનો પ્રયત્ન કરવા માંગો છો?

1134
00:58:54,870 --> 00:58:58,970
અથવા અમારી માત્ર જ કૂદકો કરી શકો છો અને તેને શરૂ?

1135
00:58:58,970 --> 00:59:01,140
રોબ: અમે કદાચ અધિકાર સાઇન કૂદી જોઈએ

1136
00:59:01,140 --> 00:59:01,880
અલી: અરે વાહ, ઠીક.

1137
00:59:01,880 --> 00:59:03,370
રોબ: અને તે દ્વારા એક સાથે ચાલવા.

1138
00:59:03,370 --> 00:59:04,440
>> અલી: વેલ હું ફક્ત જાય પડશે.

1139
00:59:04,440 --> 00:59:09,700
જેથી તેઓ શરૂઆતમાં જણાવ્યું હતું કે, અમે હમણાં જ ક્રમેક્રમે પસાર રહ્યા છીએ.

1140
00:59:09,700 --> 00:59:11,890
તેથી અમે લૂપ જરૂર જઈ રહ્યાં છો.

1141
00:59:11,890 --> 00:59:16,730
શું કોઇને લૂપ શ્રેષ્ઠ પ્રકારનો આ મારફતે જાઓ એક વિચાર છે?

1142
00:59:16,730 --> 00:59:20,544
અમે જ્યારે આંટીઓ હોય છે, આમ ત્યારે આંટીઓ, આંટીઓ છે.

1143
00:59:20,544 --> 00:59:22,400
40 વક્તા: લૂપ દો ત્યારે?

1144
00:59:22,400 --> 00:59:25,150
રોબ: તેથી યાદ હું તે વિશે પહેલાં જણાવ્યું હતું કે, અમે માત્ર કરવા-જ્યારે વાપરી રહ્યા હોય

1145
00:59:25,150 --> 00:59:27,390
આંટીઓ વપરાશકર્તા ઈનપુટ વિચાર.

1146
00:59:27,390 --> 00:59:30,890
તમે ખૂબ ખૂબ ક્યારેય ક્યારેય કંઈપણ માટે તેમને ઉપયોગ કરશે.

1147
00:59:30,890 --> 00:59:33,660
અલી: સાથે સમસ્યા શું-જ્યારે આંટીઓ છે તે કંઈક કરે તે પહેલાં માટે ચકાસે છે

1148
00:59:33,660 --> 00:59:34,470
આ પરિસ્થિતિ.

1149
00:59:34,470 --> 00:59:36,540
તેથી, તે કંઈક ખરાબ કરી શકે -

1150
00:59:36,540 --> 00:59:38,640
ગમે, નુકસાન -

1151
00:59:38,640 --> 00:59:40,350
કંઈક છે જે શક્ય નથી કરવું.

1152
00:59:40,350 --> 00:59:42,290
તેથી તમારે પ્રથમ તપાસ કરવા માંગો છો.

1153
00:59:42,290 --> 00:59:47,620
રોબ: ત્યાં કિસ્સાઓ ખૂબ જ્યાં તમે-જ્યારે આંટીઓ ઉપયોગ કરી શકો છો, પરંતુ લોકો

1154
00:59:47,620 --> 00:59:52,120
નથી અપેક્ષા નથી તમે તેમને વાપરવા માટે, સિવાય કે તે વપરાશકર્તા ઈનપુટ છે.

1155
00:59:52,120 --> 00:59:54,215
તેથી અમે ઉપયોગ કર્યો છે અમારા ડુ-જ્યારે લૂપ મને વિચાર.

1156
00:59:57,160 --> 01:00:01,260
કેટલી વખત અમારી લૂપ માટે લૂપ કરવા માંગો છો રહ્યું છે?

1157
01:00:01,260 --> 01:00:04,060
અમે i ની બિટ્સ દરેક પર લૂપ કરવા માંગો છો.

1158
01:00:04,060 --> 01:00:06,302
કેટલી બિટ્સ મને છે?

1159
01:00:06,302 --> 01:00:07,266
41 વક્તા: 32.

1160
01:00:07,266 --> 01:00:07,750
અલી: યાહ.

1161
01:00:07,750 --> 01:00:09,850
રોબ: તેથી ત્યાં 32 બિટ્સ છે.

1162
01:00:09,850 --> 01:00:12,920
અમે 32 કહેવું નથી માંગતા.

1163
01:00:12,920 --> 01:00:16,230
અમે તેના બદલે sizeof કહેવું માંગો છો -

1164
01:00:16,230 --> 01:00:18,226
જે, તો તમે તે હજુ સુધી જોવામાં વર્ગ છે?

1165
01:00:18,226 --> 01:00:19,100
અલી: ના.

1166
01:00:19,100 --> 01:00:20,380
રોબ: તે કે ઉપયોગ શા માટે કહેવું નથી -

1167
01:00:20,380 --> 01:00:22,160
sizeof (પૂર્ણાંક) 8 વખત -

1168
01:00:22,160 --> 01:00:23,530
અલી: તેથી, sizeof છે -

1169
01:00:23,530 --> 01:00:27,050
>> 42 વક્તા: [અશ્રાવ્ય]

1170
01:00:27,050 --> 01:00:27,440
અલી: રસિક.

1171
01:00:27,440 --> 01:00:31,610
તેથી, sizeof આંતરિક એક સી કાર્ય જ્યાં તે ફક્ત તમને કહે છે

1172
01:00:31,610 --> 01:00:32,500
બિટ્સ માં નંબર -

1173
01:00:32,500 --> 01:00:33,220
રોબ: બાઇટ્સ.

1174
01:00:33,220 --> 01:00:34,210
અલી: બાઇટ્સ, માફ કરશો -

1175
01:00:34,210 --> 01:00:39,990
બાઇટ્સ કે જે ચલ માટે કિંમત સ્ટોર છે સંખ્યા.

1176
01:00:39,990 --> 01:00:46,205
મને લાગે છે કે તે વર્ગમાં પર ગયા, પછી પૂર્ણાંક 4 બાઇટ્સ કદાચ છે.

1177
01:00:46,205 --> 01:00:46,610
કૂલ?

1178
01:00:46,610 --> 01:00:50,610
રોબ: પણ તમે જાણો છો કે પૂર્ણાંક 4 બાઇટ્સ છે જરૂર નથી કરીશું.

1179
01:00:50,610 --> 01:00:52,670
તમે કહો કરવાનો પ્રયત્ન કરીશું -

1180
01:00:52,670 --> 01:00:55,870
તમે sizeof (પૂર્ણાંક) નો ઉપયોગ 4 બાઇટ્સ વિચાર કરીશું.

1181
01:00:55,870 --> 01:00:59,170
અને તે કેટલીક વસ્તુઓ માટે ખરેખર અગત્યનું છે.

1182
01:00:59,170 --> 01:01:01,650
પૂર્ણાંક 4 બાઇટ્સ ન હોઈ શકે છે.

1183
01:01:01,650 --> 01:01:04,050
બીજા કમ્પ્યુટર પર, પૂર્ણાંક 8 બાઇટ્સ હોઈ શકે છે.

1184
01:01:04,050 --> 01:01:08,500
તેથી તમારા કાર્યક્રમ છે કે જે કોમ્પ્યુટર પર કામ કરશે નહિં તમે 32 હાર્ડ કોડેડ કારણ કે

1185
01:01:08,500 --> 01:01:12,230
તે કમ્પ્યુટર પર હોય ત્યારે બીટ 64 બિટ્સ બને છે.

1186
01:01:12,230 --> 01:01:15,260
અલી: તેથી તમે બીટ્સ કે તમે તેને ઉલટાવી માંગો છો કુલ સંખ્યા હોય છે.

1187
01:01:15,260 --> 01:01:17,480
રોબ: અને એક બાઇટ અને થોડી વચ્ચે તફાવત એ છે કે ત્યાં

1188
01:01:17,480 --> 01:01:19,100
એક બાઈટમાં 8 બીટ્સ છે.

1189
01:01:19,100 --> 01:01:22,110
તેથી sizeof (પૂર્ણાંક) 4 બાઇટ્સ આપે છે, તે પછી અમે તે વધવું હોય

1190
01:01:22,110 --> 01:01:24,420
8 દ્વારા 32 બિટ્સ વિચાર.

1191
01:01:24,420 --> 01:01:27,680
>> અલી: ઠીક છે, તેથી અમે મહત્તમ જણાવો અને અમે જાણીએ છીએ કે અમે માંથી જવા માગતા -

1192
01:01:27,680 --> 01:01:29,260
અમે તેમને બધા પસાર કરવા માંગો છો.

1193
01:01:29,260 --> 01:01:32,950
તેથી અમે 0 થી numBits પર જાઓ કરવા માંગો છો.

1194
01:01:32,950 --> 01:01:37,160
જેથી કોઇને ખબર નથી કે કેવી રીતે તે માટે લૂપ લખવા માટે?

1195
01:01:37,160 --> 01:01:37,790
કોઈપણ?

1196
01:01:37,790 --> 01:01:39,680
43 વક્તા: [અશ્રાવ્ય]

1197
01:01:39,680 --> 01:01:44,130
અલી: તેથી તમે zeroth બીટ માંથી એ નંબર હું પસાર કરવા માંગો છો

1198
01:01:44,130 --> 01:01:47,840
પ્રથમ બીટ, બીજો બીટ, ત્રીજા બીટ, numBits તમામ રીત.

1199
01:01:47,840 --> 01:01:50,972
બીટ્સ કે જે તમે મેળવી શકો છો મહત્તમ સંખ્યા.

1200
01:01:54,420 --> 01:01:57,780
રોબ: સામાન્ય લૂપ અમે ઉપયોગ અમે શું કરીએ કંઈક એક્સ વખત કરવા માંગો છો શું છે?

1201
01:01:57,780 --> 01:01:58,280
અલી: માટે.

1202
01:01:58,280 --> 01:01:59,280
પરફેક્ટ.

1203
01:01:59,280 --> 01:02:00,440
તેથી અમે માટે હોય છે.

1204
01:02:00,440 --> 01:02:05,242
અને પછી અમે iterator, કે જે હું નથી રહ્યું છે બનાવશો.

1205
01:02:05,242 --> 01:02:06,850
રોબ: જ.

1206
01:02:06,850 --> 01:02:08,080
અલી: = જોહાન 0.

1207
01:02:08,080 --> 01:02:09,740
તેથી અમે 0 અંતે શરૂ કરી શકશો.

1208
01:02:09,740 --> 01:02:13,110
અને પછી અમે એ ખાતરી કરો કે શરત છે જઈ રહ્યાં છો, જ્યારે તમે છો

1209
01:02:13,110 --> 01:02:14,968
તે મારફતે દરેક એક સમય જતાં -

1210
01:02:14,968 --> 01:02:16,960
[અવાજો INTERPOSING]

1211
01:02:16,960 --> 01:02:17,960
રોબ: જ.

1212
01:02:17,960 --> 01:02:19,970
અલી: જ numBits કરતાં ઓછી છે.

1213
01:02:19,970 --> 01:02:23,680
તેથી અમે એક સમકક્ષ વાસ્તવિક કરવા નહિં માંગો, તો કારણ કે તેઓ numBits છો

1214
01:02:23,680 --> 01:02:25,365
કુલ છે, અને અમે 0 શરુ થાય છે.

1215
01:02:25,365 --> 01:02:26,360
તેથી અમે ખરેખર હોય રહ્યા છીએ -

1216
01:02:26,360 --> 01:02:27,400
44 વક્તા: ઓહ.

1217
01:02:27,400 --> 01:02:29,300
અલી છે: નિર્દેશિકાઓની 1 બાદ numBits ન અંત નથી.

1218
01:02:29,300 --> 01:02:34,070
રોબ: અમે બિટ્સ લેબલ 0 થી 31, અમે તેમને 1 32 ન લેબલ નથી.

1219
01:02:34,070 --> 01:02:36,970
અલી: અને પછી અમે એક દ્વારા દરેક સમય વધારો, જઈ રહ્યાં છો કારણ કે અમે કરવા માંગો છો

1220
01:02:36,970 --> 01:02:38,050
દરેક એક એક તપાસો.

1221
01:02:38,050 --> 01:02:39,851
તેથી અમે જ જઈશ + +.

1222
01:02:39,851 --> 01:02:42,740
>> 45 વક્તા: શા માટે છે કે જે તમને કરી રહ્યા છે?

1223
01:02:42,740 --> 01:02:46,100
46 વક્તા: શા માટે તમે દરેક બીટ મારફતે જવું છે?

1224
01:02:46,100 --> 01:02:49,310
રોબ: તેથી અમે દરેક બીટ પસાર કરવા માંગો છો અને -

1225
01:02:52,780 --> 01:02:55,100
તેથી આપણે કહેવું અમે કેટલીક નંબર હોય છે.

1226
01:02:55,100 --> 01:02:56,195
અલી: 68.

1227
01:02:56,195 --> 01:02:57,470
રોબ: અમે 68 નો ઉપયોગ કરી શકો છો.

1228
01:02:57,470 --> 01:03:00,450
તેથી બાઈનરી 100100 જ હશે.

1229
01:03:00,450 --> 01:03:05,540
તેથી આ i ની અંદર છે અને અમે આ બિટ્સ દરેક પર જાઓ કરવા માંગો છો.

1230
01:03:05,540 --> 01:03:06,450
તે 1 એક?

1231
01:03:06,450 --> 01:03:07,320
1 છાપો.

1232
01:03:07,320 --> 01:03:08,120
તે 0 છે?

1233
01:03:08,120 --> 01:03:09,100
0 છાપો.

1234
01:03:09,100 --> 01:03:10,530
પછી અમે આગામી બીટ પર જાઓ.

1235
01:03:10,530 --> 01:03:11,210
તે 1 એક?

1236
01:03:11,210 --> 01:03:11,610
1 છાપો.

1237
01:03:11,610 --> 01:03:11,830
એક 0 છે?

1238
01:03:11,830 --> 01:03:13,080
0 છાપો.

1239
01:03:14,880 --> 01:03:16,710
અલી: સરસ, ઠીક છે.

1240
01:03:16,710 --> 01:03:22,880
હવે અમે જ્યાં કે બીટ છે માટે યોગ્ય ઇન્ડેક્સ પર છો.

1241
01:03:25,380 --> 01:03:28,080
અમે તે ચોક્કસ એક કેવી રીતે તપાસ કરી શકે છે?

1242
01:03:28,080 --> 01:03:33,130
હવે કહો કે અમે = જ 0 અંતે છો, જેથી અમે બીટ ઓફ 0 અનુક્રમણિકા તપાસ કરવા માંગો છો.

1243
01:03:33,130 --> 01:03:37,980
તેથી, આ કિસ્સામાં, આ એક છે.

1244
01:03:37,980 --> 01:03:41,930
>> તેથી હવે અમે કેવી રીતે તપાસ જઈ નથી - ઓહ, તો તે આ એક હશે.

1245
01:03:41,930 --> 01:03:42,810
રોબ: યાહ.

1246
01:03:42,810 --> 01:03:44,310
અલી: માફ કરશો.

1247
01:03:44,310 --> 01:03:47,930
આપણે એક કે તપાસવા વિશે કેવી રીતે એક અર્થમાં કરશે જાઓ,?

1248
01:03:47,930 --> 01:03:52,030
અમે જો તે 0 અથવા 1 એક કેવી રીતે તપાસો?

1249
01:03:52,030 --> 01:03:52,730
Let's વેલ -

1250
01:03:52,730 --> 01:03:53,940
CLASS: અને 1?

1251
01:03:53,940 --> 01:03:54,390
અલી: અને?

1252
01:03:54,390 --> 01:03:55,010
યાહ.

1253
01:03:55,010 --> 01:03:57,810
રોબ: તેથી આપણે કહેવું અમે પહેલાથી 1 હોય છે.

1254
01:03:57,810 --> 01:04:02,470
તો પછી આ &, આ પરત કરશે કે તેને 1 અથવા 0 હતી.

1255
01:04:05,580 --> 01:04:08,200
અલી: તેથી અમે નીચે જઈ શકે છે.

1256
01:04:08,200 --> 01:04:10,695
અને અમે જેમ તમે ગાય્સ જણાવ્યું હતું અને કાર્ય કરવાનું છે, કરી શકો છો.

1257
01:04:13,810 --> 01:04:15,560
રોબ: પૂર્ણાંક -

1258
01:04:15,560 --> 01:04:18,290
હું આ કેવી રીતે કરવા માંગો છો કહેવું નથી -

1259
01:04:18,290 --> 01:04:24,250
isOne = i.

1260
01:04:24,250 --> 01:04:29,770
અને પ્રથમ બીટ અમે જોઈ શકાય થાય છે, અમે હું & 1 કરી રહ્યા છીએ.

1261
01:04:29,770 --> 01:04:33,302
હવે અમે શું માટે અને બીજા બીટ માટે કરવા માંગો છો દ્વારા જવું છે?

1262
01:04:33,302 --> 01:04:34,294
47 વક્તા: 2.

1263
01:04:34,294 --> 01:04:36,110
રોબ: અરે વાહ, બીજો કે અમે 2 છો.

1264
01:04:36,110 --> 01:04:39,100
અલી: તમે નોટિસ કરીશું કે 1 આ બોલ પર ડાબી એક ખસેડવામાં આવી છે.

1265
01:04:39,100 --> 01:04:44,320
તેથી અમે કોઈ bitwise ઓપરેટરો શીખ્યા છે કે કાર્ય કરે છે?

1266
01:04:44,320 --> 01:04:45,160
રોબ: આગામી એક -

1267
01:04:45,160 --> 01:04:46,280
અલી: અરે વાહ, અધિકાર, બરાબર.

1268
01:04:46,280 --> 01:04:48,670
તેથી તે ડાબી પાળી છે.

1269
01:04:48,670 --> 01:04:51,120
તેના બદલે હંમેશા 1 થી ચકાસણીનાંબદલે, તો અમે તેને પાળી રહ્યા છીએ.

1270
01:04:51,120 --> 01:04:53,470
અને કેટલી વખત અમે તેને પાળી જવું છે?

1271
01:04:53,470 --> 01:04:59,340
જો અમે zeroth એક ચકાસણી કરી રહ્યાં છો તો અમે તેને શૂન્ય પર ખસેડી રહ્યા છીએ.

1272
01:04:59,340 --> 01:04:59,975
અરે વાહ, બરાબર.

1273
01:04:59,975 --> 01:05:02,090
જેથી તમે તેને જ દ્વારા પાળી છોડી દીધી.

1274
01:05:02,090 --> 01:05:02,550
પરફેક્ટ.

1275
01:05:02,550 --> 01:05:03,550
તેથી હવે આપણે જાણીએ છીએ -

1276
01:05:03,550 --> 01:05:06,450
અમે જો તે 1 છે આ પૂર્ણાંક હોય છે, અને તે પછી -

1277
01:05:10,690 --> 01:05:14,670
જેથી છેતરપિંડી ના રોબ અહીં પ્રકારની -

1278
01:05:14,670 --> 01:05:18,090
અને તેથી હવે તે આગળ જઈને કરવામાં આવી હતી અને તે માત્ર કહેતા છે કે જો તે વાસ્તવમાં 1,

1279
01:05:18,090 --> 01:05:23,540
કારણ કે 1 સાચું માટે મૂલ્યાંકન કરે છે, તેથી અમે કહી isf isOne 1 સમકક્ષ નથી -

1280
01:05:23,540 --> 01:05:29,210
જેથી isOne જો, તો પછી અમે 1 છાપો, અને અન્યથા અમે 0 છાપો.

1281
01:05:29,210 --> 01:05:33,350
>> રોબ: તેથી અમારા કાર્યક્રમ એકંદર ભૂલ છે.

1282
01:05:33,350 --> 01:05:35,845
વેલ, આ પ્રથમ પર પ્રશ્નો.

1283
01:05:35,845 --> 01:05:41,692
48 વક્તા: તમે ક્યારેય ચાર કામગીરી ભાગ અંદર isOne મૂકી શકે અને

1284
01:05:41,692 --> 01:05:47,804
પછી તે છેલ્લા ભાગ તરીકે છે પોતે પાળી?

1285
01:05:47,804 --> 01:05:50,050
તેથી isOne 1 અને પછી સમકક્ષ -

1286
01:05:50,050 --> 01:05:53,140
રોબ: હા, તમે આ કરી શકો છો.

1287
01:05:53,140 --> 01:05:57,200
અમે ખરેખર દર્શાવે છે કે એક વખત અમે ભૂલ કે હું છું વિશે ઠીક કરી શકે છે

1288
01:05:57,200 --> 01:06:00,050
તમે બધા સાથે ચર્ચા કરો.

1289
01:06:00,050 --> 01:06:03,470
ઓર્ડર અમે વસ્તુઓ પર જઈ રહ્યાં છો નોટિસ.

1290
01:06:03,470 --> 01:06:10,570
આ દ્વિસંગી પ્રતિનિધિત્વ આપવામાં, અમે zeroth બીટ સાથે શરૂઆત કરી છે.

1291
01:06:10,570 --> 01:06:13,010
જો તે 0 છે, તો પછી અમે છાપવા આવે છે -

1292
01:06:13,010 --> 01:06:15,620
સાથે સાથે, તે 0 છે, તેથી અમે 0 છાપવા છે.

1293
01:06:15,620 --> 01:06:16,860
તો પછી અમે બીજા બીટ પર જાઓ.

1294
01:06:16,860 --> 01:06:19,100
તે 0 છે, તેથી અમે 0 છાપો.

1295
01:06:19,100 --> 01:06:20,290
તો પછી અમે ત્રીજી બીટ પર જાઓ.

1296
01:06:20,290 --> 01:06:22,950
તેને 1 છે, તેથી અમે 1 છાપો.

1297
01:06:22,950 --> 01:06:24,580
અલી: તેથી તે પાછળની બનશે.

1298
01:06:24,580 --> 01:06:27,906
તેથી તમે કેવી રીતે ગાય્સ સૂચવે છે કે અમે તે સુધારવા અને અન્ય રીતે જવું?

1299
01:06:27,906 --> 01:06:28,900
49 વક્તા: [અશ્રાવ્ય]

1300
01:06:28,900 --> 01:06:29,490
રોબ: યાહ.

1301
01:06:29,490 --> 01:06:34,500
તેથી તેના બદલે 0 થી numBits જવા માટે, અમે numBits બિટ્સ માંથી 0 જઈશ.

1302
01:06:34,500 --> 01:06:35,600
અલી: તેથી [અશ્રાવ્ય]

1303
01:06:35,600 --> 01:06:36,940
હંમેશા અન્ય માર્ગ જઈ શકે છે.

1304
01:06:36,940 --> 01:06:38,970
રોબ: NumBits 1 બાદ, કારણ કે છેલ્લા nubmer છે -

1305
01:06:38,970 --> 01:06:41,160
અલી: કારણ કે તે 0 થી 31 પર જાય છે.

1306
01:06:41,160 --> 01:06:44,420
અને પછી આપણે હંમેશા ખાતરી કરો કે તે 0 કરતાં મોટો જ જેથી તમે ન જાય તો પડશે

1307
01:06:44,420 --> 01:06:46,100
ખૂબ દૂર જમણી બાજુ.

1308
01:06:46,100 --> 01:06:48,800
અને પછી તમે હંમેશા 1 દ્વારા સબ્ટ્રેક્ટ અધિકાર પર જાઓ પડશે.

1309
01:06:48,800 --> 01:06:52,240
>> રોબ: તેથી હવે અમે રિવર્સ લૂપ છે, અને નંબર પ્રિન્ટીંગ પાછું છે

1310
01:06:52,240 --> 01:06:53,586
યોગ્ય રીતે.

1311
01:06:53,586 --> 01:06:57,560
50 વક્તા: તમે પાળી વસ્તુ પણ બદલી નથી શું?

1312
01:06:57,560 --> 01:06:58,810
અલી: તેથી નં.

1313
01:07:03,810 --> 01:07:06,470
રોબ: અમે જ ચોક્કસ કામગીરી કરી રહ્યા છીએ હવે સિવાય,

1314
01:07:06,470 --> 01:07:07,470
વિપરીત ક્રમમાં.

1315
01:07:07,470 --> 01:07:14,170
તેથી તેના બદલે numBits દ્વારા સ્થળાંતર કરવાનું બાદ 1 કંઈપણ આ વિચાર

1316
01:07:14,170 --> 01:07:17,430
બીટ કે જે છેલ્લે કરવાનું બદલે છે, અમે માત્ર તે પ્રથમ કરવું પડશે.

1317
01:07:19,970 --> 01:07:22,970
આ ખાળવાનો અહીં, અમે બધું ક્રમ ઉલટાવી

1318
01:07:22,970 --> 01:07:24,190
કે અંદર બને છે.

1319
01:07:24,190 --> 01:07:28,610
પરંતુ અમે બદલવા માટે શું અંદર તમામ ખાતે થાય નહિં માંગો.

1320
01:07:28,610 --> 01:07:29,860
અલી: જરૂરી છે કે અર્થમાં છે?

1321
01:07:32,240 --> 01:07:33,660
પ્રક્રિયા?

1322
01:07:33,660 --> 01:07:41,200
ઠીક છે, તેથી તે અન્ય કોઈને કોઈ અન્ય પ્રત્યયાત્મક પ્રશ્નો હોય છે?

1323
01:07:41,200 --> 01:07:45,030
અલી: પહેલાં તો અમે તેના બિંદુ જાય છે કે જે -

1324
01:07:45,030 --> 01:07:46,280
અલી: અધિકાર બધા, તેમજ જાઓ.

1325
01:07:48,350 --> 01:07:53,160
જ ઉપયોગ કરીને અમારી પ્રયત્ન બદલે: - રોબ

1326
01:07:55,780 --> 01:08:00,550
તેના બદલે જ ઉપયોગ કરીને હંમેશા દ્વારા એક ડાબી પાળી જ, જેમ પાળી છે, મને લાગે છે કે શું

1327
01:08:00,550 --> 01:08:04,120
તમે કહી રહ્યાં છે ગમે, માટે જ પોતે વાપરે છે.

1328
01:08:04,120 --> 01:08:09,560
તેથી જ -

1329
01:08:09,560 --> 01:08:14,656
હું માનું આ મુશ્કેલ છે - એ જ = 1 << 31.

1330
01:08:14,656 --> 01:08:16,200
છે કે હું શું કરવા માંગો છો?

1331
01:08:16,200 --> 01:08:18,470
મને લાગે છે કે તે 31 << છે.

1332
01:08:18,470 --> 01:08:22,840
જ> = 1.

1333
01:08:22,840 --> 01:08:32,319
જ >>, >> isOne આઇ, અને જ -

1334
01:08:32,319 --> 01:08:35,620
તેથી હવે બદલે મદદથી -

1335
01:08:35,620 --> 01:08:38,370
અલી: તમે સતત કર્યા બદલે રહ્યાં છો જ ખસેડીને

1336
01:08:38,370 --> 01:08:40,520
તેને ચેક ઇન્ડેક્સ.

1337
01:08:40,520 --> 01:08:42,130
તે ખરાબ નથી.

1338
01:08:42,130 --> 01:08:43,960
અમે એક તર્કશાસ્ત્ર સમાન પ્રકારની ઉપયોગ કરી રહ્યાં છો.

1339
01:08:43,960 --> 01:08:46,202
તેથી જો તમે પાછા જાઓ -

1340
01:08:46,202 --> 01:08:50,020
ઓહ, પરંતુ તે તેને ગુમાવી રહ્યું છે.

1341
01:08:50,020 --> 01:08:51,380
ઠીક છે, તો તમે ફક્ત તેને ફરીથી લખો રહ્યા છીએ.

1342
01:08:51,380 --> 01:08:56,880
જો તમે નોંધ્યું છે કે અમે વખત 1 << જ જથ્થો ધરાવે છે, અને અમે હતા

1343
01:08:56,880 --> 01:09:02,279
જ એક ઈજાફો દ્વારા દરેક એક સમય incrementing, પરંતુ આ સમય બદલે

1344
01:09:02,279 --> 01:09:06,010
તેઓ લૂપ માટે અંદર ટોચ પર જ ના પગાર - વધારો કરી રહ્યા છીએ.

1345
01:09:06,010 --> 01:09:10,890
તેથી બદલે હંમેશા તેને ખસેડીને નીચે -

1346
01:09:10,890 --> 01:09:15,220
રોબ: લૂપ માટે આ ખૂબ જ પ્રથમ પુનરાવૃત્તિ, અમે જ 10000 છે.

1347
01:09:15,220 --> 01:09:20,000
લૂપ માટે ની આગામી પુનરાવૃત્તિ 01000 છે.

1348
01:09:20,000 --> 01:09:22,380
આગામી પુનરાવૃત્તિ હોય છે.

1349
01:09:22,380 --> 01:09:26,800
અને 1 એ માત્ર નીચે પ્રચાર રાખવા રહ્યું છે ત્યાં સુધી અમે ખૂબ જ હિટ

1350
01:09:26,800 --> 01:09:29,729
ઓવરને, હવે જ્યાં તે આ છે.

1351
01:09:29,729 --> 01:09:33,990
આગામી એક, 1 માટે આ બોલ પર કોઈ રન નોંધાયો નહીં શકાય છે, રહ્યું છે અને એ જ હવે વધારે

1352
01:09:33,990 --> 01:09:35,090
કરતાં અથવા 1 માટે સમાન.

1353
01:09:35,090 --> 01:09:38,380
હું પણ 0 કરતાં મોટો, સમાન તફાવત મૂકી શકે છે.

1354
01:09:38,380 --> 01:09:41,580
અને પછી તે તે.

1355
01:09:41,580 --> 01:09:43,720
પ્રશ્નો?

1356
01:09:43,720 --> 01:09:44,760
યાહ.

1357
01:09:44,760 --> 01:09:49,740
>> 51 વક્તા: [અશ્રાવ્ય]

1358
01:09:49,740 --> 01:09:51,729
રોબ: તેથી કે તે જ છે -

1359
01:09:51,729 --> 01:09:57,270
તમે જ + + = 3 જોઇ?

1360
01:09:57,270 --> 01:10:00,960
તેથી આ 3 જ = જ + + જેવા જ છે?

1361
01:10:00,960 --> 01:10:05,560
તમે વર્ચ્યુઅલ સી કોઈપણ ઓપરેટર કે કરી શકે છે તેથી જ >> છે = 3

1362
01:10:05,560 --> 01:10:10,490
જ = >> જ 3 થી સમાન.

1363
01:10:13,980 --> 01:10:16,760
જેથી bitwise ઓપરેટરો સાથે પણ કામ કરે છે.

1364
01:10:16,760 --> 01:10:19,630
અને હું 31 અહીં ન કરવી જોઇએ.

1365
01:10:19,630 --> 01:10:23,790
1 - હું numBits મૂકેલ છે કરીશું.

1366
01:10:23,790 --> 01:10:25,380
અલી: યે, કોઈ જાદુ નંબરો.

1367
01:10:25,380 --> 01:10:29,070
ઠીક છે, તે 4:00 જોકે, તેથી જો તમે ગાય્સ પર જાઓ હોય - પરંતુ આ અર્થમાં છે?

1368
01:10:29,070 --> 01:10:30,320
શું તમે ગાય્સ અન્ય કોઇ પ્રશ્નો હોય તો?

1369
01:10:33,920 --> 01:10:38,470
રોબ: હું પણ છે કે જે ફેંકવું જો આપણે ઇચ્છતા જઈને કરવામાં આવી હતી -

1370
01:10:38,470 --> 01:10:41,326
છે કે તેઓ ત્રણ ભાગનું બનેલું ઓપરેટર બધા ચર્ચા?

1371
01:10:41,326 --> 01:10:42,730
અલી: નંબર

1372
01:10:42,730 --> 01:10:45,090
તે ઠીક છે.

1373
01:10:45,090 --> 01:10:46,970
રોબ: તેથી તમે તેને માં આગામી સમય જોવા માટે કરી શકે છે.

1374
01:10:51,030 --> 01:10:52,080
અલી: ઠીક છે, ખરેખર?

1375
01:10:52,080 --> 01:10:53,150
હવે તમે માત્ર નિદર્શન કરી રહ્યાં છો.

1376
01:10:53,150 --> 01:10:54,210
રોબ: ના, હવે it's -

1377
01:10:54,210 --> 01:11:00,490
આ એ છે જે લોકોને રસ નહીં, અને હવે તેઓ તેને ધ્યાનમાં જવા પડશે.

1378
01:11:00,490 --> 01:11:02,640
તેથી હવે, કે જે એક પગલું આ જ વસ્તુ, કરે છે.

1379
01:11:05,150 --> 01:11:10,950
તેથી તપાસ પ્રથમ, હું અને 1 જ છે?

1380
01:11:10,950 --> 01:11:12,530
તે સાચું છે?

1381
01:11:12,530 --> 01:11:17,000
જો આમ હોય, 1 એ છાપો, બીજું, એક 0 છાપો.

1382
01:11:17,000 --> 01:11:19,190
અલી: પરંતુ તે કરવાથી અન્ય માર્ગ સંપૂર્ણપણે દંડ તેમજ છે.

1383
01:11:19,190 --> 01:11:20,920
તે જ તર્ક છે.

1384
01:11:20,920 --> 01:11:22,730
તેથી તે જેમ છે નથી -

1385
01:11:22,730 --> 01:11:24,620
રોબ: આ બિંદુએ, અમે તે સર્પાકાર કૌંસ છૂટકારો મેળવવા માટે, કારણ કે તે માત્ર શકો છો

1386
01:11:24,620 --> 01:11:27,190
લૂપ માટે એક લીટી.

1387
01:11:27,190 --> 01:11:29,370
અલી: ઠીક છે, કે જેથી અર્થમાં કમાવે છે?

1388
01:11:29,370 --> 01:11:30,370
કે જે જમ્પ પ્રકારની હતી.

1389
01:11:30,370 --> 01:11:34,870
પરંતુ તે માત્ર વાક્યરચના પ્રકારની હતું, જેથી.

1390
01:11:34,870 --> 01:11:36,250
>> કૂલ?

1391
01:11:36,250 --> 01:11:37,500
કોઈપણ અન્ય પ્રશ્નો છે?

1392
01:11:40,880 --> 01:11:41,570
બધા હક: Rob.

1393
01:11:41,570 --> 01:11:42,310
અલી: બધા અધિકાર કૂલ.

1394
01:11:42,310 --> 01:11:43,560
કલમ આવતા માટે આભાર.