1
00:00:00,000 --> 00:00:00,982

2
00:00:00,982 --> 00:00:11,293
>> [સંગીત વગાડવાનો]

3
00:00:11,293 --> 00:00:13,580
>> રોબ બોડેન: તે રોબ મને છે.

4
00:00:13,580 --> 00:00:16,540
કેવી રીતે લઈ જવામાં દો
મારિયો અમલ.

5
00:00:16,540 --> 00:00:21,040
તેથી અમે જરૂર પ્રથમ વસ્તુ છે
ઇનપુટ માટે વપરાશકર્તા પૂછવા.

6
00:00:21,040 --> 00:00:24,440
>> અમે ખરેખર કેવી રીતે તેમને પૂછવા માટે જરૂર છે
ઊંચા પિરામિડ પ્રયત્ન કરીશું.

7
00:00:24,440 --> 00:00:27,110
અહીં, અમે અમે કરી રહ્યા છીએ જુઓ
ઊંચાઈ = GetInt.

8
00:00:27,110 --> 00:00:32,479
એક અને યાદ રાખો કે GetInt કાર્ય
આ CS50 અમલમાં મૂકાયેલ છે

9
00:00:32,479 --> 00:00:38,060
પુસ્તકાલય, તેથી ઉપર, અમે જરૂર
# યાદ cs50.h. સમાવેશ થાય છે

10
00:00:38,060 --> 00:00:41,360
>> તેથી શા માટે અમે આ આવરિત છે
એક કરતા હો ત્યારે લૂપ છે?

11
00:00:41,360 --> 00:00:45,080
વેલ, અમે યાદ રાખો કે જરૂર
વપરાશકર્તાની ઇનપુટ માન્ય પ્રયત્ન છે.

12
00:00:45,080 --> 00:00:46,910
અમાન્ય ઇનપુટ શું છે?

13
00:00:46,910 --> 00:00:51,460
વેલ આ pset સ્પેક ખાસ કહે છે
કે ઊંચાઈ 0 કરતાં ઓછી અથવા તેથી વધુ

14
00:00:51,460 --> 00:00:54,530
23 અમાન્ય છે કરતાં.

15
00:00:54,530 --> 00:00:59,030
>> તેથી અહીં, આપણે વ્યાખ્યાયિત કરી રહ્યા છીએ કે નહીં તે જોવા
આ સાથે MAX_HEIGHT કહેવાય સતત

16
00:00:59,030 --> 00:01:00,750
23 કિંમત.

17
00:01:00,750 --> 00:01:06,380
આ કરતા હો ત્યારે લૂપ જ્યારે ચાલુ રહેશે
ઊંચાઈ 0 કરતાં ઓછી અથવા MAX_HEIGHT છે

18
00:01:06,380 --> 00:01:11,870
જેનો અર્થ છે કે ઊંચાઈ, કરતાં ઓછી
23 ઊંચાઇ કરતાં ઓછી છે.

19
00:01:11,870 --> 00:01:15,390
ઊંચાઈ 24 અથવા તેથી વધુ છે તેથી જો, અમે છો
રહ્યાં ચાલુ રહ્યું.

20
00:01:15,390 --> 00:01:18,300
યાદ રાખો કે આવું ત્યારે આંટીઓ ખૂબ છે
મદદરૂપ અમે વિચાર કરવા માંગો છો જ્યારે

21
00:01:18,300 --> 00:01:22,070
વપરાશકર્તા ઈનપુટ અને ત્યારથી, તે માન્ય
અમે ખચીત પર વપરાશકર્તા પૂછવા જરૂર

22
00:01:22,070 --> 00:01:25,010
ઓછા એક વખત તેઓ માંગો છો કિંમત માટે.

23
00:01:25,010 --> 00:01:28,500
>> તેથી એક વખત અમે તેમની ઇનપુટ છે, અમે
હવે પિરામિડ બનાવી શકો છો.

24
00:01:28,500 --> 00:01:31,940
સેટ આ સમસ્યા યુક્તિઓ એક છે
અમે ટોચ પર શરૂ હોય છે કે

25
00:01:31,940 --> 00:01:32,750
પિરામિડ.

26
00:01:32,750 --> 00:01:36,800
તમે નીચે printf નથી કરી શકો છો
પિરામિડ અને પછી તમારી રીતે બનાવો.

27
00:01:36,800 --> 00:01:38,830
તેથી આપણે આ ઉદાહરણ જોવા દો
આ pset સ્પેક છે.

28
00:01:38,830 --> 00:01:41,530

29
00:01:41,530 --> 00:01:45,430
>> અમે અહીં જુઓ કે અમે એક ઊંચાઇ દાખલ ત્યારે
8 છે, જે ખૂબ જ નીચે

30
00:01:45,430 --> 00:01:48,660
પિરામિડ નવ હેશ છાપે છે.

31
00:01:48,660 --> 00:01:52,990
તે એક સ્તર પ્રિન્ટ
એક જગ્યા અને આઠ હેશ.

32
00:01:52,990 --> 00:01:58,250
તે એક સ્તર બે જગ્યાઓ અને છે
સાત હેશ, બધી રીતે ત્યાં સુધી અમે

33
00:01:58,250 --> 00:02:03,050
છે પિરામિડ, જે ટોચ પર વિચાર
સાત છાપે છે આઠ સ્તરો,

34
00:02:03,050 --> 00:02:06,000
જગ્યાઓ અને બે હેશ.

35
00:02:06,000 --> 00:02:08,810
તેથી અમે હોય છે યાદ રાખો કે
પ્રથમ આ શીર્ષ સ્તર છે.

36
00:02:08,810 --> 00:02:11,620

37
00:02:11,620 --> 00:02:18,500
>> અહીં અમે થી વારો કરી રહ્યાં છો
ટોચના સ્તર, પંક્તિ 8 ચાલુ

38
00:02:18,500 --> 00:02:22,150
0 પંક્તિ સુધી પહોંચે ત્યાં સુધી.

39
00:02:22,150 --> 00:02:25,820
આમ કેવી રીતે અનેક જગ્યાઓ અમે જરૂર હતી
કે ટોચ પંક્તિ છાપી?

40
00:02:25,820 --> 00:02:29,310
અમે સાત જગ્યાઓ મુદ્રિત
અને બે હેશ.

41
00:02:29,310 --> 00:02:34,450
તેથી અમે માંગો છો જગ્યાઓ સંખ્યા છે
1 બાદ હતા કે પંક્તિ.

42
00:02:34,450 --> 00:02:39,310
>> ટોચ પંક્તિ 8 8 ઓછા છે
1 અમને સાત જગ્યાઓ છે.

43
00:02:39,310 --> 00:02:43,770
તો પછી અમે છાપશે કે લૂપ છે
એક સમયે દરેક જગ્યા એક બહાર.

44
00:02:43,770 --> 00:02:47,450
તેથી જ્યારે જગ્યાઓ આ લૂપ, 7 છે
સાત વાર મુદ્રણ

45
00:02:47,450 --> 00:02:50,300
સાત વ્યક્તિગત જગ્યાઓ.

46
00:02:50,300 --> 00:02:54,672
>> તેથી હવે અમે આ હેશ પ્રિન્ટ કરવાની જરૂર
પિરામિડ ઓવરને અંતે.

47
00:02:54,672 --> 00:02:57,930
અહીં, અમે ગણતરી કરવાની જરૂર
હેશ સંખ્યા.

48
00:02:57,930 --> 00:03:01,930
અમે ઊંચાઈ કરી રહ્યા છીએ કે નહીં તે જોવા
ઓછા પંક્તિ વત્તા 2.

49
00:03:01,930 --> 00:03:04,170
તેથી અમે કેવી રીતે તે મેળવી હતી?

50
00:03:04,170 --> 00:03:08,630
>> યાદ રાખો કે પિરામિડ ટોચ
પંક્તિ 8 છે, અને ઊંચાઇ 8 હોય છે.

51
00:03:08,630 --> 00:03:10,890
અને અમે હજુ પણ બે હેશ મુદ્રિત.

52
00:03:10,890 --> 00:03:15,420
તેથી ખૂબ જ ઓછામાં ઓછા, 8 ઓછા 8 વત્તા
2 અમને યોગ્ય જવાબ આપે છે.

53
00:03:15,420 --> 00:03:19,170
અને પછી નીચે ધ્યાનમાં
પિરામિડ, 1 પંક્તિ.

54
00:03:19,170 --> 00:03:24,020
ઊંચાઈ બાદ પંક્તિ બનાવવામાં 7 આપે છે, અને કરશે
પછી વત્તા 2 આપણને નવ હેશ આપે છે,

55
00:03:24,020 --> 00:03:26,620
જે બરાબર સંખ્યા છે
અમે મુદ્રિત કે હેશો.

56
00:03:26,620 --> 00:03:29,880
તેથી આ અમે કરવા માંગો છો તે સૂત્ર છે
સંખ્યા ગણતરી કરવા માટે ઉપયોગ

57
00:03:29,880 --> 00:03:32,220
દરેક પંક્તિ હેશો.

58
00:03:32,220 --> 00:03:36,020
>> કે જે નંબર ઉપયોગ કરતા આપણને પછી બીજા છે
આ ખૂબ જ સમાન લૂપ, માટે

59
00:03:36,020 --> 00:03:41,270
અમે જગ્યાઓ માટે વપરાય છે કે લૂપ માટે,
કે હેશ વખત iterates માટે નંબર

60
00:03:41,270 --> 00:03:43,720
એક હેશ દરેક વખતે પ્રિન્ટ કરે છે.

61
00:03:43,720 --> 00:03:46,010
ટોચ પંક્તિ પર, કે પડશે
બે હેશ છાપો.

62
00:03:46,010 --> 00:03:48,390
નીચે પંક્તિ પર, કે પડશે
નવ હેશ છાપો.

63
00:03:48,390 --> 00:03:52,610
અને દરેક અન્ય પંક્તિ દરેક છાપશે
વચ્ચે હેશો સંખ્યા.

64
00:03:52,610 --> 00:03:57,340
>> અને પછી ખૂબ જ ઓવરને અંતે, અમે જરૂર
આગામી પર જાઓ અમારા નવી લાઇન છાપો

65
00:03:57,340 --> 00:03:59,400
પિરામિડ પંક્તિ.

66
00:03:59,400 --> 00:04:03,070
છેલ્લે, અમે નવી લાઇન છાપો જરૂર
આ પંક્તિ ના અંત કરવા માટે પર

67
00:04:03,070 --> 00:04:06,260
આગામી માટે ચાલુ
પિરામિડ પંક્તિ.

68
00:04:06,260 --> 00:04:08,980
અને અમારો કાર્યક્રમ ઓવરને અંતે,
અમે વળતર 0 છે.

69
00:04:08,980 --> 00:04:12,770
>> આ pset સ્પેક, પરત મુજબ
0 સખત જરૂરી નથી.

70
00:04:12,770 --> 00:04:15,710
પરંતુ તે મુખ્ય રીતે કરવામાં આવે છે કે જે અર્થ નથી.

71
00:04:15,710 --> 00:04:17,610
મારું નામ રોબ છે, અને આ મારિયો હતી.

72
00:04:17,610 --> 00:04:22,470
>> [સંગીત વગાડવાનો]

73
00:04:22,470 --> 00:04:25,558