1
00:00:00,000 --> 00:00:03,160
>> ડેવિડ જે MALAN: અમે લખી ધારોકે
દરેક પૂછે છે કે એક કાર્યક્રમ

2
00:00:03,160 --> 00:00:06,740
તેમની ઉંમર અને પછી પ્રિન્ટ માટે એક રૂમ
તે લોકો એક હશે કે કેવી રીતે જૂના બહાર

3
00:00:06,740 --> 00:00:07,520
તેથી વર્ષ?

4
00:00:07,520 --> 00:00:09,900
હવે, દેખીતી રીતે આ માટે એરિથમેટિક
સમસ્યા એકદમ પ્રયત્ન રહ્યું છે

5
00:00:09,900 --> 00:00:10,660
સરળ.

6
00:00:10,660 --> 00:00:14,090
પરંતુ રસપ્રદ પ્રશ્ન હોય, ત્યારે
અગાઉથી ખબર નથી કેટલા લોકો

7
00:00:14,090 --> 00:00:16,790
આ રૂમ માં, કેવી રીતે હશે આવે છે
અમે સ્ટોર જઈ શકે છે

8
00:00:16,790 --> 00:00:17,980
તેમના ઉંમરના બધા?

9
00:00:17,980 --> 00:00:19,680
વેલ, જે એક નજર.

10
00:00:19,680 --> 00:00:22,760
>> પ્રથમ પૂછીને શરૂ થાય છે આ
વપરાશકર્તા, હું માટે, અહીં કર્યું છે

11
00:00:22,760 --> 00:00:26,410
મદદથી રૂમમાં લોકોની સંખ્યા
getInt અને કરવા માટે એક કરતા હો ત્યારે લૂપ

12
00:00:26,410 --> 00:00:28,220
પૂર્ણાંક n એ વિષે.

13
00:00:28,220 --> 00:00:32,310
અમે હવે એવી દરેક પૂછી શકો છો ધારો
તેમની ઉંમર માટે રૂમ માં વ્યક્તિ.

14
00:00:32,310 --> 00:00:35,820
ઠીક છે, મારા વૃત્તિ ઉપયોગ થઈ શકે છે એક
કે કરે છે, પરંતુ હું પણ માટે લૂપ

15
00:00:35,820 --> 00:00:37,840
સંગ્રહ કરવા સ્થળ જરૂર
તે લોકોની વય.

16
00:00:37,840 --> 00:00:40,760
અને મારી પ્રથમ વૃત્તિ હશે
પ્રથમ માટે ચલ ઉપયોગ

17
00:00:40,760 --> 00:00:43,690
વ્યક્તિ વય, અન્ય ચલ
બીજા વ્યક્તિ ઉંમર માટે,

18
00:00:43,690 --> 00:00:44,780
જેવું રેખાઓ.

19
00:00:44,780 --> 00:00:46,230
ઈન્ ઉંમર -

20
00:00:46,230 --> 00:00:48,850
વેલ, જે માટે 1 કૉલ કરો
પ્રથમ વ્યક્તિ.

21
00:00:48,850 --> 00:00:51,480
બીજી વ્યક્તિ માટે ઈન્ ઉંમર 2.

22
00:00:51,480 --> 00:00:53,980
ત્રીજી વ્યક્તિ માટે ઈન્ ઉંમર 3.

23
00:00:53,980 --> 00:00:56,750
>> પરંતુ એક મિનિટ રાહ જુઓ, આ કદાચ નથી
નીચે જવા માટે શ્રેષ્ઠ માર્ગ.

24
00:00:56,750 --> 00:01:00,620
હું અગાઉથી માં ખબર નથી કારણ કે
આ કાર્યક્રમ લેખન અને સંકલન કેવી રીતે

25
00:01:00,620 --> 00:01:02,330
ત્યાં ઘણા વપરાશકર્તાઓ હશે આવે છે.

26
00:01:02,330 --> 00:01:06,590
અને વધુમાં, જેમ કે ઘણા જો ત્યાં
100 ચલો જાહેર 100 વપરાશકર્તાઓ,

27
00:01:06,590 --> 00:01:10,350
આ નથી જેવા પ્રકારની વિચિત્ર રીતે નામ આપવામાં આવ્યું
ખૂબ જ શ્રેષ્ઠ ડિઝાઇન જેવી લાગે છે.

28
00:01:10,350 --> 00:01:14,430
>> વેલ, thankfully અન્ય ત્યાં હાજર છે
ચલ પ્રકારના એક એરે કહેવાય કે

29
00:01:14,430 --> 00:01:18,710
અમને ints કોઈપણ નંબર સ્ટોર કરવા માટે પરવાનગી આપે છે
તે અંદર, અમે ખબર નથી, પણ જો

30
00:01:18,710 --> 00:01:22,190
મારા પ્રોગ્રામ લખવાની જ્યારે કેટલા
જેમ કે ints અમે જરૂર જઈ રહ્યાં છો.

31
00:01:22,190 --> 00:01:25,970
તેથી આપણે backtrack દો અને આ કાઢી
તેના બદલે કેટલાક ints, અને બદલો

32
00:01:25,970 --> 00:01:29,620
એક ચલ કહેવાય છે,
, વય, બહુવચન છે.

33
00:01:29,620 --> 00:01:33,420
પરંતુ વધુ આ વાક્ય પર સ્પષ્ટ કરો
ચોરસ કૌંસમાં કોડ કે અમે

34
00:01:33,420 --> 00:01:35,460
n એ ints માંગો છો.

35
00:01:35,460 --> 00:01:39,570
અને તેથી, અમે સામૂહિક કરશે
ઉંમરના આ ints માટે નો સંદર્ભ લો.

36
00:01:39,570 --> 00:01:43,490
>> હવે માત્ર એક ક્ષણ હું વિચાર કરી શકશો
આ એરે માં ints દરેક

37
00:01:43,490 --> 00:01:47,270
એ જ રીતે ચોરસ કૌંસ માર્ગ દ્વારા
સંકેતલિપિ, 0 અંતે શરૂ થાય છે.

38
00:01:47,270 --> 00:01:51,720
તેથી આપણે માટે લૂપ હવે આગળ વધવા દો
તેઓની વય માટે વપરાશકર્તાઓ પૂછવા.

39
00:01:51,720 --> 00:01:54,780
પૂર્ણાંક માટે હું 0 વિષે.

40
00:01:54,780 --> 00:01:59,464
હું એન કરતાં ઓછી છે, લોકોની સંખ્યા
ઓરડામાં, હું વત્તા વત્તા.

41
00:01:59,464 --> 00:02:06,610
>> અને હવે આ લૂપ અંદર, આપણે કહેવું
વ્યક્તિ નંબર છે, ટકા હું printf ઉંમર

42
00:02:06,610 --> 00:02:09,430
પ્લેસહોલ્ડર, અલ્પવિરામ છે.

43
00:02:09,430 --> 00:02:13,210
અને હવે, બદલે થી ગણતરી શરૂ
કાર્યક્રમ પોતાના છે, ચાલો પર 0

44
00:02:13,210 --> 00:02:17,180
1 દ્વારા ઓછા ઈજાફો હું કે સામાન્ય
આ કાર્યક્રમ વાપરી વ્યક્તિ

45
00:02:17,180 --> 00:02:20,120
એક જેવી ગણતરી નથી
કોમ્પ્યુટર વૈજ્ઞાનિક શકે છે.

46
00:02:20,120 --> 00:02:26,130
હવે યુગો કૌંસ હું ત્યાં દો
સ્પષ્ટ છે કે માં-i મી ઉંમર અમારા

47
00:02:26,130 --> 00:02:31,480
ઉંમરના એરે વિચાર રહ્યું છે
getInt પરત કિંમત.

48
00:02:31,480 --> 00:02:37,800
>> હવે આ લૂપ નીચે, ચાલો આગળ વધો દો
કેટલાક સમય પસાર કરી રહ્યો છે માટે.

49
00:02:37,800 --> 00:02:41,690
અને હવે અન્ય લુપમાં આગળ વધવા દો
ખરેખર રૂમમાં દરેક ઉંમર માટે

50
00:02:41,690 --> 00:02:42,800
એક વર્ષ છે.

51
00:02:42,800 --> 00:02:48,110
તેથી ફરી, હું 0 વિચાર પૂર્ણાંક માટે, હું ઓછી છે
એન કરતા, માં લોકોની સંખ્યા

52
00:02:48,110 --> 00:02:49,680
રૂમ, હું વત્તા વત્તા.

53
00:02:49,680 --> 00:02:57,210
>> અને હવે આ લૂપની અંદર, ચાલો કહે
હવે વ્યક્તિ નંબર એક વર્ષ printf,

54
00:02:57,210 --> 00:03:00,990
ટકા હું પ્લેસહોલ્ડર છે, કરશે
કરી, ટકા હું અન્ય છે

55
00:03:00,990 --> 00:03:03,210
વર્ષનો પ્લેસહોલ્ડર,.

56
00:03:03,210 --> 00:03:07,230
અને પછી તે માં પ્લગ કરવા
જગ્યામાં, પ્રથમ હું કહેવું વત્તા

57
00:03:07,230 --> 00:03:11,220
1, જેથી ફરી અમે ગણતરી શરૂ
1 ના વપરાશકર્તા માટે.

58
00:03:11,220 --> 00:03:18,630
અને પછી આપણે તે વ્યક્તિ ઉંમર પ્લગ દો
ત્યાં વય કૌંસ હું વત્તા 1, તરીકે

59
00:03:18,630 --> 00:03:23,740
માં-i મી ઉંમર મળે જાઓ સ્પષ્ટ અમારા
ઉંમરના અરે, પછી તે માટે 1 ઉમેરવા, અને

60
00:03:23,740 --> 00:03:28,370
અમારા પ્લેસહોલ્ડર માં કે રકમ દાખલ કરો,
બંધ કૌંસ, અર્ધવિરામ.

61
00:03:28,370 --> 00:03:33,280
>> હવે તમારી સાથે આ કાર્યક્રમ કમ્પાઇલ
ઉંમરના અને માતાનો ડોટ સાથે ચલાવવા દો

62
00:03:33,280 --> 00:03:34,990
ઉંમરના સ્લેશ.

63
00:03:34,990 --> 00:03:38,770
અને માત્ર ત્રણ છે કે ધારો
રૂમમાં લોકો, અને કોઈ 18 વર્ષ છે,

64
00:03:38,770 --> 00:03:40,700
કોઈને 19 છે, કોઈ 20 છે.

65
00:03:40,700 --> 00:03:45,350
વેલ, એક વર્ષ, દરેક તે લોકો
, 19, 20, અને 21 પ્રયત્ન રહ્યું છે

66
00:03:45,350 --> 00:03:46,600
અનુક્રમે.

67
00:03:46,600 --> 00:03:48,948