[Powered by Google Translate] בעיה בחלק הגדרה 2: מהדורת האקר
רוב אודן, אוניברסיטת הרווארד
זה CS50. CS50.TV
אז, אני רוב. אני בכיר בקירקלנד. זו השנה השלישית שלי TFing CS50.
זה הפעם הראשונה שאנו משנים מהסעיף-הרצאה בסגנון מסורתי,
איפה אנחנו פשוט סוג של ביקורת את מה שקרה בהרצאה ולאחר מכן אתם שואלים שאלות,
עכשיו להיות הרבה יותר בעיה מבוססת, שבו אנו משתמשים ברווחים, וכן -
אה, אז הרעיון הוא ללכת לקישור שאני שלחתי אותך ואז אתה אהיה בשטח שלי.
האם מישהו לא צריך במחשב נייד? אוקיי.
אז אנחנו הולכים להיות באמצעות זה, ואנחנו הולכים לעשות בעיות חיים בסעיף
ותדון בם ולהבין מה לא בסדר
ואני יכול למשוך את חלק מהקוד שלך, ואני יכול לדון ברעיונות שלך.
אז האם מישהו היה קושי?
אתה יכול לשוחח בצד, אני לא יודע אם אהיה לנו סיבה לכך.
עכשיו, כמו supersection הקודם, אם היית באותה כיתה, אתה יודע במה מדובר.
בכל קבוצות יש P הולך להיות חלקים אלו.
אז P-סט 2, מפרטים, אני מניח שראית את זה ביום 1-P-סט כבר.
אבל אנחנו יכולים להסתכל בסט P-2 עבור מה שאנחנו הולכים להיות הולכים על היום.
ואתה תראה חלק משאלות.
אז זה יהיה בכל P-הסטים להגיע, יהיה חלק משאלות.
עד כה אמרו, "חשב על זה הזדמנות להתאמן."
אתה לא תתבקש להגיש תכנית זו.
הרעיון הוא כי אלה אמורים סוג של לעזור לך להתחיל עם סט הבעיה.
אני מניח במהדורת ההאקר, הרבה מהם אמור רק כדי להיות דברים חדשים ומעניינים ללמוד.
הם לא יכולים להיות ישימים ישירות לקבוצת הבעיה.
וכרגע אנחנו לא רואים אותך להגיש אותם, אבל בתאוריה,
לסטי בעיה בעתיד, ייתכן שתגיש אותם, ולכן אתה גם יכול לבוא לסעיף
או לצפות בקטע כדי לקבל את התשובות, או שאתה פשוט יכול לקבל אותם בעצמך
אם אתה לא מרגיש שנהנה מהנוכחות שלי.
אז - אני חושב שזה ראשון.
אה. כמו כן, לפי סעיפים אלה של שאלות יש לנו גם אתה שואל שאלות על מכנסיים הקצרים.
אז אני מניח, בתאוריה, אתה אמור לראות אותם לפני שהגעת לקטע,
אבל זה בסדר אם לא, אנחנו מתכוונים לעבור עליהם בכל מקרה.
אז אנחנו יכולים להתחיל עם אלה: "איך לולאה בזמן נבדלה מעשה תוך לולאה?
כאשר הוא השני שימושי במיוחד? "
אז מישהו יש לך -?
[סטודנטים] עשה תוך לולאה תמיד לבצע לפחות פעם אחת.
כן. אז זה ההבדל. לולאה בזמן - I'll פשוט לעשות את זה כאן - ואילו לולאה, יש לנו את המצב
ממש כאן, ואילו עשה זמן מה, אין לך מצב, עד שנגיע לכאן.
וכך, כאשר התכנית של ביצוע, וזה מגיע ללולאה בזמן,
הוא בודק באופן מיידי אם המצב הזה הוא נכון.
אם מצב זה לא נכון, זה יהיה פשוט לדלג על הלולאה לגמרי.
עשה תוך לולאה, כתכנית ביצוע, הוא מקבל את "לעשות".
שום דבר לא קורה בשלב זה, פשוט ממשיך בביצוע.
ואז כשהוא פוגע "בזמן", אם המצב נכון, זה יהיה הלולאה לחזור ולעשות זאת שוב
ושוב ושוב עד שהמצב הוא לא נכון ואז פשוט נופל דרך.
לכן, ההבדל הוא, שזה יכול לדלג ישר מההתחלה מאוד.
זה בהכרח מבצע פעם אחת ולאחר מכן רשאי לבצע יותר פעמים אם המצב הוא עדיין נכון.
אז בעוד הלולאה תהיה לעשות את זה רק פעם אחת, או - הלולאה בזמן - אנחנו לא יכולים לעשות את זה בכלל,
שכן ברגע שנגיע לזה, אם המצב הוא שקר, אנחנו פשוט לדלג מעליו.
אילו עשה תוך לולאה, נבצענו אותו פעם אחת, בהכרח.
ואז, כשנגיע למצב, אנחנו בודקים אם זה אמת או שקר.
אם זה נכון, אנחנו נעשה את זה שוב, אם הוא שגוי, אנחנו פשוט ממשיכים ללכת.
לכן, כאשר הוא האחרון שימושי במיוחד?
אז אני יכול להגיד שאוקם בכל 4 השנים, 3 שנים, מה שלא,
כי אני כבר בתכנות, אני משתמש בזה, כמו, מתחת לגיל 10 פעמים.
וכנראה 5 מהם בCS50 כאשר אנחנו משיקים לולאות לעשות-בזמן.
לכן, כאשר אתה עושה שימוש בזמן-לולאות?
מתי - כן?
[סטודנטים] כשאתה מנסה לקבל קלט ממשתמש, או משהו שאתה רוצה לבדוק -
כן. אז עשה תוך לולאות, קלט המשתמש הוא אחד הגדול.
בגלל זה על כמה סטי הבעיה הראשונות, כאשר ברצונך לשאול את המשתמש, כמו,
"תן לי את מחרוזת," אתה לא יכול להמשיך עד שאתה מקבל מחרוזת ש.
ולכן, בהכרח, צריכים לבקש את המחרוזת לפחות פעם אחת.
אבל אז, אם הם עונים על משהו רע, אז אתה צריך לולאה אחורה ולשאול שוב.
אבל חוץ מקלט משתמש, זה מאוד נדיר שאני נתקל במקרה
שם אני רוצה לולאה "לפחות פעם אחת", אבל אולי יותר.
שאלות או -? האם מישהו השתמש עשה תוך לולאה בכל מקום אחר?
אוקיי. אז הבא הוא, "מה שלא נאמר מזהה
בדרך כלל לציין אם outputted ידי צלצול? "
אז איזה סוג של קוד שאני כותב יכול לקבל 'לא מוצהר מזהה? "
[סטודנטים] זה x = 2?
אז אנחנו יכולים רק לנסות אותו כאן, x = 2.
אנחנו נפרסם את זה - אוי, אני לא לוחץ עליו. אז הנה אנחנו מקבלים - בסדר.
"שימוש בx מזהה הבלתי המוכרז."
אז זה מזהה לא מוצהר, משתנה.
זה לעתים קרובות ייקרא משתנה מזהה.
אז זה אולי לא יודע את זה ממש משתנה, זה לא יודע מה זה.
אז זה מזהה.
אז למה זה לא נאמר? כן.
אז כדי שיהיה ברור על מינוח, הכרזה על משתנה
זה כשאתה אומר מה שלא יהיה "x int", או "המחרוזת Y".
האתחול של משתנה, או ההקצאה של משתנה,
הוא בכל פעם שאתה אומר "x = 2".
אז אנחנו יכולים לעשות את זה בשלבים נפרדים, int x, x = 2, ועד - יכול להיות לנו חבורה של דברים בפה -
אבל עד קו זה קורה, x עדיין לא מאותחל, אך הוא הוכרז.
וכך אנו יכולים כמובן לעשות את זה בקו 1, ועכשיו אנחנו הכרזה ואתחול.
שאלות?
ולבסוף, "למה הצפנת הקיסר אינו בטוחה?"
אז קודם כל, האם מישהו רוצה לומר מה הצפנת הקיסר זה?
[סטודנטים] קיסר הצפנה פשוט היא שאתה ממפה, אתה מסב את כל מכתב,
מספר מסוים של אותיות ניגש, ולחזור שוב, וזה לא מאוד מאובטח מפני
יש רק 26 אופציות אפשריות ואתה פשוט תצטרך לנסות כל 1 מאלה עד שאתה מקבל את זה.
אה. אז, אני צריך לחזור?
קיסר ההצפנה, זהו - אני מתכוון, שיצטרך להתעסק עם זה בבעיות שאתם -
או אני מניח מהדורה הסטנדרטית של קבוצת הבעיה, כי לא על מהדורת ההאקר.
אז במהדורה הסטנדרטית לקבוצת הבעיה, אתה תקבל הודעה בסגנון: "שלום, עולם"
ויש לך גם מספר כמו 6, ואתה לקחת את המסר הזה, וכל תו בודד,
אתה מסובב אותו על ידי 6 עמדות באלף בית.
אז 'H' בשלום יהפוך h-i-j-k-l-m-n.
אז האות הראשונה תהיה n. אנחנו עושים את אותו דבר עם דואר.
אם יש לנו, כמו, z או משהו, אז אנחנו חוזרים לעטוף סביב ל '.'
אבל כל דמות מקבלת רכב על אופניו כעבור 6 תווים באלף הבית, וזה לא מאוד מאובטח
מכיוון שיש רק 26 אפשרויות לכמה דרכים אתה יכול לעטוף אות אחת.
אז אתה יכול פשוט לנסות את כל 26 מהם, וכנראה גם למסר מספיק ארוך,
רק 1 מתוך 26 האפשריים הדברים האלה הולך להיות קריאים,
והאחד הקריא הולך להיות הודעה המקורית.
אז זה לא דרך טובה מאוד של הצפנה שום דבר בכלל.
שאינם קשור לתחתונים האלה, "מה הוא פונקציה?"
אז מה היא פונקציה? כן.
[סטודנטים] זה כמו חתיכה נפרדת של קוד שאתה יכול להתקשר לעבור ולאחר מכן לקבל את ערך ההחזרה של כל דבר.
כן. אז אני אענה אותו גם על ידי התשובה באת - או על ידי חוזר גם פשוט עונים הבא.
אתה יכול להשתמש בפונקציות ולא רק העתקה והדבקת קוד שוב ושוב.
פשוט לקחת את הקוד ש, הכניס אותו לתוך fuction, ואז אתה יכול פשוט לקרוא את הפונקציה
בכל מקום שהיה העתקה והדבקה.
אז פונקציות שימושיות.
אז עכשיו אנחנו נעשה את הבעיות בפועל.
ראשון. אז הרעיון הראשון הוא, שאתה עובר אותו מייתר, וללא קשר ל--
או שהיא אומרת את כל האותיות קטנות? זה לא אומר את כל האותיות קטנות.
אז המסר יכול להיות כל דבר, ו-- הו לא. היא עושה.
"לשם פשטות, ניתן להניח שהמשתמש יהיה קלט אותיות וחללים קטנות בלבד."
אז אנחנו מעבירים את מסר באותיות קטנות בלבד ואז לסירוגין
בין הון וקטן - אנחנו משנים את המחרוזת להיות הון ואותיות קטנות, לסירוגין.
אז לפני שאנחנו נותנים לך שנייה אחת אפילו לצלול לבעיה,
מה הוא הדבר הראשון שאנחנו צריכים לעשות?
אוי, מה אני פשוט לוחץ על? אוי, אני פשוט לוחץ על הדוא"ל לכאן.
אז הדבר הראשון שאנחנו צריכים לעשות - אני מסתכל על זה שלא בסדר?
האם זה חלק מזה?
לא, אלה שעדיין נמצאים שם,.
אוקיי, עדיין כאן.
עכשיו אנחנו לא יכולים להניח -? כן. כאן אנחנו לא יכולים להניח שזה קטן ורווחים בלבד.
אז עכשיו אנחנו צריכים להתמודד עם העובדה שהאותיות יכולות להיות כל מה שאנחנו רוצים שהם יהיו.
ולכן, הדבר הראשון שאנחנו רוצים לעשות הוא פשוט לקבל את ההודעה.
אנחנו פשוט צריכים לקבל מחרוזת, מחרוזת s = GetString, בסדר.
עכשיו הבעיה הזאת, יש כמה דרכים לעשות זאת.
אבל אנחנו הולכים רוצים להשתמש מפעילים סיביים האופרטור כאן.
האם יש אנשים שגם לא היו בsupersection,
או משהו, ולא יודע מה מפעילים סיביים האופרטור הם?
או איך שהם מתייחסים ל-ASCII בדרך כלשהי?
[סטודנטים] לא הייתי בsupersection, אבל אני יודע מה הם מפעילים סיביים האופרטור.
אוקיי. אז אני לא צריך ללכת על היסודות שלהם, אבל אני אסביר לך
מה אנחנו הולכים לרוצים להשתמש כאן.
אז א ': ייצוג בינארי של הון, המספר הוא 65.
אני רק הולך להסתכל על - 41 הולכים להיות 01000001.
אז זה צריך להיות 65 בעשרוני; אז זה הייצוג בינארי של אופי הון א
עכשיו, הייצוג בינארי של דמות אותיות קטנות '"
הולך להיות אותו הדבר, כמעט. האם זה - 6, כן. זה נכון.
הון אז ינארי אותיות קטנות, בינארי '.'
אז שם לב שההבדל בין ו '"הוא קצת בודד זה.
וזה קורה להיות 32 ביט, קצת מייצג את המספר 32.
וזה נשמע הגיוני מאז הוא 65; "'הוא 97.
ההבדל ביניהם הוא 32.
אז עכשיו אנחנו יודעים שאנחנו יכולים להמיר ל''על ידי הנטילה
וסיבי האופרטור ORing, עם - שנראה כמו 1.
זה סיבי האופרטור OR, עם 00100000, ושייתן לנו '".
ואנחנו יכולים לקבל מ''ל על ידי סיבי האופרטור anding
עם 11, 0 באותו מקום, 11111.
אז זה אז ייתן לנו בדיוק את מה '"היה, אבל מבטל מעט אדם זה,
אז יהיה לנו 01000001; אני לא יודע אם ספרתי נכון.
אבל הטכניקה הזאת של סיבית האופרטור ORing להגיע מבירה לאותיות קטנות,
וסיבי האופרטור anding להגיע מאותיות קטנות להון אינו בלעדי לא
כל המכתבים, K לעומת k, Z vs z,
כולם פשוט הולכים להיות שונים בכל אחת הביט הזה.
ואז אתה יכול להשתמש בזה כדי לשנות מכל אות קטנה לכל אות גדולה, ולהפך.
אוקיי. אז דרך קלה להגיע מזה - אז במקום צורך
לכתוב את מה שהוא 1011111 - דרך קלה לייצג את המספר הזה, וזה לא אחד
עד שניגשתי בsupersection, אבל טילדה (~) היא עוד מפעיל סיבי האופרטור.
מה ~ עושה הוא שזה נראה בייצוג קצת.
בואו ניקח כל מספר.
זה רק חלק מספר בינארי, ומה ~ אין זה פשוט מעיף את כל החלקים.
אז זה היה 1, עכשיו 0, זה הוא 0, עכשיו 1, 010100.
אז זה כל מה שעושה ~. אז 32 הוא הולך להיות מספר - להיפטר מזה -
כך 32 הוא הולך להיות המספר 00100000, ולכן ~ זה הולך להיות
מספר זה כאן כי אני ANDed '' עם.
האם כולם רואים את זה? זה די נפוץ, כמו כאשר אתה רוצה להבין
לדברים מאוחרים שאנו עלולים לראות, מתי שאנחנו רוצים לראות אם -
או שאנחנו רוצים הכל, כל סט קצת בודד למעט 1
אתם נוטים לעשות ~ מסיביים שאנחנו לא רוצים להגדיר.
אז אנחנו לא רוצים קבוצה של 32 הביט, ולכן אנחנו ~ 32.
אוקיי. אז אנחנו יכולים להשתמש בכל אלה כאן.
בסדר, כך שזה בסדר אם אתה לא נעשה, אנחנו צריכים ללכת על איטיות יחד,
או ללכת על זה, ולכן - בזה. ללכת דרך זה.
אז יש לנו המחרוזת שלנו, ואנחנו רוצים לולאה על כל תו שבמחרוזת ולעשות משהו.
אז איך אנחנו לולאה על חוט? מה שאנחנו צריכים להשתמש?
אני לא הולך לעשות על זה כאן. כן.
אז יש לי איטרטור שלי, והוא אמר את זה, אבל איך אני יודע כמה תווים במחרוזת?
Strlen (ים), ואז אני + +.
אז מה שעשיתי כאן הוא לא הדרך הטובה ביותר לעשות דברים.
מישהו יודע למה?
מכיוון שאתה בודק את השפה של מייתר בכל פעם אחת.
אז אנחנו הולכים לרוצים לעבור strlen, אני יכול לומר עד כאן, int אורך = strlen (ים),
ואז אני <אורך, ובמקרה שלא ראיתי את זה קודם,
גם אני יכול לעשות אני int = 0, אורך = strlen (ים).
ולכן זה מעט עדיף, מפני שעכשיו אני כבר הגבלתי את ההיקף
באורך משתנה לזה רק "לשם" לולאה, במקום להכריז זה לפני
ושתמיד קיים, ובמקרה שלא יתפוס למה זה רע,
או מדוע המקורי היה רע, זהו - להתחיל בלולאה.
בדקתי את מצבו. האם אני <האורך של?
אז האורך של, בואו לעבוד עם "שלום" כל הזמן.
אז אורך של, h-E-l-l-o. אורך הוא 5.
אז אני = 0, אורכו 5, אז אני לא <5, ולכן הלולאה ממשיכה.
ואז אנחנו מתחילים שוב. אנחנו בודקים את המצב. האם אני <האורך של שלום?
אז בואו לבדוק את אורכו של שלום. H-E-l-l-o. זה 5; אני לא <5, ולכן אנו ממשיכים שוב.
אז אנחנו חישוב, אנחנו סומכים שלום, לכל איטרציה של הלולאה,
אפילו חשב שזה לעולם לא ישתנה, זה תמיד הולך להיות 5.
אז אנחנו פשוט זוכרים 5 מלפנים, ועכשיו הכול יותר טוב.
אז iterating על כל המייתרים.
מה אנחנו רוצים לעשות לכל תו של המחרוזת?
[דובר סטודנט, לא מובן]
כן. אז, אם הדמות היא שאינן אלפביתי, אז אנחנו פשוט רוצים לדלג עליו.
בגלל שאכפת לנו רק על אותיות אלף, אנחנו לא יכולים לנצל מספר.
אז איך אנחנו יכולים לעשות את זה? אז המצב שלנו, כך שאם אנחנו רוצים משהו - תבדוק אם זה א"ב.
אז איך אנחנו בודקים את זה?
[סטודנטים] אתה יכול פשוט להשתמש בפונקציה הוא אלפא.
האם זה כלול באחד משני אלה, או כל לכלול, כמו char.h או משהו?
בואו לא אשתמש היא פונקצית אלפא, ולהשתמש המפורשים - ולכן יש לנו ים [i],
שהיא הדמות השמינית של s, זכור שמחרוזת היא מערך של תווים,
כך האופי השמיני של s.
עכשיו, אם זה באות גדולה, אנחנו יודעים שזה צריך להיות בטווח מסוים.
ומהו טווח ש?
כן. אז אם s [i] הוא ≥ 65, וזה [i] הוא ≤ 90, מה אני צריך לעשות במקום זה?
כן. אז אתה בהחלט צריך אפילו לא צריך לדעת את ערכי ASCII של דבר אי פעם.
לעולם לא חושב על המספרים 65, 90, 97 ו 102, או מה שזה לא.
אתה לא צריך - 112 -? אתה לא צריך לדעת מי בכלל. זה לא נכון גם.
להשתמש רק בתווים בודדי הציטוט, הקבועים ציטוט בודד. אז א 'ופחות מ 90 הם' ז''
וזה הרבה יותר טוב - אני לא יודע את החלק העליון של הראש שלי, כי Z הוא 90.
אני יודע את החלק העליון של הראש שלי, כי "Z" הוא הבירה צ
אז כל עוד זה בטווח של הון להון Z, או שאנחנו יכולים לבדוק באותיות קטנה
או אם זה בטווח ≥ '' ו≤ z.
אז זה המצב שלנו.
הסגנון עבור איפה לשים את הדברים האלה משתנה.
אני אעשה את זה ככה.
עכשיו, מה שאנחנו רוצים לעשות?
אנחנו יודעים את המכתב הזה הוא דמות, דמות אלפביתי.
אז אנחנו צריכים להחליף בין אם זה צריך להיות עכשיו באות גדולה או אות קטנה.
כיצד לעקוב אחר האחד אנחנו רוצים שזה יהיה?
[קולות סטודנטים ולא מובנים]
אז כן, אבל תן לי לבדוק.
מודול 0-2 ספר, היה הצעה נזרקת החוצה, ואני מסכים עם זה.
מלבד הודעה כי, כמו - האם זה כך? כן.
זה כל אחד אחר, אבל אנחנו לא יכולים מודול 2 של i, או i mod 2, מאז
תבחין כי E היא הון ו''היא אותיות קטנה? אבל יש מקום להפריד ביניהם?
אז הם הולכים להיות הזהה mod 2, אבל הם מקרים שונים.
[שאלת סטודנט, לא מובן]
כן. אז אנחנו פשוט מתכוונים להמשיך לספור.
גם אנחנו יכולים לעשות את זה פה אם אנחנו רוצים; שיכולים להיות קצת מסורבל
בהצהרות ללולאה; אני אשים את זה כאן.
אז ספירת int = מתחילה ב 0.
ועכשיו, אני הולך לספור כמה יש להשתמש באותיות שהיינו לנו.
אז אנו בהכרח הולכים לספור + + מאז שנמצאנו בתו אלפביתי.
אבל, אז עכשיו אתה אומר שאם mod הספירה 2.
אז מה אם ספירת mod 2? אה. אני אעשה == 0 לעת עתה.
אנחנו גם נלך על זה. אז אם ספירת mod 2 == 0, אז מה?
[סטודנטים] תשובה, סתומים
אז אנחנו רוצים שזה בסופו של אותיות רישיות.
ישנם 2 מקרים; אותיות גדולות וקטן הם 2 המקרים.
אז אם אנחנו נמצאים באותיות קטנות שאנחנו צריכים לעשות את זה אותיות גדולות.
אם זה באותיות גדול שאנחנו לא צריכים לעשות שום דבר.
אבל, האם יש דרך - לא אמור להיות התהפך -
שאנחנו אפילו לא צריכים לבדוק אם זה אותיות גדול או קטן?
מה אנחנו יכולים לעשות תמיד לוודא שאנו תמיד בסופו באותיות גדולות?
אז שים לב למה שעשינו לאותיות קטנות '", מה שאם הייתי עושה בדיוק אותו דבר זה לאותיות גדולות?
האם אותיות גדולות שינוי, או עושה שינוי הערך?
כן. אז כל מכתב הון סיבי האופרטור ANDed עם ~ 32 הולך להיות אותו אופי רישיות
כי לכל תו באותיות גדול מעט 32 אינה מוגדר.
אז אם אנחנו רוצים להביא את האופי של [i], אנחנו רוצים שזה יהפוך אותיות קטן או אותיות רישיות.
אז אם זה היה קטן, עכשיו זה באותיות גדול, אם זה היה באותיות גדול, זה עדיין באותיות גדול, וזהו.
אני אמרתי את זה בsupersection: ניתן להשתמש ב32 אם אתה רוצה, אבל אני נוטה להעדיף עושה '"-,
במקום 32 פשוט סתם, כי זה יכול להיות כל קצת אחר.
לאחר 32 ביט, זה יכול להיות כל אחד מאלה, או שלא יהיה לי מספיק
מספרים כדי לייצג את כל התווים.
אז אם אתה מקבל 32 ביט, זה יכול להיות 64 הביט, זה יכול להיות 128 ביט.
כל אחת מהחתיכות האלה יכולה להיות קצת שמבחינה בין אותיות גדולות וקטן.
אני לא צריך לדעת שזה 32 הביט.
אני יכול להשתמש בזה '"- כדי לקבל קצת שונה שבין שניים
ללא צורך להסתמך על מספר הקסם שהוא 32.
ועכשיו, אחר לספור היה מוזר, ולכן מה שאני רוצה לעשות?
[תשובותיהם של תלמידים, לא מובן]
[סטודנטים] מה זה?
אני אעשה את זה בשני 1.
אז עכשיו אם אני רוצה - אני רוצה לוודא שהאופי הוא עכשיו באותיות קטן
ואז אני יכול או ב 32, ו'א 32 משמעות - א
אבל שים לב, על ידי אותו ההיגיון כקודמו, שאם
המכתב כבר היה קטן, ולאחר מכן ב 32 ORing פשוט שומר אותו האותיות קטנות.
זה לא שינה את האופי המקורי.
אבל עכשיו אין לי להימנע מלומר: "אם זה קטן, פשוט תשכח מזה,
אם זה באותיות גדול, ואז לשנות אותו. "
זה הרבה יותר נוח לעשות את זה.
[סטודנטים] האם אסטרטגיה זו של החסרת האותיות הגדולות מהעבודה הקטנה אם זה לא היה 32?
אם זה היה, כאילו, 34 או משהו?
אז, אתה צריך לדעת שההבדל בין 2 הוא -? >> קצת 1.
זה יכול להיות קצת יותר מ 1, כל עוד כל הביטים מתחת למיקום זה הוא אותו הדבר.
אז אנחנו צריכים לפחות 26 תווים - או, יש 26 תווים.
אז אנחנו צריכים לפחות 26 מספרים כדי לייצג את ההבדל -
ההבדל בין ו''צריך להיות לפחות 26,
אחרת לא הייתי מיוצגים כל מספרי ההון.
זה אומר שאם יתחילו ב1, זה הולך להשתמש בכל הקטעים האלה,
כל 5 החתיכות הראשונות האלה, שייצגו את הכל דרך צ
זו הסיבה שהקטע הבא, או את הקטע הזה, הקטע הבא הוא אחד כי הוא בוחר להבחין בין ו '.'
זו גם הסיבה מדוע, בטבלת ASCII, יש 5 סמלים מפרידים בין אותיות מאותיות קטנות.
מאז אלה הם סמלים, תוספת 5 שמעלה 32 להיות ההבדל ביניהם.
[סטודנטים] אז אנחנו יכולים לעשות את זה, כי ASCII מתוכנן ככה.
כן. אבל ASCII - ההבדל יכול להיות גם שתי פיסות אלה.
כאילו, אם היו 10000001, ו '' היה 11100001 - אני שוכח, לא משנה מה.
אבל אם זה היה כך, אז תוכל עדיין להשתמש '' - א
זה רק עכשיו את ההבדל בין ו''הוא עדיין 2 הביטים האלה.
אני חושב שזה כתוב 48. האם זה 32 + 64? אני חושב שזה?
זה עדיין יהיה 2 סיבי; כל דמות ודמות, כאילו, Z ו Z, K ו-K,
הם עדיין יש את אותו סט ביטים מדויקים למעט 2 הביטים האלה.
אז כל עוד זה נכון תמיד, ללא קשר אם אנחנו משתמשים ASCII או מערכת אחרת,
כל עוד יש רק מספר קבוע של ביטים שמשתנים בהתאם לכל תו,
אז זה עובד מצוין.
זה רק כי 32 הוקם בגלל שזה ראשון אולי אנחנו יכולים להשתמש. >> המגניב.
אני נוטה להעדיף, במקרה שלא ראה, אם הבלוק הוא רק קו אחד,
אתה יכול להיפטר מהסוגריים המסולסלים, ולכן אני נוטה להעדיף לעשות את זה.
כמו כן, אתה יודע איך אנחנו יכולים לעשות דברים כמו של [i] + = 1?
אתה יכול גם לעשות s [i] וסיבי האופרטור = 32.
וסיבי האופרטור OR = 32.
כמו כן, לספור mod 2 == 0.
אז לזכור את זה - אני לא כותב את זה - כל ערך שאינו אפס הוא אמיתי, ו0 הם שקר.
אז "אם ספירת mod 2 == 0" הוא כמו לומר "אם לא סופר mod 2."
בטח הייתי פשוט התהפכתי הקווים ואמר: "אם ספירת mod 2,
אל או 1, אחרת אין ו1, "כך שאני לא צריך" לא. "
אבל זה עובד באותה מידה.
ומה עוד אני יכול לעשות כאן?
אתה יכול לשלב אותם עם משולש, אם אתה רוצה, אבל אז זה הייתי פשוט לגרום לדברים מבולגנים
וכנראה קשה יותר לקריאה, כדי שלא תעשו את זה.
מישהו יש לך הצעות אחרות?
האם זה כל הבעיה בקשה? אה, כן.
אז להיפטר מהשורות הריקות האלה, עכשיו אנחנו נדפיס f,% s להיות אחד למייתרים,
אנחנו נדפיס F, S.
עכשיו בואו להפעיל אותו. האם אני עושה משהו לא בסדר?
זה \ "; אני רוצה n.
אוקיי. עכשיו אנחנו ננהל אותו. זה בטח יצעק עליי.
Strlen הוא בstring.h.
אז זה דבר נחמד על קלאנג הוא שהוא אומר לך מה זה ב,
במקום GCC שפשוט אומר, "היי, אתה שכחת משהו, אני לא יודע מה זה היה."
אבל זה יגיד לי, "אתה אמור לכלול string.h."
אז אני לא הובלתי לשום דבר, כך שזה לא אומר שום דבר.
אבל אנחנו נעשה את הדוגמא שלהם, "תודה 4 תוספת".
זה נראה נכון. הידד.
אז חוזר לעיקריים, אני כמעט אף פעם לא עושה את זה.
זה לא חובה. והעיקרי הוא הפונקציה היחידה שלשם היא אופציונלית.
אם אתה לא מחזיר שום דבר מראשי, זה הנחה הוא שאתה אמור להחזיר 0.
שאלות?
אוקיי. אז עכשיו הבעיה השנייה.
"יחזור מהרצאה השנייה של שבוע 2 כי החלפת ערכים של 2 משתנה על ידי העברה
2 משתנה אלה לפונקציה (גם אם בשם SWAP) לא בדיוק עובד, לפחות לא בלי "מצביעים".
ולהתעלם ממצביעים עד שנגיע אליהם.
אנחנו רוצים להחליף 2 משתנים, אנחנו לא משתמשים בפונקציה שעושים את זה.
אנחנו עדיין הולכים לעשות את זה במרכזי כמו שהוא אומר.
אבל להשתמש 2 המשתנים האלה, אנחנו לא רוצים להשתמש במשתנה זמנית.
ישנן 2 דרכים לעשות את זה.
אתה יכול לעשות זאת באמצעות המפעילים בינאריים המסורתיים שלך.
אז מישהו יודע דרך מהירה וקלה לעשות את זה?
היא עשויה להימשך כדקה של חשיבה. אם יש לי -
אני להגדיר את הבעיה כמו שהם שואלים. אז אם יש לי 2 משתנה,, וזה רק מספר שלם
שהם נותנים לי, ו-B משתנה הסכום, שהוא מספר שלם אחר שיינתן לי.
אז אם יש לי 2 המשתנים הללו, עכשיו אני רוצה להחליף אותם.
המסורתי, שימוש באופרטורים בינאריות הרגילים שלך, אני מתכוון, כמו +, -, ÷.
לא מפעילים סיביים האופרטור הפועלים על בינארי.
כך ששימוש ב--, +, ÷, וכל אלה.
אנחנו יכולים להחליף על ידי עושים משהו כמו = + b, ו-B = - ב, = - ב.
לכן, לבדוק את השפיות, ואז נראה למה זה עובד.
בואו נגיד = 7, ב = 3, אז a + b הולכת להיות 10.
אז עכשיו אנחנו בהגדרה = 10, ואז אנחנו עושים ב = - ב.
אז אנחנו עושים ב = - ב, שהולך להיות 7, ו= b - b שוב,
או = - ב. שהוא הולך להיות 10-7 שהוא 3.
אז עכשיו, ובצדק, '' היה 7, ב היה 3, ועכשיו הוא 7 וב '' הוא 3.
אז זה סוג של היגיון; "'הוא שילוב של 2 מספרים.
בשלב זה, '' הוא שילוב, ואז אנחנו חיסור יצא ב מקורי,
ואז אנחנו חיסור מה הייתה מקורי '.'
אבל זה לא עובד עבור כל המספרים.
כדי לראות זאת, הבה נבחן מערכת; לכן אנחנו בדרך כלל חושבים על מספרים שלמים כ32 סיביים.
בואו לעבוד במשהו שהוא אוהב רק 4 ביטים.
אני מקווה שאני בא עם דוגמה טובה כרגע.
לכן, אני יודע, זה יהיה קל.
נניח 2 המספרים שלנו הם 1111, 1111 ו; אז אנחנו בינארי עכשיו.
בשברים עשרוניים בפועל, אם אתה רוצה לחשוב על זה ככה, = 15 ו b = 15.
ולכן אנו מצפים, אחרי שאנחנו מחליפים אותם - הם אפילו לא צריכים להיות אותם המספרים,
אבל עשיתי את זה בדרך זו.
בואו נעשה להם לא אותם המספרים. בואו נעשה 1111 ו0001.
אז = 15 ו b = 1.
אחרי שמחליפים אותם, אנו מצפים ש '' להיות 1 וב להיות 15.
אז בשלב הראשון שלנו הוא = + b.
המספרים שלנו הם רחבים רק 4 ביטים, ולכן ", שזה 1111, + b, שזה 0001,
הוא הולך להיות בסופו 10000, אבל יש לנו 4 חתיכות בלבד.
אז עכשיו = 0.
ועכשיו אנחנו רוצים להגדיר ב = - ב - למעשה, זה עדיין עובד בצורה מושלמת.
= - ב - בואו נראה אם ​​זה עובד בצורה מושלמת.
אז ב = 0 - 1, שעדיין תהיינה 15, ולאחר מכן = - ב, שיהיה 1.
אולי זה עושה את העבודה.
אני מרגישה כאילו יש סיבה שזה לא עובד באמצעות רגיל.
אוקיי, אז בעבודה, בהנחה שזה לא עובד עם פעולות בינאריות רגילות,
ואני אחפש - אני גוגל כדי לראות אם זה נכון.
אז אנחנו רוצים לעשות את זה באמצעות מפעילים סיביים האופרטור, והרמז כאן הוא XOR.
לכן, החדרת XOR (^) אם לא ראית אותו.
זה, שוב, מפעיל סיבי האופרטור כך שהוא פועל לאט לאט, וזהו -
אם יש לך את הביטים 0 ו 1, ואז זה יהיה 1.
אם יש לך את חלקי 1 ו 0, זה יהיה 1, יש לך את ביטי 0 ו 0 זה יהיה 0,
ואם יש לך את חלקי 1 ו 1 זה יהיה 0.
אז זה כמו או. אם אחד מהביטים נכון, זה 1, אבל בניגוד או, זה לא יכול להיות שתי החתיכות כי הם נכונים.
או שהיה זה להיות 1, XOR יהיה זה יהיה 0.
אז אנחנו הולכים לרוצים להשתמש XOR כאן.
תחשוב על זה לרגע: אני הולך ל-Google.
ובכן, אתה לא יכול לקרוא את זה; אני כרגע על דף אלגוריתם החלפת XOR.
אני מקווה שזה יסביר למה אני לא יכול -
זה בדיוק האלגוריתם שאנחנו פשוט לא.
אני עדיין לא מבין למה - אני פשוט כנראה לקחתי דוגמה רעה,
אבל זה מקרה שבו "לא" קרה להיות 0, לאחר שקבל ל5 חתיכות, אז עכשיו '' הוא 0,
זה מה שנקרא "גלישת מספר שלמה."
על פי ויקיפדיה, "בניגוד להחלפת XOR, וריאציה זו דורשת כי היא משתמשת בכמה שיטות
כדי להבטיח שx + y אינו גורם להצפה מספר שלמה. "
אז זה עושה בעיות, זה היה הצפה שלמה, אבל אני עשיתי משהו לא בסדר.
אני לא בטוח. אני אנסה לבוא עם עוד אחד.
[סטודנטים] ובכן, לא הצפה שלמה כאשר אתה מנסה לשים את מספר שביש
גדול יותר מכמות הביטים שהוקצית?
כן. יש לנו 4 ביטים. כלומר - היה לנו 4 חתיכות, ואז לנסותנו להוסיף 1 לזה, אז אנחנו בסופו של דבר עם 5 חתיכות.
אבל קצת 5 פשוט נחתך, כן.
אולי זה דווקא -
[סטודנטים] האם זה זורקים אותך טעות, או שזה - שהיה זורק את שגיאה?
המס 'אז אין שום שגיאה. כשאתה מגיע לרמת ההרכבה, קצת מיוחד
מקום מוגדר שאמר שיש הצפה, אבל בסוג של C אתה פשוט לא מתמודד עם זה.
למעשה אתה לא יכול להתמודד עם זה, אלא אם תשתמש הוראות הרכבה מיוחדות בג
בואו נחשוב על החלפת XOR.
ואני חושב שויקיפדיה המאמר אולי גם היה אומר ש--
אז זה גם הביא את אריתמטיקה מודולרית, ולכן אני מניח שאני היה, בתאוריה, לעשות את החישובים מודולרי
כשאמרתי ש 0 - 1 הם 15 שוב.
כך שאולי בעצם - על מעבד רגיל שעושה 0-1 = 15.
מכיוון שאנו בסופו של 0, נתעלמנו 1, אז זה פשוט עוטף בחזרה סביב ל1111.
אז אלגוריתם זה דווקא יכול לעבוד, + b, - ב, ב -: אולי זה בסדר.
אבל יש כמה מעבדים שלא עושים את זה, ואז זה לא יהיה בסדר באלה ספציפיים האלה.
החלפת XOR תעבוד על כל מעבד. אוקיי.
הרעיון הוא שזה אמור להיות אותו הדבר, אם כי.
איפה אנחנו משתמשים XOR איכשהו כדי לקבל את המידע של שניהם לתוך 1 של המשתנים,
ואז לשלוף את המידע מהמשתנים הבודדים שוב.
אז למישהו יש רעיונות / תשובה?
[תשובת סטודנט, לא מובן]
כך זה צריך לעבוד, וגם, XOR הוא חלופי.
לא משנה באיזה סדר 2 המספרים האלה יקרו לך להיות בעד כאן,
תוצאה זו הולכת להיות אותו הדבר.
אז ^ ^ b הוא ב.
כדאי גם לראות את זה בכתב כ^ = B, B = ^, ^ = b שוב.
אז זה נכון, ולראות למה זה עובד, חושב על הביטים.
שימוש במספר קטן למדי, יניח 11001, 01100 ו.
אז זה '", זה ב.
אז ^ = b.
אנחנו הולכים להיות הגדרה = 'A' לXOR של 2 הדברים האלה.
אז 1 ^ 0 הם 1: 1 ^ 1 הוא 0; 0 ^ 1 הוא 1, ו0 ^ 0 הוא 0, 1 ^ 0 הם 1.
אז ',' אם אתה מסתכל על המספרים העשרוניים, זה הולך להיות -
אתה לא הולך לראות הרבה של קשר בין המקוריים '' וחדש ','
אבל מסתכל על החתיכות, '"הוא עכשיו כמו רשת של המידע
של שניהם המקוריים "וב המקורי.
אז אם אנחנו לוקחים ב ^, אנו רואים שאנחנו בסופו של דבר מקורי. "
ואם תיקחו מקורי '' ^ החדש ',' אנחנו רואים שאנחנו בסופו של דבר ב המקורי.
אז (^ b) ^ b = '.' המקורי
ו( ^ b) ^ = b המקורית.
יש - דרך אחרת לראות את זה הוא XOR דבר עצמו היא תמיד 0.
אז 1101 ^ 1101, כל הקטעים הולכים להיות אותו הדבר.
אז יש לא הולך להיות מקרה שבו 1 הוא 0 והשני הוא 1.
אז זה 0000.
אותו הדבר עם זה. (^ B) ^ b הוא כמו ^ (ב ^ ב).
(ב ^ ב) הולך להיות 0; ^ 0 הן פשוט הולכים להיות "," שכן כל הביטים הם 0.
אז היחידים שהם הולכים להיות שם '"היה במקור 1 - היו אלה.
ועל אותו הרעיון כאן, אני די בטוח שזה גם חלופי.
כן. אני לא אומר שזה היה לפני חלופי.
^ ',' וזה אסוציאטיבי, אז עכשיו (ב ^) ^.
ואנחנו יכולים לעשות ב ^ (^).
וכך שוב, אנחנו מקבלים ב מקוריים.
אז '' הוא כעת שילוב של '' ו ב יחד.
שימוש המשולב החדש שלנו '"שאנו אומרים ב = משולבים' '^ ב המקורי, אנו מקבלים את המקור'. '
ועכשיו = משולב "'^ b חדשה, שהיה מקורי - או שהוא היום מה שהיה' 'או ב.
זה המקרה הזה כאן למטה. זה = B, B הישן.
אז עכשיו הכל חוזר לסדר החליף.
אם אנחנו באמת הסתכלנו על הביטים, ב = b ^, הולך XOR 2 אלה,
והתשובה הוא הולך להיות זה, ולאחר מכן = b ^ 2 הוא XORing אלה והתשובה היא זו.
שאלות? אוקיי. אז האחרון הוא קצת משמעותי יותר קשה.
[סטודנטים] אני חושב שיש לו ספק לגבי זה. >> אה, סליחה.
[סטודנטים] מה בעצם יותר מהר? אם אתה משתמש XOR זה, או שזה אם אתה מצהיר על משתנה חדש?
אז מה הוא למעשה מהיר יותר, והצהיר משתנה חדש או באמצעות XOR להחליף?
התשובה היא, ככל הנראה, משתנה זמני.
והוא משום שפעם אחת זה הידור למטה - כך ברמת ההרכבה,
אין דבר כזה כמו משתנים מקומיים או כל משתנים זמניים או כל החומר הזה.
הם בדיוק כמו - יש זיכרון, ויש אוגרים.
אוגרים הם שבו דברים קורים באופן פעיל.
אתה לא מוסיף 2 דברים בזיכרון; אתה מוסיף 2 דברים במרשמים.
ואתה מביא את דברים מזיכרון לאוגרים אז להוסיף אותם,
ואז אתה יכול לשים אותם שוב בזיכרון, אבל כל הפעולה שקורית בקופות.
לכן, כאשר אתה משתמש בגישה משתנית הזמנית, בדרך כלל מה שקורה הוא
2 המספרים האלה כבר נמצאים בקופות.
ולאחר מכן מאותה נקודה ואילך, אחרי שהחלפת אותם,
זה פשוט להתחיל להשתמש בקופה האחרת.
לכל מקום שבו השתמש ב, זה פשוט להשתמש במרשם שכבר אחסון '.'
אז זה לא צריך לעשות שום דבר, למעשה לבצע את ההחלפה. כן?
[סטודנטים] אבל זה גם לוקח יותר זיכרון, נכון?
זה ייקח רק עוד זיכרון, אם הוא זקוק לאחסון שמשתנים זמני.
כמו שאם היית שימוש מאוחר יותר, שמשתנים זמני שוב באיזה מקום,
אז - או שתקצה למשהו שמשתנים זמני.
אז אם בכל נקודה בזמן ',' ב בטמפ יש ערכים או משהו שונים,
אז זה הולך להיות מקומות שונים בזיכרון, אבל זה נכון ש
יש הרבה משתנים מקומיים שקיימים רק בספרים.
ובמקרה זה, זה מעולם לא הכניס לזיכרון, ולכן אתה לא מבזבז את הזיכרון.
אוקיי. השאלה האחרונה היא קצת יותר.
אז הנה, בCS50 מכשיר זה, יש מילון.
והסיבה לכך היא כי [?? B66] הוא בודק איות שבו אתה כותב
שימוש בטבלאות חשיש או מנסה או חלק מבנה נתונים.
אתה הולך להיות כתיבה בודקת איות, ואתה הולך להיות באמצעות מילון זה כדי לעשות את זה.
אבל לבעיה זו, אנחנו רק הולכים להסתכל למעלה כדי לראות אם מילה היא במילון.
אז במקום לאחסן את כל המילון בחלק מבנה נתונים
ואז מסתכל על כל מסמך כדי לראות אם משהו שגוי,
אנחנו רק רוצים למצוא מילה 1. אז אנחנו פשוט יכולים לסרוק בכל המילון
ואם אנחנו לא מוצאים את המילה בכל המילון, אז זה לא היה שם.
אם אנו סורקים על כל המילון ורואים מילה, אז אנחנו טובים, אנחנו מצאנו אותו.
נאמרתי כאן שאנחנו רוצים להתחיל להסתכל פונקצית קובץ-C של הטיפול,
מכיוון שאנחנו רוצים לקרוא מילון,
אבל אני אתן רמז כאן על איזה פונקציות שאתה צריך לחשוב עליו.
אני אכתוב אותם בחדרים.
אז אלה העיקריים שאתה רוצה להסתכל עליהם ו פתוח ולאחר מכן, באופן בלתי נמנע, f סגורה,
שילכו בסוף התכנית שלך, וסריקה ו f.
אתה יכול גם להשתמש f לקרוא, אבל אתה בטח לא רוצה
כי - אתה לא בסופו של דבר צורך זה.
F הסריקה f הוא מה שאתה הולך להיות באמצעות לסרוק על המילון.
ואז אתה לא צריך לקודד את הפתרון, תנסה פשוט אוהבים פסאודו קוד בדרך שלך
לפתרון, ולאחר מכן נדונונו בו.
ובעצם, מאחר שכבר נתן להם אותך, אם אתה הולך לכל מסוף או פגז של המכשיר שלך,
הייתי - אני בדרך כלל - אם לא ראיתי עדיין, אני לא יודע אם עשיתי אותו בכיתה,
אבל איש, כך את הדפים, הוא די מועיל להתבוננות בכמעט כל פונקציה.
אז אני יכול לעשות, אוהב, f איש, סריקה ו.
זהו עכשיו המידע על המשפחה ו הסריקה של פונקציות.
גם אני יכול לעשות את f אדם, פתוחה, ושתיתן לי את הפרטים של זה.
אז אם אתה יודע מה תפקידו אתה משתמש, או שאתה קורא קוד
ואתה רואה באיזה אירוע ואתה כמו, "מה זה עושה?"
רק ששם פונקצית אדם.
יש כמה דוגמאות משונות שבו ייתכן שיש לי לומר
אוהב. גבר 2 כי שם פונקציה, או גבר 3 ששם הפונקציה,
אבל אתה רק צריך לעשות את זה אם שם פונקצית איש לא קורה לעבודה בפעם הראשונה.
[סטודנטים] אז אני קוראה את הדף לאדם פתוח, אבל אני עדיין מבולבל על איך להשתמש בו ואת התכנית.
אוקיי. הרבה את הדפים פחות מאשר מועיל.
הם יותר מועילים אם אתה כבר יודע מה הם עושים
ואז אתה רק צריך לזכור את הסדר של טענות או משהו.
או שהם יכולים לתת לכם סקירה כללית, אבל חלק מהם הם מאוד מכריע.
כמו f סריקת f, גם. זה נותן לך את מידע לכל הפונקציות הללו,
וקו 1 כאן קורה לומר, "F סריקה ו קורא מנקודת המחרוזת או הנחל."
אבל f לפתוח. אז, כיצד תשתמש f פתוחה?
הרעיון של תכנית שצריכה לעשות קובץ I / O הוא כי
אתה קודם צריך לפתוח את הקובץ שאתה רוצה לעשות דברים ובאופן בלתי נמנע,
לקרוא דברים מאותו הקובץ ולעשות דברים איתם.
F הפתוח הוא מה אנו משתמשים כדי לפתוח את הקובץ.
הדבר שנחזור, אז מה קובץ שאנו רוצים לפתוח, זה נותן לנו -
כאן זה אומר "/ dict / משתמש / שיתוף / מילים."
זה הקובץ שאנחנו רוצים לפתוח, ואנחנו רוצים לפתוח אותו -
יש לנו באופן מפורש כדי לציין אם אנחנו רוצים לפתוח אותו כדי לקרוא או אם אנחנו רוצים לפתוח אותו לכתיבה.
יש כמה שילובים וכאלה, אבל אנחנו רוצים לפתוח את זה לקריאה.
אנחנו רוצים לקרוא מהקובץ.
אז מה עושה תשואה זו? זה מחזיר את קובץ כוכבית (*),
ואני רק אראה לי כל F משתנה, ולכן *,
שוב, זה מצביע, אבל אנחנו לא רוצים להתעסק עם מצביעים.
אתה יכול לחשוב על f כ, f הוא עכשיו משתנה אתה הולך להשתמש כדי לייצג את הקובץ.
אז אם אתם רוצים לקרוא מהקובץ, אתה קורא מf.
אם אתה רוצה לסגור את התיק, אתה סוגר f.
אז בסוף התכנית, כאשר באופן בלתי נמנע אנחנו רוצים לסגור את התיק, מה אנחנו צריכים לעשות?
אנחנו רוצים לסגור f.
אז עכשיו פונקצית הקובץ האחרונה שאנחנו הולכים רוצים להשתמש היא סריקת f, f סריקת f.
ומה שעושה זה סורק את הקובץ מחפש דפוס שיתאים.
כאשר מסתכלים על דף האיש כאן, אנו רואים f סריקה ו int, להתעלם מערך ההחזרה לעת עתה.
הטיעון הראשון הוא הזרם * הקובץ, כך הטיעון הראשון שאנחנו הולכים רוצים להעביר הוא f.
אנחנו סריקה על f.
הארגומנט השני הוא מחרוזת תבנית.
אני אתן לך מחרוזת פורמט נכון עכשיו.
אני חושב שאנחנו במקרה תגידו, 127s \ n, הרבה זה מיותר.
הרעיון של מה שהיא מחרוזת תבנית, הוא שאתה יכול לחשוב על f הסריקה כהיפוכה של f הדפסה.
אז f הדפסה, f הדפסה אנחנו גם להשתמש בסוג זה של פרמטר בתבנית,
אבל בf ההדפסה מה שאנחנו עושים הוא - בואו נסתכל על מקבילה.
אז להדפיס F, ויש בעצם גם f הדפסה F, שם הטענה הראשונה הולכת להיות f.
בעת הדפסת f, תוכל לומר משהו כמו, "ההדפסה 127s \ n" ואז אם אנחנו עוברים אותו איזה מייתר,
זה הולך להדפיס מחרוזת זו ולאחר מכן בשורה חדשה.
מה 127 אמצעים, אני די בטוח, אבל אני אף פעם לא הגבלתי את עצמי לזה,
אפילו לא היית צריך לומר '127 'בf ההדפסה,
אבל מה זה אומר הוא להדפיס את 127 התווים הראשונים.
אז אני די בטוח שזה מקרה. אתה יכול לגגל בשביל זה.
אבל בפעם הבאה אני כמעט בטוח שזה אומר ש.
אז זה להדפיס את 127 התווים הראשונים, ואחריו בשורה חדשה.
F סריקה ו עכשיו, במקום להסתכל על משתנה ולהדפיס אותה,
זה הולך להסתכל על מחרוזת כלשהי, ולאחסן את התבנית לתוך המשתנה.
בואו באמת להשתמש f סריקה בדוגמה אחרת.
אז תניח לנו קצת int, x = 4,
ורצינו ליצור מחרוזת עשויה מ-- רציתי ליצור מחרוזת
זה היה, זה יעלה הרבה יותר מאוחר,
משהו שהוא בדיוק כמו 4.jpg.
אז זו יכולה להיות תכנית שבה יהיה לך סכום נגדי,
סיכום דלפק אני, ואתה רוצה להציל את החבורה של תמונות.
אז אתה רוצה לחסוך i.jpg, שבו אני הוא חלק איטרציה של הלולאה שלך.
אז איך אנחנו עושים את זה למחרוזת שJPEG?
אם אתם רוצים להדפיס 4.jpg, אנחנו יכולים רק לומר f הדפסה, d.jpg%,
ואז זה היה להדפיס עבור JPEG.
אבל אם אנחנו רוצים להציל את 4.jpg המחרוזת, אנו משתמשים f סריקה.
אז מחרוזת של - בעצם אנחנו לא יכולים - אופי, char s, בואו נלך 100.
אז אני פשוט אצהיר על חלק המערך של 100 תווים,
וזה מה שאנחנו בהכרח הולכים להיות האחסון שJPEG פנימה
אז אנחנו הולכים להשתמש f סריקה, והפורמט, איך הייתי אומר d.jpg%
כדי להדפיס 4.jpg, הפורמט של זה הולך להיות d.jpg%.
אז הפורמט הוא d.jpg%, מה שאנחנו רוצים להחליף ד% בהוא x,
ועכשיו אנחנו צריכים לאחסן את המחרוזת שבאיזשהו מקום.
ולאן אנחנו הולכים לאחסון מחרוזת זו היא במערך של.
אז אחרי שורת הקוד, של, אם להדפיס F, S% משל משתנה,
זה הולך להדפיס 4.jpg.
אז f הסריקה f הוא זהה הסריקה f, אלא שעכשיו זה מסתכל על קובץ זה
על מה לאחסן בים.
זה מה שהטיעון האחרון הוא הולך להיות.
אנחנו רוצים לאחסן - "משפחה ו סריקה של סריקות בפונקציות הן על פי מתכונת שניסה בהמשך.
אם כל מאוחסנים בנקודתי המיקום ייתכן שתחזור - "
לא, אנחנו יכולים להיות טובים. תן לי לחשוב לרגע.
אז סריקה ו לא - מה לעזאזל היא הפונקציה שעושה את זה?
אז הסריקה F הוא לא מתכוון לקחת את מספר שלם ולעשות נקודה jpg.
זה הולך [ממלמל].
שמור משתנה int במחרוזת int ג
מהו משתנה זה, או מה היא פונקציה זו נקראת?
כן. כלומר - כן. אז מה אני מגדיר לך לפני היה f של ההדפסה,
אשר - שעושה הרבה יותר הגיוני, לכן אמר שזה היה הרבה יותר כמו f הדפסה.
סריקת f הוא עדיין סוג של ההדפסה כמו f, אבל f הדפסת s עומדת לסרוק אותו
ולהחליף את המשתנים ועכשיו לאחסן אותו בחוט.
במקום להדפיס אותו, הוא מאחסן אותו בחוט.
אז להתעלם מזה לחלוטין. אתה עדיין יכול לחשוב על הפורמט מציין ככזה של f הדפסה.
אז עכשיו, אם אנחנו רוצים לעשות את דבר 4.jpg, הייתי עושה f ההדפסה של, x של זה.
אז מה הוא עושה סריקה ו - מה הייתה השאלה שלך הולכת להיות?
[סטודנטים] אני פשוט מבולבל על מה שאנחנו מנסים לעשות כאן
עם JPEG. אתה יכול להסביר כי 1 יותר זמן?
אז זה היה - זה relevent פחות לסריקה ו f עכשיו; בתקווה, זה תהיה לקשור חזרה באיזשהו אופן.
אבל מה שהיה בהתחלה מתוך הכוונה להראות להיה - זה בעצם רלוונטי ישירות ל[ אלה? F5]
אתה הולך להיות באמצעות ההדפסה של F, שם, אומרים שיש לנו 100 תמונות,
ואתה רוצה לקרוא את תמונת 1.jpg, 2.jpg, 3.jpg.
אז כדי לעשות את זה, אתה צריך f הפתוחה, ואז אתה צריך לעבור במחרוזת שברצונך לפתוח.
אז הייתי רוצה לפתוח 1.jpg; על מנת ליצור את המחרוזת שהיא 1.jpg,
ו ההדפסה שלנו של% d.jpg-לא עשיתי לאני int = 0.
i <40, אני + +.
אז% ו ההדפסה של d.jpg של i.
אז אחרי הקו הזה, עכשיו משתנה או מערך s עומדת 1.jpg.
או, 0.jpg, 1.jpg, 2.jpg. וכדי שנוכל לפתוח, בתור, כל תמונה לקריאה.
אז זה מה שזה עושה להדפיס f. האם אתה רואה מה זה להדפיס ו עכשיו עושה?
[סטודנטים] אוקיי, אז זה לוקח - זה יוצר מחרוזת, something.jpg, ולאחר מכן מאחסן אותו.
כן. זה יוצר - זה עוד מחרוזת תבנית, בדיוק כמו f סריקה והדפסת f,
שם היא מכניסה את כל אחד מהמשתנים לטענה השנייה, עשוי להיות בניגוד לשלי.
אולי - אני מתכוון, זה מקרה. אבל לא משנה מה המטרה של טיעונים היא.
זה הולך להכניס את כל המשתנים למחרוזת התבנית
ולאחר מכן לאחסן במאגר שלנו, אנחנו קוראים לזה חיץ, זה שבו אנחנו מאחסנים את המחרוזת.
אז אנחנו מאחסנים בתוך המחרוזת של הפורמט נכון-, ד% לאחר שהוחלף ב4.
[סטודנטים] אז אם עשינו את זה, הוא F משתנה פשוט הולך להיות מחדש?
כן. אז אנחנו צריכים לסגור את f המקורית לפני עושה את זה.
אבל - ולאחר מכן גם, אם לא היה F להיפתח כאן, אז הייתי צריכים לומר -
כן. אבל זה היה פותח מאה קבצים שונים.
[סטודנטים] אבל לא הייתי מסוגל לגשת או - בסדר.
אוקיי. אז הסריקה f, f סריקת f, הוא סוג של אותו הרעיון,
אבל במקום, במקום לאחסן אותו למחרוזת, זה יותר כמו שאתה עכשיו
הולך על עוקץ והתאמת דפוסים נגד שהמחרוזת ולאחסן את התוצאות למשתנים.
אתה יכול להשתמש בסריקה ו לנתח על משהו כמו 4.jpg, ולאחסן 4 מספר השלמים לתוך x int הסכום.
זה מה שאנחנו יכולים להשתמש f סריקה ל.
F הסריקה F הוא הולך לעשות את זה בשורת הפקודה.
אני דווקא די בטוח שזה מה שעושה ספריית CS50.
אז כשאתה אומר, "מקבל int," זה סריקה מזוינת על - f הסריקה היא הדרך שאתה מקבל קלט משתמש.
F הסריקה F הוא הולך לעשות את אותו דבר אבל שימוש בקובץ לסריקה על.
אז הנה, אנחנו סורקים את הקובץ הזה.
הדפוס שאנחנו מנסים להתאים זה חוט שאורכו 127 תווים
אחרי קו חדש
אז אני די בטוח שאפילו רק יכולנו להגיד "תואם של", שכן במילון
במקרה יש לנו, אנחנו מבטיחים לא מילה היא כל כך ארוכה,
וגם f f הסריקה, אני חושב, תעצור בקו החדש, לא משנה מה.
אבל אנחנו תהיינה לכלול את הקו החדש במשחק, ו--
[סטודנטים] אם לא כוללים את הקו החדש, האם לא היו מוצאים חלקים של מילה?
זה - כל - מסתכל על המילון -
אז במילון, כל אלה הם המילים שלנו.
כל אחד הוא בשורה חדשה.
F הסריקה הולך להרים את המילה הזו.
אם לא כוללים את הקו החדש, אז זה אפשרי כי f הסריקה הבאה תהיה פשוט לקרוא את השורה החדשה.
אבל כולל קו חדש אז פשוט להתעלם מהקו החדש.
אבל אנחנו לעולם לא נגיע לחלק ממילה, מכיוון שתמיד קוראים עד קו חדש, לא משנה מה.
[סטודנטים] אבל מה אם אתה מחפש את המילה "cissa," כמו cissa.
האם היא תמצא את זה, ואומר שזה משחק?
אז הנה אנחנו - זה יהיה לקרוא ב-- זו היא למעשה נקודה טובה.
אנחנו אף פעם לא משתמשים הנוכחית - המילה שאנחנו מחפשים היא ארגומנט שורת הפקודה הראשונה.
אז מחרוזת, מילה = 1 argv.
אז המחרוזת שאנחנו מחפשים היא 1 argv.
אנחנו לא מחפשים מילה בכלל בf הסריקה שלנו.
מה אנחנו עושים עם הסריקה f הוא מקבל כל מילה במילון,
ואז ברגע שיש לנו מילה שאנחנו הולכים להשתמש strcmp להשוות אותם.
אנחנו הולכים להשוות את המילה שלנו ומה שאנחנו רק קוראים פנימה
אז באופן בלתי נמנע, אנחנו הולכים בסופו של עושה חבורה של הסריקה FS
עד שזה פשוט כל כך קורה כי f סריקה תחזור -
היא תחזיר אחד, כל עוד זה מתאים מילה חדשה,
והיא תחזיר משהו אחר ברגע שהוא לא הצליח להתאים את המילה.
אנו קוראים מעל כל המילון, אחסון שורה אחרת שורה לכל מילה של משתנה.
ואז אנו משווים מילה עם הים, ואם השוואת == 0,
strcmp קורה להביא 0 אם זיווג מתאים.
אז אם זה היה 0, אז אנחנו יכולים להדפיס f, בהתאמה,
או מילה במילון, או מה שאתה רוצה להדפיס f.
ואז - אנחנו לא רוצים f לסגור שוב ושוב.
זה מסוג הדברים שאנחנו רוצים לעשות, ואנחנו לא רק מחפשים מילה במילון.
אז אנחנו יכולים לעשות את זה, אם אנחנו רוצים להסתכל לדפוס שלהם, cissa, כמו שאמרת קודם,
אם אנחנו רוצים להסתכל לדוגמה זו שאז היא הייתה נכשלת במקרה
כי זה לא ממש מילה, אבל אחת מהמילים במילון שקורה לי בזה.
כך שזה יתאים את המילה הזו, אבל זו קבוצת משנה של המילה היא לא מילה עוצמה.
אבל זה לא איך שאנחנו משתמשים בו; אנחנו קוראים בכל מילה
ואז משווה את המילה שיש לנו עם אותה המילה.
אז אנחנו תמיד אתה משווה מילים מלאות.
אני יכול לשלוח את הפתרונים הסופיים מאוחר יותר.
זה סוג של כמעט התשובה הנכונה, אני חושב.
[הערה של סטודנטים, לא מובן]
אה, האם להיפטר מזה קודם? Char s, אני מניח שאמרתי 127 - אני לא זוכר מה הוא הגדול ביותר.
נחזור רק 128; אז עכשיו זה מספיק ארוך.
אנחנו לא צריכים להדפיס כל דבר.
אנחנו גם הולכים רוצים צריכים לסגור את התיק שלנו, וזה צריך להיות על התשובה הנכונה.
CS50.TV