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

2
00:00:12,410 --> 00:00:12,830
>> DAVID MALAN: બધા અધિકાર.

3
00:00:12,830 --> 00:00:13,370
પાછા આપનું સ્વાગત છે.

4
00:00:13,370 --> 00:00:16,510
આ CS50 છે, અને આ છે
અઠવાડિયું એક, ચાલુ રાખ્યું.

5
00:00:16,510 --> 00:00:20,050
તેથી અમે પસાર કરવામાં આવ્યા છે એક કારણ
જેમ ટેકનોલોજી આસપાસ

6
00:00:20,050 --> 00:00:24,120
Google ગ્લાસ તેઓ સાથે આવે છે
માટે API તરીકે ઓળખાય છે કંઈક, એક

7
00:00:24,120 --> 00:00:25,980
એપ્લિકેશન પ્રોગ્રામિંગ ઇન્ટરફેસ.

8
00:00:25,980 --> 00:00:28,830
અને આ શું છે તે અર્થ એ થાય કે સાથે છે
અધિકાર ફાઇલો અને અધિકાર સાથે

9
00:00:28,830 --> 00:00:32,850
દસ્તાવેજીકરણ, તમે ખરેખર લખી શકો છો
આ જેવી પણ ઉપકરણો માટે સોફ્ટવેર.

10
00:00:32,850 --> 00:00:36,200
>> અને તેથી અમે તરફ ધ્યાનમાં શું
એક પ્રોજેક્ટ જો સેમેસ્ટર ઓવરને છે,

11
00:00:36,200 --> 00:00:39,310
Google ગ્લાસ, કહે છે, શકે સંડોવતા
અપીલ, આપણે શું કરી શકે છે તે જોવા મળશે

12
00:00:39,310 --> 00:00:42,220
કેટલાક સાથે તમે hooking શરતો
લોન આપનાર હાર્ડવેર તેમજ

13
00:00:42,220 --> 00:00:46,500
જાહેર સુલભ API તમે કરી શકો છો કે જેથી
વાસ્તવમાં સોફ્ટવેર બનાવવાનું શરૂ

14
00:00:46,500 --> 00:00:48,630
કે જ Google ગ્લાસ પર નહીં.

15
00:00:48,630 --> 00:00:51,710
>> અમે રમતા કરવામાં આવ્યા છે કે અન્ય ઉપકરણ
અમે હોઈ શકે વિચાર્યું કે અંતમાં સાથે

16
00:00:51,710 --> 00:00:53,910
સત્ર માતાનો ઓવરને અંતે મજા છે
અહીં આ થોડી વાત.

17
00:00:53,910 --> 00:00:56,860
તે લીપ મોશન કહેવાય છે, અને તમે છો શું છે
જોવા માટે વિશે ટેકનિકલ એક છે

18
00:00:56,860 --> 00:01:00,280
ઉપકરણ માટે જાહેરાત, પરંતુ તે
આ ચોક્કસ શું વાત નથી

19
00:01:00,280 --> 00:01:01,240
ઉપકરણ સક્ષમ છે.

20
00:01:01,240 --> 00:01:05,550
અને તે પણ, મારફતે API સાથે આવે છે
તમે સોફ્ટવેર લખી શકે છે

21
00:01:05,550 --> 00:01:10,545
એક રીતે તમારા પોતાના કોમ્પ્યુટર પર નિયંત્રણ
તદ્દન અહીં આ એક મિનિટની ફિલ્મ ગમે છે.

22
00:01:10,545 --> 00:01:12,070
>> [વિડિઓ પ્લેબેક]

23
00:01:12,070 --> 00:02:08,002

24
00:02:08,002 --> 00:02:08,590
>> [END વિડિઓ પ્લેબેક]

25
00:02:08,590 --> 00:02:11,190
>> તેથી હમણાં, આ ઉપકરણનો થાય છે
થોડી યુએસબી તરીકે અમલ કરી શકાય

26
00:02:11,190 --> 00:02:14,290
તમે તમારી માં પ્લગ કરી શકો છો કે જે કનેક્ટર
કોમ્પ્યુટર, પરંતુ હું નવાઈ નહિ લાગે

27
00:02:14,290 --> 00:02:17,930
અમે આ પ્રકારની હોય છે લાંબા પહેલાં તો
પીસી આગળના જથ્થામાં ટેકનોલોજી

28
00:02:17,930 --> 00:02:20,510
અને મેક્સ તમે કરી શકો છો, કે જેથી ખરેખર,
તેની સાથે વાર્તાલાપ

29
00:02:20,510 --> 00:02:21,650
કે જેવી રીતે.

30
00:02:21,650 --> 00:02:24,250
હકીકતમાં, હું છે, પણ, હું શું કરશો શું વિચાર્યું
હું થોડી નિદર્શન અપ ખેંચાય

31
00:02:24,250 --> 00:02:25,860
કાર્યક્રમ છે કે જે આ સોફ્ટવેર સાથે આવે છે.

32
00:02:25,860 --> 00:02:28,700
તેથી હું થોડી સેન્સર મૂકવામાં કર્યું
મારા લેપટોપ સામે.

33
00:02:28,700 --> 00:02:32,420
>> તમે જોઈ શકો છો અને, તે પહેલેથી જ ખબર
મારા હાથ છે કે ત્યાં

34
00:02:32,420 --> 00:02:33,400
તે નિયંત્રિત.

35
00:02:33,400 --> 00:02:37,900
અને આ બધા અરજી થયેલ છે કરે છે
આ જેમ swimmingly થોડી વસ્તુઓ.

36
00:02:37,900 --> 00:02:41,080
પરંતુ તમે ખરેખર, તે જોઈ શકો છો
હું ત્યાં પાંચ આંગળીઓ હોય છે.

37
00:02:41,080 --> 00:02:44,270
અમે મળી શકે તે બધા 10 કરવું
તમે એક સુઘડ પિયાનો કલ્પના કરી શકો છો

38
00:02:44,270 --> 00:02:45,390
એપ્લિકેશન અથવા જેમ.

39
00:02:45,390 --> 00:02:47,820
તમે વર્ગ પછી આવે માગતા તેથી જો
કે સાથે આજે અને નાટક

40
00:02:47,820 --> 00:02:49,720
વેલ, તમે તમારું સ્વાગત છે.

41
00:02:49,720 --> 00:02:52,930
સત્ર અંત તરફ કે તેથી વધુ પર.

42
00:02:52,930 --> 00:02:54,420
>> તેથી વહીવટી એક દંપતિ
જાહેરાત.

43
00:02:54,420 --> 00:02:58,690
એક, આ શુક્રવાર દ્વારા કલમ કરવું
cs60.net/section ખાતે મધ્યાહન ખાતે.

44
00:02:58,690 --> 00:03:01,260
તે URL કોર્સ માતાનો પર છે
હોમપેજ તરીકે સારી.

45
00:03:01,260 --> 00:03:04,010
આ દરમિયાન, જોકે, supersections
આ રવિવાર નવોદિત આવશે.

46
00:03:04,010 --> 00:03:07,800
Supersections, એક સમય વસ્તુ છે
તે અમને કામ કરવા માટે અમુક સમય લે છે, કારણ કે

47
00:03:07,800 --> 00:03:09,470
બહાર જે જે વિભાગમાં અને જ્યાં છે.

48
00:03:09,470 --> 00:03:12,280
>> આ આગામી રવિવાર, તેથી એક ત્યાં હશો
તે ઓછી આરામદાયક માટે વિભાગ,

49
00:03:12,280 --> 00:03:14,040
તે માટે એક વિભાગ
વધુ આરામદાયક.

50
00:03:14,040 --> 00:03:16,110
અને તમે તે ક્યાંક માં
વચ્ચે જવા માટે સ્વાગત છે

51
00:03:16,110 --> 00:03:17,850
અથવા બંને અથવા બે.

52
00:03:17,850 --> 00:03:19,150
આ બંને ફિલ્માંકન કરવામાં આવશે.

53
00:03:19,150 --> 00:03:22,740
તેઓ કરતાં મોટા સભાગૃહ માં હશો
એક વિભાગ સામાન્ય રીતે સાઇન હશે

54
00:03:22,740 --> 00:03:26,110
પરંતુ અહીં ધ્યેય સાથે તમને સજ્જ છે
સમસ્યા સાથે કેટલાક આરામ, એક સેટ

55
00:03:26,110 --> 00:03:29,910
જો CS50 સાધન સાથે C, આ સાથે
સપ્તાહમાં, તમે શોધવા પણ પહેલાં તમારા

56
00:03:29,910 --> 00:03:31,050
સામાન્ય વિભાગ સોંપણી.

57
00:03:31,050 --> 00:03:34,700
જેથી તમે તમારા ટીએફ અને તમારા નાના પૂરી પડશે
આશરે sectionmates ગ્રુપ

58
00:03:34,700 --> 00:03:36,350
એક સપ્તાહની સમય.

59
00:03:36,350 --> 00:03:38,200
>> ઓફિસ કલાકો દરમિયાન,
ચાલુ કરવામાં આવી છે.

60
00:03:38,200 --> 00:03:41,020
અથવા આજની રાત કે સાંજ તેમને લાભ લેવા છો
તમે ઈચ્છો તો કાલે રાત્રે.

61
00:03:41,020 --> 00:03:43,460
સમસ્યા સમૂહ 0 શુક્રવારે કારણે છે.

62
00:03:43,460 --> 00:03:46,680
આ એક દિવસ પછીથી કરતાં હોય છે
ગુરુવાર નિયમિત સુનિશ્ચિત.

63
00:03:46,680 --> 00:03:50,410
પરંતુ સમસ્યા સમૂહ 1 સાથે, તમે જોશો
તે કેટલાંક ગરમ અપ સમાવે છે

64
00:03:50,410 --> 00:03:52,770
કસરત કે જેની સાથે તમે તમારી જાતને
તમારા વધારો કરી શકે છે

65
00:03:52,770 --> 00:03:54,660
શુક્રવાર ગુરુવાર કેટલા.

66
00:03:54,660 --> 00:03:58,410
સમસ્યા સેટ 1, વચ્ચે, નવોદિત કરશે
કોર્સ વેબસાઈટ આ આવતા પર

67
00:03:58,410 --> 00:04:02,000
શુક્રવાર, તમે સાથે curl કરવા માંગતા હોય તો
હું અંતમાં એક સમય પર એકવાર હતી

68
00:04:02,000 --> 00:04:04,370
તમારા રૂમ માં શુક્રવારે રાત્રે.

69
00:04:04,370 --> 00:04:07,660
>> તેથી cs50.net/appliance સ્થળ છે જ્યાં
તમે CS50 સાધન મળી શકે

70
00:04:07,660 --> 00:04:09,040
અમે સોમવાર પર ઉપયોગ કરવાનું શરૂ કર્યું.

71
00:04:09,040 --> 00:04:10,140
અમે થોડી વધુ આજે તેનો ઉપયોગ કરીશું.

72
00:04:10,140 --> 00:04:14,040
પરંતુ બાકીના સમસ્યા 1 સુયોજિત છે કે જે ખાતરી
સ્પષ્ટીકરણ લઈ જવામાં આવશે

73
00:04:14,040 --> 00:04:16,490
તમને જરૂર ચોક્કસપણે પગલાંઓ
કે ઉપર અને ચાલતું નહીં.

74
00:04:16,490 --> 00:04:22,120
તેથી તે પહેલા કરવાનું વિશે ચિંતા નથી
Pset 1 જો તમે તેના બદલે નથી કરશો તો.

75
00:04:22,120 --> 00:04:22,660
>> બધા અધિકાર.

76
00:04:22,660 --> 00:04:27,180
જેથી અમે સ્રોત કોડ અંતે સોમવારે જોવામાં
પરંતુ નવા સંદર્ભમાં

77
00:04:27,180 --> 00:04:30,895
પ્રોગ્રામિંગ ભાષા છે, એટલે કે સી અને સી,
સ્ક્રેચ વિપરિત, ગ્રાફિકલ નથી.

78
00:04:30,895 --> 00:04:32,270
તે ટુકડાઓ પઝલ નથી.

79
00:04:32,270 --> 00:04:34,450
તે વધુ ઇંગલિશ જેવી વાક્યરચના છે.

80
00:04:34,450 --> 00:04:37,140
અને સામેલ પગલાંઓ એક દંપતિ છે
વાસ્તવમાં લેખન અને ચાલતી માં

81
00:04:37,140 --> 00:04:41,650
કારણ કે સ્રોત ઉપરાંત સી કાર્યક્રમ,
આ જેમ કોડ છે, તમે કંઈક જરૂર

82
00:04:41,650 --> 00:04:42,890
કમ્પાઇલર કહેવાય છે.

83
00:04:42,890 --> 00:04:46,682
અને જનસાધારણ ના નિયમો માં, શું
કમ્પાઇલર અમને માટે શું કરે છે?

84
00:04:46,682 --> 00:04:47,650
યાહ.

85
00:04:47,650 --> 00:04:51,040
>> વિદ્યાર્થી: તે કોડ ફેરવે
તમે 0 સે અને 1 સે લખી છે.

86
00:04:51,040 --> 00:04:51,151
>> DAVID MALAN: ગુડ.

87
00:04:51,151 --> 00:04:53,580
તેથી તે કોડ ફેરવે છે કે
અમે 0 સે અને 1 સે લખો.

88
00:04:53,580 --> 00:04:57,730
તે કહેવાતા સ્રોત કોડ ફેરવે
ઑબ્જેક્ટ કોડ છે, જુએ છે જે બાદમાં

89
00:04:57,730 --> 00:04:59,140
આ જેમ થોડી કંઈક.

90
00:04:59,140 --> 00:05:02,860
અને તે તમારા CPU ની અંદર વિશેષજ્ઞ છે
તમારા કમ્પ્યુટર, કારણ કે આ

91
00:05:02,860 --> 00:05:06,280
તે કમ્પ્યુટર્સ બનાવનાર જે લોકો,
ખબર શું તે સિક્વન્સ

92
00:05:06,280 --> 00:05:07,460
0 સે અને 1 સે અર્થ.

93
00:05:07,460 --> 00:05:08,640
>> કદાચ તે પ્રિન્ટ થાય છે.

94
00:05:08,640 --> 00:05:10,265
કદાચ તે ઉપરાંત થાય છે.

95
00:05:10,265 --> 00:05:11,610
કદાચ તે બાદબાકી થાય છે.

96
00:05:11,610 --> 00:05:13,350
કદાચ જો તે ગ્રાફિક પ્રદર્શિત થાય છે.

97
00:05:13,350 --> 00:05:16,870
બિટ્સ પૂર્વવ્યાખ્યાયિત પેટર્ન હોય છે
વિશ્વમાં અર્થ નક્કી છે કે

98
00:05:16,870 --> 00:05:17,700
અમુક વસ્તુઓ.

99
00:05:17,700 --> 00:05:20,760
પરંતુ આ કોર્સ સૌથી ભાગ માટે,
અમે ઊંચી કક્ષાએ કામ, અને પડશે

100
00:05:20,760 --> 00:05:24,180
અસ્તિત્વ ધરાવે છે કે જે મંજૂર માટે આપણે લેવા પડશે
કે કરી શકો છો કમ્પાઇલર્સ જેવી વસ્તુઓ

101
00:05:24,180 --> 00:05:27,670
અમારા સ્રોત કોડ કાર્ય કરો
જે રીતે અમે માંગો.

102
00:05:27,670 --> 00:05:31,660
>> કાર્યક્રમ જેથી અમે છેલ્લા અઠવાડિયે પ્રથમ લખ્યું
અને પછી જેથી માટે, પોર્ટ શરૂ કર્યું

103
00:05:31,660 --> 00:05:33,920
સી આ ભૂતકાળમાં માટે વાત
સોમવાર, આ હતી.

104
00:05:33,920 --> 00:05:35,700
લીલો ધ્વજ ક્લિક કરો છો, ત્યારે હેલો કહો.

105
00:05:35,700 --> 00:05:37,430
આ કોર્સ હતી,
સ્ક્રેચ લખાયેલા હોય છે.

106
00:05:37,430 --> 00:05:40,710
અને હું એવો દાવો કર્યો હતો કે સમકક્ષ
સી કાર્યક્રમ થોડી જોવામાં

107
00:05:40,710 --> 00:05:41,520
આ કંઈક.

108
00:05:41,520 --> 00:05:45,050
>> તેથી શું અમે પ્રથમ કરવું કરશો વિચાર્યું છે,
ચાલો પ્રથમ અંતે જુએ છે તે સિવાય પીંજવું

109
00:05:45,050 --> 00:05:48,790
નજર, બેશક, તરીકે એકદમ arcane
વાક્યરચના, પરંતુ તમે નોટિસ શરૂ કરશો

110
00:05:48,790 --> 00:05:50,160
અત્યંત ઝડપથી પેટર્ન.

111
00:05:50,160 --> 00:05:53,770
શું અમે પણ આજે કરીશ પૂરી પાડે છે
તમે અમુક માટે માનસિક મોડલ સાથે

112
00:05:53,770 --> 00:05:57,280
પ્રમાણભૂત, કેટલાક પ્રમાણભૂત રચના
પ્રોગ્રામિંગ છે.

113
00:05:57,280 --> 00:06:00,420
અને પછી આપણે ખરેખર અમારા હાથમાં મળશે
તેમજ કેટલાક ઉદાહરણો સાથે ગંદા.

114
00:06:00,420 --> 00:06:04,140
>> તેથી જો તમે તે માટે વધુ આરામદાયક,
ખ્યાલ છે કે આ સપ્તાહ અને પછી આગલું

115
00:06:04,140 --> 00:06:05,940
સપ્તાહ ખૂબ જ સારી રીતે સમીક્ષા એક બીટ હોઈ શકે છે.

116
00:06:05,940 --> 00:06:08,810
પરંતુ ખાસ કરીને જ્યારે હેકર આવૃત્તિ
સમસ્યા સમૂહ 1 પર બહાર જાય છે

117
00:06:08,810 --> 00:06:12,330
શુક્રવારે કોર્સ વેબસાઇટ, મને લાગે છે નથી
તમે ભરો પણ તમે તે મેળવશો

118
00:06:12,330 --> 00:06:15,390
આગામી સપ્તાહ અથવા બે, ઉપર કેટલાક બ્લેન્ક
તમે ક્યારેય વધુ વિચાર કરવાનું શરૂ કરીશું

119
00:06:15,390 --> 00:06:18,410
પડકાર અને અનુભવી
નવી અને નવી વસ્તુઓ.

120
00:06:18,410 --> 00:06:21,310
>> તેથી ચાલો સિવાય આ કાર્યક્રમ પીંજવું
એક સમયે થોડા રેખાઓ.

121
00:06:21,310 --> 00:06:24,140
ખૂબ જ ટોચ પર, અમે શું છે
ટેકનિકલ કહેવાય

122
00:06:24,140 --> 00:06:25,950
preprocessor ડાઈરેક્ટીવ.

123
00:06:25,950 --> 00:06:30,510
આ માત્ર કહે છે કે કોડ કે જે એક વાક્ય છે
એક ફાઈલના સમાવિષ્ટો સમાવેશ કરવા માટે,

124
00:06:30,510 --> 00:06:35,080
- પ્રમાણભૂત હું / એન, પ્રમાણભૂત ઈનપુટ કહેવાય
અથવા, માફ કરશો, પ્રમાણભૂત I / O, સ્ટાન્ડર્ડ

125
00:06:35,080 --> 00:06:38,670
ઇનપુટ / આઉટપુટ. h, અંદર
મારા પોતાના કાર્યક્રમ છે.

126
00:06:38,670 --> 00:06:41,670
>> હું આ લખ્યું હતું જેથી અન્ય શબ્દોમાં, જો
જેવી સાદી લખાણ સંપાદક સાથે કાર્યક્રમ

127
00:06:41,670 --> 00:06:45,260
gedit ની સરળ સમકક્ષ
માઈક્રોસોફ્ટ વર્ડ, જેમ કે કંઈક

128
00:06:45,260 --> 00:06:50,970
સૂચના, # stdio.h સમાવેશ થાય છે, માત્ર છે
કમ્પાઇલર કહી જવા માટે, પડાવી લેવું

129
00:06:50,970 --> 00:06:56,080
કે અન્ય ફાઇલ, stdio.h છે, વિષયવસ્તુ
અને અહીં તેમને પેસ્ટ કરો.

130
00:06:56,080 --> 00:06:57,090
>> હવે, હું શા માટે કાળજી નથી?

131
00:06:57,090 --> 00:07:01,850
અમે આ ફાઈલની અંદર શું છે દાવો હતી
સંગ્રહાયેલ છે જે stdio.h, કહેવાય

132
00:07:01,850 --> 00:07:05,490
ક્યાંક મારી હાર્ડ ડ્રાઈવ પર, અથવા આ
કેસ, ક્યાંક CS50 સાધન છે?

133
00:07:05,490 --> 00:07:06,635
બીજા કોઇએ મને માટે ત્યાં મૂકી.

134
00:07:06,635 --> 00:07:09,910
પરંતુ તે શું છે?

135
00:07:09,910 --> 00:07:13,020
>> અરે વાહ, જેથી તે એક ઘોષણા છે
એક કાર્ય printf કહેવાય છે.

136
00:07:13,020 --> 00:07:17,400
તેથી printf કે કાર્ય યાદ
ડિસ્પ્લે શબ્દો અને અક્ષરો અને

137
00:07:17,400 --> 00:07:20,160
મારા બોલી ખાતે સ્ક્રીન પર નંબરો.

138
00:07:20,160 --> 00:07:21,220
પરંતુ હું તે લખવા ન હતી.

139
00:07:21,220 --> 00:07:22,230
CS50 લખવા ન હતી.

140
00:07:22,230 --> 00:07:26,990
કોઇકે વર્ષ પહેલા તે લખ્યું, અને તેઓ
અનિવાર્યપણે અમને તે માટે રેસીપી આપ્યો

141
00:07:26,990 --> 00:07:29,110
stdio.h તરીકે ઓળખાતી ફાઈલ છે.

142
00:07:29,110 --> 00:07:33,240
કે જેથી પ્રથમ વાક્ય માત્ર મને ઍક્સેસ આપે છે
કાર્યો કરવા માટે કે બીજા કોઈને

143
00:07:33,240 --> 00:07:36,500
વચ્ચે, વર્ષો પહેલાં લખ્યું હતું
જે printf છે.

144
00:07:36,500 --> 00:07:39,450
>> હવે, આગામી રેખા હું મારા તરંગ જઈ રહ્યો
હાથ ઓછામાં ઓછા આગામી સપ્તાહ સુધી, મુ.

145
00:07:39,450 --> 00:07:43,620
પરંતુ હવે, ખબર છે કે ઈન્ મુખ્ય (રદબાતલ હોય)
આ આવશ્યક સમકક્ષ

146
00:07:43,620 --> 00:07:46,310
પીળા પઝલ ભાગ છે જ્યારે
લીલો ધ્વજ ક્લિક કર્યું છે.

147
00:07:46,310 --> 00:07:49,510
વિશ્વમાં, વર્ષ પહેલાં, નક્કી કર્યું કે જો
જો તમે એક કાર્યક્રમ લખી રહ્યાં

148
00:07:49,510 --> 00:07:53,150
સી, તમે શરૂ કહેવાય ભાષા
એક વાક્ય સાથે તમારા કાર્યક્રમ

149
00:07:53,150 --> 00:07:54,410
કે જેવો દેખાય છે.

150
00:07:54,410 --> 00:07:57,650
માત્ર એક સપ્તાહની સમય વિશે, તેને બનાવવા પડશે
અર્થમાં શું ઈન્ રદબાતલ શું છે, છે.

151
00:07:57,650 --> 00:08:00,840
પરંતુ હવે માટે, માત્ર તે લાગે છે
આ પીળા પઝલ ભાગ તરીકે.

152
00:08:00,840 --> 00:08:04,550
>> હવે પછી, આપણે અનુસરીને સર્પાકાર તાણવું છે
અન્ય બંધ સર્પાકાર તાણવું દ્વારા,

153
00:08:04,550 --> 00:08:05,240
તેથી વાત કરવા માટે.

154
00:08:05,240 --> 00:08:07,430
અને અમે આ સમગ્ર જોશો
સી કાર્યક્રમો, તેમજ

155
00:08:07,430 --> 00:08:08,930
જાવાસ્ક્રીપ્ટ અને PHP.

156
00:08:08,930 --> 00:08:11,345
અને આ માત્ર સમાવતા
કોડ ઓફ સંબંધિત રેખાઓ.

157
00:08:11,345 --> 00:08:14,600
ઓપન સર્પાકાર તાણવું અનિવાર્યપણે
અહીં કેટલાક કોડ આવે છે.

158
00:08:14,600 --> 00:08:17,590
અને જે બંધ સર્પાકાર તાણવું,
અન્ય દિશામાં સાંધાનો કોણ નિર્ધારિત કર્યો છે, માત્ર

159
00:08:17,590 --> 00:08:19,920
માટે અર્થ છે કે, તે છે
સંબંધિત કોડ.

160
00:08:19,920 --> 00:08:22,970
>> તેથી આ પ્રથમ માં રસદાર રેખા
કાર્યક્રમ છેલ્લા printf છે

161
00:08:22,970 --> 00:08:25,080
ભાવ-અવતરણ ચિહ્નો પૂરાં કરવાં, હેલો વર્લ્ડ.

162
00:08:25,080 --> 00:08:30,670
અને હું વચ્ચે વસ્તુ કહેવાય
અવતરણ શું છેલ્લા સમય?

163
00:08:30,670 --> 00:08:31,285
તેથી તે સ્ટ્રિંગ છે.

164
00:08:31,285 --> 00:08:35,309
અને શબ્દમાળા માત્ર techie છે
ક્રમ માટે ગાળાની

165
00:08:35,309 --> 00:08:37,169
અક્ષરો, શબ્દ, શબ્દસમૂહ.

166
00:08:37,169 --> 00:08:39,380
એક પણ અક્ષર કરી શકે છે
ડબલ નોંધાયેલા શકાય છે.

167
00:08:39,380 --> 00:08:41,840
પરંતુ તે શૂન્ય ક્રમ છે
અથવા વધુ અક્ષરો.

168
00:08:41,840 --> 00:08:43,650
>> બેકસ્લેશ-n એ, છતાં, લાગે છે
એ બીટ વિચિત્ર.

169
00:08:43,650 --> 00:08:46,290
પરંતુ તે માત્ર કંઈક અર્થ
કમ્પ્યૂટર માટે સરળ.

170
00:08:46,290 --> 00:08:48,060
બેકસ્લેશ-n એ શું છે?

171
00:08:48,060 --> 00:08:48,570
નવી લીટી.

172
00:08:48,570 --> 00:08:52,490
તેથી માત્ર ના ખાસ ક્રમ છે
વિશ્વમાં નિર્ણય લીધો છે કે જે અક્ષરો

173
00:08:52,490 --> 00:08:56,880
અર્થ, જમણી ત્યાં એક રેખા વિરામ મૂકી
કમ્પાઇલર ખરેખર વિચાર છે, કારણ કે

174
00:08:56,880 --> 00:09:02,280
ખૂબ જ, જો તમે સામાન્ય રીતે, ગેરસમજ
સમજણપૂર્વક, પરંતુ ખોટી રીતે, માત્ર

175
00:09:02,280 --> 00:09:04,570
મૂકી કંપની મથાળે સ્પર્શી શરૂ
તમારો કોડ નવી રેખાઓ.

176
00:09:04,570 --> 00:09:07,150
તમે થોડી વધુ જરૂર
બેકસ્લેશ-n એ સાથે સ્પષ્ટ.

177
00:09:07,150 --> 00:09:10,540
>> અને અમે થોડી અન્ય જેમ કે ત્યાં જોશો
ખાસ અક્ષરો માટે પેટર્ન.

178
00:09:10,540 --> 00:09:14,340
હમણાં પૂરતું, તમે ઇચ્છતા હોય તો દેવા માટે તમારી
, એક ખૂણામાં કેસ ભટકવું દિમાગમાં

179
00:09:14,340 --> 00:09:18,080
હું એક પ્રિન્ટ કરવા માગે છે ધારવું
માટે સ્ક્રીન પર બેવડું ભાવ

180
00:09:18,080 --> 00:09:21,840
ગમે તે કારણ હોય, કે લાગે કરશે
થોડી સમસ્યાવાળા, જમણી હોઈ?

181
00:09:21,840 --> 00:09:24,990
કારણ કે હું એક ડબલ ભાવ મૂકવામાં જો
મધ્યમ "હેલ્લો, વિશ્વ," ગમે તે માટે

182
00:09:24,990 --> 00:09:30,120
કારણ, શા માટે છે કે જે લાગતું નથી
સંભવિત સમસ્યાવાળા?

183
00:09:30,120 --> 00:09:32,180
તે સ્ટ્રિંગ તોડે છે.

184
00:09:32,180 --> 00:09:34,700
>> આ કમ્પાઈલર માત્ર એક પ્રોગ્રામ છે.

185
00:09:34,700 --> 00:09:37,210
કમ્પાઇલર જેવા કાર્યક્રમ માત્ર ચાલે છે
નીચે તમારો કોડ ટોચ વાંચવા માટે,

186
00:09:37,210 --> 00:09:37,990
ડાબેથી.

187
00:09:37,990 --> 00:09:41,850
અને જો તેની જગ્યાએ ત્રણ બેવડા અવતરણ જુએ
બે, તેને ખબર જવા નથી

188
00:09:41,850 --> 00:09:45,210
તમે અર્થ જો કે ડાબી વસ્તુ
શબ્દમાળા, અથવા આ વસ્તુ પ્રયત્ન કરીશું

189
00:09:45,210 --> 00:09:46,570
અધિકાર, અથવા સમગ્ર બાબત.

190
00:09:46,570 --> 00:09:50,560
તે અસ્પષ્ટ છે, અને લાક્ષણિક તેથી શું
કમ્પાઇલર શું કરશે માત્ર બહાર ફ્રીક છે,

191
00:09:50,560 --> 00:09:53,710
અને તમે અમુક ભૂલ સંદેશો આપે છે, અને
તમે સમસ્યા સાથે વ્યવહાર કરો.

192
00:09:53,710 --> 00:09:58,120
>> તેથી બેકસ્લેશ-n એ એક નવા અર્થ એ છે કે આપેલ
રેખા, શું હવે તમારા વૃત્તિ કરશે

193
00:09:58,120 --> 00:10:02,610
તમે પણ સમાવેશ થાય છે ઇચ્છતા હોય તો હોઈ શરૂ
ડબલ જેવી વિલક્ષણ કંઈક

194
00:10:02,610 --> 00:10:06,210
આ અન્યથા-નોંધાયેલા ની અંદર ઉદ્ધત
સ્ટ્રિંગ?

195
00:10:06,210 --> 00:10:07,640
બેકસ્લેશ-ડબલ ભાવ.

196
00:10:07,640 --> 00:10:09,630
અને તેથી અમે આ જોશો
ખૂબ પેટર્ન પ્રકારની.

197
00:10:09,630 --> 00:10:12,490
>> તમે થોડી કંઈક કરવા માંગો છો, તો
વિચિત્ર, તમે મળશે કે

198
00:10:12,490 --> 00:10:15,060
ઉકેલો ઘણીવાર પેટર્ન અનુસરે છે,
અને બેકસ્લેશ

199
00:10:15,060 --> 00:10:17,150
એક ભાગી ક્રમ સૂચવે છે.

200
00:10:17,150 --> 00:10:20,320
અને તે માત્ર ખાસ કંઈક અર્થ એ થાય
અમે માં પ્રતિનિધિત્વ કરવાની જરૂર છે

201
00:10:20,320 --> 00:10:21,060
અલગ રીતે.

202
00:10:21,060 --> 00:10:23,830
તમે પ્રતિનિધિત્વ કેવી રીતે માટે
એક બેકસ્લેશ, સારી રીતે, અમે કરીશું

203
00:10:23,830 --> 00:10:24,550
કે પાછા આવો.

204
00:10:24,550 --> 00:10:26,930
પરંતુ જવાબ, પણ, ખરેખર છે
એ બીટ સ્પષ્ટ.

205
00:10:26,930 --> 00:10:31,080
>> તેથી હવે કેટલાક અન્ય પરિચય દો
પ્રોગ્રામિંગ રચના

206
00:10:31,080 --> 00:10:31,915
તમે સ્ક્રેચ માં જોયું કે.

207
00:10:31,915 --> 00:10:34,790
તમે કદાચ મંજૂર માટે ભર્યું છે
જો તમે પહેલાથી જ માં dived કર્યું પહેલેથી જ જો

208
00:10:34,790 --> 00:10:36,060
સમસ્યા 0 સુયોજિત કરો.

209
00:10:36,060 --> 00:10:40,950
પરંતુ હવે સી માં સિન્ટેક્સ પરિચય દો
આ અન્યથા એકદમ સાહજિક માટે

210
00:10:40,950 --> 00:10:42,300
વિચારો, તેમને ઓછામાં ઓછા કેટલાક.

211
00:10:42,300 --> 00:10:45,570
>> તેથી આ એક સ્થિતિ છે કલ્પના અથવા
એક શાખા, જ્યારે અગાઉ અમે

212
00:10:45,570 --> 00:10:49,330
જોવામાં કોડ સાથે તે રજૂ
સ્ક્રેચ માં ડાબી પર આ જેમ -

213
00:10:49,330 --> 00:10:52,200
X વાય કરતાં ઓછી છે, તો પછી જેથી કહી -

214
00:10:52,200 --> 00:10:56,760
તેના બદલે હવે સી - મારા સલ્લી પર ચડાવીને ધાર કાઢવી દો
સરળ કેસ પર -

215
00:10:56,760 --> 00:11:01,235
ખોલો તો અમે માત્ર, કહે જઈ રહ્યાં છો
ફકરા કે વાકયમાં વધારાનાં નિરથક એવાં શબ્દ, પદ કે વાક્ય, કંઈક સાચું છે -

216
00:11:01,235 --> 00:11:04,190
બુલિયન અભિવ્યક્તિ જવા માટે ચાલે છે
હું શરત કહ્યું છે કે જ્યાં -

217
00:11:04,190 --> 00:11:08,170
બંધ ફકરા કે વાકયમાં વધારાનાં નિરથક એવાં શબ્દ, પદ કે વાક્ય, તો પછી શું નથી
તે સર્પાકાર કૌંસ અંદર.

218
00:11:08,170 --> 00:11:11,020
>> તેથી, અહીં પણ, આ સર્પાકાર કૌંસ
સ્ક્રેચ જેવા પ્રકારની છે

219
00:11:11,020 --> 00:11:12,460
યુ આકારની પઝલ ટુકડાઓ.

220
00:11:12,460 --> 00:11:14,890
આ સર્પાકાર કૌંસ અંદર શું નહીં.

221
00:11:14,890 --> 00:11:16,790
આ કિસ્સામાં, સ્લેશ સ્લેશ.

222
00:11:16,790 --> 00:11:19,720
અને આ એક આગળ છે નોટિસ
છે, ન કે બેકસ્લેશ સ્લેશ.

223
00:11:19,720 --> 00:11:21,440
આગળ, આગળ સ્લેશ, સ્લેશ
પ્રોગ્રામ કર્યું જેઓ માટે

224
00:11:21,440 --> 00:11:23,370
પહેલાં, માત્ર અર્થ એ -

225
00:11:23,370 --> 00:11:24,190
તે માત્ર એક ટિપ્પણી છે.

226
00:11:24,190 --> 00:11:26,630
ટિપ્પણી લીટી નથી
કોડના દીઠ સે.

227
00:11:26,630 --> 00:11:30,200
તે માને છે કે જો તમે ઇંગલિશ એક વાક્ય છે
માનવ, તમારા માટે લખ્યું છે

228
00:11:30,200 --> 00:11:33,540
કદાચ માટે કંઈક તમે યાદ
માટે સમજાવવા માટે, તમારા સમજાવવું

229
00:11:33,540 --> 00:11:35,260
બીજા કોઈને, તમારો કોડ શું કરવાનું છે.

230
00:11:35,260 --> 00:11:37,050
તે માત્ર વર્ણનાત્મક ટિપ્પણી છે.

231
00:11:37,050 --> 00:11:40,880
>> હવે, અલબત્ત, અમે બે રીતે કરી શકે છે
એક, ફક્ત આ કરવાથી માર્ગ માં કાંટો

232
00:11:40,880 --> 00:11:43,930
કરવાથી માર્ગ માં ત્રણ માર્ગ કાંટો
આ, અને તમે આ ચાલુ રહેશે તો

233
00:11:43,930 --> 00:11:47,570
પેટર્ન, તમે ચાર માર્ગ હોઈ શકે છે
રસ્તા માં પાંચ માર્ગ, છ માર્ગ ફોર્કનો જો

234
00:11:47,570 --> 00:11:50,150
તમે ખરેખર નિયંત્રિત કરવાની જરૂર
ઘણા શરતો છે.

235
00:11:50,150 --> 00:11:52,010
અને પછી અહીં સમાંતરણ નોટિસ -

236
00:11:52,010 --> 00:11:55,070
, બીજું (શરત), તો (શરત) જો
અને થોડી છે કે માત્ર એક

237
00:11:55,070 --> 00:11:58,010
વિચિત્ર છે, કે જે જો છેલ્લા છે
ફક્ત કે જે બીજા છે.

238
00:11:58,010 --> 00:12:01,170
પરંતુ ફરીથી, આ સમાન છે
કલ્પનાત્મક, અમે કર્યું છે તે

239
00:12:01,170 --> 00:12:04,690
પહેલેથી, છતાં પણ આ વાક્યરચના ચાલશે
માટે વપરાય રહેલી થોડી લે છે.

240
00:12:04,690 --> 00:12:07,730
>> હવે, આ ઉદાહરણમાં, ત્યાં છે
અન્ય કેટલાક વિચિત્ર વાક્યરચના.

241
00:12:07,730 --> 00:12:11,220
અમે, printf ફરીથી ખોલો ફકરા કે વાકયમાં વધારાનાં નિરથક એવાં શબ્દ, પદ કે વાક્ય જુઓ
અને બંધ ફકરા કે વાકયમાં વધારાનાં નિરથક એવાં શબ્દ, પદ કે વાક્ય.

242
00:12:11,220 --> 00:12:13,190
અને અંદર ત્યાં છે
એક નોંધાયેલા સ્ટ્રિંગ.

243
00:12:13,190 --> 00:12:17,060
આ સંદર્ભમાં કૌંસ,
printf છે, ડાબી પર જાઓ

244
00:12:17,060 --> 00:12:18,160
અને જમણી શું?

245
00:12:18,160 --> 00:12:22,190
અમે નોંધાયેલા છે કે શું વર્ણન નથી
વધુ સામાન્ય તરીકે શબ્દમાળા?

246
00:12:22,190 --> 00:12:23,320
>> તેથી તે દલીલ છે.

247
00:12:23,320 --> 00:12:26,620
કોઈપણ સમયે તમે જેમ કાર્ય છે
printf અને પછી એક ઓપન કૌંસ અને

248
00:12:26,620 --> 00:12:30,330
ની અંદર બંધ કૌંસ અને કંઈક
તે, કદાચ જો તે સ્ટ્રિંગ, અથવા એક

249
00:12:30,330 --> 00:12:34,420
પૂર્ણાંક, અથવા અન્ય કંઈપણ બાબત માં
તે કૌંસ કહેવાય છે વચ્ચે

250
00:12:34,420 --> 00:12:35,110
એક દલીલ.

251
00:12:35,110 --> 00:12:37,910
>> અને દલીલ માત્ર પ્રભાવિત
કાર્ય વર્તણૂકને.

252
00:12:37,910 --> 00:12:39,990
આ કિસ્સામાં, તે ખૂબ કેવી રીતે સાફ છે.

253
00:12:39,990 --> 00:12:44,480
x <y માં પસાર થઈ રહી છે તે છે
જેથી એક દલીલ તરીકે, વાત કરવા માટે.

254
00:12:44,480 --> 00:12:47,720
અને printf ચાલે છે
બરાબર કે છાપો.

255
00:12:47,720 --> 00:12:51,590
ચોક્કસ, વ્યક્તિ વર્ષ પહેલા કારણ કે
જેમણે printf કોઈ વિચાર અમલમાં

256
00:12:51,590 --> 00:12:55,000
આપણે માનવીય અનુગામીઓ શું હતા
માટે printf વાપરવા માટે જવાનું.

257
00:12:55,000 --> 00:12:58,610
દલીલો અસ્તિત્વમાં શા માટે છે કે જેથી માટે છે,
એક કાર્ય માતાનો પછી વર્તન અસર

258
00:12:58,610 --> 00:12:59,450
લખેલા આવી છે.

259
00:12:59,450 --> 00:13:00,780
>> હવે, બુલિયન અભિવ્યક્તિ.

260
00:13:00,780 --> 00:13:02,470
અમે સ્ક્રેચ માં પહેલા આ જોઇ છે.

261
00:13:02,470 --> 00:13:06,680
તે સી તમે પણ કરી શકો છો બહાર વળે "અથવા"
તેમને એકસાથે, તેથી વાત કરવા માટે.

262
00:13:06,680 --> 00:13:10,930
બે લંબરૂપ બાર અર્થ એ છે કે આ બ્લોક
કોડ છે, આ આવું, ચાલશે

263
00:13:10,930 --> 00:13:15,350
પ્રથમ શરત સાચી હોય ચલાવો
અથવા બીજો શરત સાચી છે.

264
00:13:15,350 --> 00:13:17,710
અને તમે પૂર્ણ ન શકે, તેમ છતાં
આ સ્ક્રેચ, તમે ખરેખર શકે

265
00:13:17,710 --> 00:13:20,580
સ્ક્રેચ કરીએ, અને તમે પણ કરી શકો છો
અલગ જાતને વ્યક્ત -

266
00:13:20,580 --> 00:13:25,300
જો પ્રથમ શરત અને બીજા
શરત સાચી છે, તો પછી શું નથી

267
00:13:25,300 --> 00:13:27,160
જો સર્પાકાર કૌંસ અંદર.

268
00:13:27,160 --> 00:13:31,210
>> અને માત્ર એક કોરે, કારણ તે છે
ડબલ & "અને" નું ચિહ્ન અને ડબલ

269
00:13:31,210 --> 00:13:34,610
વર્ટિકલ પટ્ટી, અમે આખરે જોશો
કે સિંગલ વર્ટીકલ બાર અને એક

270
00:13:34,610 --> 00:13:38,710
એક & "અને" નું ચિહ્ન ખરેખર અલગ હોય છે
હવે તેથી સી માં, જેનો અર્થ

271
00:13:38,710 --> 00:13:41,840
પ્રતીકો છે કે જે નકલ
ઇરાદાપૂર્વક છે.

272
00:13:41,840 --> 00:13:45,070
>> તેથી, થોડા સમય માતાનો પરિચય દો
સિન્ટેક્સ આ અન્ય બીટ.

273
00:13:45,070 --> 00:13:48,940
આ તદ્દન પર લઈ નથી
શરૂઆતથી, પરંતુ હું દાવો હું કરી શકો છો કે જે

274
00:13:48,940 --> 00:13:55,190
, તો જો બીજા ની કલ્પના અમલ
બીજું, બીજું તો, બીજું વિધાન વાપરી રહ્યા હોય

275
00:13:55,190 --> 00:13:56,760
કંઈક સ્વીચ નિવેદન કહેવાય છે.

276
00:13:56,760 --> 00:14:00,820
અને આ ખરેખર અસ્તિત્વમાં છે એ જ કારણ
, ફક્ત પ્રોગ્રામરને તમે આપી છે,

277
00:14:00,820 --> 00:14:05,470
કેટલાક ઉકેલવાની સહેજ અલગ રીતે
સમસ્યા, છતાં પણ તાર્કિક રીતે તે

278
00:14:05,470 --> 00:14:07,340
તમે કોઈપણ નવા ક્ષમતાઓ આપતું નથી.

279
00:14:07,340 --> 00:14:08,530
>> કે હું આ અર્થ.

280
00:14:08,530 --> 00:14:13,330
તમે સ્વિચ કરો અને પછી એક જગ્યા કહે છે, ત્યારે
અને પછી કૌંસ એક જોડી અંદર

281
00:14:13,330 --> 00:14:14,570
જે એક સમીકરણ જાય -

282
00:14:14,570 --> 00:14:18,010
અને આ થોડી બિન સ્પષ્ટ હોઈ શકે છે
ખાતે પ્રથમ, પરંતુ આ દલીલ નથી

283
00:14:18,010 --> 00:14:20,680
તકનિકી, કારણ કે સ્વીચ
એક કાર્ય છે.

284
00:14:20,680 --> 00:14:24,230
તેથી હવે, માત્ર આપણે ઉપયોગ કરી રહ્યાં છો કે જે ધારે
વિવિધ સ્થળોએ કૌંસ

285
00:14:24,230 --> 00:14:25,250
વિવિધ કારણો માટે.

286
00:14:25,250 --> 00:14:29,310
>> તેથી અભિવ્યક્તિ પર સ્વીચ હું કરી શકો છો એનો અર્થ એ થાય
તે એક ચલ અંદર મૂકવામાં

287
00:14:29,310 --> 00:14:31,350
તે અભિવ્યક્તિ કહે છે કૌંસ.

288
00:14:31,350 --> 00:14:33,090
અને પછી તે ચલ છે -

289
00:14:33,090 --> 00:14:35,400
તે X કહેવાય છે ધારવું છે, અને
તે માત્ર એ પૂર્ણાંક છે -

290
00:14:35,400 --> 00:14:38,900
હું પછી મારા સ્લાઇડ માં ગણાવવું કરી શકો છો
આ જેમ અહીં કંઈક.

291
00:14:38,900 --> 00:14:41,690
X મારા ચલ છે, અને હું તો
કંઈક કરવા માંગો છો, જો X

292
00:14:41,690 --> 00:14:43,480
1 બરાબર, હું કરી શકે છે.

293
00:14:43,480 --> 00:14:46,660
>> હું તેના બદલે કંઈક કરવા માંગો છો, તો
X 2 હોય તો, હું શું કરી શકો છો.

294
00:14:46,660 --> 00:14:50,390
બીજું, હું બીજું કંઈક કરવા માંગો છો
સંપૂર્ણપણે, હું એક મૂળભૂત કેસ હોઈ શકે છે

295
00:14:50,390 --> 00:14:52,750
જે કેસ હું આ અન્ય વસ્તુ નથી.

296
00:14:52,750 --> 00:14:58,730
તેથી તે અર્થમાં તે સમકક્ષ છે
એક્સ, જો બીજું બીજું, 1 બરાબર બરાબર જો

297
00:14:58,730 --> 00:15:01,150
પરંતુ હવે હું આ ઉલ્લેખ માત્ર કારણ કે
અમે તેને ફરીથી જોશો.

298
00:15:01,150 --> 00:15:03,720
પરંતુ હવે માટે, માત્ર તે અસ્તિત્વમાં છે કે જે ખબર.

299
00:15:03,720 --> 00:15:04,220
>> બધા અધિકાર.

300
00:15:04,220 --> 00:15:07,660
તેથી આ છેલ્લા થોડા થોડા વધુ છે
પ્રથમ નજરે ખાતે જટિલ છે, પરંતુ તેઓ કરવું

301
00:15:07,660 --> 00:15:09,385
એકદમ સરળ કંઈક.

302
00:15:09,385 --> 00:15:14,410
સી લૂપ માટે કોડ એક ચંકને છે કે
ફક્ત ફરીથી કંઈક કરે છે અને

303
00:15:14,410 --> 00:15:15,330
ફરી અને ફરી.

304
00:15:15,330 --> 00:15:17,590
અને તે વિશે જ હેરાન વસ્તુ છે
તે થોડી વિસ્મૃત કે છે

305
00:15:17,590 --> 00:15:21,380
આ ચક્રીય જાતને વ્યક્ત કરવા માટે
પર પેટર્ન છે, પરંતુ વિશ્વના પ્રમાણિત

306
00:15:21,380 --> 00:15:22,450
નીચેની રીતે.

307
00:15:22,450 --> 00:15:25,760
>> તમે લૂપ માટે ઉપયોગ કરો છો ત્યારે, તમે પુરો
ફરી કૌંસ એક જોડી.

308
00:15:25,760 --> 00:15:27,570
અને બે semicolons નોટિસ
ત્યાં.

309
00:15:27,570 --> 00:15:34,380
ત્રણ અલગ અલગ તે બે semicolons
ની અંદર વિવિધ હાવભાવ

310
00:15:34,380 --> 00:15:35,020
કૌંસ.

311
00:15:35,020 --> 00:15:37,170
એક કહેવાતા initializations છે.

312
00:15:37,170 --> 00:15:38,830
એક કહેવાતા સ્થિતિ છે.

313
00:15:38,830 --> 00:15:40,210
અને એક કહેવાતા સુધારાઓ છે.

314
00:15:40,210 --> 00:15:43,240
>> અમૂર્ત માં જોવામાં, આ છે
સંપૂર્ણપણે બિન સ્પષ્ટ છે, જેથી માતાનો જોવા દો

315
00:15:43,240 --> 00:15:44,630
એક નક્કર ઉદાહરણ છે.

316
00:15:44,630 --> 00:15:46,720
સ્ક્રેચ અમે વારંવાર બ્લોક હતી.

317
00:15:46,720 --> 00:15:50,670
અને આ બ્લોક કહે છે, 10 વખત પુનરાવર્તન જણાવ્યું હતું કે,
"હેલો, વર્લ્ડ." મારા માટે દાવો દો

318
00:15:50,670 --> 00:15:53,810
હવે, અને અમે આ માટે પાછા આવો, અને પડશે
આ, પણ, વધુ પરિચિત વિચાર કરશે

319
00:15:53,810 --> 00:15:57,345
પહેલાં લાંબા તમે સમકક્ષ સી
આ કોડ કહેવાય કરી શકાય છે -

320
00:15:57,345 --> 00:16:02,320
સ્ટેટમેન્ટ અને એક જગ્યા, એક જોડી માટે એક
કૌંસ માં semicolons નોટિસ

321
00:16:02,320 --> 00:16:05,730
ત્યાં છે, કે જે ત્રણ અલગ અલગ
વસ્તુઓ, પ્રારંભ છે,

322
00:16:05,730 --> 00:16:07,320
શરત, અને સુધારો.

323
00:16:07,320 --> 00:16:08,840
>> અને એક અનુમાન લેવા શું
પ્રથમ કરવાનું છે.

324
00:16:08,840 --> 00:16:10,690
ઈન્ હું = 0.

325
00:16:10,690 --> 00:16:15,120
રફ જનસાધારણ ના નિયમો માં, શું છે
અમને માટે કરી છે કે, કદાચ?

326
00:16:15,120 --> 00:16:15,590
હા છે.

327
00:16:15,590 --> 00:16:19,630
, હું કહેવાય જો તે ચલ જાહેર કરવામાં આવ્યું છે
અને તે શું કિંમત આપ્યા છે?

328
00:16:19,630 --> 00:16:20,220
0.

329
00:16:20,220 --> 00:16:24,280
તેથી તે કહે ચલ બનાવવા છે
હું તે મૂલ્ય 0 સ્ટોર.

330
00:16:24,280 --> 00:16:26,420
કે કહેવાતા આરંભ છે.

331
00:16:26,420 --> 00:16:29,360
>> બધા હક, હવે હું પહેલાં એવો દાવો કર્યો હતો
મધ્યમ વસ્તુ કે, હું

332
00:16:29,360 --> 00:16:31,760
<10, પરિસ્થિતિ છે.

333
00:16:31,760 --> 00:16:32,730
તેથી શું કરવાનું છે?

334
00:16:32,730 --> 00:16:36,560
ઠીક છે, શું માટે લૂપ જ્યારે કરે છે
લૂપ માટે સાથે કાર્યક્રમ ચલાવવામાં આવે છે, છે

335
00:16:36,560 --> 00:16:41,050
કમ્પ્યુટર મારફતે ચાલે છે દર વખતે
આ લૂપ, ઉપરથી નીચે સુધી, ટોચ પર

336
00:16:41,050 --> 00:16:43,740
માત્ર તમે ગાય્ઝ જેવી તળિયે હતી ત્યારે
તમે પોતે જ ગણાય છે અને નીચે બેઠક

337
00:16:43,740 --> 00:16:47,090
ફરી અને ફરી અને ફરી,
કમ્પ્યુટર ચાલુ છે

338
00:16:47,090 --> 00:16:48,560
કે શરત ચેક કરવા.

339
00:16:48,560 --> 00:16:51,140
અને, હું કરતાં ઓછી 10 હોય
તે ફરીથી તે કરીશ.

340
00:16:51,140 --> 00:16:53,100
હું કરતાં ઓછી 10 છે, તો
તે ફરીથી તે કરીશ.

341
00:16:53,100 --> 00:16:55,030
હું દસથી ઓછા છે, તો
તે ફરીથી તે કરીશ.

342
00:16:55,030 --> 00:16:57,330
સૂચવે છે કે એવું લાગે છે કે જેથી
આસ્થાપૂર્વક હું બદલાતી રહે છે.

343
00:16:57,330 --> 00:16:59,010
અન્યથા, અમે અનંત લૂપ છે લેતો.

344
00:16:59,010 --> 00:17:02,590
કારણ કે ખરેખર, હું બદલીને છે
જો અર્ધવિરામ પછી છેલ્લા વસ્તુ ત્યાં

345
00:17:02,590 --> 00:17:05,569
હું + + + + ની અંશે વિસ્મૃત વાક્યરચના છે.

346
00:17:05,569 --> 00:17:07,630
પરંતુ આ કર્યું છે જે તમને તે
પહેલાં, માત્ર અર્થ એ થાય

347
00:17:07,630 --> 00:17:08,609
તદ્દન ખાલી શું?

348
00:17:08,609 --> 00:17:09,730
>> વિદ્યાર્થીઓ: [અવાજો INTERPOSING].

349
00:17:09,730 --> 00:17:10,740
>> DAVID MALAN: હું માટે 1 ઉમેરો.

350
00:17:10,740 --> 00:17:11,819
હું ઈજાફો.

351
00:17:11,819 --> 00:17:13,910
તેથી અમે એક સ્ક્રેચ પઝલ જોયું
તે માટે ભાગ, ખરેખર.

352
00:17:13,910 --> 00:17:18,230
હું + + + +, પરંતુ તે જેવો ન હતી માત્ર
અર્થ, તદ્દન સરળ, આ વધારો

353
00:17:18,230 --> 00:17:24,040
હું 1 દ્વારા તમે આવું દર વખતે કદર છે.

354
00:17:24,040 --> 00:17:26,910
તેથી શાબ્દિક, તમે શરૂ કરો
0 હું પ્રારંભ.

355
00:17:26,910 --> 00:17:29,520
તમે પછી તમારી સ્થિતિ તપાસો.

356
00:17:29,520 --> 00:17:31,070
10 કરતાં ઓછા 0 છે?

357
00:17:31,070 --> 00:17:31,730
હા.

358
00:17:31,730 --> 00:17:32,910
અમે લૂપ દ્વારા જાઓ.

359
00:17:32,910 --> 00:17:35,150
>> હું કોમ્પ્યુટરની દાવો આગામી વસ્તુ
કરવા જઇ રહ્યું છે તે

360
00:17:35,150 --> 00:17:35,910
હું વધારો કરવાનું.

361
00:17:35,910 --> 00:17:37,080
તેથી હું હવે 1.

362
00:17:37,080 --> 00:17:37,940
તે શરત ચકાસે છે.

363
00:17:37,940 --> 00:17:39,290
10 કરતાં ઓછા 1 છે?

364
00:17:39,290 --> 00:17:39,930
કોર્સ છે.

365
00:17:39,930 --> 00:17:41,030
તેથી તે ફરીથી કરે છે.

366
00:17:41,030 --> 00:17:43,580
હું + + + + માટે 2 પછી તે ઇન્ક્રીમેન્ટ.

367
00:17:43,580 --> 00:17:44,610
10 કરતાં ઓછા 2 છે?

368
00:17:44,610 --> 00:17:45,230
હા.

369
00:17:45,230 --> 00:17:46,670
અને ફરી અને ફરી અને ફરી.

370
00:17:46,670 --> 00:17:50,070
અને આખરે, કારણ
વત્તા-plussing, અમે હું 10 બરાબર મેળવવા માટે.

371
00:17:50,070 --> 00:17:51,675
10 કરતાં 10 ઓછા છે?

372
00:17:51,675 --> 00:17:52,990
ઠીક છે, દેખીતી રીતે નથી.

373
00:17:52,990 --> 00:17:55,320
અને જે બિંદુ છે જે
લૂપ માટે માત્ર અટકે.

374
00:17:55,320 --> 00:17:58,320
અને તમે પર વધુ કોડ હોય તો
નીચે સ્ક્રીન નીચે, કમ્પ્યૂટર

375
00:17:58,320 --> 00:18:01,620
તેના બદલે કે કોડ કે જે ચલાવવા માટે પ્રક્રિયા.

376
00:18:01,620 --> 00:18:05,380
>> તેથી ફરીથી, આ ચાલે છે છતાં પણ
જુઓ અને થોડી વિચિત્ર લાગે છે

377
00:18:05,380 --> 00:18:07,830
પ્રથમ, ચોક્કસપણે તમે તે માટે જે
પહેલાં પ્રોગ્રામ નથી, તે

378
00:18:07,830 --> 00:18:11,640
શાબ્દિક કલ્પનાત્મક ઘટાડે
અન્યથા એક ખૂબ જ શું કરવા

379
00:18:11,640 --> 00:18:14,330
સરળ પઝલ
સ્ક્રેચ માં ભાગ.

380
00:18:14,330 --> 00:18:19,130
>> બધા હક, હું વચન આપ્યું છે કે ત્યાં કરશો
સ્ક્રેચ અન્ય analogs છે.

381
00:18:19,130 --> 00:18:20,060
આ એક ખૂબ છે.

382
00:18:20,060 --> 00:18:21,700
અને અમે આ સંક્ષિપ્તમાં છેલ્લા સમય જોયું.

383
00:18:21,700 --> 00:18:23,530
પરંતુ હંમેશા યાદ રાખો
સ્ક્રેચ માં બ્લૉક?

384
00:18:23,530 --> 00:18:25,490
તે માત્ર કાયમ કંઈક કરે છે?

385
00:18:25,490 --> 00:18:27,470
હું તમને અમલ કરી શકે છે એવો દાવો કર્યો હતો
આ રીતે.

386
00:18:27,470 --> 00:18:29,740
અને તમે ખરેખર આ અમલીકરણ કરી શકો છો
અલગ અલગ રીતે એક ટોળું છે.

387
00:18:29,740 --> 00:18:34,260
>> પરંતુ જ્યારે લૂપ માત્ર એક અલગ છે
જાતે વ્યક્ત ઓફ સી રીતે.

388
00:18:34,260 --> 00:18:37,080
દિવસ ઓવરને અંતે તમે ન કરી શકો
જ્યારે લૂપ સાથે કંઈ છે કે તમે

389
00:18:37,080 --> 00:18:38,360
શકતા નથી લૂપ માટે છે.

390
00:18:38,360 --> 00:18:41,430
જેથી તેઓ ઓવરને અંતે છો
વિધેયાત્મક રીતે દિવસ જ.

391
00:18:41,430 --> 00:18:43,840
પરંતુ તે તમે જાતે વ્યક્ત કરવા માટે પરવાનગી આપે છે
થોડી અલગ માં

392
00:18:43,840 --> 00:18:44,850
નીચેની રીતે.

393
00:18:44,850 --> 00:18:49,720
>> આ જ્યારે લૂપ સાથે, તે શું છે
ફરી ચકાસાયેલ અને તે કૌંસ

394
00:18:49,720 --> 00:18:51,050
ફરી અને ફરી.

395
00:18:51,050 --> 00:18:55,100
અને તરત કે અભિવ્યક્તિ ખોટા છે,
પછી લૂપ, ચલાવ્યા સ્ટોપ્સ

396
00:18:55,100 --> 00:18:57,890
અને કમ્પ્યૂટર આગળ
સ્કોર ગમે અન્ય કોડ તમને

397
00:18:57,890 --> 00:18:59,230
તમારી ફાઈલમાં હોય છે.

398
00:18:59,230 --> 00:19:02,180
>> પરંતુ અહીં રસપ્રદ શું છે ચોક્કો
હું શાબ્દિક સાચા લખ્યો છે.

399
00:19:02,180 --> 00:19:06,680
અને સાચું, બુલિયન કિંમત એક પ્રકાર છે
સાચી કે ખોટી મૂલ્ય.

400
00:19:06,680 --> 00:19:09,750
તેથી સાચા ક્યારેય બની શકે છે
હું શાબ્દિક કર્યું ખોટા તો

401
00:19:09,750 --> 00:19:11,970
મારા કાર્યક્રમ તેને હાર્ડ કોડેડ?

402
00:19:11,970 --> 00:19:12,470
આ બોલ પર કોઈ છે.

403
00:19:12,470 --> 00:19:13,730
તે હું આ શું કર્યું કે થોડી વિચિત્ર છે.

404
00:19:13,730 --> 00:19:15,190
પરંતુ સાચા સાચા છે.

405
00:19:15,190 --> 00:19:16,320
આ બોલ પર કોઈ વત્તા-plussing છે.

406
00:19:16,320 --> 00:19:17,820
અહીં ચલો કોઈ ઉપયોગ છે.

407
00:19:17,820 --> 00:19:22,740
હું જ્યારે સાચું હાર્ડ કોડેડ તેથી, કારણ કે આ
લૂપ હંમેશા મૂલ્યાંકન કરવા માટે ચાલુ છે

408
00:19:22,740 --> 00:19:24,090
ફરી અને ફરી અને ફરી.

409
00:19:24,090 --> 00:19:27,660
>> તેથી હેલો વર્લ્ડ કેટલી વખત છે
સ્ક્રીન પર છાપવા માટે ચાલે?

410
00:19:27,660 --> 00:19:28,170
કાયમ.

411
00:19:28,170 --> 00:19:31,980
જો ત્યાં સુધી વખત અનંત નંબર
બેટરી મૃત્યુ પામે છે અથવા અમુક અન્ય બાહ્ય

412
00:19:31,980 --> 00:19:32,730
ઘટના બને છે.

413
00:19:32,730 --> 00:19:35,880
તેથી આ શ્રેષ્ઠ કાર્યક્રમ કદાચ નથી
લખવા માટે છે કારણ કે જો વપરાશકર્તાને

414
00:19:35,880 --> 00:19:38,660
તમારા કાર્યક્રમ છોડી ક્યારેય કરી શકે છે, તે છે
કદાચ શું તમે હેતુ.

415
00:19:38,660 --> 00:19:41,070
>> પરંતુ ક્યારેક, કાર્યક્રમો જોઇએ
અનંત લૂપ છે.

416
00:19:41,070 --> 00:19:44,050
હમણાં પૂરતું, જો તમારી કમ્પ્યુટર છે
તે પર ઘડિયાળ, તે ચોક્કસપણે હશે

417
00:19:44,050 --> 00:19:48,130
તે અપડેટ રાખી નથી તમારી ઘડિયાળ તો સરસ
એક વખત યદ્યપિ કાયમ પોતે,

418
00:19:48,130 --> 00:19:50,500
બીજા કે એકવાર એક મિનિટ અથવા
કે કંઈક.

419
00:19:50,500 --> 00:19:53,690
તેથી પણ અનંત આંટીઓ
તેની જગ્યાએ હોય.

420
00:19:53,690 --> 00:19:54,360
>> બધા અધિકાર.

421
00:19:54,360 --> 00:19:55,190
છેલ્લે, આ એક છે.

422
00:19:55,190 --> 00:19:57,770
અને આ એક થોડુંક અલગ છે
વિધેયાત્મક રીતે, અને અમે પાછા આવો પડશે

423
00:19:57,770 --> 00:19:59,460
આ કદાચ Pset 1 માં.

424
00:19:59,460 --> 00:20:02,370
પરંતુ લૂપ અન્ય પ્રકારના છે
લૂપ જ્યારે આવું કહેવાય.

425
00:20:02,370 --> 00:20:07,100
અને વચ્ચે અહીં જ તફાવત
લૂપ અને કહે છે, જ્યારે જ્યારે લૂપ કરો,

426
00:20:07,100 --> 00:20:11,120
આ પરિસ્થિતિ ચકાસાયેલ છે કે નથી
તમે કોડ ચલાવવા છે, પરંતુ પછી તે પહેલાં

427
00:20:11,120 --> 00:20:12,080
તમે કોડ ચલાવો.

428
00:20:12,080 --> 00:20:15,380
તેથી, જ્યારે માટે ટોચ પર
લૂપ છે, એ શું છે જ્યારે જ્યારે

429
00:20:15,380 --> 00:20:16,560
તળિયે તે ચકાસે છે.

430
00:20:16,560 --> 00:20:21,370
>> અને આ માત્ર અર્થ એ થાય કે જ્યારે લૂપ
સામાન્ય રીતે વધુ વખત ચલાવવા કરશે

431
00:20:21,370 --> 00:20:24,630
અથવા જ્યારે લૂપ કરતાં ઓછા સમયમાં?

432
00:20:24,630 --> 00:20:30,810
સંભવિત વધુ વખત એક નથી કારણ કે
લૂપ સ્પષ્ટ, આવું કહીને છે જ્યારે

433
00:20:30,810 --> 00:20:34,600
માત્ર પછી તમે તપાસો નિર્દેશ
જો પરિસ્થિતિ અંદર

434
00:20:34,600 --> 00:20:35,980
કૌંસ સાચું છે.

435
00:20:35,980 --> 00:20:37,940
>> તેથી અમે ફરી આ જોશો
કદાચ Pset 1 માં.

436
00:20:37,940 --> 00:20:41,150
તમે ક્યારેય અંતે કંઈક કરવા માંગો છો, તો
ઓછો એક વાર અને પછી કદાચ કેટલાક વધુ

437
00:20:41,150 --> 00:20:43,350
વખત, આ એક સારો છે
વાપરવા માટે રચવું.

438
00:20:43,350 --> 00:20:46,970
પરંતુ જ્યારે લૂપ, તેનાથી વિપરિત, ચાલશે
પ્રથમ તેનું સ્થિતિ તપાસો.

439
00:20:46,970 --> 00:20:50,660
અને તે, સી આંટીઓ માટે તે નથી ચોક્કો
જ્યારે, અને આંટીઓ માટે, જ્યારે.

440
00:20:50,660 --> 00:20:54,700
અને ફરી, તેઓ ખૂબ સરસ રીતે પાછા મેપ
આ એક નથી, સિવાય સ્ક્રેચ માટે

441
00:20:54,700 --> 00:20:57,350
તદ્દન સ્ક્રેચ જ એનાલોગ હોય છે.

442
00:20:57,350 --> 00:20:58,880
>> ઠીક છે, તે વિશે, હવે, ચલો?

443
00:20:58,880 --> 00:21:02,600
તેથી આ હું જાહેર ચલ કેવી રીતે
વાક્યરચના અનુસાર બીજા દિવસે.

444
00:21:02,600 --> 00:21:06,440
હું એવો દાવો કર્યો હતો કે જે ઈન્ હતી
પૂર્ણાંક છે.

445
00:21:06,440 --> 00:21:09,690
હું પછી, એક ચલ કહેવાય પ્રતિ હતી
અને પછી, અર્ધવિરામ.

446
00:21:09,690 --> 00:21:11,070
તેથી કોડ કરવાથી આ વાક્ય શું છે?

447
00:21:11,070 --> 00:21:14,540
આ જાહેર, તદ્દન સરળ છે,
એક ચલ -

448
00:21:14,540 --> 00:21:17,940
કમ્પ્યુટર પૂછવા છે, મને આપી
અમુક મેમરી, મને કેટલાક બીટ્સ આપી - માં

449
00:21:17,940 --> 00:21:19,450
જે હું શું સ્ટોર કરી શકો છો?

450
00:21:19,450 --> 00:21:20,300
એક ઈન્.

451
00:21:20,300 --> 00:21:23,570
અને અર્ધવિરામ માત્ર અર્થ એ થાય
કોડ ઓફ લાઇન અંત થાય છે.

452
00:21:23,570 --> 00:21:25,500
>> હવે, બીજી લાઇન સંભવિત છે
ખૂબ guessable.

453
00:21:25,500 --> 00:21:29,710
પ્રતિ = 0 શું છે; કરી?

454
00:21:29,710 --> 00:21:31,690
તે પ્રતિક્રિયારૂપે 0 સોંપવા છે.

455
00:21:31,690 --> 00:21:33,470
અને તેથી આ બીજી બાબત એ છે કે
કે થોડી હેરાન છે

456
00:21:33,470 --> 00:21:34,540
બીજગણિત, કહે છે, વિરુદ્ધ.

457
00:21:34,540 --> 00:21:39,110
બીજગણિત માં, બરાબર સાઇન અર્થ થાય છે, જ્યારે
સમાન, સી, અહીં બરાબર

458
00:21:39,110 --> 00:21:40,470
સાઇન સોંપણી થાય છે.

459
00:21:40,470 --> 00:21:45,380
તેથી તે જમણી બાજુ પર શું મૂકો અર્થ એ થાય
ડાબી પર શું નહીં.

460
00:21:45,380 --> 00:21:49,030
અને અમે બરાબર, અન્ય પ્રતીક જોશો
અમે ખરેખર ચકાસવા માંગો છો, ત્યારે બરાબર

461
00:21:49,030 --> 00:21:50,570
જાત, કંઈક અંશે annoyingly માટે.

462
00:21:50,570 --> 00:21:52,590
>> પરંતુ આ થોડી બિનકાર્યક્ષમ છે.

463
00:21:52,590 --> 00:21:55,090
તે પ્રકારની હું છે કે નકામી છે
એક ચલ જાહેર અને

464
00:21:55,090 --> 00:21:56,110
પછી તે કિંમત આપે છે.

465
00:21:56,110 --> 00:21:59,380
સી ખરેખર અમને આ સરળ કરવા દે છે જેથી
અને માત્ર એક જ સમયે તે બધા નથી.

466
00:21:59,380 --> 00:22:01,330
તમે ચલ જાહેર કરી શકે છે
ડાબી પર.

467
00:22:01,330 --> 00:22:04,590
તમે હજુ પર સોંપણી કરી શકો છો
કે સમાન સાઇન મુકીને અધિકાર

468
00:22:04,590 --> 00:22:05,030
મધ્યમ.

469
00:22:05,030 --> 00:22:08,740
જેથી દિવસ ઓવરને અંતે આ બે છે
સમકક્ષ છે, પરંતુ આ એક, પ્રમાણિકપણે,

470
00:22:08,740 --> 00:22:11,840
કદાચ પ્રવેશ મેળવવા માટે સારી ટેવ છે
જો તે ઓછા છે માત્ર કારણ કે

471
00:22:11,840 --> 00:22:15,040
કોડ છે, તે વાંચવા માટે થોડી સરળ
અને તે માત્ર અપ સખ્ત

472
00:22:15,040 --> 00:22:17,470
તમારો કોડ છે, તેથી વાત કરવા માટે.

473
00:22:17,470 --> 00:22:22,120
>> આમ અત્યાર સુધી આંટીઓ પર કોઈપણ પ્રશ્નો,
ચલો પર, શરતો પર, પર

474
00:22:22,120 --> 00:22:27,001
બુલિયનો, ક્યાં તકનીકી
અથવા કલ્પનાત્મક?

475
00:22:27,001 --> 00:22:28,010
બધા અધિકાર.

476
00:22:28,010 --> 00:22:30,690
તેથી હવે આ આગામી એક નહીં
થોડી વધુ રસપ્રદ.

477
00:22:30,690 --> 00:22:34,790
અને આ હું છેલ્લા મૂકવામાં ઉદાહરણ છે
માત્ર એક સ્ક્રેચ ઉદાહરણ નકશો કે જે સમય

478
00:22:34,790 --> 00:22:35,820
ઉપર સી માટે

479
00:22:35,820 --> 00:22:36,580
>> એક કાર્ય છે.

480
00:22:36,580 --> 00:22:38,110
જનસાધારણ ના નિયમો માં, શું કાર્ય છે?

481
00:22:38,110 --> 00:22:42,900

482
00:22:42,900 --> 00:22:44,350
તમારા જવાબ સાથે bolder હોઈ મળી.

483
00:22:44,350 --> 00:22:45,020
એક કાર્ય શું છે?

484
00:22:45,020 --> 00:22:46,320
>> વિદ્યાર્થી: કંઈક કરે છે.

485
00:22:46,320 --> 00:22:46,780
>> DAVID MALAN: તે શું છે?

486
00:22:46,780 --> 00:22:48,000
>> વિદ્યાર્થી: કંઈક કરે છે.

487
00:22:48,000 --> 00:22:48,710
>> DAVID MALAN: કંઈક કરે છે.

488
00:22:48,710 --> 00:22:49,000
ઠીક.

489
00:22:49,000 --> 00:22:49,590
અમે ત્યાં શરૂ કરી શકશો.

490
00:22:49,590 --> 00:22:51,270
તેથી એક કાર્ય કંઈક કરે છે.

491
00:22:51,270 --> 00:22:55,160
તેથી તે કે કોડ કે જે ભાગ છે
અનિવાર્યપણે અન્યત્ર કે અમલ

492
00:22:55,160 --> 00:22:56,620
ખરેખર કંઈક કરે છે.

493
00:22:56,620 --> 00:23:00,180
હવે, એક કાર્ય વિશે રસપ્રદ શું છે
તે ઇનપુટ લઇ શકે છે,

494
00:23:00,180 --> 00:23:02,710
અને તે આઉટપુટ પેદા કરે છે.

495
00:23:02,710 --> 00:23:05,090
અને દો વાસ્તવમાં લેવા છે
આ પર એક નજર.

496
00:23:05,090 --> 00:23:09,030
>> તેથી ઢાંકપિછોડો પાછળ માણસ
એક ક્ષણ પહેલા ઇરાદાપૂર્વકની હતી.

497
00:23:09,030 --> 00:23:10,320
અહીં અમે એક કોષ્ટક હોય છે.

498
00:23:10,320 --> 00:23:13,010
પરંતુ ધારવું કે આ ખરેખર
એક મોટી બૉક્સ રજૂ કરે છે.

499
00:23:13,010 --> 00:23:14,940
તેથી આ કહેવાતા બ્લેક બોક્સ છે.

500
00:23:14,940 --> 00:23:19,800
અને સામાન્ય રીતે, ડિઝાઇન, કોમ્પ્યુટર માં
વિજ્ઞાન, કાળા બોક્સ માત્ર નો સંદર્ભ લો

501
00:23:19,800 --> 00:23:22,510
કાર્યક્ષમતા ટુકડાઓ કે કોઈને
અમલમાં છે, અને તમે નથી છે

502
00:23:22,510 --> 00:23:26,140
જરૂરી ખબર હોય અથવા તે કેવી રીતે કાળજી
હૂડ નીચે અમલ.

503
00:23:26,140 --> 00:23:28,960
તમે માત્ર કાળજી કે આ કાળા બોક્સ,
અમે હવે એક ફોન શરૂ કરી શકશો કે જે

504
00:23:28,960 --> 00:23:30,730
કાર્ય, કંઈક કરે છે.

505
00:23:30,730 --> 00:23:34,710
>> તેથી, ઉદાહરણ માટે, આ કાળા બોક્સ પર જો
અહીં સ્ટેજ, printf રજૂ કરે છે

506
00:23:34,710 --> 00:23:38,040
કાર્ય, હું અગાઉના ઉદાહરણો પરથી જાણીએ
કે printf લે છે એક અથવા વધુ

507
00:23:38,040 --> 00:23:40,910
દલીલો, અને તે પ્રથમ
દલીલો, જેમ શબ્દમાળા હોવી જોઈએ

508
00:23:40,910 --> 00:23:44,780
"હેલો, વર્લ્ડ." ઠીક છે, હું વ્યક્તિ છું તો
કાર્યક્રમ લખવા, અને હું માંગો છો

509
00:23:44,780 --> 00:23:50,460
printf વાપરવા માટે, હું, ઉદાહરણ તરીકે, કદાચ
અહીં અને ખાલી કાગળ એક ભાગ લેવા

510
00:23:50,460 --> 00:23:55,060
કાળા માર્કર અને તે પર લખી -

511
00:23:55,060 --> 00:23:56,580
હું "વર્લ્ડ" ખોટીજોડણીવાળું -

512
00:23:56,580 --> 00:23:59,560
H-ઇ એલ એલ ઓ.

513
00:23:59,560 --> 00:24:04,220
>> તેથી હું મારા કાળા માર્કર લેવા પડશે અને હું પડશે
પર અને મોટા legibly હું કરી શકો છો, જેમ લખી

514
00:24:04,220 --> 00:24:07,260
આ કાગળ ભાગ, "હેલો, વિશ્વ," અને
હવે હું આ મારા દલીલ છે દાવો.

515
00:24:07,260 --> 00:24:09,740
આ સાથે રજૂ શબ્દમાળા છે
સફેદ કાગળ એક ભાગ.

516
00:24:09,740 --> 00:24:13,030
અને હવે કાર્ય માટે મારા ઇનપુટ
printf આ હોઈ ચાલે છે.

517
00:24:13,030 --> 00:24:18,250
તેથી હું પસાર printf ફોન કરું છું
તે ઇનપુટ તરીકે કે દલીલ.

518
00:24:18,250 --> 00:24:22,110

519
00:24:22,110 --> 00:24:26,740
>> અને હવે, હું કેવી રીતે વ્યક્તિ જે ખબર નથી
printf વર્ષ પહેલાં હતી, પરંતુ લખ્યું

520
00:24:26,740 --> 00:24:31,110
હું તેની દસ્તા કે ખબર નથી
જીવનમાં તેની હેતુ શું હું છાપવાનો છે

521
00:24:31,110 --> 00:24:34,410
તે ઇનપુટ તરીકે પૂરી પાડે છે.

522
00:24:34,410 --> 00:24:40,630
અને તેથી, છતાં પણ આ અમલીકરણ
મને જાણ વિના છે

523
00:24:40,630 --> 00:24:44,170
હૂડ નીચે, હવે
હું ઓહ, તે થાય છે, જુઓ.

524
00:24:44,170 --> 00:24:45,740
તે કંઈક મુદ્રિત છે
સ્ક્રીન પર.

525
00:24:45,740 --> 00:24:49,070
અને હવે, કાર્યક્રમ નિયંત્રિત જો ત્યાં
, કોડ વધુ લીટીઓ હોત હતા

526
00:24:49,070 --> 00:24:51,070
હવે મને પરત આવ્યા છે.

527
00:24:51,070 --> 00:24:52,290
અને તેથી હકીકત કોલ્ટન કે -

528
00:24:52,290 --> 00:24:55,370
તેનું હૃદય આશિર્વાદ હેઠળ અહીં છુપાવી રહ્યું છે
તમે બધા સામે ટેબલ -

529
00:24:55,370 --> 00:24:59,530
મને ખબર નથી કે ઇરાદાપૂર્વકની છે
અને હું કેવી રીતે printf છે કાળજી નથી

530
00:24:59,530 --> 00:25:00,100
અમલ.

531
00:25:00,100 --> 00:25:03,390
હું માત્ર તેના પરથી ફરી, ખબર
તે શું કરે છે દસ્તાવેજીકરણ, અને હું કેવી રીતે

532
00:25:03,390 --> 00:25:05,040
તેને વાપરવા માટે રહેવા છું.

533
00:25:05,040 --> 00:25:09,140
>> હવે, printf વિચાર કરી શકે છે યાદ
થોડી વધુ વ્યવહારદક્ષ.

534
00:25:09,140 --> 00:25:12,220
ફરી, અમે માત્ર વિશે વાત કરી રહ્યા છીએ
સ્ક્રેચ માતાનો સે બ્લોક સમકક્ષ.

535
00:25:12,220 --> 00:25:14,230
પરંતુ હું પણ આ છેલ્લા સમય હતી.

536
00:25:14,230 --> 00:25:17,270
હું મારા હેલ્લો કાર્યક્રમ બનાવવા ઇચ્છતા એક
માત્ર હાર્ડ થોડી વધુ ગતિશીલ અને નથી

537
00:25:17,270 --> 00:25:19,740
કોડ કંઈક "વિશ્વમાં," અને
ચોક્કસપણે નથી હાર્ડ કોડ કંઈક

538
00:25:19,740 --> 00:25:22,520
D-A-V એ હું-D-જેવી મનસ્વી
કાર્યક્રમ માં.

539
00:25:22,520 --> 00:25:27,510
હું તેના અથવા તેણીના માટે વપરાશકર્તા પૂછવા માગતા હતા
નામ, અને પછી કંઈક

540
00:25:27,510 --> 00:25:29,720
તેઓ પૂરી પાડે છે કે જે શબ્દમાળા.

541
00:25:29,720 --> 00:25:32,690
>> તેથી થોડી અલગ કંઈક છે
અહીં. printf, એક ક્ષણ પહેલા,

542
00:25:32,690 --> 00:25:35,860
, ખરેખર, કંઈક છે, પરંતુ હતી તે
મને કંઈપણ પાછા ન હતી.

543
00:25:35,860 --> 00:25:36,020
બરાબર ને?

544
00:25:36,020 --> 00:25:38,910
કોલ્ટન મને ખાવા હાથ ન હતી
બેક, કાગળ પર કોઈ ભાગ.

545
00:25:38,910 --> 00:25:40,320
એક બાજુ અસર માત્ર આવી હતી.

546
00:25:40,320 --> 00:25:44,510
મારી પૂરી "હેલ્લો, વિશ્વ" તરીકે
દલીલ કોલ્ટન માં પરિણમી માટે

547
00:25:44,510 --> 00:25:48,420
એક શબ્દ આડઅસર, કેટલાક શબ્દો,
સ્ક્રીન પર દેખાય છે.

548
00:25:48,420 --> 00:25:51,350
>> getstring, જોકે, થોડો છે
અલગ. getstring પણ છે

549
00:25:51,350 --> 00:25:54,590
કાર્ય છે, પરંતુ તે કેટલાક કિંમત આપે છે.

550
00:25:54,590 --> 00:25:56,370
તે માત્ર એક નથી
સૌંદર્યલક્ષી આડઅસર.

551
00:25:56,370 --> 00:26:00,230
તે વાસ્તવમાં વ્યક્તિ, મને આપે છે
, ફોન અથવા કાર્ય મદદથી

552
00:26:00,230 --> 00:26:01,320
પાછા કંઈક.

553
00:26:01,320 --> 00:26:05,740
તેથી આ કિસ્સામાં, getstring છે
getstring ઓપન સાથે કહેવાય

554
00:26:05,740 --> 00:26:07,510
કૌંસ, બંધ કૌંસ.

555
00:26:07,510 --> 00:26:11,370
Getstring, તેથી લેવા નથી
કોઇપણ દલીલો અથવા ઇનપુટ?

556
00:26:11,370 --> 00:26:12,340
ના, તે નથી, લાગે છે.

557
00:26:12,340 --> 00:26:14,460
જીવન માં તેનો હેતુ છે
માત્ર એક શબ્દમાળા વિચાર.

558
00:26:14,460 --> 00:26:16,910
તે કરતાં વધુ કોઈ વિગત જરૂર છે.

559
00:26:16,910 --> 00:26:20,430
તેથી મને આગળ વધો અને તે ડોળ કરવો દો,
ફરીથી, આ કાળા બોક્સ, printf નથી

560
00:26:20,430 --> 00:26:25,160
પરંતુ getstring, અને વ્યક્તિ મને દો
આ પ્રોગ્રામ લખવા, કૉલ કરો અથવા ઉપયોગ

561
00:26:25,160 --> 00:26:29,720
માત્ર લખીને getstring
બંધ જી ઇ ટી એસ ટી આર આઇ એન-G, ઓપન કૌંસ,

562
00:26:29,720 --> 00:26:32,170
કૌંસ, getstring.

563
00:26:32,170 --> 00:26:36,920
>> હવે, હું કોઈ વિચાર છે કે કેવી રીતે CS50 સ્ટાફ
getstring અમલમાં છે, પરંતુ મને ખબર છે કે

564
00:26:36,920 --> 00:26:41,240
હું લાંબા પૂરતી રાહ જો, તે તેનું શું કરશે
હૂડ નીચે વસ્તુ, કદાચ મદદથી

565
00:26:41,240 --> 00:26:44,940
કેટલાક ચલો, કદાચ કેટલાક મદદથી
શરતો, કદાચ કેટલાક આંટીઓ ઉપયોગ કરીને,

566
00:26:44,940 --> 00:26:48,170
કદાચ કેટલાક કાર્યો ઉપયોગ કરીને,
કદાચ ઉપયોગ કરીને -

567
00:26:48,170 --> 00:26:52,290
માત્ર સ્ટોલ કરવાનો પ્રયાસ - કદાચ મદદથી
કેટલાક અન્ય પ્રોગ્રામિંગ લક્ષણો.

568
00:26:52,290 --> 00:26:55,350
પરંતુ હું લાંબા પૂરતી રાહ જો - વાસ્તવિકતા માં,
કમ્પ્યુટર માં, આ શું થાય

569
00:26:55,350 --> 00:26:56,270
સુપર ફાસ્ટ -

570
00:26:56,270 --> 00:26:59,910
હું લાંબા પૂરતી રાહ નહિં, તો આ કાર્ય
getstring શબ્દમાળા વિચાર ચાલે છે

571
00:26:59,910 --> 00:27:04,060
અનુમાન લખી રહ્યા છે જે વપરાશકર્તા માંથી
બહાર તેમના કીબોર્ડ પર, અને

572
00:27:04,060 --> 00:27:08,090
પછી, તમે getstring કરવામાં આવે છે ત્યારે મેળવવામાં
વપરાશકર્તા તે અક્ષરો

573
00:27:08,090 --> 00:27:14,080
અને તે, એક શબ્દમાળા માં તેમને સ્ટોર
કાર્ય, getstring છે, ચાલે છે

574
00:27:14,080 --> 00:27:17,990
હું છું જે અમુક આઉટપુટ મારા માટે તૈયાર
આ માર્ગ દ્વારા પ્રાપ્ત જવા

575
00:27:17,990 --> 00:27:19,470
સોંપણી ઓપરેટર.

576
00:27:19,470 --> 00:27:25,390
>> અને હું જવા નહિં, તો ખરેખર, આઉટપુટ માં
અહીં, Obosi ઉદારતાપૂર્વક છે

577
00:27:25,390 --> 00:27:29,900
આ જાણ્યા વગર, ભાગ લીધો
આ પર તેમના નામ લખીને, પેશગી

578
00:27:29,900 --> 00:27:33,100
રજૂ થયેલ છે, કે જે ચલ,
શબ્દમાળા.

579
00:27:33,100 --> 00:27:35,640
હવે, સોંપણી ઓપરેટર પણ, એનો અર્થ એ થાય
આ થોડી લાગે શકે છે છતાં

580
00:27:35,640 --> 00:27:38,790
રીડન્ડન્ટ, હું ખરેખર જરૂર પડશે
આ મારી પોતાની નકલ બનાવવા માટે.

581
00:27:38,790 --> 00:27:40,700
ડાબી બાજુ કારણ કે
બાજુ - દેખીતી ભૂલ માટે માફી (માગવી તે)! -

582
00:27:40,700 --> 00:27:45,760
હું આવશ્યક શબ્દમાળા છે કે નોટિસ
ડાબી બાજુ પર નામ.

583
00:27:45,760 --> 00:27:48,280
તેથી હું પણ બનાવવા જઈ રહ્યો છું
મારા પોતાના આ નકલ.

584
00:27:48,280 --> 00:27:50,990
અને આ એક એવું જૂઠાણું સફેદ એક બીટ છે
અમે એક કે બે અઠવાડિયા માં જોશો કારણ કે

585
00:27:50,990 --> 00:27:54,100
શબ્દમાળાઓ ખરેખર ન હોય તે સમય
તેઓ દેખાય છે.

586
00:27:54,100 --> 00:27:56,700
>> પરંતુ હવે, અહીં વળતર કિંમત છે.

587
00:27:56,700 --> 00:28:00,160
અહીં તે મારા પોતાના નકલ પછી
સોંપણી ઓપરેટર મદદથી.

588
00:28:00,160 --> 00:28:01,790
અને હવે, હું આગામી શું માંગો છો?

589
00:28:01,790 --> 00:28:04,080
હવે અમે બીજા પાસે
કોડ બે લાઇન છે.

590
00:28:04,080 --> 00:28:05,640
તેથી હવે હું printf કૉલ કરવા માંગો છો.

591
00:28:05,640 --> 00:28:08,500
કે કાળા હવે ડોળ કરવો ચાલો
બોક્સ હોવા માટે ફરીથી પાછા છે

592
00:28:08,500 --> 00:28:10,210
printf નથી અને getstring.

593
00:28:10,210 --> 00:28:12,200
>> Printf આ સમય ચાલે છે
કેટલા દલીલો લેવા?

594
00:28:12,200 --> 00:28:14,890

595
00:28:14,890 --> 00:28:16,770
તેથી જુઓ, તે બે જેવું છે.

596
00:28:16,770 --> 00:28:18,860
ત્યાં ત્યાં બે અલ્પવિરામ છે, પરંતુ
તે કોમા એક, તે છે

597
00:28:18,860 --> 00:28:20,220
જો અવતરણચિહ્નો ની અંદર.

598
00:28:20,220 --> 00:28:23,190
તેથી પ્રથમ દલીલ શાબ્દિક અર્થ છે
આ હોઈ ચાલે.

599
00:28:23,190 --> 00:28:31,850
H-ઇ એલ એલ ઓ, અલ્પવિરામ, ટકા
ઓ, બેકસ્લેશ-n એ.

600
00:28:31,850 --> 00:28:36,560
અને હવે હું નથી, એક દલીલ પૂરી છું
પરંતુ printf બે દલીલો.

601
00:28:36,560 --> 00:28:39,530
>> અને શું printf સાથે આવું તેવું માનવામાં આવે છે
હું તેમને પાસ આ બે ઇનપુટ્સ પછી

602
00:28:39,530 --> 00:28:42,050
દલીલો તરીકે?

603
00:28:42,050 --> 00:28:45,360
તે બીજા લેવા માટે માનવામાં આવે છે
હું નામ કહેવાય કે જે તેમને છે, તેથી

604
00:28:45,360 --> 00:28:48,660
હું બહાર લખ્યું કાગળ બીજા ભાગ
એક ક્ષણ પહેલાં નામ કહેવામાં આવે છે.

605
00:28:48,660 --> 00:28:53,550
તે કિંમત પર આધારિત છે કે પ્લગ બનશે
જો પ્લેસહોલ્ડર માં કે ચલની,

606
00:28:53,550 --> 00:28:58,310
% S, તેથી ફરી, તે માત્ર એક ક્ષણ ના
સમય, અમે એક બાજુ અસર જોવા મળશે

607
00:28:58,310 --> 00:29:04,180
અમે હવે, જેમાં printf કહેવાય કર્યા
નથી "હેલો, વિશ્વ," પરંતુ "હેલો, જુઓ

608
00:29:04,180 --> 00:29:04,710
Obosi. "

609
00:29:04,710 --> 00:29:08,730
>> તેથી બંને અભિવાદન એક મોટી ગોળ
અમારા સ્વયંસેવકો જાણતા માત્ર એક જેમાંથી

610
00:29:08,730 --> 00:29:12,010
આ શું થઈ રહ્યું આવશે.

611
00:29:12,010 --> 00:29:12,990
બધા અધિકાર.

612
00:29:12,990 --> 00:29:16,480
, કે હતું, તેથી કદાચ, સરળ
ચોક્કસપણે, તમે પહેલેથી જ પરિચિત હો તો

613
00:29:16,480 --> 00:29:20,190
જેમ કે સાથે આસ્થાપૂર્વક તમે ક્યારેય કરશે
કેવી રીતે તે ચોક્કસ દ્રશ્ય ભૂલી

614
00:29:20,190 --> 00:29:21,220
કાર્યો કામ કરે છે.

615
00:29:21,220 --> 00:29:23,000
>> તેથી માત્ર getstring કરતાં વધુ છે.

616
00:29:23,000 --> 00:29:26,020
જો CS50 પુસ્તકાલય ની અંદર, એક છે
કાર્યો સમગ્ર ટોળું, જે તમામ

617
00:29:26,020 --> 00:29:29,510
માત્ર સ્પષ્ટ બનાવવા માટે ખર્ચ કરવામાં આવે છે
અમે આ વિધેયો લખ્યું છે.

618
00:29:29,510 --> 00:29:33,610
ખાસ કરીને, સી, લગભગ દરેક અન્ય
તમે ઉપયોગ કરશો કાર્ય લોઅરકેસ છે.

619
00:29:33,610 --> 00:29:36,190
પરંતુ અમે ઇરાદાપૂર્વક મૂડી અક્ષરો વાપરો
માત્ર બનાવવા માટે સ્પષ્ટ આ કે

620
00:29:36,190 --> 00:29:39,880
અમે પડશે પ્રકારના તાલીમ વ્હીલ્સ છે
માત્ર થોડા અઠવાડિયા માટે વાપરો કે જે

621
00:29:39,880 --> 00:29:42,890
મેળવવાની પ્રક્રિયા સરળ
વપરાશકર્તા ઇનપુટ.

622
00:29:42,890 --> 00:29:46,740
>> આ CS50 પુસ્તકાલય કાંઇ નથી
તમે પોતે દ્વારા નથી કરી શકે છે

623
00:29:46,740 --> 00:29:50,230
માત્ર એક થી સી કોડ મદદથી
oldschool પુસ્તક.

624
00:29:50,230 --> 00:29:53,310
પરંતુ, ફરી, અમે તાલીમ તરીકે તેમને વાપરવા
માત્ર એક દંપતિ માટે પ્રકારના વ્હીલ્સ

625
00:29:53,310 --> 00:29:57,250
અમે છુટકારો મેળવી શકો છો અઠવાડિયા કે તેથી
તમે તરત સમજી શકશો કે જટિલતા

626
00:29:57,250 --> 00:30:00,460
તરીકે કંઈક કરવાની તમારી જાતને
મેળવવામાં તરીકે પ્રમાણમાં સરળ

627
00:30:00,460 --> 00:30:02,080
વપરાશકર્તા ઇનપુટ.

628
00:30:02,080 --> 00:30:05,540
>> તેથી જો તમે ઍક્સેસ હશે ખબર છે કે
, GetChar GetDouble માટે -

629
00:30:05,540 --> 00:30:06,050
બમણો છે.

630
00:30:06,050 --> 00:30:07,050
What's - અને પછી GetFloat.

631
00:30:07,050 --> 00:30:07,600
એક ફ્લોટ શું છે?

632
00:30:07,600 --> 00:30:09,382
ત્યાં શરૂ કરીએ.

633
00:30:09,382 --> 00:30:10,600
>> વિદ્યાર્થી: [અશ્રાવ્ય].

634
00:30:10,600 --> 00:30:10,790
>> DAVID MALAN: હા.

635
00:30:10,790 --> 00:30:12,120
જો તે દશાંશ બિંદુ સાથે નંબર છે.

636
00:30:12,120 --> 00:30:15,930
એક ઈન્ પૂર્ણાંક છે તેથી, જ્યારે જે
9 મારફતે 0 સાથે માત્ર એક નંબર છે,

637
00:30:15,930 --> 00:30:18,940
તેના પુનરાવર્તનો કેટલાક નંબર,
એક ફ્લોટ કંઈક છે

638
00:30:18,940 --> 00:30:20,100
એક દશાંશ બિંદુ સાથે.

639
00:30:20,100 --> 00:30:26,090
અને એક ડબલ, વચ્ચે, એક પણ છે
એક દશાંશ બિંદુ સાથે નંબર છે, પરંતુ વધુ

640
00:30:26,090 --> 00:30:28,160
દશાંશ પછી નંબરો
બિંદુ, સંભવિત.

641
00:30:28,160 --> 00:30:30,040
>> તેથી આપણે આ પહેલાં લાંબા પાછા મેળવી શકશો.

642
00:30:30,040 --> 00:30:34,560
પરંતુ સામાન્ય રીતે, આ પ્રકારના દરેક
ડેટા, ચલો આ પ્રકારના દરેક

643
00:30:34,560 --> 00:30:39,380
અવર્સ જેવા પુસ્તકાલય પાછા આવી શકો છો કે જે
જો તમે વિવિધ નંબરો બીટ્સ ઓફ કરવા માટે ઉપયોગ

644
00:30:39,380 --> 00:30:40,290
માહિતી સ્ટોર કરે છે.

645
00:30:40,290 --> 00:30:43,910
માત્ર અર્થ એ થાય છે કે જે સામાન્ય રીતે એક ચાર,
એક પાત્ર, 8 બીટ્સ ઉપયોગ કરે છે.

646
00:30:43,910 --> 00:30:47,490
અને અમારી સાથે ખરેખર સાતત્યપૂર્ણ છે
સ્વયંસેવકોની બાઇટ છેલ્લા સપ્તાહમાં જે

647
00:30:47,490 --> 00:30:50,410
આવ્યા અને એક રજૂ
એક સમયે ascii અક્ષર.

648
00:30:50,410 --> 00:30:51,850
જેથી ચાર 8 બીટ્સ છે.

649
00:30:51,850 --> 00:30:54,430
>> એક ફ્લોટ હોઈ બને
32 બિટ્સ, ખાસ કરીને.

650
00:30:54,430 --> 00:30:59,230
અને એક ડબલ, તમે કદાચ ધારી શકો, છે
માત્ર વધારે છે, જે વાસ્તવમાં 64 બિટ્સ,,

651
00:30:59,230 --> 00:31:01,360
જે તમે મોટી હોઈ શકે છે જેનો અર્થ એ થાય
નંબરો અથવા વધુ ચોકસાઇ.

652
00:31:01,360 --> 00:31:03,000
પરંતુ ફરી, વધુ કે અન્ય સમયે.

653
00:31:03,000 --> 00:31:06,550
GetLongLong, વચ્ચે, છતાં stupidly
નામ આપ્યું હતું, માત્ર એક ખરેખર છે

654
00:31:06,550 --> 00:31:10,770
બમણી મોટી છે કે પૂર્ણાંક, બમણી
લાંબા, સંભવિત, તરીકે નિયમિત

655
00:31:10,770 --> 00:31:12,940
પૂર્ણાંક, તેના બદલે 32 64 બીટ્સ.

656
00:31:12,940 --> 00:31:14,560
અને અમે ઉપયોગ કરી રહ્યો છું GetString.

657
00:31:14,560 --> 00:31:18,870
>> પરંતુ તે CS50 પુસ્તકાલય, બહાર વળે
અમે જોશો તરીકે જેમાં, અમલીકરણ થયેલ છે

658
00:31:18,870 --> 00:31:23,560
બે ફાઈલોની ફોર્મ છે, જે એક
cs50.h કહેવાય છે, અન્ય બે છે

659
00:31:23,560 --> 00:31:24,770
તે ડેટા પ્રકારો.

660
00:31:24,770 --> 00:31:29,700
બુલિયનો તમે આ કરી શકો છો સી અસ્તિત્વમાં નથી
માત્ર ઉપયોગ કરીને તેમને ઉભી 0 સે અને 1 સે

661
00:31:29,700 --> 00:31:30,850
તમારા કાર્યક્રમો દરમ્યાન.

662
00:31:30,850 --> 00:31:35,500
પરંતુ અમે CS50 લાઇબ્રેરી માં બનાવવામાં આવી છે
આ ચિહ્નો "સાચા" અને "ખોટા"

663
00:31:35,500 --> 00:31:38,580
તમે નથી તેથી 1 અને 0 પ્રતિનિધિત્વ કરવા માટે
હાર્ડ કોડ કંઈક છે

664
00:31:38,580 --> 00:31:39,810
શાબ્દિક 1 અને 0 જેવા.

665
00:31:39,810 --> 00:31:40,980
પરંતુ અમે ફરીથી તે જોશો.

666
00:31:40,980 --> 00:31:42,330
>> સ્ટ્રિંગ, પણ, અસ્તિત્વમાં નથી.

667
00:31:42,330 --> 00:31:44,520
હું તે ઉલ્લેખ કર્યો છે કે શા માટે છે અને તે છે
હવે એક સફેદ જૂઠ એક બીટ.

668
00:31:44,520 --> 00:31:46,660
પરંતુ અમે પાછા કે છાલ પડશે
લાંબા પહેલાં સ્તર.

669
00:31:46,660 --> 00:31:49,540
પરંતુ હવે, એક શબ્દમાળા છે
અક્ષરો ક્રમ.

670
00:31:49,540 --> 00:31:51,790
>> વચ્ચે, સી, તમે ખરેખર
વિવિધ ડેટા પ્રકારો હોય છે.

671
00:31:51,790 --> 00:31:53,200
આ લોઅરકેસ છે નોટિસ.

672
00:31:53,200 --> 00:31:56,960
કાર્યો જેથી તમે એક ક્ષણ પહેલા જોયું
કાર્યો CS50 કે દ્વારા લખવામાં આવે છે

673
00:31:56,960 --> 00:32:02,310
તમે પર પડે છે કે કિંમત આપશે
આ શ્રેણીમાં વિભાજિત.

674
00:32:02,310 --> 00:32:06,730
>> એક દંપતિ ચીટ શીટ્સ માત્ર પ્લાન્ટ માટે
અહીં બીજ. printf માત્ર નથી

675
00:32:06,730 --> 00:32:08,600
જગ્યામાં તરીકે% s ને લે છે.

676
00:32:08,600 --> 00:32:13,490
તે દશાંશ પૂર્ણાંકો માટે% d લે છે
અથવા% i તેમજ કામ કરશે.

677
00:32:13,490 --> 00:32:19,450
% એફ બિંદુ કિંમતો ફ્લોટિંગ છે. % C માટે છે
એક ચાર, તમે માત્ર એક પ્લગ કરવા માંગતા હોય તો

678
00:32:19,450 --> 00:32:23,510
એક preformatted શબ્દમાળા માં પાત્ર
અમે કરી દેવામાં કર્યું છે, જેમ તમે% c નો ઉપયોગ કરી શકો છો.

679
00:32:23,510 --> 00:32:28,490
>> અને, પછી કંઈક અંશે annoyingly,% lld છે
લાંબા, લાંબા દશાંશ પૂર્ણાંક માટે,

680
00:32:28,490 --> 00:32:31,050
જો તમે ખરેખર જરૂર હોય તો કે જે માત્ર અર્થ એ થાય
મોટા નંબર અને તમે કંઈક ઉપયોગ કરી રહ્યાં છો

681
00:32:31,050 --> 00:32:35,450
લાંબા લાંબા, અમે આવો પડશે જે કહેવાય
પાછા pset માં, તમને% lld ઉપયોગ કરી શકો છો

682
00:32:35,450 --> 00:32:40,700
ખરેખર મોટી માં printf, પ્લગ કહેવું
અથવા અહીં તેના બીજા માર્ગ દ્વારા પૂર્ણાંક

683
00:32:40,700 --> 00:32:41,830
અન્ય કેટલાક દલીલ.

684
00:32:41,830 --> 00:32:45,700
>> અને છેલ્લે, હું વચન આપ્યું છે કે
થોડા અન્ય ભાગી છે

685
00:32:45,700 --> 00:32:47,670
printf આધાર આપે છે કે સિક્વન્સ.

686
00:32:47,670 --> 00:32:49,160
અમે બેકસ્લેશ-n એ જોઈ કર્યું.

687
00:32:49,160 --> 00:32:50,510
બેકસ્લેશ-r તમે જોઈ શકો છો.

688
00:32:50,510 --> 00:32:51,780
તે જૂની શાળા વસ્તુ ના ક્રમમાં ગોઠવો છે.

689
00:32:51,780 --> 00:32:55,920
તમે ક્યારેય પ્રત્યક્ષ ટાઇપરાઇટર વર્ષ વાપરેલ હોય તો
પહેલા અને તમે ક્રેન્ક પર ખેંચાય

690
00:32:55,920 --> 00:32:59,810
જેમાં વ્હીલ ફેરવવામાં જ
આ શ્રેણી ખસેડવા, તે પણ ખસેડવામાં

691
00:32:59,810 --> 00:33:03,730
પર પાછા સમગ્ર બાબત બધી રીતે
ડાબી, સારી રીતે, બેકસ્લેશ-r માત્ર

692
00:33:03,730 --> 00:33:06,480
અનિવાર્યપણે તમારા કર્સરને પાછા ફરે છે
લીટી ની શરૂઆત

693
00:33:06,480 --> 00:33:07,830
તે નીચે ખસેડવા વિના.

694
00:33:07,830 --> 00:33:09,780
પરંતુ ફરી, વધુ કે પર,
કદાચ ભવિષ્યમાં.

695
00:33:09,780 --> 00:33:13,670
>> બેકસ્લેશ-કંપની, બેકસ્લેશ-ડબલ ભાવ,
બેકસ્લેશ-બેકસ્લેશ છે

696
00:33:13,670 --> 00:33:16,600
નાના થોડી સમસ્યા માટે ઉકેલ
હું અગાઉ જશ આપ્યો હતો.

697
00:33:16,600 --> 00:33:18,920
અને બેકસ્લેશ -0 ખરેખર છે
તદ્દન રસપ્રદ.

698
00:33:18,920 --> 00:33:21,470
પરંતુ અમે પાછા આવો પડશે
કે લાંબા પહેલા.

699
00:33:21,470 --> 00:33:25,640
>> તેથી CS50, મને હવે જવા દો
ઉપકરણ, અને ખરેખર માતાનો દો એક

700
00:33:25,640 --> 00:33:28,930
ઝડપી ઉદાહરણો એક સાથે હૂંફાળું
અમે પહેલેથી જ છે અને પછી પર ખસેડો હતી

701
00:33:28,930 --> 00:33:31,160
થોડી વધુ જટિલ કંઈક.

702
00:33:31,160 --> 00:33:34,980
હું મારા કાર્યક્રમ ખોલો તેથી જો
gedit કહેવાય -

703
00:33:34,980 --> 00:33:36,840
આ મારા ગ્રાફિકલ સંપાદક છે.

704
00:33:36,840 --> 00:33:38,460
અને હું શું કરી શકો છો -

705
00:33:38,460 --> 00:33:39,820
મને ત્યાં તે વિંડો બંધ કરો દો -

706
00:33:39,820 --> 00:33:42,720
નીચે અહીં આ આયકન માર્ગ દ્વારા,
તળિયે ડાબા gedit,

707
00:33:42,720 --> 00:33:44,170
મેનુ માટે આગામી ખૂણે.

708
00:33:44,170 --> 00:33:48,670
>> હું આગળ જાઓ અને આગળ જતાં, અને છું
કહે છે, માં જ્હોન આ ઉદાહરણ સેવ

709
00:33:48,670 --> 00:33:49,660
હાર્વર્ડના ફોલ્ડર.

710
00:33:49,660 --> 00:33:52,690
જ્હોન હાર્વર્ડના ફોલ્ડર જ તેના ઘર છે
તેમના બધી ફાઈલોને ક્યાં રહો ડિરેક્ટરી

711
00:33:52,690 --> 00:33:53,340
મૂળભૂત દ્વારા.

712
00:33:53,340 --> 00:33:58,410
અને હું આ રૂપમાં સાચવવા માટે જઇ રહ્યો છું
હેલ્લો-0.c નામની એક ફાઇલ.

713
00:33:58,410 --> 00:34:01,260
અને હું માત્ર જેથી આ નામ પસંદ કર્યું તે
પર નમૂના કોડ સાથે લાઇન અપ

714
00:34:01,260 --> 00:34:04,210
કોર્સ વેબસાઈટ અને '
ઑનલાઇન YouTube વિડિઓઝ.

715
00:34:04,210 --> 00:34:06,320
>> તેથી હવે હું શરૂ કરવા જઇ રહ્યો છું
મારી પ્રથમ પ્રોગ્રામ લખવા.

716
00:34:06,320 --> 00:34:08,469
મને સુવાચ્યતા માટે ઝૂમ કરીએ.

717
00:34:08,469 --> 00:34:12,760
અને હું આગળ જાઓ અને ઈન્ કહે જઇ રહ્યો છું
માત્ર જેવી છે જે મુખ્ય રદબાતલ કે,

718
00:34:12,760 --> 00:34:14,900
પીળા પઝલ ભાગ છે કે જે
કાર્યક્રમ શરૂ થાય છે.

719
00:34:14,900 --> 00:34:18,290
હું ઉપર આદત માં મેળવેલ છે
પછી, મારા સર્પાકાર તાણવું ખોલ્યા વર્ષો

720
00:34:18,290 --> 00:34:22,000
પણ તે બંધ છે અને પછી પાછા જતા
હું ફક્ત મારા કોડ મૂકેલ છે

721
00:34:22,000 --> 00:34:24,630
તે મને બધું રાખવામાં મદદ કારણ કે
ખાસ કરીને મારા તરીકે, સંતુલિત

722
00:34:24,630 --> 00:34:25,880
કાર્યક્રમ લાંબા નોંધાયો નહીં.

723
00:34:25,880 --> 00:34:29,239
>> અને હવે, અહીં છે, હું આગળ જવા માટે જઇ રહ્યો છું
અને,, printf કહે છે, અવતરણ ચિહ્નો પૂરાં કરવાં ભાવ

724
00:34:29,239 --> 00:34:34,330
હેલો વર્લ્ડ બેકસ્લેશ-n બંધ કંપની,
બંધ ફકરા કે વાકયમાં વધારાનાં નિરથક એવાં શબ્દ, પદ કે વાક્ય, અર્ધવિરામ.

725
00:34:34,330 --> 00:34:38,100
તેથી હું માત્ર અમે કર્યું બધું પુનરાવર્તન કરું છું
આમ અત્યાર સુધી મંજૂર માટે લઈ આવી છે.

726
00:34:38,100 --> 00:34:39,270
હવે હું બહાર ઝૂમ કરવા જઇ રહ્યો છું.

727
00:34:39,270 --> 00:34:43,030
>> અને નીચે અહીં આ ટર્મિનલ વિન્ડોમાં, શું
હું આ કાળા કરવાની અનુમતિ છું

728
00:34:43,030 --> 00:34:44,389
અને વિન્ડો સફેદ?

729
00:34:44,389 --> 00:34:46,977
હું તે શું માટે ઉપયોગ કરી શકો છો?

730
00:34:46,977 --> 00:34:49,770
તેથી આ હું આદેશો ચલાવો છે અને
જ્યાં હું વસ્તુઓ કમ્પાઇલ કરી શકો છો.

731
00:34:49,770 --> 00:34:50,620
અને હું તેને સરળ રાખવા માટે જઇ રહ્યો છું.

732
00:34:50,620 --> 00:34:52,780
હું એક કાર્યક્રમ નો ઉપયોગ કરવા જઇ રહ્યો છું
મેક તરીકે ઓળખાય છે, જે નથી

733
00:34:52,780 --> 00:34:54,020
ટેકનિકલી કમ્પાઇલર.

734
00:34:54,020 --> 00:34:56,360
આ કમ્પાઈલર માતાનો કહેવાય રણકાર, પરંતુ
અમે તે પાછા આવો પડશે

735
00:34:56,360 --> 00:34:57,190
સપ્તાહ કે બે ટાઇમ.

736
00:34:57,190 --> 00:35:03,410
>> હવે માટે, હું માત્ર બનાવવા લખો જઈ રહ્યો
હેલ્લો -0, પરંતુ તમે તે હતા

737
00:35:03,410 --> 00:35:07,050
તમારા મનમાં શું છે તે ફક્ત હું સરખાવીને
હું લખ્યો છે જોઇએ શું ટાઈપ કરી શકે છે

738
00:35:07,050 --> 00:35:10,180
હું હતી કે પહેલેથી જ ખબર
અહીં કંઇક ખોટું.

739
00:35:10,180 --> 00:35:12,160
હવે, કેટલાક ભૂલો સ્પષ્ટ છે.

740
00:35:12,160 --> 00:35:16,742
હું પણ તેઓ કોઇ છે, શું જોવા પહેલાં
હું ખોટું શું કર્યું માટે વિચારો?

741
00:35:16,742 --> 00:35:18,590
>> વિદ્યાર્થીઓ: [અવાજો INTERPOSING].

742
00:35:18,590 --> 00:35:18,840
>> DAVID MALAN: હા.

743
00:35:18,840 --> 00:35:20,640
હું પુસ્તકાલયમાં હેડર ફાઈલ ગુમ છું.

744
00:35:20,640 --> 00:35:24,240
આ. ક કોઈપણ ફાઈલો હેડર કહેવામાં આવે છે
ફાઈલો, અને તેઓ સામૂહિક

745
00:35:24,240 --> 00:35:25,680
પુસ્તકાલયો કહેવાય વસ્તુઓ અનુસરે છે.

746
00:35:25,680 --> 00:35:28,030
પુસ્તકાલયો માત્ર કોડ હિસ્સામાં છે
અન્ય લોકો લખ્યું છે.

747
00:35:28,030 --> 00:35:32,140
પ્રમાણભૂત [જેથી? હું?] પુસ્તકાલય છે
કોડ સમાવતી ફાઇલો સંગ્રહ

748
00:35:32,140 --> 00:35:33,330
અન્ય લોકો લખ્યું છે.

749
00:35:33,330 --> 00:35:34,820
>> તેથી હું કે ગુમ છું.

750
00:35:34,820 --> 00:35:36,520
તેથી શા માટે હું એક ભૂલ આવી રહ્યું છે?

751
00:35:36,520 --> 00:35:40,840
ઠીક છે, મને બેક અપ માં સ્ક્રોલ દો
અહીં મારા ટર્મિનલ વિન્ડોમાં.

752
00:35:40,840 --> 00:35:44,310
અને કમનસીબે, સી, ઘણો તરીકે
ખાસ કરીને પ્રોગ્રામિંગ ભાષાઓ,

753
00:35:44,310 --> 00:35:47,830
તે ભૂલ, તમે બધા નવા તો
સંદેશા ચોક્કસ હોય છે, પરંતુ તેઓ પણ છો

754
00:35:47,830 --> 00:35:48,620
તદ્દન વિસ્મૃત.

755
00:35:48,620 --> 00:35:51,720
અને અહીં ભૂલ, લાલ છે,
"સર્વથા જાહેર પુસ્તકાલય કાર્ય

756
00:35:51,720 --> 00:35:57,660
printf પ્રકાર સાથે, "અને પછી તે સ્ક્રોલ
આગામી વાક્ય, "ઈન્ const ચાર *,

757
00:35:57,660 --> 00:36:00,220
... "તે માત્ર ખરેખર નહીં
ઝડપથી જબરજસ્ત.

758
00:36:00,220 --> 00:36:04,420
>> પરંતુ જો તમે,, શું કરવાનું શરૂ કરીશું
ફરીથી, આ બધા નવા છે, માત્ર

759
00:36:04,420 --> 00:36:06,010
કીવર્ડ્સ માટે જુઓ શરૂ થાય છે.

760
00:36:06,010 --> 00:36:08,770
સ્પષ્ટપણે, હું અડધા સમજી નથી શકે છે
શબ્દો હું હજી સુધી જોઈ રહ્યો છું.

761
00:36:08,770 --> 00:36:10,140
તમે ચાલશે, જોકે, એક સપ્તાહ સમય છે.

762
00:36:10,140 --> 00:36:11,230
પરંતુ હું printf જુઓ.

763
00:36:11,230 --> 00:36:14,310
અને તે માટે, લાંબા પહેલાં, શરૂ થવી જોઈએ
, બધા હક, printf તમારી મેમરી હલાવવું.

764
00:36:14,310 --> 00:36:15,210
કંઈક printf સાથે ખોટી છે.

765
00:36:15,210 --> 00:36:16,580
હું તે ખોટું જોડણી હતી?

766
00:36:16,580 --> 00:36:18,130
ના, તે જેવો નથી - OH.

767
00:36:18,130 --> 00:36:21,350
હું શીખવવા સિવાય હું તેનો ઉપયોગ ન કરી શકે
તે અસ્તિત્વમાં છે કે જે કમ્પાઇલર.

768
00:36:21,350 --> 00:36:25,220
અને તેથી, ફરીથી, તમારા વૃત્તિ સાથે જાઓ
તમે ખરેખર સમજી ન હોય તો પણ

769
00:36:25,220 --> 00:36:26,510
વાસ્તવિક ભૂલ સંદેશાઓ.

770
00:36:26,510 --> 00:36:30,240
>> અને ખરેખર, અહીં ઉકેલ માત્ર છે
ફાઈલ ટોચ પર તેનો સમાવેશ

771
00:36:30,240 --> 00:36:34,340
કે જેમ, મારા ફાઇલ સાથે resaving
નિયંત્રણ-S અથવા ફાઇલ મેનુ.

772
00:36:34,340 --> 00:36:36,730
અને હવે હું અહીં નીચે પાછા જાઓ તો,
હું આ સાફ કરવા જઇ રહ્યો છું.

773
00:36:36,730 --> 00:36:39,150
નિયંત્રણ-L માત્ર એક સરસ રીત છે
સ્ક્રીન સાફ કરવા.

774
00:36:39,150 --> 00:36:44,870
અને પછી હું હેલ્લો બનાવવા "પ્રકાર જઈ રહ્યો
0 "દાખલ કરો, અને હવે હું હજુ પણ એક જુઓ

775
00:36:44,870 --> 00:36:47,710
વિસ્મૃત પ્રતીકો ક્રમ છે, પરંતુ
અમે તે પાછા આવો પડશે.

776
00:36:47,710 --> 00:36:49,230
તે તમારા માટે કરી છે મેક શું છે.

777
00:36:49,230 --> 00:36:52,590
તે લેવાની પ્રક્રિયા સ્વયં છે
સંડોવતા એકદમ હેરાન આદેશ

778
00:36:52,590 --> 00:36:54,050
રણકાર, એ વાસ્તવિક કમ્પાઇલર.

779
00:36:54,050 --> 00:36:57,460
પરંતુ હું કોઈ ભૂલો મળી હકીકત એ છે કે એનો અર્થ એ થાય
આ વસ્તુ કામ જોઈએ.

780
00:36:57,460 --> 00:37:00,630
>> તેથી હવે હું શું કરવા જઇ રહ્યો છું -
મને ફરી ઝૂમ દો -

781
00:37:00,630 --> 00:37:07,070
./hello-0 દાખલ કરો, અને ખરેખર, હું જુઓ
"હેલો, વર્લ્ડ." તેથી હવે વધારવા દો

782
00:37:07,070 --> 00:37:12,105
આ ક્યારેય જેથી થોડો માત્ર નકલ કરવા માટે
પગલાંઓ અમે હેતુપૂર્વક.

783
00:37:12,105 --> 00:37:15,370
હું સાથે આ નામ બદલી કરવા જઇ રહ્યો છું
Hello1.c માટે આ રૂપમાં સાચવો.

784
00:37:15,370 --> 00:37:20,300
અને હવે હું એક ચલ જાહેર કરવા જઇ રહ્યો છું
નામ, જેથી શબ્દમાળા નામ, કહેવાય

785
00:37:20,300 --> 00:37:23,420
અને હું તે મૂકવામાં જઈ રહ્યો
ભાવ-અવતરણ ચિહ્નો પૂરાં કરવાં બજારમૂલ્ય

786
00:37:23,420 --> 00:37:27,030
D-A-V-આઇ ડી નજીકના કંપની અર્ધવિરામ.

787
00:37:27,030 --> 00:37:31,150
અને હવે હું "વર્લ્ડ" બદલવા માટે જઇ રહ્યો છું
શબ્દમાળા માટે શું પ્લેસહોલ્ડર સાથે?

788
00:37:31,150 --> 00:37:32,200
% S.

789
00:37:32,200 --> 00:37:35,040
>> અને હવે, કેટલા દલીલો જોઇએ
printf આ સમય લાગી?

790
00:37:35,040 --> 00:37:35,700
બે તેથી.

791
00:37:35,700 --> 00:37:37,090
તેથી હું અવતરણો બહાર જાઓ.

792
00:37:37,090 --> 00:37:39,330
હું અલ્પવિરામ પછી "નામ" લખો.

793
00:37:39,330 --> 00:37:41,550
પરંતુ હું કંઈક કર્યું
બીજું ખોટું આ સમય.

794
00:37:41,550 --> 00:37:43,940
પરંતુ માતાનો હું ન ધારે છે કે દો
કે હજી સુધી ખ્યાલ.

795
00:37:43,940 --> 00:37:44,910
મને અહીં જવા દો.

796
00:37:44,910 --> 00:37:48,850
>> અને સૂચના, પણ, હું થોડું મેળવી રહ્યો છું
ટાઇપ ઓફ કંટાળો બધા "હેલ્લો 0 બનાવવા"

797
00:37:48,850 --> 00:37:50,180
સમય, "બનાવવા" અને આ બધા.

798
00:37:50,180 --> 00:37:53,270
તેથી, તે બહાર વળે, લિનસ માં તમે કરી શકો છો
ઘણી વાર તમારા પર ઉપર તીર હિટ

799
00:37:53,270 --> 00:37:56,850
કીબોર્ડ, અને તમે ખરેખર સ્ક્રોલ કરી શકો છો
હું કર્યું છે કે બધા આદેશો મારફતે

800
00:37:56,850 --> 00:37:58,830
માત્ર હવે અગાઉના ચલાવવામાં.

801
00:37:58,830 --> 00:38:02,040
મારે શું કરવું, તેથી જો ઉપર, Up, કે
હેલ્લો 0 બનાવવા છે.

802
00:38:02,040 --> 00:38:02,610
હું નથી માંગતા.

803
00:38:02,610 --> 00:38:05,450
હું માત્ર તે બદલવા માંગો છો
હેલ્લો 1 આ સમય, દાખલ કરો.

804
00:38:05,450 --> 00:38:07,620
આખરે, કે જે ચાલશે
તમે અમુક સમય સાચવો.

805
00:38:07,620 --> 00:38:08,150
>> બધા અધિકાર.

806
00:38:08,150 --> 00:38:09,520
કમનસીબે, એક ભૂલ આવી છે છે.

807
00:38:09,520 --> 00:38:10,980
તેથી મને ઉપર સ્ક્રોલ દો.

808
00:38:10,980 --> 00:38:13,120
આ હું ખરેખર જેવા દેખાય છે
આ કાર્યક્રમ butchered.

809
00:38:13,120 --> 00:38:16,530
હું, મારા ભગવાન અર્થ, તે કોડ બે લાઇન છે
અને ભૂલો તેના 10 રેખાઓ.

810
00:38:16,530 --> 00:38:18,800
પરંતુ પ્રથમ ટોચ એક જુઓ.

811
00:38:18,800 --> 00:38:21,640
બિનજાહેર ઓળખકર્તા શબ્દમાળાને ઉપયોગ કરો.

812
00:38:21,640 --> 00:38:23,270
હું n પ્રમાણભૂત અર્થ?

813
00:38:23,270 --> 00:38:23,930
કોઈ મને ન હતી.

814
00:38:23,930 --> 00:38:24,940
હું શબ્દમાળા હતો.

815
00:38:24,940 --> 00:38:29,390
>> પરંતુ શબ્દમાળા ચલ છે
પ્રકાર, જાહેર આપણે કહી dd?

816
00:38:29,390 --> 00:38:30,730
તેથી તે CS50 ગ્રંથાલયનો માં છે.

817
00:38:30,730 --> 00:38:33,740
તેથી તે આ પ્રથમ, પૂરતા નથી
અઠવાડિયા દંપતિ, માત્ર વાપરવા માટે

818
00:38:33,740 --> 00:38:34,860
શું સી અમને આપે છે.

819
00:38:34,860 --> 00:38:38,120
હું પણ અહીં જાઓ જવા, અને હું છું
ઉપર અથવા નીચે મૂકી છે, પરંતુ હું પડશે શકે

820
00:38:38,120 --> 00:38:40,340
માત્ર તેને મૂળાક્ષર રાખવા
વસ્તુઓ ઓર્ડરલી રાખવા.

821
00:38:40,340 --> 00:38:43,470
હું cs50.h સમાવેશ કરવા જઈ રહ્યો છું
માટે પૂર્વ સ્થાપિત થયેલ છે, જે

822
00:38:43,470 --> 00:38:44,900
જો CS50 ઉપકરણ પર તમે.

823
00:38:44,900 --> 00:38:47,640
અને તે લોકો પણ ઓપન સોર્સ છે, તેથી
ઇન્ટરનેટ પર તેમના પર ઉપયોગ કરી શકો છો

824
00:38:47,640 --> 00:38:48,450
પોતાના કમ્પ્યુટર્સ.

825
00:38:48,450 --> 00:38:50,700
પરંતુ તે CS50 સાધન સાથે આવે છે.

826
00:38:50,700 --> 00:38:55,320
>> તેથી હવે મને પાછા જાઓ અને recompile દો
સાથે આ હેલ્લો 1 બનાવે છે.

827
00:38:55,320 --> 00:38:55,710
તે ખરેખર.

828
00:38:55,710 --> 00:38:57,240
હજી પણ બીજા ભૂલ.

829
00:38:57,240 --> 00:38:59,370
જોકે, મને પ્રથમ સુધી સ્ક્રોલ દો.

830
00:38:59,370 --> 00:39:00,630
આ એક થોડી જટિલ છે.

831
00:39:00,630 --> 00:39:03,830
સતત મલ્ટી પાત્ર પાત્ર.

832
00:39:03,830 --> 00:39:04,890
કે મને મદદ નથી.

833
00:39:04,890 --> 00:39:08,220
પરંતુ સૂચના, રણકાર ઓછામાં ઓછા થોડી છે
બીટ માફકસરનું, જેમાં થોડો સાથે

834
00:39:08,220 --> 00:39:11,890
લીલા કાકપદું પ્રતીક છે, તે કહેતા છે
હું ખરાબ છે અહીં છે.

835
00:39:11,890 --> 00:39:16,160
તે શા માટે છે કે ઓછી, સાથે પોઇન્ટ છે
આગામી એક કંપની માટે લીલા તીર,

836
00:39:16,160 --> 00:39:18,290
મારું નામ છે?

837
00:39:18,290 --> 00:39:20,880
>> તેથી આ તમે માત્ર વસ્તુઓ છે
તમે કરી છે, ખાસ કરીને જો કરવા માટે વપરાય મળશે

838
00:39:20,880 --> 00:39:23,980
Python, અથવા JavaScript પ્રોગ્રામિંગ,
અથવા અન્ય ભાષા છે આ વિગત

839
00:39:23,980 --> 00:39:24,560
વાંધો નથી.

840
00:39:24,560 --> 00:39:25,740
સી, તે બાબત નથી.

841
00:39:25,740 --> 00:39:29,520
તમે શબ્દમાળા જાહેર કરવામાં આવે છે, તો જે છે
0 અથવા વધુ અક્ષરો ક્રમ,

842
00:39:29,520 --> 00:39:32,280
તમે ખરેખર બેવડા અવતરણ ઉપયોગ કરવો જોઈએ.

843
00:39:32,280 --> 00:39:36,670
તેથી હું ખરેખર આ પાછા બદલવાની જરૂર
કંપની ખોલવા માટે, સાથે, કંપની બંધ

844
00:39:36,670 --> 00:39:37,800
બેવડા અવતરણ.

845
00:39:37,800 --> 00:39:41,610
એક જ અવતરણચિહ્નો પોતાની જગ્યા છે, નથી, પણ
તમે વ્યક્તિગત ઉપયોગ કરી રહ્યાં છો ત્યારે જ

846
00:39:41,610 --> 00:39:44,100
બીજા સમય પર અક્ષરો, વધુ.

847
00:39:44,100 --> 00:39:46,550
હવે માટે, અવતરણચિહ્નો
જરૂરી છે.

848
00:39:46,550 --> 00:39:50,460
>> તેથી હવે, મને મારા ટર્મિનલ પર પાછા જવા દો
વિન્ડો હેલ્લો 1 બનાવે છે.

849
00:39:50,460 --> 00:39:51,450
અને જે વિશ્વાસ છે?

850
00:39:51,450 --> 00:39:53,800
આ કાર્યક્રમ હવે ચાલુ છે
યોગ્ય રીતે કમ્પાઇલ કરવા માટે?

851
00:39:53,800 --> 00:39:58,250

852
00:39:58,250 --> 00:39:58,540
ઠીક.

853
00:39:58,540 --> 00:39:59,780
તેથી અમને ત્રણ આ લાગે છે.

854
00:39:59,780 --> 00:40:00,280
બધા અધિકાર.

855
00:40:00,280 --> 00:40:01,190
દાખલ કરો.

856
00:40:01,190 --> 00:40:02,440
અને તે વાસ્તવમાં હતી.

857
00:40:02,440 --> 00:40:05,130
તેથી કોઈ ભૂલો આ સમય પણ છે,
આ કાર્યક્રમ એક બીટ મેળવેલ છે છતાં

858
00:40:05,130 --> 00:40:05,840
વધુ જટિલ.

859
00:40:05,840 --> 00:40:10,110
હવે હું કોઈ સ્લેશ હેલ્લો 1 કરશો તો, કંપની
તે કહે રહ્યું "હેલ્લો, ડેવિડ."

860
00:40:10,110 --> 00:40:11,750
>> પરંતુ લેટ્સ ત્રીજા પુનરાવૃત્તિ કરવું
આ છે, જ્યાં

861
00:40:11,750 --> 00:40:13,380
કાર્યક્રમ સાચી ગતિશીલ છે.

862
00:40:13,380 --> 00:40:16,770
મને આગળ જાઓ અને ફાઇલને બદલવા દો
માત્ર સાથે સુસંગતતા માટે નામ,

863
00:40:16,770 --> 00:40:20,410
તમે ઉપલબ્ધ હશે ફાઇલો
તમે પછીથી ઓનલાઇન.

864
00:40:20,410 --> 00:40:21,620
દાખલ કરો.

865
00:40:21,620 --> 00:40:25,510
અને હવે હું નથી અને જવા માટે જઇ રહ્યો છું
હાર્ડ અહીં કોડેડ "ડેવિડ" સંગ્રહે છે.

866
00:40:25,510 --> 00:40:28,826
હું ખૂબ જ સરળ રીતે શું કરી શકે છે
આ કાર્યક્રમ સુધારવા?

867
00:40:28,826 --> 00:40:30,520
>> હું getstring કૉલ કરી શકે છે.

868
00:40:30,520 --> 00:40:33,240
તે થોડી બિન સ્પષ્ટ શું હોઈ શકે
શું કરવા વિશે છે, તેથી હું જાઉં છું

869
00:40:33,240 --> 00:40:38,470
ખરેખર બીજી લાઇન, printf, ઉમેરવા માટે
અને, ફક્ત નામ, કોલોન, બંધ કંપની કહે છે

870
00:40:38,470 --> 00:40:40,790
વપરાશકર્તાને પ્રોમ્પ્ટ આપી
સ્ક્રીન પર.

871
00:40:40,790 --> 00:40:42,980
અને હવે હું અહીં જવા માટે જઇ રહ્યો છું, અને હું છું
મારા કિબોર્ડ શોર્ટકટ વાપરવા માટે જવાનું.

872
00:40:42,980 --> 00:40:47,680
હું ઉપર, ઉપર જવા માટે જવાનું, અને બદલી રહ્યો છુ
હેલ્લો માટે 2 1 હેલ્લો, દાખલ કરો.

873
00:40:47,680 --> 00:40:49,260
અને thankfully, હું પ્રોગ્રેસ બનાવવા છું.

874
00:40:49,260 --> 00:40:52,720
>> અને હવે હું જવા માટે જઇ રહ્યો છું
કોઈ સ્લેશ હેલ્લો અને

875
00:40:52,720 --> 00:40:54,690
2, કંપની કે જે બદલો.

876
00:40:54,690 --> 00:40:55,650
અને હવે મારી કાર્યક્રમ -

877
00:40:55,650 --> 00:40:57,700
હું ઝૂમ કરીશું - મેળવવામાં આવે છે
prettier થોડી.

878
00:40:57,700 --> 00:41:02,190
નામ હોઈ ચાલે છે, લેટ્સ રોબ કહે છે
આ સમય, હેલ્લો, રોબ દાખલ કરો.

879
00:41:02,190 --> 00:41:03,260
અમે તેને ફરીથી કરી શકો છો.

880
00:41:03,260 --> 00:41:05,360
નામ, લોરેન, દાખલ કરો.

881
00:41:05,360 --> 00:41:07,820
નામ, જોસેફ, દાખલ કરો.

882
00:41:07,820 --> 00:41:11,596
નામ, હોઈ પ્રયાસ કરીએ
મુશ્કેલ દાખલ કરો.

883
00:41:11,596 --> 00:41:12,410
EH.

884
00:41:12,410 --> 00:41:14,680
તે ખરેખર એક ભૂલ નથી.

885
00:41:14,680 --> 00:41:16,090
તેથી તે માત્ર થોડી બિહામણું છે.

886
00:41:16,090 --> 00:41:18,640
તેથી કદાચ અમે આ ઉકેલવા શકે
ભવિષ્યમાં, બિન હવે.

887
00:41:18,640 --> 00:41:20,840
>> પરંતુ તમે કેવી રીતે સહજ ભાવે કરશે
સંબોધવા વિશે જાઓ

888
00:41:20,840 --> 00:41:21,990
ચોક્કસ પડકાર?

889
00:41:21,990 --> 00:41:23,710
તે માત્ર મૂર્ખ જુએ છે.

890
00:41:23,710 --> 00:41:27,320
તમે કેવી રીતે વસ્તુઓ બચું
મૂર્ખ શોધી રહ્યાં છો?

891
00:41:27,320 --> 00:41:29,890
તેથી આપણે શું કરી શકે છે, ઠીક છે, હું એક દંપતિ સાંભળ્યું
વસ્તુઓ, એક શરત અને લૂપ.

892
00:41:29,890 --> 00:41:33,340
અમે તપાસવા માટે, એક શરત એક ઉપયોગ કરી શકે છે
શબ્દમાળા લંબાઈ શું છે

893
00:41:33,340 --> 00:41:34,190
વપરાશકર્તા અમને આપ્યું હતું?

894
00:41:34,190 --> 00:41:37,100
અને તે 0 હોય, તે માત્ર, અવતરણ ચિહ્નો પૂરાં કરવાં ઉદ્ધત છે
તેઓ માત્ર પછી Enter દબાવો

895
00:41:37,100 --> 00:41:38,930
કદાચ હું તેમને કિકિયારી કરવી જોઈએ
અને તેમને ફરીથી પૂછવા.

896
00:41:38,930 --> 00:41:39,970
પરંતુ તેમને ફરીથી કેવી રીતે પૂછવા નથી?

897
00:41:39,970 --> 00:41:44,230
ઠીક છે, હું પણ લૂપ સાંભળ્યું છે, અને હું કરી શકે છે
ફરી અને ફરી અને ફરી તે કરવા

898
00:41:44,230 --> 00:41:47,010
એક જ વસ્તુ માટે વપરાશકર્તાને પૂછવાની.

899
00:41:47,010 --> 00:41:48,880
>> વેલ, એક અન્ય ઉદાહરણ શું કરીએ
અલગ મદદથી

900
00:41:48,880 --> 00:41:50,620
જો CS50 પુસ્તકાલય કાર્ય.

901
00:41:50,620 --> 00:41:52,330
મને આ ફાઈલની બંધ કરીએ.

902
00:41:52,330 --> 00:41:53,510
મને એક નવું બનાવો દો.

903
00:41:53,510 --> 00:41:58,510
અને હું તે adder.c કૉલ કરશો, માત્ર કારણ કે
તે સરળ અંકગણિત કરવું સરળ છે

904
00:41:58,510 --> 00:42:00,890
આ સંપૂર્ણપણે હશે છતાં પણ
તમે કરી શકે છે, તેની સાથે underwhelming

905
00:42:00,890 --> 00:42:02,250
કોઈપણ આધુનિક કોમ્પ્યુટર સાથે.

906
00:42:02,250 --> 00:42:03,750
>> પરંતુ હવે મને આગળ જવા દો અને -

907
00:42:03,750 --> 00:42:10,680
હું છેલ્લા સમય મારા પાઠ શીખ્યા - સમાવેશ થાય છે
cs50.h સમાવેશ થાય છે, stdio.h, ઈન્

908
00:42:10,680 --> 00:42:14,170
મુખ્ય રદબાતલ છે, કે જે, હવે માટે, હું માત્ર પડશે
અંધ વિશ્વાસ પર લઇ, પરંતુ અમે ધારે પડશે

909
00:42:14,170 --> 00:42:16,380
શું સમજવું પડશે કે
લાંબા પહેલાં અર્થ એ થાય કે.

910
00:42:16,380 --> 00:42:21,030
અને હું કંઈક કહે જઇ રહ્યો છું
જેમ "મને એક ઈન્ આપે છે."

911
00:42:21,030 --> 00:42:22,140
>> અને હવે, હું કેવી રીતે એક ઈન્ મેળવી શકું?

912
00:42:22,140 --> 00:42:26,820
હું છેવટે ચલ જાહેર કરવા માંગો છો
પ્રકાર ઈન્ એક્સ અને કહેવાય

913
00:42:26,820 --> 00:42:29,240
તે વપરાશકર્તા માંથી પૂર્ણાંક સંગ્રહ કરે છે.

914
00:42:29,240 --> 00:42:29,970
જેથી કોળિયો હતી.

915
00:42:29,970 --> 00:42:35,680
પરંતુ કોઈને પ્રસ્તાવ કરવા માંગે છે, તો કેવી રીતે
હું પૂર્ણાંક નામના એક્સ જાહેર નથી?

916
00:42:35,680 --> 00:42:36,310
ઈન્ એક્સ.

917
00:42:36,310 --> 00:42:37,430
>> તેથી તે ખરેખર છે કે જે સરળ છે.

918
00:42:37,430 --> 00:42:38,240
મને એક ઈન્ આપો.

919
00:42:38,240 --> 00:42:39,070
તે X કૉલ કરો.

920
00:42:39,070 --> 00:42:40,580
હવે હું સોંપણી ઓપરેટર વાપરો.

921
00:42:40,580 --> 00:42:43,400
અને કેવી રીતે હું માંથી સંગ્રહ કરો
વપરાશકર્તા ની કિંમત છોડી?

922
00:42:43,400 --> 00:42:47,310
હું getstring કૉલ કરવા નહિં માંગો
દેખીતી રીતે, પરંતુ getint.

923
00:42:47,310 --> 00:42:49,060
કોઈપણ દલીલો?

924
00:42:49,060 --> 00:42:49,350
શેર્સની

925
00:42:49,350 --> 00:42:51,870
તેથી તે કૌંસ, બંધ કૌંસ ખુલ્લું
તરત જ, અને પછી એક

926
00:42:51,870 --> 00:42:53,440
અર્ધવિરામ લીટી અંત થાય છે.

927
00:42:53,440 --> 00:42:54,930
>> હવે મને ફરી આ કરવા દો.

928
00:42:54,930 --> 00:42:57,070
મને અન્ય ઈન્ આપો.

929
00:42:57,070 --> 00:43:01,850
આ સમય હું ઈન્ કરીશ, લેટ્સ
તે વાય ફોન, getint બરાબર.

930
00:43:01,850 --> 00:43:05,060
અને હવે મને સુપર સરળ કંઈક કરવા દો
કેટલાક ગણિત જેવા.

931
00:43:05,060 --> 00:43:14,340
તેથી printf,% d ની રકમ છે
એક ઈન્ માટે પ્લેસહોલ્ડર.

932
00:43:14,340 --> 00:43:20,030
અને% d, સમય, બેકસ્લેશ-n એ.

933
00:43:20,030 --> 00:43:20,360
>> બધા અધિકાર.

934
00:43:20,360 --> 00:43:21,670
કે જેથી ખરેખર ગણિત નથી.

935
00:43:21,670 --> 00:43:25,500
પરંતુ હું આ રકમ કહેવા માગો છો તો
કિંમત વત્તા આ કિંમત આ બરાબર

936
00:43:25,500 --> 00:43:29,320
અન્ય કિંમત કેટલી દલીલો માં
કુલ હું printf આપવા જોઈએ

937
00:43:29,320 --> 00:43:30,520
આખરે?

938
00:43:30,520 --> 00:43:31,420
ચાર તેથી, અધિકાર?

939
00:43:31,420 --> 00:43:33,790
પછી આ શબ્દમાળા અને ત્રણ કિંમતો.

940
00:43:33,790 --> 00:43:37,560
X પ્રથમ છે તેથી હું કરવા માંગો છો
આ% d થી પ્રથમ જોડેલ.

941
00:43:37,560 --> 00:43:39,270
વાય આગામી હોઈ ચાલે છે.

942
00:43:39,270 --> 00:43:42,030
>> અને હવે હું પણ પ્રકારની કહેવા માગો છો
z, પરંતુ z અસ્તિત્વમાં નથી.

943
00:43:42,030 --> 00:43:43,190
પરંતુ તે એક મોટી સોદો નથી.

944
00:43:43,190 --> 00:43:45,440
કારણ કે તમે, સહજ ભાવે શું કરશે
જો તમે હતી, ખાસ કરીને જો

945
00:43:45,440 --> 00:43:47,820
આલેખન કૅલ્ક્યુલેટર તમને શું લખો છો?

946
00:43:47,820 --> 00:43:48,760
કેવી રીતે X વત્તા વાય વિશે?

947
00:43:48,760 --> 00:43:50,200
તેથી તે વાસ્તવિક ચલ નથી.

948
00:43:50,200 --> 00:43:51,820
તે માત્ર બે રકમ છે
અન્ય ચલો.

949
00:43:51,820 --> 00:43:53,170
અને તે સંપૂર્ણપણે કાયદેસર છે.

950
00:43:53,170 --> 00:43:56,630
સી ચોક્કસપણે સરળ સમજે
આ જેમ અંકગણિત.

951
00:43:56,630 --> 00:43:58,450
>> અર્ધવિરામ, સાચવો.

952
00:43:58,450 --> 00:44:02,080
હવે મને અહીં નીચે જવા દો અને
દાખલ કરો, નાનો ઝેરી સાંપ બનાવવા લખો.

953
00:44:02,080 --> 00:44:04,100
કોઈ ભૂલ, પણ પ્રોગ્રેસ છે કે જેથી.

954
00:44:04,100 --> 00:44:04,890
નાનો ઝેરી સાંપ લખો.

955
00:44:04,890 --> 00:44:07,100
અને બીજા કિબોર્ડ શોર્ટકટ,
તમે કંટાળો મળશે શરૂ જો

956
00:44:07,100 --> 00:44:08,760
- બધા આદેશો સાથે

957
00:44:08,760 --> 00:44:12,650
જો તમે આદેશ લખીને શરૂ કરો, તો જેમ ડોટ
જાહેરાત સ્લેશ છે, અને તે છે જ્યાં આપના

958
00:44:12,650 --> 00:44:16,020
કંટાળાને તમે સામાન્ય રીતે હિટ કરી શકે છે, માં કિક
ટેબ કમ્પ્યુટર સમાપ્ત હોય

959
00:44:16,020 --> 00:44:20,510
તે નથી તો તમારા માટે આ શબ્દસમૂહનું આરામ
સંદિગ્ધ શું જાહેરાત પછી આવવું જોઈએ.

960
00:44:20,510 --> 00:44:23,950
>> તેથી હવે મને આગળ જવા દો
અને તમે દાખલ કરો ક્લિક કરો.

961
00:44:23,950 --> 00:44:27,490
મને એક Int, 1, 2 આપે છે, અને
thankfully, તે 3 છે.

962
00:44:27,490 --> 00:44:29,900
પરંતુ હંમેશની જેમ, કાર્યક્રમો પરીક્ષણ
માટે ઘટાડવા જોઇએ નહિં

963
00:44:29,900 --> 00:44:30,820
માત્ર એક વખત તે પ્રયાસ કરી.

964
00:44:30,820 --> 00:44:35,560
મને નકારાત્મક જેવા એક ખૂણામાં કેસ, પ્રયાસ કરીએ
1, મને 1 આપે છે, અને તે એક

965
00:44:35,560 --> 00:44:36,210
તેમજ બહાર ચકાસે છે.

966
00:44:36,210 --> 00:44:38,870
અને હું કદાચ કેટલાક વધુ કરવા માંગો છો
સખત પરીક્ષણ, પરંતુ હું ખૂબ છું

967
00:44:38,870 --> 00:44:40,630
કે ખાતે છે જ્યાં સાથે આરામદાયક.

968
00:44:40,630 --> 00:44:43,110
>> ઠીક છે, હવે માતાનો અન્ય કાર્યક્રમ પ્રયાસ દો
આ સમય વાપરે છે

969
00:44:43,110 --> 00:44:44,620
અન્ય સિન્ટેક્સ ઓફ બીટ.

970
00:44:44,620 --> 00:44:46,100
મને એક નવી ફાઈલ બનાવવા દો.

971
00:44:46,100 --> 00:44:51,050
હું વાક્ય માટે આ conditions0.c કૉલ પડશે
અપ કેટલાક નમૂના કોડ ઑનલાઇન સાથે.

972
00:44:51,050 --> 00:44:55,550
અને મને આગળ વધો અને કરવા દો
સમાવેશ થાય છે, cs50.h સમાવેશ થાય છે

973
00:44:55,550 --> 00:45:00,320
મુખ્ય રદબાતલ માં stdio.h, -

974
00:45:00,320 --> 00:45:01,030
ઠીક.

975
00:45:01,030 --> 00:45:01,850
ત્યાં અમે જાઓ.

976
00:45:01,850 --> 00:45:03,010
અમે અમારી પ્રમાણભૂત boilerplate છે.

977
00:45:03,010 --> 00:45:08,170
>> અને આ સમય હું printf કહે જઇ રહ્યો છું
માત્ર "હું ઈન્, કૃપા કરીને, માગો"

978
00:45:08,170 --> 00:45:10,030
પ્રોમ્પ્ટ થોડી બનાવવા
વધુ અનુકૂળ છે.

979
00:45:10,030 --> 00:45:11,620
અને હવે હું એક વિચાર કરવા માંગો છો
વપરાશકર્તા માંથી INT.

980
00:45:11,620 --> 00:45:15,010
હું તેને એ આ સમય કૉલ કરવા જઇ રહ્યો છું
એ નંબર જેવી લાગે છે.

981
00:45:15,010 --> 00:45:18,140
getint, અને હવે, શું
હું તેની સાથે કરવા માંગો છો?

982
00:45:18,140 --> 00:45:21,640
ઠીક છે, એ જો - અને હું ઝૂમ કરીશું -

983
00:45:21,640 --> 00:45:25,930
એ 0 કરતાં મોટી હોય, તો હું માંગો છો
નીચેના કરવા માટે -

984
00:45:25,930 --> 00:45:36,060
printf "તમે હકારાત્મક નંબર હતી."
બીજું, હું તમને "printf લખો જઈ રહ્યો

985
00:45:36,060 --> 00:45:37,870
નકારાત્મક લેવામાં

986
00:45:37,870 --> 00:45:39,650
નંબર. "ઓલ રાઇટ.

987
00:45:39,650 --> 00:45:44,410
હું હતી છતાં પણ તેથી આ કાર્યક્રમ,
ઝડપી, અધિકાર વાક્યરચના અનુસાર દેખાય છે.

988
00:45:44,410 --> 00:45:45,010
મને આ પ્રયાસ કરીએ.

989
00:45:45,010 --> 00:45:46,890
શરત 0 બનાવો.

990
00:45:46,890 --> 00:45:47,710
સ્કોર લાગે છે.

991
00:45:47,710 --> 00:45:49,230
શરત 0, દાખલ કરો.

992
00:45:49,230 --> 00:45:51,910
માતાનો તે 50 ની ઈન્ આપી દો.

993
00:45:51,910 --> 00:45:53,160
હું એક હકારાત્મક નંબર હતી.

994
00:45:53,160 --> 00:45:54,230
માતાનો તેને ફરીથી પ્રયાસ કરીએ.

995
00:45:54,230 --> 00:45:54,930
શરત 0.

996
00:45:54,930 --> 00:45:56,260
50 નકારાત્મક.

997
00:45:56,260 --> 00:45:57,290
હું એક નકારાત્મક નંબર હતી.

998
00:45:57,290 --> 00:46:00,350
>> પરંતુ હવે, અમે રાખીશું શું મને પસંદ દો
એક ખૂણામાં કેસ ફોન છે, કે જે વધારે છે

999
00:46:00,350 --> 00:46:04,702
તમને લાગે છે કે એક રસપ્રદ કિસ્સો
તમે અમુક મુશ્કેલી, 0 આપી શકે છે.

1000
00:46:04,702 --> 00:46:07,940
હવે, હું આ એક છે ખૂબ ખાતરી છું
શૂન્ય છે તે ખૂણે કિસ્સાઓમાં

1001
00:46:07,940 --> 00:46:12,330
હકારાત્મક કે નકારાત્મક બે, તેથી મારી
કાર્યક્રમ, વાક્યરચના અનુસાર જોકે

1002
00:46:12,330 --> 00:46:15,440
ઠીક - તે કમ્પાઇલ, તે ચાલે છે -
તાર્કિક રીતે યોગ્ય નથી.

1003
00:46:15,440 --> 00:46:21,050
હું માંગો છો, તો તેથી સરળ સુધારો અહીં શું છે
હું એ નિયંત્રિત કરવા માંગતા હોય તો, શોધવા માટે

1004
00:46:21,050 --> 00:46:23,840
અલગ 0 બરાબર?

1005
00:46:23,840 --> 00:46:32,980
>> એ 0 બરાબર તેથી જો, પછી હું કહેવા માગો છો
printf કંઈક "તમે 0 હતી."

1006
00:46:32,980 --> 00:46:33,990
મને હવે આ પ્રયાસ કરીએ.

1007
00:46:33,990 --> 00:46:38,320
સાફ, મને પાછા અહીં જવા દો
મારી બારી, અને recompile.

1008
00:46:38,320 --> 00:46:38,690
હમ્મ.

1009
00:46:38,690 --> 00:46:39,770
એક ભૂલ પેદા કરે છે.

1010
00:46:39,770 --> 00:46:41,630
પરંતુ હું તમને ચેક કરવા માંગો છો
એ 0 બરાબર હોય.

1011
00:46:41,630 --> 00:46:44,230

1012
00:46:44,230 --> 00:46:47,720
>> તેથી ફરી, અન્ય મૂર્ખ વસ્તુ
માટે વપરાય મેળવવા માટે, બરાબર ચિહ્ન છે

1013
00:46:47,720 --> 00:46:48,910
સોંપણી ઓપરેટર.

1014
00:46:48,910 --> 00:46:52,240
તેથી આ ખરેખર છે કે ભૂલ છે
તકનિકી, છતાં પણ કમ્પાઇલર

1015
00:46:52,240 --> 00:46:56,450
મારી પાસેથી મને સુરક્ષિત, અમે કરશો
ટેકનિકલી એ માં નકલ કરી 0, જે

1016
00:46:56,450 --> 00:46:57,590
હું શું કરવા માંગો છો નથી.

1017
00:46:57,590 --> 00:47:00,950
હું સમાનતા માટે પરીક્ષણ કરવા માંગો છો
સાથે બરાબર બરાબર.

1018
00:47:00,950 --> 00:47:03,390
અને જેથી હવે હોઈ શકે છે
મારી સારી ઉકેલ.

1019
00:47:03,390 --> 00:47:07,810
>> મને ખરેખર, આ resave કહે છે, દો
conditions1, નવા અને સુધારેલ છે.

1020
00:47:07,810 --> 00:47:10,480
હું આ recompile તેથી હવે તો,
તે શરતો કરશે -

1021
00:47:10,480 --> 00:47:16,960
દેખીતી ભૂલ માટે માફી (માગવી તે) - બનાવવા conditions1 પર કોઈ સ્લેશ
conditions1,, હું ઈન્ માગતા "દાખલ કરો,

1022
00:47:16,960 --> 00:47:18,760
. "હું જવા માટે જઇ રહ્યો છું કૃપા કરીને
આગળ અને 50 લખો.

1023
00:47:18,760 --> 00:47:19,660
તે હજુ પણ સારી છે.

1024
00:47:19,660 --> 00:47:21,200
હજુ પણ સારી, 50 નકારાત્મક.

1025
00:47:21,200 --> 00:47:24,920
0, અને તે ખરેખર, શોધાયેલ
હું 0 લેવામાં છે.

1026
00:47:24,920 --> 00:47:28,200
>> તેથી શું વધુ હવે હું આ સાથે શું કરી શકો છો?

1027
00:47:28,200 --> 00:47:32,280
વેલ, અમે ચોક્કસપણે વધુને વધુ શું કરી શકો છો
જટિલ બાબતો.

1028
00:47:32,280 --> 00:47:37,240
પરંતુ શું હું પ્રસ્તાવ કરવા માગતા છે
અમે અહીં આ નોંધ પર સમાપ્ત થાય છે.

1029
00:47:37,240 --> 00:47:41,680
અમે આ અપ ખેંચવાનો, તો તમે કદાચ જોશો
તમારામાં એક પ્રિય કાર્ટૂન

1030
00:47:41,680 --> 00:47:43,326
આજે જ્યાં સુધી તમે કદાચ
સમજ્યાં છે ક્યારેય.

1031
00:47:43,326 --> 00:47:46,550

1032
00:47:46,550 --> 00:47:49,520
અને તે હાસ્ય ગુણવત્તા વિશે
તમે સીએસ ટુચકાઓ સાથે વિચાર કરીશું.

1033
00:47:49,520 --> 00:47:51,060
તેથી તે વિશે અધિકાર છે.

1034
00:47:51,060 --> 00:47:54,900
>> પરંતુ વધુ compellingly, હું કરશો વિચાર્યું
અમને સોમવાર માટે થોડી સતામણી આપે છે.

1035
00:47:54,900 --> 00:47:56,430
તેથી અમે પૂર્ણાંકો મદદથી શરૂ કર્યું છે.

1036
00:47:56,430 --> 00:47:57,510
અમે ફ્લોટ્સ ઉલ્લેખ કર્યો છે.

1037
00:47:57,510 --> 00:48:00,120
અમે પણ ડબલ્સ ઉલ્લેખ કર્યો છે
જે, ફરીથી, તમે નંબરો આપી

1038
00:48:00,120 --> 00:48:01,390
દશાંશ પોઈન્ટ હતો.

1039
00:48:01,390 --> 00:48:04,230
>> પરંતુ તે ફ્લોટ્સ બહાર વળે છે અને
ડબલ્સમાં, અને, ખરેખર, કમ્પ્યુટર્સ,

1040
00:48:04,230 --> 00:48:08,470
મૂળભૂત વ્યક્ત કરી શકતા નથી
ચોક્કસપણે અમુક કિંમતો.

1041
00:48:08,470 --> 00:48:12,840
અમે ગણિત વર્ગો માંથી ખબર તમે આ કરી શકો છો કે જે
પછી નંબરો કોઈપણ નંબર છે

1042
00:48:12,840 --> 00:48:13,510
દશાંશ બિંદુ.

1043
00:48:13,510 --> 00:48:16,460
અને તમે પણ ઊભી બાર મૂકી શકો છો
આ કાયમ પર જવા કહે છે.

1044
00:48:16,460 --> 00:48:18,810
>> કમનસીબે, તમે ખરેખર ન કરી શકે
કમ્પ્યુટર છે કે નથી.

1045
00:48:18,810 --> 00:48:20,400
અને તેથી ખૂણે કિસ્સાઓમાં થાય છે.

1046
00:48:20,400 --> 00:48:23,120
હમણાં પૂરતું, તમે છો ધારવું
નાણાકીય કંઈક કરી.

1047
00:48:23,120 --> 00:48:25,700
તમે ગણિત કરી રહ્યા છીએ
ટકાવારી સાથે, અને

1048
00:48:25,700 --> 00:48:27,030
સાથે ડોલર અને સેન્ટનો.

1049
00:48:27,030 --> 00:48:29,230
અને તે સેન્ટ નથી
અપ લાઇન જરૂરી.

1050
00:48:29,230 --> 00:48:34,120
ઠીક છે, તે છે કે તે અપૂર્ણાંકો બહાર વળે
પેનિઝ જ્યારે ઉમેરો કરવા માટે શરૂ કરી શકો છો

1051
00:48:34,120 --> 00:48:37,250
કમ્પ્યુટર સિસ્ટમ સાથે મોડલિંગ કર્યું
એવી રીતે કે હોંશિયાર

1052
00:48:37,250 --> 00:48:39,100
મનુષ્યો લાભ લઇ શકે છે.

1053
00:48:39,100 --> 00:48:42,650
>> અને જોઇ ન હોય તેવા તમે તે, હું કરશો
તમે એક 30 સેકન્ડની સતામણી આપવા માંગો

1054
00:48:42,650 --> 00:48:48,290
ઓફિસ સ્પેસ તરીકે ઓળખાય છે એક અદ્ભુત ફિલ્મ,
એક એક ચિત્ર કરું આવશે

1055
00:48:48,290 --> 00:48:51,205
અમે સામનો કરશે સમસ્યા
સોમવારે પ્રથમ વસ્તુ.

1056
00:48:51,205 --> 00:48:53,960
અમે વોલ્યુંમ વધારવા શકે તો
થોડુંક, હું તમને 30 આપી

1057
00:48:53,960 --> 00:48:55,495
ઓફિસ ઓફ સ્પેસ સેકન્ડો.

1058
00:48:55,495 --> 00:48:55,770
>> [વિડિઓ પ્લેબેક]

1059
00:48:55,770 --> 00:48:59,000
>> આઇ અર્થ, તમે દર્શાવે આવી નથી
અપ અને તમે તમારી નોકરી જાળવી રાખવા માટે વિચાર.

1060
00:48:59,000 --> 00:49:00,620
>> વાસ્તવમાં, હું પ્રોત્સાહન આપવામાં આવી રહ્યું છું.

1061
00:49:00,620 --> 00:49:03,240
>> હું કે જે હો તે વાયરસ પ્રોગ્રામ કરી શકે છે
મોટા સમય કે સ્થળ ફાડી.

1062
00:49:03,240 --> 00:49:04,430
>> -ઠીક છે, તે કેવી રીતે કામ કરે છે?

1063
00:49:04,430 --> 00:49:06,782
>> એક બેંક વ્યવહાર ત્યાં દરેક સમય
વ્યાજ ગણતરી, અને ત્યાં થયેલ છે

1064
00:49:06,782 --> 00:49:10,160
હજારો એક દિવસ છે, કમ્પ્યૂટર અંત
એક ટકા આ અપૂર્ણાંક સાથે.

1065
00:49:10,160 --> 00:49:12,030
>> -પરંતુ હું જઈ રહ્યો નથી
ગેરકાયદે કાંઇ.

1066
00:49:12,030 --> 00:49:12,660
>> ગેરકાયદે?

1067
00:49:12,660 --> 00:49:15,075
સમીર, આ અમેરિકા છે.

1068
00:49:15,075 --> 00:49:16,570
>> -અમે ભગવાન માટે શપથ લેવા પડશે.

1069
00:49:16,570 --> 00:49:19,070
>> -તો કોઇ આ વિશે જાણે છે
પરંતુ અમને, બધા અધિકાર?

1070
00:49:19,070 --> 00:49:21,920
આ બોલ પર કોઈ પરિવારના સભ્યો આ બોલ પર કોઈ
ગર્લફ્રેન્ડને, કોઇ.

1071
00:49:21,920 --> 00:49:22,700
>> ઓફ કોર્સ.

1072
00:49:22,700 --> 00:49:23,320
>> -સંમત થયા હતા.

1073
00:49:23,320 --> 00:49:24,280
>> ચિંતા, માનવ Don't.

1074
00:49:24,280 --> 00:49:25,640
હું ક્યાં કોઈને કહી શકતા નથી.

1075
00:49:25,640 --> 00:49:26,504
>> [END વિડિઓ પ્લેબેક]

1076
00:49:26,504 --> 00:49:30,030
>> DAVID MALAN: તેથી આ, તો પછી, CS50 છે,
કે ઓફિસ સ્પેસ હતી, અને તે બધા ચાલશે

1077
00:49:30,030 --> 00:49:31,465
સોમવાર અર્થમાં બનાવે છે.

1078
00:49:31,465 --> 00:49:33,940
પછી તમે જુઓ.

1079
00:49:33,940 --> 00:49:37,880
>> નેરેટર: આગામી CS50, રોબ મુ
બંધ હોવા સાથે ગોઠવાય તે

1080
00:49:37,880 --> 00:49:39,130
હાર્વર્ડ ભોજન યોજના.

1081
00:49:39,130 --> 00:49:56,160