1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Problema Sezione Set 2: Edizione Hacker

2
00:00:02,670 --> 00:00:04,910
Rob Bowden, l'Università di Harvard

3
00:00:04,910 --> 00:00:07,410
Questo è CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Quindi, io sono Rob. Sono un anziano a Kirkland. Questo è il mio terzo anno TFing CS50.

5
00:00:15,770 --> 00:00:22,220
E 'la prima volta che stiamo cambiando dalla tradizionale lezione in stile sezione,

6
00:00:22,220 --> 00:00:25,610
dove abbiamo solo tipo di revisione ciò che è accaduto in aula e poi voi ragazzi fare domande,

7
00:00:25,610 --> 00:00:32,250
ora ad essere molto più problem-based, in cui si usa Spaces, e -

8
00:00:32,250 --> 00:00:37,410
Oh, quindi l'idea è di andare a quel link che ti ho mandato e poi sarai nel mio spazio.

9
00:00:37,410 --> 00:00:42,410
Non Qualcuno ha un computer portatile? Va bene.

10
00:00:42,410 --> 00:00:47,050
Quindi abbiamo intenzione di utilizzare questo, e stiamo andando a fare problemi vivere in sezione

11
00:00:47,050 --> 00:00:50,740
e discutere di loro e capire cosa c'è che non va

12
00:00:50,740 --> 00:00:56,390
e potrei tirare su un po 'di codice, e potrei discutere le vostre idee.

13
00:00:56,390 --> 00:01:02,140
Quindi qualcuno ha avuto difficoltà?

14
00:01:02,140 --> 00:01:07,000
Puoi chattare sul lato, io non so se avremo ragione per questo.

15
00:01:07,000 --> 00:01:12,270
Ora, come la supersection precedente, se si fosse a quella classe, sapete di cosa si tratta.

16
00:01:12,270 --> 00:01:19,200
Su tutti insiemi P ci sarà queste sezioni.

17
00:01:19,200 --> 00:01:22,550
Quindi P-set 2, le specifiche, penso che visto il P-set 1 già.

18
00:01:22,550 --> 00:01:27,400
Ma possiamo guardare P-set 2 per quello che abbiamo intenzione di andare oltre oggi.

19
00:01:27,400 --> 00:01:29,460
E vedrete una sezione di domande.

20
00:01:29,460 --> 00:01:37,530
Quindi questo sarà in tutti i P-set, ci sarà una sezione di domande.

21
00:01:37,530 --> 00:01:41,340
Finora abbiamo detto: "Consideriamo questo l'opportunità di praticare."

22
00:01:41,340 --> 00:01:44,940
Non ti verrà chiesto di presentare questo programma.

23
00:01:44,940 --> 00:01:48,480
L'idea è che questi dovrebbero tipo di aiutarvi a iniziare con il problema proposto.

24
00:01:48,480 --> 00:01:53,220
Credo che l'edizione Hacker, molti di loro dovrebbero essere solo nuove, cose interessanti da imparare.

25
00:01:53,220 --> 00:01:58,590
Essi non possono essere direttamente applicabile al problema proposto.

26
00:01:58,590 --> 00:02:01,810
E in questo momento non stiamo avendo di inviarli, ma in teoria,

27
00:02:01,810 --> 00:02:07,480
per i set di problemi successivi, è possibile inviarli, e quindi si potrà venire alla sezione

28
00:02:07,480 --> 00:02:10,380
o guardare la sezione per ottenere le risposte, o si può semplicemente farli da soli

29
00:02:10,380 --> 00:02:16,350
se non avete voglia di godere la mia presenza.

30
00:02:16,350 --> 00:02:21,010
Così il - credo che questo sia il primo.

31
00:02:21,010 --> 00:02:29,280
Oh. Inoltre, in queste sezioni di domande abbiamo anche fare domande sui pantaloncini.

32
00:02:29,280 --> 00:02:33,440
Quindi credo che, in teoria, dovresti guardare questi prima di venire al punto,

33
00:02:33,440 --> 00:02:38,550
ma va bene se non lo fai, noi andremo su di loro in ogni caso.

34
00:02:38,550 --> 00:02:42,590
Così possiamo iniziare con questi: "Come fa un ciclo while differisce da un ciclo do-while?

35
00:02:42,590 --> 00:02:46,210
Quando è quest'ultima particolarmente utile? "

36
00:02:46,210 --> 00:02:49,390
Così qualcuno ha qualche -?

37
00:02:49,390 --> 00:02:52,730
[Studente] Il ciclo do-while viene sempre eseguito almeno una volta.

38
00:02:52,730 --> 00:03:02,950
Sì. Così che è la differenza. Un ciclo while - I'Ll fatelo qui - while, abbiamo la condizione

39
00:03:02,950 --> 00:03:19,760
proprio qui, mentre un do-po ', non si dispone di una condizione fino ad arrivare qui.

40
00:03:19,760 --> 00:03:24,130
E così, quando il programma è in esecuzione, e si arriva al ciclo while,

41
00:03:24,130 --> 00:03:26,380
controlla immediatamente se la condizione è vera.

42
00:03:26,380 --> 00:03:30,710
Se questa condizione non è vera, sarà solo saltare il ciclo del tutto.

43
00:03:30,710 --> 00:03:34,390
Do-while, in quanto il programma è in esecuzione, si arriva al "fare".

44
00:03:34,390 --> 00:03:37,920
Non accade nulla, a questo punto, continua solo l'esecuzione.

45
00:03:37,920 --> 00:03:42,690
Poi, quando colpisce il "po '", se la condizione è vera, sarà Ripeti avanti e farlo di nuovo

46
00:03:42,690 --> 00:03:46,730
e ancora e ancora fino a quando la condizione non è vera e poi cade solo attraverso.

47
00:03:46,730 --> 00:03:50,600
Così, con la differenza che questa può passare direttamente fin dall'inizio.

48
00:03:50,600 --> 00:03:56,770
Esegue necessariamente una volta e poi possono eseguire più volte se la condizione è ancora vera.

49
00:03:56,770 --> 00:04:03,720
Quindi il ciclo while sarà solo fare una volta, o - il ciclo while - non aver bisogno di farlo a tutti,

50
00:04:03,720 --> 00:04:07,900
poiché non appena si arriva ad essa, se la condizione è falsa, ci limiteremo a saltare su di esso.

51
00:04:07,900 --> 00:04:11,770
Considerando che, do-while, noi lo esegue una volta, necessariamente.

52
00:04:11,770 --> 00:04:14,560
Poi, quando si arriva alla condizione, controlliamo se è vero o falso.

53
00:04:14,560 --> 00:04:19,790
Se è vero, lo faremo di nuovo, se è falso, dobbiamo solo continuare ad andare.

54
00:04:19,790 --> 00:04:24,680
Così, quando quest'ultimo è particolarmente utile?

55
00:04:24,680 --> 00:04:31,190
Quindi posso dire che la totalità dei 4 anni, 3 anni, qualunque sia,

56
00:04:31,190 --> 00:04:38,780
che sono stato di programmazione, ho usato questo, come, meno di 10 volte.

57
00:04:38,780 --> 00:04:43,140
E probabilmente 5 di loro sono in CS50 quando stiamo introducendo do-while.

58
00:04:43,140 --> 00:04:47,510
Allora, quando hai usato do-while?

59
00:04:47,510 --> 00:04:49,510
Quando è il - yeah?

60
00:04:49,510 --> 00:04:53,180
[Studente] Quando si sta cercando di ottenere l'input dell'utente, o qualcosa che si desidera controllare -

61
00:04:53,180 --> 00:04:59,700
Gia '. Quindi, do-while, l'input dell'utente è quello grande.

62
00:04:59,700 --> 00:05:03,160
Ecco perché le prime serie di problemi di coppia, quando si vuole chiedere all'utente, come,

63
00:05:03,160 --> 00:05:08,520
"Dammi una stringa," non si può continuare fino ad ottenere quella stringa.

64
00:05:08,520 --> 00:05:12,980
E così, necessariamente, bisogno di chiedere per la stringa di almeno una volta.

65
00:05:12,980 --> 00:05:16,950
Ma poi se rispondono qualcosa di brutto, allora avete bisogno di loop indietro e chiedere di nuovo.

66
00:05:16,950 --> 00:05:20,810
Ma a parte l'input dell'utente, è molto raro che ho incontrato un caso

67
00:05:20,810 --> 00:05:27,170
dove voglio loop "almeno una volta", ma forse di più.

68
00:05:27,170 --> 00:05:33,370
Domande o -? Qualcuno ha usato un ciclo do-while altrove?

69
00:05:33,370 --> 00:05:36,780
Va bene. Quindi il prossimo è: "Che cosa non dichiarati identificatore

70
00:05:36,780 --> 00:05:43,310
di solito indicano se in uscita dal clang? "

71
00:05:43,310 --> 00:05:47,380
Quindi, che tipo di codice potrei scrivere per ottenere 'identificatore non dichiarato?'

72
00:05:47,380 --> 00:05:49,550
[Studente] che x = 2?

73
00:05:49,550 --> 00:05:52,650
Così possiamo solo provare qui, x = 2.

74
00:05:52,650 --> 00:06:04,830
Faremo questo - oh, non l'ho fatto clic. Così qui otteniamo - tutti i diritti.

75
00:06:04,830 --> 00:06:07,100
"L'uso di x identificatore non dichiarato".

76
00:06:07,100 --> 00:06:11,610
Ecco, questo è l'identificatore non dichiarato, una variabile.

77
00:06:11,610 --> 00:06:13,910
Sarà spesso chiamare una variabile un identificatore.

78
00:06:13,910 --> 00:06:17,300
Quindi potrebbe non sapere che in realtà è una variabile, ma non sa cosa sia.

79
00:06:17,300 --> 00:06:19,380
Quindi è un identificatore.

80
00:06:19,380 --> 00:06:26,060
Allora perché è sommerso? Gia '.

81
00:06:26,060 --> 00:06:32,190
Quindi, per essere chiari sulla terminologia, la dichiarazione di una variabile

82
00:06:32,190 --> 00:06:37,360
è quando si dice "int x" o "y", stringa qualunque.

83
00:06:37,360 --> 00:06:41,910
L'inizializzazione della variabile, o l'assegnazione della variabile,

84
00:06:41,910 --> 00:06:44,510
è ogni volta che si dice "x = 2."

85
00:06:44,510 --> 00:06:52,950
Così siamo in grado di eseguire le operazioni in fasi separate, int x, x = 2, e fino a quando - siamo in grado di avere un sacco di roba qui dentro -

86
00:06:52,950 --> 00:07:00,350
ma fino a questa linea accade, x è ancora inizializzato, ma è stato dichiarato.

87
00:07:00,350 --> 00:07:06,760
E così possiamo ovviamente fare a 1 linea, e ora stiamo dichiarazione e l'inizializzazione.

88
00:07:06,760 --> 00:07:10,730
Domande?

89
00:07:10,730 --> 00:07:18,390
E infine: "Perché non è il cifrario di Cesare molto sicuro?"

90
00:07:18,390 --> 00:07:23,830
Quindi, prima, qualcuno vuole dire ciò che il cifrario di Cesare è?

91
00:07:23,830 --> 00:07:28,100
[Studente] Caesar Cipher è proprio questo si associa, si sposta ogni lettera,

92
00:07:28,100 --> 00:07:34,420
un certo numero di lettere andare oltre, e tornare sopra, e non è molto sicuro perché

93
00:07:34,420 --> 00:07:42,260
ci sono solo 26 le possibili opzioni e non resta che provare ogni uno di quelli fino ad arrivare.

94
00:07:42,260 --> 00:07:45,470
Oh. Quindi, devo ripetere?

95
00:07:45,470 --> 00:07:51,600
Il cifrario di Cesare, E'- voglio dire, ti a che fare con essa i problemi che voi -

96
00:07:51,600 --> 00:07:56,110
o credo che l'edizione standard del set di problema che non e 'l'edizione hacker.

97
00:07:56,110 --> 00:08:01,550
Così il l'edizione standard per il problema proposto, viene visualizzato un messaggio del tipo: "Ciao, mondo"

98
00:08:01,550 --> 00:08:08,410
e hai anche un numero come 6, e si prende quel messaggio, e ogni singolo carattere,

99
00:08:08,410 --> 00:08:11,310
lo si ruota di 6 posizioni in alfabeto.

100
00:08:11,310 --> 00:08:16,560
Così la 'h' in ciao diventerebbe h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
Quindi la prima lettera sarebbe n. Facciamo la stessa cosa con l'e.

102
00:08:19,600 --> 00:08:23,530
Se abbiamo una, come, z o qualcosa del genere, poi avvolgere indietro intorno a 'a.'

103
00:08:23,530 --> 00:08:29,280
Ma ogni personaggio ha pedalato 6 caratteri in seguito l'alfabeto, e non è molto sicuro

104
00:08:29,280 --> 00:08:35,440
dato che ci sono solo 26 possibilità per quanti modi si può avvolgere una singola lettera.

105
00:08:35,440 --> 00:08:42,919
Così si può solo provare tutte le 26 di loro e, presumibilmente, per un messaggio abbastanza a lungo,

106
00:08:42,919 --> 00:08:46,860
solo 1 di queste cose possibili 26 sta per essere leggibile,

107
00:08:46,860 --> 00:08:50,300
e quello leggibile sarà il messaggio originale.

108
00:08:50,300 --> 00:08:56,240
Quindi non è un ottimo modo per crittografare nulla.

109
00:08:56,240 --> 00:08:59,070
Estranei a quei pantaloncini, "Che cos'è una funzione?"

110
00:08:59,070 --> 00:09:03,370
Così che cosa è una funzione? Sì.

111
00:09:03,370 --> 00:09:11,640
[Studente] E 'come un foglio di codice che è possibile chiamare per passare il turno e quindi ottenere il valore di ritorno di qualsiasi altra cosa.

112
00:09:11,640 --> 00:09:18,160
Gia '. Quindi ti risponderò anche dal rispondere alla prossima - o la ripetizione di anche solo rispondendo alla successiva.

113
00:09:18,160 --> 00:09:22,410
È possibile utilizzare funzioni invece di copiare e incollare il codice più e più volte.

114
00:09:22,410 --> 00:09:27,200
Basta prendere il codice, inserirlo in una fuction, e poi si può solo chiamare la funzione

115
00:09:27,200 --> 00:09:29,870
dove siete stati copia e incolla.

116
00:09:29,870 --> 00:09:33,350
Quindi le funzioni sono utili.

117
00:09:33,350 --> 00:09:35,860
Così ora faremo problemi reali.

118
00:09:35,860 --> 00:09:46,490
La prima. Così l'idea del primo è, si passa una stringa, e indipendentemente dal -

119
00:09:46,490 --> 00:09:52,060
o lo dice tutto in minuscolo? Non dice tutto in minuscolo.

120
00:09:52,060 --> 00:09:57,730
Quindi, il messaggio può essere qualsiasi cosa, e - oh no. Lo fa.

121
00:09:57,730 --> 00:10:01,610
"Per semplicità, si può presumere che l'utente sarà solo ingresso lettere minuscole e spazi."

122
00:10:01,610 --> 00:10:08,180
Quindi passare un messaggio con solo lettere minuscole e poi alternare

123
00:10:08,180 --> 00:10:15,450
tra capitale e minuscole - si cambia la stringa di essere capitale e minuscole, alternando.

124
00:10:15,450 --> 00:10:22,920
Quindi, prima di dare un secondo per immergersi anche nel problema,

125
00:10:22,920 --> 00:10:32,420
qual è la prima cosa che dobbiamo fare?

126
00:10:32,420 --> 00:10:36,900
Oh, quello che ho appena fare clic su? Oh, ho appena cliccato su una e-mail qui.

127
00:10:36,900 --> 00:10:42,870
Quindi la prima cosa che dobbiamo fare - sto guardando quello sbagliato?

128
00:10:42,870 --> 00:10:49,320
E 'questa parte di questo?

129
00:10:49,320 --> 00:10:51,320
No, quelli sono ancora lì, però.

130
00:10:51,320 --> 00:10:55,160
Ok, ancora qui.

131
00:10:55,160 --> 00:11:03,160
Ora non possiamo pensare -? Sì. Qui non si può pensare che è solo minuscole e spazi.

132
00:11:03,160 --> 00:11:07,770
Così ora abbiamo a che fare con il fatto che le lettere possono essere tutto ciò che vogliamo che siano.

133
00:11:07,770 --> 00:11:11,910
E così la prima cosa che vogliamo fare è semplicemente il messaggio.

134
00:11:11,910 --> 00:11:19,790
Abbiamo solo bisogno di ottenere una stringa, string s = GetString, va bene.

135
00:11:19,790 --> 00:11:24,890
Ora questo problema, ci sono un paio di modi per farlo.

136
00:11:24,890 --> 00:11:29,840
Ma stiamo andando a voler utilizzare gli operatori bit a bit qui.

137
00:11:29,840 --> 00:11:35,280
Ci sono persone che o non erano al supersection,

138
00:11:35,280 --> 00:11:37,480
o qualcosa del genere, e non so che cosa operatori bit a bit sono?

139
00:11:37,480 --> 00:11:41,710
O come si riferiscono alla ASCII in qualche modo?

140
00:11:41,710 --> 00:11:45,650
[Studente] non ero al supersection, ma so quello che sono operatori bit a bit.

141
00:11:45,650 --> 00:11:49,560
Va bene. Allora non c'è bisogno di andare oltre le nozioni di base, ma ti spiego

142
00:11:49,560 --> 00:11:51,830
quello che stiamo andando a voler usare qui.

143
00:11:51,830 --> 00:11:59,680
Così 'A': rappresentazione binaria del capitale A, il numero è 65.

144
00:11:59,680 --> 00:12:07,560
Sto solo andando a guardare - 41 sta per essere 01000001.

145
00:12:07,560 --> 00:12:14,170
Quindi, che dovrebbe essere 65 in decimale, quindi questa è la rappresentazione binaria del carattere capitale A.

146
00:12:14,170 --> 00:12:19,440
Ora, la rappresentazione binaria del carattere minuscolo 'a'

147
00:12:19,440 --> 00:12:33,350
sarà la stessa cosa, o quasi. E '- 6, si'. Questo è giusto.

148
00:12:33,350 --> 00:12:37,670
Così capitale binario A, minuscolo binario 'a.'

149
00:12:37,670 --> 00:12:43,940
Così notare che la differenza fra A e 'a' è tale singolo bit.

150
00:12:43,940 --> 00:12:49,440
E questo sembra essere il 32 bit, il bit che rappresenta il numero 32.

151
00:12:49,440 --> 00:12:53,910
E questo ha un senso in quanto A è 65; 'a' è 97.

152
00:12:53,910 --> 00:12:56,610
La differenza tra loro è 32.

153
00:12:56,610 --> 00:13:03,770
Così ora sappiamo che siamo in grado di convertire da A 'a' prendendo un

154
00:13:03,770 --> 00:13:09,710
OR bit per bit e che, con - che sembra un 1.

155
00:13:09,710 --> 00:13:20,900
Si tratta di un OR bit per bit, con 00100000, e che ti ci danno 'a.'

156
00:13:20,900 --> 00:13:26,850
E siamo in grado di ottenere da 'a' ad A AND bit per bit

157
00:13:26,850 --> 00:13:33,700
con 11, 0 in quel luogo, 11111.

158
00:13:33,700 --> 00:13:43,840
Quindi questo poi ci darà esattamente quello che 'a' è stata, ma cancellare questo bit individuale,

159
00:13:43,840 --> 00:13:50,070
quindi dovremo 01000001, io non so se ho contato bene.

160
00:13:50,070 --> 00:13:56,750
Ma questa tecnica di OR bit a bit per ottenere dal capitale in lettere minuscole,

161
00:13:56,750 --> 00:14:02,080
e bit per bit AND per passare da minuscole al capitale non è esclusiva di A.

162
00:14:02,080 --> 00:14:06,510
Tutte le lettere, K vs k, Z vs z,

163
00:14:06,510 --> 00:14:10,080
tutti sono solo andando a differire da questo singolo bit.

164
00:14:10,080 --> 00:14:16,290
E così è possibile utilizzare questo per passare da tutte le lettere minuscole a qualsiasi lettera maiuscola e viceversa.

165
00:14:16,290 --> 00:14:26,670
Va bene. Quindi, un modo semplice di ottenere da questo - così invece di dover

166
00:14:26,670 --> 00:14:32,170
scrivere tutto ciò che è 1011111 - un modo semplice di rappresentare questo numero, e questo non è uno

167
00:14:32,170 --> 00:14:39,710
che sono andato oltre nella supersection, ma tilde (~) è un altro operatore bit a bit.

168
00:14:39,710 --> 00:14:42,520
Che cosa ~ fa è che guarda la rappresentazione bit.

169
00:14:42,520 --> 00:14:45,630
Prendiamo un numero qualsiasi.

170
00:14:45,630 --> 00:14:53,130
Questo è solo un certo numero binario, e ciò non è ~ si ribalta appena tutti i bit.

171
00:14:53,130 --> 00:15:00,630
Quindi questo era un 1, ora a 0, questo è uno 0, 1 ora, 010.100.

172
00:15:00,630 --> 00:15:08,320
Ecco, questo è tutto ~ fa. Quindi 32 è sarà il numero - sbarazzarsi di quel -

173
00:15:08,320 --> 00:15:23,320
32 è così sarà il numero 00100000, e quindi ~ di tutto questo sta per essere

174
00:15:23,320 --> 00:15:29,980
questo numero qui che ho AND 'a' con.

175
00:15:29,980 --> 00:15:35,600
Ritiene vedere a tutti che? Questo è abbastanza comune, come quando si vuole capire

176
00:15:35,600 --> 00:15:40,740
per le cose dopo che si potrebbe vedere, se vogliamo vedere se -

177
00:15:40,740 --> 00:15:44,710
o vogliamo che tutto, ogni insieme singolo bit, tranne per 1

178
00:15:44,710 --> 00:15:47,910
si tende a fare ~ del bit che non si desidera impostare.

179
00:15:47,910 --> 00:15:53,090
Quindi non vogliamo che il set a 32 bit, in modo da fare ~ di 32.

180
00:15:53,090 --> 00:15:57,790
Va bene. Così siamo in grado di utilizzare tutti quei qui.

181
00:15:57,790 --> 00:16:03,000
Va bene, allora va bene se non si è fatto, si lentamente camminare sopra insieme,

182
00:16:03,000 --> 00:16:11,870
o camminare su questo, quindi - attraverso questo. Passeggiata attraverso questo.

183
00:16:11,870 --> 00:16:20,790
Così abbiamo la nostra stringa, e vogliamo un ciclo su ogni carattere all'interno della stringa e fare qualcosa per esso.

184
00:16:20,790 --> 00:16:26,710
Quindi, come facciamo un ciclo su una stringa? Che cosa dovremmo usare?

185
00:16:26,710 --> 00:16:30,980
Non ho intenzione di farlo qui. Gia '.

186
00:16:30,980 --> 00:16:42,940
Così ho il mio iteratore, e lo disse, ma come faccio a sapere quanti caratteri sono nella stringa?

187
00:16:42,940 --> 00:16:47,030
Strlen (s), allora i + +.

188
00:16:47,030 --> 00:16:49,860
Quindi quello che ho fatto qui non è il modo migliore di fare le cose.

189
00:16:49,860 --> 00:16:51,860
Qualcuno sa perché?

190
00:16:51,860 --> 00:16:55,290
Perché stai controllando la lingua della stringa ogni volta.

191
00:16:55,290 --> 00:17:06,859
Così stiamo andando a voler spostare strlen, potrei dire qui, int lunghezza = strlen (s),

192
00:17:06,859 --> 00:17:11,900
e poi faccio <lunghezza, e nel caso in cui non l'avete mai visto prima,

193
00:17:11,900 --> 00:17:20,410
Potrei anche fare int i = 0, lunghezza = strlen (s).

194
00:17:20,410 --> 00:17:25,010
E così questo è un po 'preferibile, dato che ora ho ristretto il campo di applicazione

195
00:17:25,010 --> 00:17:29,150
della lunghezza variabile a proprio questo ciclo 'for', invece di dichiararla prima

196
00:17:29,150 --> 00:17:34,990
e che esiste sempre, e nel caso in cui non ho capito perché questo è male,

197
00:17:34,990 --> 00:17:39,410
o perché l'originale era male, E'- iniziare dal ciclo for.

198
00:17:39,410 --> 00:17:43,380
Ho controllato la condizione. E 'I <la lunghezza di s?

199
00:17:43,380 --> 00:17:46,790
Quindi la lunghezza di s, cerchiamo di lavorare con "ciao" per tutto il tempo.

200
00:17:46,790 --> 00:17:49,670
Così lunghezza s, h-e-l-l-o. La lunghezza è 5.

201
00:17:49,670 --> 00:17:57,580
Quindi, i = 0, la lunghezza è di 5, quindi non è <5, in modo che il ciclo continua.

202
00:17:57,580 --> 00:18:02,750
Poi ci risiamo. Verifichiamo la condizione. È i <lunghezza del ciao?

203
00:18:02,750 --> 00:18:08,390
Quindi cerchiamo di verificare la lunghezza del ciao. H-e-l-l-o. Ecco 5; i non è <5, in modo da continuare ancora.

204
00:18:08,390 --> 00:18:13,330
Quindi stiamo calcolando, contiamo ciao, per ogni iterazione del ciclo,

205
00:18:13,330 --> 00:18:17,380
anche pensato che non cambierà, ma sta andando sempre essere 5.

206
00:18:17,380 --> 00:18:22,530
Quindi abbiamo ricordate 5 davanti, e ora tutto va meglio.

207
00:18:22,530 --> 00:18:24,990
Così scorrendo l'intera stringa.

208
00:18:24,990 --> 00:18:31,470
Che cosa vogliamo fare per ogni carattere della stringa?

209
00:18:31,470 --> 00:18:38,510
[Parlando Studente, incomprensibile]

210
00:18:38,510 --> 00:18:47,000
Gia '. Quindi, se il carattere non è alfabetico, allora vuole solo saltare su di esso.

211
00:18:47,000 --> 00:18:52,300
Perché ci preoccupiamo soltanto lettere alfabetiche, non possiamo capitalizzare un numero.

212
00:18:52,300 --> 00:19:10,850
Quindi, come possiamo fare questo? Quindi la nostra condizione, quindi se vogliamo qualcosa - controllare se è alfabetico.

213
00:19:10,850 --> 00:19:14,060
Quindi, come possiamo controllare questo?

214
00:19:14,060 --> 00:19:18,720
[Studente] Si può semplicemente utilizzare la funzione alfa.

215
00:19:18,720 --> 00:19:23,160
E 'incluso in uno di questi, o sono simili, char.h o qualcosa del genere?

216
00:19:23,160 --> 00:19:32,710
Cerchiamo di non utilizzare la funzione alfa è, e usare la esplicita - quindi abbiamo s [i],

217
00:19:32,710 --> 00:19:40,460
che è l'ottavo carattere di s, ricordate che una stringa è un array di caratteri,

218
00:19:40,460 --> 00:19:43,180
così l'ottavo carattere di s.

219
00:19:43,180 --> 00:19:49,280
Ora, se si tratta di una lettera maiuscola, sappiamo che deve essere in un intervallo specifico.

220
00:19:49,280 --> 00:19:54,370
E che cosa è che vanno?

221
00:19:54,370 --> 00:20:07,860
Gia '. Quindi, se s [i] è ≥ 65, e s [i] è ≤ 90, cosa devo fare, invece?

222
00:20:07,860 --> 00:20:18,470
Gia '. Così si dovrebbe assolutamente mai nemmeno bisogno di conoscere i valori ASCII di qualsiasi cosa mai.

223
00:20:18,470 --> 00:20:25,640
Non pensare ai numeri 65, 90, 97 e 102, o quello che è.

224
00:20:25,640 --> 00:20:32,470
Non avete bisogno di - 112 - non c'è bisogno di sapere chi a tutti. Questo è sbagliato troppo.

225
00:20:32,470 --> 00:20:41,940
Utilizzare solo le virgolette singole, costanti virgolette singole. Così 'A' e meno di 90 è 'Z'

226
00:20:41,940 --> 00:20:47,930
E questo è molto meglio - non saprei la parte superiore della mia testa che Z è 90.

227
00:20:47,930 --> 00:20:52,690
So la parte superiore della mia testa che 'Z' è il capitale Z.

228
00:20:52,690 --> 00:21:02,100
Quindi, fintanto che questo è nel range di capitale dalla A alla Z capitale, o siamo in grado di verificare la presenza di minuscole,

229
00:21:02,100 --> 00:21:17,010
Oppure, se è nel range ≥ 'a' e ≤ z.

230
00:21:17,010 --> 00:21:19,010
Ecco, questo è la nostra condizione.

231
00:21:19,010 --> 00:21:22,520
Lo stile su dove mettere queste cose varia.

232
00:21:22,520 --> 00:21:29,520
Lo farò in questo modo.

233
00:21:29,520 --> 00:21:31,520
Ora, che cosa vogliamo fare?

234
00:21:31,520 --> 00:21:39,530
Sappiamo che questa lettera è un carattere, un carattere alfabetico.

235
00:21:39,530 --> 00:21:46,270
Quindi abbiamo bisogno di alternare se questa dovrebbe essere una lettera maiuscola o una lettera minuscola.

236
00:21:46,270 --> 00:21:48,820
Come si fa a tenere traccia di quali quello che volete che sia?

237
00:21:48,820 --> 00:21:55,520
[Voci degli studenti, incomprensibili]

238
00:21:55,520 --> 00:21:59,150
Quindi sì, ma fammi controllare.

239
00:21:59,150 --> 00:22:04,910
Modulo 0-2 è stato detto, è stato un suggerimento buttato fuori, e sono d'accordo con questo.

240
00:22:04,910 --> 00:22:11,780
Salvo avviso che, come - è questo il caso? Gia '.

241
00:22:11,780 --> 00:22:18,270
Si tratta di tutti gli altri, ma non possiamo modulo 2 di i, oppure i mod 2, dal momento che

242
00:22:18,270 --> 00:22:22,950
E notare che è il capitale e 'a' è minuscolo? Ma c'è uno spazio che li separa?

243
00:22:22,950 --> 00:22:27,150
Così si sta andando ad essere mod stesso 2, ma sono casi diversi.

244
00:22:27,150 --> 00:22:29,150
[Domanda Studente, incomprensibile]

245
00:22:29,150 --> 00:22:34,690
Gia '. Quindi stiamo solo andando a tenere il conto.

246
00:22:34,690 --> 00:22:38,730
Potremmo anche farlo qui dentro, se volevamo, che potrebbe avere un po 'ingombrante

247
00:22:38,730 --> 00:22:41,300
nel ciclo per le dichiarazioni, mi metterò qui.

248
00:22:41,300 --> 00:22:48,840
Quindi, int count = inizia da 0.

249
00:22:48,840 --> 00:22:54,070
E così ora, ho intenzione di contare il numero di caratteri alfabetici che abbiamo avuto.

250
00:22:54,070 --> 00:22:59,550
Quindi stiamo andando inevitabilmente a contare + + da quando abbiamo trovato un altro carattere alfabetico.

251
00:22:59,550 --> 00:23:09,130
Ma, così ora stai dicendo che se mod numero 2.

252
00:23:09,130 --> 00:23:12,590
E se conta mod 2? Oh. Farò == 0 per ora.

253
00:23:12,590 --> 00:23:21,740
Ci recheremo anche su quella. Quindi, se mod conteggio 2 == 0, e poi?

254
00:23:21,740 --> 00:23:27,830
[Gli studenti risposta, incomprensibili]

255
00:23:27,830 --> 00:23:32,750
Quindi vogliamo che finire maiuscolo.

256
00:23:32,750 --> 00:23:37,520
Ci sono 2 casi, lettere maiuscole e minuscole sono i 2 casi.

257
00:23:37,520 --> 00:23:40,990
Quindi, se siamo in minuscolo abbiamo bisogno di rendere maiuscolo.

258
00:23:40,990 --> 00:23:43,710
Se è maiuscola non abbiamo bisogno di fare nulla.

259
00:23:43,710 --> 00:23:50,760
Ma, c'è un modo - shouldn't sono ribaltate -

260
00:23:50,760 --> 00:23:54,800
che non abbiamo nemmeno bisogno di controllare se è maiuscolo o minuscolo?

261
00:23:54,800 --> 00:24:02,240
Cosa possiamo fare per fare sempre in modo che si finisce sempre in maiuscolo?

262
00:24:02,240 --> 00:24:07,830
Quindi notare ciò che abbiamo fatto per minuscole 'a'; cosa succede se abbiamo fatto la stessa cosa esatta in maiuscolo A?

263
00:24:07,830 --> 00:24:11,900
Fa maiuscolo Un cambiamento, o cambia il valore?

264
00:24:11,900 --> 00:24:23,100
Gia '. Quindi, qualsiasi lettera maiuscola bit per bit AND con ~ 32 sarà quel carattere maiuscolo stesso

265
00:24:23,100 --> 00:24:29,220
perché per ogni carattere maiuscolo il 32-esimo bit non è impostato.

266
00:24:29,220 --> 00:24:40,920
Quindi, se vogliamo portare il carattere s [i], vogliamo che diventi minuscolo o maiuscolo.

267
00:24:40,920 --> 00:24:46,890
Quindi, se era minuscolo, ora è in maiuscolo, se era maiuscola, è ancora maiuscolo, e questo è tutto.

268
00:24:46,890 --> 00:24:54,290
Ho detto questo nel supersection: È possibile utilizzare 32 se vuoi, ma io tendo a preferire fare 'a' - A,

269
00:24:54,290 --> 00:25:01,150
anziché semplicemente 32, perché può essere qualsiasi altro bit.

270
00:25:01,150 --> 00:25:03,610
Dopo il bit 32, ma può essere qualsiasi di questi, o non sarebbe sufficiente

271
00:25:03,610 --> 00:25:05,840
numeri per rappresentare tutti i caratteri.

272
00:25:05,840 --> 00:25:09,110
Quindi, se si ottiene il 32 bit, potrebbe essere il 64 bit, potrebbe essere il bit 128.

273
00:25:09,110 --> 00:25:13,990
Una di queste potrebbe essere il bit bit che distingue tra maiuscole e minuscole.

274
00:25:13,990 --> 00:25:18,350
Non avrei bisogno di sapere che è il bit 32.

275
00:25:18,350 --> 00:25:27,130
Posso usare questo 'a' - A per ottenere il bit che differisce tra i due

276
00:25:27,130 --> 00:25:33,000
senza che sia necessario ricorrere al numero magico che è 32.

277
00:25:33,000 --> 00:25:38,770
E così ora, il resto conta era strano, e quindi che cosa voglio fare?

278
00:25:38,770 --> 00:25:43,920
[Le risposte degli studenti, incomprensibile]

279
00:25:43,920 --> 00:25:45,920
[Studente] Che cos'è?

280
00:25:45,920 --> 00:25:49,850
Lo farò in 1 secondo.

281
00:25:49,850 --> 00:25:55,690
Così ora se voglio - voglio essere sicuro che il personaggio è ormai minuscolo,

282
00:25:55,690 --> 00:26:04,140
e così posso O del 32, e 32 significa 'a' - A.

283
00:26:04,140 --> 00:26:06,510
Ma notate, dallo stesso ragionamento della precedente, che se

284
00:26:06,510 --> 00:26:11,670
la lettera era già minuscolo, poi OR del 32 mantiene semplicemente minuscolo.

285
00:26:11,670 --> 00:26:16,220
Non è cambiato il carattere.

286
00:26:16,220 --> 00:26:19,910
Ma ora non c'è bisogno di evitare di dire: "Se è minuscolo, basta non pensarci più,

287
00:26:19,910 --> 00:26:23,650
se è maiuscolo, quindi sostituirla. "

288
00:26:23,650 --> 00:26:26,900
E 'molto più conveniente per farlo.

289
00:26:26,900 --> 00:26:33,190
[Studente] Vorrei che la strategia della sottrazione del maiuscola dal lavoro in minuscolo, se non fosse 32?

290
00:26:33,190 --> 00:26:35,330
Se fosse, come, 34 o qualcosa del genere?

291
00:26:35,330 --> 00:26:41,840
Quindi, è necessario sapere che la differenza tra i 2 è -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Potrebbe essere più di 1 bit, finché tutti i bit sotto questa posizione sono uguali.

293
00:26:49,840 --> 00:26:58,500
Quindi abbiamo bisogno di almeno 26 caratteri - o, ci sono 26 caratteri.

294
00:26:58,500 --> 00:27:04,590
Quindi abbiamo bisogno di almeno 26 numeri per rappresentare la differenza -

295
00:27:04,590 --> 00:27:07,650
La differenza fra A e 'a' deve essere almeno 26,

296
00:27:07,650 --> 00:27:10,760
altrimenti non avrebbe rappresentato tutti i numeri di capitale.

297
00:27:10,760 --> 00:27:18,630
Ciò significa che A, se cominciamo a 1, sta andando a utilizzare tutti questi bit,

298
00:27:18,630 --> 00:27:23,900
tutti questi primi 5 bit, per rappresentare tutto attraverso Z.

299
00:27:23,900 --> 00:27:32,170
Ecco perché il bit successivo, o questo bit, il bit successivo è quello che ha scelto di distinguere tra A e 'a.'

300
00:27:32,170 --> 00:27:40,930
Questo è anche il motivo per cui, nella tabella ASCII, ci sono 5 simboli che separano le lettere maiuscole dalle lettere minuscole.

301
00:27:40,930 --> 00:27:49,050
Dal momento che questi sono i simboli, il supplemento 5 che porta in primo piano il 32 è la differenza tra loro.

302
00:27:49,050 --> 00:27:51,840
[Studente] Così abbiamo potuto farlo, perché ASCII è progettato in quel modo.

303
00:27:51,840 --> 00:27:57,280
Sì. Ma ASCII - la differenza potrebbe anche essere sia di questi bit.

304
00:27:57,280 --> 00:28:12,040
Come, se A fosse 10000001, e 'un' era 11100001 - non ricordo, a prescindere.

305
00:28:12,040 --> 00:28:18,100
Ma se si trattasse di questo, allora possiamo ancora utilizzare 'a' - A.

306
00:28:18,100 --> 00:28:22,650
E 'solo ora la differenza fra A e' a 'è ancora questi 2 bit.

307
00:28:22,650 --> 00:28:32,240
Credo che sia scritto 48. E '32 + 64? Penso che sia?

308
00:28:32,240 --> 00:28:40,160
Sarebbe ancora 2 bit; ogni singolo carattere, come, Z e z, K e K,

309
00:28:40,160 --> 00:28:45,160
avrebbero ancora gli stessi bit esatte ad eccezione di quelli di cui 2 bit.

310
00:28:45,160 --> 00:28:48,870
Quindi, fintanto che questo è sempre vero, a prescindere se si sta utilizzando ASCII o qualche altro sistema,

311
00:28:48,870 --> 00:28:53,050
finché c'è solo un determinato numero di bit che sono differenti per ciascun carattere,

312
00:28:53,050 --> 00:28:55,050
poi che funziona bene.

313
00:28:55,050 --> 00:29:06,110
E 'solo che il 32 è stato istituito perché è il primo che potevamo usare. >> Cool.

314
00:29:06,110 --> 00:29:14,520
Io tendo a preferire, nel caso in cui non avete visto, se il blocco è solo una singola riga,

315
00:29:14,520 --> 00:29:24,280
è possibile eliminare le parentesi graffe, così io tendo a preferire fare questo.

316
00:29:24,280 --> 00:29:34,010
Inoltre, come possiamo fare le cose come s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
È anche possibile fare s [i] = 32 AND bit per bit.

318
00:29:41,090 --> 00:29:46,400
E OR bit per bit = 32.

319
00:29:46,400 --> 00:29:51,490
Inoltre, conta mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Quindi ricorda che - non lo scrivere - qualsiasi valore diverso da zero è vero, e 0 è falso.

321
00:30:00,900 --> 00:30:07,880
Quindi, "se mod conteggio 2 == 0" è lo stesso che dire "se non contano mod 2."

322
00:30:07,880 --> 00:30:11,580
Probabilmente avrei solo invertito le linee e disse: "Se count mod 2,

323
00:30:11,580 --> 00:30:15,350
fare l'OR 1, cos'altro AND 1, "in modo che non ho bisogno del" no ".

324
00:30:15,350 --> 00:30:18,650
Ma questo funziona altrettanto bene.

325
00:30:18,650 --> 00:30:25,660
E che altro posso fare qui?

326
00:30:25,660 --> 00:30:29,060
Si potrebbe combinarsi con ternario se si voleva, ma poi che aveva appena le cose messier

327
00:30:29,060 --> 00:30:33,770
e probabilmente più difficile da leggere, in modo da non farlo.

328
00:30:33,770 --> 00:30:37,330
Qualcuno ha altri suggerimenti?

329
00:30:37,330 --> 00:30:41,580
E 'tutto il problema ha chiesto? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Così sbarazzarsi di queste linee vuote, ora ci occuperemo della stampa f,% s essere quella per le stringhe,

331
00:30:51,070 --> 00:30:56,620
Noi stampa f, s.

332
00:30:56,620 --> 00:30:59,330
Ora cerchiamo di farlo funzionare. Ho fatto qualcosa di sbagliato?

333
00:30:59,330 --> 00:31:03,200
Questo è un \ ", voglio un n.

334
00:31:03,200 --> 00:31:07,840
Va bene. Ora si che si avvii. E 'probabilmente urlare contro di me.

335
00:31:07,840 --> 00:31:11,250
Strlen è in string.h.

336
00:31:11,250 --> 00:31:14,290
Quindi questa è la cosa bella è Clang ci dice che cosa è in,

337
00:31:14,290 --> 00:31:19,140
invece di GCC che dice solo: "Ehi, hai dimenticato qualcosa, non so cosa fosse."

338
00:31:19,140 --> 00:31:29,220
Ma questo mi dirà: "Tu lo scopo di includere string.h."

339
00:31:29,220 --> 00:31:32,130
Così non richiede per niente, quindi non sta dicendo niente.

340
00:31:32,130 --> 00:31:42,540
Ma faremo il loro esempio, "Grazie 4 the add".

341
00:31:42,540 --> 00:31:47,880
Che guarda a destra. Evviva.

342
00:31:47,880 --> 00:31:52,370
Quindi, tornando alla tua principale, ho quasi mai farlo.

343
00:31:52,370 --> 00:31:57,110
E 'opzionale. E la funzione principale è solo per cui è facoltativo.

344
00:31:57,110 --> 00:32:07,140
Se non si restituisce nulla da principale, si presume che si vuole restituire 0.

345
00:32:07,140 --> 00:32:13,070
Domande?

346
00:32:13,070 --> 00:32:20,980
Va bene. Così ora il secondo problema.

347
00:32:20,980 --> 00:32:24,810
"Si ricordi dalla seconda lezione due settimane che lo scambio di valori 2 variabili" passando

348
00:32:24,810 --> 00:32:30,780
le 2 variabili a una funzione (anche se chiamato swap) non è esattamente funziona, almeno non senza 'puntatori' ".

349
00:32:30,780 --> 00:32:37,020
E ignorare puntatori fino ad arrivare a loro.

350
00:32:37,020 --> 00:32:40,070
Vogliamo scambiare 2 variabili, non stiamo utilizzando una funzione per farlo.

351
00:32:40,070 --> 00:32:43,410
Stiamo ancora intenzione di farlo in main come si dice.

352
00:32:43,410 --> 00:32:48,360
Ma per usare questi 2 variabili, che non si desidera utilizzare una variabile temporanea.

353
00:32:48,360 --> 00:32:50,770
Ci sono 2 modi per farlo.

354
00:32:50,770 --> 00:32:56,310
È possibile farlo utilizzando i tradizionali operatori binari.

355
00:32:56,310 --> 00:33:00,180
Quindi, qualcuno conosce un modo rapido e sporco di fare che?

356
00:33:00,180 --> 00:33:07,650
Si potrebbe effettivamente prendere un minuto di pensare. Se ho -

357
00:33:07,650 --> 00:33:12,130
Ti posto il problema su come chiedono. Quindi, se ho 2 variabili, A, che è solo un numero intero

358
00:33:12,130 --> 00:33:17,800
che mi danno, e la variabile B somma, che è un altro intero che ho dato.

359
00:33:17,800 --> 00:33:22,700
Quindi, se ho questi 2 variabili, ora voglio per scambiarle.

360
00:33:22,700 --> 00:33:31,550
Il tradizionale, utilizzando i normali operatori binari, voglio dire, come +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Non operatori bit a bit che agiscono sul binario.

362
00:33:36,630 --> 00:33:39,600
Quindi, utilizzando -, +, ÷, e tutti coloro che.

363
00:33:39,600 --> 00:33:52,980
Potremmo scambiare facendo qualcosa di simile a = a + b, e b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Quindi, verifica di integrità, e poi vedremo perché funziona.

365
00:34:04,260 --> 00:34:13,320
Diciamo che a = 7, b = 3, allora a + b sta per essere 10.

366
00:34:13,320 --> 00:34:18,820
Così ora stiamo impostando una = 10, e poi stiamo facendo b = a - b.

367
00:34:18,820 --> 00:34:30,250
Quindi stiamo facendo b = a - b, che sta per essere 7, e b = a - b nuovo,

368
00:34:30,250 --> 00:34:38,650
o = a - b. Che sta per essere di 10 - 7, che è 3.

369
00:34:38,650 --> 00:34:44,850
Così ora, giustamente, 'a' è stato di 7, b era di 3, ed ora è 7 e b 'a' è 3.

370
00:34:44,850 --> 00:34:48,679
Modo che tipo di senso, 'a' è la combinazione dei due numeri.

371
00:34:48,679 --> 00:34:53,000
A questo punto, 'a' è la combinazione, e poi stiamo sottraendo l'originale b,

372
00:34:53,000 --> 00:34:56,860
e poi stiamo sottraendo cosa era l'originale 'a.'

373
00:34:56,860 --> 00:35:01,150
Ma questo non funziona per tutti i numeri.

374
00:35:01,150 --> 00:35:08,880
Per vedere questo, consideriamo un sistema, così di solito si pensa di interi come 32 bit.

375
00:35:08,880 --> 00:35:13,050
Facciamo lavorare su qualcosa che è solo come 4 bit.

376
00:35:13,050 --> 00:35:15,450
Spero di trovare un buon esempio in questo momento.

377
00:35:15,450 --> 00:35:18,680
Così, lo so, questo sarà facile.

378
00:35:18,680 --> 00:35:26,720
Diciamo che i nostri 2 numeri sono 1111, e 1111, così siamo in binario in questo momento.

379
00:35:26,720 --> 00:35:34,630
In decimali reali, se si vuole pensare in questo modo, a = 15 e b = 15.

380
00:35:34,630 --> 00:35:37,630
E quindi ci aspettiamo, dopo che li abbiamo scambiare - non hanno nemmeno bisogno di essere gli stessi numeri,

381
00:35:37,630 --> 00:35:41,140
ma l'ho fatto in questo modo.

382
00:35:41,140 --> 00:35:47,100
Facciamo in modo che non li stessi numeri. Facciamo 1111 e 0001.

383
00:35:47,100 --> 00:35:51,860
Quindi a = 15 e b = 1.

384
00:35:51,860 --> 00:35:57,670
Dopo li scambiare, ci aspettiamo 'a' a 1 e b di essere 15.

385
00:35:57,670 --> 00:36:01,780
Così il nostro primo passo è a = a + b.

386
00:36:01,780 --> 00:36:08,770
I nostri numeri sono solo 4 bit, in modo da 'a', che è 1111, + b, che è 0001,

387
00:36:08,770 --> 00:36:16,780
sta per finire per essere 10000, ma abbiamo solo 4 bit.

388
00:36:16,780 --> 00:36:22,540
Così ora a = 0.

389
00:36:22,540 --> 00:36:34,080
E ora vogliamo impostare b = a - b - in realtà, questo funziona ancora alla perfezione.

390
00:36:34,080 --> 00:36:39,630
a = a - b - vediamo se questo funziona alla perfezione.

391
00:36:39,630 --> 00:36:53,720
Allora b = 0 - 1, che sarebbe ancora 15, e quindi a = a - b, che sarebbe 1.

392
00:36:53,720 --> 00:36:56,210
Forse questo funziona.

393
00:36:56,210 --> 00:36:59,020
Mi sento come se ci fosse un motivo per non funziona con normale.

394
00:36:59,020 --> 00:37:06,400
Ok, quindi sul presupposto che non funziona con operazioni binarie regolari,

395
00:37:06,400 --> 00:37:15,040
e io lo guarderò per - io Google per vedere se questo è vero.

396
00:37:15,040 --> 00:37:23,490
Quindi vogliamo farlo utilizzando operatori bit a bit, e l'indizio qui è XOR.

397
00:37:23,490 --> 00:37:28,780
Quindi, l'introduzione di XOR (^) se non l'avete ancora visto.

398
00:37:28,780 --> 00:37:34,610
E ', ancora una volta, un operatore bit per bit in modo che agisce poco a poco, e E'-

399
00:37:34,610 --> 00:37:39,910
Se hai i bit 0 e 1, allora questo sarà 1.

400
00:37:39,910 --> 00:37:45,230
Se hai i bit 1 e 0, sarà 1, si ha i bit 0 e 0 sarà 0,

401
00:37:45,230 --> 00:37:47,640
e se si hanno i bit 1 e 1 sarà 0.

402
00:37:47,640 --> 00:37:56,180
Così è come OR. Se uno dei bit sono vere, è 1, ma a differenza di O, non possono essere entrambi i bit che sono vere.

403
00:37:56,180 --> 00:37:59,320
O sarebbe questo essere di 1, XOR avrebbe questo a 0.

404
00:37:59,320 --> 00:38:02,250
Quindi stiamo andando a voler utilizzare XOR qui.

405
00:38:02,250 --> 00:38:09,960
Pensateci per un minuto, ho intenzione di Google.

406
00:38:09,960 --> 00:38:16,230
Beh, non si può leggere che, io sono attualmente sulla pagina algoritmo XOR swap.

407
00:38:16,230 --> 00:38:21,340
Speriamo che questo spiega perché Io non posso -

408
00:38:21,340 --> 00:38:34,190
Questo è esattamente l'algoritmo che abbiamo appena fatto.

409
00:38:34,190 --> 00:38:37,330
Non riesco ancora a capire perché - devo aver appena preso un cattivo esempio,

410
00:38:37,330 --> 00:38:44,940
ma questo caso, dove 'a' è successo a divenire 0, dopo aver ottenuto a 5 bit, così ora 'a' è pari a 0,

411
00:38:44,940 --> 00:38:48,730
questo è ciò che si chiama "integer overflow".

412
00:38:48,730 --> 00:38:54,370
Secondo Wikipedia, "A differenza dello swap XOR, questa variante è necessario che esso utilizza alcuni metodi

413
00:38:54,370 --> 00:38:59,780
garantire che x + y non causa un overflow ".

414
00:38:59,780 --> 00:39:08,350
Quindi questo ha problemi, questo era integer overflow, ma ho fatto qualcosa di sbagliato.

415
00:39:08,350 --> 00:39:10,520
Non ne sono sicuro. Cercherò di venire con un altro.

416
00:39:10,520 --> 00:39:13,640
[Studente] Beh, non è integer overflow quando si sta cercando di mettere un numero in là

417
00:39:13,640 --> 00:39:16,640
più grande la quantità di bit che hai assegnato?

418
00:39:16,640 --> 00:39:23,730
Gia '. Abbiamo 4 bit. That's - avevamo 4 bit, che quindi si tenta di aggiungere 1 ad esso, così si finisce con 5 bit.

419
00:39:23,730 --> 00:39:26,690
Ma il quinto bit appena viene tagliato fuori, si '.

420
00:39:26,690 --> 00:39:28,970
Si potrebbe in realtà -

421
00:39:28,970 --> 00:39:33,010
[Studente] Questo ti genera un errore, o lo fa - vorrei che genera un errore?

422
00:39:33,010 --> 00:39:40,720
No. Quindi non c'è alcun errore. Quando si arriva al livello di assieme, un po 'speciale

423
00:39:40,720 --> 00:39:47,020
da qualche parte si trova che ha detto che c'era un overflow, ma in C è di tipo semplicemente non fare con questo.

424
00:39:47,020 --> 00:39:55,160
In realtà non si può fare con esso a meno di usare le istruzioni di montaggio speciali in C.

425
00:39:55,160 --> 00:39:58,110
Pensiamo di swap XOR.

426
00:39:58,110 --> 00:40:02,220
E credo che l'articolo di Wikipedia potrebbe essere anche stato detto che -

427
00:40:02,220 --> 00:40:07,310
Così anche portato aritmetica modulare, quindi credo che era, in teoria, fare aritmetica modulare

428
00:40:07,310 --> 00:40:11,160
quando ho detto che 0-1 è il 15 di nuovo.

429
00:40:11,160 --> 00:40:15,410
In modo che potrebbe in realtà - su un processore regolare che fa 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Dal momento che si finisce a 0, sottraiamo 1, così poi si avvolge appena tornato intorno al 1111.

431
00:40:20,430 --> 00:40:28,930
Quindi questo algoritmo potrebbe effettivamente funzionare, l'a + b, l'a - b, b - a, che potrebbe andare bene.

432
00:40:28,930 --> 00:40:34,030
Ma ci sono alcuni processori che non farlo, e quindi non sarebbe bene in quelli specifici.

433
00:40:34,030 --> 00:40:39,880
Di swap XOR funziona su qualsiasi processore. Va bene.

434
00:40:39,880 --> 00:40:42,280
L'idea è che si suppone essere la stessa, però.

435
00:40:42,280 --> 00:40:50,120
Dove stiamo usando XOR per ottenere in qualche modo l'informazione, sia in 1 delle variabili,

436
00:40:50,120 --> 00:40:54,120
e quindi estrarre le informazioni delle singole variabili di nuovo.

437
00:40:54,120 --> 00:41:04,330
Così qualcuno ha idee / la risposta?

438
00:41:04,330 --> 00:41:14,540
[Risposta studente, incomprensibile]

439
00:41:14,540 --> 00:41:22,220
Quindi questo dovrebbe funzionare, e anche, XOR è commutativo.

440
00:41:22,220 --> 00:41:27,620
Indipendentemente da quale ordine questi 2 numeri capita di essere qui,

441
00:41:27,620 --> 00:41:30,100
questo risultato sarà lo stesso.

442
00:41:30,100 --> 00:41:35,800
Quindi, a ^ b è b ^ a.

443
00:41:35,800 --> 00:41:51,860
Si potrebbe anche vedere questo scritto come a ^ = b, b ^ = a, a ^ = b di nuovo.

444
00:41:51,860 --> 00:42:00,200
Quindi questo è giusto, e capire perché questo funziona, pensate dei bit.

445
00:42:00,200 --> 00:42:10,400
Utilizzando un numero piuttosto piccolo, diciamo 11001, e 01100.

446
00:42:10,400 --> 00:42:12,790
Quindi questo è 'a', questo è b.

447
00:42:12,790 --> 00:42:15,540
Quindi, a ^ = b.

448
00:42:15,540 --> 00:42:22,380
Stiamo per essere l'impostazione 'a' = a XOR di queste 2 cose.

449
00:42:22,380 --> 00:42:32,920
Così 1 ^ 0 è 1; 1 ^ 1 è 0; 0 ^ 1 è 1, e 0 ^ 0 è 0, 1 ^ 0 è 1.

450
00:42:32,920 --> 00:42:37,380
So 'un,' se si guarda al numero decimale, che sta per essere -

451
00:42:37,380 --> 00:42:41,160
non si sta andando a vedere molto di una relazione tra l'originale 'a' e il nuovo 'a,'

452
00:42:41,160 --> 00:42:45,600
ma guardando i bit, 'a' è ora come una rete di informazioni

453
00:42:45,600 --> 00:42:49,970
sia l'originale 'a' e il b originale.

454
00:42:49,970 --> 00:42:57,930
Quindi, se prendiamo b ^ a, vediamo che finiremo in originale 'a.'

455
00:42:57,930 --> 00:43:08,910
E se prendiamo l'originale 'a' ^ il nuovo 'a,' vediamo finiamo in b originale.

456
00:43:08,910 --> 00:43:18,380
Quindi (a ^ b) ^ b = l'originale 'a.'

457
00:43:18,380 --> 00:43:27,910
E (a ^ b) ^ a = b l'originale.

458
00:43:27,910 --> 00:43:37,010
Vi è - un altro modo di vedere questo è XOR nulla per sé è sempre 0.

459
00:43:37,010 --> 00:43:45,020
Quindi 1101 ^ 1101, tutti i bit saranno uguali.

460
00:43:45,020 --> 00:43:47,920
Quindi c'è mai sarà un caso in cui 1 è uno 0 e l'altro è 1.

461
00:43:47,920 --> 00:43:51,080
Quindi questo è 0000.

462
00:43:51,080 --> 00:43:57,240
Lo stesso con questo. (A ^ b) ^ b è come a ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) sta per essere 0, a ^ 0 è solo andare a essere 'una,' dal momento che tutti i bit sono 0.

464
00:44:03,680 --> 00:44:08,050
Quindi gli unici che stanno per essere dove 'a' era in origine un 1 - aveva quelle.

465
00:44:08,050 --> 00:44:12,070
E la stessa idea: ecco, io sono abbastanza sicuro che sia anche commutativa.

466
00:44:12,070 --> 00:44:17,590
Gia '. Ho detto prima che era commutativa.

467
00:44:17,590 --> 00:44:24,680
Il ^ 'a,' ed è associativa, così ora (b ^ a) ^ a.

468
00:44:24,680 --> 00:44:28,970
E possiamo farlo b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
E così ancora una volta, si ottiene il b originale.

470
00:44:31,540 --> 00:44:37,120
Quindi 'a' è ora la combinazione di 'A' e B insieme.

471
00:44:37,120 --> 00:44:49,660
Utilizzando il nostro nuovo combo 'a' diciamo b = combo 'a' ^ il b originale, si ottiene l'originale 'a.'

472
00:44:49,660 --> 00:45:05,170
E ora un combo = 'a' ^ la nuova b, che era l'originale - e che ora è quello che era 'a' o b.

473
00:45:05,170 --> 00:45:13,620
Questo è il caso qui. Questo è = b, b vecchio.

474
00:45:13,620 --> 00:45:16,550
Così ora tutto è tornato in ordine scambiati.

475
00:45:16,550 --> 00:45:22,960
Se effettivamente guardato i bit, b = a ^ b, sta per XOR questi 2,

476
00:45:22,960 --> 00:45:33,920
e la risposta sarà questa, e poi a = a ^ b è XOR questi 2 e la risposta è questa.

477
00:45:33,920 --> 00:45:41,090
Domande? Va bene. Così l'ultimo è alquanto significativamente più difficile.

478
00:45:41,090 --> 00:45:43,180
[Studente] Credo che abbia una domanda su di esso. >> Oh, mi dispiace.

479
00:45:43,180 --> 00:45:49,380
[Studente] Che in realtà è più veloce? Se si utilizza questo XOR, o è, se si dichiara una nuova variabile?

480
00:45:49,380 --> 00:45:55,190
Allora, qual è il più veloce, che dichiara una nuova variabile o utilizzando XOR per scambiare?

481
00:45:55,190 --> 00:45:59,600
La risposta è, con ogni probabilità, una variabile temporanea.

482
00:45:59,600 --> 00:46:05,780
E questo è perché una volta che è compilato fino - in modo a livello di assembly,

483
00:46:05,780 --> 00:46:12,320
non c'è una cosa come le variabili locali o altre variabili temporanee o qualsiasi di queste cose.

484
00:46:12,320 --> 00:46:16,060
Sono come - c'è la memoria, e ci sono registri.

485
00:46:16,060 --> 00:46:20,920
I registri sono dove le cose sono attivamente accadendo.

486
00:46:20,920 --> 00:46:24,750
Non aggiungere 2 cose a memoria, si aggiungono 2 cose nei registri.

487
00:46:24,750 --> 00:46:28,160
E si mettono le cose dalla memoria nei registri per poi aggiungere,

488
00:46:28,160 --> 00:46:33,180
e allora si potrebbe metterli di nuovo in memoria, ma tutta l'azione avviene in registri.

489
00:46:33,180 --> 00:46:38,750
Così, quando si sta utilizzando il metodo variabile temporanea, di solito quello che succede è

490
00:46:38,750 --> 00:46:42,810
questi 2 numeri sono già in registri.

491
00:46:42,810 --> 00:46:46,570
E poi da quel momento in poi, dopo averli scambiati,

492
00:46:46,570 --> 00:46:51,540
ti basta iniziare a utilizzare il registro altro.

493
00:46:51,540 --> 00:46:56,510
Ovunque tu fossi stato con b, sarà sufficiente utilizzare il registro che già l'archiviazione 'a.'

494
00:46:56,510 --> 00:47:02,180
Quindi non ha bisogno di fare niente a che fare effettivamente la swap. Si '?

495
00:47:02,180 --> 00:47:05,690
[Studente] Ma ci vuole anche più memoria, giusto?

496
00:47:05,690 --> 00:47:10,280
Ci vorrà solo più memoria se è necessario per memorizzare la variabile temporanea.

497
00:47:10,280 --> 00:47:14,830
Come se in seguito utilizzare tale variabile temporanea di nuovo da qualche parte,

498
00:47:14,830 --> 00:47:18,920
allora - o si assegna qualcosa a quella variabile temporanea.

499
00:47:18,920 --> 00:47:24,630
Quindi, se in qualsiasi punto nel tempo 'a,' b in temperatura hanno valori distinti o qualcosa del genere,

500
00:47:24,630 --> 00:47:30,680
poi sta andando ad avere posizioni distinte nella memoria, ma è vero che

501
00:47:30,680 --> 00:47:34,800
ci sono molte variabili locali che esistono solo nei registri.

502
00:47:34,800 --> 00:47:44,370
In questo caso, non è mai messa in memoria, e così non si è mai spreco di memoria.

503
00:47:44,370 --> 00:47:58,620
Va bene. L'ultima domanda è un po 'di più.

504
00:47:58,620 --> 00:48:04,850
Ecco, in questo apparecchio CS50, c'è un dizionario.

505
00:48:04,850 --> 00:48:12,390
E la ragione di questo è perché [?? B66] è un correttore ortografico in cui sarete scrittura

506
00:48:12,390 --> 00:48:15,780
utilizzo di tabelle hash o cerca o qualche struttura dei dati.

507
00:48:15,780 --> 00:48:22,660
Hai intenzione di scrivere un correttore ortografico, e avete intenzione di utilizzare questo dizionario per farlo.

508
00:48:22,660 --> 00:48:28,280
Ma per questo problema, stiamo solo andando a guardare per vedere se una parola nel dizionario.

509
00:48:28,280 --> 00:48:31,250
Così, invece di memorizzare l'intero dizionario in qualche struttura dati

510
00:48:31,250 --> 00:48:35,180
e poi guardando su un intero documento per vedere se qualcosa è errato,

511
00:48:35,180 --> 00:48:38,490
vogliamo solo trovare 1 parola. Quindi possiamo solo eseguire la scansione su l'intero dizionario

512
00:48:38,490 --> 00:48:44,300
e se non si trova la parola nel dizionario intero, allora non era lì.

513
00:48:44,300 --> 00:48:52,150
Se eseguire la scansione su l'intero dizionario e si vede la parola, allora siamo a posto, abbiamo trovato.

514
00:48:52,150 --> 00:48:56,580
Qui si dice che vogliamo iniziare a guardare di C file di funzione di gestione,

515
00:48:56,580 --> 00:48:59,930
dal momento che vuole leggere il dizionario,

516
00:48:59,930 --> 00:49:07,680
ma darò il suggerimento qui per quali funzioni si dovrebbe pensare.

517
00:49:07,680 --> 00:49:11,510
Io li scriverai sugli spazi.

518
00:49:11,510 --> 00:49:20,490
Quindi i principali ti consigliamo di guardare sono f aperta e poi, inevitabilmente, f chiuso,

519
00:49:20,490 --> 00:49:26,540
che andrà alla fine del programma, e f f scansione.

520
00:49:26,540 --> 00:49:31,060
Si potrebbe anche usare f leggere, ma probabilmente non si vuole

521
00:49:31,060 --> 00:49:34,200
perché - non si finisce per dover tale.

522
00:49:34,200 --> 00:49:41,880
F scansione f è quello che si sta andando ad essere utilizzata per la scansione sul dizionario.

523
00:49:41,880 --> 00:49:46,370
E così non c'è bisogno di codificare la soluzione, basta provare e come pseudo-codice la tua strada

524
00:49:46,370 --> 00:50:05,200
ad una soluzione, e poi ne discuteremo.

525
00:50:05,200 --> 00:50:14,110
E in realtà, dal momento che già ti ha dato questi, se si va in un qualsiasi terminale o shell del vostro apparecchio,

526
00:50:14,110 --> 00:50:18,250
Vorrei - di solito - se non l'avete ancora visto, non so se l'avete fatto in classe,

527
00:50:18,250 --> 00:50:23,490
ma l'uomo, in modo che le pagine man, sono piuttosto utili per guardare praticamente qualsiasi funzione.

528
00:50:23,490 --> 00:50:27,330
Così posso fare, come, f uomo, scansione f.

529
00:50:27,330 --> 00:50:32,300
Questo è ora le informazioni sulla famiglia di funzioni f scansione.

530
00:50:32,300 --> 00:50:37,070
Potrei anche fare f uomo, aperti, e che mi darà i dettagli di quella.

531
00:50:37,070 --> 00:50:40,750
Quindi, se si sa cosa si sta utilizzando la funzione, o stai leggendo il codice

532
00:50:40,750 --> 00:50:43,000
e si vede un po 'di funzione e siete come, "Cosa fare?"

533
00:50:43,000 --> 00:50:45,280
Solo l'uomo che la funzione nome.

534
00:50:45,280 --> 00:50:47,340
Ci sono un paio di esempi bizzarri in cui si potrebbe dire

535
00:50:47,340 --> 00:50:51,620
piace. man 2 che nome della funzione, o uomo 3 che nome della funzione,

536
00:50:51,620 --> 00:50:58,230
ma hai solo da fare che l'uomo se il nome di funzione non è capitato di lavorare per la prima volta.

537
00:50:58,230 --> 00:51:03,010
[Studente] Così sto leggendo la pagina di manuale di aperto, ma io sono ancora confuso su come usarlo e il programma.

538
00:51:03,010 --> 00:51:06,170
Va bene. Un sacco di pagine di manuale sono meno disponibile.

539
00:51:06,170 --> 00:51:08,470
Sono più utili se già sanno quello che fanno

540
00:51:08,470 --> 00:51:12,670
e poi basta ricordare l'ordine degli argomenti o qualcosa del genere.

541
00:51:12,670 --> 00:51:17,640
Oppure possono darvi una panoramica generale, ma alcuni di loro sono molto travolgente.

542
00:51:17,640 --> 00:51:22,220
Come f f scansione, anche. Ti dà le informazioni per tutte queste funzioni,

543
00:51:22,220 --> 00:51:28,120
e 1 riga giù succede qui per dire, "F scansione f legge dal punto di stringa o un flusso."

544
00:51:28,120 --> 00:51:32,360
Ma f aprire. Quindi, come si usa f aperto?

545
00:51:32,360 --> 00:51:38,470
L'idea di un programma che ha bisogno di fare file di I / O che

546
00:51:38,470 --> 00:51:45,070
è necessario prima di aprire il file che si desidera fare le cose con, e, inevitabilmente,

547
00:51:45,070 --> 00:51:51,220
leggere le cose da quel file e fare cose con loro.

548
00:51:51,220 --> 00:51:55,350
F aperto è quello che usiamo per aprire il file.

549
00:51:55,350 --> 00:52:04,190
La cosa torniamo, quindi quale file vogliamo aprire, ci dà la -

550
00:52:04,190 --> 00:52:11,970
qui si dice "/ user / share / dict / words."

551
00:52:11,970 --> 00:52:16,740
Questo è il file che si desidera aprire, e vogliamo aprire -

552
00:52:16,740 --> 00:52:21,440
dobbiamo specificare esplicitamente se vogliamo aprirlo per leggere o se vogliamo aprirlo per scrivere.

553
00:52:21,440 --> 00:52:26,490
Ci sono un paio di combinazioni e roba del genere, ma vogliamo aprire questo per la lettura.

554
00:52:26,490 --> 00:52:29,380
Vogliamo leggere dal file.

555
00:52:29,380 --> 00:52:34,290
Che cosa significa questo ritorno? Esso restituisce un file di stelle (*),

556
00:52:34,290 --> 00:52:37,260
e mi limiterò a mostrare tutto nella variabile f, così *,

557
00:52:37,260 --> 00:52:40,840
ancora una volta, si tratta di un puntatore, ma non vogliono trattare con i puntatori.

558
00:52:40,840 --> 00:52:46,470
Si può pensare di f come, f è la variabile che si vuole utilizzare per rappresentare il file.

559
00:52:46,470 --> 00:52:49,850
Quindi, se si desidera leggere dal file, si legge da f.

560
00:52:49,850 --> 00:52:54,820
Se si desidera chiudere il file, si chiude f.

561
00:52:54,820 --> 00:53:00,350
Così, alla fine del programma quando inevitabilmente vuole chiudere il file, cosa dobbiamo fare?

562
00:53:00,350 --> 00:53:06,750
Vogliamo chiudere f.

563
00:53:06,750 --> 00:53:12,600
Così ora la funzione di ultimo file che stiamo andando a voler utilizzare è la scansione f, f f scansione.

564
00:53:12,600 --> 00:53:20,930
E che cosa è che fa la scansione sul file alla ricerca di un modello da abbinare.

565
00:53:20,930 --> 00:53:39,100
Guardando la pagina man di qui, vediamo int f f scansione, ignorare il valore restituito per il momento.

566
00:53:39,100 --> 00:53:45,230
Il primo argomento è il flusso di file *, in modo che il primo argomento che stiamo andando a voler passare è f.

567
00:53:45,230 --> 00:53:47,900
Stiamo scansione su f.

568
00:53:47,900 --> 00:53:53,680
Il secondo argomento è una stringa di formato.

569
00:53:53,680 --> 00:53:58,310
Vi darò una stringa di formato in questo momento.

570
00:53:58,310 --> 00:54:05,180
Penso che ci capita di dire, 127S \ n, un sacco di che è inutile.

571
00:54:05,180 --> 00:54:12,490
L'idea di ciò che è stringa di formato, è che si può pensare di f scansione come l'opposto di f stampa.

572
00:54:12,490 --> 00:54:17,160
Quindi f stampa, stampa f usiamo anche questo tipo di parametro format,

573
00:54:17,160 --> 00:54:25,000
ma in f stampa quello che stiamo facendo è - diamo un'occhiata a un equivalente.

574
00:54:25,000 --> 00:54:32,550
Quindi stampare f, e c'è in realtà anche f f stampa, in cui il primo argomento sarà f.

575
00:54:32,550 --> 00:54:40,980
Quando si stampa f, si potrebbe dire qualcosa come: "127S stampa \ n" e poi se la passa un po 'di spago,

576
00:54:40,980 --> 00:54:44,050
sta andando a stampare questa stringa e poi una nuova linea.

577
00:54:44,050 --> 00:54:49,690
Che cosa significa 127, sono abbastanza sicuro, ma non ho mai sono limitato ad esso,

578
00:54:49,690 --> 00:54:52,470
Non sarebbe nemmeno bisogno di dire '127 'nel f stampa,

579
00:54:52,470 --> 00:54:57,090
ma cosa vuol dire è stampare i primi 127 caratteri.

580
00:54:57,090 --> 00:54:59,350
Quindi sono abbastanza sicuro che è il caso. Potete Google per questo.

581
00:54:59,350 --> 00:55:03,000
Ma nel prossimo Sono quasi positivo significa che.

582
00:55:03,000 --> 00:55:08,880
Quindi questo è stampare i primi 127 caratteri, seguito da una nuova riga.

583
00:55:08,880 --> 00:55:14,680
F scansione f ora, invece di guardare una variabile e la stampa,

584
00:55:14,680 --> 00:55:22,620
sta andando a guardare un po 'di spago, e memorizzare il pattern nella variabile.

585
00:55:22,620 --> 00:55:26,360
Facciamo effettivamente utilizzare f scansione in un esempio diverso.

586
00:55:26,360 --> 00:55:31,670
Quindi diciamo che abbiamo avuto un po 'di int, x = 4,

587
00:55:31,670 --> 00:55:41,110
e abbiamo deciso di creare una stringa in - ha voluto creare la stringa

588
00:55:41,110 --> 00:55:44,250
che era come, ciò avverrà molto più tardi,

589
00:55:44,250 --> 00:55:49,020
qualcosa che è proprio come 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Quindi questo potrebbe essere un programma in cui si avrà contatore somma,

591
00:55:51,870 --> 00:55:56,420
Riassumendo contrastare i, e si desidera salvare un gruppo di immagini.

592
00:55:56,420 --> 00:56:02,430
Così si vuole salvare i.jpg, dove i è un po 'iterazione del ciclo.

593
00:56:02,430 --> 00:56:05,500
Quindi, come possiamo rendere questa stringa per quella JPEG?

594
00:56:05,500 --> 00:56:11,720
Se si voleva stampare 4.jpg, potremmo semplicemente dire f stampa, d.jpg%,

595
00:56:11,720 --> 00:56:14,410
e allora sarebbe stampare per che JPEG.

596
00:56:14,410 --> 00:56:20,050
Ma se vogliamo salvare il 4.jpg stringa, usiamo f scansione.

597
00:56:20,050 --> 00:56:30,860
Quindi la stringa s - in realtà abbiamo Can '- carattere, char s, andiamo 100.

598
00:56:30,860 --> 00:56:35,400
Così ho dichiarato alcuni array di 100 caratteri,

599
00:56:35,400 --> 00:56:39,830
e questo è quello che stiamo inevitabilmente sarà la memorizzazione JPEG che trovi

600
00:56:39,830 --> 00:56:47,920
Così abbiamo intenzione di utilizzare f scansione e il formato, come si direbbe d.jpg%

601
00:56:47,920 --> 00:56:54,980
per stampare 4.jpg, il formato di questo sta per essere d.jpg%.

602
00:56:54,980 --> 00:57:04,020
Quindi il formato è d.jpg%, ciò che vogliamo sostituire d con% è x,

603
00:57:04,020 --> 00:57:06,590
e ora abbiamo bisogno di memorizzare la stringa da qualche parte.

604
00:57:06,590 --> 00:57:12,500
E dove andremo a memorizzare la stringa è in s la matrice.

605
00:57:12,500 --> 00:57:21,640
Così, dopo questa riga di codice, s, se stampiamo f, s% della variabile s,

606
00:57:21,640 --> 00:57:26,280
sta andando a stampare 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Quindi f f scansione è la stessa scansione f, solo che adesso sta guardando oltre questo file

608
00:57:38,930 --> 00:57:43,600
per quello di memorizzare in s.

609
00:57:43,600 --> 00:57:46,160
Questo è ciò che l'ultimo argomento sarà.

610
00:57:46,160 --> 00:57:54,170
Vogliamo archiviare - "famiglia f scansione delle scansioni delle funzioni sia in base al formato, come ha cercato di seguito.

611
00:57:54,170 --> 00:58:02,450
Se sono memorizzati nei punti di locazione che potrebbe restituire - "

612
00:58:02,450 --> 00:58:12,910
No, potrebbe essere buono. Fammi pensare per un secondo.

613
00:58:12,910 --> 00:58:26,350
Quindi scansione f non - cosa diavolo è la funzione che fa questo?

614
00:58:26,350 --> 00:58:31,650
Quindi scansione f non sta andando a prendere un numero intero e fare punti jpg.

615
00:58:31,650 --> 00:58:43,490
E 'intenzione di [borbotta].

616
00:58:43,490 --> 00:58:49,360
Salva variabile int in stringa int C.

617
00:58:49,360 --> 00:58:55,940
Che cosa è questa variabile, o che cosa è questa funzione si chiama?

618
00:58:55,940 --> 00:59:04,950
Sì. That's - sì. Quindi quello che è stato la definizione di a te prima era s f stampa,

619
00:59:04,950 --> 00:59:09,820
che - che rende molto più senso, perché ho detto che era molto più simile f stampa.

620
00:59:09,820 --> 00:59:14,700
Scan f è ancora un po 'come f stampa, ma f stampa s sta per eseguire la scansione sopra

621
00:59:14,700 --> 00:59:17,510
e sostituire le variabili e ora memorizzare in una stringa.

622
00:59:17,510 --> 00:59:19,620
Invece di stamparlo, lo memorizza in una stringa.

623
00:59:19,620 --> 00:59:25,070
Così ignorarlo del tutto. È ancora possibile pensare a come l'identificatore di formato simile a quello di f stampa.

624
00:59:25,070 --> 00:59:34,510
Così ora, se volessimo fare la cosa 4.jpg, faremmo stampa f s, x di questo.

625
00:59:34,510 --> 00:59:38,520
Così che cosa sta facendo la scansione f - ciò che è stato la tua domanda sarebbe?

626
00:59:38,520 --> 00:59:40,820
[Studente] Sono solo confuso su quello che stiamo cercando di fare qui

627
00:59:40,820 --> 00:59:43,450
con tale JPEG. Può spiegare che il tempo altri 1?

628
00:59:43,450 --> 00:59:52,710
Quindi questo è stato - è meno relevent di scansione f f ora, si spera, sarà legare indietro in qualche modo.

629
00:59:52,710 --> 01:00:02,240
Ma quello che inizialmente aveva intenzione di mostrare era - questo è in realtà direttamente rilevante per questi [?? F5]

630
01:00:02,240 --> 01:00:08,520
Si sta andando ad utilizzare f stampa s, dove, dire che abbiamo 100 immagini,

631
01:00:08,520 --> 01:00:13,630
e si desidera leggere immagine 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Quindi, per fare questo, è necessario f aperto, e poi si deve passare la stringa che si desidera aprire.

633
01:00:21,520 --> 01:00:30,020
Quindi, vorremmo aprire 1.jpg, al fine di creare la stringa che è 1.jpg,

634
01:00:30,020 --> 01:00:37,660
facciamo s f stampa di% d.jpg--non abbiamo fatto per int i = 0.

635
01:00:37,660 --> 01:00:46,580
i <40, i + +.

636
01:00:46,580 --> 01:00:51,130
Quindi stampa% s f d.jpg di i.

637
01:00:51,130 --> 01:00:56,320
Così, dopo questa linea, ora la variabile o l'array s sta per 1.jpg.

638
01:00:56,320 --> 01:01:10,610
In alternativa, 0.jpg, 1.jpg, 2.jpg. E così siamo in grado di aprire, a sua volta, ogni immagine per la lettura.

639
01:01:10,610 --> 01:01:19,550
Quindi, questo è ciò che s stampare f fa. Vedete quello che s stampare f sta facendo?

640
01:01:19,550 --> 01:01:25,720
[Studente] Ok, quindi è tenuto - si crea una stringa, something.jpg, e quindi lo memorizza.

641
01:01:25,720 --> 01:01:30,360
Sì. Si crea - questa è un'altra stringa di formato, proprio come f f scansione e di stampa,

642
01:01:30,360 --> 01:01:37,530
in cui inserisce tutte le variabili nel secondo argomento, potrebbe essere s in contrasto con i.

643
01:01:37,530 --> 01:01:42,280
Forse - Voglio dire, questo è il caso. Ma qualunque sia l'ordine degli argomenti è.

644
01:01:42,280 --> 01:01:45,440
E 'intenzione di inserire tutte le variabili nella stringa di formato

645
01:01:45,440 --> 01:01:52,250
e quindi memorizzare nel nostro buffer; lo chiamiamo un buffer, e 'dove stiamo memorizzare la stringa.

646
01:01:52,250 --> 01:02:00,750
Così abbiamo memorizzato all'interno di s della stringa formattato correttamente, d% e sono state sostituite con 4.

647
01:02:00,750 --> 01:02:08,080
[Studente] Quindi, se abbiamo fatto questo, è la variabile f solo andando a essere riassegnati?

648
01:02:08,080 --> 01:02:18,110
Sì. Quindi dovremmo chiudere il f originale prima di fare questo.

649
01:02:18,110 --> 01:02:22,810
Ma - e poi anche, se non ci fosse un f aprire qui, allora ci sarebbe bisogno di dire -

650
01:02:22,810 --> 01:02:29,280
Gia '. Ma sarebbe aprire un centinaio di file diversi.

651
01:02:29,280 --> 01:02:37,360
[Studente] Ma non sarebbe in grado di accedere o - bene.

652
01:02:37,360 --> 01:02:44,230
Va bene. Così scansione f, f f scansione, è una specie della stessa idea,

653
01:02:44,230 --> 01:02:53,610
ma invece di, invece di memorizzare in una stringa, è più come sei ora

654
01:02:53,610 --> 01:03:02,420
andare oltre una puntura e pattern matching contro quella stringa e memorizzare i risultati in variabili.

655
01:03:02,420 --> 01:03:11,290
È possibile utilizzare f scansione per analizzare una cosa del genere 4.jpg, e memorizzare i 4 intero in x int somma.

656
01:03:11,290 --> 01:03:13,430
Questo è ciò che siamo in grado di usare f scansione per.

657
01:03:13,430 --> 01:03:16,300
F scansione f sta per farlo a riga di comando.

658
01:03:16,300 --> 01:03:19,200
In realtà sono abbastanza sicuro che questo è ciò che la biblioteca CS50 fa.

659
01:03:19,200 --> 01:03:29,050
Quindi, quando si dice, "get int", è scan f-zione over - f scansione è il modo in cui si ottiene l'input dell'utente.

660
01:03:29,050 --> 01:03:34,670
F scansione f sta per fare la stessa cosa ma utilizzando un file per la scansione su.

661
01:03:34,670 --> 01:03:41,090
Così qui, ci sta eseguendo la scansione su questo file.

662
01:03:41,090 --> 01:03:45,460
Il modello che stiamo cercando di abbinare è una stringa che è di 127 caratteri

663
01:03:45,460 --> 01:03:48,100
seguita da una nuova linea

664
01:03:48,100 --> 01:03:54,770
Quindi sono abbastanza sicuro che si potrebbe anche solo dire "match s", poiché nel dizionario

665
01:03:54,770 --> 01:03:57,770
ci capita di avere, abbiamo garantito nessuna parola è che a lungo,

666
01:03:57,770 --> 01:04:03,310
e anche f f scansione, credo, si ferma alla nuova linea non importa quale.

667
01:04:03,310 --> 01:04:06,970
Ma ci sono la nuova linea nella partita, e -

668
01:04:06,970 --> 01:04:13,960
[Studente] Se non abbiamo incluso la nuova linea, non sarebbe trovare le parti di una parola?

669
01:04:13,960 --> 01:04:22,900
It - ciascuno - guardando il dizionario -

670
01:04:22,900 --> 01:04:26,200
Così nel dizionario, queste sono tutte le nostre parole.

671
01:04:26,200 --> 01:04:30,500
Ognuno è su una nuova riga.

672
01:04:30,500 --> 01:04:32,510
La scansione f sta per prendere questa parola.

673
01:04:32,510 --> 01:04:38,750
Se non si include la nuova linea, allora è possibile che il f scansione successiva sarà solo leggere la nuova linea.

674
01:04:38,750 --> 01:04:44,180
Ma anche la nuova linea allora ignorare la nuova linea.

675
01:04:44,180 --> 01:04:49,440
Ma non arriveremo mai parte di una parola, dal momento che siamo sempre di lettura fino a una nuova linea, non importa quale.

676
01:04:49,440 --> 01:04:54,530
[Studente] Ma cosa succede se si cerca la parola "Cissa", come Cissa.

677
01:04:54,530 --> 01:04:57,380
Sarà essa ritiene che, e dire che è una partita?

678
01:04:57,380 --> 01:05:05,110
Ecco allora - si legge in - questo è in realtà un buon punto.

679
01:05:05,110 --> 01:05:10,660
Non abbiamo mai sta usando la corrente - la parola che stiamo cercando è il primo argomento della riga di comando.

680
01:05:10,660 --> 01:05:16,460
Così stringa, parola = argv 1.

681
01:05:16,460 --> 01:05:20,020
Quindi la stringa che stiamo cercando è argv 1.

682
01:05:20,020 --> 01:05:23,290
Non stiamo cercando una parola a tutti nel nostro f scansione.

683
01:05:23,290 --> 01:05:28,030
Quello che stavamo facendo con scansione f sta diventando ogni parola nel dizionario,

684
01:05:28,030 --> 01:05:34,320
e poi una volta che abbiamo questa parola che andremo a utilizzare strcmp per confrontare i loro.

685
01:05:34,320 --> 01:05:39,210
Stiamo andando a confrontare la nostra parola e quello che abbiamo appena letto trovi

686
01:05:39,210 --> 01:05:45,110
Così, inevitabilmente, stiamo andando a finire per fare un po 'di scansione fs

687
01:05:45,110 --> 01:05:52,130
fino a quando si da il caso che f scansione tornerà -

688
01:05:52,130 --> 01:05:54,800
restituisca uno, finché ha trovato una nuova parola,

689
01:05:54,800 --> 01:06:01,360
e sarà tornare qualcosa di diverso non appena è riuscito a corrispondere alla parola.

690
01:06:01,360 --> 01:06:08,440
Stiamo rileggendo l'intero dizionario, la memorizzazione riga per riga ogni parola nella variabile s.

691
01:06:08,440 --> 01:06:17,240
Allora stiamo confrontando parola con s, e se il confronto == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp capita di portare 0 se una partita è stata fatta.

693
01:06:21,650 --> 01:06:31,510
Quindi, se fosse 0, allora siamo in grado di stampare f, abbinato,

694
01:06:31,510 --> 01:06:35,370
o parola è nel dizionario, o qualsiasi altra cosa che si desidera stampare f.

695
01:06:35,370 --> 01:06:41,450
E poi - non vogliamo chiudere f più e più volte.

696
01:06:41,450 --> 01:06:50,410
Questo è il genere di cose che vogliamo fare, e non sono solo in cerca di parola nel dizionario.

697
01:06:50,410 --> 01:06:56,660
Così abbiamo potuto farlo, se volessimo cercare il loro modello, Cissa, come hai detto tu prima,

698
01:06:56,660 --> 01:07:00,260
se volessimo cercare quel modello, allora fallirebbe nel caso

699
01:07:00,260 --> 01:07:08,010
perché non è in realtà una parola, ma una delle parole nel dizionario che succede ad avere in esso.

700
01:07:08,010 --> 01:07:13,560
Quindi sarebbe abbinare a questa parola, ma questo sottoinsieme della parola non è una parola stessa.

701
01:07:13,560 --> 01:07:17,250
Ma non è il modo in cui lo si utilizza, stiamo leggendo in ogni parola

702
01:07:17,250 --> 01:07:19,740
e quindi confrontando la parola che abbiamo con quella parola.

703
01:07:19,740 --> 01:07:25,780
Quindi stiamo sempre confrontando parole piene.

704
01:07:25,780 --> 01:07:29,620
Posso inviare le soluzioni finalizzate tardi.

705
01:07:29,620 --> 01:07:32,050
Questa è una specie di quasi la risposta giusta, credo.

706
01:07:32,050 --> 01:07:34,720
[Commento Studente, incomprensibile]

707
01:07:34,720 --> 01:07:40,870
Oh, ho sbarazzarsi di quella prima? Char s, credo che abbiamo detto 127 - ho dimenticato quello che il più grande è.

708
01:07:40,870 --> 01:07:44,100
Non ci resta che fare 128, così ora s è abbastanza lunga.

709
01:07:44,100 --> 01:07:46,570
Non abbiamo bisogno di stampare nulla.

710
01:07:46,570 --> 01:07:56,440
Stiamo anche andando a voler avere a chiudere il nostro file, e che dovrebbe essere di circa la risposta giusta.

711
01:07:56,440 --> 01:07:59,440
CS50.TV