1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Problème Section Set 2: Edition Hacker

2
00:00:02,670 --> 00:00:04,910
Rob Bowden, Harvard University

3
00:00:04,910 --> 00:00:07,410
C'est CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Donc, je suis Rob. Je suis un aîné à Kirkland. C'est ma troisième année TFing CS50.

5
00:00:15,770 --> 00:00:22,220
C'est la première fois que nous changeons de la section traditionnelle conférence de style,

6
00:00:22,220 --> 00:00:25,610
où nous venons genre d'examen ce qui s'est passé dans la conférence, puis vous les gars poser des questions,

7
00:00:25,610 --> 00:00:32,250
maintenant à être beaucoup plus axée sur les problèmes, où nous utilisons les espaces, et -

8
00:00:32,250 --> 00:00:37,410
Ah, si l'idée est d'aller à ce lien que je vous envoie et vous serez dans mon espace.

9
00:00:37,410 --> 00:00:42,410
Quelqu'un at-il pas un ordinateur portable? D'accord.

10
00:00:42,410 --> 00:00:47,050
Donc, nous allons utiliser cela, et nous allons faire vivre des problèmes dans la section

11
00:00:47,050 --> 00:00:50,740
et d'en discuter et de déterminer ce qui ne va pas

12
00:00:50,740 --> 00:00:56,390
et je pourrais tirer vers le haut une partie de votre code, et je pourrais discuter de vos idées.

13
00:00:56,390 --> 00:01:02,140
Donc, toute personne a eu de la difficulté?

14
00:01:02,140 --> 00:01:07,000
Vous pouvez discuter sur le côté, je ne sais pas si nous avons des raisons pour cela.

15
00:01:07,000 --> 00:01:12,270
Maintenant, comme le supersection précédente, si vous étiez à cette classe, vous savez de quoi il s'agit.

16
00:01:12,270 --> 00:01:19,200
Sur l'ensemble des séries P il va y avoir ces sections.

17
00:01:19,200 --> 00:01:22,550
Donc P-série 2, cahier des charges, je suppose que vous l'avez vu sur P-1 déjà ensemble.

18
00:01:22,550 --> 00:01:27,400
Mais nous pouvons regarder ensemble P-2 pour ce que nous allons aller plus aujourd'hui.

19
00:01:27,400 --> 00:01:29,460
Et vous verrez une section de questions.

20
00:01:29,460 --> 00:01:37,530
Donc, ce sera dans tous les P-ensembles, il y aura une section de questions.

21
00:01:37,530 --> 00:01:41,340
Jusqu'ici, nous avons dit: «Considérez ce l'occasion de pratiquer."

22
00:01:41,340 --> 00:01:44,940
Vous ne serez pas invité à présenter ce programme.

23
00:01:44,940 --> 00:01:48,480
L'idée est que ceux-ci sont censés sorte de vous aider à démarrer avec le problème posé.

24
00:01:48,480 --> 00:01:53,220
Je suppose que sur l'édition Hacker, beaucoup d'entre eux sont censés être simplement de nouvelles choses intéressantes à apprendre.

25
00:01:53,220 --> 00:01:58,590
Ils ne peuvent pas être directement applicables au problème posé.

26
00:01:58,590 --> 00:02:01,810
Et en ce moment nous ne sommes pas vous avoir les soumettre, mais en théorie,

27
00:02:01,810 --> 00:02:07,480
pour ensembles de problèmes plus tard, vous pouvez les soumettre, et donc vous pouvez venir à la section

28
00:02:07,480 --> 00:02:10,380
ou regarder la section pour obtenir les réponses, ou vous pouvez simplement les mettre sur votre propre

29
00:02:10,380 --> 00:02:16,350
si vous n'avez pas envie de profiter de ma présence.

30
00:02:16,350 --> 00:02:21,010
Ainsi, le - je pense que c'est la première.

31
00:02:21,010 --> 00:02:29,280
Oh. En outre, en vertu de ces sections de questions que nous vous l'avons déjà poser des questions sur le short.

32
00:02:29,280 --> 00:02:33,440
Donc je suppose que, en théorie, vous êtes censé regarder ces avant de venir à la section,

33
00:02:33,440 --> 00:02:38,550
mais c'est bien si vous ne faites pas, nous allons passer en revue toute façon.

34
00:02:38,550 --> 00:02:42,590
Ainsi, nous pouvons commencer par celles-ci: "Comment ça une boucle while diffèrent d'une boucle do-while?

35
00:02:42,590 --> 00:02:46,210
Lorsque celle-ci est particulièrement utile? "

36
00:02:46,210 --> 00:02:49,390
Donc, n'importe qui a une -?

37
00:02:49,390 --> 00:02:52,730
[Étudiants] La boucle do-while s'exécute toujours au moins une fois.

38
00:02:52,730 --> 00:03:02,950
Oui. Donc, c'est la différence. Une boucle while - je vais juste le faire ici - boucle while, nous avons la condition

39
00:03:02,950 --> 00:03:19,760
ici, alors qu'un do-while, vous n'avez pas une condition jusqu'à ce que nous obtenons ici-bas.

40
00:03:19,760 --> 00:03:24,130
Ainsi, lorsque votre programme est exécuter, et il arrive à la boucle while,

41
00:03:24,130 --> 00:03:26,380
il vérifie immédiatement si cette condition est vraie.

42
00:03:26,380 --> 00:03:30,710
Si cette condition n'est pas vrai, il suffit de sauter sur la boucle entièrement.

43
00:03:30,710 --> 00:03:34,390
Boucle do-while, car le programme est exécuté, il arrive au «faire».

44
00:03:34,390 --> 00:03:37,920
Rien ne se passe en ce moment, continue simplement d'exécution.

45
00:03:37,920 --> 00:03:42,690
Puis, quand il frappe le «tout», si la condition est vraie, ça boucle arrière et le faire à nouveau

46
00:03:42,690 --> 00:03:46,730
et encore et encore jusqu'à ce que la condition n'est pas vraie, puis tombe juste à travers.

47
00:03:46,730 --> 00:03:50,600
Donc, la différence étant que cela peut aller directement dès le début.

48
00:03:50,600 --> 00:03:56,770
Cette commande exécute nécessairement une fois et peut ensuite exécuter plusieurs fois si la condition est toujours vraie.

49
00:03:56,770 --> 00:04:03,720
Ainsi, la boucle while ne faire qu'une seule fois, ou - la boucle while - nous ne pouvons pas besoin de le faire du tout,

50
00:04:03,720 --> 00:04:07,900
car dès que nous y arriverons, si la condition est fausse, nous allons juste aller directement sur elle.

51
00:04:07,900 --> 00:04:11,770
Alors que boucle do-while, nous l'exécuterons une fois, forcément.

52
00:04:11,770 --> 00:04:14,560
Puis, lorsque nous arriverons à la condition, nous vérifions si c'est vrai ou faux.

53
00:04:14,560 --> 00:04:19,790
Si c'est vrai, nous le ferons à nouveau, si elle est fausse, nous allons continuer à aller.

54
00:04:19,790 --> 00:04:24,680
Ainsi, lorsque celui-ci est particulièrement utile?

55
00:04:24,680 --> 00:04:31,190
Donc, je peux dire que dans l'ensemble des 4 ans, 3 ans, peu importe,

56
00:04:31,190 --> 00:04:38,780
que j'ai été la programmation, j'ai utilisé ça, comme, de moins de 10 fois.

57
00:04:38,780 --> 00:04:43,140
Et probablement 5 d'entre eux sont en CS50 lorsque nous introduisons boucles do-while.

58
00:04:43,140 --> 00:04:47,510
Alors quand pensez-vous utilisé boucles do-while?

59
00:04:47,510 --> 00:04:49,510
Quel est le - ouais?

60
00:04:49,510 --> 00:04:53,180
[Étudiants] Lorsque vous essayez d'obtenir une entrée utilisateur, ou quelque chose que vous souhaitez vérifier -

61
00:04:53,180 --> 00:04:59,700
Ouais. Donc boucles do-while, l'utilisateur d'entrée est le grand.

62
00:04:59,700 --> 00:05:03,160
C'est pourquoi les premières séries de problèmes de couple, si vous voulez demander à l'utilisateur, comme,

63
00:05:03,160 --> 00:05:08,520
«Donnez-moi une corde," vous ne pouvez pas continuer jusqu'à ce que vous obtenez cette chaîne.

64
00:05:08,520 --> 00:05:12,980
Et si vous, nécessairement, doivent demander la chaîne au moins une fois.

65
00:05:12,980 --> 00:05:16,950
Mais alors, si ils répondent quelque chose de mauvais, alors vous devez faire une boucle en arrière et demander à nouveau.

66
00:05:16,950 --> 00:05:20,810
Mais à part de l'utilisateur, il est très rare que je rencontre un cas

67
00:05:20,810 --> 00:05:27,170
là où je veux en boucle "au moins une fois", mais peut-être plus.

68
00:05:27,170 --> 00:05:33,370
Questions ou -? Quelqu'un at-il utilisé une boucle do-while ailleurs?

69
00:05:33,370 --> 00:05:36,780
D'accord. Donc, la prochaine est: «Qu'est-ce que non déclarés identifiant

70
00:05:36,780 --> 00:05:43,310
indiquent généralement si délivrée par clang? "

71
00:05:43,310 --> 00:05:47,380
Alors, quel genre de code que je pourrais écrire pour obtenir 'identificateur non déclaré?

72
00:05:47,380 --> 00:05:49,550
[Étudiants] Cela x = 2?

73
00:05:49,550 --> 00:05:52,650
Ainsi, nous pouvons juste essayer ici, x = 2.

74
00:05:52,650 --> 00:06:04,830
Nous allons exécuter ce - oh, je n'ai pas cliquer dessus. Donc, ici nous arrivons - tous droits.

75
00:06:04,830 --> 00:06:07,100
"L'utilisation de x identificateur non déclaré».

76
00:06:07,100 --> 00:06:11,610
Donc, c'est l'identificateur non déclaré, une variable.

77
00:06:11,610 --> 00:06:13,910
Il sera souvent appeler une variable d'un identifiant.

78
00:06:13,910 --> 00:06:17,300
Ainsi, il pourrait ne pas savoir qu'il s'agit en fait d'une variable, il ne sait pas ce que c'est.

79
00:06:17,300 --> 00:06:19,380
Donc, c'est un identifiant.

80
00:06:19,380 --> 00:06:26,060
Alors, pourquoi est-il non déclarée? Ouais.

81
00:06:26,060 --> 00:06:32,190
Donc, pour être clair sur la terminologie, la déclaration d'une variable

82
00:06:32,190 --> 00:06:37,360
c'est quand vous dites "int x" ou "y", chaîne de quoi que ce soit.

83
00:06:37,360 --> 00:06:41,910
L'initialisation de la variable ou l'affectation de la variable,

84
00:06:41,910 --> 00:06:44,510
est chaque fois que vous dites "x = 2."

85
00:06:44,510 --> 00:06:52,950
Ainsi, nous pouvons les faire dans des étapes séparées, int x, x = 2, et jusqu'à ce que - nous pouvons avoir un tas de trucs ici -

86
00:06:52,950 --> 00:07:00,350
mais jusqu'à ce que cette ligne passe, x est toujours pas initialisé, mais elle a été déclarée.

87
00:07:00,350 --> 00:07:06,760
Et si on peut évidemment le faire en 1 ligne, et maintenant nous sommes déclaration et l'initialisation.

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

89
00:07:10,730 --> 00:07:18,390
Et enfin, «Pourquoi le chiffrement de César pas très sûr?"

90
00:07:18,390 --> 00:07:23,830
Alors d'abord, personne ne veut dire ce que le chiffre de César est?

91
00:07:23,830 --> 00:07:28,100
[Étudiants] Caesar Cipher est juste que vous mappez, vous passez chaque lettre,

92
00:07:28,100 --> 00:07:34,420
un certain nombre de lettres dépasser, et de revenir plus, et ce n'est pas très sûr, car

93
00:07:34,420 --> 00:07:42,260
il n'y a que 26 options possibles et vous avez juste à essayer chaque 1 de ceux que vous l'obtenez.

94
00:07:42,260 --> 00:07:45,470
Oh. Donc, je le répète?

95
00:07:45,470 --> 00:07:51,600
Le chiffre de César, C'est - je veux dire, vous aurez affaire avec lui sur les problèmes que vous -

96
00:07:51,600 --> 00:07:56,110
ou je suppose que l'édition standard du jeu de problème, ce n'est pas sur l'édition pirate.

97
00:07:56,110 --> 00:08:01,550
Ainsi, sur l'édition standard au problème posé, vous obtenez un message du type: "Bonjour, monde»,

98
00:08:01,550 --> 00:08:08,410
et vous avez également un certain nombre comme 6, et que vous prenez ce message, et chaque caractère,

99
00:08:08,410 --> 00:08:11,310
vous le faire pivoter en 6 positions dans l'alphabet.

100
00:08:11,310 --> 00:08:16,560
Ainsi, le 'h' de bonjour deviendrait h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
Donc, la première lettre serait n. Nous faisons la même chose avec e.

102
00:08:19,600 --> 00:08:23,530
Si nous avons un, comme, z ou quelque chose, alors nous envelopper arrière autour de «une».

103
00:08:23,530 --> 00:08:29,280
Mais chaque personnage a recyclé 6 caractères loin dans l'alphabet, et il n'est pas très sûr

104
00:08:29,280 --> 00:08:35,440
car il ya seulement 26 possibilités de combien de façons que vous pouvez envelopper une seule lettre.

105
00:08:35,440 --> 00:08:42,919
Ainsi, vous pouvez juste essayer tous les 26 d'entre eux et, sans doute, pour un message assez long,

106
00:08:42,919 --> 00:08:46,860
1 seul de ces 26 choses possibles va être lisible,

107
00:08:46,860 --> 00:08:50,300
et le lisible va être le message d'origine.

108
00:08:50,300 --> 00:08:56,240
Donc ce n'est pas une très bonne façon de chiffrer quoi que ce soit.

109
00:08:56,240 --> 00:08:59,070
Indépendamment de ces courts métrages, «Qu'est-ce qu'une fonction?"

110
00:08:59,070 --> 00:09:03,370
Alors qu'est-ce qu'une fonction? Oui.

111
00:09:03,370 --> 00:09:11,640
[Étudiants] C'est comme un morceau de code que vous pouvez appeler pour passer et ensuite obtenir la valeur de retour de la chose.

112
00:09:11,640 --> 00:09:18,160
Ouais. Donc, je vais y répondre en répondant aussi à l'autre - ou de répétition en outre que répondre à la suivante.

113
00:09:18,160 --> 00:09:22,410
Vous pouvez utiliser les fonctions au lieu de simplement copier et coller le code maintes et maintes fois.

114
00:09:22,410 --> 00:09:27,200
Il suffit de prendre ce code, le mettre dans un fuction, et alors vous pouvez appeler la fonction

115
00:09:27,200 --> 00:09:29,870
où vous avez été un copier-coller.

116
00:09:29,870 --> 00:09:33,350
Ainsi, les fonctions sont utiles.

117
00:09:33,350 --> 00:09:35,860
Alors maintenant, nous ferons des problèmes réels.

118
00:09:35,860 --> 00:09:46,490
La première. Donc, l'idée de la première, c'est que vous passez une chaîne, et quel que soit le -

119
00:09:46,490 --> 00:09:52,060
ou faut-il dire tout en minuscules? Il ne dit pas tout en minuscules.

120
00:09:52,060 --> 00:09:57,730
Donc, le message peut être n'importe quoi, et - oh non. C'est le cas.

121
00:09:57,730 --> 00:10:01,610
"Pour plus de simplicité, vous pouvez supposer que l'utilisateur aura seulement l'entrée des lettres minuscules et les espaces."

122
00:10:01,610 --> 00:10:08,180
Donc, nous lui passer un message avec uniquement des lettres minuscules, puis nous alternons

123
00:10:08,180 --> 00:10:15,450
entre le capital et les minuscules - nous changer la chaîne pour être la capitale et les minuscules, en alternance.

124
00:10:15,450 --> 00:10:22,920
Donc, avant de vous donner une seconde à plonger dans le même problème,

125
00:10:22,920 --> 00:10:32,420
quelle est la première chose que nous devons faire?

126
00:10:32,420 --> 00:10:36,900
Oh, qu'est-ce que je viens de cliquer sur? Oh, j'ai juste cliqué sur un e-mail ici.

127
00:10:36,900 --> 00:10:42,870
Donc la première chose que nous devons faire - je regarde la mauvaise?

128
00:10:42,870 --> 00:10:49,320
Est-ce une partie de celle-ci?

129
00:10:49,320 --> 00:10:51,320
Non, ceux qui sont toujours là, cependant.

130
00:10:51,320 --> 00:10:55,160
Bon, encore ici.

131
00:10:55,160 --> 00:11:03,160
Maintenant, nous ne pouvons pas assumer -? Oui. Ici, nous ne pouvons pas supposer que c'est seulement en minuscules et les espaces.

132
00:11:03,160 --> 00:11:07,770
Alors maintenant, nous devons composer avec le fait que les lettres peuvent être tout ce que nous voulons qu'ils soient.

133
00:11:07,770 --> 00:11:11,910
Et la première chose que nous voulons faire est de simplement faire passer le message.

134
00:11:11,910 --> 00:11:19,790
Nous avons juste besoin d'obtenir un string, string s = GetString, d'accord.

135
00:11:19,790 --> 00:11:24,890
Maintenant ce problème, il ya deux façons de le faire.

136
00:11:24,890 --> 00:11:29,840
Mais nous allons vouloir utiliser les opérateurs binaires ici.

137
00:11:29,840 --> 00:11:35,280
Y at-il des gens qui soit ne sont pas à la supersection,

138
00:11:35,280 --> 00:11:37,480
ou quelque chose, et ne savent pas ce que les opérateurs bit à bit sont?

139
00:11:37,480 --> 00:11:41,710
Ou comment ils se rapportent à l'ASCII en aucune façon?

140
00:11:41,710 --> 00:11:45,650
[Étudiants] je n'étais pas à la supersection, mais je sais ce que les opérateurs bit à bit sont.

141
00:11:45,650 --> 00:11:49,560
D'accord. Alors je n'ai pas à revenir sur les bases d'entre eux, mais je vais vous expliquer

142
00:11:49,560 --> 00:11:51,830
ce que nous allons avoir à utiliser ici.

143
00:11:51,830 --> 00:11:59,680
Donc «A»: la représentation binaire du capital A, le nombre est de 65.

144
00:11:59,680 --> 00:12:07,560
Je vais regarder - 41 va être 01000001.

145
00:12:07,560 --> 00:12:14,170
Ce qui devrait être de 65 en décimal; c'est donc la représentation binaire de la capitale caractère A.

146
00:12:14,170 --> 00:12:19,440
Maintenant, la représentation binaire du caractère minuscule «a»

147
00:12:19,440 --> 00:12:33,350
va être la même chose, ou presque. Est-ce que - 6, ouais. Ce qui est juste.

148
00:12:33,350 --> 00:12:37,670
Ainsi, le capital binaire A minuscules, binaire «un».

149
00:12:37,670 --> 00:12:43,940
Donc remarquer que la différence entre A et 'a' est-ce un seul bit.

150
00:12:43,940 --> 00:12:49,440
Et il se trouve que le 32 bits, le bit représentant le nombre 32.

151
00:12:49,440 --> 00:12:53,910
Et c'est logique puisque A est de 65; 'a' est 97.

152
00:12:53,910 --> 00:12:56,610
La différence entre les deux est de 32.

153
00:12:56,610 --> 00:13:03,770
Alors maintenant, nous savons que nous pouvons convertir de A à 'a' en prenant un

154
00:13:03,770 --> 00:13:09,710
et il ORing bit, avec - qui ressemble à un 1.

155
00:13:09,710 --> 00:13:20,900
Il s'agit d'une opération de bits OR, avec 00100000, et qui va nous donner «un».

156
00:13:20,900 --> 00:13:26,850
Et nous pouvons obtenir de 'a' à A par bit AND

157
00:13:26,850 --> 00:13:33,700
avec 11, 0 à cet endroit, 11111.

158
00:13:33,700 --> 00:13:43,840
Donc, ce sera ensuite nous donner exactement ce que 'a' est, mais annuler ce bit individuel,

159
00:13:43,840 --> 00:13:50,070
alors nous aurons 01000001; je ne sais pas si j'ai bien compté droite.

160
00:13:50,070 --> 00:13:56,750
Mais cette technique de bit à bit pour obtenir du capital en minuscules,

161
00:13:56,750 --> 00:14:02,080
et au niveau du bit AND pour obtenir de minuscules en capital n'est pas exclusif à A.

162
00:14:02,080 --> 00:14:06,510
Toutes les lettres, K vs K, Z vs z,

163
00:14:06,510 --> 00:14:10,080
chacun d'entre eux vont juste diffèrent par ce seul bit.

164
00:14:10,080 --> 00:14:16,290
Et si vous pouvez l'utiliser pour passer d'une lettre minuscule à une majuscule et vice-versa.

165
00:14:16,290 --> 00:14:26,670
D'accord. Donc, un moyen facile d'obtenir à partir de ce - au lieu d'avoir à

166
00:14:26,670 --> 00:14:32,170
écrire quelque 1011111 est - un moyen facile de représenter ce nombre, et ce n'est pas un

167
00:14:32,170 --> 00:14:39,710
que je suis allé dans le supersection, mais tilde (~) est un autre opérateur de bits.

168
00:14:39,710 --> 00:14:42,520
Qu'est-ce ~ fait est qu'il regarde la représentation binaire.

169
00:14:42,520 --> 00:14:45,630
Prenons n'importe quel nombre.

170
00:14:45,630 --> 00:14:53,130
Ceci est juste un nombre binaire, et qu'est-ce que ~ est le retourne simplement tous les bits.

171
00:14:53,130 --> 00:15:00,630
Donc, ce fut un 1, un 0 aujourd'hui, c'est un 0, maintenant un 1, 010100.

172
00:15:00,630 --> 00:15:08,320
Donc, c'est tout ~ fait. Donc 32 est va être le nombre - se débarrasser de ce -

173
00:15:08,320 --> 00:15:23,320
si 32 est va être le numéro 00100000, et ainsi de ~ de ce qui se passe à

174
00:15:23,320 --> 00:15:29,980
ce nombre ici que je ANDed 'a' avec.

175
00:15:29,980 --> 00:15:35,600
Est-ce que tout le monde voit que? C'est assez commun, comme quand vous voulez comprendre

176
00:15:35,600 --> 00:15:40,740
pour des choses plus tard que nous pourrions voir, quand nous voulons voir si -

177
00:15:40,740 --> 00:15:44,710
ou nous voulons tout, chaque bit unique, sauf pour 1

178
00:15:44,710 --> 00:15:47,910
vous avez tendance à ne ~ du bit que nous ne voulons pas réglé.

179
00:15:47,910 --> 00:15:53,090
Donc, nous ne voulons pas le bit 32, donc nous n'avons ~ de 32 ans.

180
00:15:53,090 --> 00:15:57,790
D'accord. Nous pouvons donc utiliser tous ceux qui sont ici.

181
00:15:57,790 --> 00:16:03,000
D'accord, c'est très bien si vous n'avez pas fini, nous allons marcher lentement au cours ensemble,

182
00:16:03,000 --> 00:16:11,870
ou marcher sur cela, donc - à travers cela. Promenade à travers cela.

183
00:16:11,870 --> 00:16:20,790
Donc, nous avons notre chaîne, et nous voulons faire une boucle sur chaque caractère dans cette chaîne et faire quelque chose pour elle.

184
00:16:20,790 --> 00:16:26,710
Alors, comment avons-nous une boucle sur une chaîne? Que devrions-nous utiliser?

185
00:16:26,710 --> 00:16:30,980
Je ne vais pas le faire ici. Ouais.

186
00:16:30,980 --> 00:16:42,940
Donc j'ai mon itérateur, et il l'a dit, mais comment puis-je savoir combien de caractères sont dans la chaîne?

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

188
00:16:47,030 --> 00:16:49,860
Alors qu'est-ce que j'ai fait ici n'est pas la meilleure façon de faire les choses.

189
00:16:49,860 --> 00:16:51,860
Est-ce que quelqu'un sait pourquoi?

190
00:16:51,860 --> 00:16:55,290
Parce que vous vérifiez la langue de la chaîne à chaque fois.

191
00:16:55,290 --> 00:17:06,859
Donc, nous allons vouloir bouger strlen, je pourrais dire ici, int length = strlen (s),

192
00:17:06,859 --> 00:17:11,900
et puis ne i <longueur, et au cas où vous ne l'avez pas vu avant,

193
00:17:11,900 --> 00:17:20,410
Je pourrais aussi faire int i = 0, longueur = strlen (s).

194
00:17:20,410 --> 00:17:25,010
Et donc c'est un peu préférable, car maintenant, j'ai limité la portée

195
00:17:25,010 --> 00:17:29,150
de la longueur variable pour juste cette boucle 'for', au lieu de le déclarer avant

196
00:17:29,150 --> 00:17:34,990
et qu'il existe toujours, et dans le cas où vous n'avez pas compris pourquoi c'est mauvais,

197
00:17:34,990 --> 00:17:39,410
ou pourquoi l'original était mauvais, C'est - à commencer la boucle.

198
00:17:39,410 --> 00:17:43,380
J'ai vérifié l'état. I <est la longueur de s?

199
00:17:43,380 --> 00:17:46,790
Ainsi, la longueur de l'article, nous allons travailler avec "bonjour" tout le temps.

200
00:17:46,790 --> 00:17:49,670
Ainsi, la longueur de s, h-e-l-l-o. Longueur est de 5.

201
00:17:49,670 --> 00:17:57,580
Donc, i = 0, la longueur est de 5, donc je n'est pas <5, la boucle continue.

202
00:17:57,580 --> 00:18:02,750
Ensuite, nous allons à nouveau. Nous vérifions l'état. I <est la longueur de bonjour?

203
00:18:02,750 --> 00:18:08,390
Donc, nous allons vérifier la longueur de bonjour. H-E-L-L-o. C'est 5; i n'est pas <5, nous continuons donc à nouveau.

204
00:18:08,390 --> 00:18:13,330
Donc, nous calculons, nous comptons bonjour, pour chaque itération de la boucle,

205
00:18:13,330 --> 00:18:17,380
même pensé qu'il ne va jamais changer, il va toujours être de 5.

206
00:18:17,380 --> 00:18:22,530
Alors que nous venons de rappeler 5 jusqu'à l'avant, et maintenant tout va mieux.

207
00:18:22,530 --> 00:18:24,990
Donc itération sur toute la chaîne.

208
00:18:24,990 --> 00:18:31,470
Que voulons-nous faire pour chaque caractère de la chaîne?

209
00:18:31,470 --> 00:18:38,510
[Parlant des étudiants, inintelligible]

210
00:18:38,510 --> 00:18:47,000
Ouais. Donc, si le personnage est non alphabétique, puis nous voulons juste de sauter par-dessus.

211
00:18:47,000 --> 00:18:52,300
Parce que nous ne se soucient que des lettres alphabétiques, nous ne pouvons tirer un certain nombre.

212
00:18:52,300 --> 00:19:10,850
Alors, comment pouvons-nous faire cela? Donc, notre condition, si nous voulons quelque chose - vérifier si c'est alphabétique.

213
00:19:10,850 --> 00:19:14,060
Alors, comment pouvons-nous vérifier cela?

214
00:19:14,060 --> 00:19:18,720
[Étudiants] Vous pouvez simplement utiliser la fonction est l'alpha.

215
00:19:18,720 --> 00:19:23,160
Est-ce inclus dans un des deux, ou de tout inclure comme, char.h ou quelque chose?

216
00:19:23,160 --> 00:19:32,710
Il ne faut pas utiliser la fonction alpha est, et utiliser l'explicite - nous avons donc s [i],

217
00:19:32,710 --> 00:19:40,460
qui est le huitième caractère de s, rappelez-vous qu'une chaîne est un tableau de caractères,

218
00:19:40,460 --> 00:19:43,180
de sorte que le huitième caractère de l'art.

219
00:19:43,180 --> 00:19:49,280
Maintenant, s'il s'agit d'une lettre majuscule, nous savons qu'il doit y avoir dans une plage spécifique.

220
00:19:49,280 --> 00:19:54,370
Et quelle est cette plage?

221
00:19:54,370 --> 00:20:07,860
Ouais. Donc, si s [i] est ≥ 65, et s [i] est ≤ 90, que dois-je faire à la place?

222
00:20:07,860 --> 00:20:18,470
Ouais. Alors vous devez absolument jamais besoin de connaître les valeurs ASCII jamais rien.

223
00:20:18,470 --> 00:20:25,640
Ne pensez jamais que des numéros 65, 90, 97 et 102, ou quoi que ce soit.

224
00:20:25,640 --> 00:20:32,470
Vous n'avez pas besoin - 112 - vous n'avez pas besoin de connaître ceux du tout. C'est faux aussi.

225
00:20:32,470 --> 00:20:41,940
Utilisez uniquement les caractères guillemets simples, constantes apostrophes. Ainsi, «A» et moins de 90 est «Z.

226
00:20:41,940 --> 00:20:47,930
Et c'est nettement mieux - je ne sais pas du haut de ma tête que Z est de 90.

227
00:20:47,930 --> 00:20:52,690
Je ne sais sur le dessus de ma tête que 'Z' est la capitale Z.

228
00:20:52,690 --> 00:21:02,100
Donc, tant que cela est dans la gamme du capital de A à Z de capital, ou nous pouvons vérifier les minuscules,

229
00:21:02,100 --> 00:21:17,010
Ou si c'est dans le domaine ≥ «a» et ≤ z.

230
00:21:17,010 --> 00:21:19,010
Donc, c'est notre condition.

231
00:21:19,010 --> 00:21:22,520
Le style de l'endroit où placer ces choses varie.

232
00:21:22,520 --> 00:21:29,520
Je vais faire comme ça.

233
00:21:29,520 --> 00:21:31,520
Maintenant, qu'est-ce que nous voulons faire?

234
00:21:31,520 --> 00:21:39,530
Nous savons que cette lettre est un caractère, un caractère alphabétique.

235
00:21:39,530 --> 00:21:46,270
Nous avons donc besoin d'alterner entre si cela devrait maintenant être une majuscule ou une minuscule.

236
00:21:46,270 --> 00:21:48,820
Comment pouvons-nous garder la trace de laquelle on nous voulons qu'il soit?

237
00:21:48,820 --> 00:21:55,520
[Voix des élèves, inintelligibles]

238
00:21:55,520 --> 00:21:59,150
Donc, oui, mais laissez-moi vérifier.

239
00:21:59,150 --> 00:22:04,910
Module 0-2 disait-on, une suggestion jeté dehors, et je suis d'accord avec cela.

240
00:22:04,910 --> 00:22:11,780
Sauf avis que, comme - est-ce le cas? Ouais.

241
00:22:11,780 --> 00:22:18,270
C'est tous les autres, mais nous ne pouvons pas le module 2 de i ou i mod 2, puisque

242
00:22:18,270 --> 00:22:22,950
remarque que E est la capitale et «a» est en minuscules? Mais il ya un espace qui les sépare?

243
00:22:22,950 --> 00:22:27,150
Ils vont donc être le même mod 2, mais ils sont différents cas.

244
00:22:27,150 --> 00:22:29,150
[Question étudiants, inintelligible]

245
00:22:29,150 --> 00:22:34,690
Ouais. Donc, nous allons juste de tenir un compte.

246
00:22:34,690 --> 00:22:38,730
Nous pourrions aussi le faire ici, si nous voulions, c'est peut-être obtenir un peu lourde

247
00:22:38,730 --> 00:22:41,300
dans la boucle pour les déclarations, je vais le mettre ici.

248
00:22:41,300 --> 00:22:48,840
Donc, int count = commence à 0.

249
00:22:48,840 --> 00:22:54,070
Et maintenant, je vais compter le nombre de caractères alphabétiques que nous avons eu.

250
00:22:54,070 --> 00:22:59,550
Nous sommes donc inévitablement à compter + + depuis que nous avons trouvé un autre caractère alphabétique.

251
00:22:59,550 --> 00:23:09,130
Mais, alors maintenant vous dites que si mod le compte de 2.

252
00:23:09,130 --> 00:23:12,590
Alors, que si le nombre de mod 2? Oh. Je ferai == 0 pour l'instant.

253
00:23:12,590 --> 00:23:21,740
Nous allons également revenir là-dessus. Donc, si nombre de mod 2 == 0, alors quoi?

254
00:23:21,740 --> 00:23:27,830
[Etudiants réponse, inintelligibles]

255
00:23:27,830 --> 00:23:32,750
Donc, nous voulons finir en majuscules.

256
00:23:32,750 --> 00:23:37,520
Il ya 2 cas; majuscules et les minuscules sont les 2 cas.

257
00:23:37,520 --> 00:23:40,990
Donc, si nous sommes en minuscules, nous devons faire en majuscules.

258
00:23:40,990 --> 00:23:43,710
Si c'est en majuscules nous n'avons pas besoin de faire quoi que ce soit.

259
00:23:43,710 --> 00:23:50,760
Mais, est-il un moyen - ne devrais avoir renversé -

260
00:23:50,760 --> 00:23:54,800
que nous n'avons même pas besoin de vérifier si elle est en majuscule ou minuscule?

261
00:23:54,800 --> 00:24:02,240
Que pouvons-nous faire pour toujours vous assurer que nous finissons toujours à majuscule?

262
00:24:02,240 --> 00:24:07,830
Donc, notez ce que nous avons fait pour les minuscules 'a'; si nous l'avons fait exactement la même chose en majuscules A?

263
00:24:07,830 --> 00:24:11,900
Est-ce majuscules Un changement, ou est-ce le changement de valeur?

264
00:24:11,900 --> 00:24:23,100
Ouais. Ainsi, une lettre en majuscule opérateur AND avec ~ 32 va être ce caractère en majuscule même

265
00:24:23,100 --> 00:24:29,220
parce que, pour tout caractère majuscule le 32ème bit n'est pas défini.

266
00:24:29,220 --> 00:24:40,920
Donc, si nous voulons apporter le caractère s [i], nous voulons qu'elle devienne minuscules ou en majuscules.

267
00:24:40,920 --> 00:24:46,890
Donc, si elle était minuscule, il est maintenant en majuscules, si elle était en majuscule, il est toujours en majuscule, et c'est tout.

268
00:24:46,890 --> 00:24:54,290
Je l'ai dit dans le supersection: Vous pouvez utiliser 32 si vous voulez, mais j'ai tendance à préférer faire 'a' - A,

269
00:24:54,290 --> 00:25:01,150
au lieu de seulement 32 plaine, car il peut être n'importe quel autre morceau.

270
00:25:01,150 --> 00:25:03,610
Après le 32 bits, il peut être n'importe quel d'entre eux, sinon nous ne serions pas assez

271
00:25:03,610 --> 00:25:05,840
chiffres pour représenter tous les caractères.

272
00:25:05,840 --> 00:25:09,110
Donc, si vous obtenez le bit 32, cela pourrait être le 64 bits, il pourrait être le 128 bits.

273
00:25:09,110 --> 00:25:13,990
N'importe lequel de ces morceaux peut être le morceau qui fait la distinction entre majuscules et minuscules.

274
00:25:13,990 --> 00:25:18,350
Je n'aurais pas besoin de savoir que c'est le 32 bits.

275
00:25:18,350 --> 00:25:27,130
Je peux utiliser ce «a» - A pour obtenir le peu qui diffère entre les deux

276
00:25:27,130 --> 00:25:33,000
sans avoir besoin de s'appuyer sur le nombre magique qui est de 32.

277
00:25:33,000 --> 00:25:38,770
Et maintenant, sinon comptez était étrange, et alors qu'est-ce que je veux faire?

278
00:25:38,770 --> 00:25:43,920
[Les réponses des élèves, inintelligible]

279
00:25:43,920 --> 00:25:45,920
[Étudiants] Qu'est-ce que c'est?

280
00:25:45,920 --> 00:25:49,850
Je vais le faire en 1 seconde.

281
00:25:49,850 --> 00:25:55,690
Alors maintenant, si je veux - je veux m'assurer que le personnage est désormais en minuscules,

282
00:25:55,690 --> 00:26:04,140
et si je peux ou par 32, et «un '32 sens - A.

283
00:26:04,140 --> 00:26:06,510
Mais remarquez, par le même raisonnement que précédemment, que si

284
00:26:06,510 --> 00:26:11,670
la lettre était déjà en minuscules, puis ORing de 32 maintient juste en minuscules.

285
00:26:11,670 --> 00:26:16,220
Il n'a pas changé le caractère original.

286
00:26:16,220 --> 00:26:19,910
Mais maintenant, je n'ai pas pour éviter de dire: «Si c'est minuscule, tout oublier,

287
00:26:19,910 --> 00:26:23,650
si c'est en majuscules, puis le changer. "

288
00:26:23,650 --> 00:26:26,900
Il est beaucoup plus pratique de le faire.

289
00:26:26,900 --> 00:26:33,190
[Étudiants] Est-ce que cette stratégie de soustraire les majuscules en minuscules du travail si ce n'était pas 32?

290
00:26:33,190 --> 00:26:35,330
Si c'était, comme, 34 ou quelque chose?

291
00:26:35,330 --> 00:26:41,840
Donc, vous devez savoir que la différence entre les 2 est -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
Il pourrait être plus que 1 bit, aussi longtemps que tous les bits inférieurs à ce poste sont les mêmes.

293
00:26:49,840 --> 00:26:58,500
Nous avons donc besoin d'au moins 26 caractères - ou, il ya 26 caractères.

294
00:26:58,500 --> 00:27:04,590
Nous avons donc besoin d'au moins 26 chiffres pour représenter la différence -

295
00:27:04,590 --> 00:27:07,650
La différence entre A et "a" doit être d'au moins 26,

296
00:27:07,650 --> 00:27:10,760
sinon nous n'aurions pas représenté tous les numéros de capitaux.

297
00:27:10,760 --> 00:27:18,630
Cela signifie que A, si nous commençons à 1, il va utiliser tous ces bits,

298
00:27:18,630 --> 00:27:23,900
l'ensemble de ces 5 premiers bits, pour représenter tout à Z.

299
00:27:23,900 --> 00:27:32,170
C'est pourquoi le bit suivant, ou ce bit, le bit suivant est celui qui a choisi de faire la distinction entre A et «un».

300
00:27:32,170 --> 00:27:40,930
C'est aussi pourquoi, dans le tableau ASCII, il ya 5 symboles qui séparent les majuscules des minuscules.

301
00:27:40,930 --> 00:27:49,050
Puisque ce sont les symboles, les 5 supplémentaire qui ouvre le 32 étant la différence entre eux.

302
00:27:49,050 --> 00:27:51,840
[Étudiants] Donc, nous pourrions le faire, parce ASCII est conçu comme ça.

303
00:27:51,840 --> 00:27:57,280
Oui. Mais ASCII - la différence pourrait aussi être à la fois de ces bits.

304
00:27:57,280 --> 00:28:12,040
Comme, si A 10000001, et «a» est 11100001 - je ne sais plus, peu importe.

305
00:28:12,040 --> 00:28:18,100
Mais si c'était cela, alors nous pourrions toujours utiliser 'a' - A.

306
00:28:18,100 --> 00:28:22,650
C'est tout à l'heure la différence entre A et «a» est toujours ces 2 bits.

307
00:28:22,650 --> 00:28:32,240
Je pense que c'est écrit 48. Est-il 32 + 64? Je pense qu'il est?

308
00:28:32,240 --> 00:28:40,160
Il serait encore 2 bits; chaque personnage, comme, Z et z, K et k,

309
00:28:40,160 --> 00:28:45,160
ils ont toujours les mêmes bits exactes fixées à l'exception des 2 bits.

310
00:28:45,160 --> 00:28:48,870
Donc, tant que c'est toujours le cas, peu importe si nous utilisons ASCII ou un autre système,

311
00:28:48,870 --> 00:28:53,050
tant qu'il n'y a qu'un nombre un ensemble de bits qui sont différentes pour chaque caractère,

312
00:28:53,050 --> 00:28:55,050
puis qui fonctionne très bien.

313
00:28:55,050 --> 00:29:06,110
C'est juste que 32 a été mis en place parce que c'est la première que nous pourrions peut-être utiliser. >> Cool.

314
00:29:06,110 --> 00:29:14,520
J'ai tendance à préférer, dans le cas où vous n'avez pas vu, si le bloc est une seule ligne,

315
00:29:14,520 --> 00:29:24,280
vous pouvez vous débarrasser des accolades, donc j'ai tendance à préférer le faire.

316
00:29:24,280 --> 00:29:34,010
Aussi, vous savez comment nous pouvons faire des choses comme s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Vous pouvez également faire s [i] = 32 ET bit à bit.

318
00:29:41,090 --> 00:29:46,400
Et bit à bit OU = 32.

319
00:29:46,400 --> 00:29:51,490
En outre, compte mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Alors, n'oubliez pas que - je ne vais pas écrire - n'importe quelle valeur non nulle est vraie, et 0 est faux.

321
00:30:00,900 --> 00:30:07,880
Ainsi, «si nombre de mod 2 == 0" est la même chose que dire "si pas compter mod 2."

322
00:30:07,880 --> 00:30:11,580
J'aurais probablement juste inversé les lignes et a dit, "si le nombre de mod 2,

323
00:30:11,580 --> 00:30:15,350
ne l'OR 1, sinon ne l'ET 1 », de sorte que je n'ai pas besoin du" non ".

324
00:30:15,350 --> 00:30:18,650
Mais cela fonctionne tout aussi bien.

325
00:30:18,650 --> 00:30:25,660
Et qu'est-ce que je peux faire ici?

326
00:30:25,660 --> 00:30:29,060
Vous pouvez les combiner avec ternaire si vous voulez, mais alors que venait de rendre les choses plus désordonné

327
00:30:29,060 --> 00:30:33,770
et sans doute plus difficile à lire, donc nous ne ferons pas cela.

328
00:30:33,770 --> 00:30:37,330
Quelqu'un at-il d'autres suggestions?

329
00:30:37,330 --> 00:30:41,580
Est-ce que tout le problème demandé? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Ainsi se débarrasser de ces lignes vides, maintenant nous allons imprimer f,% s étant celui pour cordes,

331
00:30:51,070 --> 00:30:56,620
Nous imprimons f, s.

332
00:30:56,620 --> 00:30:59,330
Maintenant, nous allons l'exécuter. Ai-je fait quelque chose de mal?

333
00:30:59,330 --> 00:31:03,200
C'est un \ "; Je veux un n.

334
00:31:03,200 --> 00:31:07,840
D'accord. Maintenant, nous allons l'exécuter. Il va probablement me crier dessus.

335
00:31:07,840 --> 00:31:11,250
Strlen est dans string.h.

336
00:31:11,250 --> 00:31:14,290
Donc, c'est la bonne chose à propos Clang est-ce que vous dit ce que c'est dans,

337
00:31:14,290 --> 00:31:19,140
au lieu de GCC qui dit simplement: «Hé, vous avez oublié quelque chose, je ne sais pas ce que c'était."

338
00:31:19,140 --> 00:31:29,220
Mais cela va me dire: «Vous vouliez inclure string.h."

339
00:31:29,220 --> 00:31:32,130
Je n'ai donc pas demander quoi que ce soit, il ne dit rien.

340
00:31:32,130 --> 00:31:42,540
Mais nous ferons leur exemple, «Merci 4 the add".

341
00:31:42,540 --> 00:31:47,880
Cela ressemble à droite. Hourra.

342
00:31:47,880 --> 00:31:52,370
Donc, retour à votre main, je n'ai presque jamais le faire.

343
00:31:52,370 --> 00:31:57,110
Il est facultatif. Et principale est la seule fonction pour laquelle il est facultatif.

344
00:31:57,110 --> 00:32:07,140
Si vous ne retournez pas quelque chose de principal, il est supposé que vous vouliez retourner 0.

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

346
00:32:13,070 --> 00:32:20,980
D'accord. Alors maintenant, le deuxième problème.

347
00:32:20,980 --> 00:32:24,810
"Rappel de conférence seconde 2 semaine que l'échange des valeurs 2 variables» en passant

348
00:32:24,810 --> 00:32:30,780
ces 2 variables dans une fonction (même si elle est appelée swap) n'est pas exactement le travail, du moins pas sans «pointeurs».

349
00:32:30,780 --> 00:32:37,020
Et ignorer pointeurs jusqu'à arriver à eux.

350
00:32:37,020 --> 00:32:40,070
Nous voulons échanger 2 variables; nous ne sommes pas en utilisant une fonction pour le faire.

351
00:32:40,070 --> 00:32:43,410
Nous allons encore le faire en principal comme il est dit.

352
00:32:43,410 --> 00:32:48,360
Mais pour utiliser ces 2 variables, nous ne voulons pas d'utiliser une variable temporaire.

353
00:32:48,360 --> 00:32:50,770
Il ya 2 façons de le faire.

354
00:32:50,770 --> 00:32:56,310
Vous pouvez le faire en utilisant vos opérateurs binaires traditionnelles.

355
00:32:56,310 --> 00:33:00,180
Il en va de quelqu'un connait un moyen rapide et sale de le faire?

356
00:33:00,180 --> 00:33:07,650
Il pourrait en fait prendre une minute de réflexion. Si je dois -

357
00:33:07,650 --> 00:33:12,130
Je vais régler le problème vers le haut comme ce qu'ils demandent. Donc, si j'ai 2 variables A, qui est juste un nombre entier

358
00:33:12,130 --> 00:33:17,800
qu'ils me donnent, et la variable B la somme, ce qui est un autre entier que je me donne.

359
00:33:17,800 --> 00:33:22,700
Donc, si j'ai ces 2 variables, maintenant je veux les échanger.

360
00:33:22,700 --> 00:33:31,550
Le traditionnel, en utilisant vos opérateurs binaires régulières, je veux dire, comme +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Pas opérateurs de bits qui agissent sur binaire.

362
00:33:36,630 --> 00:33:39,600
Donc, en utilisant -, +, ÷, et tous ceux.

363
00:33:39,600 --> 00:33:52,980
Nous pourrions échanger en faisant quelque chose comme a = a + b et b = a - b, a = a - b.

364
00:33:52,980 --> 00:34:04,260
Donc, vérification de cohérence, et puis nous verrons pourquoi cela fonctionne.

365
00:34:04,260 --> 00:34:13,320
Disons que a = 7, b = 3, alors a + b va être 10.

366
00:34:13,320 --> 00:34:18,820
Nous sommes donc en train de mettre a = 10, puis nous faisons b = a - b.

367
00:34:18,820 --> 00:34:30,250
Nous faisons donc b = a - b, qui va être 7 et b = a - b nouveau,

368
00:34:30,250 --> 00:34:38,650
ou a = a - b. Qui va être de 10 - 7, qui est de 3.

369
00:34:38,650 --> 00:34:44,850
Alors maintenant, à juste titre, «a» était de 7, b est de 3, et maintenant b est 7 et «a» est de 3.

370
00:34:44,850 --> 00:34:48,679
Donc, ce genre de logique; «a» est la combinaison des 2 chiffres.

371
00:34:48,679 --> 00:34:53,000
À ce stade, «a» est la combinaison, puis nous soustrayant à l'origine b,

372
00:34:53,000 --> 00:34:56,860
puis nous soustraire à ce qui était l'original «un».

373
00:34:56,860 --> 00:35:01,150
Mais cela ne fonctionne pas pour tous les numéros.

374
00:35:01,150 --> 00:35:08,880
Pour le voir, considérons un système, de sorte que nous pensons habituellement que des entiers 32 bits.

375
00:35:08,880 --> 00:35:13,050
Nous devons travailler sur quelque chose qui n'est que comme 4 bits.

376
00:35:13,050 --> 00:35:15,450
J'espère trouver un bon exemple en ce moment.

377
00:35:15,450 --> 00:35:18,680
Alors, je sais, ce sera facile.

378
00:35:18,680 --> 00:35:26,720
Disons que nos 2 chiffres sont 1111, et 1111, de sorte que nous sommes en binaire en ce moment.

379
00:35:26,720 --> 00:35:34,630
En décimales réelles, si vous voulez penser de cette façon, une. = 15 et b = 15

380
00:35:34,630 --> 00:35:37,630
Et nous nous attendons donc, après que nous les échanger - ils n'ont même pas besoin d'être les mêmes numéros,

381
00:35:37,630 --> 00:35:41,140
mais je l'ai fait de cette façon.

382
00:35:41,140 --> 00:35:47,100
Laissons-les faire pas les mêmes numéros. Faisons 1111 et 0001.

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

384
00:35:51,860 --> 00:35:57,670
Après que nous les échanger, nous nous attendons à 'a' à 1 et b à 15.

385
00:35:57,670 --> 00:36:01,780
Donc, notre première étape consiste a = a + b.

386
00:36:01,780 --> 00:36:08,770
Nos chiffres sont seulement 4 bits de large, donc «une», qui est 1111, + b, qui est 0001,

387
00:36:08,770 --> 00:36:16,780
va finir par être 10000, mais nous n'avons que 4 bits.

388
00:36:16,780 --> 00:36:22,540
Alors maintenant, a = 0.

389
00:36:22,540 --> 00:36:34,080
Et maintenant, nous voulons mettre en b = a - b - en fait, ça fonctionne toujours parfaitement.

390
00:36:34,080 --> 00:36:39,630
a = a - nous allons voir si cela fonctionne parfaitement - b.

391
00:36:39,630 --> 00:36:53,720
Alors b = 0 - 1, ce qui serait encore 15 ans, et alors a = a - b, qui serait 1.

392
00:36:53,720 --> 00:36:56,210
Peut-être que cela ne fonctionne.

393
00:36:56,210 --> 00:36:59,020
J'ai l'impression qu'il ya une raison, il ne fonctionne pas à l'aide régulière.

394
00:36:59,020 --> 00:37:06,400
Ok, donc de l'hypothèse qu'il ne fonctionne pas avec les opérations binaires régulières,

395
00:37:06,400 --> 00:37:15,040
et je chercherai - je vais sur Google pour voir si c'est vrai.

396
00:37:15,040 --> 00:37:23,490
Donc, nous voulons le faire en utilisant les opérateurs binaires, et l'idée ici est XOR.

397
00:37:23,490 --> 00:37:28,780
Ainsi, l'introduction XOR (^) si vous ne l'avez pas encore vu.

398
00:37:28,780 --> 00:37:34,610
C'est, encore une fois, un opérateur de bits de sorte qu'il agit peu à peu, et C'est -

399
00:37:34,610 --> 00:37:39,910
Si vous avez les bits 0 et 1, puis ce sera 1.

400
00:37:39,910 --> 00:37:45,230
Si vous avez les bits 1 et 0, ce sera 1, vous avez les bits 0 et 0 ça va être 0,

401
00:37:45,230 --> 00:37:47,640
et si vous avez les bits 1 et 1, ce sera 0.

402
00:37:47,640 --> 00:37:56,180
Donc, c'est comme OR. Si l'un des bits sont vraies, c'est 1, mais à la différence OU, il ne peut pas être les deux bits qui sont vraies.

403
00:37:56,180 --> 00:37:59,320
OU aurait-il être 1, XOR aurait cet être égal à 0.

404
00:37:59,320 --> 00:38:02,250
Donc, nous allons avoir à utiliser XOR ici.

405
00:38:02,250 --> 00:38:09,960
Pensez-y une minute, je vais à Google.

406
00:38:09,960 --> 00:38:16,230
Eh bien, vous ne pouvez pas lire cela, je suis actuellement sur la page algorithme XOR swap.

407
00:38:16,230 --> 00:38:21,340
J'espère que cela va vous expliquer pourquoi je ne peux pas -

408
00:38:21,340 --> 00:38:34,190
C'est exactement l'algorithme que nous venons de faire.

409
00:38:34,190 --> 00:38:37,330
Je ne vois toujours pas pourquoi - je devais avoir juste pris un mauvais exemple,

410
00:38:37,330 --> 00:38:44,940
mais ce cas où «a» est arrivé à devenir 0, après avoir obtenu de 5 bits, alors maintenant 'a' est 0,

411
00:38:44,940 --> 00:38:48,730
c'est ce que l'on appelle "integer overflow".

412
00:38:48,730 --> 00:38:54,370
Selon Wikipedia, «Contrairement à l'échange XOR, cette variation exige qu'il utilise des méthodes

413
00:38:54,370 --> 00:38:59,780
de garantir que x + y ne provoque pas un dépassement d'entier. "

414
00:38:59,780 --> 00:39:08,350
Donc, cela ne rencontrez des problèmes, ce qui était débordement d'entier, mais je l'ai fait quelque chose de mal.

415
00:39:08,350 --> 00:39:10,520
Je ne suis pas sûr. Je vais essayer de trouver un autre.

416
00:39:10,520 --> 00:39:13,640
[Étudiants] Eh bien, ce n'est pas de dépassement d'entier lorsque vous essayez de mettre un numéro en y

417
00:39:13,640 --> 00:39:16,640
plus grand que le nombre de bits que vous avez alloué?

418
00:39:16,640 --> 00:39:23,730
Ouais. Nous disposons de 4 bits. C'est - nous avons eu 4 bits, nous puis essayez d'ajouter 1 pour l', donc on se retrouve avec 5 bits.

419
00:39:23,730 --> 00:39:26,690
Mais le cinquième bit obtient juste coupé, oui.

420
00:39:26,690 --> 00:39:28,970
Il pourrait en fait -

421
00:39:28,970 --> 00:39:33,010
[Étudiants] Est-ce que vous jeter une erreur, ou est-ce que - ce que cela génère une erreur?

422
00:39:33,010 --> 00:39:40,720
Non Il n'y a donc pas d'erreur. Lorsque vous arrivez au niveau de l'assemblage, un peu spécial

423
00:39:40,720 --> 00:39:47,020
est mis quelque part que dit qu'il y avait un débordement, mais en C, vous sorte de juste ne pas s'en occuper.

424
00:39:47,020 --> 00:39:55,160
En fait, vous ne pouvez pas traiter avec elle sauf si vous utilisez des instructions de montage spécifiques à C.

425
00:39:55,160 --> 00:39:58,110
Pensons échange XOR.

426
00:39:58,110 --> 00:40:02,220
Et je pense que l'article de Wikipédia aurait également pu dire que -

427
00:40:02,220 --> 00:40:07,310
Ainsi, il a également évoqué l'arithmétique modulaire, donc je suppose que j'ai été, en théorie, faire de l'arithmétique modulaire

428
00:40:07,310 --> 00:40:11,160
quand j'ai dit que 0 à 1 est de 15 fois.

429
00:40:11,160 --> 00:40:15,410
Alors que pourrait en fait - sur un processeur régulière qui passe de 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Depuis nous nous retrouvons à 0, nous soustrayons 1, donc il termine tout juste de retour autour de 1111.

431
00:40:20,430 --> 00:40:28,930
Donc cet algorithme pourrait en fait travailler, l'a + b, l'a - b, b - a, c'est peut-être bien.

432
00:40:28,930 --> 00:40:34,030
Mais il ya certains processeurs qui ne font pas cela, et il ne serait pas bien dans les plus spécifiques.

433
00:40:34,030 --> 00:40:39,880
Échange XOR fonctionne sur n'importe quel processeur. D'accord.

434
00:40:39,880 --> 00:40:42,280
L'idée est que c'est censé être le même, cependant.

435
00:40:42,280 --> 00:40:50,120
Où sommes-nous en utilisant XOR en quelque sorte à obtenir l'information à la fois dans 1 des variables,

436
00:40:50,120 --> 00:40:54,120
puis extraire les informations des variables individuelles nouveau.

437
00:40:54,120 --> 00:41:04,330
Il en va de ce que quelqu'un a des idées / la réponse?

438
00:41:04,330 --> 00:41:14,540
[Réponse de l'étudiant, inintelligible]

439
00:41:14,540 --> 00:41:22,220
Donc, cela devrait fonctionner, et aussi, XOR est commutatif.

440
00:41:22,220 --> 00:41:27,620
Quel que soit l'ordre dans lequel ces 2 numéros se trouvent dans là-haut,

441
00:41:27,620 --> 00:41:30,100
ce résultat sera le même.

442
00:41:30,100 --> 00:41:35,800
Donc a ^ b ^ b est un.

443
00:41:35,800 --> 00:41:51,860
Vous pouvez également voir ce écrit comme a ^ = b, b ^ = a, a ^ = b à nouveau.

444
00:41:51,860 --> 00:42:00,200
Donc, cela est juste, et de voir comment cela fonctionne, pense que des bits.

445
00:42:00,200 --> 00:42:10,400
L'utilisation d'un nombre assez petit, disons 11001, et 01100.

446
00:42:10,400 --> 00:42:12,790
C'est donc «a», ce qui est b.

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

448
00:42:15,540 --> 00:42:22,380
Nous allons être mise en 'a' = au XOR de ces 2 choses.

449
00:42:22,380 --> 00:42:32,920
Si une ^ 0 est égal à 1; 1 ^ 1 est égal à 0; 0 ^ 1 est 1, et 0 ^ 0 est égal à 0; 1 ^ 0 est égal à 1.

450
00:42:32,920 --> 00:42:37,380
Ainsi, 'a,' si vous regardez le nombre décimal, il va y avoir -

451
00:42:37,380 --> 00:42:41,160
vous n'allez pas voir grand-chose d'une relation entre l'original «a» et le nouveau 'a,'

452
00:42:41,160 --> 00:42:45,600
mais en regardant les bits, 'a' est maintenant comme un maillage de l'information

453
00:42:45,600 --> 00:42:49,970
à la fois de l'original 'a' et b l'original.

454
00:42:49,970 --> 00:42:57,930
Donc, si nous prenons b ^ a, nous voyons que nous finirons à l'original 'a.'

455
00:42:57,930 --> 00:43:08,910
Et si nous prenons l'original 'a' ^ la nouvelle 'a,' nous voyons nous nous retrouvons à l'origine b.

456
00:43:08,910 --> 00:43:18,380
Donc (a ^ b) = b ^ l'original «un».

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

458
00:43:27,910 --> 00:43:37,010
Il ya - une autre façon de voir cela est XOR quoi que ce soit lui-même est toujours 0.

459
00:43:37,010 --> 00:43:45,020
Donc 1101 ^ 1101, tous les bits vont être les mêmes.

460
00:43:45,020 --> 00:43:47,920
Donc, il ne va jamais être un cas où 1 est un 0 et l'autre est 1.

461
00:43:47,920 --> 00:43:51,080
Donc, c'est 0000.

462
00:43:51,080 --> 00:43:57,240
La même chose avec cela. (A ^ b) ^ b est comme a ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) va être égal à 0, un ^ 0 va tout simplement être «un», puisque tous les bits sont à 0.

464
00:44:03,680 --> 00:44:08,050
Donc, les seuls qui vont être là où «a» était à l'origine un 1 - avait les.

465
00:44:08,050 --> 00:44:12,070
Et la même idée ici, je suis sûr que c'est aussi commutative.

466
00:44:12,070 --> 00:44:17,590
Ouais. J'ai dit avant que c'était commutative.

467
00:44:17,590 --> 00:44:24,680
Le ^ 'a,' et il est associative, alors maintenant (b ^ a) ^ a.

468
00:44:24,680 --> 00:44:28,970
Et nous pouvons faire b ^ (a ^ a).

469
00:44:28,970 --> 00:44:31,540
Et à nouveau, on obtient le b originale.

470
00:44:31,540 --> 00:44:37,120
Ainsi, 'a' est maintenant la combinaison de 'a' et b ensemble.

471
00:44:37,120 --> 00:44:49,660
Grâce à notre nouveau combo 'a' nous disons b = combo 'a' ^ b l'origine, nous obtenons l'original «un».

472
00:44:49,660 --> 00:45:05,170
Et maintenant, un combo = 'a' ^ b la nouvelle, qui était l'original - ou qui est maintenant ce qui était 'a' ou b.

473
00:45:05,170 --> 00:45:13,620
C'est le cas ici. Il s'agit d'= b, b ancienne.

474
00:45:13,620 --> 00:45:16,550
Alors maintenant, tout est rentré dans l'ordre permuté.

475
00:45:16,550 --> 00:45:22,960
Si nous avons effectivement examiné les bits b = a ^ b, va XOR ces 2,

476
00:45:22,960 --> 00:45:33,920
et la réponse va être présent, et alors a = a ^ b est XOR ces 2 et la réponse est la suivante.

477
00:45:33,920 --> 00:45:41,090
Des questions? D'accord. Donc, le dernier est un peu beaucoup plus difficile.

478
00:45:41,090 --> 00:45:43,180
[Étudiants] Je pense qu'il a un doute à ce sujet. >> Oh, désolé.

479
00:45:43,180 --> 00:45:49,380
[Étudiants] Quelle est vraiment le plus rapide? Si vous utilisez cette XOR, ou est-il si vous déclarez une nouvelle variable?

480
00:45:49,380 --> 00:45:55,190
Alors, quel est vraiment le plus rapide, la déclaration d'une nouvelle variable ou en utilisant XOR pour échanger?

481
00:45:55,190 --> 00:45:59,600
La réponse est, selon toute vraisemblance, une variable temporaire.

482
00:45:59,600 --> 00:46:05,780
Et c'est parce qu'une fois qu'il est compilé vers le bas - donc au niveau de l'assemblage,

483
00:46:05,780 --> 00:46:12,320
il n'y a aucune une telle chose comme des variables locales ou des variables temporaires ou tout ce genre de choses.

484
00:46:12,320 --> 00:46:16,060
Ils sont comme - il ya la mémoire, et il existe des registres.

485
00:46:16,060 --> 00:46:20,920
Les registres sont là que les choses sont activement passe.

486
00:46:20,920 --> 00:46:24,750
Vous n'ajoutez pas 2 choses en mémoire, vous ajoutez 2 choses dans les registres.

487
00:46:24,750 --> 00:46:28,160
Et vous apporter des choses à partir de la mémoire dans les registres pour ensuite les ajouter,

488
00:46:28,160 --> 00:46:33,180
et alors vous pourriez les remettre en mémoire, mais toute l'action se passe dans les registres.

489
00:46:33,180 --> 00:46:38,750
Ainsi, lorsque vous utilisez l'approche variable temporaire, le plus souvent ce qui arrive est

490
00:46:38,750 --> 00:46:42,810
ces 2 numéros sont déjà dans les registres.

491
00:46:42,810 --> 00:46:46,570
Et puis, à partir de ce moment, après les avoir échangées,

492
00:46:46,570 --> 00:46:51,540
ça va juste commencer à utiliser l'autre registre.

493
00:46:51,540 --> 00:46:56,510
Partout où vous avait été l'aide de b, il vous reste plus qu'à utiliser le registre qui a été déjà stockage 'un.

494
00:46:56,510 --> 00:47:02,180
Donc, il n'a pas besoin de faire quelque chose de réellement faire le swap. Ouais?

495
00:47:02,180 --> 00:47:05,690
[Étudiants] Mais il faut aussi plus de mémoire, non?

496
00:47:05,690 --> 00:47:10,280
Cela ne prendra que plus de mémoire si elle a besoin de stocker cette variable temporaire.

497
00:47:10,280 --> 00:47:14,830
Comme si plus tard vous utilisez cette variable temporaire à nouveau quelque part,

498
00:47:14,830 --> 00:47:18,920
ensuite - ou que vous affectez quelque chose à cette variable temporaire.

499
00:47:18,920 --> 00:47:24,630
Donc, si à n'importe quel point dans le temps 'a,' b dans temp ont des valeurs distinctes ou quelque chose,

500
00:47:24,630 --> 00:47:30,680
alors il va avoir des endroits distincts dans la mémoire, mais il est vrai que

501
00:47:30,680 --> 00:47:34,800
il ya beaucoup de variables locales qui existent uniquement dans les registres.

502
00:47:34,800 --> 00:47:44,370
Dans ce cas, il n'a jamais mis en mémoire, et ainsi vous n'êtes jamais perdre la mémoire.

503
00:47:44,370 --> 00:47:58,620
D'accord. Une dernière question est un peu plus.

504
00:47:58,620 --> 00:48:04,850
Donc, ici, dans cet appareil CS50, il ya un dictionnaire.

505
00:48:04,850 --> 00:48:12,390
Et la raison en est que [? B66] est un correcteur orthographique où vous devrez écrire

506
00:48:12,390 --> 00:48:15,780
en utilisant les tables de hachage ou tente ou une structure de données.

507
00:48:15,780 --> 00:48:22,660
Vous allez être écrit un correcteur orthographique, et que vous allez utiliser ce dictionnaire pour le faire.

508
00:48:22,660 --> 00:48:28,280
Mais pour ce problème, nous allons nous contenter de regarder pour voir si un mot est dans le dictionnaire.

509
00:48:28,280 --> 00:48:31,250
Donc, au lieu de stocker l'ensemble du dictionnaire dans une structure de données

510
00:48:31,250 --> 00:48:35,180
puis regarder par-dessus un document entier pour voir si quelque chose a mal orthographié,

511
00:48:35,180 --> 00:48:38,490
nous voulons juste trouver 1 mot. Ainsi, nous pouvons simplement numériser sur l'ensemble du dictionnaire

512
00:48:38,490 --> 00:48:44,300
et si nous ne trouvons jamais le mot dans l'ensemble du dictionnaire, il n'était pas là.

513
00:48:44,300 --> 00:48:52,150
Si nous numérisons sur l'ensemble du dictionnaire et je vois le mot, puis nous sommes bons, nous l'avons trouvé.

514
00:48:52,150 --> 00:48:56,580
On dit ici que nous voulons commencer à regarder C de fichiers fonction de gestion,

515
00:48:56,580 --> 00:48:59,930
depuis que nous avons envie de lire le dictionnaire,

516
00:48:59,930 --> 00:49:07,680
mais je vous donne l'astuce ici pour les fonctions auxquelles vous devez penser.

517
00:49:07,680 --> 00:49:11,510
Je vais les écrire sur les espaces.

518
00:49:11,510 --> 00:49:20,490
Ainsi, les principaux que vous aurez envie de regarder à f sont ouverts, puis, inévitablement, f fermé,

519
00:49:20,490 --> 00:49:26,540
qui ira à la fin de votre programme, et f balayage f.

520
00:49:26,540 --> 00:49:31,060
Vous pouvez aussi utiliser f lire, mais vous ne voulez probablement pas à

521
00:49:31,060 --> 00:49:34,200
parce que - vous ne finissent pas par avoir besoin de ça.

522
00:49:34,200 --> 00:49:41,880
F balayage f est ce que vous allez utiliser pour numériser sur le dictionnaire.

523
00:49:41,880 --> 00:49:46,370
Et si vous n'avez pas besoin de coder la solution, juste essayer et comme pseudo-code à votre façon

524
00:49:46,370 --> 00:50:05,200
à une solution, puis nous en discuterons.

525
00:50:05,200 --> 00:50:14,110
Et en fait, depuis que je vous ai déjà donné ceux-ci, si vous allez dans n'importe quel terminal ou shell de votre appareil,

526
00:50:14,110 --> 00:50:18,250
Je voudrais - J'ai l'habitude - si vous n'avez pas encore vu, je ne sais pas si vous l'avez fait en classe,

527
00:50:18,250 --> 00:50:23,490
mais l'homme, de sorte que les pages de manuel, sont très utiles pour regarder à peu près n'importe quelle fonction.

528
00:50:23,490 --> 00:50:27,330
Donc, je peux faire, comme, f homme, balayage f.

529
00:50:27,330 --> 00:50:32,300
C'est aujourd'hui le plus sur la famille de fonctions f balayage.

530
00:50:32,300 --> 00:50:37,070
Je pourrais aussi faire f homme, ouvert, et que vous me donner les détails de cette.

531
00:50:37,070 --> 00:50:40,750
Donc, si vous savez quelle est la fonction que vous utilisez, ou que vous lisez le code

532
00:50:40,750 --> 00:50:43,000
et vous voyez une fonction et vous êtes comme, "Qu'est ce que cela fait?"

533
00:50:43,000 --> 00:50:45,280
Tout nom de la fonction que l'homme.

534
00:50:45,280 --> 00:50:47,340
Il ya quelques exemples bizarres où vous pourriez avoir à dire

535
00:50:47,340 --> 00:50:51,620
le souhaitez. man 2 que le nom de la fonction ou le man 3 que le nom de la fonction,

536
00:50:51,620 --> 00:50:58,230
mais vous n'avez qu'à faire ce nom si la fonction homme n'arrive pas à travailler la première fois.

537
00:50:58,230 --> 00:51:03,010
[Étudiants] Donc je lis la page de manuel ouvert, mais je suis encore confus sur la façon de l'utiliser et le programme.

538
00:51:03,010 --> 00:51:06,170
D'accord. Un grand nombre de pages de manuel sont moins utiles.

539
00:51:06,170 --> 00:51:08,470
Ils sont plus utiles si vous savez déjà ce qu'ils font

540
00:51:08,470 --> 00:51:12,670
et puis vous avez juste besoin de se rappeler l'ordre des arguments ou quelque chose.

541
00:51:12,670 --> 00:51:17,640
Ou ils peuvent vous donner un aperçu général, mais certains d'entre eux sont très accablante.

542
00:51:17,640 --> 00:51:22,220
Comme f f scan, aussi. Il vous donne des informations pour l'ensemble de ces fonctions,

543
00:51:22,220 --> 00:51:28,120
et 1 ligne vers le bas qui se passe ici pour dire, "F balayage f lit à partir du point de corde ou d'un ruisseau."

544
00:51:28,120 --> 00:51:32,360
Mais f ouvrir. Alors, comment pourrions-nous utiliser f ouverte?

545
00:51:32,360 --> 00:51:38,470
L'idée d'un programme qui a besoin de faire le fichier I / O est que

546
00:51:38,470 --> 00:51:45,070
vous devez d'abord ouvrir le fichier que vous souhaitez faire des choses avec, et inévitablement,

547
00:51:45,070 --> 00:51:51,220
lire des choses de ce fichier et faire des choses avec eux.

548
00:51:51,220 --> 00:51:55,350
F ouvert ce que nous utilisons pour ouvrir le fichier.

549
00:51:55,350 --> 00:52:04,190
La chose nous revenons, si ce fichier que nous voulons ouvrir, il nous donne la -

550
00:52:04,190 --> 00:52:11,970
ici il est écrit "/ user / share / dict / words."

551
00:52:11,970 --> 00:52:16,740
C'est le fichier que nous voulons ouvrir, et nous voulons l'ouvrir -

552
00:52:16,740 --> 00:52:21,440
nous devons spécifier explicitement si nous voulons l'ouvrir pour lire ou si l'on veut l'ouvrir pour écrire.

553
00:52:21,440 --> 00:52:26,490
Il ya un couple de combinaisons et tout ça, mais nous voulons ouvrir ce pour la lecture.

554
00:52:26,490 --> 00:52:29,380
Nous voulons lire à partir du fichier.

555
00:52:29,380 --> 00:52:34,290
Alors qu'est-ce que ce retour? Elle retourne un fichier (*) étoile,

556
00:52:34,290 --> 00:52:37,260
et je vais juste vous montrer tout dans la variable f, de sorte *,

557
00:52:37,260 --> 00:52:40,840
encore une fois, c'est un pointeur, mais nous ne voulons pas faire face à des pointeurs.

558
00:52:40,840 --> 00:52:46,470
Vous pouvez penser que f, f est la variable que vous allez utiliser pour représenter le fichier.

559
00:52:46,470 --> 00:52:49,850
Donc, si vous voulez lire à partir du fichier, vous lisez à partir de f.

560
00:52:49,850 --> 00:52:54,820
Si vous voulez fermer le fichier, vous fermez f.

561
00:52:54,820 --> 00:53:00,350
Ainsi, à la fin du programme lorsque nous avons inévitablement à fermer le fichier, que devons-nous faire?

562
00:53:00,350 --> 00:53:06,750
Nous voulons combler f.

563
00:53:06,750 --> 00:53:12,600
Alors maintenant, la fonction du dernier fichier que nous allons avoir à utiliser est le balayage f, f f balayage.

564
00:53:12,600 --> 00:53:20,930
Et qu'est-ce qui ne se fait-il balaye le fichier à la recherche d'un modèle assorti.

565
00:53:20,930 --> 00:53:39,100
En regardant la page de manuel ici, nous voyons int f f balayage, ignorer la valeur de retour pour le moment.

566
00:53:39,100 --> 00:53:45,230
Le premier argument est le flux de fichier *, de sorte que le premier argument que nous allons vouloir passer est f.

567
00:53:45,230 --> 00:53:47,900
Nous scannons sur f.

568
00:53:47,900 --> 00:53:53,680
Le second argument est une chaîne de format.

569
00:53:53,680 --> 00:53:58,310
Je vais vous donner une chaîne de format pour le moment.

570
00:53:58,310 --> 00:54:05,180
Je pense que nous arrive de dire, 127S \ n, beaucoup de ce que c'est inutile.

571
00:54:05,180 --> 00:54:12,490
L'idée de ce que la chaîne de format est, est que vous pouvez penser f balayage comme l'opposé de f d'impression.

572
00:54:12,490 --> 00:54:17,160
F impression Donc, f d'impression, nous utilisons également ce type de paramètre format,

573
00:54:17,160 --> 00:54:25,000
mais f impression que nous faisons est - Voyons un équivalent.

574
00:54:25,000 --> 00:54:32,550
Donc imprimer f, et il ya en fait également impression f f, où le premier argument va être f.

575
00:54:32,550 --> 00:54:40,980
Lorsque vous imprimez f, on pourrait dire quelque chose comme, "print 127S \ n" et si nous lui passer une chaîne de caractères,

576
00:54:40,980 --> 00:54:44,050
ça va pour imprimer cette chaîne, puis une nouvelle ligne.

577
00:54:44,050 --> 00:54:49,690
127, ce qui, je suis sûr, mais je ne me suis jamais limité à l',

578
00:54:49,690 --> 00:54:52,470
Vous n'auriez même pas besoin de dire '127 'dans la f impression,

579
00:54:52,470 --> 00:54:57,090
mais ce que cela signifie, c'est d'imprimer les 127 premiers caractères.

580
00:54:57,090 --> 00:54:59,350
Donc, je suis à peu près sûr que c'est le cas. Vous pouvez Google pour cela.

581
00:54:59,350 --> 00:55:03,000
Mais dans le prochain je suis presque positif, cela signifie que.

582
00:55:03,000 --> 00:55:08,880
Il s'agit donc d'imprimer les 127 premiers caractères, suivi d'une nouvelle ligne.

583
00:55:08,880 --> 00:55:14,680
F balayage f maintenant, au lieu de regarder une variable et l'impression,

584
00:55:14,680 --> 00:55:22,620
il va regarder une chaîne et enregistrer le modèle dans la variable.

585
00:55:22,620 --> 00:55:26,360
Nous allons utiliser effectivement f balayage dans un autre exemple.

586
00:55:26,360 --> 00:55:31,670
Donc, disons que nous avons eu quelques int, x = 4,

587
00:55:31,670 --> 00:55:41,110
et nous avons voulu créer une chaîne faite de - a voulu créer la chaîne

588
00:55:41,110 --> 00:55:44,250
qui était comme, cela viendra beaucoup plus tard,

589
00:55:44,250 --> 00:55:49,020
quelque chose qui est juste comme 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Donc, cela pourrait être un programme où vous aurez totalisateur,

591
00:55:51,870 --> 00:55:56,420
Bref i contrer, et que vous souhaitez enregistrer une série d'images.

592
00:55:56,420 --> 00:56:02,430
Donc, vous voulez sauver I.jpg, où i est une itération de la boucle.

593
00:56:02,430 --> 00:56:05,500
Alors, comment pouvons-nous faire pour que cette chaîne JPEG?

594
00:56:05,500 --> 00:56:11,720
Si vous voulez imprimer 4.jpg, nous pourrions simplement dire f d'impression, d.jpg%,

595
00:56:11,720 --> 00:56:14,410
et alors il serait imprimer pour que JPEG.

596
00:56:14,410 --> 00:56:20,050
Mais si nous voulons sauver la 4.jpg chaîne, nous utilisons f balayage.

597
00:56:20,050 --> 00:56:30,860
Ainsi, la chaîne s - en fait, nous ne peux pas - caractère, char s, allons-y 100.

598
00:56:30,860 --> 00:56:35,400
Donc je vient de déclarer certains tableau de 100 caractères,

599
00:56:35,400 --> 00:56:39,830
et c'est ce que nous allons inévitablement à stocker que JPEG po

600
00:56:39,830 --> 00:56:47,920
Donc, nous allons utiliser f numérisation et le format, la façon dont nous dirions d.jpg%

601
00:56:47,920 --> 00:56:54,980
afin d'imprimer 4.jpg, le format de ce qui se passe à d.jpg%.

602
00:56:54,980 --> 00:57:04,020
Ainsi, le format est d.jpg%, ce que nous voulons remplacer avec% d est x,

603
00:57:04,020 --> 00:57:06,590
et maintenant nous avons besoin de stocker cette chaîne quelque part.

604
00:57:06,590 --> 00:57:12,500
Et où nous allons stocker cette chaîne figure dans la chaîne s.

605
00:57:12,500 --> 00:57:21,640
Donc, après cette ligne de code, s, si nous imprimons% s f, de la variable s,

606
00:57:21,640 --> 00:57:26,280
il va imprimer 4.jpg.

607
00:57:26,280 --> 00:57:38,930
Donc f f balayage est la même que la numérisation f, sauf que maintenant c'est regarder par-dessus ce fichier

608
00:57:38,930 --> 00:57:43,600
pour quoi stocker à l'art.

609
00:57:43,600 --> 00:57:46,160
C'est ce dernier argument va être.

610
00:57:46,160 --> 00:57:54,170
Nous voulons stocker - «famille f Analyse des scans des fonctions à la fois en fonction du format que ci-dessous essayé.

611
00:57:54,170 --> 00:58:02,450
Si tout est stocké dans les points de localisation que vous pourriez retourner - "

612
00:58:02,450 --> 00:58:12,910
Non, nous pourrions être bon. Laissez-moi réfléchir une seconde.

613
00:58:12,910 --> 00:58:26,350
Donc balayage f ne fonctionne pas - ce que le diable est la fonction qui fait ça?

614
00:58:26,350 --> 00:58:31,650
Donc balayage f ne va pas prendre un entier et ne point jpg.

615
00:58:31,650 --> 00:58:43,490
Il va [marmonne].

616
00:58:43,490 --> 00:58:49,360
Enregistrer variable de type int en string int C.

617
00:58:49,360 --> 00:58:55,940
Qu'est-ce que cette variable, ou ce qui est appelé cette fonction?

618
00:58:55,940 --> 00:59:04,950
Oui. C'est - oui. Donc, ce que je vous définir avant impression était s f,

619
00:59:04,950 --> 00:59:09,820
qui - qui est beaucoup plus logique, pourquoi j'ai dit que c'était beaucoup plus comme f d'impression.

620
00:59:09,820 --> 00:59:14,700
Balayage f est toujours un peu comme f d'impression, mais f print s va le numériser sur

621
00:59:14,700 --> 00:59:17,510
et remplacez les variables et maintenant le stocker dans une chaîne.

622
00:59:17,510 --> 00:59:19,620
Au lieu de l'imprimer, il le stocke dans une chaîne.

623
00:59:19,620 --> 00:59:25,070
Donc ignorer complètement. Vous pouvez toujours penser que le spécificateur de format comme celui de f d'impression.

624
00:59:25,070 --> 00:59:34,510
Alors maintenant, si nous voulions faire la chose 4.jpg, nous ferions f print s, x de cela.

625
00:59:34,510 --> 00:59:38,520
Alors qu'est-ce balayage f fait - ce qui était votre question va être?

626
00:59:38,520 --> 00:59:40,820
[Étudiants] Je suis tout confus sur ce que nous essayons de faire ici

627
00:59:40,820 --> 00:59:43,450
avec cette JPEG. Pouvez-vous expliquer cette époque 1 plus?

628
00:59:43,450 --> 00:59:52,710
Donc, ce fut - il est moins pertinents aux f f scan maintenant, je l'espère, il sera attacher en arrière en quelque sorte de façon.

629
00:59:52,710 --> 01:00:02,240
Mais ce que j'ai d'abord été l'intention de montrer était - il s'agit en fait directement liées à ces [? F5]

630
01:00:02,240 --> 01:00:08,520
Vous allez utiliser f print s, où, disons que nous avons 100 images,

631
01:00:08,520 --> 01:00:13,630
et que vous voulez lire l'image 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Ainsi, afin de faire cela, vous avez besoin de f ouverte, puis vous devez passer à la chaîne que vous souhaitez ouvrir.

633
01:00:21,520 --> 01:00:30,020
Donc, nous voulons ouvrir 1.jpg; afin de créer la chaîne qui est 1.jpg,

634
01:00:30,020 --> 01:00:37,660
f impression que nous faisons de s% d.jpg--nous n'avons pas fait pour int i = 0.

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

636
01:00:46,580 --> 01:00:51,130
Donc f% s d.jpg impression de i.

637
01:00:51,130 --> 01:00:56,320
Donc, après cette ligne, maintenant la variable ou la chaîne s va 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Ou, 0.jpg, 1.jpg, 2.jpg. Et afin que nous puissions ouvrir, à son tour, chaque image pour la lecture.

639
01:01:10,610 --> 01:01:19,550
Donc, c'est ce que l imprimer f le fait. Voyez-vous ce que l'art d'imprimer f est en train de faire?

640
01:01:19,550 --> 01:01:25,720
[Étudiants] Bon, alors ça prend - elle crée une chaîne de caractères, something.jpg, puis il stocke.

641
01:01:25,720 --> 01:01:30,360
Oui. Il crée - c'est une autre chaîne de format, tout comme f numérisation et d'impression f,

642
01:01:30,360 --> 01:01:37,530
où il insère toutes les variables dans le second argument, peut-être s au lieu de i.

643
01:01:37,530 --> 01:01:42,280
Peut-être - je veux dire, c'est le cas. Mais quel que soit l'ordre des arguments est.

644
01:01:42,280 --> 01:01:45,440
Il va insérer toutes les variables dans la chaîne de format

645
01:01:45,440 --> 01:01:52,250
et ensuite le stocker dans notre mémoire tampon; nous appelons cela un tampon, c'est là que nous stockons la chaîne.

646
01:01:52,250 --> 01:02:00,750
Donc, nous gardons à l'intérieur de la chaîne s correctement formaté, d% ayant été remplacé par 4.

647
01:02:00,750 --> 01:02:08,080
[Étudiants] Donc, si nous le faisions, est la variable f tout va être réaffecté?

648
01:02:08,080 --> 01:02:18,110
Oui. Donc, nous devrions fermer la f d'origine avant de le faire.

649
01:02:18,110 --> 01:02:22,810
Mais - et puis aussi, s'il n'y avait pas une f ouvrir ici, nous aurions besoin de le dire -

650
01:02:22,810 --> 01:02:29,280
Ouais. Mais ce serait ouvrir une centaine de dossiers différents.

651
01:02:29,280 --> 01:02:37,360
[Étudiants] Mais nous ne serions pas en mesure d'accéder ou - d'accord.

652
01:02:37,360 --> 01:02:44,230
D'accord. Donc balayage f, f f balayage, est en quelque sorte de la même idée,

653
01:02:44,230 --> 01:02:53,610
mais au lieu d', au lieu de le stocker dans une chaîne, c'est plus comme vous êtes maintenant

654
01:02:53,610 --> 01:03:02,420
exploitation sur une piqûre et pattern matching contre cette chaîne et stocker les résultats dans des variables.

655
01:03:02,420 --> 01:03:11,290
Vous pouvez utiliser f scan pour analyser plus quelque chose comme 4.jpg et stocker l'entier 4 x int en somme.

656
01:03:11,290 --> 01:03:13,430
C'est ce que nous pouvons utiliser pour f balayage.

657
01:03:13,430 --> 01:03:16,300
F f scan va le faire à la ligne de commande.

658
01:03:16,300 --> 01:03:19,200
En fait je suis sûr que c'est ce que la bibliothèque ne CS50.

659
01:03:19,200 --> 01:03:29,050
Donc, quand vous dites: "get int,« c'est de balayage f-ment plus - f scan est la façon dont vous obtenez une entrée utilisateur.

660
01:03:29,050 --> 01:03:34,670
F f scan va faire la même chose mais en utilisant un fichier à numériser sur.

661
01:03:34,670 --> 01:03:41,090
Donc, ici, nous sommes le balayage sur ce fichier.

662
01:03:41,090 --> 01:03:45,460
Le modèle que nous essayons de faire correspondre une certaine chaîne de caractères qui est de 127 caractères

663
01:03:45,460 --> 01:03:48,100
suivie d'une nouvelle ligne

664
01:03:48,100 --> 01:03:54,770
Donc, je suis sûr que nous pourrions même dire simplement "s égaler", puisque dans le dictionnaire

665
01:03:54,770 --> 01:03:57,770
nous avons la chance d'avoir, nous garantis pas un mot, c'est que depuis longtemps,

666
01:03:57,770 --> 01:04:03,310
et aussi f f scan, je pense, va s'arrêter à la nouvelle ligne, peu importe quoi.

667
01:04:03,310 --> 01:04:06,970
Mais nous allons inclure la nouvelle ligne dans le match, et -

668
01:04:06,970 --> 01:04:13,960
[Étudiants] Si nous n'avons pas inclus la nouvelle ligne, ne serait-il trouver des pièces d'un mot?

669
01:04:13,960 --> 01:04:22,900
Il - chacun - en regardant le dictionnaire -

670
01:04:22,900 --> 01:04:26,200
Ainsi, dans le dictionnaire, ce sont toutes nos paroles.

671
01:04:26,200 --> 01:04:30,500
Chacun est sur une nouvelle ligne.

672
01:04:30,500 --> 01:04:32,510
Le balayage f va ramasser ce mot.

673
01:04:32,510 --> 01:04:38,750
Si nous ne comprennent pas la nouvelle ligne, alors il est possible que le balayage f prochaine viens de lire la nouvelle ligne.

674
01:04:38,750 --> 01:04:44,180
Mais en incluant la nouvelle ligne, puis sera simplement ignorer la nouvelle ligne.

675
01:04:44,180 --> 01:04:49,440
Mais nous ne sortirons jamais partie d'un mot, puisque nous sommes toujours à la lecture à une nouvelle ligne, peu importe quoi.

676
01:04:49,440 --> 01:04:54,530
[Étudiants] Mais que faire si vous recherchez le mot "CISSA», comme CISSA.

677
01:04:54,530 --> 01:04:57,380
Est-il trouver cela, et dire que c'est un match?

678
01:04:57,380 --> 01:05:05,110
Nous voilà donc - il va lire dans - c'est réellement un bon point.

679
01:05:05,110 --> 01:05:10,660
Nous ne sommes jamais à l'aide du courant - le mot que nous voulons, c'est l'argument première commande en ligne.

680
01:05:10,660 --> 01:05:16,460
Alors chaîne, mot = argv 1.

681
01:05:16,460 --> 01:05:20,020
Ainsi, la chaîne que nous voulons, c'est argv 1.

682
01:05:20,020 --> 01:05:23,290
Nous ne sommes pas à la recherche d'un mot à tous dans notre analyse f.

683
01:05:23,290 --> 01:05:28,030
Ce que nous faisions avec le balayage f devient chaque mot dans le dictionnaire,

684
01:05:28,030 --> 01:05:34,320
et puis une fois que nous avons ce mot nous allons utiliser strcmp pour les comparer.

685
01:05:34,320 --> 01:05:39,210
Nous allons comparer notre mot et ce que nous venons de lire po

686
01:05:39,210 --> 01:05:45,110
Alors forcément, nous allons finir par faire un tas de balayage fs

687
01:05:45,110 --> 01:05:52,130
jusqu'à ce qu'il se trouve que f scan sera de retour -

688
01:05:52,130 --> 01:05:54,800
il sera de retour un, tant qu'il n'a égalé un nouveau mot,

689
01:05:54,800 --> 01:06:01,360
et il reviendra à autre chose dès qu'il a omis de faire correspondre le mot.

690
01:06:01,360 --> 01:06:08,440
Nous lisons sur l'ensemble du dictionnaire, le stockage, ligne par ligne chaque mot en la variable s.

691
01:06:08,440 --> 01:06:17,240
Ensuite, nous comparons mot avec s, et si la comparaison == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp arrive à mettre 0 si une correspondance a été établie.

693
01:06:21,650 --> 01:06:31,510
Donc, si il était de 0, alors nous pouvons imprimer f, assorti,

694
01:06:31,510 --> 01:06:35,370
ou un mot dans le dictionnaire est, ou ce que vous souhaitez imprimer f.

695
01:06:35,370 --> 01:06:41,450
Et puis - nous ne voulons pas fermer à f maintes et maintes fois.

696
01:06:41,450 --> 01:06:50,410
C'est le genre de chose que nous voulons faire, et nous ne cherchons pas uniquement pour mot dans le dictionnaire.

697
01:06:50,410 --> 01:06:56,660
Donc, nous pourrions le faire, si nous voulions chercher leur modèle, CISSA, comme vous l'avez dit,

698
01:06:56,660 --> 01:07:00,260
si nous voulions regarder pour ce motif, il ne permettrait pas, dans le cas

699
01:07:00,260 --> 01:07:08,010
car ce n'est pas réellement un mot, mais l'un des mots du dictionnaire qui se trouve à avoir en elle.

700
01:07:08,010 --> 01:07:13,560
Donc, il correspondrait à ce mot, mais ce sous-ensemble de ce mot n'est pas un mot lui-même.

701
01:07:13,560 --> 01:07:17,250
Mais ce n'est pas la façon dont nous l'utilisons; nous lisons dans chaque mot

702
01:07:17,250 --> 01:07:19,740
et en comparant ensuite le mot que nous avons avec ce mot.

703
01:07:19,740 --> 01:07:25,780
Donc, nous sommes toujours à la comparaison des mots pleins.

704
01:07:25,780 --> 01:07:29,620
Je peux envoyer les solutions finalisées plus tard.

705
01:07:29,620 --> 01:07:32,050
C'est une sorte de près la bonne réponse, je pense.

706
01:07:32,050 --> 01:07:34,720
[Commentaire étudiants, inintelligible]

707
01:07:34,720 --> 01:07:40,870
Oh, ai-je me débarrasser de ça avant? Char s, je pense que nous avons dit 127 - J'ai oublié ce que le plus grand est.

708
01:07:40,870 --> 01:07:44,100
Nous allons juste faire 128; donc maintenant l'art est assez long.

709
01:07:44,100 --> 01:07:46,570
Nous n'avons pas besoin d'imprimer quoi que ce soit.

710
01:07:46,570 --> 01:07:56,440
Nous allons aussi envie d'avoir à fermer notre dossier, et cela devrait être sur la bonne réponse.

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