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

2
00:00:00,500 --> 00:00:02,500
ZAMYLA CHAN: Es ist ein mir, Zamyla.

3
00:00:02,500 --> 00:00:06,910
Heute in Mario, wir gehen zu sein
Zeichnen Sie die Hälfte Pyramide für Mario

4
00:00:06,910 --> 00:00:08,290
zu klettern.

5
00:00:08,290 --> 00:00:11,570
>> Bitte sprechen Sie uns über unsere
To-do ist für dieses Problem.

6
00:00:11,570 --> 00:00:13,610
Wir gehen zu wollen,
aufzufordern und zu validieren

7
00:00:13,610 --> 00:00:18,290
der Benutzer eine gültige Eingabe, wie
hoch sie wollen Mario Pyramide zu sein.

8
00:00:18,290 --> 00:00:20,090
Und dann werden wir es zu zeichnen.

9
00:00:20,090 --> 00:00:24,870
Also lassen Sie uns beginnen mit Führung und
Validierung der Benutzer für ihre Beiträge.

10
00:00:24,870 --> 00:00:27,640
>> Wir können von der machen
CS50 Library Function

11
00:00:27,640 --> 00:00:31,160
erhalten int, die, die sicherstellen,
der Benutzer gibt eine ganze Zahl.

12
00:00:31,160 --> 00:00:35,730
Jede positive ganze Zahlen sind, negativ
ganzen Zahlen, die Zahl 0 sind alle fair game.

13
00:00:35,730 --> 00:00:41,670
Andernfalls wird der Benutzer aufgefordert,
wiederholen, bis sie geben Sie eine gültige ganze Zahl ist.

14
00:00:41,670 --> 00:00:44,210
Nun, obwohl get int tut
ein großer Teil der Arbeit für uns

15
00:00:44,210 --> 00:00:46,730
sicherzustellen, dass die
Benutzer gibt uns eine ganze Zahl,

16
00:00:46,730 --> 00:00:50,760
wir müssen noch einige anwenden
zusätzliche Auflagen auf, dass.

17
00:00:50,760 --> 00:00:56,420
Schließlich können wir haben Mario Klettern nicht
eine halbe Pyramide der Höhe negativ 12.

18
00:00:56,420 --> 00:00:59,040
>> Zusätzlich dazu, die
Problemspezifikation

19
00:00:59,040 --> 00:01:02,490
dass sagt, wir können nur
erlauben Mario zu klettern

20
00:01:02,490 --> 00:01:06,940
eine Pyramide aus Höhen zwischen 0 und 23.

21
00:01:06,940 --> 00:01:11,120
OK, so bedeutet das, dass wir brauchen
kontinuierlich den Benutzer auffordern

22
00:01:11,120 --> 00:01:14,320
geben uns einen gültigen
Anzahl und nur dann weiter

23
00:01:14,320 --> 00:01:17,120
sobald sie haben uns eine gültige Höhe gegeben.

24
00:01:17,120 --> 00:01:18,720
Wie machen wir das?

25
00:01:18,720 --> 00:01:23,760
>> Nun, kontinuierliche Prozesse geben uns
die Idee der loops-- etwas zu tun

26
00:01:23,760 --> 00:01:24,720
wiederholt.

27
00:01:24,720 --> 00:01:28,220
Eine Schleife in C als während
Schleife, die wird kontinuierlich

28
00:01:28,220 --> 00:01:33,480
den Körper der Schleife ausführen, so lange
die gegebene Bedingung wahr ausgewertet.

29
00:01:33,480 --> 00:01:36,200
Sobald dieser Zustand
das Ergebnis falsch,

30
00:01:36,200 --> 00:01:39,770
das Programm fortfahren
was kommt danach.

31
00:01:39,770 --> 00:01:43,180
Während also Schleifen sind ein Weg,
um sicherzustellen, dass wir immer wieder

32
00:01:43,180 --> 00:01:45,320
fordert den Benutzer auf eine gültige Eingabe.

33
00:01:45,320 --> 00:01:50,070
Und sobald sie geben uns einen gültigen Eingang,
wir werden fortfahren, was als nächstes kommt.

34
00:01:50,070 --> 00:01:54,380
Wir wissen, dass wir gehen zu fragen
den Benutzer zur Eingabe mindestens einmal.

35
00:01:54,380 --> 00:01:59,200
So, jetzt kommen wir zu einer Schwester der
while-Schleife, die die Do while-Schleife ist.

36
00:01:59,200 --> 00:02:02,650
>> Haben während Schleifen wird die Ausführungs
Körper der mindestens einmal Schleife.

37
00:02:02,650 --> 00:02:06,150
Also ohne Überprüfung der Bedingung,
es wird der Körper der Schleife auszuführen.

38
00:02:06,150 --> 00:02:09,750
Und dann die Bedingung überprüfen, um zu sehen,
ob es braucht, sich zu wiederholen.

39
00:02:09,750 --> 00:02:13,080
Das ist praktisch, wenn
wir sind die Validierung von Benutzereingaben.

40
00:02:13,080 --> 00:02:15,830
Wir wissen, dass wir gehen
mindestens einmal zu fragen.

41
00:02:15,830 --> 00:02:18,780
So ein Do While-Schleife könnte
in etwa so aussehen.

42
00:02:18,780 --> 00:02:20,090
Wir haben eine ganze Zahl n.

43
00:02:20,090 --> 00:02:22,760
Und innerhalb des do
while-Schleife, haben wir sofort

44
00:02:22,760 --> 00:02:24,750
fordert den Benutzer für eine ganze Zahl.

45
00:02:24,750 --> 00:02:29,740
Wenn n ungültig ist, dann werden wir sie auffordern,
wieder und wieder und wieder, bis sie

46
00:02:29,740 --> 00:02:31,820
geben uns, dass gültige ganze Zahl.

47
00:02:31,820 --> 00:02:37,440
Schließlich, sobald n eine gültige Eingabe ist, werden wir
für den Rest unseres Programms fortzufahren.

48
00:02:37,440 --> 00:02:41,830
>> Also lassen Sie uns gehen zurück auf die Spezifikation und die Prüfung
was die Voraussetzungen für eine gültige Eingabe

49
00:02:41,830 --> 00:02:43,670
sein wird.

50
00:02:43,670 --> 00:02:48,090
Die gültigen Höhen gehen zu
zwischen 0 und 23 einschließlich.

51
00:02:48,090 --> 00:02:53,350
So ungültige Höhen gehen zu
kleiner als 0 oder größer als 23.

52
00:02:53,350 --> 00:02:56,420
Also denken Sie daran zu entwerfen
Ihren Zustand sorgfältig,

53
00:02:56,420 --> 00:02:58,660
wohl wissend, dass die Bedingung
für den Do while-Schleife

54
00:02:58,660 --> 00:03:01,470
sollte während n ungültig ist.

55
00:03:01,470 --> 00:03:05,080
Nun ist dies nicht ein sein würde
single Booleschen Ausdruck.

56
00:03:05,080 --> 00:03:07,630
Wir gehen zu müssen, zu kombinieren,
zwei verschiedene Ausdrücke

57
00:03:07,630 --> 00:03:09,900
unsere ganze Bedingung zu machen.

58
00:03:09,900 --> 00:03:13,290
>> Also schauen wir uns gerade in einer Wahrheitstabelle Ich habe
bereits Sie den Hinweis gegeben, dass wir

59
00:03:13,290 --> 00:03:15,200
Gehen mit zwei Boolesche Werte zu tun haben.

60
00:03:15,200 --> 00:03:19,620
Also hier ist eine Wahrheitstabelle, wo ich
haben zwei Booleans-- Boolean 1 und 2.

61
00:03:19,620 --> 00:03:27,050
So haben wir die Möglichkeit, zu bewerten
bool1 und bool2 oder bool1 oder bool2.

62
00:03:27,050 --> 00:03:31,980
Und wird nur wahr sein, wenn sowohl
Boolesche Werte bewerten zu wahren, während alle

63
00:03:31,980 --> 00:03:37,280
oder wird es wahr, solange einer von
die zwei Boolesche Werte als wahr ausgewertet.

64
00:03:37,280 --> 00:03:41,450
OK, also einen Moment Zeit nehmen, Pause das
Video und verdauen diese Wahrheitstabelle.

65
00:03:41,450 --> 00:03:42,930
Ich werde warten hier sein.

66
00:03:42,930 --> 00:03:45,760
Wenn Sie zurückkommen, sehen
wenn Sie zusammensetzen können

67
00:03:45,760 --> 00:03:51,910
ein Boolescher Ausdruck für Ihre
Zustand von n eine ungültige Eingabe.

68
00:03:51,910 --> 00:03:54,420
>> So, jetzt haben wir haben
gültiger Benutzereingabe, lassen Sie uns

69
00:03:54,420 --> 00:03:58,710
gehen Sie vor und sprechen darüber, wie wir
könnte die halbe Pyramide ziehen.

70
00:03:58,710 --> 00:04:03,410
Hier in diesem einfachen Text-Editor,
Ich habe eine linksbündig Pyramide gezogen.

71
00:04:03,410 --> 00:04:07,050
Aber wir wissen, dass wir unsere brauchen
Pyramide rechts ausgerichtet werden.

72
00:04:07,050 --> 00:04:08,650
Wie könnte ich das tun?

73
00:04:08,650 --> 00:04:11,440
Nun, ich könnte versuchen, zu schieben
alles der Seiten

74
00:04:11,440 --> 00:04:14,880
durch nur ein wenig setzen
Charakter dazwischen.

75
00:04:14,880 --> 00:04:16,779
Und dann für die nächste
Linie, ich werde zu setzen

76
00:04:16,779 --> 00:04:20,970
einige weitere Zeichen zu schieben entlang,
und further-- so weiter und so forth--

77
00:04:20,970 --> 00:04:23,360
bis ich das Recht haben, ausgerichtet Pyramide.

78
00:04:23,360 --> 00:04:27,780
So haben wir ein Recht align Pyramide haben, aber
es sieht nicht so gut aus mit den Punkten.

79
00:04:27,780 --> 00:04:30,680
Aber wir wollen immer noch
so schön Abstand halten.

80
00:04:30,680 --> 00:04:35,260
Also werde ich buchstäblich
einfügen einige Räume.

81
00:04:35,260 --> 00:04:39,420
>> Statt drei Punkte, werde ich
setzen ein, zwei, drei Räume.

82
00:04:39,420 --> 00:04:40,370
In der zweiten Zeile.

83
00:04:40,370 --> 00:04:42,640
Ich werde ein, zwei Räume setzen.

84
00:04:42,640 --> 00:04:45,370
Und am vorletzten
Linie, nur einem Raum.

85
00:04:45,370 --> 00:04:48,290
Und hier habe ich ein Recht ausgerichtet Pyramide.

86
00:04:48,290 --> 00:04:52,170
Aus dem Beispiel in dem Text zu tun
Editor, haben wir eine Idee für das Muster

87
00:04:52,170 --> 00:04:54,590
dass wir die Hälfte Pyramide verwenden zu zeichnen werde.

88
00:04:54,590 --> 00:04:58,080
Für jede Zeile, was haben wir
ist, dass wir einige Räume geben,

89
00:04:58,080 --> 00:05:00,170
und dann tippte einige
Hashes, und dann getippt

90
00:05:00,170 --> 00:05:03,020
die Enter-Taste, die
eine neue Zeile erstellt.

91
00:05:03,020 --> 00:05:07,770
So, jetzt haben wir das haben, gehen wir
einen Schritt weiter und ein Muster zu finden.

92
00:05:07,770 --> 00:05:10,170
>> Also werde ich sagen, für die
Interesse dieses Beispiels,

93
00:05:10,170 --> 00:05:12,480
wir sind mit einer Höhe von 8 zu tun haben.

94
00:05:12,480 --> 00:05:17,100
Die erste Reihe wird zwei zu haben,
Hashes, die sieben Räume folgt.

95
00:05:17,100 --> 00:05:20,020
Die second-- drei Hashes, sechs Räume.

96
00:05:20,020 --> 00:05:24,260
Dritte row-- vier Hashes, fünf
spaces-- so weiter und so fort

97
00:05:24,260 --> 00:05:26,350
bis wir zum n-ten Reihe zu bekommen.

98
00:05:26,350 --> 00:05:31,540
Also dann, ich bitte Sie, für die n-te Zeile,
wie viele Hashes werden wir haben

99
00:05:31,540 --> 00:05:33,120
und wie viele Räume?

100
00:05:33,120 --> 00:05:37,000
So ist es an Ihnen ein, um herauszufinden,
Formel darzustellen, wie viele Hashes

101
00:05:37,000 --> 00:05:42,020
und wie viele Räume benötigt werden für
der n-ten Reihe, wenn Sie einige Höhe.

102
00:05:42,020 --> 00:05:46,060
>> Nun, wenn Sie herauszufinden, dies aus,
vorsichtig sein, wie Sie die Indizierung.

103
00:05:46,060 --> 00:05:49,170
Was ich damit meine ist, dass
im Alltag von uns allen

104
00:05:49,170 --> 00:05:51,540
Zählen, in der Regel von 1 beginnen.

105
00:05:51,540 --> 00:05:55,950
Aber in CS50 und in der Informatik
in der Regel sind wir 0 indexierte.

106
00:05:55,950 --> 00:06:00,620
So ist die erste Reihe wäre
n von 0 zu 1 gegenüber.

107
00:06:00,620 --> 00:06:04,550
Achten Sie auf diese Option, wenn du bist
versuchen, Ihr Muster herauszufinden.

108
00:06:04,550 --> 00:06:07,570
So, jetzt gehen wir zurück, wie
wir werden unsere Pyramide zu zeichnen.

109
00:06:07,570 --> 00:06:12,300
Für jede Zeile, wir gehen zu wollen
drucken die Räume, drucken Sie die Hashes,

110
00:06:12,300 --> 00:06:14,050
und dann eine neue Zeile zu drucken.

111
00:06:14,050 --> 00:06:19,160
Der Hinweis ist hier die
Wort "für" jede Zeile.

112
00:06:19,160 --> 00:06:21,470
In C, haben wir ein Konstrukt
eine for-Schleife genannt,

113
00:06:21,470 --> 00:06:25,250
die aus einem besteht
Initialisierung, ein Zustand, ein Update,

114
00:06:25,250 --> 00:06:26,790
und der Körper der Schleife.

115
00:06:26,790 --> 00:06:31,360
>> Sag ich sagen wollte, hallo
Welt, 50-mal, meine for-Schleife

116
00:06:31,360 --> 00:06:32,880
in etwa so aussehen würde.

117
00:06:32,880 --> 00:06:35,480
Ich initialisieren meine ganze Zahl auf 0.

118
00:06:35,480 --> 00:06:38,230
Die Bedingung ist, dass I kleiner als 50.

119
00:06:38,230 --> 00:06:42,350
Und dann mein Update ist nur
Erhöhen ich jedes Mal ein.

120
00:06:42,350 --> 00:06:45,140
Wir können auch für Loops verwenden
über die Dinge zu durchlaufen.

121
00:06:45,140 --> 00:06:47,820
Beachten Sie hier, wie wir haben nicht
hart codiert eine Nummer,

122
00:06:47,820 --> 00:06:51,820
sondern platziert die Variable
Statt in den Zustand der Höhe.

123
00:06:51,820 --> 00:06:56,420
Also, was ich hier tue, ist, ich bin Iterieren
über jede Zeile der Pyramide.

124
00:06:56,420 --> 00:07:00,160
Ich kann für jeden etwas zu tun
Zeile innerhalb der Körper meiner Schleife.

125
00:07:00,160 --> 00:07:02,350
>> Was tun wir im Inneren
der Körper der Schleife?

126
00:07:02,350 --> 00:07:07,120
Nun, wie wir schon gesagt, wir drucken
Räume und wir drucken Hashes

127
00:07:07,120 --> 00:07:09,480
und wir drucken eine neue Zeile.

128
00:07:09,480 --> 00:07:11,950
Also meine äußere for-Schleife
wie folgt aussehen wird.

129
00:07:11,950 --> 00:07:15,070
Ich iterieren jede Zeile
der Pyramide, mit,

130
00:07:15,070 --> 00:07:18,890
in diesem Fall der Höhe als die Variable
daß speichert die Höhe der Pyramide.

131
00:07:18,890 --> 00:07:22,870
Im Inneren des Körpers dieser Schleife, ich bin
gehen Räume immer wieder zu drucken, drucken

132
00:07:22,870 --> 00:07:26,730
die Hashes wiederholt,
und dann eine neue Zeile zu drucken.

133
00:07:26,730 --> 00:07:31,010
>> So, jetzt, mit all der Konzepte, die
Ich habe in diesem Gang durch sprach über,

134
00:07:31,010 --> 00:07:35,210
Sie sollten die aufzufordern können
Benutzer zur Eingabe, zu validieren, dass die Eingabe,

135
00:07:35,210 --> 00:07:37,370
und dann ziehen die halbe Pyramide.

136
00:07:37,370 --> 00:07:41,510
>> Mein Name ist Zamyla, und dies ist CS50.

137
00:07:41,510 --> 00:07:43,167