1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] בעיה בחלק הגדרה 2: מהדורת האקר

2
00:00:02,670 --> 00:00:04,910
רוב אודן, אוניברסיטת הרווארד

3
00:00:04,910 --> 00:00:07,410
זה CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
אז, אני רוב. אני בכיר בקירקלנד. זו השנה השלישית שלי TFing CS50.

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, מפרטים, אני מניח שראית את זה ביום 1-P-סט כבר.

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
אז אנחנו יכולים להתחיל עם אלה: "איך לולאה בזמן נבדלה מעשה תוך לולאה?

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
[סטודנטים] עשה תוך לולאה תמיד לבצע לפחות פעם אחת.

38
00:02:52,730 --> 00:03:02,950
כן. אז זה ההבדל. לולאה בזמן - I'll פשוט לעשות את זה כאן - ואילו לולאה, יש לנו את המצב

39
00:03:02,950 --> 00:03:19,760
ממש כאן, ואילו עשה זמן מה, אין לך מצב, עד שנגיע לכאן.

40
00:03:19,760 --> 00:03:24,130
וכך, כאשר התכנית של ביצוע, וזה מגיע ללולאה בזמן,

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
ואז, כשנגיע למצב, אנחנו בודקים אם זה אמת או שקר.

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
שאלות או -? האם מישהו השתמש עשה תוך לולאה בכל מקום אחר?

69
00:05:33,370 --> 00:05:36,780
אוקיי. אז הבא הוא, "מה שלא נאמר מזהה

70
00:05:36,780 --> 00:05:43,310
בדרך כלל לציין אם outputted ידי צלצול? "

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 int", או "המחרוזת Y".

83
00:06:37,360 --> 00:06:41,910
האתחול של משתנה, או ההקצאה של משתנה,

84
00:06:41,910 --> 00:06:44,510
הוא בכל פעם שאתה אומר "x = 2".

85
00:06:44,510 --> 00:06:52,950
אז אנחנו יכולים לעשות את זה בשלבים נפרדים, int x, x = 2, ועד - יכול להיות לנו חבורה של דברים בפה -

86
00:06:52,950 --> 00:07:00,350
אבל עד קו זה קורה, x עדיין לא מאותחל, אך הוא הוכרז.

87
00:07:00,350 --> 00:07:06,760
וכך אנו יכולים כמובן לעשות את זה בקו 1, ועכשיו אנחנו הכרזה ואתחול.

88
00:07:06,760 --> 00:07:10,730
שאלות?

89
00:07:10,730 --> 00:07:18,390
ולבסוף, "למה הצפנת הקיסר אינו בטוחה?"

90
00:07:18,390 --> 00:07:23,830
אז קודם כל, האם מישהו רוצה לומר מה הצפנת הקיסר זה?

91
00:07:23,830 --> 00:07:28,100
[סטודנטים] קיסר הצפנה פשוט היא שאתה ממפה, אתה מסב את כל מכתב,

92
00:07:28,100 --> 00:07:34,420
מספר מסוים של אותיות ניגש, ולחזור שוב, וזה לא מאוד מאובטח מפני

93
00:07:34,420 --> 00:07:42,260
יש רק 26 אופציות אפשריות ואתה פשוט תצטרך לנסות כל 1 מאלה עד שאתה מקבל את זה.

94
00:07:42,260 --> 00:07:45,470
אה. אז, אני צריך לחזור?

95
00:07:45,470 --> 00:07:51,600
קיסר ההצפנה, זהו - אני מתכוון, שיצטרך להתעסק עם זה בבעיות שאתם -

96
00:07:51,600 --> 00:07:56,110
או אני מניח מהדורה הסטנדרטית של קבוצת הבעיה, כי לא על מהדורת ההאקר.

97
00:07:56,110 --> 00:08:01,550
אז במהדורה הסטנדרטית לקבוצת הבעיה, אתה תקבל הודעה בסגנון: "שלום, עולם"

98
00:08:01,550 --> 00:08:08,410
ויש לך גם מספר כמו 6, ואתה לקחת את המסר הזה, וכל תו בודד,

99
00:08:08,410 --> 00:08:11,310
אתה מסובב אותו על ידי 6 עמדות באלף בית.

100
00:08:11,310 --> 00:08:16,560
אז 'H' בשלום יהפוך h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
אז האות הראשונה תהיה n. אנחנו עושים את אותו דבר עם דואר.

102
00:08:19,600 --> 00:08:23,530
אם יש לנו, כמו, z או משהו, אז אנחנו חוזרים לעטוף סביב ל '.'

103
00:08:23,530 --> 00:08:29,280
אבל כל דמות מקבלת רכב על אופניו כעבור 6 תווים באלף הבית, וזה לא מאוד מאובטח

104
00:08:29,280 --> 00:08:35,440
מכיוון שיש רק 26 אפשרויות לכמה דרכים אתה יכול לעטוף אות אחת.

105
00:08:35,440 --> 00:08:42,919
אז אתה יכול פשוט לנסות את כל 26 מהם, וכנראה גם למסר מספיק ארוך,

106
00:08:42,919 --> 00:08:46,860
רק 1 מתוך 26 האפשריים הדברים האלה הולך להיות קריאים,

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
אז א ': ייצוג בינארי של הון, המספר הוא 65.

144
00:11:59,680 --> 00:12:07,560
אני רק הולך להסתכל על - 41 הולכים להיות 01000001.

145
00:12:07,560 --> 00:12:14,170
אז זה צריך להיות 65 בעשרוני; אז זה הייצוג בינארי של אופי הון א

146
00:12:14,170 --> 00:12:19,440
עכשיו, הייצוג בינארי של דמות אותיות קטנות '"

147
00:12:19,440 --> 00:12:33,350
הולך להיות אותו הדבר, כמעט. האם זה - 6, כן. זה נכון.

148
00:12:33,350 --> 00:12:37,670
הון אז ינארי אותיות קטנות, בינארי '.'

149
00:12:37,670 --> 00:12:43,940
אז שם לב שההבדל בין ו '"הוא קצת בודד זה.

150
00:12:43,940 --> 00:12:49,440
וזה קורה להיות 32 ביט, קצת מייצג את המספר 32.

151
00:12:49,440 --> 00:12:53,910
וזה נשמע הגיוני מאז הוא 65; "'הוא 97.

152
00:12:53,910 --> 00:12:56,610
ההבדל ביניהם הוא 32.

153
00:12:56,610 --> 00:13:03,770
אז עכשיו אנחנו יודעים שאנחנו יכולים להמיר ל''על ידי הנטילה

154
00:13:03,770 --> 00:13:09,710
וסיבי האופרטור ORing, עם - שנראה כמו 1.

155
00:13:09,710 --> 00:13:20,900
זה סיבי האופרטור OR, עם 00100000, ושייתן לנו '".

156
00:13:20,900 --> 00:13:26,850
ואנחנו יכולים לקבל מ''ל על ידי סיבי האופרטור anding

157
00:13:26,850 --> 00:13:33,700
עם 11, 0 באותו מקום, 11111.

158
00:13:33,700 --> 00:13:43,840
אז זה אז ייתן לנו בדיוק את מה '"היה, אבל מבטל מעט אדם זה,

159
00:13:43,840 --> 00:13:50,070
אז יהיה לנו 01000001; אני לא יודע אם ספרתי נכון.

160
00:13:50,070 --> 00:13:56,750
אבל הטכניקה הזאת של סיבית האופרטור ORing להגיע מבירה לאותיות קטנות,

161
00:13:56,750 --> 00:14:02,080
וסיבי האופרטור anding להגיע מאותיות קטנות להון אינו בלעדי לא

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
לכתוב את מה שהוא 1011111 - דרך קלה לייצג את המספר הזה, וזה לא אחד

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
אז זה היה 1, עכשיו 0, זה הוא 0, עכשיו 1, 010100.

172
00:15:00,630 --> 00:15:08,320
אז זה כל מה שעושה ~. אז 32 הוא הולך להיות מספר - להיפטר מזה -

173
00:15:08,320 --> 00:15:23,320
כך 32 הוא הולך להיות המספר 00100000, ולכן ~ זה הולך להיות

174
00:15:23,320 --> 00:15:29,980
מספר זה כאן כי אני 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 = 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
בדקתי את מצבו. האם אני <האורך של?

199
00:17:43,380 --> 00:17:46,790
אז האורך של, בואו לעבוד עם "שלום" כל הזמן.

200
00:17:46,790 --> 00:17:49,670
אז אורך של, 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
אפילו חשב שזה לעולם לא ישתנה, זה תמיד הולך להיות 5.

206
00:18:17,380 --> 00:18:22,530
אז אנחנו פשוט זוכרים 5 מלפנים, ועכשיו הכול יותר טוב.

207
00:18:22,530 --> 00:18:24,990
אז iterating על כל המייתרים.

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
בואו לא אשתמש היא פונקצית אלפא, ולהשתמש המפורשים - ולכן יש לנו ים [i],

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
כן. אז אם s [i] הוא ≥ 65, וזה [i] הוא ≤ 90, מה אני צריך לעשות במקום זה?

222
00:20:07,860 --> 00:20:18,470
כן. אז אתה בהחלט צריך אפילו לא צריך לדעת את ערכי ASCII של דבר אי פעם.

223
00:20:18,470 --> 00:20:25,640
לעולם לא חושב על המספרים 65, 90, 97 ו 102, או מה שזה לא.

224
00:20:25,640 --> 00:20:32,470
אתה לא צריך - 112 -? אתה לא צריך לדעת מי בכלל. זה לא נכון גם.

225
00:20:32,470 --> 00:20:41,940
להשתמש רק בתווים בודדי הציטוט, הקבועים ציטוט בודד. אז א 'ופחות מ 90 הם' ז''

226
00:20:41,940 --> 00:20:47,930
וזה הרבה יותר טוב - אני לא יודע את החלק העליון של הראש שלי, כי Z הוא 90.

227
00:20:47,930 --> 00:20:52,690
אני יודע את החלק העליון של הראש שלי, כי "Z" הוא הבירה צ

228
00:20:52,690 --> 00:21:02,100
אז כל עוד זה בטווח של הון להון Z, או שאנחנו יכולים לבדוק באותיות קטנה

229
00:21:02,100 --> 00:21:17,010
או אם זה בטווח ≥ '' ו≤ 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 של i, או i mod 2, מאז

242
00:22:18,270 --> 00:22:22,950
תבחין כי E היא הון ו''היא אותיות קטנה? אבל יש מקום להפריד ביניהם?

243
00:22:22,950 --> 00:22:27,150
אז הם הולכים להיות הזהה mod 2, אבל הם מקרים שונים.

244
00:22:27,150 --> 00:22:29,150
[שאלת סטודנט, לא מובן]

245
00:22:29,150 --> 00:22:34,690
כן. אז אנחנו פשוט מתכוונים להמשיך לספור.

246
00:22:34,690 --> 00:22:38,730
גם אנחנו יכולים לעשות את זה פה אם אנחנו רוצים; שיכולים להיות קצת מסורבל

247
00:22:38,730 --> 00:22:41,300
בהצהרות ללולאה; אני אשים את זה כאן.

248
00:22:41,300 --> 00:22:48,840
אז ספירת int = מתחילה ב 0.

249
00:22:48,840 --> 00:22:54,070
ועכשיו, אני הולך לספור כמה יש להשתמש באותיות שהיינו לנו.

250
00:22:54,070 --> 00:22:59,550
אז אנו בהכרח הולכים לספור + + מאז שנמצאנו בתו אלפביתי.

251
00:22:59,550 --> 00:23:09,130
אבל, אז עכשיו אתה אומר שאם mod הספירה 2.

252
00:23:09,130 --> 00:23:12,590
אז מה אם ספירת mod 2? אה. אני אעשה == 0 לעת עתה.

253
00:23:12,590 --> 00:23:21,740
אנחנו גם נלך על זה. אז אם ספירת mod 2 == 0, אז מה?

254
00:23:21,740 --> 00:23:27,830
[סטודנטים] תשובה, סתומים

255
00:23:27,830 --> 00:23:32,750
אז אנחנו רוצים שזה בסופו של אותיות רישיות.

256
00:23:32,750 --> 00:23:37,520
ישנם 2 מקרים; אותיות גדולות וקטן הם 2 המקרים.

257
00:23:37,520 --> 00:23:40,990
אז אם אנחנו נמצאים באותיות קטנות שאנחנו צריכים לעשות את זה אותיות גדולות.

258
00:23:40,990 --> 00:23:43,710
אם זה באותיות גדול שאנחנו לא צריכים לעשות שום דבר.

259
00:23:43,710 --> 00:23:50,760
אבל, האם יש דרך - לא אמור להיות התהפך -

260
00:23:50,760 --> 00:23:54,800
שאנחנו אפילו לא צריכים לבדוק אם זה אותיות גדול או קטן?

261
00:23:54,800 --> 00:24:02,240
מה אנחנו יכולים לעשות תמיד לוודא שאנו תמיד בסופו באותיות גדולות?

262
00:24:02,240 --> 00:24:07,830
אז שים לב למה שעשינו לאותיות קטנות '", מה שאם הייתי עושה בדיוק אותו דבר זה לאותיות גדולות?

263
00:24:07,830 --> 00:24:11,900
האם אותיות גדולות שינוי, או עושה שינוי הערך?

264
00:24:11,900 --> 00:24:23,100
כן. אז כל מכתב הון סיבי האופרטור ANDed עם ~ 32 הולך להיות אותו אופי רישיות

265
00:24:23,100 --> 00:24:29,220
כי לכל תו באותיות גדול מעט 32 אינה מוגדר.

266
00:24:29,220 --> 00:24:40,920
אז אם אנחנו רוצים להביא את האופי של [i], אנחנו רוצים שזה יהפוך אותיות קטן או אותיות רישיות.

267
00:24:40,920 --> 00:24:46,890
אז אם זה היה קטן, עכשיו זה באותיות גדול, אם זה היה באותיות גדול, זה עדיין באותיות גדול, וזהו.

268
00:24:46,890 --> 00:24:54,290
אני אמרתי את זה בsupersection: ניתן להשתמש ב32 אם אתה רוצה, אבל אני נוטה להעדיף עושה '"-,

269
00:24:54,290 --> 00:25:01,150
במקום 32 פשוט סתם, כי זה יכול להיות כל קצת אחר.

270
00:25:01,150 --> 00:25:03,610
לאחר 32 ביט, זה יכול להיות כל אחד מאלה, או שלא יהיה לי מספיק

271
00:25:03,610 --> 00:25:05,840
מספרים כדי לייצג את כל התווים.

272
00:25:05,840 --> 00:25:09,110
אז אם אתה מקבל 32 ביט, זה יכול להיות 64 הביט, זה יכול להיות 128 ביט.

273
00:25:09,110 --> 00:25:13,990
כל אחת מהחתיכות האלה יכולה להיות קצת שמבחינה בין אותיות גדולות וקטן.

274
00:25:13,990 --> 00:25:18,350
אני לא צריך לדעת שזה 32 הביט.

275
00:25:18,350 --> 00:25:27,130
אני יכול להשתמש בזה '"- כדי לקבל קצת שונה שבין שניים

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 משמעות - א

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
ההבדל בין ו''צריך להיות לפחות 26,

296
00:27:07,650 --> 00:27:10,760
אחרת לא הייתי מיוצגים כל מספרי ההון.

297
00:27:10,760 --> 00:27:18,630
זה אומר שאם יתחילו ב1, זה הולך להשתמש בכל הקטעים האלה,

298
00:27:18,630 --> 00:27:23,900
כל 5 החתיכות הראשונות האלה, שייצגו את הכל דרך צ

299
00:27:23,900 --> 00:27:32,170
זו הסיבה שהקטע הבא, או את הקטע הזה, הקטע הבא הוא אחד כי הוא בוחר להבחין בין ו '.'

300
00:27:32,170 --> 00:27:40,930
זו גם הסיבה מדוע, בטבלת ASCII, יש 5 סמלים מפרידים בין אותיות מאותיות קטנות.

301
00:27:40,930 --> 00:27:49,050
מאז אלה הם סמלים, תוספת 5 שמעלה 32 להיות ההבדל ביניהם.

302
00:27:49,050 --> 00:27:51,840
[סטודנטים] אז אנחנו יכולים לעשות את זה, כי ASCII מתוכנן ככה.

303
00:27:51,840 --> 00:27:57,280
כן. אבל ASCII - ההבדל יכול להיות גם שתי פיסות אלה.

304
00:27:57,280 --> 00:28:12,040
כאילו, אם היו 10000001, ו '' היה 11100001 - אני שוכח, לא משנה מה.

305
00:28:12,040 --> 00:28:18,100
אבל אם זה היה כך, אז תוכל עדיין להשתמש '' - א

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
זה עדיין יהיה 2 סיבי; כל דמות ודמות, כאילו, Z ו Z, K ו-K,

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
כמו כן, אתה יודע איך אנחנו יכולים לעשות דברים כמו של [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
אתה יכול גם לעשות s [i] וסיבי האופרטור = 32.

318
00:29:41,090 --> 00:29:46,400
וסיבי האופרטור OR = 32.

319
00:29:46,400 --> 00:29:51,490
כמו כן, לספור mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
אז לזכור את זה - אני לא כותב את זה - כל ערך שאינו אפס הוא אמיתי, ו0 הם שקר.

321
00:30:00,900 --> 00:30:07,880
אז "אם ספירת mod 2 == 0" הוא כמו לומר "אם לא סופר mod 2."

322
00:30:07,880 --> 00:30:11,580
בטח הייתי פשוט התהפכתי הקווים ואמר: "אם ספירת mod 2,

323
00:30:11,580 --> 00:30:15,350
אל או 1, אחרת אין ו1, "כך שאני לא צריך" לא. "

324
00:30:15,350 --> 00:30:18,650
אבל זה עובד באותה מידה.

325
00:30:18,650 --> 00:30:25,660
ומה עוד אני יכול לעשות כאן?

326
00:30:25,660 --> 00:30:29,060
אתה יכול לשלב אותם עם משולש, אם אתה רוצה, אבל אז זה הייתי פשוט לגרום לדברים מבולגנים

327
00:30:29,060 --> 00:30:33,770
וכנראה קשה יותר לקריאה, כדי שלא תעשו את זה.

328
00:30:33,770 --> 00:30:37,330
מישהו יש לך הצעות אחרות?

329
00:30:37,330 --> 00:30:41,580
האם זה כל הבעיה בקשה? אה, כן.

330
00:30:41,580 --> 00:30:51,070
אז להיפטר מהשורות הריקות האלה, עכשיו אנחנו נדפיס f,% s להיות אחד למייתרים,

331
00:30:51,070 --> 00:30:56,620
אנחנו נדפיס F, S.

332
00:30:56,620 --> 00:30:59,330
עכשיו בואו להפעיל אותו. האם אני עושה משהו לא בסדר?

333
00:30:59,330 --> 00:31:03,200
זה \ "; אני רוצה n.

334
00:31:03,200 --> 00:31:07,840
אוקיי. עכשיו אנחנו ננהל אותו. זה בטח יצעק עליי.

335
00:31:07,840 --> 00:31:11,250
Strlen הוא בstring.h.

336
00:31:11,250 --> 00:31:14,290
אז זה דבר נחמד על קלאנג הוא שהוא אומר לך מה זה ב,

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 משתנה אלה לפונקציה (גם אם בשם SWAP) לא בדיוק עובד, לפחות לא בלי "מצביעים".

349
00:32:30,780 --> 00:32:37,020
ולהתעלם ממצביעים עד שנגיע אליהם.

350
00:32:37,020 --> 00:32:40,070
אנחנו רוצים להחליף 2 משתנים, אנחנו לא משתמשים בפונקציה שעושים את זה.

351
00:32:40,070 --> 00:32:43,410
אנחנו עדיין הולכים לעשות את זה במרכזי כמו שהוא אומר.

352
00:32:43,410 --> 00:32:48,360
אבל להשתמש 2 המשתנים האלה, אנחנו לא רוצים להשתמש במשתנה זמנית.

353
00:32:48,360 --> 00:32:50,770
ישנן 2 דרכים לעשות את זה.

354
00:32:50,770 --> 00:32:56,310
אתה יכול לעשות זאת באמצעות המפעילים בינאריים המסורתיים שלך.

355
00:32:56,310 --> 00:33:00,180
אז מישהו יודע דרך מהירה וקלה לעשות את זה?

356
00:33:00,180 --> 00:33:07,650
היא עשויה להימשך כדקה של חשיבה. אם יש לי -

357
00:33:07,650 --> 00:33:12,130
אני להגדיר את הבעיה כמו שהם שואלים. אז אם יש לי 2 משתנה,, וזה רק מספר שלם

358
00:33:12,130 --> 00:33:17,800
שהם נותנים לי, ו-B משתנה הסכום, שהוא מספר שלם אחר שיינתן לי.

359
00:33:17,800 --> 00:33:22,700
אז אם יש לי 2 המשתנים הללו, עכשיו אני רוצה להחליף אותם.

360
00:33:22,700 --> 00:33:31,550
המסורתי, שימוש באופרטורים בינאריות הרגילים שלך, אני מתכוון, כמו +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
לא מפעילים סיביים האופרטור הפועלים על בינארי.

362
00:33:36,630 --> 00:33:39,600
כך ששימוש ב--, +, ÷, וכל אלה.

363
00:33:39,600 --> 00:33:52,980
אנחנו יכולים להחליף על ידי עושים משהו כמו = + b, ו-B = - ב, = - ב.

364
00:33:52,980 --> 00:34:04,260
לכן, לבדוק את השפיות, ואז נראה למה זה עובד.

365
00:34:04,260 --> 00:34:13,320
בואו נגיד = 7, ב = 3, אז a + b הולכת להיות 10.

366
00:34:13,320 --> 00:34:18,820
אז עכשיו אנחנו בהגדרה = 10, ואז אנחנו עושים ב = - ב.

367
00:34:18,820 --> 00:34:30,250
אז אנחנו עושים ב = - ב, שהולך להיות 7, ו= b - b שוב,

368
00:34:30,250 --> 00:34:38,650
או = - ב. שהוא הולך להיות 10-7 שהוא 3.

369
00:34:38,650 --> 00:34:44,850
אז עכשיו, ובצדק, '' היה 7, ב היה 3, ועכשיו הוא 7 וב '' הוא 3.

370
00:34:44,850 --> 00:34:48,679
אז זה סוג של היגיון; "'הוא שילוב של 2 מספרים.

371
00:34:48,679 --> 00:34:53,000
בשלב זה, '' הוא שילוב, ואז אנחנו חיסור יצא ב מקורי,

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
נניח 2 המספרים שלנו הם 1111, 1111 ו; אז אנחנו בינארי עכשיו.

379
00:35:26,720 --> 00:35:34,630
בשברים עשרוניים בפועל, אם אתה רוצה לחשוב על זה ככה, = 15 ו b = 15.

380
00:35:34,630 --> 00:35:37,630
ולכן אנו מצפים, אחרי שאנחנו מחליפים אותם - הם אפילו לא צריכים להיות אותם המספרים,

381
00:35:37,630 --> 00:35:41,140
אבל עשיתי את זה בדרך זו.

382
00:35:41,140 --> 00:35:47,100
בואו נעשה להם לא אותם המספרים. בואו נעשה 1111 ו0001.

383
00:35:47,100 --> 00:35:51,860
אז = 15 ו b = 1.

384
00:35:51,860 --> 00:35:57,670
אחרי שמחליפים אותם, אנו מצפים ש '' להיות 1 וב להיות 15.

385
00:35:57,670 --> 00:36:01,780
אז בשלב הראשון שלנו הוא = + b.

386
00:36:01,780 --> 00:36:08,770
המספרים שלנו הם רחבים רק 4 ביטים, ולכן ", שזה 1111, + b, שזה 0001,

387
00:36:08,770 --> 00:36:16,780
הוא הולך להיות בסופו 10000, אבל יש לנו 4 חתיכות בלבד.

388
00:36:16,780 --> 00:36:22,540
אז עכשיו = 0.

389
00:36:22,540 --> 00:36:34,080
ועכשיו אנחנו רוצים להגדיר ב = - ב - למעשה, זה עדיין עובד בצורה מושלמת.

390
00:36:34,080 --> 00:36:39,630
= - ב - בואו נראה אם ​​זה עובד בצורה מושלמת.

391
00:36:39,630 --> 00:36:53,720
אז ב = 0 - 1, שעדיין תהיינה 15, ולאחר מכן = - ב, שיהיה 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
ואני אחפש - אני גוגל כדי לראות אם זה נכון.

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
או שהיה זה להיות 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
אבל זה מקרה שבו "לא" קרה להיות 0, לאחר שקבל ל5 חתיכות, אז עכשיו '' הוא 0,

411
00:38:44,940 --> 00:38:48,730
זה מה שנקרא "גלישת מספר שלמה."

412
00:38:48,730 --> 00:38:54,370
על פי ויקיפדיה, "בניגוד להחלפת XOR, וריאציה זו דורשת כי היא משתמשת בכמה שיטות

413
00:38:54,370 --> 00:38:59,780
כדי להבטיח שx + y אינו גורם להצפה מספר שלמה. "

414
00:38:59,780 --> 00:39:08,350
אז זה עושה בעיות, זה היה הצפה שלמה, אבל אני עשיתי משהו לא בסדר.

415
00:39:08,350 --> 00:39:10,520
אני לא בטוח. אני אנסה לבוא עם עוד אחד.

416
00:39:10,520 --> 00:39:13,640
[סטודנטים] ובכן, לא הצפה שלמה כאשר אתה מנסה לשים את מספר שביש

417
00:39:13,640 --> 00:39:16,640
גדול יותר מכמות הביטים שהוקצית?

418
00:39:16,640 --> 00:39:23,730
כן. יש לנו 4 ביטים. כלומר - היה לנו 4 חתיכות, ואז לנסותנו להוסיף 1 לזה, אז אנחנו בסופו של דבר עם 5 חתיכות.

419
00:39:23,730 --> 00:39:26,690
אבל קצת 5 פשוט נחתך, כן.

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
למעשה אתה לא יכול להתמודד עם זה, אלא אם תשתמש הוראות הרכבה מיוחדות בג

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
כשאמרתי ש 0 - 1 הם 15 שוב.

429
00:40:11,160 --> 00:40:15,410
כך שאולי בעצם - על מעבד רגיל שעושה 0-1 = 15.

430
00:40:15,410 --> 00:40:20,430
מכיוון שאנו בסופו של 0, נתעלמנו 1, אז זה פשוט עוטף בחזרה סביב ל1111.

431
00:40:20,430 --> 00:40:28,930
אז אלגוריתם זה דווקא יכול לעבוד, + 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
איפה אנחנו משתמשים XOR איכשהו כדי לקבל את המידע של שניהם לתוך 1 של המשתנים,

436
00:40:50,120 --> 00:40:54,120
ואז לשלוף את המידע מהמשתנים הבודדים שוב.

437
00:40:54,120 --> 00:41:04,330
אז למישהו יש רעיונות / תשובה?

438
00:41:04,330 --> 00:41:14,540
[תשובת סטודנט, לא מובן]

439
00:41:14,540 --> 00:41:22,220
כך זה צריך לעבוד, וגם, XOR הוא חלופי.

440
00:41:22,220 --> 00:41:27,620
לא משנה באיזה סדר 2 המספרים האלה יקרו לך להיות בעד כאן,

441
00:41:27,620 --> 00:41:30,100
תוצאה זו הולכת להיות אותו הדבר.

442
00:41:30,100 --> 00:41:35,800
אז ^ ^ b הוא ב.

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
שימוש במספר קטן למדי, יניח 11001, 01100 ו.

446
00:42:10,400 --> 00:42:12,790
אז זה '", זה ב.

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

448
00:42:15,540 --> 00:42:22,380
אנחנו הולכים להיות הגדרה = 'A' לXOR של 2 הדברים האלה.

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
אז ',' אם אתה מסתכל על המספרים העשרוניים, זה הולך להיות -

451
00:42:37,380 --> 00:42:41,160
אתה לא הולך לראות הרבה של קשר בין המקוריים '' וחדש ','

452
00:42:41,160 --> 00:42:45,600
אבל מסתכל על החתיכות, '"הוא עכשיו כמו רשת של המידע

453
00:42:45,600 --> 00:42:49,970
של שניהם המקוריים "וב המקורי.

454
00:42:49,970 --> 00:42:57,930
אז אם אנחנו לוקחים ב ^, אנו רואים שאנחנו בסופו של דבר מקורי. "

455
00:42:57,930 --> 00:43:08,910
ואם תיקחו מקורי '' ^ החדש ',' אנחנו רואים שאנחנו בסופו של דבר ב המקורי.

456
00:43:08,910 --> 00:43:18,380
אז (^ b) ^ b = '.' המקורי

457
00:43:18,380 --> 00:43:27,910
ו( ^ b) ^ = 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 הוא כמו ^ (ב ^ ב).

463
00:43:57,240 --> 00:44:03,680
(ב ^ ב) הולך להיות 0; ^ 0 הן פשוט הולכים להיות "," שכן כל הביטים הם 0.

464
00:44:03,680 --> 00:44:08,050
אז היחידים שהם הולכים להיות שם '"היה במקור 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
^ ',' וזה אסוציאטיבי, אז עכשיו (ב ^) ^.

468
00:44:24,680 --> 00:44:28,970
ואנחנו יכולים לעשות ב ^ (^).

469
00:44:28,970 --> 00:44:31,540
וכך שוב, אנחנו מקבלים ב מקוריים.

470
00:44:31,540 --> 00:44:37,120
אז '' הוא כעת שילוב של '' ו ב יחד.

471
00:44:37,120 --> 00:44:49,660
שימוש המשולב החדש שלנו '"שאנו אומרים ב = משולבים' '^ ב המקורי, אנו מקבלים את המקור'. '

472
00:44:49,660 --> 00:45:05,170
ועכשיו = משולב "'^ 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 ^, הולך XOR 2 אלה,

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
2 המספרים האלה כבר נמצאים בקופות.

491
00:46:42,810 --> 00:46:46,570
ולאחר מכן מאותה נקודה ואילך, אחרי שהחלפת אותם,

492
00:46:46,570 --> 00:46:51,540
זה פשוט להתחיל להשתמש בקופה האחרת.

493
00:46:51,540 --> 00:46:56,510
לכל מקום שבו השתמש ב, זה פשוט להשתמש במרשם שכבר אחסון '.'

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
אז אם בכל נקודה בזמן ',' ב בטמפ יש ערכים או משהו שונים,

500
00:47:24,630 --> 00:47:30,680
אז זה הולך להיות מקומות שונים בזיכרון, אבל זה נכון ש

501
00:47:30,680 --> 00:47:34,800
יש הרבה משתנים מקומיים שקיימים רק בספרים.

502
00:47:34,800 --> 00:47:44,370
ובמקרה זה, זה מעולם לא הכניס לזיכרון, ולכן אתה לא מבזבז את הזיכרון.

503
00:47:44,370 --> 00:47:58,620
אוקיי. השאלה האחרונה היא קצת יותר.

504
00:47:58,620 --> 00:48:04,850
אז הנה, בCS50 מכשיר זה, יש מילון.

505
00:48:04,850 --> 00:48:12,390
והסיבה לכך היא כי [?? B66] הוא בודק איות שבו אתה כותב

506
00:48:12,390 --> 00:48:15,780
שימוש בטבלאות חשיש או מנסה או חלק מבנה נתונים.

507
00:48:15,780 --> 00:48:22,660
אתה הולך להיות כתיבה בודקת איות, ואתה הולך להיות באמצעות מילון זה כדי לעשות את זה.

508
00:48:22,660 --> 00:48:28,280
אבל לבעיה זו, אנחנו רק הולכים להסתכל למעלה כדי לראות אם מילה היא במילון.

509
00:48:28,280 --> 00:48:31,250
אז במקום לאחסן את כל המילון בחלק מבנה נתונים

510
00:48:31,250 --> 00:48:35,180
ואז מסתכל על כל מסמך כדי לראות אם משהו שגוי,

511
00:48:35,180 --> 00:48:38,490
אנחנו רק רוצים למצוא מילה 1. אז אנחנו פשוט יכולים לסרוק בכל המילון

512
00:48:38,490 --> 00:48:44,300
ואם אנחנו לא מוצאים את המילה בכל המילון, אז זה לא היה שם.

513
00:48:44,300 --> 00:48:52,150
אם אנו סורקים על כל המילון ורואים מילה, אז אנחנו טובים, אנחנו מצאנו אותו.

514
00:48:52,150 --> 00:48:56,580
נאמרתי כאן שאנחנו רוצים להתחיל להסתכל פונקצית קובץ-C של הטיפול,

515
00:48:56,580 --> 00:48:59,930
מכיוון שאנחנו רוצים לקרוא מילון,

516
00:48:59,930 --> 00:49:07,680
אבל אני אתן רמז כאן על איזה פונקציות שאתה צריך לחשוב עליו.

517
00:49:07,680 --> 00:49:11,510
אני אכתוב אותם בחדרים.

518
00:49:11,510 --> 00:49:20,490
אז אלה העיקריים שאתה רוצה להסתכל עליהם ו פתוח ולאחר מכן, באופן בלתי נמנע, f סגורה,

519
00:49:20,490 --> 00:49:26,540
שילכו בסוף התכנית שלך, וסריקה ו 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 איש, סריקה ו.

529
00:50:27,330 --> 00:50:32,300
זהו עכשיו המידע על המשפחה ו הסריקה של פונקציות.

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
אוהב. גבר 2 כי שם פונקציה, או גבר 3 ששם הפונקציה,

536
00:50:51,620 --> 00:50:58,230
אבל אתה רק צריך לעשות את זה אם שם פונקצית איש לא קורה לעבודה בפעם הראשונה.

537
00:50:58,230 --> 00:51:03,010
[סטודנטים] אז אני קוראה את הדף לאדם פתוח, אבל אני עדיין מבולבל על איך להשתמש בו ואת התכנית.

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 סריקה ו קורא מנקודת המחרוזת או הנחל."

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
כאשר מסתכלים על דף האיש כאן, אנו רואים f סריקה ו int, להתעלם מערך ההחזרה לעת עתה.

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
אפילו לא היית צריך לומר '127 'בf ההדפסה,

579
00:54:52,470 --> 00:54:57,090
אבל מה זה אומר הוא להדפיס את 127 התווים הראשונים.

580
00:54:57,090 --> 00:54:59,350
אז אני די בטוח שזה מקרה. אתה יכול לגגל בשביל זה.

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 סריקה ו עכשיו, במקום להסתכל על משתנה ולהדפיס אותה,

584
00:55:14,680 --> 00:55:22,620
זה הולך להסתכל על מחרוזת כלשהי, ולאחסן את התבנית לתוך המשתנה.

585
00:55:22,620 --> 00:55:26,360
בואו באמת להשתמש f סריקה בדוגמה אחרת.

586
00:55:26,360 --> 00:55:31,670
אז תניח לנו קצת int, x = 4,

587
00:55:31,670 --> 00:55:41,110
ורצינו ליצור מחרוזת עשויה מ-- רציתי ליצור מחרוזת

588
00:55:41,110 --> 00:55:44,250
זה היה, זה יעלה הרבה יותר מאוחר,

589
00:55:44,250 --> 00:55:49,020
משהו שהוא בדיוק כמו 4.jpg.

590
00:55:49,020 --> 00:55:51,870
אז זו יכולה להיות תכנית שבה יהיה לך סכום נגדי,

591
00:55:51,870 --> 00:55:56,420
סיכום דלפק אני, ואתה רוצה להציל את החבורה של תמונות.

592
00:55:56,420 --> 00:56:02,430
אז אתה רוצה לחסוך i.jpg, שבו אני הוא חלק איטרציה של הלולאה שלך.

593
00:56:02,430 --> 00:56:05,500
אז איך אנחנו עושים את זה למחרוזת שJPEG?

594
00:56:05,500 --> 00:56:11,720
אם אתם רוצים להדפיס 4.jpg, אנחנו יכולים רק לומר f הדפסה, d.jpg%,

595
00:56:11,720 --> 00:56:14,410
ואז זה היה להדפיס עבור JPEG.

596
00:56:14,410 --> 00:56:20,050
אבל אם אנחנו רוצים להציל את 4.jpg המחרוזת, אנו משתמשים f סריקה.

597
00:56:20,050 --> 00:56:30,860
אז מחרוזת של - בעצם אנחנו לא יכולים - אופי, char s, בואו נלך 100.

598
00:56:30,860 --> 00:56:35,400
אז אני פשוט אצהיר על חלק המערך של 100 תווים,

599
00:56:35,400 --> 00:56:39,830
וזה מה שאנחנו בהכרח הולכים להיות האחסון שJPEG פנימה

600
00:56:39,830 --> 00:56:47,920
אז אנחנו הולכים להשתמש f סריקה, והפורמט, איך הייתי אומר d.jpg%

601
00:56:47,920 --> 00:56:54,980
כדי להדפיס 4.jpg, הפורמט של זה הולך להיות d.jpg%.

602
00:56:54,980 --> 00:57:04,020
אז הפורמט הוא d.jpg%, מה שאנחנו רוצים להחליף ד% בהוא x,

603
00:57:04,020 --> 00:57:06,590
ועכשיו אנחנו צריכים לאחסן את המחרוזת שבאיזשהו מקום.

604
00:57:06,590 --> 00:57:12,500
ולאן אנחנו הולכים לאחסון מחרוזת זו היא במערך של.

605
00:57:12,500 --> 00:57:21,640
אז אחרי שורת הקוד, של, אם להדפיס 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
על מה לאחסן בים.

609
00:57:43,600 --> 00:57:46,160
זה מה שהטיעון האחרון הוא הולך להיות.

610
00:57:46,160 --> 00:57:54,170
אנחנו רוצים לאחסן - "משפחה ו סריקה של סריקות בפונקציות הן על פי מתכונת שניסה בהמשך.

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
אז סריקה ו לא - מה לעזאזל היא הפונקציה שעושה את זה?

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 במחרוזת int ג

617
00:58:49,360 --> 00:58:55,940
מהו משתנה זה, או מה היא פונקציה זו נקראת?

618
00:58:55,940 --> 00:59:04,950
כן. כלומר - כן. אז מה אני מגדיר לך לפני היה f של ההדפסה,

619
00:59:04,950 --> 00:59:09,820
אשר - שעושה הרבה יותר הגיוני, לכן אמר שזה היה הרבה יותר כמו f הדפסה.

620
00:59:09,820 --> 00:59:14,700
סריקת f הוא עדיין סוג של ההדפסה כמו f, אבל f הדפסת s עומדת לסרוק אותו

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, הייתי עושה f ההדפסה של, x של זה.

625
00:59:34,510 --> 00:59:38,520
אז מה הוא עושה סריקה ו - מה הייתה השאלה שלך הולכת להיות?

626
00:59:38,520 --> 00:59:40,820
[סטודנטים] אני פשוט מבולבל על מה שאנחנו מנסים לעשות כאן

627
00:59:40,820 --> 00:59:43,450
עם JPEG. אתה יכול להסביר כי 1 יותר זמן?

628
00:59:43,450 --> 00:59:52,710
אז זה היה - זה relevent פחות לסריקה ו f עכשיו; בתקווה, זה תהיה לקשור חזרה באיזשהו אופן.

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
ו ההדפסה שלנו של% d.jpg-לא עשיתי לאני int = 0.

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

636
01:00:46,580 --> 01:00:51,130
אז% ו ההדפסה של d.jpg של i.

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
אז זה מה שזה עושה להדפיס 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
שם היא מכניסה את כל אחד מהמשתנים לטענה השנייה, עשוי להיות בניגוד לשלי.

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
אז אנחנו מאחסנים בתוך המחרוזת של הפורמט נכון-, ד% לאחר שהוחלף ב4.

647
01:02:00,750 --> 01:02:08,080
[סטודנטים] אז אם עשינו את זה, הוא F משתנה פשוט הולך להיות מחדש?

648
01:02:08,080 --> 01:02:18,110
כן. אז אנחנו צריכים לסגור את f המקורית לפני עושה את זה.

649
01:02:18,110 --> 01:02:22,810
אבל - ולאחר מכן גם, אם לא היה F להיפתח כאן, אז הייתי צריכים לומר -

650
01:02:22,810 --> 01:02:29,280
כן. אבל זה היה פותח מאה קבצים שונים.

651
01:02:29,280 --> 01:02:37,360
[סטודנטים] אבל לא הייתי מסוגל לגשת או - בסדר.

652
01:02:37,360 --> 01:02:44,230
אוקיי. אז הסריקה f, f סריקת f, הוא סוג של אותו הרעיון,

653
01:02:44,230 --> 01:02:53,610
אבל במקום, במקום לאחסן אותו למחרוזת, זה יותר כמו שאתה עכשיו

654
01:02:53,610 --> 01:03:02,420
הולך על עוקץ והתאמת דפוסים נגד שהמחרוזת ולאחסן את התוצאות למשתנים.

655
01:03:02,420 --> 01:03:11,290
אתה יכול להשתמש בסריקה ו לנתח על משהו כמו 4.jpg, ולאחסן 4 מספר השלמים לתוך x int הסכום.

656
01:03:11,290 --> 01:03:13,430
זה מה שאנחנו יכולים להשתמש f סריקה ל.

657
01:03:13,430 --> 01:03:16,300
F הסריקה F הוא הולך לעשות את זה בשורת הפקודה.

658
01:03:16,300 --> 01:03:19,200
אני דווקא די בטוח שזה מה שעושה ספריית CS50.

659
01:03:19,200 --> 01:03:29,050
אז כשאתה אומר, "מקבל int," זה סריקה מזוינת על - f הסריקה היא הדרך שאתה מקבל קלט משתמש.

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
אז מחרוזת, מילה = 1 argv.

681
01:05:16,460 --> 01:05:20,020
אז המחרוזת שאנחנו מחפשים היא 1 argv.

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
ואז אנו משווים מילה עם הים, ואם השוואת == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp קורה להביא 0 אם זיווג מתאים.

693
01:06:21,650 --> 01:06:31,510
אז אם זה היה 0, אז אנחנו יכולים להדפיס f, בהתאמה,

694
01:06:31,510 --> 01:06:35,370
או מילה במילון, או מה שאתה רוצה להדפיס f.

695
01:06:35,370 --> 01:06:41,450
ואז - אנחנו לא רוצים f לסגור שוב ושוב.

696
01:06:41,450 --> 01:06:50,410
זה מסוג הדברים שאנחנו רוצים לעשות, ואנחנו לא רק מחפשים מילה במילון.

697
01:06:50,410 --> 01:06:56,660
אז אנחנו יכולים לעשות את זה, אם אנחנו רוצים להסתכל לדפוס שלהם, cissa, כמו שאמרת קודם,

698
01:06:56,660 --> 01:07:00,260
אם אנחנו רוצים להסתכל לדוגמה זו שאז היא הייתה נכשלת במקרה

699
01:07:00,260 --> 01:07:08,010
כי זה לא ממש מילה, אבל אחת מהמילים במילון שקורה לי בזה.

700
01:07:08,010 --> 01:07:13,560
כך שזה יתאים את המילה הזו, אבל זו קבוצת משנה של המילה היא לא מילה עוצמה.

701
01:07:13,560 --> 01:07:17,250
אבל זה לא איך שאנחנו משתמשים בו; אנחנו קוראים בכל מילה

702
01:07:17,250 --> 01:07:19,740
ואז משווה את המילה שיש לנו עם אותה המילה.

703
01:07:19,740 --> 01:07:25,780
אז אנחנו תמיד אתה משווה מילים מלאות.

704
01:07:25,780 --> 01:07:29,620
אני יכול לשלוח את הפתרונים הסופיים מאוחר יותר.

705
01:07:29,620 --> 01:07:32,050
זה סוג של כמעט התשובה הנכונה, אני חושב.

706
01:07:32,050 --> 01:07:34,720
[הערה של סטודנטים, לא מובן]

707
01:07:34,720 --> 01:07:40,870
אה, האם להיפטר מזה קודם? Char s, אני מניח שאמרתי 127 - אני לא זוכר מה הוא הגדול ביותר.

708
01:07:40,870 --> 01:07:44,100
נחזור רק 128; אז עכשיו זה מספיק ארוך.

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