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

2
00:00:02,970 --> 00:00:14,355

3
00:00:14,355 --> 00:00:15,700
>> ડેવિડ જે MALAN: બધા અધિકાર.

4
00:00:15,700 --> 00:00:18,832
આ CS50 છે અને આ
2 અઠવાડિયું શરૂઆત છે.

5
00:00:18,832 --> 00:00:21,040
અને તમે તે પર યાદ પડશે
અઠવાડિયા ભૂતકાળમાં દંપતી,

6
00:00:21,040 --> 00:00:24,490
અમે કમ્પ્યુટર રજૂઆત કરવામાં આવી છે
વિજ્ઞાન અને, વળાંક, પ્રોગ્રામિંગ.

7
00:00:24,490 --> 00:00:27,640
>> અને અમે માર્ગ દ્વારા વાર્તા શરૂ
સ્ક્રેચ, કે જે ગ્રાફિકલ ભાષા

8
00:00:27,640 --> 00:00:28,990
એમઆઇટી મીડિયા લેબ માંથી.

9
00:00:28,990 --> 00:00:30,780
અને પછી તાજેતરમાં,
છેલ્લા અઠવાડિયે, અમે કર્યું

10
00:00:30,780 --> 00:00:34,450
એક higher-- એક પરિચય
નીચલા સ્તરના ભાષા ઓળખાય

11
00:00:34,450 --> 00:00:36,770
સી, કંઈક કે જે કેવળ શાબ્દિક છે, કારણ કે.

12
00:00:36,770 --> 00:00:39,440
અને, ખરેખર, છેલ્લા સમય અમે
આ સંદર્ભમાં અંદર શોધવામાં

13
00:00:39,440 --> 00:00:40,450
વિચારોનું નંબર.

14
00:00:40,450 --> 00:00:43,010
>> આ, સ્મૃતિ, ખૂબ જ હતો
પ્રથમ કાર્યક્રમ અમે અંતે હતા.

15
00:00:43,010 --> 00:00:45,710
અને આ કાર્યક્રમ, તદ્દન સરળ,
છાપે, "હેલો, વિશ્વ."

16
00:00:45,710 --> 00:00:47,730
પરંતુ ત્યાં ખૂબ જ
અવાસ્તવિક જાદુ પર જવાનું.

17
00:00:47,730 --> 00:00:51,460
આ # સમાવેશ થાય છે છે
આ કોણ કૌંસ સાથે.

18
00:00:51,460 --> 00:00:52,170
ત્યાં પૂર્ણાંક છે.

19
00:00:52,170 --> 00:00:53,020
ત્યાં (રદબાતલ).

20
00:00:53,020 --> 00:00:56,330
કૌંસ, સર્પાકાર કૌંસ છે,
અર્ધ કોલોન ':', અને તેથી વધુ.

21
00:00:56,330 --> 00:00:58,480
>> અને તેથી, યાદ છે કે
અમે સ્ક્રેચ રજૂ

22
00:00:58,480 --> 00:01:02,110
કે જેથી અમે, આદર્શ રીતે, છેલ્લા જોઈ શકે
કે વાક્યરચના, સામગ્રી ખરેખર નથી કે

23
00:01:02,110 --> 00:01:04,590
બધા બુદ્ધિપૂર્વક
રસપ્રદ છે પરંતુ શરૂઆતમાં

24
00:01:04,590 --> 00:01:07,700
છે, સંપૂર્ણપણે, એક બીટ મુશ્કેલ
તમારા મન આસપાસ લપેટી.

25
00:01:07,700 --> 00:01:10,860
અને, ખરેખર, સૌથી સામાન્ય
વસ્તુઓ પર શરૂઆતમાં એક પ્રોગ્રામિંગ વર્ગ,

26
00:01:10,860 --> 00:01:13,443
ખાસ કરીને તે ઓછી માટે
આરામદાયક, દ્વારા હતાશ છે

27
00:01:13,443 --> 00:01:17,460
અને અમુક વાકયરચનામાં દ્વારા ટ્રિપ
ભૂલો, લોજિકલ ભૂલો ઉલ્લેખ નથી.

28
00:01:17,460 --> 00:01:19,800
અને અમારા ગોલ વચ્ચે એટલી
આજે, ખરેખર, વસિયતનામું

29
00:01:19,800 --> 00:01:23,280
કેટલાક સાથે તમે સજ્જ હશે
કેવી રીતે સમસ્યા હલ કરનારા તકનીકો

30
00:01:23,280 --> 00:01:26,705
સારી સમસ્યાઓ પોતાને હલ કરવા માટે
ડિબગીંગ સ્વરૂપ છે.

31
00:01:26,705 --> 00:01:29,330
અને તમે યાદ પડશે કે, પણ,
પર્યાવરણ હોય છે કે અમે રજૂ

32
00:01:29,330 --> 00:01:31,780
છેલ્લા સમય CS50 IDE તરીકે ઓળખાતું હતું.

33
00:01:31,780 --> 00:01:34,850
આ વેબ આધારિત સોફ્ટવેર છે કે
તમે મેઘ કાર્યક્રમ માટે પરવાનગી આપે છે

34
00:01:34,850 --> 00:01:38,450
તેથી વાત કરવા માટે જ્યારે બધા રાખવા તમારા
સાથે મળીને ફાઇલો, કારણ કે અમે આજે ફરી કરશે.

35
00:01:38,450 --> 00:01:41,480
અને તે આપણે યાદ
અહીં આ મુદ્દાઓ પુનરાવર્તન,

36
00:01:41,480 --> 00:01:44,480
તેમની વચ્ચે કાર્યો, અને આંટીઓ, અને
ચલો, અને બુલિયન સમીકરણો,

37
00:01:44,480 --> 00:01:45,110
અને શરતો.

38
00:01:45,110 --> 00:01:49,190
અને ખરેખર થોડા વધારે છે કે અમે
સ્ક્રેચ વિશ્વમાં અનુવાદિત

39
00:01:49,190 --> 00:01:50,800
સી વિશ્વમાં

40
00:01:50,800 --> 00:01:53,220
>> પરંતુ મૂળભૂત મકાન
બ્લોક્સ, તેથી વાત કરવા માટે

41
00:01:53,220 --> 00:01:55,150
ખરેખર હજુ પણ એ જ છેલ્લા અઠવાડિયે હતા.

42
00:01:55,150 --> 00:01:57,900
એક હકીકતમાં, અમે ખરેખર માત્ર હતી
વિવિધ પઝલ ભાગ, જો તમે કરશે.

43
00:01:57,900 --> 00:02:00,300
કે જાંબલી બદલે
બ્લોક સેવ, અમે તેના બદલે

44
00:02:00,300 --> 00:02:02,940
printf હતી, જે
સી માં આ કાર્ય કે

45
00:02:02,940 --> 00:02:05,890
તમે કંઈક છાપવા માટે પરવાનગી આપે
અને સ્ક્રીન પર તે બંધારણ.

46
00:02:05,890 --> 00:02:07,950
અમે CS50 રજૂ
લાયબ્રેરી, જ્યાં તમે

47
00:02:07,950 --> 00:02:11,420
તમારા નિકાલ get_char હવે હોય છે,
અને get_int, અને get_string,

48
00:02:11,420 --> 00:02:14,610
અને થોડા અન્ય કાર્યો
વેલ, જે દ્વારા તમે ઇનપુટ મેળવી શકો છો

49
00:02:14,610 --> 00:02:16,260
વપરાશકર્તા પોતાના કીબોર્ડ છે.

50
00:02:16,260 --> 00:02:20,640
અને અમે પણ વસ્તુઓ પર એક નજર લીધો
these- bool, અને ઘરનાં પરચૂરણ કામો જેવા,

51
00:02:20,640 --> 00:02:22,490
અને ડબલ, ફ્લોટ,
પૂર્ણાંક, long_long શબ્દમાળા.

52
00:02:22,490 --> 00:02:25,170
અને ત્યાં સી માં પણ અન્ય ડેટા પ્રકારો

53
00:02:25,170 --> 00:02:28,560
>> અન્ય શબ્દોમાં, જ્યારે તમે જાહેર માં
એક ચલ કેટલાક કિંમત સંગ્રહવા માટે,

54
00:02:28,560 --> 00:02:32,600
અથવા જ્યારે તમે એક કાર્ય અમલ
કે અમુક કિંમત આપે છે,

55
00:02:32,600 --> 00:02:35,290
તમે શું સ્પષ્ટ કરી શકો છો
કિંમત છે કે જે પ્રકાર.

56
00:02:35,290 --> 00:02:37,310
તે એક સ્ટ્રિંગ છે, જેમ
અક્ષરો ક્રમ?

57
00:02:37,310 --> 00:02:39,490
તે પૂર્ણાંક જેવા એક નંબર છે?

58
00:02:39,490 --> 00:02:41,390
તે અપૂર્ણાંક બિંદુ છે
કિંમત, અથવા જેમ?

59
00:02:41,390 --> 00:02:46,180
તેથી સી, ​​સ્ક્રેચ વિપરીત, અમે ખરેખર
માહિતી કેવા પ્રકારની સ્પષ્ટ કરવા માટે શરૂ કર્યું

60
00:02:46,180 --> 00:02:48,330
અમે પરત અથવા ઉપયોગ કરતા હતા.

61
00:02:48,330 --> 00:02:51,910
>> પરંતુ, અલબત્ત, અમે પણ સપડાઇ
કમ્પ્યુટિંગ કેટલાક મૂળભૂત મર્યાદા.

62
00:02:51,910 --> 00:02:54,100
અને ખાસ કરીને,
આ ભાષા સી, સ્મૃતિ

63
00:02:54,100 --> 00:02:57,070
અમે જોતા હતા કે
પૂર્ણાંક ઓવરફ્લો, વાસ્તવિકતા

64
00:02:57,070 --> 00:03:00,460
કે જો તમે માત્ર એક જ
મેમરી મર્યાદિત રકમ

65
00:03:00,460 --> 00:03:04,600
અથવા, ખાસ કરીને, મર્યાદિત નંબર
બિટ્સ, તમે માત્ર જેથી ઊંચી ગણતરી કરી શકે છે.

66
00:03:04,600 --> 00:03:08,460
અને તેથી અમે અહીં આ ઉદાહરણમાં પર જોવામાં
જેમાં એક વિમાન એક કાઉન્ટર,

67
00:03:08,460 --> 00:03:13,510
ખરેખર, જો પર્યાપ્ત લાંબા સમય સુધી થશે ચાલી
ઓવરફ્લો અને સોફ્ટવેર પરિણમી

68
00:03:13,510 --> 00:03:15,560
એક વાસ્તવિક ભૌતિક સંભવિત ભૂલ.

69
00:03:15,560 --> 00:03:18,600
>> અમે પણ ફ્લોટિંગ જોવામાં
બિંદુ અશુદ્ધિ, વાસ્તવિકતા

70
00:03:18,600 --> 00:03:22,280
માત્ર એક મર્યાદિત નંબર સાથે
બિટ્સ, શું તે 32 અથવા 64 છે,

71
00:03:22,280 --> 00:03:27,330
તમે માત્ર ઘણા નંબરો સ્પષ્ટ કરી શકો છો
એક દશાંશ બિંદુ પછી, જે પછી તમે

72
00:03:27,330 --> 00:03:29,110
અશુદ્ધ વિચાર શરૂ થાય છે.

73
00:03:29,110 --> 00:03:32,360
દાખલા તરીકે, એક તૃત્યાંશ તેથી
અહીં વિશ્વના, અમારા માનવ વિશ્વમાં,

74
00:03:32,360 --> 00:03:35,360
આપણે જાણીએ છીએ માત્ર એક અનંત નંબર છે
આ બાદ ચિહ્ન પછી 3s છે.

75
00:03:35,360 --> 00:03:38,820
પરંતુ કમ્પ્યૂટર જરૂરી નથી કરી શકો છો
નંબરો અનંત સંખ્યા પ્રતિનિધિત્વ

76
00:03:38,820 --> 00:03:42,590
જો તમે માત્ર પરવાનગી આપે છે તે કેટલાક
માહિતી મર્યાદિત જથ્થો.

77
00:03:42,590 --> 00:03:45,900
>> તેથી માત્ર અમે તમને સજ્જ હતી
શરતો વધારે શક્તિ સાથે

78
00:03:45,900 --> 00:03:49,280
કેવી રીતે તમે તમારી જાતને પર વ્યક્ત કરી શકે છે
પ્રોગ્રામિંગ દ્રષ્ટિએ કીબોર્ડ,

79
00:03:49,280 --> 00:03:51,430
અમે પણ મર્યાદિત શું
તમે ખરેખર કરી શકો છો.

80
00:03:51,430 --> 00:03:55,790
અને ખરેખર, ભૂલો અને ભૂલો કરી શકો છો
મુદ્દાઓ તે પ્રકારના માંથી પેદા થાય છે.

81
00:03:55,790 --> 00:03:59,900
અને ખરેખર, વિષયો વચ્ચે આજે
ડિબગીંગ જેવા વિષયો હશે આવે છે

82
00:03:59,900 --> 00:04:03,699
અને ખરેખર હૂડ નીચે જોઈ
કેવી રીતે વસ્તુઓ રજૂ કરવામાં આવ્યા હતા છેલ્લા અઠવાડિયે

83
00:04:03,699 --> 00:04:05,490
ખરેખર અમલ કરવામાં આવે છે
કે જેથી તમે વધુ સારી રીતે

84
00:04:05,490 --> 00:04:10,530
સમજી બંને ક્ષમતાઓ અને
સી જેવા ભાષા મર્યાદાઓ

85
00:04:10,530 --> 00:04:14,770
>> અને હકીકતમાં, અમે પાછા છાલ સ્તરો પડશે
માહિતી માળખું સરળ,

86
00:04:14,770 --> 00:04:17,756
કંઈક ઝાકઝમાળ કહેવાય છે, જે
સ્ક્રેચ એક કૉલ થાય છે "યાદી."

87
00:04:17,756 --> 00:04:19,589
તે થોડો છે
તે સંદર્ભમાં અલગ છે.

88
00:04:19,589 --> 00:04:23,340
અને પછી અમે પણ એક રજૂ કરીશું
અમારા ડોમેન ચોક્કસ સમસ્યાઓ પ્રથમ

89
00:04:23,340 --> 00:04:26,790
CS50 માં, વિશ્વના
ક્રિપ્ટોગ્રાફી, મૂંઝાયેલું ઓફ આર્ટ

90
00:04:26,790 --> 00:04:29,650
અથવા તેથી માહિતી સંકેત
તમે ગુપ્ત સંદેશાઓ મોકલી શકો છો કે

91
00:04:29,650 --> 00:04:34,520
અને ગુપ્ત સંદેશાઓ સાંકેતિક લખાણ વાંચવું
બે વ્યક્તિઓ, એ અને બી વચ્ચે

92
00:04:34,520 --> 00:04:37,490
>> તેથી અમે સંક્રમણ પહેલાં
કે નવા વિશ્વમાં,

93
00:04:37,490 --> 00:04:42,059
ચાલો કેટલાક સાથે સજ્જ કરવાનો પ્રયાસ કરીએ
જે ટેકનિક સાથે તમે દૂર કરી શકો છો

94
00:04:42,059 --> 00:04:43,850
અથવા ઓછામાં ઓછા કેટલાક ઘટાડવા
હતાશા

95
00:04:43,850 --> 00:04:46,630
તમે કદાચ આવી છે કે
છેલ્લા અઠવાડિયે એકલા પર.

96
00:04:46,630 --> 00:04:50,830
હકીકતમાં, તમે આગળ કેટલાક such-- છે
સી અને મતભેદ તમારા પ્રથમ સમસ્યાઓ છે,

97
00:04:50,830 --> 00:04:54,010
જો તમે મારી જેમ છો, પ્રથમ વખત
તમે એક કાર્યક્રમ બહાર લખો કરવાનો પ્રયાસ કરો,

98
00:04:54,010 --> 00:04:57,330
પણ જો તમે તાર્કિક લાગે
કાર્યક્રમ ખૂબ સરળ છે,

99
00:04:57,330 --> 00:05:01,200
તમે ખૂબ જ સારી રીતે દિવાલ હિટ કરી શકે છે, અને
કમ્પાઇલર સહકાર નથી જઈ રહ્યા છે.

100
00:05:01,200 --> 00:05:03,940
બનાવો અથવા રણકાર નથી જઈ રહ્યા છે
ખરેખર તમારી બોલી કરવા માટે.

101
00:05:03,940 --> 00:05:05,450
>> અને શા માટે છે કે હોઈ શકે છે?

102
00:05:05,450 --> 00:05:07,950
વેલ, ચાલો એક નજર કરીએ
કદાચ, એક સરળ પ્રોગ્રામ.

103
00:05:07,950 --> 00:05:11,190
હું આગળ જાઓ અને આ સેવ કરવા જઇ રહ્યો છું
ફાઇલ ઇરાદાપૂર્વક buggy0.c કહેવાય છે,

104
00:05:11,190 --> 00:05:13,590
કારણ કે હું તે ખબર
અગાઉથી અપૂર્ણ શકાય છે.

105
00:05:13,590 --> 00:05:17,400
પરંતુ હું ખ્યાલ છે કે જો આ ન શકે
પ્રથમ કે બીજા કે ત્રીજા કાર્યક્રમ છે

106
00:05:17,400 --> 00:05:18,830
કે હું ખરેખર મારી જાતને બનાવવા છું.

107
00:05:18,830 --> 00:05:23,820
તેથી હું આગળ જાઓ જાઉં છું અને
બહાર લખો, પૂર્ણાંક મુખ્ય (રદબાતલ).

108
00:05:23,820 --> 00:05:28,130
અને પછી મારી સર્પાકાર કૌંસ ની અંદર,
એક ખૂબ જ પરિચિત ( "હેલો, world--

109
00:05:28,130 --> 00:05:30,980
બેકસ્લેશ, એ ") - અને અર્ધવિરામ.

110
00:05:30,980 --> 00:05:32,360
>> હું ફાઈલ સાચવી લીધો છે.

111
00:05:32,360 --> 00:05:34,850
હવે હું નીચે જવા માટે જઇ રહ્યો છું
મારી ટર્મિનલ વિન્ડોમાં

112
00:05:34,850 --> 00:05:40,340
અને પ્રકાર બનાવવા buggy0, કારણ કે, ફરી,
આજે ફાઈલ નામ buggy0.c છે.

113
00:05:40,340 --> 00:05:43,660
તેથી હું buggy0 બનાવવા માટે, દાખલ કરો લખો.

114
00:05:43,660 --> 00:05:48,200
>> અને, ઓહ, Gosh, છેલ્લા સમય યાદ
કે કોઈ ભૂલ સંદેશાઓ એક સારી બાબત છે.

115
00:05:48,200 --> 00:05:49,740
જેથી કોઈ આઉટપુટ એક સારી બાબત છે.

116
00:05:49,740 --> 00:05:52,920
પરંતુ અહીં હું સ્પષ્ટ છે
ભૂલો કેટલાક નંબર.

117
00:05:52,920 --> 00:05:56,470
>> આઉટપુટ પ્રથમ વાક્ય તેથી
buggy0 બનાવવા લખીને પછી, સ્મૃતિ,

118
00:05:56,470 --> 00:05:59,540
રણકાર એકદમ વર્બોઝ આઉટપુટ છે.

119
00:05:59,540 --> 00:06:02,067
હૂડ નીચે,
CS50 IDE રૂપરેખાંકિત થયેલ છે

120
00:06:02,067 --> 00:06:04,150
સમગ્ર ટોળું વાપરવા માટે
આ કમ્પાઈલર સાથે વિકલ્પો

121
00:06:04,150 --> 00:06:05,941
જેથી તમે નથી કે
તેમને વિશે વિચારો.

122
00:06:05,941 --> 00:06:08,840
અને તે બધા છે કે પ્રથમ વાક્ય છે
અર્થ એ થાય કે રણકાર સાથે શરૂ થાય છે.

123
00:06:08,840 --> 00:06:11,720
>> પરંતુ તે પછી, સમસ્યાઓ
તેમના દેખાવ બનાવવા માટે શરૂ થાય છે.

124
00:06:11,720 --> 00:06:17,390
રેખા 3, પાત્ર પર Buggy0.c
5, ત્યાં એક મોટું, લાલ ભૂલ છે.

125
00:06:17,390 --> 00:06:18,380
પેલું શું છે?

126
00:06:18,380 --> 00:06:23,562
સર્વથા પુસ્તકાલય કાર્ય જાહેર
પ્રકાર પૂર્ણાંક (const ઘરનાં પરચૂરણ કામો * printf,

127
00:06:23,562 --> 00:06:26,050
...) [-Werror].

128
00:06:26,050 --> 00:06:28,379
હું ખૂબ જ ઝડપથી તેનો અર્થ, તે
ખૂબ જ Arcane નોંધાયો નહીં.

129
00:06:28,379 --> 00:06:30,170
અને ચોક્કસપણે, ખાતે પ્રથમ
નજરમાં, અમે નહીં કરશે

130
00:06:30,170 --> 00:06:32,380
તમે સમજી અપેક્ષા
તે સંદેશ સમગ્ર.

131
00:06:32,380 --> 00:06:34,213
અને તેથી પાઠ એક
આજે ચાલુ છે માટે

132
00:06:34,213 --> 00:06:36,919
નોટિસ પ્રયાસ હોઈ
પેટર્ન, અથવા સમાન વસ્તુઓ,

133
00:06:36,919 --> 00:06:38,960
ભૂલો માટે તમે હોઈ શકે છે
ભૂતકાળમાં આવી.

134
00:06:38,960 --> 00:06:41,335
તો ચાલો સિવાય માત્ર પીંજવું
તે શબ્દો પરિચિત જુઓ.

135
00:06:41,335 --> 00:06:44,290
મોટું, લાલ ભૂલ સ્પષ્ટ છે
કંઈક સાંકેતિક ખોટું છે.

136
00:06:44,290 --> 00:06:47,940
>> સર્વથા જાહેર
પુસ્તકાલય કાર્ય printf.

137
00:06:47,940 --> 00:06:51,680
તેથી તો પણ હું ખૂબ નથી સમજી નથી શું
સર્વથા પુસ્તકાલય કાર્ય જાહેર

138
00:06:51,680 --> 00:06:54,900
અર્થ, સમસ્યા ચોક્કસ
કોઈક printf સાથે સંબંધિત છે.

139
00:06:54,900 --> 00:06:59,130
અને તે મુદ્દો સ્ત્રોત
તે જાહેર સાથે શું કરવું છે.

140
00:06:59,130 --> 00:07:02,440
>> જાહેર કાર્ય છે
પ્રથમ વખત માટે તે ઉલ્લેખ.

141
00:07:02,440 --> 00:07:06,210
અને અમે ગયા સપ્તાહે પરિભાષા વપરાય
એક કાર્ય પ્રોટોટાઇપ જાહેર,

142
00:07:06,210 --> 00:07:11,860
ક્યાં ટોચ પર એક વાક્ય સાથે તમારા
પોતાના ફાઈલ અથવા કહેવાતા હેડર ફાઈલ છે.

143
00:07:11,860 --> 00:07:15,300
અને શું ફાઈલ આપણે કહી હતી
છેલ્લા અઠવાડિયે કે printf ભાવ છે,

144
00:07:15,300 --> 00:07:17,080
અવતરણ ચિહ્નો પૂરાં કરવાં, જાહેર?

145
00:07:17,080 --> 00:07:20,950
શું ફાઈલ તેના પ્રોટોટાઇપ છે?

146
00:07:20,950 --> 00:07:24,640
>> તેથી જો તમે યાદ, ખૂબ પ્રથમ વસ્તુ હું
ટાઇપ, લગભગ દરેક કાર્યક્રમ છેલ્લા સમય

147
00:07:24,640 --> 00:07:30,790
અને આકસ્મિક એક ક્ષણ પહેલા શરૂ
myself-- લખીને આ એક અહીં હતી

148
00:07:30,790 --> 00:07:38,630
hash-- # સમાવેશ થાય છે <stio-- માટે
ઇનપુટ / આઉટપુટ ટપકું એચ અને ખરેખર,

149
00:07:38,630 --> 00:07:41,860
જો હું હવે આ ફાઈલ સંગ્રહો, હું જાઉં છું
આગળ જાઓ અને મારા સ્ક્રીન સાફ કરવા માટે,

150
00:07:41,860 --> 00:07:44,740
તમે લખીને કરી શકો છો કે જે
સાફ કરો, અથવા તમે નિયંત્રણ એલ પકડી શકે છે,

151
00:07:44,740 --> 00:07:47,680
ફક્ત તમારા ટર્મિનલ વિન્ડો સાફ કરવા માટે
માત્ર કેટલાક ક્લટર દૂર કરે છે.

152
00:07:47,680 --> 00:07:51,370
>> હું આગળ જાઓ જાઉં છું અને
ફરીથી પ્રકાર બનાવવા buggy0, દાખલ કરો.

153
00:07:51,370 --> 00:07:53,790
અને વોઇલા Query, હું હજુ પણ છે કે જે જોઈ
રણકાર લાંબા આદેશ,

154
00:07:53,790 --> 00:07:55,470
પરંતુ ત્યાં કોઈ ભૂલ સંદેશો આ સમય છે.

155
00:07:55,470 --> 00:07:58,800
અને ખરેખર, જો હું ./buggy0 કરવા માટે,
માત્ર છેલ્લા સમય જેવી,

156
00:07:58,800 --> 00:08:01,860
જ્યાં કોઈ આ અર્થ એ થાય
ડિરેક્ટરી, સ્લેશે માત્ર અર્થ એ થાય,

157
00:08:01,860 --> 00:08:05,040
અહીં કાર્યક્રમ નામ આવે છે અને
કાર્યક્રમ કે નામ buggy0 છે,

158
00:08:05,040 --> 00:08:07,340
દાખલ કરો, "હેલો, વિશ્વ."

159
00:08:07,340 --> 00:08:09,440
>> હવે, તમે કેવી રીતે હોય શકે છે
આ ઉકેલ મેળવાયેલ

160
00:08:09,440 --> 00:08:12,017
વગર જરૂરી
ઘણા શબ્દો માન્યતા

161
00:08:12,017 --> 00:08:14,350
હું કર્યું, ચોક્કસપણે, કર્યા
ઘણા વર્ષો સુધી આ કર્યું?

162
00:08:14,350 --> 00:08:18,720
વેલ, પ્રથમ સમસ્યા દીઠ ખ્યાલ
સમૂહ, અમે તમને એક આદેશ દાખલ

163
00:08:18,720 --> 00:08:21,175
કે CS50 પોતાના સ્ટાફ
help50 કહેવાય લખ્યું હતું.

164
00:08:21,175 --> 00:08:24,300
અને ખરેખર, સી માટે સ્પષ્ટીકરણ કરે છે
સમસ્યા આ કેવી રીતે ઉપયોગ કરવા માટે સુયોજિત કરો.

165
00:08:24,300 --> 00:08:27,210
>> પરંતુ help50 અનિવાર્યપણે છે
એક કાર્યક્રમ છે કે જે CS50 સ્ટાફ

166
00:08:27,210 --> 00:08:30,850
તમે ચલાવવા માટે લખ્યું છે કે પરવાનગી આપે છે
આદેશ અથવા કાર્યક્રમ ચલાવો,

167
00:08:30,850 --> 00:08:36,169
અને જો તમે સમજી નથી તેની
આઉટપુટ, help50 તેના આઉટપુટ પસાર કરવા માટે

168
00:08:36,169 --> 00:08:38,890
જે સોફ્ટવેર નિર્દેશ
કે કોર્સ સ્ટાફ લખ્યું

169
00:08:38,890 --> 00:08:42,429
તમારા કાર્યક્રમ આઉટપુટ પર દેખાશે
વાક્ય દ્વારા વાક્ય અક્ષર દ્વારા પાત્ર.

170
00:08:42,429 --> 00:08:46,000
અને જો આપણે, સ્ટાફ, ઓળખી
કે તમે અનુભવી રહ્યા છો ભૂલ સંદેશ,

171
00:08:46,000 --> 00:08:50,580
અમે કેટલાક સાથે તમે ઉત્તેજિત કરવા માટે પ્રયત્ન કરશે
રેટરિકલ પ્રશ્નો, કેટલાક સલાહ સાથે,

172
00:08:50,580 --> 00:08:54,890
ખૂબ એક ટીએફ અથવા CA અથવા મારી જેમ
ઓફિસ કલાકો વ્યક્તિ કરી શકે છે.

173
00:08:54,890 --> 00:08:58,320
>> તેથી help50 નજર જો તમે ન કરતા
જરૂરી સમસ્યા ઓળખી કાઢે છે.

174
00:08:58,320 --> 00:09:00,790
પરંતુ તે પર આધાર રાખે છે નથી
એક ઘોડી તરીકે ખૂબ.

175
00:09:00,790 --> 00:09:03,990
ચોક્કસપણે સમજવા પ્રયત્ન કરો તેના
આઉટપુટ અને પછી તે જાણવા

176
00:09:03,990 --> 00:09:07,571
જેથી માત્ર એક કે બે વાર તમે શું
ક્યારેય ચોક્કસ ભૂલ માટે help50 ચલાવવા

177
00:09:07,571 --> 00:09:08,070
સંદેશ.

178
00:09:08,070 --> 00:09:10,660
કે પછી, તમે પ્રયત્ન કરીશું
તમારી જાતને વધુ સારી રીતે સજ્જ

179
00:09:10,660 --> 00:09:13,180
બહાર આકૃતિ તે શું ખરેખર છે.

180
00:09:13,180 --> 00:09:14,350
>> અહીં અન્ય એક કરીએ.

181
00:09:14,350 --> 00:09:20,410
મને આગળ જાઓ, અને અન્ય દો
ફાઇલ અમે આ buggy1.c કહી શકશો.

182
00:09:20,410 --> 00:09:23,110
અને આ ફાઈલની હું છું
deliberately-- કરવા જઇ

183
00:09:23,110 --> 00:09:26,330
પરંતુ ડોળ કરવો કે હું નથી
સમજો છો શું ભૂલ હું કર્યા છે.

184
00:09:26,330 --> 00:09:31,420
>> હું આગળ વધો અને આ કરવા જઇ રહ્યો છું
# સમાવેશ થાય છે, કારણ કે હું કર્યું

185
00:09:31,420 --> 00:09:33,660
એક ક્ષણ પહેલા મારા પાઠ શીખ્યા.

186
00:09:33,660 --> 00:09:36,220
ઈન્ મુખ્ય (રદબાતલ), પહેલાં.

187
00:09:36,220 --> 00:09:40,880
અને પછી અહીં હું જાઉં છું
શબ્દમાળા ઓ કરવું - get_string.

188
00:09:40,880 --> 00:09:43,770
અને છેલ્લા સમય યાદ છે કે
આ માધ્યમ, હેય, કોમ્પ્યુટર,

189
00:09:43,770 --> 00:09:48,280
મને એક ચલ આપે છે, તે ઓ કૉલ, અને
કે ચલ એક શબ્દમાળા પ્રકાર બનાવવા

190
00:09:48,280 --> 00:09:50,150
તેથી હું તેને એક અથવા વધુ શબ્દો સ્ટોર કરી શકો છો.

191
00:09:50,150 --> 00:09:52,191
>> અને પછી જમણી બાજુ પર
સમાન સાઇન બાજુ

192
00:09:52,191 --> 00:09:54,980
get_string છે, કે જે છે
CS50 પુસ્તકાલય કાર્ય

193
00:09:54,980 --> 00:09:55,980
બરાબર છે કે જે કરે છે.

194
00:09:55,980 --> 00:09:59,740
તે કાર્ય અને પછી નહીં
જમણેથી હાથ છોડી છે.

195
00:09:59,740 --> 00:10:02,670
તેથી આ સમાન સાઇન અર્થ એ નથી
"બરાબર" અમે ગણિતના લાગે શકે છે.

196
00:10:02,670 --> 00:10:04,750
તે જમણેથી ડાબી સોંપણી થાય છે.

197
00:10:04,750 --> 00:10:09,640
તેથી આ અર્થ એ છે, શબ્દમાળા લેવા
વપરાશકર્તા અને તે ઓ અંદર સ્ટોર કરે છે.

198
00:10:09,640 --> 00:10:10,460
>> હવે તેનો ઉપયોગ કરીએ.

199
00:10:10,460 --> 00:10:13,820
મને આગળ હવે જાઓ બીજા દો
વાક્ય, મને આગળ વધો અને કહે છે "હેલો" દો -

200
00:10:13,820 --> 00:10:19,330
નથી "વિશ્વમાં," પણ "હેલો,% s--
જે અમારા પ્લેસહોલ્ડર, અલ્પવિરામ ઓ છે,

201
00:10:19,330 --> 00:10:22,030
જે અમારા ચલ છે,
અને પછી અર્ધવિરામ.

202
00:10:22,030 --> 00:10:26,070
તેથી જો હું ખૂબ જ સ્ક્રૂ ન હતી
અહીં, આ યોગ્ય કોડ જેવો દેખાય છે.

203
00:10:26,070 --> 00:10:28,090
>> અને મારી વૃત્તિ હવે તે કમ્પાઇલ છે.

204
00:10:28,090 --> 00:10:30,400
ફાઇલ buggy1.c કહેવામાં આવે છે.

205
00:10:30,400 --> 00:10:33,770
તેથી હું buggy1 બનાવવા માટે, દાખલ કરો જાઉં છું.

206
00:10:33,770 --> 00:10:36,377
અને રફૂ તે, જો નહિ હોય
પહેલાં કરતાં પણ વધુ ભૂલો.

207
00:10:36,377 --> 00:10:38,210
હું તેનો અર્થ, ત્યાં વધુ છે
ભૂલ સંદેશાઓ તે કરશે

208
00:10:38,210 --> 00:10:40,400
આ કાર્યક્રમ વાસ્તવિક લાઇન કરતા લાગે છે.

209
00:10:40,400 --> 00:10:42,730
>> પરંતુ અહીં takeaway છે,
પણ જો તમે ભરાઈ ગયાં છો

210
00:10:42,730 --> 00:10:45,040
બે અથવા ત્રણ અથવા
ચાર વધુ ભૂલ સંદેશાઓ,

211
00:10:45,040 --> 00:10:48,340
ખૂબ જ પર હંમેશા ધ્યાન કેન્દ્રિત
તે સંદેશાઓ પ્રથમ.

212
00:10:48,340 --> 00:10:52,220
ટોચ સૌથી એક અંતે છીએ,
બેક અપ જરૂર સરકાવનાર છે.

213
00:10:52,220 --> 00:10:53,930
તેથી અહીં હું બનાવવા buggy1 લખ્યો.

214
00:10:53,930 --> 00:10:55,700
અહીં રણકાર આઉટપુટ ઈચ્છિત તરીકે છે.

215
00:10:55,700 --> 00:10:57,290
>> અને અહીં પ્રથમ લાલ ભૂલ છે.

216
00:10:57,290 --> 00:11:02,370
બિનજાહેર ઓળખકર્તા ઉપયોગ
શબ્દમાળા, હું પ્રમાણભૂત કહેવા માંગતા હતા?

217
00:11:02,370 --> 00:11:04,260
તેથી સ્ટાન્ડર્ડ છે
ખરેખર કંઈક બીજું.

218
00:11:04,260 --> 00:11:06,240
તે વપરાશકર્તાની ઉલ્લેખ કરે છે
કીબોર્ડ, અનિવાર્યપણે.

219
00:11:06,240 --> 00:11:08,080
>> પરંતુ હું શું અર્થ થાય છે.

220
00:11:08,080 --> 00:11:11,770
હું શબ્દમાળા અર્થ થાય છે, અને હું get_string અર્થ થાય છે.

221
00:11:11,770 --> 00:11:16,200
તેથી તે શું છે કે હું
આ સમય કરવા માટે ભૂલી ગયા છો?

222
00:11:16,200 --> 00:11:20,230
આ સમય શું ખૂટે છે?

223
00:11:20,230 --> 00:11:23,600
હું મારા # સમાવેશ થાય છે છે,
તેથી હું printf વપરાશ હોય છે.

224
00:11:23,600 --> 00:11:26,090
>> પરંતુ હું શું નથી
હજુ સુધી ઍક્સેસ?

225
00:11:26,090 --> 00:11:29,420
વેલ, માત્ર છેલ્લા સમય જેવી,
હું કમ્પાઇલર કહેવું જરૂર

226
00:11:29,420 --> 00:11:31,691
રણકાર શું આ વિધેયો છે.

227
00:11:31,691 --> 00:11:33,940
Get_string ન કરવામાં આવે તો
સી અને ખાસ કરીને, તે

228
00:11:33,940 --> 00:11:38,160
માં આવવું નથી
, ફાઇલ હેડરમાં.

229
00:11:38,160 --> 00:11:40,770
તે જગ્યાએ આવે છે
કંઈક સ્ટાફ લખ્યું હતું કે,

230
00:11:40,770 --> 00:11:44,176
જે એક અલગ ફાઈલ છે
નામ પરંતુ યોગ્ય રીતે નામ આપવામાં આવ્યું.

231
00:11:44,176 --> 00:11:46,990

232
00:11:46,990 --> 00:11:50,861
>> તેથી માત્ર એક લીટી કે ઉમેરીને
છેલ્લા સમય થી code-- બોલાવવાનો

233
00:11:50,861 --> 00:11:53,610
જ્યારે રણકાર ચાલે છે, તે રહ્યું છે
નીચે મારી કોડ ટોચ પર જોવા માટે,

234
00:11:53,610 --> 00:11:54,193
જમણે.

235
00:11:54,193 --> 00:11:57,200
તે નોટિસ રહ્યું છે
ઓહ, તમે કરવા માંગો છો.

236
00:11:57,200 --> 00:11:59,900
મને જવા અને તે શોધવા દો,
ત્યાં તે સર્વર પર છે,

237
00:11:59,900 --> 00:12:03,090
નકલ અને પેસ્ટ, અનિવાર્યપણે,
તમારા પોતાના ફાઈલ ટોચ માં

238
00:12:03,090 --> 00:12:06,820
જેથી વાર્તામાં આ બિંદુએ,
રેખા 1, કાર્યક્રમ બાકીના

239
00:12:06,820 --> 00:12:11,651
ખરેખર, કાર્યો કોઇ પણ ઉપયોગ કરી શકો છો
તેમાં તેમને વચ્ચે get_string.

240
00:12:11,651 --> 00:12:13,650
તેથી હું અવગણો જાઉં છું
તે ભૂલો બાકીના

241
00:12:13,650 --> 00:12:17,190
કારણ કે હું ખરેખર, કે જે માત્ર શંકા
પ્રથમ એક ખરેખર mattered.

242
00:12:17,190 --> 00:12:20,780
અને હું આગળ અને પુનઃ ચલાવો જાઓ જાઉં છું
મારા ફાઈલ બચત પછી buggy1 બનાવવા.

243
00:12:20,780 --> 00:12:22,580
અને વોઇલા Query, તે કામ કર્યું.

244
00:12:22,580 --> 00:12:29,200
અને જો હું ./buggy1 કરવું અને માં પ્રકાર માટે
દાખલા તરીકે, Zamyla, હું હવે હેલો મળશે,

245
00:12:29,200 --> 00:12:32,000
Zamyla, તેના બદલે હેલો, વિશ્વ.

246
00:12:32,000 --> 00:12:32,550
>> બધા અધિકાર.

247
00:12:32,550 --> 00:12:35,890
તેથી અહીં ટેકઅવે પછી હોય છે,
એક, તરીકે ખૂબ તરીકે તમે કરી શકો છો તરીકે છૂટુંછવાયું, વેરાયેલું એકઠું કરવાનો પ્રયાસ કરો

248
00:12:35,890 --> 00:12:39,140
એકલા ભૂલ સંદેશાઓ થી, જોઈ
ઓળખી અમુક શબ્દો પર.

249
00:12:39,140 --> 00:12:43,070
કે સિવાય, દીઠ help50 ઉપયોગ
સમસ્યા સેટ સ્પષ્ટીકરણ.

250
00:12:43,070 --> 00:12:46,500
પરંતુ સિવાય કે, પણ, હંમેશા જોવા
ટોચ ભૂલ જ છે, ઓછામાં ઓછા

251
00:12:46,500 --> 00:12:50,051
શરૂઆતમાં, તે જોવા માટે માહિતી
તે ખરેખર પેદા કરી શકે છે.

252
00:12:50,051 --> 00:12:52,300
પરંતુ તે ત્યાં છે બહાર વળે
હજુ પણ વધુ કાર્યક્ષમતા બાંધવામાં

253
00:12:52,300 --> 00:12:55,030
CS50 પુસ્તકાલય મદદ કરવા માટે
તમે શરૂઆતમાં સત્ર માં

254
00:12:55,030 --> 00:12:57,580
અને શરૂઆતમાં પ્રોગ્રામિંગ
બહાર આકૃતિ શું ખોટું થઈ રહ્યું છે.

255
00:12:57,580 --> 00:12:59,840
તેથી આપણે અન્ય ઉદાહરણ કરવા દો અહીં.

256
00:12:59,840 --> 00:13:04,350
હું, કે જે આ buggy2 કૉલ જાઉં છું,
ફરીથી, બહાર અપૂર્ણ કરી રહ્યું છે

257
00:13:04,350 --> 00:13:05,650
દ્વાર, ડિઝાઇન દ્વારા.

258
00:13:05,650 --> 00:13:09,980
>> અને હું આગળ જાઓ જાઉં છું
અને # સમાવેશ થાય છે નથી.

259
00:13:09,980 --> 00:13:12,580
અને પછી હું પૂર્ણાંક મુખ્ય (રદબાતલ) કરવા જાઉં છું.

260
00:13:12,580 --> 00:13:14,840
અને પછી હું લૂપ માટે કરવા જઇ રહ્યો છું.

261
00:13:14,840 --> 00:13:16,690
(હું પૂર્ણાંક _ 0.

262
00:13:16,690 --> 00:13:18,750
હું કરતાં ઓછી અથવા 10 સમાન છે.

263
00:13:18,750 --> 00:13:24,260
હું ++, અને પછી સર્પાકાર કૌંસ માં, હું જાઉં છું
છાપે અહીં માત્ર એક hashtag પ્રતીક

264
00:13:24,260 --> 00:13:25,920
અને એક નવી લાઇન પાત્ર.

265
00:13:25,920 --> 00:13:29,220
>> આ સાથે મારા ઉદ્દેશ તેથી
કાર્યક્રમ તદ્દન સરળ છે

266
00:13:29,220 --> 00:13:33,150
10 વખત ફરી વળવું
અને દરેક ઇટરેશન પર

267
00:13:33,150 --> 00:13:35,260
કે લૂપ દરેક સમય
ચક્ર દ્વારા,

268
00:13:35,260 --> 00:13:37,660
એક hashtag છાપે,
એક hashtag, એક hashtag.

269
00:13:37,660 --> 00:13:40,480
હું કારણ કે એક લાઇન દીઠ
ત્યાં નવી લાઇન છે.

270
00:13:40,480 --> 00:13:42,787
અને તે માટે યાદ
લૂપ, છેલ્લા સપ્તાહના દીઠ

271
00:13:42,787 --> 00:13:44,620
અને તમે વધુ મળશે
સિન્ટેક્ષ સાથે પરિચિત

272
00:13:44,620 --> 00:13:47,170
અભ્યાસ સાથે ઉપયોગ કરીને
long-- પહેલાં આ મને આપે

273
00:13:47,170 --> 00:13:49,740
એક હું કહેવાય ચલ અને તે 0 થી સુયોજિત કરે છે.

274
00:13:49,740 --> 00:13:52,650
>> આ હું ઇન્ક્રીમેન્ટ
1 દ્વારા દરેક ઇટરેશન.

275
00:13:52,650 --> 00:13:54,940
તેથી હું 3 2 1 જાય છે.

276
00:13:54,940 --> 00:13:57,690
અને પછી આ સ્થિતિ માં
અર્ધ કોલોન ':' વચ્ચે મધ્યમ

277
00:13:57,690 --> 00:14:03,010
બનાવવા માટે દરેક ઇટરેશન પર ચકાસાયેલ નહીં
ખાતરી કરો કે અમે શ્રેણી અંદર હજુ પણ છે.

278
00:14:03,010 --> 00:14:06,830
તેથી હું 10 વખત ફરી વળવું માંગો છો, તેથી હું
છે સૉર્ટ ખૂબ તર્ક માત્ર

279
00:14:06,830 --> 00:14:09,070
10 મારા બંધાયેલ ઉપર ત્યાં મૂકો.

280
00:14:09,070 --> 00:14:14,310
>> અને હજુ સુધી, જ્યારે હું આ ચલાવો, પછી
મેક સાથે સંકલન buggy2--

281
00:14:14,310 --> 00:14:15,440
અને તે બરાબર કમ્પાઇલ નથી.

282
00:14:15,440 --> 00:14:17,980
તેથી હું નથી
સિંટેક્સ ભૂલ આ સમય.

283
00:14:17,980 --> 00:14:20,940
મને આગળ હવે જાઓ
અને buggy2 ચલાવવા માટે, દાખલ કરો.

284
00:14:20,940 --> 00:14:22,620
અને હવે સ્ક્રોલ કરો.

285
00:14:22,620 --> 00:14:24,890
અને મને વધારીએ
વિન્ડો માપ.

286
00:14:24,890 --> 00:14:33,720
>> હું હોય એવું લાગે છે 1, 2, 3,
4, 5, 6, 7, 8, 9, 10, 11.

287
00:14:33,720 --> 00:14:38,891
તેથી ત્યાં, 11 hashtags છે પણ તેમ છતાં
હું સ્પષ્ટ રીતે આ લૂપની અંદર 10 મૂકો.

288
00:14:38,891 --> 00:14:42,140
હવે, તમે કેટલાક તરત જ જોઈ શકે છે
શું ભૂલ છે, કારણ કે, ખરેખર, આ છે

289
00:14:42,140 --> 00:14:43,720
એક ખૂબ જ હાર્ડ ભૂલ કરી નથી.

290
00:14:43,720 --> 00:14:46,070
પરંતુ તે ખૂબ જ સામાન્ય છે
ખૂબ જ વહેલી કરી હતી.

291
00:14:46,070 --> 00:14:49,820
>> શું હું બહાર નિર્દેશ કરવા માંગો છો, જોકે,
કેવી રીતે હું આ બહાર આકૃતિ શકે છે?

292
00:14:49,820 --> 00:14:52,300
વેલ, તે તારણ છે કે
CS50 લાઇબ્રેરી આવે

293
00:14:52,300 --> 00:14:55,380
માત્ર get_string અને get_int સાથે
અને get_float અને અન્ય કાર્ય કરે છે.

294
00:14:55,380 --> 00:14:59,980
તે પણ એક ખાસ કાર્ય સાથે આવે છે
કહેવાય eprintf, અથવા, ભૂલ printf.

295
00:14:59,980 --> 00:15:03,270
અને તે જ અસ્તિત્વમાં બનાવવા માટે
તે તમારા માટે થોડી સરળ

296
00:15:03,270 --> 00:15:06,310
જ્યારે માત્ર તમારો કોડ ડિબગીંગ
સ્ક્રીન પર એક ભૂલ સંદેશો છાપો

297
00:15:06,310 --> 00:15:07,850
અને ખબર છે કે તે ક્યાંથી આવ્યો.

298
00:15:07,850 --> 00:15:11,000
>> તેથી દાખલા તરીકે, એક વસ્તુ હું કદાચ
અહીં શું આ કાર્ય સાથે આ છે

299
00:15:11,000 --> 00:15:20,230
eprintf, અને પછી હું આગળ જાઓ જાઉં છું
અને કહે છે કે હું હવે% છે હું, બેકસ્લેશ, એ.

300
00:15:20,230 --> 00:15:22,330
અને હું કિંમત પ્લગ કરવા જઇ રહ્યો છું.

301
00:15:22,330 --> 00:15:25,400
અને ઉપર, કારણ કે આ
CS50 પુસ્તકાલય છે,

302
00:15:25,400 --> 00:15:27,580
હું આગળ જાઓ જાઉં છું
અને સમાવેશ થાય છે

303
00:15:27,580 --> 00:15:29,169
તેથી હું આ કાર્ય કરવા માટે વપરાશ હોય છે.

304
00:15:29,169 --> 00:15:31,460
પરંતુ ચાલો લીટી
9 કરી શકાય તેવું માનવામાં આવે છે.

305
00:15:31,460 --> 00:15:32,670
હું આખરે આ કાઢી જાઉં છું.

306
00:15:32,670 --> 00:15:34,670
આ કરવા માટે કંઈ નથી
મારા બહુચર્ચિત ધ્યેય સાથે.

307
00:15:34,670 --> 00:15:39,090
પરંતુ eprintf, ભૂલ printf, માત્ર અર્થ છે
મને કેટલાક તપાસ માહિતી આપે છે.

308
00:15:39,090 --> 00:15:42,460
જ્યારે હું મારા કાર્યક્રમ ચલાવવા માટે, હું કરવા માંગો છો
કામચલાઉ સ્ક્રીન પર આ જુઓ

309
00:15:42,460 --> 00:15:44,550
તેમજ માત્ર સમજવા માટે
શું થઈ રહ્યું છે.

310
00:15:44,550 --> 00:15:47,330
>> અને, ખરેખર, દરેક
9 વાક્ય અહીં પુનરાવૃત્તિ

311
00:15:47,330 --> 00:15:49,260
હું જોવા માટે કરવા માંગો છો, i ની કિંમત શું છે?

312
00:15:49,260 --> 00:15:50,290
i ની કિંમત શું છે?

313
00:15:50,290 --> 00:15:51,280
i ની કિંમત શું છે?

314
00:15:51,280 --> 00:15:55,650
અને, આસ્થાપૂર્વક, હું માત્ર જોઈએ
કે સંદેશ, પણ, 10 વખત જોવા મળે છે.

315
00:15:55,650 --> 00:15:57,780
>> તેથી દો મને આગળ વધો અને
મારા કાર્યક્રમ પુનઃકમ્પાઈલ,

316
00:15:57,780 --> 00:15:59,905
હું કોઇ પણ સમયે કરી છે, કારણ કે
હું ફેરફાર કરે છે. ./buggy2.

317
00:15:59,905 --> 00:16:02,680

318
00:16:02,680 --> 00:16:03,640
અને now-- બરાબર.

319
00:16:03,640 --> 00:16:04,820
ત્યાં વધુ ઘણો પર જવાનું છે.

320
00:16:04,820 --> 00:16:07,610
તેથી મને ઉપર સ્ક્રોલ દો
એક પણ મોટી વિન્ડો.

321
00:16:07,610 --> 00:16:10,190
>> અને તમે જે દરેક જોશો
hashtags હજુ છાપવા છે.

322
00:16:10,190 --> 00:16:15,270
પરંતુ વચ્ચે તેમને દરેક હવે આ છે
તપાસ આઉટપુટ નીચે પ્રમાણે ફોર્મેટ.

323
00:16:15,270 --> 00:16:17,960
મારા કાર્યક્રમ અહીં નામ buggy2 છે.

324
00:16:17,960 --> 00:16:20,432
ફાઇલ નામ buggy2.c છે.

325
00:16:20,432 --> 00:16:24,080
લાઇન નંબર જેમાંથી
આ મુદ્રિત કરવામાં આવી હતી 9 વાક્ય છે.

326
00:16:24,080 --> 00:16:27,500
અને પછી તે જમણી છે
કે હું અપેક્ષા છું ભૂલ સંદેશો.

327
00:16:27,500 --> 00:16:30,701
>> અને શું સરસ વિશે આ છે
હવે હું જરૂરી ગણતરી કરવાની જરૂર નથી

328
00:16:30,701 --> 00:16:32,200
મારા માથા માં શું મારા કાર્યક્રમ કરી છે.

329
00:16:32,200 --> 00:16:34,240
હું તેના પર જોઈ શકો છો
પ્રથમ પુનરાવૃત્તિ હું 0 છે,

330
00:16:34,240 --> 00:16:39,420
પછી 1, પછી 2, તે પછી 3, પછી 4, પછી
5, પછી 6, પછી 7, પછી 8, 9 પછી, તો પછી

331
00:16:39,420 --> 00:16:40,980
10.

332
00:16:40,980 --> 00:16:42,050
તેથી એક મિનિટ રાહ જુઓ.

333
00:16:42,050 --> 00:16:43,740
અહીં શું થઈ રહ્યું છે?

334
00:16:43,740 --> 00:16:48,190
હું હજુ પણ ગણાય શકાય લાગે
10 સુધી બનાવાયેલ છે.

335
00:16:48,190 --> 00:16:50,550
>> પરંતુ હું જ્યાં શરૂ થયો હતો?

336
00:16:50,550 --> 00:16:53,240
0, 1, 2, 3, 4, 5, 6, 7, 8, 9 10.

337
00:16:53,240 --> 00:16:58,040
તેથી 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10-- 11 આંગળી

338
00:16:58,040 --> 00:16:59,990
સમસ્યા સૂચક છે.

339
00:16:59,990 --> 00:17:02,850
હું ગણાશે છે એવું લાગે છે
ખોટી રીતે મારા લૂપ.

340
00:17:02,850 --> 00:17:06,599
10 iterations જાઓ બદલે,
હું 0 શરૂ કરું છું,

341
00:17:06,599 --> 00:17:09,550
હું અને 10 અંત છું.

342
00:17:09,550 --> 00:17:12,030
પરંતુ કારણ કે, એક કોમ્પ્યુટર જેવી,
હું 0 અંતે ગણતરી શરૂ કરું છું,

343
00:17:12,030 --> 00:17:15,250
હું ગણાય જોઇએ
છે, પરંતુ 10, નથી.

344
00:17:15,250 --> 00:17:18,510
>> અને તેથી સુધારો, હું આખરે
અહીં ભાન, બે વસ્તુઓ એક છે.

345
00:17:18,510 --> 00:17:22,430
હું ખૂબ જ સરળ કહી શકે
10 કરતાં ઓછી સુધી ગણતરી.

346
00:17:22,430 --> 00:17:27,260
તેથી 0, 1, 2, 3, 4, 5, 6, 7, 8,
9 છે, જે ખરેખર, યોગ્ય,

347
00:17:27,260 --> 00:17:28,900
પણ તે થોડી ખોટું લાગે છતાં.

348
00:17:28,900 --> 00:17:35,070
અથવા હું શું કરી શકે કરતાં અથવા સમાન ઓછી
9, જેથી લાંબા સમય સુધી હું 0 શરૂ.

349
00:17:35,070 --> 00:17:40,056
અથવા તમે ખરેખર ન ગમે, તો તમે
10 ગણતરી પરંતુ 1 શરૂ કરી શકો છો.

350
00:17:40,056 --> 00:17:41,680
પરંતુ ફરીથી, આ માત્ર સામાન્ય છે.

351
00:17:41,680 --> 00:17:43,977
programming-- જોકે
Scratch-- ખૂબ જ નથી

352
00:17:43,977 --> 00:17:45,810
પરંતુ પ્રોગ્રામિંગ માં
સી અને અન્ય ભાષાઓ,

353
00:17:45,810 --> 00:17:47,670
જાવાસ્ક્રિપ્ટ અને તેના જેવા
Python અને અન્ય, તે છે

354
00:17:47,670 --> 00:17:49,880
માત્ર ખૂબ જ સામાન્ય
બાઈનરી અમારી ચર્ચા

355
00:17:49,880 --> 00:17:53,450
માત્ર ગણાય શરૂ કરવા
સૌથી ઓછી સંખ્યા તમે કરી શકો છો, કે જે 0 છે.

356
00:17:53,450 --> 00:17:53,950
બધા અધિકાર.

357
00:17:53,950 --> 00:17:55,160
તેથી તે eprintf છે.

358
00:17:55,160 --> 00:17:58,600
અને ફરી, હવે હું બહાર figured કર્યું છે કે મારા
સમસ્યા છે, અને હું 0 પાછા જાઓ જાઉં છું

359
00:17:58,600 --> 00:18:01,470
કરતાં ઓછી 10, હું જાઉં છું
માં જાઓ અને eprintf કાઢી નાખવા.

360
00:18:01,470 --> 00:18:04,580
>> તે ત્યાં ન હોવી જોઈએ જ્યારે હું
મારી કોડ જહાજ કે મારા કોડ સબમિટ

361
00:18:04,580 --> 00:18:05,800
અથવા તે અન્ય કોઈને પણ દર્શાવે છે.

362
00:18:05,800 --> 00:18:07,980
તે ખરેખર માત્ર અર્થ છે
કામચલાઉ વાપરી શકાય છે.

363
00:18:07,980 --> 00:18:11,650
પરંતુ હવે હું આ સુધારેલ છે
તેમજ ખાસ સમસ્યા નથી.

364
00:18:11,650 --> 00:18:16,780
>> ઠીક છે, ચાલો એક વધુ ઉદાહરણ કરવા દો અહીં
કે હું ચાબુક નીચે પ્રમાણે જાઉં છું.

365
00:18:16,780 --> 00:18:22,850
હું આગળ જાઓ જાઉં છું અને
# સમાવેશ થાય છે. $ 50

366
00:18:22,850 --> 00:18:25,580
અને હું આગળ જાઓ જાઉં છું
અને # સમાવેશ થાય છે.

367
00:18:25,580 --> 00:18:29,030
>> અને હું સેવ જાઉં છું
આ ફાઇલ buggy3.c છે.

368
00:18:29,030 --> 00:18:31,740
અને હું આગળ જાઓ જાઉં છું
અને જાહેર પૂર્ણાંક મુખ્ય (રદબાતલ).

369
00:18:31,740 --> 00:18:34,186
અને પછી ત્યાં અંદર
હું હું પૂર્ણાંક કરવા જઇ રહ્યો છું _ -

370
00:18:34,186 --> 00:18:36,435
હું એક કાર્યક્રમ અમલ કરવા માંગો છો
એક get_negative_int સાથે.

371
00:18:36,435 --> 00:18:39,146

372
00:18:39,146 --> 00:18:40,770
આ એક કાર્ય હજુ સુધી અસ્તિત્વમાં નથી.

373
00:18:40,770 --> 00:18:42,870
તેથી અમે અમલ કરવા માટે જઈ રહ્યાં છો
તે માત્ર એક ક્ષણ.

374
00:18:42,870 --> 00:18:45,541
પરંતુ અમે શા માટે જોવા જઈ રહ્યાં છો
તે પ્રથમ પાસ પર બગડેલ છે.

375
00:18:45,541 --> 00:18:47,290
અને એક વાર હું મેળવેલ કર્યું
વપરાશકર્તા માંથી પૂર્ણાંક,

376
00:18:47,290 --> 00:18:53,365
હું હમણાં જ% હું છાપો જાઉં છું નકારાત્મક છે
પૂર્ણાંક, બેકસ્લેશ, એ, અલ્પવિરામ, હું.

377
00:18:53,365 --> 00:18:55,240
બીજા શબ્દોમાં કહીએ તો, હું
આ કાર્યક્રમ કરવા માંગો છો

378
00:18:55,240 --> 00:18:58,000
એક નકારાત્મક પૂર્ણાંક વિચાર છે
વપરાશકર્તા અને પછી છાપે

379
00:18:58,000 --> 00:18:59,980
જેમ કે અને આવા નકારાત્મક પૂર્ણાંક છે.

380
00:18:59,980 --> 00:19:02,080
>> હવે હું આ કાર્ય અમલમાં કરવાની જરૂર છે.

381
00:19:02,080 --> 00:19:05,740
તેથી મારા ફાઈલમાં પછી, હું જાઉં છું
આગળ અને એક કાર્ય કહેવાય જાહેર

382
00:19:05,740 --> 00:19:10,670
get_negative_int (રદબાતલ) - અને અમે પડશે
પાછા આવો તે શું છે તે રેખા ફરી એનો અર્થ એ થાય

383
00:19:10,670 --> 00:19:18,790
એક ક્ષણ પૂર્ણાંક n માં; શું કરી દો
નીચેના printf n છે :.

384
00:19:18,790 --> 00:19:26,210
અને પછી હું એ કરવા જઇ રહ્યો છું - get_int,
અને આ વખતે એ 0 કરતાં મોટો છે નથી.

385
00:19:26,210 --> 00:19:28,310
અને પછી એ પાછા ;.

386
00:19:28,310 --> 00:19:31,730
>> તેથી ઘણો ચાલી રહ્યું છે
આ પણ જે કંઈ અમે કર્યું

387
00:19:31,730 --> 00:19:33,710
ઓછામાં ઓછા સંક્ષિપ્તમાં ખાતે છેલ્લા અઠવાડિયે જુઓ.

388
00:19:33,710 --> 00:19:36,980
તેથી અહીં 10 વાક્ય પર હું જાહેર કર્યું છે એક
કાર્ય get_negative_int કહેવાય છે,

389
00:19:36,980 --> 00:19:39,620
અને હું મૂક્યો છે (રદબાતલ), માં
કૌંસ, કારણ આ છે

390
00:19:39,620 --> 00:19:40,950
ઇનપુટ નથી.

391
00:19:40,950 --> 00:19:42,910
હું કાંઇ નથી પસાર કરી રહ્યો છું
આ કાર્ય કરવા માટે.

392
00:19:42,910 --> 00:19:44,690
હું હમણાં જ કંઈક તેને પાછા મેળવવામાં છું.

393
00:19:44,690 --> 00:19:47,270
>> અને હું શું આશા છું
પાછા મળી પૂર્ણાંક છે.

394
00:19:47,270 --> 00:19:50,040
ત્યાં કોઈ માહિતી પ્રકાર છે
સી negative_int કહેવાય છે.

395
00:19:50,040 --> 00:19:52,880
તે માત્ર પૂર્ણાંક છે, તેથી તે ચાલી રહ્યું છે
તેની ખાતરી કરવા માટે અમને પર હોઈ

396
00:19:52,880 --> 00:19:55,340
તે કિંમત ખરેખર છે કે
પાછા ફર્યા નથી માત્ર પૂર્ણાંક છે

397
00:19:55,340 --> 00:19:56,380
પણ નકારાત્મક છે.

398
00:19:56,380 --> 00:20:02,150
>> 12 લીટી પર હું એક ચલ જાહેર છું
એન અને પ્રકાર પૂર્ણાંક તે બનાવે છે કહેવામાં આવે છે.

399
00:20:02,150 --> 00:20:07,500
અને પછી વાક્ય 13 માં 18 મારફતે હું છું
કંઈક કરી જ્યારે કંઈક સાચું છે.

400
00:20:07,500 --> 00:20:11,040
હું આગળ અને પ્રિન્ટીંગ જાઉં છું
n છે, કોલોન, અને પછી એક જગ્યા,

401
00:20:11,040 --> 00:20:12,800
વપરાશકર્તા માટે પ્રોમ્પ્ટ છે.

402
00:20:12,800 --> 00:20:16,410
>> હું પછી get_int ફોન કરું છું અને
તેના કહેવાતા વળતર કિંમત સ્ટોર

403
00:20:16,410 --> 00:20:18,130
કે ચલ n છે.

404
00:20:18,130 --> 00:20:22,600
પરંતુ હું તે કરી રાખવા માટે જઇ રહ્યો છું
આ વખતે એ 0 કરતાં મોટો છે.

405
00:20:22,600 --> 00:20:27,960
બીજા શબ્દોમાં કહીએ તો, વપરાશકર્તા મને આપે તો
પૂર્ણાંક અને તે નંબર 0 કરતાં મોટો છે,

406
00:20:27,960 --> 00:20:31,180
તેને લીધે, હકારાત્મક, હું જાઉં છું
માત્ર વપરાશકર્તા reprompting રાખો,

407
00:20:31,180 --> 00:20:37,160
reprompting રાખવા, તેમને માટે મજબૂર દ્વારા
સહકાર અને મને નકારાત્મક પૂર્ણાંક આપે છે.

408
00:20:37,160 --> 00:20:41,640
>> અને એકવાર એ ખરેખર negative-- છે
વપરાશકર્તા ધારવું છેલ્લે પ્રકારના -50,

409
00:20:41,640 --> 00:20:46,710
પછી આ વખતે લૂપ લાંબા સમય સુધી સાચું છે
કારણ કે -50 0 કરતાં મોટો નથી.

410
00:20:46,710 --> 00:20:51,140
તેથી અમે તે બહાર ભંગ
લૂપ તાર્કિક અને એ આવો.

411
00:20:51,140 --> 00:20:53,520
>> પરંતુ એક અન્ય છે
વસ્તુ હું કરી છે.

412
00:20:53,520 --> 00:20:56,190
અને હું ખાલી આ કરી શકો છો
કૉપિ અને પેસ્ટ દ્વારા

413
00:20:56,190 --> 00:20:58,540
ફાઇલ ટોચ પર કોડ એક વાક્ય.

414
00:20:58,540 --> 00:21:01,630
હું રણકાર શીખવવા કરવાની જરૂર છે
અથવા રણકાર વચન,

415
00:21:01,630 --> 00:21:04,630
બાહ્ય ચાલશે,
ખરેખર, જાઓ અને અમલ

416
00:21:04,630 --> 00:21:06,020
આ કાર્ય get_negative_int.

417
00:21:06,020 --> 00:21:07,674
તે ફક્ત ફાઇલ નીચલા હોઈ શકે છે.

418
00:21:07,674 --> 00:21:09,840
ફરીથી, યાદ છે કે રણકાર
ઉપરથી નીચે સુધી વસ્તુઓ વાંચે છે,

419
00:21:09,840 --> 00:21:12,330
જમણે, જેથી તમે કરી શકતા નથી
જો રણકાર એક કાર્ય કૉલ

420
00:21:12,330 --> 00:21:15,330
તે અસ્તિત્વમાં રહ્યું છે ખબર નથી.

421
00:21:15,330 --> 00:21:18,430
>> હવે, કમનસીબે, આ કાર્યક્રમ,
કારણ કે જેમ તમે અમુક સૂચન હોઇ શકે છે,

422
00:21:18,430 --> 00:21:19,590
પહેલેથી જ બગડેલ છે.

423
00:21:19,590 --> 00:21:21,400
મને આગળ વધો અને buggy3 બનાવવા દો.

424
00:21:21,400 --> 00:21:26,904
તે કમ્પાઇલ, જેથી મારી સમસ્યા હવે નથી
એક સિંટેક્સ ભૂલ, એક શાબ્દિક ભૂલ જેમ,

425
00:21:26,904 --> 00:21:29,570
તે ખરેખર એક લોજિકલ પ્રયત્ન રહ્યું છે
ભૂલ કે હું ઇરાદાપૂર્વક કર્યું

426
00:21:29,570 --> 00:21:32,450
કરવા માટે એક તક તરીકે કરવામાં
શું થઈ રહ્યું છે મારફતે પગલું.

427
00:21:32,450 --> 00:21:35,540
>> હું આગળ જાઓ જાઉં છું
હવે buggy3 ચલાવો.

428
00:21:35,540 --> 00:21:37,490
અને હું જવા માટે જઇ રહ્યો છું
આગળ અને સહકાર.

429
00:21:37,490 --> 00:21:39,494
હું તેને નંબર 1 આપવા જઈ રહ્યો છું.

430
00:21:39,494 --> 00:21:41,410
તે જેવી ન હતી, તેથી
તે મને ફરીથી પૂછવાની છે.

431
00:21:41,410 --> 00:21:42,147
>> કેવી રીતે 2?

432
00:21:42,147 --> 00:21:43,021
3?

433
00:21:43,021 --> 00:21:43,520
50?

434
00:21:43,520 --> 00:21:44,740
તે કંઈ કામ કરી રહ્યા છે.

435
00:21:44,740 --> 00:21:46,890
કેવી રીતે -50 વિશે શું?

436
00:21:46,890 --> 00:21:48,560
અને કાર્યક્રમ કામ લાગે છે.

437
00:21:48,560 --> 00:21:49,970
>> મને તે વધુ એક વખત પ્રયાસ કરીએ.

438
00:21:49,970 --> 00:21:53,400
મને -1 પ્રયાસ કરો, કામ લાગે છે.

439
00:21:53,400 --> 00:21:56,380
મને -2 પ્રયાસ કરો, કામ લાગે છે.

440
00:21:56,380 --> 00:21:59,640
મને 0 પ્રયાસ કરીએ.

441
00:21:59,640 --> 00:22:01,684
ઓહ, કે ખોટો છે.

442
00:22:01,684 --> 00:22:03,350
હવે, આપણે અહીં થોડી મિથ્યાપાંડિત્ય હોવા કરી રહ્યાં છો.

443
00:22:03,350 --> 00:22:07,090
પરંતુ તે છે ખરેખર, આ કેસ 0
ન તો હકારાત્મક કે નકારાત્મક છે.

444
00:22:07,090 --> 00:22:11,150
અને તેથી હકીકત મારા કાર્યક્રમ છે કે
કહે છે કે 0 નકારાત્મક પૂર્ણાંક છે

445
00:22:11,150 --> 00:22:12,820
કે ટેકનિકલી સાચી નથી.

446
00:22:12,820 --> 00:22:15,180
>> હવે, તે શા માટે આ કરવાનું છે?

447
00:22:15,180 --> 00:22:16,270
વેલ, તે સ્પષ્ટ હોઈ શકે છે.

448
00:22:16,270 --> 00:22:18,110
અને, ખરેખર, કાર્યક્રમ છે
એકદમ સરળ થઈ ગયું

449
00:22:18,110 --> 00:22:19,670
તેથી અમે અન્વેષણ કરવા માટે કંઈક છે.

450
00:22:19,670 --> 00:22:25,870
>> પરંતુ ત્રીજા ડિબગીંગ પરિચય દો
ટેકનિક અહીં debug50 કહેવાય છે.

451
00:22:25,870 --> 00:22:27,750
તેથી આ એક કાર્યક્રમ છે
અમે હમણાં બનાવેલ છે કે

452
00:22:27,750 --> 00:22:30,770
આ વર્ષે કહેવાય debug50
કે તમે પરવાનગી આપે છે

453
00:22:30,770 --> 00:22:34,130
વાપરવા માટે શું આંતરિક કહેવાય છે
CS50 IDE ગ્રાફિકલ ડીબગર.

454
00:22:34,130 --> 00:22:38,400
અને ડીબગર માત્ર એક કાર્યક્રમ છે કે
સામાન્ય રીતે તમે તમારા કાર્યક્રમ ચલાવી શકો છો

455
00:22:38,400 --> 00:22:44,050
પરંતુ પગલું, રેખા દ્વારા પગલું દ્વારા પગલું
વાક્ય દ્વારા વાક્ય દ્વારા, pausing, poking

456
00:22:44,050 --> 00:22:47,626
આસપાસ, ચલો જોઈ જેથી
કાર્યક્રમ માત્ર તમે ભૂતકાળમાં તમાચો નથી

457
00:22:47,626 --> 00:22:49,750
અને ઝડપથી કંઈક છાપવા
અથવા કંઈક છાપો.

458
00:22:49,750 --> 00:22:53,250
તે તમને એક તક આપે છે, પર
માનવ ઝડપ, તેની સાથે ક્રિયાપ્રતિક્રિયા કરે છે.

459
00:22:53,250 --> 00:22:55,470
>> અને આ કરવા માટે, તમે
ફક્ત નીચેની નથી.

460
00:22:55,470 --> 00:22:58,479
તમારો કોડ કમ્પાઇલ કર્યા પછી,
જે મને પહેલેથી જ હતી, buggy3,

461
00:22:58,479 --> 00:23:00,020
તમે આગળ વધો અને debug50 ./buggy ચલાવો.

462
00:23:00,020 --> 00:23:03,460

463
00:23:03,460 --> 00:23:06,760
બહુ ગમે help50 તમે ચલાવવા છે
help50 અને પછી આદેશ,

464
00:23:06,760 --> 00:23:10,120
debug50 તમે debug50 ચાલે છે અને
પછી આદેશ નામ.

465
00:23:10,120 --> 00:23:14,440
>> હવે જુઓ મારા સ્ક્રીન પર શું થાય છે,
ખાસ કરીને જમણી બાજુ પર.

466
00:23:14,440 --> 00:23:19,400
જ્યારે હું ચલાવો, તમામ હિટ
અચાનક આ જમણી બાજુ પેનલ

467
00:23:19,400 --> 00:23:20,419
સ્ક્રીન પર કોઈ રન નોંધાયો નહીં.

468
00:23:20,419 --> 00:23:22,210
અને ત્યાં ઘણા બધા રહ્યું છે
પ્રથમ નજરે પર.

469
00:23:22,210 --> 00:23:25,110
પરંતુ ત્યાં પણ નથી
વિશે હજુ સુધી ચિંતા કરવાની જ.

470
00:23:25,110 --> 00:23:28,570
>> આ બધું મને દર્શાવે છે
કે મારા કાર્યક્રમ ની અંદર પર ચાલી રહ્યું છે

471
00:23:28,570 --> 00:23:31,130
હમણાં અને આ દ્વારા
બટનો ટોચ પછી

472
00:23:31,130 --> 00:23:35,910
મને મારા કોડ દ્વારા પગલું માટે પરવાનગી આપે છે
આખરે પગલું દ્વારા પગલું દ્વારા પગલું.

473
00:23:35,910 --> 00:23:37,140
પરંતુ હજુ સુધી.

474
00:23:37,140 --> 00:23:38,060
નોંધ શું થાય છે.

475
00:23:38,060 --> 00:23:40,600
મારા ટર્મિનલ વિન્ડો પર
હું એ માટે પૂછવામાં આવી રહી છું.

476
00:23:40,600 --> 00:23:44,560
અને હું આગળ જવા માટે જઇ રહ્યો છું અને
આ સમય અને -1 પ્રકાર સહકાર.

477
00:23:44,560 --> 00:23:48,770
અને જોકે થોડી રહસ્યમય, -1
નકારાત્મક પૂર્ણાંક, ઈચ્છિત તરીકે છે.

478
00:23:48,770 --> 00:23:52,020
>> અને પછી બાળક સાથે બહાર
સ્થિતિ 0 gdbserver બહાર નીકળતા.

479
00:23:52,020 --> 00:23:55,180
GDB, એ GNU ડિબગર, નામ છે
અંતર્ગત સોફ્ટવેર

480
00:23:55,180 --> 00:23:56,620
કે આ ડીબગર અમલમાં મૂકે છે.

481
00:23:56,620 --> 00:24:00,500
પરંતુ આ બધા ખરેખર અર્થ થાય છે, ડીબગર
દૂર ગયા કારણ કે મારા કાર્યક્રમ બહાર નીકળવા

482
00:24:00,500 --> 00:24:01,710
અને બધા સારી હતી.

483
00:24:01,710 --> 00:24:06,020
હું ખરેખર મારા કાર્યક્રમ ડિબગ કરવા માંગો છો, તો
હું preemptively debug50 કહેવું છે

484
00:24:06,020 --> 00:24:08,920
જ્યાં હું શરૂ કરવા માંગો છો
મારી કોડ મારફતે વેગ?

485
00:24:08,920 --> 00:24:11,750
>> અને કદાચ સરળ માર્ગ
કે નીચે પ્રમાણે છે શું કરવું.

486
00:24:11,750 --> 00:24:15,300
જો હું ઉપર હૉવર
મારા સંપાદક ગટર અહીં,

487
00:24:15,300 --> 00:24:19,090
તેથી ખરેખર માત્ર સાઇડબારમાં અહીં,
લીટી નંબર ડાબી,

488
00:24:19,090 --> 00:24:21,870
નોંધ કરો કે જો હું માત્ર પર ક્લિક કરો
એક વાર, હું થોડી લાલ ટપકું મૂકો.

489
00:24:21,870 --> 00:24:24,460
અને તે થોડી લાલ ટપકું,
એક સ્ટોપ સાઇન જેવી છે, જેનો અર્થ છે, હેય,

490
00:24:24,460 --> 00:24:29,430
debug50, મારા કોડ વિરામ અમલ
અધિકાર ત્યાં જ્યારે હું આ કાર્યક્રમ ચલાવો.

491
00:24:29,430 --> 00:24:30,260
>> તેથી ચાલો તે કરીએ.

492
00:24:30,260 --> 00:24:37,340
મને આગળ વધો અને મારા કાર્યક્રમ ચલાવવા દો
debug50 ./buggy3 સાથે ફરીથી દાખલ કરો.

493
00:24:37,340 --> 00:24:40,110
અને હવે, નોટિસ, કંઈક
વિવિધ થયું છે.

494
00:24:40,110 --> 00:24:42,440
હું પૂછવામાં આવી રહી છું
હજુ સુધી મારા ટર્મિનલ વિન્ડોમાં

495
00:24:42,440 --> 00:24:45,430
કંઈપણ માટે છે, કારણ કે હું નથી
મારા કાર્યક્રમ હજુ સુધી ત્યાં મેળવેલ.

496
00:24:45,430 --> 00:24:47,950
નોંધ કરો કે 8 વાક્ય પર
જે હવે પ્રકાશિત થયેલ છે,

497
00:24:47,950 --> 00:24:51,720
અને ત્યાં થોડો એરો
ડાબી કહેવત, તમે અહીં અટકી છે.

498
00:24:51,720 --> 00:24:55,030
કોડ છે, લીટી આ વાક્ય
8, હજુ સુધી ચલાવવામાં નથી.

499
00:24:55,030 --> 00:24:58,940
>> અને જો હું જુઓ, વિચિત્ર છે
જમણી બાજુ પર અહીં પર,

500
00:24:58,940 --> 00:25:03,530
નોંધ કરો કે હું એક સ્થાનિક છે
ચલ, અર્થમાં સ્થાનિક

501
00:25:03,530 --> 00:25:05,450
કે તે વર્તમાન કાર્ય અંદર છે.

502
00:25:05,450 --> 00:25:08,920
અને તેની કિંમત, દેખીતી રીતે મૂળભૂત રીતે,
અને જેવું સરળ, 0 હોય છે.

503
00:25:08,920 --> 00:25:10,260
પરંતુ હું 0 લખો ન હતી.

504
00:25:10,260 --> 00:25:13,410
કે જે હમણાં જ બને છે તેના
આ ક્ષણે મૂળભૂત કિંમત.

505
00:25:13,410 --> 00:25:15,490
>> તેથી મને આગળ વધો અને હવે આ કરવા દો.

506
00:25:15,490 --> 00:25:18,680
મને આગળ વધો અને પર જાઓ
ઉપર જમણી અહીં, હું છું

507
00:25:18,680 --> 00:25:20,970
આગળ જાઓ રહ્યું છે અને
આ પ્રથમ ચિહ્ન પર ક્લિક કરો કે જે

508
00:25:20,970 --> 00:25:25,360
જેના પર પગલું એટલે અવગણો નથી એનો અર્થ એ થાય
તે પણ કોડના આ લીટી પર પગલું,

509
00:25:25,360 --> 00:25:27,770
રસ્તામાં તે ચલાવવા.

510
00:25:27,770 --> 00:25:30,710
>> અને હવે, નોટિસ, મારા
પ્રોમ્પ્ટ માત્ર બદલાઈ ગયેલ છે.

511
00:25:30,710 --> 00:25:31,380
શા માટે છે?

512
00:25:31,380 --> 00:25:33,639
હું debug50 કહ્યું છે,
કોડ આ વાક્ય ચલાવો.

513
00:25:33,639 --> 00:25:34,930
કોડ આ વાક્ય શું કરે છે?

514
00:25:34,930 --> 00:25:35,960
મને પૂર્ણાંક માટે પૂછે છે.

515
00:25:35,960 --> 00:25:36,460
ઠીક છે.

516
00:25:36,460 --> 00:25:37,400
મને સહકાર દો.

517
00:25:37,400 --> 00:25:41,340
મને આગળ હવે જાઓ અને ટાઇપ -1, દાખલ કરો.

518
00:25:41,340 --> 00:25:42,920
અને હવે નોટિસ બદલાઈ ગયેલ છે.

519
00:25:42,920 --> 00:25:46,060
જમણી બાજુ પર,
મારા સ્થાનિક ચલ હું

520
00:25:46,060 --> 00:25:48,200
હોવા -1 હવે સૂચવવામાં આવે છે.

521
00:25:48,200 --> 00:25:49,810
અને તે પ્રકાર પૂર્ણાંક હજુ પણ છે.

522
00:25:49,810 --> 00:25:53,102
>> અને નોટિસ, પણ, મારા કહેવાતા
સ્ટેક કૉલ, જ્યાં હું વિરામ હતી?

523
00:25:53,102 --> 00:25:54,810
અમે વિશે વધુ વાત કરીશું
ભવિષ્યમાં આ.

524
00:25:54,810 --> 00:25:58,620
પરંતુ કૉલ સ્ટેક માત્ર ઉલ્લેખ કરે છે શું
કાર્યો ગતિ હાલમાં છે.

525
00:25:58,620 --> 00:26:00,040
હમણા તે માત્ર મુખ્ય છે.

526
00:26:00,040 --> 00:26:03,590
અને હમણાં જ સ્થાનિક
ચલ 1 ની કિંમત સાથે હું છે.

527
00:26:03,590 --> 00:26:09,840
>> અને જ્યારે હું આખરે આ લીટી પર પગલું
અહીં, ઉપર જમણી બાજુએ તે જ ચિહ્ન સાથે,

528
00:26:09,840 --> 00:26:11,410
-1 નકારાત્મક પૂર્ણાંક છે.

529
00:26:11,410 --> 00:26:13,580
હવે તે સર્પાકાર તાણવું પર pausing છે.

530
00:26:13,580 --> 00:26:14,740
ચાલો તે તેના વસ્તુ કરવા દો.

531
00:26:14,740 --> 00:26:17,300
હું તે લીટી, અને વોઇલા Query પર પગલું.

532
00:26:17,300 --> 00:26:20,240
>> તેથી કે જે બધી ભયંકર
સંપન્ન હજુ સુધી,

533
00:26:20,240 --> 00:26:23,550
પરંતુ તે દો નહોતી મને વિરામ
અને તાર્કિક મારફતે લાગે

534
00:26:23,550 --> 00:26:24,870
આ કાર્યક્રમ શું કરવાનું છે.

535
00:26:24,870 --> 00:26:26,890
પરંતુ તે ભૂલભરેલા કેસ ન હતી.

536
00:26:26,890 --> 00:26:28,510
નીચે પ્રમાણે આ ફરીથી દો.

537
00:26:28,510 --> 00:26:31,340
>> હું બ્રેકપોઇન્ટ છોડી જઇ રહ્યો છું
લાલ ટપકું સાથે 8 વાક્ય પર.

538
00:26:31,340 --> 00:26:32,830
હું debug50 પુનઃ ચલાવો જાઉં છું.

539
00:26:32,830 --> 00:26:34,400
તે આપોઆપ અહીં થોભાવવામાં છે.

540
00:26:34,400 --> 00:26:37,660
પરંતુ આ સમય, બદલે
આ લીટી પર આધાર,

541
00:26:37,660 --> 00:26:42,290
મને ખરેખર અંદર જવા દો
get_negative_int અને બહાર આકૃતિ,

542
00:26:42,290 --> 00:26:45,530
શા માટે તે માન્ય જવાબ તરીકે 0 સ્વીકાર કરે છે?

543
00:26:45,530 --> 00:26:47,990
>> તેથી પગલું પર ક્લિક બદલે.

544
00:26:47,990 --> 00:26:50,630
હું આગળ જાઓ જાઉં છું
અને માં પગલું ક્લિક કરો.

545
00:26:50,630 --> 00:26:54,030
અને તે છે કે 8 વાક્ય નોટિસ
હવે અચાનક હવે પ્રકાશિત

546
00:26:54,030 --> 00:26:56,900
રેખા 17 બની જાય છે.

547
00:26:56,900 --> 00:26:59,947
>> હવે, તે ડીબગર નથી
લાઇન્સ 14 અને 15 અને 16 છોડ્યું છે.

548
00:26:59,947 --> 00:27:01,780
તે માત્ર ત્યાં કશું છે
તમે ત્યાં બતાવવા માટે.

549
00:27:01,780 --> 00:27:04,050
તે માત્ર ચલો જાહેર કરવામાં આવે છે,
અને પછી ત્યાં શબ્દ શું

550
00:27:04,050 --> 00:27:05,390
અને પછી એક ખુલ્લું સર્પાકાર તાણવું.

551
00:27:05,390 --> 00:27:09,227
માત્ર વિધેયાત્મક વાક્ય છે કે
રસદાર ખરેખર આ એક અહીં, 17 છે.

552
00:27:09,227 --> 00:27:11,060
અને તે છે જ્યાં અમે કર્યું છે
આપોઆપ થોભાવવામાં.

553
00:27:11,060 --> 00:27:13,870
>> તેથી printf ( "n.is:") ;, જેથી
કે હજુ સુધી થયું નથી.

554
00:27:13,870 --> 00:27:18,250
તેથી આપણે આગળ વધીશું અને સ્ટેપ ઓવર ક્લિક કરો.

555
00:27:18,250 --> 00:27:20,326
હવે મારા પ્રોમ્પ્ટ પર, ખરેખર,
બદલાઈ (n "છે:").

556
00:27:20,326 --> 00:27:22,450
હવે get_int, હું જાઉં છું
માં આધાર સંતાપ,

557
00:27:22,450 --> 00:27:24,750
કારણ કે તે કાર્ય હતું
લાઇબ્રેરી માં CS50 દ્વારા કરી હતી.

558
00:27:24,750 --> 00:27:25,750
તે કદાચ સાચું છે.

559
00:27:25,750 --> 00:27:28,440
>> તેથી હું આગળ જાઓ જાઉં છું અને
તે સૉર્ટ આપીને સહકાર

560
00:27:28,440 --> 00:27:30,590
પૂર્ણાંક નથી, પરંતુ એક નકારાત્મક પૂર્ણાંક.

561
00:27:30,590 --> 00:27:32,870
તેથી મને આગળ વધો અને 0 હિટ દો.

562
00:27:32,870 --> 00:27:39,460
અને હવે શું અહીં થાય છે
21 લીટી છે જ્યારે હું નીચે વિચાર?

563
00:27:39,460 --> 00:27:40,890
હું ફરીથી iterated નથી કર્યું.

564
00:27:40,890 --> 00:27:43,320
હું કે લૂપ અટકી શકાય તેમ લાગતું નથી.

565
00:27:43,320 --> 00:27:45,990
બીજા શબ્દોમાં કહીએ તો, આ પીળો
બાર આસપાસ જઈ ન રાખી હતી,

566
00:27:45,990 --> 00:27:47,130
અને આસપાસ છે, અને આસપાસ.

567
00:27:47,130 --> 00:27:48,340
>> હવે, કે શા માટે છે?

568
00:27:48,340 --> 00:27:49,920
વેલ, એન, હમણાં શું એ છે?

569
00:27:49,920 --> 00:27:53,280
હું સ્થાનિક જોવા કરી શકો છો
ડીબગર ચલો.

570
00:27:53,280 --> 00:27:53,816
એ 0 હોય છે.

571
00:27:53,816 --> 00:27:55,190
બધા હક છે, મારી હાલત શું હતું?

572
00:27:55,190 --> 00:27:58,700
>> 20-- લીટી 20 છે, સાથે સાથે,
0 0 કરતાં મોટો છે.

573
00:27:58,700 --> 00:27:59,500
તે સાચું નથી.

574
00:27:59,500 --> 00:28:01,020
0 0 કરતાં મોટો નથી.

575
00:28:01,020 --> 00:28:02,820
અને તેથી હું આ બહાર તોડી નાખ્યો હતો.

576
00:28:02,820 --> 00:28:06,370
>> અને તેથી કે શા માટે વાક્ય પર છે
21, હું ખરેખર ચાલુ રાખવા માટે,

577
00:28:06,370 --> 00:28:10,370
હું 0 પાછા જઈ રહ્યો છું, પણ
છતાં હું 0 નકારી કાઢી છે કરીશું

578
00:28:10,370 --> 00:28:12,484
કારણ કે ખરેખર નકારાત્મક નથી છે.

579
00:28:12,484 --> 00:28:14,650
તેથી હવે, હું ખરેખર પણ નથી
ડીબગર વિશે કાળજી.

580
00:28:14,650 --> 00:28:16,900
તે હું જરૂર નથી મળ્યો
ખબર શું વધુ રહ્યું છે.

581
00:28:16,900 --> 00:28:19,233
>> તેથી હું આગળ જાઓ જાઉં છું અને
માત્ર પ્લે બટન પર ક્લિક કરો,

582
00:28:19,233 --> 00:28:20,240
અને આ સમાપ્ત કરીએ.

583
00:28:20,240 --> 00:28:23,440
હવે, હું સમજાયું કર્યું મારા
ભૂલ વાક્ય 20 પર દેખીતી રીતે છે.

584
00:28:23,440 --> 00:28:25,160
તે મારા લોજિકલ ભૂલ છે.

585
00:28:25,160 --> 00:28:28,100
>> અને તેથી હું શું કરવા માંગો છો
આ બદલવા માટે શું કરવું?

586
00:28:28,100 --> 00:28:32,500
સમસ્યા છે જો કે હું નથી
0 મોહક, તે માત્ર લોજિકલ ભૂલ છે.

587
00:28:32,500 --> 00:28:35,910
અને હું કહી શકો છો n છે જ્યારે
એક કરતાં વધારે અથવા 0 સમાન

588
00:28:35,910 --> 00:28:38,330
વપરાશકર્તા ફરીથી અને ફરીથી પૂછવાની રાખો.

589
00:28:38,330 --> 00:28:41,050
>> તેથી, ફરી, સરળ ભૂલ, કદાચ
પણ સ્પષ્ટ છે જ્યારે તમે મને જોયો

590
00:28:41,050 --> 00:28:42,410
તે માત્ર થોડી મિનિટો પહેલાં લખો.

591
00:28:42,410 --> 00:28:44,570
પરંતુ અહીં takeaway
છે ડિબગ 50 સાથે,

592
00:28:44,570 --> 00:28:46,850
અને ડિબગીંગ સાથે
સોફ્ટવેર વધુ સામાન્ય રીતે,

593
00:28:46,850 --> 00:28:51,370
તમે આ નવા મળી શક્તિ હોય છે
તમારા પોતાના કોડ લઈ જવામાં, જુઓ

594
00:28:51,370 --> 00:28:55,590
જમણી બાજુ પેનલ મારફતે શું
તમારા ચલો કિંમતો છે.

595
00:28:55,590 --> 00:28:57,700
તેથી તમે જરૂરી નથી
કંઈક ઉપયોગ કરે છે

596
00:28:57,700 --> 00:29:00,630
જેમ તમે તે કિંમતો છાપો eprintf.

597
00:29:00,630 --> 00:29:04,430
તમે ખરેખર તેમને જોઈ શકે છે
દૃષ્ટિની સ્ક્રીન પર.

598
00:29:04,430 --> 00:29:08,920
>> હવે, આ ઉપરાંત, તે નોંધ વર્થ છે
ત્યાં અન્ય ટેકનિક છે કે જે

599
00:29:08,920 --> 00:29:09,890
ખરેખર સુપર સામાન્ય છે.

600
00:29:09,890 --> 00:29:13,120
અને તમે આશ્ચર્ય શકે છે શા માટે આ થોડું
અહીં વ્યક્તિ સ્ટેજ પર બેઠક કરવામાં આવી છે.

601
00:29:13,120 --> 00:29:16,490
તેથી આ ટેકનિક છે, સામાન્ય રીતે
રબર ડક ડિબગીંગ તરીકે ઓળખાય છે,

602
00:29:16,490 --> 00:29:18,786
જે ખરેખર માત્ર એક છે
હકીકત એ છે ટેસ્ટામેન્ટ

603
00:29:18,786 --> 00:29:20,660
કે ઘણીવાર જ્યારે પ્રોગ્રામરો
કોડ લખે છે,

604
00:29:20,660 --> 00:29:22,650
તેઓ જરૂરી ન હો
અન્ય લોકો સાથે સહયોગ,

605
00:29:22,650 --> 00:29:24,030
અથવા શેર્ડ પર્યાવરણ કામ કરે છે.

606
00:29:24,030 --> 00:29:25,050
>> તેઓ ઘરે પ્રકારની છો.

607
00:29:25,050 --> 00:29:25,910
કદાચ તે રાત્રે અંતમાં છે.

608
00:29:25,910 --> 00:29:28,190
તેઓ આકૃતિ કરવાનો પ્રયાસ કરી રહ્યાં છો
તેમના કોડ કેટલાક ભૂલ બહાર.

609
00:29:28,190 --> 00:29:29,330
અને તેઓ માત્ર તે નથી જોઈ રહ્યાં છો.

610
00:29:29,330 --> 00:29:30,329
>> અને ત્યાં કોઈ રૂમમેટ છે.

611
00:29:30,329 --> 00:29:31,250
આ બોલ પર કોઈ ટીએફ છે.

612
00:29:31,250 --> 00:29:32,680
ત્યાં આસપાસ કોઈ CA છે.

613
00:29:32,680 --> 00:29:36,440
બધા તેઓ તેમની શેલ્ફ પર હોય
આ થોડું રબર વહાલું છે.

614
00:29:36,440 --> 00:29:39,030
>> અને તેથી રબર ડક ડિબગીંગ
ફક્ત આ આમંત્રણ છે

615
00:29:39,030 --> 00:29:42,780
કારણ કે કોઈ કંઈક વિચાર
આ એક વાસ્તવિક પ્રાણી તરીકે,

616
00:29:42,780 --> 00:29:46,940
અને ખરેખર તમારો કોડ લઈ જવામાં
મૌખિક આ નિર્જીવ પદાર્થ છે.

617
00:29:46,940 --> 00:29:49,230
તેથી, ઉદાહરણ તરીકે, જો
આ મારા ઉદાહરણ છે અહીં

618
00:29:49,230 --> 00:29:52,470
અને પહેલાં યાદ
સમસ્યા આ હતી,

619
00:29:52,470 --> 00:29:58,140
જો હું કોડ આ પ્રથમ વાક્ય કાઢી નાખો,
અને હું આગળ જાઓ અને ફરીથી બગડેલ 0 બનાવવા માટે,

620
00:29:58,140 --> 00:30:01,220
યાદ છે કે હું આ હતી
અહીં ભૂલ સંદેશાઓ.

621
00:30:01,220 --> 00:30:05,997
તેથી તે વિચાર અહીં, છતાં હું હાસ્યાસ્પદ
આ ક્ષણે લાગે છે કે આ જાહેરમાં કરી,

622
00:30:05,997 --> 00:30:06,580
કે ભૂલ છે.

623
00:30:06,580 --> 00:30:10,910
>> ઠીક છે, તેથી મારી સમસ્યા એ છે કે હું કર્યું છે
સર્વથા એક પુસ્તકાલય કાર્ય જાહેર કર્યો.

624
00:30:10,910 --> 00:30:12,610
અને તે પુસ્તકાલય કાર્ય printf છે.

625
00:30:12,610 --> 00:30:15,290
જાહેર છે ઠીક છે, જાહેર
મને પ્રોટોટાઇપ યાદ અપાવે છે.

626
00:30:15,290 --> 00:30:18,930
>> તેનો અર્થ એ કે હું ખરેખર જરૂર
અગાઉથી કમ્પાઇલર શું કહેવું

627
00:30:18,930 --> 00:30:19,980
કાર્ય જેમ દેખાય છે.

628
00:30:19,980 --> 00:30:20,930
એક મિનીટ થોભો.

629
00:30:20,930 --> 00:30:23,580
હું ધોરણ io.h. ન હતી

630
00:30:23,580 --> 00:30:24,530
ખુબ ખુબ આભાર.

631
00:30:24,530 --> 00:30:27,330
>> તેથી માત્ર તમે લોગ આ પ્રક્રિયા
ખરેખર એક બતક છે કરવાની જરૂર નથી.

632
00:30:27,330 --> 00:30:29,819
પરંતુ વૉકિંગ આ વિચાર
જાતે તમારા પોતાના કોડ દ્વારા

633
00:30:29,819 --> 00:30:31,610
તેથી તમે પણ સાંભળી છે કે
જાતે, જેથી તમે

634
00:30:31,610 --> 00:30:35,620
તમારા પોતાના ઓમિશન ખ્યાલ
ટીકા, સામાન્ય રીતે વિચાર છે.

635
00:30:35,620 --> 00:30:38,910
>> અને, કદાચ વધારે તાર્કિક નથી, તેથી
કે એક પણ વધુ સામેલ સાથે ખૂબ

636
00:30:38,910 --> 00:30:44,220
ઉદાહરણ અમે માત્ર બગડેલ 3.સી કર્યું હતું,
તમે તે મારફતે જાતે ચાલવા શકે

637
00:30:44,220 --> 00:30:45,310
કારણ કે અનુસરે છે.

638
00:30:45,310 --> 00:30:49,190
તેથી તમામ હક, રબર
વહાલું, DDB, જો તમે કરશે.

639
00:30:49,190 --> 00:30:52,350
અહીં અમે મારી મુખ્ય કાર્ય હોય છે,
હું નકારાત્મક પૂર્ણાંક વિચાર ફોન કરું છું.

640
00:30:52,350 --> 00:30:54,660
>> અને હું પાછા આવો કિંમત મેળવવામાં છું.

641
00:30:54,660 --> 00:31:00,410
હું ડાબી બાજુ પર સંગ્રહિત છું
એક ચલ 8 વાક્ય પર હું કહેવામાં આવે છે.

642
00:31:00,410 --> 00:31:02,380
ઠીક છે, પરંતુ રાહ જુઓ, કેવી રીતે કર્યું
કે કિંમત મળી શકે?

643
00:31:02,380 --> 00:31:04,130
મને 12 લીટી માં કાર્ય જોવા દો.

644
00:31:04,130 --> 00:31:05,760
>> 12 લીટી માં, અમે નકારાત્મક પૂર્ણાંક વિચાર છે.

645
00:31:05,760 --> 00:31:08,190
કોઈપણ ઇનપુટ્સ લેવા નથી,
પૂર્ણાંક બરાબર પાછા નથી.

646
00:31:08,190 --> 00:31:10,929
હું 14 વાક્ય એક ચલ n જાહેર.

647
00:31:10,929 --> 00:31:12,220
તે પૂર્ણાંક સ્ટોર ચાલી રહ્યું છે.

648
00:31:12,220 --> 00:31:13,760
કે હું શું કરવા માંગો છો છે.

649
00:31:13,760 --> 00:31:18,480
>> તેથી નીચેના જ્યારે એ ધારો દો
મને પૂર્વવત્ શું સુધારો હું પહેલેથી જ કરી હતી.

650
00:31:18,480 --> 00:31:22,710
તેથી જ્યારે n એ કરતાં વધારે છે
0, છાપે n છે, બરાબર.

651
00:31:22,710 --> 00:31:25,170
અને પછી ફોન પૂર્ણાંક n સંગ્રહાયેલ મળશે.

652
00:31:25,170 --> 00:31:30,160
અને પછી તપાસો, તો એ 0
એ not-- ત્યાં તે છે.

653
00:31:30,160 --> 00:31:31,910
તેથી, ફરી, જો તમે ન કરો
વાસ્તવિક ડક જરૂર છે.

654
00:31:31,910 --> 00:31:35,650
પરંતુ માત્ર તમારી જાતને મારફતે વૉકિંગ
એક બૌદ્ધિક કસરત તરીકે તમારો કોડ

655
00:31:35,650 --> 00:31:37,720
ઘણી વખત તમને મદદ કરશે
ખ્યાલ શું થઈ રહ્યું છે,

656
00:31:37,720 --> 00:31:41,170
માત્ર કંઈક કરી વિરોધ
આ જેમ, સ્ક્રીન પર staring,

657
00:31:41,170 --> 00:31:43,720
અને પોતાને મારફતે વાત નથી
તે છે, કે જે પ્રામાણિકપણે નથી

658
00:31:43,720 --> 00:31:46,270
લગભગ એક અસરકારક ટેકનિક છે.

659
00:31:46,270 --> 00:31:48,620
તેથી ત્યાં તમે તે
વિવિધ તરકીબો સંખ્યા

660
00:31:48,620 --> 00:31:52,102
ખરેખર તમારો કોડ ડિબગીંગ માટે
અને દોષ શોધવા, જે તમામ

661
00:31:52,102 --> 00:31:54,810
તમારા Toolkit માં સાધનો પ્રયત્ન કરીશું
કે તમે મોડી રાત્રે ન હો તેથી,

662
00:31:54,810 --> 00:31:57,660
ખાસ કરીને, તમે ડાઇનિંગ છો
હોલ, અથવા ઓફિસ કલાકો,

663
00:31:57,660 --> 00:32:00,368
સામે તમારા માથા એકાએક સપાટો
દિવાલ, કેટલાક સમસ્યા ઉકેલવા માટે પ્રયાસ કરે છે.

664
00:32:00,368 --> 00:32:02,020
ખ્યાલ છે કે સોફ્ટવેર સાધનો છે.

665
00:32:02,020 --> 00:32:03,720
ત્યાં રબર ડક સાધનો છે.

666
00:32:03,720 --> 00:32:09,630
અને ત્યાં સમગ્ર સ્ટાફ
એક હાથ ધીરે રાહ જોઈ આધાર આપે છે.

667
00:32:09,630 --> 00:32:13,120
>> તેથી હવે, સમસ્યા પર એક શબ્દ
સમૂહો, અને અમે તમને શું આશા કરી રહ્યા છીએ પર

668
00:32:13,120 --> 00:32:15,620
તેમને મેળવવા માટે, અને કેવી રીતે
અમે મૂલ્યાંકન વિશે જાઓ.

669
00:32:15,620 --> 00:32:17,680
દીઠ કોર્સ અભ્યાસક્રમ,
માતાનો CS50 સમસ્યા સેટ

670
00:32:17,680 --> 00:32:22,320
ચાર પ્રાથમિક સીમાની પર મૂલ્યાંકન કરવામાં આવે છે, જેથી
અવકાશ speak-- માટે, ચોકસાઈ, ડિઝાઇન,

671
00:32:22,320 --> 00:32:23,060
અને શૈલી.

672
00:32:23,060 --> 00:32:25,910
અને અવકાશ માત્ર કેટલી ઉલ્લેખ કરે છે
ભાગ તમે બંધ bitten છે?

673
00:32:25,910 --> 00:32:28,080
તમે કેવી રીતે સમસ્યા ખૂબ પ્રયત્ન કર્યો છે?

674
00:32:28,080 --> 00:32:30,110
પ્રયાસ કયા સ્તરની
તમે જેની સ્પષ્ટ અભિવ્યક્તિ છે?

675
00:32:30,110 --> 00:32:35,750
>> ચોકસાઈ, છે, કારણ કે કાર્યક્રમ કામ કરે છે
તે CS50 સ્પષ્ટીકરણ દીઠ તેવું માનવામાં આવે છે

676
00:32:35,750 --> 00:32:38,640
જ્યારે તમે ચોક્કસ ઇનપુટ્સ પૂરી પાડે છે
અથવા ચોક્કસ આઉટપુટ પાછા આવતા?

677
00:32:38,640 --> 00:32:41,130
ડિઝાઇન તેમને મોટા ભાગના વસ્તુલક્ષી હોય છે.

678
00:32:41,130 --> 00:32:43,360
અને તે એક છે કે કરશે
સૌથી લાંબી લેવા શીખવા માટે

679
00:32:43,360 --> 00:32:47,220
અને સૌથી લાંબી શીખવે છે, માં
અત્યાર સુધી તે ઉકળે તરીકે,

680
00:32:47,220 --> 00:32:49,530
કેવી રીતે સારી રીતે લખાયેલ તમારો કોડ છે?

681
00:32:49,530 --> 00:32:52,920
>> તે એક વસ્તુ માત્ર યોગ્ય પ્રિન્ટ છે
આઉટપુટ અથવા જમણી કિંમતો આવો.

682
00:32:52,920 --> 00:32:55,400
પરંતુ જો તમે તેને જેમ કરી રહ્યા છે
અસરકારક રીતે શક્ય?

683
00:32:55,400 --> 00:32:58,210
તમે તેને વિભાજન કરી રહ્યા છે
અને જીતી, અથવા દ્વિસંગી

684
00:32:58,210 --> 00:33:01,500
શોધ તરીકે અમે ટૂંક સમયમાં જોવા મળશે કે અમે કર્યું
બે અઠવાડિયા પહેલા ફોન પુસ્તક સાથે?

685
00:33:01,500 --> 00:33:04,670
ત્યાં ઉકેલવા માટે વધુ સારી રીતે થાય છે
સમસ્યા તમે હાલમાં અહીં છે કરતાં?

686
00:33:04,670 --> 00:33:06,380
તે સારી ડિઝાઇન માટે એક તક છે.

687
00:33:06,380 --> 00:33:08,530
>> અને પછી કેવી રીતે શૈલી
ખૂબ તમારો કોડ છે?

688
00:33:08,530 --> 00:33:12,370
તમે નોટિસ પડશે કે હું ખૂબ છું
મારી કોડ માંગયાદી વિશે ખાસ કરીને,

689
00:33:12,370 --> 00:33:15,300
અને ખાતરી છે કે મારી ચલો બનાવવા
વ્યાજબી રાખવામાં આવ્યા છે. એન,

690
00:33:15,300 --> 00:33:19,660
ટૂંકા સમય, એક માટે એક સારા નામ છે
નંબર, ગણતરી પૂર્ણાંક માટે હું

691
00:33:19,660 --> 00:33:20,727
એક શબ્દમાળા માટે ઓ.

692
00:33:20,727 --> 00:33:22,560
અને અમે લાંબા સમય સુધી હોઈ શકે છે
ચલ નામો પ્રકાર.

693
00:33:22,560 --> 00:33:25,500
શૈલી માત્ર કેવી રીતે સારી છે
તમારો કોડ લાગતું નથી?

694
00:33:25,500 --> 00:33:26,600
અને તે કેવી રીતે વાંચી શકાય છે?

695
00:33:26,600 --> 00:33:29,650
>> અને સમય જતાં, શું તમારા ટીએ
અને TFs દરમિયાન કરશે

696
00:33:29,650 --> 00:33:31,870
કે જે તમને પૂરી પાડે છે
ગુણાત્મક પ્રતિસાદ પ્રકારની

697
00:33:31,870 --> 00:33:34,330
કે જેથી તમે વધુ સારી રીતે મળી
તે વિવિધ પાસાંઓ પર.

698
00:33:34,330 --> 00:33:37,510
અને કેવી રીતે અમે દ્રષ્ટિએ
આ સીમાની દરેક મૂલ્યાંકન,

699
00:33:37,510 --> 00:33:40,080
તે ખૂબ જ થોડા સાથે ખાસ કરીને
ડોલથી છે કે જેથી તમે સામાન્ય રીતે,

700
00:33:40,080 --> 00:33:41,680
કેટલી સારી રીતે તમે કરી રહ્યા છો તે એક અર્થમાં વિચાર.

701
00:33:41,680 --> 00:33:45,680
અને, ખરેખર, તમે પર સ્કોર પ્રાપ્ત જો
તે ખૂણાઓ ચોકસાઈ, ડિઝાઇન કોઈપણ

702
00:33:45,680 --> 00:33:49,659
અને શૈલી especially-- કે જે નંબર
સામાન્ય રીતે 1 થી 5 વચ્ચે હશે.

703
00:33:49,659 --> 00:33:52,450
અને, શાબ્દિક, તમે મળી રહ્યાં હોય
સત્ર શરૂઆતમાં 3,

704
00:33:52,450 --> 00:33:53,977
આ એક ખૂબ જ સારી બાબત છે.

705
00:33:53,977 --> 00:33:55,810
એનો અર્થ એ થયો ત્યાં હજુ પણ છે
સુધારણા માટે જગ્યા,

706
00:33:55,810 --> 00:33:58,490
તમે માટે આશા કરશે જે
પ્રથમ વખત માટે એક વર્ગ લેતી.

707
00:33:58,490 --> 00:34:01,820
ત્યાં આસ્થાપૂર્વક છત કેટલાક બીટ છે
જે તમે સુધી પહોંચવા મહત્વાકાંક્ષી કરી રહ્યાં છો.

708
00:34:01,820 --> 00:34:03,970
અને તેથી 3 પર મેળવવામાં
પૂર્વકાલીન ટુકડાઓ,

709
00:34:03,970 --> 00:34:06,550
જો ન હોય તો કેટલાક 2 અને 4 ની,
ખરેખર, એક સારી બાબત છે.

710
00:34:06,550 --> 00:34:08,880
તે સારી રીતે શ્રેણી અંદર છે,
સારી અપેક્ષાઓ અંદર.

711
00:34:08,880 --> 00:34:11,421
>> અને જો તમારા મન રેસિંગ છે, રાહ જુઓ
એક મિનિટ, ત્રણ પાંચ બહાર.

712
00:34:11,421 --> 00:34:12,620
તે ખરેખર 10 6 બહાર છે.

713
00:34:12,620 --> 00:34:13,560
60% છે.

714
00:34:13,560 --> 00:34:14,830
મારા દેવ, એક એફ છે કે

715
00:34:14,830 --> 00:34:15,870
>> તે નથી.

716
00:34:15,870 --> 00:34:17,600
તે નથી, હકીકત એ છે કે.

717
00:34:17,600 --> 00:34:22,710
તેના બદલે, તે સુધારવા માટે એક તક છે
સત્ર કોર્સ પર.

718
00:34:22,710 --> 00:34:25,580
અને જો તમે કેટલાક મળી રહ્યાં હોય
Poors, આ એક તક છે

719
00:34:25,580 --> 00:34:29,199
ઓફિસ કલાકો લાભ લેવા માટે,
ચોક્કસપણે વિભાગો અને અન્ય સ્રોતો.

720
00:34:29,199 --> 00:34:32,840
>> શ્રેષ્ઠ તક, ખરેખર, છે
તમે માત્ર અત્યાર સુધી કેવી રીતે કર્યું ગર્વ હોવાનું

721
00:34:32,840 --> 00:34:34,520
સત્ર કોર્સ પર આવે છે.

722
00:34:34,520 --> 00:34:38,199
તેથી ખ્યાલ નથી, જો કંઇ
બીજું, ત્રણ સારો છે.

723
00:34:38,199 --> 00:34:40,179
અને તે સમય પર વૃદ્ધિ માટે જગ્યા પરવાનગી આપે છે.

724
00:34:40,179 --> 00:34:43,090
>> કેવી રીતે તે સીમાની હોય છે
ભારાંક, વાસ્તવિકતાથી તમે છો

725
00:34:43,090 --> 00:34:46,745
મેળવવામાં તમારા મોટા ભાગના વખતે પસાર કરવા માટે ચાલુ
કામ કરવા માટે વસ્તુઓ, યોગ્ય રીતે એકલા દો.

726
00:34:46,745 --> 00:34:49,120
અને તેથી ચોકસાઈ કરે છે
સાથે, સૌથી મહત્ત્વપૂર્ણ કરી

727
00:34:49,120 --> 00:34:51,360
ત્રણ આ ગુણાકાર પરિબળ.

728
00:34:51,360 --> 00:34:54,659
ડિઝાઇન, પણ મહત્વપૂર્ણ છે, પરંતુ
કંઈક કે જે તમે જરૂરી નથી

729
00:34:54,659 --> 00:34:58,220
તે કલાકો બધા પર વિતાવે
વસ્તુઓ માત્ર કામ કરવા માટે વિચાર કરવાનો પ્રયાસ કરી.

730
00:34:58,220 --> 00:35:00,019
>> અને તેથી તે ભારાંક છે
થોડી વધુ થોડું.

731
00:35:00,019 --> 00:35:01,560
અને પછી શૈલી ઓછા ભારાંક છે.

732
00:35:01,560 --> 00:35:03,710
પણ તે કોઈ ઓછી છે છતાં
મૂળભૂત મહત્વનું છે,

733
00:35:03,710 --> 00:35:05,990
તે માત્ર છે, કદાચ,
સૌથી સરળ વસ્તુ અધિકાર નથી,

734
00:35:05,990 --> 00:35:08,440
ઉદાહરણો અમે એપોપ્લેક્સી
વ્યાખ્યાન અને વિભાગમાં કરવા,

735
00:35:08,440 --> 00:35:11,080
વસ્તુઓ સાથે સરસ રીતે
ઇન્ડેન્ટેડ, અને ટિપ્પણી કરી છે,

736
00:35:11,080 --> 00:35:14,320
અને તેથી આગળ આ સરળ હોવા છતાં વચ્ચે છે
વસ્તુઓ કરવું અને જમણી વિચાર.

737
00:35:14,320 --> 00:35:16,960
તેથી, જેમ કે ખ્યાલ
કે તે પોઇન્ટ છે

738
00:35:16,960 --> 00:35:19,000
કે પકડ પ્રમાણમાં સરળ હોય છે.

739
00:35:19,000 --> 00:35:22,360
>> અને હવે એક શબ્દ પર
શૈક્ષણિક ઈમાનદારી છે આ.

740
00:35:22,360 --> 00:35:25,150
તેથી કોર્સ દીઠ
અભ્યાસક્રમ, તમે જોશો

741
00:35:25,150 --> 00:35:27,630
કોર્સ છે કે જે ખૂબ
આ આસપાસ ભાષા બીટ.

742
00:35:27,630 --> 00:35:31,380
અને અલબત્ત મુદ્દો લે
ખૂબ ગંભીરતાથી શૈક્ષણિક ઈમાનદારી.

743
00:35:31,380 --> 00:35:33,450
>> અમે તફાવત હોય છે,
વધુ સારા માટે અથવા ખરાબ માટે,

744
00:35:33,450 --> 00:35:36,570
ના મોકલવામાં દર વર્ષે વધુ
શિસ્તભંગનાં પગલાં લેવા માટે વિદ્યાર્થીઓ

745
00:35:36,570 --> 00:35:39,670
સૌથી અન્ય કોઈપણ કરતાં
અલબત્ત, કે હું વાકેફ છું.

746
00:35:39,670 --> 00:35:42,580
આ જરૂરી નથી
હકીકત સૂચક

747
00:35:42,580 --> 00:35:46,340
સીએસ વિદ્યાર્થીઓ, અથવા CS50 વિદ્યાર્થીઓ, છે કે
કોઈપણ ઓછી તમારા સહપાઠીઓને કરતાં પ્રમાણિક.

748
00:35:46,340 --> 00:35:49,090
પરંતુ વાસ્તવિકતા એ છે કે આ
વિશ્વ, ઇલેક્ટ્રોનિક, અમે હમણાં જ

749
00:35:49,090 --> 00:35:50,990
ટેકનોલોજીકલ છે
આ નોંધવાની થાય છે.

750
00:35:50,990 --> 00:35:53,360
>> તે માટે મહત્વનું છે
વર્ગ સમગ્ર ઔચિત્યની

751
00:35:53,360 --> 00:35:58,550
આ શોધી, અને વધારવા કે અમે શું
મુદ્દો છે જ્યારે અમે વસ્તુઓ જુઓ.

752
00:35:58,550 --> 00:36:01,980
અને માત્ર એક ચિત્ર કરું, અને ખરેખર
આ સિંક કંઈક મદદ કરવા માટે,

753
00:36:01,980 --> 00:36:04,600
આ સંખ્યામાં છે
છેલ્લા 10 વર્ષોમાં વિદ્યાર્થીઓ

754
00:36:04,600 --> 00:36:07,610
કેટલાક સામેલ કરવામાં આવી છે કે
શૈક્ષણિક ઈમાનદારી જેવા મુદ્દાઓ,

755
00:36:07,610 --> 00:36:10,990
કેટલાક 32 વિદ્યાર્થીઓ સાથે
પતન 2015, જે

756
00:36:10,990 --> 00:36:13,760
કહે છે કે અમે લેવા નથી
આ બાબત ખૂબ જ ગંભીર.

757
00:36:13,760 --> 00:36:18,380
અને, આખરે, આ નંબરો કંપોઝ,
તાજેતરમાં સૌથી વધુ, લગભગ 3%, 4% અથવા તેથી

758
00:36:18,380 --> 00:36:19,120
વર્ગ.

759
00:36:19,120 --> 00:36:25,220
>> વિદ્યાર્થીઓને સુપર બહુમતી માટે તેથી
તેને લાગે છે કે લીટીઓ સ્પષ્ટ છે.

760
00:36:25,220 --> 00:36:27,940
પરંતુ આ રાખવા નથી
વાંધો નહીં, ખાસ કરીને અંતમાં

761
00:36:27,940 --> 00:36:32,080
રાત્રે જ્યારે સાથે સંઘર્ષ
સમસ્યા સમૂહ કેટલાક ઉકેલ,

762
00:36:32,080 --> 00:36:34,830
ત્યાં પદ્ધતિઓ છે કે જે
તમારી જાતને વધુ સારી મેળવવા માટે

763
00:36:34,830 --> 00:36:37,870
તમે કરતાં આધાર શકે
લાગે છે કે, તે પણ છે કે કલાક છે.

764
00:36:37,870 --> 00:36:40,514
ખ્યાલ છે જ્યારે અમે પ્રાપ્ત કરે છે તે
વિદ્યાર્થી સબમિશન, અમે પાર

765
00:36:40,514 --> 00:36:43,430
આ વર્ષે દરેક સબમિશન તુલના
દરેક સબમિશન ગયા વર્ષે સામે,

766
00:36:43,430 --> 00:36:47,590
2007 થી દરેક સબમિશન સામે,
અને ત્યારથી, જોઈ, તેમજ

767
00:36:47,590 --> 00:36:49,931
કોડ ભંડારોની ઓનલાઇન
ચર્ચા, જોબ સાઇટ્સ.

768
00:36:49,931 --> 00:36:51,806
અને અમે આ ઉલ્લેખ,
ખરેખર, ખાતર બધા

769
00:36:51,806 --> 00:36:56,040
સંપૂર્ણ જાહેરાત, કે જો
બીજા કોઈને તે ઑનલાઇન શોધી શકો છો,

770
00:36:56,040 --> 00:36:57,880
ચોક્કસપણે, તેથી અમે કોર્સ કરી શકો છો.

771
00:36:57,880 --> 00:37:00,100
પરંતુ, ખરેખર, ભાવના
અલબત્ત નીચે ઉકળે

772
00:37:00,100 --> 00:37:01,650
અભ્યાસક્રમ માં આ કલમ છે.

773
00:37:01,650 --> 00:37:03,670
તે ખરેખર માત્ર વાજબી હોઈ છે.

774
00:37:03,670 --> 00:37:06,680
>> અને તે પર તૈયાર અમે તો
માત્ર થોડી વધુ માં ભાષા સાથે,

775
00:37:06,680 --> 00:37:09,770
ખ્યાલ છે કે બધા સાર
કામ કે જે તમે આ કોર્સ માટે સબમિટ

776
00:37:09,770 --> 00:37:10,954
તમારા પોતાના હોવા જ જોઈએ.

777
00:37:10,954 --> 00:37:13,870
પરંતુ તે અંદર, ત્યાં ચોક્કસપણે છે
તકો, અને પ્રોત્સાહન,

778
00:37:13,870 --> 00:37:17,300
અને દેવાનો શિક્ષણશાસ્ત્ર વિષયક કિંમત
મારી others--, TFs, સીએએસ,

779
00:37:17,300 --> 00:37:20,760
ટીએ, અને વર્ગ અન્ય
આધાર માટે, એકલા મિત્રો દો

780
00:37:20,760 --> 00:37:23,547
અને રૂમમેટ્સ જે અભ્યાસ કર્યો છે
સીએસ અને પ્રોગ્રામિંગ પહેલાં.

781
00:37:23,547 --> 00:37:25,130
અને તેથી તે માટે એક ભથ્થું છે.

782
00:37:25,130 --> 00:37:28,180
અને અંગૂઠો સામાન્ય નિયમ
છે આ જ્યારે મદદ માટે પૂછે છે,

783
00:37:28,180 --> 00:37:31,470
તમે અન્ય લોકો માટે તમારા કોડ બતાવી શકે છે,
પરંતુ તમે ધેર જોવા નથી શકે છે.

784
00:37:31,470 --> 00:37:34,880
તેથી જો તમે ઓફિસ કલાકો છો તો પણ,
અથવા ડી હોલ, અથવા અન્ય ક્યાંક

785
00:37:34,880 --> 00:37:37,450
કેટલાક ભાગ સેટ પર કામ કરે છે,
એક મિત્ર, સાથે કામ જે

786
00:37:37,450 --> 00:37:40,160
અંતે, સંપૂર્ણપણે દંડ છે
દિવસ તમારા કામ ઓવરને

787
00:37:40,160 --> 00:37:43,034
આખરે દરેક સંબંધ જોઈએ
તમે અનુક્રમે, અને નથી

788
00:37:43,034 --> 00:37:45,700
કેટલાક સહયોગી પ્રયાસ હોઇ શકે છે,
અંતિમ પ્રોજેક્ટ જ્યાં સિવાય

789
00:37:45,700 --> 00:37:47,410
તે મંજૂરી અને પ્રોત્સાહન આપ્યું છે.

790
00:37:47,410 --> 00:37:49,830
>> સમજો છો કે તમને હોય છે કે
કંઈક સાથે સંઘર્ષ

791
00:37:49,830 --> 00:37:52,520
અને તમારા મિત્ર માત્ર થાય છે
તો પછી આ વધુ સારી રીતે પ્રયત્ન કરવા માટે તમે

792
00:37:52,520 --> 00:37:55,130
અથવા તમે કરતાં સમસ્યા વધુ સારી છે,
અથવા થોડી દૂર તમે કરતાં આગળ

793
00:37:55,130 --> 00:37:57,330
તેને ચાલુ કરવા માટે તદ્દન વાજબી છે
તમારા મિત્ર માટે છે અને કહે છે અરે,

794
00:37:57,330 --> 00:38:00,480
તમે અહીં મારા કોડ પર જોઈ વાંધો નથી,
મદદ મને સ્પોટ શું મારી સમસ્યા છે?

795
00:38:00,480 --> 00:38:03,760
અને, આસ્થાપૂર્વક, માં
શિક્ષણશાસ્ત્ર વિષયક કિંમત રસ

796
00:38:03,760 --> 00:38:07,040
કે મિત્ર માત્ર કરે છે
કહે છે, ઓહ, આ કરવા માટે, પરંતુ તેના બદલે,

797
00:38:07,040 --> 00:38:09,917
શું તમે વાક્ય પર ખૂટે છે
6, અથવા તે કંઈક?

798
00:38:09,917 --> 00:38:12,000
પરંતુ ઉકેલ નથી
તમે આગામી મિત્ર માટે

799
00:38:12,000 --> 00:38:15,617
કહે છે, ઓહ, ઠીક છે, અહીં, મને ખેંચવાનો દો
આ છે, અને તમે મારા ઉપાય બતાવો.

800
00:38:15,617 --> 00:38:16,450
તેથી તે લીટી છે.

801
00:38:16,450 --> 00:38:18,670
તમે તમારા કોડ બતાવવા
અન્ય, પરંતુ તમે નથી કરી શકે છે

802
00:38:18,670 --> 00:38:22,350
ધેર જોવા માટે, અન્ય વિષય
આ કોર્સ અભ્યાસક્રમ માં અવરોધ.

803
00:38:22,350 --> 00:38:24,760
>> તેથી મન આ રાખવા નથી
દિલગીરી કલમ કહેવાતા

804
00:38:24,760 --> 00:38:27,560
આ કોર્સ અભ્યાસક્રમ તેમજ,
કે તમે અમુક કૃત્ય જો કે

805
00:38:27,560 --> 00:38:30,476
વાજબી નથી, પરંતુ તેને લાવવા
અલબત્ત હેડ ધ્યાન

806
00:38:30,476 --> 00:38:34,240
72 કલાકની અંદર, અલબત્ત
સ્થાનિક પ્રતિબંધો લાદી શકે છે કે

807
00:38:34,240 --> 00:38:37,380
એક અસંતોષકારક સમાવેશ થાય છે અથવા
કામ સબમિટ નિષ્ફળ ગ્રેડ.

808
00:38:37,380 --> 00:38:41,410
પરંતુ કોર્સ નો સંદર્ભ લો નહીં
વધુ શિસ્તભંગનાં પગલાં લેવા માટે વાંધો છે,

809
00:38:41,410 --> 00:38:43,010
વારંવાર કૃત્યો કિસ્સાઓમાં સિવાય.

810
00:38:43,010 --> 00:38:46,632
અન્ય શબ્દોમાં, અમુક બનાવવા તમે શું જો
મૂર્ખ, ખાસ કરીને મોડી રાત્રે નિર્ણય

811
00:38:46,632 --> 00:38:49,340
કે આગામી સવારે અથવા બે દિવસ
પછી, તમે જાગે અને ખ્યાલ,

812
00:38:49,340 --> 00:38:50,870
હું શું વિચારતી હતી?

813
00:38:50,870 --> 00:38:53,890
તમે CS50 માં કરી આઉટલેટ છે
કે સમસ્યા સુધારવા માટે

814
00:38:53,890 --> 00:38:57,170
અને તેને અપ ધરાવતો, કે જેથી અમે
તમે અર્ધે રસ્તે મળે છે અને કામ કરશે

815
00:38:57,170 --> 00:39:01,500
તે એક બાબત માં સાથે, કે બંને છે
શૈક્ષણિક અને તમે મૂલ્યવાન,

816
00:39:01,500 --> 00:39:04,200
પરંતુ હજુ પણ અમુક રીતે શિક્ષાત્મક.

817
00:39:04,200 --> 00:39:08,590
અને હવે, ધાર બોલ લેવા માટે, આ.

818
00:39:08,590 --> 00:39:10,570
>> [વિડિઓ પ્લેબેક]

819
00:39:10,570 --> 00:39:13,540
>> [સંગીત વગાડવાનો]

820
00:39:13,540 --> 00:39:58,090

821
00:39:58,090 --> 00:39:58,866
>> [સમાપ્ત પ્લેબેક]

822
00:39:58,866 --> 00:40:00,490
ડેવિડ જે MALAN: બધા અધિકાર, અમે પાછા છે.

823
00:40:00,490 --> 00:40:03,680
અને હવે અમે એક જોવા
અમારા વાસ્તવિક વિશ્વમાં ડોમેન્સ પ્રથમ

824
00:40:03,680 --> 00:40:08,720
CS50 માં સંકેતલિપી કલા,
મોકલવા અને પ્રાપ્ત કલા

825
00:40:08,720 --> 00:40:11,840
ગુપ્ત સંદેશાઓ, એનક્રિપ્ટ થયેલ
સંદેશાઓ જો તમે કરશે,

826
00:40:11,840 --> 00:40:17,060
કે માત્ર જો તમારી પાસે સાંકેતિક ભાષાનો અર્થ કરી શકો છો
અમુક કી ઘટક મોકલનાર છે કે

827
00:40:17,060 --> 00:40:18,030
તેમજ.

828
00:40:18,030 --> 00:40:22,120
તેથી આ માટે ઉત્સાહિત કરવા માટે આપણે વાત કરીશું
અહીં આ વસ્તુ જોવા,

829
00:40:22,120 --> 00:40:26,750
જે એક ઉદાહરણ છે
ગુપ્ત ડીકોડર રિંગ કે

830
00:40:26,750 --> 00:40:34,042
હુકમ બહાર આકૃતિ માટે વાપરી શકાય છે
શું એક ગુપ્ત સંદેશ ખરેખર છે.

831
00:40:34,042 --> 00:40:35,750
હકીકતમાં, પાછળ
ગ્રેડ શાળા માં દિવસ,

832
00:40:35,750 --> 00:40:38,787
જો તમે ક્યારેય માટે ગુપ્ત સંદેશાઓ મોકલવામાં
કેટલાક મિત્ર કે વર્ગ કેટલાક ક્રશ,

833
00:40:38,787 --> 00:40:40,620
તમે વિચાર્યું છે શકે
તમે હોંશિયાર કરવામાં આવી રહી હતી

834
00:40:40,620 --> 00:40:46,530
કાગળ બદલતા તમારા ભાગ પર દ્વારા,
જેમ, બી, અને બી સી, ​​અને સી ડી માટે,

835
00:40:46,530 --> 00:40:47,590
અને તેથી આગળ.

836
00:40:47,590 --> 00:40:50,300
પરંતુ તમે ખરેખર એનક્રિપ્ટ હતા
તમારી માહિતી પણ

837
00:40:50,300 --> 00:40:53,300
જો તે થોડું તુચ્છ હતી ન હતી,
તે હાર્ડ શિક્ષક ખ્યાલ છે,

838
00:40:53,300 --> 00:40:55,675
વેલ, જો તમે માત્ર બદલી
A અને C બી બી,

839
00:40:55,675 --> 00:40:57,550
તમે ખરેખર બહાર આકૃતિ
શું સંદેશો હતો,

840
00:40:57,550 --> 00:40:59,700
પરંતુ તમે માહિતી સંકેત હતા.

841
00:40:59,700 --> 00:41:03,420
>> તમે માત્ર તે શું કરી રહ્યા હતા
ફક્ત, ખૂબ Ralphie જેમ અહીં

842
00:41:03,420 --> 00:41:07,934
એક પ્રખ્યાત ફિલ્મ કે ભજવે
ખૂબ ખૂબ જાહેરાત nauseum દરેક શિયાળામાં.

843
00:41:07,934 --> 00:41:08,600
[વિડિઓ પ્લેબેક]

844
00:41:08,600 --> 00:41:11,180
બની તે બધા છે કે માટે જાણીતા
રાલ્ફ પાર્કર આથી છે

845
00:41:11,180 --> 00:41:14,070
લિટલ એક સભ્ય તરીકે નિમણૂક
ઓરફામ એની સિક્રેટ સર્કલ

846
00:41:14,070 --> 00:41:17,700
અને બધા સન્માન માટે હકદાર છે
અને લાભો ત્યાં બનતું.

847
00:41:17,700 --> 00:41:24,340
>> -Signed, લિટલ ઓરફામ એની,
કાઉન્ટર સહી પિયર આન્દ્રે, શાહી માં.

848
00:41:24,340 --> 00:41:27,160
સન્માન અને લાભો,
પહેલેથી જ નવ વર્ષની ઉંમરે.

849
00:41:27,160 --> 00:41:30,490

850
00:41:30,490 --> 00:41:31,825
>> [રાડારાડ]

851
00:41:31,825 --> 00:41:33,750

852
00:41:33,750 --> 00:41:34,250
-ચલ.

853
00:41:34,250 --> 00:41:35,210
તે સાથે વિચાર કરીએ.

854
00:41:35,210 --> 00:41:39,530
હું તે બધા જાઝ જરૂર નથી
દાણચોરો અને ચાંચિયાઓને વિશે.

855
00:41:39,530 --> 00:41:41,660
>> માટે -listen કાલે રાત્રે
અંતિમ સાહસ

856
00:41:41,660 --> 00:41:43,880
બ્લેક સમુદ્રી ચાંચીયા.

857
00:41:43,880 --> 00:41:46,650
હવે, તે સમય આવી ગયો છે
એની ગુપ્ત સંદેશ

858
00:41:46,650 --> 00:41:49,840
તમે સિક્રેટ સર્કલ સભ્યો છે.

859
00:41:49,840 --> 00:41:53,570
યાદ રાખો, બાળકો, માત્ર સભ્યો
એની સિક્રેટ સર્કલ

860
00:41:53,570 --> 00:41:56,140
એની ગુપ્ત સંદેશ ડિકોડ કરી શકો છો.

861
00:41:56,140 --> 00:42:00,340
>> યાદ રાખો, એની તમે પર આધાર રાખીને.

862
00:42:00,340 --> 00:42:02,880
B2 માટે તમારી પીન સેટ કરો.

863
00:42:02,880 --> 00:42:05,230
અહીં સંદેશ છે.

864
00:42:05,230 --> 00:42:06,090
12, 11--

865
00:42:06,090 --> 00:42:10,250
>> -i, છું મારી પ્રથમ ગુપ્ત બેઠક.

866
00:42:10,250 --> 00:42:13,890
>> -14, 11, 18, 16.

867
00:42:13,890 --> 00:42:15,780
>> -Pierre મહાન અવાજ આજની રાત કે સાંજ હતી.

868
00:42:15,780 --> 00:42:19,000
હું માનું છું કે આજની રાત કે સાંજ માતાનો કહી શકે છે
સંદેશ ખરેખર મહત્વનું હતું.

869
00:42:19,000 --> 00:42:22,694
>> -3, 25, કે જે એક સંદેશ છે
એની જાતે જ.

870
00:42:22,694 --> 00:42:23,860
યાદ રાખો, કોઈને કહેવું નથી.

871
00:42:23,860 --> 00:42:28,760

872
00:42:28,760 --> 00:42:32,930
>> -90 સેકન્ડ પછી, હું માત્ર છું
ઘરમાં રૂમ જ્યાં નવ એક છોકરો

873
00:42:32,930 --> 00:42:37,040
ગોપનીયતા અને લિપિને ઉકેલવાના બેસી શકે છે.

874
00:42:37,040 --> 00:42:39,730
કટાક્ષ, બી!

875
00:42:39,730 --> 00:42:42,360
હું આગામી, ઇ ગયા

876
00:42:42,360 --> 00:42:44,520
>> પ્રથમ શબ્દ પણ હોઈ છે.

877
00:42:44,520 --> 00:42:49,032
એસ, તે સરળ આવી હવે, યુ, 25--

878
00:42:49,032 --> 00:42:51,733
>> -OH, Ralphie પર આવે છે, હું જવા જેમના!

879
00:42:51,733 --> 00:42:53,688
>> અધિકાર નીચે હોઈ -I'll, મા!

880
00:42:53,688 --> 00:42:54,188
જી સુસવાટો!

881
00:42:54,188 --> 00:42:58,116

882
00:42:58,116 --> 00:43:04,060
>> -T, ઓ, એક-- શું કરવા માટે ખાતરી કરો ખાતરી કરો?

883
00:43:04,060 --> 00:43:05,970
લિટલ ઓરફામ શું હતું
એની કહે છે પ્રયાસ?

884
00:43:05,970 --> 00:43:07,264
શું ખાતરી?

885
00:43:07,264 --> 00:43:09,634
>> -Ralphie, એન્ડી મળ્યું છે
જાઓ, તમે કૃપા કરીને બહાર આવશે?

886
00:43:09,634 --> 00:43:10,480
>> -બધા અધિકાર, મા!

887
00:43:10,480 --> 00:43:12,880
હું અધિકાર બહાર રહેશો!

888
00:43:12,880 --> 00:43:14,550
>> હું નજીક હવે મેળવવામાં આવી હતી.

889
00:43:14,550 --> 00:43:16,620
તણાવ ભયંકર હતી.

890
00:43:16,620 --> 00:43:17,720
તે શું હતું?

891
00:43:17,720 --> 00:43:20,170
ગ્રહ ભાવિ
સંતુલન માં અટકી શકે છે.

892
00:43:20,170 --> 00:43:20,670
>> -Ralphie!

893
00:43:20,670 --> 00:43:23,170
એન્ડી જેમના જાઓ!

894
00:43:23,170 --> 00:43:26,890
>> મોટેથી રડતી માટે અધિકાર બહાર -I'll!

895
00:43:26,890 --> 00:43:32,680
>> ત્યાં -લગભગ, મારી આંગળીઓ ઉડાન ભરી, મારા મન
એક સ્ટીલ છટકું હતું, દરેક છિદ્ર વાઇબ્રેટેડ.

896
00:43:32,680 --> 00:43:37,198
તે લગભગ સ્પષ્ટ હતી, હા, હા, હા.

897
00:43:37,198 --> 00:43:43,091
>> તમારા Ovaltine પીવા માટે ખાતરી-રહો.

898
00:43:43,091 --> 00:43:43,590
Ovaltine?

899
00:43:43,590 --> 00:43:48,160

900
00:43:48,160 --> 00:43:49,430
એક તુચ્છ વ્યાપારી?

901
00:43:49,430 --> 00:43:53,046

902
00:43:53,046 --> 00:43:54,227
એક કૂતરી પુત્ર.

903
00:43:54,227 --> 00:43:54,810
[સમાપ્ત પ્લેબેક]

904
00:43:54,810 --> 00:43:57,390
ડેવિડ જે MALAN: ઠીક છે, તેથી
તે ખૂબ જ લાંબા માર્ગ હતો

905
00:43:57,390 --> 00:44:00,660
ક્રિપ્ટોગ્રાફી રજૂ,
અને પણ Ovaltine.

906
00:44:00,660 --> 00:44:04,470
હકીકતમાં, આ જૂના જાહેરાત થી
અહીં, શા માટે Ovaltine જેથી સારી છે?

907
00:44:04,470 --> 00:44:09,470
તે તૈયાર એક સંકેન્દ્રિત નિષ્કર્ષણ છે
જવ માલ્ટ શુદ્ધ ક્રીમી ગાયનું દૂધ,

908
00:44:09,470 --> 00:44:14,360
અને ખાસ કોકો તૈયાર છે, સાથે મળીને
કુદરતી phosphatides અને વિટામિન્સ સાથે.

909
00:44:14,360 --> 00:44:18,240
તે વધુ કિલ્લા વડે મજબૂત છે
વધારાના વિટામીન બી અને ડી, Yum.

910
00:44:18,240 --> 00:44:21,600
અને તમે હજુ પણ તે મેળવી શકો છો, દેખીતી રીતે
એમેઝોન પર, અમે અહીં હતી.

911
00:44:21,600 --> 00:44:24,810
>> પરંતુ પ્રેરણા અહીં હતી
ક્રિપ્ટોગ્રાફી દાખલ, ખાસ

912
00:44:24,810 --> 00:44:28,340
ક્રિપ્ટોગ્રાફી એક પ્રકાર જાણીતા
ગુપ્ત કી ક્રિપ્ટોગ્રાફી છે.

913
00:44:28,340 --> 00:44:34,284
અને નામ સૂચવે છે, સમગ્ર
એક ગુપ્ત કી ક્રિપ્ટો સિસ્ટમ સુરક્ષા,

914
00:44:34,284 --> 00:44:36,200
જો તમે કરશે, એક પદ્ધતિ
માત્ર મૂંઝાયેલું માટે

915
00:44:36,200 --> 00:44:40,960
બે લોકો વચ્ચે માહિતી, કે જે
માત્ર મોકલનાર અને માત્ર પ્રાપ્તકર્તા

916
00:44:40,960 --> 00:44:46,980
એક ગુપ્ત key-- કેટલાક કિંમત ખબર છે, કેટલાક
ગુપ્ત શબ્દસમૂહ કેટલાક ગુપ્ત નંબર છે, કે જે

917
00:44:46,980 --> 00:44:50,660
તેમને બંને એનક્રિપ્ટ કરવા માટે પરવાનગી આપે
અને માહિતી ડિક્રિપ્ટ.

918
00:44:50,660 --> 00:44:53,470
અને સંકેતલિપી, ખરેખર,
સપ્તાહ 0 થી ફક્ત આ છે.

919
00:44:53,470 --> 00:44:56,715
>> તે એક સમસ્યા જ્યાં ઇનપુટ્સ ત્યાં છે,
ઇંગલિશ માં વાસ્તવિક સંદેશા જેવી

920
00:44:56,715 --> 00:44:59,340
અથવા ગમે ભાષા કે તમે
વર્ગ કોઇને મોકલવા માંગો છો,

921
00:44:59,340 --> 00:45:00,580
અથવા ઈન્ટરનેટ સમગ્ર.

922
00:45:00,580 --> 00:45:03,840
કેટલાક આઉટપુટ છે, કે જે રહ્યું છે
scrambled સંદેશ આવશે કે તમે

923
00:45:03,840 --> 00:45:05,250
પ્રાપ્તકર્તા પ્રાપ્ત કરવા માંગો છો.

924
00:45:05,250 --> 00:45:07,405
અને જો કોઇને
મધ્ય તે ખૂબ મેળવે છે,

925
00:45:07,405 --> 00:45:09,780
તમે નથી, તેમને કરવા માંગો છો
તે જરૂરી છે તે ડિક્રિપ્ટ કરવા માટે સક્ષમ હોય છે,

926
00:45:09,780 --> 00:45:12,840
કારણ કે આ અંદર
બ્લેક બોક્સ, અથવા અલ્ગોરિધમનો,

927
00:45:12,840 --> 00:45:17,650
કેટલાક પદ્ધતિ, પગલું દ્વારા કેટલાક પગલું છે
સૂચનાઓ, કે જે ઇનપુટ લેવા માટે

928
00:45:17,650 --> 00:45:20,710
અને તે રૂપાંતર
આઉટપુટ, આસ્થાપૂર્વક એક સુરક્ષિત રીતે.

929
00:45:20,710 --> 00:45:23,640
>> કેટલાક અને હકીકતમાં, ત્યાં છે
આ વિશ્વમાં શબ્દભંડોળ તરીકે અનુસરે છે.

930
00:45:23,640 --> 00:45:26,100
સાદો લખાણ શબ્દ છે
કોમ્પ્યુટર વૈજ્ઞાનિક કરશે

931
00:45:26,100 --> 00:45:28,449
ઇનપુટ વર્ણન કરવા માટે ઉપયોગ
સંદેશ, ઇંગલિશ જેવી

932
00:45:28,449 --> 00:45:31,240
અથવા જે તમે ખરેખર ભાષા
કેટલાક અન્ય માનવ મોકલવા માંગો છો.

933
00:45:31,240 --> 00:45:35,450
અને પછી સાઇફર ટેક્સટ ભાંખોડિયાંભર થઈને છે
enciphered, અથવા એનક્રિપ્ટ થયેલ,

934
00:45:35,450 --> 00:45:36,520
આવૃત્તિ બાંધે છે.

935
00:45:36,520 --> 00:45:38,750
>> પરંતુ એક અન્ય ઘટક અહીં છે.

936
00:45:38,750 --> 00:45:43,200
ત્યાં એક અન્ય ઈનપુટ છે
ગુપ્ત કી ક્રિપ્ટોગ્રાફી.

937
00:45:43,200 --> 00:45:45,200
અને તે કી પોતે છે,
જે સામાન્ય રીતે છે,

938
00:45:45,200 --> 00:45:48,930
કારણ કે અમે જોશો, એક નંબર, અથવા
પત્ર, અથવા શબ્દ, ગમે

939
00:45:48,930 --> 00:45:51,980
અલ્ગોરિધમનો તે ખરેખર છે અપેક્ષા રાખી છે.

940
00:45:51,980 --> 00:45:53,870
>> અને તમે જે માહિતી કેવી રીતે ડિક્રિપ્ટ કરો છો?

941
00:45:53,870 --> 00:45:55,110
તમે તેને કેવી રીતે Unscramble નથી?

942
00:45:55,110 --> 00:45:57,950
વેલ, તમે માત્ર રિવર્સ
આઉટપુટ અને ઇનપુટ્સ.

943
00:45:57,950 --> 00:46:00,900
>> બીજા શબ્દોમાં કહીએ તો, એક વાર કોઈને
તમારા એનક્રિપ્ટ થયેલ સંદેશો મેળવે છે,

944
00:46:00,900 --> 00:46:03,740
તે અથવા તેણી ફક્ત છે
તે જ કી ખબર.

945
00:46:03,740 --> 00:46:05,700
તેઓ સાઇફર ટેક્સટ પ્રાપ્ત થઈ છે.

946
00:46:05,700 --> 00:46:09,530
અને તે બે પ્લગ દ્વારા
ક્રિપ્ટો સિસ્ટમ માં ઇનપુટ્સ,

947
00:46:09,530 --> 00:46:14,260
અલ્ગોરિધમનો, આ કાળા બોક્સ, બહાર
મૂળ સાદી આવવું જોઈએ.

948
00:46:14,260 --> 00:46:17,830
અને તેથી તે ખૂબ જ ઊંચા સ્તર છે
શું ક્રિપ્ટોગ્રાફી ખરેખર છે જુઓ

949
00:46:17,830 --> 00:46:18,590
બધા વિશે.

950
00:46:18,590 --> 00:46:20,030
>> તેથી આપણે ત્યાં વિચાર કરીએ.

951
00:46:20,030 --> 00:46:22,700
હવે નીચે જુઓ
કંઈક હૂડ

952
00:46:22,700 --> 00:46:26,000
અમે મંજૂર માટે લઈ આવી છે
છેલ્લા અઠવાડિયે, અને આ માટે સત્ર

953
00:46:26,000 --> 00:46:27,629
શબ્દમાળા અહીં.

954
00:46:27,629 --> 00:46:30,295
દિવસ ઓવરને અંતે એક શબ્દમાળા
માત્ર અક્ષરો ક્રમ છે.

955
00:46:30,295 --> 00:46:33,610
>> તે હેલો વર્લ્ડ હોઈ શકે, અથવા
હેલો Zamyla, અથવા ગમે.

956
00:46:33,610 --> 00:46:37,050
પરંતુ તે શું અર્થ છે
અક્ષરો ક્રમ હશે?

957
00:46:37,050 --> 00:46:41,520
હકીકતમાં, આ CS50 પુસ્તકાલય આપે
અમને શબ્દમાળા તરીકે ઓળખાય એક માહિતી પ્રકાર.

958
00:46:41,520 --> 00:46:45,140
>> પરંતુ ત્યાં ખરેખર કોઈ
સી શબ્દમાળા તરીકે જેમ કે વસ્તુ

959
00:46:45,140 --> 00:46:49,450
તે ખરેખર માત્ર એક ક્રમ છે
પાત્ર, પાત્ર, પાત્ર,

960
00:46:49,450 --> 00:46:52,180
પાત્ર, બેક, પાછળ,
પાછા પાછળ અંદર બેકઅપ

961
00:46:52,180 --> 00:46:54,650
તમારા કમ્પ્યુટરની મેમરી, અથવા RAM ની.

962
00:46:54,650 --> 00:46:58,940
અને અમે તે માં ઊંડા જોવા મળશે
ભવિષ્યમાં જ્યારે અમે મેમરી પોતે જોવા

963
00:46:58,940 --> 00:47:02,030
અને ઉપયોગ, અને
ધમકીઓ કે સામેલ છે.

964
00:47:02,030 --> 00:47:04,100
>> પરંતુ શબ્દમાળા Zamyla વિચાર કરીએ.

965
00:47:04,100 --> 00:47:07,480
તેથી માત્ર નામ
માનવ અહીં, Zamyla,

966
00:47:07,480 --> 00:47:12,030
કે એક ક્રમ છે
અક્ષરો, Z-A-એમ-વાય-એલ-A.

967
00:47:12,030 --> 00:47:16,020
અને હવે ધારો કે દો કે Zamyla નામ
કમ્પ્યુટર ની અંદર સંગ્રહિત કરવામાં આવી રહી છે

968
00:47:16,020 --> 00:47:16,880
કાર્યક્રમ.

969
00:47:16,880 --> 00:47:20,830
>> વેલ, તે કારણ છે કે આપણે જોઇએ રહે
તે અક્ષરો જોવા માટે સમર્થ હશે

970
00:47:20,830 --> 00:47:21,590
વ્યક્તિગત રીતે.

971
00:47:21,590 --> 00:47:24,710
તેથી હું થોડી ડ્રો કરવા જઇ રહ્યો છું
અહીં Zamyla નામ આસપાસ બોક્સ.

972
00:47:24,710 --> 00:47:31,580
અને તે સી કેસ એ છે કે જ્યારે તમે
Zamyla-- અને કદાચ જેમ, એક શબ્દમાળા છે

973
00:47:31,580 --> 00:47:34,940
કે જેઓ શબ્દમાળા માંથી પાછા આવે છે
ગેટ શબ્દમાળા જેમ કાર્ય,

974
00:47:34,940 --> 00:47:38,540
તમે ખરેખર ચાલાકી કરી શકો છો
અક્ષર દ્વારા તે પાત્ર.

975
00:47:38,540 --> 00:47:42,070
>> હવે, આ માટે સંગત છે
વાતચીત હાથ પર છે, કારણ કે

976
00:47:42,070 --> 00:47:46,420
ક્રિપ્ટોગ્રાફી તમે બદલવા માંગો છો, તો
એ બી, અને બી સી, ​​અને ડી સી,

977
00:47:46,420 --> 00:47:49,650
અને તેથી આગળ, તમે કરવાનો પ્રયત્ન કરવાની જરૂર
વ્યક્તિગત અક્ષરો જોવા માટે

978
00:47:49,650 --> 00:47:50,190
એક શબ્દમાળા માં.

979
00:47:50,190 --> 00:47:52,695
તમે બદલવા કરવાનો પ્રયત્ન કરવાની જરૂર
કંઈક બીજું, એ માટે Z

980
00:47:52,695 --> 00:47:55,280
કંઈક બીજું, એમ કરવા માટે
બીજું, અને તેથી પર કંઈક.

981
00:47:55,280 --> 00:47:58,000
અને તેથી અમે એક રસ્તો જરૂર,
પ્રોગ્રામ, તેથી

982
00:47:58,000 --> 00:48:03,020
વાત કરવા માટે સી બદલવા માટે સમર્થ થવા માટે
અને વ્યક્તિગત અક્ષરો જુઓ.

983
00:48:03,020 --> 00:48:05,690
અને અમે આ નીચે પ્રમાણે કરી શકે છે.

984
00:48:05,690 --> 00:48:08,340
>> મને CS50 IDE પાછા વડા જવા દો.

985
00:48:08,340 --> 00:48:11,130
અને મને આગળ જવા દો
અને એક નવી ફાઈલ બનાવવા

986
00:48:11,130 --> 00:48:16,134
કે હું આ સમય string0 કહી શકશો,
અમારી પ્રથમ જેમ કે ઉદાહરણ તરીકે, ડોટ સી.

987
00:48:16,134 --> 00:48:18,300
અને હું આગળ જાઓ જાઉં છું
અને તે ચાબુક અપ અનુસરે છે.

988
00:48:18,300 --> 00:48:22,870
>> તેથી cs50.h સમાવેશ થાય છે, અને
પછી ધોરણ io.h સમાવેશ થાય છે,

989
00:48:22,870 --> 00:48:25,990
જે હું લગભગ હંમેશા માટે જઇ રહ્યો છું
મારા કાર્યક્રમોમાં ઉપયોગ કરીને, ઓછામાં ઓછા હોઈ

990
00:48:25,990 --> 00:48:26,780
શરૂઆતમાં.

991
00:48:26,780 --> 00:48:32,180
મુખ્ય રદબાતલ પૂર્ણાંક, અને પછી અહીં હું છું
શબ્દમાળાઓ કરવા જઇ શબ્દમાળા વિચાર નહીં.

992
00:48:32,180 --> 00:48:35,260
અને પછી હું જાઉં છું
આગળ વધો અને આ કરવા.

993
00:48:35,260 --> 00:48:37,460
હું આગળ જાઓ કરવા માંગો છો
અને, એક સેનીટી ચેક તરીકે,

994
00:48:37,460 --> 00:48:43,607
માત્ર કહે છે, હેલો, ટકા ઓ,
અર્ધવિરામ, શબ્દમાળા 0 બનાવે છે.

995
00:48:43,607 --> 00:48:44,690
ઓહો, હું અહીં શું કર્યું?

996
00:48:44,690 --> 00:48:45,930
ઓહ, હું તેને પ્લગ ન હતી.

997
00:48:45,930 --> 00:48:48,120
તેથી પાઠ શીખ્યા કે
ઇરાદાપૂર્વક ન હતી.

998
00:48:48,120 --> 00:48:52,480
>> તેથી ભૂલ, વધુ ટકા
માહિતી દલીલો કરતાં રૂપાંતરણો.

999
00:48:52,480 --> 00:48:54,940
અને આ છે જ્યાં,
રેખા 7-- ઠીક છે, તેથી હું હોય છે,

1000
00:48:54,940 --> 00:48:56,690
ભાવ અવતરણ ચિહ્નો પૂરાં કરવાં, કે
મારા શબ્દમાળા printf માટે.

1001
00:48:56,690 --> 00:48:58,151
હું એક ટકા સાઇન મળી છે.

1002
00:48:58,151 --> 00:48:59,650
પરંતુ હું બીજી દલીલ ખૂટે છું.

1003
00:48:59,650 --> 00:49:03,190
>> હું ગુમ છું અલ્પવિરામ ઓ, કે જે
હું અગાઉના ઉદાહરણો હોય હતી.

1004
00:49:03,190 --> 00:49:06,650
તેથી આ એક સારી તક સુધારવા માટે
વધુ એક ભૂલ, આકસ્મિક.

1005
00:49:06,650 --> 00:49:09,950
અને હવે મને ચલાવો
Zamyla માં string0, પ્રકાર.

1006
00:49:09,950 --> 00:49:10,970
Zamyla હેલો બરાબર.

1007
00:49:10,970 --> 00:49:14,144
>> તેથી અમે આ પ્રકારની કાર્યક્રમ ચલાવવા છે
હવે થોડા જુદા જુદા.

1008
00:49:14,144 --> 00:49:16,310
પરંતુ કંઈક કરવા દો
થોડું અલગ આ સમય.

1009
00:49:16,310 --> 00:49:19,450
તેના બદલે માત્ર Zamyla પ્રિન્ટીંગ ના
printf સાથે બહાર સમગ્ર નામ,

1010
00:49:19,450 --> 00:49:21,350
પાત્ર દ્વારા તે પાત્ર કરીએ.

1011
00:49:21,350 --> 00:49:22,700
>> હું લૂપ માટે ઉપયોગ કરવા જઇ રહ્યો છું.

1012
00:49:22,700 --> 00:49:26,160
અને હું મારી જાતને આપવા જઈ રહ્યો છું
એક ગણતરી ચલ, હું કહેવામાં આવે છે.

1013
00:49:26,160 --> 00:49:33,530
અને હું વારો રાખવા જઈ રહ્યો છું, તેથી
લાંબા સમય સુધી હું ઓ લંબાઈ કરતાં ઓછી છે.

1014
00:49:33,530 --> 00:49:35,930
>> તે બહાર વળે છે, અમે ન
આ છેલ્લી વખત કરવું,

1015
00:49:35,930 --> 00:49:39,100
કે સી સાથે આવે છે
કાર્ય સ્ટર્લિંગ કહેવામાં આવે છે.

1016
00:49:39,100 --> 00:49:42,690
પાછા દિવસ, અને સામાન્ય રીતે
હજુ પણ જ્યારે કાર્યો અમલીકરણ,

1017
00:49:42,690 --> 00:49:45,405
મનુષ્યો ઘણી વખત ખૂબ જ પસંદ કરશે
succinct નામો કે અવાજ પ્રકારની

1018
00:49:45,405 --> 00:49:48,280
તમે શું કરવા માંગો છો, તે છતાં પણ જેમ
થોડા સ્વરો અથવા અક્ષરો ખૂટે છે.

1019
00:49:48,280 --> 00:49:50,660
તેથી સ્ટર્લિંગ છે
એક કાર્ય નામ કે

1020
00:49:50,660 --> 00:49:53,880
વચ્ચે એક દલીલ લે છે
કૌંસ કે જે શબ્દમાળા હોવી જોઈએ.

1021
00:49:53,880 --> 00:49:56,910
અને તે માત્ર પૂર્ણાંક આપે છે,
કે જેઓ શબ્દમાળા લંબાઈ.

1022
00:49:56,910 --> 00:50:00,580
>> 7 વાક્ય પર લૂપ માટે આ ખૂબ રહ્યું છે
ગણાય હું 0 સમકક્ષ હોય છે શરૂ કરવા માટે.

1023
00:50:00,580 --> 00:50:02,530
તેને વધારતી જઈ રહ્યું છે
હું દરેક ઇટરેશન પર

1024
00:50:02,530 --> 00:50:04,350
1, અમે થોડા વખત કરી રહ્યો છું કારણ કે.

1025
00:50:04,350 --> 00:50:06,780
પરંતુ તે માત્ર કરવા જઇ રહ્યું છે
બિંદુ સુધી આ

1026
00:50:06,780 --> 00:50:09,660
જ્યારે હું લંબાઈ છે
શબ્દમાળા પોતે.

1027
00:50:09,660 --> 00:50:14,520
>> તેથી આ એક માર્ગ છે, આખરે,
અક્ષરો પર વારો

1028
00:50:14,520 --> 00:50:17,430
શબ્દમાળા તરીકે નીચે પ્રમાણે છે.

1029
00:50:17,430 --> 00:50:20,670
હું નથી છાપે એક જાઉં છું
સમગ્ર શબ્દમાળા છે, પરંતુ ટકા સી,

1030
00:50:20,670 --> 00:50:22,860
એક પાત્ર
એક નવી લાઇન દ્વારા અનુસરવામાં.

1031
00:50:22,860 --> 00:50:24,880
અને પછી હું જાઉં છું
આગળ જાઓ, અને હું જરૂર

1032
00:50:24,880 --> 00:50:29,080
હું પ્રિન્ટ કરવા માંગો છો કહે છે
ઓ ઇથ પાત્ર.

1033
00:50:29,080 --> 00:50:33,450
>> તેથી જો હું ચલ છે કે જે સૂચવે છે
શબ્દમાળા છે, જ્યાં ઇન્ડેક્સ

1034
00:50:33,450 --> 00:50:37,230
તમે તે, હું સમક્ષ રજુ કરવાનો પ્રયત્ન કરવાની જરૂર છે
કહે છે, મને ઓ ઇથ અક્ષર આપે છે.

1035
00:50:37,230 --> 00:50:40,390
અને સી કરી એક માર્ગ છે
ચોરસ કૌંસ સાથે આ.

1036
00:50:40,390 --> 00:50:43,679
તમે સરળતાથી નામ કહે છે
શબ્દમાળા છે, કે જે આ કિસ્સામાં ઓ છે.

1037
00:50:43,679 --> 00:50:46,970
પછી તમે ચોરસ કૌંસ છે, જે ઉપયોગ
સામાન્ય રીતે માત્ર તમારી પરત ફરવા માટેની અથવા Enter ઉપર

1038
00:50:46,970 --> 00:50:48,110
કીબોર્ડ પર કી.

1039
00:50:48,110 --> 00:50:52,410
અને પછી તમે ઇન્ડેક્સ પુટ
અક્ષર કે જે તમે પ્રિન્ટ કરવા માંગો છો.

1040
00:50:52,410 --> 00:50:55,960
તેથી ઇન્ડેક્સ પ્રયત્ન રહ્યું છે
સંખ્યાની 0, અથવા 1, અથવા 2, અથવા 3, અથવા કોઈ,

1041
00:50:55,960 --> 00:50:57,590
ડોટ, કોઈ, અન્ય કેટલાક નંબર.

1042
00:50:57,590 --> 00:51:00,920
>> અને અમે ખાતરી કરો કે તે ચાલી રહ્યું છે
, જમણી નંબર છે, કારણ કે હું

1043
00:51:00,920 --> 00:51:02,360
0 ગણતરી શરૂ કરો.

1044
00:51:02,360 --> 00:51:07,020
અને મૂળભૂત દ્વારા, પ્રથમ અક્ષર
એક શબ્દમાળા માં સંમેલન 0 છે.

1045
00:51:07,020 --> 00:51:09,230
અને બીજા પાત્ર કૌંસ 1 છે.

1046
00:51:09,230 --> 00:51:11,120
અને ત્રીજા પાત્ર કૌંસ 2 છે.

1047
00:51:11,120 --> 00:51:13,630
અને તમે પણ જવા માટે નથી માંગતા
અત્યાર સુધી, પરંતુ અમે કારણ કે અમે રહ્યાં છે

1048
00:51:13,630 --> 00:51:17,780
માત્ર તે ત્યાં સુધી હું વધારતી જઈ
શબ્દમાળા લંબાઈ સમકક્ષ હોય છે.

1049
00:51:17,780 --> 00:51:20,210
અને જે બિંદુએ,
લૂપ માટે આ બંધ કરશે.

1050
00:51:20,210 --> 00:51:25,550
>> તેથી મને આગળ વધો અને આ સાચવવા દો
કાર્યક્રમ, અને રન શબ્દમાળા 0 બનાવવા.

1051
00:51:25,550 --> 00:51:28,400
પરંતુ હું ખરાબ કર્યું.

1052
00:51:28,400 --> 00:51:35,390
સર્વથા પુસ્તકાલય કાર્ય જાહેર
પ્રકાર જેમ કે સાથે સ્ટર્લિંગ અને હવે such--,

1053
00:51:35,390 --> 00:51:36,430
આ પરિચિત લાગે છે.

1054
00:51:36,430 --> 00:51:37,440
પરંતુ તે printf નથી.

1055
00:51:37,440 --> 00:51:38,540
અને તે શબ્દમાળા મળે છે.

1056
00:51:38,540 --> 00:51:40,480
>> હું સ્ક્રૂ ન હતી
એ જ રીતે આ સમય.

1057
00:51:40,480 --> 00:51:45,100
પરંતુ નીચે નીચે અહીં થોડી નોટિસ
વધુ, હેડર string.h સમાવેશ થાય છે,

1058
00:51:45,100 --> 00:51:47,210
બાહ્ય પૂરી પાડે છે
સ્ટર્લિંગ માટે ઘોષણા.

1059
00:51:47,210 --> 00:51:48,820
તેથી ત્યાં ખરેખર ત્યાં એક ચાવી છે.

1060
00:51:48,820 --> 00:51:51,670
>> અને ખરેખર તે બહાર વળે
ત્યાં અન્ય હેડર ફાઈલ છે

1061
00:51:51,670 --> 00:51:53,970
કે અમે ઉપયોગ કર્યો
વર્ગ હજુ સુધી, પરંતુ તે

1062
00:51:53,970 --> 00:51:56,480
ઉપલબ્ધ લોકોમાં
તમને string.h કહેવાય છે.

1063
00:51:56,480 --> 00:52:00,930
અને તે ફાઇલ string.h માં
સ્ટર્લિંગ જાહેર છે.

1064
00:52:00,930 --> 00:52:05,220
તેથી દો મને આગળ વધો અને
આ સંગ્રહો, શબ્દમાળા બનાવવા

1065
00:52:05,220 --> 00:52:08,040
0 છે સરસ, કોઈ ભૂલ સંદેશાઓ આ સમય.

1066
00:52:08,040 --> 00:52:12,290
>> ./string0 Zamyla છે, અને
હું વિશે Enter દબાવો છું

1067
00:52:12,290 --> 00:52:16,710
કે બિંદુ GetString રહ્યું છે
શબ્દમાળા પાછા, તે મૂકો.

1068
00:52:16,710 --> 00:52:21,890
લૂપ માટે ફરી વળવું રહ્યા છે પછી તે
એક સમયે અક્ષરો એક પર,

1069
00:52:21,890 --> 00:52:28,420
અને તેમને લાઇન દીઠ એક છાપો, કારણ કે
હું ઓવરને અંતે કે બેકસ્લેશ n હતી.

1070
00:52:28,420 --> 00:52:34,530
તેથી હું બેકસ્લેશ રદ્દ કરી શકે છે
n એ, અને પછી માત્ર Zamyla બધા પ્રિન્ટ

1071
00:52:34,530 --> 00:52:37,460
જ વાક્ય,
અસરકારક રીતે reimplementing

1072
00:52:37,460 --> 00:52:38,999
printf, જે બધી છે કે ઉપયોગી નથી.

1073
00:52:38,999 --> 00:52:40,540
પરંતુ આ કિસ્સામાં, હું નથી કર્યું.

1074
00:52:40,540 --> 00:52:43,610
હું ખરેખર એક મુદ્રિત છે
એક સમયે પાત્ર, લાઇન દીઠ એક

1075
00:52:43,610 --> 00:52:45,400
તેથી અમે ખરેખર અસર જોવા છે.

1076
00:52:45,400 --> 00:52:46,900
>> પરંતુ હું એક વસ્તુ અહીં નોંધ લેવી જોઈએ.

1077
00:52:46,900 --> 00:52:48,930
અને અમે પાછા આવો પડશે
ભવિષ્યના સપ્તાહમાં આ.

1078
00:52:48,930 --> 00:52:52,650
આ છે કે જે બહાર વળે
કોડ સંભવિત બગડેલ છે.

1079
00:52:52,650 --> 00:52:56,560
>> તે તારણ છે કે ગેટ શબ્દમાળા
અને જીવન માં અમુક અન્ય કાર્યો

1080
00:52:56,560 --> 00:53:00,280
જરૂરી હંમેશા નથી
તમે શું અપેક્ષા કરી રહ્યાં છો આવો.

1081
00:53:00,280 --> 00:53:03,010
અમે વર્ગ છેલ્લા પરથી ખબર
આ વિચાર સમય

1082
00:53:03,010 --> 00:53:04,960
શબ્દમાળા શબ્દમાળા પાછા માનવામાં આવે છે.

1083
00:53:04,960 --> 00:53:09,900
પરંતુ જો વપરાશકર્તા પ્રકારો બહાર આવી
લાંબા શબ્દ અથવા ફકરો, અથવા નિબંધ

1084
00:53:09,900 --> 00:53:13,010
ત્યાં માત્ર પૂરતી નથી કે
કમ્પ્યુટર મેમરી તેને ફિટ.

1085
00:53:13,010 --> 00:53:15,410
>> જેમ, શું કંઈક જાય તો
હૂડ નીચે ખોટું શું છે?

1086
00:53:15,410 --> 00:53:18,400
તે ઘણી વખત ન થાય શકે છે,
પરંતુ તે એક જ બની શકે છે

1087
00:53:18,400 --> 00:53:21,520
જ્યારે માં, ખૂબ કવચિત.

1088
00:53:21,520 --> 00:53:25,460
અને તેથી તે તારણ આપે છે કે ગેટ શબ્દમાળા
અને જરૂરી નથી કે તે જેવા કાર્યો

1089
00:53:25,460 --> 00:53:26,380
હંમેશા શબ્દમાળાઓ આવો.

1090
00:53:26,380 --> 00:53:30,680
તેઓ કેટલાક ભૂલ કિંમત પાછી શકે છે,
કેટલાક સંત્રી કિંમત તેથી વાત કરવા માટે

1091
00:53:30,680 --> 00:53:32,612
કે જે સૂચવે
કંઈક ખોટું થયું છે.

1092
00:53:32,612 --> 00:53:35,320
અને તમે માત્ર આ ખબર હોત
વર્ગ તે હવે શીખ્યા,

1093
00:53:35,320 --> 00:53:37,700
અથવા કેટલાક વધુ દસ્તા વાંચી હતી.

1094
00:53:37,700 --> 00:53:43,120
તે તારણ છે કે ગેટ શબ્દમાળા
નલ કહેવાય કિંમત પાછા આવી શકો છો.

1095
00:53:43,120 --> 00:53:46,220
નલ ખાસ કિંમત છે કે અમે પડશે
ભવિષ્યના સપ્તાહ પાછા આવે છે.

1096
00:53:46,220 --> 00:53:50,420
પરંતુ હવે માટે, માત્ર ખબર છે કે જો હું માંગો છો
ખરેખર આગળ વધવા યોગ્ય હોઈ

1097
00:53:50,420 --> 00:53:52,650
શબ્દમાળા વિચાર ઉપયોગ, હું
માત્ર તે કહી ન જોઈએ,

1098
00:53:52,650 --> 00:53:56,870
અને અકારણ તેના વળતર કિંમત વાપરવા માટે,
વિશ્વાસ છે કે તે એક શબ્દમાળા છે.

1099
00:53:56,870 --> 00:53:59,420
>> હું પ્રથમ કહેવું જોઈએ
અરે, એક મિનિટ માત્ર રાહ જુઓ,

1100
00:53:59,420 --> 00:54:03,380
આગળ વધવા જો ઓ સમાન નથી
નલ છે, જ્યાં નલ, ફરી,

1101
00:54:03,380 --> 00:54:04,660
માત્ર કેટલાક ખાસ કિંમત છે.

1102
00:54:04,660 --> 00:54:07,770
અને તે માત્ર ખાસ કિંમત તમે
ગેટ શબ્દમાળા માટે વિશે ચિંતા કરવાની જરૂર છે.

1103
00:54:07,770 --> 00:54:10,900
શબ્દમાળા ક્યાં રહ્યું છે મેળવો
શબ્દમાળા અથવા નલ આવો.

1104
00:54:10,900 --> 00:54:17,219
>> અને આ ઉદ્ગારવાચક બિંદુ સાઇન સમકક્ષ
તમે કદાચ ગણિત વર્ગ થી ખબર પડી શકે છે

1105
00:54:17,219 --> 00:54:20,510
તમારી સાથે એક સમાન સાઇન ડ્રો કરી શકે છે કે
તે મારફતે વાક્ય બરાબર નથી સૂચવે છે.

1106
00:54:20,510 --> 00:54:23,135
જે સામાન્ય રીતે એક અક્ષર નથી
તમે તમારા કીબોર્ડ પર ટાઈપ કરી શકો છો.

1107
00:54:23,135 --> 00:54:26,480
અને તેથી મોટા ભાગના પ્રોગ્રામિંગ ભાષાઓ,
તમે સમાન કહેવા માગો છો, ત્યારે

1108
00:54:26,480 --> 00:54:29,160
તમે એક ઉદ્ગારવાચક બિંદુ વાપરવા માટે,
અન્યથા બેંગ તરીકે ઓળખાય છે.

1109
00:54:29,160 --> 00:54:33,180
તેથી તમે કહી બેંગ, બરાબર જે
બરાબર નથી, તાર્કિક થાય છે.

1110
00:54:33,180 --> 00:54:38,060
તે ત્યાં એક મોટી નથી જેમ છે
કરતાં, અથવા સમાન, અથવા કરતાં ઓછી

1111
00:54:38,060 --> 00:54:41,270
અથવા સમાન તમારા કીબોર્ડ પર કી
તે બધા એક પ્રતીક છે.

1112
00:54:41,270 --> 00:54:44,020
એટલે કે શા માટે, છેલ્લા ઉદાહરણોમાં,
તમે એક ઓપન કૌંસ હતી, અને પછી

1113
00:54:44,020 --> 00:54:48,670
એક સમાન સાઇન, ક્રમમાં કરવા માટે
એક કરતાં વધારે અથવા, કહે છે તે કરતાં ઓછો હોય છે.

1114
00:54:48,670 --> 00:54:49,910
>> તેથી શું અહીં takeaway?

1115
00:54:49,910 --> 00:54:53,880
આ ફક્ત હવે એક રસ્તો છે
આ વાક્યરચના રજૂઆત, આ લક્ષણ,

1116
00:54:53,880 --> 00:54:57,390
વ્યક્તિગત પર વારો
એક શબ્દમાળા માં અક્ષરો.

1117
00:54:57,390 --> 00:55:00,260
અને માત્ર તે ચોરસ જેવી
કૌંસ, તમે તેમને મેળવવા માટે પરવાનગી આપે છે

1118
00:55:00,260 --> 00:55:03,790
કારણ કે તે ચોરસ કૌંસ ધ્યાનમાં
પ્રકારની આ અંતર્ગત અંતે hinting

1119
00:55:03,790 --> 00:55:06,040
ડિઝાઇન, જેમાં દરેક
શબ્દમાળા અંદર પાત્ર

1120
00:55:06,040 --> 00:55:10,180
પ્રકારની નીચે ક્યાંક સંયોજિત છે
તમારા કમ્પ્યુટરની મેમરી હૂડ.

1121
00:55:10,180 --> 00:55:12,340
>> પરંતુ આ એક ચલ બનાવવા દો.

1122
00:55:12,340 --> 00:55:14,880
આ છે કે જે બહાર વળે
કાર્યક્રમ યોગ્ય છે.

1123
00:55:14,880 --> 00:55:18,810
તેથી CS50 માતાનો સીમાની દીઠ મૂલ્યાંકન માટે
કોડ છે, હવે આ સાચું છે.

1124
00:55:18,810 --> 00:55:22,959
ખાસ કરીને હવે હું તપાસ કરું છું
નલ, આ કાર્યક્રમ ક્યારેય ભાંગી જોઈએ.

1125
00:55:22,959 --> 00:55:24,500
અને હું માત્ર અનુભવ પરથી ખબર.

1126
00:55:24,500 --> 00:55:28,040
પરંતુ ત્યાં બીજું કંઇ છે કે
અમે ખરેખર ખોટું અહીં જઈ શકો છો.

1127
00:55:28,040 --> 00:55:31,860
પરંતુ તે ખૂબ જ સારી રીતે રચાયેલ નથી,
કારણ કે ચાલો ઈપીએસ પાછા જાઓ.

1128
00:55:31,860 --> 00:55:34,450
>> પ્રથમ, principles--
લૂપ માટે શું કરે છે?

1129
00:55:34,450 --> 00:55:36,290
લૂપ માટે ત્રણ વસ્તુઓ કરે છે.

1130
00:55:36,290 --> 00:55:39,340
તે કેટલાક પ્રારંભ
કિંમત, જો તમે તેને પૂછો.

1131
00:55:39,340 --> 00:55:41,770
તે એક શરત ચકાસે છે.

1132
00:55:41,770 --> 00:55:45,380
અને પછી દરેક
પુનરાવૃત્તિ, દરેક ચક્ર પછી,

1133
00:55:45,380 --> 00:55:49,330
તે કેટલાક ઇન્ક્રીમેન્ટ
કિંમત, અથવા મૂલ્યો, અહીં.

1134
00:55:49,330 --> 00:55:50,600
>> તેથી તે શું અર્થ છે?

1135
00:55:50,600 --> 00:55:52,940
અમે હું 0 પ્રારંભ.

1136
00:55:52,940 --> 00:55:58,610
અમે તપાસો અને ખાતરી કરો કે હું કરતાં ઓછી છે
ઓ લંબાઈ, કે જે z એ એમ વાય-એલ-A છે,

1137
00:55:58,610 --> 00:55:59,900
તેથી જે 6 કરતાં ઓછી છે.

1138
00:55:59,900 --> 00:56:02,590
અને, ખરેખર, 0 કરતાં ઓછી 6.

1139
00:56:02,590 --> 00:56:05,580
>> અમે Zamyla નામ થી Z છાપશે.

1140
00:56:05,580 --> 00:56:08,080
પછી અમે હું 0 થી 1 ઇન્ક્રીમેન્ટ.

1141
00:56:08,080 --> 00:56:11,290
અમે પછી તપાસો, 1 ઓછી છે
ઓ લંબાઈ કરતાં?

1142
00:56:11,290 --> 00:56:13,270
ઓ લંબાઈ 6 છે.

1143
00:56:13,270 --> 00:56:13,950
હા તે છે.

1144
00:56:13,950 --> 00:56:16,880
>> તેથી અમે Zamyla નામ, અફ્રિકા માં પ્રિન્ટ.

1145
00:56:16,880 --> 00:56:20,090
અમે 0 થી હું વધારો, 1, 2.

1146
00:56:20,090 --> 00:56:23,720
અમે પછી તપાસો, 2 કરતાં ઓછી છે
Zamyla નામ લંબાઈ.

1147
00:56:23,720 --> 00:56:25,380
6- જેથી 2 6 કરતાં ઓછી છે.

1148
00:56:25,380 --> 00:56:30,460
હા, એ એમ હવે છાપે દો
Zamyla નામ, ત્રીજા પાત્ર.

1149
00:56:30,460 --> 00:56:34,110
>> અહીં કી છે કે દરેક પર છે
વાર્તા પુનરાવૃત્તિ, હું ચકાસણી છું,

1150
00:56:34,110 --> 00:56:37,810
હું Zamyla ના લંબાઈ કરતાં ઓછી છે?

1151
00:56:37,810 --> 00:56:40,350
પરંતુ કેચ છે કે
સ્ટર્લિંગ એક મિલકત નથી.

1152
00:56:40,350 --> 00:56:43,100
તમે જે લોકો પ્રોગ્રામ છે
જાવા અથવા અન્ય ભાષાઓમાં પહેલાં

1153
00:56:43,100 --> 00:56:46,310
લંબાઈ ખબર પડી શકે છે એક શબ્દમાળા છે
મિલકત, માત્ર કેટલાક માત્ર કિંમત વાંચો.

1154
00:56:46,310 --> 00:56:50,220
>> આ કિસ્સામાં સી, આ છે જો
એક કાર્ય શાબ્દિક અર્થ છે કે

1155
00:56:50,220 --> 00:56:53,520
સંખ્યા ગણતરી
દર વખતે Zamyla અક્ષરો

1156
00:56:53,520 --> 00:56:54,740
અમે તે કાર્ય કૉલ કરો.

1157
00:56:54,740 --> 00:56:58,500
દર વખતે તમે ઉપયોગ કરવા માટે કમ્પ્યુટર પૂછો
સ્ટર્લિંગ, તે Zamyla પર એક નજર લેતી છે,

1158
00:56:58,500 --> 00:57:01,960
અને કહ્યું Z-A-એમ-વાય-એલ-એ, 6.

1159
00:57:01,960 --> 00:57:02,962
અને તે 6 આપે છે.

1160
00:57:02,962 --> 00:57:04,920
આગળના સમયે તમે કૉલ
તે લૂપ માટે અંદર,

1161
00:57:04,920 --> 00:57:08,610
તે Zamyla જોવા જઈ રહ્યું છે
ફરીથી, કહે Z-A-એમ-વાય-એલ-એ, 6.

1162
00:57:08,610 --> 00:57:10,320
અને તે 6 પરત ચાલી રહ્યું છે.

1163
00:57:10,320 --> 00:57:12,980
તેથી શું આ ડિઝાઇન વિશે મૂર્ખ છે?

1164
00:57:12,980 --> 00:57:17,700
>> શા માટે મારા કોડ નથી 5 બહાર 5
ડિઝાઇન માટે હમણાં, તેથી વાત કરવા માટે?

1165
00:57:17,700 --> 00:57:20,600
ઠીક છે, હું પૂછવા છું એક
બિનજરૂરી પ્રશ્ન.

1166
00:57:20,600 --> 00:57:23,030
હું વધારે કામ કરી રહ્યો છું કરતાં હું કરવાની જરૂર છે.

1167
00:57:23,030 --> 00:57:25,370
>> તેથી ભલે
જવાબ સાચો છે, હું છું

1168
00:57:25,370 --> 00:57:29,560
કમ્પ્યુટર પૂછવા, શું છે
Zamyla લંબાઈ ફરી,

1169
00:57:29,560 --> 00:57:31,380
અને ફરી, અને ફરી, અને ફરીથી?

1170
00:57:31,380 --> 00:57:33,980
અને તે જવાબ છે
ક્યારેય બદલવા માટે જઈ રહી છે.

1171
00:57:33,980 --> 00:57:35,900
તે હંમેશા 6 હોઈ ચાલે છે.

1172
00:57:35,900 --> 00:57:39,730
>> તેથી આ કરતાં એક વધુ સારો ઉકેલ
આ આગામી આવૃત્તિ હશે.

1173
00:57:39,730 --> 00:57:43,390
મને આગળ વધો અને એક માં મૂકી
string1.c કહેવાય અલગ ફાઇલ,

1174
00:57:43,390 --> 00:57:44,990
જસ્ટ રાખવા તે અલગ.

1175
00:57:44,990 --> 00:57:47,260
અને તે માટે એક બહાર વળે
લૂપ, તમે ખરેખર આ કરી શકો છો

1176
00:57:47,260 --> 00:57:50,210
એક જ સમયે બહુવિધ ચલો જાહેર.

1177
00:57:50,210 --> 00:57:53,460
>> તેથી હું રાખવા અને 0 થી તેને સુયોજિત કરવા માટે જઇ રહ્યો છું.

1178
00:57:53,460 --> 00:57:56,190
પરંતુ હું પણ જાઉં છું
અલ્પવિરામ ઉમેરવા, અને કહે છે,

1179
00:57:56,190 --> 00:58:01,050
મને એક ચલ n એ કહેવાય, જેની આપી
કિંમત ઓ શબ્દમાળા લંબાઈ સમકક્ષ હોય છે.

1180
00:58:01,050 --> 00:58:09,410
અને હવે, મારા સ્થિતિ બનાવવા કૃપા કરીને
તેથી લાંબા તરીકે હું એ કરતાં ઓછી છે.

1181
00:58:09,410 --> 00:58:14,140
>> તેથી આ રીતે, તર્ક છે
દિવસ ઓવરને અંતે સમાન.

1182
00:58:14,140 --> 00:58:18,280
પરંતુ હું યાદ કરું છું
6 કિંમત, આ કિસ્સામાં.

1183
00:58:18,280 --> 00:58:19,780
Zamyla નામ લંબાઈ શું છે?

1184
00:58:19,780 --> 00:58:20,860
અને હું એ સમયે તે મૂકી રહ્યો છું.

1185
00:58:20,860 --> 00:58:23,050
>> અને હું હજુ પણ ચકાસણી છું
શરત દર વખતે.

1186
00:58:23,050 --> 00:58:24,300
0 6 કરતા ઓછી હોય?

1187
00:58:24,300 --> 00:58:25,600
1 6 કરતા ઓછી હોય?

1188
00:58:25,600 --> 00:58:28,600
2 6 કરતા ઓછી છે, અને તેથી આગળ છે?

1189
00:58:28,600 --> 00:58:31,914
>> પરંતુ હું કોમ્પ્યુટર નથી જણાવી રહ્યો છું
ફરી, અને ફરીથી, શું

1190
00:58:31,914 --> 00:58:33,080
Zamyla નામ લંબાઈ?

1191
00:58:33,080 --> 00:58:34,320
Zamyla નામ લંબાઈ શું છે?

1192
00:58:34,320 --> 00:58:35,986
આ Zamyla નામ લંબાઈ શું છે?

1193
00:58:35,986 --> 00:58:40,440
હું શાબ્દિક યાદ કરું છું કે પ્રથમ અને
માત્ર આ બીજા ચલ n માં જવાબ આપો.

1194
00:58:40,440 --> 00:58:45,280
તેથી હવે આ માત્ર હશે
યોગ્ય છે, પણ સારી રીતે રચાયેલ છે.

1195
00:58:45,280 --> 00:58:46,670
>> હવે, શૈલી વિશે શું?

1196
00:58:46,670 --> 00:58:48,866
હું મારા ચલો નામ છે
ખૂબ સારી છે, હું કહું છું.

1197
00:58:48,866 --> 00:58:50,240
તેઓ હમણાં સુપર succinct છો.

1198
00:58:50,240 --> 00:58:52,090
અને તે સંપૂર્ણપણે દંડ છે.

1199
00:58:52,090 --> 00:58:55,120
>> તમે માત્ર એક જ હોય ​​તો
એક કાર્યક્રમ શબ્દમાળા

1200
00:58:55,120 --> 00:58:56,860
તમે તેમજ કૉલ શકે છે તે શબ્દમાળા માટે છે.

1201
00:58:56,860 --> 00:58:59,370
જો તમે માત્ર એક ચલ હોય તો
એક કાર્યક્રમ ગણતરી માટે,

1202
00:58:59,370 --> 00:59:00,710
તમે તેમજ તે હું કહી શકે છે.

1203
00:59:00,710 --> 00:59:03,500
તમે લંબાઈ હોય, તો એ
તેમજ સુપર સામાન્ય છે.

1204
00:59:03,500 --> 00:59:05,800
પરંતુ હું મારા કોડ કોઈપણ ટિપ્પણી કરી છે.

1205
00:59:05,800 --> 00:59:09,200
>> હું reader-- જાણ નથી કર્યું
કે મારા ટીએફ, અથવા તા છે કે કેમ તે,

1206
00:59:09,200 --> 00:59:12,460
અથવા માત્ર colleague-- શું માનવામાં આવે છે
આ કાર્યક્રમ ચાલુ કરી.

1207
00:59:12,460 --> 00:59:15,760
અને તેથી સારી શૈલી વિચાર,
હું શું કરવા માંગો છો શું

1208
00:59:15,760 --> 00:59:24,580
છે આ કંઈક છે
જેમ ઇનપુટ માટે વપરાશકર્તા પૂછો.

1209
00:59:24,580 --> 00:59:26,670
અને હું ફરીથી લખી શકીએ
રીતે આ કોઇ સંખ્યા.

1210
00:59:26,670 --> 00:59:35,630
>> ખાતરી કરો વિચાર કરો s-- ખાતરી
શબ્દમાળા શબ્દમાળા પાછા ફર્યા.

1211
00:59:35,630 --> 00:59:40,280
અને પછી અહીં અને આ કદાચ
સૌથી મહત્વપૂર્ણ comment-- ભારપૂર્વક

1212
00:59:40,280 --> 00:59:44,450
એક સમયે એક અક્ષરો પર.

1213
00:59:44,450 --> 00:59:47,060
અને હું કોઈપણ ઉપયોગ કરી શકે છે
ઇંગલિશ ભાષા ની પસંદગી

1214
00:59:47,060 --> 00:59:49,650
અહીં દરેક વર્ણન કરવા માટે
કોડ આ હિસ્સામાં.

1215
00:59:49,650 --> 00:59:52,740
>> નોંધ કરો કે હું એક ન મૂકી છે
કોડ ઓફ દરેક લીટી પર ટિપ્પણી,

1216
00:59:52,740 --> 00:59:55,690
ખરેખર રસપ્રદ પર માત્ર
રાશિઓ, કે રાશિઓ

1217
00:59:55,690 --> 00:59:59,460
કેટલાક અર્થ છે કે હું કદાચ
કોઈને સુપર સ્પષ્ટ બનાવવા માંગો છો

1218
00:59:59,460 --> 01:00:00,460
મારા કોડ reading.

1219
01:00:00,460 --> 01:00:02,920
અને શા માટે તમે વિચાર ફોન આવે છે
શબ્દમાળા ઇનપુટ માટે વપરાશકર્તા પૂછો?

1220
01:00:02,920 --> 01:00:05,450
પણ છે કે જે એક જરૂરી નથી
બધા કે વર્ણનાત્મક.

1221
01:00:05,450 --> 01:00:09,340
પરંતુ તે એક વાર્તા કહી મદદ કરે છે, કારણ કે
વાર્તામાં બીજી લાઇન છે, ખાતરી કરો

1222
01:00:09,340 --> 01:00:10,740
શબ્દમાળા વિચાર શબ્દમાળા પાછા ફર્યા.

1223
01:00:10,740 --> 01:00:14,260
>> અને વાર્તામાં ત્રીજી લાઇન છે,
એક અક્ષરો પર ફરી વળવું

1224
01:00:14,260 --> 01:00:15,380
એ સમયે.

1225
01:00:15,380 --> 01:00:17,920
અને હવે માત્ર સારા પગલા માટે,
હું આગળ જાઓ અને ઉમેરવા માટે જઇ રહ્યો છું

1226
01:00:17,920 --> 01:00:24,560
એક વધુ ટિપ્પણી કે જે હમણાં જ
ઓ પ્રિન્ટ આઇ મી અક્ષર કહે છે.

1227
01:00:24,560 --> 01:00:26,520
હવે, મેં શું કર્યું છે
દિવસ ના અંતે?

1228
01:00:26,520 --> 01:00:29,190
>> હું કેટલાક ઇંગલિશ ઉમેર્યું છે
ટિપ્પણીઓ સ્વરૂપમાં શબ્દો.

1229
01:00:29,190 --> 01:00:32,700
સ્લેશ સ્લેશ પ્રતીક અર્થ થાય છે, અરે,
કમ્પ્યુટર આ માનવ માટે છે,

1230
01:00:32,700 --> 01:00:33,820
તમારા માટે નથી, કોમ્પ્યુટર.

1231
01:00:33,820 --> 01:00:35,119
તેથી તેઓ તાર્કિક અવગણવામાં કરી રહ્યાં છો.

1232
01:00:35,119 --> 01:00:35,910
તેઓ માત્ર ત્યાં છો.

1233
01:00:35,910 --> 01:00:39,830
>> અને, ખરેખર, આ CS50 IDE તેમને બતાવે છે
ગ્રે, કારણ ઉપયોગી છે, પરંતુ કી હોવા

1234
01:00:39,830 --> 01:00:41,000
કાર્યક્રમ.

1235
01:00:41,000 --> 01:00:42,570
નોટિસ તમને હવે શું કરી શકો.

1236
01:00:42,570 --> 01:00:44,950
તમે સી ખબર છે કે શું
પ્રોગ્રામિંગ અથવા નથી, તો તમે

1237
01:00:44,950 --> 01:00:47,722
ફક્ત આ પર પાછા ઊભા કરી શકે છે
કાર્યક્રમ અને ટિપ્પણીઓ મલાઈ કાઢી લીધેલું.

1238
01:00:47,722 --> 01:00:50,180
ઇનપુટ માટે વપરાશકર્તા પૂછો ખાતરી કરો
શબ્દમાળા શબ્દમાળા પરત મેળવવા માટે,

1239
01:00:50,180 --> 01:00:53,009
ઓ માં અક્ષરો પર ફરી વળવું
એક સમયે એક અક્ષર છાપવા

1240
01:00:53,009 --> 01:00:55,550
આઇ મી અક્ષર s-- તમે નથી
પણ કોડ જોવા મળે છે

1241
01:00:55,550 --> 01:00:57,270
તે સમજવા માટે આ કાર્યક્રમ કરે છે.

1242
01:00:57,270 --> 01:01:00,280
અને સારી હજુ સુધી, જો તમે તમારી જાતને જોવા
એક અથવા બે સપ્તાહ માં આ કાર્યક્રમ,

1243
01:01:00,280 --> 01:01:02,280
અથવા એક મહિના અથવા એક વર્ષ,
તમે પણ નથી

1244
01:01:02,280 --> 01:01:04,420
કોડ પર અનુસરણ કરવા માટે,
યાદ કરવાનો પ્રયાસ કરી,

1245
01:01:04,420 --> 01:01:06,630
શું હું આ કોડ સાથે શું કરવું પ્રયાસ કરવામાં આવ્યો હતો?

1246
01:01:06,630 --> 01:01:07,770
>> તમે તમારી જાતને કહ્યું છે.

1247
01:01:07,770 --> 01:01:11,660
તમે તેને જાતે માટે વર્ણવાયેલ છે,
અથવા અમુક સાથી, અથવા તા, અથવા ટીએફ.

1248
01:01:11,660 --> 01:01:14,860
અને તેથી આ હવે હશે
યોગ્ય અને સારી ડિઝાઇન,

1249
01:01:14,860 --> 01:01:18,210
અને આખરે સારી શૈલી તેમજ.

1250
01:01:18,210 --> 01:01:19,990
તેથી ધ્યાનમાં રાખો કે નથી.

1251
01:01:19,990 --> 01:01:22,200
>> તેથી ત્યાં એક અન્ય છે
વસ્તુ હું અહીં કરવા જાઉં છું

1252
01:01:22,200 --> 01:01:28,240
કે જે હવે ઉજાગર કરી શકે છે બરાબર શું છે
હૂડ નીચે જઈ રહી છે.

1253
01:01:28,240 --> 01:01:30,390
તેથી આ લક્ષણ છે
સી, અને અન્ય ભાષાઓ માં,

1254
01:01:30,390 --> 01:01:33,010
કહેવાય ટાઇપકાસ્ટિંગ
કે જે ક્યાં તો સર્વથા

1255
01:01:33,010 --> 01:01:37,250
અથવા બાહ્ય તમે કન્વર્ટ કરવા માટે પરવાનગી આપે છે
અન્ય એક માહિતી પ્રકાર છે.

1256
01:01:37,250 --> 01:01:39,800
અમે જેથી વ્યવહાર કર્યો છે
અત્યાર સુધી શબ્દમાળાઓ સાથે આજે.

1257
01:01:39,800 --> 01:01:41,250
>> અને શબ્દમાળાઓ અક્ષરો છે.

1258
01:01:41,250 --> 01:01:44,910
પરંતુ સપ્તાહ થી યાદ
0, અક્ષરો શું છે?

1259
01:01:44,910 --> 01:01:49,334
પાત્રો માત્ર કલ્પનાના છે
નંબરોની દશાંશ નંબરો ટોચ પર,

1260
01:01:49,334 --> 01:01:52,500
અને દશાંશ નંબરો ખરેખર માત્ર એક છે
બાઈનરી નંબરો ટોચ પર તાત્વિક,

1261
01:01:52,500 --> 01:01:53,720
અમે તેને વ્યાખ્યાયિત થયેલ છે.

1262
01:01:53,720 --> 01:01:55,540
>> તેથી અક્ષરો નંબરો છે.

1263
01:01:55,540 --> 01:01:58,410
અને સંખ્યાઓ અક્ષરો છે,
માત્ર સંદર્ભ પર આધાર રાખીને.

1264
01:01:58,410 --> 01:02:01,250
અને તે અંદર કે બહાર વળે
એક કમ્પ્યુટર પ્રોગ્રામ છે,

1265
01:02:01,250 --> 01:02:06,830
તમે કેવી રીતે તમે જોવા માંગો છો સ્પષ્ટ કરી શકો છો
કે કાર્યક્રમ ની અંદર બિટ્સ પર?

1266
01:02:06,830 --> 01:02:10,400
>> સપ્તાહ 0 કે અમે હતા યાદ
ASCII, જે ફક્ત આ કોડ છે

1267
01:02:10,400 --> 01:02:11,620
નંબરો મેપિંગ અક્ષરો.

1268
01:02:11,620 --> 01:02:13,660
અને અમે જણાવ્યું હતું કે, મૂડી 65 છે.

1269
01:02:13,660 --> 01:02:15,860
કેપિટલ બી તેથી આગળ 66 છે, અને.

1270
01:02:15,860 --> 01:02:20,500
>> સૂચના, અમે અનિવાર્યપણે અક્ષરો પર હોય
અહીં ટોચ પંક્તિ, કારણ સે તેમને કૉલ કરશે,

1271
01:02:20,500 --> 01:02:23,400
અક્ષરો, અને પછી
બીજી પંક્તિ પર ints.

1272
01:02:23,400 --> 01:02:28,180
અને તે તારણ છે તમે કન્વર્ટ કરી શકો છો
એકીકૃત બે, સામાન્ય રીતે વચ્ચે.

1273
01:02:28,180 --> 01:02:30,042
અને અમે કરવા માંગો છો, તો
આ ઇરાદાપૂર્વક, અમે

1274
01:02:30,042 --> 01:02:31,750
હલ કરવા માંગો છો શકે
થોડું આના જેવું.

1275
01:02:31,750 --> 01:02:33,590
>> અમે રૂપાંતરિત કરવા માંગો છો શકે છે
અપર કેસ ઘટે

1276
01:02:33,590 --> 01:02:35,330
કેસ, અથવા અપર કેસ નીચલા કેસ.

1277
01:02:35,330 --> 01:02:38,000
અને તે ત્યાં છે બહાર વળે
ખરેખર એક પેટર્ન અહીં

1278
01:02:38,000 --> 01:02:39,900
અમે માત્ર એક ક્ષણ સ્વીકાર કરી શકો છો.

1279
01:02:39,900 --> 01:02:44,120
પરંતુ એક પ્રથમ દેખાવ દો
બાહ્ય આમ ઉદાહરણ.

1280
01:02:44,120 --> 01:02:46,340
>> હું CS50 IDE માં પાછા જવા માટે જઇ રહ્યો છું.

1281
01:02:46,340 --> 01:02:50,640
હું બનાવવા જઈ રહ્યો છું
ફાઇલ ASCII 0.c. કહેવાય

1282
01:02:50,640 --> 01:02:55,960
અને હું આગળ જાઓ અને ઉમેરવા માટે જઇ રહ્યો છું મારા
ટોચ પર ધોરણ io.h, પૂર્ણાંક મુખ્ય રદબાતલ

1283
01:02:55,960 --> 01:02:57,370
મારું કાર્ય ટોચ પર.

1284
01:02:57,370 --> 01:03:02,700
અને પછી હું માત્ર કરવા જઇ રહ્યો છું
લૂપ માટે નીચેના હું બરાબર,

1285
01:03:02,700 --> 01:03:04,610
ધારો કે, 65 દો.

1286
01:03:04,610 --> 01:03:10,460
>> અને પછી હું કરતાં ઓછી હોઈ ચાલે છે
મૂળાક્ષર 65, વત્તા 26 અક્ષરો.

1287
01:03:10,460 --> 01:03:12,640
તેથી હું કમ્પ્યુટર દો પડશે
ત્યાં મારા માટે ગણિત નથી.

1288
01:03:12,640 --> 01:03:15,100
અને પછી આ લૂપ અંદર,
શું હું છાપો જાઉં છું?

1289
01:03:15,100 --> 01:03:19,230
>> % C% હું એ બેકસ્લેશ છે.

1290
01:03:19,230 --> 01:03:21,290
અને હવે હું બે કિંમતો પ્લગ કરવા માંગો છો.

1291
01:03:21,290 --> 01:03:24,530
હું થોડા સમય માટે પ્રશ્ન મૂક્યો છે
ત્યાં ચિહ્નિત પ્રશ્ન આમંત્રિત કરવા માટે.

1292
01:03:24,530 --> 01:03:29,940
>> હું આગળ 65 થી ફરી વળવું માંગો છો
મૂળાક્ષર 26 અક્ષરો છે,

1293
01:03:29,940 --> 01:03:35,190
દરેક ઇટરેશન પર બહાર છાપવા કે
પાત્ર અભિન્ન સમકક્ષ.

1294
01:03:35,190 --> 01:03:38,299
અન્ય શબ્દોમાં, હું કરવા માંગો છો
ફરી વળવું પર 26 નંબરો પ્રિન્ટીંગ

1295
01:03:38,299 --> 01:03:41,590
શું ASCII પાત્ર છે, અક્ષર,
અને શું અનુરૂપ નંબર આ--

1296
01:03:41,590 --> 01:03:44,650
ખરેખર માત્ર પુનઃબનાવવાનું
કે સ્લાઇડ થી ચાર્ટ.

1297
01:03:44,650 --> 01:03:47,010
તેથી શું આ પ્રશ્ન ગુણ હોવા જોઈએ?

1298
01:03:47,010 --> 01:03:51,760
>> ઠીક છે, તે બીજા બહાર વળે
એક માત્ર ચલ હું પ્રયત્ન કરીશું.

1299
01:03:51,760 --> 01:03:53,860
હું જોવા માટે કે જે નંબર તરીકે માંગો છો.

1300
01:03:53,860 --> 01:03:58,920
અને મધ્ય દલીલ
અહીં, હું કમ્પ્યુટર કહી શકો છો

1301
01:03:58,920 --> 01:04:03,470
કે પૂર્ણાંક સારવાર માટે
હું એક પાત્ર તરીકે, જેથી

1302
01:04:03,470 --> 01:04:05,880
તે અહીં ટકા સી માટે અવેજી

1303
01:04:05,880 --> 01:04:07,990
>> અન્ય શબ્દોમાં, જો હું
માનવ પ્રોગ્રામર, ખબર

1304
01:04:07,990 --> 01:04:09,865
આ માત્ર નંબરો છે
દિવસ ના અંતે.

1305
01:04:09,865 --> 01:04:12,500
અને હું જાણું છું કે 65 જોઇએ
કેટલાક પાત્ર મેપ.

1306
01:04:12,500 --> 01:04:15,310
આ સ્પષ્ટ કાસ્ટ સાથે,
એક વાક્ય સાથે,

1307
01:04:15,310 --> 01:04:18,840
તમે કરવા માંગો છો ડેટા પ્રકાર નામ
કન્વર્ટ, અને બંધ કૌંસ,

1308
01:04:18,840 --> 01:04:21,200
તમે કહી શકો છો
કોમ્પ્યુટર, અરે, કોમ્પ્યુટર,

1309
01:04:21,200 --> 01:04:24,130
ઘરનાં પરચૂરણ કામો માટે આ પૂર્ણાંક રૂપાંતરિત કરો.

1310
01:04:24,130 --> 01:04:26,250
>> તેથી જ્યારે હું આ સ્કોર
કાર્યક્રમ સંકલન પછી,

1311
01:04:26,250 --> 01:04:29,740
માતાનો જુઓ હું શું વિચાર કરી ASCII 0 બનાવવા દો.

1312
01:04:29,740 --> 01:04:33,020
રફૂ કરવું તે, હું શું ખોટું અહીં શું કર્યું?

1313
01:04:33,020 --> 01:04:35,884
બિનજાહેર ઓળખકર્તા ઉપયોગ,
બધા હક છે, ઇરાદાપૂર્વક નથી,

1314
01:04:35,884 --> 01:04:37,800
પરંતુ માતાનો જોવા દો, તો આપણે કરી શકતા નથી
આ દ્વારા કારણ છે.

1315
01:04:37,800 --> 01:04:41,220
>> તેથી વાક્ય five-- તેથી હું મળી ન હતી
ખૂબ જ દૂર સુધી અપ screwing પહેલાં.

1316
01:04:41,220 --> 01:04:42,140
એ બરાબર છે.

1317
01:04:42,140 --> 01:04:46,560
તેથી 5 રેખા હું બરાબર 65-- હું જુઓ.

1318
01:04:46,560 --> 01:04:50,130
તેથી સી યાદ રાખો કે, કેટલાક વિપરીત
જો તમે પહેલાં પ્રોગ્રામિંગ છે ભાષાઓ

1319
01:04:50,130 --> 01:04:52,190
અનુભવ, તમે
કમ્પ્યુટર કહેવું,

1320
01:04:52,190 --> 01:04:55,040
સ્ક્રેચ જેમ નહિં પણ, શું
ચલનો પ્રકાર છે.

1321
01:04:55,040 --> 01:04:56,860
>> અને હું એક કી શબ્દસમૂહ અહીં ભૂલી ગયા છો.

1322
01:04:56,860 --> 01:04:59,200
વાક્ય પાંચ, હું હું ઉપયોગ કરવાનું શરૂ કર્યું છે.

1323
01:04:59,200 --> 01:05:01,560
પરંતુ હું સી ન હતું કે
શું ડેટા પ્રકાર છે.

1324
01:05:01,560 --> 01:05:04,570
તેથી હું અહીં જાઓ જાઉં છું અને
કહે છે, હેં, તે પૂર્ણાંક છે.

1325
01:05:04,570 --> 01:05:07,050
>> હવે હું આગળ જાઓ અને પુનઃકમ્પાઈલ કરવા જઇ રહ્યો છું.

1326
01:05:07,050 --> 01:05:08,080
કે સુધારેલ.

1327
01:05:08,080 --> 01:05:12,660
./ascii0 દાખલ કરો, કે જે પ્રકારની ઠંડી છે.

1328
01:05:12,660 --> 01:05:15,360
માત્ર તે સુપર ઝડપી છે
, કમ્પ્યુટર આ પ્રશ્ન પૂછો

1329
01:05:15,360 --> 01:05:18,885
તેના બદલે એક સ્લાઇડ પર તે જોઈ કરતાં,
તે દરેક લાઇને એક છપાયેલ હોય, એ 65 છે,

1330
01:05:18,885 --> 01:05:24,860
બી, કારણ કે હું down-- 66, તમામ માર્ગ છે
અક્ષરો Z માટે આ 26 times-- હતી,

1331
01:05:24,860 --> 01:05:25,630
જે 90 છે.

1332
01:05:25,630 --> 01:05:27,790
અને હકીકતમાં, સહેજ
વધુ બુદ્ધિશાળી કરશે

1333
01:05:27,790 --> 01:05:31,030
મારા માટે કરવામાં આવી ન આધાર રાખે છે
કમ્પ્યુટર પર 26 ઉમેરો.

1334
01:05:31,030 --> 01:05:34,060
હું માત્ર પૂર્ણ કરી શકે છે
90 તેમજ, જેથી લાંબા

1335
01:05:34,060 --> 01:05:37,390
કારણ કે હું એ જ ભૂલ બે વાર બનાવવા નથી.

1336
01:05:37,390 --> 01:05:41,880
હું મારફતે જવા માંગો છો
ઝેડ, માત્ર વાય દ્વારા અપ.

1337
01:05:41,880 --> 01:05:44,000
>> તેથી તે સ્પષ્ટ કાસ્ટ છે.

1338
01:05:44,000 --> 01:05:47,860
આ છે કે જે બહાર વળે
પણ જરૂરી નથી.

1339
01:05:47,860 --> 01:05:52,480
મને આગળ વધો અને આ પુનઃ ચલાવો દો
કમ્પાઇલર, અને પુનઃ ચલાવો ASCII 0.

1340
01:05:52,480 --> 01:05:54,940
તે તારણ છે કે સી ખૂબ સ્માર્ટ છે.

1341
01:05:54,940 --> 01:05:57,150
>> અને printf, ખાસ કરીને,
ખૂબ સ્માર્ટ છે.

1342
01:05:57,150 --> 01:06:01,260
તમે માત્ર એક હું બે વખત પાસ કરો તો
બંને જગ્યામાં માટે, printf

1343
01:06:01,260 --> 01:06:04,510
, ખ્યાલ આવશે ઓહ, સારી રીતે હું તમને ખબર
મને કેટલાક નંબર integer-- આપ્યો,

1344
01:06:04,510 --> 01:06:06,380
65, અથવા 90, અથવા ગમે છે.

1345
01:06:06,380 --> 01:06:10,170
પરંતુ હું જુઓ કે તમે મને કરવા માંગો છો
એક અક્ષર જેમ કે નંબર ફોર્મેટ.

1346
01:06:10,170 --> 01:06:16,460
અને તેથી printf સર્વથા ભૂમિકા કરી શકો છો
આ તેમજ તમારા માટે ઘરનાં પરચૂરણ કામો માટે INT.

1347
01:06:16,460 --> 01:06:19,360
તેથી તે એક સમસ્યા બધા નથી.

1348
01:06:19,360 --> 01:06:23,100
>> પરંતુ નોટિસ, આ સમકક્ષતા કારણે
અમે ખરેખર આ તેમજ કરી શકો છો.

1349
01:06:23,100 --> 01:06:26,520
મને આગળ વધો અને એક બનાવવા દો
છે આ ascii 1.c. અન્ય આવૃત્તિ

1350
01:06:26,520 --> 01:06:31,800
અને બદલે પર વારો
પૂર્ણાંકો, ખરેખર તમારા મન તમાચો કરી શકો છો

1351
01:06:31,800 --> 01:06:33,610
અક્ષરો પર વારો દ્વારા.

1352
01:06:33,610 --> 01:06:37,660
ઘરનાં પરચૂરણ કામો સી મૂડી નહીં હોય તો, હું
આગળ વધો અને આ કરવા માંગો છો,

1353
01:06:37,660 --> 01:06:41,740
જેથી લાંબા સી કરતાં ઓછી અથવા સમાન છે, કારણ કે
મૂડી ઝેડ અને દરેક ઇટરેશન પર

1354
01:06:41,740 --> 01:06:45,690
હું સી વધારો કરવા માંગો છો, હું કરી શકો છો
હવે મારી printf રેખા અહીં

1355
01:06:45,690 --> 01:06:51,320
કહે છે, ટકા સી
ટકા હું ફરીથી, અલ્પવિરામ સી

1356
01:06:51,320 --> 01:06:57,200
>> અને હવે, હું અન્ય દિશામાં જઈ શકે છે,
પાત્ર સ્પષ્ટપણે કાસ્ટિંગ

1357
01:06:57,200 --> 01:06:58,500
પૂર્ણાંક માટે.

1358
01:06:58,500 --> 01:07:00,560
તેથી, ફરી, શા માટે તમે આ શું કરશે?

1359
01:07:00,560 --> 01:07:03,830
તે સૉર્ટ થોડી વિચિત્ર છે
અક્ષરો દ્રષ્ટિએ ગણતરી.

1360
01:07:03,830 --> 01:07:07,430
>> પરંતુ જો તમે સમજો છો શું છે
હૂડ નીચે રહ્યું,

1361
01:07:07,430 --> 01:07:08,430
ત્યાં ખરેખર કોઈ જાદુ છે.

1362
01:07:08,430 --> 01:07:13,060
તમે માત્ર કહી રહ્યાં છે, અરે, કમ્પ્યુટર આપશે
મને એક ચલ પ્રકાર ઘરનાં પરચૂરણ કામો સી કહેવાય છે.

1363
01:07:13,060 --> 01:07:16,520
મૂડી એ માટે તે પ્રારંભ અને
એક જ અવતરણચિહ્નો બાબત નોટિસ.

1364
01:07:16,520 --> 01:07:19,580
>> સી અક્ષરો માટે, યાદ
છેલ્લા અઠવાડિયે, તમે એક જ અવતરણચિહ્નો ઉપયોગ કરે છે.

1365
01:07:19,580 --> 01:07:23,720
શબ્દમાળાઓ માટે, શબ્દો માટે,
શબ્દસમૂહો, તમે ડબલ નો ઉપયોગ.

1366
01:07:23,720 --> 01:07:27,210
ઠીક છે, કમ્પ્યુટર, આમ રાખો, જેથી
પાત્ર તરીકે લાંબા કરતાં ઓછી છે

1367
01:07:27,210 --> 01:07:28,050
અથવા z માટે સમાન.

1368
01:07:28,050 --> 01:07:32,640
અને હું મારી ASCII ટેબલ પરથી જાણીએ છીએ કે બધા
આ ascii કોડ સંલગ્ન છે.

1369
01:07:32,640 --> 01:07:33,400
>> ત્યાં કોઈ ગાબડા છે.

1370
01:07:33,400 --> 01:07:36,737
તેથી તે માત્ર એક Z મારફતે છે,
એક નંબર દરેક દ્વારા અલગ થયેલ છે.

1371
01:07:36,737 --> 01:07:38,820
અને પછી હું વધી શકે છે
ચાર રચે છે, જો હું ખરેખર કરવા માંગો છો.

1372
01:07:38,820 --> 01:07:40,390
દિવસ ના અંતે,
તે માત્ર એક સંખ્યા છે.

1373
01:07:40,390 --> 01:07:41,030
મને આ ખબર છે.

1374
01:07:41,030 --> 01:07:43,670
તેથી હું માત્ર તે માટે 1 ઉમેરવા માટે પાડશો કરી શકો છો.

1375
01:07:43,670 --> 01:07:46,940
>> અને પછી આ સમય, હું સી છાપો,
અને પછી અભિન્ન સમકક્ષ.

1376
01:07:46,940 --> 01:07:50,170
અને હું પણ સ્પષ્ટ કાસ્ટ જરૂર નથી.

1377
01:07:50,170 --> 01:07:52,680
હું printf અને દો કરી શકો છો
કમ્પ્યુટર વસ્તુઓ બહાર આકૃતિ,

1378
01:07:52,680 --> 01:07:57,300
જેથી હવે જો હું ચલાવવા
Ascii1./ascii1 બનાવવા માટે,

1379
01:07:57,300 --> 01:08:01,520
હું તેમજ ચોક્કસ જ વસ્તુ મળે છે.

1380
01:08:01,520 --> 01:08:04,530
>> યુઝલેસ કાર્યક્રમ, કોઈ એક though--
ખરેખર સોફ્ટવેર લખી રહ્યા છે

1381
01:08:04,530 --> 01:08:07,549
ક્રમમાં બહાર આકૃતિ માટે, શું હતું
નંબર કે એ નકશા, અથવા બી, અથવા z?

1382
01:08:07,549 --> 01:08:10,340
તમે માત્ર કે તે Google જઈ રહ્યાં છો,
તેને જોવા અપ ઓનલાઇન, અથવા તેને જોવા અપ

1383
01:08:10,340 --> 01:08:11,650
સ્લાઇડ, અથવા જેમ છે.

1384
01:08:11,650 --> 01:08:13,520
તેથી જ્યાં આ ખરેખર ઉપયોગી વિચાર કરે છે?

1385
01:08:13,520 --> 01:08:15,960
>> ઠીક છે, કે બોલતા
સ્લાઇડ, ત્યાં નોટિસ

1386
01:08:15,960 --> 01:08:20,890
મોટા વચ્ચે એક વાસ્તવિક પેટર્ન અહીં
અને નાના આકસ્મિક ન હતો.

1387
01:08:20,890 --> 01:08:23,760
નોંધ કરો કે મૂડી 65 છે.

1388
01:08:23,760 --> 01:08:25,830
લોઅરકેસ 97 છે.

1389
01:08:25,830 --> 01:08:29,649
અને દૂર અત્યાર સુધી કેવી રીતે લોઅર કેસ એક છે?

1390
01:08:29,649 --> 01:08:32,649
>> તેથી 65 97 થી કેટલા પગલાંઓ દૂર છે?

1391
01:08:32,649 --> 01:08:36,210
તેથી 97 ઓછા 65 32 છે.

1392
01:08:36,210 --> 01:08:37,910
તેથી મૂડી 65 છે.

1393
01:08:37,910 --> 01:08:39,939
તમે કે 32 ઉમેરો તો,
તમે એક લોઅરકેસ મળે છે.

1394
01:08:39,939 --> 01:08:43,729
અને, સમાન, જો તમે 32 સબ્ટ્રેક્ટ,
તમે મૂડી પાછી મેળવવા ચલો બી સાથે જ

1395
01:08:43,729 --> 01:08:46,380
લિટલ બી, થોડી સી મોટા સી.

1396
01:08:46,380 --> 01:08:50,670
>> આ ગાબડા તમામ 32 અંતરે છે.

1397
01:08:50,670 --> 01:08:54,450
હવે, આ અમને કરવા માટે પરવાનગી આપે લાગશે
માઈક્રોસોફ્ટ વર્ડ કંઈક કરી,

1398
01:08:54,450 --> 01:08:57,729
અથવા Google ડૉક્સ લક્ષણ છે, જ્યાં તમે
બધું પસંદ કરી શકો છો અને પછી કહે છે,

1399
01:08:57,729 --> 01:09:00,520
લોઅરકેસ બધા બદલવા, અથવા
અપર કેસ માટે બધા બદલી,

1400
01:09:00,520 --> 01:09:03,840
અથવા માત્ર પ્રથમ શબ્દ બદલવા
અપર કેસ માટે સજા.

1401
01:09:03,840 --> 01:09:07,390
અમે ખરેખર કંઈક કરી શકો છો
જાતને કે.

1402
01:09:07,390 --> 01:09:12,645
>> મને આગળ વધો અને એક ફાઇલ સેવ
અહીં 0.c. ઉઠાવે કહેવાય

1403
01:09:12,645 --> 01:09:15,770
અને ચાલો આગળ વધો અને એક કાર્યક્રમ ચાબુક દો
બરાબર છે કે નીચે છે.

1404
01:09:15,770 --> 01:09:18,460
તેથી CS50 પુસ્તકાલય સમાવેશ થાય છે.

1405
01:09:18,460 --> 01:09:21,430
અને પ્રમાણભૂત I / O સમાવેશ થાય છે.

1406
01:09:21,430 --> 01:09:22,787
>> અને હું આ ટૂંક સમયમાં આવી રહ્યું છે ખબર.

1407
01:09:22,787 --> 01:09:24,870
તેથી હું તેને મૂકવા જાઉં છું
ત્યાં પહેલેથી જ છે, string.h,

1408
01:09:24,870 --> 01:09:26,960
તેથી હું વપરાશ હોય છે
સ્ટર્લિંગ જેવી વસ્તુઓ,

1409
01:09:26,960 --> 01:09:29,620
અને પછી મુખ્ય રદબાતલ પૂર્ણાંક, સામાન્ય તરીકે.

1410
01:09:29,620 --> 01:09:33,420
અને પછી હું આગળ જાઓ જાઉં છું
અને શબ્દમાળાઓ શબ્દમાળા વિચાર નહીં,

1411
01:09:33,420 --> 01:09:35,032
માત્ર વપરાશકર્તા માંથી શબ્દમાળા મેળવવા માટે.

1412
01:09:35,032 --> 01:09:36,740
અને પછી હું જાઉં છું
મારા સેનીટી ચેક કરવું.

1413
01:09:36,740 --> 01:09:40,510
શબ્દમાળા સમાન નલ ન હોય તો,
પછી તે આગળ વધવા માટે સુરક્ષિત છે.

1414
01:09:40,510 --> 01:09:42,000
અને હું શું કરવા માંગો છો?

1415
01:09:42,000 --> 01:09:48,700
હું ભારપૂર્વક કહેવું હું 0 સમકક્ષ હોય છે જઇ રહ્યો છું,
અને એ ઓ શબ્દમાળા લંબાઈ સુધી.

1416
01:09:48,700 --> 01:09:51,899
>> અને હું તેથી લાંબા તરીકે આ કરવા જઇ રહ્યો છું
હું એ કરતાં ઓછી છે, અને હું વત્તા વત્તા.

1417
01:09:51,899 --> 01:09:55,060
અત્યાર સુધી, હું ખરેખર માત્ર છું
પહેલાં વિચારો ઉધાર.

1418
01:09:55,060 --> 01:09:57,010
અને હવે હું એક શાખા રજૂ કરવા જઈ રહ્યો છું.

1419
01:09:57,010 --> 01:09:59,635
>> તેથી સ્ક્રેચ, જ્યાં પાછા લાગે
અમે રસ્તા માં તે ફોર્કનો હતી,

1420
01:09:59,635 --> 01:10:05,110
અને છેલ્લા અઠવાડિયે સી હું જાઉં છું
આ કહે છે, જો એસ આઇ મી અક્ષર

1421
01:10:05,110 --> 01:10:09,250
કરતાં વધારે અથવા
કેસ નીચલી સમાન

1422
01:10:09,250 --> 01:10:13,340
and-- સ્ક્રેચ માં તમે શાબ્દિક કરશે
કહે છે, પરંતુ સી તમે કહી ચિન્હ,

1423
01:10:13,340 --> 01:10:19,830
ampersand-- અને એસ આઇ મી અક્ષર
કરતાં ઓછા અથવા કેસ z ઘટે સમાન છે,

1424
01:10:19,830 --> 01:10:21,780
કંઈક રસપ્રદ કરવા દો.

1425
01:10:21,780 --> 01:10:27,020
ચાલો ખરેખર એક છાપે
કોઈ NEWLINE સાથે અક્ષર

1426
01:10:27,020 --> 01:10:31,760
કે જેઓ શબ્દમાળા માં પાત્ર છે,
શબ્દમાળા આઇ મી પાત્ર.

1427
01:10:31,760 --> 01:10:37,420
>> પરંતુ આગળ જવા દો અને
તે 32 સબ્ટ્રેક્ટ.

1428
01:10:37,420 --> 01:10:42,120
બાકી જો પાત્ર
શબ્દમાળા કે અમે શોધી રહ્યાં છો

1429
01:10:42,120 --> 01:10:45,950
લિટલ વચ્ચે નથી
અને થોડી ઝેડ, આગળ વધો

1430
01:10:45,950 --> 01:10:48,610
અને માત્ર તે બહાર યથાવત મુદ્રિત.

1431
01:10:48,610 --> 01:10:50,840
તેથી અમે રજૂ કર્યું
આ કૌંસ નોટેશનમાં

1432
01:10:50,840 --> 01:10:53,560
અમારા શબ્દમાળાઓ પર મેળવવા માટે
આઇ મી શબ્દમાળા માં પાત્ર.

1433
01:10:53,560 --> 01:10:57,520
>> હું જેવા કેટલાક શરતી તર્ક ઉમેર્યા છે,
ગયા અઠવાડિયે અઠવાડિયે એક, જ્યાં સ્ક્રેચ

1434
01:10:57,520 --> 01:10:59,880
હું માત્ર મારા મૂળભૂત ઉપયોગ કરું છું
શું સમજ

1435
01:10:59,880 --> 01:11:01,130
હૂડ નીચે જઈ રહી છે.

1436
01:11:01,130 --> 01:11:04,190
ઓ આઇ મી અક્ષર છે
કરતાં વધારે અથવા બરાબર?

1437
01:11:04,190 --> 01:11:08,290
જેમ, તે, 97, અથવા 98 છે
અથવા 99, અને તેથી આગળ?

1438
01:11:08,290 --> 01:11:11,940
>> પરંતુ તે પણ કરતાં ઓછી અથવા સમાન છે
લોઅરકેસ z ની કિંમત?

1439
01:11:11,940 --> 01:11:16,210
અને તેથી જો, શું આ વાક્ય અર્થ છે?

1440
01:11:16,210 --> 01:11:20,250
14, આ પ્રકારની છે
સમગ્ર વિચાર કીડો,

1441
01:11:20,250 --> 01:11:23,840
દ્વારા પત્ર ઉઠાવે
ફક્ત તે 32 બાદબાકી,

1442
01:11:23,840 --> 01:11:29,370
આ કિસ્સામાં, કારણ કે હું જાણું છું કે પ્રતિ
ચાર્ટ, કેવી રીતે મારા નંબરો રજૂ થાય છે.

1443
01:11:29,370 --> 01:11:33,925
તેથી આપણે આગળ વધીશું અને આ ચલાવો,
0.c ઉઠાવે સંકલન પછી,

1444
01:11:33,925 --> 01:11:36,210
અને રન 0 ઉઠાવે છે.

1445
01:11:36,210 --> 01:11:40,300
>> માતાનો કંઈક લખો
બધા નાના અક્ષરોમાં Zamyla દાખલ કરો.

1446
01:11:40,300 --> 01:11:42,780
અને હવે અમે બધા મોટા માં Zamyla છે.

1447
01:11:42,780 --> 01:11:45,050
બધા લોઅરકેસ માં રોબ ટાઈપ કરીએ.

1448
01:11:45,050 --> 01:11:46,674
બધા લોઅરકેસ માં જેસન પ્રયાસ કરીએ.

1449
01:11:46,674 --> 01:11:48,590
અને અમે મેળવવામાં રાખવા
ફરજ પડી કેપિટલાઇઝેશન.

1450
01:11:48,590 --> 01:11:50,960
ત્યાં એક નાની ભૂલ છે કે હું
પ્રકારની અપેક્ષા ન હતી.

1451
01:11:50,960 --> 01:11:54,050
નોંધ મારી નવી પ્રોમ્પ્ટ અંત છે
તેમના નામો તરીકે જ વાક્ય પર,

1452
01:11:54,050 --> 01:11:55,520
જે થોડી અવ્યવસ્થિત લાગે છે.

1453
01:11:55,520 --> 01:11:59,170
>> તેથી હું અહીં જાઓ જાઉં છું, અને
ખરેખર આ કાર્યક્રમ ઓવરને અંતે

1454
01:11:59,170 --> 01:12:02,110
એક NEWLINE અક્ષર છાપો.

1455
01:12:02,110 --> 01:12:03,160
કે બધા છે.

1456
01:12:03,160 --> 01:12:06,120
printf સાથે, તમે જરૂર નથી
ચલો અથવા ફોર્મેટ કોડ માં પસાર કરે છે.

1457
01:12:06,120 --> 01:12:08,460
તમે શાબ્દિક માત્ર છાપી શકો છો
એક NEWLINE કંઈક.

1458
01:12:08,460 --> 01:12:13,529
>> તેથી આપણે આગળ વધીશું અને બનાવવા દો
0 ફરી ઉઠાવે, તે પુનઃ ચલાવો, Zamyla.

1459
01:12:13,529 --> 01:12:14,820
અને હવે તે થોડો prettier છે.

1460
01:12:14,820 --> 01:12:17,274
હવે, મારા પ્રોમ્પ્ટ તેના પોતાના નવા લીટી પર છે.

1461
01:12:17,274 --> 01:12:18,440
તેથી તે બધા દંડ અને સારી છે.

1462
01:12:18,440 --> 01:12:19,910
તેથી તે એક સારું ઉદાહરણ છે.

1463
01:12:19,910 --> 01:12:22,700
પરંતુ હું પણ જરૂરી નથી
હાર્ડ કોડ 32 કરવાની જરૂર છે.

1464
01:12:22,700 --> 01:12:23,350
શું તમે જાણો છો?

1465
01:12:23,350 --> 01:12:26,350
હું કહેવું શકે છે હું ક્યારેય નથી
શું યાદ તફાવત છે.

1466
01:12:26,350 --> 01:12:29,330
>> પરંતુ મને ખબર છે કે જો હું
નીચા કેસ પત્ર,

1467
01:12:29,330 --> 01:12:34,430
હું અનિવાર્યપણે બોલ બાદબાકી કરવા માંગો છો
ગમે અંતર લિટલ વચ્ચે છે

1468
01:12:34,430 --> 01:12:39,160
એક અને મોટી છે, કારણ કે જો હું તે ધારે
અન્ય અક્ષરો તમામ સમાન હોય છે,

1469
01:12:39,160 --> 01:12:41,045
તે કામ કર્યું વિચાર કરીશું.

1470
01:12:41,045 --> 01:12:42,670
પરંતુ શું બદલે, તમે શું જાણો છો?

1471
01:12:42,670 --> 01:12:44,240
ત્યાં હજુ પણ અન્ય માર્ગ છે.

1472
01:12:44,240 --> 01:12:48,090
>> જો કે, જો હું હતા 1.c-- ઉઠાવે છે
એક અલગ ફાઇલમાં મૂકી છે.

1473
01:12:48,090 --> 01:12:51,030
માતાનો ઉઠાવે 2.c નથી નીચે પ્રમાણે દો.

1474
01:12:51,030 --> 01:12:53,060
હું ખરેખર અહીં આ સાફ કરવા જઇ રહ્યો છું.

1475
01:12:53,060 --> 01:12:57,420
અને બદલે પણ કર્યા
ખબર હોય અથવા તે નીચા સ્તર વિશે કાળજી

1476
01:12:57,420 --> 01:13:01,090
અમલીકરણ વિગતો, હું બદલે છું
માત્ર એક અક્ષર છાપો રહ્યું છે,

1477
01:13:01,090 --> 01:13:04,610
ભાવ અવતરણ ચિહ્નો પૂરાં કરવાં, ટકા સી, અને
પછી બીજા કાર્ય કૉલ કે

1478
01:13:04,610 --> 01:13:09,950
અસ્તિત્વમાં છે કે જે એક દલીલ લે છે,
જે પાત્ર, આ જેવી છે.

1479
01:13:09,950 --> 01:13:12,630
>> તે સી માં વળે છે, ત્યાં
બીજા કાર્ય કૉલ

1480
01:13:12,630 --> 01:13:15,550
ઉપલા જે નામ તરીકે
સૂચવે છે કે એક પાત્ર લે

1481
01:13:15,550 --> 01:13:19,350
અને તે તેના અપર કેસ કરવા માટે બનાવે છે
સમકક્ષ છે, અને પછી તે આપે

1482
01:13:19,350 --> 01:13:21,410
જેથી printf ત્યાં તે પ્લગ કરી શકો છો.

1483
01:13:21,410 --> 01:13:25,484
અને તેથી આ કરવા માટે, જોકે, હું
એક અન્ય ફાઈલ રજૂ કરવાની જરૂર છે.

1484
01:13:25,484 --> 01:13:28,400
તે વારા બીજી ફાઇલ છે બહાર
તમે માત્ર વર્ગ ખબર હોત,

1485
01:13:28,400 --> 01:13:33,020
અથવા એક પુસ્તક, અથવા ઑનલાઇન
સંદર્ભ, સી type.h. કહેવાય

1486
01:13:33,020 --> 01:13:38,570
>> તેથી જો હું અપ મારું હેડર વચ્ચે
ફાઇલો, અને હવે ફરીથી કમ્પાઇલ આ કાર્યક્રમ

1487
01:13:38,570 --> 01:13:43,040
capitalize2 દાખલ ./capitalize2.

1488
01:13:43,040 --> 01:13:46,690
બધા માં Zamyla ટાઈપ કરીએ
લોઅરકેસ, હજુ પણ એ જ કામ કરે છે.

1489
01:13:46,690 --> 01:13:48,040
પરંતુ તમે શું જાણો છો?

1490
01:13:48,040 --> 01:13:55,590
તે ઉચ્ચ તારણ છે કે
કેટલાક અન્ય કાર્યક્ષમતા ધરાવે છે.

1491
01:13:55,590 --> 01:13:58,410
>> અને મને આ પરિચય દો
અહીં આજ્ઞા પ્રકારના awkwardly

1492
01:13:58,410 --> 01:14:00,250
નામ આપવામાં આવ્યું, પરંતુ જાતે માટે માણસ.

1493
01:14:00,250 --> 01:14:03,960
તે તારણ છે કે મોટાભાગની Linux કમ્પ્યુટર્સ,
અમે Linux ઓપરેટિંગ અહીં ઉપયોગ કરી રહ્યા છો કારણ કે

1494
01:14:03,960 --> 01:14:06,270
system-- આદેશ
કહેવાય માણસ, જે કહે છે,

1495
01:14:06,270 --> 01:14:08,530
અરે, કોમ્પ્યુટર, મને આપી
કમ્પ્યુટર જાતે.

1496
01:14:08,530 --> 01:14:10,680
શું તમે કરવા માંગો છો
કે જાતે માં જુઓ?

1497
01:14:10,680 --> 01:14:13,840
>> હું કાર્ય જોવા માંગો છો
ઉચ્ચ કહેવાય છે, દાખલ કરો.

1498
01:14:13,840 --> 01:14:16,070
અને તે માટે થોડી વિસ્મૃત
ક્યારેક વાંચી.

1499
01:14:16,070 --> 01:14:18,780
નોટિસ પણ અમે છો
Linux પ્રોગ્રામર માર્ગદર્શિકા.

1500
01:14:18,780 --> 01:14:19,530
અને તે બધા લખાણ છે.

1501
01:14:19,530 --> 01:14:21,905
નોટિસ કે ત્યાં
અહીં કાર્ય નામ.

1502
01:14:21,905 --> 01:14:25,030
તે તારણ આપે છે કે તે એક પિતરાઇ કહેવાય છે
ઘટે છે, કે જે વિરુદ્ધ કરે છે.

1503
01:14:25,030 --> 01:14:29,710
અને સારાંશ હેઠળ નોટિસ, આ વાપરવા માટે
માણસ પાનું કામ કરે છે, તેથી વાત કરવા માટે,

1504
01:14:29,710 --> 01:14:32,220
મને કે હું કહી છે
સી type.h. સમાવેશ કરવાની જરૂર

1505
01:14:32,220 --> 01:14:33,630
અને હું અભ્યાસ માંથી જાણતા હતા કે.

1506
01:14:33,630 --> 01:14:36,210
>> અહીં, તે મને દર્શાવે બે
કાર્ય માટે પ્રોટોટાઇપ,

1507
01:14:36,210 --> 01:14:39,070
જેથી હું ક્યારેય ઉપયોગ કરવા માંગો છો, તો
મને ખબર છે કે તેઓ શું ઇનપુટ તરીકે લે છે,

1508
01:14:39,070 --> 01:14:40,652
અને તેઓ શું આઉટપુટ તરીકે આવો.

1509
01:14:40,652 --> 01:14:42,360
અને પછી જો હું વાંચી
વર્ણન, હું જોઈ

1510
01:14:42,360 --> 01:14:44,820
વધુ વિગતવાર શું કાર્ય કરે છે.

1511
01:14:44,820 --> 01:14:48,100
પરંતુ વધુ મહત્ત્વની, જો
હું વળતર કિંમત હેઠળ જુઓ

1512
01:14:48,100 --> 01:14:51,710
તે કહે છે પરત કિંમત છે
રૂપાંતરિત પત્ર કે,

1513
01:14:51,710 --> 01:14:57,880
અથવા સી, મૂળ ઇનપુટ, જો
રૂપાંતર શક્ય ન હતું.

1514
01:14:57,880 --> 01:15:01,992
>> બીજા શબ્દોમાં કહીએ તો, ઉપલા પ્રયાસ કરશે
અપર કેસ એક પત્ર કન્વર્ટ કરવા માટે.

1515
01:15:01,992 --> 01:15:03,450
અને તેથી જો, તે પરત ચાલી રહ્યું છે.

1516
01:15:03,450 --> 01:15:07,010
પરંતુ જો કોઇ reason-- માટે કરી શકો છો
કદાચ તે પહેલાથી જ અપર કેસ છે,

1517
01:15:07,010 --> 01:15:09,550
કદાચ તે ઉદ્ગાર બિંદુ છે
અથવા અમુક અન્ય punctuation--

1518
01:15:09,550 --> 01:15:12,200
તે માત્ર રહ્યું છે
મૂળ સી પાછા,

1519
01:15:12,200 --> 01:15:17,340
એનો અર્થ એ થાય કે જે હું મારા કોડ કરી શકો છો
સારી નીચે પ્રમાણે રચાયેલ છે.

1520
01:15:17,340 --> 01:15:20,580
>> હું બધા જરૂર નથી
કોડ આ રફૂ રેખાઓ.

1521
01:15:20,580 --> 01:15:22,610
લાઇન્સ હું કર્યું બધા
માત્ર પ્રકાશિત કરી શકો છો

1522
01:15:22,610 --> 01:15:28,700
માત્ર એક સરળ માં પડી ભાંગી
રેખા, કે જે છે આ printf ટકા છે

1523
01:15:28,700 --> 01:15:33,510
ઉપલા એ કૌંસ હું સી.

1524
01:15:33,510 --> 01:15:36,090
અને આ એક હશે
સારી ડિઝાઇન ઉદાહરણ.

1525
01:15:36,090 --> 01:15:40,040
>> શા માટે 7 અથવા 8 રેખાઓ અમલ
કોડ, ગમે તે હું માત્ર હતી

1526
01:15:40,040 --> 01:15:44,960
કાઢી ત્યારે તમે તેના બદલે તૂટી શકે છે
કે તર્ક અને નિર્ણય તમામ

1527
01:15:44,960 --> 01:15:49,620
એક લાઇનમાં, 13 હવે, માં કે
એક લાઈબ્રેરી પર આધાર રાખે છે function--

1528
01:15:49,620 --> 01:15:53,430
એક કાર્ય છે કે C સાથે આવે છે, પરંતુ તે
શું તમે તેને કરવા માંગો છો બરાબર કરે છે.

1529
01:15:53,430 --> 01:15:55,295
અને, પ્રમાણિકપણે, પણ જો
તે C સાથે આવે ન હતી,

1530
01:15:55,295 --> 01:15:58,880
તમે તેને જાતે અમલ કરી શકે છે, કારણ કે
અમે જોઇ છે, નકારાત્મક પૂર્ણાંક વિચાર સાથે

1531
01:15:58,880 --> 01:16:01,700
અને હકારાત્મક પૂર્ણાંક છેલ્લા અઠવાડિયે તેમજ મળે છે.

1532
01:16:01,700 --> 01:16:03,470
>> આ કોડ હવે વધુ વાંચી શકાય છે.

1533
01:16:03,470 --> 01:16:06,670
અને, ખરેખર, અમે ઉપર સ્ક્રોલ જો,
કેવી રીતે વધુ કોમ્પેક્ટ જુઓ

1534
01:16:06,670 --> 01:16:08,360
મારા કાર્યક્રમ ની આ આવૃત્તિ છે.

1535
01:16:08,360 --> 01:16:11,230
તે થોડો ટોચ ભારે હવે,
આ તમામ સમાવેશ થાય છે સાથે.

1536
01:16:11,230 --> 01:16:14,380
પરંતુ તે ઠીક છે, કારણ કે હવે હું સ્થાયી છું
પ્રોગ્રામરો ખભા પર

1537
01:16:14,380 --> 01:16:15,300
મને પહેલાં.

1538
01:16:15,300 --> 01:16:18,440
અને તે જે કોઈ હતું જે
ખરેખર ઉપલા અમલ

1539
01:16:18,440 --> 01:16:21,470
મને, એક તરફેણમાં હતી જેમ જ વિષયક
અમલ સ્ટર્લિંગ ખરેખર

1540
01:16:21,470 --> 01:16:24,790
મને એક તરફેણમાં કેટલાક સમય પહેલાં હતી.

1541
01:16:24,790 --> 01:16:26,970
અને તેથી હવે અમે એક છે
સારી ડિઝાઇન કાર્યક્રમ

1542
01:16:26,970 --> 01:16:31,680
કે જે ચોક્કસ જ તર્ક લાગુ કરે છે.

1543
01:16:31,680 --> 01:16:35,580
>> સ્ટર્લિંગ બોલતા, દો
મને આગળ વધો અને આ કરવા.

1544
01:16:35,580 --> 01:16:38,320
મને આગળ વધો અને સંગ્રહ કરીએ
આ ફાઇલ stirling.c છે.

1545
01:16:38,320 --> 01:16:43,255
અને તે તારણ છે, અમે પાછા છાલ કરી શકો છો
એક અન્ય સ્તર ખૂબ સરળ હવે.

1546
01:16:43,255 --> 01:16:45,630
હું આગળ અને ચાબુક જાઓ જાઉં છું
મુખ્ય અન્ય કાર્યક્રમ

1547
01:16:45,630 --> 01:16:49,759
અહીં કે ફક્ત ફરીથી ઓજાર
શબ્દમાળા લંબાઈ નીચે પ્રમાણે.

1548
01:16:49,759 --> 01:16:52,300
તેથી અહીં કોડ એક વાક્ય છે કે
મને વપરાશકર્તા માંથી શબ્દમાળા મળે છે.

1549
01:16:52,300 --> 01:16:53,910
અમે ફરીથી અને ફરીથી આ ઉપયોગ ચાલુ રાખી.

1550
01:16:53,910 --> 01:16:58,900
મને મારી જાતને એક ચલ કહેવાય આપી દો
પ્રકાર પૂર્ણાંક છે કે જે નંબર સંગ્રહ કરે છે એન.

1551
01:16:58,900 --> 01:17:02,490
>> અને મને આગળ જાઓ અને
નીચેના તર્કશાસ્ત્ર નથી.

1552
01:17:02,490 --> 01:17:15,610
એસ એન મી અક્ષર કરે છે
સમાન બેકસ્લેશ 0, આગળ વધો

1553
01:17:15,610 --> 01:17:17,930
અને એન વધારો.

1554
01:17:17,930 --> 01:17:23,506
અને પછી printf ટકા હું એ છાપશે.

1555
01:17:23,506 --> 01:17:29,200
હું આ કાર્યક્રમ અહીં દાવો,
શબ્દમાળા લંબાઈ ફોન વગર,

1556
01:17:29,200 --> 01:17:31,150
એક શબ્દમાળા લંબાઈ આધાર.

1557
01:17:31,150 --> 01:17:34,600
>> અને જાદુ રાખે છે
8 લીટી માં સમાઇ

1558
01:17:34,600 --> 01:17:39,830
અહીં નવું શું છે વાક્યરચના જેવી લાગે છે,
આ બેકસ્લેશ 0 એક અવતરણ.

1559
01:17:39,830 --> 01:17:41,360
પરંતુ તે શા માટે છે?

1560
01:17:41,360 --> 01:17:44,100
વેલ, તે ધ્યાનમાં કરવામાં આવી છે
આ બધા સમય પર જવાનું.

1561
01:17:44,100 --> 01:17:47,990
>> અને એક કોરે પહેલાં હું ભૂલી, ખ્યાલ તરીકે
પણ, તે મેન પેજો માટે વધુમાં

1562
01:17:47,990 --> 01:17:50,920
કે એક લાક્ષણિક સાથે આવે છે
CS50 IDE જેવા Linux સિસ્ટમ,

1563
01:17:50,920 --> 01:17:53,770
ખ્યાલ છે કે અમે,
આ કોર્સ સ્ટાફ, પણ

1564
01:17:53,770 --> 01:17:56,030
એક વેબસાઇટ આવૃત્તિ કરવામાં
આ જ વિચાર કહેવાય

1565
01:17:56,030 --> 01:17:59,940
reference.cs50.net છે, જે
તે એ જ માણસ પાના તમામ,

1566
01:17:59,940 --> 01:18:02,020
તે જ તમામ
દસ્તાવેજીકરણ, તેમજ

1567
01:18:02,020 --> 01:18:05,730
ટોચ પરવાનગી આપે છે કે એક નાના બોક્સમાં
તમે એકદમ તમામ કન્વર્ટ કરવા માટે

1568
01:18:05,730 --> 01:18:09,025
ઓછી આરામદાયક માં Arcane ભાષા
સ્થિતિ છે, જ્યાં અમે, શિક્ષણ સ્ટાફ,

1569
01:18:09,025 --> 01:18:12,150
પસાર અને સરળ બનાવવા માટે પ્રયાસ કર્યો છે
વસ્તુઓ રાખવા ભાષાના કેટલાક

1570
01:18:12,150 --> 01:18:14,830
વિચારો પર ધ્યાન કેન્દ્રિત કર્યું, અને
સૂક્ષ્મતા કેટલાક.

1571
01:18:14,830 --> 01:18:20,070
જેથી ધ્યાનમાં રાખો, reference.cs50.net
અન્ય સ્ત્રોત તરીકે તેમજ.

1572
01:18:20,070 --> 01:18:23,800
>> પરંતુ શા માટે શબ્દમાળા લંબાઈ કામ કરે છે
જે રીતે હું એક ક્ષણ પહેલા સૂચિત?

1573
01:18:23,800 --> 01:18:25,160
અહીં Zamyla નામ ફરી છે.

1574
01:18:25,160 --> 01:18:27,690
અને અહીં Zamyla નામ છે
માં બોક્સવાળી હું કરી રાખવા,

1575
01:18:27,690 --> 01:18:31,360
તે છે એક ચિત્ર કરું,
ખરેખર, માત્ર અક્ષરો ક્રમ.

1576
01:18:31,360 --> 01:18:34,260
પરંતુ Zamyla અસ્તિત્વમાં નથી
એક કાર્યક્રમ એકલતા.

1577
01:18:34,260 --> 01:18:37,420
>> જ્યારે તમે લખી અને એક કાર્યક્રમ ચલાવવા માટે,
તમે તમારા Mac અથવા તમારા PC ઉપયોગ કરી રહ્યાં છો

1578
01:18:37,420 --> 01:18:40,010
મેમરી, અથવા RAM જેથી વાત કરવા માટે.

1579
01:18:40,010 --> 01:18:42,620
અને તમે વિચાર કરી શકો છો
હોવા તરીકે તમારા કમ્પ્યુટર

1580
01:18:42,620 --> 01:18:44,730
મેમરી ગીગાબાઇટ્સ આ દિવસોમાં ઘણી બધી.

1581
01:18:44,730 --> 01:18:47,700
અને એક જહાજની નાની હોડી અબજો અર્થ થાય છે,
જેથી બાઇટ્સ અબજો.

1582
01:18:47,700 --> 01:18:48,910
>> પરંતુ સમય રીવાઇન્ડ દો.

1583
01:18:48,910 --> 01:18:51,530
અને અમે ઉપયોગ કરી રહ્યાં છો ધારવું
ખરેખર જૂના કમ્પ્યુટર કે

1584
01:18:51,530 --> 01:18:55,150
માત્ર મેમરી 32 બાઇટ્સ છે.

1585
01:18:55,150 --> 01:18:59,310
હું કરી શકે છે, મારા કમ્પ્યુટર સ્ક્રીન પર,
માત્ર આ બહાર ડ્રો નીચે પ્રમાણે.

1586
01:18:59,310 --> 01:19:05,240
>> હું ફક્ત કહી શકે કે મારા
કમ્પ્યુટર આ મેમરી બધા છે.

1587
01:19:05,240 --> 01:19:08,830
અને આ મેમરી એક લાકડી જેવી છે, જો
તમે છેલ્લી વખત અમારા ચિત્ર યાદ અપાવે છે.

1588
01:19:08,830 --> 01:19:11,670
અને જો હું માત્ર વિભાજીત
પૂરતા સમયમાં આ

1589
01:19:11,670 --> 01:19:15,040
હું દાવો હું 32 બાઇટ્સ હોય છે
સ્ક્રીન પર મેમરી.

1590
01:19:15,040 --> 01:19:18,239
>> માત્ર હવે, વાસ્તવમાં, હું કરી શકો છો
અહીં આ સ્ક્રીન પર અત્યાર સુધી દોરે છે.

1591
01:19:18,239 --> 01:19:20,280
તેથી હું આગળ જાઓ જાઉં છું
અને માત્ર પરંપરા દ્વારા,

1592
01:19:20,280 --> 01:19:24,050
તરીકે મારા કમ્પ્યુટર મેમરી ડ્રો
ગ્રીડ, માત્ર કારણ કે એક સીધી રેખા.

1593
01:19:24,050 --> 01:19:28,190
ખાસ કરીને, હવે હું દાવો
આ ગ્રીડ, આ 8 4 ગ્રીડ,

1594
01:19:28,190 --> 01:19:31,800
ફક્ત તમામ 32 બાઇટ્સ રજૂ
મારા મેક ઉપલબ્ધ મેમરી,

1595
01:19:31,800 --> 01:19:33,030
અથવા મારા પીસી માં ઉપલબ્ધ છે.

1596
01:19:33,030 --> 01:19:34,780
અને તેઓ વીંટાળવવાની કરી રહ્યાં છો
પર બે લીટીઓ, માત્ર

1597
01:19:34,780 --> 01:19:38,030
કારણ કે તે સ્ક્રીન પર વધુ બંધબેસે છે.

1598
01:19:38,030 --> 01:19:40,800
પરંતુ આ પ્રથમ બાઇટ છે.

1599
01:19:40,800 --> 01:19:41,990
આ બીજા બાઈટ છે.

1600
01:19:41,990 --> 01:19:43,300
આ ત્રીજા બાઈટ છે.

1601
01:19:43,300 --> 01:19:45,310
>> અને આ 32 બાઈટ છે.

1602
01:19:45,310 --> 01:19:52,910
અથવા, અમે એક કોમ્પ્યુટર જેવી લાગે છે કે જો
વૈજ્ઞાનિક, આ બાઇટ 0, 1, 2, 3, 31 છે.

1603
01:19:52,910 --> 01:19:55,950
તેથી જો તમે 31 0 છે, તો
તમે 0 અંતે ગણતરી શરૂ કરો.

1604
01:19:55,950 --> 01:19:59,830
>> તેથી જો આપણે એક કાર્યક્રમ વાપરવા
કે કોલ શબ્દમાળા મેળવવા માટે,

1605
01:19:59,830 --> 01:20:05,280
અને અમે માનવ તરફથી એક શબ્દમાળા વિચાર
જેમ હું Zamyla કહેવાય હતી, Z-A-એમ-વાય-એલ-એ,

1606
01:20:05,280 --> 01:20:09,430
કેવી રીતે વિશ્વમાં કરે
કમ્પ્યુટર રાખો ટ્રેક છે, જે બાઇટ,

1607
01:20:09,430 --> 01:20:12,230
જે મેમરી ચંકને
જે શબ્દમાળા માટે અનુસરે છે?

1608
01:20:12,230 --> 01:20:16,270
અન્ય શબ્દોમાં, જો આપણે આગળ વધવું
કમ્પ્યૂટરમાં અન્ય નામ લખો

1609
01:20:16,270 --> 01:20:19,890
આ Andi જેમ, ફોન
શબ્દમાળા બીજી વખત વિચાર,

1610
01:20:19,890 --> 01:20:23,030
એક-એન-ડી-હું અંત છે
કમ્પ્યુટરની મેમરી તેમજ.

1611
01:20:23,030 --> 01:20:23,850
પરંતુ કેવી રીતે?

1612
01:20:23,850 --> 01:20:29,700
>> વેલ, તે તારણ છે કે જે નીચે
હૂડ, સી શું જ્યારે શબ્દમાળાઓ સ્ટોર કરે છે

1613
01:20:29,700 --> 01:20:35,080
કે માનવ પ્રકારની, અથવા તે
કેટલાક અન્ય સ્ત્રોત માંથી આવે છે, તે છે

1614
01:20:35,080 --> 01:20:39,190
સાથે તેમને ઓવરને delineates
ખાસ character-- બેકસ્લેશ

1615
01:20:39,190 --> 01:20:44,750
0, જે માત્ર એક ખાસ રીત છે
એક પંક્તિ માં 80 બીટ્સ કહ્યું.

1616
01:20:44,750 --> 01:20:47,950
>> તેથી ચલો આ નંબર 97 રિકોલ છે.

1617
01:20:47,950 --> 01:20:51,770
તેથી 8 બીટ્સ કેટલાક પેટર્ન
દશાંશ નંબર 97 પ્રતિનિધિત્વ કરે છે.

1618
01:20:51,770 --> 01:20:58,070
આ બેકસ્લેશ 0 શાબ્દિક નંબર છે
0 ઉર્ફે nul, એન યુ એલ, અગાઉ જેમ નહિં પણ,

1619
01:20:58,070 --> 01:20:59,630
એન યુ એલ એલ, કે જે અમે વિશે વાત કરી.

1620
01:20:59,630 --> 01:21:05,700
પરંતુ હવે માટે, માત્ર આ ખબર છે કે
બેકસ્લેશ 0 એક પંક્તિ માં માત્ર 80 બિટ્સ છે.

1621
01:21:05,700 --> 01:21:09,810
>> અને તે માત્ર આ વાક્ય છે
રેતી કે ડાબી કંઈપણ કહે

1622
01:21:09,810 --> 01:21:12,610
એક શબ્દમાળા, અથવા એક માહિતી પ્રકાર માટે અનુસરે છે.

1623
01:21:12,610 --> 01:21:15,480
અને જમણી કંઈપણ
કંઈક બીજું માટે અનુસરે છે.

1624
01:21:15,480 --> 01:21:17,440
Andi નામ દરમિયાન,
જે ફક્ત દૃષ્ટિની

1625
01:21:17,440 --> 01:21:21,310
અન્ય રેખા પર લપેટી થાય છે,
પરંતુ તે માત્ર એક કલાત્મક વિગતવાર છે,

1626
01:21:21,310 --> 01:21:23,990
એ જ રીતે nul સમાપ્ત કરવામાં આવે છે.

1627
01:21:23,990 --> 01:21:29,290
>> તે એક-એન-ડી-હું એ અક્ષરોની એક સ્ટ્રિંગ છે,
વત્તા એક પાંચમા ગુપ્ત પાત્ર,

1628
01:21:29,290 --> 01:21:33,560
બધા 0 બિટ્સ, કે જે હમણાં જ demarcates
Andi નામ અંત તેમજ.

1629
01:21:33,560 --> 01:21:37,120
અને શબ્દમાળા ત્રીજી વખત વિચાર જો આપણે કહી
કમ્પ્યુટર જેવી શબ્દમાળા મેળવવા માટે

1630
01:21:37,120 --> 01:21:44,210
મારિયા, એમ એ આર આઇ એ, એ જ રીતે માતાનો મારિયા છે
નામ nul બેકસ્લેશ 0 સાથે સમાપ્ત.

1631
01:21:44,210 --> 01:21:47,170
>> આ મૂળભૂત રીતે જુદા છે
કેવી રીતે એક કમ્પ્યુટર સામાન્ય રીતે કરશે

1632
01:21:47,170 --> 01:21:51,850
પૂર્ણાંક, અથવા એક ફ્લોટ, અથવા અન્ય સ્ટોર
હજુ પણ ડેટા પ્રકારો છે, કારણ કે સ્મૃતિ,

1633
01:21:51,850 --> 01:21:57,420
પૂર્ણાંક સામાન્ય રીતે 32 બિટ્સ છે, અથવા
4 બાઇટ્સ, અથવા કદાચ 64 બિટ્સ,

1634
01:21:57,420 --> 01:21:59,100
કે આઠ બાઇટ્સ.

1635
01:21:59,100 --> 01:22:02,620
પરંતુ કમ્પ્યૂટર ઘણા પૌરાણિક
એક પ્રોગ્રામિંગ ભાષા માં

1636
01:22:02,620 --> 01:22:05,550
એક નિશ્ચિત સંખ્યા છે
hood-- નીચે બાઇટો

1637
01:22:05,550 --> 01:22:08,100
કદાચ 1, કદાચ 2, કદાચ 4, કદાચ 8.

1638
01:22:08,100 --> 01:22:13,250
>> પરંતુ શબ્દમાળાઓ, ડિઝાઇન દ્વારા, એક છે
અક્ષરો ગતિશીલ સંખ્યા.

1639
01:22:13,250 --> 01:22:16,980
તમે અગાઉથી ખબર નથી, ત્યાં સુધી
Z-A-એમ-વાય-એલ-A માનવ પ્રકારો,

1640
01:22:16,980 --> 01:22:21,400
અથવા એમ એ આર આઇ એ, અથવા એ-એન-ડી-હું. તમે જાણતા નથી
કેટલી વખત વપરાશકર્તા હિટ રહ્યું છે

1641
01:22:21,400 --> 01:22:22,070
કીબોર્ડ.

1642
01:22:22,070 --> 01:22:26,490
તેથી, તમે કેવી રીતે ખબર નથી
અગાઉથી ઘણા અક્ષરો

1643
01:22:26,490 --> 01:22:27,540
તમે જરૂર જઈ રહ્યાં છો.

1644
01:22:27,540 --> 01:22:31,840
>> અને તેથી સી માત્ર પ્રકારની એક જેવા નહીં
હૂડ નીચે ગુપ્ત બ્રેડક્રમ્બને

1645
01:22:31,840 --> 01:22:32,960
શબ્દમાળા ઓવરને અંતે.

1646
01:22:32,960 --> 01:22:39,280
મેમરી Z-A-એમ-વાય-એલ-A સ્ટોર કર્યા પછી,
તે પણ માત્ર સમકક્ષ મૂકે

1647
01:22:39,280 --> 01:22:40,210
એક સમયગાળા.

1648
01:22:40,210 --> 01:22:45,060
એક સજા ઓવરને અંતે,
તે 80 બિટ્સ મૂકે છે, જેથી

1649
01:22:45,060 --> 01:22:49,120
જ્યાં યાદ
Zamyla શરૂ થાય છે અને અંત થાય છે.

1650
01:22:49,120 --> 01:22:51,490
>> તેથી શું સંબંધ છે,
પછી, આ કાર્યક્રમ માટે?

1651
01:22:51,490 --> 01:22:55,190
અહીં આ કાર્યક્રમ, સ્ટર્લિંગ,
ફક્ત એક પદ્ધતિ છે

1652
01:22:55,190 --> 01:22:57,970
શબ્દમાળા મેળવવા માટે
વપરાશકર્તા માંથી, રેખા 6.

1653
01:22:57,970 --> 01:23:01,160
7 વાક્ય પર, હું એક ચલ જાહેર
એ કહેવામાં આવે છે અને તે 0 થી સમાન સુયોજિત કરો.

1654
01:23:01,160 --> 01:23:08,680
>> અને પછી 8 વાક્ય માં, હું ફક્ત પૂછવામાં
પ્રશ્ન છે, જ્યારે એ મી અક્ષર કરે છે

1655
01:23:08,680 --> 01:23:12,120
સમાન બધા 0 bits--
અન્ય શબ્દોમાં, નથી

1656
01:23:12,120 --> 01:23:14,500
સમાન આ ખાસ
પાત્ર, બેકસ્લેશ 0, જે

1657
01:23:14,500 --> 01:23:18,470
કે જે હમણાં જ ખાસ nul character-- હતી
આગળ વધો અને માત્ર એન વધારો.

1658
01:23:18,470 --> 01:23:21,460
>> અને તે કરી રાખવા, અને રાખવા
તે કરી છે, અને તે કરી રાખવા.

1659
01:23:21,460 --> 01:23:23,430
અને તેથી પણ છતાં
છેલ્લા અમે હું ઉપયોગ કર્યો છે,

1660
01:23:23,430 --> 01:23:25,181
તે સંપૂર્ણપણે દંડ છે
અર્થનિર્ધારણ એ વાપરવા માટે,

1661
01:23:25,181 --> 01:23:27,430
તમે માત્ર પ્રયાસ કરી રહ્યા છો, તો
ઇરાદાપૂર્વક આ સમય ગણતરી,

1662
01:23:27,430 --> 01:23:28,720
અને માત્ર તે n કૉલ કરવા માંગો છો.

1663
01:23:28,720 --> 01:23:34,720
તેથી આ માત્ર પ્રશ્ન પૂછવા રાખે છે,
S ના બધા 0s એ મી અક્ષર છે?

1664
01:23:34,720 --> 01:23:38,470
જો નહિં, તો આગામી દેખાવ માટે જુઓ,
આગામી જોવા આગામી જુઓ,

1665
01:23:38,470 --> 01:23:39,460
આગામી જુઓ.

1666
01:23:39,460 --> 01:23:45,540
>> પરંતુ જલદી તમે બેકસ્લેશ 0 જુઓ,
11-- દ્વારા આ લૂપ લાઈન 9 અટકી જાય છે.

1667
01:23:45,540 --> 01:23:49,640
તમે જ્યારે લૂપ બહાર ભંગ,
કે ચલ n ના અંદર છોડીને

1668
01:23:49,640 --> 01:23:54,530
તમામ કુલ સભ્યપદ
શબ્દમાળા તમે જોયું અક્ષરો,

1669
01:23:54,530 --> 01:23:55,660
ત્યાં તે બહાર છાપવા.

1670
01:23:55,660 --> 01:23:56,760
તેથી આપણે આ પ્રયાસ કરો.

1671
01:23:56,760 --> 01:23:59,500
>> મને આગળ જવા દો અને વિના,
સ્ટર્લિંગ કાર્ય ઉપયોગ કરીને,

1672
01:23:59,500 --> 01:24:04,240
પરંતુ માત્ર મારા પોતાના સ્થાનિક આવૃત્તિ વાપરી
અહીં સ્ટર્લિંગ કહેવાય છે, દો મને આગળ વધો

1673
01:24:04,240 --> 01:24:07,700
અને રન સ્ટર્લિંગ, કંઈક લખો
Zamyla છે, જે હું અગાઉથી ખબર જેવા

1674
01:24:07,700 --> 01:24:08,670
છ અક્ષરો છે.

1675
01:24:08,670 --> 01:24:10,080
ચાલો જોવા જો તે કામ કરે છે.

1676
01:24:10,080 --> 01:24:10,920
ખરેખર, તે છ છે.

1677
01:24:10,920 --> 01:24:15,257
માતાનો રોબ સાથે પ્રયત્ન કરીએ, ત્રણ અક્ષરો,
ત્રણ અક્ષરો તેમજ, અને તેથી આગળ.

1678
01:24:15,257 --> 01:24:17,340
તેથી કે જે બધા રહ્યું છે
હૂડ નીચે.

1679
01:24:17,340 --> 01:24:19,548
અને જોડાણો નોટિસ,
પછી, પ્રથમ સપ્તાહ સાથે

1680
01:24:19,548 --> 01:24:22,370
વર્ગ છે, જ્યાં અમે વિશે વાત કરી
તાત્વિક કંઈક,

1681
01:24:22,370 --> 01:24:26,960
જે ફક્ત વિચારો આ layering છે, અથવા
જટિલતા, મૂળભૂત સિદ્ધાંતો ટોચ પર.

1682
01:24:26,960 --> 01:24:30,710
અહીં, આપણે સૉર્ટ શોધી રહ્યાં છો
સ્ટર્લિંગ હૂડ નીચે,

1683
01:24:30,710 --> 01:24:33,510
તેથી વાત કરવા માટે બહાર આકૃતિ,
તે કેવી રીતે અમલમાં આવશે?

1684
01:24:33,510 --> 01:24:35,232
>> અને અમે તેને જાતને ફરીથી અમલ કરી શકે છે.

1685
01:24:35,232 --> 01:24:37,440
પરંતુ અમે ક્યારેય ફરીથી જઈ રહ્યાં છો
માટે ફરીથી અમલમાં સ્ટર્લિંગ.

1686
01:24:37,440 --> 01:24:39,780
અમે હમણાં જ જઈ રહ્યાં છો
ક્રમમાં સ્ટર્લિંગ ઉપયોગ

1687
01:24:39,780 --> 01:24:42,100
વાસ્તવમાં કેટલાક શબ્દમાળાઓ લંબાઈ વિચાર.

1688
01:24:42,100 --> 01:24:44,200
>> પરંતુ ત્યાં કોઈ જાદુ છે
હૂડ નીચે.

1689
01:24:44,200 --> 01:24:46,716
કે નીચે જો તમે જાણો છો
હૂડ, શબ્દમાળા

1690
01:24:46,716 --> 01:24:48,090
માત્ર અક્ષરો ક્રમ છે.

1691
01:24:48,090 --> 01:24:51,090
અને અક્ષરો કે ક્રમ
બધા સંખ્યાની સંબોધી શકાય

1692
01:24:51,090 --> 01:24:53,330
કૌંસ 0, કૌંસ સાથે
1, કૌંસ 2, અને તમે

1693
01:24:53,330 --> 01:24:57,420
ખબર છે કે એક શબ્દમાળા ઓવરને અંતે એક છે
ખાસ પાત્ર, તમે બહાર આકૃતિ કરી શકો છો

1694
01:24:57,420 --> 01:25:01,710
કેવી રીતે સૌથી કંઈ પણ કરવા માટે
કાર્યક્રમ, કારણ કે તે તમામ નીચે ઉકળે

1695
01:25:01,710 --> 01:25:03,400
વાંચન અને મેમરી લખી રહ્યો છે.

1696
01:25:03,400 --> 01:25:06,130
એટલે કે, બદલાતી અને શોધી
મેમરી પર, અથવા વસ્તુઓ ખસેડવાની

1697
01:25:06,130 --> 01:25:10,940
મેમરી આસપાસ, પ્રિન્ટીંગ વસ્તુઓ
સ્ક્રીન, અને તેથી આગળ પર.

1698
01:25:10,940 --> 01:25:14,800
>> તો ચાલો હવે આ નવા ઉપયોગ
શું ખરેખર શબ્દમાળાઓ સમજ

1699
01:25:14,800 --> 01:25:17,910
હૂડ નીચે છે, અને
પાછા છાલ એક અન્ય સ્તર

1700
01:25:17,910 --> 01:25:20,080
કે જે હવે ત્યાં સુધી અમે કર્યું
એકસાથે અવગણીને કરવામાં આવી.

1701
01:25:20,080 --> 01:25:22,650
ખાસ કરીને, કોઈ પણ સમયે
અમે એક કાર્યક્રમ અમલમાં છે,

1702
01:25:22,650 --> 01:25:25,930
અમે કોડ આ વાક્ય પડ્યું
ટોચ નજીક મુખ્ય જાહેર કર્યુ.

1703
01:25:25,930 --> 01:25:27,810
અને અમે પૂર્ણાંક મુખ્ય રદબાતલ સ્પષ્ટ કર્યું છે.

1704
01:25:27,810 --> 01:25:31,240
>> અને કૌંસ અંદર કે રદબાતલ
આ બધા સમય કહેતા હોય છે કે મુખ્ય

1705
01:25:31,240 --> 01:25:33,440
પોતે કોઇ દલીલો લેવા નથી.

1706
01:25:33,440 --> 01:25:36,210
કોઈપણ ઇનપુટ મુખ્ય છે કે
વપરાશકર્તા માંથી મળી જતા

1707
01:25:36,210 --> 01:25:39,020
કેટલાક અન્ય આવે છે
પદ્ધતિ, જેવા વિચાર પૂર્ણાંક,

1708
01:25:39,020 --> 01:25:42,040
અથવા ફ્લોટ વિચાર, અથવા શબ્દમાળા મેળવવા માટે,
અથવા અમુક અન્ય કાર્ય.

1709
01:25:42,040 --> 01:25:44,710
પરંતુ તે તારણ આપે છે કે
જ્યારે તમે કાર્યક્રમ લખી,

1710
01:25:44,710 --> 01:25:47,690
તમે ખરેખર સ્પષ્ટ કરી શકો છો
આ કાર્યક્રમ રહેશે

1711
01:25:47,690 --> 01:25:51,730
માનવ ઇનપુટ્સ લેવા
આદેશ વાક્ય જ.

1712
01:25:51,730 --> 01:25:56,310
>> અન્ય શબ્દોમાં, છતાં પણ અમે આમ અત્યાર સુધી
માત્ર હેલ્લો ચાલી આવી હેલો છે

1713
01:25:56,310 --> 01:26:00,312
અથવા સમાન કાર્યક્રમો, બધા
અન્ય કાર્યક્રમો કે જે અમે ઉપયોગ કરી રહ્યો છું,

1714
01:26:00,312 --> 01:26:02,770
આપણે આપણી જાતને લખી ન હતી,
છે લેવા આવી છે, તે લાગે છે,

1715
01:26:02,770 --> 01:26:05,210
આદેશ વાક્ય દલીલો
મેક જેવી વસ્તુઓ.

1716
01:26:05,210 --> 01:26:07,450
તમે બનાવવા કંઈક કહે છે,
અને પછી બીજા શબ્દ.

1717
01:26:07,450 --> 01:26:10,950
અથવા રણકાર, તમે રણકાર કહે છે, અને પછી
બીજા શબ્દ, ફાઇલ નામ.

1718
01:26:10,950 --> 01:26:14,410
>> અથવા તો આરએમ અથવા સી.પી., કારણ કે તમે કદાચ
અથવા જોઈ પહેલેથી ઉપયોગમાં છે

1719
01:26:14,410 --> 01:26:15,880
દૂર અથવા ફાઈલો નકલ કરવા.

1720
01:26:15,880 --> 01:26:18,920
તે બધા કહેવાતા લેવા
આદેશ વાક્ય દલીલો

1721
01:26:18,920 --> 01:26:21,130
ટર્મિનલ પ્રોમ્પ્ટ પર વધારાના શબ્દો.

1722
01:26:21,130 --> 01:26:23,260
પરંતુ હવે ત્યાં સુધી, અમે
જાતને થયું નથી

1723
01:26:23,260 --> 01:26:27,080
ઇનપુટ લેવાના આ વૈભવી
વપરાશકર્તા જ્યારે તે અથવા તેણી ખરેખર ચાલે

1724
01:26:27,080 --> 01:26:29,120
કાર્યક્રમ પોતે આદેશ વાક્ય પર.

1725
01:26:29,120 --> 01:26:33,710
>> પરંતુ અમે તે દ્વારા ફરી જાહેર કરી શકો છો
મુખ્ય આગળ ખસેડવાની, હોવા તરીકે

1726
01:26:33,710 --> 01:26:36,750
કૌંસ માં રદબાતલ,
પરંતુ આ બે દલીલો

1727
01:26:36,750 --> 01:26:40,600
પ્રથમ પૂર્ણાંક instead--,
અને બીજા કંઈક

1728
01:26:40,600 --> 01:26:44,170
નવા, કંઈક કે અમે કહી રહ્યા છીએ
ઝાકઝમાળ, ભાવના સમાન કંઈક

1729
01:26:44,170 --> 01:26:49,220
શું આપણે એક યાદી તરીકે સ્ક્રેચ માં જોયું છે, પરંતુ
શબ્દમાળાઓ ઝાકઝમાળ, અમે ટૂંક સમયમાં જોવા મળશે કારણ કે.

1730
01:26:49,220 --> 01:26:51,790
પરંતુ ચાલો આ જોવા
ઉદાહરણ રીતે, આપણે પહેલા

1731
01:26:51,790 --> 01:26:53,690
તફાવત તે બરાબર શું થાય છે.

1732
01:26:53,690 --> 01:26:56,520
>> તેથી જો હું CS50 IDE જાય
અહીં, હું આગળ ચાલ્યા કર્યું

1733
01:26:56,520 --> 01:27:01,840
અને તરીકે ઓળખાતી ફાઈલ માં જાહેર
નીચેની નમૂના argv0.c.

1734
01:27:01,840 --> 01:27:04,120
અને માત્ર વસ્તુ નોટિસ
કે અત્યાર સુધી અલગ છે

1735
01:27:04,120 --> 01:27:08,570
છે કે હું પૂર્ણાંક માટે રદબાતલ બદલ્યું
argc શબ્દમાળા ઓપન કૌંસ argv, બંધ

1736
01:27:08,570 --> 01:27:09,070
કૌંસ.

1737
01:27:09,070 --> 01:27:11,730
અને હવે નોટિસ, ત્યાં છે
તે કૌંસ ની અંદર કંઈ નથી.

1738
01:27:11,730 --> 01:27:12,620
>> આ બોલ પર કોઈ નંબર છે.

1739
01:27:12,620 --> 01:27:15,070
અને ત્યાં કોઈ હું, અથવા
એન, અથવા અન્ય કોઇ પત્ર.

1740
01:27:15,070 --> 01:27:17,010
હું માત્ર ઉપયોગ કરું છું
હવે ચોરસ કૌંસ,

1741
01:27:17,010 --> 01:27:19,510
કારણોસર અમે આવો પડશે
પાછા માત્ર એક ક્ષણ માટે.

1742
01:27:19,510 --> 01:27:21,330
>> અને હવે હું શું કરવા જાઉં છું આ છે.

1743
01:27:21,330 --> 01:27:26,680
argc બરાબર તો બરાબર 2--
અને યાદ છે કે સમકક્ષ સમકક્ષ

1744
01:27:26,680 --> 01:27:30,040
સમાનતા ઓપરેટર સરખામણી છે
ડાબી અને સમાનતા માટે યોગ્ય છે.

1745
01:27:30,040 --> 01:27:31,790
તે સોંપણી નથી
ઓપરેટર છે, જે

1746
01:27:31,790 --> 01:27:36,510
એક સમાન સાઇન છે, કે જે નકલ અર્થ એ થાય
અધિકાર કેટલાક કિંમત બાકી છે.

1747
01:27:36,510 --> 01:27:42,840
>> argc 2 સમકક્ષ સમકક્ષ હોય તો, હું કરવા માંગો છો
કહે છે, printf, હેલ્લો, percents, નવી લાઇન,

1748
01:27:42,840 --> 01:27:47,340
અને પછી વાહ પ્લગ અને અહીં નવું
trick-- argv કૌંસ 1, કારણો માટે

1749
01:27:47,340 --> 01:27:48,840
કે અમે એક ક્ષણ પાછા આવો પડશે.

1750
01:27:48,840 --> 01:27:52,110
બાકી જો argc નથી
સમાન 2, તમે શું જાણો છો?

1751
01:27:52,110 --> 01:27:57,400
માત્ર આગળ વધો અને સામાન્ય, પ્રિન્ટ તરીકે,
બહાર હેલો કોઈ બદલી સાથે વિશ્વ.

1752
01:27:57,400 --> 01:28:02,710
>> તેથી તેને લાગે છે કે જો argc, જે
દલીલ ગણતરી માટે વપરાય છે, 2 સમકક્ષ હોય છે,

1753
01:28:02,710 --> 01:28:04,740
હું છાપે જાઉં છું
હેલો કંઈક અથવા અન્ય.

1754
01:28:04,740 --> 01:28:07,560
નહિંતર, મૂળભૂત રીતે, હું છું
હેલો છાપવા માટે વિશ્વ જઈ રહી છે.

1755
01:28:07,560 --> 01:28:08,770
તેથી આ શું અર્થ છે?

1756
01:28:08,770 --> 01:28:15,550
>> ઠીક છે, મને આગળ વધો અને સાચવવા દો
આ ફાઇલ, અને પછી argv0 કરે છે,

1757
01:28:15,550 --> 01:28:18,940
અને પછી ./argv0, દાખલ કરો.

1758
01:28:18,940 --> 01:28:20,300
અને તે હેલો વર્લ્ડ કહે છે.

1759
01:28:20,300 --> 01:28:21,260
હવે, કે શા માટે છે?

1760
01:28:21,260 --> 01:28:24,730
>> વેલ, તે ગમે ત્યારે બહાર વળે તમે
આદેશ વાક્ય પર એક કાર્યક્રમ ચલાવવા માટે,

1761
01:28:24,730 --> 01:28:29,570
તમે ભરતા હોય છે, આપણે શું કરીશું
સામાન્ય રીતે એક દલીલ વેક્ટર કૉલ કરો.

1762
01:28:29,570 --> 01:28:33,100
અન્ય શબ્દોમાં, આપોઆપ
કોમ્પ્યુટર, ઓપરેટિંગ સિસ્ટમ,

1763
01:28:33,100 --> 01:28:38,340
તમારા કાર્યક્રમ માટે હાથ રહ્યું છે
પોતે બધા જ શબ્દો યાદી

1764
01:28:38,340 --> 01:28:40,850
માનવ પર લખ્યો છે કે
પ્રોમ્પ્ટ પર, કિસ્સામાં તમે

1765
01:28:40,850 --> 01:28:43,790
પ્રોગ્રામર કરવા માંગો છો
તે માહિતી સાથે કંઈક.

1766
01:28:43,790 --> 01:28:48,540
અને આ કિસ્સામાં, માત્ર શબ્દ
હું પ્રોમ્પ્ટ પર લખ્યો છે ./argv0 છે.

1767
01:28:48,540 --> 01:28:55,420
>> અને તેથી દલીલો સંખ્યા છે કે
મારા કાર્યક્રમને પસાર થયા છે.

1768
01:28:55,420 --> 01:28:58,880
અન્ય શબ્દોમાં, દલીલ
ગણતરી, અન્યથા argc તરીકે ઓળખાય

1769
01:28:58,880 --> 01:29:00,970
અંહિ પૂર્ણાંક છે, માત્ર એક છે.

1770
01:29:00,970 --> 01:29:03,000
એક, અલબત્ત, સમાન બે નથી.

1771
01:29:03,000 --> 01:29:05,980
અને તેથી આ શું છાપે છે, હેલો વર્લ્ડ છે.

1772
01:29:05,980 --> 01:29:08,170
>> પરંતુ મને આ ક્યાંક લેવા દો.

1773
01:29:08,170 --> 01:29:09,930
મને કહો, argv0.

1774
01:29:09,930 --> 01:29:12,740
અને પછી કેવી રીતે મારિયા વિશે શું?

1775
01:29:12,740 --> 01:29:14,990
અને પછી Enter દબાવો.

1776
01:29:14,990 --> 01:29:18,020
>> નોટિસ શું જાદુઇ અહીં થાય છે.

1777
01:29:18,020 --> 01:29:22,640
હવે, તેની જગ્યાએ હેલો વિશ્વના, હું
આ કાર્યક્રમ વર્તણૂક બદલી

1778
01:29:22,640 --> 01:29:26,310
ઇનપુટ વિચાર ન લેવા દ્વારા
શબ્દમાળા અથવા અમુક અન્ય કાર્ય,

1779
01:29:26,310 --> 01:29:30,570
પરંતુ, દેખીતી રીતે, મારા આદેશ
પોતે, હું શું મૂળ લખ્યો.

1780
01:29:30,570 --> 01:29:35,720
અને હું ફરીથી આ રમત રમી શકે છે
તે Stelios બદલવા, દાખલા તરીકે.

1781
01:29:35,720 --> 01:29:38,400
>> અને હવે હું બીજું નામ હજુ પણ જુઓ.

1782
01:29:38,400 --> 01:29:40,540
અને અહીં, હું Andi કહી શકે છે.

1783
01:29:40,540 --> 01:29:42,137
અને હું Zamyla કહી શકે છે.

1784
01:29:42,137 --> 01:29:45,220
અને અમે આ રમત બધા દિવસ સુધી રમી શકે છે,
માત્ર અલગ અલગ કિંમતો માં પ્લગ,

1785
01:29:45,220 --> 01:29:49,550
જેથી લાંબા સમય સુધી હું બરાબર પૂરી પાડે છે કારણ કે
પ્રોમ્પ્ટ પર બે શબ્દો,

1786
01:29:49,550 --> 01:29:52,260
જેમ કે argc, મારા દલીલ ગણતરી, 2 છે.

1787
01:29:52,260 --> 01:29:57,240
>> હું જોઈ નથી કે નામ જોડવામાં
printf માટે, આ સ્થિતિ અહીં પ્રતિ?

1788
01:29:57,240 --> 01:30:00,550
તેથી અમે હવે હોય એવું લાગે છે
અર્થસભર ક્ષમતા

1789
01:30:00,550 --> 01:30:04,410
અન્ય પદ્ધતિ ઇનપુટ લેવાના,
કહેવાતા આદેશ વાક્યમાંથી,

1790
01:30:04,410 --> 01:30:07,000
તેના બદલે રાહ કર્યા કરતાં
ત્યાં સુધી વપરાશકર્તા કાર્યક્રમ ચાલે છે,

1791
01:30:07,000 --> 01:30:10,220
અને પછી તેને અથવા તેણીને પૂછવા
ગેટ શબ્દમાળા કંઈક મદદથી.

1792
01:30:10,220 --> 01:30:11,230
>> તેથી આ શું છે?

1793
01:30:11,230 --> 01:30:15,010
Argc, ફરી, માત્ર એક પૂર્ણાંક છે,
words-- દલીલો સંખ્યા

1794
01:30:15,010 --> 01:30:18,540
કે પૂરી પાડવામાં વપરાશકર્તા
પ્રોમ્પ્ટ પર, ટર્મિનલ વિન્ડો પર,

1795
01:30:18,540 --> 01:30:20,110
કાર્યક્રમ નામ સમાવેશ થાય છે.

1796
01:30:20,110 --> 01:30:23,340
તેથી અમારા ./argv0, અસરકારક છે,
કાર્યક્રમ નામ,

1797
01:30:23,340 --> 01:30:24,520
કે કેવી રીતે હું કાર્યક્રમ ચાલે છે.

1798
01:30:24,520 --> 01:30:25,810
>> એક શબ્દ તરીકે ગણે છે.

1799
01:30:25,810 --> 01:30:27,080
તેથી argc 1 હશે.

1800
01:30:27,080 --> 01:30:29,750
પરંતુ જ્યારે હું Stelios લખો, અથવા
Andi, અથવા Zamyla, અથવા મારિયા,

1801
01:30:29,750 --> 01:30:31,660
તેનો અર્થ એ કે દલીલ ગણક બે છે.

1802
01:30:31,660 --> 01:30:33,910
અને તેથી હવે ત્યાં પસાર બે શબ્દો છે.

1803
01:30:33,910 --> 01:30:36,070
>> સૂચના, અમે આ તર્ક ચાલુ રાખી શકો છો.

1804
01:30:36,070 --> 01:30:39,050
જો હું ખરેખર કહેવું
ચાન કંઈક,

1805
01:30:39,050 --> 01:30:42,200
સંપૂર્ણ નામ, ત્યાં પસાર
કુલ ત્રણ દલીલો,

1806
01:30:42,200 --> 01:30:47,410
હવે તે મૂળભૂત ફરીથી કહે છે,
કારણ કે, અલબત્ત, 3 સમાન 2 કરે છે.

1807
01:30:47,410 --> 01:30:54,080
>> અને તેથી આ રીતે, હું હોય
argv આ નવી દલીલ દ્વારા એક્સેસ

1808
01:30:54,080 --> 01:30:56,080
કે અમે તકનીકી શકે
અમે માંગો કંઈપણ કૉલ કરો.

1809
01:30:56,080 --> 01:30:58,940
પરંતુ સંમેલન દ્વારા, તે
argv અને argc, અનુક્રમે.

1810
01:30:58,940 --> 01:31:04,470
Argv, દલીલ વેક્ટર, પ્રકારની છે
એક પ્રોગ્રામિંગ સમાનાર્થી ના

1811
01:31:04,470 --> 01:31:07,140
સી લક્ષણ ઝાકઝમાળ કહેવાય છે.

1812
01:31:07,140 --> 01:31:14,410
>> ઝાકઝમાળ સમાન કિંમતો યાદી છે
પાછળ, પાછળ, પાછળ પાછળ.

1813
01:31:14,410 --> 01:31:17,810
બીજા શબ્દોમાં કહીએ તો, જો એક અહીં છે
રેમ, આગામી એક અધિકાર આગામી છે,

1814
01:31:17,810 --> 01:31:18,800
અને તે અધિકાર આગામી.

1815
01:31:18,800 --> 01:31:20,101
તેઓ સ્થળ પર તમામ નથી.

1816
01:31:20,101 --> 01:31:23,100
અને બાદમાં દૃશ્ય, જ્યાં વસ્તુઓ
બધા મેમરી માં સ્થળ પર છે,

1817
01:31:23,100 --> 01:31:25,082
ખરેખર એક શક્તિશાળી લક્ષણ હોઈ શકે છે.

1818
01:31:25,082 --> 01:31:28,040
પરંતુ અમે જ્યારે અમે તે પાછા આવો પડશે
પારખુ માહિતી માળખાં વિશે વાત કરો.

1819
01:31:28,040 --> 01:31:32,260
હવે માટે, ઝાકઝમાળ માત્ર એક છે
સંલગ્ન મેમરી ચંકને

1820
01:31:32,260 --> 01:31:36,520
દરેક જેની તત્વો છે
પાછા પાછળ પાછળ પાછળ,

1821
01:31:36,520 --> 01:31:38,050
અને સામાન્ય રીતે એક જ પ્રકારના.

1822
01:31:38,050 --> 01:31:42,630
>> તેથી જો તમે વિશે વિચારો તો એક થી,
ક્ષણ પહેલા, એક શબ્દમાળા શું છે?

1823
01:31:42,630 --> 01:31:50,460
વેલ, એક શબ્દમાળા Zamyla જેમ,
Z-A-એમ-વાય-એલ-એ, ટેક્નિકલ, છે,

1824
01:31:50,460 --> 01:31:51,400
માત્ર એક એરે.

1825
01:31:51,400 --> 01:31:53,700
તે અક્ષરો ઝાકઝમાળ છે.

1826
01:31:53,700 --> 01:31:59,250
>> અને તેથી જો આપણે ખરેખર આ ડ્રો તરીકે હું
, મેમરી એક ભાગ તરીકે, અગાઉ કર્યું

1827
01:31:59,250 --> 01:32:04,510
તે આ દરેક બહાર વળે
અક્ષરો એક બાઈટ લે છે.

1828
01:32:04,510 --> 01:32:07,630
અને પછી ત્યાં છે કે જે ખાસ
સંત્રી પાત્ર, બેકસ્લેશ 0,

1829
01:32:07,630 --> 01:32:12,360
અથવા બધા આઠ 0 બિટ્સ, કે
કે જેઓ શબ્દમાળા ઓવરને demarcates.

1830
01:32:12,360 --> 01:32:15,090
તેથી શબ્દમાળા, તે કરે છે
બહાર, અવતરણ ચિહ્નો પૂરાં કરવાં શબ્દમાળા ઉદ્ધત,

1831
01:32:15,090 --> 01:32:20,580
માત્ર chara-- ઝાકઝમાળ છે
ઘરનાં પરચૂરણ કામો એક વાસ્તવિક માહિતી પ્રકાર છે.

1832
01:32:20,580 --> 01:32:24,560
>> અને હવે argv, meanwhile--
પાછા કાર્યક્રમ જવા દો.

1833
01:32:24,560 --> 01:32:29,582
Argv, તેમ છતાં અમે શબ્દ જુઓ
શબ્દમાળા અહીં, એક શબ્દમાળા પોતે નથી.

1834
01:32:29,582 --> 01:32:33,640
Argv, દલીલ વેક્ટર,
શબ્દમાળાઓ ઝાકઝમાળ છે.

1835
01:32:33,640 --> 01:32:37,620
>> તમે ઝાકઝમાળ હોઈ શકે છે જેમ
અક્ષરો, તમે ઊંચા સ્તર હોઈ શકે છે,

1836
01:32:37,620 --> 01:32:46,279
strings-- ઝાકઝમાળ તેથી, ઉદાહરણ તરીકે,
જ્યારે હું એક ક્ષણ પહેલા લખ્યો ./argv0

1837
01:32:46,279 --> 01:33:00,150
argv0, જગ્યા Z-A-એમ-વાય-એલ-એ, હું દાવો કર્યો હતો કે
argv, તેને ./argv0 બે શબ્દમાળાઓ હતી

1838
01:33:00,150 --> 01:33:03,185
અને Z એ એમ વાય એલ એ. માં
અન્ય શબ્દોમાં, argc 2 હતી.

1839
01:33:03,185 --> 01:33:03,980
શા માટે છે?

1840
01:33:03,980 --> 01:33:08,370
>> વેલ, અસરકારક રીતે, શું થઈ રહ્યું છે
પર છે આ શબ્દમાળાઓ દરેક કે

1841
01:33:08,370 --> 01:33:13,990
અલબત્ત, અક્ષરો ઝાકઝમાળ છે
પહેલાં, જેની દરેક અક્ષરો

1842
01:33:13,990 --> 01:33:15,670
એક બાઇટ અપ લે છે.

1843
01:33:15,670 --> 01:33:19,720
અને વાસ્તવિક 0 ગૂંચવવામાં ન શકું
0 કાર્યક્રમ નામ,

1844
01:33:19,720 --> 01:33:22,040
જે તમામ 80 બીટ્સ થાય છે.

1845
01:33:22,040 --> 01:33:27,140
અને Zamyla દરમિયાન, હજુ પણ છે
પણ અક્ષરો ઝાકઝમાળ.

1846
01:33:27,140 --> 01:33:31,450
>> દિવસ ઓવરને અંતે તેથી, તે ખરેખર
હૂડ નીચે આ જેવો દેખાય છે.

1847
01:33:31,450 --> 01:33:38,800
પરંતુ કેવી રીતે મુખ્ય argv, કુદરત દ્વારા
કામ કરે છે, મને આ બધી લપેટી માટે પરવાનગી આપે છે

1848
01:33:38,800 --> 01:33:44,810
જો તમે કરશે, એક મોટી એરે માં
કે, જો અમે સહેજ ઉપર સરળ

1849
01:33:44,810 --> 01:33:48,180
ચિત્ર જેવી અને નથી શું લાગે
તદ્દન ત્યાં આરોહણ કરવા માટે તે ડ્રો,

1850
01:33:48,180 --> 01:33:56,720
આ એરે, પ્રથમ માત્ર 2 કદ છે
તત્વ એક શબ્દમાળા સમાવે છે,

1851
01:33:56,720 --> 01:33:59,230
બીજા તત્વ
જે શબ્દમાળા સમાવે છે.

1852
01:33:59,230 --> 01:34:01,687
અને, બદલામાં, તમે જો
પ્રકારની દરેક પર ઝૂમ

1853
01:34:01,687 --> 01:34:03,770
તે શબ્દમાળાઓ, શું તમે
હૂડ નીચે જોવા

1854
01:34:03,770 --> 01:34:07,190
કે દરેક શબ્દમાળા માત્ર છે
અક્ષરો ઝાકઝમાળ.

1855
01:34:07,190 --> 01:34:11,680
>> હવે, માત્ર શબ્દમાળાઓ સાથે,
અમે ઍક્સેસ મેળવવા માટે સમર્થ હતા

1856
01:34:11,680 --> 01:34:15,260
એક શબ્દમાળા માં આઇ મી અક્ષર
કે ચોરસ કૌંસ સંકેતલિપિ ની મદદથી.

1857
01:34:15,260 --> 01:34:17,320
એ જ રીતે, એરે સાથે
સામાન્ય રીતે, અમે કરી શકો છો

1858
01:34:17,320 --> 01:34:22,700
ચોરસ કૌંસ નોટેશનમાં ઉપયોગ વિચાર
ઝાકઝમાળ શબ્દમાળાઓ કોઈપણ નંબર પર?

1859
01:34:22,700 --> 01:34:25,100
દાખલા તરીકે, મને દો
આગળ વધો અને આ કરવા.

1860
01:34:25,100 --> 01:34:32,420
>> મને આગળ વધો અને argv1.c બનાવીએ,
જે થોડી અલગ આ સમય છે.

1861
01:34:32,420 --> 01:34:35,635
તેના બદલે argc2 માટે ચકાસણી,
હું બદલે આ કરવા માટે જઇ રહ્યો છું.

1862
01:34:35,635 --> 01:34:41,270
પૂર્ણાંક હું 0 વિચાર માટે, હું ઓછી છે
argc કરતાં, હું વત્તા વત્તા,

1863
01:34:41,270 --> 01:34:47,920
અને પછી આ ની અંદર બહાર છાપો,
ટકા ઓ, નવી લાઇન, અને પછી

1864
01:34:47,920 --> 01:34:50,740
argv કૌંસ હું.

1865
01:34:50,740 --> 01:34:55,220
>> તેથી અન્ય શબ્દોમાં, હું સાથે વ્યવહાર છું
ક્ષણ પર વ્યક્તિગત અક્ષરો.

1866
01:34:55,220 --> 01:35:00,190
Argv, કારણ કે આ ખાલી સ્ક્વેર દ્વારા સૂચિત
નામ argv જમણી કૌંસ,

1867
01:35:00,190 --> 01:35:03,320
argv શબ્દમાળાઓ ઝાકઝમાળ છે એનો અર્થ એ થાય.

1868
01:35:03,320 --> 01:35:04,870
અને argc માત્ર પૂર્ણાંક છે.

1869
01:35:04,870 --> 01:35:08,800
>> અહીં આ વાક્ય, 6, છે
સમૂહ કહે છે કે હું 0 સમાન.

1870
01:35:08,800 --> 01:35:11,980
બધી રીતે ગણક,
પરંતુ argc સમાવેશ થાય છે.

1871
01:35:11,980 --> 01:35:14,010
અને પછી દરેક ઇટરેશન પર,
શબ્દમાળા છાપી શકે છે.

1872
01:35:14,010 --> 01:35:14,800
શું શબ્દમાળા?

1873
01:35:14,800 --> 01:35:17,270
>> argv આઇ મી શબ્દમાળા.

1874
01:35:17,270 --> 01:35:19,530
તેથી જ્યારે તે પહેલાં હું હતી
ચોરસ કૌંસ મદદથી

1875
01:35:19,530 --> 01:35:22,180
સંકેત ઇથ પર વિચાર
એક શબ્દમાળા માં પાત્ર, હવે

1876
01:35:22,180 --> 01:35:27,240
હું ચોરસ કૌંસ નોટેશનમાં ઉપયોગ કરું છું
ઝાકઝમાળ ઇથ શબ્દમાળા મેળવવા માટે.

1877
01:35:27,240 --> 01:35:30,310
તેથી તે એક સ્તર પ્રકારની છે
ઉપર, સરળ.

1878
01:35:30,310 --> 01:35:35,390
>> અને તેથી આ વિશે સુઘડ છે
હવે કાર્યક્રમ, જો હું argv1 કમ્પાઇલ,

1879
01:35:35,390 --> 01:35:42,067
અને પછી ./argv1 કરવા માટે, અને પછી લખો
foo બાર બાઝ કંઈક,

1880
01:35:42,067 --> 01:35:45,400
જે ત્રણ મૂળભૂત શબ્દો છે કે જે છે
કોમ્પ્યુટર વૈજ્ઞાનિક કોઈપણ સમયે માટે પહોંચે છે

1881
01:35:45,400 --> 01:35:51,010
તે અથવા તેણી કેટલીક પ્લેસહોલ્ડર શબ્દો જરૂર છે,
અને Enter દબાવો, તે શબ્દો દરેક

1882
01:35:51,010 --> 01:35:54,980
કાર્યક્રમ નામ, સહિત જે
પ્રથમ સ્થાન પર argv છે,

1883
01:35:54,980 --> 01:35:58,320
અંત થાય છે એક સમયે એક મુદ્રિત કરવામાં આવી.

1884
01:35:58,320 --> 01:36:05,290
અને જો હું આ બદલવા માટે, અને હું કહી
argv1 ચાન કંઈક,

1885
01:36:05,290 --> 01:36:08,800
અમે તે બધા ત્રણ વિચાર
શબ્દો છે, જે argv0 છે,

1886
01:36:08,800 --> 01:36:14,400
argv1, argv2, આ કારણ કે
કેસ argc, ગણતરી, 3 છે.

1887
01:36:14,400 --> 01:36:20,020
>> પરંતુ શું સુઘડ છે જો તમે સમજો
કે argv, માત્ર શબ્દમાળાઓ ઝાકઝમાળ છે

1888
01:36:20,020 --> 01:36:24,910
અને તમે એક શબ્દમાળા કે સમજવા
અક્ષરો ઝાકઝમાળ છે,

1889
01:36:24,910 --> 01:36:29,470
અમે ખરેખર પ્રકારની ઉપયોગ કરી શકો છો
ચોરસ કૌંસ નોટેશનમાં ઘણી વખત

1890
01:36:29,470 --> 01:36:33,320
શબ્દમાળા પસંદ કરો, અને પછી પસંદ કરો
શબ્દમાળા અંદર એક પાત્ર,

1891
01:36:33,320 --> 01:36:35,730
નીચે ઊંડા તરીકે ડ્રાઇવીંગ.

1892
01:36:35,730 --> 01:36:40,100
આ ઉદાહરણમાં, મને જવા દો
આગળ અને આ argv2.c કૉલ કરો.

1893
01:36:40,100 --> 01:36:43,920

1894
01:36:43,920 --> 01:36:50,180
અને આ ઉદાહરણ માં, દો મને આગળ વધો
અને પૂર્ણાંક હું 0 વિચાર નીચેના કરવું,

1895
01:36:50,180 --> 01:36:53,286
હું argc કરતાં ઓછી છે, હું વત્તા
પ્લસ, પહેલાંની જેમ.

1896
01:36:53,286 --> 01:36:55,910
તેથી અન્ય words-- અને હવે આ
પૂરતી જટિલ રહ્યો છે.

1897
01:36:55,910 --> 01:36:59,940
પછી હું કહેવા જાઉં છું
argv શબ્દમાળાઓ પર ફરી વળવું,

1898
01:36:59,940 --> 01:37:01,294
મને પોતાને એક ટિપ્પણી તરીકે.

1899
01:37:01,294 --> 01:37:03,960
અને પછી હું એક હોય જાઉં છું
લૂપ માટે નેસ્ટ, તો તમે કદાચ જે

1900
01:37:03,960 --> 01:37:06,290
થાય છે, અથવા ગણવામાં
જ્યાં કરી સ્ક્રેચ માં,

1901
01:37:06,290 --> 01:37:08,600
હું કહે છે ઈન્ હું જાઉં છું
હું ફરીથી ઉપયોગ કરવા માટે નથી જતા,

1902
01:37:08,600 --> 01:37:12,590
કારણ કે હું છાયા કરવા માંગો છો નથી, અથવા
સૉર્ટ વર્તમાન હું ફરીથી લખી.

1903
01:37:12,590 --> 01:37:15,780
>> હું, તેના બદલે, જે કહે છે જઇ રહ્યો છું, કારણ કે
કે હું પછી ચલ મારા જાઓ,

1904
01:37:15,780 --> 01:37:18,590
જ્યારે હું માત્ર પ્રયાસ કરી રહ્યો છું
સરળ નંબરો ગણક.

1905
01:37:18,590 --> 01:37:28,850
J મળે 0 છે અને એ પણ, એ, રહ્યું છે
, Argv કૌંસ હું કડક લંબાઈ વિચાર

1906
01:37:28,850 --> 01:37:36,030
તેથી લાંબા તરીકે જ એમ કરતાં ઓછી છે,
J વત્તા વત્તા, નીચે પ્રમાણે કરો.

1907
01:37:36,030 --> 01:37:37,500
અને અહીં રસપ્રદ ભાગ છે.

1908
01:37:37,500 --> 01:37:46,330
>> એક અક્ષર અને એક નવી લાઇન છાપો,
argv કૌંસ હું, કૌંસ જે માં પ્લગ.

1909
01:37:46,330 --> 01:37:47,940
ઠીક છે, તેથી મને અહીં કેટલાક ટિપ્પણીઓ ઉમેરો.

1910
01:37:47,940 --> 01:37:54,820
અક્ષરો પર ફરી વળવું
વર્તમાન શબ્દમાળા માં,

1911
01:37:54,820 --> 01:38:02,290
આઇ મી શબ્દમાળા માં પ્રિન્ટ J મી પાત્ર.

1912
01:38:02,290 --> 01:38:04,630
તેથી હવે, ચાલો
આ ટિપ્પણીઓને શું અર્થ થાય.

1913
01:38:04,630 --> 01:38:06,750
>> શબ્દમાળાઓ પર ફરી વળવું
argv-- કેટલા

1914
01:38:06,750 --> 01:38:09,300
શબ્દમાળાઓ argv છે, કે જે એરે છે?

1915
01:38:09,300 --> 01:38:13,420
Argc ઘણા છે, તેથી હું વારો છું
હું સમાન 0 argc સુધી.

1916
01:38:13,420 --> 01:38:20,020
દરમિયાન, કેટલા અક્ષરો
argv આઇ મી શબ્દમાળા છે?

1917
01:38:20,020 --> 01:38:22,880
>> ઠીક છે, કે જવાબ મેળવવા માટે,
હું માત્ર શબ્દમાળા લંબાઈ કૉલ

1918
01:38:22,880 --> 01:38:26,810
વર્તમાન શબ્દમાળા હું સંભાળ
વિશે, જે argv કૌંસ હું છે.

1919
01:38:26,810 --> 01:38:30,090
અને હું કામચલાઉ સંગ્રહ કરવા માટે કે જઇ રહ્યો છું
કિંમત n એ, માત્ર કેશીંગ હેતુઓ માટે,

1920
01:38:30,090 --> 01:38:31,590
કાર્યક્ષમતા માટે તેને યાદ છે.

1921
01:38:31,590 --> 01:38:36,330
અને પછી હું 0 જોહાન પ્રારંભ જાઉં છું,
જેથી લાંબા રહ્યું j તરીકે એન કરતા ઓછો રાખવા,

1922
01:38:36,330 --> 01:38:38,430
અને દરેક ઇટરેશન ઈજાફો જોહાન પર.

1923
01:38:38,430 --> 01:38:41,030
>> અને પછી અહીં, દર
12 લીટી પર મારી ટિપ્પણી,

1924
01:38:41,030 --> 01:38:43,390
એક અક્ષર છાપો,
એક નવી લાઇન દ્વારા અનુસરવામાં,

1925
01:38:43,390 --> 01:38:48,140
ખાસ argv કૌંસ
હું મને આઇ મી શબ્દમાળા આપે છે

1926
01:38:48,140 --> 01:38:51,690
argv-- તેથી પ્રથમ શબ્દ છે,
બીજા શબ્દ, ત્રીજા શબ્દ, ગમે.

1927
01:38:51,690 --> 01:38:57,370
અને પછી ઊંડા જોહાન થીજેલા, અને નહીં
મને કે શબ્દ J મી પાત્ર.

1928
01:38:57,370 --> 01:39:02,200
અને તેથી, અસર, તમે સારવાર કરી શકે છે
argv બહુ આયામી તરીકે,

1929
01:39:02,200 --> 01:39:06,050
બે પરિમાણીય એરે તરીકે,
જેમાં દેખાવ દરેક શબ્દ પ્રકારની

1930
01:39:06,050 --> 01:39:08,580
તમારા મન માં આ જેમ
આંખ, અને દરેક પાત્ર

1931
01:39:08,580 --> 01:39:10,930
પ્રકારની માં બનેલો છે
એક કૉલમ, જો કે મદદ કરે છે.

1932
01:39:10,930 --> 01:39:13,260
>> વાસ્તવમાં, અમે જ્યારે પીંજવું
ભવિષ્યમાં અઠવાડિયામાં આ સિવાય,

1933
01:39:13,260 --> 01:39:15,580
તે થોડી હોઈ ચાલે છે
કરતાં વધુ આધુનિક.

1934
01:39:15,580 --> 01:39:17,800
પરંતુ તમે ખરેખર આ કરી શકો છો
કે લાગે છે, હવે માટે,

1935
01:39:17,800 --> 01:39:22,110
ફક્ત આ બે પરિમાણીય તરીકે
અરે, જેમાં તે એક સ્તર

1936
01:39:22,110 --> 01:39:23,260
શબ્દમાળાઓ તમામ છે.

1937
01:39:23,260 --> 01:39:26,760
અને પછી તમે ઊંડા, તમે ડાઇવ જો
વ્યક્તિગત અક્ષરો પર વિચાર કરી શકે

1938
01:39:26,760 --> 01:39:29,600
અહીં આ સંકેતલિપિ ની મદદથી દ્વારા તેમાં.

1939
01:39:29,600 --> 01:39:31,620
>> તેથી આ પ્રક્રિયાની ચોખ્ખી અસર શું છે?

1940
01:39:31,620 --> 01:39:34,970
મને આગળ જવા દો અને
argv2-- રફૂ કરવું તે બનાવે છે.

1941
01:39:34,970 --> 01:39:36,210
હું એક ભૂલ અહીં કરી હતી.

1942
01:39:36,210 --> 01:39:40,160
સર્વથા જાહેર
પુસ્તકાલય કાર્ય સ્ટર્લિંગ.

1943
01:39:40,160 --> 01:39:42,190
તેથી આ બધા સમય, તે
કદાચ યોગ્ય

1944
01:39:42,190 --> 01:39:45,130
અમે પ્રકારના અંતિમ રહ્યાં છે કે
બરાબર જ્યાં અમે શરૂ કર્યું.

1945
01:39:45,130 --> 01:39:48,160
>> હું ખરાબ છે, સર્વથા જાહેર
પુસ્તકાલય કાર્ય સ્ટર્લિંગ.

1946
01:39:48,160 --> 01:39:48,987
ઠીક છે, એક મિનિટ રાહ જુઓ.

1947
01:39:48,987 --> 01:39:51,070
હું યાદ રાખો કે, ખાસ કરીને
કારણ કે તે અહીં છે.

1948
01:39:51,070 --> 01:39:54,490
હું string.h સમાવેશ કરવાની જરૂર
કાર્યક્રમ આ આવૃત્તિ.

1949
01:39:54,490 --> 01:40:00,050
>> મને આગળ વધો અને સમાવેશ થાય છે દો
string.h, કે સેવ, આગળ વધો

1950
01:40:00,050 --> 01:40:04,460
અને argv2 પુનઃકમ્પાઈલ.

1951
01:40:04,460 --> 01:40:08,390
અને હવે, અહીં અમે જાઓ, argv2 બનાવવા માટે, દાખલ કરો.

1952
01:40:08,390 --> 01:40:10,590
અને તેમ છતાં તે થોડો છે
પ્રથમ નજરમાં ભેદી,

1953
01:40:10,590 --> 01:40:15,690
નોંધ્યું છે કે, ખરેખર, શું
છપાયેલી હોય છે ટપકું argv2 છે.

1954
01:40:15,690 --> 01:40:19,970
>> પરંતુ જો હું પછી કેટલાક શબ્દો લખો
પ્રોમ્પ્ટ પર, argv2 ચાન જેમ,

1955
01:40:19,970 --> 01:40:22,560
દાખલ કરો, પણ થોડી
પ્રથમ નજરમાં છુપાયેલું.

1956
01:40:22,560 --> 01:40:30,540
પરંતુ જો આપણે પાછા સ્ક્રોલ,
./argv2 Z-A-એમ-વાય-એલ સી એચ-A-એન.

1957
01:40:30,540 --> 01:40:32,190
તેથી અમે દરેક શબ્દ પર iterated છે.

1958
01:40:32,190 --> 01:40:37,770
અને, વળાંક, અમે ઉપર iterated છે
એક શબ્દ અંદર દરેક પાત્ર.

1959
01:40:37,770 --> 01:40:40,040
>> હવે, આ તમામ કર્યા પછી,
ખ્યાલ છે કે ત્યાં

1960
01:40:40,040 --> 01:40:43,120
એક અન્ય વિગત અમે પ્રકારની કરવામાં આવી છે
આ સમગ્ર સમય ઉપેક્ષા કરે છે.

1961
01:40:43,120 --> 01:40:46,180
અમે હમણાં જ સિવાય પરેશાન કરતું શું
મુખ્ય ઇનપુટ્સ હોઈ શકે છે?

1962
01:40:46,180 --> 01:40:47,780
શું મુખ્ય આઉટપુટ વિશે શું?

1963
01:40:47,780 --> 01:40:50,540
>> આ સમયે બધા, અમે થયા છો
માત્ર કૉપિ અને પેસ્ટ

1964
01:40:50,540 --> 01:40:53,870
મુખ્ય સામે શબ્દ પૂર્ણાંક,
તમે ઑનલાઇન જોઈ શકો છો તેમ છતાં,

1965
01:40:53,870 --> 01:40:58,340
ક્યારેક જૂની આવૃત્તિઓ માં ખોટી રીતે
સી અને કમ્પાઇલરોનો, તેઓ રદબાતલ કહે છે કે,

1966
01:40:58,340 --> 01:40:59,410
અથવા બધા કંઈ નથી.

1967
01:40:59,410 --> 01:41:01,580
પરંતુ, ખરેખર, આવૃત્તિ માટે
સી અમે ઉપયોગ કરી રહ્યાં છો કે,

1968
01:41:01,580 --> 01:41:06,180
સી 11, અથવા 2011, ખ્યાલ
કે તે પૂર્ણાંક પ્રયત્ન કરીશું.

1969
01:41:06,180 --> 01:41:09,300
અને તે ક્યાં તો પ્રયત્ન કરીશું
રદબાતલ અથવા argc અને અહીં argv.

1970
01:41:09,300 --> 01:41:10,790
>> પરંતુ શા માટે પૂર્ણાંક મુખ્ય?

1971
01:41:10,790 --> 01:41:12,480
તે ખરેખર શું પરત આવે છે?

1972
01:41:12,480 --> 01:41:16,280
વેલ, તે આ સમયે બધા બહાર વળે છે,
કોઈપણ સમયે તમે એક કાર્યક્રમ મુખ્ય તેવા પરચૂરણ ખર્ચ કર્યો

1973
01:41:16,280 --> 01:41:18,440
હંમેશા કંઈક પરત આવે છે.

1974
01:41:18,440 --> 01:41:19,960
પરંતુ તે ગુપ્ત કરી દેવામાં આવી છે.

1975
01:41:19,960 --> 01:41:23,350
>> એક કે કંઈક છે
પૂર્ણાંક, રેખા તરીકે 5 સૂચવે છે.

1976
01:41:23,350 --> 01:41:24,225
પરંતુ શું પૂર્ણાંક?

1977
01:41:24,225 --> 01:41:26,100
વેલ, આ છે
પ્રોગ્રામિંગ સંમેલન,

1978
01:41:26,100 --> 01:41:29,790
જેમાં જો કંઈ નથી
ખોટું ગયો અને બધા સારી છે,

1979
01:41:29,790 --> 01:41:34,250
કાર્યક્રમો અને કાર્યો સામાન્ય
return-- અંશે counterintuitively--

1980
01:41:34,250 --> 01:41:35,230
0.

1981
01:41:35,230 --> 01:41:38,070
0 સામાન્ય રીતે તમામ સારી છે દર્શાવે છે.

1982
01:41:38,070 --> 01:41:40,610
તેથી ભલે તમે વિચાર
તે ઘણા બધા સંદર્ભમાં ખોટી,

1983
01:41:40,610 --> 01:41:42,930
ખરેખર તો સામાન્યતઃ તે એક સારી બાબત અર્થ એ થાય

1984
01:41:42,930 --> 01:41:49,560
>> દરમિયાન, જો કાર્યક્રમ આપે છે 1,
નકારાત્મક 1, અથવા 5, અથવા નકારાત્મક 42,

1985
01:41:49,560 --> 01:41:52,941
અથવા કોઈપણ બિન કિંમત 0,
જે સામાન્ય રીતે નોંધે

1986
01:41:52,941 --> 01:41:54,190
કે કંઈક ખોટું થયું છે.

1987
01:41:54,190 --> 01:41:56,700
હકીકતમાં, તમારા પોતાના મેક કે પીસી પર,
તમે ખરેખર જોઈ હોય શકે

1988
01:41:56,700 --> 01:42:01,050
ભૂલ સંદેશો છે, જેમાં તે
કંઈક કહે છે અથવા અન્ય, ભૂલ

1989
01:42:01,050 --> 01:42:04,940
કોડ નકારાત્મક 42, અથવા ભૂલ કોડ
23, અથવા કંઈક કે જેમ.

1990
01:42:04,940 --> 01:42:08,980
કે જે નંબર સામાન્ય રીતે માત્ર એક સંકેત છે
પ્રોગ્રામર, અથવા કંપની માટે

1991
01:42:08,980 --> 01:42:11,174
કે સોફ્ટવેર,
શું ખોટું છે અને શા માટે ગયા

1992
01:42:11,174 --> 01:42:13,590
જેથી તેઓ મારફતે જોવા કરી શકો છો
તેમના દસ્તાવેજો અથવા કોડ છે,

1993
01:42:13,590 --> 01:42:15,465
અને બહાર આકૃતિ શું
ભૂલ ખરેખર થાય છે.

1994
01:42:15,465 --> 01:42:18,400
તે સામાન્ય રીતે નથી
અમને ઉપયોગી વપરાશકર્તાઓ અંત.

1995
01:42:18,400 --> 01:42:20,550
>> પરંતુ મુખ્ય વળતર 0, બધા સારી છે જ્યારે.

1996
01:42:20,550 --> 01:42:23,770
અને જો તમે સ્પષ્ટ કરો નહિં
મુખ્ય પાછા જોઈએ શું

1997
01:42:23,770 --> 01:42:26,950
તે માત્ર આપોઆપ ચાલશે
તમે 0 પરત.

1998
01:42:26,950 --> 01:42:30,870
પરંતુ કંઈક પરત
બીજું ખરેખર ઉપયોગી છે.

1999
01:42:30,870 --> 01:42:34,660
>> આ અંતિમ કાર્યક્રમ માં, મને દો
આગળ વધો અને આ exit.c કૉલ,

2000
01:42:34,660 --> 01:42:38,630
અને આજે છેલ્લા દાખલ
વિષયો, ભૂલ કોડ તરીકે ઓળખાય છે.

2001
01:42:38,630 --> 01:42:42,930
મને આગળ વધો અને સમાવેશ થાય છે એ આપણી
પરિચિત ફાઈલો ટોચ, પૂર્ણાંક મુખ્ય નથી.

2002
01:42:42,930 --> 01:42:49,500
અને આ સમય, ચાલો પૂર્ણાંક argc કરવા દો
શબ્દમાળા argv, અને મારા કૌંસ સાથે

2003
01:42:49,500 --> 01:42:50,836
સૂચિત કરે છે કે તે એરે માં છે.

2004
01:42:50,836 --> 01:42:52,460
અને પછી મને માત્ર એક સેનીટી ચેક કરવા દો.

2005
01:42:52,460 --> 01:42:56,640
આ સમય, જો argc નથી
સમાન 2, પછી તમે શું જાણો છો?

2006
01:42:56,640 --> 01:42:57,520
તે ભૂલી જાવ.

2007
01:42:57,520 --> 01:43:03,170
હું કહે છે કે જાઉં છું, અરે, વપરાશકર્તા,
તમે આદેશ વાક્ય દલીલ ખૂટે છે

2008
01:43:03,170 --> 01:43:04,210
બેકસ્લેશ n એ.

2009
01:43:04,210 --> 01:43:05,230
>> અને પછી તે છે.

2010
01:43:05,230 --> 01:43:06,130
હું બહાર નીકળવા માંગો છો.

2011
01:43:06,130 --> 01:43:11,030
હું preemptively કરવા જઈ રહ્યો છું,
અને અકાળે ખરેખર વળતર

2012
01:43:11,030 --> 01:43:12,810
કંઈક નંબર 1 કરતાં અન્ય.

2013
01:43:12,810 --> 01:43:15,360
પ્રથમ કિંમત પર જાઓ
ભૂલ થઇ શકે છે કે 1 છે.

2014
01:43:15,360 --> 01:43:17,860
તમે કેટલાક અન્ય ભૂલભરેલા હોય તો
પરિસ્થિતિ કે જે ઉદ્દભવી શકે છે,

2015
01:43:17,860 --> 01:43:21,390
તમે વળતર 2 કહે છે કે 3 પાછા શકે છે, અથવા
કદાચ નકારાત્મક 1 અથવા નકારાત્મક 2.

2016
01:43:21,390 --> 01:43:23,750
>> આ માત્ર બહાર નીકળો કોડ છે
છે, સામાન્ય રીતે,

2017
01:43:23,750 --> 01:43:27,770
માત્ર પ્રોગ્રામર માટે ઉપયોગી છે, અથવા
કંપની કે સોફ્ટવેર શીપીંગ છે.

2018
01:43:27,770 --> 01:43:30,500
પરંતુ હકીકત એ છે કે તે છે
0 નથી શું મહત્વનું છે.

2019
01:43:30,500 --> 01:43:34,310
તેથી આ કાર્યક્રમ તો, હું કરવા માંગો છો
ખાતરી આપી છે કે આ કાર્યક્રમ માત્ર

2020
01:43:34,310 --> 01:43:38,190
કામ કરે છે જો વપરાશકર્તા મને પૂરી પાડે છે
બે એક દલીલ ગણતરી સાથે,

2021
01:43:38,190 --> 01:43:42,880
કાર્યક્રમ નામ છે, અને કેટલાક અન્ય
શબ્દ, હું નીચે તેટલી દબાણ કરી શકો છો,

2022
01:43:42,880 --> 01:43:46,110
printf કહેવત સાથે વપરાશકર્તા અંતે કિકિયારી,
ગુમ આદેશ વાક્ય દલીલ,

2023
01:43:46,110 --> 01:43:46,970
1 આવો.

2024
01:43:46,970 --> 01:43:49,940
કે જે હમણાં જ તરત જ ચાલશે
કાર્યક્રમ છોડી દીધું.

2025
01:43:49,940 --> 01:43:55,840
>> માત્ર જો argc બરાબર 2 અમે નીચે મળશે
અહીં, જે બિંદુએ હું કહેવા જાઉં છું,

2026
01:43:55,840 --> 01:44:00,410
હેલો ટકા ઓ, બેકસ્લેશ n એ, argv1.

2027
01:44:00,410 --> 01:44:03,827
અન્ય શબ્દોમાં, હું છું
argv 0 પછી ન જવું,

2028
01:44:03,827 --> 01:44:05,410
જે ફક્ત કાર્યક્રમ નામ છે.

2029
01:44:05,410 --> 01:44:09,450
હું છાપે હેલો, અલ્પવિરામ માંગો છો,
બીજા શબ્દ હોય કે જેને માનવ લખ્યો.

2030
01:44:09,450 --> 01:44:12,580
અને આ કિસ્સામાં
રેખા 13, બધા સારી છે.

2031
01:44:12,580 --> 01:44:15,920
>> મને ખબર છે કે argc 2 છે
તાર્કિક આ કાર્યક્રમ.

2032
01:44:15,920 --> 01:44:17,770
હું આગળ જાઓ અને 0 પાછા જઈ રહ્યો છું.

2033
01:44:17,770 --> 01:44:21,230
એક કોરે તરીકે, ધ્યાનમાં રાખો કે
આ જ રીતે સ્ક્રેચ માં સાચું છે.

2034
01:44:21,230 --> 01:44:24,760
>> તાર્કિક રીતે, હું આ કરી શકે
અને આ રેખાઓ સમાવતા

2035
01:44:24,760 --> 01:44:27,020
આ બીજા અહીં કલમ કોડ.

2036
01:44:27,020 --> 01:44:29,420
પરંતુ તે પ્રકારની છે
બિનજરૂરી મારી કોડ માંગયાદી.

2037
01:44:29,420 --> 01:44:31,800
અને હું સુપર બનાવવા માંગો છો
સ્પષ્ટ છે કે કોઈ બાબત શું,

2038
01:44:31,800 --> 01:44:34,670
મૂળભૂત રીતે, હેલો
કંઈક મુદ્રિત કરવામાં આવશે,

2039
01:44:34,670 --> 01:44:36,050
જેથી લાંબા વપરાશકર્તા સહકાર છે.

2040
01:44:36,050 --> 01:44:39,360
>> તેથી તે વાપરવા માટે ખૂબ જ સામાન્ય છે
એક શરત છે, માત્ર એક તો,

2041
01:44:39,360 --> 01:44:41,870
કેટલાક ભૂલભરેલા પકડી
પરિસ્થિતિ, અને પછી બહાર નીકળો.

2042
01:44:41,870 --> 01:44:45,690
અને પછી, જેથી લાંબા બધા છે
વેલ, એક બીજા નથી,

2043
01:44:45,690 --> 01:44:48,060
પરંતુ માત્ર કોડ છે
કે બહાર, તો તે છે, કારણ કે

2044
01:44:48,060 --> 01:44:51,060
આ સમકક્ષ
ખાસ કિસ્સામાં, તાર્કિક.

2045
01:44:51,060 --> 01:44:54,480
તેથી હું 0 પરત કરું છું, માત્ર
બાહ્ય અર્થ બધા સારી છે.

2046
01:44:54,480 --> 01:44:58,480
>> જો હું વળતર 0 અવગણવામાં, તે કરશે
આપોઆપ મારા માટે ધારણ કરવામાં આવે છે.

2047
01:44:58,480 --> 01:45:00,890
પરંતુ હવે હું પરત છું
ઓછામાં ઓછા આ કિસ્સામાં એક

2048
01:45:00,890 --> 01:45:04,940
હું જાઉં છું, સારા પગલા માટે અને
સ્પષ્ટતા, આ કિસ્સામાં 0 આવો.

2049
01:45:04,940 --> 01:45:09,690
તેથી હવે દો મને આગળ વધો અને બહાર નીકળો બનાવવા દો,
જે સંપૂર્ણ જીતે માત્ર છોડી છે.

2050
01:45:09,690 --> 01:45:14,401
>> પરંતુ બહાર નીકળો બનાવે છે, અને મને જવા દો
આગળ અને ./exit કરવા માટે, દાખલ કરો.

2051
01:45:14,401 --> 01:45:16,900
અને કાર્યક્રમ મને અંતે yelled,
ગુમ આદેશ વાક્ય દલીલ.

2052
01:45:16,900 --> 01:45:18,120
ઠીક છે, મને સહકાર દો.

2053
01:45:18,120 --> 01:45:23,810
>> દો મને બદલે ./exit કરવા, ડેવિડ, દાખલ કરો.

2054
01:45:23,810 --> 01:45:25,190
અને હવે તે કહે છે, ડેવિડ હેલો.

2055
01:45:25,190 --> 01:45:27,300
અને તમે સામાન્ય રીતે આ ન જોઈ શકે છે.

2056
01:45:27,300 --> 01:45:30,650
>> પરંતુ તે તારણ છે કે એક છે કે
Linux માં ખાસ રીતે ખરેખર જોવા માટે

2057
01:45:30,650 --> 01:45:34,470
શું બહાર નીકળો કોડ સાથે એક કાર્યક્રમ બહાર.

2058
01:45:34,470 --> 01:45:37,184
ગ્રાફિકલ ક્યારેક
મેક ઓએસ અથવા Windows જેવા વિશ્વના,

2059
01:45:37,184 --> 01:45:40,100
તમે માત્ર આ નંબરો જ્યારે જોવા
ભૂલ સંદેશો સ્ક્રીન પર પૉપ અપ

2060
01:45:40,100 --> 01:45:41,940
અને પ્રોગ્રામર
તમે તે સંખ્યા બતાવે છે.

2061
01:45:41,940 --> 01:45:44,773
પરંતુ અમે શું ભૂલ જોવા માંગો છો, તો
સંદેશ છે, અમે તેને અહીં કરી શકો છો

2062
01:45:44,773 --> 01:45:48,100
જેથી ./exit, દાખલ કરો, પ્રિન્ટ
ગુમ આદેશ વાક્ય દલીલ.

2063
01:45:48,100 --> 01:45:54,590
>> હવે હું પડઘો $ ?, શું છે, તો જે છે
હાસ્યજનક રીતે ભેદી શોધી.

2064
01:45:54,590 --> 01:45:56,590
પરંતુ $?

2065
01:45:56,590 --> 01:45:59,220
જાદુઈ મંત્ર છે
કહે છે કે, અરે, કોમ્પ્યુટર,

2066
01:45:59,220 --> 01:46:01,900
મને કહો અગાઉના
કાર્યક્રમ બહાર નીકળો કોડ હતો.

2067
01:46:01,900 --> 01:46:03,410
અને હું Enter દબાવો.

2068
01:46:03,410 --> 01:46:07,520
હું 1 જુઓ, કે જે છે, કારણ કે હું શું
પાછા મારી મુખ્ય કાર્ય હતું.

2069
01:46:07,520 --> 01:46:12,310
>> દરમિયાન, જો હું ./exit ડેવિડ કરવા માટે,
અને હિટ દાખલ કરો, હું જુઓ, ડેવિડ હેલો.

2070
01:46:12,310 --> 01:46:16,800
અને જો હું હવે પડઘો $ કરવા ?, હું હેલ્લો 0 જુઓ.

2071
01:46:16,800 --> 01:46:19,080
અને તેથી આ ખરેખર ચાલશે
મૂલ્યવાન માહિતી બની શકે

2072
01:46:19,080 --> 01:46:23,420
ડીબગર સંદર્ભમાં, તેથી નથી
જ કે તમે, માનવ, કાળજી કરશે.

2073
01:46:23,420 --> 01:46:26,060
પરંતુ ડીબગર અને અન્ય
કાર્યક્રમો અમે આ સત્ર ઉપયોગ કરશો

2074
01:46:26,060 --> 01:46:29,420
ઘણીવાર તે નંબર પર જોવા મળશે,
છતાં પણ તે પ્રકારના દૂર છુપાયેલા છે

2075
01:46:29,420 --> 01:46:32,780
જ્યાં સુધી તમે તે માટે, જોવા માટે
નક્કી કરો કે શું નથી અથવા કાર્યક્રમ

2076
01:46:32,780 --> 01:46:37,050
અમલ યોગ્ય અથવા અયોગ્ય હતી.

2077
01:46:37,050 --> 01:46:40,450
>> અને જેથી અમને લાવે
આ દિવસ ઓવરને અંતે.

2078
01:46:40,450 --> 01:46:43,917
અમે જોઈ દ્વારા આજે પ્રારંભ
ડિબગીંગ, અને કોર્સ ખાતે વળાંક

2079
01:46:43,917 --> 01:46:46,750
પોતે, અને પછી વધુ રસપ્રદ વાત એ છે
તકનીકી હૂડ નીચે

2080
01:46:46,750 --> 01:46:49,490
શું શબ્દમાળાઓ છે, જે ગયા
સપ્તાહ અમે માત્ર મંજૂર લીધો,

2081
01:46:49,490 --> 01:46:51,900
અને ચોક્કસપણે તેમને લીધો
માટે સ્ક્રેચ માં આપી હતી.

2082
01:46:51,900 --> 01:46:56,040
>> અમે પછી અમે કેવી રીતે ઍક્સેસ કરી શકો છો પર જોવામાં
એક શબ્દમાળા માં વ્યક્તિગત અક્ષરો,

2083
01:46:56,040 --> 01:47:00,310
અને પછી ફરીથી એક ઉચ્ચ સ્તર લીધો
, વસ્તુઓ જોવા પરિચિત હોઈ શકે છે કેવી રીતે જોઈ

2084
01:47:00,310 --> 01:47:04,226
અમે વ્યક્તિગત પર વિચાર કરવા માંગો છો, તો
જેવું માળખું યાદીમાં તત્વો,

2085
01:47:04,226 --> 01:47:05,850
અમે કે જે ઘણાબધા શબ્દમાળાઓ સાથે ન કરી શકો?

2086
01:47:05,850 --> 01:47:08,050
અને અમે આદેશ વાક્ય દલીલો સાથે કરી શકો છો.

2087
01:47:08,050 --> 01:47:12,800
પરંતુ આ ચિત્ર માત્ર બોક્સ અહીં
આ સામાન્ય વિચાર પ્રતિપાદક છે

2088
01:47:12,800 --> 01:47:14,451
ઝાકઝમાળ, અથવા એક યાદી છે, અથવા એક વેક્ટર.

2089
01:47:14,451 --> 01:47:16,450
અને પર આધાર રાખીને
સંદર્ભ, આ બધા જ શબ્દો

2090
01:47:16,450 --> 01:47:17,880
સહેજ અલગ વસ્તુઓ થાય છે.

2091
01:47:17,880 --> 01:47:20,060
તેથી સી, ​​અમે માત્ર જઈ રહ્યાં છો
એક એરે વિશે વાત કરવા માટે.

2092
01:47:20,060 --> 01:47:23,840
અને ઝાકઝમાળ એક ભાગ છે
મેમરી, જેમાંથી દરેક છે

2093
01:47:23,840 --> 01:47:27,720
તત્વો, સંલગ્ન છે પાછા,
પાછળ, પાછળ પાછળ.

2094
01:47:27,720 --> 01:47:31,970
>> અને તે તત્વો છે, સામાન્ય રીતે,
જ માહિતી પ્રકાર, પાત્ર,

2095
01:47:31,970 --> 01:47:35,966
પાત્ર, પાત્ર, અક્ષર, અથવા
શબ્દમાળા શબ્દમાળા શબ્દમાળા શબ્દમાળા, અથવા પૂર્ણાંક,

2096
01:47:35,966 --> 01:47:38,600
પૂર્ણાંક, પૂર્ણાંક, ગમે તે હોય
અમે સ્ટોર કરવાનો પ્રયાસ કરી રહ્યાં છો.

2097
01:47:38,600 --> 01:47:42,540
પરંતુ દિવસ ઓવરને અંતે, આ છે
તે શું કલ્પનાત્મક જેવો દેખાય છે.

2098
01:47:42,540 --> 01:47:44,530
તમે લઈ રહ્યા છો તમારા
કમ્પ્યુટરની મેમરી અથવા રેમ.

2099
01:47:44,530 --> 01:47:48,590
અને તમે તેને બહાર કોતરકામ કરી રહ્યાં છો
સરખું કદના બોક્સ, જે તમામ

2100
01:47:48,590 --> 01:47:50,920
પાછળ છે, પાછળ,
પાછા, આ રીતે પાછા.

2101
01:47:50,920 --> 01:47:53,200
>> અને શું સારું છે
આ વિચાર, અને હકીકત એ છે

2102
01:47:53,200 --> 01:47:58,580
અમે આ રીતે કિંમતો વ્યક્ત કરી શકો છો કે
અમારી માહિતી માળખાં પ્રથમ સાથે

2103
01:47:58,580 --> 01:48:02,520
વર્ગ માં, અમે શરૂ કરી શકો છો
કોડ સાથે સમસ્યાઓ ઉકેલવા માટે

2104
01:48:02,520 --> 01:48:04,079
કે 0 સપ્તાહમાં જેથી તર્ક આવ્યા હતા.

2105
01:48:04,079 --> 01:48:05,870
તમે ફોન યાદ પડશે
પુસ્તક ઉદાહરણ તરીકે,

2106
01:48:05,870 --> 01:48:09,110
અમે વિભાજન વપરાય છે અને જીતી,
અથવા દ્વિસંગી શોધ અલ્ગોરિધમનો,

2107
01:48:09,110 --> 01:48:13,220
સમગ્ર દ્વારા સત્ય હકીકત તારવવી
નામો અને નંબરો સમૂહ.

2108
01:48:13,220 --> 01:48:18,220
પરંતુ અમે ધારી, સ્મૃતિ, કે
ફોન પુસ્તક પહેલાથી જ છટણી કરવામાં આવી હતી

2109
01:48:18,220 --> 01:48:21,630
કોઈના પહેલેથી જ હતી કે
out-- નામો ની યાદી આપવામાં figured

2110
01:48:21,630 --> 01:48:24,430
અને નંબરોની તેમને alphabetize કેવી રીતે.

2111
01:48:24,430 --> 01:48:26,950
અને હવે સી અમે
પણ, ક્ષમતા હોય છે

2112
01:48:26,950 --> 01:48:30,290
વસ્તુઓ બહાર મૂકે છે, નથી
શારીરિક ફોન પુસ્તક

2113
01:48:30,290 --> 01:48:34,220
પરંતુ વાસ્તવમાં કમ્પ્યુટર માં
મેમરી, અમે સક્ષમ આગામી સપ્તાહ હશે

2114
01:48:34,220 --> 01:48:38,470
પ્રથમ છે આ ફરી દાખલ કરવા માટે
એક એરે અમારી માહિતી માળખાં

2115
01:48:38,470 --> 01:48:43,530
પરંતુ વધુ મહત્ત્વની, વાસ્તવિક કમ્પ્યુટર
વિજ્ઞાન ગાણિતીક નિયમો અમલમાં

2116
01:48:43,530 --> 01:48:47,720
કોડ માં, જેની સાથે આપણે સ્ટોર કરી શકો છો
આ જેમ માળખાં માહિતી,

2117
01:48:47,720 --> 01:48:50,730
અને પછી તેને ચાલાકી શરૂ કરવા માટે, અને
ખરેખર તેની સાથે સમસ્યાઓ ઉકેલવા માટે,

2118
01:48:50,730 --> 01:48:53,570
અને તે ટોચ પર બિલ્ડ કરવા માટે,
આખરે, સી કાર્યક્રમો,

2119
01:48:53,570 --> 01:48:56,730
Python માં, જાવાસ્ક્રિપ્ટ,
એસક્યુએલ સાથે ડેટાબેઝ પ્રશ્ન?

2120
01:48:56,730 --> 01:48:59,980
>> અને અમે આ બધા જોશો
અલગ અલગ વિચારો એકસાથે બાંધવું.

2121
01:48:59,980 --> 01:49:04,100
પરંતુ હવે માટે, કે યાદ
ડોમેન કે અમે આજે રજૂ

2122
01:49:04,100 --> 01:49:06,920
આ વસ્તુ અહીં હતો, અને
ક્રિપ્ટોગ્રાફી વિશ્વ.

2123
01:49:06,920 --> 01:49:11,200
અને તમે તમારી જાતને આગામી સમસ્યાઓ વચ્ચે
હલ થશે ક્રિપ્ટોગ્રાફી કળા છે,

2124
01:49:11,200 --> 01:49:13,630
મૂંઝાયેલું અને દ-મૂંઝાયેલું
માહિતી અને સંકેત

2125
01:49:13,630 --> 01:49:15,930
અને લખાણ અર્થ,
અને છેવટે એમ ધારી રહ્યા છીએ

2126
01:49:15,930 --> 01:49:18,970
તમે હવે ખબર છે કે શું
હૂડ નીચે છે

2127
01:49:18,970 --> 01:49:21,860
જેથી જ્યારે તમે જુઓ કે પ્રાપ્ત
આ જેમ એક સંદેશ, તમે

2128
01:49:21,860 --> 01:49:24,060
તે જાતે પદ્ધતિને ડિસાયફર કરવું શકો છો.

2129
01:49:24,060 --> 01:49:26,740
આ બધા અને વધુ આગામી સમય.

2130
01:49:26,740 --> 01:49:29,890

2131
01:49:29,890 --> 01:49:30,790
>> [વિડિઓ પ્લેબેક]

2132
01:49:30,790 --> 01:49:32,970
>> -Mover માત્ર પહોંચ્યા.

2133
01:49:32,970 --> 01:49:35,146
હું મુલાકાત જવા માટે જઇ રહ્યો છું
તેના કોલેજના પ્રોફેસર.

2134
01:49:35,146 --> 01:49:37,611
હા.

2135
01:49:37,611 --> 01:49:40,080
હાય.

2136
01:49:40,080 --> 01:49:40,660
તે તમે જ છો.

2137
01:49:40,660 --> 01:49:44,125

2138
01:49:44,125 --> 01:49:45,110
રાહ જુઓ!

2139
01:49:45,110 --> 01:49:45,610
ડેવિડ.

2140
01:49:45,610 --> 01:49:53,936

2141
01:49:53,936 --> 01:49:56,060
હું માત્ર આકૃતિ કરવાનો પ્રયાસ કરી રહ્યો છું
શું થયું બહાર.

2142
01:49:56,060 --> 01:49:58,130
કૃપા કરીને, ખાવા મદદ કરી શકે છે.

2143
01:49:58,130 --> 01:50:05,020

2144
01:50:05,020 --> 01:50:08,354
તમે તેના કોલેજ હતા
રૂમમેટ, તમે ન હતા?

2145
01:50:08,354 --> 01:50:10,770
તમે તેને જ્યારે ત્યાં હતા
તેમણે CS50 પ્રોજેક્ટ સમાપ્ત?

2146
01:50:10,770 --> 01:50:13,770

2147
01:50:13,770 --> 01:50:15,765
>> [સંગીત વગાડવાનો]

2148
01:50:15,765 --> 01:50:32,110

2149
01:50:32,110 --> 01:50:33,150
>> એટલે CS50 હતી.

2150
01:50:33,150 --> 01:50:42,690

2151
01:50:42,690 --> 01:50:44,770
>> હું આ જગ્યા પ્રેમ.

2152
01:50:44,770 --> 01:50:45,854
>> -ખાઓ.

2153
01:50:45,854 --> 01:50:47,020
અમે બિઝનેસ બહાર જઈ રહ્યાં છો.

2154
01:50:47,020 --> 01:50:52,120

2155
01:50:52,120 --> 01:50:53,970
>> [સમાપ્ત પ્લેબેક]