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

2
00:00:00,982 --> 00:00:11,293
>> [MUSIC ప్లే]

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
పిరమిడ్ తొమ్మిది hashes ముద్రిస్తుంది.

31
00:01:48,660 --> 00:01:52,990
నుండి ఒక స్థాయి అప్ ముద్రలు
ఒక ఖాళీ మరియు ఎనిమిది hashes.

32
00:01:52,990 --> 00:01:58,250
నుండి ఒక స్థాయి రెండు ప్రదేశములలో ఉంది
ఏడు hashes, అన్ని మార్గం వరకు మేము

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
>> ఇక్కడ మేము నుండి iterating చేస్తున్నారు
ఉన్నత స్థాయిలో, వరుసగా 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
>> కాబట్టి ఇప్పుడు మేము ఈ hashes ప్రింట్ అవసరం
పిరమిడ్ చివరిలో.

47
00:02:54,672 --> 00:02:57,930
ఇక్కడ, మేము లెక్కించేందుకు అవసరం
hashes సంఖ్య.

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 మాకు తొమ్మిది hashes ఇస్తుంది,

55
00:03:24,020 --> 00:03:26,620
ఇది ఖచ్చితంగా సంఖ్య
మేము ముద్రిత hashes.

56
00:03:26,620 --> 00:03:29,880
ఈ మేము కావలసిన సూత్రం
సంఖ్య లెక్కించేందుకు ఉపయోగించే

57
00:03:29,880 --> 00:03:32,220
ప్రతి వరుసలో hashes.

58
00:03:32,220 --> 00:03:36,020
>> ఆ సంఖ్య ఉపయోగించి, మేము వేరొక కలిగి
కు సమానమైన లూప్, కోసం

59
00:03:36,020 --> 00:03:41,270
ఫైళ్ళను కోసం ఉపయోగించిన లూప్,
ఆ hashes సార్లు 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
వరుసను పైన, ఆ చేస్తాము
తొమ్మిది hashes ప్రింట్.

63
00:03:48,390 --> 00:03:52,610
మరియు ప్రతి ఇతర వరుసగా ప్రతి ముద్రిస్తుంది
మధ్య లో hashes సంఖ్య.

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
>> [MUSIC ప్లే]

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