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

2
00:00:02,420 --> 00:00:05,189

3
00:00:05,189 --> 00:00:05,980
વક્તા: બધા અધિકાર.

4
00:00:05,980 --> 00:00:08,540
તેથી આપણે અન્ય વિશે વાત કરો
સી પ્રકારની અનન્ય છે કે વસ્તુ,

5
00:00:08,540 --> 00:00:10,010
જે ડેટા પ્રકારો અને ચલો છે.

6
00:00:10,010 --> 00:00:12,340
જ્યારે હું કહી અનન્ય સે, હું ખરેખર
માત્ર સંદર્ભમાં તેનો અર્થ,

7
00:00:12,340 --> 00:00:14,470
તમે પ્રોગ્રામર આવી છે, તો
ખરેખર લાંબા સમય માટે,

8
00:00:14,470 --> 00:00:16,270
તમે કદાચ ન કર્યું
ડેટા પ્રકારો સાથે કામ કર્યું હતું

9
00:00:16,270 --> 00:00:18,470
તમે આધુનિક ઉપયોગ કર્યો છે તો
પ્રોગ્રામિંગ ભાષાઓ છે.

10
00:00:18,470 --> 00:00:20,432
જેવી આધુનિક ભાષાઓ
PHP અને જાવાસ્ક્રિપ્ટ,

11
00:00:20,432 --> 00:00:22,640
અમે પણ થોડી જોશો જે
પાછળથી દરમિયાન,

12
00:00:22,640 --> 00:00:25,550
તમે ખરેખર સ્પષ્ટ કરવાની જરૂર નથી
એક ચલ ડેટા પ્રકાર

13
00:00:25,550 --> 00:00:26,270
તમે તેનો ઉપયોગ કરે છે.

14
00:00:26,270 --> 00:00:28,067
>> તમે માત્ર તે જાહેર અને તેનો ઉપયોગ શરૂ કરો.

15
00:00:28,067 --> 00:00:29,900
તે પૂર્ણાંક છે, તો તે
તે પૂર્ણાંક છે ખબર.

16
00:00:29,900 --> 00:00:31,960
તે એક પાત્ર છે, તો તે છે
તે એક પાત્ર છે જાણે છે.

17
00:00:31,960 --> 00:00:35,320
તે શબ્દ છે, તો તે જાણે
તે કહેવાતા એક શબ્દમાળા છે.

18
00:00:35,320 --> 00:00:37,300
>> પરંતુ સી, જે એક
જૂની ભાષા, અમે જરૂર

19
00:00:37,300 --> 00:00:39,420
માહિતી સ્પષ્ટ કરવા માટે
દરેક ચલનો પ્રકાર

20
00:00:39,420 --> 00:00:42,990
અમે પ્રથમ સમય બનાવો કે
અમે તે ચલ ઉપયોગ કરે છે.

21
00:00:42,990 --> 00:00:45,030
તેથી સી કેટલાક સાથે આવે છે
બિલ્ટ-ઇન ડેટા પ્રકારો.

22
00:00:45,030 --> 00:00:46,972
અને પરિચિત વિચાર કરીએ
તે કેટલાક સાથે.

23
00:00:46,972 --> 00:00:50,180
અને પછી પાછળથી અમે પણ એક વાત કરીશું
આ ડેટા પ્રકારો કેટલાક વિશે થોડુંક

24
00:00:50,180 --> 00:00:54,450
અમે તમારા માટે તેવા પરચૂરણ ખર્ચ કર્યો છે,
જેથી તમે CS50 માં વાપરી શકો છો.

25
00:00:54,450 --> 00:00:56,130
>> પ્રથમ પૂર્ણાંક છે.

26
00:00:56,130 --> 00:00:59,110
આ પૂર્ણાંક માહિતી પ્રકાર ચલો માટે વપરાય છે
કે પૂર્ણાંક કિંમતો સ્ટોર કરશે.

27
00:00:59,110 --> 00:01:03,210
તેથી 1, 2, 3, નકારાત્મક 1, 2, 3, અને તેથી પર.

28
00:01:03,210 --> 00:01:05,960
કંઈક કે જે તમને છે પૂર્ણાંકો,
ક્વિઝ માટે ધ્યાનમાં રાખવા જોઈએ,

29
00:01:05,960 --> 00:01:09,590
હંમેશા ચાર બાઇટ્સ લાગી
મેમરી, જે 32 બિટ્સ છે.

30
00:01:09,590 --> 00:01:11,620
એક બાઈટ આઠ બિટ્સ છે.

31
00:01:11,620 --> 00:01:14,470
>> તેથી આ શ્રેણી છે કે જે અર્થ થાય છે
પૂર્ણાંક સ્ટોર કરી શકો છો કિંમતો કે જે

32
00:01:14,470 --> 00:01:19,130
અંદર ફિટ થઈ શકે છે શું દ્વારા મર્યાદિત હોય છે
માહિતી વર્થ 32 બિટ્સ.

33
00:01:19,130 --> 00:01:21,850
હવે તે બહાર વળે છે,
તે લાંબા સમય પહેલા નક્કી કરવામાં આવ્યું હતું

34
00:01:21,850 --> 00:01:24,310
અમે વિભાજિત થશે કે
32 બીટ્સ કે શ્રેણી

35
00:01:24,310 --> 00:01:26,650
નકારાત્મક પૂર્ણાંકો માં
અને હકારાત્મક પૂર્ણાંકો,

36
00:01:26,650 --> 00:01:28,390
શ્રેણી દરેક મેળવવામાં અડધા.

37
00:01:28,390 --> 00:01:32,230
અમે પ્રતિનિધિત્વ કિંમતો કે જે શ્રેણી જેથી
નકારાત્મક 2 પૂર્ણાંક શ્રેણી સાથે

38
00:01:32,230 --> 00:01:36,520
2 31 શક્તિ માટે
31 શક્તિ ઓછા 1,

39
00:01:36,520 --> 00:01:38,190
તમે પણ 0 માટે એક સ્પોટ જરૂર થાય છે.

40
00:01:38,190 --> 00:01:41,650
>> શક્ય કિંમતો જેથી મૂળભૂત અડધા
તમે નકારાત્મક છે પૂર્ણાંક ફિટ થઈ શકે છે

41
00:01:41,650 --> 00:01:42,610
અને અડધા હકારાત્મક છે.

42
00:01:42,610 --> 00:01:47,270
અને આશરે અહીં, આ નકારાત્મક વિશે છે
2 અબજ હકારાત્મક 2 અબજ વિશે.

43
00:01:47,270 --> 00:01:50,207
આપો અથવા એક દંપતિ સો મિલિયન લે છે.

44
00:01:50,207 --> 00:01:52,290
કે જેથી તમે ફિટ થઈ શકે છે શું છે
પૂર્ણાંક ચલ.

45
00:01:52,290 --> 00:01:55,490
હવે અમે પણ કંઈક હોય
એક બિનનોંધાયેલ પૂર્ણાંક કહેવાય છે.

46
00:01:55,490 --> 00:01:59,220
હવે સહી થયેલ નહિં ints નથી છે
ચલ અલગ પ્રકાર.

47
00:01:59,220 --> 00:02:01,590
તેના બદલે, સહી થયેલ નહિં છે
શું ક્વોલિફાયર કહેવાય છે.

48
00:02:01,590 --> 00:02:04,990
તે માહિતી સુધારે
સહેજ પૂર્ણાંક પ્રકાર.

49
00:02:04,990 --> 00:02:07,850
>> અને આ કિસ્સામાં, શું સહી થયેલ નહિં
means-- અને તમે પણ કરી શકો છો

50
00:02:07,850 --> 00:02:11,530
સહી થયેલ નહિં અન્ય ડેટા પ્રકારો વાપરવા માટે,
પૂર્ણાંક માત્ર એક નથી.

51
00:02:11,530 --> 00:02:15,310
શું તે અસરકારક રીતે કરે છે ડબલ્સ છે
કિંમતો હકારાત્મક શ્રેણી

52
00:02:15,310 --> 00:02:19,350
પૂર્ણાંક પર લઇ શકે છે કે
લાંબા સમય સુધી પરવાનગી આપે છે ખર્ચ

53
00:02:19,350 --> 00:02:21,140
તમે પહેલાના નકારાત્મક કિંમતો પર લે છે.

54
00:02:21,140 --> 00:02:25,400
તમે જાણો છો કે નંબરો હોય તો
કરતાં વધારે 2 અબજ પરંતુ ઓછા મળશે

55
00:02:25,400 --> 00:02:31,280
4 અબજ કરતાં ઉદાહરણ માટે
જે 32 માટે 2 છે power--

56
00:02:31,280 --> 00:02:33,330
તમે ઉપયોગ કરવા માંગો છો શકે છે
જો તમે એક બિનનોંધાયેલ પૂર્ણાંક

57
00:02:33,330 --> 00:02:35,050
તમારી કિંમત નકારાત્મક થશે નહીં ખબર.

58
00:02:35,050 --> 00:02:37,216
>> તમે ક્યારેક ક્યારેક પડશે
સહી થયેલ નહિં ચલો માટે વપરાય છે

59
00:02:37,216 --> 00:02:39,460
હું તેને અહીં ઉલ્લેખ શા માટે CS50 માં, જે.

60
00:02:39,460 --> 00:02:43,830
પરંતુ કિંમતો ફરીથી, આ શ્રેણી છે કે જે તમને
એક બિનનોંધાયેલ પૂર્ણાંક સાથે પ્રતિનિધિત્વ કરી શકે છે

61
00:02:43,830 --> 00:02:48,240
નિયમિત પૂર્ણાંક ટી તરીકે, 0 છે
32 મા શક્તિ -1 ઘાત 2,

62
00:02:48,240 --> 00:02:50,840
અથવા આશરે 0 4 અબજ.

63
00:02:50,840 --> 00:02:53,730
તેથી જો તમે અસરકારક રીતે બમણો કર્યો
તમે ફિટ થઈ શકે છે કે જે હકારાત્મક શ્રેણી

64
00:02:53,730 --> 00:02:56,270
પરંતુ તમે બધા ઉપર આપી છે
નકારાત્મક કિંમતો.

65
00:02:56,270 --> 00:03:00,040
>> હવે એક કોરે, સહી થયેલ નહિં તરીકે
એક માત્ર ક્વોલિફાયર નથી

66
00:03:00,040 --> 00:03:01,790
અમે જોઈ શકો કે
ચલ ડેટા પ્રકારો.

67
00:03:01,790 --> 00:03:05,779
કહેવાય વસ્તુઓ પણ છે
ટૂંકા અને લાંબા અને const.

68
00:03:05,779 --> 00:03:07,820
Const અમે થોડી જોશો
થોડીવાર પછી દરમિયાન.

69
00:03:07,820 --> 00:03:10,830
ટૂંકા અને લાંબા, અમે કદાચ નથી.

70
00:03:10,830 --> 00:03:12,830
>> પરંતુ માત્ર તે ત્યાં ખબર
અન્ય ક્વોલિફાયર છે.

71
00:03:12,830 --> 00:03:14,080
નહિં સહી માત્ર એક નથી.

72
00:03:14,080 --> 00:03:16,596
પરંતુ તે અમે છો માત્ર એક જ છે
હમણાં વિશે વાત કરવા માટે જઈ રહી છે.

73
00:03:16,596 --> 00:03:17,310
તેથી બધા અધિકાર.

74
00:03:17,310 --> 00:03:18,393
તેથી અમે પૂર્ણાંકો આવરી લેવામાં આવ્યાં છે.

75
00:03:18,393 --> 00:03:19,200
શું છે?

76
00:03:19,200 --> 00:03:20,130
>> અક્ષરો.

77
00:03:20,130 --> 00:03:23,620
તેથી અક્ષરો ચલો માટે ઉપયોગ કરવામાં આવે છે
કે એક અક્ષરો સંગ્રહ કરશે.

78
00:03:23,620 --> 00:03:24,850
ચાર પાત્ર માટે ટૂંકા હોય છે.

79
00:03:24,850 --> 00:03:27,870
અને ક્યારેક તમે સાંભળી શકે છે
લોકો કાર, કે ઉચ્ચાર.

80
00:03:27,870 --> 00:03:32,020
>> અક્ષરો હંમેશા એક લાગી તેથી
માત્ર 8 બીટ્સ છે, કે જે મેમરી બાઇટ.

81
00:03:32,020 --> 00:03:35,700
તેથી આ તેઓ માત્ર ફિટ થઈ શકે છે કે જે થાય છે
નકારાત્મક 2 ની રેન્જમાં કિંમતો

82
00:03:35,700 --> 00:03:42,430
સાતમી શક્તિ, અથવા નકારાત્મક 128,
2 7 શક્તિ 1, અથવા 127 ઓછા છે.

83
00:03:42,430 --> 00:03:45,710
>> તે ASCII માટે આભાર, તે હતી
લાંબા સમય પહેલા એક માર્ગ તૈયાર કર્યો

84
00:03:45,710 --> 00:03:50,805
તે હકારાત્મક નંબરો મેપ
વિવિધ પાત્રો 0 127

85
00:03:50,805 --> 00:03:52,182
અમારા બધા કીબોર્ડ પર અસ્તિત્વમાં છે કે જે.

86
00:03:52,182 --> 00:03:54,640
અમે પાછળથી જોશો તેથી
કોર્સ, અને તમે કદાચ પડશે

87
00:03:54,640 --> 00:03:57,700
કેટલાક યાદ આવે
બિંદુ, કેપિટલ A, ઉદાહરણ માટે

88
00:03:57,700 --> 00:04:00,732
અક્ષર કેપિટલ A--
સંખ્યા 65 નકશો.

89
00:04:00,732 --> 00:04:02,940
અને તે માટે કારણ છે
કારણ કે તે શું છે

90
00:04:02,940 --> 00:04:05,490
તે ASCII પ્રમાણભૂત દ્વારા સોંપાયેલ કરવામાં આવી છે.

91
00:04:05,490 --> 00:04:07,850
>> લોઅરકેસ 97 છે.

92
00:04:07,850 --> 00:04:11,900
જ્યારે તમે આ અક્ષર 0
ખરેખર, પાત્ર નથી લખો

93
00:04:11,900 --> 00:04:13,532
સંખ્યા શૂન્ય રજૂ, 48 છે.

94
00:04:13,532 --> 00:04:15,240
તમે એક દંપતિ જાણવા મળશે
આ તરીકે તમે જાઓ.

95
00:04:15,240 --> 00:04:17,990
અને તમે ચોક્કસપણે જરૂર આવવું પડશે
તેમને થોડુંક પછીથી CS50 માં.

96
00:04:17,990 --> 00:04:20,450

97
00:04:20,450 --> 00:04:23,390
>> આગામી મુખ્ય માહિતી પ્રકાર
અપૂર્ણાંક બિંદુ સંખ્યામાં આવે છે.

98
00:04:23,390 --> 00:04:26,100
તેથી અપૂર્ણાંક બિંદુ નંબરો છે
પણ વાસ્તવિક સંખ્યાઓ તરીકે ઓળખાય છે.

99
00:04:26,100 --> 00:04:28,850
તેઓ મૂળભૂત રીતે નંબરો છો કે
તેમને એક દશાંશ બિંદુ છે.

100
00:04:28,850 --> 00:04:33,360
બિંદુ કિંમતો ફ્લોટિંગ
પૂર્ણાંકો જેવા પણ છે

101
00:04:33,360 --> 00:04:36,090
મેમરી 4 બાઇટ્સ અંદર સમાયેલ છે.

102
00:04:36,090 --> 00:04:37,580
હવે અહીં કોઈ ચાર્ટ છે.

103
00:04:37,580 --> 00:04:40,890
કોઈ સંખ્યા રેખા, કારણ કે ત્યાં છે
એક ફ્લોટ ની શ્રેણી વર્ણન

104
00:04:40,890 --> 00:04:44,550
બરાબર સ્પષ્ટ અથવા સાહજિક નથી.

105
00:04:44,550 --> 00:04:47,350
>> તમે કહી તે પૂરતો
સાથે કામ કરવા માટે 32 બિટ્સ હોય છે.

106
00:04:47,350 --> 00:04:49,730
અને તમે એક નંબર હોય તો
ધરાવે છે, જે જેવા પી,

107
00:04:49,730 --> 00:04:55,510
પૂર્ણાંક ભાગ 3, અને ફ્લોટિંગ
બિંદુ ભાગ, અથવા દશાંશ ભાગ 0,14159,

108
00:04:55,510 --> 00:04:58,735
અને તેથી પર, તમે પ્રયત્ન કરવાની જરૂર છે
તેને તમામ પ્રતિનિધિત્વ કરવાનો

109
00:04:58,735 --> 00:05:02,420
પૂર્ણાંક ભાગ અને દશાંશ ભાગ છે.

110
00:05:02,420 --> 00:05:04,550
>> તેથી તમે શું છે કે જે અર્થ કરી શકે છે લાગે છે નથી?

111
00:05:04,550 --> 00:05:08,180
એક વસ્તુ છે કે જે આ બાદ જો
ભાગ અને લાંબા સમય સુધી લાંબા સમય સુધી નહીં

112
00:05:08,180 --> 00:05:10,660
હું ખૂબ જ મોટા હોય તો
પૂર્ણાંક ભાગ, હું નથી શકે છે

113
00:05:10,660 --> 00:05:13,090
તરીકે ચોક્કસ કરી શકાય કરવા માટે સમર્થ હશે
એ દશા ભાગ સાથે.

114
00:05:13,090 --> 00:05:15,280
અને તે ખરેખર છે
એક ફ્લોટ મર્યાદા.

115
00:05:15,280 --> 00:05:17,229
>> ફ્લોટ્સને ચોકસાઇ સમસ્યા હોય છે.

116
00:05:17,229 --> 00:05:19,270
અમે માત્ર 32 બીટ્સ હોય છે
સાથે કામ કરે છે, તેથી અમે કરી શકો છો

117
00:05:19,270 --> 00:05:22,510
અમારા દશાંશ ભાગ સાથે જેથી ચોક્કસ છે.

118
00:05:22,510 --> 00:05:27,300
અમે જરૂરી દશાંશ હોઈ શકે નહિં
100 અથવા 200 અંકો ચોક્કસ ભાગ,

119
00:05:27,300 --> 00:05:29,710
અમે માત્ર છે, કારણ કે
32 બિટ્સ સાથે કામ કરવા માટે.

120
00:05:29,710 --> 00:05:31,590
જેથી એક ફ્લોટ એક મર્યાદા છે.

121
00:05:31,590 --> 00:05:33,590
>> હવે સદનસીબે છે
કહેવાય અન્ય માહિતી પ્રકાર

122
00:05:33,590 --> 00:05:36,530
, જે ડબલ અંશે
આ સમસ્યા સાથે વહેવાર.

123
00:05:36,530 --> 00:05:39,980
ડબલ્સમાં, ફ્લોટ્સ, જેમ પણ ઉપયોગ કરવામાં આવે છે
વાસ્તવિક સંખ્યાઓ, અથવા ફ્લોટિંગ પોઇન્ટ સંગ્રહ

124
00:05:39,980 --> 00:05:40,840
કિંમતો.

125
00:05:40,840 --> 00:05:44,340
આ તફાવત છે
ડબલ્સમાં ડબલ ચોકસાઇ છે.

126
00:05:44,340 --> 00:05:48,177
તેઓ 64 બિટ્સ ફિટ થઈ શકે છે
માહિતી, અથવા આઠ બાઇટ્સ.

127
00:05:48,177 --> 00:05:49,010
કે શું અર્થ છે?

128
00:05:49,010 --> 00:05:51,801
વેલ, તે અમે કરી શકો છો છે ઘણો વધુ
આ બાદ ચિહ્ન સાથે ચોક્કસ.

129
00:05:51,801 --> 00:05:54,830
તેના બદલે સાત PI કર્યા
એક ફ્લોટ સાથે કદાચ સ્થળો,

130
00:05:54,830 --> 00:05:56,710
અમે કદાચ 30 સ્થળોએ તે કરી શકે છે.

131
00:05:56,710 --> 00:05:59,824
એ મહત્વનું છે, તો તમે કરવા માંગો છો શકે છે
તેના બદલે એક ફ્લોટ એક ડબલ ઉપયોગ કરે છે.

132
00:05:59,824 --> 00:06:01,740
મૂળભૂત રીતે, તમે છો, તો
કંઈપણ જ્યાં પર કામ

133
00:06:01,740 --> 00:06:06,540
ખરેખર લાંબા દશાંશ સ્થળ કર્યા
અને ચોકસાઇ ઘણો મહત્વપૂર્ણ છે,

134
00:06:06,540 --> 00:06:08,630
તમે કદાચ કરવા માંગો છો
ડબલ overfloat ઉપયોગ કરે છે.

135
00:06:08,630 --> 00:06:11,250
હવે તમારા કામ મોટા ભાગના માટે
CS50, એક ફ્લોટ માટે પૂરતું છે.

136
00:06:11,250 --> 00:06:15,340
પરંતુ ડબલ્સમાં તરીકે અસ્તિત્વ ધરાવે છે કે ખબર નથી
કંઈક ચોકસાઇ સાથે વ્યવહાર કરવા માટે માર્ગ

137
00:06:15,340 --> 00:06:20,980
તમે 32 વધારાની આપીને સમસ્યા
બિટ્સ તમારા નંબરો માટે સાથે કામ કરવા માટે.

138
00:06:20,980 --> 00:06:23,650
>> હવે આ એક માહિતી પ્રકાર નથી.

139
00:06:23,650 --> 00:06:24,390
આ એક પ્રકાર છે.

140
00:06:24,390 --> 00:06:25,340
અને તે રદબાતલ કહેવાય છે.

141
00:06:25,340 --> 00:06:27,506
અને હું તે વિશે વાત કરું છું
અહીં અમે કદાચ કર્યું કારણ કે

142
00:06:27,506 --> 00:06:29,520
પહેલેથી જ થોડા વખત CS50 માં તે જોવા મળે છે.

143
00:06:29,520 --> 00:06:32,020
અને તમે આશ્ચર્ય પામી થઈ શકે છે
તે શું બધા વિશે છે.

144
00:06:32,020 --> 00:06:33,390
>> તેથી રદબાતલ એક પ્રકાર છે.

145
00:06:33,390 --> 00:06:34,097
તે અસ્તિત્વમાં નથી.

146
00:06:34,097 --> 00:06:35,180
પરંતુ તે એક માહિતી પ્રકાર નથી.

147
00:06:35,180 --> 00:06:39,350
>> અમે પ્રકારની એક ચલ બનાવવા કરી શકો છો
રદબાતલ અને તેને કિંમત સોંપી.

148
00:06:39,350 --> 00:06:42,519
પરંતુ કાર્યો, ઉદાહરણ તરીકે,
રદબાતલ પરત પ્રકાર હોઈ શકે છે.

149
00:06:42,519 --> 00:06:45,060
મૂળભૂત રીતે, તમે એક કાર્ય જુઓ તો
કે રદબાતલ પરત પ્રકાર છે,

150
00:06:45,060 --> 00:06:46,970
તે કિંમત પાછી નથી થાય છે.

151
00:06:46,970 --> 00:06:49,440
તમે એક સામાન્ય વિચાર કરી શકો છો
અમે અત્યાર સુધી ઉપયોગ કર્યો છે કે કાર્ય

152
00:06:49,440 --> 00:06:52,780
CS50 માં એક કિંમત પાછી નથી કે?

153
00:06:52,780 --> 00:06:54,700
>> Printf એક છે.

154
00:06:54,700 --> 00:06:56,820
Printf ખરેખર નથી
તમે કંઈપણ પાછા.

155
00:06:56,820 --> 00:06:59,850
તે કંઈક છાપે
સ્ક્રીન, અને તે મૂળભૂત છે

156
00:06:59,850 --> 00:07:01,650
printf શું કરે છે એક બાજુ અસર.

157
00:07:01,650 --> 00:07:03,620
પરંતુ તે તમે કિંમત પાછા આપી નથી.

158
00:07:03,620 --> 00:07:08,419
તમે પરિણામ અને સ્ટોર મેળવે નથી
કેટલાક ચલ તે પાછળથી તેને વાપરવા માટે.

159
00:07:08,419 --> 00:07:10,710
તે માત્ર કંઈક છાપે
સ્ક્રીન અને તમે પૂર્ણ કરી રહ્યાં છો.

160
00:07:10,710 --> 00:07:14,360
>> તેથી અમે printf કહે છે કે
રદબાતલ કાર્ય છે.

161
00:07:14,360 --> 00:07:16,450
તે કંઇ આપે છે.

162
00:07:16,450 --> 00:07:18,580
>> એક પરિમિતિ યાદી
કાર્ય પણ રદબાતલ કરી શકાય છે.

163
00:07:18,580 --> 00:07:21,410
અને તમે પણ તે જોઈ કર્યું
પણ CS50 માં ખૂબ બીટ છે.

164
00:07:21,410 --> 00:07:22,300
ઈન્ મુખ્ય રદબાતલ.

165
00:07:22,300 --> 00:07:23,260
ઘંટડી કે કરે છે?

166
00:07:23,260 --> 00:07:24,080

167
00:07:24,080 --> 00:07:27,220
મૂળભૂત છે કે શું અર્થ થાય છે,
મુખ્ય કોઈપણ પરિમાણો લેવા નથી.

168
00:07:27,220 --> 00:07:29,520
કોઈ દલીલ છે કે ત્યાં
મુખ્ય પસાર કરો.

169
00:07:29,520 --> 00:07:32,780
હવે પાછળથી આપણે ત્યાં છે તે જોવા મળશે
એક રીતે, મુખ્ય માં દલીલો પસાર કરવા માટે

170
00:07:32,780 --> 00:07:36,189
પરંતુ અત્યાર સુધી અમે કર્યું શું
પૂર્ણાંક મુખ્ય રદબાતલ જોવામાં આવે છે.

171
00:07:36,189 --> 00:07:37,730
મુખ્ય માત્ર કોઇ દલીલો લેવા નથી.

172
00:07:37,730 --> 00:07:40,236
અને તેથી અમે રદબાતલ કહે છે કે તે સ્પષ્ટ કરો.

173
00:07:40,236 --> 00:07:42,110
અમે હમણાં જ ખૂબ જ છે રહ્યાં છો
હકીકત વિશે સ્પષ્ટ

174
00:07:42,110 --> 00:07:44,430
તે કોઇ પણ દલીલો લેવા નથી.

175
00:07:44,430 --> 00:07:47,160
>> તેથી હવે, તે પૂરતો
મૂળભૂત છે કે રદબાતલ કહે

176
00:07:47,160 --> 00:07:50,789
માત્ર એક પ્લેસહોલ્ડર તરીકે સેવા આપવી જોઇએ
તમારા માટે કંઇ તરીકે વિશે વિચારવાનો છે.

177
00:07:50,789 --> 00:07:52,080
તે ખરેખર કંઇ કરવાનું નથી.

178
00:07:52,080 --> 00:07:53,550
અહીં કોઈ વળતર કિંમત થાય છે.

179
00:07:53,550 --> 00:07:54,770
અહીં કોઈ પરિમાણો છે.

180
00:07:54,770 --> 00:07:55,709
તે રદબાતલ છે.

181
00:07:55,709 --> 00:07:57,250
તે કરતાં થોડી વધુ જટિલ છે.

182
00:07:57,250 --> 00:08:00,640
પરંતુ આ માટે પૂરતા હોવા જોઈએ
કોર્સ સારી રીતે ભાગ.

183
00:08:00,640 --> 00:08:05,010
અને આસ્થાપૂર્વક હવે તમે થોડા હોય છે
રદબાતલ શું છે એક ખ્યાલ વધુ બીટ.

184
00:08:05,010 --> 00:08:08,460
>> તે તેથી પાંચ પ્રકારના તમે પડશે
આંતરિક છે કે સી એન્કાઉન્ટર

185
00:08:08,460 --> 00:08:10,670
પરંતુ CS50 અમે પણ એક પુસ્તકાલય છે.

186
00:08:10,670 --> 00:08:13,550
તમે સમાવેશ કરી શકે છે કે જે cs50.h,.

187
00:08:13,550 --> 00:08:15,930
અને તમે પ્રદાન કરશે, જે
બે વધારાના પ્રકારો સાથે

188
00:08:15,930 --> 00:08:18,280
તમે કદાચ રજુ કરવાનો પ્રયત્ન કરીશું કે
તમારા કાર્ય પર વાપરવા માટે,

189
00:08:18,280 --> 00:08:21,210
અથવા માત્ર સામાન્ય રીતે કામ પ્રોગ્રામિંગ.

190
00:08:21,210 --> 00:08:23,030
>> આ પ્રથમ bool છે.

191
00:08:23,030 --> 00:08:26,780
તેથી બુલિયન માહિતી પ્રકાર,
bool, ચલો માટે વપરાય છે

192
00:08:26,780 --> 00:08:28,114
કે જે બુલિયન કિંમત સ્ટોર કરશે.

193
00:08:28,114 --> 00:08:29,863
તમે ક્યારેય સાંભળ્યું કર્યું છે, તો
આ શબ્દ પહેલાં, તમે

194
00:08:29,863 --> 00:08:31,960
બુલિયન તે ખબર પડી શકે
કિંમત માત્ર સક્ષમ છે

195
00:08:31,960 --> 00:08:34,440
બે અલગ અલગ અલગ કિંમતો હોલ્ડિંગ.

196
00:08:34,440 --> 00:08:35,872
સાચા અને ખોટા.

197
00:08:35,872 --> 00:08:37,580
હવે આ ખૂબ લાગે છે
મૂળભૂત, અધિકાર?

198
00:08:37,580 --> 00:08:40,496
આ એક આશ્ચર્યજનક છે કે પ્રકારની છે
તે આંતરિક તરીકે સી અસ્તિત્વમાં નથી.

199
00:08:40,496 --> 00:08:42,640
અને ઘણી આધુનિક ભાષાઓમાં અને,
અલબત્ત, બુલિયનો

200
00:08:42,640 --> 00:08:45,390
પ્રમાણભૂત મૂળભૂત માહિતી પ્રકાર છે.

201
00:08:45,390 --> 00:08:47,192
પરંતુ સી, તેઓ ખરેખર નથી.

202
00:08:47,192 --> 00:08:48,400
પરંતુ અમે તમને તે બનાવી છે.

203
00:08:48,400 --> 00:08:51,910
તમે ક્યારેય બનાવવાની જરૂર હોય તો તેથી
પ્રકાર જેની bool છે ચલ,

204
00:08:51,910 --> 00:08:55,230
માત્ર CS50.h સમાવેશ કરવા માટે ખાતરી કરો
તમારા કાર્યક્રમ શરૂઆતમાં,

205
00:08:55,230 --> 00:08:57,800
અને તમે બનાવવા માટે સમર્થ હશો
આ bool પ્રકાર ચલો.

206
00:08:57,800 --> 00:09:02,095
>> તમે CS50.h સમાવેશ ભૂલી, અને જો
તમે બુલિયન પ્રકારના ચલો વાપરી રહ્યા પ્રારંભ

207
00:09:02,095 --> 00:09:04,970
તમે કેટલીક સમસ્યાઓ અનુભવી શકે
જ્યારે તમે તમારા કાર્યક્રમ કમ્પાઇલ કરી રહ્યાં છો.

208
00:09:04,970 --> 00:09:06,490
તેથી માત્ર તે માટે ચોકી પર હોય છે.

209
00:09:06,490 --> 00:09:11,180
અને કદાચ તમે માત્ર ઠીક કરી શકે છે
cs50.h. સહિત પાઉન્ડ દ્વારા સમસ્યાઓ

210
00:09:11,180 --> 00:09:14,590
>> અન્ય મુખ્ય માહિતી પ્રકાર કે અમે
CS50 પુસ્તકાલય તમારા માટે પૂરી પાડે છે

211
00:09:14,590 --> 00:09:15,670
શબ્દમાળા છે.

212
00:09:15,670 --> 00:09:17,130
તેથી શબ્દમાળા શું છે?

213
00:09:17,130 --> 00:09:18,520
સ્ટ્રીંગ્સ ખરેખર માત્ર શબ્દો છે.

214
00:09:18,520 --> 00:09:20,000
તેઓ અક્ષરો સંગ્રહ છો.

215
00:09:20,000 --> 00:09:20,640
તેઓ શબ્દો છો.

216
00:09:20,640 --> 00:09:21,390
તેઓ વાક્યો છો.

217
00:09:21,390 --> 00:09:22,480
તેઓ ફકરા છો.

218
00:09:22,480 --> 00:09:25,850
પણ, આખા પુસ્તકો હોઈ શકે છે.

219
00:09:25,850 --> 00:09:29,690
>> ખૂબ લાંબા ખૂબ જ ટૂંકા
અક્ષરો શ્રેણી.

220
00:09:29,690 --> 00:09:34,310
તમે શબ્દમાળાઓ વાપરવા માટે જરૂર હોય તો,
ઉદાહરણ તરીકે, એક શબ્દ સંગ્રહ માટે,

221
00:09:34,310 --> 00:09:37,609
માત્ર cs50.h સમાવેશ થાય છે માટે ખાતરી કરો
તમારા કાર્યક્રમ ની શરૂઆતમાં

222
00:09:37,609 --> 00:09:38,900
તેથી જો તમે શબ્દમાળા પ્રકાર ઉપયોગ કરી શકો છો.

223
00:09:38,900 --> 00:09:43,910
અને પછી તમે ચલો બનાવી શકો છો
જેની માહિતી પ્રકાર શબ્દમાળા છે.

224
00:09:43,910 --> 00:09:46,160
હવે પાછળથી દરમિયાન,
અમે પણ છે કે છે કે નહીં તે જોવા મળશે

225
00:09:46,160 --> 00:09:47,752
ક્યાં નથી સમગ્ર વાર્તા.

226
00:09:47,752 --> 00:09:49,460
અમે વસ્તુઓ અનુભવી શકશો
કહેવાય માળખાં,

227
00:09:49,460 --> 00:09:54,249
શું હોઈ શકે જૂથ માટે તમને પરવાનગી આપે છે કે જે
પૂર્ણાંક અને એક એકમ માં શબ્દમાળા.

228
00:09:54,249 --> 00:09:56,290
અને અમે ઉપયોગ કરી શકો છો
કેટલાક હેતુ, જે કદાચ

229
00:09:56,290 --> 00:09:57,750
દરમિયાન પાછળથી હાથમાં આવે છે.

230
00:09:57,750 --> 00:09:59,500
>> અને અમે પણ જાણવા મળશે
વ્યાખ્યાયિત પ્રકારના વિશે,

231
00:09:59,500 --> 00:10:01,720
જે તમે બનાવવા માટે પરવાનગી આપે છે
તમારા પોતાના ડેટા પ્રકારો.

232
00:10:01,720 --> 00:10:03,060
અમે ચિંતા કરવાની જરૂર નથી
હવે તે વિશે.

233
00:10:03,060 --> 00:10:04,550
પરંતુ માત્ર તે ખબર છે કે
ક્ષિતિજ પર કંઈક

234
00:10:04,550 --> 00:10:07,633
આ સમગ્ર ઘણો વધુ છે કે
હું માત્ર તમને જણાવું છું કરતાં પ્રકાર વસ્તુ

235
00:10:07,633 --> 00:10:08,133
હવે.

236
00:10:08,133 --> 00:10:10,591
તેથી હવે અમે એક શીખી કર્યું છે કે
મૂળભૂત માહિતી વિશે થોડુંક

237
00:10:10,591 --> 00:10:14,230
પ્રકારો અને આ CS50 ડેટા પ્રકારો, ચાલો
ચલો સાથે કામ કરવા માટે કેવી રીતે વિશે વાત

238
00:10:14,230 --> 00:10:18,530
અને આ મદદથી તેમને બનાવવા
અમારા કાર્યક્ર ડેટા પ્રકારો.

239
00:10:18,530 --> 00:10:22,670
તમે એક ચલ બનાવવા માંગો છો તો,
તમે શું કરવાની જરૂર બધા બે વસ્તુઓ છે.

240
00:10:22,670 --> 00:10:24,147
>> પ્રથમ, તમે તેને એક પ્રકાર આપવી પડે છે.

241
00:10:24,147 --> 00:10:26,230
તમને જરૂર બીજા વસ્તુ
કરવા માટે તેને એક નામ આપે છે.

242
00:10:26,230 --> 00:10:28,740
તમે તે કર્યું છે અને slapped એકવાર એક
તે લીટી ઓવરને અંતે અર્ધવિરામ,

243
00:10:28,740 --> 00:10:29,830
તમે એક ચલ બનાવી છે.

244
00:10:29,830 --> 00:10:32,370
>> તેથી અહીં બે ઉદાહરણો છે.

245
00:10:32,370 --> 00:10:35,744
પૂર્ણાંક સંખ્યા; ઘરનાં પરચૂરણ કામો પત્ર ;.

246
00:10:35,744 --> 00:10:36,660
હું અહીં શું કર્યું છે?

247
00:10:36,660 --> 00:10:38,110
હું બે ચલો બનાવી છે.

248
00:10:38,110 --> 00:10:40,190
>> ચલ છે, પ્રથમ
નામ નંબર છે.

249
00:10:40,190 --> 00:10:44,830
અને નંબર પૂર્ણાંક હોલ્ડિંગ સક્ષમ છે
તેનો પ્રકાર પૂર્ણાંક છે, કારણ કે કિંમતો લખો.

250
00:10:44,830 --> 00:10:48,040
પત્ર અન્ય એક પરિબળ છે
અક્ષરો કે જે પકડી શકે છે

251
00:10:48,040 --> 00:10:50,240
તેની માહિતી પ્રકાર ઘરનાં પરચૂરણ કામો છે.

252
00:10:50,240 --> 00:10:51,772
>> ખૂબ સરળ, અધિકાર?

253
00:10:51,772 --> 00:10:53,480
તમે જાતે શોધી તો
એક પરિસ્થિતિ જ્યાં

254
00:10:53,480 --> 00:10:56,250
જો તમે બહુવિધ બનાવવાની જરૂર છે
એક જ પ્રકારના ચલો,

255
00:10:56,250 --> 00:10:58,740
તમે માત્ર સ્પષ્ટ કરવાની જરૂર છે
એકવાર પ્રકાર નામ.

256
00:10:58,740 --> 00:11:01,600
પછી માત્ર ઘણા ચલો યાદી
તે પ્રકારના તમને જરૂર તરીકે.

257
00:11:01,600 --> 00:11:04,230
>> તેથી હું ઉદાહરણ માટે, અહીં કરી શકે
કોડ આ ત્રીજી લાઇન માં,

258
00:11:04,230 --> 00:11:07,420
પૂર્ણાંક ઊંચાઈ ;, નવી લાઇન કહે છે.

259
00:11:07,420 --> 00:11:08,291
ઈન્ પહોળાઈ ;.

260
00:11:08,291 --> 00:11:09,290
અને તે પણ કામ કરશે.

261
00:11:09,290 --> 00:11:12,039
હું હજુ પણ બે ચલો કહેવાય છો
ઊંચાઈ અને પહોળાઈ, જેમાં દરેક

262
00:11:12,039 --> 00:11:12,730
એ પૂર્ણાંક છે.

263
00:11:12,730 --> 00:11:16,970
પરંતુ હું, સી વાક્યરચના વસ્તુઓ મંજૂરી છું
એક વાક્ય માં ભેગા કરો.

264
00:11:16,970 --> 00:11:20,230
ઈન્ ઊંચાઈ, પહોળાઈ; તે જ વાત છે.

265
00:11:20,230 --> 00:11:23,900
હું કહેવાય બે ચલો, એક બનાવી છે
પહોળાઈ કહેવાય ઊંચાઈ એક, જે બંને

266
00:11:23,900 --> 00:11:26,730
હોલ્ડિંગ સક્ષમ છે
પૂર્ણાંક પ્રકાર કિંમતો.

267
00:11:26,730 --> 00:11:30,920
>> એ જ રીતે, અહીં હું ત્રણ બનાવી શકો છો
એક જ સમયે બિંદુ કિંમતો ફ્લોટિંગ.

268
00:11:30,920 --> 00:11:33,350
હું કદાચ એક ચલ બનાવી શકો છો
2-- ચોરસ રુટ કહેવાય

269
00:11:33,350 --> 00:11:35,766
જે કદાચ છેવટે કરશે
ફ્લોટિંગ બિંદુ પકડી

270
00:11:35,766 --> 00:11:39,222
ચોરસ કે પ્રતિનિધિત્વ
2-- સ્ક્વેર 3 રુટ અને પાઇ ની રુટ.

271
00:11:39,222 --> 00:11:41,180
હું આ કરી શકે છે
ત્રણ અલગ અલગ લીટીઓ પર.

272
00:11:41,180 --> 00:11:47,690
ફ્લોટ, વર્ગમૂળ 2; વર્ગમૂળ રહેલું
3; PI ફ્લોટ; અને તે પણ કામ કરશે.

273
00:11:47,690 --> 00:11:50,590
>> પરંતુ ફરીથી, હું માત્ર એકત્રિત કરી શકે છે
કોડ એક વાક્ય માં આ.

274
00:11:50,590 --> 00:11:54,050
વસ્તુઓ થોડો બનાવે છે
ટૂંકા તરીકે clunky નથી.

275
00:11:54,050 --> 00:11:57,259
>> હવે સામાન્ય રીતે, તે માત્ર સારી ડિઝાઇન છે
જ્યારે તમે તેને જરૂર એક ચલ જાહેર.

276
00:11:57,259 --> 00:11:59,050
અને અમે થોડી વાત કરીશું
તે વિશે થોડી વધુ

277
00:11:59,050 --> 00:12:00,945
પાછળથી દરમિયાન
ત્યારે અમે અવકાશ ચર્ચા કરો.

278
00:12:00,945 --> 00:12:03,320
તેથી જરૂરી કરવાની જરૂર નથી
તમારા ચલો બધા બનાવવા

279
00:12:03,320 --> 00:12:05,990
કાર્યક્રમ શરૂઆતમાં જે
કેટલાક લોકો છેલ્લા કર્યું હોય શકે છે

280
00:12:05,990 --> 00:12:08,700
અથવા ચોક્કસપણે ખૂબ જ સામાન્ય હતી
કોડિંગ પ્રથા ઘણા વર્ષો પહેલા

281
00:12:08,700 --> 00:12:11,700
સી સાથે કામ જ્યારે તમે માત્ર કદાચ
જ્યારે એક ચલ અધિકાર બનાવવા માંગો છો

282
00:12:11,700 --> 00:12:13,140
તમે તેને જરૂર છે.

283
00:12:13,140 --> 00:12:13,640
બધા અધિકાર.

284
00:12:13,640 --> 00:12:15,150
તેથી અમે ચલો બનાવી છે.

285
00:12:15,150 --> 00:12:16,790
આપણે કઈ રીતે ઉપયોગ કરી શકું?

286
00:12:16,790 --> 00:12:18,650
અમે જાહેર કર્યા પછી
ચલ, અમે જરૂર નથી

287
00:12:18,650 --> 00:12:21,237
ડેટા પ્રકાર સ્પષ્ટ કરવા માટે
કે ચલ હવે.

288
00:12:21,237 --> 00:12:24,070
તમે આવું કરવા હકીકતમાં, જો, તમે કદાચ
કેટલાક વિચિત્ર પરિણામ સાથે અંત

289
00:12:24,070 --> 00:12:25,490
અમે પ્રકારની હવે પર ચળકાટ પડશે.

290
00:12:25,490 --> 00:12:27,365
પરંતુ તે પૂરતો કહે,
વિચિત્ર વસ્તુઓ જોઈ રહ્યા છે

291
00:12:27,365 --> 00:12:30,740
અજાણતા જો તમે રહ્યું શરૂ કરવા માટે
એ જ નામ સાથે ચલો-જાહેર ફરી

292
00:12:30,740 --> 00:12:32,210
ઉપર અને ઉપર.

293
00:12:32,210 --> 00:12:33,882
>> તેથી અહીં હું કોડ ચાર રેખાઓ હોય છે.

294
00:12:33,882 --> 00:12:36,090
અને હું એક દંપતિ છે
માત્ર સૂચવે છે ત્યાં ટિપ્પણીઓ

295
00:12:36,090 --> 00:12:37,840
શું પર ચાલી રહ્યું છે
દરેક વાક્ય માત્ર મદદ કરવા માટે

296
00:12:37,840 --> 00:12:40,520
તમે શું થઈ રહ્યું છે આવેલું મળે છે.

297
00:12:40,520 --> 00:12:41,520
તેથી પૂર્ણાંક સંખ્યા ;.

298
00:12:41,520 --> 00:12:42,520
તમે તે પહેલાં જોયું.

299
00:12:42,520 --> 00:12:44,000
કે ચલ ઘોષણા છે.

300
00:12:44,000 --> 00:12:46,670
>> હવે હું એક ચલ બનાવી છે
છે કે કહેવાય નંબર

301
00:12:46,670 --> 00:12:48,970
પૂર્ણાંક પ્રકારના કિંમતો હોલ્ડિંગ સક્ષમ.

302
00:12:48,970 --> 00:12:50,210
હું તેને જાહેર કર્યું છે.

303
00:12:50,210 --> 00:12:53,770
>> હું સોંપવા છું આગામી વાક્ય
નંબર કિંમત.

304
00:12:53,770 --> 00:12:54,992
નંબર 17 સમકક્ષ હોય છે.

305
00:12:54,992 --> 00:12:55,950
ત્યાં શું થઈ રહ્યું છે?

306
00:12:55,950 --> 00:12:58,880
હું 17 નંબર મૂકી રહ્યો છું
કે ચલ અંદર.

307
00:12:58,880 --> 00:13:02,760
>> હું ક્યારેય પછી છાપે તો તેથી શું
નંબર સમાવિષ્ટો પાછળથી છે,

308
00:13:02,760 --> 00:13:04,030
તેઓ 17 છે મને કહી શકશો.

309
00:13:04,030 --> 00:13:07,030
તેથી હું એક ચલ જાહેર કર્યું છે,
અને પછી હું તેને સોંપેલ છે.

310
00:13:07,030 --> 00:13:10,570
>> અમે આ પ્રક્રિયા પુનરાવર્તન કરી શકો છો
ફરી ચાર રચે અક્ષર સાથે ;.

311
00:13:10,570 --> 00:13:11,640
કે ઘોષણા છે.

312
00:13:11,640 --> 00:13:14,010
પત્ર મૂડી બરાબર
એચ કે એક સોંપણી છે.

313
00:13:14,010 --> 00:13:16,030
ખૂબ સરળ, પણ.

314
00:13:16,030 --> 00:13:18,319
>> હવે આ પ્રક્રિયા કદાચ
પ્રકારની સિલી લાગે છે.

315
00:13:18,319 --> 00:13:20,110
શા માટે આપણે આ કરી રહ્યા છે
કોડ બે રેખાઓ?

316
00:13:20,110 --> 00:13:21,401
તે કરવા માટે એક સારી રીત છે?

317
00:13:21,401 --> 00:13:22,250
હકીકતમાં, ત્યાં છે.

318
00:13:22,250 --> 00:13:24,375
ક્યારેક તમે જોઈ શકો
આ આરંભ કહેવાય છે.

319
00:13:24,375 --> 00:13:28,446
તમે એક ચલ જાહેર કરે છે ત્યારે તે
અને તે જ સમયે એક કિંમત સોંપી.

320
00:13:28,446 --> 00:13:30,320
આ ખરેખર એક સુંદર છે
સામાન્ય વસ્તુ કરવા માટે.

321
00:13:30,320 --> 00:13:32,870
તમે એક ચલ, તમે સામાન્ય રીતે બનાવો, ત્યારે
તે કેટલાક મૂળભૂત કિંમત હોય છે કરવા માંગો છો.

322
00:13:32,870 --> 00:13:34,330
પણ તે 0 અથવા કંઈક હોય તો.

323
00:13:34,330 --> 00:13:36,180
તમે માત્ર તમે તેને નીચેની આપે છે.

324
00:13:36,180 --> 00:13:38,360
>> તમે એક ચલ પ્રારંભ કરી શકે છે.

325
00:13:38,360 --> 00:13:42,320
17 બરાબર નંબર પૂર્ણાંક તરીકે જ છે
ઉપર ઉપર કોડ પ્રથમ બે લીટીઓ.

326
00:13:42,320 --> 00:13:46,829
ચાર અક્ષર એચ તરીકે જ છે બરાબર
ઉપર કોડ ત્રીજા અને ચોથા રેખાઓ.

327
00:13:46,829 --> 00:13:49,620
અહીં સૌથી મહત્વપૂર્ણ takeaway
અમે જાહેર અને સોંપણી કરી રહ્યા હો ત્યારે

328
00:13:49,620 --> 00:13:51,740
અમે કર્યું પછી ચલો છે
તે જાહેર નોટિસ

329
00:13:51,740 --> 00:13:53,700
હું ફરીથી માહિતી પ્રકાર ઉપયોગ રહ્યો નથી.

330
00:13:53,700 --> 00:13:57,916
હું પૂર્ણાંક સંખ્યા પર 17 બરાબર નથી કહી રહ્યો છું
ઉદાહરણ માટે કોડ બીજા વાક્ય.

331
00:13:57,916 --> 00:13:59,290
હું માત્ર નંબર 17 બરાબર કહી રહ્યો છું.

332
00:13:59,290 --> 00:14:02,537
>> ફરીથી, એક ચલ પછી ફરીથી જાહેર
જો તમે પહેલાથી જ તે જીવી શકે છે જાહેર કર્યું

333
00:14:02,537 --> 00:14:03,620
કેટલાક વિચિત્ર પરિણામ છે.

334
00:14:03,620 --> 00:14:05,950
તેથી માત્ર કે ખૂબ કાળજી રાખો.

335
00:14:05,950 --> 00:14:06,660
>> હું ડો લોયડ છું.

336
00:14:06,660 --> 00:14:08,870
અને આ CS50 છે.

337
00:14:08,870 --> 00:14:10,499