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

2
00:00:00,500 --> 00:00:02,500
ZAMYLA చాన్: ఇది ఒక నాకు, 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
నిర్థారిస్తుంది ఆ Int పొందండి
యూజర్ ఇన్పుట్లను పూర్ణాంకం.

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
OK, కాబట్టి మేము అవసరం అర్థం
నిరంతరం యూజర్ ప్రాంప్ట్

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
మళ్లీ మళ్లీ.

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
n చెల్లని ఉంటే, అప్పుడు మేము వాటిని ప్రాంప్ట్
మళ్ళీ మళ్ళీ మళ్ళీ అవి వరకు

46
00:02:29,740 --> 00:02:31,820
మాకు ఆ చెల్లుబాటు అయ్యే పూర్ణాంక ఇవ్వాలని.

47
00:02:31,820 --> 00:02:37,440
చివరగా, ఒకసారి n చెల్లుబాటు అయ్యే ఇన్పుట్, మేము చేస్తాము
మా కార్యక్రమం మిగిలిన వెళ్లండి.

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
n చెల్లదు అయితే ఉండాలి.

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
రెండు Booleans వ్యవహరించే కావడం.

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
లేదా ఒకటి ఉన్నంత నిజమైన ఉంటుంది
రెండు Booleans ఒప్పుకు మదింపు.

64
00:03:37,280 --> 00:03:41,450
OK, కాబట్టి ఒక క్షణం పడుతుంది, ఈ విరామం
వీడియో మరియు ఈ నిజం పట్టిక జీర్ణం చేస్తాయి.

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
ఒక బూలియన్ వ్యక్తీకరణ మీ
n యొక్క పరిస్థితి చెల్లని ఇన్పుట్ ఉండటం.

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
Well, నేను పుష్ ప్రయత్నించండి
వైపు ప్రతిదీ

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-- అందువలన న మొదలగునవి

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
కానీ మేము ఇంకా కావలసిన
ఆ nice అంతరాన్ని నిర్వహించడానికి.

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
ఎంటర్ మీట
ఒక కొత్త లైన్ సృష్టిస్తుంది.

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
రెండవ మూడు హష్లు, ఆరు ఖాళీలు.

96
00:05:20,020 --> 00:05:24,260
మూడో వరుస నాలుగు హష్లు, ఐదు
spaces-- అందువలన న మొదలగునవి

97
00:05:24,260 --> 00:05:26,350
మేము n వ వరుస వచ్చేవరకు.

98
00:05:26,350 --> 00:05:31,540
కాబట్టి అప్పుడు, నేను n వ వరుస కోసం మీరు అడగండి,
ఎన్ని హష్లు మేము కలిగి వెళ్తున్నారు

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
మరియు ఎన్ని ఖాళీలు అవసరమైన
N వ వరుసగా మీరు కొన్ని ఎత్తు కలిగి ఉన్నప్పుడు.

102
00:05:42,020 --> 00:05:46,060
>> ఇప్పుడు మీరు ఈ ఇందుకు చేసినప్పుడు,
మీరు సూచి చేస్తున్నారు జాగ్రత్తగా ఉండండి.

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 యొక్క n 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
అప్పుడు నా నవీకరణ కేవలం ఉంది
ఒకటి ప్రతిసారీ నేను పెంచడం.

120
00:06:42,350 --> 00:06:45,140
మేము కూడా ఉచ్చులు కోసం ఉపయోగించవచ్చు
విషయాలు పైగా iterate.

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
సో నేను ఇక్కడ చేస్తున్నానో నాకు iterating ఉన్నాను ఉంది
పిరమిడ్ ప్రతి వరుసలో మీద.

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
Well, మేము ఇప్పటికే చెప్పారు వంటి, మేము ప్రింటింగ్
ఖాళీలు మరియు మేము హాష్లను ప్రింటింగ్

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
నేను ప్రతి వరుసలో మీద iterate
పిరమిడ్, ఉపయోగించి,

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

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