1 יסודות מדעי המחשב

Transcription

1 יסודות מדעי המחשב

‫יסודות מדעי המחשב ‪1‬‬
‫בשפת ‪Java‬‬
‫חלק ב'‬
‫ד"ר מיכל ארמוני – ראש צוות הכתיבה‬
‫יעל בילצ'יק )סופרין(‬
‫נעה גרדוביץ‬
‫עדי גרין‬
‫אתי מנשה‬
‫ייעוץ‪ :‬ד"ר דוד גינת‬
‫מהדורת עיצוב‬
‫תשס"ז ‪2006‬‬
‫אוניברסיטת תל‪-‬אביב החוג להוראת המדעים‬
‫מטה מל"מ המרכז הישראלי להוראת המדעים ע"ש עמוס דה‪-‬שליט‬
‫משרד החינוך האגף לתכנון ולפיתוח תכניות לימודים‬
‫יסודות מדעי המחשב ‪ 1‬בשפת ‪Java‬‬
‫חלק ב'‬
‫ד"ר מיכל ארמוני‬
‫יעל בילצ'יק )סופרין(‬
‫נעה גרדוביץ‬
‫עדי גרין‬
‫אתי מנשה‬
‫ייעוץ‪ :‬ד"ר דוד גינת‬
‫כל הזכויות שמורות © ‪2006‬‬
‫"השראה" הוצאה לאור‪ ,‬ת"ד ‪ ,19022‬חיפה ‪34341‬‬
‫טל'‪ ,8254752-04 :‬פקס‪8254752-1534 :‬‬
‫‪E-Mail: [email protected]‬‬
‫‪www.hashraa.co.il‬‬
‫השראה הוצאה לאור‬
‫מהדורה ראשונה ‪2006‬‬
‫אין לשכפל‪ ,‬להעתיק‪ ,‬לצלם‪ ,‬לתרגם‪ ,‬להקליט‪ ,‬לאחסן במאגר מידע כלשהו‪ ,‬לשדר או לקלוט בכל דרך או בכל‬
‫אמצעי אלקטרוני‪ ,‬אופטי או מכני )לרבות צילום‪ ,‬הקלטה‪ ,‬אינטרנט‪ ,‬מחשב ודואר אלקטרוני(‪ ,‬כל חלק שהוא‬
‫מהחומר שבספר זה‪ .‬שימוש מסחרי מכל סוג בחומר הכלול בספר זה אסור בהחלט‪ ,‬אלא ברשות מפורשת בכתב‬
‫מהמו"ל ומהגורמים המפורטים להלן‪.‬‬
‫©‬
‫כל הזכויות שמורות‬
‫אוניברסיטת תל‪-‬אביב ומשרד החינוך‬
‫פתח דבר‬
‫יחידות הלימוד "יסודות מדעי המחשב ‪ 1‬ו‪ "2-‬מיועדות להקניית מושגי יסוד ועקרונות שעליהם‬
‫מושתת התחום מדעי המחשב‪ .‬פרקי יחידות הלימוד משלבים שני ערוצים – ערוץ תיאורטי וערוץ‬
‫יישומי‪ .‬הערוץ התיאורטי מתמקד בחשיבה אלגוריתמית ופיתוח וניתוח אלגוריתמים‪ ,‬שהם מתכונים‬
‫לביצוע משימות‪ .‬הערוץ היישומי כולל יישום של האלגוריתמים בשפת התכנות ‪ ,Java‬שהיא שפה‬
‫מונחית עצמים‪.‬‬
‫ספר זה כולל את היחידה "יסודות מדעי המחשב ‪ ."1‬היחידה מציגה בעיות ראשונות ופתרונותיהן‪,‬‬
‫המיועדים לביצוע למחשב‪ .‬הבעיות נקראות בעיות אלגוריתמיות‪ ,‬ופתרונותיהן – אלגוריתמים‪.‬‬
‫האלגוריתמים מיושמים באמצעות תוכניות מחשב‪ .‬במהלך הלימוד מוצגים המרכיבים הבסיסיים של‬
‫אלגוריתמים ותוכניות מחשב‪ .‬ההצגה משולבת בפיתוח וניתוח אלגוריתמים‪ ,‬וכוללת התייחסות‬
‫מצומצמת למושג עצמים‪ .‬הפיתוח של אלגוריתמים נעשה בשלבים‪ ,‬תוך שימת דגש על ניתוח בעיה‬
‫והתייחסות להיבטים של נכונות ויעילות‪ .‬כמו כן‪ ,‬מושם דגש על מבנים תבניתיים בפתרונות‬
‫אלגוריתמיים‪ ,‬הנקראים תבניות‪.‬‬
‫ספר זה פותח על בסיס ספר הלימוד "יסודות מדעי המחשב ‪ "1‬שפותח במכון ויצמן למדע בסוף שנות‬
‫ה‪ .90-‬בספר הקודם נעשה היישום של אלגוריתמים באמצעות שפת התכנות ‪ ,Pascal‬שהיא שפה‬
‫פרוצדורלית‪ .‬בספר זה נעשה היישום בשפת ‪ ,Java‬שהיא מונחית עצמים‪ .‬העקרונות האלגוריתמיים‬
‫בשני הספרים זהים‪ ,‬וכך גם הנושאים בשמונת הפרקים הראשונים של שני הספרים‪ .‬שני הפרקים‬
‫האחרונים בספר זה מציגים מבוא ראשוני לעצמים )משולב בנושאים האלגוריתמיים של הפרקים‬
‫האחרונים בספר הקודם(‪ .‬בספר "יסודות מדעי המחשב ‪ "2‬מורחב המבט על עצמים‪ ,‬אלגוריתמים‬
‫ותבניות‪.‬‬
‫תודות‪ .‬ספר זה פותח בתמיכת מפמ"ר מדעי המחשב במשרד החינוך‪ ,‬ד"ר אבי כהן‪ ,‬וחברי שתי ועדות‬
‫המקצוע האחרונות להוראת מדעי המחשב – הועדה בראשות פרופ' עמיהוד אמיר והועדה )הנוכחית(‬
‫בראשות פרופ' יהודית גל‪-‬עזר‪ .‬תודתנו נתונה להם על תמיכתם והערותיהם‪ .‬בנוסף‪ ,‬לאורך הספר‬
‫משולבת התייחסות מפורשת לתבניות בפיתוח וניתוח אלגוריתמים‪ .‬ההתייחסות מבוססת על הספר‬
‫"תבניות במדעי המחשב" שפותח בשנת ‪ 2001‬על‪-‬ידי חברי קבוצת הוראת מדעי המחשב בחוג להוראת‬
‫המדעים באוניברסיטת תל‪-‬אביב‪ .‬ארנה מילר‪ ,‬אחת מחברות הקבוצה‪ ,‬אף חקרה בצורה מסודרת את‬
‫הנושא של הוראה מוכוונת תבניות‪ ,‬ושיתפה את חברות צוות הכתיבה מניסיונה‪ .‬תודתנו נתונה לה על‬
‫כך‪.‬‬
‫תוכן העניינים‬
‫פרק ‪ – 1‬מבוא‪11 ..................................................................................‬‬
‫‪ 1.1‬מהו מחשב?‪.........................................................................................‬‬
‫‪11‬‬
‫‪ 1.2‬חומרה‪.................................................................................................‬‬
‫‪13‬‬
‫‪ 1.3‬תוכנה‪16 ..................................................................................................‬‬
‫‪ 1.4‬התפתחות המחשבים ומדעי המחשב‪........................................................‬‬
‫‪20‬‬
‫התפתחות הנדסית וטכנולוגית – חומרה‪20 .......................................................‬‬
‫התפתחות הנדסית וטכנולוגית – תוכנה‪.......................................................‬‬
‫‪22‬‬
‫התפתחות מדעית‪....................................................................................‬‬
‫‪22‬‬
‫סיכום‪........................................................................................................‬‬
‫‪23‬‬
‫שאלות נוספות‪............................................................................................‬‬
‫‪24‬‬
‫פרק ‪ – 2‬פתרון בעיות אלגוריתמיות‪......................................................‬‬
‫‪25‬‬
‫‪ 2.1‬אלגוריתמים‪25 ..........................................................................................‬‬
‫‪ 2.2‬תבניות‪................................................................................................‬‬
‫‪36‬‬
‫סיכום‪........................................................................................................‬‬
‫‪37‬‬
‫שאלות נוספות‪............................................................................................‬‬
‫‪38‬‬
‫פרק ‪ – 3‬מודל חישוב בסיסי‪41 ................................................................‬‬
‫‪ 3.1‬צעדים ראשונים‪ :‬הוראת פלט‪ ,‬הוראת קלט ומשתנים‪....................................‬‬
‫‪41‬‬
‫‪ 3.2‬הוראת השמה‪51 .......................................................................................‬‬
‫‪ 3.3‬טבלת מעקב‪.........................................................................................‬‬
‫‪58‬‬
‫‪ 3.4‬החלפה בין ערכי משתנים‪65 ........................................................................‬‬
‫‪ 3.5‬טיפוסים‪...............................................................................................‬‬
‫‪68‬‬
‫‪ 3.6‬קבועים‪................................................................................................‬‬
‫‪73‬‬
‫סיכום‪........................................................................................................‬‬
‫‪74‬‬
‫סיכום מרכיבי שפת ‪ Java‬שנלמדו בפרק ‪77 .......................................................3‬‬
‫שאלות נוספות‪............................................................................................‬‬
‫‪80‬‬
‫תבניות – פרק ‪...................................................................................3‬‬
‫‪87‬‬
‫החלפת ערכים בין שני משתנים‪.........................................................‬‬
‫‪87‬‬
‫היפוך סדר האיברים בסדרה‪.............................................................‬‬
‫‪91‬‬
‫ממוצע של סדרת מספרים‪................................................................‬‬
‫‪93‬‬
‫הזזה מעגלית בסדרה‪......................................................................‬‬
‫‪96‬‬
‫פרק ‪ – 4‬הרחבה בפיתוח אלגוריתמים‪...................................................‬‬
‫‪99‬‬
‫‪ 4.1‬מבט נוסף אל התהליך של פיתוח אלגוריתם ויישומו‪.....................................‬‬
‫‪99‬‬
‫המחלקה המתמטית‪.................................................................................‬‬
‫‪105‬‬
‫‪ 4.2‬פעולות חלוקה בשלמים‪..........................................................................‬‬
‫‪106‬‬
‫עוד על פעולת השארית‪113 .............................................................................‬‬
‫המרת ערך שלם לממשי‪115 ............................................................................‬‬
‫פירוק מספר דו‪-‬ספרתי לספרותיו‪................................................................‬‬
‫‪118‬‬
‫‪ 4.3‬הטיפוס התווי‪123 ........................................................................................‬‬
‫המרה מתו המייצג ספרה לערך מספרי מתאים‪128 ..............................................‬‬
‫סיכום‪........................................................................................................‬‬
‫‪129‬‬
‫שאלות נוספות‪............................................................................................‬‬
‫‪131‬‬
‫תבניות – פרק ‪...................................................................................4‬‬
‫‪135‬‬
‫חלוקת כמות פריטים לקבוצות בגודל נתון‪............................................‬‬
‫‪135‬‬
‫פירוק מספר חיובי לספרותיו‪.............................................................‬‬
‫‪138‬‬
‫בניית מספר‪...................................................................................‬‬
‫‪141‬‬
‫פרק ‪ – 5‬ביצוע מותנה‪145 ........................................................................‬‬
‫‪ 5.1‬הוראה לביצוע בתנאי‪145 ..............................................................................‬‬
‫הוראה לביצוע בתנאי במבנה ‪...íà‬‬
‫‪......................................... ...úøçà‬‬
‫‪145‬‬
‫הוראה לביצוע בתנאי במבנה ‪155 ...................................................... ...íà‬‬
‫התניית ביצוע של יותר מהוראה אחת‪..........................................................‬‬
‫‪162‬‬
‫ביטויים בוליאניים הכוללים תווים‪166 .................................................................‬‬
‫‪ 5.2‬תנאי מורכב‪..........................................................................................‬‬
‫‪171‬‬
‫הקשר ‪172 .....................................................................................íâå‬‬
‫הקשר ‪.......................................................................................åà‬‬
‫‪177‬‬
‫תנאים מורכבים מעורבים‪..........................................................................‬‬
‫‪185‬‬
‫‪ 5.3‬קינון של הוראה לביצוע בתנאי‪.................................................................‬‬
‫‪186‬‬
‫* ‪ 5.4‬הוראת שרשרת לביצוע בתנאי‪197 ..................................................................‬‬
‫* ‪ 5.5‬הוראת בחירה‪.......................................................................................‬‬
‫‪203‬‬
‫סיכום‪........................................................................................................‬‬
‫‪210‬‬
‫שאלות נוספות‪............................................................................................‬‬
‫‪213‬‬
‫תבניות – פרק ‪...................................................................................5‬‬
‫‪219‬‬
‫מציאת מקסימום ומינימום בסדרה‪219 ......................................................‬‬
‫סידור ערכים בסדרה‪225 ........................................................................‬‬
‫ערכים עוקבים‪................................................................................‬‬
‫‪228‬‬
‫זוגיות מספר‪230 ...................................................................................‬‬
‫מחלק של מספר‪.............................................................................‬‬
‫‪232‬‬
‫פרק ‪ – 6‬נכונות אלגוריתמים‪...............................................................‬‬
‫‪235‬‬
‫סיכום‪........................................................................................................‬‬
‫‪245‬‬
‫פרק ‪ – 7‬ביצוע חוזר‪247 ...........................................................................‬‬
‫‪ 7.1‬ביצוע חוזר באורך ידוע מראש‪..................................................................‬‬
‫‪247‬‬
‫‪ 7.2‬מציאת מקסימום או מינימום‪....................................................................‬‬
‫‪267‬‬
‫‪ 7.3‬מציאת מקום מקסימום או מינימום‪............................................................‬‬
‫‪271‬‬
‫‪ 7.4‬ביצוע חוזר בתנאי‪..................................................................................‬‬
‫‪274‬‬
‫ביצוע חוזר עם זקיף‪.................................................................................‬‬
‫‪274‬‬
‫ביצוע חוזר עם תנאי כניסה כלשהו‪..............................................................‬‬
‫‪282‬‬
‫ביצוע חוזר אינסופי‪294 ...................................................................................‬‬
‫‪ 7.5‬משתנים מטיפוס בוליאני‪.........................................................................‬‬
‫‪299‬‬
‫‪ 7.6‬הקשר הלוגי ‪307 .............................................................................(not) àì‬‬
‫‪ 7.7‬קינון הוראות לביצוע חוזר‪310 ........................................................................‬‬
‫סיכום‪........................................................................................................‬‬
‫‪317‬‬
‫תבניות – פרק ‪...................................................................................7‬‬
‫‪321‬‬
‫מנייה וצבירה‪.................................................................................‬‬
‫‪321‬‬
‫ממוצע של סדרת מספרים‪................................................................‬‬
‫‪332‬‬
‫מציאת מקסימום או מינימום בסדרה‪337 ...................................................‬‬
‫מציאת ערך נלווה למקסימום או למינימום בסדרה‪.................................‬‬
‫‪342‬‬
‫איסוף בקיזוז‪..................................................................................‬‬
‫‪347‬‬
‫פירוק מספר חיובי לספרותיו‪.............................................................‬‬
‫‪352‬‬
‫בניית מספר‪...................................................................................‬‬
‫‪354‬‬
‫האם כל הערכים בסדרה מקיימים תנאי?‪356 .............................................‬‬
‫האם קיים ערך בסדרה המקיים תנאי?‪................................................‬‬
‫‪359‬‬
‫מציאת כל הערכים בסדרה המקיימים תנאי‪363 ..........................................‬‬
‫מעבר על זוגות סמוכים בסדרה‪.........................................................‬‬
‫‪366‬‬
‫פרק ‪ – 8‬יעילות של אלגוריתמים‪369 ..........................................................‬‬
‫סיכום‪........................................................................................................‬‬
‫‪382‬‬
‫פרק ‪ – 9‬המחלקה מחרוזת )‪ (String‬ומבוא לעצמים‪.................................‬‬
‫‪383‬‬
‫‪ 9.1‬היכרות ראשונית עם המחלקה ‪.......................................................String‬‬
‫‪383‬‬
‫‪ 9.2‬ביצוע פעולות על מחרוזות‪.......................................................................‬‬
‫‪386‬‬
‫שרשור מחרוזות‪......................................................................................‬‬
‫‪391‬‬
‫ומה בפנים? פעולות המסתכלות אל תוך הקנקן‪.............................................‬‬
‫‪393‬‬
‫‪ 9.3‬השמת מחרוזות‪....................................................................................‬‬
‫‪396‬‬
‫סיכום‪........................................................................................................‬‬
‫‪408‬‬
‫רשימת פעולות על מחרוזות‪410 ...........................................................................‬‬
‫פרק ‪ – 10‬מערכים‪............................................................................‬‬
‫‪413‬‬
‫‪ 10.1‬מערך ואיברי מערך‪..............................................................................‬‬
‫‪413‬‬
‫‪ 10.2‬חריגה מגבולות מערך‪434 ...........................................................................‬‬
‫‪ 10.3‬קשרים בין מערכים‪..............................................................................‬‬
‫‪438‬‬
‫עיבוד מערכים במקביל ובקצב זהה‪438 ..............................................................‬‬
‫עיבוד מערכים במקביל‪ ,‬בקצב לא זהה‪439 .........................................................‬‬
‫‪ 10.4‬מערך מונים‪........................................................................................‬‬
‫‪442‬‬
‫‪ 10.5‬מערך צוברים‪......................................................................................‬‬
‫‪446‬‬
‫‪ 10.6‬יעילות מקום‪.......................................................................................‬‬
‫‪447‬‬
‫‪ 10.7‬בחירה אקראית‪...................................................................................‬‬
‫‪454‬‬
‫סיכום‪........................................................................................................‬‬
‫‪460‬‬
‫סיכום מרכיבי שפת ‪ Java‬שנלמדו בפרק ‪461 .....................................................10‬‬
‫תבניות – פרק ‪.................................................................................10‬‬
‫‪463‬‬
‫מערך מונים‪...................................................................................‬‬
‫‪463‬‬
‫מערך צוברים‪.................................................................................‬‬
‫‪466‬‬
‫חישוב שכיח‪471 ...................................................................................‬‬
‫הזזה מעגלית בסדרה‪......................................................................‬‬
‫‪474‬‬
‫הזזה של תת‪-‬סדרה‪........................................................................‬‬
‫‪477‬‬
‫היפוך סדר הערכים בסדרה‪..............................................................‬‬
‫‪479‬‬
‫פרק ‪ – 6‬נכונות אלגוריתמי‬
‫לאור ההיסטוריה הקצרה של מדעי המחשב ישנ אינספור דוגמאות של תוכניות שגויות‪ ,‬אשר לא‬
‫מעט מה הסתיימו בכי רע‪ .‬אחת הדוגמאות הוא סיפורה של ספינת חלל אמריקנית מסדרת מרינר‬
‫שנשלחה אל כוכב הלכת ונוס‪ .‬הספינה אבדה כתוצאה משגיאה בתוכנית המחשב שהופקדה על בקרת‬
‫הטיסה‪ ,‬ומיליוני דולרי ירדו לטמיו‪.‬‬
‫חלק לא מבוטל מ המחקר במדעי המחשב מוקדש לתחו הנקרא "הוכחת נכונות של תוכניות"‪.‬‬
‫מטרתה של הוכחת נכונות של תוכנית היא אימות מלא של הטענה שהתוכנית מציגה עבור כל קלט את‬
‫הפלט הדרוש‪.‬‬
‫חוקרי פיתחו ומפתחי שיטות שונות להוכחת נכונות של תוכניות‪ .‬שיטות אלה ה מתמטיות‬
‫באופיי ונשענות על תיאוריות מתמטיות מורכבות למדי‪ .‬חומר הלימוד של "יסודות מדעי המחשב"‬
‫איננו ד בהוכחת נכונות של תוכניות‪ ,‬כיוו שהדבר מחייב ידע מתמטי שאיננו נרכש בביתספר תיכו‪.‬‬
‫א ההתייחסות לנכונות של תוכניות חשובה לאור חומר הלימוד כולו‪ ,‬כבר ע פיתוח תוכניות‬
‫ראשונות‪ .‬לכ‪ ,‬אנו מציגי נושא זה כבר עתה‪ ,‬בצורה פשוטה ואינטואיטיבית‪.‬‬
‫אלגורית )תוכנית( לפתרו בעיה אלגוריתמית נתונה הוא נכו א ביצועו מביא להצגת הפלט הדרוש‬
‫עבור כל קלט חוקי )כלומר‪ ,‬כל קלט המתאי להגדרת הבעיה(‬
‫מספר האפשרויות השונות לקלטי חוקיי הוא )בדר כלל( רב‪ ,‬ולעיתי רבות אפילו אינסופי‪ ,‬ולכ‬
‫לא מתקבל על הדעת להיווכח בנכונותו של אלגורית עלידי בדיקת הפלט עבור כל קלט אפשרי‪.‬‬
‫בפרקי הלימוד של "יסודות מדעי המחשב" אנו בודקי את נכונותו של אלגורית עלידי בדיקת‬
‫הפלט עבור דוגמאות שונות של קלט‪.‬‬
‫בפרק ‪ 4‬הצגנו בדיקת נכונות עבור דוגמאות קלט מגוונות; כלומר‪ ,‬דוגמאות קלט אשר מאפייניה‬
‫מבטאי את מגוו הקלטי האפשריי‪ .‬עתה‪ ,‬נחדד בנקודה של בדיקת נכונות‪ ,‬ונשתמש בדר כלל‬
‫במושג דוגמאות קלט מייצגות‪.‬‬
‫דוגמאות קלט מייצגות ה דוגמאות קלט אשר כל אחת מה מייצגת קבוצת קלטי‪ .‬בחירה‬
‫ממצה‬
‫של דוגמאות קלט מייצגות היא בחירה המבטאת חלוקה ממצה של הקלטי האפשריי‬
‫לקבוצות מיוצגות‪.‬‬
‫בפתרו הבעיה הבאה נמחיש בחירה ממצה של דוגמאות קלט מייצגות‪ ,‬ונראה שימוש בדוגמאות‬
‫הקלט המייצגות כדי לזהות שגיאה בתוכנית ולתקנה‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-235-‬‬
‫מדעי המחשב‬
1 ‫בעיה‬
‫ בחירת דוגמת‬,‫ הדגמה של חלוקת הקלטי לקבוצות אשר מאפייניה שוני‬:‫מטרת הבעיה ופתרונה‬
‫ ושימוש בדוגמאות הקלט המייצגות כדי לאמת נכונותה של תוכנית וכדי‬,‫קלט מייצגת לכל קבוצה‬
.‫לתקנה במידת הצור‬
:‫נתונה התוכנית הבאה‬
/*
‫ שתי אותיות לועזיות גדולות‬:‫קלט‬
‫ הודעה האם האותיות עוקבות זו לזו‬:‫פלט‬
*/
public class Letters
{
public static void main(String[] args)
{
char letter1, letter2;
letter1 = In.readChar("insert a capital letter, avoid the letter
Z");
letter2 = In.readChar("insert another capital letter, avoid the
letter Z");
if (letter2 == letter1 + 1)
{
System.out.println("one of the letters follows the other in
the ABC");
}
else
{
System.out.println("These are not consecutive letters of the
ABC");
}
}// main
} // class Letters
-236-
‫אביב‬-‫ אוניברסיטת תל‬,‫הוראת המדעים‬
‫ביצוע התוכנית יביא להצגת הודעת פלט מתאימה רק עבור חלק מ הקלטי האפשריי‪.‬‬
‫חלקו את הקלטי האפשריי לקבוצות‪ ,‬בחרו דוגמת קלט מייצגת לכל קבוצה‪ ,‬ותארו עבור אילו‬
‫דוגמאות תוצג הודעה מתאימה ועבור אילו דוגמאות תוצג הודעה לא מתאימה‪ .‬אחרכ‪ ,‬תקנו את‬
‫התוכנית כ שעבור כל קלט תוצג הודעה מתאימה‪.‬‬
‫?‬
‫מכותרת התוכנית וממשפטי הפלט נית לראות שמטרת התוכנית היא לבדוק הא שתי האותיות‬
‫הנתונות כקלט ה אותיות לועזיות עוקבות‪ .‬מהי חלוקה מתאימה של הקלטי האפשריי לקבוצות?‬
‫מתאי לחלק את הקלטי האפשריי לשתי הקבוצות הבאות‪:‬‬
‫‪ .1‬קלטי בה האותיות הנתונות ה אותיות לועזיות עוקבות‪.‬‬
‫‪ .2‬קלטי בה האותיות הנתונות אינ אותיות לועזיות עוקבות‪.‬‬
‫?‬
‫החלוקה המתוארת אכ מבטאת אבחנה בי קלטי אשר לה מאפייני שוני‪ .‬הא חלוקה זו‬
‫מספיקה? הא לא קיימי קלטי בעלי מאפייני שוני בקבוצות אלו?‬
‫למשל‪ ,‬הקלט ‪ B C‬שיי לקבוצה הראשונה‪ ,‬בה האותיות הינ לועזיות עוקבות‪ .‬ג הקלט ‪ C B‬שיי‬
‫לקבוצה הראשונה‪ ,‬א לשני קלטי אלה מאפייני שוני‪ .‬בקלט ‪ B C‬האות השנייה עוקבת לאות‬
‫הראשונה‪ ,‬ואילו בקלט ‪ C B‬האות הראשונה עוקבת לאות השנייה‪.‬‬
‫שימו ♥‪ :‬נית ג לחלק את קבוצת הקלטי השנייה באופ דומה‪ ,‬א חלוקה זו איננה נחוצה‪ :‬כיוו‬
‫שהאותיות אינ עוקבות‪ ,‬הרי סדר הופעת בקלט איננו משנה‪.‬‬
‫א כ‪ ,‬נקבל את החלוקה הבאה של הקלטי האפשריי לשלוש קבוצות‪:‬‬
‫‪1‬א‪ .‬האות השנייה עוקבת לאות הראשונה‪.‬‬
‫‪1‬ב‪ .‬האות הראשונה עוקבת לאות השנייה‪.‬‬
‫‪ .2‬שתי האותיות אינ עוקבות‪.‬‬
‫?‬
‫חילקנו את הקלטי האפשריי חלוקה ממצה לקבוצות‪ .‬מה תהיה בחירה ממצה של דוגמאות‬
‫קלט מייצגות עבור הבעיה הנתונה?‬
‫בחירה ממצה של דוגמאות קלט מייצגות תהיה בחירת דוגמת קלט מכל קבוצה‪ .‬למשל‪ ,‬קבוצת‬
‫דוגמאות הקלט הבאות מבטאת בחירה ממצה‪) X Y :‬מייצגת את קבוצת הקלטי ‪1‬א(; ‪) E D‬מייצגת‬
‫את קבוצת הקלטי ‪1‬ב(; ‪) D O‬מייצגת את קבוצת הקלטי ‪(2‬‬
‫?‬
‫עבור אלו מדוגמאות הקלט המתוארות תוצג הודעת פלט מתאימה?‬
‫‪-237-‬‬
‫עבור דוגמת הקלט הראשונה )‪ (X Y‬והשלישית )‪ (D O‬תוצג הודעת פלט מתאימה‪ .‬א עבור דוגמת‬
‫הקלט השנייה )‪ (E D‬תוצג הודעת פלט לא מתאימה! עבור דוגמה זו תוצג ההודעה‪:‬‬
‫‪These are not consecutive letters of the ABC‬‬
‫הודעה לא מתאימה תוצג‪ ,‬בעצ‪ ,‬עבור כל קלט מהקבוצה ‪1‬ב‪ ,‬המיוצגת עלידי דוגמת הקלט השנייה‪.‬‬
‫?‬
‫כיצד נית לתק את התוכנית‪ ,‬כ שתציג פלט דרוש עבור כל קלט חוקי? כלומר‪ ,‬כ שג עבור‬
‫קלטי מ הקבוצה השנייה תוצג הודעה מתאימה?‬
‫יש להרחיב את הביטוי הבוליאני שבמשפט ‪ .if‬הביטוי הבוליאני שבתוכנית הנתונה כולל רק את‬
‫האפשרות שהאות השנייה בקלט היא אות עוקבת לאות הראשונה בקלט‪ .‬יש להרחיב ביטוי זה כ‬
‫שיכלול ג את האפשרות שהאות הראשונה בקלט היא אות עוקבת לאות השנייה‪.‬‬
‫לכ‪ ,‬הביטוי הבוליאני שבתוכנית המתוקנת יהיה‪:‬‬
‫)‪(letter2 == letter1 + 1) || (letter1 == letter2 + 1‬‬
‫התוכנית המתוקנת תהיה‪:‬‬
‫*‪/‬‬
‫קלט‪ :‬שתי אותיות לועזיות גדולות‬
‫פלט‪ :‬הודעה האם האותיות עוקבות‬
‫‪*/‬‬
‫‪public class Letters‬‬
‫{‬
‫)‪public static void main(String[] args‬‬
‫{‬
‫;‪char letter1, letter2‬‬
‫קלט ‪//‬‬
‫‪letter1 = In.readChar("insert a capital letter, avoid the letter‬‬
‫;)"‪Z‬‬
‫‪letter2 = In.readChar("insert another capital letter, avoid the‬‬
‫;)"‪letter Z‬‬
‫) )‪if ( (letter2 == letter1 + 1) || (letter1 == letter2 + 1‬‬
‫{‬
‫‪System.out.println("one of the letters follows the other in‬‬
‫;)"‪the ABC‬‬
‫}‬
‫‪else‬‬
‫{‬
‫‪System.out.println("These are not consecutive letters of the‬‬
‫;)"‪ABC‬‬
‫}‬
‫‪}// main‬‬
‫‪} // class Letters‬‬
‫סוף פתרון בעיה‬
‫‪-238-‬‬
‫‪1‬‬
‫נית ללמוד לקח מ הפתרו לדוגמה של בעיה ‪:1‬‬
‫השגיאה שהופיעה בתוכנית הנתונה נובעת מכ שמפתח התוכנית לא ביצע ניתוח מלא של כל‬
‫אפשרויות הקלט השונות‪ .‬מפתח התוכנית לא הבחי בכ שהמשמעות של אותיות לועזיות עוקבות‪,‬‬
‫איננה רק האפשרות ש"האות השנייה עוקבת לאות הראשונה"‪ ,‬אלא ג האפשרות ש"האות הראשונה‬
‫עוקבת לאות השנייה"‪ .‬זיהוי השגיאה ותיקונה התאפשר הודות לחלוקה ממצה של הקלטי‬
‫האפשריי לקבוצות‪ ,‬אשר הביאה לבחירה ממצה של דוגמאות קלט מייצגות‪.‬‬
‫שימו ♥‪ :‬הבדיקה בעזרת דוגמאות קלט מייצגות אינה מוכיחה נכונות‪ ,‬אלא מסייעת באיתור‬
‫שגיאות‪ ,‬ומקטינה מאוד את ההסתברות לטעות‪ ,‬א תמיד ייתכ )בייחוד בתוכניות גדולות מאוד(‬
‫שנפספס תתמקרה מסוי‪ ,‬משו שאי בידינו מתכו לקביעת חלוקה ממצה לקבוצות‪.‬‬
‫כיו בכל חברת תוכנה יש צוות בודקי אשר כל תפקידו הוא לוודא כי התוכנה עובדת כשורה עבור‬
‫כל קלט אפשרי‪ .‬חשיבות בדיקות אלה גבוהה ונועדה על מנת להימנע מהפסדי ולעיתי ג מנזקי‬
‫משמעותיי הרבה יותר‪ ,‬כמו פגיעה בחיי אד )למשל בתוכנות רפואיות(‪.‬‬
‫במרבית חברות התוכנה מער הבדיקות מבוסס ג הוא על סימולציה‪ ,‬כלומר‪ ,‬על בחירה מתוחכמת‬
‫של דוגמאות קלט מייצגות ובדיקת התוכניות עליה‪ ,‬בחירה שיכולה להיות מורכבת מאוד ומסובכת‬
‫מאוד בתוכניות גדולות ומורכבות‪ .‬ע זאת‪ ,‬יש ג חברות )בעיקר דווקא חברות לתכנו ופיתוח‬
‫חומרה( המשתמשות בכלי הוכחה )הנשעני על תורות מתמטיות(‪ .‬הסיבה למיעוט יחסי של השימוש‬
‫בכלי ההוכחה הוא הקושי של כלי מסוג זה הקיימי כיו להתמודד בצורה נוחה ע תוכניות‬
‫גדולות‪ .‬הסיבה שה משמשי יותר בתעשיית החומרה הוא שהרבה יותר יקר לייצר מחדש רכיב‬
‫חומרה‪ ,‬א מתגלית בו טעות אחרי שלב הייצור‪ ,‬מאשר לתק ולהפי( גרסה חדשה של תוכנה‪,‬‬
‫שהתגלתה בה טעות‪.‬‬
‫שאלה ‪6.1‬‬
‫נתו הלוח הבא‪ ,‬אשר בכל משבצת בו מופיע מספר של‪:‬‬
‫‪2‬‬
‫‪1‬‬
‫‪4‬‬
‫‪3‬‬
‫קטע התוכנית הבא‪ ,‬אשר הקלט שלו הוא שניי מ המספרי המופיעי בלוח‪ ,‬יציג כפלט הודעה‪.‬‬
‫‪-239-‬‬
‫;)"‪num1 = In.readInt("insert first number‬‬
‫;)"‪num2 = In.readInt("insert second number‬‬
‫)‪if (num1 == num2 + 2‬‬
‫{‬
‫;)"‪System.out.println("The numbers appear at the same column‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println("The numbers don’t appear at the same column‬‬
‫}‬
‫א‪ .‬בחרו שתי דוגמאות קלט‪ ,‬אשר עבור כל אחת מה תוצג הודעה מתאימה אחרת‪ .‬תארו את‬
‫המאפייני של שתי קבוצות הקלטי אליה שייכות הדוגמאות שבחרת‪.‬‬
‫ב‪ .‬בחרו דוגמת קלט שעבורה תוצג הודעה לא מתאימה‪ ,‬ותארו את המאפיי של קבוצת הקלטי‬
‫שעבור תוצג הודעה לא מתאימה‪.‬‬
‫ג‪ .‬שנו את הביטוי הבוליאני שבקטע התוכנית לביטוי בוליאני אחר‪ ,‬שעבורו תוצג תמיד הודעה‬
‫מתאימה‪ .‬נסחו את הביטוי החדש כביטוי פשוט‪.‬‬
‫שאלה ‪6.2‬‬
‫הקלט לקטע התוכנית הבא הוא מספר של כלשהו‪ .‬מטרת קטע התוכנית הבא הוא להציג כפלט ער‬
‫שסימנו כסימ המספר הנתו בקלט וגודלו הוא ריבוע המספר הנתו בקלט‪ .‬למשל‪ ,‬עבור הקלט ‪10‬‬
‫הפלט הנדרש הוא ‪ ,100‬ועבור הקלט ‪ -10‬הפלט הנדרש הוא ‪.-100‬‬
‫שימו ♥‪ :‬בקטע התוכנית נעשה שימוש במחלקה המתמטית ובפעולה ‪ Math.pow‬השייכת למחלקה‬
‫זו‪ ,‬שנלמדו בפרק ‪.4‬‬
‫;)"‪.readInt("insert a number‬מ‪num = I‬‬
‫;)‪s = Math.pow(num, 2‬‬
‫;)‪System.out.println(s‬‬
‫קטע התוכנית שגוי‪.‬‬
‫א‪ .‬תנו דוגמת קלט מייצגת שעבורה יתקבל הפלט הדרוש‪.‬‬
‫א‪ .‬תנו דוגמת קלט מייצגת שעבורה לא יתקבל הפלט הדרוש‪.‬‬
‫ב‪ .‬תארו את קבוצת הקלטי שעבור לא יתקבל הפלט הדרוש‪.‬‬
‫ג‪ .‬תקנו את קטע התוכנית‪ ,‬כ שעבור כל קלט יתקבל הפלט הדרוש‪.‬‬
‫‪-240-‬‬
‫שאלה ‪6.3‬‬
‫נתו קטע התוכנית הבא אשר הקלט שלו הוא ארבע אותיות לועזיות גדולות‪.‬‬
‫;)"‪letter1 = In.readChar("insert a capital letter‬‬
‫))‪if ((letter1 == letter2) && (letter3 == letter4‬‬
‫{‬
‫;)"‪System.out.println("All letters are equal‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println("Not all letters are equal‬‬
‫}‬
‫א‪ .‬תנו שתי דוגמאות קלט שונות אשר עבור כל אחת מה תתקבל הודעה לא מתאימה‪.‬‬
‫ב‪ .‬תארו את קבוצת הקלטי שעבור תתקבל הודעה לא מתאימה‪.‬‬
‫ג‪ .‬שנו את הביטוי הבוליאני שבקטע התוכנית כ שעבור כל קלט תתקבל הודעה מתאימה‪.‬‬
‫שאלה ‪6.4‬‬
‫לפניכ תוכנית בשפת ‪ .Java‬התוכנית קולטת תו כקלט‪ .‬מטרת התוכנית היא לבדוק הא התו מייצג‬
‫מספר‪ .‬א כ‪ ,‬יוצג כפלט המספר הבא אחריו‪ .‬אחרת‪ ,‬תוצג הודעה כי התו אינו מספר‪.‬‬
‫הראו שלוש דוגמאות קלט מייצגות לתוכנית זו והסבירו עבור כל דוגמה איזו קבוצה היא מייצגת‪.‬‬
‫מצאו את השגיאה בתוכנית ותקנו אותה‪.‬‬
‫*‪/‬‬
‫התוכנית קולטת תו‬
‫אם התו מייצג מספר התוכנית מציגה כפלט את המספר הבא אחריו‬
‫בכל מקרה אחר מוצגת ההודעה "לא מספר"‬
‫‪*/‬‬
‫‪public class NextNumber‬‬
‫{‬
‫)‪public static void main (String[] args‬‬
‫{‬
‫הגדרת משתנים ‪//‬‬
‫תו הקלט‪char character; //‬‬
‫קלט ‪//‬‬
‫;)"‪character = In.readChar("Insert a character‬‬
‫‪-241-‬‬
‫פלט ‪//‬‬
‫)'‪if (character >= '0' && character <= '9‬‬
‫{‬
‫;) )‪System.out.println( (char)(character + 1‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println("Not a number‬‬
‫}‬
‫‪} // main‬‬
‫‪} // class NextNumber‬‬
‫ראינו עד כה בפרק זה ניתוח של תוכנית נתונה‪ ,‬שמטרתה ברורה‪ .‬א בפיתוח תוכנה קורה לא פע‬
‫שיש לשלב תוכניות אשר אינ מתועדות כראוי ומטרת איננה ברורה‪ .‬במקרי כאלו יש לזהות קוד‬
‫כל את מטרת התוכנית הנתונה‪.‬‬
‫זיהוי מטרת תוכנית נתונה‬
‫מתבצע על ידי בחינת פלט התוכנית עבור דוגמאות קלט שונות‪,‬‬
‫והכללת היחס בי הקלט לפלט‪.‬‬
‫נדגי זאת בעזרת שתי השאלות הבאות‪.‬‬
‫שאלה ‪6.5‬‬
‫נתו קטע התוכנית הבא שהקלט שלו הוא מספר לא שלילי‪ ,‬והמשתני בו ה מטיפוס ממשי‪.‬‬
‫שימו ♥‪ :‬בקטע התוכנית נעשה שימוש במחלקה המתמטית‪ ,‬ובפעולה ‪ sqrt‬של המחלקה המתמטית‪,‬‬
‫שנלמדו בפרק ‪ ,4‬וכ בפעולה ‪ Math.floor‬אשר מקבלת מספר ממשי ומחזירה את החלק השל שלו‬
‫)למשל‪ ,‬ער הביטוי )‪ Math.floor(5.8‬שווה ל‪(5.0‬‬
‫;)"‪num = In.readDouble("insert a number‬‬
‫;)‪sqrtNum = Math.sqrt(num‬‬
‫;)‪fraction = sqrtNum – Math.floor(sqrtNum‬‬
‫)‪if (fraction > 0‬‬
‫{‬
‫;)"‪System.out.println("1‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println("0‬‬
‫}‬
‫‪-242-‬‬
‫א‪ .‬תנו דוגמת קלט שעבורה יהיה הפלט ‪.1‬‬
‫ב‪ .‬תנו דוגמת קלט שעבורה יהיה הפלט ‪.0‬‬
‫ג‪ .‬תארו את מטרת קטע התוכנית תו חלוקת הקלטי האפשריי לשתי קבוצות ותיאור הפלט עבור‬
‫הקלט בכל קבוצה‪.‬‬
‫שאלה ‪6.6‬‬
‫נתו קטע התוכנית הבא‪ ,‬שהקלט שלו הוא ארבעה מספרי שלמי שוני‪ .‬כל המשתני בקטע‬
‫התוכנית ה מטיפוס של‪.‬‬
‫;)"‪.readInt("insert a number‬מ‪num1 = I‬‬
‫)‪if (num1 > num2‬‬
‫{‬
‫;‪max1=num1‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;‪max1 = num2‬‬
‫‪} // if‬‬
‫)‪if (num3 > num4‬‬
‫{‬
‫;‪max2 = num3‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;‪max2 = num4‬‬
‫‪} // if‬‬
‫)‪if (max1 > max2‬‬
‫{‬
‫;)‪System.out.println(max1‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)‪System.out.println(max2‬‬
‫‪} // if‬‬
‫‪-243-‬‬
.20 30 40 50 ‫ ו‬40 30 20 10 :‫ מהו הפלט עבור כל אחת מדוגמאות הקלט הבאות‬.‫א‬
.5 ‫ תנו שלוש דוגמאות קלט שונות של מספרי חיוביי שהפלט עבור הוא‬.‫ב‬
?‫ מהי מטרת קטע התוכנית‬.‫ג‬
6.7 ‫שאלה‬
:Java ‫לפניכ תוכנית בשפת‬
/*
‫התוכנית קולטת שלושה מספרים שלמים‬
‫התוכנית‬
*/
public class What
{
public static void main (String[] args)
{
// ‫הגדרת משתנים‬
int num1, num2, num3; // ‫משתני הקלט‬
int temp;
// ‫משתנה עזר‬
//‫קלט‬
num1 = In.readInt("Insert first number");
num2 = In.readInt("Insert second number");
num3 = In.readInt("Insert third number");
if (num1 > num2)
{
temp = num1;
num1 = num2;
num2 = temp;
}
if (num2 > num3)
{
temp = num2;
num2 = num3;
num3 = temp;
}
// ‫פלט‬
System.out.println(num1 + "," + num2 + "," + num3);
} // main
} // class What
-244-
‫א‪ .‬כתבו במשפט אחד מהי לדעתכ מטרת התוכנית‪.‬‬
‫ב‪ .‬הציעו חלוקה ממצה של הקלטי האפשריי לקבוצות‪.‬‬
‫ג‪ .‬בחרו דוגמאות קלט מייצגות עלפי החלוקה שהצעת בסעי) א'‪ ,‬וציינו את הפלט עבור כל אחת‬
‫מה‪.‬‬
‫ד‪ .‬הא התוכנית משיגה את מטרתה? א כ‪ ,‬הסבירו מדוע; א לא‪ ,‬תקנו אותה‪.‬‬
‫סיכום‬
‫בפרק זה הרחבנו והעמקנו בנושא נכונות של אלגורית )תוכנית(‪.‬‬
‫אלגורית נכו" הוא אלגורית אשר ביצועו מביא להשגת המטרה עבור כל קלט חוקי )המתאי‬
‫להגדרת הבעיה(‪.‬‬
‫לא מתקבל על הדעת להיווכח בנכונות של אלגורית עלידי בניית טבלת מעקב עבור כל קלט אפשרי‪.‬‬
‫לכ‪ ,‬אנו בוחרי בצורה ממצה דוגמאות מייצגות של קלט ובודקי את מהל ביצוע האלגורית עבור‬
‫דוגמאות קלט אלה‪.‬‬
‫דוגמאות קלט מייצגות ה דוגמאות קלט אשר כל אחת מה מייצגת קבוצת קלטי בעלת מאפייני‬
‫שוני‪.‬‬
‫בחירה ממצה של דוגמאות קלט מייצגות היא בחירה המבטאת חלוקה ממצה של הקלטי האפשריי‬
‫לקבוצות מייצגות‪.‬‬
‫לפעמי נתונות תוכניות או תתתוכניות אשר מטרת אינה ברורה‪ .‬זיהוי מטרת תוכנית נתונה מתבצע‬
‫על ידי בחינת פלט התוכנית עבור דוגמאות קלט שונות‪ ,‬והכללת היחס בי הקלט לפלט‪.‬‬
‫‪-245-‬‬
‫פרק ‪ – 7‬ביצוע חוזר‬
‫עד כה הכרנו בעיות אשר פתרונ
כלל ביצוע של כמה תתמשימות שונות‪ ,‬באופ
סדרתי‪ .‬כלומר‪ ,‬כל‬
‫תתמשימה בסדרה בוצעה פע אחת )וא זו משימה שביצועה תלוי בתנאי‪ ,‬ייתכ
שלא בוצעה אפילו‬
‫פע אחת(‪ .‬אול‪ ,‬ישנ
בעיות אשר לצור פתרונ
יש לבצע תתמשימה אחת‪ ,‬או כמה תתמשימות‪,‬‬
‫יותר מפע אחת‪ ,‬ואולי ג מספר רב של פעמי‪ .‬בפרק זה נכיר אלגוריתמי אשר מורי על חזרה‬
‫שוב ושוב של ביצוע של תתמשימה )או תתמשימות(‪ .‬אלגוריתמי אלה כוללי הוראה לביצוע חוזר‬
‫של קבוצת הוראות‪.‬‬
‫בסעי ‪ 7.1‬נכיר אלגוריתמי שבה מבנה הביצוע החוזר הוא פשוט‪ .‬באלגוריתמי אלה מספר‬
‫הפעמי של הביצוע החוזר נקבע לפני תחילת ביצועו‪.‬‬
‫בסעי ‪ 7.4‬נכיר אלגוריתמי שבה מבנה הביצוע החוזר מורכב יותר‪ .‬באלגוריתמי אלה מספר‬
‫הפעמי של הביצוע החוזר לא נקבע מראש‪ ,‬אלא תלוי בתנאי אשר נבדק שוב ושוב במהל הביצוע‬
‫החוזר‪.‬‬
‫‪ 7.1‬ביצוע חוזר באורך ידוע מראש‬
‫בעיה ‪1‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת אלגורית הכולל הוראה לביצוע חוזר באור ידוע מראש‪.‬‬
‫עלינו להמיר רשימת מחירי מייצוג בדולרי לייצוג בשקלי‪ .‬פתחו ויישמו אלגורית אשר הקלט‬
‫שלו הוא שער ההמרה מדולרי לשקלי ואחריו רשימה של עשרה מחירי הנתוני בדולרי‪ .‬הפלט‬
‫שלו הוא הער בשקלי של כל אחד מעשרת המחירי‪ .‬הפלט עבור כל מחיר צרי להינת
מייד אחרי‬
‫קליטתו‪ ,‬לפני קליטת המחיר הבא‪.‬‬
‫פירוק הבעיה לתתמשימות‬
‫‪ .1‬קליטת שער ההמרה מדולרים לשקלים‬
‫‪ .2‬קליטת כל אחד מ‪ 10-‬המחירים הדולרים‪ ,‬חישוב ערכו בשקלים‪ ,‬והצגה כפלט של הערך‬
‫המחושב‪.‬‬
‫?‬
‫נית
לפרט את התתמשימה השנייה יותר‪ .‬כיצד?‬
‫התתמשימה השנייה מורכבת בעצ מביצוע חוזר‪ ,‬עשר פעמי‪ ,‬של התתמשימות הבאות‪:‬‬
‫‪-247-‬‬
‫‪ .2.1‬קליטת מחיר דולרי‬
‫‪ .2.2‬חישוב ערכו של המחיר בשקלים‬
‫‪ .2.3‬הצגה כפלט של הערך המחושב‬
‫דר אחת להורות על ביצוע חוזר‪ ,‬עשר פעמי‪ ,‬של התתמשימות שניסחנו‪ ,‬היא כמוב
לכתוב אות
‬
‫עשר פעמי‪ ,‬כ‪:‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.2.28‬‬
‫קליטת מחיר דולרי‬
‫‪.2.29‬‬
‫חישוב ערכו של המחיר בשקלים‬
‫‪.2.30‬‬
‫הצגה כפלט של הערך המחושב‬
‫כמוב
‪ ,‬זהו ניסוח מסורבל‪ .‬עבור רשימה של עשרה מחירי נכתבות שלושי הוראות‪ .‬עבור רשימה של‬
‫מאה מחירי יכתבו ‪ 300‬הוראות‪ .‬ובעצ‪ ,‬עבור רשימות מחירי באורכי שוני ייכתבו‬
‫אלגוריתמי שבה מספר הוראות שונה‪ .‬כלומר‪ ,‬לא רק שמדובר באלגוריתמי ארוכי מאוד‪ ,‬אלא‬
‫שעבור שינוי קט
בהגדרת הבעיה )מספר המחירי(‪ ,‬יש צור לבצע שינוי משמעותי באלגורית‪.‬‬
‫הא נית
להימנע מ
הסירבול המתואר? הא נית
לכתוב אלגורית שבו יהיה אותו מספר הוראות‬
‫עבור רשימות מחירי באורכי שוני?‬
‫אכ
נית
‪ ,‬באמצעות הוראה לביצוע חוזר של קבוצת הוראות‪ .‬בפתרו
הבעיה הנוכחית‪ ,‬שבה יש להמיר‬
‫עשרה מחירי נית
להשתמש בהוראה הבאה לביצוע חוזר‪:‬‬
‫‪:íéîòô 10 òöá‬‬
‫÷‪éøìåã øéçî èåì‬‬
‫‪íéì÷ùá øéçîä ìù åëøò úà áùç‬‬
‫‪áùåçîä êøòä úà èìôë âöä‬‬
‫‪-248-‬‬
‫עבור רשימה של ‪ 100‬מחירי נית
לכתוב אלגורית הכולל הוראה לביצוע חוזר במבנה זהה‪ ,‬אלא‬
‫שבו מספר הפעמי המצוי
בכותרת ההוראה הוא ‪ 100‬במקו ‪.10‬‬
‫שימו ♥ לעימוד בהוראה לביצוע חוזר‪ .‬בהוראה זו )כמו בהוראה לביצוע בתנאי( אנו מזיזי פנימה‬
‫את קבוצת ההוראה לביצוע חוזר‪.‬‬
‫בחירת משתני‬
‫נשתמש במשתני הבאי מטיפוס ממשי‪:‬‬
‫‪ – dollarPrice‬ישמור מחיר דולרי‬
‫‪ – shekelPrice‬ישמור את ערכו בשקלי של המחיר השמור ב‪dollarPrice‬‬
‫‪ – rate‬ישמור את שער ההמרה מדולרי לשקלי‪.‬‬
‫האלגורית‬
‫‪rate-á äøîä øòù èåì÷ .1‬‬
‫‪.2‬‬
‫‪dollarPrice-á øéçî èåì÷ .2.1‬‬
‫‪-á íùäå dollarPrice-á øåîùä øéçîä ìù íéì÷ùá åëøò úà áùç .2.2‬‬
‫‪shekelPrice‬‬
‫‪shekelPrice ìù åëøò úà èìôë âöä .2.3‬‬
‫יישו האלגורית‬
‫הוראה לביצוע חוזר במבנה של ‪...íéîòô øôñî òöá‬‬
‫מיושמת ב ‪ Java‬על ידי משפט ‪.for‬‬
‫משפט ‪ for‬משתמש במשתנה בקרה‪ ,‬אשר שולט על ביצוע הלולאה‪ .‬למשל‪ ,‬א ברצוננו לבצע קבוצת‬
‫הוראות ‪ 10‬פעמי‪ ,‬כפי שברצוננו לעשות בפתרו
בעיה זו‪ ,‬נכתוב משפט ‪ for‬מהצורה הבאה‪:‬‬
‫)‪for (i = 1; i <= 10; i++‬‬
‫{‬
‫ההוראות לביצוע‬
‫}‬
‫משתנה הבקרה במשפט זה הוא ‪ .i‬ערכו מאותחל ל‪) 1‬כפי שמורה משפט ההשמה ‪ ,i = 1‬המהווה‬
‫את הרכיב הראשו
בסוגריי(‪ .‬בכל פע אחרי שסדרת ההוראות לביצוע מתבצעת פע אחת ערכו של‬
‫משתנה הבקרה גדל ב‪) 1‬על כ מורה הרכיב השלישי בסוגריי‪ ,(i++ :‬והביצוע החוזר יימש כל עוד‬
‫ערכו של ‪ i‬קט
או שווה ל‪) 10‬כפי שמורה התנאי ‪ ,i <= 10‬הרכיב השני בסוגריי(‪.‬‬
‫‪-249-‬‬
‫א כ‪ ,‬בתחילת הביצוע של משפט ה‪ i ,for‬יאותחל ל‪ .1‬אחרי שקבוצת ההוראות לביצוע תבוצע‬
‫פע אחת‪ ,‬ערכו יגדל ל‪ .2‬אחרי שקבוצת ההוראות תבוצע פע שנייה‪ ,‬ערכו יגדל ל‪ .3‬אחרי שקבוצת‬
‫ההוראות תבוצע פע עשירית‪ ,‬ערכו כבר יהיה ‪ ,11‬ואז יסתיי הביצוע החוזר‪ ,‬משו שערכו של‬
‫התנאי ‪ i <= 10‬יהיה ‪.false‬‬
‫באופ
כללי‪ ,‬בביצוע משפט ‪ ,for‬מוש ער תחילי במשתנה הבקרה על פי הרכיב הראשו
במשפט‪.‬‬
‫לאחר מכ
מתבצעת בדיקת התנאי‪ ,‬המתואר ברכיב השני‪ .‬א ערכו של התנאי הוא ‪ true‬מתבצעות‬
‫ההוראות לביצוע‪ .‬בתו ביצוע קבוצת ההוראות גדל ערכו של משתנה הבקרה לפי השינוי המוגדר‬
‫ברכיב השלישי‪ .‬כעת מתבצעת שוב בדיקת התנאי‪ .‬א ערכו של התנאי הוא ‪ true‬מתבצעת שוב קבוצת‬
‫ההוראות וכ הלאה‪ ,‬עד אשר ערכו של התנאי הוא ‪ false‬ואז מסתיי הביצוע‪.‬‬
‫באופ
דומה‪ ,‬נית
היה לבחור ג במשפט ‪ for‬הבא ליישו ההוראה לביצוע חוזר שבאלגורית‪:‬‬
‫)‪for (i = 0; i < 10; i++‬‬
‫{‬
‫הוראות לביצוע‬
‫}‬
‫ג במקרה זה ההוראות לביצוע מתבצעות ‪ 10‬פעמי‪ :‬פע אחת כאשר ערכו של ‪ i‬שווה ל‪ ,0‬פע‬
‫שנייה כאשר ערכו שווה ל‪ ,1‬פע שלישית כאשר ערכו שווה ל‪ ,2‬ובפע העשירית ואחרונה כאשר‬
‫ערכו של ‪ i‬שווה ל‪ .9‬כאשר ערכו של ‪ i‬גדל שוב‪ ,‬ומגיע ל‪ ,10‬התנאי להמש הביצוע כבר לא מתקיי‪,‬‬
‫והביצוע החוזר מסתיי‪.‬‬
‫שימו ♥‪ :‬ההוראה ‪ i++‬היא למעשה הוראת השמה מקוצרת‪ .‬היא שקולה להוראת ההשמה‬
‫‪ .i = i + 1‬נית
להשתמש בהוראה זו בכל מקו בתוכנית‪ ,‬לאו דווקא במשפט ‪.for‬‬
‫התוכנית המלאה‬
‫*‪/‬‬
‫הקלט‪ :‬שער ההמרה מדולרים לשקלים ורשימה של ‪ 10‬מחירים בדולרים‬
‫הפלט‪ :‬הערכים השקליים של ‪ 10‬המחירים הנתונים בדולרים‬
‫‪*/‬‬
‫‪public class Convertor‬‬
‫{‬
‫)‪public static void main (String [] args‬‬
‫{‬
‫קבוע‪ :‬מספר המחירים הנקראים מהקלט‪//‬‬
‫;‪final int HOW_MANY=10‬‬
‫שער ההמרה‪//‬‬
‫;‪double rate‬‬
‫מחיר בדולרים‪//‬‬
‫;‪double dollarPrice‬‬
‫‪-250-‬‬
‫מחיר בשקלים‪//‬‬
‫;‪double shekelPrice‬‬
‫משתנה בקרה‪//‬‬
‫;‪int i‬‬
‫קלט ‪//‬‬
‫;)"‪1. rate = In.readDouble("Insert the rate‬‬
‫‪//‬‬
‫ההוראה לביצוע חוזר‬
‫)‪2. for (i = 1; i <= HOW_MANY; i++‬‬
‫{‬
‫;)"‪2.1. dollarPrice = In.readDouble("Insert price in Dollars‬‬
‫;‪2.2. shekelPrice = dollarPrice * rate‬‬
‫;)‪2.3. System.out.println("Price in Shekels is " + shekelPrice‬‬
‫‪}// for‬‬
‫‪}// main‬‬
‫‪}// Convertor‬‬
‫מעקב‬
‫בטבלת מעקב הכוללת משפט ‪ for‬נכלול עמודה עבור משתנה הבקרה של המשפט‪ .‬בתוכנית לפתרו
‬
‫בעיה ‪ ,1‬ערכו של משתנה הבקרה‪ ,i ,‬גדל ב‪ 1‬אחרי כל ביצוע של קבוצת המשפטי לביצוע הכלולה‬
‫במשפט ‪ .for‬ערכו בביצוע החוזר הראשו
הוא ‪ 1‬וערכו בביצוע החוזר האחרו
הוא ‪.10‬‬
‫נעקוב אחר ביצוע התוכנית עבור הקלט הבא‪ :‬שער ההמרה הוא ‪ ,3‬ועשרת המחירי להמרה ה‪:‬‬
‫‪.10.1 5 18.2 120.3 200.01 50.3 60 71.05 61.03 100‬‬
‫כדי להימנע מהצגת טבלה ארוכה מדי‪ ,‬תכלול הטבלה הבאה מעקב רק אחרי עיבוד שני המחירי‬
‫הראשוני ושני המחירי האחרוני שבקלט‪.‬‬
‫פלט‬
‫‪Insert‬‬
‫‪the rate‬‬
‫‪Insert‬‬
‫‪price in‬‬
‫‪dollars‬‬
‫‪shekel‬‬
‫‪dollar‬‬
‫‪rate‬‬
‫?‬
‫?‬
‫?‬
‫?‬
‫?‬
‫‪3‬‬
‫?‬
‫?‬
‫‪3‬‬
‫?‬
‫‪10.1‬‬
‫‪3‬‬
‫‪1‬‬
‫‪30.3‬‬
‫‪10.1‬‬
‫‪3‬‬
‫‪1‬‬
‫‪30.3‬‬
‫‪10.1‬‬
‫‪3‬‬
‫‪1‬‬
‫‪i<=10‬‬
‫המשפט לביצוע‬
‫‪i‬‬
‫?‬
‫?‬
‫‪rate=In.readDouble("Insert‬‬
‫‪1‬‬
‫)"‪the rate‬‬
‫‪true‬‬
‫‪1‬‬
‫)‪for (i = 1; i <= 10; i++‬‬
‫‪2‬‬
‫‪dollarPrice‬‬
‫‪2.1‬‬
‫=‬
‫‪price‬‬
‫‪In.readDouble("Insert‬‬
‫;)"‪in dollars‬‬
‫* ‪shekelPrice = dollarPrice‬‬
‫‪2.2‬‬
‫;‪rate‬‬
‫‪Price in‬‬
‫‪Shekels‬‬
‫‪is 30.3‬‬
‫‪System.out.println("Price‬‬
‫‪in Shekels is " +‬‬
‫;)‪shekelPrice‬‬
‫‪-251-‬‬
‫‪2.3‬‬
2
for (i = 1; i <= 10; i++)
2
2.1
dollarPrice =
true
3
10.1
30.3
2
3
5
30.3
2
3
5
15
2
3
5
15
3
71.05
213.15
In.readDouble("Insert price
in dollars");
2.2
shekelPrice = dollarPrice *
Insert
price in
dollars
rate;
2.3
System.out.println("Price
in Shekels is " +
shekelPrice);
Price in
Shekels
is 15
.
.
.
2
for (i = 1; i <= 10; i++)
9
2.1
dollarPrice =
9
3
61.03
213.15
9
3
61.03
183.09
9
3
61.03
183.09
3
61.03
183.09
true
In.readDouble("Insert price
in dollars");
2.2
Insert
price in
dollars
rate;
2.3
in Shekels is " +
shekelPrice);
2
for (i = 1; i <= 10; i++)
10
2.1
dollarPrice
10
3
100
183.09
10
3
100
300
10
3
100
300
3
100
300
true
=In.readDouble("Insert
price in dollars");
2.2
Price in
Shekels
is 183.09
Insert
price in
dollars
rate;
2.3
in Shekels is " +
shekelPrice);
2
for (i = 1; i <= 10; i++)
11
false
Price in
Shekels
is 300
.‫ ולבדיקת התנאי של משתנה הבקרה‬i ‫שימו לב לשינויי שחלי בערכו של משתנה הבקרה‬
1 ‫סוף פתרון בעיה‬
-252-
‫נציג את המושגי החדשי שהכרנו בפתרו
לדוגמה של בעיה ‪.1‬‬
‫באלגורית לפתרו
הבעיה כללנו הוראה לביצוע חוזר במבנה ‪...íéîòô øôñî òöá‬‬
‫כדי לציי
ביצוע חוזר של תתמשימה‪ .‬הוראה זו מורה על ביצוע חוזר של קבוצת הוראות מספר‬
‫פעמי‪ .‬הוראה לביצוע חוזר היא הוראת בקרה‪.‬‬
‫הוראה לביצוע חוזר נקראת ג לולאה‬
‫)‪ ,(loop‬וקבוצת ההוראות לביצוע הכלולות בה נקראת‬
‫גו הלולאה‪.‬‬
‫בדומה לכתיבה של הוראה לביצוע בתנאי ג כתיבה של הוראה לביצוע חוזר נעשית תו הקפדה על‬
‫עימוד מתאי‪ :‬קבוצת ההוראות שיש לחזור על ביצוע
מוזזת פנימה‪.‬‬
‫בשפת ‪ Java‬מיושמת הוראה לביצוע חוזר במבנה זה על ידי משפט ‪.for‬‬
‫זהו המבנה הכללי של משפט‬
‫‪ for‬בשפת ‪:Java‬‬
‫)שינוי משתנה הבקרה ;התנאי להמשך הביצוע ;אתחול משתנה הבקרה( ‪for‬‬
‫{‬
‫}‬
‫אתחול משתנה הבקרה‪ :‬הוראת השמה הקובעת ער התחלתי למשתנה הבקרה‪.‬‬
‫התנאי להמש‬
‫הביצוע‪ :‬ביטוי בוליאני שמהווה את התנאי השולט על הביצוע החוזר‪ .‬התנאי‬
‫נבדק אחרי האתחול‪ ,‬ונבדק שוב בכל פע שמסתיי ביצוע של קבוצת ההוראות לביצוע‪ .‬כל עוד‬
‫התנאי מתקיי הביצוע החוזר ממשי‪ .‬כאשר ערכו של התנאי הוא ‪ false‬הביצוע החוזר מסתיי‪.‬‬
‫שינוי משתנה הבקרה‪ :‬השינוי שחל במשתנה הבקרה בכל פע שמסתיי שלב ביצוע נוס‪.‬‬
‫בטבלת‬
‫מעקב אחר תוכנית הכוללת משפט ‪ for‬אנו כוללי עמודה עבור משתנה הבקרה ועמודה‬
‫עבור התנאי של משתנה הבקרה‪.‬‬
‫משתנה הבקרה במשפט ‪ for‬הוא בדר כלל מטיפוס של‪ .‬מאחר שבמקרי רבי תפקידו של משתנה‬
‫הבקרה הוא רק לשלוט על המשפט ‪ ,for‬ואי
בו שימוש בחלקי התוכנית האחרי‪ ,‬שפת ‪Java‬‬
‫מאפשרת להצהיר על משתנה הבקרה בתו הוראת ה ‪ ,for‬כלומר‪ ,‬נוכל לכתוב‪:‬‬
‫) ‪for (int i = 1; i <= 10; i++‬‬
‫‪-253-‬‬
‫ע זאת‪ ,‬כדי שהתוכנית תהיה קריאה ובהירה מוטב לנהוג כ רק כאשר אי
למשתנה זה תפקיד מעבר‬
‫למשפט ‪.for‬‬
‫שאלה ‪7.1‬‬
‫בנו טבלת מעקב אחר מהל ביצוע התוכנית ‪) Convertor‬לפתרו
בעיה ‪ (1‬עבור הקלט שבו שער‬
‫ההמרה הוא ‪ 4.5‬ועשרת המחירי להמרה ה‪:‬‬
‫‪5.05 18.01 17.03 20.9 101 105 213.05 16.1 17.2 18.3‬‬
‫פרטו בטבלה רק את השורות המתאימות לעיבוד שני הקלטי הראשוני ושני הקלטי האחרוני‬
‫)בדומה לנעשה בפתרו
בעיה ‪.(1‬‬
‫שאלה ‪7.2‬‬
‫נסחו עבור כל אחת מ
הבעיות האלגוריתמיות הבאות קבוצת תתמשימות לביצוע חוזר‪:‬‬
‫א‪ .‬הקלט הוא ‪ 20‬מרחקי‪ ,‬נתוני במיילי‪ ,‬והפלט הוא ‪ 20‬המרחקי בקילומטרי )‪ 1‬מייל = ‪1.6‬‬
‫קילומטר(‪.‬‬
‫ב‪ .‬הקלט הוא עשר אותיות מ
ה‪ ,ABC‬השונות מהאות ‪ ,Z‬והפלט הוא עשר האותיות שעוקבות‬
‫לאותיות הנתונות‪.‬‬
‫ג‪ .‬הקלט הוא ‪ 40‬זוגות של ציוני )זוג ציוני עבור כל תלמיד(‪ ,‬והפלט הוא רשימה של ארבעי‬
‫מספרי‪ :‬כל מספר הוא ממוצע של זוג הציוני המתאי לו‪.‬‬
‫שאלה ‪7.3‬‬
‫לפניכ קטע תוכנית‪:‬‬
‫;)'‪System.out.print('X‬‬
‫)‪for (i = 0; i < 10; i++‬‬
‫{‬
‫;)"*"(‪System.out.print‬‬
‫}‬
‫;)'‪System.out.print('X‬‬
‫מהו פלט קטע התוכנית?‬
‫שאלה ‪7.4‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא תו‪ ,‬והפלט שלו הוא שכפול של התו הנקלט חמישי‬
‫פעמי‪ .‬למשל‪ ,‬עבור הקלט ‪ A‬יהיה הפלט ‪) AAA...AA‬חמישי פעמי(‪.‬‬
‫בשלב החלוקה לתתמשימות הקפידו על ניסוח תתמשימה לביצוע חוזר‪.‬‬
‫‪-254-‬‬
‫שאלה ‪7.5‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא ‪ 20‬מספרי שלמי חיוביי דוספרתיי‪ ,‬והפלט שלו‬
‫הוא סכו הספרות של של כל אחד מהמספרי הנתוני‪.‬‬
‫למשל‪ ,‬א הקלט הוא‪:‬‬
‫‪11 17 99 10 20 30 10 20 30 10 20 30 10 10 20 20 30 30 88 15‬‬
‫הפלט המתאי הוא‪:‬‬
‫‪2 8 18 1 2 3 1 2 3 1 2 3 1 1 2 2 3 3 16 6‬‬
‫בשלב החלוקה לתתמשימות הקפידו על ניסוח תתמשימה לביצוע חוזר‪ ,‬ובשלב הבדיקה הקפידו על‬
‫בדיקה מסודרת באמצעות טבלת מעקב‪.‬‬
‫בפתרו
בעיה ‪ 1‬מספר הפעמי לביצוע חוזר נקבע עוד לפני תחילת ביצוע התוכנית‪ .‬במקרי רבי‪,‬‬
‫ייתכ
כי מספר הפעמי לביצוע חוזר ידוע לפני שמתחיל ביצועה של ההוראה לביצוע חוזר‪ ,‬א לא‬
‫לפני תחילת ביצוע התוכנית‪ .‬כלומר‪ ,‬הוא תלוי בקלט‪ .‬מקרה כזה מודג בבעיה הבאה‪:‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת ביצוע חוזר שאורכו נקבע על פי נתו
קלט‪.‬‬
‫פתחו אלגורית שיקבל כקלט מספר של ‪ ,N‬ויציג על המס שורה של כוכביות באור ‪.N‬‬
‫‪ .1‬קליטת אורך הרשימה‬
‫‪ .2‬הדפסת כוכביות לפי המספר הנקלט‬
‫רשימת המשתני‬
‫עד עתה השתמשנו בתנאי לסיו הביצוע החוזר במספרי קבועי‪ .‬בבעיה זו אנו נדרשי לקבל כקלט‬
‫את מספר הפעמי שתתבצע הלולאה‪ ,‬ולכ
התנאי להמש הביצוע צרי להיות תלוי בערכו של‬
‫משתנה‪.‬‬
‫‪ – numOfTimes‬מספר הפעמי שיש לצייר כוכבית‬
‫‪ – i‬משתנה הבקרה של הלולאה‬
‫‪numOfTimes-ì íìù øôñî èåì÷ .1‬‬
‫‪.2‬‬
‫‪:íéîòô numOfTimes òöá‬‬
‫‪'*' ñôãä .2.1‬‬
‫‪-255-‬‬
‫בפתרו
בעיה ‪ ,1‬כאשר רצינו לבצע קבוצת משימות ‪ 10‬פעמי יישמנו זאת על ידי משפט‬
‫‪for‬‬
‫שכותרתו‬
‫)‪for(i = 1; i <= 10; i++‬‬
‫)או על ידי המשפט שכותרתו )‪ ,for(i = 1; i <= HOW_MANY; i++‬כאשר ‪ HOW_MANY‬הוא קבוע‬
‫שערכו ‪.(10‬‬
‫כעת אנחנו רוצי לבצע את הוראה ‪ numOfTimes 2.1‬פעמי‪ .‬לכ
נייש את ההוראה לביצוע חוזר‬
‫על ידי משפט ‪ for‬שכותרתו‪:‬‬
‫)‪for(i = 1; i <= numOfTimes; i++‬‬
‫‪public class Stars‬‬
‫{‬
‫{‬
‫;‪int numOfTimes‬‬
‫;)"‪numOfTimes = In.readInt("Insert a number please‬‬
‫)‪for (int i = 1; i <= numOfTimes; i++‬‬
‫{‬
‫;)'*'(‪System.out.print‬‬
‫‪} // for‬‬
‫‪} // main‬‬
‫‪} // Stars‬‬
‫סוף פתרון בעיה ‪2‬‬
‫בתוכנית ‪ Stars‬ראינו שימוש בנתו
קלט לקביעת מספר הפעמי של ביצוע לולאה‪ .‬בפיתוח‬
‫אלגוריתמי בהמש נשתמש בכ פעמי רבות‪.‬‬
‫דר הבעיה הבאה נכיר שני סוגי של משתני המשמשי בפתרו
בעיות רבות‪ ,‬ותבנית העבודה אית‬
‫היא שימושית מאוד‪ .‬כפי שנראה‪ ,‬תבנית העבודה ע משתני כאלה מערבת שימוש בהוראות לביצוע‬
‫חוזר‪.‬‬
‫‪-256-‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת מונה וצובר ואופ
העבודה אית‪.‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא מספר חיובי של‪ ,‬ולאחריו רשימה של מספרי‬
‫ממשיי‪ ,‬שאורכה שווה לער הקלט הראשו
‪ .‬הפלט שלו הוא ממוצע המספרי ברשימה ומספר‬
‫המספרי ברשימה שערכ עולה על ‪.50‬‬
‫למשל‪ ,‬עבור הקלט‪:‬‬
‫‪23.4 100 95 78 64.15 75 90.3 54.2 67 20‬‬
‫הפלט המתאי הוא‪66.7 8 :‬‬
‫משו שממוצע המספרי הוא ‪ ,66.7‬ו‪ 8‬מתוכ ה גדולי מ‪.50‬‬
‫‪ .1‬קליטת אורך הרשימה‬
‫‪ .2‬קליטת רשימת הערכים‪ ,‬סיכומם‪ ,‬ומניית מספר הערכים הגבוהים מ‪50-‬‬
‫‪ .3‬חישוב ממוצע הערכים‬
‫‪ .4‬הצגה כפלט של הממוצע שחושב ושל מספר הערכים הגבוהים מ‪50-‬‬
‫?‬
‫כדי לחשב את הממוצע יש לסכ את הערכי הנתוני בקלט‪ ,‬ובנוס יש למנות כמה מהערכי‬
‫הנתוני בקלט ה גבוהי מ‪ .50‬נית
לבצע ה
את פעולת הסיכו וה
את פעולת המנייה תו כדי‬
‫קריאת נתוני הקלט‪ .‬כיצד נית
לבטא זאת כהוראה לביצוע חוזר?‬
‫נית
לבצע את פעולת הסיכו על ידי הוספת כל ער שנקרא לסכו מצטבר‪ ,‬לפני קריאת הער הבא‪.‬‬
‫בדומה‪ ,‬נית
לבצע את פעולת המנייה על ידי השוואת כל ער שנקרא מהקלט ל‪ ,50‬והגדלת מונה‬
‫מתאי בכל פע שהער שנקלט עולה על ‪ .50‬לכ
‪ ,‬את תתמשימה ‪ 2‬נוכל לבצע על ידי ביצוע חוזר של‬
‫קבוצת ההוראות הבאה‪:‬‬
‫‪ .2.1‬קליטת ערך‬
‫‪ .2.2‬הוספת הערך שנקלט לסכום המצטבר‬
‫‪ .2.3‬השוואת הערך שנקלט ל‪ .50-‬אם גבוה מ‪ ,50-‬הגדלת ערכו של מונה למניית מספר‬
‫הערכים הגבוהים מ‪.50-‬‬
‫מ
התתמשימות לביצוע חוזר נית
להסיק שיש להשתמש במשתנה אשר בו יישמר ער תור
שנקרא‬
‫מהקלט‪ ,‬במשתנה שיצבור את סכו הערכי‪ ,‬ובמשתנה שימנה את מספר הערכי הגבוהי מ‪.50‬‬
‫לכ
‪ ,‬ניעזר במשתני הבאי‪:‬‬
‫‪-257-‬‬
‫‪ – length‬מטיפוס של‪ ,‬ישמור את אור רשימת המספרי‬
‫‪ – num‬מטיפוס ממשי‪ ,‬ישמור ער תור
הנקרא מהקלט‬
‫‪ – sum‬מטיפוס ממשי‪ ,‬צובר שישמור את סכו הערכי‬
‫‪ – average‬מטיפוס ממשי‪ ,‬ישמור את ממוצע הערכי‬
‫‪ – counterLarge‬מטיפוס של‪ ,‬מונה שישמור את מספר הערכי הגבוהי מ‪50‬‬
‫שימו ♥‪ :‬המשתני ‪ sum ,num ,average‬ה מטיפוס ממשי‪ ,‬כיוו
שערכי הקלט בבעיה ה‬
‫ממשיי‪ .‬לעומת ‪ counterLarge‬הוא מטיפוס של כיוו
שהוא משמש למנייה‪.‬‬
‫את ההוראה לביצוע חוזר נוכל לנסח באופ
הבא‪:‬‬
‫‪:íéîòô length òöá‬‬
‫‪.1‬‬
‫÷‪num-á éùîî êøò èåì‬‬
‫‪.2‬‬
‫‪sum-á øåîùä øáèöîä íåëñì num ìù åëøò úà óñåä‬‬
‫‪.3‬‬
‫‪íà‬‬
‫‪.3.1‬‬
‫‪50-î ìåãâ num ìù åëøò‬‬
‫‪counterLarge ìù åëøò úà 1-á ìãâä‬‬
‫שימו ♥שקבוצת ההוראות לביצוע חוזר )גו הלולאה( כוללת הוראה לביצוע בתנאי‪.‬‬
‫?‬
‫אילו הוראות יש להוסי לפני ההוראה לביצוע חוזר?‬
‫כדי שהצבירה והמנייה יתבצעו באופ
נכו
‪ ,‬עלינו לאתחל נכונה את הערכי של ‪ sum‬ושל‬
‫‪ .counterLarge‬על פי תפקיד של שני המשתני באלגורית יש לאתחל את ערכיה ל‪.0‬‬
‫‪-258-‬‬
:‫הנה האלגורית המלא‬
0-ì sum úà ìçúà .1
0-ì counterLarge úà ìçúà .2
length-á íìù éáåéç êøò èåì÷ .3
:íéîòô length òöá
.4
num-á éùîî êøò èåì÷ .4.1
sum-á øåîùä øáèöîä íåëñì num ìù åëøò úà óñåä .4.2
50-î ìåãâ num ìù åëøò
íà
.4.3
counterLarge ìù åëøò úà 1-á ìãâä .4.3.1
average-á íùäå sum/length éãé ìò íéëøòä òöåîî úà áùç .5
average ìù åëøò úà èìôë âöä .6
counterLarge ìù åëøò úà èìôë âöä .7
/*
‫ רשימת ערכים ממשיים‬:‫קלט‬
50-‫ ממוצע הערכים ומספר הערכים הגבוהים מ‬:‫פלט‬
*/
public class CalcAvgAndCountLargerThan50
{
public static void main (String [] args)
{
// ‫הצהרה על קבוע בתוכנית‬
final int LIMIT = 50;
// ‫הצהרה על משתנים בתוכנית‬
int length;
//‫אורך רשימת הקלט‬
double num;
//‫ערך קלט תורן‬
double sum = 0; // ‫צובר‬
double average; // ‫ממוצע‬
int
counterLarge = 0;
//50-‫מונה למספר הערכים הגבוהים מ‬
length = In.readInt("Insert length of input list");
//
‫ההוראה לביצוע חוזר‬
-259-
‫)‪for (int i = 1; i <= length; i++‬‬
‫{‬
‫;)"‪num = In.readDouble("Insert number‬‬
‫;‪sum = sum + num‬‬
‫)‪if (num > LIMIT‬‬
‫{‬
‫שקול ל‪// counterLarge=counterLarge+1 -‬‬
‫;‪counterLarge++‬‬
‫‪}// if‬‬
‫‪}// for‬‬
‫;‪average = sum / length‬‬
‫;)‪System.out.println("Average is " + average‬‬
‫‪System.out.println(counterLarge + " numbers are larger then " +‬‬
‫;)‪LIMIT‬‬
‫‪}// main‬‬
‫‪}// CalcAvgAndCountLargerThan50‬‬
‫באלגורית לפתרו
בעיה ‪ 3‬משמש המשתנה ‪ sum‬כצובר של הערכי הנתוני‪.‬‬
‫צובר‬
‫הינו משתנה אשר תפקידו לצבור ערכי‪ .‬למשל‪ ,‬נית
להשתמש בצובר לסכימת ערכי‪.‬‬
‫המשתנה ‪ counterLarge‬משמש באלגורית לפתרו
בעיה ‪ 3‬כמונה של מספר הערכי הגבוהי מ‪50‬‬
‫מבי
הערכי הנתוני‪.‬‬
‫מונה‬
‫הינו משתנה אשר תפקידו למנות מספר פעמי שהתרחש אירוע מסוי )למשל‪ ,‬מספר הפעמי‬
‫שנקרא נתו
קלט(‪ .‬כיוו
שהשימוש במונה הוא לספירה‪ ,‬מונה הוא משתנה מטיפוס של‪.‬‬
‫בתוכנית לפתרו
בעיה ‪ 3‬מופיעי המשפטי המבטאי את פעולות הצבירה והמנייה בגו הלולאה‪,‬‬
‫לאחר משפט הקלט‪.‬‬
‫המשפט המבטא את פעולת הצבירה בגו הלולאה הוא‪:‬‬
‫;‪sum = sum + num‬‬
‫המשפט המבטא את פעולת המנייה בגו הלולאה הוא‪:‬‬
‫;‪counterLarge++‬‬
‫מאחר שתחזוקה של מונה או צובר מערבת ביצוע של פעולות עדכו
חוזרות ונשנות‪ ,‬מתבצעות בדר‬
‫כלל פעולות צבירה ומנייה בגו הלולאה‪.‬‬
‫שימו ♥ שבשני המקרי מתווס ער למשתנה המשמש כצובר או מונה‪ .‬במקרה של צובר מתווס‬
‫לצובר ער ששיי לקבוצת הערכי המצטברי‪ .‬במקרה של מונה מתווס למונה הער ‪.1‬‬
‫‪-260-‬‬
‫באלגורית בו יש שימוש בצובר או במונה יש לאתחל את הצובר או את המונה‪ .‬בתוכנית לפתרו
‬
‫הבעיה מאותחלי הצובר ‪ sum‬והמונה ‪ counterLarge‬ל‪.0‬‬
‫איתחול של צובר או‬
‫מונה הוא השמת ער אשר מתאי לתחילת תהלי הצבירה או המנייה‪.‬‬
‫מונה מאותחל בדר כלל ל‪ .0‬הער התחילי המתאי לצובר תלוי במהות הצבירה המתבצעת בו‪.‬‬
‫למשל‪ ,‬צובר השומר סכו מצטבר יאותחל ל‪.0‬‬
‫שאלה ‪7.6‬‬
‫שנו את המשפטי שבגו הלולאה שבתוכנית לפתרו
בעיה ‪ 3‬כ שיחושב ממוצע הערכי הגבוהי מ‬
‫‪.50‬‬
‫שאלה ‪7.7‬‬
‫לפעמי נית
להשתמש בערכו של מונה לחישוב מספר הנתוני שה בעלי מאפיי
הפו למאפיי
של‬
‫הנתוני הנימני באמצעות המונה‪ .‬למשל‪ ,‬נניח שבבעיה ‪ 3‬יש להציג כפלט ג את מספר הערכי‬
‫הקטני או שווי ל‪.50‬‬
‫דר אחת לחישוב מספר זה היא באמצעות שימוש במונה חדש ‪) counterSmall‬נוס ל‬
‫‪ ,(counterLarge‬אשר ערכו יוגדל ב‪ 1‬בכל פע שנקרא מהקלט ער הקט
או שווה ל‪.50‬‬
‫א בעצ אי
צור במונה נוס‪ .‬נית
לבצע את החישוב אחרי תו ביצוע הלולאה‪ ,‬באמצעות המונה‬
‫‪ counterLarge‬המופיע כבר בתוכנית‪ .‬כיצד? הוסיפו לתוכנית את ההוראה או ההוראות‬
‫המתאימות‪.‬‬
‫שאלה ‪7.8‬‬
‫ציינו עבור כל אחת מ
הבעיות האלגוריתמיות הבאות הא נחו‪ ,‬לפתרונה צובר‪ ,‬מונה‪ ,‬או א אחד‬
‫מהשניי‪:‬‬
‫א‪ .‬קלט‪ :‬רשימת מחירי‬
‫פלט‪ :‬ס כל המחירי‬
‫ב‪ .‬קלט‪ :‬רשימת מחירי‬
‫פלט‪ :‬מספר המחירי הגבוהי מ‪100‬‬
‫ג‪ .‬קלט‪:‬רשימת מחירי‬
‫פלט‪ :‬מספר המחירי שמרכיב האגורות בה שונה מ‪0‬‬
‫ד‪ .‬קלט‪ :‬רשימת מספרי‬
‫פלט‪ :‬הער המוחלט של כל אחד מהמספרי‬
‫ה‪ .‬קלט‪ :‬רשימת מספרי‬
‫פלט‪ :‬הממוצע של הערכי המוחלטי של המספרי‪.‬‬
‫‪-261-‬‬
‫שאלה ‪7.9‬‬
‫יש לקלוט סדרה של תווי‪ ,‬אשר אורכה שמור במשתנה ‪ ,listSize‬ולמנות את מספר התווי שה‬
‫אותיות גדולות )‪ (capital letters‬ב‪.ABC‬‬
‫בחרו משתני‪ ,‬כתבו הוראה לביצוע חוזר אשר לפניה אתחול מתאי‪ ,‬ויישמו אותה על ידי משפט‬
‫‪.for‬‬
‫שאלה ‪7.10‬‬
‫מטרת קטע התוכנית הבא היא מניית מספר תווי קלט אשר שוני מ
האות ‪ .A‬המשתני‬
‫‪counter‬‬
‫ו ‪ listSize‬ה מטיפוס של והמשתנה ‪ letter‬הוא מטיפוס תווי‪.‬‬
‫; __________ = ‪int counter‬‬
‫)‪for (int i = 1; i <= listSize; i++‬‬
‫{‬
‫;)"‪= In.ReadChar ("Insert char‬‬
‫‪letter‬‬
‫)____________( ‪if‬‬
‫{‬
‫__________‬
‫}‬
‫‪}// for‬‬
‫" ‪System.out.println("There are " + counter + "letters different than A‬‬
‫;)‪+ counter‬‬
‫קטע התוכנית כולל לולאה‪.‬‬
‫א‪ .‬כמה פעמי תתבצע הלולאה עבור הער ‪ 10‬ב‪?listSize‬‬
‫ב‪ .‬כמה פעמי תתבצע הלולאה עבור הער ‪ 1‬ב‪?listSize‬‬
‫ג‪ .‬השלימו את קטע התוכנית‪.‬‬
‫שאלה ‪7.11‬‬
‫נתונה התוכנית הבאה‪:‬‬
‫*‪/‬‬
‫קלט‪ :‬טור של ‪ 15‬תווים מטופס ספורטוטו‬
‫פלט‪______________________________________:‬‬
‫‪*/‬‬
‫‪public class Toto‬‬
‫{‬
‫{‬
‫;‪final int NUM_OF_GAMES = 15‬‬
‫;‪int d = 0‬‬
‫;‪char score‬‬
‫‪-262-‬‬
‫)‪for (int i = 0; i < NUM_OF_GAMES; i++‬‬
‫{‬
‫;)"‪score = In.readChar("Insert the score‬‬
‫)'‪if (score == 'X‬‬
‫{‬
‫;‪d++‬‬
‫‪} // if‬‬
‫‪} // for‬‬
‫;)‪System.out.println(d‬‬
‫‪} // main‬‬
‫‪} // Toto‬‬
‫קלט התוכנית הוא טור בטופס הספורטוטו‪ .‬כלומר‪ 15 ,‬תווי שכל אחד מה מציי
תוצאת משחק )‪,1‬‬
‫‪ 2‬או ‪.(X‬‬
‫א‪ .‬מהו הפלט עבור הקלט‪?12X12X12X12X12X :‬‬
‫ב‪ .‬הא התוכנית כוללת מונה או צובר? א כ
‪ ,‬מהו או מה?‬
‫ג‪ .‬כמה פעמי תתבצע לולאת התוכנית?‬
‫ד‪ .‬הביאו דוגמת קלט אשר הפלט עבורה הוא ‪.0‬‬
‫ה‪ .‬הביאו דוגמת קלט אשר הפלט עבורה הוא ‪.15‬‬
‫ו‪ .‬מה מאפיי
את הקלטי אשר הפלט עבור הוא ‪?1‬‬
‫ז‪ .‬מה ערכי הפלט האפשריי?‬
‫ח‪ .‬מהי מטרת התוכנית? בחרו ש משמעותי למשתנה ‪.d‬‬
‫שאלה ‪7.12‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא מספר המציי
אור של רשימה ואחריו רשימה באור‬
‫הנתו
של מספרי ממשיי‪ .‬הפלט שלו הוא סכו החלקי השלמי של המספרי הממשיי‬
‫הנתוני‪.‬‬
‫בדוגמאות שראינו עד כה שימש צובר לצבירת סכו‪ .‬א נית
להשתמש בצובר ג לצבירת מכפלה‪.‬‬
‫כאשר צובר משמש לצבירת מכפלה הוא מאותחל לער שונה מ‪ .0‬שימו לב לכ בשאלה הבאה‪:‬‬
‫שאלה ‪7.13‬‬
‫פתחו ויישמו אלגורית שיקבל כקלט רשימה של ‪ 50‬מספרי ויציג כפלט את מכפלת של המספרי‬
‫הקטני מ‪.10‬‬
‫להעמקה בתבניות מנייה וצבירה פנו לעמוד ‪ .321‬בעיה ‪ 3‬השתמשה ג בתבנית ממוצע‪ .‬להעמקה‬
‫בתבניות ממוצע עבור סדרה שיכולה להכיל יותר מ‪ 3‬ערכי פנו לעמוד ‪.332‬‬
‫‪-263-‬‬
‫מטרת הבעיה ופתרונה‪ :‬עוד על הוראה לביצוע חוזר באור ידוע מראש‪ :‬הצגת הוראה לביצוע חוזר‬
‫המבצעת עיבוד על איברי תחו‪ ,‬והדגמת שימוש במשתנה הבקרה בתו גו הלולאה‪.‬‬
‫פתחו ויישמו אלגורית‪ ,‬שיקבל כקלט מספר של‪ ,‬ויציג כפלט את כל המספרי השלמי החיוביי‬
‫הקטני מהמספר הנתו
‪ .‬למשל‪ ,‬עבור הקלט ‪ ,5‬הפלט המתאי הוא‪4 :‬‬
‫‪3‬‬
‫‪2‬‬
‫‪.1‬‬
‫ברצוננו לקלוט מספר של‪ ,num ,‬ולבצע הצגה כפלט של ‪ num−1‬ערכי‪ ,‬מ‪ 1‬עד ‪ .num−1‬א כ‪,‬‬
‫החלוקה לתתמשימות היא ברורה למדי‪:‬‬
‫‪ .1‬קליטת מספר מהקלט‬
‫‪ .2‬הצגה כפלט של כל הערכים החיוביים והשלמים שקטנים מהמספר שנקלט‬
‫ברור כי לש ביצוע תתמשימה ‪ 2‬נזדקק להוראה לביצוע חוזר‪ ,‬שתתבצע ‪ num−1‬פעמי‪.‬‬
‫ברור כי נזדקק למשתנה עבור הער הנקרא מהקלט‪ .‬סביר כי נהיה ג זקוקי למשתנה כלשהו‪ ,‬עבור‬
‫האיבר התור
להצגה‪ .‬משתנה זה יאותחל ל‪ 1‬ויקוד בסיו כל סיבוב בלולאה ב‪ ,1‬עד אשר ערכו‬
‫יגיע ל‪.num‬‬
‫אבל‪ ,‬איננו זקוקי למשתנה נוס'‪ ,‬כי תיאור זה מתאי בדיוק למשתנה הבקרה של ההוראה לביצוע‬
‫חוזר!‬
‫לכ
‪ ,‬נקבל את רשימת המשתני הבאה‪:‬‬
‫‪ – num‬מטיפוס של‪ ,‬לשמירת הער הנקרא מהקלט‬
‫‪ – i‬משתנה הבקרה‬
‫כאמור‪ ,‬תתמשימה ‪ 2‬משרה הוראה לביצוע חוזר‪ .‬למעשה‪ ,‬בהוראה זו אנו מעונייני לעבור על תחו‬
‫של ערכי )מהער ‪ 1‬ועד הער ‪ (num−1‬ולבצע עיבוד עבור כל ער בתחו )במקרה זה‪ ,‬להציגו כפלט(‪.‬‬
‫כדי לבטא זאת‪ ,‬ננסח את ההוראה לביצוע חוזר בצורה שונה מעט מזו שראינו באלגוריתמי קודמי‬
‫בפרק‪.‬‬
‫‪num-ì íìù øôñî èåì÷ .1‬‬
‫‪.2‬‬
‫‪:òöá num-î ïè÷ä íìù éáåéç i øôñî ìë øåáò‬‬
‫‪i ìù åëøò úà èìôë âöä .2.1‬‬
‫‪-264-‬‬
‫את הוראה ‪ 2‬באלגורית שכתבנו נייש על ידי משפט ‪ .for‬זהו משפט ‪ for‬הדומה מאוד לאלה‬
‫שראינו בתוכניות קודמות בפרק‪ ,‬רק שבו משתנה הבקרה אינו משמש רק כדי לשלוט על ביצוע‬
‫הלולאה‪ .‬יש התייחסות למשתנה הבקרה ג בתו גו הלולאה‪ ,‬ולא רק בשלושת הרכיבי שבכותרת‬
‫הלולאה‪.‬‬
‫*‪/‬‬
‫קלט‪ :‬מספר שלם‬
‫פלט‪ :‬כל המספרים השלמים והחיוביים הקטנים מהמספר הנתון‬
‫‪*/‬‬
‫‪public class PrintNumbers‬‬
‫{‬
‫)‪public static void main(String[] args‬‬
‫{‬
‫ערך הנקרא מהקלט ‪//‬‬
‫;‪int num‬‬
‫;)"‪num=In.readInt("Insert a number‬‬
‫)‪for (int i = 1; i < num; i++‬‬
‫{‬
‫;)‪System.out.print(i‬‬
‫‪} // for‬‬
‫‪} // main‬‬
‫‪} // PrintNumbers‬‬
‫שאלה ‪7.14‬‬
‫על פי הגדרת בעיה ‪ ,4‬יכול להינת
כנתו
ראשו
בקלט כל מספר של‪ .‬תארו את מהל ביצוע התוכנית‬
‫‪ PrintNumbers‬א הער הראשו
בקלט הוא המספר השל ‪ .0‬תארו את מהל הביצוע של התוכנית‬
‫א הער הראשו
בקלט הוא המספר השל ‪.-2‬‬
‫שאלה ‪7.15‬‬
‫פתחו אלגורית שמקבל כקלט מספר חיובי של ‪ ,n‬מחשב את !‪ ,n‬ומציג את הער שחושב כפלט‪.‬‬
‫ישמו את האלגורית בשפת ‪.Java‬‬
‫להזכירכ‪ n! :‬היא מכפלת המספרי מ‪ 1‬עד ‪ ,n‬כלומר‪.n! = 1⋅2⋅…⋅n :‬‬
‫‪-265-‬‬
‫שאלה ‪7.16‬‬
‫‪1 1‬‬
‫‪1‬‬
‫פתחו אלגורית שמקבל כקלט מספר חיובי של ‪ , n‬ומחשב את הסכו‪ . + + ... + :‬ישמו את‬
‫‪1 2‬‬
‫‪n‬‬
‫האלגורית בשפת ‪.java‬‬
‫כזכור‪ ,‬הרכיב השלישי במשפט ‪ for‬הוא משפט השמה‪ ,‬המתאר את השינוי של משתנה הבקרה בתו‬
‫כל סיבוב בלולאה‪ .‬עד עתה כתבנו תוכניות שבה
משתנה הבקרה גדל ב‪ 1‬בתו כל סיבוב של הלולאה‪.‬‬
‫אבל‪ ,‬לעיתי נרצה לקד את משתנה הבקרה ב‪ 3 ,2‬או אפילו פי ‪ .2‬שפת ‪ Java‬מאפשרת לנו לתאר‬
‫שינויי כאלה‪ ,‬פשוט על ידי כתיבת משפט השמה מתאי‪ .‬הנה מספר דוגמאות לכותרות משפטי‬
‫‪for‬‬
‫כאלה‪:‬‬
‫)‪for(int i = small; i < big; i = i + 2‬‬
‫)‪for(int i = small; i < big; i = i * 2‬‬
‫)‪for(int i = big; i > small; i--‬‬
‫)כפי שוודאי הבנת‪ i--,‬היא דר מקוצרת לכתוב‪.( i = i - 1:‬‬
‫במקרי רבי‪ ,‬אכ
מתאי לבצע עדכוני שוני של משתנה הבקרה‪ ,‬כפי שמדגימות השאלות‬
‫הבאות‪.‬‬
‫שאלה ‪7.17‬‬
‫לפניכ קטע תוכנית הכתוב ב‪java‬‬
‫)‪for (int i = 1; i <= 50; i = i * 2‬‬
‫{‬
‫;)‪System.out.println(i‬‬
‫}‬
‫א‪ .‬עקבו בעזרת טבלת מעקב אחר קטע התוכנית? מה יודפס?‬
‫ב‪ .‬נניח כי במקו הער ‪ 50‬מופיע ער חיובי של כלשהו‪ .N ,‬תארו מה מבצע קטע התוכנית‪ ,‬כתלות‬
‫בער ‪.N‬‬
‫שאלה ‪7.18‬‬
‫פתחו אלגורית‪ ,‬אשר מקבל כקלט מספר של‪ ,‬ומציג כפלט את כל המספרי הזוגיי החיוביי‬
‫הקטני מהמספר שנקרא‪.‬‬
‫‪-266-‬‬
‫‪ 7.2‬מציאת מקסימום או מינימום‬
‫שתיי מהבעיות הבסיסיות ביותר במדעי המחשב ה
חישוב הער הגדול ביותר או הקט
ביותר‬
‫ברשימה של ערכי נתוני‪ .‬פתרונ
מהווה תבנית שימושית מאוד‪ .‬בסעי זה נערו היכרות ע בעיות‬
‫אלו ונראה כי כאשר אור הרשימה ידוע נית
לפתור אות
בעזרת הוראה לביצוע חוזר באור ידוע‬
‫מראש‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת אופ
חישוב הער הגדול ביותר ברשימת ערכי נתוני שאורכה נתו
‬
‫א הוא‪.‬‬
‫מנהל סני הבנק החליט לבדוק מהו סכו הכס הגדול ביותר השמור בחשבונות של לקוחות הסני‪.‬‬
‫פתחו אלגורית אשר קולט את מספר החשבונות בסני‪ ,‬ולאחר מכ
את סכו הכס הנמצא בכל‬
‫חשבו
וחשבו
)כמספר ממשי(‪ .‬פלט האלגורית יהיה הסכו הגבוה ביותר‪ .‬ישמו את האלגורית‬
‫בשפת ‪.Java‬‬
‫ניתוח הבעיה בעזרת דוגמאות‬
‫נניח לרגע כי מדובר בסני בנק ייחודי‪ ,‬בו מתנהל חשבו
אחד בלבד‪ .‬ברור כי סכו הכס בחשבו
זה‬
‫הוא הגדול ביותר‪ .‬מייד אחרי שנקלט סכו הכס בחשבו
היחיד בסני‪ ,‬אפשר להכריז עליו כעל‬
‫הסכו הגדול ביותר‪.‬‬
‫א בסני מתנהלי שני חשבונות‪ ,‬ברור כי יש להשוות בי
סכו הכס בחשבו
הראשו
‪ ,‬לבי
זה‬
‫שבחשבו
השני‪ .‬הסכו הגדול מבי
אלה הוא ג הגדול ביותר בסני כולו‪.‬‬
‫א בסני מתנהלי שלושה חשבונות‪ ,‬יש להשוות קוד בי
שני הסכומי הראשוני הנקראי‬
‫מהקלט‪ .‬את הסכו השלישי יש להשוות לגדול מבי
השניי‪.‬‬
‫א כ‪ ,‬הרעיו
המרכזי בפתרו
הבעיה הוא בעצ לזכור בכל זמ) מהל הביצוע‪ ,‬מיהו הער הגדול‬
‫ביותר מבי
אלה שכבר נקלטו‪ .‬ער זה יושווה תמיד לער הבא שנקרא מהקלט‪ ,‬ויתעדכ
בהתא‬
‫לתוצאת ההשוואה‪.‬‬
‫את הרעיו
שתיארנו נוכל לבטא באמצעות התתמשימה הבאה‪ ,‬אשר על ביצועה יש לחזור לאחר כל‬
‫קליטת ער נוס‪:‬‬
‫השוואת הסכום האחרון שנקלט לסכום הגדול ביותר שנקלט עד כה ועדכון הסכום הגדול ביותר‬
‫שנקרא עד כה על פי תוצאת ההשוואה‬
‫‪-267-‬‬
‫נזדקק למשתנה שיזכור את מספר ערכי הקלט )מספר החשבונות(‪ ,‬ולמשתנה לשמירת הער התור
‬
‫בקלט‪ .‬בנוס נזדקק למשתנה כדי לזכור את הער הגדול ביותר מבי
אלה שנקלטו‪ .‬נבחר את‬
‫המשתני הבאי מטיפוס של‪:‬‬
‫‪ – howMany‬מספר הערכי ברשימת הנתוני‪ ,‬מספר החשבונות בסני‬
‫‪ – balance‬הער התור
ברשימת ערכי הקלט‬
‫‪ – max‬לשמירת הסכו הגדול ביותר מבי
אלה שנקלטו‬
‫‪ max‬יאותחל לסכו הראשו
ברשימה‪ ,‬כיוו
שמייד אחרי שנקרא הסכו הראשו
‪ ,‬הוא בוודאי הגדול‬
‫ביותר מבי
כל הסכומי שנקראו‪ .‬כעת יש לקרוא את כל הסכומי האחרי‪ ,‬בעזרת הוראה לביצוע‬
‫חוזר‪ .‬לאחר כל קליטה של סכו נוס‪ ,‬יש להשוות את הסכו החדש שנקלט לסכו הגדול ביותר‬
‫שנקרא עד כה )השמור ב‪ .(max‬א הסכו החדש גדול מזה השמור ב‪ ,max‬יישמר ב‪ max‬הסכו‬
‫החדש‪.‬‬
‫?‬
‫כמה פעמי צרי להתבצע גו ההוראה לביצוע חוזר?‬
‫הסכו הראשו
נקרא מהקלט עוד לפני הביצוע החוזר‪ ,‬לצור האתחול של המשתנה ‪ .max‬לכ
‪,‬‬
‫הלולאה צריכה להתבצע רק ‪ howMany–1‬פעמי‪ ,‬כדי לקלוט ולעבד את ערכי הקלט הנותרי‪.‬‬
‫הנה האלגורית המלא‪:‬‬
‫‪howMany-á úåðåáùçä øôñî úà èåì÷ .1‬‬
‫‪balance-á ïåùàøä íåëñä úà èåì÷ .2‬‬
‫‪max-á balance ìù åëøò úà íùä .3‬‬
‫‪.4‬‬
‫‪òöá‬‬
‫‪:íéîòô howMany-1‬‬
‫‪balance-á àáä íåëñä úà èåì÷ .4.1‬‬
‫‪.4.2‬‬
‫‪íà‬‬
‫‪max < balance‬‬
‫‪max-á balance ìù åëøò úà íùä .4.2.1‬‬
‫‪max ìù åëøò úà èìôë âöä .5‬‬
‫‪-268-‬‬
‫*‪/‬‬
‫קלט‪ :‬מספר חשבונות בנק‪ ,‬ורשימת הסכומים בחשבונות אלה‬
‫פלט‪ :‬הסכום הגבוה ביותר ברשימה‬
‫‪*/‬‬
‫‪public class FindMax‬‬
‫{‬
‫{‬
‫;‪int howMany‬‬
‫מספר הערכים ברשימה ‪//‬‬
‫;‪int balance‬‬
‫הסכום התורן ‪//‬‬
‫;‪int max‬‬
‫הסכום הגבוה ביותר מבין אלה שנקלטו‪//‬‬
‫;)"‪1. howMany = In.readInt("Insert the amount of accounts‬‬
‫;)"‪2. balance = In.readInt("Insert the first balance‬‬
‫אתחול המקסימום לסכום הראשון‪//‬‬
‫;‪3. max = balance‬‬
‫)‪4. for(int i = 2; i <= howMany; i++‬‬
‫{‬
‫;)‪4.1. balance = In.readInt("Insert balance of account " + i‬‬
‫הסכום הנוכחי גדול מהמקסימום הנוכחי‪//‬‬
‫)‪4.2. if (balance > max‬‬
‫{‬
‫;‪4.2.1. max = balance‬‬
‫‪} // if‬‬
‫‪} // for‬‬
‫;)‪5. System.out.println("The maximum is " + max‬‬
‫‪}// main‬‬
‫‪}// FindMax‬‬
‫שאלה ‪7.19‬‬
‫בנו טבלת מעקב אחר מהל ביצוע התוכנית ‪ FindMax‬לפתרו
בעיה ‪ 5‬עבור הקלט‪:‬‬
‫‪5 3 2 4 6 -9‬‬
‫כמה פעמי במהל ביצוע התוכנית על קלט זה מוש ער במשתנה ‪?max‬‬
‫שאלה ‪7.20‬‬
‫בפתרו
בעיה ‪ 5‬אותחל ‪ max‬לערכו של הנתו
הראשו
ברשימה‪ .‬הא הפתרו
היה נכו
לו ‪ max‬היה‬
‫מאותחל לער קבוע כלשהו‪ ,‬למשל ‪?0‬‬
‫‪-269-‬‬
‫שאלה ‪7.21‬‬
‫נתו
קטע התוכנית החלקי הבא לחישוב המספר הקט) ביותר ברשימת מספרי שליליי נתונה‪ ,‬אשר‬
‫אורכה שמור במשתנה ‪.len‬‬
‫_____________ = ‪min‬‬
‫;)"‪len = In.readInt("Insert the list size‬‬
‫)‪for (int i = 1; i <= len; i++‬‬
‫{‬
‫_________________________‬
‫_________________________‬
‫_________________________‬
‫}‬
‫;)‪System.out.println("The minimum is: " + min‬‬
‫השלימו את קטע התוכנית )הוסיפו משתנה או משתני במידת הצור(‪.‬‬
‫במשפט הראשו
אתחלו את ‪ min‬לער קבוע כלשהו )ולא לער הראשו
ברשימה(‪.‬‬
‫שאלה ‪7.22‬‬
‫פתחו ויישמו אלגורית שמקבל כקלט רשימה של ציוני במדעי המחשב של ‪ 40‬תלמידי‪ .‬הפלט הוא‬
‫הציו
הגבוה ביותר מבי
התלמידי שנכשלו במבח
)ציו
נכשל הוא ציו
הנמו מ‪.(55‬‬
‫שימו לב‪ :‬כא
הציו
התור
הנקרא מהקלט אינו מושווה בכל מקרה למקסימו הנוכחי‪ ,‬אלא רק‬
‫כאשר הוא קט
מ‪.55‬‬
‫כפי שראינו בתרגילי הקודמי‪ ,‬ישנ
דרכי שונות לאתחול בתבנית מציאת מקסימו )וכמוב
‪ ,‬כ‬
‫ג לגבי תבנית מציאת מינימו(‪ .‬המשתנה ששומר את המקסימו התור
‪ ,‬צרי בכל שלב לשמור את‬
‫האיבר הגדול ביותר מבי
האיברי שהושוו עד כה‪ .‬בדר כלל נעדי לאתחל את המשתנה הזה להיות‬
‫האיבר הראשו
ברשימה‪ .‬אכ
‪ ,‬אחרי שנקלט איבר אחד בלבד בוודאי שהוא הגדול מבי
כל אלה‬
‫שנקלטו‪ .‬א ישנ מיקרי שעובדה זו אינה מספיקה ולא נוכל להשתמש באתחול כזה‪ .‬כ‪ ,‬למשל‪,‬‬
‫בשאלה ‪ :7.22‬בשאלה זו אנו מעונייני למצוא מקסימו רק מבי
ציוני הנכשלי ולא מבי
כל‬
‫הציוני שבקלט‪ .‬כלומר‪ ,‬לא כל איבר שנקלט צרי להיות מושווה לצור מציאת מקסימו‪ .‬בפרט‪,‬‬
‫לא בטוח שהאיבר הראשו
הוא ציו
נכשל וייתכ
שהוא בכלל לא מועמד למקסימו‪ .‬לכ
יהיה זה‬
‫שגוי לקבוע אותו כמקסימו התחלתי‪.‬‬
‫במקרי כאלה נוכל להשתמש בקצוות של טווח הערכי האפשריי‪ .‬למשל‪ ,‬א מדובר בציוני‪,‬‬
‫ערכ יכול לנוע מ‪ 0‬עד ‪ .100‬במקרה כזה‪ ,‬נכו
יהיה לאתחל את המקסימו התור
ל‪) 0‬ואת‬
‫המינימו התור
ל‪ .(100‬כיוו
שברור שהער הראשו
שנשווה למקסימו התור
ערכו הוא לפחות ‪,0‬‬
‫הרי שמייד אחרי ההשוואה הראשונה המקסימו התור
יכיל את האיבר הראשו
שהושווה‪.‬‬
‫שימו ♥‪ :‬לא תמיד ידועי ערכי קצה לטווח הערכי האפשריי )ראו את שאלה ‪!(7.20‬‬
‫להעמקה בתבניות מציאת מקסימום ומציאת מינימום פנו לעמוד ‪.337‬‬
‫‪-270-‬‬
‫‪ 7.3‬מציאת מקום מקסימום או מינימום‬
‫בסעי זה נכיר בעיות הדומות לבעיית מציאת מקסימו או מינימו‪ ,‬א מעט יותר מורכבות‪ .‬ג‬
‫פתרונותיה
מהווי תבניות שימושיות‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת אופ
חישוב מקומו של הער הגדול ביותר והקט
ביותר ברשימת‬
‫ערכי נתוני‪.‬‬
‫בנג
‪ MP3‬שמורי ‪ 100‬שירי‪ .‬לכל שיר מספר ייחודי משלו בי
‪ 1‬ל‪ .100‬על צג המכשיר מוצגי‬
‫מספריה של השיר הארו ביותר והקצר ביותר שנמצאי בו‪ .‬עליכ לפתח אלגורית שיאפשר את‬
‫הצגת המידע הזה‪ .‬כלומר‪ ,‬האלגורית יקבל כקלט את רשימת אורכי ‪ 100‬השירי במכשיר‪ ,‬ופלט‬
‫האלגורית יהיה מספרו של השיר הארו היותר‪ ,‬ומספרו של השיר הקצר ביותר‪.‬‬
‫כמוב
שלצור פתרו
הבעיה יש למצוא את השיר הארו ביותר ואת השיר הקצר ביותר‪ .‬כלומר‪ ,‬יש‬
‫למצוא ברשימת אורכי השירי ער מקסימלי וער מינימלי‪ .‬אבל‪ ,‬בבעיה זו עלינו לשמור‪ ,‬מלבד הער‬
‫המקסימלי והער המינימלי‪ ,‬ג את מקומ של ערכי אלה ברשימה‪.‬‬
‫את הרעיו
המרכזי בפתרו
נוכל לבטא באמצעות התתמשימה הבאה‪ ,‬אשר על ביצועה יש לחזור‬
‫לאחר כל קליטת ער נוס‪:‬‬
‫השוואת אורך השיר האחרון שנקלט לאורך השיר הגדול ביותר שנקלט עד כה ולאורך השיר‬
‫הקצר ביותר שנקלט עד כה‪ ,‬ובהתאם לתוצאת ההשוואה עדכון ערך המקסימום ומקום‬
‫המקסימום ועדכון ערך המינימום ומקום המינימום‪.‬‬
‫‪ – currentSongLength‬מטיפוס ממשי‪ ,‬ישמור את אור השיר הנוכחי‪.‬‬
‫‪ – longest‬מטיפוס ממשי‪ ,‬ישמור את אור השיר הארו ביותר שנקלט עד כה‪.‬‬
‫‪ – shortest‬מטיפוס ממשי‪ ,‬ישמור את אור השיר הקצר ביותר שנקלט עד כה‪.‬‬
‫‪ – placeLongest‬מטיפוס של‪ ,‬ישמור את מקומו של השיר הארו ביותר שנקלט עד כה‪.‬‬
‫‪ – placeShortest‬מטיפוס של‪ ,‬ישמור את מקומו של השיר הקצר ביותר שנקלט עד כה‪.‬‬
‫שימו ♥ לבחירת טיפוסי המשתני‪ :‬המשתני ‪ longest‬ו‪ shortest‬אשר שומרי את האור‬
‫המקסימלי והאור המינימלי‪ ,‬חייבי להיות מאותו טיפוס כמו הערכי ברשימת הקלט‪ ,‬וכיוו
שכא
‬
‫‪-271-‬‬
‫ המשתני‬,‫ לעומת‬.‫ בחרנו בטיפוס ממשי‬,(‫מדובר באורכי שירי )שיכולי להיות לא שלמי‬
.‫ ולכ
ה מטיפוס של‬,‫ שומרי מקו ברשימה‬placeShortest‫ ו‬placeLongest
currentSongLength-á ïåùàøä øéùä êøåà úà èåì÷ .1
longest-á currentSongLength ìù åëøò úà íùä .2
shortest-á currentSongLength ìù åëøò úà íùä .3
1 êøòä úà placeLongest-ì íùä .4
1 êøòä úà placeShortest-ì íùä .5
:
íéîòô 99 òöá
.6
currentSongLength-á àáä øôñîä úà èåì÷ .6.1
currentSongLength > longest
íà
.6.2
longest-á currentSongLength úà íùä .6.2.1
placeLongest-á éçëåðä øéùä ìù åîå÷î úà íùä .6.2.2
currentSongLength < shortest
íà
.6.3
shortest-á currentSongLength úà íùä .6.3.1
placeShortest-á éçëåðä øéùä ìù åîå÷î úà íùä .6.3.2
placeShortest ìù åëøò úàå placeLongest ìù åëøò úà èìôë âöä .7
‫ ו‬placeLongest ‫ דאגנו לאתחל ג את‬,shortest‫ ו‬longest ‫ בדיוק כמו שדאגנו לאתחל את‬:♥ ‫שימו‬
,‫ אותחל לאורכו של השיר הראשו
ולכ
בהתא‬Longest .‫ באופ
עקבי‬,placeShortest
‫ ו‬shortest ‫כ ג לגבי האתחול של‬
.(1‫ ל‬,‫ אותחל למקו הראשו
)כלומר‬placeLongest
.placeShortest
?
‫כיצד נדע מהו מקומו של שיר נתו‬
?
‫ משתנה‬,‫ פעמי‬99 ‫ כדי שהלולאה תתבצע‬.for‫לש כ נוכל להשתמש במשתנה הבקרה של משפט ה‬
.
‫ וערכו של משתנה הבקרה יהיה בדיוק מספרו של השיר התור‬,100 ‫ עד‬2‫הבקרה יתקד מ‬
-272-
/*
MP3 ‫ השירים במכשיר‬100 ‫ רשימת אורכי‬:‫קלט‬
‫ ומספרו של השיר הקצר ביותר‬,‫ מספרו של השיר הארוך היותר‬:‫פלט‬
*/
public class Mp3
{
{
final int NUM_OF_SONGS=100;
// ‫הגדרת קבוע – מספר השירים בנגן‬
double currentSongLength; //‫אורך השיר הנוכחי‬
double shortest; // ‫אורך השיר הקצר ביותר‬
double longest; //‫אורך השיר הארוך ביותר‬
int placeLongest, placeShortest; // ‫מקומם של השיר הקצר והארוך‬
currentSongLength = In.readDouble("Insert the length of the
first song");
// ‫ המינימום ומקומם‬,‫איתחולם של המקסימום‬
longest = currentSongLength;
shortest = currentSongLength;
placeLongest = 1;
placeShortest = 1;
// ‫ כיוון שהשיר הראשון כבר נקלט‬2-‫הלולאה מתחילה מ‬
for(int i = 2; i <= NUM_OF_SONGS; i++)
{
currentSongLength = In.readDouble("Insert the length of song
" + i);
if (currentSongLength > longest)
{
longest = currentSongLength;
placeLongest = i;
} // if
if (currentSongLength < shortest)
{
shortest = currentSongLength;
placeShortest = i;
} // if
} // for
-273-
‫‪System.out.println("The number of the longest song is" +‬‬
‫;)‪placeLongest‬‬
‫‪System.out.println("The number of the shortest song is" +‬‬
‫;)‪placeShortest‬‬
‫‪} // main‬‬
‫‪}// class Mp3‬‬
‫שאלה ‪7.23‬‬
‫פתחו אלגורית שיקבל כקלט מספר חיובי של‪ ,‬המציי
את מספר שחקני מכבי ת"א‪ ,‬ואחר כ‬
‫יקלוט רשימה של נתוני קליעות של השחקני‪ :‬עבור כל שחק
ייקלט מספרו )המספר שעל החולצה‬
‫שלו(‪ ,‬ומספר הנקודות שקלע במהל העונה‪ .‬פלט האלגורית יהיה מספרו של השחק
שקלע הכי‬
‫הרבה במהל העונה‪.‬‬
‫שימו ♥‪ :‬במקרה זה‪ ,‬משתנה הבקרה אינו מצביע על ה"מקו" התור
)כלומר‪ ,‬מספר השחק
‬
‫התור
(‪ .‬את המקו התור
יש לקרוא מהקלט‪.‬‬
‫להעמקה בתבניות מציאת ערך נלווה למקסימום ומציאת ערך נלווה למינימום פנו לעמוד ‪.342‬‬
‫‪ 7.4‬ביצוע חוזר בתנאי‬
‫לצור פתרו
הבעיות שראינו עד כה נית
היה להשתמש בהוראה לביצוע חוזר אשר מספר הסיבובי‬
‫בה נקבע לפני תחילת הביצוע החוזר‪ :‬בפתרו
בעיה ‪ 1‬מספר הפעמי לביצוע חוזר היה ער קבוע של‬
‫התוכנית‪ ,‬וכ ג בפתרו
שנית
לבעיה ‪ .6‬בפתרו
בעיה ‪ 2‬מספר הפעמי לביצוע חוזר נקרא מהקלט‪,‬‬
‫וכ ג בפתרונות שניתנו לבעיות ‪ 4 ,3‬ו‪.5‬‬
‫בסעי זה נכיר בעיות אשר בפתרונ
לא נית
לקבוע לפני תחילת הביצוע החוזר את מספר הפעמי‬
‫לביצוע חוזר‪ .‬בפתרו
בעיות אלה מהל הביצוע החוזר נקבע בהתא לתנאי‪ .‬הביצוע החוזר מתבצע‬
‫שוב ושוב כל עוד התנאי מתקיי‪ .‬הביצוע החוזר מסתיי כאשר התנאי לא מתקיי‪.‬‬
‫ביצוע חוזר עם זקיף‬
‫בסעי זה נראה בעיות דומות לאלו שראינו בסעיפי הקודמי‪ .‬הדמיו
מתבטא בכ שג בבעיות אלו‬
‫מתבצע עיבוד של רשימת נתוני קלט‪ .‬ההבדל נעו‪ ,‬באור הרשימה המעובדת‪ .‬בבעיות שהוצגו עד כה‪,‬‬
‫אור הרשימה היה קבוע של התוכנית או נקרא מהקלט‪ .‬בבעיות שיוצגו בסעי זה אור הרשימה אינו‬
‫ידוע כלל‪ .‬במקו זאת‪ ,‬האיבר האחרו
בקלט הוא איבר מיוחד המסמ
את סופה של רשימת ערכי‬
‫הקלט‪.‬‬
‫‪-274-‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת הוראה לביצוע חוזר בתנאי ע שימוש בזקי‪.‬‬
‫צבי עובד בשעות אחה"צ בחלוקת משלוחי פרחי‪ .‬הוא מעוניי
להיעזר במחשב הנייד שהוא נושא‬
‫עימו כדי לחשב בסיו יו העבודה את סכו הטיפי שהרוויח במהל היו‪ .‬בכל פע שצבי מקבל‬
‫טיפ הוא מקיש את הסכו שקיבל‪ .‬בסיו יו העבודה הוא מקיש ‪ .-1‬פתחו אלגורית המקבל כקלט‬
‫את רשימת הטיפי שקיבל צבי‪ ,‬המסתיימת בער ‪ ,-1‬ומחשב את סכו הטיפי הכולל‪ .‬ישמו את‬
‫האלגורית בשפת ‪.Java‬‬
‫שאלה ‪7.24‬‬
‫תארו את הפלט עבור כל אחד מ
הקלטי הבאי )משמאל לימי
(‪:‬‬
‫א‪12 10 7 9 -1 .‬‬
‫ב‪20 -1 .‬‬
‫בניתוח ראשוני של הבעיה נית
לראות שיש להשתמש בביצוע חוזר של שתי התתמשימות‪:‬‬
‫‪ .1‬קליטת מספר‬
‫‪ .2‬הוספת המספר לסכום )תוך שימוש בצובר(‬
‫לו הקלט היה כולל בתחילתו את מספר הערכי בסדרה הנתונה‪ ,‬היינו מפתחי אלגורית דומה‬
‫לאלגוריתמי שבסעיפי הקודמי‪ ,‬תו שימוש בהוראה במבנה ‪øôñî òöá‬‬
‫‪ .íéîòô‬אבל‬
‫מספר הערכי בסדרה לא נתו
בתחילת הקלט )כלומר‪ ,‬אי
אנו יודעי מראש כמה שליחויות ביצע‬
‫צבי באותו היו(‪ .‬במקו זה מופיע בסו הקלט הער ‪ -1‬המציי
"סו קלט"‪ .‬כיצד נשתמש בסימו
‬
‫זה בהוראה לביצוע חוזר?‬
‫נשתמש בער ‪ -1‬כדי להחליט על סיו ביצוע חוזר של התתמשימות שתיארנו‪ .‬כלומר‪ ,‬לאחר קליטה‬
‫של טיפ תור
‪ ,‬יושווה ער הטיפ לער ‪ .-1‬א הוא שונה מ‪ 1-‬הרי הוא נתו
קלט רגיל‪ ,‬ולכ
יש להוסיפו‬
‫לסכו המצטבר‪ .‬אחרת‪ ,‬יש לסיי את הביצוע החוזר‪.‬‬
‫‪ – tip‬מטיפוס של‪ ,‬ישמור את הטיפ למשלוח הנוכחי‪.‬‬
‫‪ – sum‬מטיפוס של‪ ,‬ישמור את סכו הטיפי‪.‬‬
‫‪-275-‬‬
‫ננסח את הרעיו
שתיארנו‪:‬‬
‫‪:òöá -1 åððéà èì÷ðù ïåøçàä êøòä ãåò ìë‬‬
‫‪øáèöîä íåëñì èì÷ðù ïåøçàä êøòä úà óñåä‬‬
‫‪øáèöîä íåëñä ìù åëøò úà èìôë âöä‬‬
‫בהוראה לביצוע חוזר מסוג זה נבדק תנאי לפני כל סיבוב בלולאה‪ .‬במקרה זה התנאי הוא ‪êøòä‬‬
‫‪ .-1 åððéà èì÷ðù ïåøçàä‬א התנאי מתקיי מתבצע סיבוב נוס בלולאה‪ .‬כאשר התנאי לא מתקיי‪,‬‬
‫כלומר הער שנקלט הוא אכ
‪ ,-1‬מסתיי הביצוע החוזר‪.‬‬
‫?‬
‫בי
ההוראות האלו לא נמצאת עדיי
הוראת לקליטת הטיפ התור
‪ .‬היכ
נמק את הוראת הקלט?‬
‫יש לבצע את קליטת הטיפ התור
לפני השוואתו לסימ
‪ .-1‬לכ
‪ ,‬את הער הראשו
יש לקרוא מהקלט‬
‫עוד לפני ההוראה לביצוע חוזר‪ .‬קליטת הערכי הבאי )עד לקליטת סימ
סו הקלט( תהיה ההוראה‬
‫האחרונה בגו הלולאה‪ ,‬כלומר‪ ,‬מייד כאשר מסתיי עיבוד איבר קלט תור
‪ ,‬ולפני שנבדק קיו‬
‫התנאי ביחס לאיבר הקלט החדש‪ ,‬מתבצעת קליטה של איבר הקלט החדש‪.‬‬
‫‪0-ì sum äðúùîä úà ìçúà .1‬‬
‫‪tip-á íìù øôñî èåì÷ .2‬‬
‫‪.3‬‬
‫‪:òöá tip ≠ -1 ãåò ìë‬‬
‫‪tip êøòä úà sum-ì óñåä .3.1‬‬
‫‪tip-á íìù øôñî èåì÷ .3.2‬‬
‫‪sum ìù åëøò úà èìôë âöä .4‬‬
‫את ההוראה במבנה ‪...ãåò ìë‬‬
‫‪ ,òöá‬נייש ב‪ Java‬על ידי משפט ‪ .while‬משפט ‪ while‬כולל‬
‫תנאי בוליאני שקיומו קובע את המש ביצוע הלולאה‪.‬‬
‫‪-276-‬‬
/*
(-1)-‫ סדרת מספרים שלמים חיוביים המסתיימת ב‬:‫קלט‬
‫ סכומם של המספרים שנקלטו‬:‫פלט‬
*/
public class sumOfTips
{
{
int tip;
// ‫הטיפ מהמשלוח הנוכחי‬
int sum;
// ‫סכום הטיפים המצטבר‬
1. sum = 0;
2. tip = In.readInt("Insert your first tip for today. End the list
of tips with -1");
3. while (tip != -1)
{
3.1. sum = sum + tip;
3.2. tip = In.readInt("Insert the next tip. End the list of tips
with -1");
} // while
4. System.out.println("You have earned " + sum + "shekels");
}// main
}// sumOfTips
‫מעקב‬
:12 6 3 -1 ‫ עבור הקלט‬sumOfTips ‫נעקוב אחר מהל ביצוע התוכנית‬
.‫ אנו כוללי עמודה עבור התנאי הבוליאני שבכותרת המשפט‬while ‫בטבלת מעקב הכוללת משפט‬
‫המשפט הבא לביצוע‬
1
sum = 0;
2
tip = In.readInt("Insert your first
tip
sum
?
?
?
0
12
0
12
0
tip!= -1
Insert your
first tip for
today. End
the list of
tips with -1
tip for today. End the list of tips
with -1");
3
while (tip!= -1)
-277-
‫פלט‬
true
3.1
3.2
sum = sum + tip;
tip = In.readInt("Insert the next
12
12
6
12
Insert the
next tip. End
the list of
tip. End the list of tips with -1");
tips with -1
while (tip != -1)
6
12
3.1
sum = sum + tip;
6
18
3.2
3
18
3
true
Insert the
next tip. End
the list of
tips with -1
3
while (tip!= -1)
3
18
3.1
sum = sum + tip;
3
21
3.2
-1
21
true
Insert the
next tip. End
the list of
tips with -1
3
4
while (tip!= -1)
System.out.println("You have earned
-1
21
-1
21
false
You have
" + sum + "shekels");
earned 21
Shekels
:7 ‫נציג את המבנה החדש שהכרנו בפתרו
לדוגמה של בעיה‬
.‫בתנאי מבטאת ביצוע חוזר של תת משימה התלוי בקיו תנאי‬
‫הוראה לביצוע חוזר‬
...òöá ...ãåò ìë ‫הוראה כזאת נכתבת במבנה‬
‫תנאי הכניסה‬
‫ והתנאי להמש הביצוע החוזר נקרא‬,‫ג הוראה כזאת נקראת לולאה‬
.‫ללולאה‬
-278-
‫הוראה לביצוע חוזר בתנאי מיושמת ב‪ Java‬על ידי משפט ‪.while‬‬
‫המבנה הכללי של משפט ‪ while‬הוא‪:‬‬
‫)ביטוי בוליאני(‬
‫‪while‬‬
‫{‬
‫גו הלולאה‪ :‬משפט או משפטי לביצוע‬
‫}‬
‫ביצוע משפט‬
‫‪ while‬מתחיל בחישוב ערכו של הביטוי הבוליאני‪ .‬א ערכו ‪ true‬מתבצע גו‬
‫הלולאה‪ .‬בתו ביצוע גו הלולאה מחושב הביטוי הבוליאני שוב‪ .‬א ערכו ‪ true‬מתבצע גו הלולאה‬
‫שוב‪ .‬תהלי זה נמש כל עוד ערכו של הביטוי הבוליאני הוא ‪ .true‬כאשר ערכו הוא ‪ false‬מסתיי‬
‫ביצוע משפט ה‪.while‬‬
‫בטבלת מעקב‬
‫אחר מהל ביצוע תוכנית הכוללת משפט ‪ while‬אנו כוללי עמודה עבור תנאי‬
‫הכניסה ללולאה‪.‬‬
‫נית
לתאר משפט ‪ while‬באמצעות תרשי הזרימה הבא‪:‬‬
‫התנאי‬
‫מתקיים‬
‫משפט‪/‬ים‬
‫ביטוי בוליאני‬
‫התנאי לא‬
‫מתקיים‬
‫כאמור‪ ,‬השוני בי
בעיה ‪ 7‬לבעיות הקודמות לה בפרק הוא בהגדרת הקלט‪ .‬בבעיות הקודמות נית
‬
‫מראש אור רשימת איבר הקלט‪ ,‬ואילו בבעיה ‪ 7‬סיו רשימת הקלט מסומ
על ידי סימ
מיוחד )‪.(-1‬‬
‫סימ
כזה נקרא זקי'‪.‬‬
‫זקי‬
‫הינו נתו
קלט חריג‪ ,‬שתפקידו לסמ
את סו סדרת ערכי הקלט‪ .‬הזקי אינו חלק מסדרת‬
‫הנתוני‪ ,‬ואי
לעבד אותו כמו שאר איברי הסדרה‪.‬‬
‫‪-279-‬‬
‫למשל‪ ,‬בפתרו
בעיה ‪ ,7‬לא הוספנו את הער ‪ -1‬לסכו איברי הסדרה‪ ,‬כיוו
שהזקי אינו נחשב כחלק‬
‫מהסדרה!‬
‫השוני בהגדרת הקלט משפיע ג על מבנה הלולאה‪ .‬הבדל ברור אחד הוא שבפתרו
בעיה ‪ 7‬השתמשנו‬
‫בהוראה לביצוע חוזר בתנאי‪ ,‬שיושמה על ידי משפט ‪ ,while‬בעוד שבפתרו
הבעיות הקודמות‬
‫השתמשנו בהוראות לביצוע חוזר באור ידוע מראש‪ ,‬שיושמו על ידי משפטי ‪ .for‬א יש הבדל נוס –‬
‫האופ
שבו משולבות הוראות הקלט בתו הלולאה‪:‬‬
‫בלולאות בה
השתמשנו בפתרו
בעיות קודמות‪ ,‬גו הלולאה כלל הוראת קלט ומיד לאחריה הוראה‬
‫לעיבוד הקלט‪ .‬מבנה זה של גו הלולאה התאי לבעיות בה
היה צרי לעבד כל אחד ואחד מאיברי‬
‫הקלט באופ
אחיד‪.‬‬
‫בבעיות דוגמת בעיה ‪ ,7‬עיבוד איברי הקלט אינו אחיד‪ :‬העיבוד של הזקי שונה מהעיבוד של איברי‬
‫אחרי בקלט‪ .‬דרוש מבנה המאפשר לקרוא איבר קלט ולעבד אותו רק אחרי שבוצעה בדיקה כי הוא‬
‫אינו הזקי‪ .‬לכ
‪ ,‬בפתרו
בעיות בה
הגדרת הקלט כוללת זקי‪ ,‬מתבצעת הוראת קלט ראשונה לפני‬
‫הלולאה‪ .‬גו הלולאה כולל קוד כל הוראה לעיבוד הקלט‪ ,‬ואחריה הוראת קלט‪.‬‬
‫המבנה הכללי של הוראה לביצוע חוזר לעיבוד רשימת קלט המסתיימת‬
‫בזקי‪:‬‬
‫÷‪ïåúð èåì‬‬
‫‪ãåò ìë‬‬
‫‪:òöá óé÷æä åððéà èì÷ðä ïåúðä‬‬
‫‪èì÷ðä ïåúðä úà ãáò‬‬
‫÷‪ïåúð èåì‬‬
‫באופ
זה‪ ,‬הנתו
החדש ייבדק תמיד מייד לאחר קליטתו‪.‬‬
‫שאלה ‪7.25‬‬
‫נתו
קטע התוכנית הבא‪ ,‬הקלט הוא רשימת תווי‪ ,‬המהווה מילה באנגלית אשר בסופה הזקי '*'‪.‬‬
‫;‪int i = 0‬‬
‫;‪char letter‬‬
‫;)"‪letter = In.readChar("Insert the first letter of the word‬‬
‫)'*' =! ‪while (letter‬‬
‫{‬
‫;‪i = i + 1‬‬
‫;)"‪letter = In.readChar("Insert the next letter of the word‬‬
‫}‬
‫מהי מטרת קטע התוכנית?‬
‫‪-280-‬‬
‫שאלה ‪7.26‬‬
‫פתחו אלגורית אשר הקלט שלו הוא רשימת ציוני )נתוני כמספרי שלמי( בי
‪ 0‬ל‪ 100‬אשר‬
‫בסופה הזקי ‪ ,101‬והפלט שלו הוא מספר הציוני ברשימה הגדולי או שווי ל‪ .60‬ישמו את‬
‫שאלה ‪7.27‬‬
‫אלו
ובני מתחרי על תפקיד יושב ראש ועדת קישוט של הכיתה‪ ,‬מועמד זוכה א יותר מחצי מ
‬
‫הבוחרי הצביעו עבורו‪ .‬פתחו ויישמו אלגורית אשר הקלט שלו הוא סדרה של התווי ‪ A‬ו‪A) B‬‬
‫עבור אלו
‪ B ,‬עבור בני(‪ ,‬המבטאת את קולות הבוחרי‪ ,‬ומסתיימת בזקי '‪ .'#‬הפלט שלו הוא‬
‫הודעה הא אלו
זכה או לא זכה ברוב קולות )כלומר‪ ,‬ביותר מחצי מקולות הבוחרי(‪.‬‬
‫למשל‪ ,‬עבור הקלט ‪ ABBAABBAA#‬הפלט המתאי הוא ‪wins‬‬
‫‪ ,Alon‬ועבור הקלט‬
‫‪ ABBABBAA#‬הפלט המתאי הוא ‪.Alon didn’t win‬‬
‫להעמקה בתבנית איסוף בקיזוז פנו לעמוד ‪.347‬‬
‫שאלה ‪7.28‬‬
‫בבחירות לוועד חיות היער מועמדות שלוש חיות‪ :‬העכבר‪ ,‬שמספרו ‪ ,1‬האריה‪ ,‬שמספרו ‪ ,2‬והנמלה‪,‬‬
‫שמספרה ‪ .3‬פתחו אלגורית אשר הקלט שלו הוא רשימת קולות הבוחרי )כל קול הוא אחד מ
‬
‫המספרי ‪ 2 ,1‬או ‪ (3‬אשר בסופה הזקי ‪ .0‬הפלט הוא הודעה המתארת עד כמה צריכות חיות היער‬
‫להיזהר‪ :‬א האריה קיבל פחות מ‪ 30%‬מהקולות עליה
להיזהר מאוד‪ ,‬א האריה קיבל בי
‪ 31%‬ל‬
‫‪ 70%‬מהקולות עליה
להיזהר קצת‪ ,‬וא האריה קיבל יותר מ‪ 71%‬מהקולות ה
יכולות להיות‬
‫רגועות ואינ
צריכות להיזהר כלל‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪7.29‬‬
‫פתחו אלגורית אשר הקלט שלו הוא סדרת תווי המהווה מילה באנגלית‪ ,‬ומסתיימת בזקי '*'‪.‬‬
‫הפלט שלו הוא מילת הקלט‪ ,‬כשהיא מוצפנת באופ
הבא‪ :‬כל אות במילה מוחלפת באות העוקבת לה‬
‫"בצורה מעגלית" ב‪) ABC‬כלומר‪ ,‬כל אות מלבד האות ‪ Z‬מוחלפת באות העוקבת לה ב‪ ,ABC‬והאות‬
‫‪ Z‬מוחלפת באות ‪ .(A‬למשל‪ ,‬עבור הקלט *‪ ZEBRA‬הפלט הוא ‪.AFCSB‬‬
‫‪-281-‬‬
‫ביצוע חוזר עם תנאי כניסה כלשהו‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת שימוש בהוראה לביצוע חוזר בתנאי כניסה כלשהו שאינו תלוי בזקי‪.‬‬
‫בתוכנית "הנוסע המתמיד" של חברת התעופה "שחקי" נית
לצבור מרחקי טיסה‪ .‬נוסע אשר צובר‬
‫למעלה מ‪ 3000‬קילומטרי זוכה בכרטיס טיסה חינ להונולולו‪.‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא רשימת מרחקי הטיסה של נוסע אשר זכה בכרטיס חינ‬
‫)כלומר‪ ,‬ידוע שכבר צבר יותר מ‪ 3000‬ק"מ(‪ .‬הפלט שלו הוא‪ :‬מספר המרחקי המופיעי ברצ‬
‫מתחילת הרשימה אשר סכומ המצטבר עולה על ‪ ,3000‬ומספר הקילומטרי שנשארו לנוסע מעבר‬
‫ל‪ 3000‬כיתרה לצבירות הבאות‪.‬‬
‫למשל עבור הקלט‪ 800 1000 700 150 500 :‬הפלט המתאי הוא ‪ ,5 150‬משו שרק סכומ של‬
‫כל חמשת המרחקי עולה על ‪ ,3000‬ואחרי שמופחת מסכו המרחקי הער ‪ 3000‬נשארת יתרה של‬
‫‪.150‬‬
‫שאלה ‪7.30‬‬
‫מהו הפלט המתאי עבור כל אחד מ
הקלטי הבאי‪:‬‬
‫א‪.600 600 800 1000 200 .‬‬
‫ב‪. 900 800 1200 300 700 .‬‬
‫?‬
‫ברור שבפתרו
הבעיה יש לצבור את המרחקי הנתוני‪ .‬כלומר‪ ,‬יש לבצע לולאה שבה ייקלט‬
‫מרחק נתו
ויתווס לצובר‪ .‬א כמה פעמי יש לבצע זאת?‬
‫בניגוד לבעיות בסעיפי הקודמי‪ ,‬בה אור רשימת איברי הקלט היה נתו
‪ ,‬או שנית
לנו סימ
‬
‫מיוחד לסיו הקלט )זקי(‪ ,‬בבעיה זו יש לקלוט מרחקי ולהוסיפ לצובר כל עוד ערכו של הצובר‬
‫איננו גדול מ‪ .3000‬ברגע שערכו של הצובר גדול מ‪ 3000‬אי
צור להמשי בפעולות הקליטה‬
‫והצבירה‪ .‬מכא
‪ ,‬שיש לבצע את פעולות הקליטה והצבירה רק כל עוד מתקיי התנאי הבא‪:‬‬
‫‪3000-ì äååù åà ïè÷ øáöðä ÷çøîä‬‬
‫‪-282-‬‬
‫כל עוד המרחק הנצבר קט
או שווה ל‪ 3000‬יש לחזור על ביצוע התתמשימות הבאות‪:‬‬
‫קליטת מרחק נתון‬
‫הוספת המרחק הנתון לצובר‬
‫הגדלה ב‪ 1-‬של "מונה המרחקים"‬
‫המונה המוזכר בתתמשימה האחרונה ימנה את מספר המרחקי שנצברו בצובר‪ .‬כאשר יסתיי‬
‫ביצוע הלולאה‪ ,‬ישמור מונה זה את מספר המרחקי שנצברו עד שהסכו המצטבר עלה על ‪.3000‬‬
‫‪ – dist‬מטיפוס ממשי‪ ,‬ישמור מרחק תור
בקלט‬
‫‪ – sum‬מטיפוס ממשי‪ ,‬צובר שישמור את סכו המרחקי המצטבר‬
‫‪ – counter‬מטיפוס של‪ ,‬מונה שישמור את מספר המרחקי שנצברו‬
‫‪0-ì sum úà ìçúà .1‬‬
‫‪úà ìçúà .2‬‬
‫‪.3‬‬
‫‪0-ì counter‬‬
‫‪:òöá 3000-ì äååù åà ïè÷ sum ãåò ìë‬‬
‫‪dist-á ÷çøîä úà èåì÷ .3.1‬‬
‫‪sum-ì dist úà óñåä .3.2‬‬
‫‪counter úà 1-á ìãâä .3.3‬‬
‫‪counter ìù åëøò úà èìôë âöä .4‬‬
‫‪.5‬‬
‫‪sum−3000 ùøôää úà èìôë âöä‬‬
‫*‪/‬‬
‫קלט‪ :‬רשימת מרחקי טיסה שנצברו על ידי נוסע מתמיד‪ ,‬שצבר יותר מ‪ 3000-‬ק"מ‬
‫פלט‪ :‬מספר המרחקים הראשונים שסכומם גדול מ‪ ,3000-‬וההפרש בין סכומם ל‪3000-‬‬
‫‪*/‬‬
‫‪public class distanceSum‬‬
‫{‬
‫{‬
‫קבוע‪ ,‬המרחק הדרוש ‪//‬‬
‫;‪final int DISTANCE = 3000‬‬
‫‪-283-‬‬
double sum = 0;
//‫סכום מרחקים מצטבר‬
int counter = 0;
//‫מונה מרחקים שנצברו‬
double dist;
//‫מרחק טיסה‬
double left;
//3000-‫היתרה מעבר ל‬
1. while (sum <= DISTANCE)
{
1.1. dist = In.readDouble("Insert next flight distance");
1.2. sum += dist; //sum = sum + dist :‫דרך מקוצרת לכתוב‬
1.3. counter ++; //counter = counter+1 :‫דרך מקוצרת לכתוב‬
} // while
2. System.out.println("The number of distances which sum to more
than " + DISTANCE + " is " + counter);
3. left = sum - DISTANCE;
4. System.out.println("The passenger has " + left + " kilometers
left");
} // main
} // distanceSum
‫מעקב‬
:1000 700 1500 :‫נעקוב אחר מהל ביצוע התוכנית עבור הקלט‬
sum
counter
dist
sum<=DISTANCE
left
0
0
?
?
?
true
?
1
while (sum <= DISTANCE)
0
0
?
1.1
dist=In.readDouble("Insert
0
0
1000
?
next flight distance");
1.2
sum += dist;
1000
0
1000
?
1.3
counter++;
1000
1
1000
?
1
1000
1
1000
1.1
1000
1
700
true
‫פלט‬
Insert
next
flight
distance
?
?
Insert
next
flight
distance
-284-
1.2
sum += dist;
1700
1
700
?
1.3
counter++;
1700
2
700
?
1
1700
2
700
1.1
1700
2
1500
true
?
Insert
?
next
flight
distance
1.2
sum += dist;
3200
2
1500
?
1.3
counter++;
3200
3
1500
?
1
3200
3
1500
2
System.out.println("The
3200
3
1500
false
?
The number
?
number of distances which
of
sum to more than " +
distances
DISTANCE + " is " +
which sum
counter);
to more
than 3000
is 3
3
left = sum-DISTANCE;
3200
3
1500
200
4
System.out.println("The
3200
3
1500
200
passenger has " + left + "
The
passenger
kilometers left");
has 200
kilometers
left
‫ ולכ
הער השמור במשתנה‬,‫שימו ♥ שבכל ביצוע חוזר של הלולאה נקלט מרחק טיסה אחד‬
.‫ הוא בעצ מספר הפעמי שמתבצעת הלולאה‬counter
7.31 ‫שאלה‬
:‫( עבור הקלט‬8 ‫ )לפתרו
בעיה‬DistanceSum ‫בנו טבלת מעקב אחר ביצוע התוכנית‬
500 1200 800 300 300
?‫כמה פעמי יתבצע גו הלולאה‬
-285-
‫שאלה ‪7.32‬‬
‫נסחו תנאי כניסה בוליאני מתאי עבור כל אחד מ
התיאורי הבאי של ביצוע חוזר‪:‬‬
‫א‪ .‬סכימת משקלי מכוניות )לצור מעבר במעבורת( כל עוד הסכו אינו עולה על ‪ 100‬טו
‪.‬‬
‫ב‪ .‬סכימת המספרי החיוביי השלמי המתחילי ב‪ 1‬עד אשר הסכו גדול מער הנתו
כקלט‪.‬‬
‫ג‪ .‬קריאת אותיות עד אשר נקלטות ‪ 10‬אותיות ‪.A‬‬
‫שימו ♥ שבסעי א מתואר הביצוע החוזר במתכונת של כל עוד ובסעיפי ב וג מתואר הביצוע‬
‫החוזר במתכונת של עד אשר‪.‬‬
‫שאלה ‪7.33‬‬
‫בכל אחד מ
הסעיפי הבאי מופיע קטע תוכנית הכולל משפט ‪ while‬אשר חסר בו תנאי כניסה‪.‬‬
‫השלימו את תנאי הכניסה בהתא למטרת קטע התוכנית‪ ,‬ובנו טבלת מעקב אחר ביצוע הקטע השל‪.‬‬
‫א‪ .‬מטרת הקטע‪ :‬הצגה כפלט של המספר הזוגי הקט
ביותר אשר גדול מנתו
הקלט‪ ,‬כאשר נתו
‬
‫הקלט הוא מספר חיובי‪.‬‬
‫;)"‪num = In.readInt("Insert a number‬‬
‫;‪i = 0‬‬
‫)_____________( ‪while‬‬
‫{‬
‫;‪i = i + 2‬‬
‫}‬
‫בנו טבלת מעקב אחר ביצוע קטע התוכנית השל עבור הקלט ‪.9‬‬
‫ב‪ .‬מטרת הקטע‪ :‬הצגה כפלט של מכפלת שני נתוני הקלט‪ ,‬שה מספרי שלמי חיוביי‬
‫;)"‪x = In.readInt("Insert a number‬‬
‫;)"‪y = In.readInt("Insert a number‬‬
‫;‪counter = 0‬‬
‫;‪sum = 0‬‬
‫)______________( ‪while‬‬
‫{‬
‫;‪sum = sum + x‬‬
‫;‪counter = counter + 1‬‬
‫}‬
‫;)‪System.out.println(sum‬‬
‫בנו טבלת מעקב אחר ביצוע קטע התוכנית השל עבור הקלט ‪.4 3‬‬
‫‪-286-‬‬
‫שאלה ‪7.34‬‬
‫נתו
קטע התוכנית הבא אשר הקלט שלו הוא מספר חיובי של‪:‬‬
‫;)"‪limit = In.readInt("Insert a number‬‬
‫;‪s = 0‬‬
‫;‪c = 0‬‬
‫)‪while (s < limit‬‬
‫{‬
‫;‪c = c + 1‬‬
‫;‪s = s + c‬‬
‫}‬
‫;)‪System.out.println(c‬‬
‫קטע התוכנית כולל מונה ‪ c‬וצובר ‪ .s‬הצובר צובר את ערכיו של המונה במהל הביצוע החוזר‪.‬‬
‫א‪ .‬מהו הפלט עבור הקלט ‪ ?1‬מהו הפלט עבור הקלט ‪?11‬‬
‫ב‪ .‬ציינו שני קלטי שוני שעבור יהיה הפלט ‪ .5‬מהו מספר הפעמי של הביצוע החוזר עבור קלטי‬
‫אלה?‬
‫ג‪ .‬מהי מטרת קטע התוכנית?‬
‫היעזרו בטבלת מעקב כדי לענות על סעיפי א וב‪.‬‬
‫שאלה ‪7.35‬‬
‫נתו
קטע התוכנית הבא‪ ,‬אשר הקלט שלו הוא מספר חיובי של‪ ,‬כאשר ‪ TOP_LIMIT‬הוא קבוע‬
‫שערכו ‪:100‬‬
‫;)"‪num = In.readInt("Insert a number‬‬
‫;‪= 1‬‬
‫‪mult‬‬
‫;‪i = 0‬‬
‫))‪while ((i<num) && (mult < TOP_LIMIT‬‬
‫{‬
‫;‪i = i + 1‬‬
‫;‪mult = mult * i‬‬
‫}‬
‫;)‪System.out.println(mult‬‬
‫קטע התוכנית הנתו
כולל צובר )‪ (mult‬אשר צובר ער של מכפלה‪ ,‬והוא מאותחל לער ‪.1‬‬
‫א‪ .‬מהו הפלט עבור הקלט ‪ ? 2‬ומהו הפלט עבור הקלט ‪?5‬‬
‫ב‪ .‬מהו הקלט שעבורו יהיה הפלט ‪ ?24‬ומהו מספר הפעמי של הביצוע החוזר עבור קלט זה?‬
‫היעזרו בטבלת מעקב כדי לענות על סעיפי א וב‪.‬‬
‫‪-287-‬‬
‫שאלה ‪7.36‬‬
‫פתחו אלגורית אשר הקלט שלו הוא מספר חיובי של‪ ,‬והפלט שלו הוא החזקה הקטנה ביותר של ‪2‬‬
‫אשר גדולה מנתו
הקלט‪ .‬למשל‪ :‬עבור הקלט ‪ 7‬הפלט הדרוש הוא ‪) 8‬כי ‪ ,(23=8‬ועבור הקלט ‪ 8‬הפלט‬
‫הדרוש הוא ‪) 16‬כי ‪ .(24=16‬ישמו את האלגורית בשפת ‪.Java‬‬
‫במהל הפיתוח הקפידו על ניסוח תתמשימות לביצוע חוזר‪ ,‬וניסוח תנאי לביצוע חוזר‪.‬‬
‫שימו ♥שבאלגורית זה יש להשתמש בצובר של מכפלה‪.‬‬
‫בלולאות ‪ while‬שראינו עד כה תנאי הכניסה היו דומי למדי זה לזה‪ .‬ה כללו תמיד השוואה בי
‬
‫משתנה‪ ,‬אשר ערכו גדל במהל הביצוע חוזר של הלולאה‪ ,‬לבי
חס )אשר נשמר במשתנה או נקבע‬
‫מפורשות(‪ .‬הביצוע החוזר הסתיי כאשר ערכו של המשתנה גדל ועבר את החס )או השתווה לחס(‪.‬‬
‫אבל‪ ,‬תנאי כניסה כאלה ה רק סוג אחד של תנאי כניסה ללולאה‪ .‬בפתרו
הבעיה הבאה נראה דוגמה‬
‫לתנאי כניסה מסוג אחר‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת תבנית פירוק מספר של חיובי כלשהו לספרותיו‪.‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא מספר של חיובי והפלט שלו הוא מספר ספרות המספר‪.‬‬
‫למשל‪ :‬עבור הקלט ‪ 31‬הפלט הדרוש הוא ‪ 2‬ועבור הקלט ‪ 15568‬הפלט הדרוש הוא ‪.5‬‬
‫בפרקי קודמי כבר עסקנו בפירוק של מספר של לספרותיו‪ ,‬אבל כאשר מספר ספרות המספר היה‬
‫קט
וידוע‪ .‬בבעיה הנתונה מספר הספרות איננו ידוע ויכול להיות גדול מאד‪.‬‬
‫מה יהיו התתמשימות לביצוע חוזר עבור מניית ספרות המספר? ומה יהיה התנאי לחזרה על ביצוע‬
‫תתמשימות אלה?‬
‫נוכל "לקצ‪ ",‬את ספרות המספר אחת אחת ולמנות את מספר הספרות הנקצצות‪ .‬נעשה זאת‬
‫באמצעות תתמשימות לביצוע חוזר הכוללות קיצו‪ ,‬ספרה מ
המספר והגדלת מונה ב‪ .1‬קיצו‪ ,‬ספרה‬
‫יתבצע על ידי חלוקה בשלמי של המספר ב‪ .10‬חלוקה זו תביא לקיצו‪ ,‬הספרה הימנית ביותר‪.‬‬
‫למשל‪ ,‬במקו המספר ‪ 534‬יתקבל המספר ‪.53‬‬
‫א כ‪ ,‬ננסח את התתמשימות הבאות לביצוע חוזר‪:‬‬
‫‪ .1‬קיצוץ הספרה הימנית ביותר‬
‫‪ .2‬הגדלה ב‪ 1-‬של מונה הספרות‬
‫‪-288-‬‬
‫ כל עוד המספר הנותר במהל הביצוע‬,‫ כלומר‬,",‫יש לבצע תתמשימות אלו כל עוד "יש מה לקצ‬
.0-î ìåãâ (øúåðä) øôñîä :‫ התנאי לביצוע חוזר יהיה‬,
‫ לכ‬.0‫החוזר גדול מ‬
:‫נבחר שני משתני מטיפוס של‬
‫ וספרותיו נקצצות‬,‫ ישמור את המספר הנית
כקלט‬− num
‫ מונה שישמור את מספר הספרות שנקצצו‬− digits
0-ì digits úà ìçúà .1
num-á éáåéç íìù øôñî èåì÷ .2
:òöá 0-î ìåãâ num ìù åëøò
ãåò ìë
.3
10-á num ìù íéîìùá ä÷åìç éãé ìò num ìù úéðîéä äøôñä úà õö÷ .3.1
digits úà 1-á ìãâä .3.2
digits ìù åëøò úà èìôë âöä .4
/*
‫ מספר חיובי שלם‬:‫קלט‬
‫ מספר הספרות במספר הנתון‬:‫פלט‬
*/
public class digitCount
{
{
int digits = 0; // ‫מספר הספרות‬
int num; // ‫המספר המעובד‬
1. num = In.readInt("Insert a number");
2. while (num > 0)
{
2.1. num = num / 10;
2.2. digits++;
}
3. System.out.println("The number of digits is " + digits);
}// main
}//digitCount
-289-
‫מעקב‬
‫נעקוב אחר מהל ביצוע התוכנית ‪ digitCount‬עבור הקלט ‪:153‬‬
‫פלט‬
‫‪Insert a‬‬
‫‪number‬‬
‫‪num>0‬‬
‫‪digits‬‬
‫‪num‬‬
‫?‬
‫?‬
‫‪0‬‬
‫‪0‬‬
‫?‬
‫‪153‬‬
‫;)"‪num=In.readInt("Insert a number‬‬
‫‪1‬‬
‫‪true‬‬
‫‪0‬‬
‫‪153‬‬
‫)‪while(num > 0‬‬
‫‪2‬‬
‫‪0‬‬
‫‪15‬‬
‫;‪num = num / 10‬‬
‫‪2.1‬‬
‫‪1‬‬
‫‪15‬‬
‫;‪digits++‬‬
‫‪2.2‬‬
‫‪1‬‬
‫‪15‬‬
‫)‪while (num > 0‬‬
‫‪2‬‬
‫‪1‬‬
‫‪1‬‬
‫;‪num = num / 10‬‬
‫‪2.1‬‬
‫‪2‬‬
‫‪1‬‬
‫‪2.2‬‬
‫‪2‬‬
‫‪1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪0‬‬
‫;‪num = num / 10‬‬
‫‪2.1‬‬
‫‪3‬‬
‫‪0‬‬
‫‪2.2‬‬
‫‪3‬‬
‫‪0‬‬
‫‪2‬‬
‫‪3‬‬
‫‪0‬‬
‫‪System.out.println("The number of‬‬
‫‪3‬‬
‫‪true‬‬
‫‪true‬‬
‫‪false‬‬
‫‪The number of‬‬
‫‪digits is 3‬‬
‫;)‪digits is " + digits‬‬
‫להעמקה בתבניות פירוק מספר לספרותיו ובניית מספר פנו לעמוד ‪ 352‬ו‪ ,354‬בהתאמה ‪.‬‬
‫שאלה ‪7.37‬‬
‫א‪ .‬שנו את התוכנית ‪ digitCount‬לפתרו
בעיה ‪ ,9‬כ שהפלט יכלול את סכו ספרות המספר‪ ,‬למשל‪,‬‬
‫עבור הקלט ‪ 153‬הפלט המתאי הוא ‪.9‬‬
‫ב‪ .‬שנו את התוכנית ‪ digitCount‬לפתרו
בעיה ‪ ,9‬כ שהפלט יכלול רק את מספר הספרות האי‬
‫זוגיות במספר הנתו
‪ .‬למשל‪ ,‬עבור הקלט ‪ 150‬הפלט המתאי הוא ‪.2‬‬
‫שאלה ‪7.38‬‬
‫נתו
קטע התוכנית החלקי הבא‪ ,‬אשר הקלט שלו הוא שני מספרי שלמי חיוביי ‪ x‬ו‪ y -‬ומטרתו‬
‫היא הצגה כפלט של שארית החלוקה בשלמי של ‪ x‬ב‪) y‬כלומר‪ ,‬תוצאת החישוב ‪ .(x % y‬בקטע‬
‫התוכנית מתבצע החישוב הדרוש באמצעות פעולת חיסור‪.‬‬
‫השלימו את קטע התוכנית‪.‬‬
‫‪-290-‬‬
‫;)"‪x = In.readInt("Insert a number‬‬
‫;)"‪y = In.readInt("Insert a number‬‬
‫)_____________( ‪while‬‬
‫{‬
‫;‪x = x – y‬‬
‫}‬
‫;)____________(‪System.out.println‬‬
‫שאלה ‪7.39‬‬
‫שנו את הקטע הנתו
בשאלה ‪ 7.38‬כ שיציג ג את מנת החלוקה של ‪ x‬ב‪) ,y‬כלומר‪ ,‬את תוצאת‬
‫החישוב ‪ .(x / y‬יש לבצע את החישובי הדרושי באמצעות פעולות חיבור וחיסור בלבד!‬
‫שאלה ‪7.40‬‬
‫שני תלמידי המשחקי אחד נגד השני מותחי בתחילת המשחק קו באור ‪ N‬סנטימטרי )‪.(N > 1‬‬
‫השחקני מחליפי תורי לסירוגי
‪ .‬כל שחק
בתורו מקצר את הקו לחצי מאורכו‪ .‬השחק
אשר‬
‫מקצר בתורו את הקו לאור של פחות מסנטימטר אחד מנצח במשחק‪.‬‬
‫למשל‪ ,‬א אורכו של הקו הוא ‪ 8‬ס"מ‪ ,‬השחק
הראשו
יקצר את הקו ל‪ 4‬ס"מ‪ ,‬השחק
השני יקצר‬
‫את הקו ל‪ 2‬ס"מ‪ ,‬השחק
הראשו
יקצר את הקו ל‪ 1‬ס"מ והשחק
השני יקצר את הקו ל‪ 0.5‬ס"מ‬
‫וינצח במשחק‪.‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא אורכו התחילי של הקו‪ ,‬והפלט שלו הוא הודעה מיהו‬
‫השחק
המנצח )הראשו
או השני(‪.‬‬
‫שאלה ‪7.41‬‬
‫במשחק אסימוני מניח שחק
‪ 2‬אסימוני בתור הראשו
‪ 4 ,‬אסימוני בתור השני‪ 8 ,‬אסימוני בתור‬
‫השלישי‪ ,‬וכ הלאה – בכל תור מוכפל מספר האסימוני‪.‬‬
‫נתו
קטע התוכנית הבא אשר הקלט שלו הוא מספר האסימוני התחילי של השחק
‪ ,‬והפלט שלו צרי‬
‫להיות המספר הסידורי של התור אשר בו לא נית
להמשי לשחק לפי השיטה המתוארת‪ .‬למשל‪ ,‬עבור‬
‫הקלט )מספר אסימוני תחילי( ‪ ,9‬הפלט הדרוש הוא ‪ ,3‬כיוו
שאחרי הנחת ‪ 2‬אסימוני בתור‬
‫הראשו
ו‪ 4‬אסימוני נוספי בתור השני יוותרו לשחק
רק ‪ 3‬אסימוני )ולא ‪ 8‬אסימוני‪ ,‬כפי‬
‫שנדרש לתור השלישי(‪ .‬קטע התוכנית שגוי‪.‬‬
‫המספר הסידורי של התור הנוכחי‪int turn = 0; //‬‬
‫מספר אסימונים למשחק בתור הנוכחי‪//‬‬
‫;‪int tokensInCurrentTurn = 0‬‬
‫סכום אסימונים כולל בתורות שהתבצעו עד כה ‪int totalPlayedTokens = 0; //‬‬
‫מספר אסימונים תחילי‪//‬‬
‫;‪int startTokens‬‬
‫;)"‪startTokens = In.readInt("insert number of tokens to start with‬‬
‫)‪while (totalPlayedTokens <= startTokens‬‬
‫{‬
‫;‪turn = turn + 1‬‬
‫‪-291-‬‬
‫;‪tokensInCurrentTurn = tokensInCurrentTurn * 2‬‬
‫;‪totalPlayedTokens = totalPlayedTokens + tokensInCurrentTurn‬‬
‫}‬
‫;)"‪System.out.println("The game cannot go on after " + turn + "turns‬‬
‫ציינו מהי השגיאה ותקנו אותה‪.‬‬
‫שאלה ‪7.42‬‬
‫בצלחת פטרי החיידקי מכפילי את עצמ פי ‪ 5‬בכל דקה‪ ,‬עד אשר מספר עובר ס מסוי הנקרא‬
‫"ס ההכפלה"‪.‬‬
‫פתחו אלגורית אשר הקלט שלו הוא שני נתוני‪ :‬מספר חיידקי תחילי בצלחת‪ ,‬וס ההכפלה‪.‬‬
‫הפלט שלו הוא מספר החיידקי שיהיו בצלחת בדקה שבה יעבור מספר את ס ההכפלה‪ .‬ישמו את‬
‫ראינו עד כה את המבני ‪) íéîòô øôñî òöá‬או ‪ ...(òöá ...ìë øåáò‬ו‪...ãåò ìë‬‬
‫‪ ...òöá‬לביצוע חוזר של תתמשימה‪ .‬לעיתי נוהגי לכנות את המבנה הראשו
בש "לולאת ‪"for‬‬
‫ואת המבנה השני בש "לולאת ‪ ."while‬מתי נבחר להשתמש במבנה הראשו
ומתי נעדי את המבנה‬
‫השני?‬
‫♦ כאשר אפשר לחשב לפני ביצוע לולאה את מספר הפעמי שהיא תתבצע‪ ,‬נעדי לש הנוחות ולש‬
‫הבהירות להשתמש בלולאת ‪.for‬‬
‫♦ כאשר אי אפשר לחשב לפני ביצוע לולאה את מספר הפעמי שהיא תתבצע‪ ,‬בי
א הסיו נשלט‬
‫על ידי זקי או על ידי תנאי אחר‪ ,‬נשתמש בלולאת ‪ .while‬המבנה של לולאת ‪ while‬מבהיר כי‬
‫ביצועה תלוי בתנאי‪ ,‬והתנאי עצמו קל לזיהוי‪.‬‬
‫בחירה נכונה בהוראה לביצוע חוזר מבהירה לקורא התוכנית הא מספר הפעמי לביצוע ידוע מראש‪,‬‬
‫וא לא‪ ,‬על פי מה הוא נקבע‪ .‬לכ
‪ ,‬בחירה נכונה של הוראה לביצוע חוזר מסייעת לקריאות ובהירות‬
‫התוכנית‪.‬‬
‫שאלה ‪7.43‬‬
‫כתבו לולאה להצגת פלט של ‪ 50‬כוכביות‪.‬‬
‫א‪ .‬כתבו לולאת ‪ for‬להצגת הפלט הדרוש‪.‬‬
‫ב‪ .‬כתבו לולאת ‪ while‬להצגת הפלט הדרוש‪.‬‬
‫ג‪ .‬איזה מ
הפתרונות פשוט יותר?‬
‫שאלה ‪7.44‬‬
‫א‪ .‬כתבו לולאת ‪ for‬המציגה כפלט את ‪ 20‬הכפולות החיוביות הראשונות של ‪) 5‬כלומר‪ ,‬הפלט הוא‬
‫‪15 … 100‬‬
‫‪10‬‬
‫‪.(5‬‬
‫‪-292-‬‬
‫ב‪ .‬כתבו לולאת ‪ for‬נוספת המבצעת אותו דבר אבל בעלת כותרת שונה וגו לולאה שונה‪.‬‬
‫ג‪ .‬כתבו לולאת ‪ while‬המבצעת אותו דבר‪.‬‬
‫שאלה ‪7.45‬‬
הבעיות הבאות הא לפתרונה מתאי יותר להשתמש בלולאת ‪ for‬או בלולאת‬
‫‪ .while‬נמקו את תשובותיכ‪.‬‬
‫א‪ .‬הקלט‪ :‬מספר של חיובי ‪ .num‬הפלט‪ :‬רשימת המספרי השלמי החיוביי מ‪ 1‬עד ‪.num‬‬
‫ב‪ .‬הקלט‪ :‬מספר של חיובי ‪ .num‬הפלט‪ :‬רשימת המספרי השלמי השליליי מ‪ -1‬עד ‪.-num‬‬
‫ג‪ .‬הקלט‪ :‬מספר של חיובי ‪ .num‬הפלט‪ :‬רשימת המספרי השלמי החיוביי מ‪ 1‬עד המספר‬
‫הקט
ביותר ‪ k‬אשר עבורו מתקיי ‪.1+2+…+k > num‬‬
‫שתי השאלות הבאות מתייחסות להשוואה בי
אותיות ב‪ .ABC‬הכוונה ב"אות מוקדמת" היא לאות‬
‫הקרובה יותר לתחילת ה‪ ,ABC‬וב"אות מאוחרת" הכוונה היא לאות הקרובה יותר לסו ה‪ABC‬‬
‫)למשל‪ B ,‬מוקדמת יותר מ‪ E‬ו‪ F‬מאוחרת יותר מ‪.(C‬‬
‫שאלה ‪7.46‬‬
‫עבור כל אחת מ
הבעיות הבאות ציינו הא לפתרונה מתאי יותר להשתמש בלולאת ‪ for‬או בלולאת‬
‫‪ .while‬נמקו בקצרה את תשובותיכ‪.‬‬
‫שימו ♥‪ :‬בעיות אלו מתאימות לתבניות מקסימו‪ ,‬מינימו‪ ,‬מקו המקסימו ומקו המינימו‪,‬‬
‫א לא תמיד גודל התחו בו מופעלת התבנית ידוע מראש‪.‬‬
‫א‪ .‬הקלט הוא סדרת אותיות מה‪ ABC‬שבסופה '*'‪ ,‬והפלט הוא האות המאוחרת ביותר שמופיעה‬
‫בקלט‪.‬‬
‫ב‪ .‬הקלט הוא מספר של חיובי המציי
אור סדרה ואחריו סדרת אותיות מה‪ ABC‬באור המצוי
‪,‬‬
‫והפלט הוא האות המוקדמת ביותר שמופיעה בקלט‪.‬‬
‫ג‪ .‬הקלט הוא כמו הקלט לסעי ב‪ ,‬והפלט הוא המקו הסידורי של ההופעה הראשונה )אולי יש יותר‬
‫מאחת( של האות המאוחרת ביותר שמופיעה בקלט‪.‬‬
‫ד‪ .‬הקלט הוא כמו הקלט לסעי ב‪ ,‬והפלט הוא המקו הסידורי של ההופעה האחרונה )אולי יש יותר‬
‫מאחת( של האות המוקדמת ביותר שמופיעה בקלט‪.‬‬
‫ה‪ .‬מה ההבדלי ביישו האלגורית בי
סעי ג לד?‬
‫שאלה ‪7.47‬‬
‫פתחו אלגורית אשר הקלט שלו הוא סדרת אותיות מ
ה‪ ABC‬שמסתיימת ב‪ ,'*'-‬והפלט שלו‬
‫הוא האות המאוחרת ביותר מבי
האותיות ‪ B‬עד ‪ I‬המופיעות בקלט‪.‬‬
‫‪-293-‬‬
‫למשל‪ ,‬עבור הקלט *‪ SCHOOL‬הפלט המתאי הוא ‪ .H‬אמנ‪ ,‬ישנ
בקלט אותיות מאוחרות יותר מ‬
‫‪ ,H‬למשל ‪ ,S‬א אותיות אלו לא כלולות בסדרת האותיות ‪ B‬עד ‪.I‬‬
‫הניחו שבקלט מופיעה לפחות אות אחת בתחו ‪ B‬עד ‪ .I‬ישמו את האלגורית בשפת ‪.Java‬‬
‫ביצוע חוזר אינסופי‬
‫כאמור‪ ,‬ההוראות לביצוע חוזר שהוצגו בשלושת הסעיפי הראשוני‪ ,‬היו תמיד באור ידוע מראש‪.‬‬
‫כמוב
‪ ,‬עבור לולאות כאלו‪ ,‬התשובה לשאלה "כמה פעמי יתבצע גו הלולאה" היא פשוטה מאוד‪.‬‬
‫אבל‪ ,‬כאשר מדובר בהוראה לביצוע חוזר בתנאי‪ ,‬התשובה לשאלה זו אינה תמיד פשוטה‪ ,‬כפי‬
‫שמדגימה הבעיה הבאה‪.‬‬
‫בעיה ‪10‬‬
‫מטרת הבעיה ופתרונה‪ :‬דיו
בחישוב מספר הפעמי שמתבצעת לולאה‪ ,‬והצגת לולאה אינסופית‪.‬‬
‫נתונה התוכנית הבאה )מטרתה מתוארת בהערה בתחילת התוכנית(‪:‬‬
‫*‪/‬‬
‫קלט‪ :‬מספר חיובי שלם‬
‫פלט‪ :‬כל המספרים האי‪-‬זוגיים החיוביים הקטנים מן המספר הנתון‬
‫‪*/‬‬
‫‪public class OddNumbers‬‬
‫{‬
‫{‬
‫המספר הנתון ‪int limit; //‬‬
‫המספר האי‪-‬זוגי החיובי הראשון‪int oddN = 1; //‬‬
‫;)"‪1) limit = In.readInt("Insert a number‬‬
‫‪2) System.out.println("The odd numbers that are smaller‬‬
‫;)" ‪than the given number are:‬‬
‫)‪3) while (oddN != limit‬‬
‫{‬
‫;)" " ‪3.1) System.out.print(oddN +‬‬
‫;‪3.2) oddN = oddN + 2‬‬
‫}‬
‫‪} //main‬‬
‫‪}// OddNumbers‬‬
‫חשבו את מספר הפעמי שתתבצע הלולאה שבתוכנית עבור קלט נתו
‪.L‬‬
‫‪-294-‬‬
‫כדי לבטא בצורה כללית )עבור קלט ‪ (L‬את מספר הפעמי שתתבצע לולאת התוכנית נחשב את מספר‬
‫הפעמי של ביצוע הלולאה עבור דוגמאות קלט שונות‪:‬‬
‫עבור הקלט ‪ 1‬לא יתבצע גו הלולאה אפילו פע אחת‪ ,‬כיוו
שערכי ‪ limit‬ו‪ oddN-‬שווי כבר בפע‬
‫הראשונה בה מחושב תנאי הכניסה ללולאה‪.‬‬
‫עבור הקלט ‪ ,5‬נבח
את מספר הפעמי של ביצוע הלולאה באמצעות טבלת מעקב‪:‬‬
‫פלט‬
‫‪oddN!=limit‬‬
‫‪true‬‬
‫‪1‬‬
‫‪true‬‬
‫‪3‬‬
‫‪false‬‬
‫‪limit‬‬
‫‪oddN‬‬
‫‪5‬‬
‫‪1‬‬
‫‪5‬‬
‫‪1‬‬
‫)‪while (oddN != limit‬‬
‫‪3‬‬
‫‪5‬‬
‫‪1‬‬
‫;)" " ‪System.out.print(oddN +‬‬
‫‪3.1‬‬
‫‪5‬‬
‫‪3‬‬
‫;‪oddN = oddN + 2‬‬
‫‪3.2‬‬
‫‪5‬‬
‫‪3‬‬
‫‪3‬‬
‫‪5‬‬
‫‪3‬‬
‫‪3.1‬‬
‫‪5‬‬
‫‪5‬‬
‫‪3.2‬‬
‫‪5‬‬
‫‪5‬‬
‫‪3‬‬
‫עבור הקלט ‪ 5‬יתבצע גו הלולאה פעמיי ויוצג הפלט‪.1 3 :‬‬
‫באופ
דומה נוכל לראות שעבור הקלט ‪ 15‬יתבצע גו הלולאה ‪ 7‬פעמי‪ ,‬ויוצג הפלט‪:‬‬
‫‪1 3 5 7 9 11 13‬‬
‫?‬
‫ננסה להכליל‪ ,‬על פי הדוגמאות שבחנו‪ ,‬את מספר הפעמי שהלולאה תתבצע עבור קלט איזוגי‬
‫שערכו ‪ .L‬מהו הביטוי הכללי?‬
‫עבור קלט איזוגי שערכו ‪ L‬הלולאה תתבצע ‪ (L-1)/2‬פעמי‪.‬‬
‫?‬
‫ניסחנו ביטוי כללי של מספר הפעמי לביצוע הלולאה עבור קלטי איזוגיי‪ .‬הא קיי ביטוי‬
‫כללי דומה עבור קלטי זוגיי?‬
‫נבח
את מספר הפעמי של ביצוע הלולאה עבור הקלט ‪ 2‬באמצעות טבלת מעקב‪:‬‬
‫‪-295-‬‬
‫פלט‬
‫‪oddN!=limit‬‬
‫‪true‬‬
‫‪1‬‬
‫‪true‬‬
‫‪3‬‬
‫‪true‬‬
‫‪limit‬‬
‫‪oddN‬‬
‫‪2‬‬
‫‪1‬‬
‫‪2‬‬
‫‪1‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪3.1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪3.2‬‬
‫‪2‬‬
‫‪3‬‬
‫‪3‬‬
‫‪2‬‬
‫‪3‬‬
‫‪3.1‬‬
‫‪2‬‬
‫‪5‬‬
‫‪3.2‬‬
‫‪2‬‬
‫‪5‬‬
‫‪3‬‬
‫קטענו את מילוי הטבלה לפני סיו ביצוע המעקב המלא‪ .‬נית
לראות שעבור הקלט ‪ 2‬מוצג הפלט ‪3‬‬
‫אשר אי
להציגו‪ ,‬כיוו
שהוא מספר איזוגי שאיננו קט
מ
הקלט!‬
‫כאשר מחושב הביטוי הבוליאני ‪) oddN != limit‬תנאי הכניסה ללולאה( בפע השנייה‪ ,‬ערכו של‬
‫‪ oddN‬הוא ‪ ,3‬וערכו של ‪ limit‬הוא ‪ ,2‬ולכ
ערכו של הביטוי הבוליאני הוא ‪ true‬ומוצג הער ‪ 3‬כפלט‪.‬‬
‫ערכו של ‪ OddN‬גדל )ב‪ (2‬בכל סיבוב בלולאה‪ ,‬ולכ
הלולאה תתבצע ג פע שלישית ויוצג הפלט ‪.5‬‬
‫בעצ‪ ,‬הלולאה תתבצע שוב ושוב‪ ,‬וערכו של הביטוי הבוליאני יהיה תמיד‬
‫‪ ,true‬כיוו
שערכו של ‪oddN‬‬
‫רק יל ויגדל‪ .‬מכא
‪ ,‬שהלולאה תתבצע אינסו' פעמי‪.‬‬
‫הלולאה תתבצע אינסו פעמי ג עבור הקלט ‪ ,4‬ועבור הקלט ‪ ,6‬ובעצ‪ ,‬עבור כל קלט זוגי‪ .‬זאת‬
‫משו שעבור קלט זוגי יתקיי תנאי הכניסה ללולאה שוב ושוב וא פע לא יהיה מצב של שוויו
בי
‬
‫ערכו של ‪) limit‬שהוא מספר זוגי( וערכו של ‪) oddN‬שיהיה תמיד מספר איזוגי(‪.‬‬
‫כיוו
שעבור קלט זוגי הלולאה תתבצע אינסו פעמי‪ ,‬הרי יוצגו כפלט מספרי איזוגיי שאי
‬
‫להציג‪ ,‬ולכ
לא רק שהתוכנית אינה מסתיימת‪ ,‬היא ג מציגה פלט שגוי!‬
‫?‬
‫כיצד נית
לתק
את התוכנית ולדאוג לכ שהלולאה תתבצע מספר מתאי של פעמי ג עבור‬
‫קלט זוגי?‬
‫נית
לשנות את תנאי הכניסה ללולאה ל‪ ,oddN < limit‬ובכ לדאוג שביצוע הלולאה יסתיי לאחר‬
‫הצגת המספר האיזוגי הגדול ביותר שעדיי
קט
מהקלט‪.‬‬
‫‪-296-‬‬
‫יישו האלגורית המתוק)‬
‫*‪/‬‬
‫קלט‪ :‬התוכנית תקלוט מספר חיובי שלם‬
‫פלט‪ :‬כל המספרים האי‪-‬זוגיים החיוביים שקטנים מן המספר הנתון‬
‫‪*/‬‬
‫‪public class OddNumbers‬‬
‫{‬
‫{‬
‫;‪int limit‬‬
‫;‪int oddN = 1‬‬
‫;)"‪1) limit = In.readInt("Insert a number‬‬
‫‪2) System.out.println("The odds numbers that are smaller‬‬
‫;)" ‪than the given number are:‬‬
‫)‪3) while (oddN < limit‬‬
‫{‬
‫;)" " ‪3.1) System.out.print(oddN +‬‬
‫;‪3.2) oddN = oddN + 2‬‬
‫}‬
‫‪} //main‬‬
‫‪}// OddNumbers‬‬
‫התוכנית שהוצגה בבעיה ‪ 10‬כללה לולאה אשר התבצעה כדרוש עבור כל קלט איזוגי‪ ,‬א ביצועה‬
‫נמש אינסו פעמי עבור כל קלט זוגי‪.‬‬
‫לולאה אשר מתבצעת אינסו פעמי עבור קלט כלשהו נקראת לולאה אינסופית‪ .‬בחומר הלימוד‬
‫של "יסודות מדעי המחשב" תוכניות אשר כוללות לולאה אינסופית נחשבות כתוכניות שגויות‪.‬‬
‫בפיתוח אלגורית קורה לעיתי שנכתבת לולאה אינסופית‪ .‬לולאה כזו עלולה להתבצע אינסו‬
‫פעמי רק עבור חלק מ
הקלטי‪ .‬לכ
‪ ,‬חשוב להקפיד לבדוק לולאת אלגורית עבור בחירה ממצה של‬
‫דוגמאות קלט מייצגות‪ ,‬כפי שעשינו בפתרו
בעיה ‪ .10‬בפתרו
זה בדקנו תחילה את הלולאה עבור‬
‫דוגמה של קלט איזוגי‪ ,‬וראינו שעבורה מושגת המטרה‪ .‬אחר כ בדקנו עבור דוגמה של קלט זוגי‬
‫ונוכחנו שהלולאה אינסופית‪.‬‬
‫‪-297-‬‬
‫שאלה ‪7.48‬‬
הלולאות הבאות א היא לולאה אינסופית‪.‬‬
‫א הלולאה סופית )כלומר‪ ,‬איננה אינסופית( ציינו את מספר הפעמי שהיא תתבצע‪ .‬היעזרו בטבלת‬
‫מעקב לביצוע החישובי הדרושי‪.‬‬
‫ב‪.‬‬
‫א‪.‬‬
‫;‪int i = 0‬‬
‫;‪int j = 0‬‬
‫)‪while (i < 30‬‬
‫)‪while (j < 50‬‬
‫{‬
‫{‬
‫;‪j = j - 10‬‬
‫;‪i = i + 4‬‬
‫}‬
‫ג‪.‬‬
‫}‬
‫ד‪.‬‬
‫;‪int j = 0‬‬
‫;‪int k = 0‬‬
‫)‪while (Math.abs(j) < 30‬‬
‫)‪for (int j = 1; j < 10; j++‬‬
‫{‬
‫{‬
‫;‪k = k + 11‬‬
‫;‪j = j - 10‬‬
‫}‬
‫ה‪.‬‬
‫}‬
‫ו‪.‬‬
‫‪ num‬הוא מספר של חיובי כלשהו‬
‫‪ num‬הוא מספר של חיובי כלשהו‬
‫;)"‪num = In.readInt("insert number‬‬
‫;)"‪num = In.readInt("insert number‬‬
‫)‪while (num != 10‬‬
‫)‪while (num != 0‬‬
‫{‬
‫{‬
‫;)‪System.out.println(num‬‬
‫;‪num = num + 1‬‬
‫;‪num = num - 1‬‬
‫}‬
‫}‬
‫שאלה ‪7.49‬‬
‫נתו
קטע התוכנית הבא אשר הקלט שלו הוא מספר של חיובי‪:‬‬
‫;)"‪num = In.readInt("insert a number‬‬
‫{‬
‫;‪num = num % 3‬‬
‫}‬
‫הלולאה בקטע התוכנית תתבצע מספר סופי של פעמי עבור חלק מ
הקלטי‪ ,‬ומספר אינסופי של‬
‫פעמי עבור שאר הקלטי‪ .‬לכ
‪ ,‬הלולאה שבקטע התוכנית היא לולאה אינסופית‪.‬‬
‫א‪ .‬תנו דוגמת קלט שעבורה תתבצע הלולאה מספר סופי של פעמי‪.‬‬
‫מה מאפיי
את הקלטי שעבור תתבצע הלולאה מספר סופי של פעמי?‬
‫כמה פעמי תתבצע הלולאה עבור קלטי אלה?‬
‫‪-298-‬‬
‫ב‪ .‬תנו דוגמת קלט שעבורה תתבצע הלולאה מספר אינסופי של פעמי‪.‬‬
‫מה מאפיי
את הקלטי שעבור תתבצע הלולאה מספר אינסופי של פעמי?‬
‫שאלה ‪7.50‬‬
‫נתו
קטע התוכנית הבא אשר הקלט שלו הוא שני מספרי שלמי‪:‬‬
‫;)"‪x = In.readInt("insert a number‬‬
‫;)"‪y = In.readInt("insert a number‬‬
‫)‪while (x != y‬‬
‫{‬
‫;‪y = y - 1‬‬
‫;‪x = x + 1‬‬
‫}‬
‫;)‪System.out.println(x‬‬
‫א‪ .‬תנו שתי דוגמאות קלט שונות שעבור
לא יתבצע גו הלולאה‪.‬‬
‫ב‪ .‬תנו שתי דוגמאות קלט שונות שעבור
יתבצע גו הלולאה בדיוק פע אחת‪.‬‬
‫ג‪ .‬תנו שתי דוגמאות קלט שונות שעבור
יתבצע גו הלולאה בדיוק חמש פעמי‪.‬‬
‫ד‪ .‬תנו שתי דוגמאות קלט שונות שעבור
יתבצע גו הלולאה אינסו' פעמי‪.‬‬
‫ה‪ .‬נניח שערכו של ‪ x‬הוא ‪ .0‬עבור אילו ערכי של ‪ y‬יתבצע גו הלולאה אינסו' פעמי?‬
‫‪ 7.5‬משתנים מטיפוס בוליאני‬
‫בסעי זה נכיר משתני מטיפוס בוליאני‪ ,‬כלומר‪ ,‬משתני היכולי לשמור בתוכ אחד משני הערכי‬
‫‪ true‬או ‪ .false‬משתני כאלה יכולי להשתלב בביטויי בוליאניי ולכ
ה שימושיי מאוד‬
‫בהוראות לביצוע בתנאי ובהוראות לביצוע חוזר בתנאי‪ ,‬כפי שנדגי בהמש הסעי‪.‬‬
‫בעיה ‪11‬‬
‫מטרת הבעיה הבאה‪ :‬הצגת משתנה מטיפוס בוליאני‪.‬‬
‫פתחו אלגורית שהקלט שלו הוא מספר של גדול מ‪ 1‬ולאחריו רשימה‪ ,‬המסתיימת בספרה ‪ ,0‬של‬
‫מספרי שלמי נוספי הגדולי מ‪ .1‬א המספר הראשו
שנקרא הוא זוגי‪ ,‬אז הפלט הוא כל מספר‬
‫ומספר מרשימת המספרי כשהוא מוכפל ב‪ .2‬א המספר הראשו
שנקרא הוא איזוגי אז הפלט הוא‬
‫כל מספר ומספר מרשימת המספרי כשהוא מוכפל ב‪.3‬‬
‫למשל עבור הקלט‪ 9 2 4 6 0 :‬הפלט המתאי הוא ‪.6 12 18‬‬
‫ועבור הקלט‪ 8 2 4 6 0 :‬הפלט המתאי הוא ‪.4 8 12‬‬
‫‪-299-‬‬
‫ננסח רעיו
לפירוק ראשוני לתתמשימות לפתרו
הבעיה‪:‬‬
‫‪ .1‬קליטת מספר ב‪num-‬‬
‫‪ .2‬עבור כל מספר ברשימה בדיקה האם ‪ num‬זוגי‪ .‬אם כן‪ ,‬הצגה כפלט של המספר הנקלט‬
‫כפול ‪ ,2‬אחרת‪ ,‬הצגה כפלט של המספר הנקלט כפול ‪3‬‬
‫נסתכל על התתמשימה השנייה‪ :‬כפי שהיא מנוסחת‪ ,‬עבור כל מספר ברשימה אנו בודקי שוב הא‬
‫‪ num‬זוגי או לא‪ ,‬למרות שבעצ התשובה לשאלה זו תהיה זהה בכל פע‪.‬‬
‫לכ
‪ ,‬כדאי לבדוק רק פע אחת הא ‪ num‬זוגי או לא‪.‬‬
‫הנה פירוק שני לתתמשימות לפתרו
הבעיה‪:‬‬
‫‪ .1‬קליטת מספר ב‪num-‬‬
‫‪ .2‬אם ‪ num‬זוגי‬
‫‪ .2.1‬עבור כל מספר ברשימה הצגה כפלט של המספר הנקלט כפול ‪2‬‬
‫‪ .3‬אחרת )אם ‪ num‬אי‪-‬זוגי(‬
‫‪ .3.1‬עבור כל מספר ברשימה הצגה כפלט של המספר הנקלט כפול ‪3‬‬
‫אמנ‪ ,‬כעת אנו בודקי רק פע אחת הא ‪ num‬זוגי או לא‪ ,‬אבל א נסתכל על התתמשימה השנייה‬
‫והתתמשימה השלישית נראה ששתיה
כוללות קליטה של רשימת המספרי‪ .‬כלומר‪ ,‬באלגורית‬
‫המושרה על ידי הפירוק הזה‪ ,‬ולאחר מכ
ג בתוכנית ליישו האלגורית‪ ,‬הוראות הקלט יופיעו‬
‫פעמיי‪.‬‬
‫פירוק בהיר יותר לתתמשימות הוא הפירוק הבא‪:‬‬
‫‪ .1‬קליטת מספר‬
‫‪ .2‬בדיקה האם המספר שנקלט זוגי ושמירת תוצאת הבדיקה‬
‫‪ .2.1‬ביצוע עבור כל מספר ברשימה‬
‫‪ .2.1.1‬אם תוצאת הבדיקה חיובית )כלומר‪ ,‬המספר הראשון שנקלט זוגי(‬
‫‪ .2.1.1.1‬הצגה כפלט של המספר הנוכחי כפול ‪2‬‬
‫‪ .2.1.2‬אחרת )כלומר‪ ,‬המספר הראשון שנקלט אי‪-‬זוגי(‬
‫‪ .2.1.2.1‬הצגה כפלט של המספר הנוכחי כפול ‪3‬‬
‫בפירוק זה נבדקת הזוגיות של ער הקלט הראשו
רק פע אחת‪ .‬ג המעבר על רשימת הערכי‬
‫מתואר רק פע אחת‪ .‬עבור כל ער קלט ברשימה‪ ,‬ההחלטה על הער המוצג כפלט תלויה בתוצאת‬
‫הבדיקה שבוצעה קוד לכ
‪.‬‬
‫‪-300-‬‬
‫מהו טיפוס הער המתאי לשמירת תוצאת בדיקת הזוגיות של הער הראשו
בקלט? הערכי‬
‫האפשריי לתשובה לשאלה הא הער הוא זוגי ה כ) ולא‪ .‬טיפוס המתאי לערכי מסוג זה הוא‬
‫טיפוס בוליאני‪ .‬כזכור מפרקי קודמי‪ ,‬ער מטיפוס בוליאני יכול להיות אחד משני הערכי‪true :‬‬
‫או ‪.false‬‬
‫עד כה ראינו ביטויי מטיפוס בוליאני‪ ,‬ששימשו אותנו לתיאור תנאי‪ .‬אבל‪ ,‬נית
ג להצהיר על‬
‫משתני מטיפוס בוליאני‪ ,‬ולשלב ג אות בביטויי בוליאניי‪ .‬א נשמור את תוצאת בדיקת‬
‫הזוגיות של ער הקלט הראשו
במשתנה בוליאני‪ ,‬נוכל להשתמש במשתנה זה כתנאי בהוראה לביצוע‬
‫בתנאי שעוברת על רשימת איברי הקלט ומעבדת אות‪.‬‬
‫א כ‪ ,‬נשתמש במשתני הבאי‪:‬‬
‫‪ − num‬מטיפוס של‪ ,‬ישמור את ער הקלט הראשו
‬
‫‪ – numInList‬מטיפוס של‪ ,‬ישמור את ער הקלט התור
מהרשימה‬
‫‪ – isEven‬מטיפוס בוליאני‪ ,‬ישמור את תוצאת בדיקת הזוגיות של ‪num‬‬
‫מאחר שהרשימה מסתיימת בזקי‪ ,‬נשתמש בהוראה לביצוע חוזר בתנאי התלוי בזקי‪.‬‬
‫‪num-á øôñî èåì÷ .1‬‬
‫‪isEven-á ä÷éãáä úàöåú úà øåîùå éâåæ num íàä ÷åãá .2‬‬
‫‪numInList-á äîéùøá ïåùàøä øôñîä úà èåì÷ .3‬‬
‫‪.4‬‬
‫‪:òöá numList ≠ 0 ãåò ìë‬‬
‫‪.4.1‬‬
‫‪íà‬‬
‫‪true àåä isEven ìù åëøò‬‬
‫‪numInList*2 úà èìôë âöä .4.1.1‬‬
‫‪.4.2‬‬
‫‪úøçà‬‬
‫‪numInList*3 úà èìôë âöä .4.2.1‬‬
‫‪numInList-á äîéùøá àáä øôñîä úà èåì÷ .4.3‬‬
‫הצהרה על משתנה מטיפוס בוליאני נעשית באמצעות ש הטיפוס ‪ .boolean‬לכ
‪ ,‬נית
להצהיר על‬
‫המשתנה ‪ isEven‬באופ
הבא‪:‬‬
‫;‪boolean isEven‬‬
‫‪-301-‬‬
‫כמו כל משתנה בתוכנית‪ ,‬ג למשתני מטיפוס בוליאני אפשר לבצע השמה‪ .‬הביטוי שבצד ימי
של‬
‫משפט ההשמה צרי להיות ביטוי בוליאני‪ .‬אנו מעונייני שהמשתנה ‪ isEven‬ישמור את תוצאת‬
‫בדיקת הזוגיות של ער הקלט הראשו
‪ ,‬ולכ
נוכל לכתוב את ההוראה הבאה לביצוע בתנאי‪:‬‬
‫)‪if(num % 2 == 0‬‬
‫{‬
‫;‪isEven = true‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;‪isEven = false‬‬
‫}‬
‫במקרה האחד אנחנו משימי למשתנה ‪ isEven‬את הער הבוליאני ‪ true‬ובמקרה האחר את הער‬
‫הבוליאני ‪.false‬‬
‫אבל‪ ,‬מאחר שבצד ימי
של משפט השמה למשתנה בוליאני אפשר לכתוב כל ביטוי בוליאני‪ ,‬ולאו‬
‫דווקא את הביטויי הפשוטי ‪ true‬או ‪ ,false‬נוכל ג לכתוב את משפט ההשמה הבא‪:‬‬
‫;)‪isEven = (num % 2 == 0‬‬
‫בעקבות ביצוע ההשמה שלעיל‪ ,‬יוש למשתנה ‪ isEven‬הער ‪ true‬א ‪ num‬זוגי‪ ,‬ואחרת יוש בו‬
‫הער ‪.false‬‬
‫אנו מעונייני לשלב את המשתנה ‪ isEven‬בביטוי הבוליאני בהוראה לביצוע בתנאי‪ .‬נוכל לכתוב כ‪:‬‬
‫)‪if (isEven == true‬‬
‫אבל‪ ,‬מאחר שערכו של ביטוי בוליאני הוא ‪ true‬או ‪ ,false‬וכ ג ערכו של משתנה בוליאני‪ ,‬הרי‬
‫שמשתנה בוליאני כבר מהווה בעצמו ביטוי בוליאני )בדיוק כמו שמשתנה של מהווה כבר בעצמו‬
‫ביטוי חשבוני(‪ .‬לכ
‪ ,‬נוכל ג לכתוב‪:‬‬
‫)‪if (isEven‬‬
‫‪-302-‬‬
/*
0-‫ שמסתיימת ב‬1-‫ מספר שלם ולאחריו רשימת מספרים שלמים גדולים מ‬:‫קלט‬
‫ ואחרת יוצגו‬,2-‫ אם המספר הראשון זוגי יוצגו המספרים ברשימה מוכפלים ב‬:‫פלט‬
3-‫המספרים ברשימה מוכפלים ב‬
*/
public class IfEven
{
{
int num;
//‫המספר הראשון בקלט‬
int numInList; //‫מספר תורן ברשימת הקלט‬
boolean isEven // ‫האם המספר הראשון זוגי‬
// ‫קליטת המספר הראשון ובדיקה האם הוא זוגי‬
1. num = In.readInt("Insert the first number ");
2. isEven = (num % 2 == 0);
3. numInList = In.readInt("Insert a number. Enter 0 to finish the
list");
4. while (numInList != 0)
{
4.1. if (isEven)
{
4.1.1. System.out.println(numInList * 2);
} // if
4.2. else
{
4.2.1. System.out.println(numInList * 3);
} // else
4.3. numInList = In.readInt("Insert the next number. Enter 0 to
finish the list");
} // while
}// main
}// IfEven
-303-
‫מעקב‬
.7 2 4 0 ‫נעקוב אחר מהל ביצוע התכנית עבור הערכי‬
1
num=In.readInt("Insert the first
numInList
numInList!=0
?
?
num
isEven
?
7
?
?
7
false
7
false
7
false
number");
2
isEven =(num % 2
== 0)
3
numInList=In.readInt("Insert a
2
number. Enter 0 to finish the
list");
‫פלט‬
Insert
the
first
number
Insert a
number.
Enter 0
to
finish
the list
4
while (numInList != 0)
2
4.1
if (isEven)
2
7
false
4.2.
System.out.println(
2
7
false
6
1
numInList * 3);
4.3
numInList=In.readInt("Insert the
4
7
false
Insert
the next
number.
Enter 0
to
finish
the list
7
false
true
next number. Enter 0 to finish the
list");
4
4
4.1
if (isEven)
4
7
false
4.2.
System.out.println(
4
7
false
12
1
numInList * 3);
4.3
numInList=In.readInt("Insert the
0
7
false
Insert
the next
number.
Enter 0
to
finish
the list
7
false
true
next one. Enter 0 to finish the
list");
4
0
false
-304-
‫בפתרו
הבעיה השתמשנו במשתנה מטיפוס בוליאני‪:‬‬
‫משתנה בוליאני שומר ערכי מטיפוס בוליאני‪ ,‬כלומר אחד משני הערכי ‪ true‬או ‪.false‬‬
‫למשתנה בוליאני נית
להשי ער של ביטוי בוליאני כלשהו‪.‬‬
‫נית
לשלב משתנה בוליאני בתו תנאי בוליאני‪.‬‬
‫מתאי להשתמש במשתנה בוליאני כדי לזכור תוצאה של בדיקה‪.‬‬
‫ב‪ Java‬משמשת המילה השמורה ‪ boolean‬להצהרה על משתנה בוליאני‪.‬‬
‫בדומה למשתני מטיפוסי אחרי‪ ,‬נית
לבצע‬
‫אתחול של משתנה בוליאני תו כדי‬
‫הצהרה‪ ,‬למשל‪:‬‬
‫;‪boolean boolVariable = true‬‬
‫למשתנה בוליאני נוהגי לעיתי לקרוא דגל )‪ .(flag‬כאשר ערכו של המשתנה ‪ ,true‬הוא משול לדגל‬
‫מור‪ ,‬המסמ
מעבר אפשרי‪ .‬כאשר ער המשתנה ‪ false‬הוא משול לדגל מורד‪ ,‬המסמ
כי אי
‬
‫אפשרות מעבר‪.‬‬
‫שאלה ‪7.51‬‬
‫בנו טבלת מעקב אחר מהל ביצוע התכנית ‪ IfEven‬לפתרו
בעיה ‪ 11‬עבור הקלט ‪.4 5 7 0‬‬
‫שאלה ‪7.52‬‬
‫בקטע התוכנית הבא המשתנה ‪ length‬שומר מספר חיובי של המבטא אור רשימה‪ .‬מתבצע קלט‬
‫של רשימת תוצאות הטלה של קובייה )תוצאת הטלה של קובייה היא מספר של בי
‪ 1‬ל‪ .(6‬רשימת‬
‫התוצאות עלולה לכלול מספרי שגויי )כלומר‪ ,‬שאינ בי
‪ 1‬ל‪ .(6‬המשתנה ‪ valid‬הוא מטיפוס‬
‫בוליאני ושאר המשתני ה מטיפוס של‪.‬‬
‫;‪i = 1‬‬
‫;‪s = 0‬‬
‫;‪valid = true‬‬
‫))‪while(valid && (i <= length‬‬
‫{‬
‫;)" ‪dice = In.readInt("Insert the dice number‬‬
‫))‪if((dice >= 1) && (dice <= 6‬‬
‫{‬
‫;‪s = s + dice‬‬
‫‪} // if‬‬
‫‪else‬‬
‫‪-305-‬‬
‫{‬
‫;‪valid = false‬‬
‫‪} // else‬‬
‫;‪i = i + 1‬‬
‫‪} // while‬‬
‫)‪if (valid‬‬
‫{‬
‫;)‪System.out.println(s‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)‪System.out.println(dice‬‬
‫}‬
‫א‪ .‬תארו את הפלט עבור הקלט‪.3 1 2 3 :‬‬
‫ב‪ .‬תארו את הפלט עבור הקלט‪.3 1 0 3 :‬‬
‫ג‪ .‬מהו תפקיד המשתנה הבוליאני ‪?valid‬‬
‫ד‪ .‬מהי מטרת קטע התוכנית?‬
‫שאלה ‪7.53‬‬
‫פתחו אלגורית שהקלט שלו הוא רשימה של ‪ 20‬מספרי חיוביי‪ .‬הקלט נחשב חוקי א כל‬
‫המספרי בו ה זוגיי‪ .‬האלגורית בודק הא הקלט חוקי‪ .‬א הקלט חוקי האלגורית מציג כפלט‬
‫את סכו המספרי שבקלט‪ ,‬ואחרת תוצג הודעה כי הקלט איננו חוקי‪ .‬ישמו את האלגורית בשפת‬
‫‪.Java‬‬
‫הדרכה‪ :‬השתמשו במשתנה בוליאני שיאותחל ל‪ .true‬א יימצא בקלט מספר איזוגי יוש‬
‫במשתנה זה הער ‪.false‬‬
‫הבעיה המוצגת בשאלה ‪ 7.53‬מתאימה לתבנית האם כל הערכים בסדרה מקיימים תנאי? להעמקה‬
‫בתבנית פנו לעמוד ‪.356‬‬
‫שאלה ‪7.54‬‬
‫פתחו אלגורית שהקלט שלו הוא סיסמה‪ ,‬המורכבת מרשימת אותיות לועזיות המסתיימת ב'*'‪.‬‬
‫הפלט הוא הודעה המציינת הא הסיסמה תקינה‪ .‬סיסמה תקינה כוללת לפחות ‪ 6‬תווי‪ ,‬כאשר‬
‫לפחות אחד מה אמור להיות אות קטנה )מה‪ (abc‬ולפחות אחד מה צרי להיות אות גדולה )מה‬
‫‪ .(ABC‬ישמו את האלגורית בשפת ‪.Java‬‬
‫‪-306-‬‬
‫שאלה ‪7.55‬‬
‫בקטע התוכנית הבא ‪ length‬מכיל מספר של חיובי‪ .‬הקלט לקטע התוכנית הוא סדרה באור‬
‫‪ length‬של מילי בנות שלוש אותיות כל אחת‪.‬‬
‫מטרת קטע התוכנית היא להציג כל מילה בסדרה בסדר אותיות הפו‪ ,‬כל עוד אותיות המילה שונות זו‬
‫מזו‪ .‬ברגע שנקלטת מילה שבה לפחות שתי אותיות זהות יש לעצור את מהל הביצוע‪.‬‬
‫המשתנה ‪ diff‬הוא מטיפוס בוליאני‪ ,‬המשתני ‪ length‬ו‪ i‬מטיפוס של והמשתני‬
‫ו‪ let3‬ה מטיפוס תווי‪.‬‬
‫‪let2 ,let1‬‬
‫__________ = ‪diff‬‬
‫;‪i = 1‬‬
‫)________________(‪while‬‬
‫{‬
‫;)"‪let1 = In.readChar("Insert the first letter of the word‬‬
‫;)"‪let2 = In.readChar ("Insert the second letter of the word‬‬
‫;)"‪let3 = In.readChar ("Insert the third letter of the word‬‬
‫)_______________( ‪if‬‬
‫{‬
‫;)‪System.out.println(let3 + " " + let2 + " " + let1‬‬
‫}‬
‫‪else‬‬
‫{‬
‫________ = ‪diff‬‬
‫}‬
‫‪} // while‬‬
‫השלימו את קטע התוכנית‪.‬‬
‫‪ 7.6‬הקשר הלוגי ‪(not) àì‬‬
‫הביטויי הבוליאניי שהכרנו עד כה ה ביטויי פשוטי וביטויי מורכבי‪ .‬הביטויי הבוליאניי‬
‫הפשוטי שהכרנו כוללי קבועי )‪ true‬או ‪ ,(false‬משתני בוליאניי‪ ,‬או ביטויי השוואה בי
ערכי‬
‫בעזרת פעולות השוואה‪ .‬ביטויי בוליאניי מורכבי מתקבלי על ידי קישור של ביטויי פשוטי‬
‫באמצעות קשרי לוגיי‪ .‬עד כה הכרנו שני קשרי לוגיי‪ (or) åà :‬ו‪.(and) íâå‬‬
‫קשר לוגי נוס‪ ,‬הוא הקשר ‪àì‬‬
‫נכיר כעת ָ‬
‫)‪ .(not‬כשמו כ
הוא – הוא מבטא שלילה‪ ,‬היפו התנאי‪.‬‬
‫בניגוד לקשרי שהכרנו עד כה‪ ,‬הקשר ‪ àì‬מופעל על ביטוי בוליאני אחד‪ ,‬ולא על שניי‪.‬‬
‫‪-307-‬‬
‫הנה טבלת האמת של הקשר ‪àì‬‬
‫‪ ,‬כאשר ‪ b‬הוא ביטוי בוליאני‪:‬‬
‫‪b àì‬‬
‫‪b‬‬
‫‪true‬‬
‫‪false‬‬
‫‪false‬‬
‫‪true‬‬
‫עדיפותו של הקשר ‪àì‬‬
‫גבוהה מעדיפות של הקשרי ‪ íâå‬ו‪.åà‬‬
‫בשפת ‪ Java‬הקשר ‪àì‬‬
‫נכתב על ידי סימ
קריאה‪.‬‬
‫דוגמאות‬
‫נניח ש‪ a‬הוא משתנה מטיפוס של ו‪ b‬הוא משתנה מטיפוס בוליאני‬
‫♦ ערכו של הביטוי הבוליאני ‪ !true‬הוא ‪.false‬‬
‫♦ ערכו של הביטוי הבוליאני )‪ !(a == 1‬הוא ‪ false‬כאשר ערכו של ‪ a‬שווה ל‪ ,1‬ו‪ true‬אחרת‪.‬‬
‫♦ ערכו של הביטוי הבוליאני ‪ !b‬הוא ‪ false‬כאשר ערכו של ‪ b‬הוא ‪ .true‬כאשר ערכו של ‪ b‬הוא ‪,false‬‬
‫ערכו של הביטוי ‪ !b‬הוא ‪.true‬‬
‫שאלה ‪7.56‬‬
‫נניח שהמשתני ‪ a‬ו‪ b‬ה מטיפוס של‪ .‬עבור כל ביטוי מ
הביטויי הבוליאניי הבאי‪ ,‬תנו דוגמה‬
‫של ערכי המשתני שעבור יהיה ערכו של הביטוי ‪ ,true‬ודוגמה של ערכי המשתני שעבור יהיה‬
‫ערכו של הביטוי ‪.false‬‬
‫א‪.‬‬
‫)‪!(a != b‬‬
‫ב‪.‬‬
‫)‪!(Math.abs(a) == a‬‬
‫שאלה ‪7.57‬‬
‫נניח שהמשתני ‪ a‬ו‪ b‬ה מטיפוס של והמשתנה ‪ c‬הוא מטיפוס בוליאני‪ .‬עבור כל ביטוי מ
‬
‫הביטויי שבמשפטי ההשמה הבאי‪ ,‬תנו דוגמה של ערכי המשתני שעבור יוש ב‪ c‬הער ‪,true‬‬
‫ודוגמה של ערכי המשתני שעבור יוש ב‪ c‬הער ‪.false‬‬
‫א‪.‬‬
‫))‪c =(x == Math.sqrt(x‬‬
‫ב‪.‬‬
‫))‪c =(c && (a == b‬‬
‫ג‪.‬‬
‫))‪c =(!((a + b)>= 5‬‬
‫‪-308-‬‬
‫שאלה ‪7.58‬‬
‫במשחק הניחושי מקיש אחד המשתתפי מספר בתחו ‪ ,1-100‬והמשתת השני צרי לנחש אותו‪,‬‬
‫בתו המשחק יודיע המחשב למשתת השני בכמה ניסיונות הצליח לנחש‪.‬‬
‫לפניכ קטע תוכנית ב‪ .Java‬השלימו את הקטע כ שיבצע את הנדרש‪:‬‬
‫;)"‪num = In.readInt("First player, Insert your number, between 1 and 100‬‬
‫;____________ = ‪int numOfGuesses‬‬
‫;___________ = ‪boolean found‬‬
‫)‪while (!found‬‬
‫{‬
‫;‪numOfGuesses++‬‬
‫;)"‪guess = In.readInt("Insert your guess please‬‬
‫)____________( ‪if‬‬
‫{‬
‫;)" !!‪System.out.println("Good‬‬
‫;‪found = true‬‬
‫}‬
‫)______________( ‪else if‬‬
‫{‬
‫;)"‪System.out.println("Your guess is too big‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println("Your guess is too small‬‬
‫}‬
‫‪} // while‬‬
‫;)"‪System.out.println("It took you " + _______________ + " guesses‬‬
‫שאלה ‪7.59‬‬
‫הבעיה עוסקת בהצפנת הודעות‪ .‬הודעה היא סדרת מילי‪ ,‬כ שכל מילה היא רצ אותיות מ
ה‪ABC‬‬
‫ובי
כל שתי מילי מופיע סימ
קריאה )!(‪ .‬הצפנת הודעה מתבצעת באופ
הבא‪ :‬בכל מילה איזוגית‬
‫)כלומר‪ ,‬המילה הראשונה‪ ,‬השלישית‪ ,‬החמישית וכו'( מוחלפת כל אות באות העוקבת לה ב‪,ABC‬‬
‫בכל מילה זוגית )כלומר‪ ,‬המילה השנייה‪ ,‬הרביעית‪ ,‬השישית וכו'( מוחלפת כל אות באות הקודמת לה‬
‫ב‪ .ABC‬סימני הקריאה נותרי במקומ ללא שינוי‪.‬‬
‫כלומר‪ ,‬תחילה יש להצפי
כל אות נתונה לאות העוקבת לה ב‪ ABC‬ולאחר כל קריאה של סימ
‬
‫קריאה יש להפו את "כיוו
ההצפנה" )מעוקבת ב‪ ABC‬לקודמת‪ ,‬או מקודמת ב‪ ABC‬לעוקבת(‪.‬‬
‫‪-309-‬‬
‫למשל‪ ,‬הצפנת ההודעה !‪ DING!DING!DONG‬תהיה ‪.EJOH!CHMF!EPOH‬‬
‫לש הפשטות נניח שהאותיות ‪ A‬ו‪ Z‬אינ
נכללות בהודעה‪.‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא מספר המציי
אור של הודעה )כלומר‪ ,‬מספר התווי‬
‫בהודעה( ואחריו ההודעה עצמה )הנקלטת תו אחר תו(‪ .‬הפלט שלו הוא ההודעה כשהיא מוצפנת באופ
‬
‫שתואר לעיל‪.‬‬
‫הדרכה‪ :‬השתמשו באלגורית במשתנה מטיפוס בוליאני לשמירת "כיוו
ההצפנה"‪ .‬אתחלו את ערכו‬
‫של משתנה זה ל‪ ,true‬ולאחר כל סימ
קריאה הפכו את ערכו באמצעות הקשר ‪.àì‬‬
‫הקשר הבוליאני ‪àì‬‬
‫משמש בתבנית האם קיים ערך בסדרה המקיים תנאי? להעמקה בתבנית זו‬
‫פנו לעמוד ‪.359‬‬
‫‪ 7.7‬קינון הוראות לביצוע חוזר‬
‫בהוראה לביצוע חוזר‪ ,‬גו הלולאה יכול להכיל הוראות שונות‪ .‬ייתכ
כי בי
הוראות אלו יש ג‬
‫הוראות לביצוע חוזר‪ .‬בכ מתקבל מבנה מקונ
‪ ,‬הכולל הוראה לביצוע חוזר בתו הוראה לביצוע‬
‫חוזר‪ .‬הדבר דומה לקינו
של הוראות לביצוע בתנאי‪ ,‬שהכרנו בפרק ‪ .5‬בסעי זה נראה כי מבנה מקונ
‬
‫של הוראות לביצוע חוזר הוא שימושי מאוד בפתרו
בעיות מסויימות‪.‬‬
‫בעיה ‪12‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת הוראה מקוננת לביצוע חוזר‪.‬‬
‫פתחו ויישמו אלגורית אשר הפלט שלו הוא לוח הכפל‪ ,‬מוצג באופ
הבא‪:‬‬
‫‪1 2 3 ….… 10‬‬
‫‪2 4 6 ….… 20‬‬
‫‪3 6 9 ….… 30‬‬
‫‪…………..‬‬
‫‪…………..‬‬
‫‪10….….. 100‬‬
‫בבעיה הנתונה אי
קלט‪ .‬מוגדר פלט בלבד‪ .‬הפלט הוא טבלת המספרי של לוח הכפל‪ .‬טבלה זו מכילה‬
‫‪ 100‬מספרי‪ ,‬המסודרי בעשר שורות ובעשרה טורי‪.‬‬
‫‪-310-‬‬
‫דר אחת להצגת לוח הכפל היא על ידי אלגורית שבו ‪ 10‬לולאות‪ ,‬אשר כל אחת מה
תציג כפלט‬
‫שורה של ‪ 10‬מספרי‪.‬‬
‫כלומר‪ ,‬נקבל את הפירוק הבא לתתמשימות‪:‬‬
‫‪ .1‬הצגה כפלט בשורה אחת של המספרים ‪ 1‬עד ‪10‬‬
‫‪ .2‬הצגה כפלט בשורה אחת של המספרים ‪ 1‬עד ‪ ,10‬מוכפלי ב‪2‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫זהו ניסוח מסורבל וארו‪ .‬בנוס‪ ,‬ניסוח זה אינו כללי‪ :‬כדי להציג טבלה בעריכה שונה או טבלה‬
‫חלקית )למשל‪ ,‬רק את חמש השורות הראשונות(‪ ,‬יש לכתוב אלגורית שונה‪ .‬בנוס‪ ,‬קשה להכליל את‬
‫האלגורית הזה לבעיה מעט שונה‪ ,‬בה גודל הטבלה )מספר השורות ומספר העמודות( מתקבל כקלט‬
‫ואינו ידוע בעת כתיבת האלגורית‪.‬‬
‫הא נית
לכתוב אלגורית פשוט‪ ,‬קצר יותר‪ ,‬ובצורת ניסוח כללית יותר?‬
‫כ
!‬
‫בכל אחת מהלולאות המפורטות מתואר ביצוע חוזר של תתמשימה‪ .‬א בעצ נית
להתייחס לכל‬
‫לולאה כאל תתמשימה כוללת יותר‪ ,‬אשר ג על ביצועה יש לחזור ‪ 10‬פעמי‪.‬‬
‫כלומר‪ ,‬נית
לתאר זאת על ידי תתהמשימה הבאה‪ ,‬שאותה יש לבצע ‪ 10‬פעמי‪:‬‬
‫הצגה כפלט של השורה הבאה בתור בטבלה‬
‫כאשר הצגה של שורה בטבלה א היא מבוטאת על ידי תתמשימה שיש לבצעה ‪ 10‬פעמי‪:‬‬
‫הצגה כפלט של האיבר הבא בתור בשורה‬
‫מאחר שיש לנו צור בשתי הוראות לביצוע חוזר )האחת בתו השנייה( שאורכ
ידוע מראש‪ ,‬נזדקק‬
‫לשני משתני הבקרה מטיפוס של‪ i :‬ו‪.j‬‬
‫‪:òöá 10 ãò 1-î i øåáò .1‬‬
‫‪:òöá 10 ãò 1-î j øåáò .1.1‬‬
‫‪i*j éåèéáä êøò úà èìôë âöä .1.1.1‬‬
‫‪äøåù øåáò .1.1.2‬‬
‫‪-311-‬‬
/*
10*10 ‫התוכנית מציגה כפלט את לוח הכפל של‬
*/
public class MultTable
{
{
final int TABLE_DIMENSION = 10;
1. System.out.println("Mult Table");
2. for (int i = 1; i <= TABLE_DIMENSION; i++)
{
2.1. for (int j = 1; j <= TABLE_DIMENSION; j++)
{
2.1.1. System.out.print ((i * j) + " ");
} // for j
2.2. System.out.println();// ‫מעבר לשורת הפלט הבאה‬
} // for i
} // main
} // MultTable
‫מעקב‬
i
j
?
?
1
System.out.println("Mult Table");
2
for (int i = 1; i <= 10; i++)
1
?
2.1
for (int j = 1; j <= 10; j++)
1
1
2.1.1
System.out.print ((i * j) + " ")
1
1
2.1
for (int j = 1; j <= 10; j++)
1
2
2.1.1
1
2
2.1
for (int j = 1; j <= 10; j++)
1
3
2.1.1
1
3
‫פלט‬
Mult Table
1
2
3
.
.
.
-312-
‫‪10‬‬
‫‪2‬‬
‫‪4‬‬
‫‪90‬‬
‫‪100‬‬
‫‪10‬‬
‫‪1‬‬
‫)‪for (int j = 1; j <= 10; j++‬‬
‫‪2.1‬‬
‫‪10‬‬
‫‪1‬‬
‫)" " ‪System.out.print ((i * j) +‬‬
‫‪2.1.1‬‬
‫;)""(‪System.out.println‬‬
‫‪2.2‬‬
‫‪10‬‬
‫‪2‬‬
‫)‪for (int i = 1; i <= 10; i++‬‬
‫‪2‬‬
‫‪1‬‬
‫‪2‬‬
‫)‪for (int j = 1; j <= 10; j++‬‬
‫‪2.1‬‬
‫‪1‬‬
‫‪2‬‬
‫‪2.1.1‬‬
‫‪2‬‬
‫‪2‬‬
‫)‪for (int j = 1; j <= 10; j++‬‬
‫‪2.1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪2.1.1‬‬
‫‪10 10‬‬
‫)‪for (int i = 1; i <= 10; i++‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫‪2‬‬
‫‪9‬‬
‫‪10‬‬
‫)‪for (int j = 1; j <= 10; j++‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫‪2.1‬‬
‫‪9‬‬
‫‪10‬‬
‫‪2.1.1‬‬
‫‪10 10‬‬
‫)‪for (int j = 1; j <= 10; j++‬‬
‫‪2.1‬‬
‫‪10 10‬‬
‫‪2.1.1‬‬
‫;)""(‪System.out.println‬‬
‫‪2.2‬‬
‫‪12‬‬
‫בפתרו
בעיה ‪ 12‬היה מתאי לנסח ביצוע חוזר של תתמשימה‪ ,‬אשר כללה בתוכה ביצוע חוזר של‬
‫תתמשימה מצומצמת יותר‪ .‬כדי לנסח ביצוע חוזר של תת משימה שכוללת בתוכה ביצוע חוזר של תת‬
‫משימה מצומצמת יותר‪ ,‬מתאי להשתמש במבנה מקונ
של לולאות‪.‬‬
‫במבנה מקונ
של לולאות נכללת לולאה פנימית בגו הלולאה של לולאה‬
‫חיצונית‪.‬‬
‫בביצוע המבנה המקונ
‪ ,‬מבוצעת הלולאה הפנימית כולה במהל ביצוע אחד של גו הלולאה‬
‫החיצונית‪.‬‬
‫בפתרו
בעיה ‪ 12‬הביצוע חוזר של הלולאה החיצונית כלל ‪ 10‬ביצועי חוזרי של גו הלולאה‬
‫הפנימית‪ .‬כיוו
שהלולאה החיצונית מתבצעת ‪ 10‬פעמי‪ ,‬הרי מספר הפעמי הכולל שיתבצע גו‬
‫הלולאה הפנימית הוא ‪.(10*10=100) 100‬‬
‫‪-313-‬‬
‫שימו ♥‪ :‬קינו
אינו מוגבל רק להוראות לביצוע חוזר שאורכ
ידוע מראש‪ .‬ההוראה החיצונית יכולה‬
‫להיות ג הוראה לביצוע חוזר שתלויה בתנאי‪ ,‬וכ ג ההוראה הפנימית‪.‬‬
‫בכתיבת מבנה מקונ
של לולאות נקפיד על עימוד‪ .‬כיוו
שהלולאה הפנימית היא חלק מגו הלולאה‬
‫החיצונית‪ ,‬ניישר את הלולאה הפנימית ע ההוראות של גו הלולאה החיצונית‪ .‬הדבר דומה לעימוד‬
‫שבמבנה המקונ
של ביצוע בתנאי‪.‬‬
‫שאלה ‪7.60‬‬
‫נניח שבאלגורית דומה לאלגורית המתואר בבעיה ‪ ,12‬משתנה הבקרה של הלולאה החיצונית‪,i ,‬‬
‫יתחיל מהער ‪ ,2‬ויגדל בכל ביצוע של הלולאה ב‪ ,1‬עד הגיעו לער ‪ .6‬מה יהיה הפלט של אלגורית‬
‫זה? ומה יהיה מספר הפעמי הכולל שיתבצע גו הלולאה הפנימית שבו?‬
‫שאלה ‪7.61‬‬
‫תארו עבור כל אחד מקטעי התוכניות הבאי את פלט קטע התוכנית ואת מספר הפעמי הכולל‬
‫שמתבצע גו הלולאה הפנימית‪:‬‬
‫א‪.‬‬
‫ב‪.‬‬
‫)‪for (int i = 1; i <= 5; i++‬‬
‫)‪for (int i = 1; i <= 5; i++‬‬
‫{‬
‫{‬
‫)‪for (int j = 1; j <= 5; j++‬‬
‫)‪for (int j = 1; j <= i; j++‬‬
‫{‬
‫{‬
‫}‬
‫}‬
‫;)(‪System.out.println‬‬
‫}‬
‫}‬
‫ד‪.‬‬
‫ג‪.‬‬
‫)‪for (int i = 1; i <= 5; i++‬‬
‫)‪for (int i = 1; i <= 5; i++‬‬
‫{‬
‫{‬
‫)‪for (int j = 1; j <= 5; j++‬‬
‫)‪for (int j = 5; j >= i; j--‬‬
‫{‬
‫{‬
‫;)‪System.out.print(j‬‬
‫}‬
‫}‬
‫}‬
‫}‬
‫‪-314-‬‬
‫שאלה ‪7.62‬‬
‫עבור כל אחד מהסעיפי הבאי פתחו ויישמו אלגורית אשר הפלט שלו הוא כפי שמופיע בתיאור‬
‫הסעי‪ .‬בכל אחד מהאלגורית מותר לכתוב רק הוראה אחת המדפיסה תו או ספרה‪ ,‬והוראה אחת‬
‫למעבר שורה בפלט )מכא
נובע כי עליכ להשתמש בלולאות מקוננות(‪:‬‬
‫ב‪.‬‬
‫א‪.‬‬
‫ד‪.‬‬
‫ג‪.‬‬
‫*‬
‫*****‬
‫*****‬
‫‪1‬‬
‫**‬
‫****‬
‫****‬
‫‪12‬‬
‫***‬
‫***‬
‫***‬
‫‪123‬‬
‫****‬
‫**‬
‫**‬
‫‪1234‬‬
‫*****‬
‫*‬
‫*‬
‫‪12345‬‬
‫**‬
‫***‬
‫****‬
‫*****‬
‫ז‪.‬‬
‫ו‪.‬‬
‫ה‪.‬‬
‫ח‪.‬‬
‫‪1‬‬
‫‪12345‬‬
‫‪55555‬‬
‫‪11111‬‬
‫‪22‬‬
‫‪1234‬‬
‫‪4444‬‬
‫‪2222‬‬
‫‪333‬‬
‫‪123‬‬
‫‪333‬‬
‫‪333‬‬
‫‪4444‬‬
‫‪12‬‬
‫‪22‬‬
‫‪44‬‬
‫‪55555‬‬
‫‪1‬‬
‫‪1‬‬
‫‪5‬‬
‫שאלה ‪7.63‬‬
‫בכיתה ‪ 40‬תלמידי‪ ,‬כל תלמיד לומד ‪ 20‬מקצועות‪ .‬לפניכ תוכנית המחשבת עבור כל תלמיד את‬
‫ממוצע ציוניו‪:‬‬
‫*‪/‬‬
‫קלט‪ 20 :‬הציונים עבור כל אחד מ‪ 40-‬תלמידי הכיתה‬
‫פלט‪ :‬הממוצע של כל תלמיד ותלמיד‬
‫‪*/‬‬
‫‪public class Grades‬‬
‫{‬
‫{‬
‫;‪final int STUDENT_NUM = 40‬‬
‫‪-315-‬‬
‫;‪final int GRADE_NUM = 20‬‬
‫;‪double grade‬‬
‫;‪double sum‬‬
‫;‪double average‬‬
‫)‪for(int i = 1; i <= STUDENT_NUM; i++‬‬
‫{‬
‫)‪for(int j = 1; j <= GRADE_NUM; j++‬‬
‫{‬
‫;)(‪grade = In.readInt‬‬
‫;‪sum += grade‬‬
‫‪} // for j‬‬
‫‪} // for i‬‬
‫‪} // main‬‬
‫‪} // Grades‬‬
‫המשפטי הבאי חסרי בתוכנית הנתונה‪ ,‬היכ
צרי לשלב את המשפטי האלה כדי שהתוכנית‬
‫תבצע את הנדרש?‬
‫א‪.‬‬
‫;‪sum = 0‬‬
‫ב‪.‬‬
‫;)‪System.out.println(sum / 20‬‬
‫שאלה ‪7.64‬‬
‫פתחו אלגורית שמקבל כקלט מספר חיובי של ‪ ,num‬ולאחריו ‪ num‬סדרות באור לא ידוע של‬
‫מספרי חיוביי שלמי‪ ,‬כאשר כל סדרה מסתיימת ב‪ .-1‬האלגורית יציג כפלט את אורכה של‬
‫הסדרה הארוכה ביותר‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪7.65‬‬
‫במפעל לייצור נעליי עובדי רבי‪ .‬פתחו אלגורית שיקבל כקלט את מספר העובדי במפעל‪ ,‬ואחר‬
‫כ רשימה של כל המשכורות של השנה האחרונה )‪ 12‬משכורות( לכל אחד מעובדי המפעל‪ .‬האלגורית‬
‫יחשב וידפיס את המשכורת האחרונה של העובד המסכ
שסכו משכורותיו כל השנה היה הנמו‬
‫ביותר‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫בעזרת החומר הנלמד בפרק ‪ 7‬נית
לפתור ג בעיות המשתמשות בתבניות מציאת כל הערכים‬
‫בסדרה המקיימים תנאי ומעבר על זוגות סמוכים בסדרה‪ .‬להעמקה בתבניות אלו פנו לעמוד‬
‫‪ 363‬ו‪ ,366‬בהתאמה‪.‬‬
‫‪-316-‬‬
‫סיכום‬
‫בפרק זה למדנו כיצד להורות על ביצוע חוזר של תתמשימה‪ .‬הדבר נעשה באמצעות הוראה לביצוע‬
‫חוזר שהיא הוראת בקרה הנקראת ג לולאה‪.‬‬
‫הכרנו שני מבני של הוראה לביצוע חוזר‪ :‬הוראה לביצוע חוזר באור‪ ,‬ידוע מראש‪ ,‬והוראה לביצוע‬
‫חוזר בתנאי‪.‬‬
‫הוראה לביצוע חוזר באור‪ ,‬ידוע מראש נכתבת בצורה‪:‬‬
‫‪òöá‬‬
‫‪X‬‬
‫‪:íéîòô‬‬
‫‪òåöéáì úåàøåä‬‬
‫או‬
‫‪ìë øåáò‬‬
‫‪... íåçúá øáéà‬‬
‫‪:òöá‬‬
‫במבנה הראשו
‪ ,‬סדרת ההוראות לביצוע מתבצעת ‪ X‬פעמי‪.‬‬
‫במבנה השני‪ ,‬נסרקי איבריו של התחו המוגדר‪ ,‬ועבור כל אחד מה מבוצעת סדרת ההוראות‬
‫לביצוע‪.‬‬
‫הוראה לביצוע חוזר בתנאי נכתבת בצורה‪:‬‬
‫>‪<éàðú‬‬
‫‪:òöá‬‬
‫התנאי המתואר נקרא תנאי הכניסה ללולאה‪ .‬כל עוד התנאי מתקיי‪ ,‬סדרת ההוראות לביצוע‬
‫מתבצעת שוב ושוב‪ .‬כאשר התנאי לא מתקיי‪ ,‬מסתיימת ההוראה לביצוע חוזר‪.‬‬
‫בכתיבת הוראה לביצוע חוזר )באור ידוע מראש או בתנאי( אנו מקפידי על עימוד‪ :‬קבוצת ההוראות‬
‫אשר יש לחזור על ביצוע
כתובות כשה
"מוזזות פנימה"‬
‫קבוצת ההוראות אשר יש לחזור על ביצוע
נקראת גו' הלולאה‪.‬‬
‫כאשר מספר הפעמי לביצוע חוזר אינו ידוע מראש )לפני תחילת ביצוע הלולאה(‪ ,‬והוא תלוי בתנאי‪,‬‬
‫נשתמש בהוראה לביצוע חוזר בתנאי‪ .‬בכל מקרה אחר נשתמש בהוראה לביצוע חוזר באור ידוע‬
‫מראש‪ .‬בכ נסייע ביצירת תוכניות קריאות ובהירות‪.‬‬
‫בי
ההוראות לביצוע חוזר בתנאי הבחנו בסוג מסוי‪ :‬הוראות לביצוע חוזר התלויות בזקי'‪.‬‬
‫‪-317-‬‬
‫זקי' הוא סימ
מיוחד המציי
את סו רשימת איברי הקלט‪ .‬הזקי אינו נחשב כחלק מהקלט‪ .‬לכ
‪,‬‬
‫בהוראה לביצוע חוזר שנועדה לעיבוד רשימת קלט שמסתיימת בזקי‪ ,‬יש לוודא לפני עיבוד איבר‬
‫הקלט התור
כי הוא אינו הזקי‪ .‬זיהוי הזקי צרי להביא לסיו הביצוע החוזר‪.‬‬
‫הוראה לביצוע חוזר משמשת‪ ,‬בי
השאר לביצוע פעולות צבירה ומנייה‪ .‬צבירה נעשית באמצעות צובר‪,‬‬
‫ומנייה באמצעות מונה‪.‬‬
‫צובר הינו משתנה שתפקידו לצבור ערכי )למשל‪ ,‬נתוני או תוצאות חישוב(‪ .‬צובר יכול לשמש‬
‫לפעולות צבירה שונות )למשל‪ ,‬סכו מצטבר או מכפלה מצטברת(‪.‬‬
‫מונה הינו משתנה אשר תפקידו למנות אירועי )למשל‪ ,‬מספר הופעות של נתוני או מספר חישובי‬
‫מבוצעי(‪ .‬מאחר שהשימוש במונה הוא לצור ספירה הרי הוא בדר כלל מטיפוס של‪.‬‬
‫באלגוריתמי בה יש שימוש במונה או צובר יש להקפיד על אתחול עבור‪ .‬באתחול יוש למונה או‬
‫לצובר ער התחלתי המתאי להגדרת תפקיד‪.‬‬
‫הוראות לביצוע חוזר משמשות ג לפתרו
בעיות בה
נדרש למצוא איבר מקסימלי או איבר מינימלי‬
‫בתו קבוצת איברי‪ ,‬או את מקומו של האיבר המקסימלי )או המינימלי( בקבוצת איברי סדורה‪.‬‬
‫כאשר אלגורית כולל לולאה‪ ,‬נית
לחשב את מספר הפעמי שהלולאה תתבצע‪ .‬מספר זה תלוי בדר‬
‫כלל בקלט לאלגורית‪.‬‬
‫יתכ
שעבור קלטי מסוימי תתבצע הלולאה אינסו פעמי‪ .‬לולאה כזאת נקראת לולאה אינסופית‪.‬‬
‫אנו מחשיבי לולאה אינסופית כלולאה שגויה‪.‬‬
‫בפרק הבא נדגיש את החשיבות של פתרו
בעיות באמצעות אלגוריתמי שבה מספר הפעמי לביצוע‬
‫חוזר הוא קט
ככל האפשר‪.‬‬
‫משתנה בוליאני הוא משתנה שיכול לקבל אחד משני הערכי ‪ true‬ו‪ .false‬נית
להשתמש במשתני‬
‫בוליאניי בתו ביטויי בוליאניי‪.‬‬
‫הקשר הלוגי‬
‫‪àì‬‬
‫לקשרי ‪íâå‬‬
‫משמש ליצירת ביטויי בוליאניי מורכבי מביטויי פשוטי יותר )בדומה‬
‫ו‪ .(åà‬הוא מופעל על ביטוי בוליאני והוא הופ את ערכו הלוגי )מ‪ true‬ל‪,false‬‬
‫ולהיפ(‪ .‬עדיפותו של הקשר הלוגי ‪ àì‬גבוהה מעדיפות של הקשרי ‪ íâå‬ו‪.åà‬‬
‫הוראה שנמצאת בתו הוראה לביצוע חוזר יכולה להיות בעצמה הוראה לביצוע חוזר‪ .‬בכ מתקבל‬
‫קינו) של הוראות לביצוע חוזר‪.‬‬
‫‪-318-‬‬
‫סיכום מרכיבי שפת ‪ Java‬שנלמדו בפרק ‪7‬‬
‫הוראה לביצוע חוזר באור‪ ,‬ידוע מראש מיושמת ב‪ Java‬על ידי משפט ‪.for‬‬
‫המבנה הכללי של משפט ‪ for‬הוא‪:‬‬
‫)שינוי משתנה הבקרה ; התנאי להמשך הביצוע ;אתחול משתנה הבקרה( ‪for‬‬
‫{‬
‫}‬
‫כל עוד התנאי להמש הביצוע )שתלוי בדר כלל בערכו של משתנה הבקרה( מתקיי‪ ,‬ביצוע הלולאה‬
‫ממשי‪ ,‬כלומר‪ ,‬מתבצעת סדרת ההוראות לביצוע‪ .‬סדרת הוראות זו נקראת גו' הלולאה‪.‬‬
‫משתנה הבקרה הוא בדר כלל מטיפוס של‪ .‬א אי
בו שימוש מעבר לתחו הלולאה נית
להצהיר‬
‫עליו בתו הלולאה‪ ,‬למשל כ‪:‬‬
‫)‪for(int i = 1; i <= 10; i++‬‬
‫הוראה לביצוע חוזר בתנאי מיושמת ב‪ Java‬על ידי משפט ‪.while‬‬
‫המבנה הכללי של משפט ‪ while‬הוא‪:‬‬
‫)ביטוי בוליאני( ‪while‬‬
‫{‬
‫}‬
‫ביצוע משפט ‪ while‬מתחיל בחישוב ערכו של הביטוי הבוליאני‪ .‬א ערכו ‪ true‬מתבצעות ההוראות‬
‫לביצוע )גו הלולאה(‪ .‬בתו ביצוע המשפט מחושב ערכו של הביטוי הבוליאני שוב‪ .‬א ערכו ‪true‬‬
‫מתבצעות שוב ההוראות לביצוע‪ ,‬וכ הלאה‪ ,‬כל עוד ערכו של הביטוי הבוליאני הוא ‪ .true‬כאשר ערכו‬
‫‪ false‬מסתיי ביצוע משפט ה‪.while‬‬
‫ההצהרה על משתנה בוליאני נעשית בשפת ‪ Java‬באמצעות המילה השמורה ‪ ,boolean‬למשל כ‪:‬‬
‫;‪boolean flag‬‬
‫הקשר ‪ àì‬נכתב ב‪ Java‬באמצעות הסימ
!‪ ,‬למשל כ‪:‬‬
‫)‪!(x==5‬‬
‫‪-319-‬‬
‫תבניות – פרק ‪7‬‬
‫מנייה וצבירה‬
‫נתבונ בשתי הבעיות האלגוריתמיות הבאות‪:‬‬
‫בעיה ‪ :1‬עליה על מתק "רכבת הרי" מותרת רק לילדי שגובה עולה על ‪ 1.40‬מטר וגיל‬
‫עולה על ‪ .8‬כתבו אלגורית שהקלט שלו ‪ 40‬זוגות ערכי המייצגי את הגובה והגיל של ‪40‬‬
‫ילדי‪ ,‬והפלט שלו הוא מספר הילדי הרשאי לעלות למתק‪.‬‬
‫בעיה ‪ :2‬מנהל האתר הביתספרי "ישראלנד" מעוניי לדעת מהו מספר הכניסות לאתר ביממה‪.‬‬
‫כתבו אלגורית שהקלט שלו הוא סדרה של קודי משתמשי‪ ,‬המסתיימת בזקי ‪ ,0‬והפלט שלו‬
‫הוא מספר הכניסות לאתר ביממה‪.‬‬
‫בשתי הבעיות האלגוריתמיות עלינו למנות )לספור( ערכי‪ .‬בבעיה ‪ 1‬יש למנות את מספר הילדי‬
‫הרשאי לעלות למתק "רכבת הרי" ובבעיה ‪ 2‬יש למנות את מספר הכניסות לאתר ביממה‪.‬‬
‫מנייה היא אחת התבניות השימושיות ביותר בפיתוח אלגוריתמי‪ .‬השימוש בתבנית זו נעשה בכל‬
‫פע שיש למנות כמות הופעות של ער‪.$‬‬
‫נתבונ בשני האלגוריתמי הבאי‪ ,‬הפותרי את שתי הבעיות שלעיל‪:‬‬
‫‪0-ì count úà ìçúà .1‬‬
‫‪:íéîòô 40 òöá .2‬‬
‫‪code-á ùîúùî ãå÷ èåì÷ .2‬‬
‫‪age-á ìéâå height-á äáåâ èåì÷ .2.1‬‬
‫‪.2.2‬‬
‫‪íâå height > 1.4 íà‬‬
‫‪:òöá code <> 0 ãåò ìë .3‬‬
‫‪1-á count úà ìãâä .3.1‬‬
‫‪age > 8‬‬
‫‪1-á count úà ìãâä .2.2.1‬‬
‫‪count ìù åëøò úà èìôë âöä .3‬‬
‫‪code-á ùîúùî ãå÷ èåì÷ .3.2‬‬
‫‪count ìù åëøò úà èìôë âöä .4‬‬
‫בשני האלגוריתמי ערכו של המונה )‪ (count‬מאותחל לפני הלולאה ל‪ 0‬ובגו הלולאה גדל ערכו‬
‫של המונה ב‪ .1‬שימו לב כי בפתרו לבעיה ‪ 1‬מספר הפעמי שמבוצע גו הלולאה ידוע מראש )‪(40‬‬
‫ואילו בפתרו לבעיה ‪ 2‬מספר הפעמי שמבוצע גו הלולאה אינו ידוע מראש )סדרת נתוני הקלט‬
‫מסתיימת ע קליטת הזקי ‪.(0‬‬
‫‪-321-‬‬
‫עתה נתבונ בשתי הבעיות האלגוריתמיות הבאות‪:‬‬
‫בעיה ‪ :3‬כתבו אלגורית שהקלט שלו הוא ‪ 15‬מספרי ממשיי והפלט שלו הוא סכו המספרי‬
‫החיוביי‪.‬‬
‫בעיה ‪ :4‬בתחרות הרמת משקולות משקלה של המשקולת ההתחלתית הוא ‪ 20‬ק"ג‪ .‬כל המתחרי‬
‫בתחרות מסוגלי להרי משקולת זו‪ .‬ע התקדמות התחרות נוספות עוד ועוד משקולות‬
‫למשקולת ההתחלתית‪ .‬כתבו אלגורית שהקלט שלו הוא סדרה של זוגות נתוני‪ :‬הנתו הראשו‬
‫הוא משקל המשקולת אותה מוסיפי למשקל המצטבר שהרי מתחרה‪ ,‬והנתו השני הוא התו '‪'y‬‬
‫א המתחרה הצליח להרי את המשקל המצטבר כולל המשקולת החדשה‪ ,‬והתו '‪ 'n‬א לא‬
‫הצליח‪ .‬התו '‪ 'n‬יופיע רק בזוג הנתוני האחרו‪ .‬הפלט של האלגורית הוא המשקל המצטבר של‬
‫המשקולות שהמתחרה הצליח להרי‪.‬‬
‫בשתי הבעיות האלגוריתמיות עלינו לצבור )בדוגמה זו‪ ,‬לחשב סכו( ערכי‪ .‬בבעיה ‪ 3‬יש לצבור‬
‫מספרי חיוביי ובבעיה השנייה יש לצבור את משקלי המשקולות‪ .‬תבנית הצבירה‪ ,‬בדומה‬
‫לתבנית מנייה‪ ,‬הינה תבנית שימושית ביותר בפיתוח אלגוריתמי‪ .‬השימוש בתבנית זו נעשה בכל‬
‫פע שיש לצבור סדרת ערכי בצורה כלשהי‪ ,‬למשל על ידי סכו או על ידי מכפלה‪.‬‬
‫נתבונ בשני האלגוריתמי ‪ ,‬הפותרי את שתי הבעיות שלעיל‪:‬‬
‫‪.2‬‬
‫‪-á êùîä åúå weight-á úìå÷ùî ì÷ùî èåì÷ .2‬‬
‫‪continuation‬‬
‫‪num-á éùîî øôñî èåì÷ .2.1‬‬
‫‪íà .2.2‬‬
‫‪.3‬‬
‫‪:òöá continuation <> ‘n’ ãåò ìë‬‬
‫‪weight úà sum -ì óñåä .3.1‬‬
‫‪num > 0‬‬
‫‪åúå weight-á úìå÷ùî ì÷ùî èåì÷ .3.2‬‬
‫‪num úà sum -ì óñåä .2.1.1‬‬
‫‪continuation-á êùîä‬‬
‫בשני האלגוריתמי ערכו של הצובר )‪ (sum‬מאותחל לפני הלולאה לער‪ $‬תחילי‪ ,‬ולהבדיל ממונה‪,‬‬
‫ער‪ $‬זה אינו בהכרח ‪ .0‬בפתרו לבעיה ‪ 3‬ערכו מאותחל ל‪ 0‬ובפתרו לבעיה ‪ 4‬ערכו מאותחל ל‪.20‬‬
‫בגו הלולאה משתנה ערכו של הצובר בער‪ $‬כלשהו‪ ,‬השונה מ‪) 1‬שימו לב כי ייתכ שערכו של‬
‫הצובר עלול לקטו במהל‪ $‬הצבירה‪ ,‬למשל‪ ,‬במקרה של צבירת ערכי שליליי(‪.‬‬
‫נציג כעת את מאפייני שתי התבניות‪ .‬ראשית‪ ,‬נציג את מאפייני התבנית מנייה ואחר כ‪ $‬נציג את‬
‫מאפייני התבנית צבירה‪ .‬עבור כל אחת מהתבניות נראה אלגורית עבור ביצוע חוזר באור‪ $‬הידוע‬
‫מראש וכ אלגורית לביצוע חוזר בתנאי‪.‬‬
‫‪-322-‬‬
‫ מנייה‬:‫ש התבנית‬
condition ‫ תנאי מנייה‬, ‫ סדרת ערכי הקלט‬,limit ‫ סדרת נתוני הקלט‬$‫ אור‬:‫נקודת מוצא‬
limit ‫ סדרת קלט שאורכה‬$‫ מתו‬,condition ‫ מנייה של ערכי הקלט המקיימי את התנאי‬:‫מטרה‬
:‫אלגורית‬
0-ì count úà ìçúà .1
:íéîòô limit òöá
.2
element-á êøò èåì÷ .2.1
condition úà íéé÷î element
íà
.2.2
1-á count úà ìãâä .2.2.1
:Java‫יישו ב‬
count = 0;
for (i = 1; i <= limit; i++)
{
element = In.readInt();
if (condition)
{
count++;
}
}
-323-
‫ מנייה‬:‫ש התבנית‬
conditionToCount ‫ תנאי מנייה‬,‫ ערכי הקלט‬,conditionToEnd ‫ תנאי סיו‬:‫נקודת מוצא‬
‫ של ערכי הקלט המקיימי את‬,conditionToEnd ‫ ביצועה תלוי בתנאי‬$‫ שמש‬,‫ מנייה‬:‫מטרה‬
conditiontoCount ‫התנאי‬
0-ì count úà ìçúà .1
element-á êøò èåì÷ .2
:òöá conditionToEnd íéé÷úî àì ãåò ìë
conditionToCount úà íéé÷î element
.3
íà .3.1
1-á count úà ìãâä 3.1.1
count = 0;
while (!conditionToEnd)
{
if (conditionToCount)
{
count++;
}
}
-324-
‫ישנ שתי צורות בסיסיות של צבירה‪ :‬צבירת סכו וצבירת מכפלה‪ .‬אנו נראה תחילה את התבניות‬
‫של צבירת סכו שמש‪ $‬ביצועה ידוע מראש וצבירת סכו שמש‪ $‬ביצועה תלוי בתנאי‪.‬‬
‫ש התבנית‪ :‬צבירת סכו‬
‫נקודת מוצא‪ :‬אור‪ $‬סדרת נתוני הקלט ‪ ,limit‬ער‪ $‬תחילי של הצובר ‪ ,initial‬ערכי הקלט‪ ,‬תנאי‬
‫צבירה ‪condition‬‬
‫מטרה‪ :‬צבירה אל הער‪ initial $‬של סכו ערכי הקלט המקיימי את התנאי ‪ ,condition‬מתו‪$‬‬
‫סדרת קלט שאורכה ‪limit‬‬
‫אלגורית‪:‬‬
‫‪initial-ì sum úà ìçúà .1‬‬
‫‪:íéîòô limit òöá .2‬‬
‫‪element-á êøò èåì÷ .2.1‬‬
‫‪íà .2.2‬‬
‫‪condition úà íéé÷î element‬‬
‫‪element ìù åëøò úà sum-ì óñåä .2.2.1‬‬
‫יישו ב‪:Java‬‬
‫;‪sum = initial‬‬
‫)‪for (i = 1; i <= limit; i++‬‬
‫{‬
‫;)(‪element = In.readInt‬‬
‫)‪if (condition‬‬
‫{‬
‫;‪sum += element‬‬
‫}‬
‫}‬
‫‪-325-‬‬
‫ צבירת סכו‬:‫ש התבנית‬
‫ תנאי‬,‫ ערכי הקלט‬,initial ‫ תחילי של הצובר‬$‫ ער‬,conditionToEnd ‫ תנאי סיו‬:‫נקודת מוצא‬
conditionToSum ‫צבירה‬
‫ של ערכי‬,initial $‫ אל הער‬,conditionToEnd ‫ ביצועה תלוי בתנאי‬$‫ שמש‬,‫ צבירת סכו‬:‫מטרה‬
conditionToSum ‫הקלט המקיימי את התנאי‬
initial-ì sum úà ìçúà .1
:òöá conditionToEnd íéé÷úî àì ãåò ìë .3
conditionToSum
úà íéé÷î element
íà .3.1
element ìù åëøò úà sum-ì óñåä .3.1.1
sum = initial;
{
if (conditionToSum)
{
sum += element;
}
}
-326-
‫עתה נראה את התבנית של צבירת מכפלה שמש‪ $‬ביצועה ידוע מראש ושל צבירת מכפלה שמש‪$‬‬
‫ביצועה תלוי בתנאי‪.‬‬
‫ש התבנית‪ :‬צבירת מכפלה‬
‫נקודת מוצא‪ :‬אור‪ $‬סדרת נתוני הקלט ‪ ,limit‬ער‪ $‬תחילי של הצובר ‪ ,initial‬ערכי הקלט‪ ,‬תנאי‬
‫צבירה ‪condition‬‬
‫מטרה‪ :‬צבירת מכפלה אל הער‪ initial $‬של ערכי הקלט המקיימי את התנאי ‪ ,condition‬מתו‪$‬‬
‫סדרת קלט שאורכה ‪limit‬‬
‫‪initial-ì mult úà ìçúà .1‬‬
‫‪íà .2.2‬‬
‫‪mult-á äìôëîä úà íùäå element-á mult úà ìôëä .2.2.1‬‬
‫;‪mult = initial‬‬
‫)‪for (i = 1; i <= limit; i++‬‬
‫{‬
‫{‬
‫;‪mult *= element‬‬
‫}‬
‫}‬
‫‪-327-‬‬
‫ש התבנית‪ :‬צבירת מכפלה‬
‫נקודת מוצא‪ :‬תנאי סיו ‪ ,conditionToEnd‬ער‪ $‬תחילי של הצובר ‪ ,initial‬ערכי הקלט‪ ,‬תנאי‬
‫צבירה ‪conditionToMult‬‬
‫מטרה‪ :‬צבירת מכפלה‪ ,‬שמש‪ $‬ביצועה תלוי בתנאי ‪ ,conditionToEnd‬אל הער‪ ,initial $‬של ערכי‬
‫הקלט המקיימי את התנאי ‪conditionToMult‬‬
‫‪initial-ì mult úà ìçúà .1‬‬
‫‪element-á êøò èåì÷ .2‬‬
‫‪:òöá conditionToEnd íéé÷úî àì ãåò ìë .3‬‬
‫‪íà .3.1‬‬
‫‪úà íéé÷î element‬‬
‫‪conditionToMult‬‬
‫‪mult-á äìôëîä úà íùäå element-á mult úà ìôëä .3.1.1‬‬
‫;‪mult = initial‬‬
‫)‪while (!conditionToEnd‬‬
‫{‬
‫)‪if (conditionToMult‬‬
‫{‬
‫;‪mult *= element‬‬
‫}‬
‫}‬
‫שימו ♥‪ :‬ערכו של ‪ initial‬חייב להיות שונה מ‪ ,0‬שהרי מכפלת ‪ 0‬בכל מספר תשאיר את ערכו של‬
‫הצובר ‪ .0‬ערכו של הצובר יכול להיות שלילי‪ ,‬וערכו של הצובר עשוי לקטו א ערכו של ‪element‬‬
‫גדול מ‪ 0‬וקט מ‪) 1‬כלומר‪ ,‬הוא שבר(‪ ,‬או א נצברי ג ערכי שליליי‪.‬‬
‫ועוד שימו ♥‪ :‬הבעיה האלגוריתמית אינה חייבת לכלול תנאי למנייה ולצבירה )‪,condition‬‬
‫‪ conditionToSum‬ו‪ .(conditionToMult‬ייתכנו מקרי‪ ,‬כפי שאכ ראינו בבעיות האלגוריתמיות‬
‫‪ 2‬ו‪ ,4‬שהמנייה והצבירה מתבצעות ללא תנאי‪.‬‬
‫שאלה ‪1‬‬
‫א‪ .‬ישמו את פתרונותיה של ארבע הבעיות האלגוריתמיות ‪ 14‬בשפת ‪.Java‬‬
‫‪-328-‬‬
‫ב‪ .‬בהתייחס לבעיה ‪ :1‬שנו את התוכנית כ‪ $‬שתציג כפלט את מספר הילדי שאינ רשאי לעלות‬
‫למתק "רכבת הרי"‪.‬‬
‫ג‪ .‬בהתייחס לבעיה ‪ :2‬שנו את התוכנית כ‪ $‬שתציג כפלט את מספר הכניסות לאתר ביממה רק‬
‫עבור המשתמשי שהקוד שלה בי ‪ 100‬ל‪.200‬‬
‫ד‪ .‬בהתייחס לבעיה ‪ :3‬הרחיבו את התוכנית כ‪ $‬שתציג כפלט ג את סכו המספרי השליליי‪.‬‬
‫ה‪ .‬בהתייחס לבעיה ‪ :4‬הרחיבו את התוכנית כ‪ $‬שתציג כפלט ג את מספר המשקולות הכולל‬
‫שהמתחרה הצליח להרי‪.‬‬
‫נתונה סדרת הקלט הבאה‪0 :‬‬
‫‪14 -6 15‬‬
‫‪2 -3‬‬
‫א‪ .‬מה יוצג כפלט עבור כל אחד מהשימושי השוני בתבניות‪:‬‬
‫‪ .1‬מנה את האיברים האי‪-‬חיוביים בסדרת הקלט שאורכה ‪êøòä úà èìôë âöäå 6‬‬
‫‪ìá÷úäù‬‬
‫‪ .2‬מנה את האיברים הזוגיים בסדרת הקלט המסתיימת בזקיף ‪êøòä úà èìôë âöäå 0‬‬
‫‪ìá÷úäù‬‬
‫‪ .3‬חשב את הסכום המצטבר של האיברים המתחלקים ב‪ 3-‬בסדרת הקלט שאורכה ‪6‬‬
‫‪ìá÷úäù êøòä úà èìôë âöäå‬‬
‫‪ .4‬חשב את הסכום המצטבר של ‪ 7‬עם כל האיברים בסדרת הקלט המסתיימת בזקיף ‪0‬‬
‫‪ìá÷úäù êøòä úà èìôë âöäå‬‬
‫‪ .5‬חשב את המכפלה המצטברת של האיברים האי‪-‬זוגיים בסדרת הקלט המסתיימת‬
‫בזקיף ‪ìá÷úäù êøòä úà èìôë âöäå 5‬‬
‫‪ .6‬חשב את המכפלה המצטברת של ‪ 4‬בכל האיברים בסדרת הקלט המסתיימת בזקיף‬
‫‪ìá÷úäù êøòä úà èìôë âöäå 15‬‬
‫ב‪ .‬ישמו כל אחד מ השימושי בשפת ‪.Java‬‬
‫א‪ .‬בכיתה בת ‪ 41‬תלמידי קיימו בחירות לנציג מועצת תלמידי‪ .‬שני תלמידי הציגו את‬
‫מועמדות וכל תלמיד בכיתה הצביע עבור אחד המועמדי‪ .‬נתו אלגורית שהקלט שלו הוא‬
‫סדרה באור‪ 41 $‬של המספרי ‪ 1‬ו‪ 2‬המייצגי את מספרי המועמדי‪ ,‬והפלט שלו הוא מספרו‬
‫של המועמד שזכה ברוב קולות‪.‬‬
‫‪0-ì count1 úà ìçúà .1‬‬
‫‪0-ì count2 úà ìçúà .2‬‬
‫‪.3‬‬
‫‪candidate-á ãîòåî ìù øôñî èåì÷ .3.1‬‬
‫‪-329-‬‬
‫‪1-ì äååù candidate íà .3.2‬‬
‫‪1-á count1 úà ìãâä .3.2.1‬‬
‫‪.3.3‬‬
‫‪1-á count2 úà ìãâä .3.3.1‬‬
‫‪count1 > count2 íà .4‬‬
‫‪"úåìå÷ áåøá äëæ 1 øôñî ãîòåî" èìôë âöä .4.1‬‬
‫‪.5‬‬
‫באלגורית הנתו ישנו שילוב בשימוש של שני מוני‪ :‬ציינו מה ומהו תפקיד של אחד מה‪.‬‬
‫ב‪ .‬נתו אלגורית חלקי‪ ,‬השקול לאלגורית הנתו‪ ,‬א‪ $‬משתמש במונה אחד‪ .‬השלימו‪:‬‬
‫‪ .1‬מנה את האיברים ה________ בסדרת הקלט שאורכה ‪úà count-á íùäå 41‬‬
‫‪ìá÷úîä êøòä‬‬
‫‪.2‬‬
‫‪íà‬‬
‫________‬
‫‪"úåìå÷ áåøá äëæ 1øôñî ãîòåî" èìôë âöä .2.1‬‬
‫‪.3‬‬
‫א‪ .‬בסופרמרקט השכונתי בודקי מדי יו את הפדיו היומי ואת מספר הקוני‪ .‬פתחו אלגורית‬
‫שהקלט שלו הוא סדרת מספרי המייצגת את תשלומי הקוני‪ ,‬שבסיומה הזקי ‪ ,-1‬והפלט‬
‫שלו הוא מספר הקוני באותו יו והודעה המציינת א ביו זה ס‪ $‬הפדיו מקניות בסכומי‬
‫הגבוהי מ‪ ) 500‬עלה על ס‪ $‬הפדיו מקניות בסכומי שאינ גבוהי מ‪ .) 500‬ישמו את‬
‫ב‪ .‬ציינו באילו תבניות השתמשת בסעי א וכיצד שילבת ביניה‪.‬‬
‫תתסדרה תחילית של המספרי הטבעיי היא סדרה מהצורה ‪ .1, 2, 3, … n‬בניסיו לבחו את‬
‫"כוחה של המכפלה לעומת הסכו" הטילה המורה על תלמידיה לסכ את ערכיה של תתסדרות‬
‫תחיליות של המספרי הטבעיי וכ להכפיל את ערכיה‪.‬‬
‫א‪ .‬פתחו אלגורית שאינו מקבל קלט‪ ,‬והפלט שלו הוא האור‪ $‬הקט ביותר של תתסדרה‬
‫תחילית של המספרי הטבעיי‪ ,‬שעבורה ערכה של המכפלה המצטברת יהיה לפחות פי ‪100‬‬
‫מערכו של הסכו המצטבר‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫‪-330-‬‬
‫ב‪ .‬בפתרו בעיה זו יש שימוש בצובר מכפלה‪ .‬מהו ערכו התחילי של צובר זה? הסבירו‪.‬‬
‫ג‪ .‬ציינו באילו תבניות נוספות השתמשת וכיצד שילבת ביניה‪.‬‬
‫לקראת בחינות בגרות בית הספר מעוניי לתת שיעורי תגבור ל‪ 75‬תלמידי משתי כיתות שונות‪.‬‬
‫שיעורי התגבור יכולי להתקיי לאחר הלימודי‪ ,‬בימי ראשו ושלישי‪ .‬כדי להיער‪ $‬הוחלט‬
‫להעביר שאלו‪ ,‬שבעזרתו נית יהיה לקבוע כמה תלמידי רוצי שיעורי תגבור ומהו היו‬
‫המועד על רוב‪ .‬כל תלמיד רש בשאלו את מספר כיתתו )‪ 1‬או ‪ (2‬ואת מספר היו שאותו הוא‬
‫מעדי )‪ 1‬או ‪ .(3‬תלמיד שאינו מעוניי בתגבור רש את מספר כיתתו ואת המספר ‪.0‬‬
‫כתבו אלגורית‪ ,‬שהקלט שלו הוא הערכי שרשמו ‪ 75‬התלמידי‪ ,‬והפלט שלו כולל את‪:‬‬
‫‪ .1‬מספר התלמידי המעונייני בשיעורי תגבור‪.‬‬
‫‪ .2‬היו בשבוע שמרבית התלמידי מעדיפי‪.‬‬
‫‪ .3‬מספר החדרי הדרושי לשיעורי התגבור )בכל חדר ילמדו ‪ 15‬תלמידי לכל היותר(‪.‬‬
‫‪ .4‬מספר הכיתה שבה נרשמו פחות תלמידי לשיעורי התגבור‪.‬‬
‫א‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫ב‪ .‬ציינו באילו תבניות השתמשת וכיצד שילבת ביניה‪.‬‬
‫א‪ .‬פתחו אלגורית אשר מקבל כקלט סדרת גילאי של זוגות נשואי )גיל הבעל וגיל האישה(‪.‬‬
‫סו הקלט יצוי על ידי זוג הערכי ‪ .0 0‬הפלט יהיה אחוז הזוגות‪ ,‬שבה גיל האישה גבוה‬
‫מגילו של הבעל‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫א‪ .‬פתחו אלגורית אשר מקבל כקלט רשימת מספרי שלמי תלתספרתיי המסתיימת‬
‫במספר שאינו תלתספרתי‪ ,‬והפלט שלו הוא כמות המספרי שספרת העשרות שלה זוגית או‬
‫שסכומ של ספרות המספר הוא איזוגי‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫‪-331-‬‬
‫ממוצע של סדרת מספרים‬
‫נתבונ בבעיה האלגוריתמית הבאה‪:‬‬
‫כתבו אלגורית שהקלט שלו כולל ‪ 31‬מספרי המייצגי את הטמפרטורה בכל אחד מימי חודש‬
‫יולי‪ ,‬והפלט שלו הוא ממוצע הטמפרטורות בחודש זה‪.‬‬
‫לפתרו הבעיה עלינו לחשב ממוצע של ערכי מספריי‪ .‬בפרק ‪ 3‬היכרנו את התבנית ממוצע של‬
‫סדרת מספרים‪ ,‬עבור סדרה בת שני מספרי‪ .‬עתה נרחיב את התבנית עבור סדרת מספרי‬
‫באור‪ $‬כלשהו‪ .‬כדי לחשב ממוצע של סדרת מספרי יש לחשב תחילה את הסכו הכולל של‬
‫איברי הסדרה ולאחר מכ לחלקו במספר הערכי בסדרה‪ .‬התבנית של ממוצע‪ ,‬כפי שמשמשת‬
‫בפתרו בעיה זו‪ ,‬דומה לחישוב הממוצע שהוצג בפתרו בעיה ‪ 3‬בפרק הלימוד‪.‬‬
‫נתבונ בשני האלגוריתמי הבאי‪ ,‬הראשו לפתרו הבעיה שלעיל‪ ,‬והשני הוא האלגורית שנית‬
‫בפרק ‪ 7‬כפתרו לבעיה ‪:3‬‬
‫‪.2‬‬
‫‪temperature-á éìåé ùãåçá íåé ìù äøåèøôîè èåì÷ .2.1‬‬
‫‪temperature ìù åëøò úà sum ìù åëøòì óñåä .2.2‬‬
‫‪sum/31 éðåáùçä éåèéáä ìù åëøò úà average-á íùä .3‬‬
‫‪average ìù åëøò úà èìôë âöä .4‬‬
‫‪0-ì counterLarge úà ìçúà .2‬‬
‫‪length-á íìù éáåéç êøò èåì÷ .3‬‬
‫‪.4‬‬
‫‪:íéîòô length òöá‬‬
‫‪num-á éùîî êøò èåì÷ .4.1‬‬
‫‪sum-á øåîùä øáèöîä íåëñì num ìù åëøò úà óñåä .4.2‬‬
‫‪.4.3‬‬
‫‪íà‬‬
‫‪50-î ìåãâ num ìù åëøò‬‬
‫‪counterLarge ìù åëøò úà 1-á ìãâä .4.3.1‬‬
‫‪average-á íùäå sum/length éãé ìò íéëøòä òöåîî úà áùç .5‬‬
‫‪average ìù åëøò úà èìôë âöä .6‬‬
‫‪counterLarge ìù åëøò úà èìôë âöä .7‬‬
‫‪-332-‬‬
‫בשני האלגוריתמי אותחל ערכו של ‪ sum‬ל‪ 0‬ואז חושב הסכו המצטבר בתו‪ .sum $‬בתו‬
‫הביצוע החוזר מתבצעת חלוקה של ‪ sum‬במספר הערכי שסוכמו‪ .‬עבור הבעיה הנתונה מספר‬
‫הערכי שסוכמו הוא ‪ ,31‬כמספר הימי בחודש יולי‪ .‬בפתרו בעיה ‪ 3‬שהוצגה בפרק הלימוד‬
‫מספר הערכי המסוכמי הוא ‪.Length‬‬
‫נציג את מאפייני התבנית לחישוב ממוצע עבור ביצוע חוזר התלוי בתנאי‪ .‬שימו לב כי האלגורית‬
‫של התבנית משלב במקביל תבנית צבירה )כדי לסכו את הערכי( ותבנית מנייה )כדי לדעת כמה‬
‫ערכי נצברו(‪.‬‬
‫ש התבנית‪ :‬ממוצע של סדרת מספרי‬
‫נקודת מוצא‪ :‬תנאי סיו ‪ ,conditionToEnd‬ערכי הקלט‪ ,‬תנאי ‪conditionToInclude‬‬
‫מטרה‪ :‬חישוב ממוצע‪ ,‬שביצועו תלוי בתנאי ‪ ,conditionToEnd‬של ערכי הקלט המקיימי את‬
‫התנאי ‪conditionToInclude‬‬
‫‪:òöá conditionToEnd íéé÷úî àì ãåò ìë .4‬‬
‫‪conditionToInclude úà íéé÷î element íà .4.1‬‬
‫‪element úà sum ìù åëøòì óñåä .4.1.2‬‬
‫‪sum / count éðåáùçä éåèéáä ìù åëøò úà average-á íùä .5‬‬
‫;‪count = 0‬‬
‫;‪sum = 0‬‬
‫)‪while (!onditionToEnd‬‬
‫{‬
‫)‪if (conditionToInclude‬‬
‫{‬
‫;‪count++‬‬
‫;‪sum += element‬‬
‫}‬
‫}‬
‫;‪average = (double) sum / count‬‬
‫‪-333-‬‬
‫בדומה לדר‪ $‬בה נהגנו עבור תבניות מנייה וצבירה נית ג כא להציג תתתבנית המתאימה‬
‫לביצוע חוזר שאורכו ידוע מראש‪ .‬במקרה של ביצוע חוזר שאורכו ידוע מראש )והוא שווה ל‪(limit‬‬
‫אי צור‪ $‬במניית הערכי‪ .‬ולכ האלגורית הוא פשוט יותר‪:‬‬
‫‪ .1‬חשב את הסכום המצטבר של איברי סדרת הקלט שאורכה ‪limit‬‬
‫‪limit-á áùåçù øáèöîä íåëñä úà ÷ìç .2‬‬
‫שימו ♥‪ :‬עבור התבנית של ממוצע של סדרת מספרי יש להניח שבקלט יש לפחות ער‪ $‬אחד‬
‫המקיי את התנאי‪ ,‬וזאת כדי להימנע מחלוקה ב‪.0‬‬
‫ועוד שימו ♥‪ :‬בדומה לתבניות מנייה וצבירה‪ ,‬ג בתבנית ממוצע נית להשתמש ללא תנאי‬
‫)‪ ,(conditionToInclude‬כלומר לחשב את ממוצע כל האיברי בסדרה‪.‬‬
‫א‪ .‬ישמו את האלגורית לפתרו הבעיה של הטמפרטורה הממוצעת בחודש יולי בשפת ‪.Java‬‬
‫ב‪ .‬שנו את התוכנית שכתבת בסעי א כ‪ $‬שתחשב את הטמפרטורה הממוצעת רק עבור הימי‬
‫שבה הטמפרטורה הייתה מעל ‪ 30‬מעלות צלסיוס‪.‬‬
‫ג‪ .‬מעונייני להשוות בי הטמפרטורה הממוצעת בחודש יולי בשנה זו לבי הטמפרטורה‬
‫הממוצעת בחודש יולי בשנה הקודמת‪ ,‬ולהציג כפלט הודעה המציינת באיזו שנה מבי השתיי‬
‫הטמפרטורה הממוצעת הייתה גבוהה יותר‪ .‬הקלט כולל קוד כל את הערכי הנתוני עבור‬
‫חודש יולי בשנה זו‪ ,‬ואחר כ‪ $‬את הנתוני עבור חודש יולי בשנה הקודמת‪ .‬השלימו את‬
‫האלגורית החלקי‪:‬‬
‫‪ úà áùç .1‬הממוצע של סדרת ערכי הקלט שאורכה ______ ‪-á åúåà íùäå‬‬
‫‪averageCurrentYear‬‬
‫‪ úà áùç .2‬הממוצע של סדרת ערכי הקלט שאורכה ______ ‪-á åúåà íùäå‬‬
‫‪averageLastYear‬‬
‫‪.3‬‬
‫‪íà‬‬
‫________‬
‫‪________ èìôë âöä .3.1‬‬
‫‪.4‬‬
‫‪íà úøçà‬‬
‫________‬
‫‪________ èìôë âöä .4.1‬‬
‫‪.5‬‬
‫‪________ èìôë âöä .5.1‬‬
‫‪-334-‬‬
‫שאלה ‪10‬‬
‫באוניברסיטת "בית הסטודנט" הוחלט כי בקורס אשר בו ממוצע ציוני הבחינה של הסטודנטי‬
‫הוא מתחת ל‪ 55‬ייער‪ $‬מבח חוזר‪ .‬נתו אלגורית חלקי שהקלט שלו הוא סדרת ציוני‬
‫הסטודנטי בקורס מסוי‪ ,‬רשימה המסתיימת בזקי ‪ ,-1‬והפלט שלו הוא הודעה הא יש לקיי‬
‫מבח חוזר‪.‬‬
‫‪________ .1‬‬
‫‪________ .2‬‬
‫‪mark-á êøò èåì÷ .3‬‬
‫‪.4‬‬
‫‪:òöá -1-î äðåù mark ãåò ìë‬‬
‫‪________ .4.1‬‬
‫‪mark-á êøò èåì÷ .4.2‬‬
‫‪________ éðåáùçä éåèéáä ìù åëøò úà average-á íùä .5‬‬
‫‪________ íà .6‬‬
‫‪________ .6.1‬‬
‫א‪ .‬השלימו את האלגורית‪.‬‬
‫ב‪ .‬נית לכתוב את האלגורית בעזרת תבנית‪ .‬השלימו‪:‬‬
‫‪ ______________ úà áùç .1‬סדרת ערכי הקלט המסתיימת על ידי הזקיף ‪.-1‬‬
‫‪.2‬‬
‫‪íà‬‬
‫________‬
‫‪________ .2.1‬‬
‫ג‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪11‬‬
‫בשירות המטאורולוגי מחשבי בכל שנה את ממוצע המשקעי החודשי‪.‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא ‪ 12‬מספרי המייצגי את כמות המשקעי בכל אחד‬
‫מחודשי השנה‪ ,‬והפלט שלו הוא ממוצע המשקעי לחודש‪.‬‬
‫ב‪ .‬הרחיבו את האלגורית כ‪ $‬שיציג כפלט ג את ממוצע ששת החודשי הראשוני בשנה ואת‬
‫ממוצע ששת החודשי האחרוני בשנה‪.‬‬
‫שאלה ‪12‬‬
‫במפעל מסוי התבקש מנהל מחלקת משאבי אנוש לבדוק הא גיל הממוצע של הנשי במפעל‬
‫נמו‪ $‬מגיל הממוצע של הגברי במפעל‪.‬‬
‫‪-335-‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא ‪ 100‬זוגות נתוני המייצגי את מי העובד )'‪ – 'm‬גבר‪'f' ,‬‬
‫אישה( ושנת הלידה של העובד‪ ,‬והפלט שלו הוא הודעה מתאימה של מנהל מחלקת משאבי‬
‫האנוש לאחר הבדיקה‪.‬‬
‫ב‪ .‬הרחיבו את האלגורית שכתבת בסעי א כ‪ $‬שיציג כפלט את מספר העובדי הכולל שאמור‬
‫לצאת לגמלאות ב‪ 5‬השני הקרובות )הניחו כי גברי יוצאי לפנסיה בגיל ‪ 67‬ונשי בגיל‬
‫‪.(62‬‬
‫ד‪ .‬ציינו באילו תבניות השתמשת וכיצד שילבת ביניה‪.‬‬
‫‪-336-‬‬
‫מציאת מקסימום או מינימום בסדרה‬
‫למכרז זורמות הצעות כספיות שונות‪ .‬ההצעה הכספית הגבוהה ביותר היא זו הזוכה במכרז‪ .‬כתבו‬
‫אלגורית שהקלט שלו הוא סדרה המסתיימת בזקי ‪ ,0‬של מספרי המייצגי את ההצעות‬
‫הכספיות‪ ,‬והפלט שלו הוא סכומה של ההצעה הזוכה‪ .‬הניחו שבקלט יש לפחות הצעה אחת וכ‬
‫הניחו שקיימת הצעה יחידה שזוכה‪.‬‬
‫לפתרו הבעיה עלינו לחשב את הער‪ $‬המקסימלי מבי סדרת הערכי המספריי הנקלטי‪ .‬בפרק‬
‫‪ 5‬הראינו את התבנית של מציאת מקסימום ומינימום בסדרה בת שניי או שלושה ערכי‪ .‬עתה‬
‫נרחיב את התבנית עבור סדרה באור‪ $‬כלשהו‪ .‬התבנית של מציאת מקסימום ומינימום בסדרה‪,‬‬
‫כפי שמשמשת בפתרו בעיה זו‪ ,‬דומה לתבנית מציאת מקסימום ומינימום בסדרה שהוצגה‬
‫בבעיה ‪ 5‬בפרק הלימוד‪.‬‬
‫נתבונ בשני האלגוריתמי הבאי‪ ,‬הראשו לפתרו הבעיה שלעיל‪ ,‬והשני הוא האלגורית שנית‬
‫בפרק ‪ 7‬לפתרו בעיה ‪:5‬‬
‫‪max-á øéçî úòöä èåì÷ .1‬‬
‫‪price-á øéçî úòöä èåì÷ .2‬‬
‫‪.3‬‬
‫‪:òöá price ≠ 0 ãåò ìë‬‬
‫‪.3.1‬‬
‫‪íà‬‬
‫‪price > max‬‬
‫‪price ìù åëøò úà max-á íùä .3.1.1‬‬
‫‪price-á øéçî úòöä èåì÷ .3.2‬‬
‫‪howMany-á úåðåáùçä øôñî úà èåì÷ .1‬‬
‫‪balance-á ïåùàøä íåëñä úà èåì÷ .2‬‬
‫‪max-á balance ìù åëøò úà íùä .3‬‬
‫‪.4‬‬
‫‪:íéîòô howMany-1 òöá‬‬
‫‪balance-á àáä íåëñä úà èåì÷ .4.1‬‬
‫‪.4.2‬‬
‫‪íà‬‬
‫‪max < balance‬‬
‫‪max-á balance ìù åëøò úà íùä .4.2.1‬‬
‫‪-337-‬‬
‫בשתי הבעיות נדרשנו למצוא את הער‪ $‬הגדול ביותר בסדרת ערכי‪ .‬בשלב ראשו‪ ,‬קבענו באופ‬
‫שרירותי כי הער‪ $‬של המשתנה הראשו הוא המקסימלי ולכ נשמר ערכו במשתנה ‪ .max‬לאחר‬
‫מכ‪ ,‬נבדקו על פי סדר קליטת ערכיה של שאר נתוני הקלט‪ .‬עבור כל נתו קלט שערכו גדול‬
‫יותר מהמקסימו הנוכחי‪ ,‬הוחל ערכו של ‪ max‬בערכו של נתו הקלט‪ .‬באופ דומה‪ ,‬ע שינויי‬
‫קלי‪ ,‬עובד האלגורית עבור מציאת הער‪ $‬הקט ביותר בסדרה‪.‬‬
‫נפריד את מאפייני התבנית מציאת מקסימום ומינימום בסדרה לשתי תתתבניות‪ :‬ראשית‪ ,‬נציג‬
‫את מאפייני התבנית מציאת מקסימום בסדרה ואחר כ‪ $‬נציג את מאפייני התבנית מציאת‬
‫מינימום בסדרה‪ .‬עבור התבנית מציאת מקסימום נתייחס לביצוע חוזר באור‪ $‬הידוע מראש‬
‫ואילו עבור התבנית מציאת מינימום נתייחס לביצוע חוזר התלוי בתנאי‪ .‬באופ דומה נית‪ ,‬עבור‬
‫כל אחת מהתבניות‪ ,‬לטפל במקרה שאליו לא התייחסנו‪.‬‬
‫ש התבנית‪ :‬מציאת מקסימו בסדרה‬
‫נקודת מוצא‪ :‬אור‪ $‬סדרת נתוני הקלט ‪ ,limit‬ערכי הקלט‬
‫מטרה‪ :‬מציאת הער‪ $‬הגדול ביותר בסדרת ערכי הקלט שאורכה הוא ‪limit‬‬
‫‪max-á êøò èåì÷ .1‬‬
‫‪òöá .2‬‬
‫‪limit - 1‬‬
‫‪:íéîòô‬‬
‫‪íà 2.2‬‬
‫‪element > max‬‬
‫‪element ìù êøòä úà max-á íùä 2.2.1‬‬
‫;)(‪max = In.readInt‬‬
‫)‪for (i = 2; i <= limit; i++‬‬
‫{‬
‫)‪if (element > max‬‬
‫{‬
‫;‪max = element‬‬
‫}‬
‫}‬
‫‪-338-‬‬
‫ש התבנית‪ :‬מציאת מינימו בסדרה‬
‫נקודת מוצא‪ :‬תנאי סיו ‪ ,conditionToEndMinSearch‬ערכי הקלט‬
‫מטרה‪ :‬מציאת הער‪ $‬הקט ביותר מבי ערכי הקלט‪ ,‬עד אשר מתקיי התנאי‬
‫‪conditionTtoEndMinSearch‬‬
‫‪min-á êøò èåì÷ .1‬‬
‫‪:òöá conditionToEndMinSearch íéé÷úî àì ãåò ìë .3‬‬
‫‪íà .3.1‬‬
‫‪element < min‬‬
‫‪íùä .3.1.1‬‬
‫‪êøò èåì÷ .3.2‬‬
‫‪min-á‬‬
‫‪ìù êøòä úà‬‬
‫‪element‬‬
‫‪element-á‬‬
‫;)(‪min = In.readInt‬‬
‫)‪while (!conditionToEndMinSearch‬‬
‫{‬
‫)‪if (element < min‬‬
‫{‬
‫;‪min = element‬‬
‫}‬
‫}‬
‫שימו ♥‪ :‬לפני ההוראה לביצוע חוזר כבר נקראי שני ערכי מהקלט‪ .‬אנו נניח שהתנאי לסיו‬
‫)‪ (conditionToEndMinSearch‬יכול להתקיי עבור האיבר השני ואיל‪ .$‬לכ‪ ,‬למשל‪ ,‬א תנאי‬
‫הסיו מבטא קריאת זקי‪ ,‬הרי שסדרת הקלט מכילה לפחות איבר אחד‪.‬‬
‫ועוד שימו ♥‪ :‬א בקלט יש שני ערכי או יותר השווי למקסימו )או למינימו( אז‬
‫האלגוריתמי עבור התבניות מציאת מקסימום ומציאת מינימום מוצאי את המופע הראשו"‬
‫של המקסימו )או המינימו( בנתוני הקלט‪.‬‬
‫‪-339-‬‬
‫שאלה ‪13‬‬
‫א‪ .‬השלימו את השימוש בתבנית עבור בעיית המכרז‪:‬‬
‫מצא מקסימום בסדרת ערכי הקלט ______________ ‪èìôë åëøò úà âöäå‬‬
‫ב‪ .‬ישמו את האלגורית של המכרז בשפת ‪.Java‬‬
‫ג‪ .‬הרחיבו את האלגורית כ‪ $‬שיוצג כפלט ג סכו ההצעה השנייה בגודלה‪ .‬ישמו את‬
‫האלגורית המתקבל בשפת ‪.Java‬‬
‫שאלה ‪14‬‬
‫מדעני העוסקי בתחו המטאורולוגיה החליטו לגלות מהי הטמפרטורה הנמוכה ביותר ומהי‬
‫הטמפרטורה הגבוהה ביותר בצהרי היו בחודש נובמבר באזור הקוטב הצפוני‪ ,‬בו הטמפרטורה‬
‫תמיד מתחת ל‪ 0‬מעלות צלסיוס‪ .‬לצור‪ $‬כ‪ ,$‬המדעני מדדו את הטמפרטורה במש‪ 30 $‬יו‬
‫במהל‪ $‬חודש נובמבר‪ ,‬מדי יו ביומו‪ ,‬בשעה ‪ 12:00‬בצהריי‪.‬‬
‫נתו אלגורית שגוי‪ ,‬שהקלט שלו הוא ‪ 30‬ערכי הטמפרטורות והפלט שלו הוא הער‪ $‬הנמו‪$‬‬
‫ביותר והער‪ $‬הגדול ביותר‪:‬‬
‫‪0-ì maxTemperature úà ìçúà .1‬‬
‫‪0-ì minTemperature úà ìçúà .2‬‬
‫‪.3‬‬
‫‪temperature-á úéîåé äøåèøôîè êøò èåì÷ .3.1‬‬
‫‪temperature > maxTemperature íà .3.2‬‬
‫‪temperature úà maxTemperature-á íùä .3.2.1‬‬
‫‪.3.3‬‬
‫‪temperature < minTemperature íà‬‬
‫‪temperature úà minTemperature -á íùä .3.3.1‬‬
‫‪âöä .4‬‬
‫‪èìôë‬‬
‫"‪äøåèøôîèä‬‬
‫‪äëåîðä‬‬
‫‪øúåéá‬‬
‫‪ùãåçá‬‬
‫‪øáîáåð‬‬
‫‪"àéä‬‬
‫‪minTemperature‬‬
‫‪âöä .5‬‬
‫‪èìôë‬‬
‫"‪äøåèøôîèä‬‬
‫‪ääåáâä‬‬
‫‪øúåéá‬‬
‫‪ùãåçá‬‬
‫‪øáîáåð‬‬
‫‪"àéä‬‬
‫‪maxTemperature‬‬
‫א‪ .‬הסבירו במלי מדוע האלגורית שגוי‪.‬‬
‫ב‪ .‬תקנו את האלגורית‪.‬‬
‫שאלה ‪15‬‬
‫קבוצת אנשי מוגדרת כ"הומוגנית" א טווח הגילאי של חבריה אינו עולה על ‪ 5‬שני‪ ,‬אחרת‬
‫הקבוצה מוגדרת כ"הטרוגנית"‪.‬‬
‫‪-340-‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר האנשי בקבוצה‪ ,n ,‬ולאחר מכ סדרה של ‪ n‬מספרי‬
‫המייצגי את גילאי החברי בקבוצה‪ .‬הפלט שלו הוא הודעה הא הקבוצה "הומוגנית" או‬
‫"הטרוגנית"‪.‬‬
‫ב‪ .‬ציינו באילו תבניות השתמשת בכתיבת האלגורית וכיצד שילבת ביניה‪.‬‬
‫‪-341-‬‬
‫מציאת ערך נלווה למקסימום או למינימום בסדרה‬
‫היכרנו את התבנית של מציאת מקסימו או מינימו בסדרה אול לעיתי אנו מעונייני לאו‬
‫דווקא בערכי של המקסימו והמינימו אלא‪ ,‬למשל‪ ,‬במיקומ היחסי בקלט‪ .‬דוגמה למקרה‬
‫כזה הוא מציאת היו בחודש ינואר בו ירדה כמות משקעי מקסימלית‪.‬‬
‫נרחיב את בעיית המכרז שהוצגה בסעי הד בתבנית מציאת מקסימום ומינימום בסדרה כ‪$‬‬
‫שהקלט הוא סדרה של זוגות נתוני‪ ,‬כאשר כל זוג מכיל את הקוד של מגיש ההצעה )מספר של(‬
‫ואת סכו ההצעה הכספית‪ .‬הסדרה מסתיימת ע קליטת הזקי ‪ 0‬כאיבר שני בזוג‪ .‬הפלט של‬
‫האלגורית הוא הקוד של מגיש ההצעה הזוכה ‪.‬‬
‫לפתרו הבעיה עלינו לחשב את ההצעה המקסימלית מבי סדרת ההצעות הכספיות הנתונות‬
‫בקלט‪ ,‬אבל אנו נדרשי בנוס‪ $‬לשמור ג את קוד מגיש ההצעה‪ .‬התבנית של מציאת ערך נלווה‬
‫למקסימום ולמינימום בסדרה‪ ,‬כפי שמשמשת בפתרו בעיה זו‪ ,‬דומה לתבנית מציאת ערך‬
‫נלווה למקסימום ולמינימום בסדרה שהוצגה בבעיה ‪ 6‬בפרק הלימוד‪.‬‬
‫נתבונ בשני האלגוריתמי הבאי‪ ,‬האחד לפתרו הבעיה שלעיל‪ ,‬והשני הוא האלגורית שנית‬
‫בפרק ‪ 7‬לפתרו בעיה ‪:6‬‬
‫‪äòöä ùéâî ãå÷ èåì÷ .1‬‬
‫‪øéçî úòöä èåì÷ .2‬‬
‫‪winCode-á‬‬
‫‪max-á‬‬
‫‪äòöä ùéâî ìù óñåð ãå÷ èåì÷ .3‬‬
‫‪úôñåð øéçî úòöä èåì÷ .4‬‬
‫‪.5‬‬
‫‪code-á‬‬
‫‪price-á‬‬
‫‪:òöá price ≠ 0 ãåò ìë‬‬
‫‪.5.1‬‬
‫‪íà‬‬
‫‪price > max‬‬
‫‪ìù åëøò úà‬‬
‫‪íùä .5.1.1‬‬
‫‪max-á‬‬
‫‪íùä .5.1.2‬‬
‫‪winCode-á‬‬
‫‪äòöä ùéâî ãå÷ èåì÷ .5.2‬‬
‫‪øéçî úòöä èåì÷ .5.3‬‬
‫‪ìù åëøò úà‬‬
‫‪code‬‬
‫‪code-á‬‬
‫‪price-á‬‬
‫‪ìù åëøò úà èìôë âöä .6‬‬
‫‪price‬‬
‫‪winCode‬‬
‫‪-342-‬‬
‫‪currentSongLength-á ïåùàøä øéùä êøåà úà èåì÷ .1‬‬
‫‪longest-á currentSongLength ìù åëøò úà íùä .2‬‬
‫‪shortest-á currentSongLength ìù åëøò úà íùä .3‬‬
‫‪1 êøòä úà placeLongest-ì íùä .4‬‬
‫‪1 êøòä úà placeShortest-ì íùä .5‬‬
‫‪.6‬‬
‫‪: íéîòô 99 òöá‬‬
‫‪currentSongLength-á àáä øôñîä úà èåì÷ .6.1‬‬
‫‪.6.2‬‬
‫‪íà‬‬
‫‪currentSongLength > longest‬‬
‫‪longest-á currentSongLength úà íùä .6.2.1‬‬
‫‪placeLongest-á éçëåðä øéùä ìù åîå÷î úà íùä .6.2.2‬‬
‫‪.6.3‬‬
‫‪íà‬‬
‫‪currentSongLength < shortest‬‬
‫‪shortest-á currentSongLength úà íùä .6.3.1‬‬
‫‪placeShortest-á éçëåðä øéùä ìù åîå÷î úà íùä .6.3.2‬‬
‫‪.7‬‬
‫‪placeShortest ìù åëøò úàå placeLongest ìù åëøò úà èìôë âöä‬‬
‫בשתי הבעיות נדרשנו למצוא ער‪ $‬נלווה לער‪ $‬הגדול ביותר בסדרת ערכי‪ .‬בבעיה הנתונה בתחילת‬
‫הסעי הער‪ $‬הנלווה הוא קוד מגיש ההצעה ובבעיה ‪ 6‬בפרק הלימוד הער‪ $‬הנלווה הוא מקומו של‬
‫השיר הארו‪ $‬ביותר‪.‬‬
‫כדי למצוא את הער‪ $‬הנלווה לער‪ $‬הגדול ביותר בסדרת ערכי נתבסס על התבנית למציאת‬
‫מקסימו‪ :‬בכל פע שנעדכ את ערכו של ‪) max‬וכמוב ג באתחול( נשמור במשתנה נוס את‬
‫ערכו של הער‪ $‬הנלווה ל‪ .max‬באופ דומה‪ ,‬ע שינויי קלי‪ ,‬מתבצע האלגורית עבור מציאת‬
‫הער‪ $‬הנלווה לער‪ $‬הקט ביותר בסדרה‪.‬‬
‫בתבנית של מציאת ער‪ $‬נלווה למקסימו ולמינימו בסדרה נדגי כער‪ $‬הנלווה את מקו‬
‫המקסימו או המינימו‪ ,‬אבל כאמור‪ ,‬ער‪ $‬נלווה יכול להיות כל ער‪ $‬שהוא‪ ,‬כמו הקוד הנלווה‬
‫להצעה‪ ,‬בבעיה שלעיל‪.‬‬
‫נפריד את מאפייני התבנית מציאת ערך נלווה למקסימום ולמינימום בסדרה לשתי תת‬
‫תבניות‪ :‬ראשית‪ ,‬נציג את מאפייני התבנית מציאת ערך נלווה למקסימום בסדרה ואחר כ‪$‬‬
‫נציג את מאפייני התבנית מציאת ערך נלווה למינימום בסדרה‪ .‬עבור התתתבנית הראשונה‬
‫נתייחס לביצוע חוזר באור‪ $‬הידוע מראש‪ ,‬ואילו עבור השנייה נתייחס לביצוע חוזר התלוי בתנאי‪.‬‬
‫משו הדמיו בי שתי התתתבניות‪ ,‬קל לפתח אלגורית מתאי למקרה האחר‪ ,‬עבור כל אחת‬
‫מה‪.‬‬
‫‪-343-‬‬
‫ נלווה למקסימו בסדרה‬$‫ מציאת ער‬:‫ש התבנית‬
‫ ערכי הקלט‬,limit ‫ סדרת נתוני הקלט‬$‫ אור‬:‫נקודת מוצא‬
limit ‫ הגדול ביותר בסדרת ערכי הקלט שאורכה הוא‬$‫ מציאת מקו הער‬:‫מטרה‬
max-á êøò èåì÷ .1
1-ì placeOfMax úà ìçúà .2
:íéîòô
limit -1
òöá .3
element > max
íà .3.2
element ìù êøòä úà max-á íùä .3.2.1
èì÷á element ìù åîå÷î úà placeOfMax-á íùä 3.2.2
max = In.readInt();
placeOfMax = 1;
for (i = 2; i <= limit; i++)
{
if (element > max)
{
max = element;
placeOfMax = i;
}
}
-344-
‫ נלווה למינימו בסדרה‬$‫ מציאת ער‬:‫ש התבנית‬
‫ ערכי הקלט‬,conditionToEnd ‫ תנאי סיו‬:‫נקודת מוצא‬
‫ עד אשר מתקיי התנאי‬,‫ הקט ביותר מבי ערכי הקלט‬$‫ מציאת מקו הער‬:‫מטרה‬
conditionTtoEnd
min-á êøò èåì÷ .1
1-ì placeOfMin úà ìçúà .2
2-ì currentPlace úà ìçúà .4
:òöá conditionToEnd íéé÷úî àì ãåò ìë .5
element < min
íà .5.1
element ìù êøòä úà min-á íùä .5.1.1
currentPlace ìù êøòä úà placeOfMin-á íùä .5.1.2
1-á currentPlace úà ìãâä .5.2
element-á
êøò èåì÷ .5.3
min = In.readInt();
placeOfMin = 1;
currentPlace = 2;
{
if (element < min)
{
min = element;
placeOfMin = currentPlace;
}
currentPlace++;
}
-345-
‫שימו ♥‪ :‬לפני ההוראה לביצוע חוזר כבר נקראי שני ערכי מהקלט‪ .‬אנו נניח שהתנאי לסיו‬
‫)‪ (conditionToEnd‬יכול להתקיי עבור האיבר השני ואיל‪ .$‬לכ‪ ,‬למשל‪ ,‬א תנאי הסיו מבטא‬
‫קריאת זקי‪ ,‬הרי שסדרת הקלט מכילה לפחות איבר אחד‪.‬‬
‫לא פע מופיע הער‪ $‬המינימלי או המקסימלי בסדרה יותר מפע אחת‪ .‬בתבנית המוצגת מחושב‬
‫מקו המופע הראשו" של הער‪ $‬המקסימלי או המינימלי‪ .‬שינוי מזערי באלגורית יאפשר את‬
‫חישוב מקו המופע האחרו"‪ .‬שאלה ‪ 16‬מתייחסת לנקודה זאת‪ .‬ע ההתקדמות בחומר הלימוד‬
‫נתייחס ג לסוגיית מציאת כל המופעי של הער‪ $‬המקסימלי או המינימלי‪.‬‬
‫שאלה ‪16‬‬
‫א‪ .‬ישמו את האלגורית המורחב של המכרז בשפת ‪.Java‬‬
‫ב‪ .‬עתה‪ ,‬הניחו שבקלט יש שתי הצעות זוכות‪ ,‬כלומר שהער‪ $‬הגבוה ביותר של הצעה הוצע על ידי‬
‫שני מגישי‪ .‬שנו את האלגורית‪ ,‬ואחר כ‪ $‬את התוכנית שכתבת בסעי א‪ ,‬כ‪ $‬שיוצג כפלט‬
‫הקוד של מגיש ההצעה השנייה )במקו של הראשונה(‪.‬‬
‫שאלה ‪17‬‬
‫חנוכייה אופיינית היא חנוכייה בת ‪ 9‬קני‪ ,‬שאחד מה גבוה מ השאר ומשמש כשמש‪ .‬חנוכיה‬
‫כזו נחשבת "סימטרית" א השמש ממוק במרכז החנוכיה )ארבעה קני ממוקמי מימינו של‬
‫השמש וארבעה ממוקמי משמאלו(‪ .‬חנוכיה כזו נחשבת "צידית" א השמש ממוק בקצה אחד‬
‫שלה )שאר הקני ממוקמי משמאלו של השמש‪ ,‬או מימינו(‪.‬בכל מקרה אחר‪ ,‬נחשבת החנוכיה‬
‫"מיוחדת"‪.‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא ‪ 9‬מספרי המייצגי את גבהי הקני של חנוכייה אופיינית‪,‬‬
‫ונתוני לפי סדר מיקומ )משמאל לימי(‪ ,‬והפלט שלו הוא הודעה המציינת את סוג החנוכיה‪.‬‬
‫ב‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪18‬‬
‫בשכבת כיתות י' נער‪ $‬מבח משווה במדעי המחשב‪ .‬המבח נבדק על ידי המורי‪ ,‬וציוני‬
‫התלמידי נרשמו בטופס ריכוז בו כל תלמיד מיוצג על ידי מספר סידורי‪ .‬כל מורה התבקש למסור‬
‫למרכז המגמה את הציו הגבוה ביותר בכיתה ומספרו הסידורי של התלמיד שקיבל ציו זה‪ ,‬וכ‬
‫את הציו הנמו‪ $‬ביותר בכיתה ומספרו הסידורי של התלמיד שקיבל ציו זה )המורה ידווח על‬
‫תלמיד אחד מכל קטגוריה‪ ,‬ג א יש יותר מתלמיד אחד שקיבל את הציו הגבוה ביותר בכיתה‬
‫או יותר מתלמיד אחד שקיבל את הציו הנמו‪ $‬ביותר בכיתה(‪.‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר התלמידי ‪ n‬בכיתה מסוימת‪ ,‬ואחריו סדרה של ‪n‬‬
‫ציוני התלמידי בכיתה‪ ,‬והפלט שלו הוא הציו הגבוה ביותר בכיתה ומספרו הסידורי של‬
‫התלמיד שקיבל ציו זה‪ ,‬והציו הנמו‪ $‬ביותר בכיתה ומספרו הסידורי של התלמיד שקיבל ציו‬
‫זה‪.‬‬
‫ב‪ .‬הרחיבו את האלגורית כ‪ $‬שיציג כפלט ג את הציו השני בגודלו‪.‬‬
‫‪-346-‬‬
‫איסוף בקיזוז‬
‫באוניברסיטה נער‪ $‬סקר לבדיקת ההשערה‪" :‬מספר הסטודנטיות הלומדות קורסי המשלבי‬
‫מחשב קט יותר ממספר הסטודנטי בקורסי אלה"‪ .‬כתבו אלגורית שהקלט שלו הוא סדרה‬
‫באור‪ 100 $‬שאיבריה ה התו '‪ 'f‬או התו '‪ ,'m‬המייצגת את מינ )'‪ 'm‬סטודנט‪ 'f' ,‬סטודנטית( של‬
‫‪ 100‬סטודנטי הלומדי קורסי המשלבי מחשב‪ .‬הפלט הוא הודעה הא ההשערה נכונה או‬
‫אינה נכונה ביחס לנתוני‪.‬‬
‫בפתרו הבעיה אי חשיבות למספר הסטודנטי ומספר הסטודנטיות הלומדי קורסי המשלבי‬
‫מחשב‪ .‬לכ אי צור‪ $‬במנייה רגילה‪ .‬במקרה זה מתאי יותר למנות תו‪ $‬כדי קיזוז‪ .‬כלומר‪ ,‬נגדיר‬
‫מונה יחיד‪ ,‬שערכו יגדל בכל פע שנקלוט סטודנט‪ ,‬וערכו יקט בכל פע שנקלוט סטודנטית‪.‬‬
‫בסיו התהלי‪ $‬יהיה במונה ההפרש בי מספר הסטודנטי למספר הסטודנטיות‪ .‬נבדוק את ערכו‬
‫של המונה‪ :‬א ערכו חיובי ההשערה נכונה‪ .‬אחרת‪ ,‬ההשערה אינה נכונה‪ .‬ג עבור שאלה ‪7.27‬‬
‫בפרק הלימוד נית לכתוב אלגורית המתבסס על איסו בקיזוז‪.‬‬
‫נתבונ בשני האלגוריתמי הבאי‪ ,‬האחד לפתרו הבעיה שלעיל‪ ,‬והשני לפתרו שאלה ‪:7.27‬‬
‫‪:íéîòô 100 òöá .2‬‬
‫‪vote-á øçåá ìå÷ èåì÷ .2‬‬
‫‪gender-á èðãåèñä ïéî èåì÷ .2.1‬‬
‫‪'m' -ì äååù gender íà .2.2‬‬
‫‪:òöá vote <> '#' ãåò ìë .3‬‬
‫‪'A' -ì äååù vote íà .3.1‬‬
‫‪úøçà .3.2‬‬
‫‪úøçà 2.3‬‬
‫‪1-á count úà ïè÷ä .2.3.1‬‬
‫‪íà .3‬‬
‫‪1-á count úà ïè÷ä .3.2.1‬‬
‫‪0-î ìåãâ count‬‬
‫‪"äðåëð äøòùää" èìôë âöä .3.1‬‬
‫‪vote-á øçåá ìå÷ èåì÷ .3.3‬‬
‫‪íà .4‬‬
‫‪úøçà .4‬‬
‫‪"äðåëð àì äøòùää" èìôë âöä .4.1‬‬
‫‪0-î ìåãâ count‬‬
‫‪"äëæ ïåìà" èìôë âöä .4.1‬‬
‫‪úøçà .5‬‬
‫‪"äëæ àì ïåìà" èìôë âöä .4.2‬‬
‫התבנית של איסוף בקיזוז מתאימה ג לקיזוז באמצעות צבירה ולא רק לקיזוז באמצעות מנייה‪.‬‬
‫בהמש‪ $‬נראה שאלות‪ ,‬שבה יש צור‪ $‬לאסו בקיזוז באמצעות צבירה‪.‬‬
‫‪-347-‬‬
‫נפריד את מאפייני התבנית איסוף בקיזוז לשתי תתתבניות‪ :‬ראשית‪ ,‬נציג את מאפייני התבנית‬
‫איסוף בקיזוז באמצעות מנייה ואחר כ‪ $‬נציג את מאפייני התבנית איסוף בקיזוז באמצעות‬
‫צבירה‪ .‬עבור התבנית הראשונה נתייחס לביצוע חוזר באור‪ $‬הידוע מראש ואילו עבור השנייה‬
‫נתייחס לביצוע חוזר התלוי בתנאי‪ .‬כבמקרי קודמי‪ ,‬עבור כל אחת מהתבניות נית לפתח‬
‫אלגוריתמי מתאימי ג למקרה האחר‪.‬‬
‫ש התבנית‪ :‬איסו בקיזוז באמצעות מנייה‬
‫נקודת מוצא‪:‬אור‪ $‬סדרת נתוני הקלט ‪ ,limit‬ערכי הקלט‪ ,‬תנאי לקיזוז ‪conditionToDecrease‬‬
‫מטרה‪ :‬איסו בקיזוז באמצעות מנייה של ערכי הקלט‪ ,‬מתו‪ $‬סדרה שאורכה ‪ ,limit‬כשהקיזוז‬
‫מתבצע על פי התנאי ‪conditionToDecrease‬‬
‫‪íà .2.2‬‬
‫‪conditionToDecrease úà íéé÷î àì element‬‬
‫‪úøçà .2.3‬‬
‫‪1-á count úà ïè÷ä .2.3.1‬‬
‫;‪count = 0‬‬
‫)‪for (i = 1; i <= limit; i++‬‬
‫{‬
‫)‪if (!conditionToDecrease‬‬
‫{‬
‫;‪count++‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;‪count--‬‬
‫}‬
‫}‬
‫‪-348-‬‬
‫ שונה‬,‫ שליטה בקיזוז‬,‫ ותפקידו‬,‫ הוא הכרחי‬condition ‫ בתבנית איסוף בקיזוז התנאי‬:♥ ‫שימו‬
‫ בתבניות‬conditionToMult ‫ או‬conditionToSum ,conditionToCount ‫מתפקיד התנאי‬
.‫מנייה וצבירה‬
.‫ ביצועה תלוי בתנאי‬$‫ עבור שמש‬,‫עתה נראה את התבנית של איסו בקיזוז באמצעות צבירה‬
‫ איסו בקיזוז באמצעות צבירה‬:‫ש התבנית‬
‫ תנאי‬,initial ‫ צבירה התחלתי‬$‫ ער‬,‫ ערכי הקלט‬,conditionToEnd ‫ תנאי סיו‬:‫נקודת מוצא‬
conditionToDecrease ‫לקיזוז‬
‫ הביצוע תלוי‬$‫ כאשר מש‬,initial $‫ איסו בקיזוז באמצעות צבירה של ערכי הקלט אל הער‬:‫מטרה‬
conditionToDecrease ‫ והקיזוז מתבצע על פי התנאי‬,conditionToEnd ‫בתנאי‬
initial-ì sum úà ìçúà .1
:òöá conditionToEnd íéé÷úî àì
conditionToDecrease
element
úà íéé÷î àì
ìù åëøò úà
sum-ì
element
ãåò ìë .3
íà .3.1
óñåä .3.1.1
úøçà .3.2
element
ìù åëøò úà
sum-î
úçôä .3.2.1
element-á
êøò èåì÷ .3.3
sum = initial;
{
if (!conditionToDecrease)
{
sum += element;
}
else
{
sum -= element;
}
}
-349-
‫שאלה ‪19‬‬
‫ישמו את הפתרו לבעיית הסקר באוניברסיטה בשפת ‪.Java‬‬
‫שאלה ‪20‬‬
‫נתונה סדרת ההוראות הבאה‪ ,‬שיש בה שימוש בתבנית איסוף בקיזוז‪:‬‬
‫‪ .1‬אסוף בקיזוז באמצעות מנייה את איברי סדרת הקלט שאורכה ‪ ,8‬תוך קיזוז‬
‫האיברים האי‪-‬זוגיים‬
‫‪ìá÷úîä êøòä úà èìôë âöä .2‬‬
‫א‪ .‬תנו דוגמה לסדרת נתוני קלט של מספרי חיוביי שעבורה יוצג כפלט הער‪.3 $‬‬
‫ב‪ .‬הסבירו בקצרה מהי מטרת ההוראה‪.‬‬
‫ג‪ .‬השלימו את סדרת ההוראות הבאה‪ ,‬השקולה לסדרה הנתונה‪ ,‬א‪ $‬משתמשת בתנאי לקיזוז‬
‫אחר‪:‬‬
‫‪ .1‬אסוף בקיזוז באמצעות מנייה את איברי סדרת הקלט שאורכה ‪ ,8‬תוך קיזוז‬
‫האיברים הזוגיים‬
‫‪____________ úà èìôë âöä .2‬‬
‫שאלה ‪21‬‬
‫נתו אלגורית שהקלט שלו הוא סדרת מספרי ממשיי‪:‬‬
‫‪ sum úà ìçúà .1‬ל‪0‬‬
‫‪num-á éùîî øôñî èåì÷ .2‬‬
‫‪.3‬‬
‫‪:òöá num ≠ 0 ãåò ìë‬‬
‫‪num > 0 íà .3.1‬‬
‫‪num ìù åëøò úà sum-ì óñåä .3.1.1‬‬
‫‪.3.2‬‬
‫‪num ìù åëøò úà sum-î úçôä .3.2.1‬‬
‫‪num-á øôñî èåì÷ .3.3‬‬
‫א‪ .‬תנו שתי דוגמאות קלט שונות לסדרות נתוני קלט של מספרי ממשיי‪ ,‬שעבור יוצג כפלט‬
‫הער‪.0 $‬‬
‫ב‪ .‬הסבירו בקצרה מהי מטרת האלגורית‪.‬‬
‫ג‪ .‬כתבו הוראה השקולה לאלגורית תו‪ $‬שימוש בתבנית‪ .‬השלימו‪:‬‬
‫אסוף בקיזוז באמצעות צבירה ל‪ _______-‬של איברי סדרת הקלט המסתיימת‬
‫בזקיף ‪ ,0‬תוך קיזוז ________________‬
‫‪-350-‬‬
‫שאלה ‪22‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא יתרת לקוח של בנק בתחילת החודש‪ ,‬ואחריו סדרה של‬
‫מספרי‪ ,‬המסתיימת ב‪ .0‬כל מספר מייצג את סכו הפעולה‪ :‬סכו חיובי מציי הפקדת‬
‫הסכו בחשבו הבנק וסכו שלילי מציי משיכת הסכו מחשבו הבנק‪ .‬הפלט של‬
‫האלגורית הוא היתרה של הלקוח בסו החודש‪.‬‬
‫שאלה ‪) 23‬שאלה זו מתאימה לאחר לימוד סעי ‪ – 7.7‬קינו הוראות לביצוע חוזר(‬
‫מבח במתכונת של שאלו אמריקני הועבר ל‪ 30‬סטודנטי של הקורס "דיוק בתשובות"‪ .‬במבח‬
‫‪ 20‬שאלות‪ .‬ניקוד תשובות התלמידי התבצע באופ הבא‪ :‬כל תשובה נכונה זיכתה ב‪ 5‬נקודות‬
‫וכל תשובה שגויה גרמה להפחתה של ‪ 3‬נקודות )בכל מקרה‪ ,‬לא נית לקבל ציו נמו‪ $‬מ‪.(0‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא ‪ 20‬התשובות הנכונות ואחריה תשובות של ‪ 30‬הסטודנטי‬
‫בקורס )‪ 20‬תשובות לכל סטודנט(‪ .‬הפלט הוא מספר הסטודנטי שציונ "עובר" )לפחות ‪.(55‬‬
‫ב‪ .‬הרחיבו את האלגורית שכתבת בסעי א כ‪ $‬שיציג כפלט ג את אחוז התלמידי שקיבלו ‪0‬‬
‫במבח‪.‬‬
‫ג‪ .‬הרחיבו את האלגורית שכתבת בסעי ב כ‪ $‬שיציג כפלט ג את הציו הגבוה ביותר בבחינה‬
‫ואת הציו הנמו‪ $‬ביותר בבחינה )שאינו ‪.(0‬‬
‫ד‪ .‬ציינו מה התבניות המשמשות לפתרו וכיצד שילבת ביניה"‪.‬‬
‫ה‪ .‬ישמו את האלגורית שכתבת בסעי ג בשפת ‪.Java‬‬
‫שאלה ‪(*) 24‬‬
‫נתוני ארבעה ביטויי בוליאניי המשתמשי בתבניות‪ ,‬הבודקי אותו תנאי‪ ,‬עבור סדרת קלט‬
‫נתונה‪:‬‬
‫‪-î ìá÷úîä êøòä .1‬איסוף בקיזוז באמצעות צבירה של איברי סדרת הקלט שאורכה ‪,10‬‬
‫תוך קיזוז האיברים הזוגיים ‪ àåä‬זוגי‬
‫‪-î ìá÷úîä êøòä .2‬מנייה של האיברים האי‪-‬זוגיים בסדרת הקלט שאורכה ‪ àåä 10‬זוגי‬
‫‪-î ìá÷úîä êøòä .3‬צבירת סכום איברי סדרת הקלט שאורכה ‪ àåä 10‬זוגי‬
‫‪-î ìá÷úîä êøòä .4‬צבירת סכום האיברים האי‪-‬זוגיים בסדרת הקלט שאורכה ‪àåä 10‬‬
‫זוגי‬
‫א‪ .‬תנו דוגמה לסדרת מספרי שלמי חיוביי שעבורה הער‪ $‬של כל אחד מהביטויי‬
‫הבוליאניי יהיה ‪.true‬‬
‫ב‪ .‬נסחו במלי את התנאי שמבטאי הביטויי הבוליאניי‪.‬‬
‫ג‪ .‬ישמו כל אחד מהשימושי השוני כקטעי תוכניות בשפת ‪.Java‬‬
‫‪-351-‬‬
‫פירוק מספר חיובי לספרותיו‬
‫בפרק ‪ 4‬היכרנו את התבנית של פירוק מספר דוספרתי חיובי לספרותיו‪ .‬עתה נרחיב את התבנית‬
‫עבור מספר של חיובי באור‪ $‬כלשהו‪ .‬פירוק המספר מתבסס על רעיו של הפרדת ספרת האחדות‬
‫מהמספר‪ ,‬כ‪ $‬שהמספר שנותר קט פי ‪ ,10‬וחוזר חלילה עד שלא נותרות ספרות במספר‪.‬‬
‫נראה את מאפייני התבנית פירוק מספר חיובי לספרותיו‪:‬‬
‫ש התבנית‪ :‬פירוק מספר חיובי לספרותיו‬
‫נקודת מוצא‪ :‬מספר של חיובי ‪num‬‬
‫מטרה‪ :‬הצגה כפלט של ספרותיו של ‪num‬‬
‫‪òöá 0-î äðåù num ãåò ìë .1‬‬
‫‪ úà èìôë âöä .2‬ספרת האחדות של ‪num‬‬
‫‪10 éô num úà ïè÷ä .3‬‬
‫{‬
‫;)‪System.out.println(num % 10‬‬
‫;‪num /= 10‬‬
‫}‬
‫שימו ♥‪ :‬באלגורית של התבנית הצגנו כפלט את ספרותיו של ‪ ,num‬אול נית כמוב לבצע‬
‫פעולות אחרות על ספרות המספר‪ ,‬כגו‪ :‬מנייה‪ ,‬צבירה‪ ,‬ועוד‪ .‬השאלות הבאות מתייחסות לבעיות‬
‫אלגוריתמיות בה נדרשות פעולות אחרות על ספרות המספר‪.‬‬
‫שאלה ‪25‬‬
‫א‪ .‬פתחו אלגורית שהקלט שלו הוא מספר של חיובי‪ ,‬והפלט שלו הוא מספר הספרות במספר‪.‬‬
‫ב‪ .‬הרחיבו את האלגורית שכתבת בסעי א כ‪ $‬שיציג כפלט ג את סכו הספרות האיזוגיות‬
‫במספר ‪.‬‬
‫ג‪ .‬הרחיבו את האלגורית שכתבת בסעי ב כ‪ $‬שיציג כפלט ג הודעה המציינת א יש במספר‬
‫יותר ספרות המתחלקות ב‪ 3‬ללא שארית מאשר ספרות שאינ מתחלקות ב‪ .3‬ישמו את‬
‫האלגורית המלא בשפת ‪.Java‬‬
‫ד‪ .‬ציינו באילו תבניות השתמשת בכתיבת האלגורית המלא וכיצד שילבת ביניה‪.‬‬
‫‪-352-‬‬
‫שאלה ‪26‬‬
‫לפניכ קטע תוכנית בשפת ‪ ,Java‬שהקלט שלו הוא מספר של חיובי‪ ,‬והפלט שלו אמור להיות‬
‫מספר הספרות במספר‪ .‬קטע התוכנית שגוי‪.‬‬
‫;)(‪num = In.readInt‬‬
‫;‪sum = num % 10‬‬
‫)‪while ((num / 10) > 0‬‬
‫;‪sum += num % 10‬‬
‫;)‪System.out.println(sum‬‬
‫א‪ .‬הביאו דוגמת קלט שעבורה יתקבל הפלט הדרוש‪.‬‬
‫ב‪ .‬הביאו דוגמת קלט שעבורה לא יתקבל הפלט הדרוש‪.‬‬
‫ג‪ .‬הסבירו במלי מדוע קטע התוכנית שגוי‪.‬‬
‫ד‪ .‬תקנו את קטע התוכנית כ‪ $‬שישיג את מטרתו עבור כל קלט חוקי‪.‬‬
‫שאלה ‪27‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר של וחיובי ‪ num‬ומספר חדספרתי ‪ place‬המייצג‬
‫מקו‪ .‬הפלט שלו הוא הספרה הנמצאת במקו ‪ place‬במספר ‪) num‬מיקו הספרות מתחיל‬
‫מימי"(‪ .‬א אי במספר ‪ place‬ספרות יוצג כפלט הער‪.-1 $‬‬
‫למשל‪ ,‬עבור הקלט‬
‫‪ 17489 2‬יוצג כפלט הער‪ ,8 $‬ועבור הקלט ‪ 17489 6‬יוצג כפלט‬
‫הער‪. -1 $‬‬
‫שאלה ‪28‬‬
‫ספרת שורש של מספר היא ספרה בי ‪ 1‬ל‪ 9‬המתקבלת מתהלי‪ $‬של חיבור חוזר של ספרות‬
‫המספר עד אשר מתקבל מספר חדספרתי‪ .‬למשל‪ ,‬ספרת השורש של המספר ‪ 30486‬היא ‪ ,2‬כיוו‬
‫שסכו ספרות המספר המקורי הוא ‪ 20‬וסכו הספרות של ‪ 20‬הוא ‪.2‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר של חיובי והפלט שלו הוא ספרת השורש של המספר‬
‫הנתו‪.‬‬
‫שאלה ‪29‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר של חיובי והפלט שלו הוא ההפרש בי הספרה‬
‫הגדולה ביותר במספר לבי הספרה הקטנה ביותר במספר‪.‬‬
‫‪-353-‬‬
‫בניית מספר‬
‫בפרק ‪ 4‬היכרנו את התבנית של בניית מספר כאשר התמקדנו בבניית מספר דוספרתי משתי‬
‫ספרות‪ .‬עתה נרחיב את התבנית לבניית מספר של באור‪ $‬כלשהו מספרות הנקלטות בזו אחר זו‪.‬‬
‫כדי להרכיב מספר מספרות צרי‪ $‬בכל שלב בלולאה להגדיל את המספר פי ‪ 10‬ולחבר לו את ספרת‬
‫הקלט החדשה‪ .‬כ‪ $‬עד לסיו הקלט‪.‬‬
‫נית להרחיב את התבנית‪ ,‬למשל‪ ,‬על ידי בניית מספר ממספרי דוספרתיי‪ ,‬ואז בכל שלב יגדל‬
‫המספר פי ‪ 100‬ויתווס לו המספר הדוספרתי התור מהקלט‪.‬‬
‫נציג עבור התבנית בניית מספר אלגורית עבור ביצוע חוזר באור‪ $‬הידוע מראש‪ .‬נית להתאימו‬
‫ג למקרי בה סיו הבנייה תלוי בתנאי‪.‬‬
‫ש התבנית‪ :‬בניית מספר‬
‫נקודת מוצא‪ :‬אור‪ $‬סדרת נתוני הקלט ‪ ,limit‬ספרות הקלט‬
‫מטרה‪ :‬בניית מספר מספרות הקלט‬
‫‪0-ì num úà ìçúà .1‬‬
‫‪digit-á äøôñ èåì÷ .2.1‬‬
‫‪num * 10 + digit éðåáùçä éåèéáä ìù êøòä úà num-á íùä .2.2‬‬
‫;‪num = 0‬‬
‫)‪for (i = 1; i <= limit; i++‬‬
‫{‬
‫;)(‪digit = In.readInt‬‬
‫;‪num = num * 10 + digit‬‬
‫}‬
‫שאלה ‪30‬‬
‫נתו האלגורית הבא‪:‬‬
‫‪digit-á äøôñ èåì÷ .1‬‬
‫‪limit-á øôñî èåì÷ .2‬‬
‫‪0-ì num úà ìçúà .3‬‬
‫‪.4‬‬
‫‪:íéîòô limit òöá‬‬
‫‪-354-‬‬
‫‪num * 10 + digit éðåáùçä éåèéáä ìù êøòä úà num-á íùä .4.1‬‬
‫‪num úà èìôë âöä .4.2‬‬
‫א‪ .‬מה יהיה הפלט עבור הקלט ‪?5 3‬‬
‫ב‪ .‬תנו דוגמה לקלט שעבורו הפלט יהיה ‪.6‬‬
‫ג‪ .‬הסבירו בקצרה מהי מטרת האלגורית‪.‬‬
‫שאלה ‪31‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר של וחיובי ‪ ,num‬ספרה ‪ digit‬ומקו ‪ .place‬הפלט‬
‫שלו הוא המספר שמתקבל מהחלפת הספרה הנמצאת במקו ‪) place‬מימי( במספר ‪num‬‬
‫בספרה ‪.digit‬‬
‫למשל‪ ,‬עבור הקלט ‪ 78342 4 6‬יוצג כפלט הער‪ ,76342 $‬ועבור הקלט ‪ 13608 1 9‬יוצג‬
‫כפלט הער‪.13608 $‬‬
‫שאלה ‪32‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר של וחיובי ‪ num‬והפלט שלו הוא המספר המתקבל‬
‫מ‪ num‬על ידי היפו‪ $‬סדר ספרותיו‪.‬‬
‫‪-355-‬‬
‫האם כל הערכים בסדרה מקיימים תנאי?‬
‫במסגרת הפעילות של עידוד "הקורא הצעיר" הוחלט להעניק פרס לביתספר שבו כל תלמידיו‬
‫קראו לפחות ספר קריאה אחד במהל‪ $‬חופשת הקי‪ ./‬פתחו אלגורית שהקלט שלו הוא מספר‬
‫הספרי שקרא כל אחד מתלמידי ביתספר "אמירי" שבסיומה הזקי ‪) -1‬עבור תלמיד שלא‬
‫קרא כלל ספרי ייקלט הער‪ ,(0 $‬והפלט שלו הוא הודעה המציינת א הפרס יוענק לביתהספר‪.‬‬
‫לפתרו הבעיה עלינו לעבור על כל נתוני הקלט‪ ,‬כלומר‪ ,‬לבדוק עבור כל תלמיד הא קרא ספרי‬
‫קריאה במהל‪ $‬החופשה או לא‪ .‬אבל‪ ,‬א קיי לפחות תלמיד אחד שלא קרא ספר קריאה אז‬
‫לביתהספר לא יוענק הפרס ולכ אי טע להמשי‪ $‬ולבדוק את מספר ספרי הקריאה שקראו שאר‬
‫תלמידי ביתהספר‪ .‬אלגורית זה הוא תיאור של התבנית האם כל הערכים בסדרה מקיימים‬
‫תנאי? ‪ .‬ג עבור שאלה ‪ 7.53‬בפרק הלימוד נית לכתוב אלגורית המתבסס על תבנית זו‪.‬‬
‫נתבונ בשני האלגוריתמי הבאי‪ ,‬הראשו לפתרו הבעיה שלעיל‪ ,‬והשני לפתרו שאלה ‪:7.53‬‬
‫‪true-ì allReaders úà ìçúà .1‬‬
‫‪books-á ãéîìúì äàéø÷ éøôñ øôñî èåì÷ .2‬‬
‫‪.3‬‬
‫‪:òöá true àåä allReaders ìù åëøò íâå books ≠ -1 ãåò ìë‬‬
‫‪0 àåä books ìù åëøò íà .3.1‬‬
‫‪false êøòä úà allReaders-á íùä .3.1.1‬‬
‫‪.3.2‬‬
‫‪books-á ãéîìúì äàéø÷ éøôñ øôñî èåì÷ .3.2.1‬‬
‫‪true àåä allReaders ìù åëøò íà .4‬‬
‫‪"ñøôä ÷ðòåî íéøéîà øôñä-úéáì" èìôë âöä .4.1‬‬
‫‪ allEven úà ìçúà .1‬ל‪true‬‬
‫‪ sum úà ìçúà .2‬ל‪0‬‬
‫‪1-ì howMany úà ìçúà .3‬‬
‫‪.4‬‬
‫‪:òöá true àåä allEven ìù åëøò íâå howMany ≤ 20 ãåò ìë‬‬
‫‪num-á éáåéç øôñî èåì÷ .4.1‬‬
‫‪1-á howMany ìù åëøò úà ìãâä .4.2‬‬
‫‪.4.3‬‬
‫‪íà‬‬
‫‪ num‬מספר אי‪-‬זוגי‬
‫‪false êøòä úà allEven-á íùä .4.3.1‬‬
‫‪.4.4‬‬
‫‪num-á sum úà ìãâä .4.4.1‬‬
‫‪-356-‬‬
‫‪allEven íà .5‬‬
‫‪sum ìù åëøò úà èìôë âöä .5.1‬‬
‫‪.6‬‬
‫‪"é÷åç åðéà èì÷ä" èìôë âöä .6.1‬‬
‫משמעות התבנית האם כל הערכים בסדרה מקיימים תנאי? היא בדיקה של קיו תנאי עבור‬
‫כל ערכי הסדרה‪ .‬מתבצעת סריקה של ערכי הקלט בזה אחר זה‪ ,‬וא אחד הערכי אינו מקיי‬
‫את התנאי אי טע בהמש‪ $‬הסריקה‪ .‬בבעיה הנתונה א ערכו של ‪ books‬שווה ל‪ 0‬אז נמצא‬
‫תלמיד שלא קרא א לא ספר קריאה אחד ולכ אי צור‪ $‬להמשי‪ $‬בסריקה‪ .‬בשאלה ‪ 7.53‬א‬
‫בקלט יש מספר איזוגי אז אי טע להמשי‪ $‬בבדיקת שאר ערכי המספרי‪.‬‬
‫נציג את מאפייני התבנית האם כל הערכים בסדרה מקיימים תנאי? עבור סדרה שאורכה ידוע‬
‫מראש‪ .‬נית להתאי את האלגורית למקרה שבו אור‪ $‬הסדרה אינו ידוע מראש‪ ,‬בדומה‬
‫לאלגורית שנית לבעיה שלעיל‪.‬‬
‫ש התבנית‪ :‬הא כל הערכי בסדרה מקיימי תנאי?‬
‫נקודת מוצא‪ :‬אור‪ $‬סדרת נתוני הקלט ‪ ,limit‬ערכי הקלט‪ ,‬תנאי ‪condition‬‬
‫מטרה‪ :‬חישוב הער‪ true $‬א כל הערכי בסדרה מקיימי את התנאי ‪ condition‬והער‪false $‬‬
‫א קיי ער‪ $‬אחד בסדרה שאינו מקיי את התנאי‬
‫‪true-ì all úà ìçúà .1‬‬
‫‪1-ì howmany úà ìçúà .2‬‬
‫‪:òöá true àåä all ìù åëøò íâå howmany ≤ limit ãåò ìë .3‬‬
‫‪1-á howMany ìù åëøò úà ìãâä .3.2‬‬
‫‪íà .3.3‬‬
‫‪condition úà íéé÷î åðéà element‬‬
‫‪false êøòä úà all-á íùä .3.3.1‬‬
‫;‪all = true‬‬
‫;‪howmany = 1‬‬
‫))‪while ((howmany <= limit) && (all‬‬
‫{‬
‫;‪howmany++‬‬
‫‪ element‬אינו מקיים את התנאי ‪if (condition)//‬‬
‫{‬
‫;‪all = false‬‬
‫}‬
‫}‬
‫‪-357-‬‬
‫התבנית האם כל הערכים בסדרה מקיימים תנאי? מחשבת ער‪ $‬בוליאני שערכו ‪ true‬או ‪.false‬‬
‫אנו משתמשי במשתנה בוליאני ‪ all‬שערכו התחילי הוא ‪ ,true‬כלומר‪ ,‬ההנחה התחילית היא שכל‬
‫ערכי הסדרה אכ מקיימי את התנאי‪ .‬א במהל‪ $‬הסריקה אחד הערכי אינו מקיי את התנאי‬
‫אז ההנחה התחילית שלנו מתבדה ולכ ערכו של ‪ all‬מקבל ער‪ false $‬ו הסריקה מסתיימת‪.‬‬
‫שאלה ‪33‬‬
‫א‪ .‬רשמו הוראה השקולה לאלגורית של "הקורא הצעיר" תו‪ $‬שימוש בתבנית החדשה‪ .‬השלימו‪:‬‬
‫האם כל הערכים בסדרת הקלט המסתיימת ב‪ _________-‬מקיימים את‬
‫התנאי________?‬
‫שאלה ‪34‬‬
‫א‪ .‬כתבו אלגורית שהקלט שלו הוא מספר של וחיובי ‪ num‬והפלט שלו הוא ההודעה "ספרות‬
‫זהות" א כל ספרות המספר זהות וההודעה "ספרות שונות" א לא כל הספרות זהות‪.‬‬
‫שאלה ‪35‬‬
‫לפניכ קטע תוכנית בשפת ‪ ,Java‬שהקלט שלו הוא סדרה של מספרי שלמי וחיוביי‪ .‬סו‬
‫הקלט מצוי על ידי המספר ‪ .-1‬קטע התוכנית אמור להציג כפלט את ההודעה "כל המספרי ה‬
‫כפולות של ‪ "6‬א ‪ 6‬מחלק של כל המספרי בסדרת הקלט‪ .‬קטע התוכנית שגוי‪.‬‬
‫)‪while (num != -1‬‬
‫{‬
‫)‪ok = (num % 6 == 0‬‬
‫}‬
‫)‪if (ok‬‬
‫{‬
‫;)"‪System.out.println ("All numbers are multiples of 6‬‬
‫}‬
‫א‪ .‬תנו דוגמה לסדרת קלט )לפחות ‪ 5‬ערכי( עבורה לא נית להבחי שקטע התוכנית שגוי‪.‬‬
‫ב‪ .‬תנו דוגמה לסדרת קלט )לפחות ‪ 5‬ערכי( עבורה נית להבחי שקטע התוכנית שגוי‪.‬‬
‫ג‪ .‬הסבירו במילי מדוע קטע התוכנית שגוי‪.‬‬
‫ד‪ .‬תקנו את קטע התוכנית כ‪ $‬שיבצע את מטרתו עבור כל סדרת קלט‪.‬‬
‫‪-358-‬‬
‫האם קיים ערך בסדרה המקיים תנאי?‬
‫בעיה ‪ :1‬כתבו אלגורית‪ ,‬שהקלט שלו הוא סדרה של ‪ 15‬מספרי שלמי‪ ,‬והפלט שלו הוא‬
‫הודעה המציינת א קיי בסדרת הקלט מספר שלילי‪.‬‬
‫בעיה ‪ :2‬כתבו אלגורית‪ ,‬שהקלט שלו הוא סדרה של תווי‪ ,‬המסתיימת בזקי '*'‪ ,‬והפלט שלו‬
‫הוא הודעה המציינת א נקלטה בסדרת התווי אחת מאותיות ה‪ ABC‬או אחת מאותיות ה‬
‫‪.abc‬‬
‫לפתרו שתי הבעיות עלינו לעבור על נתוני הקלט עד למציאת ער‪ $‬המקיי את התנאי‪ .‬בבעיה ‪1‬‬
‫התנאי הוא הא ער‪ $‬הקלט הוא מספר שלילי ובבעיה ‪ 2‬התנאי הוא הא נקלטה אחת מאותיות‬
‫ה‪ ABC‬או אחת מאותיות ה‪ .abc‬א קיי ער‪ $‬אחד המקיי את התנאי אז יש להפסיק את‬
‫הסריקה כי ער‪ $‬מתאי כבר נמצא‪ .‬אלגורית זה הוא תיאור של התבנית האם קיים ערך‬
‫בסדרה המקיים תנאי?‪.‬‬
‫נתבונ בשני האלגוריתמי לפתרו בעיה ‪ 1‬ובעיה ‪:2‬‬
‫‪false-ì found úà ìçúà .1‬‬
‫‪.3‬‬
‫‪:òöá false-ì äååù found ìù åëøò íâå howmany ≤ 15 ãåò ìë‬‬
‫‪num-á íìù øôñî èåì÷ .3.1‬‬
‫‪1-á howmany ìù åëøò úà ìãâä .3.2‬‬
‫‪num < 0 íà .3.3‬‬
‫‪true êøòä úà found-á íùä .3.3.1‬‬
‫‪found íà .4‬‬
‫‪"èì÷ä úøãñá éìéìù øôñî íéé÷" èìôë âöä .4.1‬‬
‫‪.5‬‬
‫‪"èì÷ä úøãñá éìéìù øôñî íéé÷ àì" èìôë âöä .5.1‬‬
‫‪false-ì found úà ìçúà .1‬‬
‫‪ch-á åú èåì÷ .2‬‬
‫‪.3‬‬
‫‪ìë‬‬
‫‪ch ≠ '*' ãåò‬‬
‫‪:òöá false àåä found ìù åëøò íâå‬‬
‫‪-359-‬‬
(ch ≤ 'Z'
íâå ch ≥ 'A' ) åà (ch ≤= 'z' íâå ch ≥ 'a') íà
.3.1
true êøòä úà found-á íùä .3.1.1
úøçà
.3.2
ch-á åú èåì÷ .3.2.1
found íà .4
"èì÷ä úøãñá abc-á åà ABC-á úåà úîéé÷" èìôë âöä .4.1
úøçà
.5
"èì÷ä úøãñá abc-á åà ABC-á úåà úîéé÷ àì" èìôë âöä .5.1
‫נציג את מאפייני התבנית האם קיים ערך בסדרה המקיים תנאי? עבור סדרה שאורכה אינו‬
‫ בדומה‬,‫ הסדרה ידוע מראש‬$‫ נית להתאי את האלגורית למקרה שבו אור‬.‫ידוע מראש‬
.‫ שלעיל‬1 ‫לאלגורית שנית לבעיה‬
?‫ בסדרה המקיי תנאי‬$‫ הא קיי ער‬:‫ש התבנית‬
condition ‫ תנאי‬,‫ ערכי הקלט‬,toEnd ‫ תנאי לסיו הסדרה‬:‫נקודת מוצא‬
‫ א‬false $‫ והער‬condition ‫ בסדרה המקיי את התנאי‬$‫ א קיי ער‬true $‫ חישוב הער‬:‫מטרה‬
‫כל הערכי בסדרה אינ מקיימי את התנאי‬
false-ì found úà ìçúà .1
:òöá false àåä found ìù åëøò íâå íéé÷úî àì toEnd éàðúä ãåò ìë .3
condition úà íéé÷î element íà .3.1
true
êøòä úà found-á íùä .3.1.1
úøçà .3.2
element-á êøò èåì÷ .3.2.1
found = false;
while (!toEnd && !found)
{
if (condition) // ‫ מקיים את התנאי‬element
{
found = true;
}
}
-360-
‫משמעות התבנית האם קיים ערך בסדרה המקיים תנאי? היא בדיקה של קיו תנאי עבור‬
‫ערכי בסדרה‪ .‬מתבצעת סריקה של ערכי הקלט בזה אחר זה‪ ,‬וא אחד הערכי אכ מקיי את‬
‫התנאי אי טע בהמש‪ $‬הסריקה‪ .‬התבנית מחשבת ער‪ $‬בוליאני שערכו ‪ true‬או ‪ .false‬לכ‪ ,‬אנו‬
‫משתמשי במשתנה בוליאני ‪ found‬שערכו התחילי הוא ‪ .false‬כלומר‪ ,‬ההנחה התחילית היא‬
‫שאי ער‪ $‬בסדרה המקיי את התנאי‪ .‬א במהל‪ $‬הסריקה אחד הערכי אכ מקיי את התנאי‬
‫אז ההנחה התחילית שלנו מתבדה‪ ,‬מאחר שמצאנו ער‪ $‬המקיי את התנאי‪ .‬לכ ‪ found‬יקבל ער‪$‬‬
‫‪ true‬והסריקה תסתיי‪.‬‬
‫שאלה ‪36‬‬
‫א‪ .‬כתבו הוראה השקולה לאלגוריתמי של כל אחת מהבעיות ‪ 1‬ו‪ 2‬תו‪ $‬שימוש בתבנית האם‬
‫קיים ערך בסדרה המקיים תנאי?‪ .‬השלימו‪:‬‬
‫בעיה ‪:1‬‬
‫‪.1‬‬
‫‪íà‬‬
‫קיים ערך בסדרת הקלט שאורכה________ המקיים ________‬
‫‪.2‬‬
‫בעיה ‪:2‬‬
‫‪ íà .1‬קיים ערך בסדרת הקלט שמסתיימת ב‪ _________-‬המקיים ________‬
‫‪"èì÷ä úøãñá abc-á åà ABC-á úåà úîéé÷" èìôë âöä .1.1‬‬
‫‪.2‬‬
‫‪"èì÷ä úøãñá abc-á åà ABC-á úåà úîéé÷ àì" èìôë âöä .2.1‬‬
‫ב‪ .‬ישמו את האלגוריתמי לפתרו הבעיות ‪ 1‬ו‪ 2‬בשפת ‪.Java‬‬
‫ג‪ .‬עבור כל אחד מהאלגוריתמי נית לכתוב אלגורית שקול תו‪ $‬שימוש בתבנית האם כל‬
‫הערכים בסדרה מקיימים תנאי?‪ .‬השלימו את ההוראות הבאות עבור בעיה ‪ ,1‬וכתבו‬
‫הוראות מתאימות‪ ,‬המשתמשות בתבנית זו‪ ,‬לבעיה ‪.2‬‬
‫בעיה ‪:1‬‬
‫‪.1‬‬
‫‪àì íà‬‬
‫כל הערכים בסדרה שאורכה________ מקיימים את התנאי‬
‫_____________‬
‫‪.2‬‬
‫‪-361-‬‬
‫שאלה ‪37‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו מספר של חיובי והפלט שלו הוא הודעה המציינת א קיימת‬
‫במספר הספרה ‪.0‬‬
‫ב‪ .‬שנו את האלגורית שכתבת בסעי א כ‪ $‬שיציג הודעה המציינת א קיימת ספרה זוגית‬
‫במספר‪ .‬ציינו איזו תבנית שילבת בפתרו הבעיה‪.‬‬
‫שאלה ‪38‬‬
‫בכיתה י' המורה העלתה הצעה לעשות קומזי‪ /‬לגיבוש ‪ 39‬תלמידי הכיתה‪ .‬ההצעה תתקבל רק א‬
‫א תלמיד לא יתנגד להגיע לקומזי‪ ./‬כל תלמיד התבקש לרשו על ד את האות '‪ 'y‬א הוא‬
‫מסכי להצעה או את האות '‪ 'n‬א הוא מתנגד להצעה‪ .‬יש לכתוב אלגורית‪ ,‬שהקלט שלו הוא‬
‫סדרה של ‪ 39‬תווי כאשר התו '‪ 'y‬מייצג את הסכמת התלמיד להצעה והתו '‪ 'n‬מייצג את התנגדות‬
‫התלמיד להצעה‪ .‬הפלט הוא הודעה המציינת א ההצעה התקבלה או לא‪.‬‬
‫לפניכ שני אלגוריתמי לפתרו הבעיה‪:‬‬
‫אלגורית ‪:1‬‬
‫‪ íà .1‬קיים ערך בסדרת הקלט שאורכה ‪ 39‬המקיים את התנאי )‪ answer‬שווה ל‪-‬‬
‫'‪('n‬‬
‫‪"äìá÷úä àì äòöää" äòãåää úà èìôë âöä .1.1‬‬
‫‪.2‬‬
‫‪"äìá÷úä äòöää" äòãåää úà èìôë âöä .2.1‬‬
‫‪.1‬‬
‫‪íà‬‬
‫כל הערכים בסדרת הקלט שאורכה ‪ 39‬מקיימים את התנאי )‪ answer‬שווה‬
‫ל‪('y' -‬‬
‫‪"äìá÷úä äòöää" äòãåää úà èìôë âöä .1.1‬‬
‫‪.2‬‬
‫‪"äìá÷úä àì äòöää" äòãåää úà èìôë âöä .2.1‬‬
‫ישמו את שני האלגוריתמי בשפת ‪.Java‬‬
‫‪-362-‬‬
‫מציאת כל הערכים בסדרה המקיימים תנאי‬
‫בעיה ‪ :1‬כתבו אלגורית‪ ,‬שהקלט שלו הוא סדרה של ‪ 25‬זוגות מספרי שלמי‪ ,‬והפלט שלו הוא‬
‫כל זוגות המספרי המקיימי את היחס של מספרי עוקבי‪.‬‬
‫בעיה ‪ :2‬כתבו אלגורית‪ ,‬שהפלט שלו הוא כל המספרי מ‪ 1‬עד ‪ 100‬המקיימי את הכללי של‬
‫"‪ 7‬בו"‪ ,‬כלומר‪ :‬מתחלקי ב‪ 7‬ללא שארית או כוללי את הספרה ‪.7‬‬
‫לפתרו שתי הבעיות עלינו לעבור על כל הערכי בסדרה ולהציג כפלט את כל הערכי המקיימי‬
‫את התנאי‪ .‬בבעיה ‪ 1‬התנאי הוא יחס של עוקב בי כל זוג מספרי ברשימה ובבעיה ‪ 2‬התנאי הוא‬
‫קיו הכללי של "‪ 7‬בו"‪ .‬יש דמיו מסוי בי תבנית זו לשתי התבניות האחרונות‪ ,‬א‪ $‬במקרה‬
‫זה איננו יכולי להפסיק את הסריקה לפני שנגיע אל סיו סדרת הקלט‪ .‬אלגורית זה הוא‬
‫תיאור של התבנית מציאת כל הערכים בסדרה המקיימים תנאי‪.‬‬
‫נתבונ בשני האלגוריתמי לפתרו בעיה ‪ 1‬ובעיה ‪:2‬‬
‫‪.1‬‬
‫‪num2-áå num1-á íéîìù íéøôñî âåæ èåì÷ .2‬‬
‫‪.2.1‬‬
‫‪íà‬‬
‫‪ num1‬ו‪ num2-‬הם ערכים עוקבים‬
‫‪åà‬‬
‫‪ num2‬ו‪ num1-‬הם ערכים‬
‫עוקבים‬
‫‪ num1 ìù íéëøòä úà èìôë âöä .2.1.1‬ושל ‪num2‬‬
‫‪.1‬‬
‫‪:òöá 100-î ïè÷ä íìù éáåéç i øôñî ìë øåáò‬‬
‫‪.1.1‬‬
‫‪íà‬‬
‫‪ 7‬מחלק של ‪ åà i‬ספרת העשרות של ‪ i‬שווה ל‪ åà 7-‬ספרת האחדות‬
‫של ‪ i‬שווה ל‪7-‬‬
‫‪i ìù êøòä úà èìôë âöä .1.1.1‬‬
‫בתבנית מציאת כל הערכים בסדרה המקיימים תנאי מתבצעת סריקה של כל ערכי הקלט בזה‬
‫אחר זה‪ .‬בכל פע שנמצא ער‪ $‬שמקיי את התנאי מבצעי עליו פעולה כגו הצגה כפלט‪ ,‬מנייה‪,‬‬
‫פעולה חשבונית‪.‬‬
‫נציג את מאפייני התבנית מציאת כל הערכים בסדרה המקיימים תנאי עבור סדרה שאורכה‬
‫אינו ידוע מראש‪ .‬נית להתאי את האלגורית למקרה שבו אור‪ $‬הסדרה ידוע מראש‪ ,‬בדומה‬
‫‪-363-‬‬
‫לאלגורית שנית לבעיה ‪ 1‬ו‪ 2‬שלעיל‪ .‬מאפייני התבנית מוגדרי לפי ביצוע פעולת קלט עבור כל‬
‫איבר שנמצא מקיי את התנאי‪ .‬נית להתאימ למקרה בו נדרשת פעולה אחרת‪ ,‬כפי שקורה‬
‫בכמה מהשאלות הבאות‪.‬‬
‫ש התבנית‪ :‬מציאת כל הערכי בסדרה המקיימי תנאי‬
‫נקודת מוצא‪ :‬תנאי לסיו הסדרה ‪ ,toEnd‬ערכי הקלט‪ ,‬תנאי ‪condition‬‬
‫מטרה‪ :‬הצגה כפלט של כל ערכי הקלט המקיימי את התנאי ‪condition‬‬
‫‪:òöá íéé÷úî àì toEnd éàðúä ãåò ìë .2‬‬
‫‪íà .3.1‬‬
‫‪element ìù åëøò úà èìôë âöä .3.1.1‬‬
‫)‪while (!toEnd‬‬
‫{‬
‫{‬
‫;)‪System.out.println(element‬‬
‫}‬
‫}‬
‫שאלה ‪39‬‬
‫א‪ .‬רשמו הוראה השקולה לאלגורית לפתרו בעיה ‪ 1‬תו‪ $‬שימוש בתבנית‪ .‬השלימו‪:‬‬
‫מצא את כל הערכים בסדרת הקלט שאורכה ________ המקיימים את התנאי‬
‫________‬
‫ג‪ .‬רשמו הוראה השקולה לאלגורית לפתרו בעיה ‪ 2‬תו‪ $‬שימוש בתבנית‪ .‬השלימו‪:‬‬
‫מצא את כל הערכים בסדרת הקלט שאורכה ________ המקיימים את התנאי‬
‫________‬
‫ד‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫‪-364-‬‬
‫שאלה ‪40‬‬
‫תלמידי שכבה י' בביתספר "היובל" השתתפו בתחרויות יו ספורט היתולי‪ ,‬במהלכו כל משתת‬
‫צבר נקודות‪ .‬תוצאתו של תלמיד שלא השתת היא ‪ .0‬למע גיבוש הכיתות הוחלט להעניק "יו‬
‫כי" לכיתות שבה השתתפו כל התלמידי בתחרויות של יו הספורט‪.‬‬
‫נתו אלגורית חלקי‪ ,‬שהקלט שלו הוא תוצאות התחרויות של כל אחת מ‪ 10‬הכיתות בבית‬
‫הספר‪ .‬לכל כיתה נקלטת סדרת התוצאות של כל התלמידי עד לקליטת הזקי ‪ .-1‬הפלט של‬
‫האלגורית הוא מספרי הכיתות שזכו ב"יו כי"‪.‬‬
‫‪.1‬‬
‫‪:òöá 10-ì äååù åà ïè÷ä íìùå éáåéç i ìë øåáò‬‬
‫‪________-ì prize úà ìçúà .1.1‬‬
‫‪result-á ãéîìú úàöåú èåì÷ .1.2‬‬
‫‪.1.3‬‬
‫‪:òöá ________ íâå ________ ãåò ìë‬‬
‫‪________ íà .1.3.1‬‬
‫‪false êøòä úà prize-á íùä .1.3.1.1‬‬
‫‪.1.3.2‬‬
‫‪________ .1.3.2.1‬‬
‫‪________ íà .2‬‬
‫‪________ èìôë âöä .2.1‬‬
‫א‪ .‬השלימו את האלגורית‪.‬‬
‫ב‪ .‬ציינו מה התבניות המשולבות באלגורית‪.‬‬
‫ג‪ .‬בהנהלת ביתהספר החליטו להעניק פרס נוס "גיבושו" לכיתה שתלמידיה צברו את מירב‬
‫הנקודות בתחרות‪ .‬הרחיבו את האלגורית כ‪ $‬שיציג כפלט את מספר הכיתה שזכתה בפרס‬
‫"גיבושו"‪ .‬איזו תבנית שילבת עתה בפתרו הבעיה האלגוריתמית?‬
‫שאלה ‪41‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא סדרה של מספרי חיוביי )סו הסדרה מצוי ע"י מספר‬
‫שלילי(‪ ,‬והפלט שלו הוא כל המספרי המתחלקי בסכו ספרותיה וכמות המספרי‬
‫המקיימי תנאי זה‪.‬‬
‫לדוגמה‪ :‬עבור סדרת הקלט ‪ :4000 110 550 83 103 18 -7‬המספרי ‪ 110 550 18‬ו‪-‬‬
‫‪ 4000‬מתחלקי בסכו ספרותיה‪ ,‬לכ הפלט הוא רשימת המספרי ‪18 550 110 4000‬‬
‫והודעה המציינת כי כמות המספרי המתחלקי בסכו ספרותיה‪4 :‬‬
‫‪-365-‬‬
‫מעבר על זוגות סמוכים בסדרה‬
‫בעיה ‪ :1‬כתבו אלגורית‪ ,‬שהקלט שלו הוא סדרה של ‪ 18‬מספרי שלמי‪ ,‬והפלט שלו הוא‬
‫הודעה הא הסדרה מסודרת בסדר עולה ממש‪.‬‬
‫בעיה ‪ :2‬כתבו אלגורית‪ ,‬שהקלט שלו הוא סדרה של מספרי שלמי חיוביי‪ ,‬המסתיימת ע‬
‫קליטת הזקי ‪ ,0‬והפלט שלו הוא סדרה שבה מכפלות כל זוגות המספרי הזוגיי הנקלטי זה‬
‫אחר זה בסמיכות‪ .‬לדוגמה‪ ,‬עבור הקלט‪ 3 5 6 4 8 9 4 2 0 :‬תוצג כפלט הסדרה‪,24 32 8 :‬‬
‫המתקבלת ממכפלת ‪ 6‬ב‪ ,4‬מכפלת ‪ 4‬ב‪ 8‬ומכפלת ‪ 4‬ב‪.2‬‬
‫לפתרו שתי הבעיות יש לעבור על כל זוגות הערכי הסמוכי בסדרה‪ .‬בבעיה ‪ 1‬יש לבדוק עבור כל‬
‫זוג ערכי סמוכי א הוא מקיי את היחס של הער‪ $‬הראשו )משמאל( קט יותר מהער‪ $‬השני‪.‬‬
‫בבעיה ‪ 2‬יש להציג כפלט את המכפלות של זוגות מספרי סמוכי שאיבריה זוגיי‪ .‬זה הוא‪,‬‬
‫למעשה‪ ,‬תיאור של התבנית מעבר על זוגות סמוכים בסדרה‪.‬‬
‫נתבונ בשני האלגוריתמי הבאי לפתרו בעיות ‪ 1‬ו‪:2‬‬
‫‪true-ì ordered úà ìçúà .1‬‬
‫‪beforeLast-á íìù øôñî èåì÷ .3‬‬
‫‪.4‬‬
‫‪ìë‬‬
‫‪true àåä ordered ìù åëøò íâå howmany < 18 ãåò‬‬
‫‪last-á íìù øôñî èåì÷ .4.1‬‬
‫‪beforelast ≥ last íà .4.2‬‬
‫‪false êøòä úà ordered-á íùä .4.2.1‬‬
‫‪.4.3‬‬
‫‪last ìù êøòä úà beforeLast-á íùä .4.3.1‬‬
‫‪.5‬‬
‫‪íà‬‬
‫‪ordered‬‬
‫‪"ùîî äìåò øãñá úøãåñî äøãñä" äòãåää úà èìôë âöä .5.1‬‬
‫‪.6‬‬
‫‪"ùîî äìåò øãñá úøãåñî äðéà äøãñä" èìôë âöä .6.1‬‬
‫‪beforeLast-á íìù øôñî èåì÷ .1‬‬
‫‪last-á íìù øôñî èåì÷ .2‬‬
‫‪.3‬‬
‫‪:òöá last<>0 ãåò ìë‬‬
‫‪-366-‬‬
‫‪.3.1‬‬
‫‪ àåä beforeLast íà‬מספר זוגי ‪íâå‬‬
‫‪ àåä last‬מספר זוגי‬
‫‪éåèéáä ìù êøòä úà èìôë âöä .3.1.1‬‬
‫‪êøòä úà beforeLast-á íùä .3.2‬‬
‫‪last-á íìù øôñî èåì÷ .3.3‬‬
‫‪beforeLast * last éðåáùçä‬‬
‫‪last ìù‬‬
‫בפתרו בעיות אלגוריתמיות רבות יש לבצע פעולות על זוגות ערכי הסמוכי בסדרה‪ .‬עבור סדרת‬
‫נתוני קלט באור‪ limit $‬יש בס‪ $‬הכול ‪ limit-1‬זוגות ערכי סמוכי‪ .‬למעשה נית להסתכל על כל‬
‫זוג ערכי סמוכי כאל פריט אחד‪ .‬הרעיו שבבסיס של שני האלגוריתמי הוא שבכל שלב‬
‫המשתני ‪ beforeLast‬ו‪ last‬מכילי איברי זוג סמו‪ .$‬המעבר לזוג הבא מתבצע כ‪beforeLast :$‬‬
‫מקבל את ערכו של ‪) last‬כלומר‪ ,‬האיבר שקוד היה איבר שני בזוג הוא עכשיו איבר ראשו בזוג‬
‫הסמו‪ ($‬וב‪ last‬נקלט ער‪ $‬נוס‪ .‬כ‪ $‬עד לסיו הקלט‪.‬‬
‫לש המחשה נדגי בתבנית הצגה כפלט של סכו זוגות ערכי סמוכי בסדרה‪ .‬נית כמוב לבצע‬
‫פעולות אחרות על ערכי כל זוג‪ ,‬כגו מנייה‪ ,‬צבירה ועוד‪ .‬בהמש‪ $‬נדגי כמה מהאפשרויות השונות‬
‫דר‪ $‬שאלות‪.‬‬
‫נציג את מאפייני התבנית מעבר על זוגות סמוכים בסדרה עבור סדרה שאורכה ידוע מראש‪.‬‬
‫אפשר לערו‪ $‬התאמות למקרה בו אור‪ $‬סדרת הקלט אינו ידוע מראש‪ ,‬כמו בבעיה ‪ 2‬לעיל‪.‬‬
‫ש התבנית‪ :‬מעבר על זוגות סמוכי בסדרה‬
‫נקודת מוצא‪ :‬אור‪ $‬סדרת נתוני הקלט ‪ ,limit‬ערכי הקלט‬
‫מטרה‪ :‬הצגה כפלט של סכומי כל זוגות הערכי הסמוכי בסדרת הקלט שאורכה ‪limit‬‬
‫‪beforeLast-á êøò èåì÷ .1‬‬
‫‪íéîòô limit-1 òöá .2‬‬
‫‪last-á êøò èåì÷ .2.1‬‬
‫‪beforeLast + last éðåáùçä éåèéáä ìù êøòä úà èìôë âöä .2.2‬‬
‫‪last ìù êøòä úà beforeLast-á íùä .2.3‬‬
‫;)(‪beforeLast = In.readInt‬‬
‫)‪for (i = 1; i <= limit-1; i++‬‬
‫{‬
‫;)(‪last = In.readInt‬‬
‫;)‪System.out.println(beforeLast + last‬‬
‫;‪beforeLast = last‬‬
‫}‬
‫‪-367-‬‬
‫שימו ♥‪ :‬אנו מניחי שבסדרת הקלט לפחות שני ערכי‪.‬‬
‫שאלה ‪42‬‬
‫ישמו את האלגוריתמי של שתי הבעיות הנתונות בשפת ‪. Java‬‬
‫שאלה ‪43‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא ‪ 25‬תווי והפלט שלו הוא כל הזוגות הסמוכי בסדרת‬
‫הקלט שמכילי אותיות קטנות ב‪ abc‬עוקבות‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫ב‪ .‬ציינו באילו תבניות נוספות השתמשת בכתיבת האלגורית וכיצד שילבת ביניה‪.‬‬
‫שאלה ‪44‬‬
‫כתבו אלגורית שהקלט שלו הוא סדרת מספרי שלמי המסתיימת בזקי ‪ ,-1‬והפלט הוא כל‬
‫המספרי בקלט השווי לסכו שני המספרי הקודמי לה בסדרה )שני המספרי הראשוני‬
‫לא יודפסו(‪.‬‬
‫למשל‪ ,‬עבור סדרת הקלט הבאה )משמאל לימי(‪ 4 9 2 11 13 0 13 5 6 89 -1 :‬יוצגו כפלט‬
‫המספרי‪.11 13 13 :‬‬
‫שאלה ‪45‬‬
‫כתבו תוכנית בשפת ‪ ,Java‬שהקלט שלה הוא מספר של וחיובי ‪ num‬והפלט שלה הוא הודעה‬
‫הא ספרות המספר מסודרות בסדר עולה ממש‪.‬‬
‫ציינו באילו תבניות נוספות השתמשת בכתיבת התוכנית וכיצד שילבת ביניה‪.‬‬
‫‪-368-‬‬
‫פרק ‪ – 8‬יעילות של אלגוריתמי‬
‫אלגוריתמי נבחני על פי מספר קני מידה‪ .‬קנה המידה החשוב ביותר הוא נכונות‪ .‬כלומר השגת‬
‫המטרה )מת הפלט הנכו( עבור כל קלט חוקי‪ .‬קנה מידה נוס הוא יעילות‪.‬‬
‫יעילות של‬
‫אלגורית )תוכנית( נמדדת על פי "משאבי המחשב" הדרושי לביצוע האלגורית‪.‬‬
‫משאבי אלה ה גודל המקו )בזיכרו( והזמ הדרוש לביצוע האלגורית‪.‬‬
‫גודל המקו נמדד‪ ,‬בעיקר‪ ,‬על פי מספר המשתני של האלגורית‪.‬‬
‫זמ הביצוע נקבע על פי מספר פעולות היסוד שיתבצעו במהל ביצוע האלגורית‪.‬‬
‫פעולות‬
‫היסוד ה‪ :‬פעולת קלט‪ ,‬פעולת פלט ופעולות חישוב‪.‬‬
‫למעשה‪ ,‬בצורה פשטנית נאמר שכל הוראה באלגורית כוללת פעולת יסוד אחת‪ ,‬ומכא‪ ,‬מדידת‬
‫זמ הביצוע של‬
‫אלגורית נעשית על פי מספר ההוראות שיתבצעו במהל ביצוע האלגורית‬
‫)בזמ הרצתו על המחשב(‪.‬‬
‫שימו ♥‪ :‬המדד הוא מספר ההוראות שיתבצעו ולא מספר ההוראות באלגורית! מספר ההוראות‬
‫באלגורית אינו מעיד בהכרח על מספר ההוראות שיתבצעו במהל ביצוע האלגורית‪ .‬בפרט‪ ,‬עבור‬
‫אלגורית הכולל לולאה‪ ,‬ייתכ שמספר ההוראות שבו הוא מועט‪ ,‬א מספר ההוראות שיתבצעו הוא‬
‫רב‪ ,‬כי כל הוראה בלולאה יכולה להתבצע כמה פעמי‪ .‬נפרט נקודה זו במהל הפרק‪.‬‬
‫מדידת זמ הביצוע לא נעשית על פי הזמ בפועל שאורכת ריצת תוכנית המיישמת את האלגורית‪ .‬יש‬
‫לכ כמה סיבות‪:‬‬
‫‪ .1‬ישנ מחשבי מהירי יותר ומהירי פחות‪ .‬מכיוו שפעולות היסוד נמשכות זמ שונה‬
‫ממחשב למחשב‪ ,‬זמ ההרצה בפועל של אותה תוכנית יכול להיות שונה ממחשב למחשב‪.‬‬
‫‪ .2‬ג א נרי‪ %‬את התוכנית על אותו מחשב כמה פעמי יתכ שבכל פע ההרצה תיקח פרק‬
‫זמ שונה‪ ,‬כתלות בעומס המחשב באותו הזמ‪ .‬נית לדמות זאת לזמ המתנה במסעדה‪:‬‬
‫זמ ההמתנה קצר יותר כאשר במסעדה פחות אורחי‪ .‬בדומה‪ ,‬זמ ההמתנה לסיו ריצת‬
‫תוכנית קצר יותר כאשר ישנ מעט תוכניות נוספות אשר רצות במקביל על המחשב‪.‬‬
‫‪ .3‬ג המהדר )הקומפיילר( שבו השתמשנו כדי להדר את התוכנית משפיע על מהירותה של‬
‫תוכנית‪ .‬מהדרי שוני מביאי ליצירת תוכניות )בשפת מכונה( שונות ולכל אחת מה‬
‫זמ ריצה שונה במקצת‪ ,‬ג א ה מורצות על אותו המחשב ובאותה השעה‪.‬‬
‫‪-369-‬‬
‫בפרק זה נתמקד בזמ הביצוע של אלגורית‪ ,‬ונכיר אלגוריתמי שוני לפתרו אותה הבעיה‪ ,‬אשר‬
‫נבדלי זה מזה בזמ הביצוע‪ ,‬לפעמי בצורה משמעותית‪ .‬למדד המקו נתייחס בפרק ‪.10‬‬
‫נמחיש את ההבדל בי זמני הביצוע של שני אלגוריתמי שוני באמצעות בעיה שאנו נתקלי בה מדי‬
‫פע בחיי יו(יו‪ ,‬והיא ג אחת מבעיות היסוד במדעי המחשב‪ .‬הבעיה היא בעיית חיפוש ברשימה‬
‫ממוינת‪:‬‬
‫קלט‪ :‬רשימה של שמות ממויני לפי סדר הא"ב )למשל‪ ,‬מדרי טלפוני או ד קשר(‪.‬‬
‫פלט‪ :‬הודעה מתאימה א ש מסוי מופיע ברשימה‪.‬‬
‫נית לחפש את הש המבוקש בשתי דרכי‪:‬‬
‫הדר הראשונה‪ ,‬היא על ידי חיפוש סדרתי‪ ,‬כלומר‪ ,‬מעבר על פני הרשימה‪ ,‬ש אחרי ש‪ ,‬עד שיימצא‬
‫הש המבוקש‪ ,‬או עד שיתברר שהש לא מופיע ברשימה‪ .‬ברשימות ארוכות מאד‪ ,‬למשל כמו ספר‬
‫טלפוני‪ ,‬חיפוש כזה עלול לקחת הרבה מאד זמ‪.‬‬
‫א תיזכרו כיצד את מחפשי בספר טלפוני תיווכחו שלחיפושי ברשימות ארוכות אנו משתמשי‬
‫בדר כלל בחיפושי לא סדרתיי‪ ,‬למשל‪ ,‬החיפוש הלאסדרתי הבא‪ :‬נתבונ בש המופיע באמצע‬
‫הרשימה‪ ,‬ונשווה אותו לש המבוקש‪ ,‬א השמות זהי – סיימנו את תהלי החיפוש‪ ,‬אחרת‪ ,‬נבדוק‬
‫איפה עלינו להמשי את החיפוש‪ :‬אחרי הש המבוקש )כלומר‪ ,‬בחציה השני של הרשימה( או לפניו‬
‫)בחציה הראשו של הרשימה(‪ .‬א הש המבוקש מופיע בסדר הא"ב אחרי הש האמצעי נמשי את‬
‫תהלי החיפוש רק בחצי השני )כיוו שהרשימה ממוינת‪ ,‬לא ייתכ שיהיה בחצי הראשו(‪ ,‬וא הש‬
‫המבוקש מופיע בסדר הא"ב לפני הש האמצעי נמשי את התהלי רק בחצי הראשו‪ .‬תהלי החיפוש‬
‫ימשי בדיוק באותו אופ‪ :‬בדיקת הש האמצעי והשוואתו לש המבוקש‪ ,‬ובהתא לתוצאת‬
‫ההשוואה המש חיפוש במחצית התחו המתאימה‪ ,‬וכ הלאה עד מציאת הש או עד שהסתיי‬
‫התהלי )והש לא נמצא(‪ .‬חיפוש זה נקרא חיפוש בינארי‪ ,‬כיוו שהוא מבוסס על הקטנת תחו‬
‫החיפוש לחצי מגודלו אחרי כל השוואה של הש המבוקש לש נבחר )האמצעי בתחו החיפוש(‪.‬‬
‫נדגי זאת‪:‬‬
‫לפנינו רשימה ממוינת של מספרי‪:‬‬
‫‪1, 3, 5, 6, 7, 9, 12, 13, 15, 19, 20, 24, 25, 27, 31, 35, 36‬‬
‫וברצוננו לחפש בתוכה את המספר ‪.27‬‬
‫בשיטת החיפוש הסדרתי‪ ,‬דרושות לנו ‪ 14‬פעולות השוואה עד שנמצא את המספר המבוקש )כי ‪27‬‬
‫נמצא במקו ה(‪ 14‬ברשימה(‪.‬‬
‫נבדוק מה קורה בשיטת החיפוש הבינארי‪:‬‬
‫♦ נתבונ במספר האמצעי ברשימה‪ .15 ,‬כיוו שהמספר המבוקש גדול ממנו‪ ,‬נמשי את החיפוש‬
‫מימינו‪.‬‬
‫♦ כעת אנו מתמקדי ברשימת המספרי‪.19, 20, 24, 25, 27, 31, 35, 36 :‬‬
‫‪-370-‬‬
‫♦ נתבונ במספר האמצעי ברשימה זו‪) 25 ,‬למעשה‪ ,‬אור הרשימה זוגי ולכ שני מספרי נמצאי‬
‫באמצע הרשימה; בחרנו שרירותית את הקט מביניה(‪ .‬כיוו שהמספר המבוקש גדול ממנו‪,‬‬
‫נמשי את החיפוש מימינו‪.‬‬
‫♦ כעת אנו מתמקדי ברשימת המספרי‪.27, 31, 35, 36 :‬‬
‫♦ נתבונ במספר האמצעי ברשימה זו‪) 31 ,‬ג הפע‪ ,‬זהו למעשה המספר הקט מבי שני המספרי‬
‫שבאמצע הרשימה(‪ .‬כיוו שהמספר המבוקש קט ממנו‪ ,‬נמשי את החיפוש משמאלו‪.‬‬
‫♦ כעת אנו מתמקדי ברשימת המספרי‪ .27 :‬זו רשימה בת מספר אחד‪ ,‬השווה בדיוק למספר‬
‫המבוקש‪ ,‬ולכ סיימנו את תהלי החיפוש‪.‬‬
‫בס הכל ביצענו ארבע השוואות )ע המספרי ‪ 31 ,25 ,15‬ו(‪.(27‬‬
‫בהשוואה לחיפוש הסדרתי ההבדל הוא משמעותי!‬
‫כאשר רשימת השמות ארוכה‪ ,‬יש חשיבות רבה לבחירת הדר שתאפשר את ביצוע משימת החיפוש‬
‫בזמ קצר עד כמה שנית‪ .‬זמ החיפוש נקבע בעיקר על פי מספר ההשוואות )של הש המבוקש לש‬
‫נבחר( המתבצעות במהל החיפוש‪ .‬לכ נעדי לבחור בדר אשר בה יתבצעו פחות השוואות‪ .‬עבור‬
‫רשימה ע ‪ 1000‬שמות‪ ,‬מספר ההשוואות בחיפוש הסדרתי עלול להיות קרוב ל(‪ ,1000‬כיוו שייתכ‬
‫שהש המבוקש נמצא בקצה הרשימה‪ .‬לעומת זאת‪ ,‬בחיפוש בינארי באותה רשימה מספר ההשוואות‬
‫לא יעלה‪ ,‬בכל מקרה‪ ,‬על ‪ 10‬השוואות‪ .‬לכ‪ ,‬עבור בעיית החיפוש הנתונה‪ ,‬חיפוש בינארי יעיל הרבה‬
‫יותר‪ .‬בפרקי הבאי נכיר חיפוש בינארי ביתר פירוט‪.‬‬
‫ישנ אנשי הסוברי שמחשבי הינ כה מהירי עד שאי משמעות למושג "זמ ביצוע של‬
‫אלגורית )או תוכנית(" ולהשוואה בי זמני הביצוע של אלגוריתמי שוני‪ .‬לדעה זו אי כל בסיס‪.‬‬
‫קיימות בעיות אשר עבור זמ הריצה של תוכנית יכול להיות דקות רבות‪ ,‬שעות וא ימי )למשל‪,‬‬
‫תוכניות לחיזוי מזג אויר(‪ .‬עבור בעיית החיפוש שהצגנו‪ ,‬זמ הריצה של תוכנית המבצעת חיפוש סדרתי‬
‫ברשימה בת ‪ 10,000,000‬שמות עלול להיות מספר דקות‪ .‬לעומת זאת‪ ,‬זמ הריצה של תוכנית‬
‫המבצעת חיפוש בינארי באותה רשימה ובאותו המחשב לא יעלה על מספר שניות‪.‬‬
‫כזכור‪ ,‬זמ הביצוע של אלגורית נמדד על פי מספר ההוראות שיתבצעו במהל ביצוע האלגורית‪.‬‬
‫מספר זה תלוי )בדר כלל( בקלט של האלגורית‪.‬‬
‫למשל‪ ,‬בבעיית החיפוש‪ ,‬הקלט לאלגורית הוא רשימת השמות הממוינת והש שיש לחפש‪ .‬מספר‬
‫ההוראות שיתבצעו תלוי באור רשימת השמות‪ :‬ככל שהרשימה תהיה ארוכה יותר ייתכנו יותר‬
‫השוואות‪ ,‬כלומר‪ ,‬יתבצעו יותר פעולות השוואה‪.‬‬
‫בפתרו הבעיה הבאה נראה דוגמה לאלגורית אשר זמ הביצוע שלו תלוי בערכו של הקלט‪.‬‬
‫‪-371-‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת שלושה אלגוריתמי שוני לפתרו בעיה‪ ,‬הנבדלי זה מזה במידת‬
‫יעילות )מבחינת זמ ביצוע(‪ .‬באלגוריתמי היעילי יותר נעשה ניצול טוב של מאפייני קלט(פלט‪.‬‬
‫פתחו אלגורית אשר הקלט שלו הוא מספר של גדול מ(‪ ,1‬והפלט שלו הוא המחלקי של המספר‬
‫הנתו‪ .‬המחלקי של מספר של חיובי ה כל המספרי השלמי החיוביי המחלקי את המספר‬
‫ללא שארית‪ .‬לכ למשל‪ ,‬עבור הקלט ‪ 6‬הפלט הדרוש הוא‪.1 2 3 6 :‬‬
‫ישמו את האלגורית בשפת ‪ .Java‬תארו את זמ ביצוע האלגורית על ידי הערכת מספר ההוראות‬
‫שיתבצעו במהל ביצוע האלגורית‪.‬‬
‫בדיקת דוגמאות קלט‬
‫שאלה ‪8.1‬‬
‫ציינו מהו הפלט המתאי עבור כל אחד מהקלטי הבאי‪:‬‬
‫א‪12 .‬‬
‫ב‪29 .‬‬
‫ג‪30 .‬‬
‫תחו המספרי השלמי אליו שייכי המחלקי שיש להציג הוא התחו שבי ‪ 1‬לבי המספר הנתו‬
‫כקלט‪ .‬כלומר‪ ,‬כל מחלק הוא שווה ל(‪ 1‬או גדול מ(‪ ,1‬והוא קט מהמספר הנתו או שווה לו‪ .‬יש להציג‬
‫כל מספר בתחו אשר מחלק את המספר הנתו ללא שארית‪.‬‬
‫?‬
‫כיצד נית לחשב את המספרי הדרושי לפלט?‬
‫הנה רעיו ראשו‪ :‬נסרוק את תחו המספרי בי ‪ 1‬לבי המספר הנתו‪ ,‬ונבדוק עבור כל מספר‬
‫בתחו הא הוא מחלק את המספר הנתו ללא שארית‪.‬‬
‫ננסח זאת ניסוח ראשוני‪:‬‬
‫סריקת כל המספרים החיוביים בין ‪ 1‬ועד למספר הנתון כקלט‪ ,‬ובדיקה עבור כל מספר האם הוא‬
‫מחלק את המספר הנתון‪ .‬אם כן‪ ,‬הצגתו כפלט‪.‬‬
‫‪-372-‬‬
‫?‬
‫הרעיו המתואר מציג תת(משימה לביצוע חוזר‪ .‬מהי תת(משימה זו?‬
‫הרעיו המתואר כולל ביצוע חוזר של התת(משימה הבאה‪ ,‬עבור כל מספר בתחו שבי ‪ 1‬למספר‬
‫הנתו‪:‬‬
‫אם המספר מחלק את המספר הנתון‪ ,‬הצגתו כפלט‪.‬‬
‫ננסח אלגורית לביטוי הרעיו המתואר‪.‬‬
‫משתני האלגורית ה‪:‬‬
‫‪ – num‬מטיפוס של‪ ,‬לשמירת את נתו הקלט‪.‬‬
‫‪ – i‬מטיפוס של‪ ,‬משתנה בקרה של ההוראה לביצוע חוזר‪.‬‬
‫‪num-á éáåéç íìù øôñî èåì÷ .1‬‬
‫‪.2‬‬
‫‪íà .2.1‬‬
‫‪:òöá åì äååù åà num-î ïè÷ä i éáåéç íìù øôñî‬‬
‫‪úéøàù àìì num úà ÷ìçî i‬‬
‫‪.2.1.1‬‬
‫‪i ìù åëøò úà èìôë âöä‬‬
‫שימו ♥‪ :‬מתאי להשתמש כא בהוראה לביצוע חוזר‪ ,‬שמספר הסיבובי בה מחושב מראש‬
‫)הממומשת בשפת ‪ Java‬על ידי לולאת ‪ .(for‬בהוראה אנו מפרטי את תחו הערכי הנסרק‬
‫באמצעות משתנה הבקרה של הלולאה )‪.(i‬‬
‫באלגורית נעשה שימוש במשתנה הבקרה בגו הלולאה‪ .‬גו הלולאה כולל בדיקה הא ערכו של‬
‫משתנה הבקרה‪ ,i ,‬הוא מחלק של ‪ .num‬כיוו שבמהל ביצוע הלולאה ערכי משתנה הבקרה משתני‬
‫מ(‪ 1‬עד ‪ ,num‬הרי בדיקת החלוקה מתבצעת עבור כל מספר של בתחו ‪ 1‬עד ‪.num‬‬
‫‪-373-‬‬
‫הנה התוכנית המיישמת את אלגורית ‪:1‬‬
‫*‪/‬‬
‫קלט‪ :‬מספר שלם חיובי‬
‫פלט‪ :‬כל המחלקים של המספר הנתון‬
‫‪*/‬‬
‫‪public class Divisors_1‬‬
‫{‬
‫{‬
‫המספר הנתון ‪//‬‬
‫משתנה הבקרה ‪//‬‬
‫;‪int i‬‬
‫;)"‪num = In.readInt("Insert a number Please‬‬
‫;) " ‪System.out.println( "The divisors of " + num + " are‬‬
‫)‪for(i = 1; i <= num ; i++‬‬
‫{‬
‫)‪if (num % i == 0‬‬
‫{‬
‫‪} // if‬‬
‫‪} // for‬‬
‫‪} // main‬‬
‫‪} // Divisors_1‬‬
‫ניגש עתה לחישוב זמ ביצוע האלגורית על ידי הערכת מספר ההוראות שיתבצעו במהל הביצוע‪.‬‬
‫כדי לבצע את ההערכה נתמקד במרכיב העיקרי באלגורית המשפיע על מספר ההוראות שיתבצעו‪.‬‬
‫?‬
‫מהו המרכיב העיקרי באלגורית המעיד על מספר ההוראות שיתבצעו?‬
‫באלגורית אשר אינו כולל הוראה לביצוע חוזר )לולאה( אי בעצ מרכיב בולט‪ .‬מספר ההוראות‬
‫שיתבצעו במהל ביצוע האלגורית הוא לכל היותר כמספר ההוראות באלגורית‪ .‬לעומת זאת‪,‬‬
‫באלגורית הכולל לולאה‪ ,‬הוראה זו היא המרכיב העיקרי המעיד על מספר ההוראות שיתבצעו‪ .‬זאת‬
‫כיוו שייתכ שהלולאה תתבצע מספר רב של פעמי‪ ,‬ובכל ביצוע חוזר יתבצעו שוב כל ההוראות‬
‫שבגו הלולאה‪.‬‬
‫מכיוו שייתכ שהלולאה תתבצע מספר רב של פעמי‪ ,‬הרי מספר ההוראות שיתבצעו במהל ביצוע‬
‫האלגורית עשוי להיות גדול בהרבה ממספר ההוראות שכתובות באלגורית‪ .‬למשל במהל ביצוע‬
‫‪-374-‬‬
‫אלגורית ‪ 1‬עבור הקלט ‪ ,1000‬תתבצע ההוראה לביצוע בתנאי שבגו הלולאה ‪ 1000‬פעמי‪ .‬מספר‬
‫זה גדול בהרבה ממספר ההוראות שבאלגורית‪.‬‬
‫בדר כלל הלולאה תתבצע מספר שונה של פעמי עבור קלטי שוני‪ .‬לכ‪ ,‬כדי לתאר בצורה כללית‬
‫את מספר הפעמי שלולאה תתבצע‪ ,‬יש לבטא מספר זה על פי הקלט‪.‬‬
‫?‬
‫מהו מספר הפעמי שתתבצע הלולאה באלגורית ‪ 1‬עבור קלט שערכו ‪? N‬‬
‫מספר הפעמי שהלולאה באלגורית ‪ 1‬יתבצע עבור קלט שערכו ‪ N‬הוא ‪ .N‬הלולאה תתבצע פע‬
‫אחת עבור כל אחד מהערכי ‪ N ,... ,3 ,2 ,1‬של משתנה הבקרה ‪. i‬‬
‫כיוו שלולאה היא המרכיב העיקרי באלגורית המעיד על מספר הפעולות שיתבצעו‪ ,‬נהוג להתייחס‬
‫למספר הפעמי שהלולאה תתבצע כמדד לחישוב זמ הביצוע‪ .‬לכ‪ ,‬נאמר שתוצאת חישוב זמ הביצוע‬
‫של אלגורית ‪ 1‬היא שלולאת האלגורית תתבצע ‪ N‬פעמי עבור קלט שערכו ‪.N‬‬
‫ננסה לראות א ביכולתנו לפתח אלגורית יעיל יותר מאלגורית ‪ 1‬מבחינת זמ הביצוע‪.‬‬
‫?‬
‫הא נית לפתח אלגורית שבו תהיה לולאה שתתבצע פחות מ(‪ N‬פעמי עבור קלט שערכו ‪? N‬‬
‫כ‪ .‬נית לפתח אלגורית ובו לולאה "יעילה" יותר‪ .‬נראה זאת כעת‪.‬‬
‫אחד המאפייני של חלוקה בי מספרי שלמי היא שהמחלקי של מספר של חיובי ‪ num‬אינ‬
‫גדולי מ(‪ ,num/2‬מלבד המספר ‪ num‬עצמו‪ .‬נית לראות זאת בדוגמאות הקלט שנבדקו בשאלה ‪.8.1‬‬
‫לכ‪ ,‬בעצ‪ ,‬נית להרי‪ %‬את משתנה הבקרה בלולאה שבאלגורית רק עד ל(‪ .num/2‬נבטא רעיו זה‬
‫באלגורית ‪ ,2‬שהוא אלגורית יעיל יותר לפתרו הבעיה‪.‬‬
‫‪.2‬‬
‫‪íà .2.1‬‬
‫‪:òöá åì äååù åà num/2-î ïè÷ä i éáåéç íìù øôñî‬‬
‫‪.2.1.1‬‬
‫‪num ìù åëøò úà èìôë âöä .3‬‬
‫אמנ‪ ,‬הוצאנו את הצגתו כפלט של ‪ num‬אל מחו‪ %‬ללולאה‪ ,‬א עיקר העבודה נעשית בלולאה‪.‬‬
‫באלגורית ‪ ,2‬תתבצע הלולאה רק ‪ N/2‬פעמי עבור קלט שערכו ‪ .N‬זהו שיפור משמעותי‪ ,‬במיוחד‬
‫עבור קלטי שערכ גדול )למשל ‪.(10,000‬‬
‫‪-375-‬‬
‫התוכנית ליישו אלגורית ‪ 2‬תהיה‪:‬‬
‫*‪/‬‬
‫קלט‪ :‬מספר שלם חיובי‬
‫פלט‪ :‬כל המחלקים של המספר הנתון‬
‫‪*/‬‬
‫‪Divisors_2‬‬
‫‪public class‬‬
‫{‬
‫{‬
‫המספר הנתון ‪//‬‬
‫משתנה הבקרה ‪//‬‬
‫;‪int i‬‬
‫;)"‪num = In.readInt("Insert a number Please‬‬
‫;) " ‪System.out.println( "The divisors of " + num + " are‬‬
‫)‪for(i = 1; i <= num / 2 ; i++‬‬
‫{‬
‫)‪if (num % i == 0‬‬
‫{‬
‫‪} // if‬‬
‫‪} // for‬‬
‫‪} // main‬‬
‫‪} // Divisors_2‬‬
‫שיפרנו את הפתרו הראשו‪ .‬הא נוכל להמשי ולשפר ג את הפתרו השני?‬
‫?‬
‫הא נית לפתח אלגורית שבו תהיה לולאה שתתבצע פחות מ(‪ N/2‬פעמי עבור קלט שערכו ‪? N‬‬
‫כ‪ .‬נית לפתח אלגורית ובו לולאה "יעילה" יותר‪.‬‬
‫לכל מספר של ‪ k‬שהוא מחלק של ‪ ,num‬יש "ב(זוג" של ‪ ,num/k‬שג מחלק את ‪) .num‬שהרי‬
‫‪ .(num = k⋅num/k‬א באלגורית‪ ,‬עבור כל מחלק ‪ k‬שנמצא‪ ,‬נציג כפלט ג את ‪ ,num/k‬לא נצטר‬
‫לעבור על כל המחלקי של ‪ ,num‬אלא רק עד מחצית )שהרי הצגנו כבר את "בני(הזוג"(‪.‬‬
‫?‬
‫היכ נמצא קו המחצית של המחלקי? כלומר‪ ,‬מתי עלינו להפסיק את החיפוש כדי לא להציג‬
‫מחלקי כפולי?‬
‫‪-376-‬‬
‫התשובה היא ‪ . num‬זה נובע מהאבחנה הבאה‪ :‬עבור כל זוג מחלקי ‪ k‬ו(‪ ,num/k‬לפחות אחד מה‬
‫אינו גדול מ( ‪ . num‬מדוע? משו שא שניה גדולי מ( ‪ , num‬אז מכפלת גדולה מ(‪ .!num‬א‬
‫כ ‪ ,‬עבור כל מספר ‪ ,num‬א נסרוק את כל המספרי מ(‪ 1‬עד ‪ , num‬ונציג כפלט עבור כל מחלק ג‬
‫את "ב(זוגו" המחלק‪ ,‬למעשה נציג את כל המחלקי של ‪.num‬‬
‫?‬
‫מהו ב זוגו של ‪? num‬‬
‫זהו ‪ , num‬משו שמכפלתו של ‪ num‬בעצמו שווה ל(‪.num‬‬
‫לכ‪ ,‬משו שב(זוגו של ‪num‬‬
‫הוא ‪num‬‬
‫עצמו‪ ,‬עלינו לשי לב לא להציג את ‪ num‬פעמיי‬
‫כפלט‪.‬‬
‫לדוגמה‪ :‬א ‪ num = 100‬אז ‪ . num = 10‬כל מחלקיו של ‪ 100‬הקטני מ(‪ 10‬ה‪ ,4 ,2 :‬ו(‪" .5‬בני‬
‫זוג" ה‪ 25 ,50 :‬ו(‪ ,20‬בהתאמה‪ .‬א נוסי לה את ‪num = 10‬‬
‫נקבל את הרשימה המלאה של‬
‫כל המחלקי של ‪.100‬‬
‫לכ‪ ,‬בעצ‪ ,‬נית להרי‪ %‬את משתנה הבקרה בלולאה שבאלגורית עד ל( ‪num‬‬
‫בלבד‪ .‬נבטא רעיו זה‬
‫באלגורית ‪ ,3‬שהוא אלגורית יעיל יותר משני האלגוריתמי האחרי‪.‬‬
‫‪.2‬‬
‫‪íà .2.1‬‬
‫‪.3‬‬
‫‪íà‬‬
‫‪num‬‬
‫‪num -î ïè÷ä i éáåéç íìù øôñî‬‬
‫‪:òöá‬‬
‫‪.2.1.1‬‬
‫‪.2.1.2‬‬
‫‪num/i ìù åëøò úà èìôë âöä‬‬
‫‪úéøàù àìì num úà ÷ìçî‬‬
‫‪num ìù åëøò úà èìôë âöä .3.1‬‬
‫כאמור‪ ,‬הוצאנו מחו‪ %‬ללולאה את הבדיקה של ‪ , num‬כדי שלא נציג את ערכו פעמיי כפלט במקרה‬
‫שהוא מחלק את ‪ .num‬לעומת זאת‪ ,‬אי צור לטפל מחו‪ %‬בלולאה ב(‪ num‬עצמו‪ ,‬כמו באלגורית‬
‫הקוד‪ ,‬משו שהוא ב הזוג של ‪ ,1‬ולכ יוצג כפלט בסיבוב הראשו בלולאה‪.‬‬
‫‪-377-‬‬
‫כעת ביצענו שיפור משמעותי יותר מאלגורית ‪ .2‬עבור קלטי גדולי מאד המספר ‪N‬‬
‫קט‬
‫משמעותית מהמספר ‪ .N/2‬למשל‪ ,‬א ‪ N‬הוא ‪ ,10,000‬באלגורית ‪ 2‬יהיו ‪ 5000‬סיבובי בלולאה‪,‬‬
‫בעוד שבאלגורית ‪ 3‬יהיו ‪ 100‬סיבובי בלבד!‬
‫נסו לייש בעצמכ את האלגורית בשפת ‪.Java‬‬
‫‪1‬‬
‫נסכ את הנלמד מפתרו בעיה ‪:1‬‬
‫♦ באלגורית שאינו כולל לולאה מספר הפעולות שיתבצעו הוא לכל היותר כמספר ההוראות‬
‫באלגורית‪.‬‬
‫♦ באלגורית שכולל לולאה‪ ,‬מספר ההוראות שיתבצעו עשוי להיות גדול בהרבה ממספר הוראות‬
‫האלגורית‪ .‬מספר ההוראות שיתבצעו תלוי במספר הפעמי שהלולאה תתבצע‪ .‬לכ‪ ,‬מספר‬
‫הפעמי שהלולאה תתבצע משמש כמדד לזמ ביצוע האלגורית‪.‬‬
‫♦ מספר הפעמי שהלולאה תתבצע תלוי )בדר כלל( בערכו של הקלט‪ ,‬ומבוטא על פי ערכו‪.‬‬
‫בפתרו בעיה ‪ 1‬פיתחנו תחילה אלגורית אחד‪ ,‬ואחר כ פיתחנו אלגורית שני‪ ,‬אשר היה יעיל יותר‬
‫מבחינת מספר הפעמי של ביצוע הלולאה‪ ,‬כלומר‪ ,‬מבחינת זמ הביצוע‪ ,‬ולבסו מצאנו אלגורית‬
‫יעיל יותר ג ממנו‪ .‬בפיתוח האלגורית השני ניצלנו את המאפיי שאיברי הפלט‪ ,‬הלא ה כל‬
‫המחלקי של נתו הקלט ‪ ,N‬אינ גדולי מ(‪ ,N/2‬מלבד ‪ N‬עצמו‪ .‬בפיתוח האלגורית השלישי‪,‬‬
‫היעיל מבי השלושה‪ ,‬ניצלנו את המאפיי שאיברי הפלט‪ ,‬פרט ל(‪ N‬עצמו‪ ,‬ניתני לחלוקה לזוגות כ‬
‫שמכפלת איברי כל זוג שווה ל(‪ N‬ובכל זוג איבר אחד קט מ( ‪ . N‬המאפיי האחרו איפשר לנו‬
‫לכתוב לולאה אשר תתבצע ‪N‬‬
‫פעמי בלבד‪ ,‬במקו הלולאה המקורית שמתבצעת ‪ N‬פעמי‪.‬‬
‫♦ פיתוח אלגורית יעיל יותר נעשה תו ניתוח וניצול טוב של מאפייני קלט(פלט‪ .‬שימוש טוב‬
‫במאפייני קלט(פלט חשוב לפיתוח לולאה אשר תתבצע מספר מועט ככל האפשר של פעמי‪.‬‬
‫כלומר‪ ,‬השקעת מאמ‪ %‬בניתוח מעמיק של הבעיה יכולה להתבטא אחר כ באלגורית שהוא‬
‫משמעותית יעיל יותר‪.‬‬
‫♦ במהל פתרו בעיה אלגוריתמית נשתדל לפתח אלגורית יעיל ככל האפשר מבחינת זמ הביצוע‪.‬‬
‫כלומר‪ ,‬אלגורית שהלולאות שבו יתבצעו מספר פעמי מועט )לולאות "יעילות"( עד כמה שנית‪.‬‬
‫‪-378-‬‬
‫שאלה ‪8.2‬‬
‫ציינו עבור כל אחד מהקלטי הבאי את מספר הפעמי שתתבצע הלולאה‪ ,‬בכל אחד משלושת‬
‫האלגוריתמי שפיתחנו‪:‬‬
‫א‪1000 .‬‬
‫ב‪2000 .‬‬
‫שאלה ‪8.3‬‬
‫בקטע התוכנית הבא מחושבת המכפלה של שני נתוני קלט חיוביי שלמי‪ ,‬תו שימוש בפעולת חיבור‬
‫בלבד‪:‬‬
‫;)"‪x = In.readInt("Insert an integer number‬‬
‫;)"‪y = In.readInt("Insert another one‬‬
‫;‪sum = 0‬‬
‫)‪for(i = 1; i <= x ; i++‬‬
‫{‬
‫;‪sum = sum + y‬‬
‫}‬
‫;)‪System.out.println( "The product is " + sum‬‬
‫ידוע שאחד מנתוני הקלט גדול באופ משמעותי מהשני‪ ,‬א לא ידוע א זה הנתו הראשו או השני‪.‬‬
‫השתמשו במאפיי זה של הקלט כדי לשנות את קטע התוכנית הנתו כ שיהיה יעיל ככל שנית‪.‬‬
‫הדרכה‪ :‬שימו לב שיש חשיבות לבחירת המשתנה אשר על פיו נקבע מספר הפעמי שתתבצע‬
‫הלולאה‪.‬‬
‫מהו מספר הפעמי שתתבצע הלולאה של קטע התוכנית הנתו‪ ,‬ומהו מספר הפעמי שתתבצע‬
‫הלולאה של קטע התוכנית החדש?‬
‫שאלה ‪8.4‬‬
‫פתחו אלגורית )מבלי ליישמו( יעיל ככל האפשר אשר הקלט שלו הוא שני מספרי שלמי גדולי מ(‬
‫‪ 1‬שאינ מחלקי זה את זה‪ ,‬והפלט שלו הוא כל המספרי השלמי החיוביי המחלקי את שני‬
‫מספרי הקלט‪ .‬תארו‪ ,‬על פי ערכו של הקלט‪ ,‬את מספר הפעמי שתתבצע לולאת האלגורית‪.‬‬
‫שאלה ‪) 8.5‬מתקדמת(‬
‫נניח שבבעיה ‪ 1‬הפלט הדרוש הוא כל המספרי השלמי החיובי שאינ מחלקי את נתו הקלט ‪.N‬‬
‫מה יהיה מספר הפעמי של ביצוע הלולאה באלגורית לפתרו הבעיה החדשה?‬
‫‪-379-‬‬
‫שאלה ‪8.6‬‬
‫יש לפתח אלגורית אשר הקלט שלו הוא מספר של חיובי ‪ ,N‬והפלט שלו הוא כל המספרי‬
‫)השלמי החיוביי( אשר קטני מ(‪ ,N‬והשורש שלה הוא מספר של‪.‬‬
‫למשל‪ ,‬עבור הקלט ‪ 50‬הפלט יהיה ‪.1 4 9 16 25 36 49‬‬
‫האלגורית הבא‪ ,‬הכולל משתני מטיפוס של הוא פתרו אפשרי‪:‬‬
‫‪.2‬‬
‫‪íà .2.1‬‬
‫‪:òöá num-î ïè÷ù i éáåéç íìù øôñî‬‬
‫‪íìù øôñî àåä i ìù ùøåùä‬‬
‫‪.2.1.1‬‬
‫א‪ .‬מהו מספר הפעמי שתתבצע הלולאה של האלגורית הנתו?‬
‫ב‪ .‬ישמו על ידי ביטוי בוליאני בשפת ‪ Java‬את התנאי "השורש של ‪ i‬הוא מספר של"‬
‫ג‪ .‬נית לכתוב אלגורית אשר זמ הביצוע שלו יהיה קצר בהרבה מהאלגורית הנתו‪ ,‬וזאת על ידי‬
‫"ייצור" מספרי הפלט‪ ,‬באמצעות העלאה בריבוע של כל המספרי השלמי אשר ריבוע קט מ‬
‫הקלט‪.‬‬
‫האלגורית החלקי הבא מבוסס על הרעיו המתואר‪:‬‬
‫‪ìë øåáò .1.1‬‬
‫‪.1.1.1‬‬
‫‪:òöá ___________-î ïè÷ä i éáåéç íìù øôñî‬‬
‫‪i2 ìù åëøò úà èìôë âöä‬‬
‫השלימו את האלגורית‪ ,‬ותארו את מספר הפעמי שתתבצע הלולאה של אלגורית זה‪.‬‬
‫כל האלגוריתמי שניתחנו עד עתה בפרק כללו לולאה שמספר הביצועי שלה מחושב מראש ובה‬
‫הור‪ %‬משתנה הבקרה מ(‪ 1‬עד ער כלשהו בקפיצות של ‪ .1‬לכ קל היה לחשב את מספר הפעמי של‬
‫ביצוע הלולאה‪.‬‬
‫בלולאות מורכבות יותר‪ ,‬בה ערכו ההתחלתי של משתנה הבקרה אינו ‪ ,1‬והשינוי בערכו בי סיבוב‬
‫לסיבוב הוא לאו דווקא ‪ ,1‬חישוב מספר הסיבובי עלול להיות מסוב יותר‪ .‬בלולאת ‪ ,while‬שבה אי‬
‫משתנה בקרה‪ ,‬חישוב זמ הביצוע יכול להיות א מורכב יותר‪ .‬יש לספור את מספר הפעמי של ביצוע‬
‫הלולאה תו מעקב אחר שינוי ערכי משתני‪ ,‬המעודכני בגו הלולאה ומופיעי בתנאי הכניסה‬
‫ללולאה‪.‬‬
‫‪-380-‬‬
‫שאלה ‪8.7‬‬
‫יש לפתח ולייש אלגורית אשר הקלט שלו הוא שני מספרי שלמי חיוביי‪ ,‬כ שהמספר השני‬
‫גדול מהראשו‪ .‬הפלט הדרוש הוא הכפולות של המספר הראשו אשר קטנות מהמספר השני או שוות‬
‫לו‪ .‬למשל‪ ,‬עבור הקלט ‪ ,200 1000‬יהיה הפלט ‪.200 400 600 800 1000‬‬
‫משפטי התוכנית הבאי ה יישו של אלגורית לפתרו הבעיה‪:‬‬
‫;)"‪x = In.readInt("Insert an integer number‬‬
‫;)"‪y = In.readInt("Insert another one‬‬
‫;‪i = x‬‬
‫)‪for (i = x; i <= y; i++‬‬
‫{‬
‫)‪if (i % x == 0‬‬
‫{‬
‫‪} // if‬‬
‫‪} // for‬‬
‫א‪ .‬כמה פעמי תתבצע הלולאה עבור הקלט ‪?200 1000‬‬
‫ב‪ .‬תארו בצורה כללית את מספר הפעמי שתתבצע הלולאה‪ ,‬על פי ערכי נתוני הקלט ‪ x‬ו(‪.y‬‬
‫ג‪ .‬בפתרו המוצג ‪ i‬גדל בקפיצות של ‪ .1‬נית לשפר את יעילות הפתרו הנתו‪ ,‬תו שינוי הקפיצות‬
‫של ‪ i‬לקפיצות גדולות מ(‪ ,1‬קפיצות אשר מתאימות למרחק בי זוג מספרי פלט עוקבי )שימו לב‬
‫שהמרחק בי כל זוג מספרי פלט עוקבי הוא אחיד(‪ .‬כתבו פתרו יעיל יותר המבוסס על הרעיו‬
‫המתואר‪ ,‬ותארו את מספר הפעמי שתתבצע לולאת הפתרו החדש‪.‬‬
‫שאלה ‪8.8‬‬
‫נתונה לולאת ‪ for‬הבאה‪:‬‬
‫)‪for (i = 1 ; i <= 30000 ; i++‬‬
‫{‬
‫)‪if (i % 500 == 0‬‬
‫{‬
‫‪} // if‬‬
‫‪} // for‬‬
‫א‪ .‬מהו מספר הפעמי שתתבצע הלולאה?‬
‫ב‪ .‬מהי מטרת הלולאה?‬
‫ג‪ .‬כתבו לולאה יעילה הרבה יותר להשגת אותה המטרה‪ .‬מהו מספר הפעמי שתתבצע הלולאה‬
‫היעילה שכתבת? פי כמה מספר זה קט מתשובתכ בסעי א'?‬
‫‪-381-‬‬
‫סיכום‬
‫בפרקי הקודמי בחנו אלגוריתמי על פי קנה המידה נכונות‪ .‬בפרק זה הכרנו קנה מידה חדש –‬
‫יעילות‪.‬‬
‫יעילות של אלגורית נמדדת על פי "משאבי המחשב" הדרושי לביצוע האלגורית‪ .‬משאבי אלה‬
‫ה גודל המקו בזיכרו והזמ הדרוש לביצוע‪.‬‬
‫גודל המקו‪ ,‬נמדד בעיקר על פי מספר המשתני של האלגורית‪.‬‬
‫זמ הביצוע נקבע לפי מספר פעולות היסוד שיתבצעו במהל ביצוע האלגורית‪.‬‬
‫פעולות היסוד ה‪ :‬פעולות קלט‪ ,‬פעולות פלט ופעולות חישוב‪ .‬בצורה פשטנית נית לומר‪ ,‬שכל הוראה‬
‫באלגורית כוללת פעולת יסוד אחת‪ ,‬ומכא – מדידת זמ הביצוע של אלגורית נעשית על פי מספר‬
‫ההוראות שיתבצעו במהל ביצוע האלגורית )בזמ הריצה(‪.‬‬
‫באלגורית אשר אינו כולל לולאה מספר ההוראות שיתבצעו במהל הביצוע הוא לכל היותר כמספר‬
‫ההוראות באלגורית‪.‬‬
‫לעומת זאת‪ ,‬באלגורית הכולל לולאה‪ ,‬מספר ההוראות שיתבצעו במהל הביצוע אינו נקבע על פי‬
‫מספר ההוראות באלגורית‪ ,‬אלא על פי מספר הפעמי שהלולאה תתבצע‪ .‬מספר זה יכול להיות תלוי‬
‫בקלט של האלגורית ולכ הוא מבוטא על פי הקלט‪.‬‬
‫כאשר נתוני שני אלגוריתמי שוני לפתרו בעיה‪ ,‬משווי את יעילות מבחינת זמ הביצוע על פי‬
‫מספר פעמי שהלולאות שבה יתבצעו במהל ביצוע כל אלגורית‪.‬‬
‫בפיתוח אלגורית נשתדל לבחור לולאות שיתבצעו מספר פעמי מועט עד כמה שנית‪ ,‬כלומר לולאות‬
‫"יעילות" ככל האפשר‪ .‬בחירת לולאה יעילה נעשית תו ניתוח וניצול טוב של מאפייני הקשר בי‬
‫הקלט לפלט‪.‬‬
‫‪-382-‬‬
‫פרק ‪ – 9‬המחלקה מחרוזת )‪ (String‬ומבוא‬
‫לעצמי‬
‫בתוכניות שכתבנו עד כה השתמשנו בטיפוסי שוני המוגדרי בשפת ‪ :Java‬של‪ ,‬ממשי‪ ,‬תווי‬
‫ובוליאני‪ .‬יכולנו להגדיר משתני מטיפוסי אלו‪ ,‬ולבצע עליה פעולות שונות )קלט‪ ,‬פלט‪ ,‬חישובי‬
‫וכו'(‪ .‬ע זאת‪ ,‬מרבית התוכניות שכתבנו התייחסו ג למחרוזות‪ ,‬סדרות של תווי‪ .‬עד עתה השתמשנו‬
‫במחרוזות כאשר רצינו להדפיס הודעות למשתמש ותחמנו אות במירכאות‪ ,‬למשל‪ ,‬בהוראה‪:‬‬
‫;)"‪System.out.println("Please insert two numbers‬‬
‫ההודעה "‪ "Please insert two numbers‬היא מחרוזת‪.‬‬
‫הנה דוגמאות נוספות למחרוזות בשפת ‪:Java‬‬
‫"?‪"" ,"J" ,"453" ,"Hello, How Are You‬‬
‫)האחרונה היא מחרוזת ריקה‪ ,‬שאינה מכילה א תו(‪.‬‬
‫לעיתי נוח להתייחס למחרוזות במפורש ולבצע עליה פעולות נוספות‪ ,‬פרט להדפסה‪ .‬בפרק זה נראה‬
‫כיצד נית לקלוט מחרוזות מהמשתמש‪ ,‬לשמור אות‪ ,‬ולבצע עיבודי על מחרוזות‪ .‬א עד עתה יכולנו‬
‫לקלוט מספרי או תווי בודדי בלבד‪ ,‬עכשיו נוכל לבקש מהמשתמש להקיש את שמו‪ ,‬כתובתו‬
‫וכדומה‪ ,‬ולבצע פעולות שונות על המחרוזות הנקלטות‪ .‬דר! ההיכרות ע מחרוזות נערו! ג היכרות‬
‫ראשונית ע מחלקות ועצמי‪.‬‬
‫‪ 9.1‬היכרות ראשונית עם המחלקה ‪String‬‬
‫בשפת ‪ Java‬לא מוגדר טיפוס פשוט עבור מחרוזות‪ ,‬בדומה לטיפוסי אחרי שראינו‪ .‬אבל‪ ,‬בשפת‬
‫‪ Java‬מוגדרת המחלקה ‪ ,String‬ובה נוכל להיעזר כאשר נרצה להשתמש במחרוזות‪.‬‬
‫למעשה‪ ,‬נית להתייחס אל מחלקה כאל טיפוס חדש בשפה‪ ,‬המאפשר הצהרה ושימוש במשתני‬
‫מטיפוס זה‪ .‬למשל‪ ,‬א ‪ String‬היא מחלקה בשפה‪ ,‬אפשר לכתוב‪:‬‬
‫;‪String s1, s2‬‬
‫בדומה להצהרה על משתני מטיפוס רגיל )למשל‪ ,‬של או תווי(‪.‬‬
‫נהוג לקרוא למשתני של טיפוסי חדשי כאלה מופעי של המחלקה ‪ String‬או עצמי של‬
‫המחלקה ‪ .String‬כפי שנראה מיד‪ ,‬השימוש בעצמי שונה מעט משימוש במשתני רגילי‪ .‬בפרק זה‬
‫נכיר‪ ,‬בעזרת המחלקה ‪ ,String‬מושגי בסיסיי הקשורי לשימוש במחלקות ובעצמי‪ .‬ביחידת‬
‫ההמש! )"יסודות מדעי המחשב ‪ ("2‬תלמדו כיצד להגדיר בעצמכ מחלקות חדשות‪.‬‬
‫‪-383-‬‬
‫אמנ‪ ,‬הצהרה על עצמי דומה להצהרה על משתני מטיפוסי רגילי‪ .‬אבל‪ ,‬שלא כמו עבור‬
‫משתני מטיפוסי רגילי‪ ,‬בדר! כלל הצהרה על עצ חדש אינה מספיקה! עלינו להקצות מקו חדש‬
‫בזיכרו עבור עצ זה‪ .‬עבור משתני רגילי‪ ,‬הקצאת המקו בזיכרו נעשית אוטומטית ע ההצהרה‬
‫עליה‪ .‬אי זה כ! עבור עצמי‪ .‬בהמש! הפרק נראה כיצד מבוצעת הקצאת שטח עבור עצמי‪.‬‬
‫בשפת ‪ Java‬מחרוזת‬
‫היא עצ‪ ,‬כלומר‪ ,‬מופע של המחלקה )‪ (class‬מחרוזת‪ .‬נית להצהיר על‬
‫מחרוזות בדומה להצהרת משתני רגילי‪.‬‬
‫כדי שנית יהיה להשתמש בעצ מהמחלקה מחרוזת‪ ,‬יש להקצות עבורו שטח זיכרו‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת שימוש בסיסי במחלקה מחרוזת‪.‬‬
‫פתחו ויישמו אלגורית שיקבל כקלט את שמכ‪ ,‬וידפיס על המס! את המחרוזת ‪Your name is‬‬
‫ומיד אחריה את הש שנקלט‪.‬‬
‫?‬
‫באיזה טיפוס נשתמש כדי לשמור את הש שנקלט?‬
‫כיוו שעלינו לקלוט מילה‪ ,‬נשתמש במחלקה מחרוזת‪ .‬א כ!‪ ,‬רשימת המשתני תכלול את העצ‬
‫‪ name‬מהמחלקה מחרוזת‪.‬‬
‫האלגורית‪:‬‬
‫‪name-ì úæåøçî èåì÷ .1‬‬
‫‪"Your name is " èìôë âöä .2‬‬
‫‪name úà èìôë âöä .3‬‬
‫עד כה ראינו כיצד לקלוט ערכי של טיפוסי פשוטי – שלמי‪ ,‬ממשיי ותווי‪ .‬ביצוע קלט של‬
‫מחרוזת נעשה בצורה דומה‪ .‬את הוראה ‪ 1‬נוכל לממש על ידי המשפט‪:‬‬
‫;)(‪name = In.readString‬‬
‫בדומה להוראות קלט אחרות בה השתמשנו‪ ,‬א נרצה לצר הנחיה למשתמש לגבי מהות הקלט לו‬
‫מצפה התוכנית‪ ,‬נכתוב את ההודעה המתאימה בתו! הסוגריי‪.‬‬
‫‪-384-‬‬
‫שימו ♥‪ :‬כמו הוראות קלט של ערכי מטיפוסי פשוטי‪ ,‬ג הוראת קלט של מחרוזת היא למעשה‬
‫הוראת השמה‪ .‬בעת ביצוע ההוראה ;)(‪ name = In.readString‬נקראת מחרוזת מהקלט‪ ,‬ונוצר‬
‫עצ חדש מהמחלקה מחרוזת‪ ,‬שהוקצה עבורו מקו בזיכרו כחלק מפעולת הקלט‪ .‬עצ זה שומר את‬
‫מחרוזת הקלט‪ .‬הפעולה ‪ ,In.readString‬מחזירה הפניה לשטח הזיכרו החדש שהוקצה‪ .‬בעקבות‬
‫ההשמה מפנה ‪ name‬אל אותו שטח זיכרו‪ ,‬ודר! ‪ name‬נית להגיע אל אותו שטח ולבצע עליו פעולות‬
‫שונות‪ .‬בהמש! הפרק נעמיק בהשמה של מחרוזות‪.‬‬
‫משו שפעולת קליטת מחרוזת מבצעת הקצאת שטח בזיכרו עבור המחרוזת הנקלטת אי צור!‬
‫במקרה זה להקצות שטח זיכרו עבור מחרוזת זו ע הצהרתה‪.‬‬
‫*‪/‬‬
‫קלט‪ :‬שם‪ ,‬הנקלט כמחרוזת‬
‫פלט‪ :‬השם‪ ,‬מלווה בהודעה מקדימה‬
‫‪*/‬‬
‫‪public class YourName‬‬
‫{‬
‫{‬
‫הצהרה על עצם מהמחלקה מחרוזת ‪//‬‬
‫;‪String name‬‬
‫הוראת קלט ‪ +‬הקצאת מקום בזיכרון ‪//‬‬
‫;)"‪name = In.readString("Insert your name‬‬
‫פלט ‪//‬‬
‫;)‪System.out.println("your name is: " + name‬‬
‫‪} // main‬‬
‫‪} // class YourName‬‬
‫‪1‬‬
‫נית לבצע קלט של מחרוזת באמצעות הפעולה ‪.In.readString‬‬
‫נית להעביר לפעולת הקלט מחרוזת שתנחה את המשתמש לגבי הקלט שהוא מתבקש לתת‪.‬‬
‫פעולת הקלט מקצה שטח עבור המחרוזת החדשה‪.‬‬
‫‪-385-‬‬
‫‪ 9.2‬ביצוע פעולות על מחרוזות‬
‫כש שעל ערכי ומשתני של טיפוסי פשוטי‪ ,‬כגו ‪ char‬ו(‪ ,int‬אפשר לבצע פעולות שונות‬
‫)למשל‪ ,‬פעולות חשבוניות או פעולות השוואה(‪ ,‬נרצה לבצע פעולות שונות ג על מופעי של מחלקות‪,‬‬
‫הטיפוסי החדשי בשפה‪ .‬כאשר מוגדרת מחלקה בשפה‪ ,‬מוגדרות איתה ג פעולות שנית לבצע על‬
‫עצמי של המחלקה‪.‬‬
‫כדי לבצע פעולה של מחלקה על עצ מהמחלקה יש לכתוב ראשית את שמו‪ ,‬אחריו את הסימ נקודה‪,‬‬
‫ולאחר מכ את ש הפעולה לביצוע‪ .‬למשל‪ ,‬אחת מהפעולות המוגדרות עבור המחלקה מחרוזת היא‬
‫הפעולה ‪ ,length‬המחשבת את אורכה של מחרוזת מסוימת‪ .‬א ‪ s1‬הוא עצ של המחלקה מחרוזת‪,‬‬
‫אז הביטוי )(‪ s1.length‬מפעיל את הפעולה ‪ length‬על העצ ‪ s1‬ומחזיר את תוצאת ההפעלה‪,‬‬
‫כלומר את אורכה של המחרוזת ‪ .s1‬בכל הפעלה של פעולה של המחלקה מחרוזת נשתמש בסימו‬
‫הנקודה‪ ,‬כדי לציי את העצ שעליו היא מופעלת‪.‬‬
‫הסוגריי שאחרי ש הפעולה נועדו להעברת ערכי )פרמטרי( לה נזקקת הפעולה‪ .‬במקרה של‬
‫הפעולה ‪ length‬אי צור! בהעברת ער!‪ ,‬ולכ הסוגריי נותרי ריקי‪ .‬בהמש! הפרק נכיר פעולות‬
‫נוספות‪ ,‬אשר מצפות לקבל ערכי מסוימי לצור! הפעלת‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת השימוש בפעולות על מחרוזות‪ .‬הכרת הפעולות ‪ length‬ו( ‪.charAt‬‬
‫פתחו ויישמו אלגורית אשר יקבל כקלט מחרוזת‪ .‬א אור! המחרוזת הוא זוגי יוצג כפלט התו‬
‫הראשו במחרוזת‪ ,‬וא אור! המחרוזת הוא אי(זוגי יוצג התו האחרו במחרוזת‪.‬‬
‫למשל‪ ,‬עבור הקלט ‪ shalom‬יוצג התו‪ .'s' :‬ועבור הקלט ‪ dog‬יוצג התו‪.'g' :‬‬
‫שימו ♥‪ :‬בשפת ‪ Java‬מיקו התווי במחרוזת מתחיל מ(‪ .0‬כלומר‪ ,‬התו הראשו במחרוזת נמצא‬
‫במקו ‪ ,0‬התו השני במחרוזת הוא במקו ‪ ,1‬השלישי במקו ‪ ,2‬וכ הלאה‪.‬‬
‫?‬
‫א התו הראשו נמצא במקו ‪ ,0‬באיזה מקו נמצא התו האחרו?‬
‫נתבונ למשל במחרוזת "‪ "abcd‬שאורכה ‪ .4‬התו האחרו בה הוא '‪ 'd‬והוא נמצא במקו ‪.3‬‬
‫מיקו התווי‬
‫במחרוזת מתחיל מ(‪.0‬‬
‫בכל מחרוזת‪ ,‬א נסמ את אור! המחרוזת ב(‪ ,len‬אז התו האחרו במחרוזת נמצא במקו ‪.len −1‬‬
‫‪-386-‬‬
‫נשתמש במשתני הבאי‪:‬‬
‫‪ – str‬עצ מהמחלקה מחרוזת‬
‫‪ – letter‬האות המבוקשת‪ ,‬מטיפוס ‪char‬‬
‫‪ – len‬לשמירת אור! המחרוזת‪ ,‬מטיפוס של‬
‫‪str-ì úæåøçî èåì÷ .1‬‬
‫‪len-á str úæåøçîä ìù äëøåà úà íùä .2‬‬
‫‪.3‬‬
‫‪íà‬‬
‫‪éâåæ len‬‬
‫‪str-á 0 íå÷îá àöîðä åúä úà letter-á íùä 3.1‬‬
‫‪.4‬‬
‫‪str-á len−1 íå÷îá àöîðä åúä úà letter-á íùä 4.1‬‬
‫‪letter ìù åëøò úà èìôë âöä .5‬‬
‫?‬
‫כדי לבדוק את אורכה של המחרוזת נשתמש בפעולה ‪ ,length‬באיזו פעולה נשתמש כדי לדעת מהו‬
‫התו שנמצא במקו מסוי במחרוזת?‬
‫במחלקה מחרוזת מוגדרות פעולות נוספות ואחת מה היא הפעולה )‪ .charAt(k‬פעולה זו מקבלת‬
‫כפרמטר )בתו! הסוגריי( מספר של ‪ ,k‬ומחזירה את התו שנמצא במקו ה(‪ k‬במחרוזת עבורה‬
‫הופעלה‪ .‬לכ‪ ,‬למשל‪ ,‬כדי לדעת מהו התו שנמצא במקו ‪0‬‬
‫במחרוזת ‪ str‬נכתוב )‪.str.charAt(0‬‬
‫*‪/‬‬
‫קלט‪ :‬מחרוזת‬
‫פלט‪ :‬התו הראשון או האחרון במחרוזת‪ ,‬בהתאם לאורכה )זוגי או אי‪-‬זוגי(‬
‫‪*/‬‬
‫‪public class IsEven‬‬
‫{‬
‫{‬
‫;‪String str‬‬
‫;‪int len‬‬
‫;‪char letter‬‬
‫‪-387-‬‬
‫;)"‪str = In.readString("Insert a string please‬‬
‫;)(‪len = str.length‬‬
‫)‪if (len % 2 == 0‬‬
‫{‬
‫;)‪letter = str.charAt(0‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)‪letter = str.charAt(len - 1‬‬
‫}‬
‫;)‪System.out.println("The letter is " + letter‬‬
‫‪} // main‬‬
‫‪} // class IsEven‬‬
‫בסו הפרק תוכלו למצוא טבלה המפרטת את הפעולות השכיחות המוגדרות ב(‪ Java‬עבור עצמי‬
‫מהמחלקה ‪.String‬‬
‫העמודה הימנית בטבלה מתארת את ש הפעולה ואת רשימת הפרמטרי שהיא מצפה לקבל )בתו!‬
‫סוגריי(‪ .‬כפי שראינו זה עתה‪ ,‬הפעולה הראשונה בטבלה‪ ,length ,‬אינה מצפה לקבל ער! כלשהו‪,‬‬
‫ולכ הסוגריי ריקי‪ .‬לעומתה‪ ,‬הפעולה השנייה‪ ,charAt ,‬מצפה לקבל פרמטר אחד מטיפוס של‪,‬‬
‫והפעולה השלישית‪ indexOf ,‬מצפה לקבל עצ מהמחלקה מחרוזת‪ ,‬או תו‪.‬‬
‫העמודה השלישית מתארת את טיפוס הער! המוחזר כתוצאת הפעולה‪ .‬בדומה לפעולות המתמטיות‬
‫שלמדנו בפרק ‪ ,4‬ג כא יש לשי לב לטיפוס הער! המוחזר ולוודא התאמה בינו לבי הפעולות‬
‫המבוצעות עליו‪ .‬למשל‪ ,‬א נבצע השמה של ער! מוחזר מפעולה על מחרוזת לתו! משתנה‪ ,‬עלינו‬
‫לוודא התאמה בי טיפוס הער! המוחזר לטיפוס המשתנה אליו מתבצעת ההשמה‪.‬‬
‫חלק מהגדרת המחלקה מחרוזת כוללת הגדרה של פעולות הניתנות לביצוע‬
‫על מחרוזת‪.‬‬
‫הפעלת פעולה של המחלקה מחרוזת על עצ מהמחלקה מחרוזת נכתבת כ!‪:‬‬
‫)פרמטרי(ש הפעולה‪.‬ש העצ‬
‫יש לבדוק היטב בתיאור הפעולה אילו ערכי היא מצפה לקבל ומה טיפוס הער! שהיא מחזירה‪.‬‬
‫‪-388-‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת השימוש בפעולת השוואת מחרוזת של המחלקה ‪ ,String‬ושילוב‬
‫מחרוזות בתבנית מנייה‪.‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא רשימת מחרוזות שמסתיימת במחרוזת‬
‫"‪"STOP‬‬
‫)זקי (‪ ,‬והפלט הוא מספר המחרוזות ברשימה‪.‬‬
‫למשל‪ ,‬עבור הקלט‪ "abc", "dog", "shalom", "people", "STOP" :‬הפלט המתאי הוא ‪.4‬‬
‫למעשה‪ ,‬האלגורית צרי! לבצע מנייה‪ ,‬בדומה לאלגוריתמי אחרי שפיתחנו בפרקי אחרי‪ .‬לכ‪,‬‬
‫נית פשוט לכתוב את רשימת התת(משימות הבאה‪:‬‬
‫‪ .1‬מניית מספר המחרוזות שבקלט‬
‫‪ .2‬הצגה כפלט של מספר המחרוזות שנמנו‬
‫תת(משימה ‪ 1‬תבוצע בדומה למשימות מנייה אחרות‪ ,‬ההבדל הוא כמוב בטיפוס הערכי הנמני –‬
‫מחרוזת במקרה זה – ובאופ ביצוע הפעולות עליה‪ .‬בשלב יישו האלגורית נראה כיצד לעשות‬
‫זאת‪.‬‬
‫‪ – str‬המחרוזת התורנית מהקלט‪ ,‬עצ מהמחלקה מחרוזת‬
‫‪ – counter‬למניית מספר המחרוזות‪ ,‬מטיפוס של‬
‫‪0-ì counter úà ìçúà .1‬‬
‫‪.3‬‬
‫"‪:òöá str ≠"STOP‬‬
‫‪1-á counter ìù åëøò úà ìãâä .3.1‬‬
‫‪str-ì úæåøçî èåì÷ .3.2‬‬
‫‪counter ìù åëøò úà èìôë âöä .4‬‬
‫‪-389-‬‬
‫?‬
‫כיצד נבדוק הא המחרוזת הנקלטת שווה למחרוזת "‪?"STOP‬‬
‫הפעולה ‪ equals‬בודקת הא שתי מחרוזות שוות זו לזו‪ .‬נשתמש בה‪ ,‬כפי שמתואר בטבלה שבסו‬
‫הפרק‪.‬‬
‫*‪/‬‬
‫קלט‪ :‬רשימת מחרוזות המסתיימת בזקיף‬
‫פלט‪ :‬מספר המחרוזות ברשימה‬
‫‪*/‬‬
‫‪public class HowManyStrings‬‬
‫{‬
‫{‬
‫הגדרת משתנים ואתחולם ‪//‬‬
‫;‪int counter = 0‬‬
‫לולאת זקיף ‪//‬‬
‫כל עוד המחרוזת ‪ str‬שונה מ‪while (! str.equals("STOP")) //"STOP"-‬‬
‫{‬
‫;‪counter++‬‬
‫;)"‪str = In.readString("Insert another string please‬‬
‫‪} // while‬‬
‫;)" ‪System.out.println(counter + " Strings‬‬
‫‪} // main‬‬
‫‪} // class HowManyStrings‬‬
‫שימו ♥‪ :‬כפי שהסברנו קוד‪ ,‬הוראת הקלט של מחרוזת מקצה בכל פע מקו בזיכרו עבור‬
‫המחרוזת החדשה‪ .‬לכ למעשה‪ ,‬העצ ‪ str‬מפנה בכל פע אל מקו אחר בזיכרו‪ ,‬משו שבכל פע‬
‫ההשמה המתבצעת אליו מתייחסת לשטח זיכרו אחר‪.‬‬
‫‪-390-‬‬
‫שאלה ‪9.1‬‬
‫פתחו ויישמו אלגורית שיקבל כקלט מילה באנגלית ויציג אותה פעמיי‪ ,‬פע באותיות גדולות ופע‬
‫באותיות קטנות‪ .‬למשל‪ ,‬עבור הקלט ‪ Memory‬הפלט יהיה‪ MEMORY :‬ומיד אחר(כ! ‪.memory‬‬
‫שאלה ‪9.2‬‬
‫פתחו אלגורית שיקבל כקלט מחרוזת ותו‪ .‬פלט האלגורית יהיה מספר ההופעות של התו הנתו‬
‫בתו! המחרוזת הנתונה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫הדרכה‪ :‬מאחר שנית לברר את אור! המחרוזת הנתונה נית להשתמש בהוראה לביצוע חוזר שמספר‬
‫הסיבובי בה ידוע מראש )לולאת ‪.(for‬‬
‫שאלה ‪9.3‬‬
‫פתחו אלגורית המקבל כקלט רשימת מחרוזות המסתיימת במחרוזת "***"‪.‬‬
‫פלט האלגורית יהיה המחרוזת הארוכה ביותר ברשימה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שרשור מחרוזות‬
‫פעולה נוספת ושימושית מאוד על מחרוזות היא פעולת השרשור‪ .‬פעולה זו מקבלת שתי מחרוזות‬
‫ויוצרת מחרוזת חדשה‪ ,‬המורכבת מהמחרוזת הראשונה כשאחריה מוצמדת המחרוזת השנייה‪ .‬היא‬
‫אינה משנה את המחרוזות המקוריות‪.‬‬
‫בשפת ‪ Java‬מתבצע שרשור בעזרת סימ הפעולה ‪ .+‬כלומר‪ ,‬א ‪ s1‬ו(‪ s2‬ה מחרוזות‪ ,‬אז ער! הביטוי‬
‫‪ s1+s2‬הוא השרשור של ‪ s1‬ו(‪ .s2‬למשל‪ ,‬א ב(‪ s1‬נמצאת המחרוזת "‪ "he‬וב(‪ s2‬נמצאת המחרוזת‬
‫"‪ ,"llo‬אז ‪ s1+s2‬היא המחרוזת החדשה "‪."hello‬‬
‫שימו ♥‪ :‬פעולת השרשור אינה פעולה של המחלקה מחרוזת ולכ אופ הפעלתה שונה מזה של‬
‫פעולות כמו ‪ charAt ,length‬או פעולות אחרות של המחלקה‪ .‬היא אינה מופעלת על עצ של‬
‫המחלקה‪ ,‬ולכ אי שימוש בסימ הנקודה‪ .‬אופ הפעלת פעולת השרשור על מחרוזות דומה לאופ‬
‫הפעלת פעולות על טיפוסי רגילי בשפה‪.‬‬
‫למעשה‪ ,‬כבר השתמשנו פעמי רבות בפעולת השרשור על מחרוזות‪ .‬כזכור‪ ,‬עד כה השתמשנו‬
‫במחרוזות בהוראות הדפסה כגו‬
‫;)"‪System.out.println("hello‬‬
‫לעיתי‪ ,‬פקודות ההדפסה היו מעט יותר מורכבות‪ .‬למשל‬
‫; )‪System.out.println("The number is: " + number‬‬
‫או אפילו‬
‫‪-391-‬‬
‫‪System.out.println("There are " + bags + " bags, " + left + " are left‬‬
‫;)"‪over.‬‬
‫בכל ההוראות האלו הפעולה ‪ println‬מקבלת מחרוזת להדפסה‪ .‬בראשונה מבי דוגמאות ההדפסה‬
‫שלעיל‪ ,‬זוהי המחרוזת "‪ ."hello‬בדוגמאות האחרות מועברות לפעולה ‪ println‬מחרוזות‬
‫שהתקבלה כתוצאה מהפעלת פעולה‪ ,‬פעולה שמחזירה מחרוזת‪ .‬כ! למשל‪ ,‬המחרוזת שקיבלה‬
‫‪ println‬בכל אחת משתי הדוגמאות האחרות‪ ,‬התקבלה כתוצאה מהפעלת הפעולה ‪) +‬פע אחת‬
‫בדוגמה הראשונה‪ ,‬וארבע פעמי בשנייה(‪.‬‬
‫למשל‪ ,‬א ערכו של המשתנה ‪ number‬הוא ‪ ,3‬אז המחרוזת שהועברה להדפסה בהוראה הראשונה‬
‫היא שרשור של המחרוזת " ‪ "The number is:‬ע המחרוזת "‪ ,"3‬כלומר המחרוזת‬
‫‪"The‬‬
‫"‪.number is: 3‬‬
‫שימו ♥‪ :‬מאחר שבמשתנה ‪ number‬יש ער! מטיפוס של‪ ,‬הרי שטר ביצוע פעולת השרשור‬
‫התבצעה באופ אוטומטי פעולת הסבה של הער! המספרי למחרוזת המתאימה לו‪ .‬כ! קורה תמיד‬
‫כאשר אנו מבקשי לשרשר מחרוזת ע ער! מטיפוס שאינו מחרוזת‪ :‬לפני ביצוע פעולת השרשור‬
‫מתבצעת באופ אוטומטי פעולת הסבה של הערכי שאינ מחרוזות למחרוזות‪ .‬לכ‪ ,‬הפעולה ‪+‬‬
‫מתבצעת כפעולת שרשור של מחרוזות ולפעולה ‪ println‬מועברת מחרוזת אחת‪ ,‬שהיא תוצאת‬
‫השרשור‪.‬‬
‫שרשור מחרוזות נית לבצע בעזרת הפעולה ‪ ,+‬כ!‪:‬‬
‫מחרוזת‪ + 2‬מחרוזת‪1‬‬
‫פעולת השרשור יוצרת מחרוזת חדשה‪ ,‬ודואגת להקצות עבורה מקו‪ .‬היא אינה משפיעה על‬
‫המחרוזות המקוריות‪.‬‬
‫לפני ביצוע שרשור של מחרוזת ע ער! שאינו מחרוזת‪ ,‬הער! שאינו מחרוזת מוסב באופ אוטומטי‬
‫למחרוזת‪.‬‬
‫שאלה ‪9.4‬‬
‫פתחו אלגורית שיקבל כקלט ‪ 100‬זוגות של מחרוזות‪ .‬עבור כל זוג מחרוזות תוצג כפלט מחרוזת‬
‫שהיא שרשור של שתי המחרוזות )כלומר‪ ,‬בס! הכל יוצגו ‪ 50‬מחרוזות(‪ .‬ישמו את האלגורית בשפת‬
‫‪.Java‬‬
‫‪-392-‬‬
‫ומה בפנים? פעולות המסתכלות אל תוך הקנקן‬
‫למרות שכל מחרוזת היא עצ אחד‪ ,‬כמה מ הפעולות המוגדרות על עצמי של המחלקה מחרוזת‬
‫מאפשרות להתייחס באופ מפורש ג לתווי שמרכיבי מחרוזת‪ .‬פעולות כאלו‪ ,‬כמו הפעולה‬
‫‪ charAt‬שכבר היכרנו‪ ,‬מסייעות מאוד בפתרו בעיות שונות‪ ,‬כפי שמדגימה הבעיה הבאה‪:‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת השימוש בפעולות המגלות מידע על רכיביה של מחרוזת‪.‬‬
‫פתחו אלגורית שהקלט שלו הוא מחרוזת המהווה משפט באנגלית‪ ,‬והפלט הוא האות האחרונה של‬
‫המילה הראשונה במשפט‪ ,‬ומספר המילי במשפט‪.‬‬
‫למשל‪ ,‬עבור הקלט‪ welcome to Israel and have a nice day! :‬הפלט המתאי הוא ‪.e 8‬‬
‫נתבונ במשפט שנית כדוגמה‪.welcome to Israel and have a nice day! :‬‬
‫?‬
‫כיצד נית לדעת כמה מילי יש במשפט הנתו?‬
‫כיוו שלפני כל מילה‪ ,‬חו* מהראשונה‪ ,‬יש רווח‪ ,‬נוכל למנות את מספר הרווחי במחרוזת ולהוסי ‪.1‬‬
‫למשל‪ ,‬במשפט !‪ welcome to Israel and have a nice day‬יש ‪ 7‬רווחי‪ ,‬ולכ ‪ 8‬מילי‪) .‬זאת בהנחה‬
‫שבי מילה למילה יש רווח אחד בלבד!(‬
‫?‬
‫מהי האות האחרונה במילה הראשונה?‬
‫האות האחרונה במילה הראשונה היא האות שנמצאת מיד לפני הרווח הראשו‪.‬‬
‫לש פתרו הבעיה נפתור את התת(משימות הבאות‪:‬‬
‫‪ .1‬קליטת המחרוזת‬
‫‪ .2‬מניית מספר הרווחים במחרוזת שנקלטה‬
‫‪ .3‬חישוב מספר המילים במחרוזת‬
‫‪ .4‬מציאת הרווח הראשון במחרוזת‬
‫‪ .5‬מציאת התו שנמצא מיד לפני הרווח הראשון במחרוזת‬
‫‪ .6‬הצגה כפלט של מספר המילים במחרוזת ושל התו שנמצא בתת‪-‬משימה ‪5‬‬
‫‪-393-‬‬
‫‪ – sentence‬מחרוזת לשמירת המשפט שנקלט‬
‫‪– numOfSpaces‬של‪ ,‬מונה את מספר הרווחי במשפט‬
‫‪ – numOfWords‬של‪ ,‬שומר את מספר המילי במשפט‬
‫‪ – placeOfFirstSpace‬של‪ ,‬שומר את מיקומו של הרווח הראשו )לפניו נמצאת האות‬
‫המבוקשת(‬
‫‪sentence-á èôùî èåì÷ .1‬‬
‫‪0-ì numOfSpaces ìù åëøò úà ìçúà .2‬‬
‫‪.3‬‬
‫‪íà .3.1‬‬
‫‪:òöá úæåøçîä êøåàî ïè÷ù i éìéìù-éà íìù øôñî‬‬
‫‪çååø àåä sentence úæåøçîá i-ä íå÷îá àöîðù åúä‬‬
‫‪.3.1.1‬‬
‫‪1-á numOfSpaces ìù åëøò úà ìãâä‬‬
‫‪numOfSpaces+1 êøòä úà numOfWords-á íùä .4‬‬
‫‪placeOfFirstSpace-á íùäå ïåùàøä çååøä ìù åîå÷î úà àöî .5‬‬
‫‪sentence-á placeOfFirstSpace-1 íå÷îá úàöîðù úåàä úà èìôë âöä .6‬‬
‫‪numOfWords ìù åëøò úà èìôë âöä .7‬‬
‫את הוראה ‪ 3.1‬אפשר לייש בעזרת הפעולה ‪ .charAt‬אבל‪ ,‬נשי לב שהפעולה ‪ charAt‬מחזירה ער!‬
‫מטיפוס ‪ char‬ולא מטיפוס מחרוזת‪ ,‬ולכ יש להשוות את הער! המוחזר ממנה לתו רווח )ולא‬
‫למחרוזת המכילה את התו היחיד רווח(‪ .‬א כ!‪ ,‬את הוראה ‪ 3.1‬נייש כ!‪:‬‬
‫)' '==)‪if (sentence.charAt(i‬‬
‫ליישו הוראה ‪ 5‬נשתמש בפעולה ‪ .indexOf‬כפי שמתואר בטבלה שבסו הפרק‪ ,‬פעולה זו יכולה‬
‫לקבל תו או מחרוזת‪ .‬לכ נעביר לה את התו רווח והיא תחזיר את מקומו במחרוזת‪ ,‬כמספר של‪:‬‬
‫)' '(‪sentence.indexOf‬‬
‫שימו ♥‪ :‬יש תמיד לדאוג להתאמה בי טיפוסי הערכי בה אנו משתמשי לבי אלו המתוארי‬
‫בכותרת הפעולה‪.‬‬
‫‪-394-‬‬
/*
‫ משפט באנגלית‬:‫קלט‬
‫ האות האחרונה במילה הראשונה ומספר המילים במשפט‬:‫פלט‬
*/
public class HowManyWords
{
{
String sentence;
int placeOfFirstSpace;
int numOfSpaces = 0;
int numOfWords;
sentence = In.readString("Enter a sentence, with exactly one
space between words");
// ‫מניית הרווחים במשפט‬
for (int i = 0 ; i < sentence.length() ; i++)
{
if (sentence.charAt(i) == ' ')
{
numOfSpaces++;
} // if
} // for
numOfWords = numOfSpaces + 1;
// ‫מציאת מקומו של הרווח הראשון‬
placeOfFirstSpace = sentence.indexOf(' ');
System.out.println("The last letter of the first word is: " +
sentence.charAt(placeOfFirstSpace - 1));
// ‫כמה מילים במשפט‬
System.out.println("There are " + numOfWords + " words");
}//main
}// class HowManyWords
-395-
‫שאלה ‪9.5‬‬
‫פתחו ויישמו אלגורית שהקלט שלו הוא תו ומחרוזת והפלט הוא הודעה הא התו נמצא במחרוזת‬
‫או לא‪.‬‬
‫שאלה ‪) 9.6‬בגרות ‪(1995‬‬
‫פתחו ויישמו אלגורית שקולט מחרוזת‪ .‬האלגורית מציג כפלט כל תו במחרוזת פעמיי‪ ,‬פרט לתו‬
‫'*' )כוכבית( אשר ג א הוא כלול במחרוזת הוא לא מוצג כלל‪ .‬הפלט מוצג בשורה אחת‪.‬‬
‫למשל‪ ,‬עבור הקלט‪ AB*3B*? :‬הפלט יהיה ??‪.AABB33BB‬‬
‫שאלה ‪9.7‬‬
‫פתחו ויישמו אלגורית שמקבל כקלט רשימה של ‪ 100‬מחרוזות‪ .‬האלגורית מחשב בכמה מחרוזות‬
‫מתו! ה(‪ 100‬התו הראשו שווה לתו האחרו‪ ,‬ומציג כפלט את הער! שחישב‪.‬‬
‫שאלה ‪9.8‬‬
‫פתחו אלגורית שהקלט שלו הוא שלוש מחרוזות‪ ,‬והפלט שלו הוא שלוש המחרוזות לפי סדר מילוני‪.‬‬
‫למשל‪ ,‬עבור הקלט‪ good, today, apple :‬הפלט המתאי הוא‪today :‬‬
‫‪good‬‬
‫‪.apple‬‬
‫‪ 9.3‬השמת מחרוזות‬
‫עד כה ראינו כיצד לבצע פעולות קלט ופלט של מחרוזות‪ ,‬והשתמשנו בפעולות שונות על מחרוזות‪,‬‬
‫פעולות שמחזירות לנו מידע על המחרוזת‪ .‬בעיבוד של משתני רגילי‪ ,‬אחת מהפעולות השימושיות‬
‫ביותר היא הוראת השמה‪ .‬בסעי זה נדו בביצוע השמה עבור מחרוזות‪ ,‬כלומר בהשמה של מחרוזת‬
‫אל מחרוזת‪.‬‬
‫למעשה‪ ,‬כפי שכבר נאמר‪ ,‬ג הוראת קלט של מחרוזת היא הוראת השמה‪ .‬למשל‪ ,‬בהוראה‬
‫;)(‪str = In.readString‬‬
‫הפעולה ‪ In.readString‬מחזירה הפניה לשטח הזיכרו החדש שהוקצה עבור מחרוזת הקלט‪.‬‬
‫בעקבות ההשמה מפנה ‪ str‬אל אותו שטח זיכרו‪ ,‬ודר! ‪ str‬נית להגיע אל אותו שטח ולבצע עליו‬
‫פעולות שונות‪.‬‬
‫בסעי זה נראה כיצד לבצע השמה של מחרוזות‪ ,‬שאינה הוראת קלט או הוראת הקצאה ואתחול‪.‬‬
‫‪-396-‬‬
‫מטרת הבעיה הבאה‪ :‬הצגת השמת מחרוזת למחרוזת והדגמה נוספת של השימוש בפעולות של‬
‫המחלקה ‪.String‬‬
‫נאמר שכתובת דואר אלקטרוני היא חוקית א היא מקיימת את התנאי הבאי‪:‬‬
‫מתחילה באות לועזית‪ ,‬מורכבת מרצ לא ריק של תווי שאחריו מגיע התו '@'‪ ,‬אחריו שוב רצ לא‬
‫ריק‬
‫של‬
‫תווי‪,‬‬
‫אחריו‬
‫התו‬
‫'‪,'.‬‬
‫ולאחריו‬
‫עוד‬
‫רצ‬
‫לא‬
‫ריק‬
‫של‬
‫תווי‪.‬‬
‫כתובת ישראלית מסתיימת במחרוזת "‪".il‬‬
‫בקביעת חוקיות של כתובת דואר אי משמעות להבדל בי אותיות גדולות וקטנות‪.‬‬
‫למשל‪ ,‬המחרוזת ‪ [email protected]‬היא כתובת דואר אלקטרוני חוקית‪ ,‬וכ! ג ‪.IL‬ייי@‪ ,t‬שהיא כתובת‬
‫ישראלית‪ .‬לעומת‪ ,‬המחרוזות הבאות אינ כתובות חוקיות‪.cc :‬יח@ח )לא מתחילה באות לועזית(‪,‬‬
‫‪) [email protected]‬רצ‬
‫התווי שבי התו '@' לבי התו '‪ '.‬הוא ריק(‪) rt@jjj ,‬לא מכילה את התו '‪('.‬‬
‫‪) sda.asd@sad‬התו '‪ '.‬מופיע לפני התו '@'(‪.‬‬
‫פתחו אלגורית המקבל כקלט מחרוזת‪ .‬נית להניח כי במחרוזת המתקבלת התו '‪ '.‬לא מופיע יותר‬
‫מפע אחת וכ! ג התו '@'‪ .‬האלגורית מציג כפלט את המחרוזת שנקלטה‪ ,‬בצירו הודעה‬
‫המבהירה א המחרוזת מהווה כתובת דואר אלקטרוני חוקית‪ ,‬וא כ‪ ,‬הא זוהי כתובת ישראלית‪.‬‬
‫ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫הכתובת ‪ [email protected]‬היא חוקית וישראלית‪ .‬ג הכתובת ‪ [email protected]‬היא חוקית וישראלית‪ .‬אכ‪ ,‬אי‬
‫משמעות לשימוש באותיות קטנות או גדולות – ההבדל ביניה אינו משפיע על קביעת חוקיות‬
‫המחרוזת וג לא על סיווגה ככתובת ישראלית‪ .‬אבל‪ ,‬הפלט אינו לגמרי זהה בשני המקרי‪ :‬אמנ‪,‬‬
‫בשני המקרי נציג הודעה כי המחרוזת חוקית וישראלית‪ ,‬א! במקרה הראשו נציג את המחרוזת‬
‫‪ [email protected]‬ובמקרה השני את המחרוזת ‪[email protected]‬‬
‫כיוו שלצור! בדיקת חוקיות המחרוזת והקביעה א היא ישראלית או לא אי משמעות להבדל בי‬
‫אותיות גדולות לקטנות‪ ,‬נוכל לפשט את הבדיקה א נבצע אותה על מחרוזת זהה למחרוזת הקלט‬
‫פרט לכ! שהיא אחידה‪ ,‬כלומר‪ ,‬מורכבת רק מאותיות גדולות או רק מאותיות קטנות‪ .‬נחליט כי‬
‫המחרוזת האחידה תורכב כולה מאותיות קטנות‪ .‬את מחרוזת הקלט נשמור כמו שהיא‪ ,‬כדי שנוכל‬
‫להציגה כפלט‪.‬‬
‫‪-397-‬‬
‫קל לבדוק א התו הראשו הוא אות לועזית‪ .‬ברגע שבדיקה זו הצליחה‪ ,‬כבר ברור שהמילה אינה‬
‫מתחילה בתו '@'‪ ,‬כלומר‪ ,‬שהרצ שלפני התו '@' אינו ריק‪.‬‬
‫‪ .1‬קליטת מחרוזת‬
‫‪ .2‬יצירת מחרוזת זהה לזו שנקלטה‪ ,‬פרט לכך שבמקום כל אות גדולה מופיעה האות הקטנה‬
‫המתאימה לה‬
‫‪ .3‬בדיקה שהתו הראשון הוא אות לועזית‬
‫‪ .4‬בדיקה שהתוים '@' ו‪ '.'-‬מופיעים במחרוזת‬
‫‪ .5‬בדיקה שהתו '‪ '.‬מופיע אחרי התו '@'‪ ,‬אך לא מיד אחריו‬
‫‪ .6‬בדיקה שהרצף אחרי התו '‪ '.‬אינו ריק‬
‫‪ .7‬עבור מחרוזת חוקית‪ :‬בדיקה אם היא ישראלית‬
‫‪ .8‬הצגה כפלט של המחרוזת ושל הודעה מלווה מתאימה‬
‫בשאלה מתוארי כמה תנאי בה צריכה לעמוד מחרוזת חוקית‪ .‬מספיק שאחד מה לא מתקיי‪,‬‬
‫כדי לקבוע שהמחרוזת אינה חוקית‪ .‬נוכל להיעזר במשתנה בוליאני‪ :‬כל עוד לא מצאנו בעיה בכתובת‬
‫הדואר האלקטרוני ערכו של המשתנה יהיה ‪ .true‬כאשר נמצא שגיאה באחד התנאי נציב בו ‪.false‬‬
‫ההודעה לפלט תוצג על פי ערכו של המשתנה‪.‬‬
‫בנוס נזדקק לשתי מחרוזות‪ :‬האחת לשמירת מחרוזת הקלט המקורית‪ ,‬והשנייה לשמירת המחרוזת‬
‫האחידה‪.‬‬
‫כדי לבדוק את חוקיות המחרוזת נשתמש בשני משתני שלמי שישמרו את מקו התווי '@' ו('‪.'.‬‬
‫לבסו ‪ ,‬נקדיש משתנה ג לאור! המחרוזת שנקרא מהקלט‪ .‬כ! נוכל לחשב את האור! פע אחת‪,‬‬
‫ולהשתמש בער! המשתנה בכל הפעמי בה נזדקק לאור! המחרוזת‪.‬‬
‫‪ – isLegal‬משתנה בוליאני )"דגל"(‪ ,‬שיעיד הא הכתובת היא חוקית או לא‬
‫‪ – str‬מחרוזת לשמירת הכתובת הנקלטת‬
‫‪ – lowerCaseStr‬מחרוזת זהה למחרוזת הקלט פרט לכ! שבמקו כל אות גדולה נמצאת‬
‫האות הקטנה המתאימה לה‬
‫‪ – atPlace‬מספר של‪ ,‬לשמירת מקומו של התו '@'‬
‫‪ – dotPlace‬מספר של‪ ,‬לשמירת מקומו של התו '‪'.‬‬
‫‪ – len‬אור! מחרוזת הקלט‬
‫‪-398-‬‬
true-ì isLegal êøò úà ìçúà .1
str-ì úáåúë èåì÷ .2
äìåãâ úåà ìë íå÷îáù êëì èøô ,str-áù úæåøçîì ääæ ,äùãç úæåøçî øåö .3
lowerCaseStr-á äúåà íùäå ,äì äîéàúîä äðè÷ä úåàä úàöîð
úéìâðà úåà àì àéä äðåùàøä úåàä
íà
.4
false-ì isLegal êøò úà äðù .4.1
úæåøçîá íéòéôåî íðéà '@' åúä
åà '.' åúä íà
.5
úøçà
åéøçà ãééî àì êà '@' åúä éøçà òéôåî '.' åúä
false-ì isLegal êøò úà äðù
.6
íà .6.1
.6.1.1
(len – 1 íå÷îá) úæåøçîá ïåøçà òéôåî '.' åúä
íà
.7
true-ì äååù isLegal ìù åëøò
íà
.8
úé÷åç úáåúëä éë äòãåä èìôë âöä .8.1
".il"
úæåøçîä íä íéðåøçàä íéååúä úùåìù
úéìàøùé úáåúëä éë äòãåä èìôë âöä
íà .8.2
.8.2.1
úøçà .8.3
úéìàøùé äðéà úáåúëä éë äòãåä èìôë âöä
.8.3.1
úøçà
.9
úé÷åç úáåúëä éë äòãåä èìôë âöä .9.1
-399-
‫כדי לבדוק הא התווי '‪ '.‬ו( '@' מופיעי במחרוזת ‪ ,str‬וא כ – הא מיקומ תקי‪ ,‬נשתמש‬
‫בפעולה ‪ str.indexOf‬המקבלת תו‪ ,‬ומחזירה את מקומו במחרוזת ‪.str‬‬
‫כדי ליצור ממחרוזת הקלט )השמורה ב(‪ (str‬מחרוזת חדשה הזהה לה‪ ,‬פרט לכ! שכל אות גדולה‬
‫הוחלפה באות הקטנה המתאימה לה‪ ,‬נשתמש בפעולה ‪ .str.toLowerCase‬כמו כל פעולה הפועלת‬
‫על מחרוזות‪ ,‬ג הפעולה ‪ toLowerCase‬אינה משנה את המחרוזת עליה היא מופעלת‪ ,‬כלומר‪ ,‬היא‬
‫אכ יוצרת מחרוזת חדשה‪ .‬כמו כל פעולה שיוצרת מחרוזת חדשה‪ ,‬הפעולה ‪ toLowerCase‬דואגת‬
‫להקצות מקו עבור המחרוזת החדשה‪.‬‬
‫אנו מעונייני שדר! המשתנה ‪ lowerCaseStr‬נית יהיה להגיע למחרוזת החדשה‪ .‬לכ נשתמש‬
‫במשפט השמה‪ ,‬ונשי את הער! המוחזר מהפעולה ‪ str.toLowerCase‬ל(‪ ,lowerCaseStr‬כ!‪:‬‬
‫;)(‪lowerCaseStr = str.toLowerCase‬‬
‫בעקבות הוראה זאת העצ ‪ lowerCaseStr‬מפנה אל שטח בזיכרו‪ ,‬בו שמורה מחרוזת חדשה‪ ,‬הזהה‬
‫למחרוזת הקלט‪ ,‬פרט לכ! שבמקו כל אות גדולה נמצאת האות הקטנה המתאימה לה‪ .‬במחרוזת‬
‫המקורית‪ ,‬השמורה ב(‪ str‬לא חל כל שינוי‪.‬‬
‫לא היינו צריכי להקצות במפורש שטח זיכרו לעצ ‪ ,lowerCaseStr‬מפני שההקצאה עבור השטח‬
‫אליו הוא מפנה בוצעה בתו! הפעולה ‪.toLowerCase‬‬
‫*‪/‬‬
‫התוכנית מקבלת כקלט מחרוזת‪ ,‬מציגה אותה כפלט‪ ,‬ומציגה גם הודעה המבהירה אם‬
‫זו מחרוזת דואר אלקטרוני חוקית‪ ,‬ואם כן‪ ,‬האם היא כתובת ישראלית‬
‫‪*/‬‬
‫‪public class EmailAddress‬‬
‫{‬
‫{‬
‫מחרוזת הקלט ‪//‬‬
‫‪//‬‬
‫;‪String lowerCaseStr‬‬
‫מחרוזת זהה למחרוזת הקלט‪ ,‬פרט לכך‬
‫שאותיות גדולות מוחלפות בקטנות‬
‫שומר מיקום התו '@' ‪//‬‬
‫;‪int atPlace‬‬
‫שומר מיקום התו '‪// '.‬‬
‫;‪int dotPlace‬‬
‫דגל חוקיות הכתובת ‪//‬‬
‫;‪boolean isLegal = true‬‬
‫אורך המחרוזת שנקלטה ‪//‬‬
‫‪-400-‬‬
‫;‪int len‬‬
// ‫קלט מחרוזת ושמירת אורכה‬
str = In.readString("Insert an e-mail address, with only one .
and one @");
len = str.length();
// ‫יצירת המחרוזת החדשה ושמירתה‬
lowerCaseStr = str.toLowerCase();
// ‫בדיקה שהתו הראשון הוא אות לועזית‬
if (!(str.charAt(0) >= 'a' && str.charAt(0) <= 'z'))
{
isLegal = false;
} // if
// '@'-‫' ו‬.' ‫מציאת מקום התווים‬
atPlace = lowerCaseStr.indexOf('@');
dotPlace = lowerCaseStr.indexOf('.');
if ((dotPlace == -1)||(atPlace == -1)) // ‫אחד משני התווים חסר‬
{
isLegal = false;
}
else
{
if ((dotPlace < atPlace)|| (dotPlace == atPlace + 1))
{ // ‫הסדר בין התווים שגוי או שהם מופיעים ברצף‬
isLegal = false;
}
} // else
// ‫' אינו ריק‬.' ‫בדיקה שרצף התווים שאחרי התו‬
if (dotPlace == len - 1)
{
isLegal = false;
}
// ‫הפלט‬
if (isLegal)
{
System.out.println(str + " is a legal Email address");
// .il-‫ האם שווים ל‬,‫בדיקת שלושת התווים האחרונים במחרוזת‬
if (lowerCaseStr.IndexOf(".il") == len - 3)
-401-
‫{‬
‫;)"‪System.out.println("Email address is Israeli‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println("Email address is not Israeli‬‬
‫}‬
‫)‪}// if (isLegal‬‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println(str + " is not a legal Email address‬‬
‫}‬
‫‪} // main‬‬
‫‪} // EmailAddress‬‬
‫השמת מחרוזות נכתבת כהוראת השמה רגילה‪:‬‬
‫;‪string1 = string2‬‬
‫בעקבות ביצוע ההשמה‪ ,‬מפנה ‪ string1‬אל אותו שטח זיכרו שאליו מפנה ‪ .string2‬לכ‪ ,‬אי‬
‫צור! לבצע קוד הקצאת זיכרו עבור ‪.string1‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת בניית מחרוזת בשלבי‪ .‬היכרות ע הפעולה ‪.new‬‬
‫פתחו אלגורית אשר הקלט שלו הוא מחרוזת‪ .‬הפלט יהיה מחרוזת חדשה‪ ,‬הזהה למחרוזת‬
‫המקורית‪ ,‬פרט לכ! שמופיעה בה האות ‪ c‬בכל מקו שבו הופיעה האות ‪ b‬או ‪ B‬במחרוזת המקורית‪.‬‬
‫למשל‪ ,‬עבור המחרוזת "‪ "abcd‬הפלט יהיה המחרוזת "‪."accd‬‬
‫שימו ♥‪ :‬פרט לשינוי המתואר‪ ,‬המחרוזת החדשה צריכה להיות זהה למקורית‪ .‬בפרט‪ ,‬לא נית‬
‫להפו! בה אותיות גדולות לקטנות או להפ!‪.‬‬
‫‪ .1‬קליטת מחרוזת‬
‫‪ .2‬בניית המחרוזת החדשה‬
‫‪ .3‬הדפסת המחרוזת החדשה‬
‫‪-402-‬‬
‫את תת(משימה ‪ 2‬נוכל לפרק באופ הבא‪:‬‬
‫‪ .2.1‬יצירת מחרוזת חדשה ואתחולה למחרוזת ריקה‬
‫‪ .2.2‬בנייה הדרגתית של המחרוזת החדשה‪ ,‬תו בכל פעם‬
‫את תת(משימה ‪ 2.2‬נוכל לייש על ידי הוראה לביצוע חוזר‪ ,‬בה מספר הפעמי לביצוע ידוע מראש‬
‫ונקבע על פי אור! המחרוזת‪.‬‬
‫‪ – str‬המחרוזת שמתקבלת כקלט‬
‫‪ – new_str‬המחרוזת החדשה‬
‫‪ä÷éø úæåøçîë new_str úà ìçúà .2‬‬
‫‪.3‬‬
‫‪:òöá str-á character åú‬‬
‫‪åà 'b'-ì äååù character íà .3.1‬‬
‫‪.3.1.1‬‬
‫'‪'B‬‬
‫‪'c' åúä úà new_str-ì øùøù‬‬
‫‪úøçà .3.2‬‬
‫‪.3.2.1‬‬
‫‪character åúä úà new_str-ì øùøù‬‬
‫‪new_str úà èìôë âöä .4‬‬
‫בפתרו בעיה זו אנו מצהירי לראשונה על מחרוזת שתקבל את ערכה הראשוני לא על ידי הוראת‬
‫קלט ולא על ידי השמה אלא על ידי אתחול )הוראה ‪ .(2‬משו כ!‪ ,‬בניגוד לפתרונות הקודמי בה‬
‫הקצאת השטח עבור המחרוזת נעשתה באופ סמוי )על ידי פעולת הקלט או על ידי פעולות אחרות‬
‫המייצרות מחרוזות( בפתרו זה נדאג אנו להקצאת שטח עבור המחרוזת‪.‬‬
‫הקצאה מקו לעצ מתבצעת על ידי הפעולה ‪ .new‬למשל‪ ,‬כדי להקצות מקו בזיכרו לעצ‬
‫מהמחלקה מחרוזת נכתוב‪:‬‬
‫‪str‬‬
‫;)(‪String str = new String‬‬
‫הוראה זו מצהירה על העצ ומקצה לו מקו בזיכרו‪.‬‬
‫כזכור‪ ,‬עבור משתני רגילי נית לבצע אתחול תו! כדי הצהרה‪ .‬ג עצמי נית לאתחל תו! כדי‬
‫הצהרה‪ ,‬על ידי העברת ער! לפעולה ‪ .new‬למשל‪ ,‬ההוראה‬
‫‪-403-‬‬
‫;)"‪String str = new String("abc‬‬
‫מצהירה על עצ של המחלקה מחרוזת בש ‪ ,str‬מקצה לו מקו בזיכרו‪ ,‬ומאתחלת את ערכו‪ ,‬כ!‬
‫שכעת הוא שומר בתוכו את המחרוזת "‪."abc‬‬
‫לא במקרה הוראת אתחול זו דומה להשמה‪ .‬למעשה‪ ,‬פעולת ‪ ,new‬מיד אחרי שהיא מקצה שטח‬
‫בזיכרו‪ ,‬היא מחזירה ער!‪ ,‬שהוא הפניה לשטח הזיכרו שהוקצה‪.‬‬
‫ההוראה )"‪ str = new String("abc‬היא אכ הוראת השמה‪ ,‬בה מוש הער! המוחזר מהפעולה‬
‫‪ new‬ב(‪ .str‬כעת‪ str ,‬מפנה אל השטח שהוקצה עבורו בזיכרו‪ ,‬ובכל פע שנתייחס בתוכנית לעצ‬
‫‪ str‬ונבצע עליו פעולות שונות‪ ,‬ה יתבצעו על שטח הזיכרו המתאי‪.‬‬
‫בדומה להשמת ער! ראשוני לתו! משתני‪ ,‬ג הקצאת מקו בזיכרו לעצמי‪ ,‬ואתחול המקו הזה‬
‫לא חייבי להיעשות מיד ע ההצהרה‪ .‬למשל‪ ,‬נית לכתוב את ההוראות הבאות‪:‬‬
‫;)"‪str = new String("abc‬‬
‫ע זאת‪ ,‬בדיוק כמו שעבור משתני העדפנו לאתחל משתנה כמה שיותר מוקד‪ ,‬מיד כשידוע ער!‬
‫מתאי לאתחול‪ ,‬ולא לדחות את האתחול‪ ,‬כ! ג לגבי עצמי בכלל‪ ,‬ומחרוזות בפרט‪.‬‬
‫ביישו האלגורית לפתרו בעיה ‪ ,2‬האתחול כמחרוזת ריקה )הוראה ‪ (2‬יכול להתבצע יחד ע‬
‫הקצאת המקו עבור המחרוזת‪ ,‬כלומר‪ ,‬בעזרת הפעולה ‪ ,new‬כ!‪:‬‬
‫;)""(‪new_str = new String‬‬
‫את ערכו של כל תו תור במחרוזת נוכל לדעת )לצור! הוראה ‪ (3.1‬בעזרת הפעולה ‪.charAt‬‬
‫בהוראות ‪ 3.1.1‬ו(‪ 3.2.1‬עלינו לשרשר תו נוס למחרוזת‪ .‬נוכל להשתמש לש כ! בפעולת השרשור על‬
‫מחרוזות‪ .‬לכ‪ ,‬למשל‪ ,‬את הוראה ‪ 3.1.1‬נוכל לייש כ!‪:‬‬
‫;'‪new_str = new_str +'c‬‬
‫שימו ♥‪ :‬פעולת השרשור היא פעולה שמחזירה מחרוזת‪ .‬כמו כל פעולה שמחזירה מחרוזת‪ ,‬פעולת‬
‫השרשור אינה משנה את המחרוזות עליה היא פועלת‪ ,‬אלא יוצרת מחרוזת חדשה )כמוב‪ ,‬אחרי‬
‫שדאגה להקצות מקו עבורה(‪ ,‬השווה לשרשור המחרוזות המקוריות‪.‬‬
‫נניח למשל‪ ,‬שב(‪ new_str‬נמצאת המחרוזת "‪ ."ad‬מה קורה בעת ביצוע הוראת ההשמה שלעיל?‬
‫פעולת השרשור מקבלת שתי מחרוזות )במקרה זה‪ new_str ,‬והמחרוזת "‪ ,"c‬אחרי המרת התו‬
‫'‪'c‬‬
‫למחרוזת(‪ ,‬יוצרת‪ ,‬תו! הקצאת מקו מתאי בזיכרו‪ ,‬מחרוזת חדשה שמכילה את שרשור שתי‬
‫המחרוזות‪ ,‬כלומר את המחרוזת "‪ ."adc‬היא מחזירה את המחרוזת החדשה‪.‬‬
‫בפעולת ההשמה מושמת אותה מחרוזת חדשה אל ‪ .new_str‬כלומר‪ ,‬במקו ש(‪ new_str‬יפנה אל‬
‫המחרוזת המקורית )"‪ ,("ad‬הוא מצביע כעת אל השטח החדש בזיכרו‪ .‬מה קרה לעצ שהוא‬
‫המחרוזת המקורית? נית לומר שהוא הל! לאיבוד‪ .‬בכ! פעולת השמה של מחרוזות אינה שונה‬
‫‪-404-‬‬
‫מפעולת השמה רגילה של משתני‪ :‬ג כאשר אנו מבצעי השמה כגו ‪ ,x = y‬כאשר ‪ x‬ו(‪ y‬משתני‬
‫רגילי‪ ,‬ערכו המקורי של ‪ x‬אובד‪ ,‬והער! החדש‪ ,‬הלא הוא ערכו של ‪ ,y‬מחלי אותו‪.‬‬
‫כאשר נשרשר למחרוזת תו נוס ‪ ,‬אותו תהלי! יחזור על עצמו‪ :‬הקצאת שטח למחרוזת חדשה שהיא‬
‫שרשור של המחרוזת המקורית והתו החדש‪ ,‬והשמה‪ ,‬הגורמת ל(‪ new_str‬להצביע על המחרוזת‬
‫החדשה‪.‬‬
‫א כ!‪ ,‬בבנייה הדרגתית של מחרוזת‪ ,‬כפי שתואר לעיל‪ ,‬לא יהיה זה מדויק לומר שאותה מחרוזת‬
‫צומחת כל פע בתו נוס ‪ .‬למעשה‪ ,‬נוצרת סדרה של מחרוזות‪ :‬בכל פע נוצרת מחרוזת חדשה‪ ,‬ארוכה‬
‫בתו אחד‪ ,‬והיא תופסת את מקומה של המחרוזת הקודמת‪.‬‬
‫*‪/‬‬
‫קלט‪ :‬מחרוזת‬
‫פלט‪ :‬מחרוזת זהה למקורית‪ ,‬פרט לכך שכל '‪ 'B‬או '‪ 'b‬מוחלף ב‪'c'-‬‬
‫‪*/‬‬
‫‪public class ReplaceCForB‬‬
‫{‬
‫{‬
‫מחרוזת הקלט ‪//‬‬
‫המחרוזת החדשה ‪//‬‬
‫;‪String new_str‬‬
‫קלט ‪//‬‬
‫בניית המחרוזת החדשה ‪//‬‬
‫אתחול המחרוזת החדשה למחרוזת ריקה ‪new_str = new String("");//‬‬
‫סריקת מחרוזת הקלט תו אחר תו‪for(int i = 0; i<str.length(); i++)//‬‬
‫{‬
‫))'‪if ((str.charAt(i) == 'b') || (str.charAt(i) == 'B‬‬
‫{‬
‫החלפת '‪ 'B‬או '‪ 'b‬ב‪new_str = new_str + 'c'; // 'c'-‬‬
‫}‬
‫‪else‬‬
‫{‬
‫העתקת התו המקורי ‪new_str = new_str + str.charAt(i); //‬‬
‫}‬
‫‪} // for‬‬
‫פלט ‪//‬‬
‫;)‪System.out.println("The new String is: " + new_str‬‬
‫‪} // main‬‬
‫‪} // class ReplaceCForB‬‬
‫‪-405-‬‬
‫הקצאת שטח זיכרו למחרוזת‬
‫נית לבצע בעזרת הפעולה ‪.new‬‬
‫נית להעביר לפעולה ‪ new‬ער! לאתחול המחרוזת החדשה‪.‬‬
‫כאשר אנו נדרשי לבנות מחרוזת חדשה בשלבי‪ ,‬תו אחרי‬
‫תו נית לעשות זאת באופ‬
‫הבא‪ :‬ליצור מחרוזת חדשה ולאתחל אותה כמחרוזת ריקה )""(; באמצעות הוראה לביצוע חוזר‪,‬‬
‫לבצע בכל פע שרשור של המחרוזת הנוכחית ע תו מתאי‪ ,‬והחלפת המחרוזת הנוכחית במחרוזת‬
‫החדשה‪ ,‬שהתקבלה מפעולת השרשור‪.‬‬
‫שאלה ‪9.9‬‬
‫פתחו ויישמו אלגורית שהקלט שלו הוא מחרוזת המהווה משפט משובש‪ :‬במקו כל רווח מופיע‬
‫הסימ ‪ .$‬האלגורית מייצר מחרוזת חדשה ובה המשפט התקני‪ ,‬ומציג אותו כפלט‪ .‬ישמו את‬
‫שאלה ‪9.10‬‬
‫ר וד המציאו שפה מוצפנת‪ .‬המשפטי הניתני להצפנה כוללי מילי ורווחי בלבד‪ ,‬כאשר כל‬
‫מילה נכתבת רק באותיות לועזיות קטנות‪.‬‬
‫ההצפנה מתבצעת באופ הבא‪ :‬כל רווח מוחל בסימ '@'‪ ,‬ולאחר כל אות מופיעה האות הלועזית‬
‫הגדולה המתאימה לה‪.‬‬
‫למשל‪ ,‬המשפט ‪ good morning‬מוצפ כ! ‪.gGoOoOdD@mMoOrRnNiInNgG‬‬
‫פתחו אלגורית המקבל משפט כקלט ומציג כפלט את המשפט המוצפ המתאי לו‪ .‬ישמו את‬
‫שאלה ‪9.11‬‬
‫פתחו אלגורית שמקבל כקלט מחרוזת‪ ,‬מייצר מחרוזת חדשה שבה סדר התווי הפו! ביחס‬
‫למחרוזת המקורית‪ ,‬ומציג את המחרוזת החדשה כפלט‪ .‬בנוס ‪ ,‬האלגורית בודק א שתי המחרוזות‬
‫)המקורית וההפוכה( שוות זו לזו‪ .‬במילי אחרות‪ ,‬האלגורית בודק א המחרוזת המקורית היא‬
‫פלינדרו‪ .‬האלגורית מציג כפלט הודעה מתאימה לתוצאת הבדיקה‪.‬‬
‫למשל‪ ,‬עבור הקלט‪dog :‬‬
‫עבור הקלט‪aba :‬‬
‫יהיה הפלט‪.god – not a palindrome :‬‬
‫יהיה הפלט‪.aba – a palindrome :‬‬
‫שאלה ‪9.12‬‬
‫תלמידי הכיתה התעניינו לדעת למי יש סבתא ע הש הכי ארו!‪ .‬פתחו אלגורית אשר יקבל כקלט‬
‫את מספר התלמידי בכיתה‪ ,‬ואחר כ! רשימה שאורכה כמספר תלמידי הכיתה‪ ,‬של שמות הסבתות‬
‫‪-406-‬‬
‫של תלמידי הכיתה‪ ,‬כמחרוזות‪ .‬פלט האלגורית יהיה הש הארו! ביותר‪ .‬ישמו את האלגורית‬
‫בשפת ‪.Java‬‬
‫שאלה ‪9.13‬‬
‫כתובת אתר אינטרנט של חברה מסחרית בינלאומית בנויה בדר! כלל מ(‪ 3‬חלקי המופרדי‬
‫בנקודות‪:‬‬
‫‪.com‬ש החברה‪www.‬‬
‫פתחו אלגורית המקבל כקלט כתובת של אתר של חברה מסחרית בינלאומית‪ ,‬במבנה שתואר לעיל‪,‬‬
‫ומציגה כפלט את ש החברה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫הדרכה‪ :‬השתמשו בפעולה ‪ substring‬שבטבלת הפעולות אשר בסו הפרק‪.‬‬
‫שאלה ‪9.14‬‬
‫כתובת אתר אינטרנט של חברה מסחרית שאינה בינלאומית בנויה בדר! כלל מ(‪ 3‬חלקי המופרדי‬
‫בנקודות‪:‬‬
‫סיומת המדינה‪.‬ש החברה‪www.‬‬
‫פתחו אלגורית המקבל כקלט רשימת כתובות של אתרי חברות מסחריות לאומיות )כל אחת מה‬
‫במבנה שתואר לעיל(‪ ,‬המסתיימת במחרוזת "‪ ,"end‬ומציגה כפלט עבור כל חברה את שמה ואת סיומת‬
‫המדינה שלה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪9.15‬‬
‫יואב ועומרי המציאו משחק‪ .‬כל אחד בתורו רוש משפט המתחיל במילה האחרונה של המשפט‬
‫מהתור הקוד‪ .‬המשפט הראשו במשחק יתחיל במילה "‪ ."start‬למשל‪:‬‬
‫‪start the game‬‬
‫‪game is one of the best ways to kill the time‬‬
‫‪time is money‬‬
‫פתחו אלגורית המסייע למשחקי‪ :‬האלגורית מקבל כקלט את מספר התורות המבוקש‪ .‬בתחילת‬
‫כל תור הוא מציג את המילה בה צרי! להתחיל המשפט הבא‪ ,‬ולאחר מכ הוא מקבל כקלט את‬
‫המשפט החדש‪ .‬המשחק מסתיי כאשר מספר התורות הגיע לחס המבוקש‪ ,‬או כאשר המשפט שבחר‬
‫אחד השחקני מתחיל במילה שגויה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫‪-407-‬‬
‫סיכום‬
‫בפרק זה למדנו כיצד לבצע עיבוד של מחרוזות‪.‬‬
‫בשפת ‪ Java‬מחרוזת אינה טיפוס פשוט‪ ,‬כמו ‪ int‬או ‪ .char‬הטיפוס החדש מוגדר בשפה כמחלקה‬
‫בש ‪ ,String‬ומחרוזות ה עצמי של מחלקה זו‪.‬‬
‫למעשה‪ ,‬כבר הכרנו והשתמשנו במחלקות שונות כגו מחלקת המתמטיקה ששימשה אותנו לצור!‬
‫ביצוע פעולות מתמטיות שונות‪ ,‬או המחלקה ‪ System‬ששימשה אותנו להוראות פלט )כמו‬
‫‪ .(System.out.println‬אבל‪ ,‬בפרק זה הכרנו והגדרנו לראשונה מופעי של מחלקה‪ ,‬עצמי‪ ,‬שה‪,‬‬
‫כאמור‪ ,‬מעי משתני של הטיפוס החדש‪ .‬בפרק זה ג הפעלנו לראשונה פעולות של מחלקה על עצ‬
‫מהמחלקה‪ .‬השימוש בעצמי שונה מהשימוש במשתני מהטיפוסי המוכרי לנו‪.‬‬
‫הצהרה על עצ ממחלקה מסוימת דומה להצהרה על משתנה מטיפוס סטנדרטי )כגו ‪ int‬או ‪.(char‬‬
‫למשל‪,‬‬
‫;‪string str‬‬
‫בניגוד להצהרה על משתני מטיפוסי סטנדרטיי‪ ,‬אחרי הצהרה על עצ צרי! ג לבצע עבורו‬
‫הקצאת שטח זיכרו‪ ,+‬על ידי הפעולה ‪ .new‬הפעולה ‪ new‬משמשת ג לאתחול עצ‪ ,‬תו! כדי הצהרה‬
‫עליו או לאחר מכ‪.‬‬
‫למשל‪ ,‬ההוראה הבאה מקצה מקו עבור ‪ s‬ומאתחלת אותו כ! שישמור את המחרוזת "‪: "ab‬‬
‫;)"‪s = new String("ab‬‬
‫מיקו התווי במחרוזת מתחיל מ(‪ .0‬בפרט‪ ,‬בכל מחרוזת‪ ,‬א נסמ את אור! המחרוזת ב(‪ ,len‬אז‬
‫התו האחרו במחרוזת נמצא במקו ‪ ,len −1‬והתו הראשו נמצא במקו ה(‪.0‬‬
‫במחלקה ‪ String‬מוגדרות פעולות שנית‪ +‬לבצע על מחרוזות‪ ,‬כלומר‪ ,‬על עצמי של המחלקה‪.‬‬
‫לכל פעולה המוגדרת במחלקה יש חוקי משלה‪ :‬איזה סוגי ערכי )פרמטרי( היא מצפה לקבל‪,‬‬
‫ומאיזה טיפוס הער! המוחזר ממנה‪ .‬חשוב לוודא התאמה בי טיפוסי הפרמטרי המועברי לפעולה‬
‫לאלה אות היא מצפה לקבל‪ ,‬ובי טיפוס הער! המוחזר ממנה לפעולות המתבצעות עליו‪ .‬למשל‪ ,‬א‬
‫אנו מבצעי השמה של הער! המוחזר מפעולה לתו! משתנה‪ ,‬יש לוודא התאמה בי הטיפוס של‬
‫המשתנה לטיפוס הער! המוחזר‪.‬‬
‫כדי לציי ביצוע פעולה של עצ מהמחלקה משתמשי בסימו‪ +‬הנקודה‪ :‬ראשית נכתב ש העצ‪,‬‬
‫אחריו נכתבת נקודה‪ ,‬לאחר מכ נכתב ש הפעולה לביצוע‪ ,‬ומייד אחר כ! מפורטי בסוגריי‬
‫הערכי המועברי לפעולה‪ .‬למשל‪ str.length() ,‬או )‪.str.charAt(5‬‬
‫‪-408-‬‬
‫עבור עצמי של המחלקה ‪ String‬מוגדרות פעולות רבות‪ ,‬המשמשות אותנו ביישו אלגוריתמי‬
‫הקשורי למחרוזות‪ .‬למחלקה זו פעולות רבות נוספות‪ ,‬פרט לאלו שהוצגו בפרק‪ ,‬ולא נרחיב עליה את‬
‫הדיבור כא‪ .‬תוכלו למצוא הרחבה על כל אחת מהפעולות בקישור הזה‪:‬‬
‫‪http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html‬‬
‫ביחידה זו נשתמש רק בפעולות אות למדנו בפרק זה‪.‬‬
‫כל הפעולות שמחזירות מחרוזת‪ ,‬אינ משנות את המחרוזת עבורה הופעלו‪ .‬ה יוצרות מחרוזת חדשה‬
‫ומבצעות כבר הקצאת שטח עבורה‪.‬‬
‫לביצוע קלט של מחרוזת השתמשנו בפעולה ‪ .In.readString‬ג פעולה זו מקצה שטח זיכרו עבור‬
‫המחרוזת החדשה‪.‬‬
‫בעקבות ביצוע השמה של מחרוזת אל מחרוזת‪ ,string1 = string2 ,‬מפנה ‪ string1‬אל אותו‬
‫שטח זיכרו שאליו מפנה ‪ .string2‬לכ‪ ,‬אי צור! לבצע קוד הקצאת זיכרו עבור ‪.string1‬‬
‫בנוס לפעולות הסטנדרטיות על מחרוזות‪ ,‬למדנו בפרק זה על פעולת השרשור‪ .‬פעולה זו מקבלת שתי‬
‫מחרוזות ויוצרת מחרוזת חדשה שהיא שרשור של שתי המחרוזות‪ .‬זוהי פעולה שימושית מאוד לצור!‬
‫הדפסה‪ .‬פעולת השרשור אינה פעולה של המחלקה ‪ String‬ולכ בכתיבתה אי שימוש בסימו‬
‫הנקודה‪ .‬סימ פעולת השרשור הוא הסימ ‪.+‬‬
‫ביחידת ההמש! )"יסודות מדעי המחשב ‪ ("2‬נלמד להגדיר מחלקות בעצמנו‪ ,‬ולא רק להשתמש‬
‫במחלקות קיימות‪.‬‬
‫‪-409-‬‬
‫רשימת פעולות על מחרוזות‬
‫הפעולה‬
‫תיאור הפעולה‬
‫טיפוס‬
‫התוצאה‬
‫פעולה המחזירה את אורכה‬
‫של המחרוזת )מספר התווי‬
‫במחרוזת(‪.‬‬
‫של‬
‫דוגמאות‬
‫הער‪ ,‬המוחזר‬
‫הפעולה‬
‫)(‪s1.length‬‬
‫)(‪length‬‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫‪3‬‬
‫"‪"dog‬‬
‫)(‪s2.length‬‬
‫‪0‬‬
‫""‬
‫)‪charAt(int index‬‬
‫)‪indexOf(String s‬‬
‫)‪indexOf(char c‬‬
‫פעולה המחזירה את התו‬
‫הנמצא במחרוזת במקו‬
‫)‪s1.charAt(2‬‬
‫תו‬
‫)אינדקס( הנתו‪.‬‬
‫"‪"shalom‬‬
‫פעולה המקבלת מחרוזת‪ ,‬או‬
‫תו ומחזירה את המקו‬
‫)"‪s1.indexOf("pl‬‬
‫הראשו שממנו מופיעה‬
‫המחרוזת הנתונה או התו‬
‫הנתו בתו! המחרוזת שעליה‬
‫מופעלת הפעולה‪ .‬א‬
‫'‪'a‬‬
‫‪3‬‬
‫"‪"people‬‬
‫של‬
‫)'‪s1.indexOf('o‬‬
‫המחרוזת או התו לא‬
‫מופיעי‪ ,‬יוחזר הער! ‪.(1‬‬
‫‪2‬‬
‫"‪"people‬‬
‫)‪s1.equals(s2‬‬
‫)‪equals(String s‬‬
‫פעולה המקבלת מחרוזת‪,‬‬
‫ומחזירה ‪ true‬א המחרוזת‬
‫"‪ "love‬וב(‪ s2‬נמצאת‬
‫המחרוזת "‪"Love‬‬
‫שעליה הופעלה הפעולה‬
‫בוליאני‬
‫והמחרוזת הנתונה שוות זו‬
‫)‪s1.equals(s2‬‬
‫לזו בדיוק‪ .‬אחרת‪ ,‬היא‬
‫"‪ "love‬וב(‪ s2‬נמצאת‬
‫מחזירה ‪.false‬‬
‫המחרוזת "‪"love‬‬
‫‪-410-‬‬
‫‪false‬‬
‫‪true‬‬
‫פעולה המקבלת מחרוזת‪,‬‬
‫ומשווה בינה לבי המחרוזת‬
‫שעליה הופעלה הפעולה‪ .‬א‬
‫ה שוות זו לזו מוחזר הער!‬
‫)‪compareTo(String s‬‬
‫‪ .0‬א המחרוזת עליה‬
‫)‪s1.compareTo(s2‬‬
‫מופעלת הפעולה קודמת‬
‫"‪ "aa‬וב(‪ s2‬נמצאת המחרוזת‬
‫למחרוזת הנתונה‪ ,‬על פי סדר‬
‫מילוני‪ ,‬יוחזר מספר של‬
‫שלילי‪ .‬א המחרוזת הנתונה‬
‫קודמת על פי סדר מילוני‬
‫של‬
‫"‪"ab‬‬
‫מספר חיובי‬
‫כלשהו‬
‫למחרוזת שעליה מופעלת‬
‫הפעולה‪ ,‬יוחזר מספר של‬
‫חיובי‪.‬‬
‫)(‪toLowerCase‬‬
‫פעולה שיוצרת ומחזירה‬
‫מחרוזת שזהה למחרוזת‬
‫עליה היא מופעלת‪ ,‬פרט לכ!‬
‫שבמקו כל אות לועזית‬
‫גדולה נמצאת האות הקטנה‬
‫המתאימה לה‪.‬‬
‫)(‪s1.toLowerCase‬‬
‫מחרוזת‬
‫"‪"Peace‬‬
‫המחרוזת‬
‫החדשה‬
‫"‪"peace‬‬
‫)(‪toUpperCase‬‬
‫)‪substring(int k‬‬
‫מחרוזת שזהה למחרוזת‬
‫עליה היא מופעלת‪ ,‬פרט לכ!‬
‫שבמקו כל אות לועזית‬
‫גדולה נמצאת האות הקטנה‬
‫המתאימה לה‪.‬‬
‫מחרוזת שזהה לתת(מחרוזת‬
‫המתחילה מהמקו ה(‪ k‬של‬
‫המחרוזת עליה היא מופעלת‪,‬‬
‫ועד סופה‬
‫‪-411-‬‬
‫מחרוזת‬
‫מחרוזת‬
‫)(‪s1.toUpperCase‬‬
‫החדשה‬
‫"‪"Peace‬‬
‫"‪"PEACE‬‬
‫)‪s1.substring(4‬‬
‫החדשה‬
‫"‪"GoodBye‬‬
‫"‪"Bye‬‬
‫‪substring(int k,‬‬
‫)‪int s‬‬
‫מחרוזת שזהה לתת(מחרוזת‬
‫המתחילה מהמקו ה(‪ k‬של‬
‫המחרוזת עליה היא מופעלת‪,‬‬
‫ואורכה הוא ‪ ,s-k‬כלומר‪,‬‬
‫היא מסתיימת במקו ה(‬
‫החדשה‬
‫"‪"GoodBye Israel‬‬
‫"‪"Bye Is‬‬
‫)‪s1.substring(4,10‬‬
‫מחרוזת‬
‫)‪(s-1‬‬
‫‪-412-‬‬
‫פרק ‪ – 10‬מערכי‬
‫האלגוריתמי שפיתחנו לפתרו בעיות שונות בפרקי הקודמי היו שוני ומגווני‪ .‬בפרט‪ ,‬ה היו‬
‫שוני זה מזה בכמות המידע הנקלט בה‪ ,‬כלומר‪ ,‬בגודל הקלט‪ .‬אבל‪ ,‬בכל האלגוריתמי שהצגנו עד‬
‫כה‪ ,‬ג כאשר כמות המידע הנקלט )הקלט( הייתה גדולה‪ ,‬הרי כמות המידע שצרי היה לשמור או‬
‫לזכור במהל ביצוע האלגורית היתה קטנה‪ .‬למשל‪ ,‬כאשר רצינו לחשב ממוצע של ‪ 100‬מספרי קלט‪,‬‬
‫שמרנו א ורק את סכומ המצטבר ונתו קלט תור‪ ,‬ולא את כל ‪ 100‬נתוני הקלט‪ .‬בכל האלגוריתמי‬
‫שפיתחנו עד כה השתמשנו במספר משתני מצומצ‪ ,‬ולכל משתנה הוגדר תפקיד ייחודי משלו‪.‬‬
‫בפרק זה יוצגו בעיות אשר לצור פתרונ יש לשמור מספר גדול של נתוני‪ ,‬ויש קשר בי הנתוני‬
‫הנשמרי‪ :‬ה בעלי משמעות דומה וניתני לתיאור כאוס סדור של איברי מאותו טיפוס‪ .‬אוס‬
‫סדור כזה של איברי נקרא "מער"‪.‬‬
‫‪ 10.1‬מערך ואיברי מערך‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת שימוש במער לפתרו בעיה אלגוריתמית‪.‬‬
‫פתחו אלגורית המקבל כקלט את זמני ההקפה של כל אחד מארבעי משתתפי מרו" הקרטינג‪.‬‬
‫האלגורית מציג כפלט את מספר המשתתפי שביצעו הקפה בזמ נמו מהזמ הממוצע של כלל‬
‫המשתתפי‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪10.1‬‬
‫מהו הפלט כאשר נתוני ‪ 40‬זמני הקפה‪ ,‬עשרי מה שווי ל‪ ,4.50#‬עשרה שווי ל‪ ,4.20#‬ועשרה‬
‫שווי ל‪?4.60#‬‬
‫בפרק ‪ 7‬כבר ראינו כיצד לחשב ממוצע של רשימת ערכי קלט‪:‬‬
‫‪ .1‬קליטת נתוני הקלט וצבירתם‬
‫‪ .2‬חלוקת הסכום המצטבר במספר ערכי הקלט‬
‫‪-413-‬‬
‫?‬
‫במהל צבירת הנתוני לצור חישוב הממוצע נוס לצובר ערכו של כל נתו נקרא‪ ,‬א הנתו איננו‬
‫נשמר‪ .‬לאחר קליטת כל נתוני הקלט נית לחשב את הממוצע‪ ,‬א ערכי הקלט עצמ אינ שמורי‪.‬‬
‫אבל‪ ,‬כדי למנות את מספר הנתוני שמתחת לממוצע יש לשמור את ערכי הקלט עד לאחר חישוב‬
‫הממוצע‪ ,‬משו שרק לאחר חישוב הממוצע‪ ,‬אפשר להשוות כל אחד מערכי הקלט לממוצע‪ .‬כיצד‬
‫נרחיב את התת‪#‬משימות המתוארות כ שיתייחסו ג למציאת ערכי הקלט הקטני מהממוצע?‬
‫‪ .1‬קליטת נתוני הקלט‪ ,‬שמירתם וצבירתם‬
‫‪ .2‬חלוקת הסכום המצטבר במספר ערכי הקלט‬
‫‪ .3‬השוואת כל ערך קלט לממוצע‪ ,‬ומנייתו אם הוא קטן מהממוצע‬
‫ישנ ‪ 40‬נתוני קלט‪ ,‬ועלינו לשמור כל אחד מה בנפרד‪ .‬הא נצהיר על ‪ 40‬משתני‪ ,‬כל אחד בנפרד?‬
‫מכיוו שלכל אחד מנתוני הקלט איפיו דומה‪ ,‬מתאי לקשר יחד‪ .‬נית להתייחס אל נתוני הקלט‬
‫כאל סדרת ערכי בת ‪ 40‬איברי דומי‪ ,‬ולפיכ לשמור אות בסדרת משתני‪ .‬הער הנקלט ראשו‬
‫יישמר במשתנה הראשו בסדרה‪ ,‬הער הנקלט שני יישמר במשתנה השני בסדרה‪ ,‬וכ הלאה‪ .‬הקישור‬
‫בי המשתני יתבצע על ידי מת ש לסדרה‪ ,‬ופנייה לכל אחד מהמשתני על פי מקומו הסידורי‬
‫בסדרה‪ .‬סדרה כזאת של משתני מקושרי נקראת מער‪.‬‬
‫מער )‪(array‬‬
‫הינו אוס סדור של איברי מאותו טיפוס‪ .‬נית להתייחס לכל אחד מאיברי‬
‫המער כמו למשתנה לכל דבר‪ .‬כלומר‪ ,‬נית לשמור בו ערכי ולקרוא את הערכי השמורי בו‪.‬‬
‫מקומו הסידורי של איבר במער מצוי על‪#‬ידי מציי )‪.(index‬‬
‫א כ‪ ,‬בבעיה זו אנו זקוקי למער בעל ארבעי איברי‪ ,‬איבר אחד עבור כל אחד מארבעי זמני‬
‫ההקפה הנתוני‪ .‬הטיפוס של כל איבר יהיה ממשי‪ .‬נקרא למער לשמירת זמני ההקפה ‪. scores‬‬
‫לכ‪ ,‬זוהי רשימת המשתני לה נזדקק‪:‬‬
‫‪ – scores‬מער של ‪ 40‬איברי ממשיי‪ ,‬לשמירת כל זמני ההקפה‬
‫‪ – sumOfScores‬מטיפוס ממשי‪ ,‬ישמור את סכו זמני ההקפות הנתוני בקלט‬
‫‪ – averageScore‬ממוצע זמני ההקפה‪ ,‬מטיפוס ממשי‬
‫‪ – belowAverageCounter‬למניית מספר הזמני שערכ הוא מתחת לממוצע‪ ,‬מטיפוס‬
‫של‪.‬‬
‫‪-414-‬‬
‫‪0-ì sumOfScores úà ìçúà .1‬‬
‫‪0-ì belowAverageCounter úà ìçúà .2‬‬
‫‪:òöá íéèì÷ðä íéëøòä øôñîì 1 ïéá íìù i ìë øåáò .3‬‬
‫‪scores êøòîá i-ä øáéàá íùäå i-ä äô÷ää ïîæ úà èåì÷ .3.1‬‬
‫‪i-ä äô÷ää ïîæ úà sumOfScores-á øåîùä êøòì óñåä .3.2‬‬
‫‪-á íùäå èì÷ä éëøò øôñîá sumOfScores-á øåîùä êøòä úà ÷ìç .4‬‬
‫‪averageScore‬‬
‫‪.5‬‬
‫‪:òöá íéèì÷ðä íéëøòä øôñîì 1 ïéá íìù i ìë øåáò‬‬
‫‪averageScore-î ìåãâ scores êøòîá i-ä øáéàä ìù åëøò íà .5.1‬‬
‫‪1-á belowAverageCounter ìù åëøò úà äìòä .5.1.1‬‬
‫‪belowAverageCounter ìù åëøò úà èìôë âöä .6‬‬
‫בשפת ‪ Java‬נית להגדיר מער שאיבריו ה מכל טיפוס נתוני שהוא‪ ,‬למשל‪ ,‬מער שאיבריו ה‬
‫מטיפוס של‪ ,‬או מער שאיבריו ה מטיפוס תו‪ .‬לצור פתרו בעיה זו אנו נדרשי להגדיר מער‬
‫מטיפוס ממשי‪ ,‬כלומר‪ ,‬שאיבריו ה מטיפוס ממשי‪ .‬ההצהרה על מער של מספרי ממשיי נעשית‬
‫באופ הבא‪:‬‬
‫;‪double[] scores‬‬
‫שימו ♥‪ :‬ההצהרה דומה להצהרה על משתנה מטיפוס ממשי‪ ,‬ורק תוספת הסוגריי המרובעי )][(‬
‫מבהירה כי אי הכוונה כא למשתנה יחיד מטיפוס ממשי אלא לעצ שהוא מער שאיבריו ה‬
‫מטיפוס ממשי‪.‬‬
‫א ההצהרה אינה מספיקה‪ .‬עלינו להקצות מקו חדש בזכרו עבור אוס האיברי שבמער‪ ,‬על ידי‬
‫ההוראה ‪ ,new‬המוכרת לנו מפרק ‪ .9‬כמוב‪ ,‬בעת ההקצאה עלינו לציי את מספר האיברי במער‪ ,‬כי‬
‫יש לכ השפעה על גודל שטח הזיכרו שיש להקצות‪.‬‬
‫א כ‪ ,‬הגדרת עצ מתאי‪ ,‬שהוא מער מטיפוס ממשי‪ ,‬והקצאת מקו בזכרו עבורו )תו ציו‬
‫מספר האיברי שהוא אמור להכיל( תיעשה כ‪:‬‬
‫;]‪double[] scores = new double[40‬‬
‫כזכור‪ ,‬הפעולה ‪ new‬מחזירה הפניה לשטח הזיכרו שהוקצה‪ .‬לכ‪ ,‬למעשה‪ scores ,‬מפנה כעת אל‬
‫השטח שהוקצה עבורו בזיכרו‪.‬‬
‫נשתמש בקבוע על מנת להגדיר את מספר האיברי‪ ,‬וכ תיראה ההגדרה‪:‬‬
‫;‪final int NUM_OF_RUNNERS = 40‬‬
‫;]‪double[] scores = new double[NUM_OF_RUNNERS‬‬
‫‪-415-‬‬
‫יש להדגיש כי בשפת ‪ ,Java‬כאשר מוקצה שטח זיכרו עבור מער של איברי מטיפוס פשוט‪ ,‬מתבצע‬
‫ג אתחול אוטומטי של כל איבריו‪ .‬איברי מער מספרי )שלמי או ממשיי( יאותחלו ל‪ ,0#‬איברי‬
‫מער בוליאני יאותחלו ל‪ ,false#‬ואיברי מער תווי יאותחלו לתו מיוחד‪ ,‬שנקרא תו ריק‪.‬‬
‫בשפת ‪ Java‬האיבר הראשו במער הוא במיקו ‪ 0‬מתחילת המער ולכ פניה לאיבר הראשו תיעשה‬
‫באמצעות המציי ‪ ,0‬כ‪ .scores[0] :‬האיבר השני נמצא במיקו ‪ 1‬מתחילת המער ולכ פנייה אליו‬
‫תיעשה באמצעות המציי ‪ ,1‬כ‪ .scores[1] :‬האיבר האחרו ברשימה‪ ,‬איבר מספר ‪ ,40‬נמצא במיקו‬
‫‪ 39‬מתחילת המער ונפנה אליו על ידי ]‪ .scores[39‬באופ כללי‪ ,‬ציו איברי מער בשפת ‪ Java‬מתחיל‬
‫תמיד מ‪ ,0#‬ופנייה לאיבר הנמצא במיקו ‪ i‬מתחילת מער ‪ anArray‬נכתבת כ‪ .anArray[i] :‬איבר‬
‫זה הוא האיבר ה‪ i+1#‬ברשימת האיברי‪.‬‬
‫נמחיש את המער ‪ scores‬בעזרת האיור הבא‪:‬‬
‫]‪scores[39‬‬
‫…‬
‫…‬
‫לכל עצ שהוא מער מוגדרת בשפה תכונה בש ‪ length‬השומרת את גודל המער‪ ,‬כלומר‪ ,‬את‬
‫מספר האיברי שהוא מכיל‪ .‬לתכונה זו נוכל לגשת באמצעות סימו הנקודה‪ ,‬בדומה לאופ שבו‬
‫הפעלנו פעולות של עצ‪ .‬למשל‪ scores.length ,‬היא תכונת האור של המער ‪ ,scores‬וערכה‬
‫שווה ל‪.40#‬‬
‫תכונת האור של מער היא קבועה ואינה ניתנת לשינוי‪ .‬כלומר‪ ,‬נוכל לשלב אותה בתו ביטויי‬
‫שוני בתוכנית‪ ,‬למשל ‪ ,x = scores.length + 1‬א לא נוכל להציבה בצד שמאל של הוראת‬
‫השמה‪ .‬כ למשל‪ ,‬הוראה כמו ‪ scores.length = 3‬היא שגויה‪ .‬א כ‪ scores.length ,‬הוא‬
‫בעצ קבוע לכל דבר )בדומה לקבוע ‪ ,(NUM_OF_RUNNERS‬א הוא מקושר לעצ ‪ ,scores‬אפילו שיי‬
‫אליו‪ ,‬ונית לגשת אליו רק דר העצ ‪ ,scores‬כפי שמביע סימו הנקודה‪.‬‬
‫שימו ♥‪ :‬ג כדי להשתמש בפעולה של עצ וג כדי לגשת לתכונה שלו אנו משתמשי בסימו‬
‫הנקודה‪ ,‬א הפניה לפעולה תלווה תמיד בסוגריי )אולי ריקי‪ ,‬א הפעולה אינה מצפה לקבל‬
‫פרמטרי(‪ ,‬ואילו פנייה לתכונה‪ ,‬בדומה לפנייה למשתנה רגיל‪ ,‬היא ללא סוגריי‪.‬‬
‫באלגורית לפתרו בעיה ‪ 1‬כללנו הוראה לביצוע חוזר באור ידוע מראש‪ ,‬למעבר על כל איברי המער‬
‫בזה אחר זה‪ .‬נוכל להשתמש בתכונת האור של המער הנסרק כדי לשלוט על מספר הסיבובי‬
‫בלולאה‪ .‬כלומר‪ ,‬נוכל לקבוע מראש את מספר הסיבובי בלולאה ל‪.scores.length#‬‬
‫מאחר שהתכונה ‪ length‬שומרת את מספר האיברי במער‪ ,‬נית ג לומר שאיברי המער נמצאי‬
‫בו מהמקו ‪ 0‬ועד המקו ‪ .length-1‬א כ‪ ,‬נאתחל את משתנה הבקרה של הלולאה ל‪ ,0#‬והלולאה‬
‫תסתיי כאשר ערכו יגיע ל‪) scores.length-1#‬אפשר כמוב ג לקבוע את ער הסיו של משתנה‬
‫הבקרה ל‪.(NUM_OF_RUNNERS–1#‬‬
‫‪-416-‬‬
/*
‫ זמני ההקפה של ארבעים משתתפי מרוץ קרטינג‬:‫קלט‬
‫ מספר המשתתפים שביצעו הקפה בזמן נמוך מהממוצע הקבוצתי‬:‫פלט‬
*/
public class BelowAverage
{
{
// ‫הגדרת קבוע‬
final int NUM_OF_RUNNERS = 40;
double[] scores = new double[NUM_OF_RUNNERS]; // ‫מערך זמני ההקפה‬
double sumOfScores = 0;
// ‫צובר זמני ההקפה‬
double averageScore;
// ‫ממוצע זמני ההקפה‬
int belowAverageCounter = 0; //
‫מונה‬
// ‫קלט וצבירה‬
1. for (int i = 0; i < scores.length; i++)
{
1.1. scores[i] = In.readDouble("Insert score: ");
1.2. sumOfScores = sumOfScores + scores[i];
} // for
// ‫חישוב ממוצע‬
2. averageScore = sumOfScores/scores.length;
// ‫מניית הנמוכים מהממוצע‬
3. for (int i = 0; i < scores.length; i++)
{
3.1. if (scores[i] < averageScore)
{
3.1.1. belowAverageCounter++;
} // if
} // for
// ‫פלט‬
4. System.out.println(belowAverageCounter + " participants are
below average");
} // main
} //class BelowAverage
-417-
‫מעקב‬
4.50 4.10 … 4.20 ‫נעקוב באופ חלקי אחר מהל ביצוע התכנית עבור הקלט‬
.168.8 ‫נניח שסכו זמני ההקפות הוא‬
‫משפט‬
‫לביצוע‬
scores[i] >
i
scores[0]
…
scores[39]
sumOfScores
belowAverage
averageScore
averageScore
?
?
?
0
?
0
1.
0
?
?
0
?
0
1.1
0
4.50
?
0
?
0
1.2
0
4.50
?
4.50
?
0
1
1
4.50
?
4.50
?
0
1.1
1
4.50
?
4.50
?
0
1.2
1
4.50
?
8.60
?
0
.
.
.
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
49
4.50
?
164.6
?
0
1.1
49
4.50
4.20
164.6
?
0
1.2
49
4.50
4.20
168.8
?
0
2.
49
4.50
4.20
168.8
4.22
0
3.
0
4.50
4.20
168.8
4.22
0
3.1
0
4.50
4.20
168.8
4.22
0
3.
1
4.50
4.20
168.8
4.22
0
3.1
1
4.50
4.20
168.8
4.22
0
3.1.1
1
4.50
4.20
168.8
4.22
1
.
.
.
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
4.50
4.20
168.8
4.22
1
3.1
39
4.50
4.20
168.8
4.22
1
3.1.1
39
4.50
4.20
168.8
4.22
2
4.
39
4.50
.
.
.
.
.
.
4.20
false
true
true
168.8
4.22
-418-
‫פלט‬
Counter
2
Insert
score:
Insert
score:
Insert
score:
2
particip
ants are
below
average
‫שימו ♥‪ :‬המעקב אחר הערכי השמורי באיבר של המער זהה למעקב אחר הערכי השמורי‬
‫במשתנה‪.‬‬
‫בפתרו הבעיה הכרנו שימוש במער עבור שמירת נתוני שנית להתייחס אליה כאל אוס סדור של‬
‫איברי מאותו טיפוס‪ .‬נית להתייחס אל איבר במער כאל משתנה‪ .‬כלומר‪ ,‬נית לשמור בו ערכי‬
‫ולקרוא את הערכי השמורי בו‪ .‬מקומו הסידורי של איבר במער מצוי על‪#‬ידי מציי )‪.(index‬‬
‫באלגורית לפתרו בעיה זו הכרנו דר נוחה לסרוק מער ולבצע עיבוד על כל איבריו‪ ,‬באמצעות‬
‫הוראה לביצוע חוזר‪ ,‬שמספר הסיבובי בה ידוע מראש‪ ,‬ושווה למספר האיברי במער )במילי‬
‫אחרות‪ ,‬לאורכו של המער(‪.‬‬
‫נסכ את המושגי הבסיסיי שהכרנו בפתרו בעיה ‪ ,1‬הנוגעי למערכי ולעבודה עימ בשפת‬
‫‪:Java‬‬
‫מער בשפת ‪ Java‬הוא עצ המוגדר בשפה‪.‬‬
‫משו שזהו עצ‪ ,‬אחרי ההצהרה על מער‪ ,‬צרי לבצע עבורו הקצאת מקו‬
‫בזיכרו‪ ,‬על ידי‬
‫ההוראה ‪ .new‬בעקבות ההקצאה מפנה ש המער אל שטח הזיכרו שהוקצה עבורו‪.‬‬
‫בשפת ‪ ,Java‬מייד אחרי הקצאת שטח זיכרו עבור מער של איברי מטיפוס פשוט‪ ,‬מתבצע ג‬
‫אתחול‬
‫אוטומטי של כל איבריו‪ .‬איברי מער מספרי )שלמי או ממשיי( יאותחלו ל‪ ,0#‬איברי‬
‫מער בוליאני יאותחלו ל‪ ,false#‬ואיברי מער תווי יאותחלו לתו הריק‪.‬‬
‫ציו איברי מער מתחיל תמיד מ‪ .0#‬פנייה‬
‫לאיבר הנמצא במיקו ‪ i‬מתחילת מער ‪anArray‬‬
‫נכתבת כ‪ .anArray[i] :‬איבר זה הוא האיבר ה‪ i+1#‬ברשימת האיברי‪.‬‬
‫לכל עצ שהוא מער יש תכונה השומרת את אורכו‬
‫)‪ .(length‬נית להשתמש בה כדי לדעת‬
‫את מספר האיברי במער‪ ,‬א לא נית לשנותה‪ .‬נוח להשתמש בתכונה זו כדי לקבוע את מספר‬
‫הפעמי לביצוע בהוראות לביצוע חוזר שסורקות את כל איברי המער‪.‬‬
‫פנייה לתכונת‬
‫האור נעשית על ידי סימו הנקודה‪ ,‬למשל כ‪.anArray.length :‬‬
‫בתוכנית שבפתרו בעיה ‪ 1‬הצהרנו על המער ‪ scores‬והקצינו לו מקו בזיכרו באופ הבא‪:‬‬
‫;]‪double[] acores = new double[NUM_OF_RUNNERS‬‬
‫ננסח זאת באופ כללי‪:‬‬
‫‪-419-‬‬
‫הצהרה על מער מטיפוס כלשהו נכתבת בשפת ‪ Java‬כ‪:‬‬
‫;שם המערך‬
‫][ טיפוס‬
‫ש הטיפוס‪ ,‬ולאחריו סוגריי מרובעי )המצייני שזוהי הצהרה על מער של איברי מהטיפוס‪,‬‬
‫ולא של משתנה פשוט(‪ ,‬ואז שמו של המער‪.‬‬
‫הקצאת שטח למער‬
‫מתבצעת על ידי ההוראה ‪ new‬שאחריה מופיע טיפוס איברי המער‪,‬‬
‫ואחריו מופיע בסוגריי מרובעי מספר איברי המער‪:‬‬
‫;]מספר הערכים[ טיפוס ‪new‬‬
‫כזכור‪ ,‬נית לצר את ההצהרה וההקצאה להוראה אחת‪:‬‬
‫;]מספר הערכים[ טיפוס ‪ = new‬שם המערך‬
‫][ טיפוס‬
‫ונית ג לבצע בנפרד‪:‬‬
‫][ טיפוס‬
‫כדי להמחיש את המושגי החדשי נתבונ בדוגמה הבאה‪:‬‬
‫בשורה הבאה יש הצהרה על מער מטיפוס של‪ ,‬והקצאת שטח המספיק ל‪5#‬איברי‪.‬‬
‫;]‪int[] arr = new int[5‬‬
‫א כ‪ ,‬המער ‪ arr‬מורכב בעצ מחמישה תאי בזיכרו‪:‬‬
‫]‪arr[4‬‬
‫]‪arr[3‬‬
‫]‪arr[2‬‬
‫]‪arr[1‬‬
‫]‪arr[0‬‬
‫‪arr‬‬
‫האיבר הראשו במער ‪ arr‬הוא ]‪ ,arr[0‬האיבר השני הוא ]‪ ,arr[1‬וכ הלאה‪ .‬האיבר האחרו הוא‬
‫]‪.arr[4‬‬
‫על כל איבר במער ‪ arr‬נית לבצע כל פעולה שנית לבצע על כל משתנה מטיפוס של‪ .‬למשל‪:‬‬
‫♦ השמה‪:‬‬
‫;‪arr[4] = num‬‬
‫♦ קלט‪:‬‬
‫;)"‪arr[i] = In.readInt("Insert a number‬‬
‫♦ פלט‪:‬‬
‫;)]‪System.out.println(arr[i‬‬
‫נראה כיצד ייראה המער ‪ arr‬לאחר ביצוע ההוראות הבאות‪:‬‬
‫;‪arr[0] = 9‬‬
‫;‪arr[1] = 7‬‬
‫;‪arr[2] = 2 * 4‬‬
‫;]‪arr[3] = 4 + arr[1‬‬
‫;]‪arr[4] = arr[2] + arr[3‬‬
‫‪-420-‬‬
‫]‪arr[4‬‬
‫]‪arr[3‬‬
‫]‪arr[2‬‬
‫]‪arr[1‬‬
‫]‪arr[0‬‬
‫‪19‬‬
‫‪11‬‬
‫‪8‬‬
‫‪7‬‬
‫‪9‬‬
‫‪arr‬‬
‫שאלה ‪10.2‬‬
‫נניח כעת שבמרו" הקרטינג משתתפי רק שלושה מתחרי‪ ,‬כלומר‪ ,‬ערכו של הקבוע‬
‫‪ NUM_OF_RUNNERS‬הוא ‪ .3‬הקלט לתוכנית )כלומר‪,‬זמני ההקפה שלה( הוא‪ .4.20 4.80 4.40 :‬בנו‬
‫טבלת מעקב לתוכנית ‪ BelowAverage‬ועקבו אחר מהל ביצוע האלגורית לפי הנתוני החדשי‪.‬‬
‫מהו הפלט המתקבל?‬
‫שאלה ‪10.3‬‬
‫הוסיפו הוראה או הוראות לתוכנית ‪ BelowAverage‬כ שהפלט יהיה רשימת זמני ההקפות‬
‫הנמוכי מהממוצע‪.‬‬
‫שאלה ‪10.4‬‬
‫נתו קטע התוכנית הבא‪:‬‬
‫;‪int a1,a2‬‬
‫;‪arr[0] = 2‬‬
‫;)"‪a1 = In.readInt("Insert a number‬‬
‫;)"‪arr[2] = In.readInt("Insert a number‬‬
‫;)"‪a2 = In.readInt("Insert a number‬‬
‫;]‪arr[3] = 2 * arr[2‬‬
‫;]‪arr[1] = a2 + arr[2‬‬
‫;‪a1 = a[1] + a[2] + a1‬‬
‫;)‪System.out.println(a1 + " " + a2‬‬
‫)‪for (i = 0; i < arr.length; i++‬‬
‫{‬
‫}‬
‫בנו טבלת מעקב אחר מהל ביצוע קטע התוכנית עבור הקלט‪.1 2 3 :‬‬
‫מה יהיה פלט קטע התוכנית עבור הקלט הנתו?‬
‫שאלה ‪10.5‬‬
‫נתונה הצהרת המער הבאה‪:‬‬
‫;]‪int[] temp = new int[10‬‬
‫א‪ .‬כתבו לולאה להשמת הער ‪ 0‬בכל אחד מאיברי המער‪.‬‬
‫‪-421-‬‬
‫ב‪ .‬כתבו לולאה לקליטת עשרה נתוני קלט בעשרת איברי המער‪.‬‬
‫ג‪ .‬כתבו לולאה להכפלה ב‪ 2#‬של ערכו של כל איבר במער‪.‬‬
‫ד‪ .‬כתבו לולאה להצגה כפלט של חצי מערכו של כל איבר במער‪.‬‬
‫שאלה ‪10.6‬‬
‫פתחו אלגורית אשר הקלט שלו הוא רשימה של עשרה ציוני‪ ,‬והפלט שלו הוא רשימת הכוללת לכל‬
‫ציו את מרחקו מהציו הממוצע‪ .‬מרחקו של ציו מהציו הממוצע הוא ‪ ‬ציו ממוצע ‪ −‬ציו ‪ ,‬כלומר‪,‬‬
‫הער המוחלט של ההפרש בי הציו לציו הממוצע‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שימו ♥‪ :‬חשוב להבחי בי ערכו של איבר לבי ערכו של המציי של איבר‪ ,‬כפי שמראה הדוגמה‬
‫הבאה‪.‬‬
‫נניח שנתו המער ‪ arr‬הבא‪:‬‬
‫]‪arr[2‬‬
‫]‪arr[1‬‬
‫]‪arr[0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪-1‬‬
‫‪arr‬‬
‫ערכו של האיבר הראשו הוא ‪ ,-1‬ערכו של האיבר השני הוא ‪ 0‬וערכו של האיבר השלישי הוא ‪.1‬‬
‫נתו משתנה ‪ ,i‬מטיפוס של‪ ,‬ונתו קטע התוכנית הבא‪:‬‬
‫;‪1. i = 0‬‬
‫;)]‪2. System.out.println(i + " " + arr[i‬‬
‫;‪3. i = i + 1‬‬
‫;‪5. arr[i] = arr[i] + 1‬‬
‫הנה טבלת המעקב אחר מהל ביצוע ההוראות שבקטע התוכנית‪:‬‬
‫פלט‬
‫‪0 -1‬‬
‫‪1 0‬‬
‫‪1 1‬‬
‫]‪arr[2‬‬
‫]‪arr[1‬‬
‫]‪arr[0‬‬
‫‪i‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪-1‬‬
‫‪-1‬‬
‫?‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪-1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪-1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪-1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪-1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪-1‬‬
‫‪1‬‬
‫מספר‬
‫שורה‬
‫‪i = 0‬‬
‫‪System.out…(i + " " +‬‬
‫)]‪arr[i‬‬
‫‪i = i + 1‬‬
‫)]‪arr[i‬‬
‫‪arr[i] = arr[i] + 1‬‬
‫)]‪arr[i‬‬
‫‪-422-‬‬
‫‪1.‬‬
‫‪2.‬‬
‫‪3.‬‬
‫‪4.‬‬
‫‪5.‬‬
‫‪6.‬‬
‫בקטע התוכנית הזה תפקידו של המשתנה ‪ i‬הוא להיות מציי של איברי המער ‪ ,arr‬כלומר‪ ,‬משתנה‬
‫שבאמצעותו פוני אל איברי המער‪ .‬כפי שנית לראות מטבלת המעקב ערכו של ‪ i‬אינו שווה בהכרח‬
‫לערכו של האיבר שנמצא במקו ה‪ ,i#‬כלומר ל‪.arr[i]#‬‬
‫בפרט‪ ,‬שינוי בערכו של האיבר שנמצא במקו ה‪ i#‬אינו משפיע על ערכו של ‪ ,i‬כפי שמדגימות בקטע‬
‫תוכנית זה הוראת ההשמה שבשורה ‪ 5‬והוראת הפלט שבשורה ‪.6‬‬
‫שאלה ‪10.7‬‬
‫כתבו קטע תוכנית המצהיר על מער מטיפוס של בגודל ‪ ,10‬ומציב בכל תא ער מספרי ששווה‬
‫לריבוע מקומו הסידורי‪ .‬למשל‪ ,‬בתא ‪ 0‬יהיה הער ‪ 0‬ובתא ‪ 5‬יהיה הער ‪.25‬‬
‫שאלה ‪10.8‬‬
‫במער ‪ t‬שלהל שמורי ערכי שלמי‪:‬‬
‫]‪int[] t = new int[20‬‬
‫א‪ .‬מה מטרת משפט ‪ for‬הבא‪:‬‬
‫)‪for (int i = 0; i < t.length; i++‬‬
‫{‬
‫)‪if (t[i] > i‬‬
‫{‬
‫}‬
‫}‬
‫ב‪ .‬כתבו משפט ‪ for‬אשר יציג כפלט את מקומ במער )כלומר‪ ,‬את מצייניה( של כל האיברי‬
‫במער שערכ כפול )כלומר‪ ,‬שווה לפי שניי( ממקומ הסידורי במער‪.‬‬
‫שאלה ‪10.9‬‬
‫בתוכנית הבאה נעשה שימוש במער של תווי‪:‬‬
‫*‪/‬‬
‫קלט‪ :‬עשר אותיות לועזיות‬
‫פלט‪:‬‬
‫_________________________________‬
‫‪*/‬‬
‫‪public class Letters‬‬
‫{‬
‫{‬
‫;]‪char[] letters = new char[10‬‬
‫)‪for (int i = 0; i < letters.length; i++‬‬
‫{‬
‫‪-423-‬‬
‫;)"‪letters[i] = In.readChar("Insert a character‬‬
‫‪} // for‬‬
‫)‪for (int i = 0; i < letters.length; i++‬‬
‫{‬
‫) ]‪== letters[letters.length -1‬‬
‫]‪if (letters[i‬‬
‫{‬
‫‪} // if‬‬
‫‪} // for‬‬
‫‪} // main‬‬
‫‪} // Letters‬‬
‫א‪ .‬מהו פלט התוכנית עבור הקלט‪?ABBASABABA :‬‬
‫ב‪ .‬מהי מטרת התוכנית? מלאו את תיאור הפלט בהערה שבראש התוכנית‪.‬‬
‫ג‪ .‬מדוע נחו" שימוש במער להשגת המטרה שתיארת בסעי ב?‬
‫בדוגמאות שראינו עד כה ההצהרה על מער לוותה בהקצאה מיידית של מקו עבורו‪ ,‬בעזרת הפעולה‬
‫‪ .new‬ע זאת‪ ,‬הזכרנו שהקצאת המקו בזיכרו יכולה להתבצע ג מאוחר יותר‪ .‬לעיתי‪ ,‬אכ נרצה‬
‫לדחות את ההקצאה‪ ,‬למשל‪ ,‬כאשר לא ידוע מראש גודל המער‪ ,‬והוא תלוי בקלט לתוכנית‪ ,‬כפי‬
‫שמדגימה הבעיה הבאה‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת מער שאורכו אינו ידוע מראש‪.‬‬
‫למבח הקבלה לכיתה המדעית יתקבלו רק התלמידי אשר ציוניה מעל הציו הממוצע של הכיתה‪.‬‬
‫פתחו אלגורית אשר קולט את מספר הניגשי למבח‪ ,‬ואחר כ קולט את רשימת הציוני של‬
‫הנבחני‪ .‬פלט האלגורית יהיה מספר התלמידי המתקבלי לכיתה‪ .‬ישמו את האלגורית בשפת‬
‫‪.Java‬‬
‫נית להניח כי לפחות תלמיד אחד ניגש למבח‪.‬‬
‫התהלי המבוקש כמעט זהה לזה שבפתרו בעיה ‪ :1‬עלינו לקלוט נתוני ולשמור אות‪ ,‬לחשב את‬
‫הממוצע‪ ,‬ולמנות את מספר הנתוני במער הגדולי מהממוצע‪) .‬שלא כמו בבעיה ‪ ,1‬ש היה עלינו‬
‫למנות את מספר הנתוני הקטני מהממוצע(‪.‬‬
‫אבל‪ ,‬ההבדל העיקרי בי בעיה זו לבעיה ‪ 1‬היא שכעת לא ידוע מראש מספר הנתוני‪ ,‬ולכ צרי קוד‬
‫כל לקרוא ער זה מהקלט‪.‬‬
‫‪-424-‬‬
‫בהתא לכ‪ ,‬נקבל את הפירוק הבא לתת‪#‬משימות‪:‬‬
‫‪ .1‬קליטת מספר הניגשים למבחן‬
‫‪ .2‬קליטת הציונים‪ ,‬שמירתם וצבירתם‬
‫‪ .3‬חלוקת הסכום המצטבר במספר הנבחנים‬
‫‪ .4‬השוואת כל ציון לממוצע‪ ,‬ומנייתו אם הוא גדול מהממוצע‬
‫‪ – numOfStudents‬מטיפוס של‪ ,‬לשמירת מספר התלמידי הנבחני‬
‫‪ – grades‬מער באור ‪ numOfStudents‬מטיפוס ממשי‪ ,‬לשמירת הציוני‬
‫‪ – sumOfGrades‬מטיפוס ממשי‪ ,‬ישמור את סכו הציוני‬
‫‪ – averageGrade‬ממוצע הציוני‪ ,‬מטיפוס ממשי‬
‫‪ – aboveAverageGrade‬למניית מספר הציוני מעל לממוצע‪ ,‬מטיפוס של‪.‬‬
‫האלגורית כמעט זהה לאלגורית שהוצג בפתרו בעיה ‪:1‬‬
‫שאלה ‪10.10‬‬
‫כתבו את האלגורית לפתרו בעיה ‪ .2‬היעזרו באלגורית שנית לפתרו בעיה ‪ ,1‬ושנו אותו כ שיכלול‬
‫הוראת קלט של מספר התלמידי הנבחני‪ ,‬יתייחס למשתני שנבחרו‪ ,‬ויית את הפלט המבוקש‪.‬‬
‫הנה קטע התוכנית המטפל בהצהרה על המער‪ ,‬קליטת מספר התלמידי‪ ,‬והקצאת מקו בזיכרו‬
‫עבור המער‪:‬‬
‫;‪int numOfstudents‬‬
‫;‪int[] grades‬‬
‫;)" ‪numOfstudents = In.readInt("Insert number of students:‬‬
‫;]‪grades = new int[numOfstudents‬‬
‫מיד אחרי שמוקצה למער מקו מתאי בזיכרו‪ ,‬התכונה ‪ length‬של המער שומרת את אורכו‪.‬‬
‫שאלה ‪10.11‬‬
‫השלימו את התוכנית לפתרו הבעיה‪.‬‬
‫‪-425-‬‬
‫שאלה ‪10.12‬‬
‫כתבו קטע תוכנית המקבלת כקלט מספר של‪ ,‬חיובי וזוגי‪ ,‬ומקצה מער מטיפוס של בגודל הער‬
‫שנקלט‪ .‬לאחר מכ התוכנית משימה באיברי המער הנמצאי במחצית הראשונה של המער את‬
‫המספר ‪ ,0‬ובאיברי המער הנמצאי במחצית השנייה של המער את המספר ‪.1‬‬
‫בדוגמאות שראינו עד כה איברי מער נסרקו באופ רצי ‪ ,‬האחד אחרי השני‪ .‬לעיתי‪ ,‬נרצה לסרוק‬
‫איברי מער באופ לא רצי ‪ .‬למשל‪ ,‬נניח ש‪ arr#‬הוא מער של עשרה איברי ויש להציג כפלט את‬
‫ערכיה של כל האיברי שבמקומות הזוגיי במער‪ .‬ג עבור סריקה כזאת נוכל להשתמש בהוראה‬
‫לביצוע חוזר באור ידוע מראש‪ ,‬א נקד את משתנה הבקרה של הלולאה בדילוגי של ‪:2‬‬
‫)‪for (int i = 0; i < arr.length; i = i + 2‬‬
‫{‬
‫}‬
‫שאלה ‪10.13‬‬
‫נתו המער ‪ arr‬המכיל מאה איברי מטיפוס של‪.‬‬
‫א‪ .‬תארו את מטרת הלולאה הבאה‪:‬‬
‫)‪for (int i = 0; i < arr.length; i++‬‬
‫{‬
‫)‪if (array[i] % 5 == 0‬‬
‫{‬
‫;)]‪System.out.println(array[i‬‬
‫}‬
‫}‬
‫ב‪ .‬תארו את מטרת הלולאה הבאה‪:‬‬
‫)‪for (int i = 0; i < array.length; i++‬‬
‫{‬
‫)‪if (i % 5 == 0‬‬
‫{‬
‫;)]‪System.out.println(array[i‬‬
‫}‬
‫}‬
‫ג‪ .‬כתבו לולאה יעילה יותר )כלומר‪ ,‬שמספר הסיבובי בה קט יותר( להשגת המטרה של סעי ב‪.‬‬
‫‪-426-‬‬
‫בבואנו לכתוב הוראה לביצוע חוזר המבצעת סריקה ועיבוד של איברי מער‪ ,‬נתאי את סוג ההוראה‬
‫להגדרת הסריקה שצריכה להתבצע‪.‬‬
‫א ידועי מראש ה המציי ממנו צריכה הסריקה להתחיל וה המציי בו היא אמורה להסתיי‪,‬‬
‫והסריקה עצמה היא בדילוגי ידועי‪ ,‬נשתמש בהוראה לביצוע חוזר שמספר הסיבובי בה ידוע‬
‫מראש )המיושמת על ידי לולאת ‪.(for‬‬
‫א סיו הסריקה תלוי בקיו תנאי‪ ,‬נשתמש בהוראה לביצוע חוזר בתנאי )המיושמת על ידי לולאת‬
‫‪.(while‬‬
‫שאלה ‪10.14‬‬
‫במער ‪ s‬ערכי מטיפוס תו‪.‬‬
‫א‪ .‬תארו את מטרת קטע התוכנית הבא‪:‬‬
‫;‪int i = 0‬‬
‫;‪int len = s.length‬‬
‫)]‪while (s[i] < s[len - 1‬‬
‫{‬
‫;‪i = i + 1‬‬
‫}‬
‫ב‪ .‬תארו את מטרת קטע התוכנית הבא‪:‬‬
‫;‪int c = 0‬‬
‫;‪int len = s.length‬‬
‫)‪for (int i = 0; i < len; i++‬‬
‫{‬
‫) )]‪if ( (i % 10 == 0) && (s[i] < s[len - 1‬‬
‫{‬
‫;‪c = c + 1‬‬
‫}‬
‫}‬
‫;)‪System.out.println(c‬‬
‫ג‪ .‬לולאת ה‪ for#‬שבקטע התוכנית בסעי ב מתבצעת מספר פעמי השווה לאור המער ‪ .s‬כתבו‬
‫לולאה שמבצעת אותה המשימה‪ ,‬א שמספר הסיבובי בה יהיה הרבה יותר קט‪.‬‬
‫‪-427-‬‬
‫מטרת הבעיה ופתרונה‪ :‬שימוש במער לצור תיאור מבנה‪ ,‬ושימוש בביטוי חשבוני כמציי של איבר‪.‬‬
‫נתאר משחק על לוח הכולל שורה של שלושי משבצות אשר בחלק מצויי מוקשי‪ .‬המשבצות‬
‫ממוספרות מ‪ 1#‬עד ‪.30‬‬
‫שחק מתקד לאור הלוח על ידי הטלת קובייה‪ ,‬שעל פיאותיה הספרות ‪ 1‬עד ‪ .6‬א המספר‬
‫המתקבל מהטלת הקובייה מוביל למשבצת שיש בה מוקש‪ ,‬השחק נשאר במקומו‪ .‬א המספר‬
‫המתקבל מהטלת הקובייה מוביל למשבצת פנויה השחק יכול להתקד‪.‬‬
‫פתחו אלגורית אשר הקלט שלו הוא תיאור הלוח‪ ,‬נתו על ידי שלושי תווי שערכיה '‪) 'T‬עבור‬
‫משבצת פנויה( או '‪) 'F‬עבור מוקש(‪ ,‬ואחריו מספר המציי את מספר המשבצת עליה מוצב השחק‪.‬‬
‫פלט האלגורית הוא הטלות הקובייה אשר עבור יוכל השחק להתקד‪ .‬הניחו שהשחק מוצב על‬
‫משבצת שמספרה בי ‪ 1‬ל‪ .24#‬ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫נתבונ בלוח הבא‪ ,‬כאשר הסימו ☺ מציי את מיקו השחק והסימו ☼ מציי מוקש‪:‬‬
‫☼‬
‫……‬
‫☼‬
‫☼‬
‫☼‬
‫☺‬
‫בלוח זה‪ ,‬השחק יכול לקד את הכלי עבור כל אחת מ ההטלות‪ 5 ,3 ,1 :‬או ‪ ,6‬א לא יוכל לקד‬
‫אותו עבור ההטלות ‪ 2‬או ‪.4‬‬
‫הנה חלוקה ראשונית של פתרו הבעיה לתת‪#‬משימות‪:‬‬
‫‪ .1‬קליטה ושמירה של מצב הלוח ומקום השחקן על הלוח‬
‫‪ .2‬חישוב הטלות הקובייה המותרות להתקדמות והצגתן כפלט‬
‫את לוח המשחק נתאר על ידי מער של ערכי בוליאניי בגודל ‪ ,30‬שמצייני איבריו נעי בי ‪ 0‬ל‪.29#‬‬
‫כל איבר במער ישמור את מצב המשבצת המתאימה בלוח‪ .‬הער ‪ true‬יתאר משבצת פנויה‪ ,‬ואילו‬
‫הער ‪ false‬יתאר מוקש‪ .‬בנוס נזדקק למשתנה שיציי את מיקו השחק על הלוח‪.‬‬
‫א כ‪ ,‬אלה יהיו המשתני בה נשתמש‪:‬‬
‫‪ – board‬מער של ‪ 30‬איברי מטיפוס בוליאני‬
‫‪ – pawn‬מטיפוס של‪ ,‬לשמירת מיקו השחק על הלוח‬
‫‪-428-‬‬
‫למשל‪ ,‬עבור הדוגמה שלעיל‪ ,‬המער ‪ board‬ייראה כ‪:‬‬
‫]‪[28] [29‬‬
‫‪true‬‬
‫]‪[27‬‬
‫‪false true‬‬
‫…‬
‫]‪[10‬‬
‫]‪[9‬‬
‫]‪[8‬‬
‫]‪[7‬‬
‫]‪[6‬‬
‫]‪[5‬‬
‫]‪[4‬‬
‫]‪[3‬‬
‫]‪[2‬‬
‫]‪[1‬‬
‫]‪[0‬‬
‫… ‪true true true false true false true true true true false‬‬
‫והמשתנה ‪ pawn‬יכיל את הער ‪) 1‬כיוו שהשחק נמצא על המשבצת השנייה(‪.‬‬
‫ההתייחסות לאיברי המער היא בעזרת מציי‪ ,‬למשל‪ ,‬הער בתא ]‪ board[pawn‬מבטא את מצב‬
‫המשבצת בה נמצא השחק‪.‬‬
‫שימו ♥‪ :‬אמנ‪ ,‬לוח המשחק ממוספר מ‪ 1#‬עד ‪ ,30‬אבל המער המתאר אותו ממוספר מ‪ 0#‬עד ‪.29‬‬
‫לכ‪ ,‬ערכי המשתנה ‪ pawn‬יהיו בתחו ‪ 0‬עד ‪.29‬‬
‫?‬
‫כיצד נשתמש במער ‪ board‬כדי לחשב את ההטלות שעבור יוכל השחק להתקד?‬
‫כדי לחשב את ההטלות שעבור יוכל השחק להתקד יש לבדוק את מצב של שש המשבצות‬
‫העוקבות למשבצת בה נמצא השחק‪ .‬כיוו שהמשבצת בה נמצא השחק מתוארת על ידי האיבר‬
‫]‪ board[pawn‬במער‪ ,‬שש המשבצות העוקבות מיוצגות על ידי ששת האיברי הבאי לפי הסדר‪:‬‬
‫]‪.board[pawn+6] , ... ,board[pawn+2] ,board[pawn+1‬‬
‫עבור כל איבר מששת האיברי האלה יש לבדוק א הוא מייצג משבצת פנויה )כלומר‪ ,‬ערכו הוא‬
‫‪ .(true‬א כ‪ ,‬יש להציג כפלט את הטלת הקובייה אשר מביאה אליו את השחק‪.‬‬
‫למשל‪ ,‬א ערכו של ]‪ board[pawn+3‬מבטא משבצת פנויה‪ ,‬יוצג ‪ 3‬כפלט‪ ,‬כיוו שהטלת ‪ 3‬בקובייה‬
‫מביאה את השחק למשבצת פנויה‪.‬‬
‫‪.1‬‬
‫‪:òöá êøòîä ìãåâ ãò 0-î íìù i ìë øåáò‬‬
‫‪çåìä ìù i-ä úöáùîä áöî úà èåì÷ .1.1‬‬
‫‪ï÷çùä íå÷éî úà èåì÷ .2‬‬
‫‪.3‬‬
‫‪:òöá 6 ãò 1-î íìù i ìë øåáò‬‬
‫‪.3.1‬‬
‫‪íà‬‬
‫‪ä÷éø ï÷çùä íå÷éîî i ÷çøîá úöáùîä‬‬
‫‪i ìù åëøò úà èìôë âöä .3.1.1‬‬
‫‪-429-‬‬
/*
-‫ ל‬1 ‫ משבצות ומיקום משבצת עליה מוצב שחקן )בין‬30 ‫ תיאור לוח משחק בן‬:‫קלט‬
(24
‫ הטלות קובייה אשר מביאות את השחקן למשבצת פנויה‬:‫פלט‬
*/
public class MineBoardGame
{
{
// ‫הגדרת קבוע‬
final int BOARD_SIZE = 30;
boolean[] board = new boolean[BOARD_SIZE];
char cellStatus;
int pawn;
// ‫קלט הלוח‬
System.out.println("Insert the board details: Insert F for a
cell with a mine, and T for a free cell");
for (int i = 0; i < board.length; i++)
{
cellStatus = In.readChar("Insert status of cell number " +
(i+1));
board[i] = (cellStatus == 'T');
}
// ‫קלט מיקום השחקן והתאמתו לאופן שמירת הלוח‬
pawn = In.readInt("Insert the pawn place:");
pawn = pawn - 1;
// ‫פלט‬
System.out.println("The rolls that lead to an empty place are:
");
for (int i = 1; i <= 6; i++)
{
if (board[pawn + i])
{
-430-
‫‪} // if‬‬
‫‪} // for‬‬
‫‪}// main‬‬
‫‪} //class MineBoardGame‬‬
‫שימו ♥‪ :‬בלולאה הראשונה השתמשנו במציי ‪ i‬כדי לעדכ את מצב המשבצת התורנית בלוח‪ .‬על‬
‫מנת להודיע למשתמש את מספר המשבצת שאת מצבה עליו להזי השתמשנו בביטוי ‪,i + 1‬‬
‫שמתאי בי מצייני המער )הנעי בי ‪ 0‬ל‪ (29#‬לאופ הספירה של הלוח )מ‪ 1#‬עד ‪ .(30‬למשל‪ ,‬בסיבוב‬
‫הראשו של הלולאה‪ ,‬כאשר ערכו של ‪ i‬הוא ‪ ,0‬מוצגת ההודעה‬
‫‪Insert status of cell number 1‬‬
‫בלולאה השנייה השתמשנו כמציי בביטוי ‪ .pawn + i‬הביטוי ‪ pawn + i‬מבטא מקו במער‬
‫שמרחקו מהמקו ‪ pawn‬הוא ‪.i‬‬
‫?‬
‫לאחר קליטת מקו השחק‪ ,‬מדוע מוש במשתנה ‪ pawn‬הער הנקלט רק לאחר הקטנתו ב‪?1#‬‬
‫המשתמש בתכנית יזי את מיקו השחק על הלוח כמספר של בי ‪ 1‬ל‪ .30#‬לעומת זאת‪ ,‬ערכי‬
‫המשתנה ‪ pawn‬צריכי להתאי לאופ מספור המער‪ ,‬מ‪ 0#‬עד ‪.29‬‬
‫שאלה ‪10.15‬‬
‫בנו טבלת מעקב אחר מהל ביצוע התכנית ‪ MineBoardGame‬לפתרו בעיה ‪ 3‬עבור הקלט‪:‬‬
‫‪TTFFTFTFT ...T2‬‬
‫כלומר‪ ,‬יש מוקש במשבצת השלישית והרביעית‪ ,‬ומהמשבצת השישית ואיל‪ ,‬יש מוקש בכל משבצת‬
‫זוגית‪ .‬השחק נמצא במשבצת השנייה‪.‬‬
‫מהו הפלט המתקבל?‬
‫שאלה ‪10.16‬‬
‫הרחיבו את האלגורית לפתרו בעיה ‪ 3‬כ שיציג כפלט לא רק את ההטלות שמאפשרות לשחק‬
‫להתקד‪ ,‬אלא ג את המשבצות אליה הטלות אלו מובילות‪ .‬למשל‪ ,‬עבור הקלט שבשאלה הקודמת‬
‫יכלול הפלט החדש ג את הרשימה‪7 :‬‬
‫‪.5‬‬
‫שאלה ‪10.17‬‬
‫נניח שנכתבו משפטי ההצהרה הבאי‪:‬‬
‫;‪int position‬‬
‫;‪int counter = 0‬‬
‫‪-431-‬‬
‫לאיברי המער ‪ arr‬הושמו ערכי‪ ,‬ולמשתנה ‪ position‬נקלט ער חיובי של בתחו ‪ 1‬עד ‪.79‬‬
‫א‪ .‬תארו את מטרת קטע התוכנית הבא‪:‬‬
‫) ]‪if (arr[position] == arr[position - 1‬‬
‫{‬
‫;)"‪System.out.println("previous one is equal‬‬
‫}‬
‫) ]‪if (arr[position] == arr[position + 1‬‬
‫{‬
‫;)"‪System.out.println("next one is equal‬‬
‫}‬
‫ב‪ .‬תארו את מטרת קטע התוכנית הבא‪:‬‬
‫)‪for (int i = 0; i < 10; i++‬‬
‫{‬
‫) ]‪if (arr[position] == arr[position + i‬‬
‫{‬
‫;‪counter = counter + 1‬‬
‫}‬
‫}‬
‫;)‪System.out.println(counter‬‬
‫ג‪ .‬כתבו לולאה שמטרתה הצגה כפלט של מצייניה של איברי המער‪ ,‬מבי ‪ 20‬האיברי העוקבי‬
‫ל‪ , arr[position]#‬אשר ערכ גדול מערכו של ]‪.arr[position‬‬
‫ד‪ .‬כתבו לולאה שמטרתה הצגה כפלט של מצייניה של איברי המער‪ ,‬מבי ‪ 20‬האיברי העוקבי‬
‫ל‪ , arr[position]#‬אשר ערכ גדול בדיוק ב‪ 1‬מערכו של ]‪. arr[position‬‬
‫שאלה ‪10.18‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא רצ של ‪ 20‬תווי‪ ,‬והפלט שלו הוא מספר הזוגות של‬
‫תווי עוקבי ששווי לזוג התווי האחרו‪.‬‬
‫למשל‪ ,‬עבור הקלט ‪ abcabacadcababddaaab‬הפלט הוא ‪ 4‬כיוו שהזוג האחרו הוא ‪ ,ab‬ויש עוד‬
‫ארבעה זוגות השווי ל‪.ab#‬‬
‫שימו ♥‪ :‬עבור קלט של ‪ 20‬תווי זהי הפלט צרי להיות ‪) 19‬כיוו שכל הזוגות‪ ,‬מהראשו ועד הזוג‬
‫הלפני אחרו‪ ,‬שווי לזוג האחרו(‪.‬‬
‫‪-432-‬‬
‫שאלה ‪10.19‬‬
‫במשחק נתו לוח הכולל שורה של ‪ 25‬משבצות אשר בכל אחת מה רשו מספר של בי ‪ 0‬ל‪ .5#‬על‬
‫הלוח מוצב שחק בי המשבצות העשירית והחמש‪#‬עשרה‪.‬‬
‫השחק מטיל קובייה כדי לנסות ולהתקד על הלוח‪ .‬א המספר המתקבל בהטלת הקובייה מוביל‬
‫למשבצת אשר המספר הרשו בה קט או שווה למספר המתקבל בקובייה‪ ,‬השחק מקד את הכלי‬
‫למשבצת זו‪ .‬אחרת‪ ,‬השחק נסוג אחורה מספר משבצות השווה למספר המתקבל בקובייה‪.‬‬
‫פתחו אלגורית אשר הקלט שלו הוא תיאור הלוח‪ ,‬נתו על‪#‬ידי ‪ 25‬מספרי )שערכיה נעי בי ‪ 0‬ל‪#‬‬
‫‪ ,(5‬ואחריו מקו השחק על הלוח וערכה של הטלת הקובייה‪ .‬הפלט שלו הוא מקומו החדש של‬
‫השחק על הלוח‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שימו ♥‪ :‬יש להתאי בי מיקו המשבצת כפי שנקלוט )בי ‪ 1‬ל‪ (25#‬לבי מציי המער‪ ,‬בי ‪ 0‬ל‪.24#‬‬
‫שאלה ‪10.20‬‬
‫מה יהיה פלט קטע התוכנית הבא?‬
‫)‪for (int i = 0; i < arr.length / 2; i++‬‬
‫{‬
‫;‪arr[i * 2] = i‬‬
‫}‬
‫שאלה ‪10.21‬‬
‫המער ‪ arr‬הוא מער מאור ‪ 10‬המכיל מספרי שלמי‪ .‬תארו מה יהיה הפלט של קטע התוכנית‬
‫הבא‪.‬‬
‫)‪for (int i = 0; i < arr.length; i++‬‬
‫{‬
‫;]‪arr[i] = arr[arr.length - i‬‬
‫}‬
‫שאלה ‪10.22‬‬
‫א‪ .‬המער ‪ arr‬הוא מער מאור ‪ 10‬המכיל מספרי שלמי‪ .‬תארו מה יהיה הפלט של קטע התוכנית‬
‫הבא‪.‬‬
‫)‪for (int i = 0; i < arr.length - 1; i++‬‬
‫{‬
‫;]‪arr[i + 1] = arr[i‬‬
‫}‬
‫‪-433-‬‬
‫ב‪ .‬תקנו את קטע התוכנית כ שיבצע הזזה של ערכי התאי במער בצורה מעגלית‪ ,‬כלומר‪ ,‬התא השני‬
‫יכיל את ערכו המקורי של התא הראשו‪ ,‬התא השלישי יכיל את ערכו המקורי של התא השני‪ ,‬וכ‬
‫הלאה‪ ,‬והתא הראשו – יכיל את ערכו המקורי של התא האחרו‪.‬‬
‫שאלה ‪10.23‬‬
‫א‪ .‬חברי קבוצת "סיורי הגליל" הולכי תמיד בטור‪ ,‬זה אחר זה‪ .‬לאחר עשרי דקות הליכה‪ ,‬הראשו‬
‫בטור נעצר וממתי עד שהטור כולו עובר אותו‪ ,‬ואז מצטר לטור שוב כאחרו‪ .‬פתחו אלגורית‬
‫המקבל כקלט את מספר חברי הקבוצה‪ ,‬ולאחר מכ את רשימת השמות של חברי הקבוצה‪ ,‬על פי‬
‫הסדר בו ה מתחילי את הטיול‪ .‬פלט האלגורית יהיה סדר חברי הקבוצה לאחר שעה ורבע של‬
‫הליכה‪ .‬ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫ב‪ .‬חברי קבוצת "סיורי הגליל למתחילי" הולכי תמיד בטור‪ ,‬כאשר ראשו נמצא המדרי‪ ,‬ובסו‬
‫נמצאי החובש‪ ,‬המלווה והמאס ‪ .‬בקדמת הטור צועדות הבנות ואחריה צועדי הבני‪ .‬רק‬
‫הבני מחליפי מקומותיה כל עשרי דקות כפי שתואר עבור קבוצת "סיורי הגליל"‪.‬‬
‫פתחו אלגורית המקבל כקלט את מספר הבני ומספר הבנות בקבוצה‪ ,‬ורשימה של שמות חברי‬
‫הקבוצה‪ ,‬על פי הסדר בו ה מתחילי את הטיול‪ .‬פלט האלגורית יהיה סדר חברי הקבוצה לאחר‬
‫שעה ורבע של הליכה‪ .‬ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫שאלה ‪10.24‬‬
‫פתחו אלגורית המקבל כקלט סדרת מספרי בסדר עולה‪ ,‬ולאחר קליטתה מסדר ושומר את הסדרה‬
‫הנתונה בסדר יורד‪ .‬ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫‪ 10.2‬חריגה מגבולות מערך‬
‫?‬
‫בהגדרת בעיה ‪ 3‬נכללה הנחה כי השחק מוצב על משבצת שמספרה בי ‪ 1‬ל‪ .24 #‬מדוע הנחה זו‬
‫חשובה?‬
‫נניח כי השחק עומד על משבצת שערכה גבוה מהמספר ‪ ,24‬למשל‪ .25 ,‬הטלת הקובייה נותנת מספר‬
‫כלשהו בי ‪ 1‬ל‪ .6#‬א הטלת הקובייה תית את המספר ‪ ,6‬השחק ינסה לנוע ‪ 6‬צעדי קדימה‪ ,‬החל‬
‫מהמשבצת ה‪ .25#‬כ יגיע השחק למשבצת מספר ‪ .31‬א משבצת זו אינה קיימת ואינה חוקית בתנאי‬
‫המשחק!‬
‫ניסיו להתייחס במהל ביצוע תוכנית בשפת ‪ ,Java‬לתא שאיננו קיי במער )למשל ]‪,(board[30‬‬
‫יגרו להפסקת פעולתה של התוכנית‪ ,‬ולהצגת הודעת שגיאה על חריגה מגבולות המער‪ .‬חריגה‬
‫מגבולות המער היא שגיאת ריצה‪ ,‬המתגלה בזמ ביצוע התוכנית ולא בזמ ההידור‪.‬‬
‫‪-434-‬‬
‫שאלה ‪10.25‬‬
‫נוסי לפתרו בעיה ‪ 3‬משתנה בש ‪ ,limit‬מטיפוס של‪ ,‬אשר ישמש כער סופי למשתנה הבקרה‬
‫של הלולאה השנייה )לולאת הצגת הפלט(‪.‬‬
‫נשתמש ב‪ limit#‬כדי להרחיב את משפטי התוכנית ‪) MineBoardGame‬לפתרו בעיה ‪ ,(3‬כ‬
‫‪i‬‬
‫שהתוכנית תאפשר לקלוט עבור מיקו השחק ער בי ‪ 1‬ל‪) 29#‬במקו ‪ 24‬כמו בבעיה המקורית(‪,‬‬
‫ובכל זאת בלולאה השנייה לא תהיה חריגה מגבולות המער‪.‬‬
‫לפני הלולאה השנייה נוסי הוראה לביצוע בתנאי‪:‬‬
‫)_______________( ‪if‬‬
‫_______________‬
‫‪else‬‬
‫_______________‬
‫וכותרת הלולאה השנייה תהיה‪:‬‬
‫)‪for (int i = 1; i <= limit; i++‬‬
‫השלימו את ההוראה לביצוע בתנאי‪ ,‬כ שהתוכנית תבצע את הדרוש‪.‬‬
‫שאלה ‪10.26‬‬
‫נתו המער ‪ arr‬שהצהרתו היא‪:‬‬
‫וערכי איבריו ה‪:‬‬
‫]‪arr[7‬‬
‫]‪arr[6‬‬
‫]‪arr[5‬‬
‫]‪arr[4‬‬
‫]‪arr[3‬‬
‫]‪arr[2‬‬
‫]‪arr[1‬‬
‫]‪arr[0‬‬
‫‪7‬‬
‫‪6‬‬
‫‪7‬‬
‫‪5‬‬
‫‪40‬‬
‫‪30‬‬
‫‪20‬‬
‫‪10‬‬
‫א‪ .‬מה יהיה פלט הלולאה הבאה?‬
‫)‪for (int i = 0; i < arr.length - 1; i++‬‬
‫{‬
‫)]‪if (i == arr[i] || i == arr[i + 1‬‬
‫{‬
‫}‬
‫}‬
‫‪-435-‬‬
?‫ מה יהיו ערכי המער אחרי ביצוע הלולאה הבאה‬.‫ב‬
for (int i = 0; i < arr.length; i++)
{
if (arr[i] == (10 * i))
{
arr[i] = arr[i] + 1;
}
else
{
arr[i] = arr[i] - 1;
}
}
?‫ עבור אילו מארבעת הלולאות הבאות תהיה חריגה מגבולות המער‬.‫ג‬
.1
for (int i = 0; i < arr.length; i++)
{
arr[i] = arr[i + 1];
}
.2
for (int i = 0; i < arr.length - 1; i++)
{
arr[i] = arr[i - 1];
}
.3
{
arr[i] = arr[i] * 2;
}
.4
{
arr[i] = arr[i * 2];
}
-436-
‫שאלה ‪10.27‬‬
‫השאלה מתייחסת למער ‪ arr‬ב ‪ 8‬האיברי שהוגדר בשאלה הקודמת‪.‬‬
‫כתבו הוראה לביצוע חוזר אשר בה יושוו ערכיה של כל זוג איברי שכני במער )]‪ arr[0‬ע‬
‫]‪ arr[1] ,arr[1‬ע ]‪ arr[6] , ... ,arr[2‬ע ]‪ ,(arr[7‬ויחושב מספר זוגות האיברי השכני‬
‫שערכיה שווי זה לזה‪.‬‬
‫שימו ♥‪ :‬לא לחרוג מגבולות המער‪.‬‬
‫שאלה ‪10.28‬‬
‫על אלי הוטל לכתוב תוכנית המגדירה מער ב ‪ 50‬תאי‪ ,‬ומציבה בה את הערכי‬
‫… ‪0.5 1 1.5 2 2.5 3 3.5‬‬
‫אלי כתבה‪:‬‬
‫;]‪double arr[] = new int[50‬‬
‫)‪for (int i = 0; i < arr.length * 2; i++‬‬
‫{‬
‫;‪arr[i] = i/2‬‬
‫}‬
‫הא קטע התוכנית נכו? א איננו נכו – תקנו את השגיאות כ שתושג המטרה המבוקשת‪.‬‬
‫שאלה ‪) 10.29‬מבגרות קי" ‪(2002‬‬
‫לפניכ קטע תוכנית‪:‬‬
‫)‪for (int i = 0; i < n - 2; i++‬‬
‫{‬
‫)]‪if (a[i] + 2 == a[i + 2‬‬
‫{‬
‫;)]‪System.out.println(i + " " + a[i‬‬
‫}‬
‫}‬
‫‪ a‬הוא המער הבא בגודל ‪:10‬‬
‫‪9‬‬
‫‪1‬‬
‫‪6‬‬
‫‪5‬‬
‫‪4‬‬
‫‪2‬‬
‫‪20‬‬
‫‪5‬‬
‫‪18‬‬
‫‪3‬‬
‫‪a:‬‬
‫א‪ .‬עקבו בעזרת טבלת מעקב אחר קטע התוכנית עבור ‪ n=10‬ועבור המער ‪ a‬הנתו‪ ,‬ורשמו מה יהיה‬
‫הפלט‪.‬‬
‫ב‪ .‬הסבירו מדוע קבע כותב קטע התוכנית שהגבול העליו של הלולאה יהיה ‪ n - 2‬ולא ‪.n‬‬
‫‪-437-‬‬
‫‪ 10.3‬קשרים בין מערכים‬
‫בדוגמאות שראינו עד כה השתמשנו במער יחיד‪ .‬לעיתי פתרו בעיה מצרי יותר ממער אחד‪.‬‬
‫בסעי זה נראה פתרונות אלגוריתמיי המשתמשי ביותר ממער אחד‪ .‬בחלקו הראשו של הסעי‬
‫נציג עיבוד של כמה מערכי במקביל‪ ,‬בקצב זהה‪ ,‬ובחלקו השני נעסוק ג בעיבוד של כמה מערכי‪,‬‬
‫שאינו נעשה באותו קצב התקדמות‪.‬‬
‫עיבוד מערכים במקביל ובקצב זהה‬
‫השאלה הבאה עוסקת בניתוח קטע תוכנית המעבד במקביל שני מערכי‪ ,‬ופתרו השאלה שאחריה‬
‫מצרי שימוש בשלושה מערכי‪.‬‬
‫שאלה ‪10.30‬‬
‫‪ m1‬ו‪ m2#‬ה שני מערכי שהוצהרו באופ הבא‪:‬‬
‫;‪final int SIZE = 10‬‬
‫;]‪int m1[] = new int[SIZE‬‬
‫;]‪int m2[] = new int[SIZE‬‬
‫נתוני שני קטעי התוכניות הבאי אשר אמורי להציג כפלט הא שני המערכי מכילי בדיוק את‬
‫אות איברי‪ ,‬באותו סדר‪.‬‬
‫‪II‬‬
‫‪I‬‬
‫;‪boolean compare = false‬‬
‫;‪boolean compare = false‬‬
‫)‪for (int i = 0; i < SIZE; i++‬‬
‫)‪for (int i = 0; i < SIZE; i++‬‬
‫{‬
‫{‬
‫)]‪if (m1[i] == m2[i‬‬
‫)]‪compare = (m1[i] == m2[i‬‬
‫{‬
‫‪} // for‬‬
‫‪compare = true‬‬
‫)‪if (compare‬‬
‫‪} // if‬‬
‫{‬
‫‪} // for‬‬
‫)‪if (compare‬‬
‫{‬
‫‪System.out.println("The arrays‬‬
‫;)"‪are equal‬‬
‫}‬
‫;)"‪are equal‬‬
‫‪else‬‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪are not equal‬‬
‫}‬
‫;)"‪are not equal‬‬
‫}‬
‫‪-438-‬‬
‫שני קטעי התוכניות שגויי‪ .‬ענו על הסעיפי הבאי ביחס לכל אחד מהקטעי‪:‬‬
‫א‪ .‬הביאו דוגמה לערכי של איברי שני המערכי עבור קטע התוכנית משיג את מטרתו‪.‬‬
‫ב‪ .‬הביאו דוגמה לערכי של איברי שני המערכי עבור קטע התוכנית אינו משיג את מטרתו‪,‬‬
‫והסבירו מדוע זה קורה‪.‬‬
‫ג‪ .‬תקנו את קטע התוכנית כ שישיג את מטרתו‪.‬‬
‫שאלה ‪10.31‬‬
‫כיתה י'‪ 5‬ניגשה למבח‪ .‬לאחר המבח הוחלט כי הכיתה כולה תיגש למבח נוס ‪ ,‬והציו הגבוה מבי‬
‫שני ציוני המבחני יהיה הציו הקובע‪.‬‬
‫פתחו אלגורית הקולט את מספר התלמידי בכיתה‪ ,‬ולאחר מכ קולט את ציוני המבח הראשו‬
‫למער ‪ arr‬ואת ציוני המבח השני למער ‪ .brr‬האלגורית ימלא מער ‪ crr‬כ שיכיל את הציו הקובע‬
‫לכל אחד מתלמידי הכיתה‪ ,‬ויציג כפלט עבור כל אחד מהתלמידי את ציו המבח הראשו‪ ,‬ציו‬
‫המבח השני והציו הקובע‪ ,‬בליווי הודעות מתאימות‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫עיבוד מערכים במקביל‪ ,‬בקצב לא זהה‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת עיבוד של כמה מערכי במקביל‪ ,‬בקצב לא זהה‪.‬‬
‫פתחו אלגורית המקבל כקלט מספר חיובי של ‪ ,num‬ולאחר מכ קורא מהקלט ‪ num‬מספרי‬
‫שלמי לתו מער ‪ .arr‬האלגורית מעתיק מהמער ‪ arr‬את המספרי החיוביי למער ‪ brr‬ואת‬
‫המספרי השליליי למער ‪ ,crr‬תו שמירה על סדר המספרי‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫נניח כי הקלט הוא ‪.6 1 -2 3 4 -2‬‬
‫המער ‪ arr‬ישמור בתוכו ‪ 6‬מספרי שלמי‪ .‬בעקבות ההעתקה הדרושה יכיל המער ‪ brr‬שלושה‬
‫איברי‪ 3 ,1 :‬ו‪ .4#‬המער ‪ crr‬יכיל שני איברי‪ -1 :‬ו‪.-2#‬‬
‫אנו רואי כי לא רק שלכל מער מועתק מספר שונה של איברי‪ ,‬אלא שקצב ההתקדמות על‬
‫המערכי הללו שונה‪ :‬ייתכ כי נסרוק כמה איברי במער ‪ ,arr‬א לא נתקד כלל באחד המערכי‬
‫אליה מתבצעת ההעתקה‪ .‬למשל‪ ,‬בדוגמת הקלט שלעיל‪ ,‬בזמ שבמער ‪ arr‬נסרקי האיברי‬
‫השלישי והרביעי‪ ,‬בזה אחר זה‪ ,‬אי כלל התקדמות במילוי המער ‪.crr‬‬
‫‪-439-‬‬
‫‪ .1‬קליטת מספר הערכים לעיבוד‬
‫‪ .2‬קליטת רשימת הערכים ושמירתה במערך ‪arr‬‬
‫‪ .3‬ביצוע במקביל של סריקת המערך ‪ arr‬ומילוי המערכים ‪ brr‬ו‪crr-‬‬
‫כדי לסרוק את המערכי בקצב לא זהה‪ ,‬עלינו לשמור שלושה מצייני שוני‪ ,‬אחד עבור כל מער‪:‬‬
‫המציי של המער ‪ arr‬יסרוק את איברי המער בזה אחר זה‪ .‬המציי של מער ‪ brr‬והמציי של‬
‫המער ‪ crr‬יצביעו בכל רגע על המקו הפנוי הבא במער המתאי‪ ,‬כדי שהעתקת האיבר הבא תתבצע‬
‫במקו הנכו‪.‬‬
‫המציי של המער ‪ arr‬יקוד ב‪ 1#‬בכל פע שנסיי עיבוד של איבר תור במער ונתקד לאיבר‬
‫האיבר הבא‪.‬‬
‫כל אחד מהמצייני האחרי‪ ,‬של המער ‪ brr‬ושל המער ‪ ,crr‬יקוד ב‪ 1#‬רק אחרי ביצוע העתקה‬
‫למער אליו הוא מתייחס‪.‬‬
‫‪ – size‬מספר הערכי לעיבוד‬
‫‪ – arr‬מער מטיפוס של‪ ,‬בגודל ‪size‬‬
‫‪ – brr‬מער מטיפוס של‪ ,‬בגודל ‪size‬‬
‫‪ – crr‬מער מטיפוס של‪ ,‬בגודל ‪size‬‬
‫‪ – indexArr‬מטיפוס של‪ ,‬יציי את מיקו האיבר התור במער ‪arr‬‬
‫‪ – indexBrr‬מטיפוס של‪ ,‬יציי את המקו הפנוי הבא במער ‪brr‬‬
‫‪ # indexCrr‬מטיפוס של‪ ,‬יציי את המקו הפנוי הבא במער ‪crr‬‬
‫‪size-ì íìù éáåéç êøò èåì÷ .1‬‬
‫‪.2‬‬
‫‪:òöá size -1 ãò 0-î íìù i ìë øåáò‬‬
‫‪arr[i] ì ïåúð èåì÷ .2.1‬‬
‫‪0-ì indexBrr úà ìçúà .3‬‬
‫‪0-ì indexCrr úà ìçúà .4‬‬
‫‪.5‬‬
‫‪:òöá size -1 ãò 0-î íìù indexArr ìë øåáò‬‬
‫‪-440-‬‬
‫‪íà .5.1‬‬
‫‪arr[indexArr]>0‬‬
‫‪brr[indexBrr]-ì arr[indexArr] ìù åëøò úà ÷úòä .5.1.1‬‬
‫‪1-á indexBrr ìù åëøò úà ìãâä .5.1.2‬‬
‫‪úøçà .5.2‬‬
‫‪crr[indexCrr]-ì arr[indexArr] ìù åëøò úà ÷úòä .5.2.1‬‬
‫‪1-á indexCrr ìù åëøò úà ìãâä .5.2.2‬‬
‫שאלה ‪10.32‬‬
‫ישמו את האלגורית לפתרו בעיה ‪ 4‬בשפת ‪.Java‬‬
‫שאלה ‪10.33‬‬
‫פתחו אלגורית אשר מקבל כקלט מספר חיובי של‪ ,‬ולאחר מכ קולט רשימת מספרי שאורכה‬
‫כער הנתו הראשו‪ .‬האלגורית ישמור את המספרי הנקלטי בשני מערכי שוני‪ ,‬מער אחד‬
‫עבור מספרי זוגיי‪ ,‬ומער שני עבור מספרי אי‪#‬זוגיי‪ .‬האלגורית יציג כפלט את כל הערכי‬
‫שברשימה‪ :‬ראשית את כל המספרי הזוגיי‪ ,‬על פי סדר קליטת‪ ,‬ואחר‪#‬כ את כל המספרי האי‪#‬‬
‫זוגיי‪ ,‬על פי סדר קליטת‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪10.34‬‬
‫נניח ש‪ arr1#‬ו‪ arr2#‬ה שני מערכי מטיפוס של‪ ,‬שאורכ אינו בהכרח שווה‪ .‬כתבו קטע תוכנית‬
‫אשר מעתיק למער שלישי ‪ ,arr3‬רק את האיברי אשר נמצאי ג ב‪ arr1#‬וג ב‪.arr2#‬‬
‫למשל‪ ,‬א ב‪ arr1#‬וב‪ arr2#‬נמצאי הערכי הבאי‪:‬‬
‫‪4‬‬
‫‪3‬‬
‫‪11‬‬
‫‪73‬‬
‫‪9‬‬
‫‪8‬‬
‫‪36‬‬
‫‪arr1‬‬
‫‪12‬‬
‫‪8‬‬
‫‪8‬‬
‫‪77‬‬
‫‪4‬‬
‫‪arr2‬‬
‫אז ב‪ arr3#‬יהיו הערכי הבאי‪:‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪8‬‬
‫‪4‬‬
‫‪arr3‬‬
‫הדרכה‪ :‬יש להשתמש בקינו של הוראות לביצוע חוזר‪.‬‬
‫‪-441-‬‬
‫‪ 10.4‬מערך מונים‬
‫בפרק ‪ 7‬למדנו על משתנה מסוג מונה‪ .‬למדנו כי מונה הוא משתנה אשר תפקידו למנות מספר של‬
‫אירועי שמתרחשי )כמו למשל‪ ,‬הופעות של נתוני או מספר חישובי מבוצעי(‪ .‬כיוו שהשימוש‬
‫במונה הוא לצור ספירה‪ ,‬מונה הוא משתנה מטיפוס של‪ .‬לעיתי יש לתחזק במקביל כמה מוני‪,‬‬
‫בעלי תכונות דומות‪ .‬לש כ נית להשתמש במער של מוני‪ ,‬כפי שמדגימה הבעיה הבאה‪ .‬העבודה‬
‫ע מער מוני היא תבנית שימושית לפתרו בעיות אלגוריתמיות‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת מער מוני ושימוש בו‬
‫בתוכנית "כוכב נולד" יש ‪ N‬מועמדי‪ ,‬ולכל מועמד מספר סידורי בי ‪ 1‬ל‪ .N#‬הצופי בבית נתבקשו‬
‫לבחור את אחד המועמדי ולהצביע עבורו‪ .‬בכל תוכנית המועמד שמקבל את מספר הקולות הקט‬
‫ביותר עוזב את התוכנית‪ .‬פתחו אלגורית אשר מקבל כקלט את מספר המועמדי )מספר חיובי‬
‫של(‪ ,‬ואחר כ קולט רשימה של הצבעות של הצופי‪ ,‬המסתיימת במספר ‪ .-1‬האלגורית מודיע‬
‫כפלט מי המועמד אשר קיבל את מספר הקולות הקט ביותר‪ .‬ישמו את האלגורית בשפת התכנות‬
‫‪.Java‬‬
‫‪ .1‬קליטת מספר מועמדים‬
‫‪ .2‬קליטת הצבעות למועמדים תוך מניה של ההצבעות עבור כל מועמד‬
‫‪ .3‬מציאת המונה בעל הערך המינימלי והצגה כפלט של המועמד אליו הוא מתאים‬
‫כדי לבצע את תת‪#‬משימה ‪ 2‬עלינו לתחזק במקביל כמה מוני‪ ,‬מונה לכל מועמד‪ .‬כלומר‪ ,‬מספר‬
‫המוני שווה למספר המועמדי‪ .‬כמוב שאי אנו יכולי להצהיר על מונה נפרד לכל מועמד‪ :‬מספר‬
‫המועמדי כלל אינו ידוע מראש‪ ,‬ואפילו א היה ידוע‪ ,‬ייתכ כי הוא גדול למדי‪ .‬בכל מקרה‪ ,‬הצהרה‬
‫על מונה נפרד לכל מועמד הופכת את התוכנית למסורבלת‪ ,‬קריאה פחות‪ ,‬וקשה יותר לשינוי )למשל‪,‬‬
‫א מספר המועמדי משתנה(‪.‬‬
‫לכ‪ ,‬נשמור את המוני כמער שאורכו כמספר המועמדי‪.‬‬
‫נזדקק למשתני הבאי‪:‬‬
‫‪ – numOfSingers‬מטיפוס של‪ ,‬שומר את מספר המתמודדי בתחרות‬
‫‪ – votes‬מער מטיפוס של‪ ,‬מער מוני‪ ,‬באור ‪ ,numOfSingers‬למניית ההצבעות עבור‬
‫כל מועמד ומועמד‬
‫‪-442-‬‬
‫‪ – vote‬מטיפוס של‪ ,‬שומר הצבעה תורנית מהקלט‬
‫‪ – min‬מטיפוס של‪ ,‬לשמירת ההצבעה המצטברת הנמוכה ביותר‬
‫‪ – minSinger‬מטיפוס של‪ ,‬שומר את מספר המתמודד שקיבל מספר הצבעות נמו ביותר‬
‫לצור ביצוע תת‪#‬משימה ‪ 2‬יש להשתמש בביצוע חוזר‪ ,‬אשר בכל סיבוב בו תיקלט הצבעה נוספת‬
‫מהקלט‪ ,‬ובהתא לערכה יגדל ערכו של המונה המתאי‪ .‬מאחר שמספר ההצבעות אינו ידוע מראש‪,‬‬
‫וסו רשימת ההצבעות מצוי על ידי זקי ‪ ,‬נשתמש בביצוע חוזר בתנאי‪ ,‬המתייחס לזקי ‪.‬‬
‫לצור ביצוע תת‪#‬משימה ‪ 3‬נחפש את האיבר הקט ביותר במער המוני‪.‬‬
‫שימו ♥‪ :‬יש להציג כפלט את מספרו הסידורי של המתמודד שקיבל את מספר הקולות הקט ביותר‪,‬‬
‫ולא את מספר הקולות שקיבל‪ .‬לכ‪ ,‬בעצ‪ ,‬נשתמש בתבנית של מציאת מקו המינימו‪.‬‬
‫‪numOfSingers-á íéããåîúîä øôñî úà èåì÷ .1‬‬
‫‪vote-á ãîòåî øôñî èåì÷ .2‬‬
‫‪ãåò ìë .3‬‬
‫‪vote ≠ -1‬‬
‫‪:òöá‬‬
‫‪vote øôñî ããåîúî ìù (êøòîá) äðåîä úà 1-á äìòä .3.1‬‬
‫‪vote-á ãîòåî øôñî èåì÷ .3.2‬‬
‫‪ïåùàøä ããåîúîä ìù äðåîä êøòì min úà ìçúà .4‬‬
‫‪1-ì minSinger úà ìçúà .5‬‬
‫‪:òöá numOfSingers ãò 2-î íìù i ìë øåáò .6‬‬
‫‪.6.1‬‬
‫‪íà‬‬
‫‪min-î ïè÷ i øôñî ããåîúî ìù äðåîä êøò‬‬
‫‪i øôñî ããåîúî ìù äðåîä êøò úà min-á íùä .6.1.1‬‬
‫‪minSinger-á i úà íùä .6.1.2‬‬
‫‪minSinger êøò úà èìôë âöä .7‬‬
‫חשוב לשי לב כי המספרי הסידוריי של המועמדי מתחילי מ‪ ,1#‬בעוד שמספור איברי המער‬
‫מתחיל מ‪ .0#‬לכ למשל‪ ,‬היישו של הוראה ‪ 3.1‬באלגורית הוא‬
‫;‪votes[vote – 1]++‬‬
‫והיישו של הוראה ‪ 6.1‬הוא‬
‫‪if (votes[i – 1] < min‬‬
‫‪-443-‬‬
/*
‫ מספר המועמדים בתוכנית "כוכב נולד" והצבות הצופים למועמדים‬:‫קלט‬
‫ המספר הסידורי של המתמודד המפסיד‬:‫פלט‬
*/
public class IsraeliIdol
{
{
int numOfSingers;
int[] votes;
int vote;
int min;
int minSinger;
// ‫קליטת מספר מועמדים והקצאת גודל מערך מתאים‬
numOfSingers = In.readInt("Insert number of contestants: ");
votes = new int[numOfSingers];
// ‫קליטת בחירת הצופים בלולאת זקיף‬
vote = In.readInt("Insert a vote, end the list of votes with -1
");
while (vote != -1)
{
// ‫הוספת קול נוסף למונה המתאים‬
votes[vote - 1]++;
vote = In.readInt("Insert a vote, end the list of votes with
-1 ");
}
// ‫אתחול משתני מינימום ומקום המינימום‬
min = votes[0];
minSinger = 1;
// ‫חיפוש ערך מינימלי ושמירת ערכו וערך המציין שלו‬
for(int i = 2; i <= numOfSingers; i++)
{
if (votes[i - 1] < min)
{
min = votes[i - 1];
minSinger = i;
} // if
} // for
// ‫פלט‬
-444-
‫‪System.out.println("contestant number " + minSinger + " is going‬‬
‫;)"‪home‬‬
‫‪} //main‬‬
‫‪} //class IsraeliIdol‬‬
‫שימו ♥‪ :‬כש שיש לאתחל משתנה מסוג מונה לאפס‪ ,‬כ ג יש לאתחל כל איבר ואיבר במער‬
‫מוני ל‪ .0#‬אי אנו מבצעי אתחול כזה במפורש‪ ,‬משו שאנו מסתמכי על כ שבשפת ‪ Java‬איבריו‬
‫של מער מטיפוס מספרי מאותחלי אוטומטית ל‪ ,0#‬מייד אחרי שמוקצה שטח עבור המער‪.‬‬
‫ועוד שימו ♥‪ :‬את תבנית מציאת מקו המינימו נית ג לייש בצורה מעט שונה‪ ,‬הנוחה לעבודה‬
‫ע מערכי‪ .‬למעשה‪ ,‬ביישו זה נשמר רק מקו האיבר המינימלי ולא ערכו‪ ,‬ואנו מסתמכי על כ‬
‫שבמער‪ ,‬קל לברר את ערכו של איבר‪ ,‬כאשר ידוע המציי שלו‪:.‬‬
‫חיפוש ערך מינימלי ושמירת ערך המציין שלו ‪//‬‬
‫)‪for(int i = 2; i <= numOfSingers; i++‬‬
‫{‬
‫)]‪if (votes[i - 1] < votes[minSinger‬‬
‫{‬
‫;‪minSinger = i‬‬
‫‪} // if‬‬
‫‪} // for‬‬
‫;)"‪System.out.println("contestant number " + minSinger + " is going home‬‬
‫להעמקה בתבנית מערך מונים פנו לעמוד ‪.463‬‬
‫שאלה ‪10.35‬‬
‫עקבו אחר התכנית ‪ IsraeliIdol‬בעזרת טבלת מעקב‪ ,‬עבור הקלט ‪4 2 3 1 1 2 4 4 2 -1‬‬
‫)משמאל לימי(‪.‬‬
‫שאלה ‪10.36‬‬
‫בכיתה נערכו הצבעה לנציג הכיתה למועצת תלמידי‪ .‬כל תלמיד הזי למחשב את בחירתו על פי‬
‫המפתח הבא‪ :‬עבור רותי מוז הער ‪ ,1‬עבור אלי – הער ‪ ,2‬עבור אביב – הער ‪ ,3‬ועבור אופיר –‬
‫הער ‪.4‬‬
‫פתחו אלגורית המקבל כקלט את מספר התלמידי בכיתה‪ ,‬ואת רשימת ההצבעות )הצבעה אחת‬
‫עבור כל תלמיד בכיתה( ומציג כפלט את מספר המועמד המנצח‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫‪-445-‬‬
‫שאלה ‪10.37‬‬
‫בספריית הווידיאו יש לכל סרט קוד ב ‪ 4‬ספרות‪ .‬הספרה השמאלית ביותר מסמנת את קוד המחלקה‬
‫)בי ‪ 1‬ל‪ ,(6#‬שתי הספרות האמצעיות מסמנות את קוד הסרט )בי ‪ 1‬ל‪ (99#‬והספרה הימנית ביותר‬
‫מסמנת את מספר העותקי בספריה )בי ‪ 1‬ל‪.(9#‬‬
‫פתחו אלגורית המקבל כקלט רשימה של הקודי של כל הסרטי בספריה‪ ,‬המסתיימת במספר ‪.0‬‬
‫פלט האלגורית הוא הקוד של המחלקה שבה יש את מספר הסרטי הגדול ביותר‪.‬‬
‫ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫בשאלה ‪ 10.37‬יש למצוא איבר שכיח במער‪ .‬להעמקה בתבנית חישוב שכיח פנו לעמוד ‪.471‬‬
‫‪ 10.5‬מערך צוברים‬
‫באותו אופ בו מימשנו מער של מוני‪ ,‬נית לממש מער של צוברי‪ .‬במער צוברי כל איבר הוא‬
‫צובר בפני עצמו‪ ,‬א יש קשר בי משימות הצבירה עליה אחראיי הצוברי השוני במער‪ .‬לצור‬
‫פתרו השאלה הבאה יש להשתמש במער צוברי‪ ,‬שהעבודה עימו מהווה א היא תבנית שימושית‪.‬‬
‫שאלה ‪10.38‬‬
‫במשחק הקלפי קירטטה משתתפי ארבעה שחקני בעלי מספרי סידוריי מ‪ 1#‬עד ‪ ,4‬במש כמה‬
‫סבבי‪ .‬בכל סבב מוכרזי השחקני שזכו במקו הראשו )המנצח(‪ ,‬במקו שני ובמקו שלישי‪.‬‬
‫השחק הנותר נחשב כמפסיד‪ .‬המנצח במקו הראשו מקבל ‪ 7‬נקודות‪ ,‬השחק שבמקו השני מקבל‬
‫‪ 3‬נקודות‪ ,‬השחק שבמקו השלישי אינו מקבל נקודות והמפסיד מאבד ‪ 4‬נקודות‪.‬‬
‫המנצח במשחק כולו הוא זה שקיבל את מירב הנקודות בסיו כל הסבבי‪.‬‬
‫פתחו אלגורית אשר מקבל כקלט את מספר הסבבי‪ ,‬ולאחר מכ מקבל עבור כל סבב את מספרי‬
‫השחקני שהגיעו למקו הראשו‪ ,‬השני‪ ,‬והשלישי‪ .‬האלגורית מציג כפלט את מספרו של השחק‬
‫המנצח במשחק‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שימו ♥‪ :‬מאחר שנית ג לאבד נקודות‪ ,‬הרי ייתכ ששחק יגיע למספר נקודות שלילי‪.‬‬
‫להעמקה בתבנית מערך צוברים פנו לעמוד ‪.466‬‬
‫‪-446-‬‬
‫‪ 10.6‬יעילות מקום‬
‫בכל הבעיות שפתרנו בפרק זה נעזרנו במער‪ ,‬ועבור כל בעיה ראינו את נחיצות השימוש במער‬
‫במהל הפתרו‪ .‬בסעי הבא נתמקד באבחנה בי בעיות אשר בפתרונ נחו" מער לבי בעיות אשר‬
‫נית לפתור אות ג ללא מער‪ ,‬ונבי מדוע לא כדאי להשתמש במער א אי בו צור‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת המדד של יעילות מקו‪ ,‬והשוואה בי אלגוריתמי ביחס ליעילות‬
‫מקו‪ .‬מבט נוס אל יעילות מבחינת זמ ביצוע‪.‬‬
‫ערוצי הכבלי עורכי מדי פע סקרי כדי לברר את אחוזי הצפייה בתוכניותיה השונות‪ .‬פרסו‬
‫תוצאות סקר כזה כולל רשימת תוכניות יחד ע אחוז צפייה בכל תוכנית‪.‬‬
‫א‪ .‬פתחו אלגורית אשר הקלט שלו הוא מספר של תוכניות )של וחיובי(‪ ,‬ולאחר מכ רשימה‬
‫שאורכה כער הנתו הראשו‪ ,‬של אחוזי צפייה בתוכניות‪ .‬הפלט הוא מספר התוכניות שאחוז‬
‫הצפייה בה גבוה מממוצע אחוזי הצפייה‪.‬‬
‫ב‪ .‬פתחו אלגורית אשר הקלט שלו הוא מספר של תוכניות )של וחיובי(‪ ,‬ולאחר מכ רשימה‬
‫שאורכה כער הנתו הראשו‪ ,‬של אחוזי צפייה בתוכניות‪ .‬הפלט הוא מספר התוכניות שאחוז‬
‫הצפייה בה גבוה מ‪.20%#‬‬
‫ג‪ .‬הא תשובתכ לסעי א תשתנה א ידוע כי רשימת אחוזי הצפייה נתונה בסדר יורד )כלומר‪,‬‬
‫תחילה נתו אחוז הצפייה בתוכנית האהודה ביותר‪ ,‬אחר‪#‬כ אחוז הצפייה התוכנית האהודה‬
‫הבאה‪ ,‬וכ הלאה‪ ,‬עד אחוז הצפייה בתוכנית שנצפית הכי פחות(‬
‫נתחיל בסעי א‪.‬‬
‫הבעיה המוגדרת בסעי א זהה לחלוטי לבעיה ‪ .2‬יש לקלוט אור של רשימת נתוני לא ריקה‪ ,‬לקלוט‬
‫את הרשימה עצמה‪ ,‬לחשב את ממוצע הערכי‪ ,‬ולמנות את הערכי הגדולי מהממוצע‪ .‬מאחר שכבר‬
‫פתרנו בעיה זהה לה‪ ,‬לא נחזור כעת על הפתרו בפירוט‪ ,‬רק נזכיר שהפתרו משתמש במער לשמירת‬
‫ערכי הקלט )במקרה זה‪ ,‬רשימת אחוזי הצפייה(‪.‬‬
‫נעבור כעת לסעי ב‪.‬‬
‫נניח כי הקלט הוא ‪ .4 21 13 18 31‬במקרה זה הפלט הוא ‪ ,2‬כי אחוז הצפייה בשתי תוכניות‬
‫)הראשונה והרביעית( גבוה מ‪ .20%#‬אי אנו נדרשי לחשב ממוצע של אחוזי הצפייה‪.‬‬
‫‪-447-‬‬
‫נית להציג פירוק הדומה לפירוק המתאי לסעי א‪:‬‬
‫‪ .1‬קליטת מספר התוכניות‬
‫‪ .2‬קליטת אחוזי הצפיה ושמירתם‬
‫‪ .3‬השוואת כל אחוז צפיה ל‪ 20-‬ומנייתו אם הוא גדול מ‪20-‬‬
‫פירוק זה אכ משרה צור במער‪ .‬קוד כל נשמרי הנתוני‪ ,‬ואחר כ ה מעובדי )במקרה זה‪,‬‬
‫מושווי ל‪ 20#‬ונמני בהתא לתוצאת ההשוואה(‪.‬‬
‫?‬
‫הא נית להציג פירוק פשוט יותר‪ ,‬שאינו מחייב שימוש במער?‬
‫כ! נית לעבד כל נתו נקלט מייד ע קליטתו‪ ,‬להשוותו ל‪ ,20#‬ולהחליט א למנות אותו או לא‪,‬‬
‫ובעצ אי צור בשמירת ערכי הקלט לאחר מכ‪ .‬לכ נקבל את הפירוק הבא לתת‪#‬משימות‪:‬‬
‫‪ .2‬קליטת אחוזי הצפיה‪ ,‬ועבור כל אחוז צפייה נקלט‪ ,‬השוואתו ל‪ 20-‬ועדכון המונה בהתאם‬
‫מאחר שכאמור‪ ,‬אי צור במער‪ ,‬נשתמש במשתני הבאי‪:‬‬
‫‪ – rate‬מטיפוס ממשי‪ ,‬ישמור את אחוז הצפייה התור בקלט‪.‬‬
‫‪ – above20Counter‬מטיפוס של‪ ,‬מונה לשמירת מספר אחוזי הצפייה הגבוהי מ‪.20#‬‬
‫‪úåéðëåúä øôñî úà èåì÷ .1‬‬
‫‪0-ì above20Counter ìù åëøò úà ìçúà .2‬‬
‫‪.3‬‬
‫‪:òöá úåéðëåúä øôñî ãò 0-î íìù i ìë øåáò‬‬
‫‪rate-á ïøåúä äééôöä æåçà úà èåì÷ .3.1‬‬
‫‪íà .3.2‬‬
‫‪.3.2.1‬‬
‫‪20 < rate‬‬
‫‪1-á above20Counter ìù åëøò úà ìãâä‬‬
‫‪above20Counter ìù åëøò úà èìôë âöä .4‬‬
‫א כ‪ ,‬למרות שהבעיה המוגדרת בסעי א והבעיה המוגדרת בסעי ב נראות דומות‪ ,‬הרי שלצור‬
‫פתרו סעי א יש צור במער‪ ,‬ואילו לצור פתרו סעי ב אי צור במער‪.‬‬
‫‪-448-‬‬
‫מדוע יש בכ חשיבות? כידוע‪ ,‬בעת ביצוע תוכנית אשר יש בה שימוש במער‪ ,‬מוקצה שטח זיכרו‬
‫המספיק עבור כל איברי המער‪ .‬מספר תאי הזיכרו המוקצי למער הינו מרכיב משמעותי בקביעת‬
‫גודל הזיכרו הכולל הדרוש לביצוע התוכנית‪ .‬כיוו שמשאבי הזיכרו של המחשב מוגבלי‪ ,‬נשתדל‬
‫לפתח אלגוריתמי אשר גודל המקו הדרוש לביצוע הוא מצומצ במידת האפשר‪ .‬כלומר‪ ,‬נשתדל‬
‫לפתח אלגוריתמי יעילי עד כמה שנית מבחינת מקו בזיכרו‪ .‬זאת בנוס להקפדה על יעילות‬
‫מבחינת זמ ביצוע‪ ,‬כפי שהוצג בפרק ‪.8‬‬
‫כאשר ידועי שני אלגוריתמי שוני לפתרו אותה בעיה‪ ,‬אשר באחד מה יש שימוש במער ובשני‬
‫אי שימוש במער‪ ,‬נאמר שהאלגורית השני יעיל יותר מבחינת מקו בזיכרו‪.‬‬
‫נעבור לפתרו סעי ג‪.‬‬
‫ג בסעי זה יש לפתח אלגורית הפותר את הבעיה שהוצגה בסעי א‪ .‬אבל‪ ,‬שלא כמו בסעי א‪ ,‬נתו‬
‫לנו מאפיי נוס של הקלט‪ :‬רשימת אחוזי הצפייה נתונה בסדר יורד ‪.‬‬
‫למשל‪ ,‬הנה קלט העונה להגדרת הבעיה‪.5 41 30 29 15 3 :‬‬
‫ממוצע הערכי הנתוני הוא ‪ .23.6‬הערכי הגבוהי מ הממוצע ה ‪ 30 ,41‬ו‪ .29#‬נית לראות כי‬
‫מאחר שרשימת הערכי נתונה בסדר יורד‪ ,‬הרי כל הערכי הגבוהי מ הממוצע נמצאי בתחילת‬
‫הרשימה‪.‬‬
‫בדיוק כמו בסעי א‪ ,‬את ההשוואה לממוצע נית לבצע רק לאחר חישוב הממוצע‪ ,‬כלומר רק לאחר‬
‫קליטת כל הערכי‪.‬‬
‫?‬
‫הא נית לפתור סעי זה ללא מער?‬
‫לא‪ .‬מאחר שההשוואה לממוצע יכולה להיעשות רק אחרי סיו הקלט‪ ,‬יש לשמור את כל הערכי‬
‫הנקלטי‪ ,‬ולש כ נחו" מער‪.‬‬
‫?‬
‫הא נוכל בכל זאת לשפר את הפתרו‪ ,‬תו שימוש במאפיי הקלט הנוס ?‬
‫בעזרת דוגמת הקלט שניתחנו ראינו כי הערכי הגדולי מ הממוצע נמצאי כול בתחילת הרשימה‪,‬‬
‫ולכ ג יישמרו ראשוני‪ ,‬בשלב שמירת הקלט‪ .‬לכ‪ ,‬בשלב ההשוואה לממוצע לא נצטר לעבד שוב‬
‫את כל ערכי הקלט‪ ,‬אלא רק את אלה המופיעי בהתחלה‪.‬‬
‫לכ‪ ,‬במקו להשתמש בהוראה לביצוע חוזר באור ידוע מראש‪ ,‬שתעבור על כל האיברי שנשמרו‪,‬‬
‫נוכל להשתמש בהוראה לביצוע חוזר בתנאי‪ .‬התנאי יאפשר את המש ביצוע הלולאה כל עוד האיבר‬
‫התור גדול מהממוצע‪.‬‬
‫‪-449-‬‬
‫ניתוח זה מראה כי הפתרו שנית לא יהיה יעיל יותר מהפתרו של סעי א מבחינת מקו בזיכרו‪,‬‬
‫אבל יהיה בו שיפור מבחינת יעילות זמ‪ :‬מניית הערכי הגדולי מהממוצע תצרי מעבר רק על חלק‬
‫מהאיברי שנשמרו ולא על כול‪.‬‬
‫בהתא לניתוח שערכנו‪ ,‬נפרק את הבעיה באופ הבא‪:‬‬
‫‪ .2‬קליטת אחוזי הצפייה‪ ,‬שמירתם וצבירתם‬
‫‪ .3‬חישוב הממוצע‬
‫‪ .4‬מעבר על הערכים הגדולים מן הממוצע‪ ,‬תוך כדי מנייתם‬
‫‪ .5‬הצגת ערך המונה‬
‫‪ – numOfPrograms‬מטיפוס של‪ ,‬לשמירת מספר התוכניות‬
‫‪ – rating‬מער מטיפוס ממשי ב ‪ numOfPrograms‬איברי‪ ,‬לשמירת אחוזי הצפייה‬
‫הנתוני‪ ,‬שיהיו מסודרי בו בסדר יורד‬
‫‪ – sumOfRating‬מטיפוס ממשי‪ ,‬צובר שישמור את סכו אחוזי הצפייה‬
‫‪ – averageOfRating‬מטיפוס ממשי‪ ,‬לשמירת ממוצע אחוזי הצפייה‬
‫‪ – aboveAverageCounter‬מטיפוס של‪ ,‬מונה את אחוזי הצפייה הגבוהי מאחוז הצפייה‬
‫הממוצע‪.‬‬
‫‪0-ì sumOfRating úà ìçúà .1‬‬
‫‪0-ì aboveAverageCounter úà ìçúà .2‬‬
‫‪numOfPrograms-á úåéðëåúä øôñî úà èåì÷ .3‬‬
‫‪:òöá numOfPrograms - 1 ãò 0-î íìù i ìë øåáò .4‬‬
‫‪rating[i]-á i-ä äééôöä æåçà úà èåì÷ .4.1‬‬
‫‪rating[i] êøòä úà sumOfRating øáåöì óñåä .4.2‬‬
‫‪averageOfRating-á íùäå sumOfRating / numOfPrograms úà áùç .5‬‬
‫‪0 êøòä úà i-á íùä .6‬‬
‫‪:òöá rating[i] > averageOfRating ãåò ìë .7‬‬
‫‪1-á aboveAverageCounter äðåîä ìù åëøò úà ìãâä .7.1.1‬‬
‫‪i ìù åëøò úà 1-á ìãâä .7.1.2‬‬
‫‪aboveAverageCounter ìù åëøò úà èìôë âöä .8‬‬
‫‪-450-‬‬
‫שימו ♥ להבדל בי אופי השימוש בתנאי ‪ rating[i] > averageOfRating‬באלגורית לפתרו סעי א‬
‫לבי אופי השימוש בו באלגורית המתואר כא‪ .‬כא זהו תנאי כניסה להוראה לביצוע חוזר‪ ,‬בעוד‬
‫שבאלגורית לפתרו סעי א הוא תנאי השולט על הוראה לביצוע בתנאי‪.‬‬
‫שאלה ‪10.39‬‬
‫מדוע מובטח כי ההוראה לביצוע חוזר בתנאי‪ ,‬המונה את הערכי הגבוהי מהממוצע‪ ,‬אינה לולאה‬
‫אינסופית )במילי אחרות‪ ,‬מדוע מובטח כי תנאי הכניסה יתקיי בשלב כלשהו?(?‬
‫*‪/‬‬
‫קלט‪ :‬מספר של תוכניות )שלם חיובי( ורשימת אחוזי צפייה בתוכניות‪ ,‬נתונים‬
‫בסדר יורד‬
‫פלט‪ :‬מספר אחוזי הצפייה הגבוהים מאחוז הצפייה הממוצע‬
‫‪*/‬‬
‫‪public class AboveAverage‬‬
‫{‬
‫{‬
‫מספר התוכניות ‪//‬‬
‫;‪int numOfPrograms‬‬
‫מערך אחוזי הצפייה ‪//‬‬
‫;‪double[] rating‬‬
‫צובר אחוזי הצפייה ‪//‬‬
‫;‪double sumOfRating = 0‬‬
‫ממוצע אחוזי הצפייה ‪//‬‬
‫; ‪double averageOfRating‬‬
‫מונה הגבוהים מהממוצע ‪//‬‬
‫;‪int aboveAverageCounter = 0‬‬
‫קלט וצבירה ‪//‬‬
‫‪numOfPrograms = In.ReadInt("How many programs? Insert a positive‬‬
‫;)"‪integer‬‬
‫;]‪rating = new double[numOfPrograms‬‬
‫)‪for (int i = 0; i < numOfPrograms; i++‬‬
‫{‬
‫;)"‪rating[i] = In.readInt("Insert rating percentage‬‬
‫;]‪sumOfRating = sumOfRating + rating[i‬‬
‫‪} // for‬‬
‫חישוב ממוצע ‪//‬‬
‫;‪averageOfRating = sumOfRating / numOfPrograms‬‬
‫מניית הגבוהים מהממוצע ‪//‬‬
‫;‪int i = 0‬‬
‫)‪while(rating[i] > averageOfRating‬‬
‫‪-451-‬‬
‫{‬
‫;‪i++‬‬
‫;‪aboveAverageCounter++‬‬
‫‪} // while‬‬
‫פלט ‪//‬‬
‫" ‪System.out.println("The rating of " + aboveAverageCounter +‬‬
‫;)"‪programs is above average‬‬
‫‪} // main‬‬
‫‪} //class AboveAverage‬‬
‫מפתרו בעיה ‪ 6‬למדנו לקח חשוב‪:‬‬
‫יש לנצל עד כמה שנית את מאפייני הקלט‪#‬פלט כדי לנסח אלגורית יעיל‪ ,‬ה מבחינת מקו בזיכרו‬
‫וה מבחינת זמ ביצוע‪.‬‬
‫ייתכנו שתי בעיות אלגוריתמיות הנראות דומות‪ ,‬לפחות במבט ראשו‪ ,‬אשר פתרונות יעילי עבור‬
‫נבדלי זה מזה ה מבחינת מקו וה מבחינת זמ‪ .‬בפרט‪ ,‬יתכ שעבור פתרו בעיה אחת נחו" מער‬
‫ועבור פתרו הבעיה האחרת לא נחו" מער‪.‬‬
‫שאלה ‪10.40‬‬
‫נתונה רשימת קלט של ‪ 40‬ציוני‪ .‬סמנו הא לביצוע כל אחד מהחישובי הבאי נחו" או לא נחו"‬
‫מער‪:‬‬
‫א‪ .‬מספר הציוני הגבוהי מ‪ ....................................................... 80#‬נחו" מער ‪ /‬לא נחו" מער‬
‫ב‪ .‬מספר הציוני השווי לציו הראשו ברשימה ‪ .................................‬נחו" מער ‪ /‬לא נחו" מער‬
‫ג‪ .‬מספר הציוני הגבוהי מ הציו האחרו ברשימה ‪ ...........................‬נחו" מער ‪ /‬לא נחו" מער‬
‫ד‪ .‬מספר הציוני הנמוכי מ הציו הלפני אחרו ברשימה ‪ ....................‬נחו" מער ‪ /‬לא נחו" מער‬
‫ה‪ .‬מספר הציוני הנמוכי מ הציו הראשו ומ הציו האחרו ‪ .............‬נחו" מער ‪ /‬לא נחו" מער‬
‫ו‪ .‬מספר הציוני הנמוכי מממוצע הציוני ‪ ........................................‬נחו" מער ‪ /‬לא נחו" מער‬
‫ז‪ .‬מספר הציוני הגבוהי מהממוצע של שני הציוני הראשוני ‪ ...........‬נחו" מער ‪ /‬לא נחו" מער‬
‫ח‪ .‬מספר הציוני הגבוהי מהממוצע של שני הציוני האחרוני ‪ ...........‬נחו" מער ‪ /‬לא נחו" מער‬
‫שאלה ‪10.41‬‬
‫בבעיה ‪ 3‬בפרק הקלט כלל רשימה של ‪ 30‬תווי )'‪ 'T‬או '‪ ('F‬אשר ציינו מצב לוח‪ ,‬ואחר כ מספר שציי‬
‫מקו של שחק על לוח‪ .‬בפתרו הבעיה נעשה שימוש במער ב ‪ 30‬איברי לשמירת מצב הלוח‪.‬‬
‫נניח שמקו השחק על הלוח יינת כקלט לפני הרשימה המתארת את מצב הלוח )ולא אחריה(‪ .‬הא‬
‫ג במקרה זה נחו" מער? הסבירו את תשובתכ‪.‬‬
‫‪-452-‬‬
‫שאלה ‪10.42‬‬
‫עודד המציא משחק חדש‪ .‬הוא מציג לפני חבריו קופסת מטבעות סגורה‪ .‬כל אחד מחבריו רוש ניחוש‬
‫של מספר המטבעות בקופסה‪ .‬לאחר מכ עודד סופר את מספר המטבעות בקופסה‪ .‬המטבעות‬
‫מחולקי בי כל מי שניחש את המספר המדויק של המטבעות‪ .‬שארית המטבעות נשארת אצל עודד‪.‬‬
‫א‪ .‬פתחו אלגורית אשר מקבל כקלט מספר המציי את מספר החברי המשתתפי במשחק‪ ,‬אחר‪#‬‬
‫כ את רשימת הניחושי‪ ,‬ניחוש עבור כל חבר המשתת במשחק‪ ,‬ולבסו את מספר המטבעות‬
‫שבקופסה‪ .‬פלט האלגורית הוא מספריה הסידוריי ברשימה של החברי שניחשו את מספר‬
‫המטבעות המדויק‪ ,‬וכ מספר מטבעות שיקבל כל זוכה‪.‬‬
‫שימו ♥‪ :‬היזהרו מחלוקה ב‪!0#‬‬
‫ב‪ .‬ענו על סעי א כאשר סדר נתוני הקלט שונה‪ :‬תחילה נתו מספר המטבעות שבקופסה‪ ,‬אחריו‬
‫מספר המשתתפי במשחק‪ ,‬ולבסו רשימת הניחושי‪.‬‬
‫שאלה ‪10.43‬‬
‫בכספת של בנק שמורי יהלומי על מדפי הממוספרי מ‪ 1#‬עד ‪.100‬‬
‫נתונה כקלט רשימת ערכי המבטאי את מצב מדפי הכספת‪ ,‬כ שהער ה‪ i#‬ברשימה מבטא את מצב‬
‫המד ה‪) i#‬מכיל יהלומי או לא מכיל יהלומי(‪.‬‬
‫ציינו עבור כל אחד מהחישובי הבאי הא נחו" או לא נחו" מער לצור ביצועו‪ .‬נמקו את‬
‫תשובותיכ‪.‬‬
‫א‪ .‬מספר המדפי המכילי יהלומי‪ ,‬ומספר המדפי ללא יהלומי ‪ ......‬נחו" מער ‪ /‬לא נחו" מער‬
‫נימוק‪:‬‬
‫ב‪ .‬מספר המדפי שמצב שווה למצב המד השני ‪ ................................‬נחו" מער ‪ /‬לא נחו" מער‬
‫ג‪ .‬מספר המדפי שמצב שווה למצב המד האחרו ‪ ............................‬נחו" מער ‪ /‬לא נחו" מער‬
‫ד‪ .‬מספר הסידורי של המדפי שמצב שווה למצב המד השני ‪ ...........‬נחו" מער ‪ /‬לא נחו" מער‬
‫ה‪ .‬מספר הסידורי של המדפי שמצב שווה למצב המד האחרו ‪ .......‬נחו" מער ‪ /‬לא נחו" מער‬
‫‪-453-‬‬
‫‪ 10.7‬בחירה אקראית‬
‫הגרלת מספרי אקראיי הינה פעולה שימושית מאוד במדעי המחשב‪ .‬למשל‪ ,‬בתחו בדיקות‬
‫התוכנה‪ ,‬השימוש במספרי אקראיי מאפשר בדיקת תוכנה על אוס קלטי גדול ואקראי שנוצר‬
‫אוטומטית‪ .‬ג בתחו ההצפנה מספרי אקראיי ה שימושיי מאוד‪ .‬בסעי זה נכיר מחלקה‬
‫המוגדרת בשפת ‪ Java‬ומאפשרת עבודה נוחה ע מספרי אקראיי‪.‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת מחלקת מספרי אקראיי ואופ השימוש בה‪.‬‬
‫ששת חברי קבוצה בצופי מצאו דר חדשה להגרלה‪ .‬ה מחלקי ביניה את המספרי מ‪ 1#‬עד ‪,6‬‬
‫ומטילי קובייה עד אשר מספר כלשהו מוגרל פעמיי‪ .‬החבר בעל המספר שהוגרל פעמיי הוא‬
‫הזוכה‪ .‬פתחו אלגורית אשר מדמה את תהלי זריקת הקובייה ומדפיס את המספר הזוכה‪ .‬ישמו את‬
‫האלגורית בשפת התכנות ‪.Java‬‬
‫בבעיה זו אנו מתבקשי לדמות הטלת קובייה במהל ביצוע התוכנית ולא לקבל את תוצאות הטלת‬
‫הקובייה כקלט‪ .‬מטרת הטלת קובייה היא למעשה‪ ,‬בחירת מספר אקראי בי ‪ 1‬ל‪.6#‬‬
‫נפרק את הבעיה באופ הבא‪:‬‬
‫‪ .1‬הגרלת מספרים בין ‪ 1‬ל‪ ,6-‬עד אשר מוגרל מספר בתחום פעם שנייה‬
‫‪ .2‬הצגה כפלט של המספר שהוגרל פעמיים‬
‫כיוו שעלינו למנות את מספר הפעמי שהוגרל כל מספר בתחו‪ ,‬יש לתחזק במקביל ‪ 6‬מוני )מוני‬
‫אלה ימנו רק עד ‪ ,2‬כלומר‪ ,‬יוכלו לקבל את הערכי ‪ 1 ,0‬או ‪ .(2‬לש כ ניעזר במער מוני‪ .‬בנוס ‪,‬‬
‫עלינו להמשי ולהגריל מספרי כל עוד לא הוגרל מספר אחד פעמיי‪ .‬לש כ נשתמש במשתנה‬
‫בוליאני אשר יאותחל ל‪ false#‬ויקבל ער ‪ true‬כאשר אחד המספרי מוגרל פע שנייה‪.‬‬
‫א כ‪ ,‬המשתני העיקריי בה נשתמש ה‪:‬‬
‫‪ – diceRolls‬מער מוני‪ ,‬למניית ההגרלות של כל מספר בי ‪ 1‬ל‪.6#‬‬
‫‪ – stop‬משתנה בוליאני‪ ,‬יציי הא הוגרל אחד המספרי פעמיי‪.‬‬
‫‪ – currentRoll‬של‪ ,‬לשמירת תוצאת ההגרלה הנוכחית‪.‬‬
‫‪-454-‬‬
‫‪false-ì stop úà ìçúà .1‬‬
‫‪.2‬‬
‫‪:òöá (íééîòô åäùìë øôñî ìøâåä àì) false àåä stop ìù åëøò ãåò ìë‬‬
‫‪currentRoll-á íùäå 6-ì 1 ïéá øôñî ìøâä .2.1‬‬
‫‪1-á currentRoll-ì íéàúîä äðåîä ìù åëøò úà ìãâä .2.2‬‬
‫‪2-ì äååù currentRoll-ì íéàúîä äðåîä ìù åëøò íà .2.3‬‬
‫‪true-ì stop ìù åëøò úà äðù .2.3.1‬‬
‫‪currentRoll úà èìôë âöä .3‬‬
‫שאלה ‪10.44‬‬
‫הסבירו מדוע הוראה ‪ 2‬היא הוראה לביצוע חוזר סופית‪.‬‬
‫כדי לייש את הוראה ‪ 2.1‬עלינו לבצע הגרלה של מספר אקראי‪ ,‬בי ‪ 1‬ל‪ .6#‬נוכל לבצע הגרלה כזאת ב‪#‬‬
‫‪ Java‬בעזרת מחלקת מספרי אקראיי‪.Random :‬‬
‫בעזרת עצ מהמחלקה ‪ Random‬נית לבצע הגרלות של ערכי בכל תחו שנבחר‪ .‬כמוב‪ ,‬כדי שנוכל‬
‫להשתמש בעצ מהמחלקה עלינו להצהיר עליו ולהקצות לו מקו בזיכרו‪ ,‬למשל כ‪:‬‬
‫;)(‪Random rnd = new Random‬‬
‫הוראה זו מצהירה על עצ מהמחלקה ‪ ,Random‬בש ‪ ,rnd‬ומקצה לו מקו בזיכרו‪.‬‬
‫כעת‪ ,‬כשיש בידינו עצ מהמחלקה ‪ Random‬אנו יכולי להגריל בעזרתו מספר של על ידי הפעלת‬
‫הפעולה ‪ nextInt‬של העצ‪ .‬פעולה זו מקבלת פרמטר יחיד‪ ,‬שהוא ער של המתאר את טווח‬
‫המספרי להגרלה‪ .‬א הער שמועבר לפעולה הוא ‪ ,n‬יוגרל מספר של בתחו שבי ‪ 0‬ל‪ .n-1#‬מאחר‬
‫שזו פעולה של העצ‪ ,‬יש להשתמש בסימו הנקודה כדי להפעילה‪.‬‬
‫למשל‪ ,‬בעקבות ביצוע ההוראה ;)‪ num = rnd.nextInt(6‬יוש במשתנה ‪ num‬מספר כלשהו בי ‪0‬‬
‫ל‪.5#‬‬
‫?‬
‫כיצד נדמה הטלת קובייה? כלומר‪ ,‬כיצד נגריל מספר בי ‪ 1‬ל‪?6#‬‬
‫נעביר לפעולה ‪ nextInt‬את הער ‪ ,6‬על מנת לקבל מספר אקראי בי ‪ 0‬ל‪ .5#‬כדי "לתרג" את הער‬
‫שהתקבל לער אפשרי עבור הטלת קובייה‪ ,‬נוסי לו את הער ‪ .1‬כ יהיה בידינו מספר אקראי בי ‪1‬‬
‫ל ‪. 6#‬‬
‫?‬
‫כיצד נקשר בי הער המוגרל למונה המתאי לו במער?‬
‫‪-455-‬‬
‫מאחר שמיקו האיברי במער מתחיל מ‪ ,0#‬הרי שהאיבר הנמצא במקו ‪ 0‬מונה את מספר ההטלות‬
‫של המספר ‪ ,1‬האיבר הנמצא במקו ‪ 1‬מונה את מספר ההטלות של המספר ‪ ,2‬וכ הלאה‪ ,‬עד לאיבר‬
‫האחרו‪ ,‬הנמצא במקו ‪ 5‬ומונה את מספר ההטלות של המספר ‪ .6‬כלומר‪ ,‬כדי להשתמש בער‬
‫שהוגרל כמציי מתאי במער‪ ,‬יש להפחית מערכו ‪.1‬‬
‫לכ‪ ,‬במקרה זה‪ ,‬נוח לוותר על התרגו מהער המוגרל )בי ‪ 0‬ל‪ (5#‬לער אפשרי להטלת קובייה )בי ‪1‬‬
‫ל‪ ,(6#‬ולהשתמש בער המוגרל ישירות כמציי למער‪.‬‬
‫בתוכנית זו עלינו לבצע הגרלות חוזרות ונשנות‪ .‬אבל‪ ,‬לאחר שהקצינו לעצ מהמחלקה‬
‫מקו בזיכרו‪ ,‬אנו יכולי להשתמש בו שוב ושוב להגרלות נוספות )אפילו מתו תחומי שוני(‪.‬‬
‫‪Random‬‬
‫עלינו להצהיר בתחילת התוכנית על כוונתנו להשתמש במחלקה ‪ ,Random‬כפי שאנו עושי כאשר‬
‫ברצוננו להשתמש במחלקה ‪ .Math‬ההצהרה נכתבת באופ הבא‪:‬‬
‫;‪import java.util.Random‬‬
‫*‪/‬‬
‫התוכנית מדמה סדרת הטלות קובייה עד שאחד המספרים מוגרל פעם שנייה‬
‫פלט‪ :‬המספר שהוגרל פעמיים‬
‫‪*/‬‬
‫הודעה כי אנו‬
‫מתכוונים להשתמש‬
‫בגוף התוכנית‬
‫במחלקה ‪Random‬‬
‫‪public class ScoutDiceGame‬‬
‫{‬
‫{‬
‫;‪boolean stop = false‬‬
‫מערך מונים ‪int[] diceRolls = new int[6]; //‬‬
‫תוצאת הטלת קוביה ‪//‬‬
‫;‪int currentRoll = 0‬‬
‫עצם להגרלה ‪//‬‬
‫;)(‪Random rnd = new Random‬‬
‫ביצוע הטלות חוזרות כל עוד לא הוגרל מספר פעמיים ‪//‬‬
‫)‪while (!stop‬‬
‫{‬
‫הטל קובייה ‪//‬‬
‫;)‪currentRoll = rnd.nextInt(6‬‬
‫הוסף ‪ 1‬למונה מתאים ‪//‬‬
‫;‪diceRolls[currentRoll]++‬‬
‫‪-456-‬‬
‫בדוק האם המספר הוגרל בפעם השנייה ‪//‬‬
‫;)‪stop = (diceRolls[currentRoll] == 2‬‬
‫‪} // while‬‬
‫פלט‪//‬‬
‫‪System.out.println("number " + (currentRoll + 1) + " is the‬‬
‫;)"‪winner‬‬
‫‪} // main‬‬
‫‪} // class ScoutDiceGame‬‬
‫שימו ♥‪ :‬אמנ ויתרנו על התרגו בי הער המוגרל לער אפשרי להטלת קובייה‪ ,‬כדי שנוכל‬
‫להשתמש בער המוגרל ישירות כמציי למער‪ ,‬אבל ההתאמה עדיי נדרשת לצור הצגה ברורה של‬
‫הפלט‪ .‬לכ‪ ,‬לפני הצגת הער הזוכה מוגדל ערכו ב‪) 1#‬בתו ההוראה ‪.(System.out.println‬‬
‫נסכ את המושגי החדשי שהוצגו בפתרו בעיה ‪:7‬‬
‫בשפת ‪ Java‬מוגדרת‬
‫מחלקה למספרי אקראיי‬
‫הנקראת ‪ .Random‬באמצעות עצ‬
‫מהמחלקה נית להגריל מספרי אקראיי בתחו מבוקש‪ .‬כדי להשתמש במחלקה בתו תוכנית‬
‫‪ Java‬צרי לשלב את ההוראה הבאה בתוכנית‪:‬‬
‫לפני ביצוע הגרלות‬
‫יש להצהיר על עצ מהמחלקה ‪ Random‬ולהקצות עבורו מקו בזיכרו‪,‬‬
‫למשל כ‪:‬‬
‫;)( ‪Random rnd = new Random‬‬
‫הפעולה‬
‫‪ nextInt‬של עצ מהמחלקה ‪ Random‬מקבלת כפרמטר מספר של חיובי ‪ n‬ומחזירה‬
‫איבר אקראי בתחו ‪ 0‬עד ‪ .n-1‬מאחר שזו פעולה של עצ‪ ,‬יש להפעילה באמצעות סימו הנקודה‪,‬‬
‫למשל כ‪:‬‬
‫)‪rnd.nextInt(6‬‬
‫נית לשלב את הפעולה בתו ביטויי חשבוניי‪ ,‬כ שערכ יהיה ער אקראי בתחו רצוי‪.‬‬
‫באמצעות עצ מהמחלקה ‪ ,Random‬שהוקצה עבורו מקו בזיכרו‪ ,‬נית לבצע הגרלות חוזרות‬
‫ונשנות‪ ,‬ג מתחומי שוני‪.‬‬
‫נחזור ונדגי את המושגי החדשי שהוצגו בפתרו בעיה ‪:7‬‬
‫?‬
‫כיצד נדע מה טווח הערכי האפשריי עבור ביטוי הכולל הגרלה של מספר אקראי?‬
‫‪-457-‬‬
‫נתבונ בביטוי לדוגמה ונבדוק מה טווח הערכי האפשריי עבורו‪:‬‬
‫‪rnd.nextInt(11)+100‬‬
‫הפעולה )‪ rnd.nextInt(11‬מחזירה מספר אקראי של בטווח שבי ‪ 0‬ל‪.10-‬לאחר מכ נוס לער‬
‫המוגרל המספר ‪ .100‬לכ‪ ,‬א יוגרל המספר ‪ 0‬ער הביטוי כולו הוא ‪ ,100‬וא יוגרל המספר ‪ 10‬ער‬
‫הביטוי כולו הוא ‪ .110‬לפיכ טווח הערכי האפשריי עבור הביטוי הוא בי ‪ 100‬ל‪.110 #‬‬
‫?‬
‫כיצד נגריל מספר בטווח הערכי בי ‪ 400‬ל‪?500#‬‬
‫תחילה נבדוק כמה מספרי יש בי ‪ 400‬ל‪ .500#‬בתחו זה יש ‪ 101‬מספרי )מדוע?(‪.‬‬
‫א כ‪ ,‬עלינו להגריל אחד מתו ‪ 101‬מספרי‪ ,‬וזאת נעשה בעזרת הפעולה‬
‫)‪.rnd.nextInt(101‬‬
‫באופ זה יוגרל מספר בי ‪ 0‬ל‪ .100#‬כעת‪ ,‬כדי לקבל מספר בתחו שבי ‪ 400‬ל‪ ,500#‬עלינו להוסי‬
‫לער המוגרל ‪ .400‬אכ‪ ,‬א יוגרל ‪ 0‬נקבל לאחר ההוספה את הער ‪ ,400‬וא יוגרל ‪ 100‬נקבל לאחר‬
‫ההוספה את הער ‪ .500‬לכ‪ ,‬הביטוי המתאי הוא‪:‬‬
‫‪rnd.nextInt(101)+400‬‬
‫שאלה ‪10.45‬‬
‫העצ ‪ rnd‬הוא עצ המחלקה ‪ ,Random‬שכבר הוקצה עבורו מקו בזיכרו‪.‬‬
‫א‪ .‬מהו טווח הערכי האפשריי למשתנה השל ‪ num‬בעקבות ביצוע ההוראה הבאה?‬
‫;‪num = rnd.nextInt(6) + 1‬‬
‫ב‪ .‬מהו טווח הערכי האפשריי שיוצגו על המס בעקבות ביצוע ההוראה הבאה?‬
‫;))‪System.out.println(rnd.nextInt(10‬‬
‫ג‪ .‬מהו טווח הערכי האפשריי שיוצגו על המס בעקבות ביצוע ההוראה הבאה?‬
‫;)‪System.out.println(rnd.nextInt(11) + 100‬‬
‫ד‪ .‬תארו את ערכי הפלט האפשריי שיוצגו למס בעקבות ביצוע ההוראה הבאה‪:‬‬
‫)‪for (int i = 0; i < 100; i++‬‬
‫{‬
‫;)" " ‪System.out.print(rnd.nextInt(50) +‬‬
‫}‬
‫שאלה ‪10.46‬‬
‫העצ ‪ rnd‬הוא עצ המחלקה ‪ ,Random‬שכבר הוקצה עבורו מקו בזיכרו‪.‬‬
‫מהו טווח הערכי האפשריי עבור כל אחד מהביטויי הבאי?‬
‫א‪.‬‬
‫)‪rndNum.nextInt(100‬‬
‫_________________________‬
‫ב‪.‬‬
‫‪rndNum.nextInt(100) + 1‬‬
‫_________________________‬
‫‪-458-‬‬
‫ג‪.‬‬
‫)‪rndNum.nextInt(100 + 1‬‬
‫_________________________‬
‫ד‪.‬‬
‫_________________________‬
‫ה‪.‬‬
‫_________________________‬
‫ו‪.‬‬
‫_________________________‬
‫שאלה ‪10.47‬‬
‫בכל אחד מהסעיפי הבאי תארו ביטוי‪ ,‬המתייחס לעצ ‪ rndNum‬מהמחלקה ‪ ,Random‬כ שער‬
‫הביטוי הוא בתחו המבוקש‪.‬‬
‫א‪ .‬מספר אקראי של בי ‪ 0‬ל‪9#‬‬
‫_________________________‬
‫ב‪ .‬מספר אקראי של בי ‪ 10‬ל‪100#‬‬
‫_________________________‬
‫ג‪ .‬מספר אקראי של בי ‪ 100‬ל‪500#‬‬
‫_________________________‬
‫ד‪ .‬מספר אקראי של וזוגי בי ‪ 0‬ל‪_________________________ 100#‬‬
‫שאלה ‪10.48‬‬
‫בפתרו בעיה ‪ 7‬השתמשנו במער מוני‪ ,‬א בכל מהל הביצוע ערכיו לא עברו א פע את הער ‪,2‬‬
‫ושינוי אחד הערכי במער ל‪ 2#‬הביא לסיו האלגורית‪ .‬שנו את הפתרו כ שבמקו מער מטיפוס‬
‫של‪ ,‬ישתמש במער מטיפוס בוליאני‪ .‬ישמו את הפתרו החדש בשפת ‪.Java‬‬
‫שאלה ‪10.49‬‬
‫טורניר השש‪#‬בש מתחיל‪ ,‬א איבדת את הקוביות! פתחו אלגורית אשר מקבל כקלט סדרה של‬
‫הקשות על המקש רווח‪ ,‬ובעקבות כל הקשה הוא מדמה הטלת שתי קוביות ומציג כפלט את תוצאות‬
‫ההטלה‪ .‬בנוס ‪ ,‬א תוצאת ההטלה היא צמד המספרי ‪ 5‬ו‪) 6#‬כלומר‪ ,‬בקובייה אחת תוצאת ההטלה‬
‫‪ 5‬ובשנייה ‪ ,6‬או ההפ( האלגורית מציג כפלט את ההודעה שש‪-‬בש‪ .‬הקשה על כל מקש אחר פרט‬
‫למקש רווח מביאה לסיו הביצוע‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪10.50‬‬
‫פתחו אלגורית הקולט מספר חיובי של‪ ,‬ואחר כ מדמה סדרת הטלות קובייה‪ ,‬שאורכה כער‬
‫המספר שנקלט‪ .‬פלט האלגורית הוא מספר הפעמי שהוגרלה כל אחת משש התוצאות האפשריות‬
‫להטלת קובייה‪ .‬ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫שאלה ‪10.51‬‬
‫בפרק ‪ ,7‬בשאלה ‪ 7.56‬הוצג משחק ניחושי‪ .‬במשחק זה השחק צרי לנחש נכונה מספר בי ‪ 1‬ל‪,100#‬‬
‫שנבחר קוד לכ על ידי שחק נוס ‪ .‬שנו את קטע התוכנית שהוצג בשאלה ‪ 7.56‬כ שהמספר הסודי‬
‫יוגרל כעת בתחילת הביצוע ולא ייבחר על ידי שחק אחר‪.‬‬
‫‪-459-‬‬
‫בעזרת החומר הנלמד בפרק ‪ 10‬נית לפתור ג בעיות המשתמשות בתבניות הזזה מעגלית בסדרה‬
‫הזזה של תת‪-‬סדרה‪ ,‬ו‪#‬היפוך של תת‪-‬סדרה ‪ .‬להעמקה בתבניות אלו פנו לעמוד ‪ 477 ,474‬ו‪,479#‬‬
‫בהתאמה‪.‬‬
‫סיכום‬
‫בפרק זה הוצגו בעיות שפתרונ מצרי שמירה של סדרת ערכי מאותו טיפוס‪ .‬נית לשמור סדרה‬
‫כזאת כמער )‪. (array‬‬
‫מער הוא אוס סדור של משתני מאותו טיפוס‪ ,‬הקשורי זה לזה ולה ש משות ‪.‬‬
‫איבר במער הוא משתנה לכל דבר‪ ,‬כלומר‪ ,‬נית לשמור בו ערכי ולקרוא את הערכי השמורי בו‪.‬‬
‫שמו של איבר במער מורכב מש המער‪ ,‬וממספרו הסידורי של האיבר במער‪ .‬למשל‪.arr[3] ,‬‬
‫במקרה זה‪ ,‬ש המער הוא ‪ arr‬ו‪ 3#‬הוא המציי )אינדקס( שמפנה אותנו לאיבר שנמצא במקו מספר‬
‫‪ 3‬במער‪.‬‬
‫באלגוריתמי רבי נוח לבצע סריקה של מער‪ ,‬תו עיבוד איבריו‪ ,‬באמצעות הוראה לביצוע חוזר‪.‬‬
‫א נדרשת סריקה מלאה‪ ,‬של כל איברי המער‪ ,‬הרי מספר הסיבובי ידוע מראש‪ ,‬ושווה לאור‬
‫המער‪ .‬ג סריקה לא רציפה‪ ,‬אבל במרווחי ידועי מראש‪ ,‬ניתנת לביצוע בעזרת הוראה לביצוע‬
‫חוזר שמספר הסיבובי בה ידוע מראש‪.‬‬
‫א הסריקה אינה רציפה ומתבצעת בדילוגי שאינ קבועי‪ ,‬או א ביצועה תלוי בתנאי‪ ,‬נשתמש‬
‫בהוראה לביצוע חוזר בתנאי‪.‬‬
‫בטבלת מעקב אחר מהל ביצוע תוכנית הכוללת מער נכלול עמודות נפרדות עבור איברי שוני של‬
‫המער‪.‬‬
‫מער יכול לתפקד כמער מוני או כמער צוברי‪ ,‬במקרי בה יש צור לתחזק במקביל כמה‬
‫צוברי או מוני בעלי אופי משות ‪.‬‬
‫בעת ביצוע תוכנית אשר יש בה שימוש במער‪ ,‬מוקצי תאי עבור כל איבר במער‪ .‬כיוו שמשאבי‬
‫הזיכרו של המחשב מוגבלי‪ ,‬נשתדל לפתח אלגוריתמי אשר גודל המקו הדרוש לביצוע הוא‬
‫מצומצ ככל האפשר‪.‬‬
‫ייתכנו שני אלגוריתמי שוני לפתרו אותה בעיה‪ ,‬אשר באחד יש שימוש במער ובשני אי‪ .‬נאמר‬
‫שהאלגורית השני יותר יעיל מבחינת מקו‪.‬‬
‫‪-460-‬‬
‫יש לנצל עד כמה שנית את מאפייני הקלט‪#‬פלט כדי לנסח אלגורית יעיל‪ ,‬ה מבחינת מקו בזיכרו‬
‫וה מבחינת זמ ביצוע‪.‬‬
‫ייתכנו שתי בעיות אלגוריתמיות הנראות דומות‪ ,‬לפחות במבט ראשו‪ ,‬אשר פתרונות יעילי עבור‬
‫נבדלי זה מזה ה מבחינת מקו וה מבחינת זמ‪ .‬בפרט‪ ,‬יתכ שעבור פתרו בעיה אחת נחו" מער‬
‫ועבור פתרו הבעיה האחרת לא נחו" מער‪.‬‬
‫סיכום מרכיבי שפת ‪ Java‬שנלמדו בפרק ‪10‬‬
‫הצהרה על מער בשפת ‪ Java‬נכתבת כ‪:‬‬
‫][ טיפוס‬
‫ראשית‪ ,‬ש הטיפוס‪ ,‬ולאחריו סוגריי מרובעי )המצייני שזוהי הצהרה על מער של איברי‬
‫מהטיפוס‪ ,‬ולא של משתנה פשוט מטיפוס זה(‪ ,‬ואז שמו של המער‪.‬‬
‫לפני שימוש במער מוצהר יש לבצע עבורו הקצאת שטח זיכרו ‪ .‬הקצאת שטח למער מתבצעת על ידי‬
‫הפעולה ‪ new‬שאחריה מופיע טיפוס איברי המער‪ ,‬ואחריו מופיע בסוגריי מרובעי מספר איברי‬
‫המער‪:‬‬
‫;]מספר הערכים[ טיפוס ‪new‬‬
‫נית לצר את ההצהרה וההקצאה להוראה אחת‪:‬‬
‫][ טיפוס‬
‫בשפת ‪ ,Java‬כאשר מוקצה שטח זיכרו עבור מער של איברי מטיפוס פשוט‪ ,‬מתבצע ג אתחול‬
‫אוטומטי של כל איבריו‪ .‬איברי מער מספרי )שלמי או ממשיי( יאותחלו ל‪ ,0#‬איברי מער‬
‫בוליאני יאותחלו ל‪ ,false#‬ואיברי מער תווי יאותחלו לתו הריק‪.‬‬
‫בשפת ‪ Java‬מספור האיברי במער מתחיל מ‪ ,0#‬ולכ ]‪ arr[0‬מפנה אותנו לאיבר הראשו במער‪,‬‬
‫ו‪ arr[3]#‬מפנה אותנו לאיבר הרביעי במער‪.‬‬
‫לכל מער מוגדרת תכונת אור בש ‪ ,length‬השומרת את אורכו‪ .‬תכונה זו מקבלת את ערכה בעת‬
‫הקצאת שטח זיכרו עבור המער‪ ,‬ואינה ניתנת לשינוי לאחר מכ‪ .‬הפנייה לתכונה נעשית באמצעות‬
‫סימו הנקודה‪ ,‬למשל כ‪ .arr.length :‬אי להוסי סוגריי‪ ,‬משו שזו אינה פעולה!‬
‫יש להקפיד על פנייה לאיבר באמצעות מציי שערכו איננו חורג מתחו הערכי המותר‪ ,‬כלומר‪ ,‬נע בי‬
‫‪ 0‬לבי )‪ -1‬אור המער(‪ .‬חריגה מגבולות המער תגרו לעצירת התכנית‪ ,‬עקב שגיאת ריצה‪.‬‬
‫סריקת איברי מער יכולה להיעשות באמצעות לולאת ‪ ,for‬א ידועות מראש נקודות ההתחלה‬
‫והסיו של הסריקה‪ ,‬ומרווחי הדילוג )עבור סריקה לא רציפה(‪ .‬בלולאה כזאת‪ ,‬משתנה הבקרה של‬
‫הלולאה משמש ג כמציי‪ ,‬לציו מקומו של האיבר הנסרק במער‪ .‬משתנה הבקרה מאותחל בתחילת‬
‫‪-461-‬‬
‫הלולאה למציי של האיבר ממנו מתחילה הסריקה‪ ,‬וערכו מקוד בכל צעד בער הרצוי )לסריקה‬
‫רציפה הוא מקוד ב‪ 1#‬בכל פע(‪ ,‬עד שיגיע למקומו של האיבר בו מסתיימת הסריקה‪.‬‬
‫לסריקה רציפה של כל איברי המער‪ ,‬נית להיעזר בתכונת האור‪ ,‬כ שערכי משתני הבקרה ינועו מ‪#‬‬
‫‪ 0‬עד ל‪ -1)#‬אור המער(‪ ,‬ויגדלו ב‪ 1#‬בכל סיבוב‪.‬‬
‫לסריקה שאינה רציפה‪ ,‬ובמרווחי שאינ ידועי מראש‪ ,‬או לסריקה התלויה בתנאי‪ ,‬יש להשתמש‬
‫בלולאת ‪.while‬‬
‫בשפת ‪ Java‬נית לבצע הגרלת מספר אקראי באמצעות המחלקה ‪.Random‬‬
‫כדי להשתמש במחלקה ‪ Random‬בתו תוכנית ‪ Java‬צרי לשלב את ההוראה הבאה בתוכנית‪:‬‬
‫לפני ביצוע הגרלות יש להצהיר על עצ מהמחלקה ולהקצות לו מקו בזיכרו‪ ,‬כ‪:‬‬
‫;)(‪ = new Random‬שם העצם ‪Random‬‬
‫הגרלת איבר אקראי של בתחו שבי ‪ 0‬ל‪ n#‬מתבצעת על ידי הפעלת הפעולה )‪ nextInt(n‬על עצ‬
‫מהמחלקה ‪ .Random‬הפעולה מופעלת באמצעות סימו הנקודה )למשל כ )‪,(rnd.nextInt(5‬‬
‫ומחזירה ער אקראי של בתחו המבוקש‪.‬‬
‫נית לשלב פעולת הגרלת איבר בתו ביטויי חשבוניי‪ ,‬כ שערכ יהיה ער אקראי בתחו רצוי‪.‬‬
‫באמצעות עצ מהמחלקה ‪ ,Random‬שהוקצה עבורו מקו בזיכרו‪ ,‬נית לבצע הגרלות חוזרות‬
‫ונשנות‪ ,‬ג מתחומי שוני‪.‬‬
‫‪-462-‬‬
‫תבניות – פרק ‪10‬‬
‫מערך מונים‬
‫כתבו אלגורית שהקלט שלו הוא ‪ 58‬ספרות והפלט שלו הוא מספר הפעמי שהופיעה כל ספרה‬
‫בקלט‪.‬‬
‫למעשה‪ ,‬עבור פתרו הבעיה האלגוריתמית אנו צריכי ‪ 10‬מוני – מונה לכל ספרה‪ .‬כדי להימנע‬
‫מסירבול‪ ,‬נגדיר מער ‪ CountDigitsArr‬בגודל ‪ .10‬מצייני המער ה מ‪ 0‬ועד ‪ ,9‬ולכ כל תא‬
‫במער מייצג את המונה של המציי‪ .‬כ‪ ,‬למשל‪ ,‬תפקידו של התא ]‪ countDigitsArr[3‬הוא למנות‬
‫את מספר הפעמי שמופיעה הספרה ‪ 3‬בקלט‪ .‬באופ כללי תפקידו של התא‬
‫]‪ countDigitsArr[digit‬הוא למנות את מספר הפעמי שמופיעה הספרה ‪ digit‬בקלט‪ .‬זהו‬
‫אלגורית המתבסס על התבנית מערך מונים‪ .‬התבנית של מערך מונים‪ ,‬כפי שמשמשת בחלקו‬
‫הראשו של פתרו בעיה זו‪ ,‬דומה לחלקו הראשו של הפתרו שהוצג בבעיה ‪ 5‬בפרק ‪.10‬‬
‫נתבונ בחלק הראשו של כל אחד משני האלגוריתמי הללו‪ ,‬לפתרו הבעיה שלעיל ולפתרו בעיה‬
‫‪ 5‬בפרק ‪:10‬‬
‫‪.1‬‬
‫‪1-á countDigitsArr[digit] úà ìãâä .1.2‬‬
‫‪numOfSingers-á íéããåîúîä øôñî úà èåì÷ .1‬‬
‫‪vote-á ãîòåî øôñî èåì÷ .2‬‬
‫‪.3‬‬
‫‪vote ≠ -1‬‬
‫‪:òöá‬‬
‫‪vote øôñî ããåîúî ìù äðåîä úà 1-á äìòä .3.1‬‬
‫‪vote-á ãîòåî øôñî èåì÷ .3.2‬‬
‫בשני קטעי האלגוריתמי האלה נית לזהות תבנית מנייה‪ ,‬אלא שהיא מופעלת על כמה מוני‬
‫הפועלי במקביל‪ ,‬ושמורי במער אחד‪.‬‬
‫נציג את מאפייני התבנית מערך מונים‪ ,‬עבור ביצוע חוזר התלוי בתנאי‪ .‬נית להתאי את‬
‫מאפייני התבנית למקרי בה מש הביצוע ידוע מראש‪ ,‬בדומה לקטע האלגורית לפתרו‬
‫הבעיה שהוצגה לעיל‪.‬‬
‫‪-463-‬‬
‫ש התבנית‪ :‬מער מוני‬
‫נקודת מוצא‪ :‬תנאי סיו ‪ ,toEnd‬סדרת ערכי‪ ,‬ביטוי חשבוני ‪ whichCounter‬המקשר בי ער‬
‫בסדרה למציי של המער‬
‫מטרה‪ :‬בניית מער מוני עבור ערכי הסדרה‪ ,‬כאשר מש הבנייה תלוי בביטוי ‪.toEnd‬‬
‫‪0-ì countElements êøòîä éøáéà úà ìçúà .1‬‬
‫‪äøãñá àáä êøòä úà íùä .2‬‬
‫‪:òöá toEnd éàðúä íéé÷úî àì ãåò ìë .3‬‬
‫‪1-á countElements[whichCounter] úà ìãâä .3.1‬‬
‫‪äøãñá àáä êøòä úà íùä .3.2‬‬
‫;הערך הבא בסדרה = ‪element‬‬
‫)‪while (!toEnd‬‬
‫{‬
‫;‪countElements[whichCounter]++‬‬
‫}‬
‫שימו ♥‪:‬‬
‫♦ התבנית כללית ואינה מפרטת מהיכ מגיעי איברי הסדרה‪ .‬ערכי אלה יכולי‪ ,‬למשל‪,‬‬
‫להתקבל כקלט או מקריאת ערכי מער אחר‪.‬‬
‫♦ המשתנה ‪ element‬מתייחס לאיבר התור בסדרה‪ .‬למרות שאי זה מופיע במפורש באלגורית‬
‫שנית עבור התבנית וביישו שלו‪ ,‬הרי פעולת המנייה תלויה ב‪ :element‬הביטוי‬
‫‪ whichCounter‬תלוי ב‪ element‬ומקשר בי ערכו לער של מציי במער‪ .‬הנה כמה דוגמאות‬
‫לביטויי אפשריי עבור ‪:whichCounter‬‬
‫• ‪) element‬כלומר‪ ,‬הער הבא בסדרה משמש כמציי למער‪ ,‬בדומה לפתרו של הבעיה‬
‫שהוצגה בתחילת הסעי‪.($‬‬
‫• ספרת העשרות של ‪.element‬‬
‫• ‪) element - 1‬בדומה לביטוי המשמש לגישה למער בפתרו בעיה ‪ 5‬בפרק ‪.(10‬‬
‫♦ בדומה לתבנית מנייה‪ ,‬ג התבנית של מערך מונים כוללת אתחול של המוני ל‪ .0‬אי לכ‬
‫התייחסות ביישו‪ ,‬משו שבשפת ‪ Java‬מתבצע אתחול אוטומטי של איברי מער שלמי ל‪.0‬‬
‫‪-464-‬‬
‫א‪ .‬ישמו את הפתרו המלא לבעיית מניית מופעי הספרות בשפת ‪.Java‬‬
‫ב‪ .‬שנו את התוכנית שכתבת בסעי‪ $‬א כ שהקלט שלה יהיה ‪ 58‬מספרי מהתחו ‪ 1‬עד ‪,10‬‬
‫והפלט שלה יהיה מספר הפעמי שהופיע כל אחד מהמספרי‪ .‬מהו הביטוי החשבוני בו‬
‫השתמשת כדי לקשר בי ער תור למציי במער?‬
‫ג‪ .‬שנו את התוכנית שכתבת בסעי‪ $‬א כ שהקלט שלה יהיה ‪ 58‬מספרי שלמי חיוביי‪ .‬הפלט‬
‫שלה יהיה עבור כל אחת מהספרות ‪ 0‬עד ‪ 9‬את מספר הפעמי שהופיעה כספרת האחדות של‬
‫מספר בקלט‪ .‬מהו הביטוי החשבוני בו השתמשת כדי לקשר בי ער תור למציי במער?‬
‫נתו המער ‪ arr‬ובו ערכי שלמי ונתו קטע התוכנית הבא‪:‬‬
‫;]‪int[] counts = new int[2‬‬
‫)‪for (i = 0; i < arr.length; i++‬‬
‫{‬
‫;]‪element = arr[i‬‬
‫;‪counts[element % 2]++‬‬
‫}‬
‫)‪for (i = 0; i < counts.length; i++‬‬
‫{‬
‫;)]‪System.out.println(counts[i‬‬
‫}‬
‫א‪ .‬מה יוצג כפלט עבור המער ‪ arr‬הבא‪:‬‬
‫]‪arr[7‬‬
‫]‪arr[6‬‬
‫]‪arr[5‬‬
‫]‪arr[4‬‬
‫]‪arr[3‬‬
‫]‪arr[2‬‬
‫]‪arr[1‬‬
‫]‪arr[0‬‬
‫‪6‬‬
‫‪89‬‬
‫‪34‬‬
‫‪11‬‬
‫‪5‬‬
‫‪198‬‬
‫‪68‬‬
‫‪90‬‬
‫ב‪ .‬תנו דוגמה למער ‪ arr‬בגודל ‪ ,10‬שעבורו יוצגו כפלט הערכי‪.7 3 :‬‬
‫ד‪ .‬הציעו קטע תוכנית השקול לקטע התוכנית הנתו ללא שימוש בתבנית מערך מונים‪ .‬ציינו‬
‫באילו תבניות השתמשת עבור כתיבת קטע התוכנית‪.‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא סדרת תווי המסתיימת בתו '*' והפלט שלו הוא מספר‬
‫המופעי של כל אחת מאותיות ה‪) abc‬כלומר‪ ,‬אותיות הא"ב האנגלי הקטנות(‪.‬‬
‫ב‪ .‬מהו הביטוי החשבוני בו השתמשת עבור התאמת אותיות ה‪ abc‬למצייני המער?‬
‫‪-465-‬‬
‫מערך צוברים‬
‫בעיה ‪ :1‬תלמידי שכבה י' בבית הספר "נו‪$‬י"‪ ,‬המונה ‪ 7‬כיתות‪ ,‬החליטו על מבצע לסיוע‬
‫למשפחות נזקקות‪ :‬כל תלמיד בשכבה יעבוד בעבודות מזדמנות )כגו שטיפתמכוניות‪ ,‬בייביסיטר‬
‫וכו'(‪ ,‬ואת הסכו שירוויח יעביר לקופת הכיתה‪ .‬בסו‪ $‬החודש יעבירו הנציגי מכל אחת‬
‫מהכיתות דיווח של הסכו המצטבר שנאס‪ $‬אל נציג השכבה‪ .‬נציג השכבה יעביר את הסכו‬
‫הכולל לנציג ועד השכונה‪ .‬יש לציי כי כל התלמידי בשכבה נרתמו להצלחת המבצע‪ .‬כתבו‬
‫אלגורית שהקלט שלו הוא ‪ 247‬זוגות מספרי עבור כל תלמידי השכבה‪ ,‬כאשר המספר הראשו‬
‫מייצג את מספר הכיתה של התלמיד והמספר השני מייצג את הסכו שהעביר התלמיד לקופת‬
‫הכיתה‪ .‬הפלט של האלגורית הוא הסכו המצטבר של כל אחת מהכיתות וכ הסכו הכולל‬
‫שהצטבר בשכבה‪.‬‬
‫בעיה ‪ :2‬בחנות הנעליי "נעל לכל" מעונייני לדעת מהו הפדיו היומי מס כל המכירות בכל‬
‫אחת מ‪ 5‬המחלקות בחנות )המחלקות ממוספרות מ‪ 1‬עד ‪ .(5‬כתבו אלגורית שהקלט שלו הוא‬
‫סדרה של זוגות מספרי‪ ,‬כאשר המספר הראשו בכל זוג מייצג את מספר המחלקה והמספר השני‬
‫מייצג את המחיר של סכו הקניה של לקוח‪ .‬סו‪ $‬הקלט יסומ על ידי זוג שהמספר הראשו בו‬
‫הוא ‪ .0‬הפלט של האלגורית הוא התפלגות המכירות לפי מחלקות )כלומר‪ ,‬עבור כל מחלקה‬
‫הפדיו היומי הכולל שלה(‪.‬‬
‫עבור הפתרונות של שתי הבעיות האלגוריתמיות דרושי לנו כמה צוברי‪ .‬בבעיה ‪ 1‬אנו צריכי‬
‫שבעה צוברי עבור הסכומי המצטברי לכל אחת מהכיתות‪ ,‬ובבעיה ‪ 2‬אנו צריכי חמישה‬
‫צוברי )צובר סכו מכירות לכל מחלקה(‪ .‬כדי להימנע מסירבול‪ ,‬נגדיר מער שגודלו כמספר‬
‫הצוברי הנדרש )‪ 7‬עבור בעיה ‪ 1‬ו‪ 5‬עבור בעיה ‪ .(2‬בבעיה ‪ 1‬מצייני המער מייצגי את מספרי‬
‫הכיתות‪ ,‬ובבעיה ‪ 2‬ה מייצגי את מספרי המחלקות‪ .‬כל תא במער מייצג צובר המתאי‬
‫למציי‪ .‬זהו אלגורית המתבסס על התבנית מערך צוברים‪ .‬הרעיו בבסיסה של התבנית מערך‬
‫צוברים דומה לתבנית של מער המוני‪ .‬ההבדל הוא באופי הפעולה על כל תא במער‪ :‬מנייה‬
‫במער המוני לעומת צבירה במער הצוברי‪.‬‬
‫נתבונ בשני האלגוריתמי הבאי‪ ,‬הראשו לפתרו בעיה ‪ 1‬והשני לפתרו בעיה ‪:2‬‬
‫‪.1‬‬
‫‪-á ãéîìú çéååøäù óñë íåëñå classNum-á äúéë øôñî èåì÷ .1.1‬‬
‫‪sumStudent‬‬
‫‪sumStudent-á sumClasses[classNum-1] úà ìãâä .1.2‬‬
‫‪-466-‬‬
0-ì sumTotal úà ìçúà .2
:òöá 6 ãò 0 íåçúá íìù i ìë øåáò
.3
sumClasses[i] :àåä i+1 äúéëì øáèöîä íåëñä :èìôë âöä .3.1
sumClasses[i]-á sumTotal úà ìãâä .3.2
sumTotal àåä äáëùì øáèöîä íåëñä :èìôë âöä .4
price-á çå÷ì ìù äéð÷ä íåëñå departmentNum-á ä÷ìçî øôñî èåì÷ .1
:òöá 0-î äðåù departmentNum ãåò ìë
.2
price-á sumDepartments[departmentNum-1] úà ìãâä .2.1
price-á çå÷ì ìù äéð÷ä íåëñå departmentNum-á ä÷ìçî øôñî èåì÷ .2.2
:òöá 4 ãò 0 íåçúá íìù i ìë øåáò
.3
sumDepartments[i] :àåä i+1 ä÷ìçîì éîåéä ïåéãôä :èìôë âöä .3.1
‫ אלא שהיא מופעלת על כמה צוברי‬,‫בשני קטעי האלגוריתמי האלה נית לזהות תבנית צבירה‬
.‫ ושמורי במער אחד‬,‫הפועלי במקביל‬
‫ נית להתאי‬.‫ עבור סדרת ערכי שאורכה ידוע מראש‬,‫נציג את מאפייני התבנית מערך צוברים‬
‫ התבנית‬.1 ‫ בדומה לפתרו בעיה‬,‫את מאפייני התבנית למקרי בה מש הביצוע תלוי בתנאי‬
‫ א נית להציג מאפייני של תבנית דומה המתייחסת לצבירה על‬,‫מתייחסת לצבירה על ידי סכו‬
.‫ידי מכפלה‬
-467-
‫ש התבנית‪ :‬מער צוברי‬
‫נקודת מוצא‪ :‬אור סדרת הערכי ‪ ,limit‬סדרת ערכי‪ ,‬ביטוי חשבוני ‪ whichSum‬המקשר בי‬
‫ער בסדרה למציי של המער‬
‫מטרה‪ :‬בניית מער צוברי עבור ערכי הסדרה‪ ,‬שאורכה ‪limit‬‬
‫‪íéøáåöä êøòî éëøò úà ìçúà .1‬‬
‫‪element-á äøãñá àáä êøòä úà íùä .2.1‬‬
‫‪value-á äøéáöì êøòä úà íùä .2.2‬‬
‫‪value ìù åëøò úà sumElements[whichSum]-ì óñåä .2.3‬‬
‫)‪for (i = 1; i <= limit; i++‬‬
‫{‬
‫;הערך לצבירה = ‪value‬‬
‫;‪sumElements[whichSum] += value‬‬
‫}‬
‫שימו ♥‪ :‬ג התבנית של מערך צוברים‪ ,‬הוצגה באופ כללי‪ ,‬כ שהיא מתאימה למגוו בעיות‪:‬‬
‫♦ לא נקבעו במפורש הערכי לאתחול‪ .‬במקרה הפשוט‪ ,‬מאותחלי כל הצוברי ל‪ .0‬במקרה‬
‫כזה‪ ,‬ביישו בשפת ‪ Java‬אי צור לבצע אתחול מפורש‪ ,‬משו שב‪ Java‬מתבצע אתחול‬
‫אוטומטי של איברי מער שלמי ל‪.0‬‬
‫♦ בדומה לתבנית מערך מונים‪ ,‬ג התבנית של מערך צוברים אינה מפרטת מהיכ מגיעי‬
‫איברי הסדרה‪ .‬ערכי אלה יכולי‪ ,‬למשל‪ ,‬להתקבל כקלט או מקריאת ערכי מער אחר‪.‬‬
‫♦ התבנית של מערך צוברים ג אינה מפרטת כצד מחושבי הערכי לצבירה‪ .‬ג ערכי אלה‬
‫יכולי‪ ,‬למשל‪ ,‬להתקבל כקלט או מקריאת ערכי מער אחר‪ ,‬וייתכ כי נית לחשב‪ ,‬עבור כל‬
‫איבר ‪ ,element‬בעזרת ביטוי חשבוני מסוי התלוי ב‪ ,element‬את ער הצבירה המתאי לו‬
‫‪.value‬‬
‫♦ כמו בתבנית מערך מונים‪ ,‬ג בתבנית של מערך צוברים המשתנה ‪ element‬מתייחס לאיבר‬
‫התור בסדרה‪ ,‬ולמרות שאי זה מופיע במפורש באלגורית שנית עבור התבנית וביישו שלו‪,‬‬
‫הרי פעולת הצבירה תלויה ב‪ :element‬הביטוי ‪ whichSum‬תלוי ב‪ element‬ומקשר בי ערכו‬
‫לער של מציי במער‪.‬‬
‫‪-468-‬‬
‫ישמו את שני האלגוריתמי עבור בעיות ‪ 1‬ו‪ 2‬בשפת ‪.Java‬‬
‫לאור הצלחת המבצע לסיוע למשפחות נזקקות החליטה הנהלת ביתהספר "נו‪ $‬י" להעניק יו‬
‫טיול לנגב לתלמידי הכיתה שאספה את הסכו המירבי‪ .‬יש להרחיב את האלגורית כ שיוצג‬
‫כפלט ג מספר הכיתה שזכתה ביו הטיול‪ .‬א יש יותר מכיתה אחת שאספה את הסכו המירבי‬
‫יוענק יו טיול לכול‪.‬‬
‫נתו האלגורית הבא לפתרו הבעיה‪:‬‬
‫‪0-ì sumClasses êøòîä éøáéà úà ìçúà .1‬‬
‫‪.2‬‬
‫‪-á ãéîìú çéååøäù óñë íåëñå classNum-á äúéë øôñî èåì÷ .2.1‬‬
‫‪sumStudent‬‬
‫‪sumStudent-á sumClasses[classNum-1] úà ìãâä .2.2‬‬
‫‪0-ì sumTotal úà ìçúà .3‬‬
‫‪.4‬‬
‫‪:òöá 6 ãò 0 íåçúá íìù i ìë øåáò‬‬
‫‪sumClasses[i] :àåä i+1 äúéëì øáèöîä íåëñä :èìôë âöä .4.1‬‬
‫‪sumClasses[i]-á sumTotal úà ìãâä .4.2‬‬
‫‪sumTotal àåä äáëùì øáèöîä íåëñä :èìôë âöä .5‬‬
‫‪sumClasses[0]-ì max úà ìçúà .6‬‬
‫‪.7‬‬
‫‪sumClasses[i] > max íà .7.1‬‬
‫‪sumClasses[i] ìù êøòä úà max-á íùä .7.1.1‬‬
‫‪.8‬‬
‫‪maxì äååù sumClasses[i] ìù åëøò íà .8.1‬‬
‫‪áâðì ìåéè íåéá äëåæ i+1 øôñî äúéë :èìôë âöä .8.1.1‬‬
‫א‪ .‬ציינו מה התבניות המשולבות באלגורית‪.‬‬
‫ב‪ .‬ישמו את האלגורית בשפת ‪) Java‬כזכור‪ ,‬אי צור לייש את שלב אתחול המער(‪.‬‬
‫בחנות הנעליי "נעל לכל" מעונייני לדעת את הפדיו מס כל המכירות בכל אחד מימות השבוע‪.‬‬
‫יש לכתוב אלגורית שהקלט שלו הוא סדרות של ספרי ממשיי )המסתיימות בזקי‪ – (0 $‬סדרה‬
‫‪-469-‬‬
‫עבור כל יו מהימי א' עד ו'‪ .‬המספרי הממשיי מייצגי את סכומי הקניות של הלקוחות‪.‬‬
‫הפלט של האלגורית הוא התפלגות המכירות לפי ימי )כלומר‪ ,‬עבור כל יו הפדיו הכולל שלו(‪.‬‬
‫נתו האלגורית הבא לפתרו הבעיה‪:‬‬
‫‪0-ì sumDays êøòîä éøáéà úà ìçúà .1‬‬
‫‪.2‬‬
‫‪:òöá 5 ãò 0 íåçúá íìù day ìë øåáò‬‬
‫‪price-á äéð÷ íåëñ èåì÷ .2.1‬‬
‫‪.2.2‬‬
‫‪:òöá 0-î äðåù price ìù åëøò ãåò ìë‬‬
‫‪price-á sumDays[day] úà ìãâä .2.2.1‬‬
‫‪price-á äéð÷ íåëñ èåì÷ .2.2.2‬‬
‫‪.3‬‬
‫‪:òöá 5 ãò 0 íåçúá íìù day ìë øåáò‬‬
‫‪sumDays[day] àåä day+1 íåé øåáò éîåéä ïåéãôä :èìôë âöä .3.1‬‬
‫א‪ .‬באלגורית ישנו שימוש בתבנית מערך צוברים‪ .‬הציעו אלגורית השקול לאלגורית הנתו‬
‫ללא שימוש בתבנית מערך צוברים‪ .‬ציינו באילו תבניות השתמשת עבור כתיבת האלגורית‪.‬‬
‫ב‪ .‬ישמו את האלגורית הנתו בשפת ‪) Java‬כזכור‪ ,‬אי צור לייש את שלב אתחול המער(‪.‬‬
‫א‪ .‬במוסד לביטוח רפואי בוצע מחקר על צריכת ‪ 150‬תרופות על ידי החולי המבוטחי‪ .‬לכל‬
‫תרופה מספר סידורי בי ‪ 1‬ל‪ .150‬פתחו אלגורית‪ ,‬שהקלט שלו הוא סדרת שלשות של‬
‫ערכי‪ ,‬כאשר כל שלשה מייצגת גיל של מבוטח‪ ,‬מספר סידורי של התרופה שנצרכה והכמות‬
‫שלה )מספר יחידות(‪ .‬סדרת הקלט מסתיימת ע קליטת הזקי‪ -1 $‬כגיל המבוטח‪ .‬הפלט של‬
‫האלגורית הוא קבוצת הגילאי הצורכת כמות תרופות כוללת גדולה ביותר‪ ,‬מבי ‪ 4‬קבוצות‬
‫הגילאי הבאות‪ :‬קבוצת גילאי ‪ 0‬עד ‪ ,10‬קבוצת גילאי ‪ 11‬עד ‪ ,30‬קבוצת גילאי ‪ 31‬עד ‪,50‬‬
‫קבוצת גילאי ‪ 51‬ומעלה‪ .‬ייתכ שיותר מקבוצת גיל אחת צורכת את כמות התרופות הכוללת‬
‫הגדולה ביותר‪.‬‬
‫שימו לב‪ :‬לצור פתרו סעי‪ $‬זה אי צור להבחי בי סוגי התרופות השוני‪.‬‬
‫ב‪ .‬הרחיבו את האלגורית כ שיוצגו כפלט ג מספרי התרופות שלא נצרכו כלל‪.‬‬
‫ג‪ .‬ציינו באילו תבניות השתמשת בכתיבת האלגורית וכיצד שילבת ביניה‪.‬‬
‫‪-470-‬‬
‫חישוב שכיח‬
‫כתבו אלגורית שהקלט שלו הוא ‪ 58‬ספרות והפלט שלו הוא הספרה שהופיעה בקלט הכי הרבה‬
‫פעמי‪ .‬א יש יותר מספרה אחת כזאת‪ ,‬יש להציג את כול‪.‬‬
‫לצור פתרו הבעיה צרי קוד כל למנות את מספר המופעי של כל אחת מהספרות‪ .‬לש כ‪,‬‬
‫נשתמש בתבנית מערך מונים‪ .‬לאחר מכ‪ ,‬עלינו לחשב את הער המקסימלי מבי ערכי המוני‪.‬‬
‫זהו למעשה הער השכיח‪ ,‬כלומר הער שהופיע מספר פעמי רב ביותר‪ .‬לצור כ נוכל להשתמש‬
‫בתבנית של מציאת מקסימום בסדרה‪ ,‬כדי למצוא את הער המקסימלי‪ ,‬ולאחר מכ להשתמש‬
‫בתבנית של מציאת כל הערכים בסדרה המקיימים תנאי‪ ,‬כאשר התנאי הוא שוויו לער‬
‫המקסימלי‪ ,‬תו הצגה כפלט של מצייני הערכי שנמצאו‪ .‬יש לשי לב‪ ,‬שעלינו לבצע שינויי‬
‫קלי בתבניות מציאת מקסימום בסדרה ומציאת כל הערכים בסדרה המקיימים תנאי‬
‫מאחר שהערכי בסדרה אינ נקראי מהקלט‪ ,‬אלא שמורי במערך מונים‪.‬‬
‫‪.1‬‬
‫‪1-á countDigitsArr[digit] úà ìãâä .1.2‬‬
‫‪countDigitsArr[0] úà max-á íùä .2‬‬
‫‪.3‬‬
‫‪max-î ìåãâ countDigitsArr[i] íà .3.1‬‬
‫‪countDigitsArr[i] ìù êøòä úà max-á íùä .3.1.1‬‬
‫‪.4‬‬
‫‪max-ì äååù countDigitsArr[i] íà .4.1‬‬
‫‪íéîòô äáøä éëä äòéôåä i äøôñ :èìôë âöä .4.1.1‬‬
‫נציג את מאפייני התבנית חישוב שכיח עבור ביצוע חוזר שאורכו ידוע מראש‪ .‬נית להתאי את‬
‫מאפייני התבנית לביצוע חוזר התלוי בתנאי‪.‬‬
‫‪-471-‬‬
‫ חישוב שכיח‬:‫ש התבנית‬
‫ המקשר בי‬whichSum ‫ ביטוי חשבוני‬,‫ סדרת ערכי‬,limit ‫ אור סדרת הערכי‬:‫נקודת מוצא‬
‫ער בסדרה למציי של המער‬
limit ‫ שאורכה הוא‬,‫ הצגה כפלט של הער השכיח או הערכי השכיחי בסדרת הקלט‬:‫מטרה‬
íéðåîä êøòî éëøò úà ìçúà .1
:íéîòô limit òöá .2
element-á äøãñá àáä êøòä úà íùä .2.1
1-á sumElements[whichCount] úà ìãâä .2.2
countElements[0] ìù åëøòì max úà ìçúà .3
:òöá countElements êøòîä êøåà ãò 1-î íåçúá íìù i ìë øåáò .4
countElements[i] > max íà .4.1
countElements[i] ìù êøòä úà max-á íùä .4.1.1
:òöá countElements êøòîä êøåà ãò 1-î íåçúá íìù i ìë øåáò .5
max-ì äååù countElements[i] ìù åëøò íà 5.1
i
úà èìôë âöä .5.1.1
for (i = 1; i <= limit; i++)
{
element = ‫;הערך הבא בסדרה‬
sumElements[whichCount]++;
}
max = countElements[0];
for (i = 1; i < countElements.length; i++)
{
if (countElements[i] > max)
{
max = countElements[i];
}
}
for (i = 0; i < countElements.length; i++)
{
if (countElements[i] == max)
{
System.out.println(counts[i]);
}
}
-472-
‫שימו ♥‪ :‬באלגורית של התבנית בחרנו להציג כפלט את הער השכיח או הערכי השכיחי‬
‫אבל נית לבצע על ערכי אלו פעולות חישוביות שונות כגו מנייה‪ ,‬צבירה וכו'‪.‬‬
‫המורה אמיר החליט לבצע כמה עיבודי סטטיסטיי על ציוני ‪ 40‬תלמידיו ב"יסודות מדעי‬
‫המחשב"‪ .‬אמיר חילק את ציוני התלמידי‪ ,‬הנעי בי ‪ 0‬ל‪ ,100‬ל‪ 10‬קבוצות באופ הבא‪:‬‬
‫קבוצת הציוני בי ‪ 0‬ל‪) 10‬קבוצת ציוני ראשונה(‪ ,‬קבוצת הציוני בי ‪ 11‬ל‪) 20‬קבוצת ציוני‬
‫שנייה( וכ הלאה עד קבוצת הציוני בי ‪ 91‬ל‪) 100‬קבוצת ציוני עשירית(‪.‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא ציוני ‪ 40‬התלמידי והפלט שלו הוא מספר התלמידי בכל‬
‫קבוצת ציוני‪ ,‬וכ קבוצת הציוני השכיחה )תיתכ יותר מקבוצה אחת(‪.‬‬
‫ב‪ .‬הרחיבו את האלגורית שכתבת בסעי‪ $‬א כ שיציג כפלט את טווח הציוני‪ ,‬כלומר‪ ,‬ההפרש‬
‫בי הציו הגבוה ביותר במבח לבי הציו הנמו ביותר במבח‪ .‬ציינו באילו תבניות נוספות‬
‫השתמשת וכיצד שילבת ביניה‪.‬‬
‫ג‪ .‬הרחיבו את האלגורית שכתבת בסעי‪ $‬ב כ שיציג כפלט הודעה הא הציוני מתפלגי‬
‫סימטרית‪ ,‬כלומר‪ ,‬מספר התלמידי בקבוצה הראשונה שווה למספר התלמידי בקבוצה‬
‫העשירית‪ ,‬מספר התלמידי בקבוצה השנייה שווה למספר התלמידי בקבוצה התשיעית וכ‬
‫הלאה‪ .‬ציינו באילו תבניות נוספות השתמשת וכיצד שילבת ביניה‪.‬‬
‫ד‪ .‬הרחיבו את האלגורית שכתבת בסעי‪ $‬ג כ שא הציוני מתפלגי סימטרית‪ ,‬על‬
‫האלגורית להציג הודעה הא הציוני מתפלגי סימטרית בצורת פעמו‪ ,‬כלומר‪ ,‬הערכי ב‬
‫‪ 5‬קבוצות הציוני הראשונות מהווי סדרה עולה ממש‪ ,‬והערכי ב‪ 5‬קבוצות הציוני‬
‫האחרונות מהווי סדרה יורדת ממש‪ .‬ציינו באילו תבניות נוספות השתמשת וכיצד שילבת‬
‫ביניה‪.‬‬
‫ה‪ .‬ישמו את האלגורית המורחב שכתבת בסעי‪ $‬ד בשפת ‪.Java‬‬
‫‪-473-‬‬
‫הזזה מעגלית בסדרה‬
‫בפרק ‪ 3‬הראינו את התבנית הזזה מעגלית בסדרה עבור סדרה בת שני ערכי‪ .‬עתה נרחיב את‬
‫התבנית עבור סדרת ערכי באור כלשהו‪ .‬נזכיר כי ישנ שני סוגי הזזות מעגליות‪ :‬הזזה מעגלית‬
‫שמאלה והזזה מעגלית ימינה‪.‬‬
‫נפריד את מאפייני התבנית הזזה מעגלית בסדרה לשתי תתתבניות‪ :‬ראשית נציג את מאפייני‬
‫התבנית הזזה מעגלית שמאלה בסדרה ואחר כ נציג את מאפייני התבנית הזזה מעגלית‬
‫ימינה בסדרה‪.‬‬
‫ש התבנית‪ :‬הזזה מעגלית שמאלה בסדרה‬
‫נקודת מוצא‪ :‬סדרת ערכי במער ‪ elements‬שאורכו ‪length‬‬
‫מטרה‪ :‬הזזה מעגלית שמאלה של ערכי המער‬
‫‪elements[0] úà temp-á íùä .1‬‬
‫‪ 0 íåçúá íìù i ìë øåáò .2‬עד ‪:òöá length-2‬‬
‫‪elements[i+1] ìù êøòä úà elements[i]-á íùä .2.1‬‬
‫‪temp ìù êøòä úà elements[length-1]-á íùä .3‬‬
‫;]‪temp = elements[0‬‬
‫)‪for (i = 0; i <= elements.length - 2; i++‬‬
‫{‬
‫;]‪elements[i] = elements[i + 1‬‬
‫}‬
‫;‪elements[elements.length - 1] = temp‬‬
‫‪-474-‬‬
‫ש התבנית‪ :‬הזזה מעגלית ימינה בסדרה‬
‫נקודת מוצא‪ :‬סדרת ערכי במער ‪ elements‬שאורכו ‪length‬‬
‫מטרה‪ :‬הזזה מעגלית ימינה של ערכי המער‬
‫‪elements[length-1] úà temp-á íùä .1‬‬
‫‪øåáò .2‬‬
‫‪(ãøåé øãñá) 1 ãò length-1 íåçúá íìù i ìë‬‬
‫‪:òöá‬‬
‫‪elements[i-1] ìù êøòä úà elements[i]-á íùä .2.1‬‬
‫‪temp ìù êøòä úà elements[0]-á íùä .3‬‬
‫;]‪temp = elements[elements.length - 1‬‬
‫)‪for (i = elements.length -1; i >= 1; i--‬‬
‫{‬
‫;]‪elements[i] = elements[i - 1‬‬
‫}‬
‫;‪elements[0] = temp‬‬
‫שימו ♥‪ :‬לש פשטות‪ ,‬התבנית מניחה שאיברי הסדרה המיועדי להזזה נמצאי במער‬
‫‪ ,elements‬האחד אחרי השני‪ .‬אבל‪ ,‬ייתכ שהסדרה שבה נדרש לבצע הזזה מעגלית היא תתסדרה‬
‫)רצופה או לא רצופה( של איברי המער‪ .‬שאלה ‪ 10‬מתייחסת לבעיה כזאת‪.‬‬
‫נתו אלגורית‪ ,‬שהקלט שלו הוא ‪ 6‬מספרי שיישמרו במער ‪ ,numbers‬ומספר של חיובי‬
‫‪:num‬‬
‫‪.1‬‬
‫‪numbers[i]-á íìù øôñî èåì÷ .1.1‬‬
‫‪.3‬‬
‫‪:íéîòô num òöá‬‬
‫‪ .3.1‬הזזה מעגלית שמאלה במערך ‪numbers‬‬
‫א‪ .‬נקלטו הערכי הבאי למער ‪21 34 9 78 6 4 :numbers‬‬
‫‪ .1‬מה יהיה הפלט של האלגורית עבור הקלט ‪ 5‬ל‪?num‬‬
‫‪ .2‬מה יהיה הפלט של האלגורית עבור הקלט ‪ 35‬ל‪?num‬‬
‫‪-475-‬‬
‫ב‪ .‬מהו מספר הפעמי שמתבצעת פעולת התבנית‪ :‬הזזה מעגלית שמאלה?‬
‫ג‪ .‬כתבו אלגורית יעיל יותר‪ ,‬השקול לאלגורית הנתו כ שפעולת התבנית‪ :‬הזזה מעגלית‬
‫שמאלה תתבצע מספר קט יותר של פעמי‪ .‬ציינו באיזו תבנית השתמשת עבור כתיבת‬
‫האלגורית היעיל‪.‬‬
‫ד‪ .‬ישמו את האלגורית היעיל בשפת ‪.Java‬‬
‫שאלה ‪10‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא ‪ 16‬מספרי למער‪ ,‬והפלט שלו הוא ערכי המער לאחר‬
‫הזזה מעגלית שמאלה עבור סדרת המספרי הנמצאי במקומות האיזוגיי במער והזזה‬
‫מעגלית ימינה עבור סדרת המספרי הנמצאי במקומות הזוגיי במער‪.‬‬
‫‪-476-‬‬
‫הזזה של תת‪-‬סדרה‬
‫הזזה של תת‪-‬סדרה היא תבנית הנחוצה בהקשרי רבי בעיבוד סדרות‪ .‬הזזה של תת‪-‬סדרה‬
‫היא תבנית הזזה ליניארית )לא מעגלית( של תתסדרה של ערכי אל מקו אחד שמאלה או אל‬
‫מקו אחד ימינה‪ .‬הנה שתי דוגמאות בולטות לשימוש בתבנית‪ :‬הוצאת ער ממקו ‪ k‬בסדרה‬
‫ו"צמצומה לשמאל"‪ ,‬כלומר‪ ,‬הזזה במקו אחד שמאלה של כל האיברי מהמקו ‪ k+1‬וימינה;‬
‫"ריווח הסדרה ימינה" על ידי הזזה של הערכי החל מהמקו ה‪ k+1‬ימינה כדי לפנות מקו‬
‫להכנסה של איבר חדש לסדרה במקו ה‪ .k‬במקרה של "צמצו לשמאל" מתבצעת פעולת‬
‫"הוצאה" של ער מהמקו ה‪ k‬לפני ההזזה‪ ,‬ובמקרה של "ריווח ימינה" תתבצע פעולת "הכנסה"‬
‫של ער חדש למקו ה‪ k‬אחרי ההזזה‪ .‬באופ דומה נית לבצע "צמצו לימי" ו"ריווח‬
‫שמאלה"‪.‬‬
‫נפריד את מאפייני התבנית הזזה של תת‪-‬סדרה לשתי תתתבניות‪ :‬ראשית נציג את מאפייני‬
‫התבנית הזזה של תת‪-‬סדרה שמאלה ואחר כ נציג את מאפייני התבנית הזזה של תת‪-‬סדרה‬
‫ימינה‪.‬‬
‫ש התבנית‪ :‬הזזה של תתסדרה שמאלה‬
‫נקודת מוצא‪ :‬סדרת ערכי במער ‪ elements‬באור ‪ ,length‬מקו ‪ k‬במער )‪(0 ≤ k <length-1‬‬
‫מטרה‪ :‬הזזה שמאלה של התתסדרה הנמצאת במקומות ‪ k+1..length-1‬למקומות‬
‫‪k..length-2‬‬
‫‪:òöá length-2 ãò k-î íåçúá íìù i ìë øåáò .1‬‬
‫‪elements[i+1] ìù êøòä úà elements[i]-á íùä .2‬‬
‫)‪for (i = k; i <= elements.length - 2; i++‬‬
‫{‬
‫;]‪elements[i] = elements[i + 1‬‬
‫}‬
‫‪-477-‬‬
‫ש התבנית‪ :‬הזזה של תתסדרה ימינה‬
‫נקודת מוצא‪ :‬סדרת ערכי במער ‪ elements‬באור ‪ ,length‬מקו ‪ k‬במער )‪(0 < k ≤ length-1‬‬
‫מטרה‪ :‬הזזה ימינה של התתסדרה הנמצאת במקומות ‪ 0 .. k-1‬למקומות ‪1 .. k‬‬
‫‪.1‬‬
‫‪:òöá (ãøåé øãñá) 1 ãò k-î íåçúá íìù i ìë øåáò‬‬
‫‪elements[i-1] ìù êøòä úà elements[i]-á íùä .1.1‬‬
‫)‪for (i = k; i >= 1; i--‬‬
‫{‬
‫;]‪elements[i] = elements[i - 1‬‬
‫}‬
‫שאלה ‪11‬‬
‫ברשימת החולי המוזמני לרופא מומחה נקבעה לכל מוזמ פגישה‪ ,‬החל מהשעה ‪ 16:00‬ועד‬
‫השעה ‪ ,20:00‬כאשר לכל מוזמ מוקדש פרק זמ של חצי שעה‪.‬‬
‫מקרה בהול גר להכנסת חולה חדש לרשימה בשעה ‪ ,18:30‬ולכ יש לעדכ אצל המזכירה‬
‫הרפואית את רשימת המוזמני‪ ,‬המסודרת לפי סדר פגישת המיועדת ע הרופא‪.‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא הרשימה התחילית של מספרי הזהות של ‪ 9‬החולי‬
‫המוזמני וכ את מספר הזהות של החולה החדש‪ ,‬והפלט שלו הוא רשימת מספרי הזהות של‬
‫החולי‪ ,‬על פי הסדר לאחר העדכו‪ ,‬כאשר לכל חולה מוצגת ג שעת הפגישה המיועדת לו ע‬
‫הרופא‪.‬‬
‫שאלה ‪12‬‬
‫ב"מכרז המבטיח" מנהלי רישו של הצעות רכישה ל‪ 5‬מערכות ישיבה לסלו‪ .‬המידע נשמר‬
‫עבור ‪ 20‬ההצעות הגבוהות ביותר וה מסודרות לפי סדר יורד‪.‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא ‪ 20‬הסכומי של ההצעות הגבוהות שהתקבלו עד כה‪ ,‬וכ‬
‫סכו של הצעה חדשה‪ ,‬והפלט שלו הוא ‪ 20‬ההצעות הגבוהות ביותר לאחר העדכו של ההצעה‬
‫החדשה‪.‬‬
‫ב‪ .‬ציינו באילו תבניות השתמשת וכיצד שילבת ביניה?‬
‫ג‪ .‬הרחיבו את האלגורית כ שיציג כפלט את הסכומי של הזוכי ב‪ 5‬מערכות הישיבה לסלו‪.‬‬
‫ציינו באיזו תבנית נוספת השתמשת וכיצד שילבת אותה באלגורית‪.‬‬
‫‪-478-‬‬
‫היפוך סדר הערכים בסדרה‬
‫בפרק ‪ 3‬הראינו את התבנית היפוך סדר הערכים בסדרה עבור סדרה בת שני ערכי‪ .‬עתה‬
‫נרחיב את התבנית עבור סדרת ערכי באור כלשהו‪.‬‬
‫לצור היפוך סדר הערכים בסדרה אפשר להחלי‪ $‬בי הער הראשו בסדרה לבי הער האחרו‬
‫בסדרה‪ ,‬להחלי‪ $‬בי הער השני בסדרה לבי הער הלפני אחרו בסדרה וכ הלאה‪.‬‬
‫נציג את מאפייני התבנית היפוך סדר האיברים בסדרה‪:‬‬
‫ש התבנית‪ :‬היפו סדר האיברי בסדרה‬
‫נקודת מוצא‪ :‬סדרת ערכי במער ‪elements‬‬
‫מטרה‪ :‬היפו סדר הערכי במער‪ ,‬שאורכו ‪length‬‬
‫‪ úà limit-á íùä .1‬מנת החלוקה של ‪ length‬פריטים לשתי קבוצות‬
‫‪:òöá limit-1 ãò 0-î íåçúá íìù i ìë øåáò .2‬‬
‫‪ .2.1‬החלף את הערכים של ]‪ elements[i‬ושל ]‪elements[length-i-1‬‬
‫שימו ♥‪ :‬ההחלפה מתבצעת עד מחצית אור סדרת הערכי‪ .‬א אורכה אינו זוגי‪ ,‬אז האיבר‬
‫האמצעי אינו מוחל‪ $‬ע א‪ $‬איבר‪ ,‬ונשאר במקומו‪ ,‬כפי שאכ צרי להיות‪.‬‬
‫שאלה ‪13‬‬
‫א‪ .‬כתבו אלגורית‪ ,‬שהקלט שלו הוא ‪ 15‬מספרי למער‪ ,‬המסודרי בסדר עולה‪ ,‬והפלט שלו‬
‫הוא ערכי המער לאחר היפוכ‪.‬‬
‫ב‪ .‬שנו את האלגורית שכתבת בסעי‪ $‬א כ שיהפו את הסדר של ‪ 12‬האיברי הראשוני‬
‫במער‪ .‬שלושת הערכי הגדולי ביותר במער יישארו במקומ‪ .‬הפלט יהיה ערכי המער‬
‫לאחר ההיפו‪.‬‬
‫ג‪ .‬נית לבצע את האלגוריתמי שבסעיפי א וב ללא שימוש בתבנית היפוך סדר הערכים‬
‫בסדרה‪ .‬כתבו את האלגוריתמי המתאימי‪.‬‬
‫‪-479-‬‬

1 יסודות מדעי המחשב

Transcription

Similar documents

אזרחות

2 תרגיל בית מספר

Java - השראה הוצאה לאור

לחצו כאן

דף נוסחאות 2

הקדמה לניתוח סיבוכיות של בעיות

שיעור במבני נתונים ויעילות אלגוריתמים מיום ד

כתה ט – רצף הוראה כימיה

לצפייה במבחן בדף מלא לחץ כאן

אירית שדה רות אמיר - המרכז הארצי למורי ביולוגיה