[Powered by Google Translate] [Walkthrough - סט בעיה 2]
[Zamyla צ'אן - אוניברסיטת הרווארד]
[זה CS50. CS50.TV]
בסדר. שלום לכולם, וברוך הבאים לWalkthrough 2.
ראשית, אני רוצה לברך אותך לגמר 1 pset.
אני יודע שזה היה יכול להיות קצת קשה עבור חלק מכם,
היה יכול להיות תכנית המחשב הראשונה שלך שאתה כתבת,
אבל רק לזכור כי בסופו של זה, כשאתה מסתכל אחורה בסוף הסמסטר,
אתה מסתכל 1 pset ואתה אומר, "היי, אני יכול לעשות את זה ב 5 דקות."
אז מכיר ובוטח שבסופו של זה תוכל בהחלט למצוא pset 1 די פשוט.
אבל לעת עתה זה הישג עצום, וברכות על המתבצעת.
עכשיו, גם הערה מהירה לפני שאנחנו מקבלים את הבשר של ההדרכה.
אני רק רוצה לעשות את הערה מהירה שלפעמים לא יהיה לי מספיק זמן
במהלך ההדרכות לעבור כל דרך יחידה לעשות סט הבעיה
ולא רק אולי להתמקד בסוג 1 או 2 של מימושים,
דרכים שאתה יכול לעשות את זה.
אבל זה לא אומר שאסור מלעשות את זה בדרך אחרת.
לעתים קרובות יש, כמו במדע המחשב, דרכים רבות לעשיית דברים,
וכך בהחלט מרגיש חופשי להשתמש בסוג אחר של פתרון ממה שאני יכול להיות מוצג.
[Pset 2: אנוסים - Zamyla צ'אן - zamyla@cs50.net]
[Pset2 - 0. סעיף של שאלות - 1. קיסר - 2. Vigenere]
בסדר. אז הבעיה להגדיר 2: אנוסים הוא אחד מהנה.
שוב, עם כל pset יתחיל עם קטע של שאלות
זה הולך להיות שנערך בסעיפים שלך עם בחור ההוראה יוקצה לכם.
אנחנו לא הולכים לעבור אלה על ההדרכה,
אבל הם בהחלט יעזרו לך להשלים את pset.
אז את החלק הראשון של סדרת הבעיה הוא קיסר.
וכך בקיסר מישהו יעבור לך מפתח עם מספר שלם,
ואתה להצפין מחרוזת הטקסט שהם מספקים לך
ולתת להם בחזרה דבר מוצפן.
אם מישהו ראה סיפור חג המולד, יש דוגמה של שיש.
אז את החלק השני של סט הבעיה הוא Vigenere,
שהיא טכניקת הצפנה מתקדמת יותר.
וכך אנחנו הולכים בצופן קטע הטקסט,
רק שבמקום רק עם אחת שלם, אנחנו באמת הולכים לקודד אותו
עם מילת מפתח שהמשתמש יספק אותנו.
אוקיי, אז הכלי הראשון בארגז הכלים של היום הוא בעצם הולך להיות עדכון המכשיר.
בלוח הדיונים היינו רואים דברים כמו, "למה זה לא עובד?"
"מדוע לא להגיש 50 עבודות?"
ולעתים קרובות הפתרון הוא למעשה רק כדי לעדכן את המכשיר שלך.
ואז אם רק תפעל בחלון מסוף sudo במכשיר שלך yum-y -
זה דגל אומר כן, לעדכן הכל - עדכון,
אז המכשיר שלך יעדכן אם יהיה בכך צורך.
וזה לא כואב, אם אתה כבר נמצאת בגרסה העדכנית ביותר של המכשיר.
אז זה פשוט יגיד אין עדכונים חדשים זמינים ותוכל להמשיך לעבוד יחד.
אבל זה טוב לביצוע גם בכל פעם שאתה פותח את המכשיר
בגלל שאנחנו עדיין מאוד -
לפעמים אם אנחנו באים לבאג - לתקן את זה במכשיר.
אז ודא שיש לך את הגרסה העדכנית ביותר של המכשיר
ולהפעיל שאעדכן שם.
בסדר. אז מכיוון שאנחנו עוסקים באותיות ובשינוי, enciphering דברים,
אנחנו הולכים באמת רוצים להיות חברים הכי טובים עם תרשים ASCII שלנו.
ישנם אלה רבים באינטרנט, אם אתה מוצא. אולי אפילו להפוך את עצמו.
בעיקרון, עם כל מכתב וכל מספר וכל תו
מקיים מספר המשויך אליהם,
ולכן זה טוב לראות את ערכי ASCII שלהם יחד עם המכתב בפועל.
זה בהחלט יעזור לך בסט הבעיה.
דבר אחד שבאמת עזר לי בסט בעיה זו היה למעשה להדפיס אותו,
וכמו שעברתי עליי, הייתי ממש לצייר על זה,
לכתוב, "אם זה צריך ללכת לשם, אז ..."
הסוג של לצייר על זה ולסמן אותו, הפך לחברים הטובים ביותר עם שולחן ASCII שלך.
אז יש לנו כמה כלים אחרים העומדים לרשותנו.
הפעם במקום באמת לשאול את המשתמש לכל הקלט שלהם
אנחנו הולכים לעשות את שילוב.
אנחנו הולכים כדי להנחות אותם לקלט כלשהו,
אבל אנחנו גם הולכים רק כדי להשתמש בטיעוני שורת הפקודה.
לכן, כאשר הם רצים התכנית שלהם, בדרך כלל שאתה אומר. / שלום, למשל,
אם התכנית שלך הייתה hello.c.
אך הפעם, במקום להסתפק באמירה שהם יכולים לשים את מילים, ויכוחים לאחר מכן.
וכך אנחנו הולכים להשתמש בכל מה שהם עוברים אלינו כקלט שלהם, כמו גם,
כל כך מרגש מעבר רק להציג עבור מספר שלם, אלא גם משתמש בנימוקים של שורת פקודה.
ואז נלך למערכים ומחרוזות, שיהיה לנו באמצעות הרבה גם כן.
הנה רק דוגמה לתרשים ASCII 1 מיני.
כפי שאמרתי, כל אות מתאימה למספר,
וכך להכיר את עצמך עם זה. זה יהיה שימושי.
ומאוחר יותר, כאשר אנחנו מתחילים לעשות כמה ASCIIMath התמודדות עם מספרים -
הוספה, חיבורם - אז בהחלט טוב להתייחס לטבלה זו.
אז הנה דוגמה לצופן קיסר - משהו שאתה אולי שחקת ב.
זה רק הגה. בעיקרו של דבר, יש האלפבית חיצוני ואז יש האלפבית פנימי.
אז כאן הוא דוגמה לצופן הקיסר אבל עם מפתח של 0.
בעיקרו של דבר, הוא מתואם עם A, B מיושר עם B, כל הדרך עד לז'
אבל אז אומר שרצינו מפתח של 3, למשל.
אז הייתי לסובב את הגלגל הפנימי כך שכעת מיישר עם ד ', וכו'
ואז זה בעצם מה שאנחנו הולכים לעשות.
אין לנו גלגל, אבל מה שאנחנו הולכים לעשות הוא להפוך את התכנית שלנו
סוג של להעביר את האלפבית איתנו כמות מסוימת של מספרים.
אז כמו שאמרתי קודם, אנחנו הולכים להיות התמודדות עם טיעוני שורת פקודה
כמו גם מקבל מספר שלם.
לכן הדרך שמשתמש יהיה להפעיל את התכנית שלך היא על ידי הקיסר אומר. / קיסר
ולאחר מכן הזנת מספר לאחר מכן.
והמספר שמייצג את המפתח, המשמרת,
כמה פעמים אתה הולך להיות סיבוב הגלגל הפנימי של צופן הקיסר שלך.
ואז אתה רואה כאן דוגמה.
אם נכנסו למכתבים משמאל לצופן הקיסר שלנו,
אז זה היית קלט D דרך O כי זה כל אות עברה מעל 3 פעמים,
בדיוק כמו בדוגמא של הגלגל שהראיתי לך.
אז אם אתה נכנסת, למשל, זה CS50!
אז זה גם היה עובר את כל האותיות.
וזה דבר חשוב הוא בקיסר וVigenere
הוא שאנחנו הולכים לדלג על כל מי שאינם אותיות.
אז את כל רווחים, תווים, וכו ', מספרים, אנחנו הולכים כדי לשמור אותם אותו הדבר.
אנחנו רק הולכים להעביר את המכתבים במקרה זה.
אז כפי שאתם רואים בגלגל, יש לנו את המכתבים לרשותנו בלבד,
אז אנחנו רוצים רק להעביר את המכתבים ולהצפין את המכתבים.
אז הדבר הראשון לעשות, אתה ראית שהשימוש לקיסר בבעיה להגדיר 2
הוא להפעיל קיסר ולאחר מכן להזין את המספר כשאתה מפעיל אותו במסוף.
אז מה שאנחנו צריכים לעשות זה איכשהו כדי לקבל את המפתח ושלגשת אליו.
וכך אנחנו רוצים לראות את זה איכשהו הולך להיות ויכוח שורת הפקודה השנייה.
הראשון הולך להיות. / קיסר, והבא הוא הולך להיות מספר המפתח.
אז לפני שהיה לנו int (void) העיקרי להפעלת תוכניות C שלנו.
אנחנו הולכים לקלף שכבה קצת
וממש רואה שבמקום לעבור בחלל לפונקציה העיקרית שלנו
אנו בעצם מתעסקים עם 2 פרמטרים.
יש לנו בשם int argc ולאחר מכן מערך של מייתרים, הנקרא argv.
אז argc הוא מספר שלם,
והיא מייצגת את מספר הארגומנטים שמועברים לתכנית שלך.
ואז argv הוא למעשה הרשימה של הטיעונים עברו.
כל הטענות הן מחרוזות, וכך argv מייצג מערך, רשימה, של מחרוזות.
בואו נדבר על מערכים קצת.
מערכים הם בעצם מבנה נתונים חדש.
יש לנו ints, יש לנו זוגות, יש לנו מייתרים, ועכשיו יש לנו מערכים.
מערכים הם מבני נתונים שיכולים להכיל ערכים מרובים מאותו הסוג,
כך למעשה, רשימה של כל סוג שאתה רוצה.
בעיקרו של דבר, אם אתה רוצה רשימה של מספרים שלמים בכל משתנים 1,
אז היית ליצור משתנה חדש שהיה של מערך הסוג int.
אז מערכים הם אפס למדד, כלומר האלמנט הראשון של המערך הוא במדד 0.
אם המערך הוא באורך 4, כמו בדוגמא הזו, אז האלמנט האחרון שלך יהיה בשעה 3 מדד
אשר הם 4 - 1.
אז כדי ליצור את המערך, היית עושה משהו כזה.
אמר שאתה רוצה מערך כפול.
זה שהולך לכל סוג של סוג נתונים,.
אז תגיד שאתה רוצה מערך כפול. אומר שאתה רוצה לקרוא לזה תיבת דואר.
בדיוק כמו שהיית לאתחל כל פעמים אחרות,
היית אומר כפול ולאחר מכן את השם, אבל הפעם אנו שמים את הסוגריים המרובעים,
ואז המספר יהיה האורך של המערך.
שים לב כי במערכים לא תוכל אי פעם לשנות את האורך,
כך שתמיד יש להגדיר ולבחור כמה תיבות,
כמה ערכי המערך שלך הולך להחזיק.
אז כדי להגדיר ערכים שונים במערך שלך, אתה הולך להשתמש בתחביר הבא זה,
כפי שאתם רואים בשקופית.
יש לך 0 תיבת דואר המדד ייקבעו ל -1.2,
סט תיבת דואר ראשי 1-2.4, וכו '
אז עכשיו שסקרנו מערכים קצת, בואו נחזור לargc וargv.
אנו יודעים כי argv הוא עכשיו מערך של מחרוזות.
לכן, כאשר משתמש עובר ב-- אומרים שהם פועלים בתכנית -
הם אומרים. / שלום דוד מלאן,
מה התכנית תעשה בשבילך כבר לבוא דווקא עם מה argc וargv הם.
אז אתה לא צריך לדאוג בקשר לזה.
Argc במקרה זה יהיה 3, כי הוא רואה 3 מילים שונות מופרדות על ידי רווחים.
ואם כך את המערך במקרה זה, במדד הראשון יהיה. / שלום,
את הבא אחריו הדוד, מלאן הבא.
האם מישהו רואה מייד מה קשר בין argv,
המערך, וargc הוא?
כן. אנחנו נגיע לזה בדוגמה בargs.c.
בואו נראה אם ​​אנחנו יכולים לנצל את היחסים בין 2.
כאן אתה עשוי לגלות כי במכשיר יישום ברירת המחדל
כדי לפתוח קבצים. C הוא לעתים Emacs.
אבל אנחנו רוצים להתמודד עם gedit, אז מה אתה יכול לעשות הוא שאתה ממש יכול ללחוץ על קובץ C שלך,
ללכת נכסים, פתח עם, ולאחר מכן בחר gedit, קבע כברירת מחדל,
ועכשיו התכנית שלך צריכה לפתוח בgedit במקום Emacs.
מושלם.
אז הנה יש לי תכנית שאני רוצה להדפיס את כל ארגומנט שורת פקודה.
אז מה תשומות המשתמש, אני רוצה בעצם להחזיר אותו חזרה אליהם בשורה חדשה.
אז מה מבנה שאנחנו יכולים להשתמש בו כדי לחזר על משהו -
משהו שאתה כנראה השתמשת ב1 pset?
אם אתה רוצה לעבור את מספר מוגדר של דברים? >> [תלמיד] ללולאה.
ללולאה. בדיוק. אז בואו נתחיל עם ללולאה.
יש לנו עבור אני int = 0. בואו נתחיל עם משתנה אתחול רגיל.
אני הולך לעזוב את התנאי לסט ואז אומר אני + +, הולך לעשות דברים שם.
בסדר.
אז חשבתי לחזור לargv, אם argv הוא רשימת הארגומנטים שמועברים לתכנית
וargc הוא מספר הארגומנטים בתכנית,
אז זה אומר שargc הוא למעשה אורך argv, ימינה,
משום שיש הולך להיות ויכוחים רבים ככל הערך של argc.
אז אם אנחנו רוצים לחזר על כל אלמנט בargv,
אנחנו הולכים בכל פעם שירצו לגשת למשתנה בargv במדד המסוים.
זה יכול להיות מיוצג עם זה, נכון?
משתנה זה כאן מייצג את המחרוזת המסוימת במקרה זה
כי זה מערך מחרוזת - מחרוזת מסוימת במדד זה נתון.
מה שאנחנו רוצים לעשות, במקרה זה אנו רוצים להדפיס אותו, אז בואו נגיד printf.
ועכשיו argv הוא מחרוזת, ולכן אנחנו רוצים לשים מציינים מקום שיש.
אנחנו רוצים בשורה חדשה, רק כדי לגרום לו להיראות טוב.
אז הנה יש לנו לולאה. אין לנו מצב עדיין.
אז אני מתחיל ב0, ולאחר מכן בכל פעם שזה הולך להדפיס את מחרוזת הנתונה
באותו מדד מסוים במערך.
לכן, כאשר אנו רוצים להפסיק את ההדפסה של אלמנטים במערך?
כשסיימנו, נכון? כשהגענו לסוף המערך.
אז אנחנו לא רוצים לחרוג עבר האורך של המערך,
ואנחנו כבר יודעים שאנחנו לא צריכים ממש פעילים לברר מה האורך של argv הוא
כי זה שניתן לנו, ומה זה? Argc. בדיוק.
אז אנחנו רוצים לעשות מספר argc זה תהליך של פעמים.
אני לא במדריך הנכון.
בסדר.
עכשיו בואו נעשה ארגומנטים. אין טעויות, וזה נהדר.
אז בואו פשוט להריץ ארגומנטים.
מה זה אמור לחזור אלינו? זה רק הולך להדפיס אותו בחזרה.
"אתה הוזנת ארגומנטים לתכנית; אני הולך להחזיר לך אותו."
אז אניח שאנחנו רוצים לומר ארגומנטים אז בר foo.
ואז זה מדפיס אותו בחזרה אלינו. בסדר?
אז הנה דוגמה של איך אתה יכול להשתמש argc וargv
ידיעת argc שמייצגת את האורך של argv.
ודא שאתה עושה לא פעם עם גישה למערכים אחד מעבר לאורכו של המערך
משום C בהחלט צועק עליך.
אתה תקבל משהו שנקרא אשמת פילוח,
שהוא אף פעם לא כיף, בעצם אומר שאתה מנסה לגשת למשהו
שאינו קיים, לא שייך לך.
אז לייתר ביטחון, ובמיוחד עם אפס האינדקס, אנו לא רוצים -
כמו למשל, אם יש לנו מערך באורך 4,
שהאינדקס של המערך 4 אינו קיים מפני שמתחילים ב 0, באפס מדד.
זה יהפוך לטבע שנייה בדיוק כמו ללולאות כאשר אנו מתחילים ב 0.
אז רק לזכור את זה.
אתה לא רוצה אי פעם לגשת לאינדקס של מערך זה מעבר להישג שלך.
כך אנו יכולים לראות עכשיו איך שאנחנו יכולים סוג של גישה
טיעוני שורת הפקודה, כי הם עברו פנימה
אבל כמו שאתה רואה את המחרוזת, argv הוא למעשה מערך מחרוזת.
אז זה ממש לא שלם עדיין, אבל בקיסר אנחנו רוצים להתמודד עם מספרים שלמים.
למזלנו, יש פונקציה שיצרה עבורנו, כי בעצם יכול להמיר מחרוזת למספר שלם.
גם כאן אין לנו עניין עם קלט משתמש שבו אנו מעודדים אותם
עבור קלט כאן לקבלת המפתח, ולכן אנחנו לא יכולים reprompt ואומרים,
"הו, תן לי מספר שלם אחר, אומר, אם זה לא חוקי."
אבל אנחנו עדיין צריכים לבדוק לשימוש נכון.
בקיסר הם מורשים רק לעבור במספר 1,
ולכן הם צריכים לרוץ. / קיסר, ואז הם צריכים לתת לך מספר.
אז argc חייב להיות מספר מסוים.
מה מספר שהייתי להיות אם הם צריכים לעבור אותך. / קיסר ולאחר מכן מפתח?
מה הוא argc? >> [תלמיד] 2. >> שתיים. בדיוק.
אז אתה רוצה לוודא שargc הוא 2.
אחרת אתה בעצם מסרב להפעיל את התכנית.
בעיקרי זה פונקציה שאומרת int ראשי,
אם כך אנחנו תמיד ב0 תמורת תרגול טובים בסוף התכנית מוצלחת.
אז אם, יניח, הם נותנים לך 3 טיעוני שורת פקודה במקום 2
או לתת לך 1, למשל, אז מה שאתה תעשה זה שאתה רוצה לבדוק ש
ואז לחזור 1 אומר, לא, אני לא יכול להמשיך בתכנית זו.
[תלמיד] אין ולא יכול להיות מקום בטקסט שלך. >> סליחה?
[תלמיד] לא יכול להיות מקום בטקסט שאתה מנסה להצפין.
אה!
במונחים של הטקסט שאנחנו מנסים להצפין, שמקורו דווקא בהמשך
כאשר אנו נותנים טקסט.
אז כרגע אנחנו פשוט מקבלים את הטענות כפקודת מספר בפועל,
השינוי בפועל עבור הצפנת הקיסר.
[תלמיד] למה אתה צריך 2 לעומת רק argc 1? יש בהחלט מספר 1.
נכון. הסיבה שאנחנו צריכים 2 לargc במקום 1
משום שכאשר אתה מפעיל תכנית ואומר. / או קיסר. / שלום,
שלמעשה נחשב ארגומנט שורת פקודה.
אז שכבר לוקח עד 1 וכן אז אנחנו מזינים נוספים 1.
אז אתה בעצם מזין מחרוזת בארגומנט שורת הפקודה.
מה אתה רוצה לעשות, לקיסר אנחנו רוצים להתמודד עם מספר שלם,
כך שאתה יכול להשתמש בפונקצית atoi זה.
ובעצם, אתה תעבור אותו בחוט ואז זה יחזיר אותך חזרה שלם
אם זה אפשרי לעשות את זה במחרוזת של מספרים שלמים.
עכשיו זוכר מתי שאנחנו מתעסקים עם דברי printf או GetString, כמו ש,
אנו כוללים את הספריות ספציפיות לנו.
אז בהתחלה אנחנו מתחילים עם תג קלט / פלט סטנדרטי,. שעות, משהו כמו שחשיש.
ובכן, atoi אינו באחת מהספריות הללו,
אז מה יש לנו לעשות הוא שיש לנו לכלול את הספרייה המתאימה לכך.
אז זוכר חזרה לWalkthrough 1 שבו אני דנתי את הפונקציה הידנית.
אתה מקליד אדם במסוף שלך ולאחר מכן ואחריו השם של פונקציה.
וכדי שיביא את רשימה שלמה של השימוש בו,
אבל גם זה יביא אותה הספרייה ששייכת.
אז אני אשאיר לך את זה כדי להשתמש בפונקציה הידנית עם atoi
ולהבין איזה ספרייה אתה צריך לכלול כדי שתוכל להשתמש בפונקצית atoi.
אז יש לנו את המפתח ועכשיו זה מגיע מקבל טקסט הרגיל,
וכך למעשה הוא הולך להיות קלט משתמש שבו אתה תבקש.
התמודדנו עם GetInt וGetFloat, וכך באותה הרוח
אנחנו הולכים להיות התמודדות עם GetString.
אבל במקרה זה אנחנו לא צריכים לעשות כל לעשות בזמן או בזמן לולאות כדי לבדוק.
GetString בהחלט נותן לנו מחרוזת,
ואנחנו הולכים כדי להצפין את כל מה שהמשתמש נותן לנו.
אז אתה יכול להניח שכל מחרוזות שהוזנו משתמש אלה הם נכונים.
גדול.
אז ברגע שיש לך את המפתח וברגע שיש לך את הטקסט,
עכשיו מה שנשאר זה שיש לך בצופן בטקסט.
רק כדי לכסות במהירות על שפה, הטקסט הוא מה שהמשתמש נותן לך,
והמוצפן הוא מה שאתה חוזר אליהם.
אז מייתרים, כדי להיות מסוגל לעבור למעשה אות אחרת אות
כי יש לנו להעביר את כל מכתב,
אנו מבינים שלהתחייבות, אם אנחנו סוג של לקלף את השכבה,
אנו רואים שהם פשוט באמת רשימה של תווים.
אחד מגיע בזה אחר זה.
וכך אנו יכולים לטפל במחרוזות כמערכים כי הם מערכים של תווים.
אז אומר שיש לך מחרוזת בשם טקסט,
ובתוך טקסט שמשתנה מאוחסן זו CS50.
אז טקסט במדד 0 יהיה הבירה T, 1 המדד יהיה שעות, וכו '
ולאחר מכן עם מערכים, בדוגמא argc בargs.c,
ראינו שיש לנו כדי לעבור על מערך
ואז היינו צריכים לחזר מi = 0 עד i היא פחות מהאורך.
אז אנחנו זקוקים לדרך להבין מה האורך של המחרוזת שלנו הוא
אם אנחנו הולכים לחזר על זה.
למזלנו שוב, יש פונקציה שיש לנו, אם כי בשלב מאוחר יותר בCS50
אתה בהחלט תוכל ליישם ולבצע פונקציה משלך
שיכול לחשב את אורכו של חוט.
אבל נכון לעכשיו אנחנו הולכים להשתמש באורך מחרוזת, כך strlen.
אתה עובר בחוט, ואז הוא יחזיר לך int שמייצג את האורך של המחרוזת שלך.
בואו נסתכל על דוגמה של איך אנחנו יכולים להיות מסוגלים לחזר על כל תו במחרוזת
ולעשות עם זה משהו.
מה שאנחנו רוצים לעשות הוא לחזר על כל תו של המחרוזת,
ומה שאנחנו רוצים לעשות הוא להדפיסנו חזרה כל תו 1 עד 1
מלבד נוסיף משהו לצד זה.
אז בואו נתחיל עם ללולאה. אני int = 0.
אנחנו הולכים להשאיר מקום למצבו.
אנחנו רוצים לחזר עד שאנחנו מגיעים לסוף המחרוזת, נכון?
אז מה פונקציה נותן לנו את אורכו של החוט?
[תגובת תלמיד לא נשמעה]
זה האורך של הארגומנטים בשורת הפקודה.
אבל עבור מחרוזת שאנחנו רוצים להשתמש בפונקציה שנותנת לנו את אורכו של החוט.
אז זה אורך מחרוזת.
וכן אז אתה צריך לעבור במחרוזת לזה.
הוא צריך לדעת מה מחרוזת שהוא צריך לחשב את האורך.
אז במקרה הזה יש לנו עסק עם מחרוזת s.
גדול.
אז מה אנחנו רוצים לעשות, בואו printf.
עכשיו, אנחנו רוצים להתמודד עם תווים. אנו רוצים להדפיס כל תו בודד.
כאשר אתה רוצה את זה כדי להדפיס את מצוף, שהיית משתמש במציין מיקום כמו% f.
עם int היית משתמש ד%.
וכך באופן דומה, עם אופי אתה משתמש ג% להגיד שאני הולך להיות דפוס אופי
שמאוחסן בתוך משתנה.
אז יש לנו את זה, ובואו נוסיף תקופה ומקום אליו.
איזו דמות שאנחנו משתמשים?
אנחנו הולכים להיות באמצעות מה שדמות שאנחנו במחרוזת.
אז אנחנו הולכים להיות באמצעות משהו עם מחרוזת,
אבל אנחנו רוצים להיות בגישה לאופי מסוים שם.
אז אם מחרוזת היא פשוט מערך, אז איך אנחנו לגשת אלמנטים של מערכים?
יש לנו אותן סוגריים מרובעים, ולאחר מכן אנחנו מכניסים את המדד לשם.
אז יש לנו סוגריים מרובעים. האינדקס שלנו במקרה זה אנחנו יכולים פשוט להשתמש. בדיוק.
אז הנה מה שאנחנו אומרים שאנחנו הולכים להיות דפוס אופי אחריו נקודה וחלל,
והדמות שהולכת להיות מכתב ith במחרוזת שלנו.
אני רק הולך להציל את זה. אוקיי.
עכשיו אני הולך להפעיל את אורך מחרוזת.
אז היה לנו מחרוזת בשם OMG, ועכשיו זה הדגיש עוד יותר.
כמו כן, אניח שאנו באמת רוצים לקבל מחרוזת מהמשתמש.
איך ניתן לעשות זאת?
לפני כן, איך הגענו int?
אנחנו אמרנו GetInt, נכון? אבל זה לא int, אז בואו GetString.
בואו נעשה את אורך מחרוזת. כאן אנו לא נכנסנו הנחיה ספציפית.
אז אני לא יודע.
אני הולך לשים את השם שלי בפה וכן אז אני יכול לעשות אחד מהדברים האלה
איפה אני להקצות מילה לכל אות או משהו כזה. מגניב.
אז זה אורך מחרוזת.
אז חזר לקיסר.
יש לנו כמה כלים באופן שנעמיק את המחרוזת,
איך לגשת לכל רכיב בנפרד.
אז עכשיו אנחנו יכולים לחזור לתכנית.
כפי שציינתי קודם, בטבלת ASCII, החבר הכי הטוב שלך,
אתה הולך לראות את המספרים הקשורים לכל מכתב.
אז הנה אומרים הטקסט שלנו הוא יש לי סחרחורת!
אז כל אחד מהתווים האלה הולך להיות מספר וערך ASCII הקשור אליו,
אפילו גרש, גם המרחב, גם בסימן הקריאה,
אז אתה רוצה לשמור את זה בחשבון.
אז אומר שהמפתח שלנו למשתמש הכלול בארגומנט שורת הפקודה שלהם הוא 6.
כלומר, למכתב הראשון, שהוא אני, שמיוצג על ידי 73,
אתה רוצה להחזיר להם כל מה שמכתב מיוצג על ידי ערך ASCII של 73 + 6.
במקרה זה שיהיה 79.
עכשיו אנחנו רוצים ללכת לתו הבא.
אז הבא במדד של 1 הטקסט יהיה הגרש.
אבל תזכור אנחנו רק רוצים להצפין את האותיות.
אז אנחנו רוצים לוודא שהגרש בעצם נשאר אותו הדבר,
שלא נשנה מ 39 ל 45 מה הוא.
אנחנו רוצים לשמור אותו כגרש.
אז אנחנו רוצים לזכור בצופן האותיות בלבד
כי אנחנו רוצים את כל סמלים האחרים כדי להישאר ללא שינוי בתכנית שלנו.
דבר נוסף שאנחנו רוצים הוא לשמר היוון.
לכן, כאשר יש לך אות גדולה, זה צריך להישאר כאותיות רישיות.
אותיות קטנות צריכות להישאר כאותיות קטנות.
אז כמה פונקציות שימושיות כדי להיות מסוגלות להתמודד עם מכתבי enciphering בלבד
ולשמור שמירת הייוון של דברים
היא את isalpha, isupper, פונקציות islower.
ולכן אלה הם פונקציות שמחזירות לך ערך בוליאני.
בעיקרון, אמת או שקר. האם זה אותיות גדולות? האם זה אלפאנומרי?
האם זה מכתב, למעשה.
אז הנה 3 דוגמאות של איך היית להשתמש בפונקציה ש.
בעיקרון, אתה יכול לבדוק אם הערך שהוחזר לך על ידי שהפונקציה הוא אמת או שקר
המבוסס על קלט.
או שיעשה משהו לא להצפין או צופנים או לוודא שזה באותיות גדולה, ועוד
[תלמיד] אתה יכול פשוט להסביר אלו קצת יותר ואיך אתה משתמש בם? >> כן, בטח.
אז אם אנחנו מסתכלים אחורה, כאן יש לנו הוני, נכון?
אז אנחנו יודעים שאני הולך לO כי אני + 6 הוא O.
אבל אנחנו רוצים לוודא שO הולך להיות בירת O.
אז בעצם, שהוא סוג של הולך לשנות הקלט שלנו.
אז אם זה אותיות גדול או לא תהיה סוג של שינוי האופן שבו אנו מתמודדים עם זה.
אז אם אנחנו משתמשים בפונקצית isupper שבמדד מסוים,
כך isupper ("אני"), שמחזיר לנו אמיתי, ולכן אנחנו יודעים שזה עליון.
על סמך זה אז, אחר כך תלכו לנוסחה
כי אתה תהיה באמצעות להעביר דברים בקיסר,
אז בעצם, יש הולך להיות נוסחה מעט שונה אם זה אותיות גדול
בניגוד לאותיות קטנות. הגיוני?
כן. אין בעיה.
דברתי קצת על הוספת 6 למכתב, שלא ממש הגיוני
למעט כאשר אנחנו סוג של ההבנה שהדמויות הללו
הם סוג של החלפה עם מספרים שלמים.
מה שאנו עושים זה סוג של יציקה משתמעת שימוש.
אנחנו נלך לליהוק קצת יותר מאוחר שבו אתה לוקח ערך והופך אותם לסוג אחר
ממה שהיה במקור.
אבל עם זה אנו pset נוכל להשתמש בסוג של דמויות לסירוגין
והערכים השלמים המקבילים להם.
אז אם אתה פשוט לעטוף את דמות רק עם מרכאות בודדות,
אז אתה תהיה מסוגל לעבוד עם אותו עם מספרים שלמים, התמודדות עימו כמספר שלם.
אז ההון C מתייחס ל 67. ו אותיות קטנות מתייחס ל102.
שוב, אם אתה רוצה לדעת את הערכים הללו, יסתכלו על טבלת ASCII שלך.
אז בואו נלך לכמה דוגמאות של איך ייתכן שתוכל להפחית ולהוסיף,
איך אתה יכול ממש ממש לעבוד עם הדמויות הללו, להשתמש בם לסירוגין.
אני אומר ASCIIMath כי הוא הולך לחשב את התוספת של דמות למספר שלם
ולאחר מכן מציג את אופי התוצאה, כמו גם את ערך ASCII שנוצר.
אז הנה אני אומר - להכין מעסקה עם החלק הזה בהמשך -
אבל בעצם, אני אומר שהמשתמש צריך לומר ASCIIMath לרוץ יחד עם מפתח,
ואני אומר שמפתח שהוא הולך להיות המספר
שבה אנו הולכים להוסיף הדמות הזאת.
אז הנה שם לב שמאז אני דורש מפתח,
מאז שאני דורש מהם שאתה נותן לי דבר 1,
אני רוצה רק לקבל. / Asciimath ומפתח.
אז אני הולך לדרוש שargc שווה ל 2.
אם זה לא, אז אני הולך להחזיר 1 והתכנית תסתיים.
אז אני אומר המפתח הוא לא הולך להיות ויכוח שורת הפקודה הראשונה,
זה הולך להיות שני אחת, וכמו שאתה רואה כאן,
אני הולך להפוך את זה למספר שלם.
ואז אני הולך להגדרת אופי להיות r.
שים לב כי הסוג של chr משתנה הוא למעשה מספר שלם.
הדרך שאני מסוגל להשתמש r כשלם היא על ידי encasing זה עם המרכאות בודדות האלה.
אז בחזרה להצהרת printf שבו יש לנו מקום עבור תו
ולאחר מכן מציין מיקום עבור מספר שלם,
האופי מיוצג על ידי chr, והשלם הוא המפתח.
וכך אז אנחנו הולכים בתוצאה להוסיף 2 ביחד.
אז אנחנו הולכים להוסיף R + מה המפתח הוא,
ואז אנחנו הולכים להדפיס את התוצאה של זה.
אז בואו נעשה asciimath. זה מעודכן, אז בוא פשוט להפעיל asciimath.
אה, אבל תראה, זה לא לעשות שום דבר, כי אנחנו לא ממש נותנים לו מפתח.
אז כשזה פשוט חזר 1, הפונקציה העיקרית שלנו, זה פשוט חזר אלינו.
אז בואו נעבור במפתח. מישהו נתן לי מספר. >> [תלמיד] 4.
4. אוקיי.
אז r גדל ב 4 הוא הולך לתת לנו V, אשר תואם את ערך ASCII של 118.
ואז זה סוג של הגיוני כי -
למעשה, אני יכול לשאול אותך, מה אתה חושב שערך ASCII של r הוא אם r + 4 הוא 118?
אז כן, r הוא 114.
אז אם אתה מסתכל על שולחן ASCII אז בטוח מספיק, אתה תראה שr מיוצג על ידי 114.
אז עכשיו אנחנו יודעים שאנחנו יכולים להוסיף מספרים שלמים לתווים, זה נראה די פשוט.
אנחנו רק הולכים לחזר על מחרוזת כמו שראינו בדוגמה קודמת.
אנחנו נבדוק אם זה מכתב.
אם כן, אז להעביר אותו בכל מה שהמפתח הוא.
די פשוט, למעט כאשר אתה מגיע לאוהב את זה,
אתה רואה שz, מיוצג על ידי 122, אז היה נותן לך אופי שונה.
אנחנו באמת רוצים להישאר במסגרת האלפבית שלנו, נכון?
אז אנחנו צריכים למצוא דרך כלשהי מסוג של גלישה מסביב.
כאשר אתם מגיעים zed ואתה רוצה להגדיל על ידי מספר מסוים,
אתה לא רוצה להיכנס לקטע מעבר האלפבית ASCII;
אתה רוצה לעטוף בחזרה את כל הדרך עד א '
אבל יש לזכור שעדיין משמר את המקרה.
אז הידיעה שמכתבים לא יכולה לסמל
בדיוק כמו סמלים לא הולך להיות שינוי גם כן.
בpset האחרון אתה בהחלט לא צריך,
אבל אפשרות הייתה ליישם pset החמדן שלך על ידי שימוש בפונקצית מודולוס.
אבל עכשיו אנחנו ממש הולכים צריכים להשתמש במודול,
אז בואו נלך על זה קצת.
בעיקרון, כאשר יש לך x מודולו y, שנותן לך את השארית של x החלק y.
הנה כמה דוגמאות כאן. יש לנו 27% 15.
בעיקרון, כאשר אתה להחסיר 15 מ 27 פעמים רבות ככל האפשר מבלי לקבל שלילי
ואז אתה מקבל 12 שנשאר.
אז זה כמו סוג של בהקשר המתמטיקה, אבל איך אנחנו יכולים להשתמש בזה?
זה הולך להיות שימושי עבור wrapover.
לשם כך, בואו רק נאמרתי ששאלתי את כל מה שאתה לחלק ל 3 קבוצות.
לפעמים אתה עושה את זה בקבוצות ומשהו כזה.
אגיד שאני אמרתי, "טוב, אני רוצה שכולכם להיות מחולק 3."
כיצד תוכל לעשות זאת?
[תגובת תלמיד לא ברורה] כן, בדיוק. התפקד. אוקיי.
בואו לעשות את זה בפועל. האם אתה רוצה להתחיל?
[תלמידים לספור את] 1, 2, 3, 4.
אבל תזכור ... >> [תלמיד] אה, סליחה.
זו נקודה ממש טובה.
אתה אמרת 4, אבל אנחנו ממש רוצים שתגידו 1 כי אנחנו רוצים 3 קבוצות בלבד.
אז, איך - לא, זה דוגמה ממש טובה כי אז איך אתה יכול לומר 1?
מה הקשר בין 4 ו 1?
ובכן, 4 mod 3 הוא 1.
אז אם אתה ממשיך, אתה יהיה 2.
אז יש לנו 1, 2, 3, 1, 2.
שוב, אתה בעצם האדם 5. איך אתה יודע להגיד 2 במקום 5?
אתה אומר 5 mod 3 הוא 2.
אני רוצה לראות כמה קבוצות של 3 נותרים מעל, אז שכדי am I.
ואם כך, אילו המשיך לאורך כל החדר,
אז הייתי רואה שאנחנו תמיד למעשה יישום פונקצית mod לעצמנו
סוג של להתפקד.
גם זה סוג של דוגמה מוחשית יותר של איך אתה יכול להשתמש במודולו
כי אני בטוחה שרובנו כנראה עברתי כי תהליך
איפה שהיינו לנו לספור את.
כל שאלות במודולו?
זה יהיה די חשוב להבין את המושגים של זה,
אז אני רוצה לוודא שאתם מבינים.
[תלמיד] אם אין שארית, זה ייתן לך את המספר האמיתי?
אם אחד מ3 הראשונים שלהם עשה את זה, זה היה נותן להם את מה שהם באמת היו,
או שזה נתן להם [לא ברור] >> זו שאלה טובה.
כאשר אין שארית למודולו - כך אומר שיש לך 6 mod 3 -
שבעצם נותן לך גב 0.
נידבר על זה קצת מאוחר יותר.
אה, כן, למשל, האדם 3 - 3 mod 3 הוא למעשה 0 אבל היא אמרה 3.
אז זה כמו סוג של מלכוד פנימי, למשל,
כמו בסדר, אם mod הוא 0 אז אני הולך להיות האדם 3.
אבל נעשה לנו סוג של איך יתכן שעלינו להתמודד עם מה 0 הוא מאוחר יותר.
אז עכשיו אנחנו איכשהו יש דרך מיפוי zed לאות הנכונה.
אז עכשיו שעברנו כל הדוגמות הללו,
אנחנו סוג של לראות איך קיסר יכול לעבוד.
אתה רואה את 2 אותיות ואז אתה רואה אותם משתנה.
אז בואו ננסה ולבטא את זה במונחים של נוסחה.
נוסחה זו היא למעשה שניתן לך במפרט,
אבל סוג בואו של מבט דרך מה כל משתנה משמעות.
התוצאה הסופית שלנו הולכת להיות מוצפנת.
אז זה אומר שהאופי של ith המוצפן
הולך מתאים לאופי ith של הטקסט.
זה הגיוני, כי אנחנו רוצים להיות תמיד הזדנבות את הדברים האלה.
אז זה הולך להיות דמות ith של המוצפן התוספת k, שהוא המפתח שלנו -
זה הגיוני - ואז יש לנו 26 mod זה.
זכור בחזרה כאשר היו לנו zed
אנחנו לא רוצים להיכנס לאופי, אז רציתי mod זה
וסוג של עוטף את האלפבית.
לאחר zed שהיית הולך אל א, ב, ג, ד, עד שהגעת למספר הנכון.
אז אנחנו יודעים שzed, אם + 6, היה נותנים לנו F כי אחרי zed מגיע, B, C, D, E, F.
אז הבה נזכור שאנו יודעים בודאות כי zed + 6 הוא הולך לתת לנו f.
בערכי ASCII, z הוא 122 ו f היא 102.
אז אנחנו צריכים למצוא איזו דרך לעשות נוסחת הקיסר שלנו נותנים לנו 102
לאחר שלקח ב122.
אז אם רק ליישם את הנוסחא הזו,% (צ'+ 6) 26, שבעצם נותנים לך 24
בגלל 122 + 6 הם 128; 128% 26 נותנים לך 24 שארית.
אבל זה לא באמת מתכוון f. זה בהחלט לא 102.
זה גם לא המכתב 6 באלף הבית.
אז ברור, שאנחנו צריכים לעבור כמה דרך של tweaking זה קצת.
במונחים של האלפבית הרגיל, אנו יודעים כי z הוא האות 26 ו-F הוא 6.
אבל אנחנו במדעי מחשב, ולכן אנחנו הולכים למדד ב 0.
אז במקום z להיות המספר 26, אנחנו הולכים להגיד את המספר שלו 25
כי הוא 0.
אז עכשיו בואו ננסה להפעיל את הנוסחא הזאת.
יש לנו z מיוצג על ידי 25 + 6, אשר נותן לך 31.
ו31 mod 26 נותן לך 5 כשארית.
זה מושלם, כי אנחנו יודעים שf הוא 5 המכתב באלפבית.
אבל זה עדיין לא F, נכון? זה עדיין לא 102.
אז לpset זה, אתגר יהיה בניסיון לברר את הקשר
בין ההמרה בין הערכים אלה ASCII ומדד אלפביתי.
בעיקרו של דבר, מה שאתה רוצה לעשות, אתה רוצה לצאת לדרך עם ערכי ASCII,
אבל אז אתה רוצה איכשהו צריך לתרגם את זה לאינדקס אלפביתי
לאחר מכן לחשב מה מכתב זה צריך להיות - בעצם, מה האינדקס אלפביתי שלה הוא
של אופי הצופן - ולאחר מכן לתרגם את זה בחזרה לערכי ASCII.
אז אם אתה לשלוף טבלת ASCII שלך, ואז לנסות ולמצוא יחסים בין, תניח, 102 ו 5
או 122 ו 25.
Gotten המפתח שלנו מטיעוני שורת הפקודה, קבל הטקסט,
אנחנו כבר הצפנו אותו.
עכשיו כל מה שנותרנו לנו לעשות הוא להדפיס אותו.
אנחנו יכולים לעשות את זה כמה דרכים שונות.
מה שאנחנו יכולים לעשות הוא למעשה להדפיס כמו שאנחנו הולכים יחד.
ככל שנעמיק יותר את התווים במחרוזת,
אנחנו פשוט יכולים פשוט להדפיס באותו רגע, כאשר אנו מחשבים אותו.
לחלופין, אתה יכול גם לאחסן אותו במערך ויש מערך של תווים
ובסופו לחזר על שכל המערך ולהדפיס אותו.
אז יש לך כמה אפשרויות לכך.
ותזכור ש% ג הולך להיות המקום עבור הדפסת תו.
אז יש לנו את קיסר, ועכשיו אנחנו עוברים לVigenere,
אשר דומה מאוד לקיסר אלא רק מעט יותר מורכב.
אז בעצם עם Vigenere הוא שאתה הולך להיות עובר במילת מפתח.
אז במקום מספר, אתה הולך להיות מחרוזת,
וכך זה הולך לפעול כמילת המפתח שלך.
ואז, כרגיל, אתה הולך לקבל את הבקשה למחרוזת מהמשתמש
ואז להצפין אותו ואז לתת להם בחזרה המוצפן.
אז כמו שאמרתי, זה דומה מאוד לקיסר, אלא שבמקום תפנית של מספר מסוים,
המספר הוא בעצם הולך לשנות כל פעם מדמה לדמות.
לייצג שמספר אמיתי להעביר, זה מיוצג על ידי אותיות המקלדת.
אז אם אתם נכנסים במשמרת של, למשל, אז זה יהיה מתאים לשינוי של 0.
אז זה שוב חוזר למדד אלפביתי.
מה יכול להיות שימושי אם אתה רואה שאנחנו בעצם מתעסקים עם ערכי ASCII
כמו גם את המכתבים, כמו גם ראשי אלפביתי,
אולי למצוא או ליצור טבלת ASCII משלך המציגה את האינדקס אלפביתי של 0 עד 25,
עד Z, ​​ואת ערכי ASCII, כך שאתה יכול לראות סוג של מערכת היחסים
ולשרטט ולנסות ולמצוא כמה דפוסים.
בדומה לכך, אם היית עובר במקרה המסוים על ידי ו -
וזה או הוא או f הקטן או אותיות רישיות - אז זה יהיה מתאים ל5.
האם אנחנו טובים עד כה?
הנוסחא לVigenere היא קצת שונה.
בעיקרון, אתה רואה שזה בדיוק כמו קיסר,
רק שבמקום רק k יש לנו k ראשי j.
שימו לב שאנו לא משתמשים אני כי בעצם, באורך של מילת המפתח
הוא לא בהכרח האורך של ההודעה המוצפנת שלנו.
זה יהיה יותר ברור קצת, כאשר אנו רואים דוגמה לכך שיש לי קצת יותר מאוחר.
בעיקרון, אם אתה מפעיל את התכנית שלך עם מילת מפתח של Ohai,
אז זה אומר שכל פעם, Ohai הולכת להיות המשמרת שלך.
אז תלוי מה עמדתך היא במילת המפתח שלך,
אתה הולך להעביר את האופי המוצפן המסוים בסכום זה.
שוב, בדיוק כמו קיסר, אנחנו רוצים לוודא שאנחנו משמרים את השווי של דברים
ואנחנו רק אותיות הצפן, לא תווים או רווחים.
אז מסתכל אחורה לקיסר על הפונקציות שייתכן שהשתמש בם,
הדרך שאתה החלטת כיצד להעביר את הדברים, וליישם את זה לתכנית שלך כאן.
אז בואו למפות את זה.
יש לנו טקסט שקבלנו מהמשתמש מGetString
אומר את זה ... הוא CS50!
אז יש לנו מילת מפתח של Ohai.
את 4 התווים הראשונים הם די פשוט.
אנו יודעים כי T הולך להיות מוזז על ידי o,
אז h הולך להיות מוזז על ידי ח, אני הולך להיות מוזז על ידי.
כאן אתה רואה שמייצג 0,
כן אז הערך הסופי הוא למעשה רק אותו המכתב כמו קודם.
אז שלו הוסט על ידי א.
אבל אז יש לך תקופות אלו כאן.
אנחנו לא רוצים בצופן ש, אז אנחנו לא לשנות אותו על ידי שום דבר
ופשוט להדפיס את התקופה ללא שינוי.
[תלמיד] אני לא מבין איך אתה יודע שזה מוזז על ידי - מאיפה אתה - >> אה, סליחה.
בראש כאן אתה רואה שOhai שורת פקודת הוויכוח כאן,
שהולך להיות מילת המפתח.
וכך בעצם, אתה רכבת על אופניים בדמויות במילת המפתח.
[תלמיד] o אז הוא הולך להיות הסטה אותו הדבר -
אז o מתאים למספר מסוים באלף הבית.
[תלמיד] ימני. אבל איפה השגת את CS50 חלק מ?
אה. זה בGetString בי אתה כמו, "תן לי את מחרוזת לקידוד".
[תלמיד] הם הולכים לתת לך טיעון שכדי להסיט
ואז תשאלו למחרוזת הראשונה שלך. >> כן.
אז כשהם מפעילים את התכנית, הם הולכים לכלול את מילת המפתח
בטיעוני שורת הפקודה שלהם כשהם נתקלים בו.
ואז ברגע שבדקת שהם נתנו לך 1 בפועל ולא יותר, לא פחות,
ואז אתה הולך לתנחה אותם למחרוזת, אומר, "תן לי חבל".
אז לשם במקרה זה הם נתנו לך זה ... הוא CS50!
אז אתה הולך להשתמש בזה ומשתמש בOhai ולחזר על.
שים לב שכאן אנחנו פוסחים על הצפנת התקופות,
אבל במונחים של עמדתנו לOhai, אחד ליד השתמשנו O.
במקרה הזה זה קצת יותר קשה לראות כי זה 4,
אז בואו נמשיך קצת. פשוט להישאר עימי כאן.
אז יש לנו אני וים, ולאחר מכן שמתורגמים על ידי o וח בהתאמה.
אז יש לנו חלל, וכך אז אנחנו יודעים שאנחנו לא הולכים בצופן את הרווחים.
אבל שים לב שבמקום ללכת למקום זה ממש כאן,
אנחנו הצפנה על ידי - אני לא יודע אם אתה יכול לראות את זה - ממש כאן.
אז זה לא מתאים לך מראש בעצם, אומר, o הולכת כאן, h הולך כאן,
הולך כאן, אני הולך כאן, o h,, I, O, h,, אני. אתה לא עושה את זה.
אתה לשנות את התנוחה שלך רק במילות המפתח
כשאתה יודע שאתה בעצם הולך להיות הצפנת מכתב בפועל.
האם זה סוג של היגיון?
אוקיי.
אז רק כמה תזכורות.
אתה רוצה לוודא שאתה להתקדם רק לאות הבאה במילת המפתח שלך
אם הדמות בטקסט שלך היא מכתב.
אז להגיד שאנחנו בo.
אנו מבחינים כי התו הבא, במדד שלי בטקסט, הוא מספר, למשל.
אז אנחנו לא מתקדמים j, מדד למילות המפתח שלנו, עד שנגיע מכתב נוסף.
שוב, אתה גם רוצה לוודא שאתה מעטפת לתחילת מילת המפתח
כאשר אתה נמצא בסופו.
אם אתה רואה כאן אנחנו באני, הבא צריך להיות O.
אז אתה רוצה למצוא דרך של יכולת מעטפת לתחילת מילת המפתח שלך
בכל פעם שאתה מגיע לסוף.
וכך שוב, איזה סוג של מפעיל הוא שימושי במקרה זה לגלישה סביב?
כמו בספירה את הדוגמא.
[התלמיד] סימן האחוזים. >> כן, סימן האחוזים, שהוא מודולו.
אז מודולו יהיה שימושי כאן כאשר אתה רוצה לעטוף לעומת המדד בOhai.
ורק רמז מהיר: נסה לחשוב על עטיפה מעל מילת המפתח קצת כמו את הספירה,
שבו אם יש 3 קבוצות, האדם 4,
מספרם שהם אמרו שהיה 4 mod 3, שהיה 1.
אז לנסות ולחשוב על זה ככה.
כפי שראית בנוסחה, בכל מקום שיש לך ולאחר מכן ci pi אבל אז KJ,
אתה רוצה לוודא שאתה לעקוב אחר אלה.
אתה לא צריך לקרוא לזה אני, אתה לא צריך לקרוא לזה j,
אבל אתה רוצה לוודא שאתה לעקוב אחר העמדה שאתה נמצא בבית בטקסט שלך
כמו גם העמדה שאתה נמצא בבית במילת המפתח שלך
כי אלה לא בהכרח הולכים להיות אותו הדבר.
לא רק את מילת המפתח - זה יכול להיות באורך שונה לחלוטין מהטקסט שלך.
כמו כן, בטקסט שלך, יש מספרים ותווים,
כך שזה לא הולך להתאים יחד באופן מושלם. כן.
[תלמיד] האם יש פונקציה לשינוי מצב?
האם אתה יכול לשנות לבירה? >> כן, יש בהחלט.
אתה יכול לבדוק - אני מאמין toupper זה, כל המילה 1.
אבל כאשר אתה מנסה צופן דברים ולשמר את הטקסט,
זה הכי טוב בעיקרון יש מקרים נפרדים.
אם זה באותיות גדולה, ואז אתה רוצה להעביר את זה על ידי
כי בנוסחא שלך, כשאתה מסתכל אחורה כמה שיש לנו לסוג של דרכים
לסירוגין בין דרך ASCII של המספרים המייצגים את
ומדד אלפביתי בפועל, אנו רוצים לוודא
יש הולך להיות איזה דפוס שאתה הולך להשתמש.
עוד הערה על הדפוס, בעצם.
אתה הולך בהחלט להיות התמודדות עם מספרים.
נסה לא להשתמש במספר קסם, שהוא דוגמה לסגנון.
אז אומר שאתה רוצה משהו בכל עת על ידי שינוי אוהב -
אוקיי, אז רמז, ספוילר נוסף הוא כאשר אתה הולך להיות משהו משתנה
במידה מסוימת, נסה לא מייצג שעל ידי מספר בפועל
אלא לנסות ולראות אם אתה יכול להשתמש בערך ASCII, שסוג של הגיוני יותר.
הערה נוספת: מכיוון שיש לנו עסק עם נוסחות,
למרות TF יהיה סוג של דפוס יודע מה אתה יכול להיות באמצעות,
הכי טוב בסוג של ההערות שלך להסביר את ההיגיון, אוהב,
"אני משתמש בדפוס זה בגלל ..." וסוג של להסביר את הדפוס בתמציתיות את הערותיך.
[זו הייתה הדרכה 2] אם אין עוד שאלות, אז אני פשוט אשאר כאן לקצת.
בהצלחה עם pset 2: האנוסים ותודה שבאת.
[תלמיד] תודה לך. תודה. >>
[הקדמה מנותקת מדיה]