[Powered by Google Translate] [סעיף 3] [פחות נוח]
>> [נייט Hardison] [אוניברסיטת הרווארד]
>> [זה CS50.] [CS50.TV]
>> בסדר, בואו נתחיל.
ברוכים הבאים לשבוע 4 של CS50.
אם אתם פותחים את דפדפן אינטרנט ולפתוח 3 pset,
מירוץ עם CS50, אנחנו מתכוונים להתחיל ללכת
דרך הסעיף של שאלות שם.
בדיוק כמו בשבוע שעבר, אנו נפעל בCS50 Spaces,
אם אתה גם למשוך את זה עד, כמו גם,
ואם אתה הולך קדימה ובקר בקישור זה שיש לי כאן למעלה בראש.
זה זמן להתחיל לעבוד.
יש לנו תכנית ההיי הקטנה שלנו כאן. לא בצורה מטורפת.
אחד הדברים הראשונים שאני רוצה לעשות איתכם היום הוא לעבור על כמה פתרונות
על ערכת בעיה 1, סוג של פתרונות לדוגמה,
רק אז אתה יכול לקבל תחושה של איזה סוג של צוות הקוד כותב,
אילו סוגים של תלמידי קוד אחרים כותבים,
ויש לך תסתכל על זה, כי אני יודע שזה מוזר
כשאתה מגיש פתרון לבעיה ולקבל סט הערות
בגרסה שלך, אבל לפעמים זה מועיל כדי לראות איך אנשים אחרים עשו את זה,
במיוחד אלה שאינם נחמדים למראה.
על פי רוב, אני מאוד התרשמתי מהפתרונים שאתם יצרתם.
אני עדיין לא התחלתי להסתכל 2s הגדרת הבעיה שלך, אבל אם הם כל דבר כמו הראשון,
זה אומר רק דברים טובים.
>> אם אתה מסתכל על התיקונים שלי, בואו נתחיל את כל הדרך למטה ליום 1 בגרסות,
ואנחנו הולכים לקחת מבט מהיר על פתרון מריו.
אם אתה מושך את זה, תוכניות אלה שאנחנו הולכים להציג הן נכונות.
לא היו בעיות עם תקינות בעיות אלה, אלא,
אנחנו רוצים לדבר קצת על נושאי העיצוב השונים
שהיו בשימוש כאן.
אחד הדברים שהיו מעניין לגבי הפתרון
הוא שהוא משמש המבנה החדש הזה שנקרא ק"ג להגדיר,
לפעמים גם מכונה חשיש להגדיר.
בואו להתקרב על זה כאן.
# Define מאפשר לך לתת שמות למספרים הללו בתכנית שלך.
במקרה זה, בגובה המרבי של פירמידה במריו
היה 23 ולא לשים 23 בקוד שלי,
היינו מתייחס לזה כקשה 23 קידוד -
במקום זה נותן את השם MAX_HEIGHT למספר זה,
כך שכאן בעשה תוך לולאתי
אתה באמת יכול להתייחס לMAX_HEIGHT
במקום לשים את המספר 23 פנימה
[סטודנטים] מה היתרון של עושה את זה?
זו שאלה גדולה.
אחת היא קריאות.
יתרון של שימוש זה הוא להגדיר # קריאות.
כשאני קורא את הקוד הזה, אני יכול לראות מה קורה.
>> אני יכול לראות במצב הזה כאן שאנו בודקים
לגובה להיות <0, שיכולנו לקבלו גם מוגדרים
להיות גובה מינימאלי או גובה דקות.
היתרון השני הוא שאני יכול לקרוא ואז שאר השורה כדי לראות
שגם אנחנו בודקים כדי לוודא שגובה הוא לא יותר מגובה המקסימום,
כי אנחנו מתכוונים להמשיך ואילו הגובה הוא גדול יותר מגובה המקסימום.
היתרון השני הוא, אם אני להתרחק קצת כאן
אם אני מפעיל את התכנית הזאת ואני מפעיל אותו, למשל, עם 23 עכשיו,
זה יהיה להדפיס את כל 23 שורות בדיוק כמו ש.
אבל להגיד שאני רוצה לשנות את הגובה המרבי,
ועכשיו אני רוצה להגביל את הגובה המרבי של פירמידות
להיות איש רק לומר, שהיה פאנקי.
# כולל , # define MAX_HEIGHT,
ונניח שאנחנו רוצים להגדיר אותו שווים ל 10.
עכשיו, בשלב זה, כל מה שהיה צריך לעשות זה לשנות אותו במיקום זה.
אני יכול להדר מחדש את הקוד, ועכשיו אם אני מנסה והקלד ב12,
אותו ינחה אותי שוב.
במקרה זה, אנחנו רק באמצעות MAX_HEIGHT פעם אחת.
זה לא כל כך גדול של טרחה ללכת ב
ולשנות אותו בלולאה בזמן, אם אתה צריך.
אבל בתוכניות שבו אתה מפנה אותו מספר הקסם
שוב ושוב, זה # להגדיר מנגנון הוא באמת שימושי
כי אתה פשוט לשנות אותו פעם אחת בחלק העליון של קובץ זה בדרך כלל שבו אתה שם אותם
והשינוי מחלחל דרך שאר הקבצים.
>> דברים שרציתי לציין במשימה הזאת הוא נראה לי ממש נחמדים,
אחד מהם היה השמות של המשתנים.
אתה רואה כאן שיש לנו משתנה בשם שלם שורה ונקרא גובה.
רווחים, hashes, זה עוזר להפוך את הקוד לקריא יותר קטן,
עושה את זה קצת יותר מובן מה בעצם קורה.
זאת בניגוד לשימוש, למשל, אותיות אקראיות
או סתם קשקוש לחלוטין.
דבר אחרון שאני מוכן להצביע הוא שבלולאות,
לעתים קרובות משתנה אלה איטרטור, הדלפקים האלה שבם אתה משתמש בלולאות,
זה סטנדרטי וקונבנציונלי כדי להתחיל אותם עם שתי i ואז י ולאחר מכן k
והולך משם, אם אתה צריך עוד משתנה,
וזו רק מוסכמה.
יש הרבה מוסכמות.
זה תלוי בשפת תכנות שאתה משתמש.
אבל ב-C, שמתחילים בדרך כלל עם i.
זה לא הגיוני להשתמש, למשל, או ב
בהתאם למצב.
זהו זה לזה.
אם אתה עכשיו למשוך את הגרסות 2, תראה עוד מריו,
ואת זה הוא דומה לאחד האחר שראינו הרגע,
אבל זה סוג של משהו מגניב.
אם נסתכל על סעיף זה ממש כאן בתוך פנימי ללולאה,
הם משתמשים באיזה תחביר מחפש מטורף כאן ממש במשפט הזה.
זה נקרא מפעיל משולש.
זה הצהרה אם אחרת הנדחסת לשורה אחת.
המצב זה הוא חלק בתוך סוגריים.
זה שווה ערך לאמירה אם j גובה <- אני - 1.
ואז מה את התוכן שאם יהיה בלוק הוא המרחב
ולאחר מכן את התוכן של מה יהיה אחר הוא זה #.
זה מהות של הקצאת שטח למשתנה זה.
זה לשים את החלל בתוכן של משתנה הבלוק,
אם תנאי זה מתקיים, ואם מצבו לא נפגש,
אז משתנה הבלוק מקבל זה #.
ואז, כמובן, במקום לבנות את כל מחרוזת
ומדפיס את כל מה בסוף פתרון זה מדפיס אותו תו אחד בכל פעם.
די מגניב.
>> עוד כמה דברים להסתכל. נצטרך להמשיך הלאה לחמדנים.
עכשיו, אם אנחנו מסתכלים על חמדן, פתרון ראשון זה
משתמש באלה # מגדיר לא מעט.
יש לנו קבוע שהוגדר לכל אחד מהמספרים השונים בתכנית זו.
יש לנו אחת לסנאט לדולר, אחד לרבעים, עשר הסנאט, הניקל ופרוטות,
ועכשיו אם אנחנו לגלול למטה ולקרוא את הקוד,
אנו יכולים לראות את כל מה שיעשה, ואילו לולאת הדפסה סטנדרטית.
סוג של עיקר הבעיה היה להבין כי
אתה צריך להמיר את המצוף שאתה קורא במשתמש מספר שלם
מדויק כדי לעשות את החשבון, וזה בגלל
עם מספרי נקודה צפו, כמו שדברנו בהרצאה קצרה,
זה לא אפשרי כדי לייצג במדויק כל ערך בודד על קו המספר
כי יש ערכים רבים לאין שיעור שבין 3 ו, יניחו, 3.1 אפילו.
אתה יכול לקבל 3.01 ו3.001 ו3.0001, ואתה יכול להמשיך.
מתברר בכל פעם שאתה עובד עם כסף, לעתים קרובות אתה רוצה להמיר אותו
לפורמט שלם, כך שאתה לא מאבד פרוטות ולכל מיני דברים.
עושה את זה ולעיגול היה מפתח.
פתרון זה השתמש באלגוריתם פשוט לגמרי, גדול,
אשר מופחת מספר הסנאטים שנותרו, 1 לפי רבעונים,
לאחר מכן על ידי מטבעות, ולאחר מכן על ידי מטבעים, אז בפרוטות,
ומוסיף למספר מטבעים בכל פעם.
>> פתרון נוסף שאנו רואים, כפי שזום החוצה וללכת לגרסה 4,
הייתה התחלה דומה מאוד אבל div וmod להשתמש במקום זאת
זכות לכאן כדי לחשב את מספר הסנאטים.
זה, במספר הרבעים שווה למספר הסנאטים מחולקים 25,
והסיבה זו היא עובדת בגלל שאנחנו עושים חלוקת מספר שלמה,
כך שזה משליך כל שארית.
[סטודנטים] האם יש לנו להגיב חיפוש?
זה מאוד תלוי.
[סטודנטים] אתה להעיר יותר מקוד ממש כאן.
כן, ולכן יש חבורה של פילוסופיות שונות על זה.
הפילוסופיה האישית שלי היא שהקוד שלך הוא באמת את האמת,
כמו הקוד שלך הוא מה באמת נמצא בביצוע במחשב,
וכן את הקוד שלך צריך להיות קריא ככול האפשר שלא מחייב כמו הערות רבות.
עם זאת, כאשר אתה עושה את של מסובך דברים שהם סוג מתמטי
או אלגוריתמי, זה טוב למי להגיב, כך שאתה יכול
להוסיף ממד נוסף, שכבה נוספת למי שקורא את הקוד שלך.
בפתרונות אלו, לעתים קרובות הם הגיבו יותר בכבדות רק בגלל
אנחנו רוצים להיות מסוגלים להפיץ אותם ויש אנשים לאסוף אותם
ולקרוא אותם די בקלות.
אבל בהחלט, אני מסכים שזה כבד.
[סטודנטים] אבל במקרה של ספק, עבור כבד יותר?
במקרה של ספק, עבור כבד יותר.
חלק מהאנשים לפעמים אומרים 0 תמורה או משהו כזה.
אני חושב שזה מגוחך תגובה.
ברור שזה מה שקורה.
אני לא צריך לספר לי באנגלית ש.
לפעמים אנשים כותבים דברים כמו "kthxbai!"
זה די חמוד אבל גם לא,
שלא עושה את ההבדל בין נקודות להעיר או לא.
אלו סוגים של הערות הם רק חה, חה.
מגניב.
>> בשלב זה, בואו נתחיל לעבוד על בעיית הגדרת סעיף 3 של שאלות.
אם אתם מושכים את זה שוב,
כמו בשבוע שעבר, אנחנו לא מתכוונים לצפות במכנסיים הקצרים בסעיף זה.
אנחנו נודיע לכם לעשות את זה בזמן שלך ולדבר על השאלות.
אבל עכשיו בסעיף זה אנחנו הולכים לבלות קצת יותר זמן
מדבר על פחות מיסודות הקידוד
כמו שעשינו בשבוע שעבר, ובמקום זאת, אנחנו הולכים להתמקד יותר ב
קצת יותר מהתאוריה, ולכן מדבר על החיפוש בינארי ולאחר מכן מיון.
מאלה מכם שעוקבים יחד עם ההרצאה,
מישהו יכול לתת לי סיכום של מה ההבדל
בין החיפוש בינארי והחיפוש ליניארי?
מה קורה? בטח.
חיפושי חיפוש ינארית באמצעות כל אלמנט ברשימה הממוינת
אחד אחד על ידי אחד אחד על ידי אחד,
וחיפוש בינארי חלק הרשימה ל 2 קבוצות,
בודק אם ערך המפתח שאתה מחפש הוא גדול יותר או קטן יותר מערך נקודת האמצע
שאתה פשוט נמצא, ואם זה פחות מ, זה הולך עם הרשימה הנמוכה
ולאחר מכן חלק את זה שוב, עושה את אותו התפקיד
כל הדרך למטה עד שהוא מוצא את נקודת האמצע כדי להיות שווה הערך עצמו.
נכון.
>> למה אכפת לנו?
למה אנחנו מדברים על חיפוש בינארי לעומת החיפוש ליניארי?
כן.
בינארי הוא הרבה יותר מהר, ולכן אם תכפיל את גודל הבעיה
זה לוקח עוד צעד אחד ולא כמות כפולה.
בדיוק.
זאת תשובה גדולה.
חיפוש בשכבות רבה בודק מרכיב אחד בכל פעם,
וכפי שראינו ביום הראשון של הרצאה
כאשר הדוד עבר למשל ספר הטלפון שלו
ותלש דף אחד של ספר טלפונים בזמן
וכל זמן עושה את זה שוב ושוב ושוב,
זה הולך לקחת אותו באמת הרבה זמן כדי למצוא מישהו בספר הטלפונים,
אלא אם כן, כמובן, הוא היה מחפש מישהו ממש בתחילתו של אלף הבית.
בחיפוש בינארי, אתה יכול ללכת הרבה יותר מהר,
וזה לא רק במהירות כפולה או 3 פעמים מהר או 4 פעמים באותה מהירות.
אבל הבעיה הולכת וקטנה וקטנה הרבה יותר מהר.
כדי להמחיש זאת, תתחילו לדבר על מה שקורה
כאשר אנו כותבים חיפוש בינארי.
הבעיה העומדת על הפרק היא שאם יש לי מערך של מספרים,
תגיד, 1, 2, 3, 5, 7, 23, 45, 78, 12323,
ולאחר מכן 9 עם טונה של 0s אחריו,
אנחנו רוצים להיות מסוגלים להבין מהר מאוד מה הוא ב
זה מערך של מספרים.
אני יודע שזה נראה קצת מטופש וקצת מאולץ,
כי כרגע זה.
יש לנו מערך שאין לו הרבה מאוד אלמנטים בזה,
ואם אני שואל את אחד מכם כדי להבין אם או לא
23 הם במערך, אתה יכול לעשות את זה די מהר
רק העף מבט בזה ואומר לי כן או לא.
האנלוגי לשקול הוא לדמיין אם זה היה, יניח,
גיליון אלקטרוני של Excel עם 10,000 שורות, 20000 שורות.
כמובן, אתה יכול לעשות את הפקודה או F F השליטה ולחפש משהו.
אתה יכול גם להשתמש במסננים, וחומר החיפוש,
אם היה לך להסתכל דרך אותו קו קובץ על ידי שורה אחרת שורה, אבל,
זה ייקח לך הרבה זמן כדי למצוא אותו.
זה כמו סוג של בדוגמא ספר הטלפונים, גם בי
אף אחד לא מסתכל בספר עמוד אחד טלפון בכל פעם.
בדרך כלל, הם פותחים אותו לאמצע,
או במקרה של הרבה ספרי טלפונים ומילונים בי
למעשה יש לכם את זה רגש על האות הראשונה,
להעיפך שלאות הראשונה ולפתוח ולהתחיל ללכת דרך שם.
>> מזכיר לי את השם שלך שוב. >> סם.
סם.
כמו סם אמר, שתהליך החיפוש ליניארי הולך להיות ממש איטי,
ובמקום עם חיפוש בינארי, את אופן הפעולה הוא ש
בכל פעם שאנו עוברים איטרציה של אלגוריתם החיפוש שלנו,
אנחנו הולכים לחלק את הרשימה לשתיים, למעשה,
לשתי רשימות קטנות יותר.
ולאחר מכן באיטרציה הבאה של הלולאה, אנחנו נחלק את זה שוב
לרשימות אחרות, קטנות יותר.
כפי שניתן לראות, הבעיה הולכת ונעשתה קטנה יותר ויותר
בגלל שאנחנו לשמור על החצי שלכת של הרשימה בכל פעם אחת.
איך זה עובד שנזרק?
רק כתזכורת, מה אנחנו הולכים לעשות אם היינו מחשב
ואנחנו, למשל, מחפשים את המספר 5 ברשימה זו
הוא שהיינו קוטף מספר באמצע.
באמצע הרשימה זו, משום שיש 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 מספרים,
שניקח את המספר אחת בעמדה 4 או בעמדה 5,
והיינו קוראים לזה באמצע הרשימה שלנו.
בחר מספר באמצע.
ואז, בדיוק כמו שסם אמר שנבדוק כדי לראות אם המספר שהוא שווה
למספר שאנחנו רוצים לקבל או המספר הרצוי שלנו.
אם זה שווה, אז אנחנו כבר מצאנו את זה. אנחנו ננצח.
אם זה לא שווה, אז יש כמה מקרים.
שני המקרים הם גם המספר חייב להיות גדול מהמספר שאנחנו מסתכלים עליו,
או שזה פחות מ.
אם זה גדול יותר, אנו עוברים לצד ימין.
ואם זה פחות, אנו עוברים לצד השמאל.
ואז אנחנו חוזרים על כל התהליך שוב
שתי המחצית הימנית או המחצית השמאלית של הרשימה.
>> הבעיה הראשונה בסעיף של היום היא להבין
איך אנחנו יכולים באמת להתחיל לבטא את זה בקוד C.
יש לנו pseudocode כאן.
מה יהיה לנו להתחיל לעשות הוא אני אעצור מרחב חדש לגמרי,
שמירת גרסה זו, כך שיש לנו הערות אלה למועד מאוחר יותר,
אנחנו נמחק את כל זה, ולאחר מכן להעתיק ולהדביק מסט הבעיה
את המידע הזה במקומותינו, ואני מקווה שזה לא ישבור.
מושלם.
אם אתם עושים את כל זה, להעתיק ולהדביק את הקוד הזה לתוך החלל החדש שלך,
לתוך אחד ריק.
בואו ננסה דניאל. אם לקמפל ולהריץ תכנית זו, זה עובד?
המספר >> מה זה אומר?
זה אומר השליטה מגיעה סוף הפונקציה שאינה מבוטלת.
כן, אז תן לי לנסות להפעיל אותו.
האם אתם ראיתם את זה קודם? אתה יודע מה זה אומר?
אוקיי, בואו ננתח את זה קצת.
זה אומר בfile.c על קו 9, העמודה 1 יש לנו טעות, בדיוק כמו שאתה אמרת,
וזה אומר שזה נובע מאזהרת השגיאה ואזהרת סוג התמורה.
זה נראה כמו משהו שקורה עם טיפוס ההחזרה, וזה הגיוני.
יש לנו פונקציה שאינה מבוטלת, מה שאומר שיש לנו פונקציה
שלא מחזיר מבוטל.
פונקצית חלל היא אחד שנראית כך:
החלל foo (), וזה בטל משום סוג ההחזרה הוא ריק,
מה שאומר שאם יש לנו משהו בפה
כמו בתמורה 1, הייתי מקבל שגיאת מהדר עבור זה.
עם זאת, יש לנו פונקציה שאינה מבוטלת.
הפונקציה הלא המבוטלת שלנו במקרה זה היא פונקצית החיפוש שלנו
כי יש לו סוג החזרה של bool.
כשזה אומר שהשליטה מגיעה לסוף הפונקציה שאינה מבוטלת,
זה בגלל שהחיפוש אינו קיים הצהרת תמורה.
זה לא חוזר שום דבר מהסוג bool.
>> אנחנו יכולים לתקן את זה, ומה שאתם חושבים
חיפוש צריך לחזור כברירת מחדל?
מה צריך להיות ערך החזרת ברירת המחדל של חיפוש?
כי זה מה שאנחנו יכולים לשים בסוף.
שרלוט, האם יש לך-?
אמת או שקר? >> אמת או שקר.
איזה מהם?
שקר. אני לא יודע.
שקר? בואו ננסה את זה.
למה את אומר את חזרת השווא? זה אינטואיציה רבה.
[שארלוט] אני לא יודע.
אנחנו הולכים לחזור שווא במקרה זה כי זה יהיה ברירת המחדל שלנו
אם מסיבה כלשהי הרשימה ריקה או המחט
שאנחנו מחפשים לא קיימים.
ואז ממש בסוף, אם לא מוקדם יותר בהחזר אמיתי בפונקציה זו,
אנחנו תמיד יודעים שהתפקוד הזה יגיד לא, זה לא במערך.
זה לא בערימת השחת.
עכשיו, אם אנחנו לקמפל ולהריץ אותו, תנו לי להציל את זה, כדי שנוכל למשוך אותו.
עכשיו, אם אנחנו לקמפל ולהריץ את התכנית שלנו, שהיא בונה.
אנחנו מקבלים את הפקודה הקטנה שלנו.
אם אני מכה 4-אוי.
זה לא להדפיס כל דבר. זה נראה כאילו כל מה שהסתיים בסדר.
אנחנו חייבים למלא את זה פנימה
דברנו על האלגוריתם בpseudocode קצת לפני.
תן לי לראות, לשמור את זה,
ואני אוציא אלגוריתם שאחזור שוב.
בואו פגענו בבחור הזה. לא.
זה מה שיש.
איך עושים את זה?
מה יהיה אסטרטגיה טובה להתחלה נכונה בקוד זה?
אתה צריך לבחור את המספר באמצע.
איך לבחור מספר באמצע מערך?
יש לך הצעות?
[סטודנטים] strlen חלק 2.
Strlen חלק 2. זה אחד גדול.
Strlen עובד עם סוגים מיוחדים של מערכים.
אילו סוגים של מערכים?
מערכי מחרוזות, מערכי אופי.
זה אותו הסוג של קונספט שאנחנו רוצים להחיל,
אבל אנחנו לא יכולים להשתמש strlen מכיוון שאין לנו מערך של תווים.
יש לנו מערך של ints.
אבל מה strlen לקבל עבורנו?
אתה יודע מה הוא מקבל עבורנו?
[סטודנטים] strlen מביא אותנו לכל אורך.
בדיוק, זה מביא אותנו לכל אורך.
Strlen מקבל אורך של המערך עבורנו.
>> איך אנחנו מקבלים את זה בתכנית החיפוש בינארי שלנו?
איך היית לקבל את אורך מערך?
[סטודנטים] strlen?
אתה יכול לקבל את אורך מערך מעוצב כהלכה C מחרוזת עם strlen.
הבעיה, אם כי, היא שאין לנו מערך מחרוזת.
אם אנחנו מסתכלים אחורה בקוד זה, יש לנו מערך השלם הזה.
איך אנחנו יודעים כמה זמן זה?
[סטודנטים] האם יש מקבילה לנקודת סיום 1, כמו שאני או משהו int?
מתברר למעשה הוא לא קיים, וזאת בדרך, זה
אחד מהדברים האלה שפשוט טובים לדעת על C,
כי אין דרך להשיג את אורך מערך
אם כל מה שאני נותן לך הוא המערך.
הסיבה שזה עובד עם מחרוזות, סיבת strlen עבודות,
משום שאם מחרוזת היא בפורמט מתאים,
זה יהיה \ 0 תו מיוחד שממש בסוף.
>> אתה יכול גם לדמיין אם יש לך מחרוזת כראוי מעוצבת
ואין \ 0 דמות שם, אז כל העניין לא עובד.
[סטודנטים] האם אתה יכול להוסיף את \ 0?
אנחנו יכולים במקרה זה.
אנחנו יכולים להוסיף איזה \ 0
או איזה סוג של מסמני אופי ולאחר מכן להשתמש בו.
אבל זה לא ממש הולך לעבודה
בגלל \ 0 הם לסוג char,
וכאן יש לנו ints.
הדבר השני הוא שאם היינו משתמש בערך מיוחד
כמו -1, כדי לסמן את סוף המערך
אז אנחנו לא יכולים לאחסן -1 במערכים השלמים שלנו.
אנחנו נתקענו.
מתבררת שהדרך היחידה להשיג את האורך
של מערך ב C היא למעשה לזכור את זה
כשאתה מגדיר את זה ולאחר מכן להעביר אותו מסביב עם המערך
כך שבכל פעם שיש לי פונקציה שהולכת לעשות קצת עבודה
על מערך של מספרים שלמים או מרחף או זוגות או מה יש לך,
אני גם צריך לתת לפונקציה של אורך המערך,
וזה בדיוק מה שעשינו כאן בפונקצית החיפוש.
אם אתה מסתכל, מה שאנחנו עשינו כאשר אנו עוברים במערך שלנו כאן,
אנחנו גם עוברים באורך, הגודל.
זה פשוט קורה כי יש לנו משתנה בשם זה פה,
פרמטר זה או ויכוח.
זה נקרא רשימה של פונקצית הטיעון או רשימת פרמטרים,
ואלה נקראים גם טיעונים או פרמטרים.
אנשים משתמשים במונחים שונים בזמנים שונים.
לפעמים אני להחליפם בעצמי.
זה פשוט כל כך קורה כי משתנה זה כאן בשם דומה
לזה # להגדיר עד כאן.
אבל הם לא אותו הדבר.
השווי כן קובע.
>> אם אתה מסתכל על מה שקורה כאן, אנו מצהירים
המערך שלנו int, שקראנו לי מספרים.
אנחנו נתנו לו הגודל שלנו, אשר תואם אותנו # להגדיר למעלה בקומה העליונה.
זה הולך להיות 8.
ואז, כשאז לקרוא לפונקצית החיפוש שלנו למטה,
אנחנו עוברים במספר שאנחנו רוצים לחפש, שאנחנו מתבקשים,
קבל מהמשתמש.
אנחנו עוברים במערך, מספרים זה,
ואז יש לנו גם לעבור בגודל של המערך,
ולאחר מכן את הערך של גודל 8 מאוחסן
או עבר לגודל משתנה שלם בשם זה.
יש לנו את גודלו של המערך.
עכשיו, אם לחזור למה שאנחנו מדברים עליו קודם לכן,
אני חושב שהמסים העלו את הטענה כי מה שאנחנו צריכים לעשות הוא לקבל את האורך של המערך
ולחלק אותו על ידי 2, ושייתן לנו את נקודת אמצע.
בואו נראים.
האם יש לי מישהו לכתוב את זה ולשמור אותו במרחב שלהם?
מה דעתך על ליילה?
האם יש לי שאתה כותב בזה?
לכתוב את השורה הראשונה שבו אתה לוקח את האורך של המערך ולקבל את נקודת האמצע
ולאחסן אותו במשתנה חדשה.
אני אתן לך כמה שניות. האם אתה מוכן?
[סטודנטים לא נשמעו]
בטח, יכולתי להיות לך לחשב את נקודת האמצע
של מערך ערימת השחת בתוך פונקציית החיפוש
שימוש באורך של מערך ערימת השחת, שהוא משתנה הגודל?
שום דבר לא מסובך כאן.
[ליילה] רק גודל / 2 ופשוט-
ולשמור אותו, ולחץ על הכפתור השמור עד כאן בחלקו העליון,
ואנחנו למשוך אותו.
מושלם.
הנה. מדהים.
>> כפי שהוא, יהיה זה לקמפל?
[ליילה] לא, זה צריך להיות גבוה יותר.
[נייט] כן, אז מה שאנחנו צריכים לעשות?
[ליילה] כמו נקודת אמצע או משהו int.
מדהים. כן, בואו נעשה את זה, int אמצע = גודל.
האם זה לקמפל?
בואו למחוק תגובה זו ולקבל את זה בדרך.
מה שלא יהיה לקמפל על זה?
אנחנו לא עושים שום דבר עם מספר שלם,
כך שאנחנו צריכים להדפיס אותו או משהו כזה.
כן, בדיוק.
אנחנו נקבל משתנים שאינם בשימוש.
מה עוד הוא לא הולך לעבוד על זה?
אני חושב שאמרת משהו, סם. פסיק.
כן, אני חסר פסיק אלה.
זה הולך להיות דבר קבוע לאורך המסלול של המונח.
הדבר האחרון שאעשה הוא אני אשים קצת חלל לבן משני הצדדים
של מפעיל זה כאן, מכיוון שזה בדרך כלל מה שאנחנו עושים
על פי מדריך הסגנון שלנו.
יש לנו את נקודת האמצע של המערך שלנו.
עכשיו, אם אנחנו זוכרים בחזרה לאלגוריתם שלנו,
מה היה הצעד השני שאנחנו צריכים לעשות ברגע שיש לנו את נקודת אמצע?
[סטודנטים] אם זה גדול יותר [לא ברור].
כן, אז יש לנו לעשות איזה השוואה, ומה שאנו משווים כאן?
אתה אמרת שאם הוא גדול מ. מה זה שבמשפט מתייחס?
המספר שעולה, אם זה גדול יותר מנקודת האמצע, ואז ללכת עד למערך?
בדיוק, כך המספר אשר עולה כאשר אנו-
המחט, ולכן אנחנו בהשוואה למחט,
ומה שאנו משווים נגד המחט?
בגלל המחט היא מה שאנחנו מחפשים.
אנחנו משווים את זה כדי להגיע לנקודת האמצע.
>> אבל האם זה הגיוני לבדוק
אם נקודת אמצע = מחט?
האם זה הגיוני?
האם מישהו לא מסכים?
בואו לנסות את זה, אם (מחט == נקודת אמצע).
[סטודנטים] האם printf שמצאו אותו.
[נייט] printf ("מצאתי אותו \ n");
אחרת, אני מתכוון להתחיל לעשות משהו שונה כאן.
אני הולך להתחיל לשים פלטה סביב אם הצהרות כל הזמן
רק בגלל שאם תוסיפו יותר דברים, ולאחר מכן
אנחנו לא מקבלים את המהדרים.
כן, סם. יש לך נקודה.
הבעיה היא שנקודת אמצע מייצגת עמדה במערך,
אבל אתה יכול לקבל את זה כדי לייצג את הערך שבעמדתו של המערך.
זו נקודה מצוינת.
האם כולם שומעים את מה שאמר סם?
הוא אמר שנקודת האמצע היא כ
מייצג רק את העמדה במערך, אבל זה לא המרכיב הממשי במערך.
אם אתה חושב על הקוד כפי שנכתב ממש עכשיו,
אם נסתכל על המערך הזה כאן למטה, שבו יש 8 אלמנטים בזה,
מהו הערך של נקודת האמצע הולכת להיות בתפקיד הזה?
[סטודנטים] 4.
[נייט] 4.
אם נסתכל למספר 4 -
ואנחנו רק יכולים להפעיל את הקוד הזה ולשים פרצוף עצוב מעט בכאן
כי אנחנו לא מוצאים אותו, אם אנו מפעילים את הקוד הזה
כמו עכשיו, העלאתו, בניין, שלא לגלול אותי,
אם אנחנו מחפשים את המספר 4 ו,
אנחנו מצאנו אותו, אבל אנחנו לא מקבלים את זה לprintf כן.
אחת סיבות לכך הן שאנחנו לא החזר אמיתי,
אבל אנחנו באמת למצוא את מספר 4?
וסם אומר לא.
מה מצא?
אנחנו באמת מצאנו את נקודת האמצע, שאם יסתכלו על המערך כאן למטה,
זה הולך להיות האלמנט בעמוד 4 שאנחנו מסתכלים,
שהוא 23.
>> איך אנחנו בעצם מקבלים אלמנט שבנקודת האמצע
ולא רק את נקודת האמצע עצמו?
[סטודנטים] היינו נכנס char או משהו?
מה שהיה עושה, פשוט מתוך סקרנות?
האם אתה יכול לפרט קצת יותר?
אתה צריך לשנות את המיקום למספר,
כך שאתה חייב ליצור קשר כלשהו, ​​אני חושב שזה char, אבל זה לא יכול להיות.
כן, זה נקודה טובה.
אנחנו כבר עושים הרבה עמדות המרה זה לתווים, תווים אלה,
בשתי קבוצות הבעיה הראשונות.
מתברר כי כאן, זה כמעט דומה ל
גישה לתו ה-i במחרוזת, אם זה נשמע הגיוני.
כאן אנו רוצים לגשת לאלמנט נקודת האמצע.
איך עושה את זה?
קווין, האם יש לך הצעות כיצד תוכל לעשות זאת?
אתה יכול לעשות את ערימת שחת, סוגר פתוח, באמצע, סגר את הסוגר.
האם אתה יכול לכתוב את זה בשבילנו?
שמור אותו בכאן, ואנחנו למשוך את זה.
אנחנו מסתכלים על קו 9 זה,
ואנחנו מבינים שאנחנו לא רוצים להשוות את המחט למרכז,
אבל במקום זה, אנחנו רוצים להשוות את המחט
לאלמנט באמצע המיקום בתוך מערך ערימת השחת שלנו.
מגניב.
הנה.
כן, זה נראה די טוב, אם (מחט בערימת שחת == [אמצע]).
אנחנו מצאנו אותו.
עכשיו אם אנחנו רצים בחזרה קוד להכין מלמעלה קצת-
זה הידור, שהיא פועלת, ועכשיו אם אנחנו מסתכלים על 4,
לא מצאנו את זה כי עכשיו אנחנו למעשה מקבלים את המספר 23.
אנחנו מקבלים את הערך 23, וזה מה שאנחנו משווים למחט שלנו.
אבל זה טוב. זה צעד בכיוון הנכון.
>> זה מה שאנחנו מנסים לעשות.
אנחנו לא מנסים להשוות את המחט נגד עמדות במערך
אלא נגד הגורמים בפועל במערך.
אם נסתכל שוב עכשיו בשלב הבא באלגוריתם שלנו,
מה הצעד הבא?
ליילה כבר הזכירה את זה בקצרה.
[סטודנטים] בדקו אם זה גדול יותר או קטן יותר ואז להחליט לאיזה כיוון לנוע.
[נייט] כן, אז איך אנחנו עושים את זה?
האם אתה יכול לשים בחלק-I'll לחסוך גרסה זו,
ואז אם אתה מכניס כמה שורות שתעשינה את זה.
כן, שרלוט. >> יש לי שאלה.
לא היה צריך להיות נקודת אמצע - 1 כי הדבר הראשון הוא
זה 0 אינדקס, כך שאם אנחנו שמים 4, זה לא ממש האופי שאנחנו מחפשים?
כן, ובעיה האחרת עם שהוא
זה מציאה גדולה, כי מה שקורה בסופו קורה אולי
אם להמשיך לנוע ואנחנו אף פעם לא להתאים בתחילה?
אני מניח מה שעשוי בסופו של דבר עושה מנסה לגשת
האלמנט בעמדה 8 של המערך,
שבמקרה זה לא קיים.
אנחנו רוצים לעשות איזה חשבון את העובדה
כי יש לנו כמה אינדוקס אפס.
[שארלוט] סליחה, התכוון אמצע - 1 בסוגריים המרובעים.
אנחנו יכולים לעשות את זה.
אנחנו נחזור לנושא הזה בקצת.
ברגע שנתחיל להגיע לlooping בפועל,
זה הרגע שבי אנחנו באמת רואים את זה בא לידי הביטוי.
לעת עתה, אנחנו יכולים לעשות את זה, אבל אתה לגמרי נכון.
כי אינדקס אפס יהיה השפעה שאנחנו צריכים להסביר.
בואו נראים.
>> איך הוא גדול יותר ופחות מ-?
[סטודנטים] אני מקבל איך לעשות יותר ומחלק פחות.
אני רק לא היה בטוח מה להדפיס אם אתה מוצא שזה פחות מנקודת אמצע ערימת השחת או גדול מ.
כאן אני יכול לשמור את מה ברצינות,
[נייט] כן, אם אתה שומר את מה שיש לך, ואנחנו נמשוך אותו.
הנה.
[סטודנטים] ושמתי סימני שאלה על מה שאני לא יודע.
[נייט] זה נראה נהדר.
כאן יש לנו סימני שאלה כי אנחנו עדיין לא יודעים
מה שאנחנו הולכים לעשות מאוד עדיין.
מה היינו רוצה לעשות, אופס, יש לנו כמה פלטות כל פאנקי עלינו.
אנחנו לתקן פלטות אלה.
הנה.
ואז מה שאנחנו רוצים לעשות, על פי האלגוריתם שלנו,
אם אנחנו לא מוצאים את המחט?
תגיד במקרה שהמחט היא פחות ממה שאנחנו מסתכלים. קווין.
מסתכל רק על חיצו השמאלי.
טוב, אז ישים את תגובה בכאן שאומרת "להסתכל על חיצו השמאלי."
ואם המחט גדולה מערימת השחת בנקודת האמצע, מה אנחנו רוצים לעשות?
[סטודנטים] ואז אתה מסתכל מהצד הימני.
תראה את החצי הימני, "יסתכל על מחציתו הימנית."
גם בכלל לא רע.
אוקיי, אז בנקודה זו, דברים נראים טוב למדי.
הבעיה עם הקוד שנכתב היא מה?
[סטודנטים] אתה לא צריך נקודתי קצה לחצאים.
נכון, אין לנו נקודתי קצה לחצאים.
אנחנו גם רק הולכים לעבור פעם אחת את זה.
אנחנו רק הולכים להסתכל על נקודת אמצע אחת.
כך או הרכיב הוא שם, או שזה לא.
כדי להשלים את זה, יצטרך לעשות איזה חזרה.
אנחנו צריכים לחזור שוב ושוב עד שנמצאנו כי
אם הרכיב הוא שם כי יש לנו הצטמצמתי ולבסוף מצאתי אותו,
או שהוא לא שם כי אנחנו בדקנו דרך כל הדברים
בחצי המתאימים של המערך ומצא כי דבר הוא לשם.
>> בכל פעם שיש לנו חזרות זה קורות, מה אנחנו הולכים להשתמש?
[סטודנטים] לולאה.
איזה לולאה. כן.
[סטודנטים] אנחנו יכולים לעשות עשו תוך לולאה ויש לו לעשות את זה ואז בזמן
המחט לא שווה, אני לא בטוח לאן אני הולך עם זה.
אבל כמו סוג של לעשות את זה כל עוד זה לא שווה הערך שקלט המשתמש.
כן, אז בואו נראים, איך זה יכול לכתוב את עצמו?
את אמר לי להשתמש עשה תוך לולאה.
מאיפה מתחיל?
[סטודנטים] מייד לאחר הגודל / 2.
[נייט] אוקיי, ומה אנחנו הולכים לעשות?
אנו נמלאים בזמן מאוחר יותר.
מה אנחנו הולכים לעשות?
[סטודנטים] האם אנחנו לא רוצים לעשות את כל הדברים שיש לנו באם החלק?
[נייט] האם כל החומר הזה, גדול.
העתק ודבק.
הו, בן אדם.
בואו נראה אם ​​זה עובד, אם תוכל כרטיסייה על זה.
יפה.
אוקיי, ואנחנו חוסכים את זה כל כך יש לכם את זה.
בסדר, ואנחנו הולכים לעשות את זה בזמן,
מה היה המצב בזמן שהיית אחרי?
[סטודנטים] בזמן שהמחט אינה שווה, ולכן כמו הסימן הקריא.
אבל אני לא בטוח בדיוק מה זה עדיין.
[נייט] כן, זו דרך אחת לעשות את זה.
סם, יש לך הערה?
[סם] נזכרתי שכשהסתכלתי על סרטוני וידאו,
לקחתי את צילום מסך של אחד כמו כשעשינו pseudocode לזה,
יש קשר כלשהו בין מקס ודקות.
אני חושב שזה היה משהו כמו אם המקסימום הוא אי פחות מ דקות.
קבל אותו.
[סם] או כמו אם המקסימום הוא לא פחות מ דקות או משהו כזה,
כי אז זה אומר שאתה כבר חפשת הכל.
>> כן, אז מה זה נשמע כמו מקס ודקות היו מתייחסים?
[סם] ערכים ש- מספרים שלמים כי הם הולכים לשנות
יחסית למקום בו אנו שמים את נקודת האמצע.
בדיוק.
[סם] בשלב זה, זה הולך [לא ברור] לחשב את המקסימום ודקות.
נקודת אמצע היא זה מקסימום ורעיון דקות.
האם זה הגיוני לאנשים?
אם היינו מתחיל להסתכל על איך אנחנו הולכים לעשות איטרציה זו,
אתה לגמרי נכון שאנחנו רוצים להשתמש בסוג מסוים של לעשות-תוך לולאה.
אבל אני מניח שאם אזכור מה קורה בנקודה של מערך זה
ומה בעצם קורה, אני הולך לכתוב פה,
באיטרציה הראשונה של חיפוש בינארי, יש לנו,
אני הולך להשתמש ב ודואר כדי לציין את ההתחלה.
ואז בסוף המערך שלנו.
אנחנו יודעים שהיא בתחילת 4 ממש כאן,
ואנחנו יודעים שהם בסופו של דבר 108.
אומר שאנחנו מחפשים את המספר 15.
הפעם הראשונה שאנחנו עושים את זה, כמו שראינו קודם,
נקודת האמצע היא גם הולכת להיות 16 או 23
תלויים איך מחשבים את הדברים.
מאז באופן שווה חלוקה באמצע היה נותנת לנו המרחב הזה
בין 16 ו 23, אנחנו לא יכולים לחלק אותו שווים בשווים
או לחלק אותו ולהגיע אל נקודת אמצע נכונה.
אנחנו נסתכל על 16.
אנחנו נבין "היי, 16> 15 שאנחנו מחפשים".
אז להסתכל על חיצו השמאלי של המערך
מה שנקבל בסופו של דבר עושה הוא שלכת
כל חלק עליון זה
ואמר, "בסדר, עכשיו נקודת הסיום שלנו הולכת להיות כאן."
איטרציה הבאה של הלולאה שלנו, אנחנו מסתכלים עכשיו מערך זה,
יעילות שהושלך חלק זה כי עכשיו
אם אנחנו לוקחים את נקודת האמצע כדי להיות ההבדל בין ההתחלה והסוף,
אנו מוצאים נקודת האמצע שלנו להיות 8,
אשר לאחר מכן יכול לבדוק 8 כדי לראות איפה הוא ביחס למספר שאנחנו מחפשים,
15, מוצא ש15 גדול,
לכן יש לנו כדי לעבור לחלק הימני של הרשימה,
אשר אנו יודעים כי אנחנו בני אדם, ואנחנו יכולים לראות את זה.
אנחנו יודעים שהחלק הימני הולך להיות בו אנו מוצאים אותו,
אבל המחשב לא יודע את זה, אז מה שנעשינו הוא שנהיה בפועל
שזה יעלה, ועכשיו התחלה והסוף
הן באותה הנקודה, ולכן נקודת האמצע הופכת את המספר רק ברשימה בשלב זה,
שהוא בן 15, ואנחנו כבר מצאנו את זה.
האם זה לשפוך קצת אור על איך כל זה המקסימום וסימון דקות הולכים,
שמירה על מסלול של נקודתי הקצה של המערך כדי להבין
כיצד לצמצם את הדברים?
>> מה יקרה אם זה לא היה שווה 15 עכשיו?
מה אם אנחנו מחפשים 15 ובמקום זאת, המספר הזה היה גם 16?
היינו אומרים, "אוי, זה גדול.
אנחנו רוצים לחזור לשמאל ".
ואנחנו נעביר את הדואר שלנו בצד ימין,
ובשלב זה יש לנו נקודת סיום שיהיה סותר.
זה לא יהיה מסוגל לחפש כל אלמנטים נוספים
כי עכשיו יש לנו נקודת הסיום שלנו ואת נקודת ההתחלה שלנו,
המקסימום שלנו והדקות שלנו, עכשיו התהפכו.
אנחנו חיפוש בכל המערך. אנחנו לא יכולים למצוא שום דבר.
זו נקודה שבה היינו רוצה לומר, "טוב, אנחנו הולכים לעצור את האלגוריתם הזה.
לא מצאנו שום דבר. אנחנו יודעים שזה לא לכאן. "
איך זה קורה?
[סטודנטים] איך בדיוק עושה את המחשב לעבור לסוף?
כיצד הסיום אינו בסופו של לפני ההתחלה?
הסוף מסתיים לפני התחילה
בגלל המתמטיקה שאנחנו הולכים לעשות בכל פעם שאנחנו עושים את זה.
הדרך בה אנו מחליפים היא אם אתה מסתכל בפעם הראשונה שאנחנו עושים עסקה זו
שם יש לנו בתחילת 4 וסופו של דבר
כל הדרך למטה ובאמצע 108, למשל, בגיל 16 -
אני הולך לאפס את זה בחזרה 15-אם אתה מחפש 15,
ידעתי שמה שעשינו כשבדקנו 16 וראו שזה היה גדול יותר
ורציתי לבטל את כל החלק הימני של הרשימה,
ראינו כי מה שרצינו לעשות הוא להעביר דואר זה ממש כאן.
ביעילות, עבר לדואר קבל אחד לפני האמצע.
כמו כן, כשעשינו חזרות זה של האלגוריתם
ונקודת האמצע הייתה בשעת 8,
מצאנו כי 8 <15, אז רצינו לעבור ב
1 עבר נקודת האמצע.
עכשיו, את ההתחלה וסוף שניהם ביחד בזה 15.
>> אם הייתי קורה לחפש ערך אחר, ולא 15,
או אם זה היו 15 במקום 16,
היינו מוצא שהדואר אנחנו רוצים להעביר אחד לפני האמצע.
עכשיו הדואר יהיה שם התהפך פחות מ b.
הבה ללכת דרך איך אנחנו בסופו למעשה קידוד אלגוריתם זה.
אנחנו יודעים שאנחנו רוצים שנהיה לי חישוב נקודת האמצע הזה.
אנחנו יודעים גם שאנחנו רוצים לעקוב אחר ההתחלה והסוף של המערך
של המערך הנוכחי שלנו, כך שנוכל להבין
שהמחצית שמאלית זו של הרשימה היא ואיפה במחצית הימנית של הרשימה היא.
אנחנו עושים את זה עם כל אחד מתחיל ומסתיים,
או שאנו יכולים לקרוא להם דקות ומקסימום.
אני אשתמש מתחיל ומסתיים שלב זה.
כאשר אנו מתחילים, אם אנחנו מסתכלים אחורה בדוגמא שלנו כאן למטה,
ההתחלה שלנו הייתה מוגדרת מאוד בהתחלה של המערך, כטבעי.
מה היה מדד זה? מה שלנו צריך להתחיל להיות?
דניאל.
[דניאל] שחת [0].
[נייט] כן, כדי שנוכל להגדיר אותו שווה לערימת שחת [0].
הבעיה, אם כי, היא שזה לא נותן לנו את מיקומו של היסוד הראשון.
זה נותן לנו המדד של הרכיב הראשון או הערך הממשי שבמקום הראשון.
[סטודנטים] זה יהיה להמיר ל.20?
[נייט] מה זה יעשה הוא, טוב, זה לא יעשה את כל המרות.
מה זה יעשה לו זה יהיה לאחסן 4 במתחיל,
ואז זה יהיה קשה לעשות השוואות נגד להתחיל
כי בגין יקיים את הערך של 4,
המהווה את תחילתו של המערך שלנו,
אבל אנחנו רוצים לעקוב אחר המדדים במערך
בניגוד לערכים.
אנחנו בעצם נשתמש 0, ככה.
לסוף מערך שארלוט הביא את זה קצת יותר מוקדם.
זה המקום בו אנו לוקחים בחשבון את אינדקס אפס.
>> שרלוט, מה זה הסוף של המערך?
מהו המדד של הסוף?
[שארלוט] גודל - 1.
כן, ושגודל אנחנו צריכים להשתמש?
האם עלינו להשתמש בגודל הון או גודל אותיות קטן?
גודל הון.
במקרה זה, אנחנו יכולים להשתמש בגודל הון.
אם רציתי בפונקציה זו כדי להיות ניידת
ולהשתמש בפונקציה זו בתוכניות אחרות,
אנו יכולים להשתמש בגודל קטן.
זה גם בסדר.
אבל שרלוט היא לגמרי נכונה שאנחנו רוצים שנהיה לי גודל - 1.
בשלב זה,
[סטודנטים] איך זה שאתה יכול להשתמש בגודל אותיות גדולים?
איך זה שאנחנו יכולים להשתמש בגודל אותיות גדולים?
מתברר כי אלה הם באמת מגדירים #,
מתחת למכסת המנוע, טקסט כמו חיפוש והחלפה, אם זה נשמע הגיוני.
כשאתה לקמפל את הקוד שלך, שלב preprocessing
של המהדר עובר את הקובץ,
וזה נראה לכל מקום שאתה כתבת גודל הון,
והוא מחליף טקסט מילולי עם 8, סתם ככה.
במובן זה, זה מאוד שונה ממשתנה.
זה לא לוקח את כל מקום בזיכרון.
זה טריק החלפת טקסט פשוט.
במקרה זה, אנחנו הולכים להשתמש בגודל.
מכאן אנו רוצים לעשות איזה חזרה,
ואנחנו בדרך הנכונה עם עשה תוך הלולאה שלנו.
אנחנו רוצים לעשות משהו עד שמצבו אינו מחזיק יותר,
וכפי שראינו קודם, ראה שזה מצב
אכן היה שאנחנו לא רוצים את הסוף
להיות פחות מלהתחיל.
>> זה תנאי העצירה שלנו.
במקרה זה, אנחנו רוצים לעצור ולהכריז כמו: "היי, לא מצאנו שום דבר."
כדי להביע את זה, אל רוצים להשתמש בסוג מסוים של לולאה.
במקרה זה, זה יהיה עשה תוך לולאה, ללולאה, לולאה בזמן?
יש לנו עשה תוך לולאה כאן.
האם אתה חבר 'ה כמו שהגישה?
האם אתה חושב שאנחנו צריכים לנסות גישה שונה?
קווין, כל מחשבות?
אנחנו יכולים להיות לולאה בזמן, כי אנחנו יודעים מרביים
יהיה גדול יותר דקות בכל מקרה ההתחלה.
כן, כך שאין אתחול שצריך לקרות.
לולאותיהן עשה תוך נהדרות כאשר יש לך משהו כדי לאתחל
לפני כן בדיקה, ואילו כאן
אנחנו יודעים שאנחנו לא מתכוונים לשמור reinitializing הן מתחילות ומסתיימות
בכל סיבוב של הלולאה.
אנחנו יודעים שאנחנו רוצים לאתחל אותם, ואז לבדוק את המצב שלנו.
במקרה זה, אני בעצם ללכת עם לולאה פשוטה.
מתברר כי לולאות לעשות-בעוד משמשות למדי לעתים רחוקות.
הרבה מקומות אפילו לא מלמדים לעשות בשעת לולאות.
הם טובים לטיפול בקלט משתמש, כך שראינו הרבה מהם עד כה.
אבל נורמלי ואילו לולאות הן הרבה יותר נפוץ.
מתברר שמצב זה כפי שנכתב
ממש לא עושה לנו הרבה טוב, ולמה זה?
אני מצטער, אני לא יודע את שמך.
אני ג'רי. >> מצטער?
זה B-O-R-U-.
אה, אוקיי.
אני לא רואה אותך ברשימה שלי.
אה, זה בגלל ש- הו, זה הגיוני.
האם יש לך מושג למה לולאה בזמן זה עלולה שלא לפעול כמתוכנן,
כפי שנכתב עם המצב?
[ג'רי] אתה מתכוון כמו שאתה רוצה את כל הדברים אחריו לתוך-?
כן, אז זה אחד.
יכול להיות שנצטרך לשים את כל החומר הזה ללולאה בזמן, שהוא לגמרי נכון.
הדבר השני שזה קצת יותר בעייתי, אם כי, הוא שמצב זה לא עובד.
[סטודנטים] אתה צריך להעיף אותו.
בסדר, אז מצב זה אף לא אהיה נכון בתחילה כמו שדברנו על זה.
אנחנו רוצים לעשות משהו עד <הסוף מתחילים,
אבל אנחנו רוצים לעשות משהו בזמן
תתחיל ≤ הסוף.
>> יש היפוך של ההיגיון שם.
אני אשם בטעויות האלה כל הזמן.
[סטודנטים] למה זה צריך להיות פחות או שווה ל?
כי אתה זוכר את המקרה שהגענו ל
שם היה רק ​​מרכיב אחד, ואנחנו היינו למטה,
ואנחנו מסתכלים רק 15 במערך שלנו?
וההתחלה שלנו והסוף שלנו היו אותו היסוד.
אנחנו רוצים לוודא שאנחנו מטפלים במקרה זה.
אם הייתי עושה ישר פחות מ,
היינו יכול לרדת למערך 2-אלמנט היחיד.
ברגע שהגענו עד שהאלמנט האחרון, אם זה היה עיקרון היסוד שלנו, לא הייתי מוצא אותו.
עכשיו הוא כאן, אנחנו יכולים לעשות בדיוק כמו שאמרתם.
אנחנו יכולים להתחיל נושרת חומר נכון לאמצע הלולאה בזמננו.
אנחנו יכולים פלופ בנקודת האמצע שלנו.
אנחנו יכולים לקחת את כל אלה אם ההצהרות,
למשוך אותם מעשה תוך הלולאה הזו,
פלופ ב,
לנקות את הדברים קצת קטן,
ואני אמשיך הלאה ולשמור גרסה זו.
ובנקודה הזאת, אנחנו מקבלים די קרובים.
סם.
אני חושב שאתה גם צריך שיהיה לי אמצע int = גודל - 1/2.
קבל את זה, גודל - 1/2.
האם יש עוד משהו שאנחנו צריכים לשנות על אותה השורה?
זה היה שידוך טוב.
>> מה גודל עושה? האם אי פעם שינוי גודל?
על מנת לשמור על הקו כזה, אנחנו צריכים לשנות את הגודל.
אנחנו צריכים לשנות את הגודל בכל פעם שאנחנו הולכים מסביב ללולאה.
אבל זוכר שהיו הולכים דרך הדוגמא שלנו רק קצת מוקדם יותר,
והיו לנו התחלה בשעת 4
וסופו של דבר כל הדרך ב 108?
איך לחשב את נקודת האמצע?
האם הייתי משתמש בגודל?
או שהיינו באמצעות מתחיל ומסתיימים במקום זה?
זה הבדל בין הסוף וההתחלה.
בדיוק, ואיך בדיוק אני צריך לכתוב את זה, שרלוט?
רק בסוף - להתחיל.
לא היית צריך לעשות - 1
משום - 1 נכלל בסופו של דבר ולהתחיל עם זה כבר.
[נייט] גדול, את לגמרי נכון.
אנחנו לא צריכים לעשות - 1 משום ש-- 1 נכלל
והיוויתי כאשר אנו לאתחל את משתנת הסוף.
>> האם יש עוד משהו שאני צריך לעשות מבחינה תחבירית יש קו זה הגיוני?
[סטודנטים] פלוס מתחילה. >> פלוס להתחיל?
[סטודנטים] בסוף.
כי הוא מחושב כמחצית האורך בלבד.
אתה צריך להוסיף להתחיל.
[נייט] מה זה לחשב עבורנו?
אם אנחנו חושבים על הסוף באיטרציה הראשונה של הלולאה,
הסוף הולך להיות בעמדת הראשים 7.
בגין הוא בעמדה 0.
זכרו, אנחנו מחפשים שני
עמדה 3 או עמדה 4.
אם נסתכל על זה במתמטיקה, רק כדי לעשות את זה קצת יותר מוחשי,
לשים כמה מספרים כאן, יש לנו 7, 0,
כך 7-0, ולאחר מכן / 2
הוא 3 בחטיבה שלמה, כי הוא.
ואז אנחנו צריכים אז להוסיף חזרה להתחיל?
אנחנו לא במקרה הזה.
באיטרציה הראשונה, זה יהיה בסדר, כי בגין הוא 0.
אבל כמו שאנו מתקדמים, אנו עושים באמת הכילו רק צריכים
הסוף - מתחילים / 2.
יש טריק אחד אחר כאן, וזה אחד מכלומר קדימות.
[סטודנטים] האם אנחנו צריכים סוגריים?
[נייט] בדיוק, וזה בגלל שאם לא לשים הסוגריים האלה,
אז הקו הזה יתפרש במקום
כ( סוף) - (מתחילים / 2), שאנחנו בהחלט לא רוצים.
תיזהר כללי קדימות אלה.
[סטודנטים] מדוע לא יסתיים + להתחיל?
למה זה לא יסתיים + להתחיל?
[סטודנטים] למה זה לא כך?
למה שזה יהיה +?
אני חושב שאתה צודק.
[סטודנטים] כי זה ממוצע?
[נייט] סיום + להתחיל, את לגמרי נכון.
וואו, אני לגמרי פשלתי. אתה צודק.
אם היינו עושים פחות, הייתי רוצה להוסיף את מתחיל בחזרה פנימה
במקרה זה, שאתה מאוד נכון שאנחנו רוצים לקחת את הממוצע של שניים,
אז אל רוצים להוסיף אותם, בניגוד ללחסר אותם.
[סטודנטים] זה גם הייתי עובד אם הייתי עושה סוף - מתחילים / 2 + להתחיל.
אראה, אם אנחנו עושים, אני מאמינים שכן.
>> לדוגמה, אם אנחנו מסתכלים להתחיל,
ואנחנו עברנו על זה כאן
ל15.
עכשיו מתחילים הוא בעמדה 2.
סיום הוא בעמדה 7.
אם נתעלמתי מהם, אנחנו מקבלים 5.
מחלק כי על ידי 2, אנחנו מקבלים 2.
ואז להוסיף 2 בחזרה,
וזה מביא אותנו לעמדה 4,
שנמצא ממש כאן, שהוא נקודת האמצע.
[סטודנטים] האם אנחנו צריכים לדאוג לעטיפה?
באיזה מובנת אנחנו צריכים לדאוג לעטיפה?
אם הסכום או את ההבדל בין
תלויה איך אנחנו עושים את זה הוא לא מספר זוגי.
אז המחשב מתבלבל אם כאשר זה 2.5;
אתה לעבור לשמאל או לימין כדי לקבוע אילו הוא נקודת האמצע?
קבל אותו.
מתברר שעם חטיבה שלמה,
אנחנו אף פעם לא מקבלים מספרי הנקודה צפו אלה.
אנחנו אף פעם לא מקבלים העשרוניים.
זה נזרק לחלוטין.
אם יש לך מחשב לחלק את שני משתני int,
ואחת הוא 7, והשני הוא 2,
אתה לא תקבל 3.5 כתוצאה מכך.
הוא יקבל 3.
היתרה תימחק, כך שזה למעשה עיגול
לא עגול אלא רצפה, אם אתם מכירים שבמתמטיקה,
שבו אתה זורק עשרוני לחלוטין,
ואז אתה בעצם מקצר אותו למוקד
כל עמדה, למספר השלם הקרוב ביותר.
[סטודנטים] אבל אז זה בעייתי, כי אם יש לך מערך של 7 אלמנטים
אז באופן אוטומטי שלוקח את האלמנט 3 מתוך נקודת אמצע במקום 4.
איך מתמודדים עם זה?
זה בעייתי, כי אם היה לנו מערך של 7,
זה יהיה לאסוף 3 במקום 4.
אתה יכול להסביר קצת יותר?
[סטודנטים] כי אם יש לך 7 אלמנטים אז אלמנט 4
יהיה נקודת האמצע, נכון?
זכור את התגובה שלך על להיות אפס באינדקס, אם כי.
[סטודנטים] כן, אז בעמדה 3. זה יהיה נקודת האמצע.
כן.
אה, אוקיי. אני מבין למה אתה מתכוון.
זה קצת מוזר, כמו שאנחנו מתרגלים לכל הרעיון הזה של
להיפטר משברים עשרוניים.
זו נקודה מצוינת.
בואו נסיים את זה.
חשבנו נקודת האמצע שלנו.
>> אנחנו בודקים כדי לראות אם המחט שלנו שווה לערך האמצעי.
אנחנו מדפיסים שמצאנו אותו, אבל באמת, מה אנחנו רוצים לעשות במצב כזה?
אנחנו כבר מצאנו את זה, ולכן אנחנו רוצים לתת למתקשר לדעת שמצאנו אותה.
יש לנו תפקיד זה פונקציה שהוקלדה בוליאני.
הדרך בה אנו לאותת למתקשר של הפונקציה שלנו שאנחנו מוכנים ללכת
הוא שאנו אומרים, "היי, זה נכון."
איך הייתי עושה את זה, קווין?
אתה מהנהן בראש שלך. >> שיבה [קווין] הוסף אמיתי.
[נייט] בדיוק, החזר אמיתי.
עכשיו, אם זה לא שווה, איך אנו מסתכלים על המחצית השמאלית?
יש לך רעיונות?
סטלה, לך רעיונות?
אתה צריך להגדיר מיקום חדש לסוף.
כן.
אז יש לנו לעשות עמדה של אמצע - הסוף.
גדול.
אנחנו צריכים לקבוע עמדה חדשה לסיום
להסתכל על חיצו השמאלי.
זה היה על מה דבר לפני שבו
אני ממשיך לחזור לדוגמה זו.
אני אתחיל כאן, ואז יש לי בסוף כל הדרך לכאן.
>> שוב, אם אנחנו מחפשים 15, ונקודת האמצע שלנו היא בגיל 16,
ואנחנו מבינים, "אופס, 16 הם גדולים יותר.
אנחנו רוצים לעבור לצד שמאל. "
הייתי אז להעביר את הסוף ל15,
ואנחנו עושים את זה על ידי לקחת את אחד מנקודת האמצע
וקביעה כי כסיום החדש שלנו.
כמו כן, אם אנחנו רוצים להסתכל על החץ ימינה, איך אנחנו עושים את זה?
האם יש לך רעיון?
[סטודנטים] אתה פשוט להגדיר מתחיל אמצע + 1.
[נייט] גדול.
ועכשיו במקרה שאנחנו לא מוצאים שום דבר,
זה מביא את לטפל בכך עבורנו?
דניאל, זה מביא את המטופל ל?
[דניאל] מס
[נייט] אם אנחנו עושים את זה דרך כל המערך ואנחנו לא מוצאים שום דבר,
איפה הייתי שאטופל, או שעל לטפל בזה?
[דניאל] המצב בזמן.
[נייט] כן, המצב בזמן, בדיוק.
זה ידאג לעובר כל המערך אם אנחנו לא מוצאים שום דבר.
לולאה בזמן זה תסתיים.
אנחנו לעולם לא נתקלנו במצב זה,
ואנחנו יכולים לחזור שווא.
אנחנו גם יכולים להשאיר את זה, אם כך לכאן
כי אם זה אם הטענה נכונה,
והפונקציה שלנו תחזור,
ואז אנחנו בעצם להפיל זה פונקציה בנקודה זו
כשנחזור נכון.
אבל מה קורה עם המבנה הזה כאן?
האם זה עובד לחלוטין, או שיש איזה פגם לוגי שם?
>> יש איזה פגם לוגי לשם, בדרך שבה הם מאורגנים.
מה יכול להיות?
[סטודנטים] למה אתה צריך - ו+ 1s?
שמגדיר המערך שלנו עד למחצית השמאלית שלנו החדשה והחצי נכון.
[סטודנטים] אבל למה לא יכל לעשות את זה בלי - 1s ו+ 1s?
[נייט] אנו יכולים להגדיר אותו שווים לנקודת האמצע?
מה יכול להיות בעייתי בזה?
[סטודנטים] אני מניח שזה לא יעיל, כי אתה בודק ערך שכבר בדק.
[נייט] בדיוק, כדי שסם הוא לגמרי נכון.
אם תגדיר את הסוף ומתחיל שווה לנקודת האמצע
במקום - 1 + 1 ומהורהר,
בשלב מסוים בעתיד, בסוף עוד בדיקת האמצע שוב.
[סטודנטים] התחלתי pset, ולאחר מכן היה לי משהו כזה
איפה שכחתי + 1, והוא היה נתקע בלולאה אינסופית.
נכון, כי בשלב מסוים אתה לא הולך לקבל מתחיל ומסתיים
למעשה חופף.
מגניב.
יש פגם לוגי אחד יותר, וזה שזה בהחלט צריך להיות
אם אחר.
למה זה יכול להיות?
>> הסיבה היא שאם זה לא אחר אם לא, אתה רואה את זה, קווין?
[קווין] כן, כי אתה משנה את נקודת הסיום.
[נייט] בדיוק.
אנחנו משנים את נקודת הסיום,
ואם זה כתוב כמו להכין מזה לעשות רווחים בין
זה יהיה לבדוק את המקרה הזה.
במקרה זה, אם היא תצליח, יצא להפלה של הפונקציה.
ואז זה יהיה לבדוק המקרה הבא,
ואם זה יצליח, זה יהיה להתאים את נקודת הסיום,
ואז זה ימשיך הלאה ולבדוק מקרה זה.
אך בשלב זה, אנחנו לא רוצים שזה ימשיך לבדוק.
למרבה המזל, יש לנו לא לאפס את נקודת האמצע כאן,
ואנחנו יודעים שמקרה זה לא יצליח.
אבל אנחנו בהחלט רוצים לשים אחרים אם יש ב
למרות שאולי במקרה הזה,
מאז אנחנו לא התאמנו את נקודת אמצע, מה זה משנה?
לא, משום שמקרים אלה הם כל בלעדיים.
שוב, שלי רע.
אנחנו לא, אני חושב, צריכים אחר זה אם.
אנחנו יכולים לתת לו לנסות ולהפעיל אותו ולראות מה קורה.
בניין, אירע שגיאה.
זה כנראה בגלל שהשארתי אותם ב של דואר ושל כאן.
האם יש לי יותר מאלו למעלה בחלק העליון?
זה לא נראה כמותו.
אנו להתרחק, לבנות,
שם זה הולך, אז עכשיו אם תחפש ל15,
כן.
בואו להתקרב פנימה
15, כן. אנחנו יכולים להפעיל אותו שוב.
מעלה את קוד מקור, בנייה, הפעלה.
אנחנו יכולים לחפש משהו כמו 13,
ואנחנו לא מקבלים שום דבר בהדפסה, כך שזה לא מוצא את זה בשבילנו.
זה נהדר, כי זה לא ברשימה שלנו.
>> אנו נמצאים כעת מחוץ לזמן.
זה הולך להיות אותו לשבוע הזה.
תודה שהצטרף, ולראות אותך מאוחר יותר.
>> [CS50.TV]