1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,500
ચાન: તે મને Zamyla છે.

3
00:00:02,500 --> 00:00:06,910
મારિયો આજે અમે પ્રયત્ન જઈ રહ્યાં છો
મારિયો માટે અડધા પિરામિડ ચિત્રકામ

4
00:00:06,910 --> 00:00:08,290
ચઢી.

5
00:00:08,290 --> 00:00:11,570
>> તેથી આપણે તે વિશે વાત કરો અમારા
આ સમસ્યા માટે-શું.

6
00:00:11,570 --> 00:00:13,610
અમે માંગો છો જઈ રહ્યાં છો
પૂછવા અને માન્ય કરવા

7
00:00:13,610 --> 00:00:18,290
કેવી રીતે એક માન્ય ઇનપુટ માટે વપરાશકર્તા
ઉચ્ચ તેઓ મારિયો પિરામિડ પ્રયત્ન કરવા માંગો છો.

8
00:00:18,290 --> 00:00:20,090
અને પછી, અમે તે ડ્રો રહ્યા છીએ.

9
00:00:20,090 --> 00:00:24,870
તેથી આપણે પૂછવાની સાથે પ્રારંભ દો અને
તેમના ઇનપુટ માટે વપરાશકર્તા માન્ય.

10
00:00:24,870 --> 00:00:27,640
>> અમે ઉપયોગ કરી શકો છો
CS50 પુસ્તકાલય કાર્ય

11
00:00:27,640 --> 00:00:31,160
પૂર્ણાંક છે કે જે ખાતરી કરશે કે વિચાર
વપરાશકર્તા પૂર્ણાંક ઇનપુટ્સ.

12
00:00:31,160 --> 00:00:35,730
કોઇ પણ હકારાત્મક પૂર્ણાંકો, નકારાત્મક
પૂર્ણાંકો, નંબર 0 બધા વાજબી રમત છે.

13
00:00:35,730 --> 00:00:41,670
નહિંતર, વપરાશકર્તા માટે પૂછવામાં આવશે
તેઓ ઇનપુટ માન્ય પૂર્ણાંક સુધી ફરી પ્રયાસ કરો.

14
00:00:41,670 --> 00:00:44,210
હવે જોકે પૂર્ણાંક વિચાર કરે છે
અમારા માટે કામ ઘણું

15
00:00:44,210 --> 00:00:46,730
ખાતરી છે કે
વપરાશકર્તા અમને પૂર્ણાંક આપે છે,

16
00:00:46,730 --> 00:00:50,760
અમે હજુ પણ કેટલાક અરજી કરવાની જરૂર
કે પર વધારાની પરિમાણોને.

17
00:00:50,760 --> 00:00:56,420
બધા પછી, અમે મારિયો ચડતા હોઈ શકે નહિં
ઊંચાઈ નકારાત્મક 12 અડધા પિરામિડ.

18
00:00:56,420 --> 00:00:59,040
>> આ ઉપરાંત,
સમસ્યા સ્પષ્ટીકરણ

19
00:00:59,040 --> 00:01:02,490
કહે છે કે અમે માત્ર આ કરી શકો છો
મારિયો ચઢી કરવા માટે પરવાનગી આપે

20
00:01:02,490 --> 00:01:06,940
0 અને 23 વચ્ચે ઊંચાઈ એક પિરામિડ.

21
00:01:06,940 --> 00:01:11,120
ઠીક છે, કે જેથી અર્થ એ થાય કે અમે જરૂર
સતત વપરાશકર્તા પૂછવા

22
00:01:11,120 --> 00:01:14,320
અમને માન્ય આપી
નંબર અને માત્ર ચાલુ

23
00:01:14,320 --> 00:01:17,120
એક વાર તેઓ અમને માન્ય ઊંચાઇ આપી છે.

24
00:01:17,120 --> 00:01:18,720
અમે તે કેવી રીતે કરવું?

25
00:01:18,720 --> 00:01:23,760
>> વેલ, સતત પ્રક્રિયાઓ અમને આપો
loops-- કંઈક કરવાની વિચાર

26
00:01:23,760 --> 00:01:24,720
repetitively.

27
00:01:24,720 --> 00:01:28,220
જ્યારે કે સી એક લૂપ
લૂપ કે સતત ચાલશે

28
00:01:28,220 --> 00:01:33,480
તરીકે લાંબા સમય સુધી લૂપ શરીર ચલાવવા
આપેલ શરત સાચું મૂલ્યાંકન કરે છે.

29
00:01:33,480 --> 00:01:36,200
જલદી કે શરત તરીકે
ખોટા મૂલ્યાંકન,

30
00:01:36,200 --> 00:01:39,770
કાર્યક્રમ માટે આગળ વધવું પડશે
ગમે તે પછી આવે છે.

31
00:01:39,770 --> 00:01:43,180
તેથી જ્યારે આંટીઓ એક રીત છે
કે અમે સતત ખાતરી

32
00:01:43,180 --> 00:01:45,320
માન્ય ઇનપુટ માટે વપરાશકર્તા પૂછવા.

33
00:01:45,320 --> 00:01:50,070
અને એકવાર તેઓ અમને માન્ય ઇનપુટ આપે છે,
અમે ગમે આગામી આવે છે કરવા માટે આગળ ધપાવો પડશે.

34
00:01:50,070 --> 00:01:54,380
અમે જાણીએ છીએ કે અમે પૂછો જઈ રહ્યાં છો
ઓછામાં ઓછા એક વખત ઇનપુટ માટે વપરાશકર્તા.

35
00:01:54,380 --> 00:01:59,200
તેથી હવે અમે એક બહેન આવવા
જ્યારે લૂપ છે, કે જે શું, જ્યારે લૂપ છે.

36
00:01:59,200 --> 00:02:02,650
>> જ્યારે આંટીઓ ચલાવવા કરશે
લૂપ શરીર ઓછામાં ઓછા એક વખત.

37
00:02:02,650 --> 00:02:06,150
તેથી સ્થિતિ ચકાસણી વિના,
તે લૂપ શરીર ચલાવવા કરશે.

38
00:02:06,150 --> 00:02:09,750
અને પછી સ્થિતિ તપાસો જોવા માટે
શું તે પોતે પુનરાવર્તન કરવાની જરૂર છે.

39
00:02:09,750 --> 00:02:13,080
આ હાથમાં જ્યારે આવે
અમે વપરાશકર્તા ઇનપુટ માન્ય કરી રહ્યાં છો.

40
00:02:13,080 --> 00:02:15,830
અમે જાણીએ છીએ કે અમે જઈ રહ્યાં છો
તેમને ઓછામાં ઓછા એક વખત પૂછો.

41
00:02:15,830 --> 00:02:18,780
તેથી શું જ્યારે લૂપ કદાચ
આ કંઈક જુઓ.

42
00:02:18,780 --> 00:02:20,090
અમે પૂર્ણાંક n એ છે.

43
00:02:20,090 --> 00:02:22,760
અને શું અંદર
જ્યારે લૂપ, અમે તરત જ

44
00:02:22,760 --> 00:02:24,750
પૂર્ણાંક માટે વપરાશકર્તા પૂછવા.

45
00:02:24,750 --> 00:02:29,740
જો એ અયોગ્ય છે, તો પછી અમે તેમને પૂછવા પડશે
ફરીથી અને ફરીથી અને ફરીથી તેઓ ત્યાં સુધી

46
00:02:29,740 --> 00:02:31,820
અમને માન્ય પૂર્ણાંક આપે છે.

47
00:02:31,820 --> 00:02:37,440
છેલ્લે, એક વાર એ એક માન્ય ઇનપુટ છે, અમે પડશે
અમારા કાર્યક્રમ બાકીના માટે આગળ ધપાવો.

48
00:02:37,440 --> 00:02:41,830
>> તેથી માતાનો સ્પેક અને ચેક પર પાછા જાઓ
શું એક માન્ય ઇનપુટ માટે શરતો

49
00:02:41,830 --> 00:02:43,670
હોઈ ચાલે છે.

50
00:02:43,670 --> 00:02:48,090
માન્ય ઊંચાઈ પર જતા હોય છે
0 અને 23, વ્યાપક વચ્ચે હોય છે.

51
00:02:48,090 --> 00:02:53,350
તેથી અમાન્ય ઊંચાઈ પર જતા હોય છે
0 કરતાં ઓછા અથવા 23 કરતાં વધુ હોઈ શકે છે.

52
00:02:53,350 --> 00:02:56,420
જેથી ડિઝાઇન કરવા માટે યાદ
તમારી સ્થિતિ કાળજીપૂર્વક

53
00:02:56,420 --> 00:02:58,660
જાણીને શરત છે કે
શું જ્યારે લૂપ માટે

54
00:02:58,660 --> 00:03:01,470
હોવા જોઈએ એ અમાન્ય છે.

55
00:03:01,470 --> 00:03:05,080
હવે આ એક હોઈ નથી જઈ રહ્યા છે
સરળ એક બુલિયન અભિવ્યક્તિ.

56
00:03:05,080 --> 00:03:07,630
અમે ભેગા છે જઈ રહ્યાં છો
બે અલગ અલગ સમીકરણો

57
00:03:07,630 --> 00:03:09,900
અમારા સમગ્ર સ્થિતિ બનાવવા માટે.

58
00:03:09,900 --> 00:03:13,290
>> તેથી આપણે માત્ર એક સત્ય ટેબલ હું કર્યું જોવા દો
પહેલેથી જ તમે સંકેતની અમે છો કે જે આપેલ

59
00:03:13,290 --> 00:03:15,200
બે બુલિયનો સાથે વ્યવહાર કરવામાં જઈ રહી છે.

60
00:03:15,200 --> 00:03:19,620
તેથી અહીં એક સત્ય ટેબલ જ્યાં હું
બે Booleans-- બુલિયન 1 અને 2 છે.

61
00:03:19,620 --> 00:03:27,050
તેથી અમે મૂલ્યાંકન કરવા માટે વિકલ્પ હોય છે
bool1 અને bool2 અથવા bool1 અથવા bool2.

62
00:03:27,050 --> 00:03:31,980
અને માત્ર બંને જો સાચું હશે
બુલિયનો, સાચું મૂલ્યાંકન જ્યારે બધા

63
00:03:31,980 --> 00:03:37,280
અથવા લાંબા સમય સુધી સાચું હશે એક તરીકે
બે બુલિયનો સાચું મૂલ્યાંકન કરે છે.

64
00:03:37,280 --> 00:03:41,450
ઠીક છે, તેથી એક ક્ષણ લે છે, આ વિરામ
વિડિઓ અને આ સત્ય ટેબલ પાચન.

65
00:03:41,450 --> 00:03:42,930
હું અહીં રાહ જોઈ હશો.

66
00:03:42,930 --> 00:03:45,760
જ્યારે તમે પાછા આવો, જુઓ
તમે મળીને ભાગ કરી શકો છો જો

67
00:03:45,760 --> 00:03:51,910
માટે બુલિયન અભિવ્યક્તિ તમારા
એ શરત અમાન્ય ઇનપુટ છે.

68
00:03:51,910 --> 00:03:54,420
>> તેથી હવે અમે કે જે
માન્ય વપરાશકર્તા ઈનપુટ, ચાલો

69
00:03:54,420 --> 00:03:58,710
આગળ જાઓ અને કેવી રીતે અમે વિશે વાત
અડધા પિરામિડ દોરે.

70
00:03:58,710 --> 00:04:03,410
અહીં આ સરળ લખાણ સંપાદકમાં,
હું ડાબી ગોઠવાયેલ પિરામિડ દોરવામાં કર્યું છે.

71
00:04:03,410 --> 00:04:07,050
પરંતુ આપણે જાણીએ છીએ કે અમે અમારા જરૂર
પિરામિડ અધિકાર ગોઠવાયેલ શકાય.

72
00:04:07,050 --> 00:04:08,650
તેથી હું આ કેવી રીતે કરી શકે છે?

73
00:04:08,650 --> 00:04:11,440
ઠીક છે, હું દબાણ કરવાનો પ્રયાસ કરી શકે
બાજુ બધું

74
00:04:11,440 --> 00:04:14,880
માત્ર થોડી મૂકીને
વચ્ચે પાત્ર.

75
00:04:14,880 --> 00:04:16,779
અને પછી, આગામી માટે
રેખા, હું મૂકી જાઉં છું

76
00:04:16,779 --> 00:04:20,970
કેટલાક વધુ અક્ષરો તેને દબાણ સાથે,
અને further-- તેથી પર અને તેથી forth--

77
00:04:20,970 --> 00:04:23,360
ત્યાં સુધી હું અધિકાર ગોઠવાયેલ પિરામિડ છે.

78
00:04:23,360 --> 00:04:27,780
તેથી અમે એક જમણે સંરેખિત કરો પિરામિડ હોય છે, પરંતુ
તે બિંદુઓ સાથે જેથી મહાન લાગતું નથી.

79
00:04:27,780 --> 00:04:30,680
પરંતુ અમે હજુ પણ કરવા માંગો છો
કે સરસ અંતર જાળવી રાખે છે.

80
00:04:30,680 --> 00:04:35,260
તેથી હું શાબ્દિક જાઉં છું
કેટલાક જગ્યાઓ દાખલ કરો.

81
00:04:35,260 --> 00:04:39,420
>> તેના બદલે ત્રણ બિંદુઓ, હું પડશે
એક, બે, ત્રણ જગ્યાઓ મૂકો.

82
00:04:39,420 --> 00:04:40,370
બીજા વાક્ય પર.

83
00:04:40,370 --> 00:04:42,640
હું એક, બે જગ્યાઓ મૂકીશું.

84
00:04:42,640 --> 00:04:45,370
અને ઉપાંત્ય પર
રેખા, માત્ર એક જગ્યા.

85
00:04:45,370 --> 00:04:48,290
અને અહીં હું અધિકાર ગોઠવાયેલ પિરામિડ છે.

86
00:04:48,290 --> 00:04:52,170
લખાણ ઉદાહરણ કરવાથી
સંપાદક, અમે પેટર્ન માટે વિચાર છે

87
00:04:52,170 --> 00:04:54,590
કે અમે અડધા પિરામિડ ડ્રો ઉપયોગ કરશો.

88
00:04:54,590 --> 00:04:58,080
દરેક પંક્તિ માટે, અમે શું કર્યું
અમે કેટલાક જગ્યાઓ પ્રકાર છે,

89
00:04:58,080 --> 00:05:00,170
કેટલાક અને પછી લખેલા
હેશો, અને પછી લખેલા

90
00:05:00,170 --> 00:05:03,020
Enter કી, કે જે
એક નવી લાઇન બનાવી છે.

91
00:05:03,020 --> 00:05:07,770
તેથી હવે અમે કે જે, માતાનો જવા દો
એક પગલું આગળ અને એક પેટર્ન શોધવા.

92
00:05:07,770 --> 00:05:10,170
>> તેથી હું કહેવા જાઉં છું, માટે
આ ઉદાહરણ રસ,

93
00:05:10,170 --> 00:05:12,480
અમે 8 ની ઊંચાઈ સાથે કામ કરીએ છીએ.

94
00:05:12,480 --> 00:05:17,100
પ્રથમ પંક્તિ બે હોય રહ્યું છે
હેશો સાત જગ્યાઓ અનુસરે છે.

95
00:05:17,100 --> 00:05:20,020
second-- ત્રણ હેશો, છ જગ્યાઓ.

96
00:05:20,020 --> 00:05:24,260
ત્રીજા હરોળ ચાર હેશો, પાંચ
જગ્યાઓ તેથી પર અને તેથી આગળ

97
00:05:24,260 --> 00:05:26,350
ત્યાં સુધી અમે nth પંક્તિ મળે છે.

98
00:05:26,350 --> 00:05:31,540
તેથી, હું nth પંક્તિ માટે પૂછશે,
કેટલા હેશો અમે હોય જતાં હોય છે

99
00:05:31,540 --> 00:05:33,120
અને કેટલી જગ્યાઓ?

100
00:05:33,120 --> 00:05:37,000
તેથી તે બહાર આકૃતિ તમે નક્કી કરો
ફોર્મ્યુલા કેટલા હેશો પ્રતિનિધિત્વ

101
00:05:37,000 --> 00:05:42,020
અને કેટલા જગ્યાઓ માટે જરૂરી છે
Nth પંક્તિ તમે કેટલાક ઊંચાઈ હોય છે.

102
00:05:42,020 --> 00:05:46,060
>> હવે તમે આ બહાર figuring કરી રહ્યા હો ત્યારે,
સાવચેત તમે કેવી રીતે ઇન્ડેક્સીંગ કરી રહ્યા છીએ.

103
00:05:46,060 --> 00:05:49,170
શું હું આ દ્વારા અર્થ છે કે
રોજિંદા જીવન અમને તમામ

104
00:05:49,170 --> 00:05:51,540
1 દ્વારા ગણતરી સામાન્ય રીતે શરૂ કરો.

105
00:05:51,540 --> 00:05:55,950
CS50 માં અને કોમ્પ્યુટર વિજ્ઞાન પરંતુ
સામાન્ય રીતે, અમે 0 અનુક્રમિત છે.

106
00:05:55,950 --> 00:06:00,620
તેથી પ્રથમ પંક્તિ હશે
0 એન 1 તરીકે વિરોધ કર્યો હતો.

107
00:06:00,620 --> 00:06:04,550
આ ખૂબ કાળજી રાખો જ્યારે તમે છો
તમારા પેટર્ન બહાર આકૃતિ કરવાનો પ્રયાસ.

108
00:06:04,550 --> 00:06:07,570
તેથી હવે આપણે કેવી રીતે પાછા જવા દો
અમે અમારા પિરામિડ ડ્રો રહ્યા છીએ.

109
00:06:07,570 --> 00:06:12,300
દરેક પંક્તિ માટે, અમે કરવા માંગો છો જઈ રહ્યાં છો
, જગ્યાઓ પ્રિન્ટ હેશો છાપો,

110
00:06:12,300 --> 00:06:14,050
અને પછી એક નવી લાઇન છાપો.

111
00:06:14,050 --> 00:06:19,160
સંકેત અહીં છે
દરેક પંક્તિ "માટે" શબ્દ.

112
00:06:19,160 --> 00:06:21,470
સી, અમે એક રચના છે
લૂપ માટે કહેવાય છે,

113
00:06:21,470 --> 00:06:25,250
એક બનેલું છે કે જે
પ્રારંભિક, શરત, સુધારો,

114
00:06:25,250 --> 00:06:26,790
અને લૂપ શરીર.

115
00:06:26,790 --> 00:06:31,360
>> હું હેલ્લો કહે છે ઇચ્છતા કહે છે,
વિશ્વ, 50 વખત, મારા લૂપ માટે

116
00:06:31,360 --> 00:06:32,880
આ કંઈક જોવા આવશે.

117
00:06:32,880 --> 00:06:35,480
હું 0 મારા પૂર્ણાંક પ્રારંભ.

118
00:06:35,480 --> 00:06:38,230
શરત એ છે કે હું 50 કરતાં ઓછી છે.

119
00:06:38,230 --> 00:06:42,350
અને પછી મારા સુધારા માત્ર છે
એક દરેક સમય દ્વારા હું incrementing.

120
00:06:42,350 --> 00:06:45,140
અમે પણ આંટીઓ માટે ઉપયોગ કરી શકો છો
વસ્તુઓ પર ફરી વળવું.

121
00:06:45,140 --> 00:06:47,820
અહીં નોટિસ અમે કેવી રીતે નથી
હાર્ડ નંબર કોડેડ

122
00:06:47,820 --> 00:06:51,820
પરંતુ ચલ મૂકવામાં
તેના બદલે શરત માં ઊંચાઇ.

123
00:06:51,820 --> 00:06:56,420
તેથી શું હું અહીં કરી રહ્યો છું હું વારો છું છે
પિરામિડ દરેક પંક્તિ પર.

124
00:06:56,420 --> 00:07:00,160
હું દરેક માટે કંઈક કરી શકો છો
મારા લૂપ શરીર અંદર પંક્તિ.

125
00:07:00,160 --> 00:07:02,350
>> અમે અંદર શું કરી રહ્યા છે
લૂપ શરીર?

126
00:07:02,350 --> 00:07:07,120
વેલ, અમે પહેલાથી જ કહ્યું હતું કે, અમે છાપવા કરી રહ્યાં છો
જગ્યાઓ અને અમે હેશ છાપવા કરી રહ્યાં છો

127
00:07:07,120 --> 00:07:09,480
અને અમે એક નવી લાઇન છાપવા કરી રહ્યાં છો.

128
00:07:09,480 --> 00:07:11,950
તેથી લૂપ માટે મારા બાહ્ય
આના જેવો દેખાશે.

129
00:07:11,950 --> 00:07:15,070
હું દરેક પંક્તિ પર ફરી વળવું
પિરામિડ, વાપરી રહ્યા હોય,

130
00:07:15,070 --> 00:07:18,890
આ કિસ્સામાં, ચલ તરીકે ઊંચાઈ
કે પિરામિડ ઓફ ઊંચાઇ સંગ્રહ કરે છે.

131
00:07:18,890 --> 00:07:22,870
કે લૂપ શરીર અંદર, હું છું
વારંવાર જગ્યાઓ છાપી રહ્યા, પ્રિન્ટ

132
00:07:22,870 --> 00:07:26,730
વારંવાર હેશો,
અને પછી એક નવી લાઇન છાપો.

133
00:07:26,730 --> 00:07:31,010
>> તેથી હવે, ખ્યાલો બધા મદદથી
હું, આ WALK- મારફતે વિશે વાત કરી છે

134
00:07:31,010 --> 00:07:35,210
તમે પૂછવા માટે સમર્થ હોવા જોઈએ
વપરાશકર્તા ઈનપુટ માટે, કે જે ઇનપુટ માન્ય,

135
00:07:35,210 --> 00:07:37,370
અને પછી અડધા પિરામિડ દોરે છે.

136
00:07:37,370 --> 00:07:41,510
>> મારું નામ Zamyla છે, અને આ CS50 છે.

137
00:07:41,510 --> 00:07:43,167