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
మొదటి నాలుగు hashes, రెండు ఖాళీలు, ముద్రిస్తుంది
మరియు నాలుగు hashes.

14
00:01:01,520 --> 00:01:06,280
>> అప్పుడు ఆ పైన ఒకటి వరుసగా ఒక ముద్రిస్తుంది
స్పేస్ మూడు hashes, రెండు ఖాళీలు

15
00:01:06,280 --> 00:01:09,690
పిరమిడ్లు వేరు, మరియు
అప్పుడు మూడు hashes.

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
మేము iterating చేస్తున్నట్లు ఇక్కడ చూడగలరు
పిరమిడ్ అన్ని వరుసలు పైగా.

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
>> కొనసాగిస్తూ, ఇప్పుడు మేము ప్రింట్ మీరు
ఇది ఎడమ పిరమిడ్, hashes

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
మళ్ళీ hashes అదే నెంబర్
ఎడమవైపు వంటి.

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