1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] セクションの問題セット2：ハッカー版

2
00:00:02,670 --> 00:00:04,910
ロブボーデン、ハーバード大学

3
00:00:04,910 --> 00:00:07,410
これはCS50です。 CS50.TV

4
00:00:07,410 --> 00:00:15,770
だから、私はロブだ。私はカークランドの先輩だ。これはCS50をTFing 3年目です。

5
00:00:15,770 --> 00:00:22,220
それは、我々は伝統的な講義形式のセクションから変化しているのは初めてのことである

6
00:00:22,220 --> 00:00:25,610
講義の中で起こった、その後皆さんが質問を何件どこ我々はちょうど一種、

7
00:00:25,610 --> 00:00:32,250
今我々は空白を使ってどこで、より多くの問題がベースであることに、そして - 

8
00:00:32,250 --> 00:00:37,410
ああ、だからアイデアは私が送ったそのリンクへ行くことであると、あなたは私のスペースになるでしょう。

9
00:00:37,410 --> 00:00:42,410
誰もがラップトップを持っていないのですか？オーケー。

10
00:00:42,410 --> 00:00:47,050
だから我々はこれを使用することになるだろう、と我々はセクションに住んで問題をやっているつもりだ

11
00:00:47,050 --> 00:00:50,740
そしてそれらの議論と何が悪いかを考え出す

12
00:00:50,740 --> 00:00:56,390
と私はあなたのコードの一部を引き上げるかもしれない、と私はあなたのアイデアを議論することがあります。

13
00:00:56,390 --> 00:01:02,140
だから誰も苦労しました？

14
00:01:02,140 --> 00:01:07,000
あなたが側にチャットすることができ、我々はそれには理由があるでしょうかどうかは分からない。

15
00:01:07,000 --> 00:01:12,270
あなたは、そのクラスにいた場合、今、前のスーパーセクションと同様に、あなたはそれが約何を知っています。

16
00:01:12,270 --> 00:01:19,200
Pのすべての上では、これらのセクションがあるように起こっているのが設定されます。

17
00:01:19,200 --> 00:01:22,550
だからP-SET 2、仕様は、私はあなたが既にP-SET 1でそれを見たと思います。

18
00:01:22,550 --> 00:01:27,400
しかし、我々は我々が今日上に行くことになるだろう何のために、P-2セットを見ることができます。

19
00:01:27,400 --> 00:01:29,460
そして、あなたが質問のセクションが表示されます。

20
00:01:29,460 --> 00:01:37,530
だから、これは、P-セットのすべてになります。質問のセクションがあるだろう。

21
00:01:37,530 --> 00:01:41,340
これまでのところ、我々は "この練習する機会を検討してください。"と言ってきた

22
00:01:41,340 --> 00:01:44,940
あなたは、このプログラムを提出するよう求められることはありません。

23
00:01:44,940 --> 00:01:48,480
アイデアは、これらの種類のあなたが問題セットを使い始めるための助けになっているということです。

24
00:01:48,480 --> 00:01:53,220
私はハッカー版に推測、それらの多くは、単に学ぶために新しい、面白いものであることになっている。

25
00:01:53,220 --> 00:01:58,590
彼らは、問題セットに直接適用できない場合があります。

26
00:01:58,590 --> 00:02:01,810
そして今、我々はあなたがそれらを送信することが、理論的にはしていない、

27
00:02:01,810 --> 00:02:07,480
後で問題セットのために、あなたはそれらを提出する可能性があり、その結果、あなたはどちらのセクションに来ることができる

28
00:02:07,480 --> 00:02:10,380
または答えを得るためにセクションを見たり、あなたは自分自身でそれらを得ることができます

29
00:02:10,380 --> 00:02:16,350
あなたは私の存在感を楽しんでように感じていない場合。

30
00:02:16,350 --> 00:02:21,010
だから - 私は、これが最初のものであると思います。

31
00:02:21,010 --> 00:02:29,280
ああ。あなたも、質問のこれらのセクションの下に我々はまた、ショートパンツについての質問をしました。

32
00:02:29,280 --> 00:02:33,440
だから、私が推測する、理論的には、節に来る前に、これらを鑑賞することになっている

33
00:02:33,440 --> 00:02:38,550
そうしない場合、それは大丈夫です、我々はとにかくそれらをチェックするでしょう。

34
00:02:38,550 --> 00:02:42,590
だから我々はこれらを起動することができます： "どのようにwhileループはdo-whil​​eループとはどう違うのですか？

35
00:02:42,590 --> 00:02:46,210
とき、後者は特に便利ですか？ "

36
00:02:46,210 --> 00:02:49,390
だから誰もが何かを持っている - ？

37
00:02:49,390 --> 00:02:52,730
[学生] do-whil​​eループは常に少なくとも一度は実行されます。

38
00:02:52,730 --> 00:03:02,950
はい。だから、その差である。 whileループ -  I'llはちょうどここでそれを行う - ループしながら、我々は条件があります

39
00:03:02,950 --> 00:03:19,760
我々がここで降りるまで、右ここでは、do-whil​​eのに対し、条件を持っていない。

40
00:03:19,760 --> 00:03:24,130
だから、あなたのプログラムが実行、そしてそれは、whileループに到達したときに、

41
00:03:24,130 --> 00:03:26,380
この条件が真であれば、それはすぐにチェックします。

42
00:03:26,380 --> 00:03:30,710
その条件が真でない場合、それだけで完全にループを飛ばします。

43
00:03:30,710 --> 00:03:34,390
do-whil​​eループプログラムが実行されると、それは "何"になる

44
00:03:34,390 --> 00:03:37,920
何もこの時点では起こりません、単に実行を継続します。

45
00:03:37,920 --> 00:03:42,690
条件が真の場合、それが当たったときに "しばらく"は、ループバックがありますし、再びそれを行う

46
00:03:42,690 --> 00:03:46,730
と何度も何度も条件が真でないし、ただ通って落ちるまで。

47
00:03:46,730 --> 00:03:50,600
だから、違いは、これは非常に最初からスキップできること、である。

48
00:03:50,600 --> 00:03:56,770
これは、必ずしも一度だけ実行され、条件がまだ本当であるなら複数回実行してもよい。

49
00:03:56,770 --> 00:04:03,720
whileループは一度だけそれを行うことができるようになるので、または -  whileループ - 我々は、すべてでそれを行う必要はありません

50
00:04:03,720 --> 00:04:07,900
条件がfalseの場合は、できるだけ早く我々はそれに着いて以来、我々はそれの上で右をスキップします。

51
00:04:07,900 --> 00:04:11,770
do-whil​​eループのに対し、我々は必ずしも、それを1回実行します。

52
00:04:11,770 --> 00:04:14,560
それがtrueまたはfalseの場合、我々は条件に到達したとき、我々は確認してください。

53
00:04:14,560 --> 00:04:19,790
それが本当なら、我々は再びそれをやる、それがfalseであれば、私たちはちょうど行く続けるつもりです。

54
00:04:19,790 --> 00:04:24,680
だからとき、後者は特に役立ちましたか？

55
00:04:24,680 --> 00:04:31,190
だから私は、その4年間の全体を、3年間で、何でも、言うことができます

56
00:04:31,190 --> 00:04:38,780
私はプログラミングをしてきたことに、私は10回で、好きで、これを使用している。

57
00:04:38,780 --> 00:04:43,140
我々はdo-whil​​eループを導入しているときに、おそらくそれらの5 CS50にある。

58
00:04:43,140 --> 00:04:47,510
だから、これは、do-whil​​eループをするときに使用しますか？

59
00:04:47,510 --> 00:04:49,510
いつです - ええ？

60
00:04:49,510 --> 00:04:53,180
[学生]とき、あなたがチェックしたいユーザー入力、または何かを取得しようとしている - 

61
00:04:53,180 --> 00:04:59,700
うん。だからこれは、do-whil​​e、ユーザー入力の大きな一つであるループ。

62
00:04:59,700 --> 00:05:03,160
なぜ最初のカップルの問題セットでそれは、あなたが好きで、ユーザーに質問したいときには、だ

63
00:05:03,160 --> 00:05:08,520
あなたは、その文字列を取得するまで、 "私に文字列を与えて、"あなたは続行できません。

64
00:05:08,520 --> 00:05:12,980
そしてあなたは、必然的に、少なくとも一度文字列を求める必要がある。

65
00:05:12,980 --> 00:05:16,950
しかし、彼らは何か悪いことを答えた場合、その後、あなたは戻ってループする必要があると再び尋ねる。

66
00:05:16,950 --> 00:05:20,810
しかし、ユーザー入力以外の、それは私が事件に遭遇したことは非常に稀だ

67
00:05:20,810 --> 00:05:27,170
私は、 "1回以上"ループにしたいが、多分もっとある。

68
00:05:27,170 --> 00:05:33,370
質問や - ？誰もがdo-whil​​eループ、他の場所で使用していますか？

69
00:05:33,370 --> 00:05:36,780
オーケー。だから次は、未宣言の識別子は何 "です

70
00:05:36,780 --> 00:05:43,310
ガチャンという音が出力した場合、通常示す？ "

71
00:05:43,310 --> 00:05:47,380
だから、どのようなコードの私が取得する書き込みでした "宣言されていない識別子ですか？ '

72
00:05:47,380 --> 00:05:49,550
[学生]は、x = 2？

73
00:05:49,550 --> 00:05:52,650
だから我々はちょうどここでそれを試すことができ、x = 2である。

74
00:05:52,650 --> 00:06:04,830
我々はこれを実行することになるでしょう - ああ、私はそれをクリックしなかった。そこでここでは、取得する - すべての権利。

75
00:06:04,830 --> 00:06:07,100
"宣言されていない識別子xの使用。"

76
00:06:07,100 --> 00:06:11,610
だからそれは、未宣言の識別子は、変数です。

77
00:06:11,610 --> 00:06:13,910
それは頻繁に変数識別子と呼ぶことにします。

78
00:06:13,910 --> 00:06:17,300
だから、それが実際に変数の知らないかもしれない、それはそれが何であるかを知りません。

79
00:06:17,300 --> 00:06:19,380
だからそれは識別子です。

80
00:06:19,380 --> 00:06:26,060
では、なぜそれが宣言されていないか？うん。

81
00:06:26,060 --> 00:06:32,190
だから用語、変数の宣言に明確にすること

82
00:06:32,190 --> 00:06:37,360
あなたは "int型のx、"または "文字列yを、"何でも言うときです。

83
00:06:37,360 --> 00:06:41,910
変数の初期化、または変数の代入、

84
00:06:41,910 --> 00:06:44,510
あなたが言うたびに、 "X = 2"である。

85
00:06:44,510 --> 00:06:52,950
だから我々は別々のステップでこれらを行うことができますが、int型のx、x = 2、までは - 私たちはここで何かの束を持つことができます - 

86
00:06:52,950 --> 00:07:00,350
しかし、この行が発生するまで、xがまだ初期化されていますが、それが宣言されています。

87
00:07:00,350 --> 00:07:06,760
それで、我々は明らかに1行でそれを行うことができます、そして、今、私たちは宣言および初期化されています。

88
00:07:06,760 --> 00:07:10,730
質問はありますか？

89
00:07:10,730 --> 00:07:18,390
そして最後に、 "なぜ、シーザー暗号は非常に安全ではないですか？"

90
00:07:18,390 --> 00:07:23,830
だから最初は、誰でも、シーザー暗号とは何かを言いたいのでしょうか？

91
00:07:23,830 --> 00:07:28,100
[学生]シーザー暗号はちょうどあなたがマップされていることです、あなたは、すべての文字をシフト

92
00:07:28,100 --> 00:07:34,420
文字の特定の番号は、上に行くと、上に戻し、そして、それは非常に安全ではないので、

93
00:07:34,420 --> 00:07:42,260
わずか26使用可能なオプションは、だとあなたはちょうどあなたがそれを取得するまで、それらの各1を試してみてそこに。

94
00:07:42,260 --> 00:07:45,470
ああ。だから、私は繰り返す必要がありますか？

95
00:07:45,470 --> 00:07:51,600
シーザー暗号、it's  - 私はあなたがその問題にそれを扱うことでしょう、という意味 - 

96
00:07:51,600 --> 00:07:56,110
または私はハッカーのエディションではない問題セットの標準版を推測する。

97
00:07:56,110 --> 00:08:01,550
だから問題セットに標準版では、 "こんにちは、世界"のようなメッセージが出る

98
00:08:01,550 --> 00:08:08,410
そして、あなたはまた、6のような番号を持っていて、そのメッセージを受け取り、個々の文字

99
00:08:08,410 --> 00:08:11,310
あなたはアルファベットで6ポジションでそれを回転させます。

100
00:08:11,310 --> 00:08:16,560
だから、 'h'はハローのH-I-J-K-L-M-Nになるだろう。

101
00:08:16,560 --> 00:08:19,600
だから、最初の文字はnになります。我々は電子と同じことを行う。

102
00:08:19,600 --> 00:08:23,530
我々は、のような、zまたは何かを持っているなら、私たちは周りのために戻ってラップ '。'

103
00:08:23,530 --> 00:08:29,280
しかし、それぞれの文字がアルファベットで6文字後で入れ直す取得し、それは非常に安全ではありません

104
00:08:29,280 --> 00:08:35,440
あなたは、単一の文字をラップすることができますどのように多くの方法のための唯一の26の可能性がありますので。

105
00:08:35,440 --> 00:08:42,919
だから、あなただけの、十分な長さのメッセージを、おそらく、それらのすべての26を試すことができ

106
00:08:42,919 --> 00:08:46,860
それらの可能性26のものの1つだけでは、読みやすいものであるために起こっている

107
00:08:46,860 --> 00:08:50,300
読みやすい1は、元のメッセージになるだろう。

108
00:08:50,300 --> 00:08:56,240
だから、まったく何を暗号化するのは非常に良い方法ではありません。

109
00:08:56,240 --> 00:08:59,070
これらのショートパンツとは無関係の、 "機能は何ですか？"

110
00:08:59,070 --> 00:09:03,370
だから、機能は何ですか？はい。

111
00:09:03,370 --> 00:09:11,640
[学生]それはあなたが通過し、その後何の戻り値を取得するために呼び出すことができるコードの別々の作品のようだ。

112
00:09:11,640 --> 00:09:18,160
うん。だから私は、また次回に答えることによって、それにお答えします - あるいはまた、単に次のいずれかを答えることによって、繰り返してください。

113
00:09:18,160 --> 00:09:22,410
あなたはただコピーして何度も何度もコードを貼り付けるのではなく、関数を使用することができます。

114
00:09:22,410 --> 00:09:27,200
ただ、そのコードを取るのfuctionに入れて、その後、単に関数を呼び出すことができます

115
00:09:27,200 --> 00:09:29,870
どこには、コピー＆ペーストされています。

116
00:09:29,870 --> 00:09:33,350
だから機能が便利です。

117
00:09:33,350 --> 00:09:35,860
だから今我々は実際の問題をやる。

118
00:09:35,860 --> 00:09:46,490
最初の1つ。最初のアイデアはあるので、あなたはそれを文字列を渡すとにかかわらず - 

119
00:09:46,490 --> 00:09:52,060
またはそれはすべて小文字と言っていますか？これは、すべて小文字を言うことはありません。

120
00:09:52,060 --> 00:09:57,730
メッセージは何でもかまいませんので、と - ああ、いや。それはありません。

121
00:09:57,730 --> 00:10:01,610
"簡単にするために、ユーザーが入力小文字とスペースのみと仮定するかもしれません。"

122
00:10:01,610 --> 00:10:08,180
だから我々はそれを小文字のみでメッセージを渡し、その後、私たちは交互に

123
00:10:08,180 --> 00:10:15,450
大文字と小文字の間で - 私たちは、文字列が交互に、大文字と小文字になるように変更。

124
00:10:15,450 --> 00:10:22,920
だから前に、私たちは、あなたにも問題に飛び込む第二を与える

125
00:10:22,920 --> 00:10:32,420
私たちが行う必要がある最初のことは何ですか？

126
00:10:32,420 --> 00:10:36,900
ああ、私はちょうど上にあるものをクリックしましたか？ああ、私はちょうどここで電子メールをクリックしました。

127
00:10:36,900 --> 00:10:42,870
だから我々は最初にやるべきこと - 私は間違ったもので探しています？

128
00:10:42,870 --> 00:10:49,320
これはこの1の部分になるのでしょうか？

129
00:10:49,320 --> 00:10:51,320
いいえ、それらは、しかし、そこに残っている。

130
00:10:51,320 --> 00:10:55,160
さて、まだここにいる。

131
00:10:55,160 --> 00:11:03,160
今我々は仮定することはできません - ？はい。ここでは、それが唯一の小文字とスペースだと仮定することはできません。

132
00:11:03,160 --> 00:11:07,770
だから今我々は手紙は、私たちがそれらになりたいものは何でもすることができるという事実に対処する必要があります。

133
00:11:07,770 --> 00:11:11,910
それで、我々は最初にしたいことは、ただメッセージを取得しています。

134
00:11:11,910 --> 00:11:19,790
私たちは、単なる文字列、文字列s = GetStringメソッド、大丈夫を取得する必要があります。

135
00:11:19,790 --> 00:11:24,890
今、この問題は、それを行うためのいくつかの方法があります。

136
00:11:24,890 --> 00:11:29,840
しかし、我々はここでビット演算子を使用したいとしている。

137
00:11:29,840 --> 00:11:35,280
スーパーセクションのどちらかではなかった人々は、そこにある

138
00:11:35,280 --> 00:11:37,480
か何か、とビット演算子が何であるか分からないのですか？

139
00:11:37,480 --> 00:11:41,710
または、彼らはどのような方法でASCIIにどのように関連するか？

140
00:11:41,710 --> 00:11:45,650
[学生]私はスーパーセクションではなかったが、私はビット演算子が何であるかを知っている。

141
00:11:45,650 --> 00:11:49,560
オーケー。それでは、私はそれらの基礎の上に行く必要はありませんが、私は説明しましょう

142
00:11:49,560 --> 00:11:51,830
私たちは、ここで使用するつもりだ。

143
00:11:51,830 --> 00:11:59,680
だから ''：資本のバイナリ表現、その数は65です。

144
00:11:59,680 --> 00:12:07,560
私はただ見に行くよ -  41は01000001になるだろう。

145
00:12:07,560 --> 00:12:14,170
だから10進数で65でなければなりません。ので、これは文字資本Aのバイナリ表現である

146
00:12:14,170 --> 00:12:19,440
さて、文字のバイナリ表現は '小文字

147
00:12:19,440 --> 00:12:33,350
ほぼ、同じことになるだろう。 6ええ、 - それはです。これは正しいです。

148
00:12:33,350 --> 00:12:37,670
だからバイナリー資本、バイナリ小文字の '。'

149
00:12:37,670 --> 00:12:43,940
だからと 'a'はこの単一のビットとの差があることに気づく。

150
00:12:43,940 --> 00:12:49,440
そして、これは、番号32を表すビット、32ビットであることを起こる。

151
00:12:49,440 --> 00:12:53,910
65であるので、それは理にかなっている、 'A'は97です。

152
00:12:53,910 --> 00:12:56,610
両者の差は32です。

153
00:12:56,610 --> 00:13:03,770
だから今我々は、我々が取ることによって 'へ'から変換することができます知っている

154
00:13:03,770 --> 00:13:09,710
およびビット単位で、それを論理和（OR） -  1のように見える。

155
00:13:09,710 --> 00:13:20,900
これは0010万とビット単位の論理和（OR）、であり、それが私たちに与えるでしょうに '。'

156
00:13:20,900 --> 00:13:26,850
そして、我々はビット単位のAND演算によって 'から得ることができる

157
00:13:26,850 --> 00:13:33,700
その場所に付き11、0、11111。

158
00:13:33,700 --> 00:13:43,840
が、この個々のビットを打ち消し、だから、これはその後、 'a'があった正確に何を私たちに授けてくれます

159
00:13:43,840 --> 00:13:50,070
ので、我々は01000001があるでしょう、私は右のカウントかどうかは分からない。

160
00:13:50,070 --> 00:13:56,750
しかし、ビット単位の論理和のこの技術は、小文字に資本から取得する

161
00:13:56,750 --> 00:14:02,080
およびビット単位は小文字から資金を得るために論理積をとると、Aに排他的ではありません

162
00:14:02,080 --> 00:14:06,510
すべての文字、対K、K、Z対Z、

163
00:14:06,510 --> 00:14:10,080
それらのすべては、ただこのシングル·ビットによって異なるとしている。

164
00:14:10,080 --> 00:14:16,290
そしてあなたは、任意の大文字、またはその逆に任意の小文字から変更するには、これを使用することができます。

165
00:14:16,290 --> 00:14:26,670
オーケー。ので、代わりに持っていることの - これから取得する簡単な方法は、そう

166
00:14:26,670 --> 00:14:32,170
何であれ1011111書き出す - この数を表すのに簡単な方法が、これはものではありません

167
00:14:32,170 --> 00:14:39,710
ことを私はスーパーセクションに渡ったが、チルダ（〜）は別のビット単位の演算子です。

168
00:14:39,710 --> 00:14:42,520
どういう〜をすることは、ビット表現を見ています。

169
00:14:42,520 --> 00:14:45,630
の任意の数字を見てみましょう。

170
00:14:45,630 --> 00:14:53,130
これは、単にいくつかのバイナリ数であり、〜はないものを、それだけですべてのビットを反転させます。

171
00:14:53,130 --> 00:15:00,630
だからこれは1でしたが、現在0、これは今では0、1、010100です。

172
00:15:00,630 --> 00:15:08,320
だからそれはすべての〜んだ。だから32は数になるだろう - それを取り除く - 

173
00:15:08,320 --> 00:15:23,320
そう32は数0010万であることを行っているので、この中には〜になるだろう

174
00:15:23,320 --> 00:15:29,980
私は 'をAND演算しているここでは、この番号まで。

175
00:15:29,980 --> 00:15:35,600
誰もがそれを見ていますか？これはあなたが把握したいときのように、かなり一般的です

176
00:15:35,600 --> 00:15:40,740
我々がどうかを確認したいときに我々は、見ているかもしれないもののために後で - 

177
00:15:40,740 --> 00:15:44,710
あるいは、我々は1を除いてすべてのもの、すべての単一のビットがセットされて欲しい

178
00:15:44,710 --> 00:15:47,910
あなたは私たちが設定したくない少しの〜のことをする傾向がある。

179
00:15:47,910 --> 00:15:53,090
だから我々は32ビットがセットされたくないので、我々は32の〜ん。

180
00:15:53,090 --> 00:15:57,790
オーケー。だから我々はここでそれらのすべてを使用することができます。

181
00:15:57,790 --> 00:16:03,000
すべての権利は​​、あなたが完了していないでいるならそれは結構だが、我々はゆっくりと一緒に歩いていくものとし、

182
00:16:03,000 --> 00:16:11,870
またはそう、この上を歩く - これを通じて。この中を歩く。

183
00:16:11,870 --> 00:16:20,790
だから我々は文字列を持って、私たちは、その文字列内の各文字をループしたいし、そこに何かを行います。

184
00:16:20,790 --> 00:16:26,710
では、どのように文字列をループしますか？我々は何を使うべきでしょうか？

185
00:16:26,710 --> 00:16:30,980
私はそれをここでやるつもりはない。うん。

186
00:16:30,980 --> 00:16:42,940
だから、私はイテレータを持っており、彼はそれを言ったが、どのように私は、文字列内の文字数を知っていますか？

187
00:16:42,940 --> 00:16:47,030
strlenは（S）の場合、i + +は。

188
00:16:47,030 --> 00:16:49,860
それでは、私はここでやったことをやっての最善の方法ではありません。

189
00:16:49,860 --> 00:16:51,860
なぜ誰もが知っていますか？

190
00:16:51,860 --> 00:16:55,290
あなたは、文字列毎回の言語をチェックしているので。

191
00:16:55,290 --> 00:17:06,859
だから我々は、strlen、私がここまで言うことが、int型の長さ=はstrlen（s）を移動したいとしている、

192
00:17:06,859 --> 00:17:11,900
その後私が行う<長さ、場合にあなたは前にそれを見ていない、

193
00:17:11,900 --> 00:17:20,410
私もint i = 0のとき、長さ=はstrlen（s）を行うことができます。

194
00:17:20,410 --> 00:17:25,010
それで、これは今ので、私は範囲を制限した、やや望ましい

195
00:17:25,010 --> 00:17:29,150
代わりに前にそれを宣言する 'for'ループちょうどこれに可変長の

196
00:17:29,150 --> 00:17:34,990
そして、それは常に存在し、それが悪いといわれる理由の場合には聞き取れませんでしたことを

197
00:17:34,990 --> 00:17:39,410
あるいは、なぜオリジナルit's、悪かった -  forループで開始。

198
00:17:39,410 --> 00:17:43,380
私は状態をチェックしました。 iはsの長さを<されていますか？

199
00:17:43,380 --> 00:17:46,790
sの長さはそう、全体の時間の "hello"で作業してみましょう。

200
00:17:46,790 --> 00:17:49,670
sの長だから、H-E-L-L-O。長さは5です。

201
00:17:49,670 --> 00:17:57,580
それで、i = 0のとき、長さが5であるので、私は<5ではないので、ループが繰り返されます。

202
00:17:57,580 --> 00:18:02,750
それから私達は再度行く。我々は状態を確認してください。私はハローの長さを<されていますか？

203
00:18:02,750 --> 00:18:08,390
だからハローの長さをチェックしてみましょう。 H-E-L-L-O。私は<5ではないので、我々は再び続ける;それは5だ。

204
00:18:08,390 --> 00:18:13,330
だから我々は、ループが繰り返されるたびに、私たちがハロー数えて、計算している

205
00:18:13,330 --> 00:18:17,380
たとえそれが変更するつもりがないだと思った、それは常に5になるだろう。

206
00:18:17,380 --> 00:18:22,530
だから我々はちょうど正面に5を覚えていて、今ではすべてが良いです。

207
00:18:22,530 --> 00:18:24,990
だから、文字列全体を反復する。

208
00:18:24,990 --> 00:18:31,470
我々は、文字列の各文字に何をしたいですか？

209
00:18:31,470 --> 00:18:38,510
[学生に言えば、理解不能]

210
00:18:38,510 --> 00:18:47,000
うん。だから、文字が英字以外であれば、我々はそれを飛ばしたいと思います。

211
00:18:47,000 --> 00:18:52,300
我々は唯一の英字を気にするので、私たちは数を大文字にすることはできません。

212
00:18:52,300 --> 00:19:10,850
それでは、どのように我々はこれを行うことができますか？我々が何かをしたい場合は私たちの条件SO、SO  - それはアルファベットだかどうかを確認します。

213
00:19:10,850 --> 00:19:14,060
それでは、どのように我々はこれをチェックしますか？

214
00:19:14,060 --> 00:19:18,720
あなただけの機能を使用することができます[学生]がアルファです。

215
00:19:18,720 --> 00:19:23,160
これらのいずれか、またはいずれにも含まれているようですが、char.hか何か含まれていますか？

216
00:19:23,160 --> 00:19:32,710
レッツアルファ関数であり、明示的な使用を使用しない - 私たちは、s [i]は、持っている

217
00:19:32,710 --> 00:19:40,460
sの8番目の文字、つまり、文字列は文字の配列であることを覚えて、

218
00:19:40,460 --> 00:19:43,180
sの8番目の文字はそう。

219
00:19:43,180 --> 00:19:49,280
それが大文字であれば、今、私たちは、それが特定の範囲内にある必要があります知っている。

220
00:19:49,280 --> 00:19:54,370
その範囲は何ですか？

221
00:19:54,370 --> 00:20:07,860
うん。場合ので、s [i]は≥65であり、s [i]は≤90ですが、私は代わりに何をすべきか？

222
00:20:07,860 --> 00:20:18,470
うん。だから、絶対にあっても、これまで何のASCII値を知っておく必要はまったくありません。

223
00:20:18,470 --> 00:20:25,640
番号65、90、97、102、または何でもそれは考えることはありません。

224
00:20:25,640 --> 00:20:32,470
あなたが必要としない -  112  - かあなたはすべてでそれらを知っている必要はありません。それはあまりにも間違っている。

225
00:20:32,470 --> 00:20:41,940
唯一の単一引用符文字は、単一引用符定数を使用します。だから 'と90未満は "Z.'です

226
00:20:41,940 --> 00:20:47,930
そして、これはかなり良いです - 私はZは90であることが私の頭の上をオフに知ることはできません。

227
00:20:47,930 --> 00:20:52,690
私は、 'Z'は資本Zであるというのが私の頭の上をオフに知っていますか

228
00:20:52,690 --> 00:21:02,100
だから限り、これは資本Z、または私達への資本の範囲内にあるように、小文字をチェックすることができます

229
00:21:02,100 --> 00:21:17,010
またはそれは範囲内の場合≥ 'a'と≤zである。

230
00:21:17,010 --> 00:21:19,010
だからそれは私たちの状態だ。

231
00:21:19,010 --> 00:21:22,520
これらの事をどこに置くかのスタイルが異なります。

232
00:21:22,520 --> 00:21:29,520
私はこのようにそれをやる。

233
00:21:29,520 --> 00:21:31,520
今、私たちは何をすべきかをしたいですか？

234
00:21:31,520 --> 00:21:39,530
我々は、この手紙は文字、アルファベット文字であることを知っている。

235
00:21:39,530 --> 00:21:46,270
だから我々は、これは今では大文字または小文字にするかどうかを交互にする必要があります。

236
00:21:46,270 --> 00:21:48,820
どのように我々は、我々はそれになりたいかを追跡するのですか？

237
00:21:48,820 --> 00:21:55,520
[生徒の声、不明朗]

238
00:21:55,520 --> 00:21:59,150
そうです、が、私は確認してみましょう。

239
00:21:59,150 --> 00:22:04,910
0から2までは言われていたモジュールは、投げ出さ提案だった、と私はそれに同意する。

240
00:22:04,910 --> 00:22:11,780
のように、その予告を除いて - これは事実ですか？うん。

241
00:22:11,780 --> 00:22:18,270
それは他のすべての一つだが、我々はiのモジュール2できないか、または以来私はmod 2を、

242
00:22:18,270 --> 00:22:22,950
Eは首都であり、 'a'が小文字であることに気づく？しかし、それらを分離する空間がそこですか？

243
00:22:22,950 --> 00:22:27,150
そこで、彼らは同じモッズ2であることを行っているが、彼らは別の例だ。

244
00:22:27,150 --> 00:22:29,150
[学生の質問、不明朗]

245
00:22:29,150 --> 00:22:34,690
うん。だから我々は単にカウントを維持するつもりだ。

246
00:22:34,690 --> 00:22:38,730
私たちが望んだ場合、また、ここでそれを行うことができ、少し扱いを受けるかもしれない

247
00:22:38,730 --> 00:22:41,300
ループ宣言のために、私はここでそれを置くことにしましょう​​。

248
00:22:41,300 --> 00:22:48,840
だからint型のカウント= 0から始まります。

249
00:22:48,840 --> 00:22:54,070
それで今、私は我々が持っていたどのように多くのアルファベット文字カウントするつもりです。

250
00:22:54,070 --> 00:22:59,550
だから我々は必然的に我々は別のアルファベットの文字を見つけました+ +ので​​カウントするつもりだ。

251
00:22:59,550 --> 00:23:09,130
しかし、今あなたは、カウントのmod 2の場合と言っている。

252
00:23:09,130 --> 00:23:12,590
だから何カウントmod 2をすれば？ああ。私は今のところ== 0をやる。

253
00:23:12,590 --> 00:23:21,740
我々はまた、上に行くよ。それでは次に、モッズ風の2 == 0を数えたら？

254
00:23:21,740 --> 00:23:27,830
[学生の答えは、不明朗]

255
00:23:27,830 --> 00:23:32,750
だから我々はそれが大文字を終わりにしたい。

256
00:23:32,750 --> 00:23:37,520
2例がありますが、大文字と小文字が2例である。

257
00:23:37,520 --> 00:23:40,990
我々は小文字でならだから我々はそれを大文字にする必要があります。

258
00:23:40,990 --> 00:23:43,710
それが大文字の場合、私たちは何もする必要はありません。

259
00:23:43,710 --> 00:23:50,760
しかし、方法は何ですか -  shouldn'tが反転している - 

260
00:23:50,760 --> 00:23:54,800
我々もそれは大文字または小文字のかどうかチェックする必要がないこと？

261
00:23:54,800 --> 00:24:02,240
我々は常に我々は常に大文字で終わることを確認するために何ができますか？

262
00:24:02,240 --> 00:24:07,830
だから我々は小文字の ''のためにやったことに気づく、我々は大文字にこのまったく同じことをやった場合はどうなりますか？

263
00:24:07,830 --> 00:24:11,900
変化を大文字、または値の変更を行いますか？

264
00:24:11,900 --> 00:24:23,100
うん。ビット演算が〜32とAND任意の大文字はその同じ大文字の文字であることを行っているので、

265
00:24:23,100 --> 00:24:29,220
任意の大文字の文字を32ビット目がセットされていないためです。

266
00:24:29,220 --> 00:24:40,920
我々は、s [i]が、我々はそれが小文字または大文字になりたい文字を持参したいのであれば。

267
00:24:40,920 --> 00:24:46,890
それが小文字であったのであれば、それが大文字だった場合、それはまだ大文字だし、それはそれだが、今では大文字です。

268
00:24:46,890 --> 00:24:54,290
私は、スーパーセクションでこれを言った：もしあなたが望むなら、32を使用することができますが、私は 'をやって好む傾向にある - 、

269
00:24:54,290 --> 00:25:01,150
代わりに単なる32の、それは他のビットとすることがあるからです。

270
00:25:01,150 --> 00:25:03,610
32ビットの後、それはこれらのいずれかにすることも、我々は十分を持っていないだろう

271
00:25:03,610 --> 00:25:05,840
すべての文字を表現するための番号。

272
00:25:05,840 --> 00:25:09,110
あなたが32ビットを得るのであれば、それは64ビットであること、それは、128ビットである可能性があります。

273
00:25:09,110 --> 00:25:13,990
これらのビットのいずれかは、大文字と小文字が区別されます少しである可能性があります。

274
00:25:13,990 --> 00:25:18,350
私はそれが32ビットであることを知っている必要はありません。

275
00:25:18,350 --> 00:25:27,130
私は、これは 'a'を使用することができます -  2つの間で異なるビットを得るために

276
00:25:27,130 --> 00:25:33,000
32のマジックナンバーに頼る必要なし。

277
00:25:33,000 --> 00:25:38,770
そして、今、他の奇数だった数えるので、私は何をしたいのですか？

278
00:25:38,770 --> 00:25:43,920
[生徒の解答、不明朗]

279
00:25:43,920 --> 00:25:45,920
[学生]それは何ですか？

280
00:25:45,920 --> 00:25:49,850
私は1秒でそれを行います。

281
00:25:49,850 --> 00:25:55,690
だから今私がしたい場合 - 私は文字が小文字であることを確認することを望み、

282
00:25:55,690 --> 00:26:04,140
ので、私がすることができます、32分、および32の意味 ' -  A

283
00:26:04,140 --> 00:26:06,510
しかし予告、前回と同じ論法で、その場合

284
00:26:06,510 --> 00:26:11,670
手紙は、その後32で論理和（OR）がちょうどそれを小文字保ち、すでに小文字だった。

285
00:26:11,670 --> 00:26:16,220
これは、元の文字が変更されていません。

286
00:26:16,220 --> 00:26:19,910
しかし、今私は、それが小文字の場合は、単にそれを忘れる "と言って避ける必要はありません

287
00:26:19,910 --> 00:26:23,650
それが大文字の場合は、それを変更します。 "

288
00:26:23,650 --> 00:26:26,900
それがこれを行うには、はるかに便利です。

289
00:26:26,900 --> 00:26:33,190
[学生]は、それが32でなかったら仕事小文字から大文字を減算し、その戦略でしょう？

290
00:26:33,190 --> 00:26:35,330
それがあった場合は、34か何が好きですか？

291
00:26:35,330 --> 00:26:41,840
だから、あなたは2点の違いがあることを知っておく必要があります - ？ >> 1ビット。

292
00:26:41,840 --> 00:26:49,840
それがある限り、この位置より下のすべてのビットが同じであるように、1ビット以上である可能性があります。

293
00:26:49,840 --> 00:26:58,500
26文字があるか、 - だから我々は、少なくとも26文字が必要。

294
00:26:58,500 --> 00:27:04,590
だから我々は違いを表現するために少なくとも26の番号が必要になる - 

295
00:27:04,590 --> 00:27:07,650
と 'の違いは少なくとも26でなければならない、

296
00:27:07,650 --> 00:27:10,760
さもなければ、我々はすべての資本の数値を表すことはなかっただろう。

297
00:27:10,760 --> 00:27:18,630
、我々は1から開始した場合、それはこれらのすべてのビットを使用するように起こっていることを意味し、

298
00:27:18,630 --> 00:27:23,900
Zまですべてのものを表現するためにこれらの最初の5ビットのすべて、

299
00:27:23,900 --> 00:27:32,170
それはなぜ次のビット、またはこのビットだが、次のビットはとを区別するために選んだものである '。'

300
00:27:32,170 --> 00:27:40,930
まただからこそ、ASCIIテーブルで、小文字から大文字を分離5シンボルがあります。

301
00:27:40,930 --> 00:27:49,050
それらは、シンボル、それらの間の差である32が表示されます余分な5であるので。

302
00:27:49,050 --> 00:27:51,840
[学生]だからASCIIがそのように設計されているので、我々は、それを行うことができます。

303
00:27:51,840 --> 00:27:57,280
はい。しかし、ASCII  - の違いは、これらのビットの両方の可能性があります。

304
00:27:57,280 --> 00:28:12,040
10000001たし、 'a'は11100001だった場合、同じように - 私は何でも、忘れている。

305
00:28:12,040 --> 00:28:18,100
A.  - それはこれだったしかし、もし我々はまだ 'を使用することができます

306
00:28:18,100 --> 00:28:22,650
それはまだ、これらの2ビットである今だけと 'A'の違いだ。

307
00:28:22,650 --> 00:28:32,240
私はそれが48を書いていると思う。それは32 +64ですか？私はそれだと思う？

308
00:28:32,240 --> 00:28:40,160
すべての単一の文字、のように、ZとZ、KとK、、それはまだ2ビットになり

309
00:28:40,160 --> 00:28:45,160
彼らはまだそれらの2ビットを除いて設定したのと同じ正確なビットを持っているでしょう。

310
00:28:45,160 --> 00:28:48,870
我々は、ASCIIまたはいくつかの他のシステムを使用している場合ように、それは常に真であるかぎりかかわらず、

311
00:28:48,870 --> 00:28:53,050
限り、各キャラクタごとに異なる​​ビットが設定された数しか存在だとして、

312
00:28:53,050 --> 00:28:55,050
その後、それが正常に動作します。

313
00:28:55,050 --> 00:29:06,110
それは、我々はおそらく使うことができます最初のものですので、32が設定されたというだけです。クール。>>

314
00:29:06,110 --> 00:29:14,520
私は、ブロックは、単一の行である場合は、見ていない場合には、好む傾向にある

315
00:29:14,520 --> 00:29:24,280
あなたは、中括弧を取り除くことができ、ので、私はこれをやって好む傾向にある。

316
00:29:24,280 --> 00:29:34,010
また、我々はs [i]は+ = 1のようなものを行うことができます知っている？

317
00:29:34,010 --> 00:29:41,090
また、s [i]はビット単位の論理積（AND）= 32を行うことができます。

318
00:29:41,090 --> 00:29:46,400
とビット単位の論理和（OR）= 32。

319
00:29:46,400 --> 00:29:51,490
また、モッズ風の2 == 0をカウントします。

320
00:29:51,490 --> 00:30:00,900
だから、それを覚えている - 私はそれを書き込むことはありません - ゼロ以外の値がtrueで、0はfalseです。

321
00:30:00,900 --> 00:30:07,880
"カウントあればモッズ2 == 0"がそう言って同じである "モッズ2を数えていない場合。"

322
00:30:07,880 --> 00:30:11,580
私はたぶん、行を反転し、IFカウントモッズ2 "と言っただろう

323
00:30:11,580 --> 00:30:15,350
または1を行うには、他にはない "私は必要としなかったので"と、1やる。 "

324
00:30:15,350 --> 00:30:18,650
しかし、これも同様に動作します。

325
00:30:18,650 --> 00:30:25,660
そして、私はここで、他に何を行うことができますか？

326
00:30:25,660 --> 00:30:29,060
あなたが望んでいる場合三、それらを組み合わせることもできますが、その物事が乱雑作ると思いますその

327
00:30:29,060 --> 00:30:33,770
と読むことがおそらくより難しいので、我々はそれを行うことはありません。

328
00:30:33,770 --> 00:30:37,330
誰もが何か他の提案はありますか？

329
00:30:37,330 --> 00:30:41,580
すべての問題が求めているのですか？そうとも。

330
00:30:41,580 --> 00:30:51,070
だから今我々は、fを刷る、これらの空行を取り除くため、％sは文字列のための一つである、

331
00:30:51,070 --> 00:30:56,620
我々は、F、Sを出力します。

332
00:30:56,620 --> 00:30:59,330
今それを実行してみましょう。私は何も悪いことをしたのか？

333
00:30:59,330 --> 00:31:03,200
つまり、 "\だ、私は、nを求めています。

334
00:31:03,200 --> 00:31:07,840
オーケー。今、私たちはそれを実行することになるでしょう。それはおそらく、私に向かって怒鳴ります。

335
00:31:07,840 --> 00:31:11,250
strlenはstring.hである。

336
00:31:11,250 --> 00:31:14,290
だから、これは、それがに何があるかがわかりますですClangのいいところです

337
00:31:14,290 --> 00:31:19,140
だけではなく、言うGCCの "ねえ、あなたが何かを忘れて、私はそれが何だったかわからない。"

338
00:31:19,140 --> 00:31:29,220
しかし、これは私に教えてくれる、 "あなたはstring.hを含むことを意味する。"

339
00:31:29,220 --> 00:31:32,130
だから私は何のために要求されなかったので、それは何も言っていない。

340
00:31:32,130 --> 00:31:42,540
しかし、我々は彼らの例をやる、 "4 addはありがとうございました"。

341
00:31:42,540 --> 00:31:47,880
右に見えます。めでたしめでたし。

342
00:31:47,880 --> 00:31:52,370
だからあなたのメインに戻って、私はほとんどそれを行うことはありません。

343
00:31:52,370 --> 00:31:57,110
これはオプションとなっています。そして主は、それが任意である唯一の関数です。

344
00:31:57,110 --> 00:32:07,140
あなたは主から何かを返さない場合は、0を返すことを意味していることを前提にしています。

345
00:32:07,140 --> 00:32:13,070
質問はありますか？

346
00:32:13,070 --> 00:32:20,980
オーケー。だから今、第二の問題。

347
00:32:20,980 --> 00:32:24,810
"渡すことによって、2変数の値を交換することが週2の第二の講義を思い出して

348
00:32:24,810 --> 00:32:30,780
正確に動作しない機能（スワップと呼ばれていても）にそれらの2つの変数は、少なくともではないとせずに "ポインタ" "。

349
00:32:30,780 --> 00:32:37,020
我々は彼らに到達するまでとポインタを無視します。

350
00:32:37,020 --> 00:32:40,070
我々は2つ​​の変数を入れ替えたい、我々はそれを行うには、関数を使用していない。

351
00:32:40,070 --> 00:32:43,410
我々はまだそれが言うようにメインでそれをやろうとしている。

352
00:32:43,410 --> 00:32:48,360
しかし、これら2つの変数を使用するように、我々は一時的な変数を使用する必要はありません。

353
00:32:48,360 --> 00:32:50,770
これを行うには2通りの方法があります。

354
00:32:50,770 --> 00:32:56,310
あなたは、あなたの伝統的な二項演算子を使用してそれを行うことができます。

355
00:32:56,310 --> 00:33:00,180
だから誰もがあることを行うための手っ取り早い方法を知っていますか？

356
00:33:00,180 --> 00:33:07,650
これは、実際的な思考の分かかることがあります。私が持っている場合 - 

357
00:33:07,650 --> 00:33:12,130
彼らが求めるように私は問題を設定してみましょう。だから、僕は整数であり、2つの変数、持っている場合

358
00:33:12,130 --> 00:33:17,800
彼らは私を与える、と私が与えられていることを別の整数であるsum変数Bのこと。

359
00:33:17,800 --> 00:33:22,700
私はこれらの2つの変数を持っているなら、今、私はそれらを交換したいと思います。

360
00:33:22,700 --> 00:33:31,550
伝統的な、あなたの通常のバイナリ演算子を使用して、私が言いたいのは、+のような、 - 、÷。

361
00:33:31,550 --> 00:33:36,630
バイナリに作用ビット演算子ではない。

362
00:33:36,630 --> 00:33:39,600
だから使用して+、 - 、÷、そしてすべてのそれら。

363
00:33:39,600 --> 00:33:52,980
我々は以下のようなやり方で交換できる= a + bを、aとb = a  -  bを、A = A  -  B。

364
00:33:52,980 --> 00:34:04,260
だから、正気をチェックした後、我々は、なぜその作品を見ることができます。

365
00:34:04,260 --> 00:34:13,320
レッツは言う= 7、B = 3、Bは10になるだろう+。

366
00:34:13,320 --> 00:34:18,820
だから我々は今= 10を設定しているし、我々はB = Aをやっている - と、b。

367
00:34:18,820 --> 00:34:30,250
だから我々がやっているB = A  -  7であることを行っているB、A、aとb = a  -  bをもう一度、

368
00:34:30,250 --> 00:34:38,650
または= A  -  B。 7 3  -  10であることを行っている。

369
00:34:38,650 --> 00:34:44,850
だから今、正しく、 'A'はbが3であった、7歳、今bは7であり、 'a'は3です。

370
00:34:44,850 --> 00:34:48,679
だからそういうのは理にかなっている、 'a'は2つの数値の組み合わせです。

371
00:34:48,679 --> 00:34:53,000
この時点では、 'A'は組み合わせですし、我々は元のBを引いている

372
00:34:53,000 --> 00:34:56,860
それから私達は元の何であったかを引いている '。'

373
00:34:56,860 --> 00:35:01,150
しかし、これはすべての数字に対しては機能しません。

374
00:35:01,150 --> 00:35:08,880
これを確認するには、のシステムを考えてみましょう、私たちは通常、32ビット整数として考える。

375
00:35:08,880 --> 00:35:13,050
4ビットのみのようだ何かで作業してみましょう。

376
00:35:13,050 --> 00:35:15,450
うまくいけば、私は今は良い例を思い付く。

377
00:35:15,450 --> 00:35:18,680
だから、私は知っている、これは簡単なことでしょう。

378
00:35:18,680 --> 00:35:26,720
Let 'sは、私たちの2数字は1111と1111であると言う、申し訳バイナリにしているので。

379
00:35:26,720 --> 00:35:34,630
実際の小数では、あなたがそれをそのように考えるようにしたい場合は、= 15、B = 15。

380
00:35:34,630 --> 00:35:37,630
それで、我々はそれらを交換した後、我々は期待して - 彼らも、同じ番号である必要はありません

381
00:35:37,630 --> 00:35:41,140
しかし、私はこのようにそれをやった。

382
00:35:41,140 --> 00:35:47,100
それらは同一の番号確認してみましょう。 1111および0001を実行してみましょう。

383
00:35:47,100 --> 00:35:51,860
だから= 15、b = 1である。

384
00:35:51,860 --> 00:35:57,670
我々はそれらを交換した後、我々は 'a​​'が1になるように、aとbが15であることを期待しています。

385
00:35:57,670 --> 00:36:01,780
だから私たちの最初のステップです= a + bを。

386
00:36:01,780 --> 00:36:08,770
私たちの番号は0001です1111年である '、'、+ B、、そう、唯一の4ビット幅である

387
00:36:08,770 --> 00:36:16,780
万のままで終わるつもりが、我々は唯一の4ビットを持っています。

388
00:36:16,780 --> 00:36:22,540
だから今= 0。

389
00:36:22,540 --> 00:36:34,080
 -  B  - 実際に、これはまだ完全にうまくいくと、今、私たちはB = Aに設定したいと思います。

390
00:36:34,080 --> 00:36:39,630
= A  -  B  - これは完璧に動作するかどうか見てみましょう。

391
00:36:39,630 --> 00:36:53,720
それでは、b = 0である - 当時はまだ15だろう1、および= a  -  bを、これは1になります。

392
00:36:53,720 --> 00:36:56,210
多分これは仕事をしません。

393
00:36:56,210 --> 00:36:59,020
それは正規の使用して動作しない理由があるような気がします。

394
00:36:59,020 --> 00:37:06,400
わかりましたので、それは通常のバイナリ演算で機能しないことを前提に取り組んで、

395
00:37:06,400 --> 00:37:15,040
と私は探します - 私はそれが本当であるかどうかを確認するためにGoogleます。

396
00:37:15,040 --> 00:37:23,490
だから我々はビット演算子を使用してそれをやってみたい、ここで手がかりはXORです。

397
00:37:23,490 --> 00:37:28,780
だから、あなたはまだそれを見ていない場合、XOR（^）を導入。

398
00:37:28,780 --> 00:37:34,610
それはちょっと、とit'sによってビット働くので、それは、再び、ビット演算子です - 

399
00:37:34,610 --> 00:37:39,910
あなたはビット0と1を持っている場合、これは1になります。

400
00:37:39,910 --> 00:37:45,230
あなたはビット1および0を持っている場合、それは1になるでしょう、あなたはそれが、0になりますビット0と0を持っている

401
00:37:45,230 --> 00:37:47,640
あなたはビット1と1を持っている場合、それは0になるでしょう。

402
00:37:47,640 --> 00:37:56,180
だから、まるで、ORです。ビットのいずれかが真である場合、それは1ですが、ORとは違って、それが真である両方のビットにすることはできません。

403
00:37:56,180 --> 00:37:59,320
またはこれが1になるでしょうが、XORは、これは0でなければならないでしょう。

404
00:37:59,320 --> 00:38:02,250
だから我々はここでXORを使用するつもりだ。

405
00:38:02,250 --> 00:38:09,960
分のためにそれについて考えて、私はGoogleに行くよ。

406
00:38:09,960 --> 00:38:16,230
さて、あなたはそれを読み取ることができない、私は、XORスワップアルゴリズムのページで現在です。

407
00:38:16,230 --> 00:38:21,340
私はマストアイテムなぜうまくいけば、これは説明します - 

408
00:38:21,340 --> 00:38:34,190
これはまさに我々がちょうどやったアルゴリズムです。

409
00:38:34,190 --> 00:38:37,330
私はまだ理由を見ていない - 私はちょうど悪い例をピックアップしている必要があり、

410
00:38:37,330 --> 00:38:44,940
しかし、 'a'は、今 'が0で、5ビットに取得した後、0になることが起こった、この場合、

411
00:38:44,940 --> 00:38:48,730
それはと呼ばれるものである "整数オーバーフローが発生しました。"

412
00:38:48,730 --> 00:38:54,370
ウィキペディアによると、 "XORのスワップとは異なり、この変化は、それがいくつかのメソッドを使用している必要があります

413
00:38:54,370 --> 00:38:59,780
x + yは整数オーバーフローが発生しないことを保証します。 "

414
00:38:59,780 --> 00:39:08,350
だから、これは問題を持っていませんが、これは整数のオーバーフローでしたが、私は何か間違ったことをしました。

415
00:39:08,350 --> 00:39:10,520
私はよく分からない。私は別のものを思い付くしようとするでしょう。

416
00:39:10,520 --> 00:39:13,640
[学生]さて、あなたはそこに数字を入れしようとしている整数オーバーフローではありません

417
00:39:13,640 --> 00:39:16,640
あなたが割り当てられたビットの量よりも大きい？

418
00:39:16,640 --> 00:39:23,730
うん。我々は、4ビットを持っています。 That'sは - 私たちは4ビットを持っていた、我々はそれに1を追加しようとするので、我々は5ビットで終わる。

419
00:39:23,730 --> 00:39:26,690
しかし、第五ビットがちょうどええ、切断される。

420
00:39:26,690 --> 00:39:28,970
それは実際にかもしれない - 

421
00:39:28,970 --> 00:39:33,010
[学生]は、はエラーを投​​げるか、それをしないか - そのエラーをスローしていました？

422
00:39:33,010 --> 00:39:40,720
いいえ、だからエラーはありません。あなたは、アセンブリレベルに到達する、特殊なビット

423
00:39:40,720 --> 00:39:47,020
どこかにあることは、オーバーフローがあったと述べたが、C言語では一種のは、まさにそれに対処しない設定されています。

424
00:39:47,020 --> 00:39:55,160
あなたがCで特殊なアセンブリ命令を使用しない限り、実際にそれに対処することはできません

425
00:39:55,160 --> 00:39:58,110
のは、XORスワップについて考えてみましょう。

426
00:39:58,110 --> 00:40:02,220
そして、私はWikipediaの記事にもあることを言っているかもしれないと思う - 

427
00:40:02,220 --> 00:40:07,310
だから、それはまた、モジュラー演算を育てたので、私はモジュラー演算をやって、理論的には、私がいたと思います

428
00:40:07,310 --> 00:40:11,160
1再び15です - 私は0と言ったとき。

429
00:40:11,160 --> 00:40:15,410
だから実際にかもしれない -  1 = 15から0までを行い、正規のプロセッサ上で。

430
00:40:15,410 --> 00:40:20,430
我々は0で終わるので、私達は1を引くので、それだけで周りに1111に戻ってラップします。

431
00:40:20,430 --> 00:40:28,930
B、​​B  -   - だから、このアルゴリズムは、実際には、A + B、Aに働くかもしれない、それは大丈夫かもしれません。

432
00:40:28,930 --> 00:40:34,030
しかし、それをしないので、それは、それらの特定のもので大丈夫ではないだろういくつかのプロセッサがあります。

433
00:40:34,030 --> 00:40:39,880
XORのスワップは、任意のプロセッサ上で動作します。オーケー。

434
00:40:39,880 --> 00:40:42,280
アイデアは、それはしかし、同じことになっているということです。

435
00:40:42,280 --> 00:40:50,120
ここで、我々は、何らかの形での変数の1への両方の情報を取得するためにXORを使用している

436
00:40:50,120 --> 00:40:54,120
その後再び個々の変数の情報を引き出します。

437
00:40:54,120 --> 00:41:04,330
だから誰もがアイデア/答えを持っているのですか？

438
00:41:04,330 --> 00:41:14,540
[学生の答えは、不明朗]

439
00:41:14,540 --> 00:41:22,220
だから、これは動作するはずであり、また、XORは可換である。

440
00:41:22,220 --> 00:41:27,620
かかわらず、どのような順序でこれら2つの数字は、ここまでにたまたま

441
00:41:27,620 --> 00:41:30,100
この結果は同じになるだろう。

442
00:41:30,100 --> 00:41:35,800
だから^ Bはb ^ A。

443
00:41:35,800 --> 00:41:51,860
また、これが書かれたとして見るかもしれません^ = B、B ^ = A、A ^ = bをもう一度。

444
00:41:51,860 --> 00:42:00,200
だから、これは右であり、この作品は、ビットが考える理由を確認する。

445
00:42:00,200 --> 00:42:10,400
小さめの番号を使用して、11001および01100を考えてみましょう。

446
00:42:10,400 --> 00:42:12,790
だから、これは ''ですが、これはbです。

447
00:42:12,790 --> 00:42:15,540
だから^ = bの。

448
00:42:15,540 --> 00:42:22,380
我々は、これらの2つのもののXORに '=を設定することになるだろう。

449
00:42:22,380 --> 00:42:32,920
1 SO ^ 0は1で、1 ^ 1は0で、0 ^ 1は1で、0 ^ 0は0です。1 ^ 0は1です。

450
00:42:32,920 --> 00:42:37,380
だから '、'を10進数を見れば、それがために起こっている - 

451
00:42:37,380 --> 00:42:41,160
あなたは '、'はるかにオリジナルの 'A'と新しいの間の関係のを参照してくださいするつもりはない

452
00:42:41,160 --> 00:42:45,600
しかしビットを見て、 'A'は情報のメッシュのようになりました

453
00:42:45,600 --> 00:42:49,970
オリジナルの 'a'とbの両方の元。

454
00:42:49,970 --> 00:42:57,930
我々は、b ^、私たちはオリジナルで終わるだろうことがわかり '。'を取るのであれば

455
00:42:57,930 --> 00:43:08,910
我々が取る場合と、元の '^新しい'、 '私たちは元のbで終わるを参照してください。

456
00:43:08,910 --> 00:43:18,380
（^ b）は^ B =元の '。'だから

457
00:43:18,380 --> 00:43:27,910
と（a ^ b）の^ A =オリジナルB。

458
00:43:27,910 --> 00:43:37,010
があります - これは何かのXORそのもので見てのもう一つの方法は、常に0です。

459
00:43:37,010 --> 00:43:45,020
だから、1101 ^ 1101は、すべてのビットが同じであることを行っています。

460
00:43:45,020 --> 00:43:47,920
だから1が0で、もう一方が1であるケースのようにそこに行くことはない。

461
00:43:47,920 --> 00:43:51,080
だから、これは0000です。

462
00:43:51,080 --> 00:43:57,240
これと同じ。 （^ b）のようなものです^ B ^（B ^ b）に示す。

463
00:43:57,240 --> 00:44:03,680
（B ^ b）が0であることを行っている、すべてのビットが0であるので^ 0は '、'であることを行っている。

464
00:44:03,680 --> 00:44:08,050
だから、 'a'はもともと1だった場所になるだろうしている唯一のものは、 - のものを持っていた。

465
00:44:08,050 --> 00:44:12,070
そして、ここで同じアイデアが、私はそれも可換だと確信しています。

466
00:44:12,070 --> 00:44:17,590
うん。私はそれが可換であったその前に言っていた。

467
00:44:17,590 --> 00:44:24,680
^ '、'、それが連想なので、今では（B ^ A）^ A。

468
00:44:24,680 --> 00:44:28,970
そして、我々が行うことができますB ^（A ^ A）。

469
00:44:28,970 --> 00:44:31,540
それで再び、我々は元のbを得る。

470
00:44:31,540 --> 00:44:37,120
だから 'は現在、一緒に' a 'とbの組み合わせです。

471
00:44:37,120 --> 00:44:49,660
私たちの新しいコンボを使用して 'を'我々は言うB =コンボ '^オリジナルB、我々は元の取得'。 '

472
00:44:49,660 --> 00:45:05,170
そして今、コンボ= '^新しいBは、元あった - またはそれは'またはbだったものになりました。

473
00:45:05,170 --> 00:45:13,620
この場合は、ここに、そのダウンだ。これは、A = B、古いbです。

474
00:45:13,620 --> 00:45:16,550
だから今はすべてが入れ替わっために戻ってきました。

475
00:45:16,550 --> 00:45:22,960
我々は実際にビットを見ている場合、B = A ^ Bは、これらの2のXORしようとしている

476
00:45:22,960 --> 00:45:33,920
その答えは、これになるだろう、とされている= A ^ bのこれらの2のXORをとると答えがこれです。

477
00:45:33,920 --> 00:45:41,090
質問はありますか？オーケー。だから、最後のものは幾分よりかなり難しいです。

478
00:45:41,090 --> 00:45:43,180
[学生]私は彼がそれについての質問を持っていると思う。 >>ああ、ごめんね。

479
00:45:43,180 --> 00:45:49,380
[学生]実際には高速は何ですか？このXORを使用している場合は、新しい変数を宣言した場合、またはそれを何ですか？

480
00:45:49,380 --> 00:45:55,190
だから、新しい変数を宣言するか、交換するXORを使用して、実際には高速は何ですか？

481
00:45:55,190 --> 00:45:59,600
答えは、十中八九、一時的な変数です。

482
00:45:59,600 --> 00:46:05,780
そして、それは、それがダウンしてコンパイルされた後からである - ので、アセンブリレベルで、

483
00:46:05,780 --> 00:46:12,320
ローカル変数または一時変数やこのようなもののいずれかのようなものはありません。

484
00:46:12,320 --> 00:46:16,060
彼らはただ、希望している - メモリがそこだし、レジスタがあります。

485
00:46:16,060 --> 00:46:20,920
物事が活発に起こっている場所のレジスタがあります。

486
00:46:20,920 --> 00:46:24,750
あなたは、メモリ内の2つのものを追加しないでください、あなたはレジスタ内の2つのものを追加します。

487
00:46:24,750 --> 00:46:28,160
そして、あなたは、それらを追加するには、レジスタにメモリから物事をもたらす

488
00:46:28,160 --> 00:46:33,180
してから、メモリにそれらを戻すかもしれませんが、すべてのアクションは、レジスタで行われます。

489
00:46:33,180 --> 00:46:38,750
だから何が起こるか通常、一時的な変数のアプローチを使用しているときです

490
00:46:38,750 --> 00:46:42,810
これら2つの数値は、レジスタに既に登録されている。

491
00:46:42,810 --> 00:46:46,570
そして、その時点から、あなたがそれらを交換した後、上に、

492
00:46:46,570 --> 00:46:51,540
それだけで他のレジスタを使用して開始します。

493
00:46:51,540 --> 00:46:56,510
どこでもあなたがBを使用していた、それだけで既に保存されたレジスタに使用します。 '

494
00:46:56,510 --> 00:47:02,180
だから、実際にスワップを行うために何かをする必要はありません。うん？

495
00:47:02,180 --> 00:47:05,690
[学生]しかし、それはまた、右の、より多くのメモリを取る？

496
00:47:05,690 --> 00:47:10,280
それは、その一時的な変数を格納するために必要がある場合、それはより多くのメモリしかかかりません。

497
00:47:10,280 --> 00:47:14,830
後でどこかで再びその一時変数を使用する場合と同様に、

498
00:47:14,830 --> 00:47:18,920
それから - あるいは、その一時変数に何かを割り当てることができます。

499
00:47:18,920 --> 00:47:24,630
だから時間tempに '、' bのいずれかの時点では、個別の値か何かを持っている

500
00:47:24,630 --> 00:47:30,680
それは、メモリ内の異なる位置を持っているつもりだが、それは事実だが、

501
00:47:30,680 --> 00:47:34,800
レジスタのみに存在することになる多くのローカル変数があります。

502
00:47:34,800 --> 00:47:44,370
その場合には、それがメモリに入れたことがない、とするので、メモリを無駄にしていることはありません。

503
00:47:44,370 --> 00:47:58,620
オーケー。最後の質問は、もう少しです。

504
00:47:58,620 --> 00:48:04,850
そこでここでは、このCS50アプライアンスで、辞書がある。

505
00:48:04,850 --> 00:48:12,390
そしてその理由は、ためである[？B66]あなたは書きますスペルチェッカーです

506
00:48:12,390 --> 00:48:15,780
ハッシュテーブルや試行またはいくつかのデータ構造を使用しています。

507
00:48:15,780 --> 00:48:22,660
あなたは、スペルチェッカーを書くことになるだろう、とあなたはそれを行うには、この辞書を使用してすることになるだろう。

508
00:48:22,660 --> 00:48:28,280
しかし、この問題のために、私たちはただ一つの単語が辞書にあるかどうかを調べるとしている。

509
00:48:28,280 --> 00:48:31,250
だからではなく、いくつかのデータ構造で全体の辞書を格納

510
00:48:31,250 --> 00:48:35,180
その後、何かのスペルが間違っているかどうかを確認するために、文書全体を見ている

511
00:48:35,180 --> 00:48:38,490
私達はちょうど1ワードを見つけたい。だから我々はちょうど全体の辞書をスキャンすることができます

512
00:48:38,490 --> 00:48:44,300
我々は全体の辞書で単語を見つけることは決してないならば、それはそこにはありませんでした。

513
00:48:44,300 --> 00:48:52,150
我々は全体の辞書をスキャンして、単語を参照しない場合、我々は良いしている、我々はそれを発見した。

514
00:48:52,150 --> 00:48:56,580
それは、我々はCのファイル処理機能を見て開始することをここで言う

515
00:48:56,580 --> 00:48:59,930
私たちは辞書を読んでもらいたいので、

516
00:48:59,930 --> 00:49:07,680
しかし、私は、あなたが考えるべき機能として、ここにヒントを与えるだろう。

517
00:49:07,680 --> 00:49:11,510
私はスペースにそれらを書こうと思います。

518
00:49:11,510 --> 00:49:20,490
だから、主なものあなたは、その後オープン、fは、必然的に、fが閉じている時に見てよいでしょう

519
00:49:20,490 --> 00:49:26,540
これは、あなたのプログラムの最後に移動して、Fスキャンのfになります。

520
00:49:26,540 --> 00:49:31,060
また、fは読み込む使うことができますが、あなたはおそらくしたくない

521
00:49:31,060 --> 00:49:34,200
そのため、 - あなたはそれを必要とするまで終了しない。

522
00:49:34,200 --> 00:49:41,880
Fスキャンfは辞書をオーバースキャンに使用されようとしているものです。

523
00:49:41,880 --> 00:49:46,370
そしてあなたはあなたの方法を試してみて、擬似コードと同じように、ソリューションをコーディングする必要はありません

524
00:49:46,370 --> 00:50:05,200
溶液にした後、我々はそれを説明します。

525
00:50:05,200 --> 00:50:14,110
私はすでに、これらを与えたので、そして、実際に、あなたは、任意の端末またはアプライアンスのシェルに入る場合

526
00:50:14,110 --> 00:50:18,250
私はだろう - 私は通常 - あなたがまだ見ていない場合は、クラスでやった場合、私は知らないが、

527
00:50:18,250 --> 00:50:23,490
しかし、男なので、manページは、かなり任意の関数を見てのためにかなり便利です。

528
00:50:23,490 --> 00:50:27,330
だから私は、、のように、スキャンfを男fを行うことができます。

529
00:50:27,330 --> 00:50:32,300
これは、現在の関数のスキャンFファミリに関する情報です。

530
00:50:32,300 --> 00:50:37,070
私はまた、オープンな男fを行うことができ、そしてそれは私にその詳細を与えるでしょう。

531
00:50:37,070 --> 00:50:40,750
ですから、あなたが使用しているか、コードを読んでいてどのような機能を知っていれば

532
00:50:40,750 --> 00:50:43,000
と "これは何をするのか？"は、いくつかの関数を参照してください、あなたが似ている

533
00:50:43,000 --> 00:50:45,280
男だけでその関数名。

534
00:50:45,280 --> 00:50:47,340
あなたが言っているかもしれない奇妙な例が​​いくつかあります

535
00:50:47,340 --> 00:50:51,620
好きです。その関数名、またはman 3関数名、男性2

536
00:50:51,620 --> 00:50:58,230
しかし、あなたは場合にのみ、男の関数名が初めて動作するように起こらないことを行う必要があります。

537
00:50:58,230 --> 00:51:03,010
[学生]だから私はオープンのmanページを読んでいるが、私はまだそれをして、プログラムを使用する方法について混乱している。

538
00:51:03,010 --> 00:51:06,170
オーケー。 manページの多くは役立たずです。

539
00:51:06,170 --> 00:51:08,470
あなたはすでに彼らが何をすべきか知ってたらもっと便利だ

540
00:51:08,470 --> 00:51:12,670
そして、あなただけの引数か何かの順番を覚えておく必要があります。

541
00:51:12,670 --> 00:51:17,640
または彼らはあなたの一般的な概要を与えることができますが、それらのいくつかは非常に圧倒的です。

542
00:51:17,640 --> 00:51:22,220
また、fはfのようなスキャン。それはあなたにこれらの機能のすべての情報を与える

543
00:51:22,220 --> 00:51:28,120
と1回線がダウンここで言う、たまたま、 "Fスキャンfは文字列ポイントまたはストリームから読み込みます。"

544
00:51:28,120 --> 00:51:32,360
しかしfが開きます。ですから、どのように我々は、fがオープン使うのでしょうか？

545
00:51:32,360 --> 00:51:38,470
ファイルを実行する必要があるプログラムのアイデアは、I / Oがあること

546
00:51:38,470 --> 00:51:45,070
は、最初に、で物事を行いたいファイルを開く必要があり、必然的に、

547
00:51:45,070 --> 00:51:51,220
そのファイルから物事を読み取ると、それらにものを行う。

548
00:51:51,220 --> 00:51:55,350
Fのオープンは、我々は、ファイルを開くために使用するものです。

549
00:51:55,350 --> 00:52:04,190
我々は取り戻すことは、我々はオープンしたいんどのファイルので、それは私たちに与える - 

550
00:52:04,190 --> 00:52:11,970
ここでは "/ユーザ/共有/辞書/単語"と述べている。

551
00:52:11,970 --> 00:52:16,740
これは、我々は、開きたいファイルであり、我々はそれを開きたい - 

552
00:52:16,740 --> 00:52:21,440
我々は、明示的に、私たちが読む、または我々が書くためにそれを開きたい場合は、それを開くかどうかを指定する必要があります。

553
00:52:21,440 --> 00:52:26,490
そこの組み合わせとかのカップルだが、我々は読書のためにこれを開きたい。

554
00:52:26,490 --> 00:52:29,380
我々は、ファイルから読みたい。

555
00:52:29,380 --> 00:52:34,290
だから、このリターンは何でしょうか？それは、ファイルの星印（*）を返す

556
00:52:34,290 --> 00:52:37,260
と私はちょうど、変数fので、*のすべてを紹介します

557
00:52:37,260 --> 00:52:40,840
再び、それはポインタだが、我々はポインタに対処する必要はありません。

558
00:52:40,840 --> 00:52:46,470
あなたは、fは今あなたがファイルを表すために使用しようとしている変数であるfを考えることができます。

559
00:52:46,470 --> 00:52:49,850
ファイルから読みたいのであれば、あなたは、fから読み取る。

560
00:52:49,850 --> 00:52:54,820
あなたがファイルをクローズする場合は、fを閉じます。

561
00:52:54,820 --> 00:53:00,350
だから我々は必然的にファイルを閉じたい、プログラムの終了時に、我々は何をすべきでしょうか？

562
00:53:00,350 --> 00:53:06,750
我々はfを閉じたい。

563
00:53:06,750 --> 00:53:12,600
我々が使用したいとしているようになりました最後のファイル機能は、スキャンF、Fスキャンfです。

564
00:53:12,600 --> 00:53:20,930
そして、どのようなことが行うことは、それが一致するパターンを探しているファイルの上にスキャンしています。

565
00:53:20,930 --> 00:53:39,100
ここのmanページを見てみると、我々はint FスキャンFを参照してください、今の戻り値を無視する。

566
00:53:39,100 --> 00:53:45,230
最初の引数はファイル*ストリームであり、我々が通過するつもりだ最初の引数がfであるので。

567
00:53:45,230 --> 00:53:47,900
我々は、ウェブ上にスキャンしている。

568
00:53:47,900 --> 00:53:53,680
二番目の引数はフォーマット文字列です。

569
00:53:53,680 --> 00:53:58,310
私は今あなたにフォーマット文字列を与える。

570
00:53:58,310 --> 00:54:05,180
私たちは、127S \ nは、不必要だとの多くを言うことが起こると思います。

571
00:54:05,180 --> 00:54:12,490
そのフォーマット文字列が何であるかのアイデアは、あなたがプリントfの反対としてスキャンfの考えることができますです。

572
00:54:12,490 --> 00:54:17,160
だからプリントF、我々はまた、formatパラメータは、このタイプを使用する印刷F、

573
00:54:17,160 --> 00:54:25,000
しかし、プリントfで私たちがやっているが - のは等価を見てみましょう。

574
00:54:25,000 --> 00:54:32,550
だから、fを印刷して、最初の引数がfであることを行っているウェブプリントfは、また、実際にあります。

575
00:54:32,550 --> 00:54:40,980
我々はそれにいくつかの文字列を渡す場合は、fを印刷するとき、我々は、その後、同じように何かを言う "印刷127S \ n"と可能性

576
00:54:40,980 --> 00:54:44,050
それは、この文字列とし、新しい行を印字することになっている。

577
00:54:44,050 --> 00:54:49,690
何が127手段、私はかなり確信しているが、私はそれに自分自身を制限したことがない

578
00:54:49,690 --> 00:54:52,470
あなたも、印刷fに'127 'を言う必要はないでしょう

579
00:54:52,470 --> 00:54:57,090
しかし、その意味することは最初の127文字を印刷しています。

580
00:54:57,090 --> 00:54:59,350
だから私はケースだとかなり確信している。あなたはそのためにGoogleができます。

581
00:54:59,350 --> 00:55:03,000
しかし、次のいずれかで、私はそれがあることを意味ほとんど肯定的だ。

582
00:55:03,000 --> 00:55:08,880
だから、これは新しい行に続く最初の127文字を印刷しています。

583
00:55:08,880 --> 00:55:14,680
FスキャンF今、代わりの変数を見て、それを印刷し、

584
00:55:14,680 --> 00:55:22,620
それはいくつかの文字列を見て、変数にパターンを保存するために起こっている。

585
00:55:22,620 --> 00:55:26,360
実際には別の例では、スキャンfを使用してみましょう。

586
00:55:26,360 --> 00:55:31,670
それでは、我々はいくつかのint型は、x = 4を持っていたとしましょう

587
00:55:31,670 --> 00:55:41,110
そして我々はで構成された文字列を作成したいと思った - 文字列を作成したいと思った

588
00:55:41,110 --> 00:55:44,250
それはのようだった、これはずっと後に出てくる、

589
00:55:44,250 --> 00:55:49,020
ちょうど4.jpg私のようなものだもの。

590
00:55:49,020 --> 00:55:51,870
だから、これは、あなたが合計カウンタを持っているでしょうプログラムかもしれない

591
00:55:51,870 --> 00:55:56,420
カウンタiを合計し、あなたは画像の束を保存したい。

592
00:55:56,420 --> 00:56:02,430
だから、私はあなたのループのいくつかの繰り返しですi.jpgを、保存したい。

593
00:56:02,430 --> 00:56:05,500
だから我々はそのJPEGのためにこの文字列をどのように作るのですか？

594
00:56:05,500 --> 00:56:11,720
あなたは4.JPG印刷したい場合、我々はちょうど、印刷のfは、％d.jpgを言うことができる

595
00:56:11,720 --> 00:56:14,410
そしてそれはそのJPEGのために印刷されます。

596
00:56:14,410 --> 00:56:20,050
我々は文字列4.JPGを保存したい場合は、しかし、私たちは、スキャンfを使います。

597
00:56:20,050 --> 00:56:30,860
文字列sのように - 実際に我々はマストアイテム - 文字は、char sでの100を手放す。

598
00:56:30,860 --> 00:56:35,400
だから、僕は、100文字の一部の配列を宣言した

599
00:56:35,400 --> 00:56:39,830
そしてそれは我々が必然的にそのJPEGをインチ保存しようとしているものです

600
00:56:39,830 --> 00:56:47,920
だから我々は、スキャンfを使用しようと、我々は％d.jpgだと思いますどのようにフォーマット、している

601
00:56:47,920 --> 00:56:54,980
4.JPG印刷するためには、このコマンドの形式は、％d.jpgになるだろう。

602
00:56:54,980 --> 00:57:04,020
フォーマットは％d.jpgですので、私たちが使用して％dを交換したいとxは、

603
00:57:04,020 --> 00:57:06,590
そして今我々はどこかでその文字列を格納する必要があります。

604
00:57:06,590 --> 00:57:12,500
そして、我々はこの文字列を格納しようとしている場所は、配列sにあります。

605
00:57:12,500 --> 00:57:21,640
だから、コード、sのこの行の後に、我々は変数sのf、％sを印刷する場合、

606
00:57:21,640 --> 00:57:26,280
それは4.JPG印字することになっている。

607
00:57:26,280 --> 00:57:38,930
だからFスキャンfが、今では、このファイルに目を通している場合を除き、スキャンfと同じです

608
00:57:38,930 --> 00:57:43,600
sに格納するための何のために。

609
00:57:43,600 --> 00:57:46,160
それは最後の引数があると何が起こっているか。

610
00:57:46,160 --> 00:57:54,170
機能スキャンの "スキャンFファミリをしようとしたので、下記の両方のフォーマットに応じてで - 私たちは、保存したいと思うでしょう。

611
00:57:54,170 --> 00:58:02,450
任意の場所をポイントに保存されている場合は戻るかもしれません -  "

612
00:58:02,450 --> 00:58:12,910
いいえ、私たちは良いかもしれません。私は一瞬考えてみましょう。

613
00:58:12,910 --> 00:58:26,350
だからスキャンfはない - 一体、その処理を実行する関数は何ですか？

614
00:58:26,350 --> 00:58:31,650
だからスキャンfは整数を取るとドットJPGをするつもりはありません。

615
00:58:31,650 --> 00:58:43,490
それは[マンブルズ]になるだろう。

616
00:58:43,490 --> 00:58:49,360
文字列のint Cのint型の変数を保存

617
00:58:49,360 --> 00:58:55,940
この変数は何ですか、この関数は何と呼ばれる？

618
00:58:55,940 --> 00:59:04,950
はい。 That's  - はい。だから私はあなたの前に定義されたものであり、sプリントFだった

619
00:59:04,950 --> 00:59:09,820
いる - 私はそれがプリントfのようなはるかに言いました、その理由は、はるかに理にかなっています。

620
00:59:09,820 --> 00:59:14,700
スキャンfはまだのようなプリントfの一種であるが、sプリントfはそれを上にスキャンしようとしている

621
00:59:14,700 --> 00:59:17,510
と変数を置き換えると、文字列に格納します。

622
00:59:17,510 --> 00:59:19,620
代わりに、それを印刷するのではなく、文字列に格納します。

623
00:59:19,620 --> 00:59:25,070
だから、完全に無視してください。あなたはまだプリントfのようなような書式指定子と考えることができます。

624
00:59:25,070 --> 00:59:34,510
我々は4.JPG事をしたいならだから今、私たちは、これのxをsのプリントfを行うだろう。

625
00:59:34,510 --> 00:59:38,520
だからスキャンfは何をしている - あなたの質問があることを行っていたでしょうか？

626
00:59:38,520 --> 00:59:40,820
[学生]私はちょうどここで我々が​​やろうとしていることに困惑している

627
00:59:40,820 --> 00:59:43,450
そのJPEGと。あなたはその1以上の時間を説明できますか？

628
00:59:43,450 --> 00:59:52,710
だから、これはあった - それは、fスキャンF今までより少ないreleventです;うまくいけば、それが道のいくつかの種類に戻って結ぶでしょう。

629
00:59:52,710 --> 01:00:02,240
しかし、私が最初に表示するように意図されたことだった - これは、実際には、これらの[に直接関係ある？ F5]

630
01:00:02,240 --> 01:00:08,520
あなたは、我々は100枚の画像を持っていると言うのprint fを使用してすることになるだろう

631
01:00:08,520 --> 01:00:13,630
が、このイメージ1.JPG、2.JPG、3.JPGを読んでもらいたい。

632
01:00:13,630 --> 01:00:21,520
だから、そのためには、あなたが開いているFに必要があり、その後、あなたが開こうとしている文字列を渡す必要があります。

633
01:00:21,520 --> 01:00:30,020
だから我々は1.JPG開きたいだろう。1.JPGである文字列を作成するために、

634
01:00:30,020 --> 01:00:37,660
％の我々がやるのプリントfはd.jpg-我々はint i = 0のためにしませんでした。

635
01:00:37,660 --> 01:00:46,580
私は<40、i + +は。

636
01:00:46,580 --> 01:00:51,130
プリントのf％iのd.jpg sがそう。

637
01:00:51,130 --> 01:00:56,320
したがって、この行の後に、すぐに変数や配列sは1.JPGに起こっている。

638
01:00:56,320 --> 01:01:10,610
または、0.JPG、1.JPG、2.JPG。そして私たちは、順番に、読書のためのそれぞれの画像を開くことができます。

639
01:01:10,610 --> 01:01:19,550
だからのprint fは何をするかです。あなたは、sプリントfは今何をしているかわかりますか？

640
01:01:19,550 --> 01:01:25,720
[学生]わかりましたので、それは取っている - それは文字列を作成し、something.jpgし、それを格納します。

641
01:01:25,720 --> 01:01:30,360
はい。これは、作成する - これは単なるスキャンfとプリントfのように、別の形式の文字列で、

642
01:01:30,360 --> 01:01:37,530
場所第二引数に挿入するすべての変数を、sとiに反対したかもしれません。

643
01:01:37,530 --> 01:01:42,280
多分 - 私はケースだ、という意味。しかし、どのような引数の順序は次の通りです。

644
01:01:42,280 --> 01:01:45,440
これは、書式指定文字列にすべての変数を挿入するために起こっている

645
01:01:45,440 --> 01:01:52,250
その後私たちのバッファに格納し、我々は文字列を格納している場所バッファは、それがだと呼んでいます。

646
01:01:52,250 --> 01:02:00,750
だから我々は、Sの中で正しくフォーマットされた文字列を格納して、％dが4に置き換えられました。

647
01:02:00,750 --> 01:02:08,080
[学生]は、だから我々はこれをした場合、変数fはちょうど再割り当てすることはするつもりですか？

648
01:02:08,080 --> 01:02:18,110
はい。だから我々はこれを行う前に、元のfを閉じる必要があります。

649
01:02:18,110 --> 01:02:22,810
が、 -  fここで開くが存在しなかった場合、その後も、、我々は、言う必要があるだろう - 

650
01:02:22,810 --> 01:02:29,280
うん。しかし、それは百の異なるファイルを開くだろう。

651
01:02:29,280 --> 01:02:37,360
大丈夫 -  [学生]しかし、我々は、アクセスしたりすることができないだろう。

652
01:02:37,360 --> 01:02:44,230
オーケー。だからスキャンF、Fスキャンfは、同じアイデアの一種である

653
01:02:44,230 --> 01:02:53,610
しかし代わりに、文字列の代わりにそれを格納するのではなく、それはあなたが今以上のようなものだ

654
01:02:53,610 --> 01:03:02,420
その文字列に対してマッチングを刺され、パターン上に行くと変数に結果を格納します。

655
01:03:02,420 --> 01:03:11,290
あなたは4.jpg私のような何かを解析するためにスキャンfを使用し、和のint xに整数値4を格納することができます。

656
01:03:11,290 --> 01:03:13,430
それは我々のためにスキャンfを使用することができるものだ。

657
01:03:13,430 --> 01:03:16,300
Fスキャンfは、コマンドラインでそれをやろうとする。

658
01:03:16,300 --> 01:03:19,200
私は実際にこれはCS50ライブラリが何をするかであると確信しています。

659
01:03:19,200 --> 01:03:29,050
だからあなたが言うとき、 "int型を取得、"それは、スキャンF-INGは終わった - スキャンfは、ユーザー入力を取得する方法です。

660
01:03:29,050 --> 01:03:34,670
Fスキャンfは同じことをやろうとしますが、オーバースキャンするファイルを使用しています。

661
01:03:34,670 --> 01:03:41,090
だからここで、我々は、このファイルを走査しています。

662
01:03:41,090 --> 01:03:45,460
我々が一致しようとしているパターンは、127文字の長さで、いくつかの文字列です。

663
01:03:45,460 --> 01:03:48,100
新しい行が続か

664
01:03:48,100 --> 01:03:54,770
だから私は、辞書の中から "、sにマッチし、"私たちも、ただ言うことをかなり確信して

665
01:03:54,770 --> 01:03:57,770
我々が持っているために起こる、我々は全く言葉がそれほど長くありません保証されている、

666
01:03:57,770 --> 01:04:03,310
また、Fスキャンfは、私が思うに、新しい行が何でで停止します。

667
01:04:03,310 --> 01:04:06,970
しかし、我々は試合で新しい行が含まれており、よ - 

668
01:04:06,970 --> 01:04:13,960
[学生]は、我々は新しい行を含んでいなかったなら、それは単語の部分を見つけることができませんでしょうか？

669
01:04:13,960 --> 01:04:22,900
それ - 各 - 辞書を見て - 

670
01:04:22,900 --> 01:04:26,200
だから辞書には、これらは私たちの言葉のすべてです。

671
01:04:26,200 --> 01:04:30,500
一人一人が新しい行に表示されます。

672
01:04:30,500 --> 01:04:32,510
スキャンfはこの言葉をピックアップしようとしている。

673
01:04:32,510 --> 01:04:38,750
我々は新しい行が含まれていない場合、それは次のスキャンfは単に新しい行が読み込まれている可能性があります。

674
01:04:38,750 --> 01:04:44,180
しかし、新たなラインを含むそしてちょうど新しい行を無視します。

675
01:04:44,180 --> 01:04:49,440
我々は常に何があろうと、新しい行まで読み込みをしなくなるので、しかし、我々は、単語の一部を得ることは決してないだろう。

676
01:04:49,440 --> 01:04:54,530
しかし、何cissaような単語 "cissa、"を検索する場合、[学生]。

677
01:04:54,530 --> 01:04:57,380
それはそれを見つけて、それが試合だと言うのだろうか？

678
01:04:57,380 --> 01:05:05,110
そこでここでは、 - それは読んでます - これは実際には良い点です。

679
01:05:05,110 --> 01:05:10,660
我々は、現在のを使用することはありませんしている - 我々が探している単語は、最初のコマンドライン引数です。

680
01:05:10,660 --> 01:05:16,460
だから文字列、単語= argvは1。

681
01:05:16,460 --> 01:05:20,020
だから我々が探している文字列は、argvは1である。

682
01:05:20,020 --> 01:05:23,290
私たちは、スキャンfにあるすべての単語を探していません。

683
01:05:23,290 --> 01:05:28,030
我々はスキャンfで何をしていたが、辞書の各単語を取得している

684
01:05:28,030 --> 01:05:34,320
その後一度私たちはそれらを比較するstrcmpを使用するつもりだその言葉を持っています。

685
01:05:34,320 --> 01:05:39,210
私達は私達の言葉を比較しようとしていると、私たちはただ読み込む

686
01:05:39,210 --> 01:05:45,110
だから必然的に、我々は、スキャンfsの束をやってしまうつもりだ

687
01:05:45,110 --> 01:05:52,130
 - それはちょうどので、スキャンfが返されていることが起こるまで

688
01:05:52,130 --> 01:05:54,800
それは、限り、それは新しい単語にマッチしたように、1を返します。

689
01:05:54,800 --> 01:06:01,360
そして、それはできるだけ早くそれが単語に一致するように失敗したとして、何か他のものを返します。

690
01:06:01,360 --> 01:06:08,440
我々は、変数sに各ワード行ずつ格納し、全体の辞書を読んでいる。

691
01:06:08,440 --> 01:06:17,240
その後、我々は、sで単語を比較し、その比較は== 0の場合、アール

692
01:06:17,240 --> 01:06:21,650
strcmpは、一致した場合は0を持って来るために起こる。

693
01:06:21,650 --> 01:06:31,510
それが0だったので、もし、我々は、一致した、fを印刷することができます

694
01:06:31,510 --> 01:06:35,370
または単語が辞書にあるか、またはあなたは、fを印刷したいものは何でも。

695
01:06:35,370 --> 01:06:41,450
そして、 - 我々は、fが何度も何度も上に閉じてしたくない。

696
01:06:41,450 --> 01:06:50,410
これは、我々がやりたいことの一種であり、私達はちょうど辞書で単語を探していない。

697
01:06:50,410 --> 01:06:56,660
だから我々は、あなたが前に言ったように、我々は彼らのパターン、cissa探したい場合は、次のことを行うことができます

698
01:06:56,660 --> 01:07:00,260
我々はそのパターンを探したいなら、それは場合に失敗するでしょう

699
01:07:00,260 --> 01:07:08,010
それは実際に言葉ではないので、辞書内の単語の一つは、それでそれを持っていることを起こる。

700
01:07:08,010 --> 01:07:13,560
だから、この言葉を一致させるだろうが、言葉のこのサブセットは、単語自体ではありません。

701
01:07:13,560 --> 01:07:17,250
しかし、それは我々がそれを使用している方法ではありません、我々はそれぞれの単語で読んでいる

702
01:07:17,250 --> 01:07:19,740
その後、我々はその言葉で持っている単語を比較する。

703
01:07:19,740 --> 01:07:25,780
だから我々は常に完全な単語を比較している。

704
01:07:25,780 --> 01:07:29,620
私は後で確定ソリューションを送ることができます。

705
01:07:29,620 --> 01:07:32,050
これはほぼ正しい答えのようなものですが、私は思う。

706
01:07:32,050 --> 01:07:34,720
[学生のコメント、不明朗]

707
01:07:34,720 --> 01:07:40,870
ああ、私は前にそれを取り除くためでしたか？ charのは、私たちは127を言ったと思います - 私は最大のが何であるかを忘れている。

708
01:07:40,870 --> 01:07:44,100
我々は、ちょうど128をやる;ので、今sは十分な長さです。

709
01:07:44,100 --> 01:07:46,570
我々は何も印刷する必要はありません。

710
01:07:46,570 --> 01:07:56,440
我々はまた、我々のファイルを閉じる必要はするつもりだし、それは正しい答えであるべきである。

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