1
00:00:00,000 --> 00:00:13,010

2
00:00:13,010 --> 00:00:18,290
>> રોબ બોડેન: હાય, હું રોબ છું, અને માતાનો કૂદકો
મારિયો ઓફ હેકર આવૃત્તિ માં.

3
00:00:18,290 --> 00:00:21,760
અમે જરૂર તેથી પ્રથમ વસ્તુ છે
વપરાશકર્તામાંથી ઊંચાઈ વિશે.

4
00:00:21,760 --> 00:00:26,290
અહીં અમે તેમને કહીએ છીએ
બિન નકારાત્મક પૂર્ણાંક કરતાં ઓછી 24 અને

5
00:00:26,290 --> 00:00:31,710
અમે CS50 GetInt કાર્ય ઉપયોગ કરી રહ્યાં છો
વપરાશકર્તા કે પૂર્ણાંક ગ્રેબ.

6
00:00:31,710 --> 00:00:35,260
અમે એક કરતા હો ત્યારે લૂપ અંદર છો જુઓ
કે જ્યાં સુધી રહ્યાં ચાલુ રહેશે

7
00:00:35,260 --> 00:00:38,400
ઊંચાઇ કરતાં વધારે છે
23 કે તેથી ઓછા કરતાં 0.

8
00:00:38,400 --> 00:00:42,850
અને તેથી અમે વપરાશકર્તા સુધી ચાલુ રાખીશું
ખરેખર અમે માંગો છો તે અમને આપે છે.

9
00:00:42,850 --> 00:00:46,960
>> અમે તે ઊંચાઈ છે, એટલે હંમેશાં મેળવવા
અમારા કાર્યક્રમ લૂપ માટે મુખ્ય.

10
00:00:46,960 --> 00:00:49,510
એક ઉદાહરણ તેથી ચાલો પ્રથમ દેખાવ
આ pset સ્પેક છે.

11
00:00:49,510 --> 00:00:52,270

12
00:00:52,270 --> 00:00:56,940
અમે આ ઉદાહરણમાં જોવા કે જ્યારે અમે
4 ની ઊંચાઈ, નીચે પંક્તિ દાખલ

13
00:00:56,940 --> 00:01:01,520
પ્રથમ ચાર હેશ, બે જગ્યાઓ, છાપે છે
અને ચાર વધુ હેશ.

14
00:01:01,520 --> 00:01:06,280
>> પછી તે ઉપર એક પંક્તિ એક છાપે
જગ્યા ત્રણ હેશો, બે જગ્યાઓ માટે

15
00:01:06,280 --> 00:01:09,690
પિરામિડ અલગ છે, અને
પછી વધુ ત્રણ હેશો.

16
00:01:09,690 --> 00:01:13,460
અને તે ઉપર, બે જગ્યાઓ, બે હેશ,
બે જગ્યાઓ, બે હેશ.

17
00:01:13,460 --> 00:01:18,090
અને છેલ્લે, ત્રણ જગ્યાઓ એક
હેશ, બે જગ્યાઓ એક હેશ.

18
00:01:18,090 --> 00:01:20,980
તેથી તમે નોટિસ શરૂ કરીશું
અહીં પેટર્ન.

19
00:01:20,980 --> 00:01:22,545
>> કેવી રીતે માટે કોડ જુઓ
અમે તે કરી રહ્યા છીએ.

20
00:01:22,545 --> 00:01:25,290

21
00:01:25,290 --> 00:01:28,840
અમે વારો કરી રહ્યાં છો કે અહીં જુઓ
પિરામિડ બધા પંક્તિઓ પર.

22
00:01:28,840 --> 00:01:31,720
પ્રથમ અમે ગણતરી કરવા માંગો છો
જગ્યાઓ સંખ્યા.

23
00:01:31,720 --> 00:01:34,690
અને અમે શરૂ હોય છે યાદ રાખો કે
આ પિરામિડ ઉપર અને કામ અમારા

24
00:01:34,690 --> 00:01:37,790
માર્ગ નીચે અમે છાપી શકતા નથી કારણ કે
નીચે પછી એક પંક્તિ અપ અને

25
00:01:37,790 --> 00:01:39,140
પછી એક પંક્તિ છે.

26
00:01:39,140 --> 00:01:44,030
તેથી પિરામિડ, નોટિસ ટોચ પર
જગ્યાઓ સંખ્યા સમાન છે

27
00:01:44,030 --> 00:01:45,720
ઊંચાઈ 1 બાદ.

28
00:01:45,720 --> 00:01:50,120
અમે પછી ત્રણ જગ્યાઓ છાપી રહ્યા છીએ
એક હેશ અને પછી બે જગ્યાઓ માટે

29
00:01:50,120 --> 00:01:53,350
અલગ અને અન્ય હેશ.

30
00:01:53,350 --> 00:01:57,320
>> તેથી જગ્યાઓ સમાન છે
ઊંચાઈ બાદ પંક્તિ.

31
00:01:57,320 --> 00:02:03,180
, આ પંક્તિ 1 હોય છે અને અમારા ઊંચાઇ 4 છે
અમે માંગો છો કે, અમને 3 જગ્યાઓ આપવા પડશે.

32
00:02:03,180 --> 00:02:06,900
તો પછી આ લૂપ માત્ર પ્રિન્ટ માટે
જગ્યાઓ કે જે નંબર.

33
00:02:06,900 --> 00:02:12,630
જગ્યાઓ ત્રણ છે, તો પછી અમે રહ્યા છીએ
એક જ જગ્યા ત્રણ વખત બનાવો.

34
00:02:12,630 --> 00:02:18,750
>> સતત, હવે અમે પ્રિન્ટ માંગો છો એ
જે ડાબી પિરામિડ, હેશ

35
00:02:18,750 --> 00:02:20,630
આ પંક્તિ નંબર પર માત્ર સમાન.

36
00:02:20,630 --> 00:02:23,250
પંક્તિ, અહીં પાછળ છીએ
એક, અમે એક હેશ છાપો.

37
00:02:23,250 --> 00:02:25,960
પંક્તિ બે અમે માં, બે છાપો
પંક્તિ ત્રણ અમે ત્રણ છાપો.

38
00:02:25,960 --> 00:02:30,440
તેથી અમે ફક્ત લૂપ પંક્તિ વખત
પ્રિન્ટીંગ હેશ પ્રતીક.

39
00:02:30,440 --> 00:02:34,830
પછી પિરામિડ બધા પંક્તિઓ માટે, અમે
અલગ બરાબર બે જગ્યાઓ છાપો

40
00:02:34,830 --> 00:02:36,360
તે પિરામિડ.

41
00:02:36,360 --> 00:02:39,590
>> અને છેલ્લે, અમે યોગ્ય પ્રિન્ટ માંગો છો
છે પિરામિડ, જે બાજુ

42
00:02:39,590 --> 00:02:42,160
ફરીથી હેશ જ નંબર
ડાબી બાજુ છે.

43
00:02:42,160 --> 00:02:45,680
અને તેથી તે જ ચોક્કસ છે
અહીં ઉપર લૂપ માટે.

44
00:02:45,680 --> 00:02:49,445
છેલ્લે, અમે એક નવી લાઇન બનાવવાની જરૂર છે
આગામી રો પર ખસેડો કરવા માટે

45
00:02:49,445 --> 00:02:51,690
પિરામિડ અને પ્રિન્ટીંગ ચાલુ રાખો.

46
00:02:51,690 --> 00:02:53,010
અને તે છે.

47
00:02:53,010 --> 00:02:54,860
મારું નામ રોબ છે અને આ મારિયો હતી.

48
00:02:54,860 --> 00:03:01,718