1
00:00:00,000 --> 00:00:04,664

2
00:00:04,664 --> 00:00:05,580
ડો LLOYD: બધા અધિકાર.

3
00:00:05,580 --> 00:00:08,877
તેથી હવે આપણે એક હલ કરીએ
ખરેખર મોટી વિષય, કાર્ય કરે છે.

4
00:00:08,877 --> 00:00:11,460
અત્યાર સુધી આ કોર્સ, બધા
અમે લખી રહ્યો છું કે કાર્યક્રમો

5
00:00:11,460 --> 00:00:12,969
મુખ્ય ની અંદર લખવામાં આવ્યા છે.

6
00:00:12,969 --> 00:00:14,260
તેઓ ખૂબ સરળ કાર્યક્રમો છો.

7
00:00:14,260 --> 00:00:16,940
તમે આ બધા છે કરવાની જરૂર નથી
શાખાઓ અને વસ્તુઓ પર જઈ રહી છે.

8
00:00:16,940 --> 00:00:18,773
અમે હમણાં જ તે બધા ફિટ થઈ શકે છે
મુખ્ય ની અંદર છે અને તે

9
00:00:18,773 --> 00:00:20,407
ભયંકર જબરજસ્ત વિચાર કરતું નથી.

10
00:00:20,407 --> 00:00:22,990
પરંતુ કોર્સ પર જાય છે અને
તમે કાર્યક્રમો વિકસાવવા શરૂ

11
00:00:22,990 --> 00:00:26,260
સ્વતંત્ર, તેઓ કદાચ જઈ રહ્યાં છો
10 કરતાં ઘણો વધુ વિચાર શરૂ કરવા માટે

12
00:00:26,260 --> 00:00:27,200
અથવા 15 રેખાઓ.

13
00:00:27,200 --> 00:00:31,400
તમે સેંકડો અથવા હજારો વિચાર કરી શકે છે
અથવા દસ કોડ રેખાઓ હજારો.

14
00:00:31,400 --> 00:00:34,690
અને તે ખરેખર નથી
એક વિચાર કે ક્રેઝી.

15
00:00:34,690 --> 00:00:39,720
જેમ કે, તે કદાચ એક સારો વિચાર નથી
મુખ્ય અંદર બધું રાખે છે.

16
00:00:39,720 --> 00:00:43,240
તે શોધવા માટે થોડું મુશ્કેલ વિચાર કરી શકો છો
શું તમે તે કરી, તો શોધી રહ્યાં છે.

17
00:00:43,240 --> 00:00:47,040
>> સદનસીબે, સી જોકે, અને ખૂબ ખૂબ
દરેક અન્ય પ્રોગ્રામિંગ ભાષા કે

18
00:00:47,040 --> 00:00:50,386
સાથે કામ કરી શકે છે, માટે પરવાનગી આપે છે
અમને કાર્યો લખવા માટે.

19
00:00:50,386 --> 00:00:52,260
અને હું માત્ર જાઉં છું
કોરે અહીં એક ઝડપી લેવા

20
00:00:52,260 --> 00:00:54,971
કાર્યો ઉલ્લેખ કર્યો છે કે
કોમ્પ્યુટર વિજ્ઞાન એક વિસ્તાર.

21
00:00:54,971 --> 00:00:57,970
અને તમે તેમને ઘણા વધુ જોશો
અભ્યાસક્રમ દરમિયાન વિવિધ પોઈન્ટ

22
00:00:57,970 --> 00:00:59,290
અને તમે પર રહી છે.

23
00:00:59,290 --> 00:01:02,280
જ્યાં ઘણો ત્યાં છે
એક જ શબ્દ માટે સમાનાર્થી.

24
00:01:02,280 --> 00:01:03,390
તેથી અમે વિધેયો કૉલ કરો.

25
00:01:03,390 --> 00:01:05,980
પરંતુ તમે પણ તેમને સાંભળવા શકે
કાર્યવાહી તરીકે ઓળખવામાં આવે છે,

26
00:01:05,980 --> 00:01:09,570
અથવા પદ્ધતિઓ, ખાસ કરીને, તમે કરેલા જો ક્યારેય
કોઈપણ પદાર્થ કેન્દ્રિત પ્રોગ્રામિંગની કરવામાં

27
00:01:09,570 --> 00:01:11,950
પહેલાં અને ચિંતા નથી
તમે નથી, ન હોય તો

28
00:01:11,950 --> 00:01:14,280
એક મોટી deal-- પરંતુ
ઓડિટ લક્ષી ભાષાઓ

29
00:01:14,280 --> 00:01:16,129
વારંવાર કહેવાય પદ્ધતિઓ છે.

30
00:01:16,129 --> 00:01:17,670
ક્યારેક તેઓ સબરુટીનો કહેવાય કરી રહ્યાં છો.

31
00:01:17,670 --> 00:01:20,690
પરંતુ તેઓ ખરેખર બધા નો સંદર્ભ લો
એ જ મૂળભૂત વિચાર છે.

32
00:01:20,690 --> 00:01:22,480
>> માતાનો વિચાર શું છે તે જોવા દો.

33
00:01:22,480 --> 00:01:23,310
એક કાર્ય શું છે?

34
00:01:23,310 --> 00:01:26,470
વેલ કાર્ય ખરેખર છે
બ્લેક બોક્સ કરતાં વધુ કંઈ નથી.

35
00:01:26,470 --> 00:01:31,430
શૂન્ય સમૂહ છે કે કાળા બોક્સ
વધુ ઇનપુટ્સ અને એક આઉટપુટ અથવા.

36
00:01:31,430 --> 00:01:33,420
તેથી, ઉદાહરણ તરીકે, આ
એક કાર્ય હોઈ શકે છે.

37
00:01:33,420 --> 00:01:35,510
આ કાર્યાત્મક કહેવાય કાર્ય છે.

38
00:01:35,510 --> 00:01:39,330
અને તે ત્રણ ઇનપુટ્સ એ, બી, અને સી લે છે.

39
00:01:39,330 --> 00:01:42,580
અને તે કાળા બોક્સ અંદર, અમે
તે કરે છે બરાબર શું ખબર નથી,

40
00:01:42,580 --> 00:01:45,100
પરંતુ તે ઇનપુટ્સ પ્રક્રિયા કરે છે
અમુક રીતે અને પછી તે

41
00:01:45,100 --> 00:01:48,680
આ કિસ્સામાં એક આઉટપુટ, z આપે છે.

42
00:01:48,680 --> 00:01:50,504
હવે તે થોડી બનાવવા માટે
ઓછી અમૂર્ત, અમે

43
00:01:50,504 --> 00:01:52,420
અમે તે કદાચ કહી શકે
કહેવાય કાર્ય હોય

44
00:01:52,420 --> 00:01:58,750
કે ત્રણ ઇનપુટ્સ એ, બી લે ઉમેરવા, અને
સી અને અમુક રીતે આઉટપુટ પ્રક્રિયાઓ

45
00:01:58,750 --> 00:02:01,010
બ્લેક બોક્સ અંદર
એક આઉટપુટ પેદા કરે છે.

46
00:02:01,010 --> 00:02:05,190
આ કિસ્સામાં, તેથી જો
ઉમેરો 3, 6 અને 7 લે છે.

47
00:02:05,190 --> 00:02:07,020
ક્યાંક અંદર
કાર્ય ઉમેરો, અમે કરશે

48
00:02:07,020 --> 00:02:09,750
અપેક્ષા તેમને મળીને ઉમેરવામાં આવશે
આઉટપુટ પેદા કરવા માટે જે

49
00:02:09,750 --> 00:02:13,220
3 વત્તા 6 પ્લસ 7 અથવા 16 છે.

50
00:02:13,220 --> 00:02:17,940
>> એ જ રીતે, તમે કહેવાય કાર્ય હોય
બે ઇનપુટ્સ, A અને B લે છે મલ્ટ,

51
00:02:17,940 --> 00:02:21,070
અમુક રીતે આવા તેમને પ્રક્રિયાઓ
કે કાર્ય નું આઉટપુટ

52
00:02:21,070 --> 00:02:22,920
બે ઇનપુટ્સ ઉત્પાદન છે.

53
00:02:22,920 --> 00:02:25,080
બે ઇનપુટ્સ સાથે ગુણાકાર.

54
00:02:25,080 --> 00:02:29,150
4 અને 5, મલ્ટ માં પસાર થઈ રહી
કંઈક અમે અપેક્ષા આઉટપુટ થાય

55
00:02:29,150 --> 00:02:31,090
20 છે.

56
00:02:31,090 --> 00:02:32,507
શા માટે અમે તેને એક બ્લેક બોક્સ કહી શકું?

57
00:02:32,507 --> 00:02:34,840
વેલ અમે લખી રહ્યા હોય તો
જાતને કાર્ય જે

58
00:02:34,840 --> 00:02:36,869
અમે ખૂબ થોડી અત્યાર સુધી CS50 કર્યું છે.

59
00:02:36,869 --> 00:02:39,910
અમે, ઉદાહરણ તરીકે, પ્રિન્ટ એફ જોઈ કર્યું, જે
અમે લખી ન હતી કે એક કાર્ય છે

60
00:02:39,910 --> 00:02:42,305
જાતને, પરંતુ અમે બધા સમય ઉપયોગ કરે છે.

61
00:02:42,305 --> 00:02:44,180
અમે લખી ન હોય તો
કાર્યો જાતને,

62
00:02:44,180 --> 00:02:48,450
તે કેવી રીતે અમે ખરેખર જાણવાની જરૂર નથી
ખરેખર હૂડ હેઠળ અમલમાં.

63
00:02:48,450 --> 00:02:51,710
>> તેથી, ઉદાહરણ તરીકે કાળા બોક્સ હું
માત્ર ગુણાકાર માટે તમે દર્શાવે છે

64
00:02:51,710 --> 00:02:53,740
એક મલ્ટ, બી હોઈ શકે છે
વ્યાખ્યાયિત અને આ માત્ર છે

65
00:02:53,740 --> 00:02:57,902
કેટલાક સ્યુડોકોડનો હોઈ શકે છે
આઉટપુટ વખત બી તરીકે વ્યાખ્યાયિત થયેલ છે.

66
00:02:57,902 --> 00:02:58,860
તે અર્થમાં બનાવવા, અધિકાર.

67
00:02:58,860 --> 00:03:01,370
અમે કહેવાય કાર્ય હોય, તો
બે ઇનપુટ્સ લે છે મલ્ટ.

68
00:03:01,370 --> 00:03:04,750
અમે અપેક્ષા કરશે આઉટપુટ કરશે
હોઈ બે ઇનપુટ્સ, સાથે ગુણાકાર

69
00:03:04,750 --> 00:03:06,240
એક વખત બી.

70
00:03:06,240 --> 00:03:09,170
પરંતુ મલ્ટ પણ હોઈ શકે છે
આ જેમ અમલમાં છે,

71
00:03:09,170 --> 00:03:13,150
અમે એક કાઉન્ટર ચલ હોય છે
0 મલ્ટ અંદર સમૂહ છે.

72
00:03:13,150 --> 00:03:18,000
અને પછી અમે આ પ્રક્રિયા પુનરાવર્તન
b વખત કાઉન્ટર પર એક ઉમેરો.

73
00:03:18,000 --> 00:03:24,270
ઉદાહરણ તરીકે, અમે દ્વારા 3A વધવું હોય તો
5B, અમે 0 કાઉન્ટર સુયોજિત કહી શકે છે,

74
00:03:24,270 --> 00:03:27,700
પાંચ વખત પુનરાવર્તન કાઉન્ટર 3 ઉમેરો.

75
00:03:27,700 --> 00:03:34,490
તેથી અમે 0 શરૂ થાય છે અને પછી અમે શું
પાંચ વખત 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
તે જ પરિણામ છે. અમે
હજુ પણ વિચાર 3 વખત 5 ફક્ત

77
00:03:37,500 --> 00:03:39,500
અમલીકરણ અલગ છે.

78
00:03:39,500 --> 00:03:41,490
>> કે અમે શું અર્થ છે
અમે એક બ્લેક બોક્સ કહે છે.

79
00:03:41,490 --> 00:03:44,406
તે માત્ર અમે ખરેખર કાળજી નથી એનો અર્થ એ થાય
તે હૂડ હેઠળ અમલમાં છે કેવી રીતે

80
00:03:44,406 --> 00:03:46,170
તરીકે લાંબા સમય સુધી આઉટપુટ અમે અપેક્ષા શું છે.

81
00:03:46,170 --> 00:03:49,045
હકીકતમાં, કે કરાર ભાગ છે
ખાસ કરીને, વિધેયો મદદથી

82
00:03:49,045 --> 00:03:50,630
અન્ય લખી કે કાર્ય કરે છે.

83
00:03:50,630 --> 00:03:53,980
વર્તન હંમેશા રહ્યું છે
અણધારી, લાક્ષણિક

84
00:03:53,980 --> 00:03:55,420
કાર્ય ના નામ પર આધારિત છે.

85
00:03:55,420 --> 00:03:57,500
તે ખરેખર છે અને તે શા માટે છે
મહત્વપૂર્ણ છે કે તમે વિધેયો લખી ત્યારે

86
00:03:57,500 --> 00:04:00,020
અથવા જ્યારે અન્ય લોકો લખવા
તમે ઉપયોગ કરી શકે છે કે જે કાર્યો,

87
00:04:00,020 --> 00:04:03,590
તે કાર્યો કરતા હોય છે કે
સ્પષ્ટ, પ્રમાણમાં સ્પષ્ટ નામો,

88
00:04:03,590 --> 00:04:04,990
અને સારી રીતે દસ્તાવેજીકૃત કરવામાં આવે છે.

89
00:04:04,990 --> 00:04:08,560
જે ચોક્કસપણે કેસ છે
પ્રિન્ટ એફ જેમ કાર્ય માટે.

90
00:04:08,560 --> 00:04:09,860
>> તેથી શા માટે અમે કાર્યો ઉપયોગ કરી શકું?

91
00:04:09,860 --> 00:04:14,220
વેલ હું અમે લખી છે, તો અગાઉ કહ્યું હતું કે
મુખ્ય વસ્તુઓ અંદર અમારા કોડ તમામ

92
00:04:14,220 --> 00:04:17,120
ખરેખર બોજારૂપ વિચાર કરી શકો છો
અને ખરેખર જટીલ.

93
00:04:17,120 --> 00:04:19,980
કાર્યો આપણને ક્ષમતા પરવાનગી આપે છે
વસ્તુઓ ગોઠવવા અને તોડી

94
00:04:19,980 --> 00:04:24,540
એક ખૂબ જ જટિલ સમસ્યા
ઘણો વધુ વ્યવસ્થિત પેટા ભાગો.

95
00:04:24,540 --> 00:04:28,130
કાર્યો પણ કરવા માટે પરવાનગી આપે
કોડિંગ પ્રક્રિયા સરળ બનાવે છે.

96
00:04:28,130 --> 00:04:33,080
તે 10 ડિબગ ઘણો સરળ બને છે
100 વાક્ય વિરુદ્ધ વાક્ય કાર્ય

97
00:04:33,080 --> 00:04:35,890
કાર્ય અથવા 1,000 વાક્ય કાર્ય.

98
00:04:35,890 --> 00:04:38,400
અમે માત્ર ડિબગ હોય તો
એક સમયે નાના ટુકડાઓ,

99
00:04:38,400 --> 00:04:42,110
અથવા, તે સમયે નાના ટુકડાઓ લખવા
તે પ્રોગ્રામિંગ અનુભવ બનાવે છે

100
00:04:42,110 --> 00:04:43,070
ઘણું સારું.

101
00:04:43,070 --> 00:04:44,910
કે એક પર મને વિશ્વાસ.

102
00:04:44,910 --> 00:04:48,400
>> છેલ્લે, અમે કાર્યો લખવા તો અમે
તે વિવિધ ભાગોમાં ફરી શકો છો.

103
00:04:48,400 --> 00:04:49,880
કાર્યો રિસાયકલ કરી શકાય છે.

104
00:04:49,880 --> 00:04:51,880
તેઓ ઉપયોગ કરી શકાય છે
એક કાર્યક્રમ અથવા અન્ય.

105
00:04:51,880 --> 00:04:53,713
જો તમે પહેલાથી જ તેવા પરચૂરણ ખર્ચ કર્યો
કાર્ય, બધા તમે

106
00:04:53,713 --> 00:04:56,530
કે કાર્યક્રમને કહેવું નથી કરવાની જરૂર
જ્યાં તે કાર્ય શોધવા માટે.

107
00:04:56,530 --> 00:04:59,680
અમે રિસાયક્લિંગ અને ઉપયોગ કરી રહ્યો છું
40 વર્ષથી એફ છાપો.

108
00:04:59,680 --> 00:05:02,150
પરંતુ તે માત્ર એક સમય લખવામાં આવ્યું હતું.

109
00:05:02,150 --> 00:05:04,270
ખૂબ ઉપયોગી, અધિકાર.

110
00:05:04,270 --> 00:05:04,830
બધા અધિકાર.

111
00:05:04,830 --> 00:05:06,040
તેથી કાર્યો મહાન છે.

112
00:05:06,040 --> 00:05:06,860
અમે કે ખબર.

113
00:05:06,860 --> 00:05:08,700
હવે તેમને લખવાની શરૂઆત કરીએ.

114
00:05:08,700 --> 00:05:10,830
માતાનો મેળવવામાં શરૂ કરીએ
તેમને અમારા કાર્યક્રમો માં.

115
00:05:10,830 --> 00:05:13,869
માટે, પ્રથમ તે કરવા માટે
આપણે શું વસ્તુ કાર્ય જાહેર છે.

116
00:05:13,869 --> 00:05:16,160
તમે એક કાર્ય જાહેર કરે છે ત્યારે
શું તમે મૂળભૂત કરી રહ્યા છીએ

117
00:05:16,160 --> 00:05:18,900
કમ્પાઇલર કહેવાની છે,
અરે, તમે જાણો છો,

118
00:05:18,900 --> 00:05:20,850
હું લખી શકાય જઈ રહ્યો છું
પાછળથી એક કાર્ય

119
00:05:20,850 --> 00:05:22,987
અને તેને અહીં જેમ દેખાય રહ્યું છે તે છે.

120
00:05:22,987 --> 00:05:24,820
આ માટેનું કારણ છે
કમ્પાઇલરોનો કરી શકો છો કારણ કે

121
00:05:24,820 --> 00:05:27,900
જો કેટલાક વિચિત્ર વસ્તુઓ
તેઓ પ્રતીકો સમૂહ જુઓ

122
00:05:27,900 --> 00:05:29,560
તેઓ સાથે પરિચિત નથી, છે.

123
00:05:29,560 --> 00:05:33,000
તેથી અમે ફક્ત કમ્પાઇલર આપી
વડા, હું કાર્ય બનાવી રહ્યો છું

124
00:05:33,000 --> 00:05:35,492
અને તે આ કરી રહ્યું છે.

125
00:05:35,492 --> 00:05:38,450
કાર્ય ઘોષણાઓ સામાન્ય રીતે જો
તમે જે રીતે તમારા કોડ આયોજન કરી રહ્યાં છો

126
00:05:38,450 --> 00:05:41,872
અન્ય લોકો માટે સક્ષમ હશે કે
સમજવા અને ઉપયોગ કરે છે,

127
00:05:41,872 --> 00:05:44,330
તમે સામાન્ય રીતે બધા મૂકેલ
તમારા કાર્ય જાહેરાતો

128
00:05:44,330 --> 00:05:48,220
તમારો કોડ ખૂબ જ ટોચ પર, અધિકાર
તમે પણ મુખ્ય લખવાનું શરૂ કરો તે પહેલાં.

129
00:05:48,220 --> 00:05:50,770
અને સરળ, ત્યાં
ખૂબ જ પ્રમાણભૂત સ્વરૂપ

130
00:05:50,770 --> 00:05:53,500
દરેક કાર્ય જાહેરાત કે જે અનુસરે છે.

131
00:05:53,500 --> 00:05:56,090
તેઓ બધા ખૂબ ખૂબ આ જેમ દેખાય છે.

132
00:05:56,090 --> 00:06:01,440
ત્રણ ભાગમાં એક કાર્ય કરવા માટે હોય છે
ઘોષણા, વળતર પ્રકાર, નામ,

133
00:06:01,440 --> 00:06:03,420
અને દલીલ યાદી.

134
00:06:03,420 --> 00:06:07,180
>> હવે પરત પ્રકાર પ્રકારની શું છે
ચલ કાર્ય કરશે આઉટપુટ.

135
00:06:07,180 --> 00:06:10,710
તેથી ઉદાહરણ તરીકે, જો અમે પાછા લાગે છે
બે ગુણાકાર પહેલાં મિનિટ

136
00:06:10,710 --> 00:06:15,690
નંબરો કાર્ય, અમે તો શું અપેક્ષા નથી
અમે પૂર્ણાંક દ્વારા પૂર્ણાંક વધવું

137
00:06:15,690 --> 00:06:18,502
આઉટપુટ હશે
કદાચ પૂર્ણાંક, અધિકાર.

138
00:06:18,502 --> 00:06:20,710
ગુણાકાર બે પૂર્ણાંકો
તેની સાથે, તમે એક પૂર્ણાંક વિચાર.

139
00:06:20,710 --> 00:06:24,167
કે પરત પ્રકાર તેથી
કાર્ય પૂર્ણાંક હશે.

140
00:06:24,167 --> 00:06:26,000
નામ તમે શું કરવા માંગો છો
તમારા કાર્ય કૉલ કરવા માટે.

141
00:06:26,000 --> 00:06:29,330
આ કદાચ ઓછામાં ઓછા મહત્વનું છે
કાર્ય જાહેરાત ભાગ

142
00:06:29,330 --> 00:06:30,827
વિધેય દ્રષ્ટિએ.

143
00:06:30,827 --> 00:06:33,160
પરંતુ ખરેખર કદાચ છે
સૌથી મહત્વપૂર્ણ ભાગો

144
00:06:33,160 --> 00:06:36,243
દ્રષ્ટિએ કાર્ય જાહેરાત
જાણીને કાર્ય ખરેખર શું

145
00:06:36,243 --> 00:06:37,120
કરે છે.

146
00:06:37,120 --> 00:06:40,474
તમે તમારા કાર્ય એફ અથવા G નામ તો અથવા
એચ કે રહસ્ય અથવા તે કંઈક,

147
00:06:40,474 --> 00:06:42,765
તમે કદાચ વિચાર જઈ રહ્યાં છો
થોડી પ્રયાસ કરી ટ્રિપ

148
00:06:42,765 --> 00:06:44,650
તે કાર્યો શું યાદ.

149
00:06:44,650 --> 00:06:47,880
તેથી તે આપવા માટે મહત્વપૂર્ણ છે તમારા
કાર્ય અર્થપૂર્ણ નામો.

150
00:06:47,880 --> 00:06:51,030
>> છેલ્લે, દલીલ યાદી છે
આ અલ્પવિરામથી અલગ પડેલ યાદી

151
00:06:51,030 --> 00:06:55,260
તમારા કાર્ય કરવા માટે તમામ ઇનપુટ્સ,
જે દરેક પ્રકાર અને એક નામ ધરાવે છે.

152
00:06:55,260 --> 00:06:57,840
તેથી માત્ર તમે હોય
ચલ કયા પ્રકારનું સ્પષ્ટ

153
00:06:57,840 --> 00:07:00,760
આ કાર્ય કરશે આઉટપુટ
તમે પણ સ્પષ્ટ કરવા માંગો છો

154
00:07:00,760 --> 00:07:07,694
તે લખો અને ચલો ના પ્રકાર
કાર્ય ઇનપુટ્સ તરીકે સ્વીકારી કરવામાં આવશે.

155
00:07:07,694 --> 00:07:08,860
તેથી આપણે અહીં એક ઉદાહરણ કરવા દો.

156
00:07:08,860 --> 00:07:10,220
ચાલો એક નજર કરીએ
વધુ કોંક્રિટ એક છે.

157
00:07:10,220 --> 00:07:13,130
તેથી અહીં એક કાર્ય એક ઉદાહરણ છે
એક કાર્ય માટે ઘોષણા કે

158
00:07:13,130 --> 00:07:14,925
એકસાથે બે પૂર્ણાંકો ઉમેરો કરશે.

159
00:07:14,925 --> 00:07:17,800
બે પૂર્ણાંકો ની રકમ રહ્યું છે
પૂર્ણાંક, તેમજ હોઈ અમે હમણાં જ તરીકે

160
00:07:17,800 --> 00:07:18,450
ચર્ચા કરી છે.

161
00:07:18,450 --> 00:07:21,610
અને તેથી વળતર પ્રકાર
અહીં લીલા, પૂર્ણાંક હશે.

162
00:07:21,610 --> 00:07:25,190
કે જે હમણાં જ બે ints ઉમેરો કે અમને કહે છે
દિવસ ના અંતે, ચાલે છે,

163
00:07:25,190 --> 00:07:28,799
આઉટપુટ, અથવા પાછા બોલે
અમને બહાર પૂર્ણાંક.

164
00:07:28,799 --> 00:07:31,590
આ કાર્ય અમે શું કરે આપેલ
તે એક અર્થપૂર્ણ નામ આપવા માંગો છો.

165
00:07:31,590 --> 00:07:33,630
બે ints લાગે ઉમેરો
યોગ્ય વિચારણા

166
00:07:33,630 --> 00:07:37,574
અમે ઇનપુટ્સ તરીકે બે પૂર્ણાંકો લઇ રહ્યા છીએ
અને આસ્થાપૂર્વક તેમને મળીને ઉમેરી રહ્યા છે.

167
00:07:37,574 --> 00:07:40,240
તે બોજારૂપ એક બીટ હોઈ શકે છે
નામ અને પ્રમાણિકપણે આ કાર્ય

168
00:07:40,240 --> 00:07:42,430
કદાચ જરૂરી નથી
અમે વધુમાં છે કારણ કે

169
00:07:42,430 --> 00:07:46,310
ઓપરેટર, તમે યાદ તો અમારા
અગાઉ ઓપરેટરો ચર્ચા.

170
00:07:46,310 --> 00:07:49,650
પરંતુ માત્ર ખાતર કહી દો
આ કાર્ય ઉપયોગી છે કે દલીલ

171
00:07:49,650 --> 00:07:52,860
અને તેથી અમે તે બે ints ઉમેરો કહી શકશો.

172
00:07:52,860 --> 00:07:55,230
છેલ્લે, આ કાર્ય બે ઇનપુટ્સ લે છે.

173
00:07:55,230 --> 00:07:56,960
જે દરેક એક પૂર્ણાંક છે.

174
00:07:56,960 --> 00:07:59,900
તેથી અમે આ અલ્પવિરામ છે
ઇનપુટ્સ અલગ યાદી.

175
00:07:59,900 --> 00:08:02,830
હવે અમે સામાન્ય રીતે કરવા માંગો છો
તેમને દરેક એક નામ આપો

176
00:08:02,830 --> 00:08:05,070
તેઓ ઉપયોગ કરી શકો છો કે જેથી
કાર્ય અંદર.

177
00:08:05,070 --> 00:08:07,180
નામો ભયંકર મહત્વની નથી.

178
00:08:07,180 --> 00:08:11,400
>> આ કિસ્સામાં, અમે જરૂરી નથી
તેમને જોડાયેલ કોઈ અર્થ હોય છે.

179
00:08:11,400 --> 00:08:13,140
તેથી અમે ફક્ત A અને B તેમને કૉલ કરી શકો છો.

180
00:08:13,140 --> 00:08:14,257
તે તદ્દન દંડ છે.

181
00:08:14,257 --> 00:08:16,090
જો કે, તમે શોધવા
એક પરિસ્થિતિમાં જાતે

182
00:08:16,090 --> 00:08:19,497
જ્યાં ચલો નામો
ખરેખર મહત્વપૂર્ણ હોઈ શકે છે,

183
00:08:19,497 --> 00:08:21,830
તમે તેમને કૉલ કરવા માંગો છો શકે છે
A અને B સિવાયના અન્ય

184
00:08:21,830 --> 00:08:24,701
તેમને વધુ કંઈક આપવા માટે
પ્રતીકાત્મક અર્થપૂર્ણ.

185
00:08:24,701 --> 00:08:27,700
પરંતુ આ કિસ્સામાં, અમે ખરેખર નથી
આ કાર્ય વિશે કંઈપણ ખબર.

186
00:08:27,700 --> 00:08:29,320
અમે હમણાં જ બે પૂર્ણાંકો ઉમેરવા માંગો છો.

187
00:08:29,320 --> 00:08:32,429
તેથી અમે ફક્ત કહી શકશો
તે પૂર્ણાંકો એક અને બોલ્ડ છે.

188
00:08:32,429 --> 00:08:33,990
તે એક ઉદાહરણ છે.

189
00:08:33,990 --> 00:08:36,287
>> તમે બીજા લેવા નથી શા માટે
આ એક વિશે વિચારો,

190
00:08:36,287 --> 00:08:38,870
કેવી રીતે તમે એક કાર્ય લખી હતી
એક કાર્ય માટે ઘોષણા કે

191
00:08:38,870 --> 00:08:42,940
બે અપૂર્ણાંક બિંદુ સંખ્યામાં multiplies?

192
00:08:42,940 --> 00:08:45,910
તમે શું યાદ છે
અપૂર્ણાંક બિંદુ નંબર શું છે?

193
00:08:45,910 --> 00:08:48,120
શું આ કાર્ય કરશે
ઘોષણા જેમ દેખાય છે?

194
00:08:48,120 --> 00:08:53,330
હું ખરેખર તમે વિડિઓ વિરામ ભલામણ
અહીં અને તમને કેટલી જરૂર સમય લે છે.

195
00:08:53,330 --> 00:08:55,521
શું આ વિશે વિચારો
કાર્ય જાહેરાત હશે?

196
00:08:55,521 --> 00:08:56,770
પરત પ્રકાર શું હશે?

197
00:08:56,770 --> 00:08:58,103
અર્થપૂર્ણ નામ શું હશે?

198
00:08:58,103 --> 00:08:59,580
ઇનપુટ્સ શું હશે?

199
00:08:59,580 --> 00:09:03,190
તેથી શા માટે તમે અહીં વિડિઓ વિરામ નથી
અને લખવા અપ કાર્ય જાહેરાત

200
00:09:03,190 --> 00:09:07,640
ગુણાકાર કરશે કે કાર્ય માટે
એકસાથે બે અપૂર્ણાંક બિંદુ નંબરો.

201
00:09:07,640 --> 00:09:09,330
આસ્થાપૂર્વક તમે વિડિઓ રોક્યો છે.

202
00:09:09,330 --> 00:09:12,950
>> તેથી આપણે એક ઉદાહરણ પર એક નજર કરીએ
એક શક્ય ઘોષણા છે.

203
00:09:12,950 --> 00:09:17,340
મલ્ટ બે reals, ફ્લોટ વાય એક્સ ફ્લોટ તરતા રહે છે.

204
00:09:17,340 --> 00:09:19,090
બે ઉત્પાદન
અપૂર્ણાંક બિંદુ સંખ્યામાં,

205
00:09:19,090 --> 00:09:21,710
જે યાદ કેવી રીતે અમે
વાસ્તવિક સંખ્યાઓ પ્રતિનિધિત્વ

206
00:09:21,710 --> 00:09:26,770
અથવા સી દશાંશ કિંમતો સાથે નંબરો,
એક અપૂર્ણાંક બિંદુ નંબર હોઈ ચાલે છે.

207
00:09:26,770 --> 00:09:28,570
તમે ગુણાકાર ત્યારે
દશાંશ દ્વારા દશાંશ,

208
00:09:28,570 --> 00:09:30,460
તમે કદાચ દશાંશ વિચાર જઈ રહ્યાં છો.

209
00:09:30,460 --> 00:09:31,960
તમે તેને સંબંધિત નામ આપવા માંગો છો.

210
00:09:31,960 --> 00:09:33,810
બે reals ગુણાકાર દંડ લાગે છે.

211
00:09:33,810 --> 00:09:36,620
પરંતુ તમે ખરેખર તે કહી શકે છે
મલ્ટ બે ફ્લોટ્સ, અથવા મલ્ટ તરે.

212
00:09:36,620 --> 00:09:39,540
તે લાંબા સમય સુધી કે કંઈપણ,
કેટલાક વાસ્તવિક અર્થ શું આપ્યું

213
00:09:39,540 --> 00:09:41,469
આ બ્લેક બોક્સ શું થવાનું હતું.

214
00:09:41,469 --> 00:09:44,260
અને ફરી, આ કિસ્સામાં, અમે નથી
કોઈ અર્થ જોડાયેલ હોય એવું લાગે છે

215
00:09:44,260 --> 00:09:46,390
ના નામો
અમે માં પસાર કરી રહ્યાં ચલો,

216
00:09:46,390 --> 00:09:48,645
તેથી અમે માત્ર તેમને એક્સ અને વાય કૉલ કરો.

217
00:09:48,645 --> 00:09:51,020
તમે કંઈક તેમને કોલ હવે તો
બીજું, તે તદ્દન દંડ છે.

218
00:09:51,020 --> 00:09:53,310
હકીકતમાં, તમે ન હોય તો
આ જાહેરાત બદલે

219
00:09:53,310 --> 00:09:55,450
તેના બદલે ડબલ્સ ઉપયોગ
તમે યાદ તો, તરે

220
00:09:55,450 --> 00:09:59,100
ડબલ્સમાં અલગ છે કે
માર્ગ વધુ સ્પષ્ટ

221
00:09:59,100 --> 00:10:02,330
વાસ્તવિક સંખ્યાઓ ઉલ્લેખ કરો અથવા
બિંદુ ચલો તરતી.

222
00:10:02,330 --> 00:10:03,620
તે ખૂબ સંપૂર્ણપણે દંડ છે.

223
00:10:03,620 --> 00:10:04,670
ક્યાં તો તે એક દંડ હશે.

224
00:10:04,670 --> 00:10:06,711
હકીકતમાં, ઘણા હોય છે
વિવિધ સંયોજનો

225
00:10:06,711 --> 00:10:08,410
રીતે આ કાર્ય જાહેર કરવા.

226
00:10:08,410 --> 00:10:10,884
પરંતુ આ બે ખૂબ સારી રાશિઓ છે.

227
00:10:10,884 --> 00:10:12,550
અમે કે જે મહાન છે, એક કાર્ય જાહેર કર્યું છે.

228
00:10:12,550 --> 00:10:15,700
અમે તે શું કમ્પાઇલર કહ્યું છે
અમે શું કરી શકાય જઈ રહ્યાં છો છે.

229
00:10:15,700 --> 00:10:17,630
હવે ખરેખર છે કે કાર્ય લખી દો.

230
00:10:17,630 --> 00:10:20,750
તે એક વ્યાખ્યા આપી દો,
કે જેથી બ્લેક બોક્સ અંદર

231
00:10:20,750 --> 00:10:22,840
ધારી વર્તન થઈ રહ્યું છે.

232
00:10:22,840 --> 00:10:26,270
હકીકતમાં, અમે બે વાસ્તવિક ગુણાકાર છે
એકસાથે નંબરો, કે ઉમેરી નંબરો

233
00:10:26,270 --> 00:10:29,760
તેની સાથે, અથવા તે ગમે કરી
કે અમે શું અમારા માટે કાર્ય પૂછવામાં.

234
00:10:29,760 --> 00:10:32,780
>> હકીકતમાં તેથી, ચાલો પ્રયાસ કરો અને વ્યાખ્યાયિત દો
બે reals વધવું જે અમે માત્ર

235
00:10:32,780 --> 00:10:35,350
એક સેકંડ પહેલા વિશે વાત કરી.

236
00:10:35,350 --> 00:10:38,560
હવે શરૂઆત
એક કાર્ય વ્યાખ્યા

237
00:10:38,560 --> 00:10:41,720
લગભગ બરાબર એ જ જુએ છે
એક કાર્ય જાહેરાત છે.

238
00:10:41,720 --> 00:10:43,170
હું અહીં તેમને બંને હોય છે.

239
00:10:43,170 --> 00:10:47,770
ટોચ પર કાર્ય જાહેરાત છે,
પ્રકાર, નામ, અલ્પવિરામથી અલગ પડેલ દલીલ

240
00:10:47,770 --> 00:10:49,410
યાદી, અર્ધવિરામ.

241
00:10:49,410 --> 00:10:53,800
આ અર્ધવિરામ સૂચવે છે કે
એક કાર્ય છે કે જાહેરાત છે.

242
00:10:53,800 --> 00:10:57,060
કાર્ય ની શરૂઆત
વ્યાખ્યા લગભગ બરાબર દેખાય છે

243
00:10:57,060 --> 00:11:03,790
એ જ, પ્રકાર, નામ, અલ્પવિરામથી અલગ પડેલ
દલીલ યાદી, કોઈ અર્ધવિરામ,

244
00:11:03,790 --> 00:11:05,206
સર્પાકાર તાણવું ખોલો.

245
00:11:05,206 --> 00:11:07,580
ઓપન સર્પાકાર તાણવું, જેમ
અમે મુખ્ય સાથે કરી રહ્યો છું

246
00:11:07,580 --> 00:11:09,540
આપણે હવે અર્થ એ છે કે
વ્યાખ્યાયિત કરવા માટે શરૂ

247
00:11:09,540 --> 00:11:14,567
શું બ્લેક બોક્સ અંદર થાય છે કે
અમે મલ્ટ બે reals કૉલ કરવાનો નિર્ણય લીધો છે.

248
00:11:14,567 --> 00:11:15,900
અહીં તે અમલ કરવા માટે એક રીત છે.

249
00:11:15,900 --> 00:11:20,370
અમે એક નવી જાહેર કરી શકે છે, કહે છે શકે છે
પ્રકાર ફ્લોટ કહેવાય ઉત્પાદન ચલ

250
00:11:20,370 --> 00:11:24,020
અને તે ચલ સોંપી
કિંમત X વખત વાય છે.

251
00:11:24,020 --> 00:11:27,306
અને પછી ઉત્પાદન આવો.

252
00:11:27,306 --> 00:11:28,430
રીટર્ન અહીં શું અર્થ છે.

253
00:11:28,430 --> 00:11:31,090
વેલ રીટર્ન માર્ગ છે
અમે તે કેવી રીતે સૂચવે છે

254
00:11:31,090 --> 00:11:33,400
અમે આઉટપુટ ફરીથી પસાર કરી રહ્યાં છે.

255
00:11:33,400 --> 00:11:38,160
તેથી તરીકે જ છે, કંઈક આવો
આ બ્લેક બોક્સ આઉટપુટ છે.

256
00:11:38,160 --> 00:11:40,732
તમે તેને કરવા કેવી રીતે તે છે.

257
00:11:40,732 --> 00:11:42,190
અહીં તે અમલ કરવા માટે અન્ય માર્ગ છે.

258
00:11:42,190 --> 00:11:45,050
અમે હમણાં જ વાય એક્સ વખત પરત કરી શકે છે.

259
00:11:45,050 --> 00:11:45,870
X ફ્લોટ છે.

260
00:11:45,870 --> 00:11:46,660
વાય ફ્લોટ છે.

261
00:11:46,660 --> 00:11:48,490
વખત એક્સ તેથી Y પણ એક ફ્લોટ છે.

262
00:11:48,490 --> 00:11:50,750
અમે પણ કરવાની જરૂર નથી
બીજા ચલ બનાવો.

263
00:11:50,750 --> 00:11:56,750
તેથી તે અલગ રીતે છે
ચોક્કસ જ બ્લેક બોક્સ અમલ.

264
00:11:56,750 --> 00:11:58,570
>> હવે એક ક્ષણ લે છે,
ફરી વિડિઓ વિરામ,

265
00:11:58,570 --> 00:12:01,680
અને બે ints ઉમેરો પ્રયાસ કરો અને વ્યાખ્યાયિત
જે અન્ય કાર્ય છે કે અમે

266
00:12:01,680 --> 00:12:03,090
એક ક્ષણ પહેલા વિશે વાત કરી.

267
00:12:03,090 --> 00:12:06,440
અહીં ફરીથી, હું કાર્ય મૂકી દીધું છે
ઘોષણા, અને તેથી અર્ધવિરામ,

268
00:12:06,440 --> 00:12:08,420
અને એક ખુલ્લું સર્પાકાર તાણવું
અને બંધ સર્પાકાર

269
00:12:08,420 --> 00:12:12,080
અમે ભરવા પડશે જ્યાં તાણવું સૂચવવા માટે
સમાવિષ્ટો, બે ints ઉમેરો

270
00:12:12,080 --> 00:12:15,530
અમે ખાસ વ્યાખ્યાયિત કે જેથી
કાળા બોક્સ અંદર વર્તન.

271
00:12:15,530 --> 00:12:16,380
જેથી વિડિઓ વિરામ.

272
00:12:16,380 --> 00:12:18,790
અને તેટલી સમય લાગી
તમે પ્રયાસ કરો અને વ્યાખ્યાયિત કરવા માટે જરૂર

273
00:12:18,790 --> 00:12:25,040
એક અમલીકરણ બે ints ઉમેરો, જેમ કે
કે કાર્ય નીચેની આઉટપુટ, ત્યારે

274
00:12:25,040 --> 00:12:29,209
તે હકીકતમાં, નથી, વળતર
બે ઇનપુટ્સ ની રકમ.

275
00:12:29,209 --> 00:12:32,000
તેથી માત્ર અગાઉના ઉદાહરણ તરીકે,
કેટલાક વિવિધ માર્ગો છે

276
00:12:32,000 --> 00:12:34,210
તમે અમલ કરી શકે છે બે ints ઉમેરો.

277
00:12:34,210 --> 00:12:35,130
અહીં એક છે.

278
00:12:35,130 --> 00:12:37,172
અહીં નારંગી હું કર્યું
માત્ર કેટલાક comments-- હતી

279
00:12:37,172 --> 00:12:38,880
હું માત્ર કેટલાક ઉમેર્યા છે
ટિપ્પણીઓ સૂચવે છે

280
00:12:38,880 --> 00:12:41,400
શું કોડ ઓફ દરેક લીટી પર ચાલી રહ્યું છે.

281
00:12:41,400 --> 00:12:45,430
તેથી હું એક ચલ જાહેર
પ્રકાર પૂર્ણાંક રકમ કહેવાય છે.

282
00:12:45,430 --> 00:12:47,279
હું રકમ એક વતા b બરાબર કહે છે.

283
00:12:47,279 --> 00:12:50,070
અમે ખરેખર કરી રહ્યા છીએ કે જ્યાં
કામ ઉમેરી રહ્યા છે અને સાથે મળીને બી.

284
00:12:50,070 --> 00:12:51,850
અને હું રકમ પરત.

285
00:12:51,850 --> 00:12:56,460
અને તે અર્થમાં બનાવે છે કારણ કે
રકમ પ્રકાર પૂર્ણાંક ચલ છે.

286
00:12:56,460 --> 00:13:00,180
અને ડેટા કે આ પ્રકાર શું છે
કાર્ય આઉટપુટ રહ્યું છે મને કહે છે?

287
00:13:00,180 --> 00:13:00,680
ઈન્.

288
00:13:00,680 --> 00:13:03,072
તેથી હું રકમ પરત છું જે
પૂર્ણાંક ચલ છે.

289
00:13:03,072 --> 00:13:06,030
અને તે અર્થમાં અમે કર્યું શું આપવામાં બનાવે
જાહેર અને અમારા કાર્ય વ્યાખ્યાયિત

290
00:13:06,030 --> 00:13:07,320
શું કરવું.

291
00:13:07,320 --> 00:13:09,700
>> હવે તમે પણ વ્યાખ્યાયિત કરી શકો છો
કાર્ય આ રીતે,

292
00:13:09,700 --> 00:13:15,260
પૂર્ણાંક રકમ કે અવગણો b-- એક વત્તા જેટલી જ થાય છે
step-- પ્રથમ અને પછી રકમ પરત.

293
00:13:15,260 --> 00:13:17,760
હવે તમે પણ કરી શકે છે
તે આ રીતે અમલમાં

294
00:13:17,760 --> 00:13:19,180
જે હું ખૂબ ભલામણ નથી.

295
00:13:19,180 --> 00:13:22,540
આ એક ખરાબ શૈલી છે
વસ્તુ અને ખરેખર ખરાબ ડિઝાઇન,

296
00:13:22,540 --> 00:13:24,420
પરંતુ તે હકીકત છે, કામ કરે છે.

297
00:13:24,420 --> 00:13:30,199
તમે પૂર્ણાંક છે કે જે આ કોડ છે, લેતા હો તો
ખરાબ નાનો ઝેરી સાંપ ટપકું સી ઉમેરો, અને તે ઉપયોગ કરે છે.

298
00:13:30,199 --> 00:13:31,990
તે ખરેખર ઉમેરો કરે છે
એકસાથે બે પૂર્ણાંકો.

299
00:13:31,990 --> 00:13:37,632
તે ખૂબ જ ગરીબ અમલીકરણ
આ ચોક્કસ વર્તન.

300
00:13:37,632 --> 00:13:38,340
પરંતુ તે કામ કરે છે.

301
00:13:38,340 --> 00:13:41,200
તેને સમજાવવા માટે માત્ર અહીં છે
અમે ખરેખર નથી કે બિંદુ

302
00:13:41,200 --> 00:13:44,530
અંદર શું થાય છે કાળજી
લાંબા તરીકે કાળા બોક્સ,

303
00:13:44,530 --> 00:13:46,510
તે અમે અપેક્ષા કે આઉટપુટ ધરાવે છે.

304
00:13:46,510 --> 00:13:48,870
આ એક રચના નબળી બ્લેક બોક્સ છે.

305
00:13:48,870 --> 00:13:53,801
પરંતુ અંતે દિવસ, તે કરે છે
હજુ આઉટપુટ વતા b ની રકમ.

306
00:13:53,801 --> 00:13:54,300
બધા અધિકાર.

307
00:13:54,300 --> 00:13:56,320
તેથી અમે કાર્યો જાહેર કર્યું છે.

308
00:13:56,320 --> 00:13:57,490
અને અમે કાર્ય વ્યાખ્યાયિત કર્યું.

309
00:13:57,490 --> 00:13:58,540
તેથી તે ખરેખર સારી છે.

310
00:13:58,540 --> 00:14:03,020
હવે વિધેયો વાપરવા માટે શરૂ કરો
કે અમે જાહેર કર્યું છે અને અમે વ્યાખ્યાયિત કર્યું.

311
00:14:03,020 --> 00:14:05,960
તે ખરેખર એક function-- કૉલ કરવા માટે
તમે શું કરવાની જરૂર બધા ખૂબ easy--

312
00:14:05,960 --> 00:14:09,070
યોગ્ય દલીલોને પસાર છે,
ડેટા પ્રકાર દલીલો

313
00:14:09,070 --> 00:14:11,600
તે અપેક્ષા છે, અને
પછી પરત સોંપી

314
00:14:11,600 --> 00:14:15,190
તે કાર્ય કિંમત
અને છે આ બહાનું me--

315
00:14:15,190 --> 00:14:19,390
તે કાર્ય વળતર કિંમત સોંપી
યોગ્ય પ્રકાર કંઈક છે.

316
00:14:19,390 --> 00:14:22,410
>> તેથી આપણે પર એક નજર હોય દો
ફાઈલ માં આ પ્રથા

317
00:14:22,410 --> 00:14:27,730
કહેવાય નાનો ઝેરી સાંપ 1 ટપકું સી, જે
હું મારા CS50 IDE હોય છે.

318
00:14:27,730 --> 00:14:31,042
તેથી અહીં નાનો ઝેરી સાંપ 1 ટપકું સી.

319
00:14:31,042 --> 00:14:33,500
શરૂઆતમાં તમે મારી પાસે જોવા
મારા સમાવેશ થાય છે, પાઉન્ડ, સમાવેશ થાય છે

320
00:14:33,500 --> 00:14:35,460
ધોરણ આઇઓ અને CS50 ટપકું એચ.

321
00:14:35,460 --> 00:14:37,700
અને પછી હું મારા કાર્ય ઘોષણા છે.

322
00:14:37,700 --> 00:14:39,570
હું આ તે છે જ્યાં
હું કમ્પાઇલર કહેવાની

323
00:14:39,570 --> 00:14:42,850
એક લખી શકાય જઈ
કહેવાય કાર્ય બે ints ઉમેરો.

324
00:14:42,850 --> 00:14:45,780
તે આઉટપુટ એક ચાલી રહ્યું છે
પૂર્ણાંક પ્રકાર ચલ.

325
00:14:45,780 --> 00:14:47,360
કે આ ભાગ અહીં છે શું છે.

326
00:14:47,360 --> 00:14:51,950
અને પછી હું તે બે ઇનપુટ્સ છે
અને બી, જેમાં દરેક એક પૂર્ણાંક છે.

327
00:14:51,950 --> 00:14:58,250
મુખ્ય અંદર, હું માટે વપરાશકર્તા પૂછો
કહેતા ઇનપુટ, મને એક પૂર્ણાંક આપે છે.

328
00:14:58,250 --> 00:15:01,040
અને તેઓ ભૂલી કરવા માટે પૂછવામાં આવે
એક કાર્ય છે કે જે પૂર્ણાંક છે, કે જે

329
00:15:01,040 --> 00:15:03,240
CS50 પુસ્તકાલય સમાવેશ થાય છે.

330
00:15:03,240 --> 00:15:07,660
અને તે સંગ્રહિત નહીં
એક્સ, પૂર્ણાંક ચલ.

331
00:15:07,660 --> 00:15:09,886
>> પછી અમે બીજા પૂર્ણાંક માટે તેમને પૂછવા.

332
00:15:09,886 --> 00:15:13,070
અમે બીજા પૂર્ણાંક વિચાર
અને વાય કે સ્ટોર કરે છે.

333
00:15:13,070 --> 00:15:17,990
અને પછી, અહીં લીટી 28 પર છે
જ્યાં અમે અમારા કાર્ય કૉલ કરો.

334
00:15:17,990 --> 00:15:23,770
અમે પૂર્ણાંક z સમકક્ષ કહી રહ્યા છે
2 ints X અલ્પવિરામ વાય ઉમેરો.

335
00:15:23,770 --> 00:15:25,980
આ અર્થમાં બનાવે છે શા માટે તમે જુઓ છો?

336
00:15:25,980 --> 00:15:29,710
X પૂર્ણાંક પ્રકાર ચલ છે અને
વાય પૂર્ણાંક પ્રકાર ચલ છે.

337
00:15:29,710 --> 00:15:31,220
તેથી તે સારી છે.

338
00:15:31,220 --> 00:15:34,570
શું અમારા કાર્ય સાથે તે અર્થમાં બનાવવા
વાક્ય પર 17 ઘોષણા જેવો દેખાય છે.

339
00:15:34,570 --> 00:15:38,300
આ અલ્પવિરામથી અલગ પડેલ ઇનપુટ યાદી
બે પૂર્ણાંકો, A અને B અપેક્ષા છે.

340
00:15:38,300 --> 00:15:40,300
તે કિસ્સામાં, અમે કહી શકો છો
તેમને ગમે અમે માંગો છો.

341
00:15:40,300 --> 00:15:42,300
તે માત્ર બે પૂર્ણાંકો અપેક્ષા છે.

342
00:15:42,300 --> 00:15:44,930
અને એક્સ પૂર્ણાંક છે અને વાય પૂર્ણાંક છે.

343
00:15:44,930 --> 00:15:45,640
તે કામ કરે છે.

344
00:15:45,640 --> 00:15:48,680
>> અને અમે તે કાર્ય ચાલે છે ખબર
આઉટપુટ માટે પૂર્ણાંકો તેમજ.

345
00:15:48,680 --> 00:15:51,290
અને તેથી અમે સંગ્રહિત કરવામાં આવે છે
કાર્ય ઉત્પાદન

346
00:15:51,290 --> 00:15:56,050
પૂર્ણાંક પ્રકાર માં, બે ints ઉમેરો
ચલ, અમે z કૉલ કરી રહ્યાં છો છે.

347
00:15:56,050 --> 00:16:01,980
અને પછી અમે આ રકમ કહી શકો છો
ટકા અને હું ટકા હું ટકા છે.

348
00:16:01,980 --> 00:16:06,210
એક્સ, વાય અને ઝેડ અનુક્રમે
તે ટકા હું માતાનો ભરતા.

349
00:16:06,210 --> 00:16:08,334
વ્યાખ્યા શું છે
બે ints જેવા દેખાવ ઉમેરવા?

350
00:16:08,334 --> 00:16:09,125
તે ખૂબ સરળ છે.

351
00:16:09,125 --> 00:16:11,270
તે રાશિઓ એક છે અમે
માત્ર એક સેકંડ પહેલા જોયું

352
00:16:11,270 --> 00:16:14,390
પૂર્ણાંક રકમ એક વતા b રીટર્ન રકમ સમકક્ષ હોય છે.

353
00:16:14,390 --> 00:16:15,420
આ કામ કરે છે?

354
00:16:15,420 --> 00:16:17,270
માતાનો ફાઈલ સંગ્રહો દો.

355
00:16:17,270 --> 00:16:22,080
અને પછી નીચે અહીં મારા ટર્મિનલ પર
હું નાનો ઝેરી સાંપ 1 બનાવવા જઈ રહ્યો છું

356
00:16:22,080 --> 00:16:23,000
અને હું મારી સ્ક્રીન સાફ કરો.

357
00:16:23,000 --> 00:16:25,791
હું ખબર છે કારણ કે ઝૂમ કરવા જઇ રહ્યો છું
તેને જોવા માટે થોડી મુશ્કેલ છે.

358
00:16:25,791 --> 00:16:31,520

359
00:16:31,520 --> 00:16:33,770
>> તેથી અમે નાનો ઝેરી સાંપ 1 તરીકે આ કાર્યક્રમ કમ્પાઇલ.

360
00:16:33,770 --> 00:16:37,910
તેથી અમે કોઈ સ્લેશ નાનો ઝેરી સાંપ 1 કરી શકે છે.

361
00:16:37,910 --> 00:16:40,060
10 મને પૂર્ણાંક આપો.

362
00:16:40,060 --> 00:16:42,380
20 મને બીજા પૂર્ણાંક આપો.

363
00:16:42,380 --> 00:16:45,200
10 અને 20 ની રકમ 30 છે.

364
00:16:45,200 --> 00:16:47,615
તેથી અમે એક સફળ કાર્ય કોલ કર્યો હતો.

365
00:16:47,615 --> 00:16:55,820
તમે નકારાત્મક કાર્ય ફરી ચલાવી શકો છો
10, -10 અને 17 17 રકમ 7 છે.

366
00:16:55,820 --> 00:16:57,120
આ કાર્ય કામ કરે છે.

367
00:16:57,120 --> 00:16:59,240
તે વર્તન ધરાવે છે
અમે તેને અપેક્ષા છે.

368
00:16:59,240 --> 00:17:03,610
અને તેથી અમે સફળ કર્યા છે
કાર્ય, વ્યાખ્યા, ઘોષણા,

369
00:17:03,610 --> 00:17:07,288
અને સફળ કાર્ય કૉલ કરો.

370
00:17:07,288 --> 00:17:09,079
દંપતી ન હોય તેવા પરચૂરણ
કાર્યો વિશે પોઇન્ટ

371
00:17:09,079 --> 00:17:10,611
અમે આ વિભાગમાં તારણ પહેલાં.

372
00:17:10,611 --> 00:17:12,319
યાદ અમારા
ડેટા પ્રકારો ચર્ચા,

373
00:17:12,319 --> 00:17:16,109
પહેલાં, કાર્યો કે
ક્યારેક કોઈ ઇનપુટ્સ લઇ શકે છે.

374
00:17:16,109 --> 00:17:17,930
જો કે આ કેસ છે, તો અમે
કાર્ય જાહેર

375
00:17:17,930 --> 00:17:19,788
રદબાતલ દલીલ યાદી કર્યા છે.

376
00:17:19,788 --> 00:17:21,579
તમે શું યાદ કરો
સૌથી સામાન્ય કાર્ય

377
00:17:21,579 --> 00:17:25,036
અમે અત્યાર સુધી લે છે કે જોઇ
રદબાતલ દલીલ યાદી છે?

378
00:17:25,036 --> 00:17:27,300
તે મુખ્ય છે.

379
00:17:27,300 --> 00:17:30,850
ક્યારેક પણ છે કે જે કાર્ય યાદ
ખરેખર એક આઉટપુટ નથી.

380
00:17:30,850 --> 00:17:34,210
તે કિસ્સામાં, અમે કાર્ય જાહેર
રદબાતલ પરત પ્રકાર કર્યા છે.

381
00:17:34,210 --> 00:17:37,880
દ્વારા આ વિભાગમાં તારણ દો
પ્રેક્ટિસ સમસ્યા હાથ ધરવા.

382
00:17:37,880 --> 00:17:39,900
>> તેથી અહીં બહાર નાખ્યો સમસ્યા છે.

383
00:17:39,900 --> 00:17:43,630
હું તમને એક કાર્ય લખવા માંગો છો
માન્ય ત્રિકોણ કહેવાય છે.

384
00:17:43,630 --> 00:17:47,410
આ કાર્ય શું કરવું જોઈએ
ત્રણ વાસ્તવિક સંખ્યાઓ લઇ આવે છે

385
00:17:47,410 --> 00:17:51,930
કે ત્રણ ની લંબાઈ પ્રતિનિધિત્વ
તેના પરિમાણો તરીકે એક ત્રિકોણ ના બાજુઓ,

386
00:17:51,930 --> 00:17:54,550
અથવા તેની દલીલો, અથવા તેના
સમાનાર્થી અન્ય સમૂહ inputs--

387
00:17:54,550 --> 00:17:57,340
તમે અનુભવી શકે છે.

388
00:17:57,340 --> 00:18:01,120
આ કામ કરીશું
આઉટપુટ ક્યાં સાચું કે ખોટું

389
00:18:01,120 --> 00:18:04,960
તેના પર આધાર રાખીને તે ત્રણ લંબાઈ કે શું
એક ત્રિકોણ બનાવવા માટે સક્ષમ છે.

390
00:18:04,960 --> 00:18:09,930
તમે માહિતી પ્રકાર યાદ છે કે
અમે સાચું કે ખોટું દર્શાવવા માટે ઉપયોગ?

391
00:18:09,930 --> 00:18:11,436
હવે તમે આ કેવી રીતે અમલ કરી શકું?

392
00:18:11,436 --> 00:18:13,810
વેલ એક દંપતી છે ખબર
ત્રિકોણ સંબંધિત નિયમો

393
00:18:13,810 --> 00:18:15,480
કે ખરેખર ખબર માટે ઉપયોગી છે.

394
00:18:15,480 --> 00:18:18,292
એક ત્રિકોણ માત્ર હોઈ શકે છે
હકારાત્મક લંબાઈ સાથે બાજુઓ.

395
00:18:18,292 --> 00:18:19,000
તે અર્થમાં બનાવે છે.

396
00:18:19,000 --> 00:18:21,432
તમે કદાચ duh, કહી રહ્યાં છે.

397
00:18:21,432 --> 00:18:23,390
અન્ય વસ્તુ એ નોંધવું
જોકે, આ રકમ છે

398
00:18:23,390 --> 00:18:25,484
કોઇ લંબાઈ
ત્રિકોણ બે બાજુઓ

399
00:18:25,484 --> 00:18:27,650
આ કરતાં વધારે હોઈ શકે છે
ત્રીજા બાજુ લંબાઈ.

400
00:18:27,650 --> 00:18:28,690
તે ખરેખર સાચું છે.

401
00:18:28,690 --> 00:18:34,150
તમે બાજુઓ 1 ત્રિકોણ હોઈ શકે નહિં
ઉદાહરણ તરીકે 2 અને 4, 1 વત્તા 2 કારણ કે

402
00:18:34,150 --> 00:18:36,270
4 કરતાં મોટો નથી.

403
00:18:36,270 --> 00:18:38,870
તે જેથી નિયમો છે કે
નક્કી ત્રણ કે નહીં

404
00:18:38,870 --> 00:18:42,740
ઇનપુટ્સ વિચાર એક ત્રિકોણ રચે છે શકે છે.

405
00:18:42,740 --> 00:18:46,360
તેથી બે મિનિટ લે છે
અને જાહેર અને પછી નક્કી કરે છે

406
00:18:46,360 --> 00:18:49,810
માન્ય કહેવાય કાર્ય
ત્રિકોણ, જેમ કે તે ખરેખર

407
00:18:49,810 --> 00:18:51,650
અહીં સ્પષ્ટ વર્તન ધરાવે છે.

408
00:18:51,650 --> 00:18:57,030
>> તે કરશે આઉટપુટ સાચી તે ત્રણ બાજુઓ તો
એક ત્રિકોણ સમાવેશ થાય છે માટે સક્ષમ હોય છે

409
00:18:57,030 --> 00:19:01,950
અને ખોટા અન્યથા
તમે કર્યું જોવા માટે કેવી રીતે તૈયાર છો?

410
00:19:01,950 --> 00:19:04,650
અહીં એક અમલીકરણ છે
માન્ય ત્રિકોણ.

411
00:19:04,650 --> 00:19:05,770
તે માત્ર એક નથી.

412
00:19:05,770 --> 00:19:07,770
તમારો સહેજ બદલાઇ શકે છે.

413
00:19:07,770 --> 00:19:11,040
પરંતુ આ એક હકીકત એ છે કે, હોય છે, કરે છે
અમે અપેક્ષા છે કે વર્તન.

414
00:19:11,040 --> 00:19:14,450
અમે અમારા કાર્ય જાહેર
ખૂબ જ ટોચ, માન્ય ત્રિકોણ bool

415
00:19:14,450 --> 00:19:16,630
X ફ્લોટ વાય ફ્લોટ z તરતા રહે છે.

416
00:19:16,630 --> 00:19:18,930
તેથી ફરીથી, આ કાર્ય
ત્રણ વાસ્તવિક સંખ્યાઓ લે

417
00:19:18,930 --> 00:19:22,280
તેની દલીલો તરીકે, ફ્લોટિંગ
બિંદુ કિંમત ચલો,

418
00:19:22,280 --> 00:19:26,510
અને સાચું કે ખોટું આઉટપુટ
બુલિયન, સ્મૃતિ છે, જે કિંમત.

419
00:19:26,510 --> 00:19:28,660
પરત પ્રકાર bool છે તેથી કે શા માટે છે.

420
00:19:28,660 --> 00:19:30,016
પછી અમે કાર્ય વ્યાખ્યાયિત કરે છે.

421
00:19:30,016 --> 00:19:33,140
આપણે શું પ્રથમ વસ્તુ તેની ખાતરી કરવા માટે ચકાસો
કે બાજુઓ, બધી હકારાત્મક છે.

422
00:19:33,140 --> 00:19:37,010
X કરતાં ઓછા અથવા સમાન હોય તો
0, વાય અથવા 0 સમાન છે, તો

423
00:19:37,010 --> 00:19:41,050
અથવા z, કરતાં ઓછી અથવા 0 સમાન છે, તો
કે કદાચ એક ત્રિકોણ ન હોઈ શકે.

424
00:19:41,050 --> 00:19:42,380
તેઓ હકારાત્મક બાજુઓ નથી.

425
00:19:42,380 --> 00:19:45,790
અને તેથી અમે પાછા આવી શકો છો
તે પરિસ્થિતિમાં ખોટા.

426
00:19:45,790 --> 00:19:49,010
આગળ, અમે ખાતરી કરવા માટે ચકાસણી
કે ઇનપુટ્સ દરેક જોડી

427
00:19:49,010 --> 00:19:51,830
ત્રીજા એક કરતાં વધારે હોય છે.

428
00:19:51,830 --> 00:19:54,530
>> તેથી એક્સ વત્તા વાય ઓછી હોય તો
Z માટે એક કરતાં વધારે અથવા બરાબર,

429
00:19:54,530 --> 00:19:57,060
અથવા એક્સ વત્તા z ઓછી હોય તો
વાય કરતાં અથવા સમાન,

430
00:19:57,060 --> 00:20:01,730
અથવા y વતા z તો કરતાં ઓછા અથવા સમાન છે
એક્સ, કે જે પણ માન્ય ત્રિકોણ ન હોઈ શકે.

431
00:20:01,730 --> 00:20:03,800
તેથી અમે ફરીથી ખોટા આવો.

432
00:20:03,800 --> 00:20:06,900
ધારી રહ્યા છીએ કે અમે તપાસમાં બંને પસાર
છતાં, તો પછી અમે સાચું પાછા શકે છે.

433
00:20:06,900 --> 00:20:09,440
તે ત્રણ બાજુઓ કારણ કે
returning-- સક્ષમ છે

434
00:20:09,440 --> 00:20:11,647
માન્ય ત્રિકોણ બનાવવા.

435
00:20:11,647 --> 00:20:12,230
અને તે છે.

436
00:20:12,230 --> 00:20:13,830
તમે હવે જાહેર અને વ્યાખ્યાયિત કર્યું છે.

437
00:20:13,830 --> 00:20:17,330
અને હવે તમે કરવાનો પ્રયત્ન કરી શકે
ઉપયોગ કરે છે અને આ કાર્ય કૉલ કરો.

438
00:20:17,330 --> 00:20:19,470
મહાન કામ.

439
00:20:19,470 --> 00:20:20,650
હું ડો લોયડ છું.

440
00:20:20,650 --> 00:20:22,820
આ CS50 છે.

441
00:20:22,820 --> 00:20:24,340