1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] 제 문제는 2 설정 : 해커 Edition을

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
당신은 그 클래스에 있다면 이제 이전 supersection처럼, 당신은 무슨 일인지 알아.

16
00:01:12,270 --> 00:01:19,200
P 세트의 모든 일이 섹션이있을거야.

17
00:01:19,200 --> 00:01:22,550
P-세트 2 그래서, 사양, 난 당신이 이미 P-세트 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
그래서 우리는이로 시작 할 수 있습니다 "어떻게 잠시 동안 루프가 DO-동안 루프에서의 차이점은 무엇입니까?

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-하면서 루프는 항상 한 번 이상 실행됩니다.

38
00:02:52,730 --> 00:03:02,950
예. 그래서 그 차이입니다. 동안 루프 - 난 단지 여기에 해 - 루프 동안, 우리는 조건을 가지고

39
00:03:02,950 --> 00:03:19,760
바로 여기, 반면 DO - 동안 우리가 여기까지 올 때까지, 당신은 조건이 없습니다.

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
수행 - 동안 루프 프로그램이 실행되기 때문에, 그것은 "가."하게

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
따라서 동안 루프는 한 번만 할, 또는 것 - 동안 루프를 - 우리 모두에서 수행 할 필요가 없습니다 수

50
00:04:03,720 --> 00:04:07,900
조건이 거짓 인 경우 가능한 한 빨리 우리가에 도착으로부터, 우리는 그 위로 바로 건너 뛸 수 있습니다.

51
00:04:07,900 --> 00:04:11,770
반면 수행 - 동안 루프, 우리는 반드시 한 번 실행됩니다.

52
00:04:11,770 --> 00:04:14,560
그 값이 TRUE인지 FALSE인지 그런 다음, 우리가 조건에 도착하면, 우리는 확인하십시오.

53
00:04:14,560 --> 00:04:19,790
그게 사실이라면, 우리는 또 할거야, 그것은 거짓이라면, 우리가가는 계속됩니다.

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
우리가 할 - 동안 루프를 도입 할 때 그리고 아마 그 중 5 CS50에 있습니다.

58
00:04:43,140 --> 00:04:47,510
그래서 당신은 루프 할 - 때 사용했을까요?

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
그래. 이렇게 - 동안 사용자 입력이 큰 하나입니다 루프.

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
난 "한 번 이상"루프하고 싶지만 가능성이 더있는 곳.

68
00:05:27,170 --> 00:05:33,370
질문 또는 -? 누구든지 DO-동안 루프를 다른 곳 사용 했습니까?

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
당신이 "정수 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
그래서 우리는 분명 한 줄에 할 수 있으며, 이제 우리는 선언과 초기화됩니다.

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 가능한 옵션이 있는데 당신이 그것을 얻을 때까지 당신은 그 각각의 하나를 시도해야합니다.

94
00:07:42,260 --> 00:07:45,470
오. 그럼, 내가 반복해야합니까?

95
00:07:45,470 --> 00:07:51,600
황제 암호화, 그건 - 내 말은, 당신은 당신의 문제에 대응됩니다 -

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는 어떤 것이, 우리는 주위를 다시 줄 바꿈 'A'를 클릭합니다.

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
그리고 읽기 하나는 원본 메시지가 될 것입니다.

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
첫 번째. 첫 번째의 아이디어가 그래서, 당신은에 관계없이의 그것에게 문자열을 전달하고, -

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
이 이것의 일종인가?

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
이 중 supersection에서이없는 사람들이며,

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
[학생] 나는 supersection에 없었다,하지만 난 비트 연산자가 무엇인지 알아요.

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
따라서 'A': 자본의 바이너리 표현, 그 수는 65입니다.

144
00:11:59,680 --> 00:12:07,560
그냥 보는거야 - 41 01,000,001 될 것입니다.

145
00:12:07,560 --> 00:12:14,170
그래서 그런 십진수 65이어야합니다, 그래서이 문자 자본 A.의 이진 표현입니다

146
00:12:14,170 --> 00:12:19,440
이제 문자의 이진 표현은 'a'를 소문자

147
00:12:19,440 --> 00:12:33,350
거의 같은 될 것입니다. 6 예, - 그입니다. 여기가 있습니다.

148
00:12:33,350 --> 00:12:37,670
따라서 이진 자본 A, 이진 소문자 '.'

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
이제 우리는 A를 활용하여에 ''에서 변환 할 수 있습니다 알고

154
00:13:03,770 --> 00:13:09,710
와 비트와 함께, 그것을 ORing - 1 구만.

155
00:13:09,710 --> 00:13:20,900
이 00,100,000와 비트 OR입니다, 그리고 우리 줄게 '에게'을 클릭합니다.

156
00:13:20,900 --> 00:13:26,850
그리고 우리는 비트 ANDing에 의해에 ''에서 확인할 수 있습니다

157
00:13:26,850 --> 00:13:33,700
그 곳 11111 11, 0.

158
00:13:33,700 --> 00:13:43,840
하지만이 개별 비트를 취소, 그래서이 다음 '의'어떤 건지 정확히 우리를 제공합니다

159
00:13:43,840 --> 00:13:50,070
그래서 우리는 01,000,001이됩니다, 바로 계산하면 나도 몰라.

160
00:13:50,070 --> 00:13:56,750
그러나 비트 ORing이 기술은 소문자로 자본 얻을 수

161
00:13:56,750 --> 00:14:02,080
와 비트가 소문자에서 대문자로 이동합니다 ANDing은 A.에 단독으로하지 않습니다

162
00:14:02,080 --> 00:14:06,510
문자의 모든 대 K K, Z VS 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
무엇이든 1,011,111 쓰다 -이 수를 나타내는의 쉬운 방법,이 하나가 아닙니다

167
00:14:32,170 --> 00:14:39,710
것을 나는 supersection에 갔다하지만, 틸드가 (~) 또 다른 비트 연산자입니다.

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
그래서 지금은 0이, 지금, 010,100 1 0, 1이었다.

172
00:15:00,630 --> 00:15:08,320
그럼 그게 전부 ~는 않습니다. 그 제거 - 그럼 32 수 될거야 -

173
00:15:08,320 --> 00:15:23,320
그래서 32 수 00,100,000 될 것입니다, 그래서 이것 ~이 될거야

174
00:15:23,320 --> 00:15:29,980
같이 'a'를 ANDed 것으로이 숫자까지.

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 (들), 그럼 + +.

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 (들),

192
00:17:06,859 --> 00:17:11,900
그리고 나서 <길이, 경우에 당신은 전에 보지 못 않습니다

193
00:17:11,900 --> 00:17:20,410
나는 또한 할 수있는 INT I = 0, 길이 = 나 strlen (들).에게

194
00:17:20,410 --> 00:17:25,010
그리고이 이제부터 내가 범위를 제한 한, 다소 바람직합니다

195
00:17:25,010 --> 00:17:29,150
가변 길이의 대신 루프 '에 대한'의 이번은, 전에 명시하는 것

196
00:17:29,150 --> 00:17:34,990
그리고 항상 존재하고 나쁜 이유 만약 당신이 잡을하지 않은

197
00:17:34,990 --> 00:17:39,410
나 왜 원래는 뭐냐면, 나쁜 짓을 했어요 - 루프의부터 시작합니다.

198
00:17:39,410 --> 00:17:43,380
나는 조건을 확인 했어요. 내가 S의 길이를 <있습니까?

199
00:17:43,380 --> 00:17:46,790
그래서 s의 길이는, 그럼 전체 시간 "안녕하세요"로 일하게.

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
그래서 = 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
항상 다섯 될거야, 심지어는 절대로 변하지 않을 꺼라고 생각.

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
그럼 우리는이 일을 할 수 있겠어요? 우리가 일을하려고한다면 우리의 조건, 정말 -이 알파벳인지 확인합니다.

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
그래서 우리는 님의 [내가]이 - 알파 기능이며, 명시 적을 사용을 사용하지 보자

217
00:19:32,710 --> 00:19:40,460
그 s의 여덟째 문자입니다, 문자열의 문자 배열입니다 기억

218
00:19:40,460 --> 00:19:43,180
s의 여덟째 문자 때문에.

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
그래. 그래서, 만약 님의 [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
만 단일 인용 문자, 따옴표 상수를 사용합니다. 따라서 'A'이하 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
그것은 모든 다른 하나이지만, 우리는 물론, 모듈 2 수 없거나부터 모드 2,

242
00:22:18,270 --> 00:22:22,950
E는 성도로, 'A'는 소문자가됩니다? 하지만 그들을 분리 공간이있어?

243
00:22:22,950 --> 00:22:27,150
그래서 같은 모드이 될거야하지만, 다른 가지 경우 야.

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
그러나, 그래서 지금은 경우 카운트 모드 2를 말씀하시는 거예요.

252
00:23:09,130 --> 00:23:12,590
그래서 수는 모드 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 경우입니다.

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
그러나 방법이 있습니다 - 써이 뒤집혀 있습니다 -

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
그래서 우리가 소문자로 'A'에 무슨 짓을했는지 알, 우리가 A를 대문자로 같은 정확한 일을 한 게 아닐까?

263
00:24:07,830 --> 00:24:11,900
변화를 대문자 않거나 값 변경합니까?

264
00:24:11,900 --> 00:24:23,100
그래. 그래서 ~ 32 ANDed 모든 자본 편지 비트는 같은 대문자 문자가 될거야

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
나는 supersection이 말을 : 당신이 원하면 당신은 32를 사용할 수 있지만 'a'를하고 선호하는 경향이 - A,

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
이 '을'사용할 수 있습니다 -이 두 사이에 다른 비트를 얻을

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으로 그냥 소문자 유지 ORing, 이미 소문자했습니다.

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
A와 'A'가 적어도 26이어야 사이의 차이

296
00:27:07,650 --> 00:27:10,760
아니면 우리가 모든 자본 번호를 표시하지 않았 겠죠.

297
00:27:10,760 --> 00:27:18,630
즉, A, 우리가 1에서 시작 경우,이 비트를 모두 사용하는거야 것을 의미합니다

298
00:27:18,630 --> 00:27:23,900
Z.을 통해 모든 것을 대표하는이 처음 5 비트의 모든

299
00:27:23,900 --> 00:27:32,170
그 이유를 다음 비트, 또는이 비트입니다, 그 다음 비트는 A와 구별하도록 선택한 바로 그 사람입니다 '.'

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
A가 10000001이고, 그리고 'A'가 11100001이라면, 마찬가지로 - 내가 뭐, 잊어 버려.

305
00:28:12,040 --> 00:28:18,100
A. - 그게이 있다면 그러나, 우리는 여전히 'a'를 사용할 수

306
00:28:18,100 --> 00:28:22,650
그것은 지금하고 ''그래도이 2 비트의 차이입니다.

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
또한, 당신은 우리가 님의 [내가] + = 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
그래서 기억 - 내가 쓰지 않습니다 - 모든 0이 아닌 값은 사실이며, 0은 false입니다.

321
00:30:00,900 --> 00:30:07,880
따라서 '카운트 모드이 경우 == 0 "라는 같은는"MOD 두 수를 계산하지 않으면. "

322
00:30:07,880 --> 00:30:11,580
아마 그냥 선을 반대하고있는 경우 카운트 모드 2 ", 말했을 것이다

323
00:30:11,580 --> 00:30:15,350
OR 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를 출력합니다.

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
이 꽝에 대한 좋은 점은되게, 이건에 무엇을 알 수

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 추가를 감사합니다."

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
우리는 두 변수를 교환하려면, 우리는 그것을 할 기능을 사용하고 있지 않습니다.

351
00:32:40,070 --> 00:32:43,410
우리는 여전히 말씀처럼 메인에서 할 겁니다.

352
00:32:43,410 --> 00:32:48,360
하지만 그 두 변수를 사용하여, 우리는 임시 변수를 사용하지 않습니다.

353
00:32:48,360 --> 00:32:50,770
이 작업을 수행하는 두 가지 방법이 있습니다.

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 변수를하면, A, 어떤은 정수입니다

358
00:33:12,130 --> 00:33:17,800
그들은 저를주고, 내가이 주어진 건 또 다른 정수입니다 합 변수 B,하는.

359
00:33:17,800 --> 00:33:22,700
난이 두 변수를하면, 지금은 놈들을 교환하고 싶습니다.

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
우리는 같은 일을 수행하여 교환 할 수있는 = + B,와 b = - 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 = 행동 - B입니다.

367
00:34:18,820 --> 00:34:30,250
그래서 우리가하고있는 B = A - B, 7 될 것입니다 어떤하고, b = - B 다시

368
00:34:30,250 --> 00:34:38,650
또는 = - 나. 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
이 시점에서, ''는 조합이며, 다음에 우리가 원래 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
가자 우리이 숫자는 1111, 그리고 1,111아르 말, 우리는 지금 바이너리에있어하도록합니다.

379
00:35:26,720 --> 00:35:34,630
실제 소수에서, 당신이 그것을 그렇게 생각하고 싶다면, A = 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 일하고 B는 15이 될 것으로 기대합니다.

385
00:35:57,670 --> 00:36:01,780
따라서 첫 단계는 = + 나.

386
00:36:01,780 --> 00:36:08,770
0001이 우리의 숫자는 4 비트 폭이기 때문에 ','1111입니다, + B,,

387
00:36:08,770 --> 00:36:16,780
10,000 끝나게하려고하지만, 우리는 4 비트가 있습니다.

388
00:36:16,780 --> 00:36:22,540
이제 = 0.

389
00:36:22,540 --> 00:36:34,080
B - - 사실, 아직 완벽하게 작동합니다 그리고 지금 우리는 B = 설정하고 싶습니다.

390
00:36:34,080 --> 00:36:39,630
= - B -이 완벽하게 작동하는지 보자.

391
00:36:39,630 --> 00:36:53,720
그래서 B = 0 - 그리고 아직 15 것 1, 그리고 = - 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
다시,이야, 비트 연산자는 비트, 그리고 더라구요으로 비트 역할을하므로 -

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
그럼 같은 나. 비트 중 하나에 해당하는 경우, 1 만, 또는 달리 사실 두 비트 수 없습니다.

403
00:37:56,180 --> 00:37:59,320
OR이 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'는 그래서 지금 'A'는 0이며, 5 비트를받은 후, 0이되고 일이 경우,

411
00:38:44,940 --> 00:38:48,730
그 이름이 뭔지는 "정수 오버플로."

412
00:38:48,730 --> 00:38:54,370
위키 백과 (Wikipedia)에 따르면, "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 비트가 있습니다. 그정도는 - 우리가 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
그리고 위키 백과 문서에서는 그 소리 것 같은데 -

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, B -, 괜찮아 질 거라고 그.

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
에 관계없이 어떤 순서가이 두 숫자는, 여기까지에 있어야 발생

441
00:41:27,620 --> 00:41:30,100
이 결과는 동일한 될 것입니다.

442
00:41:30,100 --> 00:41:35,800
그래서 ^ B입니다 B ^.

443
00:41:35,800 --> 00:41:51,860
당신은 또한이 같은 서면 볼 수 있습니다 ^ = B, B ^ =, ^ = B 다시.

444
00:41:51,860 --> 00:42:00,200
그래서이 맞아,이 작품은, 비트의 생각하는 이유를 볼 수 있습니다.

445
00:42:00,200 --> 00:42:10,400
smallish 번호를 사용 11001, 그리고 01100를 가정 해 봅시다.

446
00:42:10,400 --> 00:42:12,790
그래서이 'A'이며이 B입니다.

447
00:42:12,790 --> 00:42:15,540
그래서 ^ = 나.

448
00:42:15,540 --> 00:42:22,380
우리는이 2 가지의 XOR에 'A'= 설정을 할거야.

449
00:42:22,380 --> 00:42:32,920
1 그래서 ^ 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
그리고 (^ 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 ^) ^.

468
00:44:24,680 --> 00:44:28,970
그리고 우리는 할 수있는 B ^ (^).에게

469
00:44:28,970 --> 00:44:31,540
그리고 다시, 우리는 원래 B를.

470
00:44:31,540 --> 00:44:37,120
따라서 'A'지금 함께 'A'와 B의 조합입니다.

471
00:44:37,120 --> 00:44:49,660
우리의 새로운 콤보 사용 '을'우리 말 B = 콤보 ''^ 원래 B, 우리는 원래 얻기 '를'을 클릭합니다.

472
00:44:49,660 --> 00:45:05,170
지금은 = 콤보 ''^ 새로운 B, 원래 있었는지 - 나 이는 'A'또는 B 뭔지 지금입니다.

473
00:45:05,170 --> 00:45:13,620
이 사건은 여기 아래에있다. 이 = B, 오래된 B입니다.

474
00:45:13,620 --> 00:45:16,550
그래서 지금 모든 바꾼 순서로 다시입니다.

475
00:45:16,550 --> 00:45:22,960
우리가 실제로 비트를 바라 보았다 경우, B = ^ B,이 2 XOR 것입니다

476
00:45:22,960 --> 00:45:33,920
그리고 답이있을거야, 다음 = ^ B이 2 XORing과 답변이 있습니다 이예요.

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
이 두 숫자는 레지스터에 이미 있습니다.

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
따라서 시간이 온도에서 ','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]이 (가) 작성됩니다 맞춤법 검사기 is

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
하지만, 그래서 사람이 페이지는, 거의 모든 기능을보고에 매우 유용합니다.

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
좋아요. 그 함수 이름 또는 남자 셋이 기능 이름, 사람이

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
좋아요. 그 사람 페이지의 많은 도움 미만의 거리에 있습니다.

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
여기에 그 "/ 사용자 / 공유 / DICT / 단어입니다."라고

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
여기에 남자 페이지를 살펴보고, 우리는 INT F 스캔 F를 참조하십시오, 지금은 반환 값을 무시합니다.

566
00:53:39,100 --> 00:53:45,230
첫 번째 인수는 파일 * 스트림이며, 우리가 전달하려는 것 첫 번째 인수가 F집니다.

567
00:53:45,230 --> 00:53:47,900
우리는 F를 통해 스캔하고 있습니다.

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, 우리는 형식 매개 변수의 형식을 사용 인쇄 F,

573
00:54:17,160 --> 00:54:25,000
하지만 인쇄 F에 우리가하는 일입니다 -가 동등한 살펴 보자.

574
00:54:25,000 --> 00:54:32,550
따라서 F를 인쇄하고, 첫 번째 인수가 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
그럼 시작하자 우리가 어떤 정수가 있다는 말은, 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
제가 이의를 제기 합계, 당신은 이미지의 무리를 저장하고 싶습니다.

592
00:55:56,420 --> 00:56:02,430
그래서 당신은 당신의 루프의 일부 반복 is 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, 그럼 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.의 정수 변수를 저장

617
00:58:49,360 --> 00:58:55,940
어떤이 변수는, 또는이 함수가 뭐였죠입니까?

618
00:58:55,940 --> 00:59:04,950
예. 그정도면 - 예. 그래서 내가 당신에게 정의 된 것은 전에, 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로. 그 한 시간을 더 설명 할 수 있습니까?

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
당신의 인쇄 f를 사용하려고하고, 우리 100 이미지가 어디 라고요

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
%의 우리가 S 할 인쇄 말뜻은 d.jpg-- 우리는 INT 난 = 0에 대해 안 했어요.

635
01:00:37,660 --> 01:00:46,580
나는 <40, 전 + +.

636
01:00:46,580 --> 01:00:51,130
따라서 S 인쇄 F %는 전의 d.jpg.

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
그래서 그런 s는 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 등 전에 반대 될 수 있습니다.

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
그래서 우리는 올바르게 형식의 문자열, % d 개은 4로 대체 된 것으로 내부에 s의 저장됩니다.

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 같은 이상 분석하고, 합 INT의 X로 정수 4 저장하는 스캔 f를 사용할 수 있습니다.

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
그래서 당신은 말할 때, "정수 가서"은 스캔 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
그래서 사전에 이후 "을 일치"우리가 말할 수 확신

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
이, 이왕이면 새로운 단어를 일치 한 것처럼, 하나가됩니다

689
01:05:54,800 --> 01:06:01,360
그리고, 최대한 단어가 일치하도록 실패로 뭔가를 반환합니다.

690
01:06:01,360 --> 01:06:08,440
우리는 변수들로 각 단어 선으로 줄을 저장, 전체 사전을 통해 읽을 수 있습니다.

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
전에 아, 그건 제거 거죠? 숯불 S, 우리가 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