1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Problem Sekcja 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
To CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Tak, jestem Rob. Jestem starszy w Kirkland. To jest mój trzeci rok TFing CS50.

5
00:00:15,770 --> 00:00:22,220
To jest pierwszy raz, kiedy się zmieniają od tradycyjnego wykładu stylu sekcji

6
00:00:22,220 --> 00:00:25,610
gdzie po prostu rodzaj przeglądu, co stało się w wykładzie, a potem wy zadawać pytania,

7
00:00:25,610 --> 00:00:32,250
teraz jest o wiele więcej problemów, oparte, gdzie należy używać spacji, a -

8
00:00:32,250 --> 00:00:37,410
Oh, więc pomysł jest, aby przejść do tego łącza wysłałem cię i będziesz w mojej przestrzeni.

9
00:00:37,410 --> 00:00:42,410
Nie ktoś ma laptopa? Okay.

10
00:00:42,410 --> 00:00:47,050
Więc mamy zamiar używać to i będziemy robić problemów żyć w sekcji

11
00:00:47,050 --> 00:00:50,740
i omawianie ich i zastanawianie się, co jest nie tak

12
00:00:50,740 --> 00:00:56,390
i mógłbym wyciągnąć niektóre z Twojego kodu i mógłbym przedyskutować swoje pomysły.

13
00:00:56,390 --> 00:01:02,140
Więc czy ktoś miał trudności?

14
00:01:02,140 --> 00:01:07,000
Można rozmawiać na boku, ja nie wiem, czy będziemy mieć powód.

15
00:01:07,000 --> 00:01:12,270
Teraz, podobnie jak w poprzednim supersection, jeśli były w tym klasy, wiesz, co to chodzi.

16
00:01:12,270 --> 00:01:19,200
Na wszystkich zestawów P nie będzie tych sekcjach.

17
00:01:19,200 --> 00:01:22,550
Więc P-set 2, specyfikacje, Chyba widziałem to na P-set 1 już.

18
00:01:22,550 --> 00:01:27,400
Ale możemy spojrzeć na P-2 do zestawu, co będziemy się iść na dzisiaj.

19
00:01:27,400 --> 00:01:29,460
I zobaczysz sekcję pytań.

20
00:01:29,460 --> 00:01:37,530
Więc będzie to w każdym z zestawów P, tam będzie część pytań.

21
00:01:37,530 --> 00:01:41,340
Do tej pory powiedział, "Rozważ to okazja do praktyki."

22
00:01:41,340 --> 00:01:44,940
Nie będzie poproszony o przesłanie tego programu.

23
00:01:44,940 --> 00:01:48,480
Chodzi o to, że te mają rodzaju pomogą Ci rozpocząć z zestawem problem.

24
00:01:48,480 --> 00:01:53,220
Chyba od wersji hacker, wiele z nich mają być tylko nowe, ciekawe rzeczy do nauki.

25
00:01:53,220 --> 00:01:58,590
Nie mogą być bezpośrednio stosowane do zestawu problemu.

26
00:01:58,590 --> 00:02:01,810
A teraz nie masz je zgłosić, ale w teorii,

27
00:02:01,810 --> 00:02:07,480
dla późniejszych zespołów problemowych, może je zgłosić, a więc możesz przyjść do sekcji

28
00:02:07,480 --> 00:02:10,380
lub obejrzeć sekcję, aby uzyskać odpowiedzi, czy można po prostu ich na własną rękę

29
00:02:10,380 --> 00:02:16,350
jeśli nie czujesz się jak cieszyć moją obecność.

30
00:02:16,350 --> 00:02:21,010
Tak - myślę, że jest to pierwszy z nich.

31
00:02:21,010 --> 00:02:29,280
Oh. Także, w ramach tych sekcji pytań mamy także zadać pytania o szorty.

32
00:02:29,280 --> 00:02:33,440
Sądzę więc, że w teorii, masz się oglądać te przed przyjściem do sekcji,

33
00:02:33,440 --> 00:02:38,550
ale to jest w porządku, jeśli nie, pójdziemy nad nimi w każdym razie.

34
00:02:38,550 --> 00:02:42,590
Tak więc możemy zacząć od tego: "Jak pętla różni się od do-while pętli?

35
00:02:42,590 --> 00:02:46,210
Kiedy jest ona szczególnie przydatna? "

36
00:02:46,210 --> 00:02:49,390
Więc ktoś ma jakiekolwiek -

37
00:02:49,390 --> 00:02:52,730
[Student] do-while zawsze wykonać co najmniej raz.

38
00:02:52,730 --> 00:03:02,950
Tak. Tak, że jest różnica. Pętla - ll po prostu zrób to tu - przy pętli, mamy warunek

39
00:03:02,950 --> 00:03:19,760
tu, natomiast do-while, nie masz warunek, aż dojdziemy tutaj.

40
00:03:19,760 --> 00:03:24,130
I tak, gdy program jest wykonywany, i dostaje się do pętli while,

41
00:03:24,130 --> 00:03:26,380
natychmiast sprawdza, czy ten warunek jest spełniony.

42
00:03:26,380 --> 00:03:30,710
Jeśli ten warunek nie jest prawdziwy, to po prostu pominąć pętlę całkowicie.

43
00:03:30,710 --> 00:03:34,390
Do-while, ponieważ program jest wykonywany, to dostaje się "zrobić".

44
00:03:34,390 --> 00:03:37,920
Nic w tym momencie dzieje się, tak kontynuuje wykonywanie.

45
00:03:37,920 --> 00:03:42,690
Potem, gdy trafi na "chwilę", jeśli warunek jest spełniony, to będzie pętla kopię i zrobić to ponownie

46
00:03:42,690 --> 00:03:46,730
i znowu i znowu, aż warunek nie jest prawdziwy, a potem po prostu spada przez.

47
00:03:46,730 --> 00:03:50,600
Tak, różnica jest, że to można pominąć od samego początku.

48
00:03:50,600 --> 00:03:56,770
To niekoniecznie jest wykonywany raz i może wykonywać więcej razy, jeśli warunek jest nadal prawdziwe.

49
00:03:56,770 --> 00:04:03,720
Więc pętla będzie tylko zrobić to raz, lub - podczas pętli - nie może trzeba to zrobić w ogóle,

50
00:04:03,720 --> 00:04:07,900
ponieważ jak najszybciej dostać się do niego, jeśli warunek nie jest spełniony, po prostu pomiń tuż nad nim.

51
00:04:07,900 --> 00:04:11,770
Mając na uwadze, do-while, będziemy wykonywać go raz, niekoniecznie.

52
00:04:11,770 --> 00:04:14,560
Potem, kiedy dojdziemy do stanu, możemy sprawdzić, czy to prawda czy fałsz.

53
00:04:14,560 --> 00:04:19,790
Jeśli to prawda, będziemy zrobić to ponownie, jeśli jest fałszywe, musimy po prostu dalej będzie.

54
00:04:19,790 --> 00:04:24,680
Więc kiedy jest ona szczególnie przydatna?

55
00:04:24,680 --> 00:04:31,190
Więc mogę powiedzieć, że w całości 4 lata, 3 lata, cokolwiek,

56
00:04:31,190 --> 00:04:38,780
że byłem programowania, użyłem tego, jak pod 10 razy.

57
00:04:38,780 --> 00:04:43,140
I prawdopodobnie 5 z nich jest w CS50 kiedy wprowadzamy do-while pętle.

58
00:04:43,140 --> 00:04:47,510
Więc kiedy użyłeś-while pętle?

59
00:04:47,510 --> 00:04:49,510
Kiedy jest - tak?

60
00:04:49,510 --> 00:04:53,180
[Student] Jeśli próbujesz dostać dane wprowadzone przez użytkownika, czy coś chcesz sprawdzić -

61
00:04:53,180 --> 00:04:59,700
Tak. Więc zrób pętle while, instrukcja wejścia jest duży.

62
00:04:59,700 --> 00:05:03,160
Dlatego na pierwszych zbiorów problemowych kilka, jeśli chcesz zwrócić się do użytkownika, jak,

63
00:05:03,160 --> 00:05:08,520
"Daj mi łańcuch," nie można kontynuować aż do uzyskania tego ciągu.

64
00:05:08,520 --> 00:05:12,980
I tak, koniecznie, trzeba prosić o ciąg co najmniej raz.

65
00:05:12,980 --> 00:05:16,950
Ale potem, jeśli odpowiedzieć coś złego, to trzeba do pętli i zapytać ponownie.

66
00:05:16,950 --> 00:05:20,810
Ale inne niż wejściowych użytkownika, to bardzo rzadko spotykam przypadek

67
00:05:20,810 --> 00:05:27,170
gdzie chcę pętli "co najmniej raz", ale prawdopodobnie więcej.

68
00:05:27,170 --> 00:05:33,370
Pytania lub -? Czy ktoś wykorzystywane do-while gdziekolwiek indziej?

69
00:05:33,370 --> 00:05:36,780
Okay. Więc następny jest: "Co ma identyfikator nielegalna

70
00:05:36,780 --> 00:05:43,310
zazwyczaj wskazują, czy wyprowadzać przez brzękiem? "

71
00:05:43,310 --> 00:05:47,380
Więc jaki kod można napisać, aby uzyskać "nielegalnej identyfikator?

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

73
00:05:49,550 --> 00:05:52,650
Tak więc możemy po prostu spróbować tutaj, x = 2.

74
00:05:52,650 --> 00:06:04,830
Pobiegamy ta - oh, nie kliknąć. Więc tutaj mamy - wszystko w porządku.

75
00:06:04,830 --> 00:06:07,100
"Korzystanie z niezadeklarowanych x identyfikacyjnych".

76
00:06:07,100 --> 00:06:11,610
Więc to jest nielegalna identyfikator, zmienny.

77
00:06:11,610 --> 00:06:13,910
To często nazywamy zmienną identyfikator.

78
00:06:13,910 --> 00:06:17,300
Więc może nie wiedzieć, że to faktycznie zmienna, ale nie wie, co to jest.

79
00:06:17,300 --> 00:06:19,380
Więc to jest identyfikator.

80
00:06:19,380 --> 00:06:26,060
Więc dlaczego jest nielegalna? Tak.

81
00:06:26,060 --> 00:06:32,190
Tak, aby jasno terminologii deklaracji zmiennej

82
00:06:32,190 --> 00:06:37,360
jest, kiedy powiedzieć "int x" lub "ciąg r" Cokolwiek.

83
00:06:37,360 --> 00:06:41,910
Inicjalizacja zmiennej, lub przypisanie zmiennej,

84
00:06:41,910 --> 00:06:44,510
jest, gdy mówisz "x = 2".

85
00:06:44,510 --> 00:06:52,950
Więc możemy zrobić to w oddzielnych etapach, int x, x = 2, a do - możemy mieć kilka rzeczy tutaj -

86
00:06:52,950 --> 00:07:00,350
ale dopóki linia ta się dzieje, x jest nadal zainicjowana, ale został uznany.

87
00:07:00,350 --> 00:07:06,760
I tak możemy oczywiście zrobić to w 1 linii, a teraz jesteśmy deklarowania i inicjalizacji.

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

89
00:07:10,730 --> 00:07:18,390
I wreszcie: "Dlaczego nie jest szyfr Cezara bardzo bezpieczna?"

90
00:07:18,390 --> 00:07:23,830
Więc po pierwsze, czy ktoś chce powiedzieć, co Cipher Cezar?

91
00:07:23,830 --> 00:07:28,100
[Student] Caesar Cipher tylko jest to, że mapa, zmieniasz każdy list,

92
00:07:28,100 --> 00:07:34,420
pewna liczba liter przejść i wrócić nad i nie jest bardzo bezpieczny, ponieważ

93
00:07:34,420 --> 00:07:42,260
są tylko 26 możliwych opcji i po prostu trzeba spróbować każdego 1 osób aż dostaniesz.

94
00:07:42,260 --> 00:07:45,470
Oh. Tak więc, czy mam powtarzać?

95
00:07:45,470 --> 00:07:51,600
Caesar Cipher, it's - mam na myśli, będziemy mieć do czynienia z nim na temat problemów, które -

96
00:07:51,600 --> 00:07:56,110
lub chyba standardową edycję zestawu problemów, które nie znajduje się na wydanie hakerów.

97
00:07:56,110 --> 00:08:01,550
Więc w standardowej wersji do zestawu problemów, otrzymasz komunikat w stylu: "Witaj, świecie"

98
00:08:01,550 --> 00:08:08,410
i masz numer jak 6, i wziąć to przesłanie, a każdy znak,

99
00:08:08,410 --> 00:08:11,310
go obrócić o 6 pozycji w alfabecie.

100
00:08:11,310 --> 00:08:16,560
Tak "H" w stanie Cześć H-I-J-K-L-M-N.

101
00:08:16,560 --> 00:08:19,600
Więc pierwsza litera będzie n. Robimy to samo z e.

102
00:08:19,600 --> 00:08:23,530
Jeśli mamy, jak, z, czy coś, potem owinąć powraca do "."

103
00:08:23,530 --> 00:08:29,280
Ale każda postać dostaje cyklicznie 6 znaków później w alfabecie, a to nie jest bardzo bezpieczny

104
00:08:29,280 --> 00:08:35,440
ponieważ tylko 26 możliwości, jak wiele sposobów można zawinąć pojedynczą literę.

105
00:08:35,440 --> 00:08:42,919
Więc możesz po prostu spróbować wszystkich 26 z nich i, prawdopodobnie, przez długi wiadomości wystarczy,

106
00:08:42,919 --> 00:08:46,860
tylko 1 z tych możliwych 26 rzeczy będzie czytelne,

107
00:08:46,860 --> 00:08:50,300
i czytelne jeden będzie oryginalna wiadomość.

108
00:08:50,300 --> 00:08:56,240
Więc to nie jest bardzo dobry sposób szyfrowania w ogóle coś jest.

109
00:08:56,240 --> 00:08:59,070
Niezwiązane z tych spodenek, "Co to jest funkcja?"

110
00:08:59,070 --> 00:09:03,370
Więc co to jest funkcja? Tak.

111
00:09:03,370 --> 00:09:11,640
[Student] To jest jak oddzielny fragment kodu, który można zadzwonić, aby przejść przez, a następnie uzyskać wartości zwracanej cokolwiek.

112
00:09:11,640 --> 00:09:18,160
Tak. Więc ja odpowiem również poprzez odpowiadanie następny - lub też po prostu przez powtarzanie odpowiedzi na następny.

113
00:09:18,160 --> 00:09:22,410
Możesz użyć funkcji zamiast kopiowania i wklejania kodu w kółko.

114
00:09:22,410 --> 00:09:27,200
Wystarczy wziąć ten kod, umieścić go w fuction, a następnie można po prostu wywołać funkcję

115
00:09:27,200 --> 00:09:29,870
gdziekolwiek zostały kopiowanie i wklejanie.

116
00:09:29,870 --> 00:09:33,350
Więc funkcje są użyteczne.

117
00:09:33,350 --> 00:09:35,860
Więc teraz zrobimy rzeczywistych problemów.

118
00:09:35,860 --> 00:09:46,490
Pierwszy. Tak więc idea pierwszego jest, przechodzi to łańcuch, i niezależnie od tego -

119
00:09:46,490 --> 00:09:52,060
czy też powiedzieć wszystkie małe litery? Nie powiedzieć wszystkie małe litery.

120
00:09:52,060 --> 00:09:57,730
Więc wiadomość może być cokolwiek, i - o nie. Robi.

121
00:09:57,730 --> 00:10:01,610
"Dla uproszczenia można przyjąć, że użytkownik będzie tylko wejście małych liter i spacji."

122
00:10:01,610 --> 00:10:08,180
Więc przekaż mu wiadomość z tylko małymi literami a potem naprzemiennie

123
00:10:08,180 --> 00:10:15,450
między wielkimi i małymi literami - zmieniamy łańcuch zostanie kapitał i wielkie, na przemian.

124
00:10:15,450 --> 00:10:22,920
Więc zanim damy Ci sekund do nawet nurkować do problemu,

125
00:10:22,920 --> 00:10:32,420
to, co jest pierwszą rzeczą, która musimy zrobić?

126
00:10:32,420 --> 00:10:36,900
Oh, co ja po prostu kliknij na? Och, ja tylko kliknął email tutaj.

127
00:10:36,900 --> 00:10:42,870
Więc pierwszą rzeczą, którą trzeba zrobić - ja szukam w złym jeden?

128
00:10:42,870 --> 00:10:49,320
Czy to jest częścią tego?

129
00:10:49,320 --> 00:10:51,320
Nie, to nadal tam jest, choć.

130
00:10:51,320 --> 00:10:55,160
Ok, nadal tutaj.

131
00:10:55,160 --> 00:11:03,160
Teraz nie możemy zakładać, -? Tak. Tutaj nie możemy zakładać, że jest to tylko małe litery i spacje.

132
00:11:03,160 --> 00:11:07,770
Więc teraz mamy do czynienia z faktem, że litery mogą być, co chcemy, żeby były.

133
00:11:07,770 --> 00:11:11,910
A więc pierwszą rzeczą, którą chcesz zrobić, to po prostu komunikat.

134
00:11:11,910 --> 00:11:19,790
Musimy tylko dostać ciąg string s = getString, okay.

135
00:11:19,790 --> 00:11:24,890
Teraz ten problem, istnieje kilka sposobów na to zrobić.

136
00:11:24,890 --> 00:11:29,840
Ale mamy zamiar użyć operatory bitowe tutaj.

137
00:11:29,840 --> 00:11:35,280
Czy są ludzie, którzy albo nie byli w supersection,

138
00:11:35,280 --> 00:11:37,480
lub coś, i nie wiem, co operatory bitowe są?

139
00:11:37,480 --> 00:11:41,710
Albo jak odnoszą się one do ASCII w jakikolwiek sposób?

140
00:11:41,710 --> 00:11:45,650
[Student] I nie było w supersection, ale wiem, co operatory bitowe są.

141
00:11:45,650 --> 00:11:49,560
Okay. Więc nie muszę iść na podstawy nich, ale postaram się wyjaśnić

142
00:11:49,560 --> 00:11:51,830
co mamy zamiar użyć tutaj.

143
00:11:51,830 --> 00:11:59,680
Więc 'A': reprezentacja Binary kapitału A liczba jest 65.

144
00:11:59,680 --> 00:12:07,560
Idę patrzeć - 41 będzie 01000001.

145
00:12:07,560 --> 00:12:14,170
Tak, że powinno być 65 w notacji dziesiętnej, więc to jest reprezentacja binarna postać kapitału A.

146
00:12:14,170 --> 00:12:19,440
Teraz reprezentacja binarna charakteru małe litery 'a'

147
00:12:19,440 --> 00:12:33,350
będzie to samo, prawie. Jest to, że - 6, yeah. To jest w porządku.

148
00:12:33,350 --> 00:12:37,670
Więc binary kapitał, binarne małej '.'

149
00:12:37,670 --> 00:12:43,940
Więc zauważyć, że różnica między i "a" jest to jeden bit.

150
00:12:43,940 --> 00:12:49,440
I to dzieje się 32 bit, bit reprezentujący liczbę 32.

151
00:12:49,440 --> 00:12:53,910
I to ma sens, ponieważ jest 65, "a" jest 97.

152
00:12:53,910 --> 00:12:56,610
Różnica między nimi wynosi 32.

153
00:12:56,610 --> 00:13:03,770
Więc teraz wiemy, że możemy przekonwertować z A do 'A' poprzez

154
00:13:03,770 --> 00:13:09,710
i logiczną ORing go, z - który wygląda jak 1.

155
00:13:09,710 --> 00:13:20,900
To jest bitowym OR z 00100000, i że da nam '. "

156
00:13:20,900 --> 00:13:26,850
I możemy się od "A" do poprzez mnożenie logiczne

157
00:13:26,850 --> 00:13:33,700
z 11, 0 w tym miejscu, 11111.

158
00:13:33,700 --> 00:13:43,840
Więc to będzie nam dać dokładnie to, co "było, ale znoszą tę indywidualną trochę,

159
00:13:43,840 --> 00:13:50,070
więc będziemy mieć 01000001, ja nie wiem, czy mogę liczyć w prawo.

160
00:13:50,070 --> 00:13:56,750
Ale ta technika bitowej ORing dostać od kapitału na małe litery,

161
00:13:56,750 --> 00:14:02,080
i mnożenie logiczne dostać się z małej litery do kapitału nie jest zarezerwowana dla A.

162
00:14:02,080 --> 00:14:06,510
Wszystkie litery, K vs K, Z vs z,

163
00:14:06,510 --> 00:14:10,080
wszystkie z nich są po prostu będzie się różnić o tego jednego bitu.

164
00:14:10,080 --> 00:14:16,290
I tak można to wykorzystać, aby zmienić z dowolnego małej litery do każdej litery i odwrotnie.

165
00:14:16,290 --> 00:14:26,670
Okay. Tak łatwy sposób na uzyskanie z tego - więc zamiast

166
00:14:26,670 --> 00:14:32,170
pisać cokolwiek 1011111 jest - łatwy sposób reprezentująca ten numer, a to nie jest jeden

167
00:14:32,170 --> 00:14:39,710
że poszedłem w supersection, ale tylda (~) jest kolejnym bitwise operator.

168
00:14:39,710 --> 00:14:42,520
Co ~ robi to patrzy na reprezentacji bitowej.

169
00:14:42,520 --> 00:14:45,630
Weźmy dowolny numer.

170
00:14:45,630 --> 00:14:53,130
To tylko niektóre liczbę binarną, a co ~ nie jest to tylko odwraca wszystkie bity.

171
00:14:53,130 --> 00:15:00,630
Tak więc jest to 1, teraz 0, to jest 0, teraz 1 010100.

172
00:15:00,630 --> 00:15:08,320
Więc to wszystko ~ ma. Tak więc 32 będzie liczba - pozbyć, że -

173
00:15:08,320 --> 00:15:23,320
tak, 32 będzie liczba 00100000, i tak ~ to będzie

174
00:15:23,320 --> 00:15:29,980
ta liczba się tutaj, że AND "a" z.

175
00:15:29,980 --> 00:15:35,600
Czy każdy widzi? Jest to dość powszechne, jak wtedy, gdy chcesz się dowiedzieć

176
00:15:35,600 --> 00:15:40,740
dla późniejszych rzeczy, abyśmy się widząc, gdy chcemy sprawdzić, czy -

177
00:15:40,740 --> 00:15:44,710
czy chcemy wszystko, każdy set nieco poza 1

178
00:15:44,710 --> 00:15:47,910
masz tendencję do nie ~ z bitem, że nie chcemy ustawić.

179
00:15:47,910 --> 00:15:53,090
Więc nie chcesz 32 ustawiony bit, więc robimy z 32 ~.

180
00:15:53,090 --> 00:15:57,790
Okay. Tak więc możemy korzystać ze wszystkich tych tutaj.

181
00:15:57,790 --> 00:16:03,000
W porządku, więc to dobrze, jeśli nie skończymy, będziemy powoli chodzić nad sobą,

182
00:16:03,000 --> 00:16:11,870
lub spacer nad tym, więc - przez to. Spacer po tym.

183
00:16:11,870 --> 00:16:20,790
Więc mamy ciąg, i chcemy pętli nad każdego znaku tego łańcucha i coś do niego.

184
00:16:20,790 --> 00:16:26,710
Jak więc w pętli nad ciąg? Co powinniśmy używać?

185
00:16:26,710 --> 00:16:30,980
Nie zamierzam tego robić tutaj. Tak.

186
00:16:30,980 --> 00:16:42,940
Więc mam iteracyjnej, i powiedział to, ale skąd mam wiedzieć, ile znaków w ciągu?

187
00:16:42,940 --> 00:16:47,030
Strlen (s), a następnie i + +.

188
00:16:47,030 --> 00:16:49,860
Więc to, co zrobiłem tutaj nie najlepszy sposób robienia rzeczy jest.

189
00:16:49,860 --> 00:16:51,860
Czy ktoś wie dlaczego?

190
00:16:51,860 --> 00:16:55,290
Ponieważ jesteś sprawdzanie języka ciągu każdym razem jeden.

191
00:16:55,290 --> 00:17:06,859
Więc będziemy chcieli przenieść strlen, mogę powiedzieć tutaj, int length = strlen (s),

192
00:17:06,859 --> 00:17:11,900
a następnie wykonaj i <długość, w przypadku, gdy nie widziałem go wcześniej,

193
00:17:11,900 --> 00:17:20,410
Mogę też zrobić int i = 0, długość = strlen (s).

194
00:17:20,410 --> 00:17:25,010
A więc jest to nieco lepszy, ponieważ teraz mam ograniczony zakres

195
00:17:25,010 --> 00:17:29,150
zmiennej długości, tylko to "na" pętli, zamiast deklarowania przed

196
00:17:29,150 --> 00:17:34,990
i że zawsze istnieje, a w przypadku, gdy nie złapać, dlaczego to jest złe,

197
00:17:34,990 --> 00:17:39,410
lub dlaczego oryginalny był zły, it's - start w pętli for.

198
00:17:39,410 --> 00:17:43,380
Sprawdziłem stan. Czy i <długość s?

199
00:17:43,380 --> 00:17:46,790
Więc długość s, niech działa z "hello" cały czas.

200
00:17:46,790 --> 00:17:49,670
Tak więc długość s, H-l-e-l-O. Długości 5.

201
00:17:49,670 --> 00:17:57,580
I = 0, tak, długości 5, tak, że nie jest <5, a więc nadal pętli.

202
00:17:57,580 --> 00:18:02,750
Potem znowu. Sprawdzamy stan. Czy i <długość komentarzy

203
00:18:02,750 --> 00:18:08,390
Warto więc sprawdzić długość hello. H-E-L-L-O. To jest 5, i nie jest <5, więc nadal ponownie.

204
00:18:08,390 --> 00:18:13,330
Więc są obliczenia, liczymy hello, dla każdej iteracji,

205
00:18:13,330 --> 00:18:17,380
nawet, że to się nigdy nie zmieni, to zawsze będzie 5.

206
00:18:17,380 --> 00:18:22,530
Więc po prostu pamiętaj, 5 do przodu, a teraz wszystko jest lepsze.

207
00:18:22,530 --> 00:18:24,990
Więc iterowanie całego łańcucha.

208
00:18:24,990 --> 00:18:31,470
Co chcemy zrobić dla każdego znaku z ciągu?

209
00:18:31,470 --> 00:18:38,510
[Speaking Student, niezrozumiały]

210
00:18:38,510 --> 00:18:47,000
Tak. Tak więc, jeśli postać jest non-alfabetu, a następnie po prostu chcemy, aby przejść nad nim.

211
00:18:47,000 --> 00:18:52,300
Ponieważ interesują nas tylko znaki alfabetu, nie możemy wykorzystać numer.

212
00:18:52,300 --> 00:19:10,850
Więc w jaki sposób możemy to zrobić? Więc naszym stanie, więc jeśli chcemy coś - sprawdzić, czy to alfabetycznie.

213
00:19:10,850 --> 00:19:14,060
Więc jak to sprawdzić?

214
00:19:14,060 --> 00:19:18,720
[Student] Można po prostu użyć funkcji jest alfa.

215
00:19:18,720 --> 00:19:23,160
Jest to, że zawarte w jednym z nich, lub zawierają podobne, char.h czy coś?

216
00:19:23,160 --> 00:19:32,710
Niech nie używać funkcji jest alfa i używać jednoznaczne - mamy więc s [i],

217
00:19:32,710 --> 00:19:40,460
że jest ósmym charakter s, należy pamiętać, że łańcuch jest tablica znaków,

218
00:19:40,460 --> 00:19:43,180
tak ósmy znak s.

219
00:19:43,180 --> 00:19:49,280
Teraz, jeżeli jest literą wiemy musi być w określonym zakresie.

220
00:19:49,280 --> 00:19:54,370
I co to jest zasięg?

221
00:19:54,370 --> 00:20:07,860
Tak. Więc jeśli s [i] jest ≥ 65 i s [i] jest ≤ 90, co należy zrobić w zamian?

222
00:20:07,860 --> 00:20:18,470
Tak. Należy więc nigdy absolutnie nawet wiedzieć ASCII wartości niczego kiedykolwiek.

223
00:20:18,470 --> 00:20:25,640
Nigdy nie myślę o numerach 65, 90, 97 i 102, czy cokolwiek to jest.

224
00:20:25,640 --> 00:20:32,470
Nie musisz - 112 - nie musisz znać tych w ogóle. To jest złe też.

225
00:20:32,470 --> 00:20:41,940
Należy używać tylko apostrof znaków, pojedyncze stałe cytat. Tak więc "A" i jest mniejszy niż 90 "Z.

226
00:20:41,940 --> 00:20:47,930
I to jest znacznie lepsze - nie wiem z dachu mojej głowy, że Z jest 90.

227
00:20:47,930 --> 00:20:52,690
Wiem z dachu mojej głowy, że "Z" jest stolicą Z.

228
00:20:52,690 --> 00:21:02,100
Tak długo, jak to jest w zakresie od stolicy do stolicy Z, lub możemy sprawdzić, małymi literami,

229
00:21:02,100 --> 00:21:17,010
Lub jeśli jest w przedziale ≥ "a" i ≤ z.

230
00:21:17,010 --> 00:21:19,010
Więc to jest nasz stan.

231
00:21:19,010 --> 00:21:22,520
Styl, gdzie umieścić te rzeczy różne.

232
00:21:22,520 --> 00:21:29,520
Zrobię to tak.

233
00:21:29,520 --> 00:21:31,520
Teraz, co chcemy zrobić?

234
00:21:31,520 --> 00:21:39,530
Wiemy, że to pismo jest znak, znak alfabetyczny.

235
00:21:39,530 --> 00:21:46,270
Musimy więc na przemian, czy to powinno być teraz litery lub małe litery.

236
00:21:46,270 --> 00:21:48,820
Jak możemy śledzić który chcemy być?

237
00:21:48,820 --> 00:21:55,520
[Głosy studentów, niezrozumiały]

238
00:21:55,520 --> 00:21:59,150
Tak tak, ale niech mi sprawdzić.

239
00:21:59,150 --> 00:22:04,910
Moduł 0-2 mówiono, była sugestia wyrzucony, i zgadzam się z tym.

240
00:22:04,910 --> 00:22:11,780
Oprócz powiadomienia, że ​​jak - czy to przypadek? Tak.

241
00:22:11,780 --> 00:22:18,270
To co drugi, ale nie możemy z modułu 2 i, lub i mod 2, ponieważ

242
00:22:18,270 --> 00:22:22,950
zauważyć, że E jest stolicą i "a" jest małe? Ale jest miejsce, oddzielając je?

243
00:22:22,950 --> 00:22:27,150
Więc zamierzasz być sam mod 2, ale są różne przypadki.

244
00:22:27,150 --> 00:22:29,150
[Pytanie Student, niezrozumiały]

245
00:22:29,150 --> 00:22:34,690
Tak. Więc jesteśmy po prostu będzie utrzymać liczyć.

246
00:22:34,690 --> 00:22:38,730
Możemy również zrobić w tutaj, jeśli chcemy, to może się trochę nieporęczny

247
00:22:38,730 --> 00:22:41,300
w przypadku zgłoszeń pętli włożę ją tutaj.

248
00:22:41,300 --> 00:22:48,840
Więc int count = 0 zaczyna.

249
00:22:48,840 --> 00:22:54,070
I tak teraz, idę policzyć ile znaków alfabetycznych mieliśmy.

250
00:22:54,070 --> 00:22:59,550
Więc jesteśmy nieuchronnie będzie liczyć + + od kiedy znalazł inną literę alfabetu.

251
00:22:59,550 --> 00:23:09,130
Ale, tak, teraz mówisz, jeśli mod liczbę 2.

252
00:23:09,130 --> 00:23:12,590
Więc co, jeśli liczba mod 2? Oh. Zrobię == 0 do teraz.

253
00:23:12,590 --> 00:23:21,740
Będziemy również przejść nad tym. Więc jeśli mod Ilość 2 == 0, to co?

254
00:23:21,740 --> 00:23:27,830
[Studenci odpowiedź, niezrozumiały]

255
00:23:27,830 --> 00:23:32,750
Dlatego chcemy to skończyć wielkimi literami.

256
00:23:32,750 --> 00:23:37,520
Są 2 przypadki; wielkie i małe są 2 przypadki.

257
00:23:37,520 --> 00:23:40,990
Więc jeśli jesteśmy małymi literami musimy zrobić to wielkie.

258
00:23:40,990 --> 00:23:43,710
Jeśli jest to wielkie, nie musimy nic robić.

259
00:23:43,710 --> 00:23:50,760
Ale jest sposób - shouldn't zostały odwrócone -

260
00:23:50,760 --> 00:23:54,800
to, że nie trzeba nawet sprawdzić, czy to jest wielkie i małe litery?

261
00:23:54,800 --> 00:24:02,240
Co możemy zrobić, aby zawsze mieć pewność, że zawsze kończy się na wielkie litery?

262
00:24:02,240 --> 00:24:07,830
Więc zauważyć to, co zrobiliśmy dla małych liter "A", co oznacza, że ​​to zrobiliśmy to dokładnie taki sam rzecz na wielkie litery?

263
00:24:07,830 --> 00:24:11,900
Czy wielkie zmiany, czy też zmianę wartości?

264
00:24:11,900 --> 00:24:23,100
Tak. Więc każda wielka litera bitowe AND z ~ 32 będzie wielka, że ​​sam znak

265
00:24:23,100 --> 00:24:29,220
bo dla każdego wielką literą 32. bit nie jest ustawiony.

266
00:24:29,220 --> 00:24:40,920
Więc jeśli chcemy przybliżyć postać s [i], chcemy, aby stało się małe lub wielkie.

267
00:24:40,920 --> 00:24:46,890
Więc jeśli to było małe, to jest teraz wielkie, gdyby to było wielkie, to jeszcze wielka, i to jest to.

268
00:24:46,890 --> 00:24:54,290
Powiedziałem to w supersection: Możesz użyć 32, jeśli chcesz, ale wolą robić "a" - A,

269
00:24:54,290 --> 00:25:01,150
zamiast po prostu 32, ponieważ może to być dowolny inny bit.

270
00:25:01,150 --> 00:25:03,610
Po 32-bitowy, może to być dowolny z nich lub nie będzie wystarczająco dużo

271
00:25:03,610 --> 00:25:05,840
Numery do reprezentowania wszystkich znaków.

272
00:25:05,840 --> 00:25:09,110
Więc jeśli masz 32 bit, może to być 64 bit, może to być 128 bit.

273
00:25:09,110 --> 00:25:13,990
Każda z tych bitów może być nieco, że rozróżnia wielkie i małe litery.

274
00:25:13,990 --> 00:25:18,350
I nie powinien wiedzieć, że jest to 32 bit.

275
00:25:18,350 --> 00:25:27,130
Można użyć tego 'A' - w celu uzyskania nieco różniące się między dwoma

276
00:25:27,130 --> 00:25:33,000
bez konieczności polegać na magiczny numer, który jest 32.

277
00:25:33,000 --> 00:25:38,770
I tak teraz, jeszcze liczyć było dziwne, a więc to, co chcę zrobić?

278
00:25:38,770 --> 00:25:43,920
[Odpowiedzi studentów, niezrozumiały]

279
00:25:43,920 --> 00:25:45,920
[Student] Co to jest?

280
00:25:45,920 --> 00:25:49,850
Zrobię to w ciągu 1 sekundy.

281
00:25:49,850 --> 00:25:55,690
Więc teraz, jeśli chcę - chcę się upewnić, postać jest teraz małe litery,

282
00:25:55,690 --> 00:26:04,140
i tak można lub przez 32, a 32 oznacza "'- A.

283
00:26:04,140 --> 00:26:06,510
Ale zauważ, przez tego samego rozumowania, jak poprzedni, że jeśli

284
00:26:06,510 --> 00:26:11,670
List był już małe, a następnie przez 32 ORing utrzymuje ją tylko małe litery.

285
00:26:11,670 --> 00:26:16,220
To nie zmieniło pierwotny charakter.

286
00:26:16,220 --> 00:26:19,910
Ale teraz nie mam, aby uniknąć, mówiąc: "Jeśli jest małe, po prostu o tym zapomnieć,

287
00:26:19,910 --> 00:26:23,650
jeśli jest to wielka, a następnie ją zmienić. "

288
00:26:23,650 --> 00:26:26,900
Jest to o wiele bardziej wygodne, aby to zrobić.

289
00:26:26,900 --> 00:26:33,190
[Student] Oby strategia odjęcie wielkich liter z małą pracę, gdyby nie 32?

290
00:26:33,190 --> 00:26:35,330
Jeśli to było, jak, 34 czy coś?

291
00:26:35,330 --> 00:26:41,840
Tak, musisz wiedzieć, że różnica między 2 jest -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
To może być nieco większa niż 1, o ile wszystkie bity poniżej tej pozycji są takie same.

293
00:26:49,840 --> 00:26:58,500
Dlatego musimy co najmniej 26 znaków - czy istnieje 26 znaków.

294
00:26:58,500 --> 00:27:04,590
Dlatego musimy co najmniej 26 numerów stanowią różnicę -

295
00:27:04,590 --> 00:27:07,650
Różnica między i "a" musi być co najmniej 26,

296
00:27:07,650 --> 00:27:10,760
inaczej nie bylibyśmy reprezentowane wszystkie numery kapitałowych.

297
00:27:10,760 --> 00:27:18,630
Oznacza to, że, jeśli zaczniemy od 1, to będzie korzystać ze wszystkich tych bitów,

298
00:27:18,630 --> 00:27:23,900
Wszystkie z tych pierwszych 5 bitów, które są reprezentatywne wszystko przez Z.

299
00:27:23,900 --> 00:27:32,170
Dlatego następny bit, lub ten bit, następny bit jest tym, który zdecydował się odróżnić i "."

300
00:27:32,170 --> 00:27:40,930
To też, dlaczego w tabeli ASCII, są 5 symbole oddzielające litery z małych liter.

301
00:27:40,930 --> 00:27:49,050
Ponieważ są to symbole, które przynosi dodatkowe 5 do 32 jest różnica między nimi.

302
00:27:49,050 --> 00:27:51,840
[Student] Więc możemy to zrobić, bo ASCII zaprojektowany w ten sposób.

303
00:27:51,840 --> 00:27:57,280
Tak. Ale ASCII - różnica może być zarówno z tych bitów.

304
00:27:57,280 --> 00:28:12,040
Podoba Ci się, jeśli były 10000001 i "" był 11100001 - I zapomnieć, cokolwiek.

305
00:28:12,040 --> 00:28:18,100
Ale gdyby było to, to możemy nadal korzystać z 'A' - A.

306
00:28:18,100 --> 00:28:22,650
To właśnie różnica między i "a" jest nadal te 2 bity.

307
00:28:22,650 --> 00:28:32,240
Myślę, że to jest napisane 48. Czy to jest 32 + 64? Myślę, że jest?

308
00:28:32,240 --> 00:28:40,160
Jest jeszcze 2 bity, każdy znak, jak, Z i Z, K i K,

309
00:28:40,160 --> 00:28:45,160
nadal są one dokładnie takie same bity ustawione wyjątkiem tych 2 bitów.

310
00:28:45,160 --> 00:28:48,870
Tak długo, jak to jest zawsze prawdziwe, niezależnie czy używamy ASCII lub inny system,

311
00:28:48,870 --> 00:28:53,050
tak długo, jak jest tylko określoną liczbę bitów, które są różne dla każdej postaci,

312
00:28:53,050 --> 00:28:55,050
następnie, że działa dobrze.

313
00:28:55,050 --> 00:29:06,110
Tyle tylko, że 32 została utworzona, ponieważ jest to pierwszy moglibyśmy użyć. >> Cool.

314
00:29:06,110 --> 00:29:14,520
I wolą, w przypadku, gdy nie widać, jeśli blok jest tylko jeden wiersz,

315
00:29:14,520 --> 00:29:24,280
możesz pozbyć się klamrach; więc wolą to robi.

316
00:29:24,280 --> 00:29:34,010
Również, w jaki sposób możemy robić takie rzeczy jak s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
Można również zrobić s [i] = 32 bitowe AND.

318
00:29:41,090 --> 00:29:46,400
I logiczną OR = 32.

319
00:29:46,400 --> 00:29:51,490
Również liczyć mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
Więc pamiętaj, że - nie będę pisać - każdy niezerowa wartość true, a 0 jest fałszywa.

321
00:30:00,900 --> 00:30:07,880
Tak ", jeśli mod Ilość 2 == 0" jest taki sam, jak mówi "Jeśli nie liczy mod 2".

322
00:30:07,880 --> 00:30:11,580
I pewnie by tak odwrócić linii i powiedział, "jeśli liczba mod 2,

323
00:30:11,580 --> 00:30:15,350
nie lub 1 indziej I 1 ", tak że nie muszę" nie ".

324
00:30:15,350 --> 00:30:18,650
Ale to działa tak samo dobrze.

325
00:30:18,650 --> 00:30:25,660
I co jeszcze mogę zrobić tutaj?

326
00:30:25,660 --> 00:30:29,060
Można łączyć je z potrójnych, jeśli chcesz, ale wtedy to, że wystarczy dokonać rzeczy Messier

327
00:30:29,060 --> 00:30:33,770
i prawdopodobnie bardziej trudne do odczytania, więc nie będziemy tego robić.

328
00:30:33,770 --> 00:30:37,330
Ktoś ma jakieś inne propozycje?

329
00:30:37,330 --> 00:30:41,580
Czy to wszystko, problem prosiłem? Oh yeah.

330
00:30:41,580 --> 00:30:51,070
Więc pozbyć się tych pustych linii, teraz będziemy drukować f,% s jest jedna dla ciągów,

331
00:30:51,070 --> 00:30:56,620
Będziemy drukować F, S.

332
00:30:56,620 --> 00:30:59,330
Teraz uruchom go. Czy zrobiłem coś złego?

333
00:30:59,330 --> 00:31:03,200
To \ ", chcę się n.

334
00:31:03,200 --> 00:31:07,840
Okay. Teraz będziemy go uruchomić. To będzie prawdopodobnie krzycz na mnie.

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

336
00:31:11,250 --> 00:31:14,290
Więc to jest miłą rzeczą jest to Clang mówi, co to jest w,

337
00:31:14,290 --> 00:31:19,140
zamiast GCC, które po prostu mówi: "Hej, zapomniałem o czymś, nie wiem, co to było."

338
00:31:19,140 --> 00:31:29,220
Ale to powie mi, "ma obejmować string.h".

339
00:31:29,220 --> 00:31:32,130
Więc nie pytaj o nic, więc nie mówi nic.

340
00:31:32,130 --> 00:31:42,540
Ale zrobimy za ich przykładem, "Thanks 4 do Dodaj".

341
00:31:42,540 --> 00:31:47,880
To wygląda dobrze. Brawo.

342
00:31:47,880 --> 00:31:52,370
Więc wracając do głównego, prawie nigdy nie zrobić.

343
00:31:52,370 --> 00:31:57,110
Jest to opcjonalne. I jest jedynym głównym funkcji, dla których jest to opcjonalne.

344
00:31:57,110 --> 00:32:07,140
Jeśli nie zwraca niczego od głównego, to zakłada się, że masz na myśli powrót 0.

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

346
00:32:13,070 --> 00:32:20,980
Okay. Więc teraz drugi problem.

347
00:32:20,980 --> 00:32:24,810
"Przypomnijmy od 2 tygodni w drugim wykładzie, że zamiana wartości 2 zmiennych", przekazując

348
00:32:24,810 --> 00:32:30,780
te 2 zmienne do funkcji (nawet jeśli nazywa swap) nie dokładnie działa, przynajmniej nie bez "wskazówek".

349
00:32:30,780 --> 00:32:37,020
I ignorować wskazówki, aż się do nich dostać.

350
00:32:37,020 --> 00:32:40,070
Chcemy zamienić 2 zmiennych; nie używamy funkcji to zrobić.

351
00:32:40,070 --> 00:32:43,410
Ciągle dzieje się to zrobić w głównym, jak to mówi.

352
00:32:43,410 --> 00:32:48,360
Ale do korzystania z tych 2 zmiennych, nie chcemy użyć zmiennej tymczasowej.

353
00:32:48,360 --> 00:32:50,770
Istnieją 2 sposoby, aby to zrobić.

354
00:32:50,770 --> 00:32:56,310
Możesz to zrobić za pomocą swoich tradycyjnych operatorów binarnych.

355
00:32:56,310 --> 00:33:00,180
Więc czy ktoś wie, szybki i brudny sposób to robi?

356
00:33:00,180 --> 00:33:07,650
To może rzeczywiście podjąć minuty myślenia. Jeśli mam -

357
00:33:07,650 --> 00:33:12,130
Założę problem się jak pytają. Więc jeśli mam 2 zmienne, które jest po prostu liczbą całkowitą

358
00:33:12,130 --> 00:33:17,800
że dają mi, i B zmienna suma, która jest kolejnym całkowitą że jestem podane.

359
00:33:17,800 --> 00:33:22,700
Więc jeśli mam te 2 zmienne, teraz chcę, aby zamienić je.

360
00:33:22,700 --> 00:33:31,550
Tradycyjny, za pomocą regularnej operatorów binarnych, to znaczy, jak +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
Nie operatory bitowe, które działają na binarny.

362
00:33:36,630 --> 00:33:39,600
Więc za pomocą -, +, ÷, i wszystkich tych.

363
00:33:39,600 --> 00:33:52,980
Możemy zamienić robiąc coś = a + b, a b = a - b, a = - b.

364
00:33:52,980 --> 00:34:04,260
Więc, sanity sprawdzić, a potem zobaczymy, dlaczego to działa.

365
00:34:04,260 --> 00:34:13,320
Załóżmy, że a = 7, b = 3, a A i B będzie 10.

366
00:34:13,320 --> 00:34:18,820
Więc jesteśmy teraz ustawienie = 10, a następnie robimy b = a - b.

367
00:34:18,820 --> 00:34:30,250
Więc robimy b = a - b, która ma być 7, b = a - b ponownie,

368
00:34:30,250 --> 00:34:38,650
lub = a - b. Który będzie 10 - 7, który jest 3.

369
00:34:38,650 --> 00:34:44,850
Więc teraz, w pełnym zakresie "," było 7, b był 3, a teraz b jest 7 i 'a' jest 3.

370
00:34:44,850 --> 00:34:48,679
Tak więc tego rodzaju sens, "a" jest połączenie 2 numery.

371
00:34:48,679 --> 00:34:53,000
W tym momencie, "a" jest połączenie, a następnie jesteśmy odejmując Oryginał B,

372
00:34:53,000 --> 00:34:56,860
a następnie mamy odejmując co oryginał "."

373
00:34:56,860 --> 00:35:01,150
Ale to nie działa dla wszystkich numerów.

374
00:35:01,150 --> 00:35:08,880
Aby to zobaczyć, rozważmy system, tak zwykle myślimy liczb całkowitych jako 32 bitów.

375
00:35:08,880 --> 00:35:13,050
Pracujmy nad czymś, co tylko jak 4 bitów.

376
00:35:13,050 --> 00:35:15,450
Mam nadzieję, że wymyślić dobry przykład teraz.

377
00:35:15,450 --> 00:35:18,680
Tak, wiem, to będzie łatwe.

378
00:35:18,680 --> 00:35:26,720
Powiedzmy, że nasze 2 numery są 1111 i 1111, tak więc jesteśmy w binarnym teraz.

379
00:35:26,720 --> 00:35:34,630
W rzeczywistych miejsc po przecinku, jeśli chcesz, aby myśleć o tym w ten sposób, a = 15, b = 15.

380
00:35:34,630 --> 00:35:37,630
A więc się spodziewać, po tym jak zamienić je - nawet nie muszą być takie same numery,

381
00:35:37,630 --> 00:35:41,140
ale zrobiłem to w ten sposób.

382
00:35:41,140 --> 00:35:47,100
Zróbmy ich nie te same numery. Zróbmy 1111 i 0001.

383
00:35:47,100 --> 00:35:51,860
Tak = 15 i B = 1.

384
00:35:51,860 --> 00:35:57,670
Po zamienić je, oczekujemy "" być 1 i b jest 15.

385
00:35:57,670 --> 00:36:01,780
Więc nasz pierwszy krok to a = a + b.

386
00:36:01,780 --> 00:36:08,770
Nasze numery tylko 4 bitów, to "", który jest 1111, + b, które jest 0001,

387
00:36:08,770 --> 00:36:16,780
będzie w końcu jest 10000, ale mamy tylko 4 bity.

388
00:36:16,780 --> 00:36:22,540
Więc teraz = 0.

389
00:36:22,540 --> 00:36:34,080
A teraz chcemy ustawić b = a - b - faktycznie, to nadal działa idealnie.

390
00:36:34,080 --> 00:36:39,630
= a - b - zobaczymy, czy to działa doskonale.

391
00:36:39,630 --> 00:36:53,720
Tak więc B = 0 - 1, które w dalszym ciągu wynosi 15, a A = A - B, który jest 1.

392
00:36:53,720 --> 00:36:56,210
Może to działa.

393
00:36:56,210 --> 00:36:59,020
Czuję, że jest powód że nie działa za pomocą regularnych.

394
00:36:59,020 --> 00:37:06,400
Ok, więc pracuje się na założeniu, że to nie działa z regularnych operacji binarnych,

395
00:37:06,400 --> 00:37:15,040
i będę szukać - będę z Google, aby zobaczyć, czy to prawda.

396
00:37:15,040 --> 00:37:23,490
Dlatego chcemy, aby to zrobić stosując operatory bitowe, a wskazówką jest XOR.

397
00:37:23,490 --> 00:37:28,780
Tak więc, wprowadzenie XOR (^), jeśli nie widziałeś jeszcze.

398
00:37:28,780 --> 00:37:34,610
To znowu, operatory bitowe, więc działa po trochu i it's -

399
00:37:34,610 --> 00:37:39,910
Jeśli bity 0 i 1, to będzie 1.

400
00:37:39,910 --> 00:37:45,230
Jeśli masz bitów 1 i 0, to będzie 1, masz bity 0 i 0 to będzie 0,

401
00:37:45,230 --> 00:37:47,640
a jeśli masz bity 1 i 1 to będzie 0.

402
00:37:47,640 --> 00:37:56,180
Więc jak to jest OR. Jeśli jeden z bitów są prawdziwe, to 1, ale w przeciwieństwie do I, nie mogą być oba bity są prawdziwe.

403
00:37:56,180 --> 00:37:59,320
Lub mogło to być 1, XOR miałoby to być 0.

404
00:37:59,320 --> 00:38:02,250
Więc mamy zamiar użyć XOR tutaj.

405
00:38:02,250 --> 00:38:09,960
Pomyśl o tym przez chwilę, idę do Google.

406
00:38:09,960 --> 00:38:16,230
Cóż, nie można przeczytać, że, jestem obecnie na wymiany XOR strony algorytmu.

407
00:38:16,230 --> 00:38:21,340
Mam nadzieję, że będzie to wyjaśnić, dlaczego nie mogę się -

408
00:38:21,340 --> 00:38:34,190
To jest dokładnie to algorytm, który właśnie zrobił.

409
00:38:34,190 --> 00:38:37,330
I nadal nie rozumiem, dlaczego - Musiałem po prostu wybrał zły przykład,

410
00:38:37,330 --> 00:38:44,940
ale w tym przypadku, gdzie "a" się stać 0, po dotarciu do 5 bitów, więc teraz "a" jest 0,

411
00:38:44,940 --> 00:38:48,730
że to, co nazywa się "przepełnienie całkowitoliczbowe."

412
00:38:48,730 --> 00:38:54,370
Według Wikipedii: "W przeciwieństwie do wymiany XOR, to zmiana wymaga, że ​​używa kilku metod

413
00:38:54,370 --> 00:38:59,780
zapewnić, że x + y nie powoduje przepełnienie całkowitoliczbowe. "

414
00:38:59,780 --> 00:39:08,350
Więc to ma problemy, to przepełnienie całkowitoliczbowe, ale zrobiłem coś złego.

415
00:39:08,350 --> 00:39:10,520
Nie jestem pewien. Postaram się wymyślić innego.

416
00:39:10,520 --> 00:39:13,640
[Student] Cóż, nie przepełnienie całkowitoliczbowe jest, kiedy próbujesz umieścić numer tam

417
00:39:13,640 --> 00:39:16,640
większa niż ilość bitów zostały rozdzielone?

418
00:39:16,640 --> 00:39:23,730
Tak. Mamy 4 bity. That's - mieliśmy 4 bity, a my wtedy spróbować dodać 1 do niego, więc kończy się z 5 bitów.

419
00:39:23,730 --> 00:39:26,690
Ale piąty bit tylko pobiera odcięte, tak.

420
00:39:26,690 --> 00:39:28,970
To może faktycznie -

421
00:39:28,970 --> 00:39:33,010
[Student] Czy to rzucić błąd, czy też, że - by to rzucić błąd?

422
00:39:33,010 --> 00:39:40,720
No więc nie ma błędu. Gdy dojdziesz do poziomu zespołu, specjalny bit

423
00:39:40,720 --> 00:39:47,020
gdzieś jest, że powiedział, że nie było przepełnienia, ale w C masz rodzaj po prostu nie radzą sobie z tym.

424
00:39:47,020 --> 00:39:55,160
Naprawdę nie mogę sobie z tym poradzić, chyba że używa specjalnych instrukcji montażu w C.

425
00:39:55,160 --> 00:39:58,110
Pomyślmy o zamianie XOR.

426
00:39:58,110 --> 00:40:02,220
I myślę, że artykuł w Wikipedii może się również powiedzieć, że -

427
00:40:02,220 --> 00:40:07,310
Więc to też wychowany Arytmetyka modularna, więc myślę, że jestem w teorii robi arytmetyki modularnej

428
00:40:07,310 --> 00:40:11,160
kiedy powiedziałem, że 0 - 1 jest 15 ponownie.

429
00:40:11,160 --> 00:40:15,410
Tak, że może faktycznie - regularnie procesora, który nie 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Ponieważ kończy się na 0, odejmujemy 1, więc to po prostu owija powraca do 1111.

431
00:40:20,430 --> 00:40:28,930
Tak więc w rzeczywistości może to algorytm pracy, A + B, A - B, B -, że może być dobrze.

432
00:40:28,930 --> 00:40:34,030
Ale jest kilka procesorów, które tego nie robią, i tak nie byłoby to w porządku w tych konkretnych nich.

433
00:40:34,030 --> 00:40:39,880
Swap XOR będzie działać na każdym procesorze. Okay.

434
00:40:39,880 --> 00:40:42,280
Chodzi o to, że to ma być taki sam, choć.

435
00:40:42,280 --> 00:40:50,120
Gdzie korzystamy XOR jakoś uzyskać informacje zarówno na 1 zmiennych,

436
00:40:50,120 --> 00:40:54,120
a następnie wyciągnąć informacje o poszczególnych zmiennych ponownie.

437
00:40:54,120 --> 00:41:04,330
Więc czy ktoś ma pomysły / odpowiedź?

438
00:41:04,330 --> 00:41:14,540
[Odpowiedź Student, niezrozumiały]

439
00:41:14,540 --> 00:41:22,220
Tak to powinno działać, a także, XOR jest przemienne.

440
00:41:22,220 --> 00:41:27,620
Niezależnie od tego, w jakiej kolejności te 2 numery stało się w tu,

441
00:41:27,620 --> 00:41:30,100
Ten wynik będzie taki sam.

442
00:41:30,100 --> 00:41:35,800
Tak ^ b to b ^.

443
00:41:35,800 --> 00:41:51,860
Warto również zobaczyć to napisane jak ^ = b, b ^ =, ^ = b ponownie.

444
00:41:51,860 --> 00:42:00,200
Tak to jest w porządku, i dlaczego to działa, myślę o bitach.

445
00:42:00,200 --> 00:42:10,400
Korzystanie niewielka ilość, powiedzmy, 11001 i 01100.

446
00:42:10,400 --> 00:42:12,790
Więc to jest "a", to jest b.

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

448
00:42:15,540 --> 00:42:22,380
Zamierzamy być ustawienie 'a' = do XOR z tych 2 rzeczy.

449
00:42:22,380 --> 00:42:32,920
1 ^ 0, więc jest 1, 1 ^ 1 0., 0 ^ 1 oznacza 1, i 0 ^ 0 jest 0, 1 ^ 0 jest 1.

450
00:42:32,920 --> 00:42:37,380
Tak "," Jeśli spojrzeć na liczbę dziesiętną, to będzie -

451
00:42:37,380 --> 00:42:41,160
nie będziemy widzieć dużo stosunków między pierwotnym "A" i nowy ","

452
00:42:41,160 --> 00:42:45,600
ale patrząc na bitach, "a" jest teraz jak oczka informacji

453
00:42:45,600 --> 00:42:49,970
zarówno oryginalnego 'A' i B oryginalnego.

454
00:42:49,970 --> 00:42:57,930
Więc jeśli weźmiemy b ^, widzimy, że skończymy na oryginał "."

455
00:42:57,930 --> 00:43:08,910
A jeśli wziąć oryginał "'^ nowe", "widzimy skończymy w oryginalnej b.

456
00:43:08,910 --> 00:43:18,380
Tak (a ^ b) ^ b = oryginał "."

457
00:43:18,380 --> 00:43:27,910
I (a ^ b) ^ = b oryginału.

458
00:43:27,910 --> 00:43:37,010
Nie ma - inny sposób widzenia jest to XOR coś sama jest zawsze 0.

459
00:43:37,010 --> 00:43:45,020
Tak 1101 ^ 1101, wszystkie bity będą takie same.

460
00:43:45,020 --> 00:43:47,920
Tak więc nie będzie to przypadek, gdzie 1 jest 0, a drugi oznacza 1.

461
00:43:47,920 --> 00:43:51,080
Więc to jest 0000.

462
00:43:51,080 --> 00:43:57,240
To samo z tym. (A ^ b) ^ b jest jak ^ (b ^ b).

463
00:43:57,240 --> 00:44:03,680
(B ^ b) będzie 0; ^ 0 jest po prostu będzie "," ponieważ wszystkie bity 0.

464
00:44:03,680 --> 00:44:08,050
Tak więc tylko te, które będą, gdzie "a" był początkowo 1 - mieli nich.

465
00:44:08,050 --> 00:44:12,070
A sam pomysł tu jestem całkiem pewien, że to również przemienne.

466
00:44:12,070 --> 00:44:17,590
Tak. Powiedziałem wcześniej, że to było przemienne.

467
00:44:17,590 --> 00:44:24,680
^ ',' I to jest łączne, więc teraz (b ^) ^.

468
00:44:24,680 --> 00:44:28,970
I możemy zrobić b ^ (^).

469
00:44:28,970 --> 00:44:31,540
I znowu, mamy oryginalną b.

470
00:44:31,540 --> 00:44:37,120
Tak 'a' jest teraz połączenie 'A' i B razem.

471
00:44:37,120 --> 00:44:49,660
Korzystanie z naszego nowego combo 'a' b = mówimy combo '' ^ oryginalny b, otrzymujemy oryginał "."

472
00:44:49,660 --> 00:45:05,170
A teraz combo = '' ^ nowy b, która była oryginalna - lub co jest teraz to, co było "a" lub b.

473
00:45:05,170 --> 00:45:13,620
To ten przypadek tutaj. To = b, old b.

474
00:45:13,620 --> 00:45:16,550
Więc teraz wszystko jest z powrotem w zamienione kolejności.

475
00:45:16,550 --> 00:45:22,960
Jeśli rzeczywiście wyglądał na bitach, b = a ^ b, będzie XOR te 2,

476
00:45:22,960 --> 00:45:33,920
i odpowiedź będzie to i to a = a ^ b jest XORing te 2 i odpowiedź jest następująca.

477
00:45:33,920 --> 00:45:41,090
Pytania? Okay. Tak ostatni jest nieco znacznie trudniejsze.

478
00:45:41,090 --> 00:45:43,180
[Student] Myślę, że ma wątpliwości. >> O, przepraszam.

479
00:45:43,180 --> 00:45:49,380
[Student] Co rzeczywiście szybciej? Jeśli używasz tego XOR, czy to jeśli zadeklarować nową zmienną?

480
00:45:49,380 --> 00:45:55,190
Tak więc to, co jest rzeczywiście szybciej, deklarując nową zmienną lub za pomocą XOR do wymiany?

481
00:45:55,190 --> 00:45:59,600
Odpowiedź jest, według wszelkiego prawdopodobieństwa, zmienna tymczasowa.

482
00:45:59,600 --> 00:46:05,780
A to dlatego, że po jego skompilowany w dół - tak na poziomie złożenia,

483
00:46:05,780 --> 00:46:12,320
nie ma czegoś takiego jak zmienne lokalne lub jakichkolwiek zmiennych tymczasowych lub jakiekolwiek z tych rzeczy.

484
00:46:12,320 --> 00:46:16,060
Oni po prostu lubią - jest pamięć, a są rejestry.

485
00:46:16,060 --> 00:46:20,920
Rejestry są gdzie rzeczy są aktywnie dzieje.

486
00:46:20,920 --> 00:46:24,750
Nie dodać 2 rzeczy w pamięci, dodać 2 rzeczy w rejestrach.

487
00:46:24,750 --> 00:46:28,160
I przynieść rzeczy z pamięci do rejestrów, a następnie dodać je,

488
00:46:28,160 --> 00:46:33,180
a następnie można umieścić je z powrotem do pamięci, ale akcja dzieje się w rejestrach.

489
00:46:33,180 --> 00:46:38,750
Więc kiedy używasz zmiennej tymczasowej podejście, zwykle to, co się dzieje, jest

490
00:46:38,750 --> 00:46:42,810
te 2 numery są już w rejestrach.

491
00:46:42,810 --> 00:46:46,570
, A następnie od tego momentu, po tym, jak zamienić je,

492
00:46:46,570 --> 00:46:51,540
będzie to po prostu zacząć używać innego rejestru.

493
00:46:51,540 --> 00:46:56,510
Gdziekolwiek używał b, to będzie po prostu korzystać z rejestru, który został już przechowywanie ".

494
00:46:56,510 --> 00:47:02,180
Więc nie trzeba nic robić, aby rzeczywiście zrobić swap. Tak?

495
00:47:02,180 --> 00:47:05,690
[Student] Ale również zajmuje więcej pamięci, prawda?

496
00:47:05,690 --> 00:47:10,280
To zajmie tylko więcej pamięci czy potrzebuje przechowywania tej zmiennej tymczasowej.

497
00:47:10,280 --> 00:47:14,830
Lubię, jeśli później użyć tej zmiennej tymczasowej znów gdzieś,

498
00:47:14,830 --> 00:47:18,920
następnie - lub przypisać coś do tej zmiennej tymczasowej.

499
00:47:18,920 --> 00:47:24,630
Tak więc, jeśli w dowolnym momencie w czasie "," b w temp. mają różne wartości, czy coś,

500
00:47:24,630 --> 00:47:30,680
wtedy będzie miał odrębne miejsca w pamięci, ale prawdą jest, że

501
00:47:30,680 --> 00:47:34,800
istnieje wiele zmiennych lokalnych, które istnieją tylko w rejestrach.

502
00:47:34,800 --> 00:47:44,370
W tym przypadku, to nigdy nie wprowadzony do pamięci, a więc nigdy nie marnujemy pamięć.

503
00:47:44,370 --> 00:47:58,620
Okay. Ostatnie pytanie jest nieco bardziej.

504
00:47:58,620 --> 00:48:04,850
Więc, w tym urządzenia CS50 istnieje słownika.

505
00:48:04,850 --> 00:48:12,390
A powodem tego jest fakt, [? B66] jest sprawdzanie pisowni, gdzie będzie można pisać

506
00:48:12,390 --> 00:48:15,780
używając tabel mieszania lub próbuje ani trochę strukturę danych.

507
00:48:15,780 --> 00:48:22,660
Idziesz do pisania sprawdzania pisowni, a masz zamiar używać tego słownika to zrobić.

508
00:48:22,660 --> 00:48:28,280
Ale dla tego problemu, jesteśmy po prostu będzie patrzeć, czy jedno słowo jest w słowniku.

509
00:48:28,280 --> 00:48:31,250
Więc zamiast zapisania całego słownika w jakiejś strukturze danych

510
00:48:31,250 --> 00:48:35,180
a następnie patrząc na całego dokumentu, aby zobaczyć, czy coś się błędnie,

511
00:48:35,180 --> 00:48:38,490
chcemy tylko znaleźć 1 słowo. Więc może po prostu skanuje cały słownik

512
00:48:38,490 --> 00:48:44,300
i jeśli nie znajdziemy tego słowa w całym słowniku, to nie było tam.

513
00:48:44,300 --> 00:48:52,150
Jeśli skanowanie w całym słowniku i widzę słowo, to jesteś dobry, znaleźliśmy go.

514
00:48:52,150 --> 00:48:56,580
Jest tu napisane, że chcemy zacząć szukać w funkcji obsługi plików z C,

515
00:48:56,580 --> 00:48:59,930
ponieważ chcemy czytać słownik,

516
00:48:59,930 --> 00:49:07,680
ale dam podpowiedź tutaj, co do których funkcje powinny myśleć.

517
00:49:07,680 --> 00:49:11,510
Napiszę je obszarów.

518
00:49:11,510 --> 00:49:20,490
Tak więc najważniejsze z nich będziemy chcieli przyjrzeć się f otwarty, a następnie, w sposób nieunikniony, f zamknięty

519
00:49:20,490 --> 00:49:26,540
która będzie w końcu programu, F i F skanowania.

520
00:49:26,540 --> 00:49:31,060
Można także użyć f czytać, ale prawdopodobnie nie chcesz

521
00:49:31,060 --> 00:49:34,200
dlatego, że - nie skończyć potrzebują tego.

522
00:49:34,200 --> 00:49:41,880
F scan f jest co masz zamiar używać do skanowania na słownik.

523
00:49:41,880 --> 00:49:46,370
A więc nie trzeba kodować do rozwiązania, po prostu spróbuj i jak pseudo-code drogę

524
00:49:46,370 --> 00:50:05,200
do rozwiązania, a potem będziemy dyskutować.

525
00:50:05,200 --> 00:50:14,110
I rzeczywiście, bo już dał ci to, jeśli pójdziesz do dowolnego terminala lub urzàdzenia w skorupkach,

526
00:50:14,110 --> 00:50:18,250
Chciałbym - zwykle - jeśli nie widziałeś jeszcze, nie wiem, jeśli nie w klasie,

527
00:50:18,250 --> 00:50:23,490
ale człowiek, więc strony man, są bardzo przydatne do patrząc na prawie każdym funkcji.

528
00:50:23,490 --> 00:50:27,330
Więc można zrobić, jak, F Man, skanowania f.

529
00:50:27,330 --> 00:50:32,300
To jest teraz temat rodziny skanowania f funkcji.

530
00:50:32,300 --> 00:50:37,070
Mogę też zrobić F Man, otwarte, i że dam mi szczegóły tego.

531
00:50:37,070 --> 00:50:40,750
Więc jeśli wiesz, jaka funkcja jest używana, lub czytasz kod

532
00:50:40,750 --> 00:50:43,000
i widzisz jakąś funkcję i jesteś jak "Co to zrobić?"

533
00:50:43,000 --> 00:50:45,280
Tylko człowiek, że nazwa funkcji.

534
00:50:45,280 --> 00:50:47,340
Istnieje kilka dziwnych przykładów, gdzie można powiedzieć

535
00:50:47,340 --> 00:50:51,620
podoba. man 2, że nazwa funkcji lub man 3, że nazwa funkcji,

536
00:50:51,620 --> 00:50:58,230
ale trzeba tylko zrobić człowiek, jeśli nazwa funkcji nie stanie do pracy po raz pierwszy.

537
00:50:58,230 --> 00:51:03,010
[Student] Tak czytam manuala dla otwartych, ale wciąż nie wiedzą jak z niego korzystać i program.

538
00:51:03,010 --> 00:51:06,170
Okay. Wiele stron podręcznika są mniej, niż pomocny.

539
00:51:06,170 --> 00:51:08,470
Są bardziej przydatne, jeśli już wiesz, co robią

540
00:51:08,470 --> 00:51:12,670
a potem po prostu trzeba zapamiętać kolejność argumentów czy coś.

541
00:51:12,670 --> 00:51:17,640
Lub mogą dać ogólny przegląd, ale niektóre z nich są bardzo przytłaczające.

542
00:51:17,640 --> 00:51:22,220
Jak f skanowania f, również. To daje informacje dla wszystkich tych funkcji,

543
00:51:22,220 --> 00:51:28,120
i 1 linię w dół tutaj dzieje się powiedzieć, "F f skanowania odczytuje z punktu smyczkowy lub strumienia."

544
00:51:28,120 --> 00:51:32,360
Ale f otworzyć. Więc, jak będziemy używać f open?

545
00:51:32,360 --> 00:51:38,470
Ideą programu, który musi zrobić plik I / O jest to, że

546
00:51:38,470 --> 00:51:45,070
trzeba najpierw otworzyć plik, który chcesz zrobić rzeczy, i nieuchronnie

547
00:51:45,070 --> 00:51:51,220
czytać rzeczy z tego pliku i robić rzeczy z nimi.

548
00:51:51,220 --> 00:51:55,350
F otwarty jest co możemy użyć do otwarcia pliku.

549
00:51:55,350 --> 00:52:04,190
Co nam się wrócić, więc jaki plik chcemy otworzyć, daje nam -

550
00:52:04,190 --> 00:52:11,970
tu mówi "/ user / share / dict / words."

551
00:52:11,970 --> 00:52:16,740
Jest to plik, który chcemy otworzyć, a my chcemy, aby go otworzyć -

552
00:52:16,740 --> 00:52:21,440
musimy wyraźnie określić, czy chcemy, aby go otworzyć do odczytu lub, jeśli chcemy otworzyć go napisać.

553
00:52:21,440 --> 00:52:26,490
Istnieje kilka kombinacji i takie tam, ale chcemy, aby otworzyć to do czytania.

554
00:52:26,490 --> 00:52:29,380
Chcemy czytać z pliku.

555
00:52:29,380 --> 00:52:34,290
Więc co ten powrót? Zwraca plik gwiazdkę (*),

556
00:52:34,290 --> 00:52:37,260
a ja po prostu pokazać wszystko w zmiennej f, więc *,

557
00:52:37,260 --> 00:52:40,840
ponownie, jest to wskaźnik, ale nie chcemy zajmować się wskaźniki.

558
00:52:40,840 --> 00:52:46,470
Możesz myśleć, jak f, f jest teraz zmienna będziesz używać do reprezentowania plik.

559
00:52:46,470 --> 00:52:49,850
Więc jeśli chcesz do odczytu z pliku, można przeczytać od f.

560
00:52:49,850 --> 00:52:54,820
Jeśli chcesz, aby zamknąć plik, zamykasz f.

561
00:52:54,820 --> 00:53:00,350
Więc na koniec programu, kiedy nieuchronnie chce zamknąć plik, co powinniśmy zrobić?

562
00:53:00,350 --> 00:53:06,750
Chcemy zamknąć f.

563
00:53:06,750 --> 00:53:12,600
Więc teraz ostatnia funkcja plik będziemy chcesz użyć scan f, f f skanowania.

564
00:53:12,600 --> 00:53:20,930
I co to robi, to skanuje przed plikiem patrząc na wzór, aby dopasować.

565
00:53:20,930 --> 00:53:39,100
Patrząc na manualu tutaj widzimy, int f f skanowania ignorować wartości zwracanej teraz.

566
00:53:39,100 --> 00:53:45,230
Pierwszy argument jest strumień plik *, więc pierwszy argument będziemy chcesz przekazać jest f.

567
00:53:45,230 --> 00:53:47,900
Jesteśmy skanowanie ponad f.

568
00:53:47,900 --> 00:53:53,680
Drugi argument jest łańcuchem formatu.

569
00:53:53,680 --> 00:53:58,310
Dam wam ciąg formatu teraz.

570
00:53:58,310 --> 00:54:05,180
Myślę, że stało się powiedzieć, 127S \ n, dużo, że to niepotrzebne.

571
00:54:05,180 --> 00:54:12,490
Pomysł co to format string jest, jest można myśleć f skanowania jako przeciwieństwo f. druku.

572
00:54:12,490 --> 00:54:17,160
Więc f print, print f również korzystać z tego typu parametru formatu,

573
00:54:17,160 --> 00:54:25,000
ale f druku, co robimy jest - spójrzmy na ekwiwalent.

574
00:54:25,000 --> 00:54:32,550
Więc wydrukować f, a tam rzeczywiście również f print f, gdzie pierwszym argumentem będzie f.

575
00:54:32,550 --> 00:54:40,980
Podczas drukowania f, można powiedzieć coś w stylu "print 127S \ n", a następnie, jeśli mijamy mu trochę ciąg,

576
00:54:40,980 --> 00:54:44,050
to się wydrukować ten ciąg, a następnie w nowej linii.

577
00:54:44,050 --> 00:54:49,690
Co 127 znaczy, jestem pewien, ale ja nigdy nie ogranicza się do tego,

578
00:54:49,690 --> 00:54:52,470
Ty nawet nie trzeba mówić '127 'w F druku

579
00:54:52,470 --> 00:54:57,090
ale co to znaczy, to wypisuje pierwsze 127 znaków.

580
00:54:57,090 --> 00:54:59,350
Więc jestem pewien, że to przypadek. Można google na to.

581
00:54:59,350 --> 00:55:03,000
Ale w następnej jestem prawie pewien, że to oznacza, że.

582
00:55:03,000 --> 00:55:08,880
Więc jest to wypisuje pierwsze 127 znaków, a następnie w nowej linii.

583
00:55:08,880 --> 00:55:14,680
F f skanowania teraz, zamiast patrzeć na zmiennej i drukowania,

584
00:55:14,680 --> 00:55:22,620
to będzie wyglądać w pewnym ciągu, i zapisać wzór do zmiennej.

585
00:55:22,620 --> 00:55:26,360
Miejmy faktycznie używać f skanowania w innym przykładzie.

586
00:55:26,360 --> 00:55:31,670
Powiedzmy więc, że mieliśmy trochę int, x = 4,

587
00:55:31,670 --> 00:55:41,110
i chcieliśmy stworzyć łańcuch wykonany z - chciał stworzyć ciąg

588
00:55:41,110 --> 00:55:44,250
to było jak, to pojawi się znacznie później,

589
00:55:44,250 --> 00:55:49,020
coś, co jest jak 4.jpg.

590
00:55:49,020 --> 00:55:51,870
Więc może to być program, w którym będziesz miał licznik SUM,

591
00:55:51,870 --> 00:55:56,420
Podsumowując przeciwdziałać i, i chcesz zapisać kilka zdjęć.

592
00:55:56,420 --> 00:56:02,430
Więc chcesz zapisać i.jpg, gdzie i jest kilka iteracji swojej pętli.

593
00:56:02,430 --> 00:56:05,500
Jak więc uczynić ten ciąg dla tego JPEG?

594
00:56:05,500 --> 00:56:11,720
Jeżeli chcesz wydrukować 4.jpg, możemy tylko powiedzieć, f druku, d.jpg%,

595
00:56:11,720 --> 00:56:14,410
a potem to wydrukować w tym JPEG.

596
00:56:14,410 --> 00:56:20,050
Ale jeśli chcemy zapisać 4.jpg ciąg używamy f skanowania.

597
00:56:20,050 --> 00:56:30,860
Więc string s - faktycznie możemy nie mogę się - znak, char s, chodźmy 100.

598
00:56:30,860 --> 00:56:35,400
Więc po prostu oświadczył trochę tablicę 100 znaków,

599
00:56:35,400 --> 00:56:39,830
i to, co jesteśmy nieuchronnie będzie przechowywanie że JPEG w.

600
00:56:39,830 --> 00:56:47,920
Więc mamy zamiar używać f skanowania, a format, jak powiedzielibyśmy d.jpg%

601
00:56:47,920 --> 00:56:54,980
w celu wydrukowania 4.jpg, format ten będzie d.jpg%.

602
00:56:54,980 --> 00:57:04,020
Więc format d.jpg%, co chcemy zamienić% d z jest x,

603
00:57:04,020 --> 00:57:06,590
a teraz trzeba przechowywać ten ciąg gdzieś.

604
00:57:06,590 --> 00:57:12,500
A gdzie będziemy przechowywać ten ciąg jest w tablicy s.

605
00:57:12,500 --> 00:57:21,640
Tak więc po tej linii kodu, s, jeśli drukujemy F, S% zmiennej s,

606
00:57:21,640 --> 00:57:26,280
to będzie drukować 4.jpg.

607
00:57:26,280 --> 00:57:38,930
F F tak skanowania jest taki sam, jak skanowania F, lecz teraz to patrząc archiwum

608
00:57:38,930 --> 00:57:43,600
za to, co do przechowywania w sekundach.

609
00:57:43,600 --> 00:57:46,160
To właśnie ostatni argument będzie.

610
00:57:46,160 --> 00:57:54,170
Chcemy zapisać - "rodzina f skanowania funkcji skanowania zarówno wg formatu jak próbowałem poniżej.

611
00:57:54,170 --> 00:58:02,450
Jeśli którekolwiek są przechowywane w lokalizacji punktów może wrócić - "

612
00:58:02,450 --> 00:58:12,910
Nie możemy być dobry. Niech pomyślę o sekundy.

613
00:58:12,910 --> 00:58:26,350
Więc scan f nie jest - co do cholery jest funkcja, która to robi?

614
00:58:26,350 --> 00:58:31,650
Więc scan f nie zajmie integer i zrobić dot JPG.

615
00:58:31,650 --> 00:58:43,490
To będzie [Mumbles].

616
00:58:43,490 --> 00:58:49,360
Zapisz zmienną int int smyczkową C.

617
00:58:49,360 --> 00:58:55,940
Co to jest zmienna, lub co jest ta funkcja nazywa?

618
00:58:55,940 --> 00:59:04,950
Tak. That's - tak. Więc co ja do ciebie określenie przed było s print f,

619
00:59:04,950 --> 00:59:09,820
które - sprawia, że ​​o wiele więcej sensu, dlaczego powiedział, że był o wiele bardziej jak f druku.

620
00:59:09,820 --> 00:59:14,700
Skanowanie f jest jeszcze coś w rodzaju f druku, ale f print s będzie skanować go

621
00:59:14,700 --> 00:59:17,510
i zastąpić zmienne i teraz przechowywać ją w ciąg.

622
00:59:17,510 --> 00:59:19,620
Zamiast drukować go, przechowuje je w ciąg.

623
00:59:19,620 --> 00:59:25,070
Więc zignorować całkowicie. Nadal można myśleć o specyfikatora formatu jako takiego f druku.

624
00:59:25,070 --> 00:59:34,510
Więc teraz, jeśli chcemy zrobić 4.jpg rzecz, zrobilibyśmy f Wydrukuj S, X tego.

625
00:59:34,510 --> 00:59:38,520
Więc co scan f robi - co twoje pytanie będzie?

626
00:59:38,520 --> 00:59:40,820
[Student] Jestem po prostu mylić na co próbujemy zrobić tutaj

627
00:59:40,820 --> 00:59:43,450
z tym JPEG. Czy możesz wyjaśnić, że 1 więcej czasu?

628
00:59:43,450 --> 00:59:52,710
Tak to było - to mniej istotnych unormowań prawnych do f f skanowania teraz, miejmy nadzieję, że będzie to wiązać z powrotem w jakiś sposób.

629
00:59:52,710 --> 01:00:02,240
Ale to, co początkowo zamierzał pokazać było - to jest rzeczywiście bezpośrednio odnoszące się do tych [? F5]

630
01:00:02,240 --> 01:00:08,520
Będziesz używać f Wydrukuj s, gdzie, że mamy 100 zdjęć,

631
01:00:08,520 --> 01:00:13,630
i chcesz przeczytać plik 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
Tak aby to zrobić, musisz F Otwórz, a następnie trzeba przejść w ciąg, który chcesz otworzyć.

633
01:00:21,520 --> 01:00:30,020
Więc chcemy otworzyć 1.jpg, aby utworzyć ciąg, który jest 1.jpg,

634
01:00:30,020 --> 01:00:37,660
my s f wydruku% d.jpg--nie zrobić dla int i = 0.

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

636
01:00:46,580 --> 01:00:51,130
Więc print s% f d.jpg z i.

637
01:00:51,130 --> 01:00:56,320
Tak więc po tej linii, teraz zmienna lub tablica s będzie 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Albo 0.jpg, 1.jpg, 2.jpg. I tak można otworzyć, z kolei każdy obraz do odczytu.

639
01:01:10,610 --> 01:01:19,550
Więc to jest to, co s wydrukować f robi. Czy widzisz to, co s wydrukować f jest teraz robisz?

640
01:01:19,550 --> 01:01:25,720
[Student] Okay, więc to bierze - tworzy ciąg something.jpg, a następnie zapisuje go.

641
01:01:25,720 --> 01:01:30,360
Tak. Stwarza to - to jest inny format string, tak jak i f f skanowania wydruku

642
01:01:30,360 --> 01:01:37,530
gdzie wstawia wszystkie zmienne do drugiego argumentu, może być s, w przeciwieństwie do i.

643
01:01:37,530 --> 01:01:42,280
Być - to znaczy, że to przypadek. Ale cokolwiek by z argumentów jest.

644
01:01:42,280 --> 01:01:45,440
To będzie wstawić wszystkie zmienne w ciągu formatu

645
01:01:45,440 --> 01:01:52,250
a następnie zapisać się do naszego bufora; nazywamy to bufor, to gdzie będziemy przechowywać ciąg.

646
01:01:52,250 --> 01:02:00,750
Więc są przechowywane wewnątrz s prawidłowo sformatowany string,% d został zastąpiony 4.

647
01:02:00,750 --> 01:02:08,080
[Student] Więc jeśli to zrobił, to zmienna f tylko będzie przeniesiony?

648
01:02:08,080 --> 01:02:18,110
Tak. Więc powinniśmy zamknąć oryginalny f przed zrobieniem tego.

649
01:02:18,110 --> 01:02:22,810
Ale - i wtedy również, jeśli nie było f otwarcie tutaj, wtedy musielibyśmy powiedzieć -

650
01:02:22,810 --> 01:02:29,280
Tak. Ale byłoby otworzyć sto różnych plików.

651
01:02:29,280 --> 01:02:37,360
[Student] Ale nie bylibyśmy w stanie uzyskać dostęp lub - w porządku.

652
01:02:37,360 --> 01:02:44,230
Okay. Tak skanowania f, f f skanowania jest rodzaj samej idei,

653
01:02:44,230 --> 01:02:53,610
ale zamiast, zamiast przechowywać je w ciąg, to nic więcej jak jesteś teraz

654
01:02:53,610 --> 01:03:02,420
będzie ponad użądlenia i wzorzec dopasowywania tego łańcucha i przechowywania wyników do zmiennych.

655
01:03:02,420 --> 01:03:11,290
Możesz użyć skanowania f analizować nad czymś 4.jpg i przechowywać całkowitą 4 w x int sum.

656
01:03:11,290 --> 01:03:13,430
To, co możemy wykorzystać f skanującej.

657
01:03:13,430 --> 01:03:16,300
F scan f zrobi, że w linii poleceń.

658
01:03:16,300 --> 01:03:19,200
Właściwie to jestem pewien, że to właśnie biblioteka CS50 ma.

659
01:03:19,200 --> 01:03:29,050
Więc kiedy mówisz, "dostać int," to scan f-ing na - f skanowania sposób można uzyskać dane wejściowe użytkownika.

660
01:03:29,050 --> 01:03:34,670
F scan f ma zamiar zrobić to samo, ale przy użyciu pliku umożliwia skanowanie za pośrednictwem.

661
01:03:34,670 --> 01:03:41,090
Więc tutaj, jesteśmy skanowania nad tym pliku.

662
01:03:41,090 --> 01:03:45,460
Wzór staramy się dopasować jakiś ciąg znaków, który jest 127 znaków

663
01:03:45,460 --> 01:03:48,100
następnie nowej linii

664
01:03:48,100 --> 01:03:54,770
Jestem więc pewien, że moglibyśmy po prostu powiedzieć "pasuje s", ponieważ w słowniku

665
01:03:54,770 --> 01:03:57,770
zdarzy nam się mieć, mamy zagwarantowane, że żadne słowo nie jest długa,

666
01:03:57,770 --> 01:04:03,310
oraz f f skanowania, jak sądzę, będzie zatrzymywać się na nowej linii, nie wiem co.

667
01:04:03,310 --> 01:04:06,970
Ale będziemy to nową linię w tym meczu, a także -

668
01:04:06,970 --> 01:04:13,960
[Student] Jeśli nie to nową linię, czy nie byłoby znaleźć części wyrazu?

669
01:04:13,960 --> 01:04:22,900
To - każdy - patrząc w słowniku -

670
01:04:22,900 --> 01:04:26,200
Tak więc, w słowniku, to wszystko naszych słów.

671
01:04:26,200 --> 01:04:30,500
Każdy z nich jest na nowej linii.

672
01:04:30,500 --> 01:04:32,510
F skanowania będzie odebrać to słowo.

673
01:04:32,510 --> 01:04:38,750
Jeśli nie to nową linię, to jest możliwe, że następny f skanowanie tylko przeczytać w nowej linii.

674
01:04:38,750 --> 01:04:44,180
Ale w tym nowej linii to będzie po prostu zignorować nowy wiersz.

675
01:04:44,180 --> 01:04:49,440
Ale my nigdy nie dostaniesz część słowa, ponieważ jesteśmy zawsze odczytanie do nowej linii, nie wiem co.

676
01:04:49,440 --> 01:04:54,530
[Student] Ale co, jeśli wyszukać słowo "," jak Cissa Cissa.

677
01:04:54,530 --> 01:04:57,380
Znajdzie to, i mówią, że to mecz?

678
01:04:57,380 --> 01:05:05,110
Więc tutaj - będzie to czytać - to jest rzeczywiście dobry punkt.

679
01:05:05,110 --> 01:05:10,660
Nigdy nie używamy prądu - słowo, którego szukasz jest pierwszy argument wiersza polecenia.

680
01:05:10,660 --> 01:05:16,460
Więc string, word = argv 1.

681
01:05:16,460 --> 01:05:20,020
Więc ciąg szukamy jest argv 1.

682
01:05:20,020 --> 01:05:23,290
Nie szukasz słowa w ogóle w naszej f skanowania.

683
01:05:23,290 --> 01:05:28,030
Co robimy ze skanowania f jest coraz każde słowo w słowniku,

684
01:05:28,030 --> 01:05:34,320
a następnie raz mamy to słowo zamierzamy użyć strcmp ich porównanie.

685
01:05:34,320 --> 01:05:39,210
Będziemy porównywać nasze słowo i to co po prostu czytać w.

686
01:05:39,210 --> 01:05:45,110
Tak nieuchronnie, mamy zamiar w końcu robić pęczek skanowania fs

687
01:05:45,110 --> 01:05:52,130
aż tak się dzieje, że scan f wróci -

688
01:05:52,130 --> 01:05:54,800
powróci jeden, tak długo, jak to jest dopasowane nowego słowa

689
01:05:54,800 --> 01:06:01,360
i zwróci coś innego, jak tylko nie udało się dopasować słowo.

690
01:06:01,360 --> 01:06:08,440
Czytamy w całym słowniku, przechowywania wierszu w każde słowo w zmiennej s.

691
01:06:08,440 --> 01:06:17,240
Następnie porównujemy słowo z s, a jeśli porównanie == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp dzieje przynieść 0 jeśli mecz został złożony.

693
01:06:21,650 --> 01:06:31,510
Więc jeśli to było 0, to możemy wydrukować f, dopasowane,

694
01:06:31,510 --> 01:06:35,370
lub słowo jest w słowniku, czy cokolwiek chcesz wydrukować f.

695
01:06:35,370 --> 01:06:41,450
A potem - nie chcemy, aby f zamknąć w kółko.

696
01:06:41,450 --> 01:06:50,410
To jest jedna z tych rzeczy chcemy zrobić, a my nie tylko szukasz słowa w słowniku.

697
01:06:50,410 --> 01:06:56,660
Tak więc możemy zrobić, jeśli chcemy szukać ich wzór, Cissa, tak jak powiedziałem wcześniej,

698
01:06:56,660 --> 01:07:00,260
jeśli chcemy szukać tego wzorca, to byłoby nie w przypadku

699
01:07:00,260 --> 01:07:08,010
bo to nie jest właściwie słowo, ale jednym z tych słów w słowniku, że zdarza się mieć w nim.

700
01:07:08,010 --> 01:07:13,560
Więc to pasuje to słowo, ale to podzbiór słowa nie jest samo słowo.

701
01:07:13,560 --> 01:07:17,250
Ale to nie jest, w jaki sposób jest on używany, jesteśmy czytania w każdym słowie

702
01:07:17,250 --> 01:07:19,740
a następnie porównanie słowa mamy z tym słowem.

703
01:07:19,740 --> 01:07:25,780
Więc jesteśmy zawsze porównując pełne słowa.

704
01:07:25,780 --> 01:07:29,620
Mogę wysłać na sfinalizowanych rozwiązań później.

705
01:07:29,620 --> 01:07:32,050
Jest to rodzaj prawie odpowiedź prawej, myślę.

706
01:07:32,050 --> 01:07:34,720
[Komentarz Student, niezrozumiały]

707
01:07:34,720 --> 01:07:40,870
Och, nie mogę się pozbyć tego wcześniej? Char s, myślę, że powiedział, 127 - I zapomnieć, co jest największym.

708
01:07:40,870 --> 01:07:44,100
Będziemy po prostu zrobić 128, więc teraz jest to wystarczająco długo.

709
01:07:44,100 --> 01:07:46,570
Nie trzeba drukować niczego.

710
01:07:46,570 --> 01:07:56,440
Mamy również zamiar chcę zamknąć nasz plik, i że powinna być o prawidłowej odpowiedzi.

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