1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
Rob Bowden: Hallo, ich bin Rob Bowden,
und lassen Sie uns über quiz0 sprechen.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> Also, erste Frage.

5
00:00:14,545 --> 00:00:17,750
Das ist die Frage, wo
Sie den Zahlencode erforderlich

6
00:00:17,750 --> 00:00:21,270
127 in der binären Lampen.

7
00:00:21,270 --> 00:00:23,550
Wenn Sie wollten, könnten Sie
tun die regelmäßige Konvertierung

8
00:00:23,550 --> 00:00:25,950
von bi-- oder von dezimal in binär.

9
00:00:25,950 --> 00:00:28,300
Aber das wird wahrscheinlich
eine Menge Zeit in Anspruch nehmen.

10
00:00:28,300 --> 00:00:31,750
Ich meine, man könnte herausfinden, dass,
OK, 1 ist drin, 2 ist drin,

11
00:00:31,750 --> 00:00:33,650
4 ist da drin, 8 ist da drin.

12
00:00:33,650 --> 00:00:39,280
Einfacheren Weg, 127 128 minus eins.

13
00:00:39,280 --> 00:00:42,013
Das am weitesten links Glühbirne ist die 128-Bit.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
Also 127 ist wirklich nur alle
der anderen Glühbirnen,

16
00:00:47,860 --> 00:00:51,420
denn das ist die am weitesten links
Glühbirne minus 1.

17
00:00:51,420 --> 00:00:52,800
Das war es für diese Frage.

18
00:00:52,800 --> 00:00:54,060
>> Frage eins.

19
00:00:54,060 --> 00:00:56,710
Also mit 3 Bits können
stellen 8 unterschiedlichen Werte.

20
00:00:56,710 --> 00:01:01,000
Warum also ist 7 der größten nicht-negative
ganze Dezimalzahl Sie Betreiber können?

21
00:01:01,000 --> 00:01:04,050
Nun, wenn wir nur
stellen 8 unterschiedliche Werte,

22
00:01:04,050 --> 00:01:07,430
dann, was wir zu sein
repräsentiert ist 0 bis 7.

23
00:01:07,430 --> 00:01:08,745
0 nimmt einen der Werte.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> Frage zwei.

26
00:01:11,190 --> 00:01:14,610
Mit n Bits, wie viele unterschiedliche
Werte vertreten Sie?

27
00:01:14,610 --> 00:01:19,080
Also, mit n Bits, haben Sie 2
möglichen Werte für jedes Bit.

28
00:01:19,080 --> 00:01:22,300
So haben wir 2 mögliche Werte für
das erste Bit, 2 mögliche Werte

29
00:01:22,300 --> 00:01:24,450
für den zweiten, 2
möglich für den dritten.

30
00:01:24,450 --> 00:01:28,730
Und das ist also 2 mal 2 mal 2, und
schließlich ist die Antwort auf den 2 n.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> Frage drei.

33
00:01:31,100 --> 00:01:33,450
Was ist in der 0x50 binär?

34
00:01:33,450 --> 00:01:39,490
Also denken Sie daran, dass Hexadezimal hat ein sehr
unkomplizierte Umstellung auf binär.

35
00:01:39,490 --> 00:01:43,180
Also hier, wir müssen nur zum Anschauen
die 5 und die 0 unabhängig.

36
00:01:43,180 --> 00:01:45,110
Also, was ist 5 binär?

37
00:01:45,110 --> 00:01:48,400
0101, das ist der 1-Bit und das 4-Bit.

38
00:01:48,400 --> 00:01:49,900
Was ist 0 binär?

39
00:01:49,900 --> 00:01:50,520
Nicht schwierig.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
Also einfach legte sie zusammen, und
das ist die volle Zahl binär.

42
00:01:54,970 --> 00:01:57,640
01.010.000.

43
00:01:57,640 --> 00:02:00,439
Und wenn man wollte konnte man
Entfernen Sie diesen ganz links Null.

44
00:02:00,439 --> 00:02:01,105
Es ist irrelevant.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> So dann alternativ
was ist 0x50 in Dezimal?

47
00:02:05,733 --> 00:02:08,649
Wenn Sie wollten, could-- Sie, wenn Sie
komfortabler mit dem binären,

48
00:02:08,649 --> 00:02:11,340
Sie könnten, dass binäre Antwort nehmen
und konvertieren, dass in dezimal.

49
00:02:11,340 --> 00:02:13,870
Oder wir nur daran erinnern könnte
dass hexadezimal.

50
00:02:13,870 --> 00:02:21,140
0, so dass sich in der 0-ten Stelle und
die 5 ist in der 16 zu dem ersten Platz.

51
00:02:21,140 --> 00:02:25,990
Also hier haben wir 5 mal 16 zu den
Zuerst plus 0 mal 16 auf den Null,

52
00:02:25,990 --> 00:02:27,520
80.

53
00:02:27,520 --> 00:02:29,710
Und wenn man sich die gesuchte
Titel auf die Frage,

54
00:02:29,710 --> 00:02:32,920
es war CS 80, die ein bisschen eine war
Hinweis auf die Antwort auf dieses Problem.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> Frage fünf.

57
00:02:35,420 --> 00:02:40,320
Wir haben diese Scratch-Skript, das ist
Wiederholen 4 mal Erdnussbutter-Gelee.

58
00:02:40,320 --> 00:02:42,800
Wie können wir also jetzt, dass Code in C?

59
00:02:42,800 --> 00:02:47,730
Nun, wir haben hier-- das Teil fett
ist der einzige Teil, den Sie umsetzen musste.

60
00:02:47,730 --> 00:02:51,950
So haben wir eine 4-Schleife, die Schleife ist 4
Zeiten, printf-ing Erdnussbutter-Gelee,

61
00:02:51,950 --> 00:02:53,910
mit neuen Linie wie das Problem fragt nach.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> Frage sechs, ein anderer Scratch Problem.

64
00:02:57,490 --> 00:03:00,210
Wir sehen, dass wir in einer Endlosschleife sind.

65
00:03:00,210 --> 00:03:05,000
Wir sagen die Variable i
und dann Inkrementieren i um 1.

66
00:03:05,000 --> 00:03:09,580
Jetzt zu tun, dass in C. Es gibt wollen wir
mehrere Möglichkeiten, wir könnten dies getan haben.

67
00:03:09,580 --> 00:03:12,840
Hier trafen wir den Code
forever-Schleife als while (true).

68
00:03:12,840 --> 00:03:16,600
So erklären wir die Variable I, nur
wie wir hatten Variable i in Scratch.

69
00:03:16,600 --> 00:03:21,950
Deklarieren Sie die Variable i, und für immer
while (true), sagen wir die Variable i.

70
00:03:21,950 --> 00:03:25,260
So printf% i-- oder man könnte% d benutzt habe.

71
00:03:25,260 --> 00:03:27,985
Wir sagen, dass variable und
dann erhöhe ihn, ++ i.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> Frage sieben.

74
00:03:30,830 --> 00:03:35,560
Nun zu etwas ganz Ähnliches tun wollen wir
Mario dot c von der Problem gesetzt ein.

75
00:03:35,560 --> 00:03:39,110
Wir wollen diese Hashtags zu drucken,
wir eine fünf ausdrucken möchten

76
00:03:39,110 --> 00:03:40,700
durch drei Rechteck dieser Hashes.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
Also, wie sollen wir das tun?

79
00:03:43,162 --> 00:03:45,370
Nun, geben wir Ihnen eine ganze
Reihe von Code, und Sie müssen nur

80
00:03:45,370 --> 00:03:47,560
müssen in der Druckrasterfunktion auszufüllen.

81
00:03:47,560 --> 00:03:49,540
>> Also, was bedeutet Printgrid aussehen?

82
00:03:49,540 --> 00:03:51,480
Nun, Sie Vergangenheit sind
Breite und Höhe.

83
00:03:51,480 --> 00:03:53,520
So haben wir eine Außen 4
Schleife, das ist Looping

84
00:03:53,520 --> 00:03:57,650
über alle Zeilen davon
Gitter, die wir ausdrucken möchten.

85
00:03:57,650 --> 00:04:01,250
Dann haben wir die inter verschachtelten 4 Schleife
das ist das Drucken über jede Spalte.

86
00:04:01,250 --> 00:04:06,210
Also für jede Zeile, die wir für den Druck
wobei jede Spalte ein einzelner Hash.

87
00:04:06,210 --> 00:04:10,045
Dann am Ende der Zeile drucken wir ein
einzelne neue Zeile in die nächste Zeile zu gehen.

88
00:04:10,045 --> 00:04:11,420
Und das ist es für das gesamte Netz.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> Frage acht.

91
00:04:13,675 --> 00:04:17,170
Eine Funktion wie Printgrid auf der
haben einen Nebeneffekt, aber nicht eine Rückkehr

92
00:04:17,170 --> 00:04:17,670
Wert.

93
00:04:17,670 --> 00:04:19,209
Erklären Sie den Unterschied.

94
00:04:19,209 --> 00:04:23,080
Also diese stützt sich auf Sie erinnern
was ein Nebeneffekt ist.

95
00:04:23,080 --> 00:04:25,180
Nun, eine Rückkehr value--
wir wissen, Printgrid nicht

96
00:04:25,180 --> 00:04:28,180
haben Rückgabewert, da
hier heißt es nichtig.

97
00:04:28,180 --> 00:04:31,150
Also alles, die void zurück
nicht wirklich etwas zurück.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
Also, was ist die Nebenwirkung?

100
00:04:33,620 --> 00:04:36,620
Nun, das ist eine Nebenwirkung
alles, was Art von fortbesteht

101
00:04:36,620 --> 00:04:39,500
nach dem Ende der Funktion
das war nicht gerade zurückgekehrt,

102
00:04:39,500 --> 00:04:41,340
und es war nicht nur von den Eingängen.

103
00:04:41,340 --> 00:04:44,970
>> So zum Beispiel könnten wir
Ändern einer globalen Variablen.

104
00:04:44,970 --> 00:04:46,590
Das wäre ein Nebeneffekt.

105
00:04:46,590 --> 00:04:49,000
In diesem besonderen Fall wird ein
sehr wichtiger Nebeneffekt

106
00:04:49,000 --> 00:04:51,070
wird das Drucken auf dem Bildschirm.

107
00:04:51,070 --> 00:04:53,110
So daß ein Nebeneffekt
dass Printgrid hat.

108
00:04:53,110 --> 00:04:54,980
Wir drucken diese Dinge auf den Bildschirm.

109
00:04:54,980 --> 00:04:56,370
Und Sie denken können
dass als Nebeneffekt,

110
00:04:56,370 --> 00:04:58,690
denn das ist etwas,
weiterhin besteht, nachdem diese Funktion endet.

111
00:04:58,690 --> 00:05:01,481
Das ist etwas außerhalb des Geltungsbereichs
Diese Funktion, die letztlich

112
00:05:01,481 --> 00:05:03,380
wird verändert, die
Inhalt des Bildschirms.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> Frage neun.

115
00:05:05,839 --> 00:05:07,880
Betrachten Sie das folgende Programm,
auf die Zeilennummern

116
00:05:07,880 --> 00:05:09,740
Für Liebhaber von
um der Diskussion willen.

117
00:05:09,740 --> 00:05:13,480
Also in diesem Programm, das wir gerade sind
Aufruf GetString, Speicherung

118
00:05:13,480 --> 00:05:16,220
In dieser Variable s, und dann
Drucken diese Variable s.

119
00:05:16,220 --> 00:05:16,720
Ok.

120
00:05:16,720 --> 00:05:19,090
So erklären, warum Linie eine vorhanden ist.

121
00:05:19,090 --> 00:05:20,920
#include CS50 dot h.

122
00:05:20,920 --> 00:05:23,820
Warum brauchen wir den CS50 dot h # include?

123
00:05:23,820 --> 00:05:26,180
Nun rufen wir die
GetString Funktion

124
00:05:26,180 --> 00:05:28,840
und GetString definiert
in der CS50-Bibliothek.

125
00:05:28,840 --> 00:05:31,600
Also, wenn wir nicht
#include CS50 dot h,

126
00:05:31,600 --> 00:05:35,760
wir würden diese implizite Deklaration bekommen
der GetString Funktionsfehler

127
00:05:35,760 --> 00:05:36,840
vom Compiler.

128
00:05:36,840 --> 00:05:40,110
Also müssen wir die library-- gehören
wir brauchen, um die Header-Datei enthalten,

129
00:05:40,110 --> 00:05:42,870
oder aber der Compiler nicht
erkennen, dass GetString existiert.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> Erklären Sie, warum Zeile zwei vorhanden ist.

132
00:05:46,140 --> 00:05:47,890
Also Standard io dot h.

133
00:05:47,890 --> 00:05:50,430
Es ist genau das gleiche
wie das vorherige Problem,

134
00:05:50,430 --> 00:05:53,310
außer, anstatt sich mit
GetString, reden wir über printf reden.

135
00:05:53,310 --> 00:05:56,654
Also, wenn wir nicht sagen, wir brauchen
Standard io dot h gehören,

136
00:05:56,654 --> 00:05:58,820
dann würden wir nicht in der Lage sein,
die printf Funktion zu nutzen,

137
00:05:58,820 --> 00:06:00,653
Da der Compiler
würde es nicht wissen.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why-- was ist die Bedeutung
void in der vierten Zeile?

140
00:06:05,260 --> 00:06:08,010
Hier haben wir also int main (void).

141
00:06:08,010 --> 00:06:10,600
Das ist nur zu sagen, dass wir
sind nicht immer alle Befehlszeile

142
00:06:10,600 --> 00:06:12,280
Argumente zur Haupt.

143
00:06:12,280 --> 00:06:17,390
Bedenken Sie, dass wir sagen, int
Haupt int argc String argv Klammern.

144
00:06:17,390 --> 00:06:20,400
Also hier haben wir nur sagen nichtig wir sagen
ignorieren Befehlszeilenargumente.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> Erklären Sie, in Bezug auf Speicher, genau
was GetString in Reihensechs Renditen.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString zurückkehrt einen Block von
Speicher, eine Anordnung von Zeichen.

149
00:06:31,640 --> 00:06:34,870
Es ist wirklich der Rückkehr ein
Zeiger auf das erste Zeichen.

150
00:06:34,870 --> 00:06:37,170
Bedenken Sie, dass ein String eine char Stern.

151
00:06:37,170 --> 00:06:41,360
So s ist ein Zeiger auf das erste
Charakter in welcher die Saite

152
00:06:41,360 --> 00:06:43,510
dass der Benutzer an der Tastatur eingegeben.

153
00:06:43,510 --> 00:06:47,070
Und das Speicher passiert malloced werden,
so dass der Speicher im Heap.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> Frage 13.

156
00:06:50,450 --> 00:06:51,960
Betrachten Sie das folgende Programm.

157
00:06:51,960 --> 00:06:55,579
Also all das Programm tut
wird printf-ing 1 geteilt durch 10.

158
00:06:55,579 --> 00:06:57,370
Also, wenn kompiliert und
ausgeführt wird, dieses Programm

159
00:06:57,370 --> 00:07:01,170
Ausgänge 0.0, obwohl
1 geteilt durch 10 ist 0,1.

160
00:07:01,170 --> 00:07:02,970
Also warum ist es 0.0?

161
00:07:02,970 --> 00:07:05,510
Nun, das ist, weil
von Integer-Division.

162
00:07:05,510 --> 00:07:08,580
So 1 eine ganze Zahl ist, 10 eine ganze Zahl ist.

163
00:07:08,580 --> 00:07:11,980
Also 1 geteilt durch 10, alles
wird als Ganzzahlen behandelt,

164
00:07:11,980 --> 00:07:16,380
und in C, wenn wir Ganzzahl-Division zu tun,
Wir kürzen jede Dezimalstelle.

165
00:07:16,380 --> 00:07:19,590
Also 1 geteilt durch 10
0, und dann versuchen wir,

166
00:07:19,590 --> 00:07:24,410
zu drucken als Schwimmer, so
Null als Schwimmer gedruckt ist 0,0.

167
00:07:24,410 --> 00:07:27,400
Und das ist, warum wir 0,0.

168
00:07:27,400 --> 00:07:28,940
>> Betrachten Sie das folgende Programm.

169
00:07:28,940 --> 00:07:31,280
Jetzt sind wir Druck 0,1.

170
00:07:31,280 --> 00:07:34,280
Also keine Integer-Division,
wir sind nur Druck 0,1,

171
00:07:34,280 --> 00:07:37,100
aber wir sind ihn zu drucken
bis 28 Dezimalstellen.

172
00:07:37,100 --> 00:07:41,810
Und wir bekommen dies 0,1000, eine ganze Reihe
von Nullen, 5 5 5, blah blah blah.

173
00:07:41,810 --> 00:07:45,495
So ist die Frage hier ist, warum tut es
gedruckt, daß anstelle von genau 0,1?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> So ist der Grund, jetzt hier
Gleitkomma Ungenauigkeit.

176
00:07:49,640 --> 00:07:53,410
Bedenken Sie, dass ein Schwimmer nur 32 Bit.

177
00:07:53,410 --> 00:07:57,540
So können wir eine endliche Anzahl nur darstellen
von Fließkommazahlen mit jenen 32

178
00:07:57,540 --> 00:07:58,560
Bits.

179
00:07:58,560 --> 00:08:01,760
Nun gibt es letztlich unendlich
viele Fließkommawerte,

180
00:08:01,760 --> 00:08:04,940
und es gibt unendlich viele schwimm
Punktwerte zwischen 0 und 1,

181
00:08:04,940 --> 00:08:07,860
und wir sind offensichtlich in der Lage,
stellen noch mehr Werte als die.

182
00:08:07,860 --> 00:08:13,230
Also müssen wir Opfer zu machen
in der Lage, die meisten Werte darstellen.

183
00:08:13,230 --> 00:08:16,960
>> Also ein Wert wie 0,1, offenbar
können wir nicht garantieren, dass genau.

184
00:08:16,960 --> 00:08:22,500
Also statt repräsentieren 0,1 wir tun das
besten können wir diese 0.100000 5 5 stellen

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
Und das ist ziemlich nahe, aber
für eine Vielzahl von Anwendungen

187
00:08:26,306 --> 00:08:28,430
Sie haben Grund zur Sorge
Gleitkomma Ungenauigkeit,

188
00:08:28,430 --> 00:08:30,930
weil wir einfach nicht darstellen kann
alle schwebenden Punkte genau.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> Frage 15.

191
00:08:33,380 --> 00:08:34,679
Betrachten Sie den Code unten.

192
00:08:34,679 --> 00:08:36,630
Wir stehen noch am Drucken 1 plus 1.

193
00:08:36,630 --> 00:08:38,289
Also gibt es keinen Trick.

194
00:08:38,289 --> 00:08:41,780
1 plus 1 bis 2 bewertet, und
dann sind wir den Druck, dass.

195
00:08:41,780 --> 00:08:42,789
Dies druckt nur 2.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> Frage 16.

198
00:08:44,700 --> 00:08:49,450
Jetzt sind wir Druck den Charakter
1 plus der Charakter ein.

199
00:08:49,450 --> 00:08:52,110
Also warum tut dies nicht
drucken Sie die gleiche Sache?

200
00:08:52,110 --> 00:08:57,680
Nun, die Zeichen 1 plus der Charakter
1, der Charakter 1 hat ASCII-Wert 49.

201
00:08:57,680 --> 00:09:04,840
Das ist also wirklich sagen, 49 zzgl 49, und
letztlich wird dies Drucklegung 98.

202
00:09:04,840 --> 00:09:06,130
Also das wird nicht gedruckt 2.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> Frage 17.

205
00:09:09,271 --> 00:09:11,520
Abschließende Umsetzung
ungeradzahliger unten derart

206
00:09:11,520 --> 00:09:14,615
dass die Funktion liefert true, wenn
n ungerade ist und false, wenn n gerade ist.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
Dies ist ein großes Ziel
für den Mod-Operator.

209
00:09:19,330 --> 00:09:24,530
Also nehmen wir unser Argument n,
wenn n mod 2 gleich 1 ist, auch

210
00:09:24,530 --> 00:09:28,030
das bedeutet, dass n geteilt
von 2 hatte eine Rest.

211
00:09:28,030 --> 00:09:33,270
Wenn n durch 2 geteilt hatte einen Rest, dass
bedeutet, dass n ungerade ist, so dass wir return true.

212
00:09:33,270 --> 00:09:34,910
Else wir return false.

213
00:09:34,910 --> 00:09:39,070
Sie könnten auch n getan haben mod 2 equals
Null, return false, sonst true zurückgeben.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> Betrachten Sie das folgende rekursive Funktion.

216
00:09:43,640 --> 00:09:46,920
So dass, wenn n kleiner als oder
gleich 1, 1 zurückzukehren,

217
00:09:46,920 --> 00:09:50,430
andernfalls kehren n mal f von n minus 1.

218
00:09:50,430 --> 00:09:52,556
Also, was ist diese Funktion?

219
00:09:52,556 --> 00:09:54,305
Nun, das ist nur die
Fakultätsfunktion.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
Dies ist schön dargestellt
wie n Fakultät.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> Also Frage 19 jetzt, wir wollen
nehmen diese rekursive Funktion.

224
00:10:02,310 --> 00:10:04,530
Wir wollen, dass es iterative zu machen.

225
00:10:04,530 --> 00:10:05,874
Wie können wir also tun?

226
00:10:05,874 --> 00:10:07,790
Gut gerüstet für die Mitarbeiter
Lösung und wiederum gibt es

227
00:10:07,790 --> 00:10:11,090
mehrere Möglichkeiten, wie Sie getan haben könnte
dass, beginnen wir mit diesem Produkt int

228
00:10:11,090 --> 00:10:11,812
gleich 1 ist.

229
00:10:11,812 --> 00:10:13,520
Und in der gesamten
for-Schleife, wir gehen

230
00:10:13,520 --> 00:10:17,590
zu werden Multiplizieren Produkt letztendlich
am Ende mit der vollfaktorielle.

231
00:10:17,590 --> 00:10:21,870
Also für int i gleich 2 ist, ist i
weniger als oder gleich n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> Sie fragen sich vielleicht, warum ich gleich 2.

233
00:10:24,130 --> 00:10:28,380
Nun, daran erinnern, dass hier müssen wir
sicherzustellen, dass unsere Basisfall richtig ist.

234
00:10:28,380 --> 00:10:32,180
So dass, wenn n kleiner als oder gleich ist
1, sind wir nur zurück 1.

235
00:10:32,180 --> 00:10:34,830
Also hier, beginnen wir bei i gleich 2.

236
00:10:34,830 --> 00:10:39,090
Nun, wenn ich ein, dann the-- oder
wenn n waren 1, dann ist die for-Schleife

237
00:10:39,090 --> 00:10:40,600
würde überhaupt nicht auszuführen.

238
00:10:40,600 --> 00:10:43,190
Und so einfach würden wir
Return-Produkt, das 1 ist.

239
00:10:43,190 --> 00:10:45,920
In ähnlicher Weise wurden, wenn n
etwas weniger als 1--

240
00:10:45,920 --> 00:10:49,290
wenn es 0, negativ waren 1, whatever--
wir immer noch zurückkehren 1,

241
00:10:49,290 --> 00:10:52,260
das ist genau das, was das ist
rekursive Version tut.

242
00:10:52,260 --> 00:10:54,660
>> Nun, wenn n größer ist
als 1 ist, dann werden wir

243
00:10:54,660 --> 00:10:56,550
zu tun zumindest eine
Iteration dieser Schleife.

244
00:10:56,550 --> 00:11:00,630
Also sagen wir mal n 5, dann sind wir
werde Produkt mal tun gleich 2.

245
00:11:00,630 --> 00:11:02,165
So, jetzt Produkt ist 2.

246
00:11:02,165 --> 00:11:04,040
Jetzt werden wir zu tun
Produkt mal gleich 3.

247
00:11:04,040 --> 00:11:04,690
Jetzt ist es 6.

248
00:11:04,690 --> 00:11:07,500
Produkt mal gleich 4, jetzt ist es 24.

249
00:11:07,500 --> 00:11:10,420
Produkt mal gleich 5, jetzt ist es 120.

250
00:11:10,420 --> 00:11:16,730
Also letztendlich, wir Rückkehr
120, die richtig 5 Fakultät ist.

251
00:11:16,730 --> 00:11:17,510
>> Frage 20.

252
00:11:17,510 --> 00:11:22,480
Dies ist die eine, wo Sie zu füllen
in dieser Tabelle mit einem bestimmten Algorithmus,

253
00:11:22,480 --> 00:11:25,735
alles, was wir gesehen haben, dass
passt Diese algorithmischen Lauf

254
00:11:25,735 --> 00:11:28,060
Male diese asymptotische Laufzeiten.

255
00:11:28,060 --> 00:11:33,270
Also, was ist ein Algorithmus,
ist Omega von 1, aber groß O von n?

256
00:11:33,270 --> 00:11:35,970
So könnte es unendlich sein
viele Antworten hier.

257
00:11:35,970 --> 00:11:39,790
Die eine, die wir wohl je gesehen habe
Häufig ist nur lineare Suche.

258
00:11:39,790 --> 00:11:42,050
>> Also im besten Fall
Szenario: Der Artikel wir sind

259
00:11:42,050 --> 00:11:44,050
suche, ist bei der
Anfang der Liste

260
00:11:44,050 --> 00:11:47,400
und so an Omega von 1 Schritten,
das erste, was wir zu überprüfen,

261
00:11:47,400 --> 00:11:49,740
wir einfach sofort zurück
dass wir das Einzelteil fanden.

262
00:11:49,740 --> 00:11:52,189
Im schlimmsten Fall,
der Artikel ist am Ende,

263
00:11:52,189 --> 00:11:53,730
oder der Artikel nicht in der Liste überhaupt nicht.

264
00:11:53,730 --> 00:11:56,700
Also müssen wir suchen
die gesamte Liste, die alle n

265
00:11:56,700 --> 00:11:58,480
Elemente, und das ist, warum es o n.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> So jetzt ist es etwas, das sowohl die
Omega von n log n, und große O von n log n.

268
00:12:04,880 --> 00:12:08,650
Nun, die meisten relevanten Sache
wir haben hier zu sehen ist Mergesort.

269
00:12:08,650 --> 00:12:12,950
So Mergesort, denken Sie daran,
ist letztlich Theta

270
00:12:12,950 --> 00:12:16,920
n log n, wobei Theta definiert ist,
wenn beide Omega und große O sind die gleichen.

271
00:12:16,920 --> 00:12:17,580
Sowohl n log n.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> Was ist etwas, das Omega
N und O n quadriert?

274
00:12:21,970 --> 00:12:23,990
Nun, es gibt wieder
mehrere mögliche Antworten.

275
00:12:23,990 --> 00:12:26,440
Hier passieren wir sagen Bubble Sort.

276
00:12:26,440 --> 00:12:28,840
Insertion Sort würde auch hier zu arbeiten.

277
00:12:28,840 --> 00:12:31,400
Beachten Sie, dass Bubble-Sort
hat, dass die Optimierung, wo,

278
00:12:31,400 --> 00:12:34,630
wenn Sie in der Lage zu bekommen sind
durch die gesamte Liste

279
00:12:34,630 --> 00:12:37,402
ohne zu tun
alle Swaps, dann, na ja,

280
00:12:37,402 --> 00:12:40,110
können wir sofort zurück, dass
die Liste wurde sortiert, um mit anzufangen.

281
00:12:40,110 --> 00:12:43,185
Also im besten Fall
es ist nur omega n.

282
00:12:43,185 --> 00:12:45,960
Wenn es ist nicht nur ein schön
sortierte Liste zu beginnen,

283
00:12:45,960 --> 00:12:48,270
dann haben wir O n quadriert Swaps.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
Und schließlich haben wir Selection Sort
für n quadriert, sowohl Omega und große O.

286
00:12:55,610 --> 00:12:56,850
>> Frage 21.

287
00:12:56,850 --> 00:12:58,870
Was ist in der Integer-Überlauf?

288
00:12:58,870 --> 00:13:02,160
Nun wieder, ähnlich wie früher,
wir haben nur endlich viele Bits

289
00:13:02,160 --> 00:13:04,255
eine ganze Zahl darstellen,
so vielleicht 32 Bit.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
Sagen wir, wir haben eine Ganzzahl mit Vorzeichen.

292
00:13:09,180 --> 00:13:12,800
Dann schließlich die höchste
positive Zahl, die wir vertreten können

293
00:13:12,800 --> 00:13:15,910
2 bis die 31 minus 1.

294
00:13:15,910 --> 00:13:19,370
Also, was passiert, wenn wir versuchen,
dann erhöhen, die ganzzahlige?

295
00:13:19,370 --> 00:13:25,320
Nun, wir gehen von 2 bis 31 gehen
minus 1, den ganzen Weg hinunter zu negativen 2

296
00:13:25,320 --> 00:13:26,490
zum 31.

297
00:13:26,490 --> 00:13:29,470
Also das Integer-Überlauf ist
wenn Sie halten Inkrementieren

298
00:13:29,470 --> 00:13:32,330
und letztlich kann man nicht
get any höher und es ist nur

299
00:13:32,330 --> 00:13:34,520
wickelt den ganzen Weg zurück
um, um einen negativen Wert.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> Wie wärs mit einem Pufferüberlauf?

302
00:13:37,779 --> 00:13:39,820
So ein Puffer overflow--
daran erinnern, was ein Puffer.

303
00:13:39,820 --> 00:13:41,000
Es ist nur ein Teil des Speichers.

304
00:13:41,000 --> 00:13:43,350
So etwas wie ein Array ist ein Puffer.

305
00:13:43,350 --> 00:13:46,120
So ein Pufferüberlauf ist, wenn
Sie versuchen, Speicher zugreifen

306
00:13:46,120 --> 00:13:47,880
über das Ende des Arrays.

307
00:13:47,880 --> 00:13:50,410
Also, wenn Sie eine haben
Array der Größe 5 und Sie

308
00:13:50,410 --> 00:13:53,700
versuchen, Array Halterung zugreifen
5 oder 6 oder Halterung Konsole 7,

309
00:13:53,700 --> 00:13:56,610
oder irgendetwas über die
Ende oder sogar etwas

310
00:13:56,610 --> 00:14:00,790
below-- Array Halterung negativen 1--
alle von denen sind Pufferüberläufe.

311
00:14:00,790 --> 00:14:02,810
Du berühren Speicher in schlechte Wege.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> Frage 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
Also in diesem, die Sie brauchen
zu implementieren strlen.

316
00:14:09,100 --> 00:14:11,630
Und wir sagen euch, dass man
nehmen s wird nicht null sein,

317
00:14:11,630 --> 00:14:13,790
so dass Sie nicht zu haben,
Führen Sie einen Scheck über null.

318
00:14:13,790 --> 00:14:16,190
Und es gibt mehrere Möglichkeiten,
Sie könnte das getan haben.

319
00:14:16,190 --> 00:14:18,440
Hier nehmen wir eben die unkompliziert.

320
00:14:18,440 --> 00:14:21,780
Wir beginnen mit einem Zähler, n. n ist
Zählen, wie viele Zeichen sind da.

321
00:14:21,780 --> 00:14:25,560
Also wir beginnen bei 0, und dann werden wir
Iteration über die gesamte Liste.

322
00:14:25,560 --> 00:14:29,092
>> Ist s Halterung 0 gleich der
Nullabschluss Charakter?

323
00:14:29,092 --> 00:14:31,425
Angemeldet wir suchen
das Nullabschlusszeichen

324
00:14:31,425 --> 00:14:33,360
um festzustellen, wie lange unsere String ist.

325
00:14:33,360 --> 00:14:35,890
Das wird zu kündigen
alle relevanten String.

326
00:14:35,890 --> 00:14:39,400
Also ist s Halterung 0 gleich
zum Nullabschluss?

327
00:14:39,400 --> 00:14:42,850
Wenn es nicht, dann sind wir zu gehen
Blick auf s Winkel 1, s Halterung 2.

328
00:14:42,850 --> 00:14:45,050
Wir halten, bis wir
finden Sie das Nullabschluss.

329
00:14:45,050 --> 00:14:48,580
Sobald wir es gefunden haben, dann n enthält
die Gesamtlänge der Zeichenkette,

330
00:14:48,580 --> 00:14:49,942
und wir können nur zurückgeben, dass.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> Frage 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
Das ist also die eine, wo man
haben, um den Handel zu machen ab.

335
00:14:56,050 --> 00:14:59,810
So eine Sache ist gut in einem
Weise, aber in welcher Weise ist es schlecht?

336
00:14:59,810 --> 00:15:02,980
Also hier, Mergesort neigt dazu,
schneller als Bubble-Sort.

337
00:15:02,980 --> 00:15:06,530
Nachdem dass-- gut gesagt, es
mehrere Antworten hier.

338
00:15:06,530 --> 00:15:12,930
Aber der Hauptgrund ist, dass Bubble-Sort
ist Omega der n für eine sortierte Liste.

339
00:15:12,930 --> 00:15:14,950
>> Beachten Sie, dass Tisch wir gerade vorhin gesehen.

340
00:15:14,950 --> 00:15:17,600
So blase sortiert Omega
n, die besten Fall

341
00:15:17,600 --> 00:15:20,010
ist es in der Lage, gehen Sie einfach über
die Liste einmal, bestimmen

342
00:15:20,010 --> 00:15:22,270
hey das ist jetzt schon
sortiert, und zurück.

343
00:15:22,270 --> 00:15:25,960
Merge sort, egal, was
Sie tun, ist Omega von n log n.

344
00:15:25,960 --> 00:15:29,200
Also für sortierte Liste, bubble
Art geht, schneller zu sein.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> Was ist nun mit verknüpften Listen?

347
00:15:32,430 --> 00:15:36,070
So kann eine verkettete Liste wachsen und schrumpfen
so viele Elemente wie erforderlich passen.

348
00:15:36,070 --> 00:15:38,489
Nachdem dass-- so genannten
meist der direkte Vergleich

349
00:15:38,489 --> 00:15:40,280
sein wird ein verknüpftes
Liste mit einem Array.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
Also auch wenn Arrays
leicht wachsen und schrumpfen

352
00:15:44,050 --> 00:15:47,130
so viele Elemente passen
nach Bedarf, eine verkettete Liste

353
00:15:47,130 --> 00:15:49,600
im Vergleich zu einem array-- ein
Array mit wahlfreiem Zugriff.

354
00:15:49,600 --> 00:15:52,960
Wir können Index in einem
besondere Element des Arrays.

355
00:15:52,960 --> 00:15:56,430
>> Also für eine verkettete Liste, können wir nicht
nur um das fünfte Element zu gehen,

356
00:15:56,430 --> 00:16:00,260
Wir müssen von Anfang queren
bis wir mit dem fünften Element.

357
00:16:00,260 --> 00:16:03,990
Und das wird uns daran hindern
etwas wie binäre Such tut.

358
00:16:03,990 --> 00:16:08,150
Apropos binäre Suche, binäre Suche
neigt schneller als lineare Suche zu sein.

359
00:16:08,150 --> 00:16:11,120
Nachdem dass-- sagte
so ist eine mögliche Sache

360
00:16:11,120 --> 00:16:13,380
ist, dass man nicht binär tun
Suche auf verkettete Listen,

361
00:16:13,380 --> 00:16:14,730
Sie kann es nur auf Arrays.

362
00:16:14,730 --> 00:16:18,030
Aber wahrscheinlich noch wichtiger ist,
Sie kann nicht binäre Suche zu tun

363
00:16:18,030 --> 00:16:20,690
auf einem Array, die nicht sortiert ist.

364
00:16:20,690 --> 00:16:23,990
Upfront müssen Sie möglicherweise sortieren
das Array, und nur dann können

365
00:16:23,990 --> 00:16:25,370
Sie binäre Suche zu tun.

366
00:16:25,370 --> 00:16:27,660
Also, wenn Ihr Ding ist nicht
sortierten zu beginnen,

367
00:16:27,660 --> 00:16:29,250
dann lineare Suche könnte schneller sein.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> Frage 27.

370
00:16:31,740 --> 00:16:34,770
So betrachten Sie das Programm unter,
die in der nächsten Folie sein wird.

371
00:16:34,770 --> 00:16:37,790
Und das ist das, wo wir sind
werde ausdrücklich zu wollen

372
00:16:37,790 --> 00:16:39,980
Die Werte für die verschiedenen Variablen.

373
00:16:39,980 --> 00:16:41,990
Also schauen wir uns das an.

374
00:16:41,990 --> 00:16:43,160
>> So säumen ein.

375
00:16:43,160 --> 00:16:45,457
Wir haben int x gleich 1.

376
00:16:45,457 --> 00:16:47,040
Das ist das einzige, was passiert ist.

377
00:16:47,040 --> 00:16:50,440
Also in Zeile ein, in sehen wir unsere
Tisch, dass y, a, b und tmp sind

378
00:16:50,440 --> 00:16:51,540
geschwärzt.

379
00:16:51,540 --> 00:16:52,280
Also, was ist x?

380
00:16:52,280 --> 00:16:53,860
Nun, wir nur setzen Sie ihn gleich 1 ist.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
Und dann Zeile zwei, nun ja,
wir sehen, dass y auf 2 gesetzt ist,

383
00:16:58,770 --> 00:17:00,550
und die Tabelle bereits
in für uns gefüllt.

384
00:17:00,550 --> 00:17:03,040
So x 1 ist und y 2 ist.

385
00:17:03,040 --> 00:17:05,890
>> Nun Linie drei, jetzt sind wir
innerhalb der Swap-Funktion.

386
00:17:05,890 --> 00:17:07,560
Was haben wir übergeben zu tauschen?

387
00:17:07,560 --> 00:17:11,609
Wir passierten Kaufmanns-x für
a, und das kaufmännische y für b.

388
00:17:11,609 --> 00:17:15,160
Wo das Problem vorher
angegeben, dass die Adresse x

389
00:17:15,160 --> 00:17:17,520
0x10 ist, und die Adresse y 0x14.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
Also a und b gleich sind
0x10 und 0x14 sind.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> Jetzt in Zeile drei, was sind x und y?

394
00:17:26,250 --> 00:17:28,554
Nun, nichts hat sich geändert
zu x und y an diesem Punkt.

395
00:17:28,554 --> 00:17:30,470
Obwohl sie
innerhalb eines Hauptstapelrahmen,

396
00:17:30,470 --> 00:17:32,469
sie haben immer noch die gleichen
Werte, die sie zuvor.

397
00:17:32,469 --> 00:17:34,030
Wir haben keine Speicher modifiziert.

398
00:17:34,030 --> 00:17:35,710
So x 1 ist, y 2 ist.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
In Ordnung.

401
00:17:37,050 --> 00:17:40,300
So, jetzt haben wir gesagt int tmp gleich einem Stern.

402
00:17:40,300 --> 00:17:44,410
Also in Zeile vier, alles
ist gleich, mit Ausnahme tmp.

403
00:17:44,410 --> 00:17:47,130
Es wurden keine Werte geändert
von irgendetwas außer tmp.

404
00:17:47,130 --> 00:17:49,230
Wir tmp gleich einen Stern Einstellung.

405
00:17:49,230 --> 00:17:50,620
Was ist Stern ein?

406
00:17:50,620 --> 00:17:56,240
Nun, ein Punkte auf x, also Stern A
ist gleich x, die 1 geht.

407
00:17:56,240 --> 00:18:00,080
Also alles wird kopiert
unten, und tmp auf 1 gesetzt ist.

408
00:18:00,080 --> 00:18:01,110
>> Nun ist die nächste Zeile.

409
00:18:01,110 --> 00:18:03,380
Stern a gleich star b.

410
00:18:03,380 --> 00:18:10,000
Also durch die Linie five-- wieder gut, alles
ist die gleiche, außer was auch immer star a.

411
00:18:10,000 --> 00:18:10,830
Was ist Stern ein?

412
00:18:10,830 --> 00:18:13,720
Nun, nur gesagt, dass wir Sterne a x.

413
00:18:13,720 --> 00:18:16,400
Also wir verändern x Gleich Sterne b.

414
00:18:16,400 --> 00:18:18,960
Was ist Stern b? y. b zeigt auf y.

415
00:18:18,960 --> 00:18:21,030
Also star b ist y.

416
00:18:21,030 --> 00:18:25,140
Also werden wir die Einstellung x gleich y,
und alles andere ist gleich.

417
00:18:25,140 --> 00:18:29,130
So sehen wir in der nächsten Zeile, dass x ist jetzt
2, und der Rest sind nur kopiert nach unten.

418
00:18:29,130 --> 00:18:31,120
>> Jetzt in der nächsten Zeile, star b gleich tmp.

419
00:18:31,120 --> 00:18:34,740
Nun, nur gesagt, dass wir Sterne b y,
so dass wir die Einstellung y gleich tmp.

420
00:18:34,740 --> 00:18:37,450
Alles andere ist gleich,
so wird alles kopiert nach unten.

421
00:18:37,450 --> 00:18:42,050
Wir setzen y gleich tmp, das ist
ein, und alles andere ist die gleiche.

422
00:18:42,050 --> 00:18:43,210
>> Nun endlich, Zeile sieben.

423
00:18:43,210 --> 00:18:44,700
Wir sind wieder in der Hauptfunktion.

424
00:18:44,700 --> 00:18:46,350
Wir sind nach dem Swap ist beendet.

425
00:18:46,350 --> 00:18:48,972
Wir haben eine, b verloren und
tmp, aber letztlich haben wir

426
00:18:48,972 --> 00:18:51,180
sind keine Werte ändern
von irgendetwas an dieser Stelle,

427
00:18:51,180 --> 00:18:52,800
kopieren wir nur x und y nach unten.

428
00:18:52,800 --> 00:18:56,490
Und wir sehen, daß x und y
Jetzt 2 und 1 anstelle von 1 und 2.

429
00:18:56,490 --> 00:18:58,160
Der Swap wurde erfolgreich ausgeführt.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> Frage 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
Angenommen, Sie stoßen
die Fehlermeldungen

434
00:19:03,100 --> 00:19:06,790
unten während der Bürozeiten
im nächsten Jahr als CA oder TF.

435
00:19:06,790 --> 00:19:08,930
Beraten, wie jeder dieser Fehler zu beheben.

436
00:19:08,930 --> 00:19:11,160
So undefined reference to GetString.

437
00:19:11,160 --> 00:19:12,540
Warum könnte man das sehen?

438
00:19:12,540 --> 00:19:15,380
Nun, wenn ein Schüler mit
GetString in ihrem Code,

439
00:19:15,380 --> 00:19:20,310
sie ordnungsgemäß eingeschlossen CS50 Hash
dot h, um den CS50-Bibliothek enthalten.

440
00:19:20,310 --> 00:19:22,380
>> Nun, was tun sie
brauchen, um diesen Fehler zu beheben?

441
00:19:22,380 --> 00:19:26,810
Sie müssen einen Bindestrich LCS50 am tun
Befehlszeile, wenn sie kompilieren.

442
00:19:26,810 --> 00:19:29,501
Also, wenn sie nicht bestehen,
Klappern dash LCS50, sind sie

443
00:19:29,501 --> 00:19:32,000
nicht die tatsächliche zu haben
Code, der GetString implementiert.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> Frage 29.

446
00:19:34,170 --> 00:19:36,190
Implizit erklärt
Bibliotheksfunktion strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
Gut, das jetzt, nicht sie haben
getan den richtigen Hash gehören.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
In diesem besonderen Fall wird die Header-Datei
sie benötigen, um zählen ist string dot h,

451
00:19:45,410 --> 00:19:48,710
einschließlich String dot h, jetzt
die student-- jetzt der Compiler

452
00:19:48,710 --> 00:19:51,750
Zugriff auf die
Erklärungen strlen,

453
00:19:51,750 --> 00:19:54,120
und er weiß, dass Ihr Code
wird mit strlen korrekt.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> Frage 30.

456
00:19:56,580 --> 00:20:00,240
Weitere Prozent Konvertierungen
als Daten Argumente.

457
00:20:00,240 --> 00:20:01,540
Also, was ist das?

458
00:20:01,540 --> 00:20:06,470
Gut erinnern, dass diese Prozent
signs-- wie sie sind relevant für printf.

459
00:20:06,470 --> 00:20:08,890
So in printf wir könnten percent--
wir könnten etwas ausdrucken

460
00:20:08,890 --> 00:20:11,380
wie Prozent i Backslash n.

461
00:20:11,380 --> 00:20:15,310
Oder wir könnten wie Prozent i drucken,
Raum Prozent i, Raum, Prozent i.

462
00:20:15,310 --> 00:20:18,950
So dass für jede der Personen,
Prozentzeichen, müssen wir

463
00:20:18,950 --> 00:20:21,560
eine Variable am Ende der printf übergeben.

464
00:20:21,560 --> 00:20:26,980
>> Also, wenn wir sagen, printf paren Prozent
i Backslash n nahe paren,

465
00:20:26,980 --> 00:20:30,270
na ja, sagen wir, dass wir
werde eine ganze Zahl zu drucken,

466
00:20:30,270 --> 00:20:33,970
aber dann haben wir nicht printf übergeben
eine ganze Zahl, um tatsächlich zu drucken.

467
00:20:33,970 --> 00:20:37,182
Also hier mehr Prozent
Umsätze als Daten Argumente?

468
00:20:37,182 --> 00:20:39,390
Das sagt, dass wir
eine ganze Reihe von Prozenten,

469
00:20:39,390 --> 00:20:42,445
und wir haben nicht genug Variablen
tatsächlich in jenen Prozente zu füllen.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> Und dann auf jeden Fall, für Frage 31,
definitiv in einem Blöcken verlor 40 Bytes.

472
00:20:50,010 --> 00:20:52,350
Das ist also ein Valgrind Fehler.

473
00:20:52,350 --> 00:20:54,720
Dieser sagt, dass
irgendwo im Code,

474
00:20:54,720 --> 00:20:59,010
Sie eine Zuordnung, die 40 haben
Byte groß, so dass Sie malloced 40 Bytes,

475
00:20:59,010 --> 00:21:00,515
und Sie nie befreit es.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
Wahrscheinlich brauchen Sie nur
einige Speicherlecks zu finden,

478
00:21:05,140 --> 00:21:07,650
und herausfinden, wo Sie ihn brauchen
Free Speicherblock.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> Und Frage 32,
ungültigen Schreib der Größe 4.

481
00:21:11,910 --> 00:21:13,250
Auch dies ist ein Valgrind Fehler.

482
00:21:13,250 --> 00:21:15,440
Dies muss nicht zu tun
mit Speicherlecks jetzt.

483
00:21:15,440 --> 00:21:20,750
Dies ist, die meisten likely-- Ich meine, es ist
eine Art von ungültigen Speicherrechte.

484
00:21:20,750 --> 00:21:23,270
Und wahrscheinlich ist dies einige
Art von Pufferüberlauf.

485
00:21:23,270 --> 00:21:26,560
Wo haben Sie ein Array, vielleicht
ein Integer-Array, und lassen Sie uns

486
00:21:26,560 --> 00:21:30,115
sagen, es ist der Größe 5, und Sie
versuchen, Array Klammer 5 berühren.

487
00:21:30,115 --> 00:21:34,150
Also, wenn Sie versuchen, um zu schreiben
Wert, das ist nicht ein Stück Erinnerung

488
00:21:34,150 --> 00:21:37,440
dass Sie tatsächlich den Zugang zu
so wirst du diese Fehlermeldung erhalten,

489
00:21:37,440 --> 00:21:39,272
sagen ungültigen Schreib der Größe 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind wird, zu erkennen, du bist
versuchen, Speicher unsittlich zu berühren.

491
00:21:42,480 --> 00:21:43,980
>> Und das ist es für quiz0.

492
00:21:43,980 --> 00:21:47,065
Ich bin Rob Bowden, und dies ist CS50.

493
00:21:47,065 --> 00:21:51,104