דילוג לתוכן המרכזי

סיכום ביצוע מותנה וביצוע חוזר

מדעי המחשב לבגרות · 6 נושאים

כל מה שצריך לדעת בביצוע מותנה וביצוע חוזר: המושגים, הכללים, דרכי פתרון וקוד ב-Java וב-C# עם דוגמאות פתורות משאלוני הבגרות. לחזרה מהירה לפני הבחינה - הסיכום המקוצר או דף כללים.

מבני בקרה

עד עכשיו כל הוראה בתוכנית התבצעה פעם אחת, לפי הסדר. מבני הבקרה משנים את זה: הם מחליטים אם הוראה תתבצע וכמה פעמים. כמעט כל שאלה בשאלון 899371 בנויה מהם.
במדויק: ביצוע מותנה (if, if ... else) - קבוצת הוראות שמתבצעת רק אם תנאי בוליאני מתקיים. ביצוע חוזר - לולאה: for כשמספר החזרות ידוע מראש, while כשהלולאה נעצרת לפי תנאי. בבחינה משלבים אותם: תנאי בתוך לולאה (מונה, צובר, דגל), לולאה בתוך לולאה, ולולאה שמפרקת מספר לספרות.

1. ביצוע מותנה: if, else ותנאים מורכבים

ביצוע מותנה

תוכנית צריכה להגיב אחרת לנתונים שונים: נהג מהיר מדי מקבל קנס, ותושב בן 70 ומעלה מקבל הנחה. משפט if בודק תנאי, ולפי התשובה מחליט מה לבצע.
במדויק: תנאי הוא ביטוי בוליאני - ביטוי שערכו true או false, כמו speed >= max + 10. תנאי מורכב בנוי מכמה תנאים שמחוברים ב-&& (וגם), || (או) ו-! (לא). if מבצע את הגוף רק כשהתנאי true; if ... else מבצע בדיוק אחד משני הגופים. בבחינה צריך לתרגם תנאי מילולי ("גבוהה ב-10 קמ"ש לפחות") לתנאי בקוד, בדיוק בגבולות.

כמעט כל לולאה בבחינה מכילה if: מונה גדל רק כשתנאי מתקיים, ודגל נדלק רק כשמופיע ערך מסוים (ראו "צבירה, מנייה, ממוצע, מקסימום ומינימום"). פעולה שמחזירה ערך בוליאני אפשר לשים ישר בתוך התנאי: if (isPerfect(i)).

פעולות השוואה ופעולות בוליאניות

פעולהJava ו-C#דוגמה מהבגרות
שווה / שונה== / !=place == i, status[i] != 0
גדול / גדול או שווה> / >=sum > 150, age >= 70
קטן / קטן או שווה< / <=speed <= min - 10
וגם: שני התנאים מתקיימים&&quantity >= 10 && sum > 170.00
לא: הופך את הערך!if (!check(products))

או (לפחות אחד מתקיים) כותבים ||, למשל avg > 5.0 || countHigh > num / 2.0 || hit10.
&& נותן true רק כששני הצדדים true; || נותן false רק כששני הצדדים false.

המילים בשאלה והסימן בקוד

בשאלה כתובבקוד
"70 ומעלה", "לפחות 10">= 70, >= 10
"גדול מ-150", "מעל 5.0"> 150, > 5.0
"גבוהה ב-10 לפחות מ-max"speed >= max + 10
"נמוכה ב-10 לפחות מ-min"speed <= min - 10
"... וגם ..."&& בין התנאים

"לפחות אחד מן המקרים" - || בין התנאים.

ענפים נפרדים מול שרשרת else if

// ענפים נפרדים: כל תנאי נבדק, ויכולים להתבצע כמה ענפים
if (age >= 12)
    arr[0] = 1;
if (age >= 16)
    arr[1] = 1;
if (age >= 18)
    arr[2] = 1;

// שרשרת if - else if - else: מתבצע רק הענף הראשון שתנאו מתקיים
if (speed >= max + 10)
    status = 1;
else if (speed <= min - 10)
    status = -1;
else
    status = 0;
מבנהמה מתבצעמתי משתמשים
כמה if נפרדיםכל תנאי נבדק; כמה גופים יכולים להתבצעכמה דברים יכולים להיות נכונים יחד: בן 18 רשאי בכל שלושת המתקנים
if - else if - elseרק הגוף הראשון שתנאו מתקייםבדיוק מקרה אחד: מהירות היא "מהירה מדי", "איטית מדי" או "תקינה"
דרך הפתרון

תרגום תנאי מילולי לקוד

1.מסמנים את מילות הגבול: "לפחות", "ומעלה", "מעל", "גדול מ-". הן קובעות אם כותבים > או >=.
2.כותבים כל תנאי לבד, ורק אחר כך מחברים ב-&& או ב-||.
3.בוחרים מבנה: אם כמה מקרים יכולים להתקיים יחד - if נפרדים; אם בדיוק אחד - שרשרת else if, או return בכל ענף.
4.בודקים את ערך הגבול עצמו: בדיוק 80 כש-max = 70, בדיוק 150, בדיוק גיל 70. אחר כך ערך אחד מעליו ואחד מתחתיו.
שים לב

שרשרת else if שמתחילה מהגיל הנמוך נותנת תשובה שגויה כשכמה מקרים נכונים יחד: בפעולה checkAge / CheckAge, עם else if בן 18 יקבל רק [1, 0, 0], כי אחרי age >= 12 שאר הענפים מדולגים. שם צריך שלושה if נפרדים.

שים לב

return מסיים את הפעולה מיד. לכן בפעולה שמחזירה ערך, if נפרדים שבכל אחד return מתנהגים כמו שרשרת: if (speed >= max + 10) return 1; ואחריו if (speed <= min - 10) return -1;, ובסוף return 0;.

שים לב

לא משווים ערכים ממשיים (double) ב-== או ב-!=: המספר נשמר בזיכרון בקירוב, ושני חישובים "שווים" יכולים לצאת שונים. בבגרות משווים ממוצע לגבול ב-> (avg > 5.0), לא ב-==.

דוגמה א - סיווג מהירות נסיעה לקנס

הפרמטר max הוא מהירות הנסיעה המקסימלית המותרת בקטע כביש (בקמ"ש), והפרמטר min הוא מהירות הנסיעה המינימלית המותרת באותו קטע.
כתבו פעולה חיצונית ששמה getStatus בשפת Java או GetStatus בשפת C# המקבלת מספר שלם חיובי speed (מהירות הנסיעה של כלי רכב), ואת הפרמטרים max ו-min. הפעולה תחזיר:

•1, אם מהירות הנסיעה גבוהה ב-10 קמ"ש לפחות מהמהירות המקסימלית המותרת;
•-1, אם מהירות הנסיעה נמוכה ב-10 קמ"ש לפחות מהמהירות המינימלית המותרת;
•0, אם שני התנאים לא מתקיימים.
פתרון
1.התנאי הראשון: "גבוהה ב-10 לפחות מ-max" פירושו speed - max >= 10, כלומר speed >= max + 10.
2.התנאי השני: "נמוכה ב-10 לפחות מ-min" פירושו speed <= min - 10.
3.מבנה: בדיוק מקרה אחד מתקיים, ולכן return בכל ענף, ו-return 0 בסוף.
public static int getStatus(int speed, int max, int min)
{
    if (speed >= max + 10)
        return 1;
    if (speed <= min - 10)
        return -1;
    return 0;
}
4.בדיקה עם max = 70 ו-min = 30:
מהירותהבדיקהמוחזר
8080 >= 801
79אף תנאי לא מתקיים0
2020 <= 20-1
21אף תנאי לא מתקיים0
תשובה

speed >= max + 10 - מחזירים 1; speed <= min - 10 - מחזירים -1; אחרת 0.

דוגמה ב - בניית מספר זכאות משלושה תנאים נפרדים

תושב שגילו 70 ומעלה זכאי להנחה בארנונה; תושב שיש לו 3 ילדים ומעלה זכאי להנחה בגני הילדים; תושב שמקום עבודתו בעיר זכאי להנחה בחניה.
הזכאות מיוצגת במספר תלת-ספרתי שמורכב מהספרות 1 (זכאי) ו-2 (לא זכאי): ספרת המאות - ארנונה, ספרת העשרות - גני ילדים, ספרת האחדות - חניה. למשל 122: זכאי להנחה בארנונה בלבד.
כתבו פעולה חיצונית ששמה discounts בשפת Java או Discounts בשפת C#, המקבלת את age (גיל, שלם), את num (מספר הילדים, שלם) ואת city (האם מקום העבודה בעיר, בוליאני), ומחזירה את המספר התלת-ספרתי.

פתרון
1.שלושה תנאים בלתי תלויים: תושב יכול להיות זכאי לכמה הנחות יחד, ולכן שלושה if נפרדים, לא שרשרת.
2.ערך ברירת מחדל: כל ספרה מתחילה ב-2 (לא זכאי), ומשתנה ל-1 אם התנאי שלה מתקיים.
3.מילות הגבול: "70 ומעלה" - age >= 70; "3 ילדים ומעלה" - num >= 3.
4.הרכבת המספר: hundreds * 100 + tens * 10 + units.
public static int discounts(int age, int num, boolean city)
{
    int hundreds = 2;   // 2 = לא זכאי
    int tens = 2;
    int units = 2;
    if (age >= 70)
        hundreds = 1;   // הנחה בארנונה
    if (num >= 3)
        tens = 1;       // הנחה בגני ילדים
    if (city)
        units = 1;      // הנחה בחניה
    return hundreds * 100 + tens * 10 + units;
}
5.בדיקה: (75, 1, false) מחזירה 122, כמו בדוגמה; (40, 3, true) - 211; (70, 4, true) - 111; (69, 2, false) - 222.
תשובה

לכל ספרה ערך 2, ומשנים ל-1 אם age >= 70 (מאות), num >= 3 (עשרות), city (אחדות). מחזירים hundreds * 100 + tens * 10 + units.

2. לולאת for: מספר חזרות ידוע מראש

לולאת for

כשיודעים מראש כמה פעמים צריך לחזור על משהו - לכל אחד מ-850 הלקוחות, לכל תא במערך, לכל מספר מ-low עד high - כותבים לולאת for. כל המידע על החזרות נמצא בשורה אחת, הכותרת.
במדויק: בכותרת for (אתחול; תנאי; קידום) שלושה חלקים. האתחול מתבצע פעם אחת, לפני הכול. התנאי נבדק לפני כל סיבוב: אם הוא true - הגוף מתבצע, ואם false - הלולאה נגמרת. הקידום מתבצע אחרי כל סיבוב, ואז בודקים שוב את התנאי. המשתנה i (המציין) הוא משתנה רגיל: אפשר להשתמש בו בגוף (arr[i], isPerfect(i)), או רק לספור בעזרתו סיבובים.

מעבר על מערך הוא כמעט תמיד for (int i = 0; i < arr.length; i++): האינדקסים 0 עד length - 1. כשמספר הסיבובים תלוי בתנאי ולא ידוע מראש, עוברים ל-while (השיעור הבא).

כמה פעמים הלולאה רצה

כותרת הלולאההערכים של iמספר הסיבובים
for (int i = 0; i < n; i++)0, 1, ..., n - 1n
for (int i = 1; i <= n; i++)1, 2, ..., nn
for (int i = 0; i < arr.length - 1; i++)0, ..., arr.length - 2arr.length - 1
for (int i = low; i <= high; i++)low, ..., highhigh - low + 1
for (int i = 3; i <= 999999; i = i + 2)3, 5, 7, ..., 999999499999

הבדיקה האחרונה של התנאי נעשית עם הערך הראשון של i שבו התנאי נכשל: ב-for (int i = 0; i < 7; i++) זה i = 7, והוא השורה האחרונה בטבלת המעקב. (i שהוגדר בכותרת לא קיים אחרי הלולאה.)

תבנית: מעבר על תחום של מספרים

public static void thePerfects(int low, int high)
{
    for (int i = low; i <= high; i++)   // אתחול; תנאי; קידום
    {
        if (isPerfect(i))
        {
            System.out.println(i);
        }
    }
}

הפעולה thePerfects / ThePerfects מדפיסה את כל המספרים המושלמים בין low ל-high, כולל שניהם (<=). בעבור low = 4 ו-high = 10 היא מדפיסה 6.

דרך הפתרון

כתיבת הכותרת של לולאת for

1.מאיפה: הערך הראשון של i - 0 לאינדקס במערך, 1 לספירה, low לתחום.
2.עד איפה, וכולל או לא: "בין low ל-high (כולל)" - i <= high; אינדקסים של מערך - i < arr.length.
3.בכמה קופצים: i++, או i = i + 2 כשעוברים רק על האי-זוגיים.
4.בודקים את הסיבוב הראשון והאחרון: מה i בכל אחד מהם, והאם גישה כמו arr[i + 1] עדיין בתוך המערך.
שים לב

לולאה שמחפשת דוגמה נגדית מחזירה false בתוך הלולאה מיד כשמצאה, אבל מחזירה true רק אחרי הלולאה. מי שכותב else return true; בתוך הלולאה מחזיר תשובה כבר אחרי המספר הראשון.

שים לב

כשהגוף ניגש ל-a[i + 1], התנאי הוא i < a.length - 1. עם i < a.length הסיבוב האחרון ניגש לתא שלא קיים, והתוכנית נעצרת בשגיאה.

דוגמה א - מעקב אחר לולאה שמשנה את המערך

נתון המערך arr = {3, 4, 9, 6, 8, 4, 2} ונתון קטע התוכנית:

int sum = arr[0];
for (int i = 1; i < arr.length; i++)
{
    arr[i] = arr[i] - sum;
    sum += arr[i];
}

עקבו בעזרת טבלת מעקב אחר ביצוע קטע התוכנית, ורשמו את תוכן המערך arr לאחר הביצוע. בטבלת המעקב יש לכלול עמודה עבור כל אחד מהמשתנים i, arr[i], sum.

פתרון
1.אתחול: sum = arr[0], כלומר 3. הלולאה מתחילה ב-i = 1 ורצה כל עוד i < 7: שישה סיבובים.
2.בכל סיבוב, לפי הסדר: קודם arr[i] מקבל את arr[i] - sum, ורק אחר כך מוסיפים ל-sum את הערך החדש של arr[i].
סיבובii < 7arr[i] אחרי ההשמהsum אחרי ההוספה
אתחול---3
11true4 - 3 = 14
22true9 - 4 = 59
33true6 - 9 = -36
44true8 - 6 = 28
55true4 - 8 = -44
66true2 - 4 = -22
סיום7false-2
3.מה קורה כאן: sum + (arr[i] - sum) שווה לערך המקורי של arr[i]. לכן בסוף כל סיבוב sum הוא הערך המקורי של התא, וכל תא (חוץ מהראשון) הופך להפרש בין הערך המקורי שלו לערך המקורי של התא שלפניו.
תשובה

arr = {3, 1, 5, -3, 2, -4, -2}

דוגמה ב - חיפוש מספר מושלם אי-זוגי בקפיצות של 2

מספר חיובי ייקרא "מספר מושלם" אם סכום כל המחלקים שלו, חוץ ממנו, שווה לו (למשל 6 = 1 + 2 + 3). נתונה הפעולה isPerfect / IsPerfect, שמקבלת מספר שלם הגדול מ-2 ומחזירה true אם הוא מספר מושלם.
יש השערה שלא קיים מספר אי-זוגי שהוא מספר מושלם. כתבו פעולה חיצונית ששמה noOdd בשפת Java או NoOdd בשפת C#, המחזירה true אם אכן מבין כל המספרים 3 עד 999,999 (כולל) אין מספר מושלם שהוא אי-זוגי. אחרת היא מחזירה false.

פתרון
1.אילו מספרים: רק האי-זוגיים מ-3 עד 999999. מתחילים ב-3 וקופצים ב-2: i = i + 2. 999999 אי-זוגי, ולכן i <= 999999 מגיע אליו בדיוק.
2.חיפוש: אם isPerfect(i) מחזירה true - מצאנו מספר מושלם אי-זוגי, ומחזירים false מיד.
3.רק אחרי הלולאה: אם אף מספר לא נמצא - מחזירים true.
public static boolean noOdd()
{
    for (int i = 3; i <= 999999; i = i + 2)
    {
        if (isPerfect(i))
        {
            return false;   // נמצא מספר מושלם אי-זוגי
        }
    }
    return true;            // רק אחרי שכל המספרים נבדקו
}
4.בדיקה: הלולאה עוברת על 499999 מספרים, אף אחד מהם אינו מושלם, והפעולה מחזירה true.
תשובה

לולאה for (int i = 3; i <= 999999; i = i + 2); אם isPerfect(i) - מחזירים false; אחרי הלולאה מחזירים true. (התוצאה: true.)

3. לולאת while ולולאת זקיף

לולאת while

לפעמים לא יודעים מראש כמה סיבובים יהיו: מחסירים מ-n עד שהוא מגיע ל-0, או קולטים גילים עד שמגיע מבקר שאינו רשאי בשום מתקן. while חוזרת על הגוף כל עוד התנאי מתקיים.
במדויק: while (תנאי) בודקת את התנאי לפני כל סיבוב; אם הוא false כבר בהתחלה, הגוף לא מתבצע אף פעם. משהו בגוף חייב לשנות את המשתנים שבתנאי, אחרת הלולאה לא נגמרת. לולאת זקיף היא while שקולטת ערכים עד שמגיע ערך זקיף - ערך מיוחד שמסמן "סוף הקלט" ואינו חלק מהנתונים.

for ו-while שקולות: כל for אפשר לכתוב כ-while, עם אתחול לפני הלולאה וקידום בסוף הגוף. גם פירוק מספר לספרות (while (temp > 0)) הוא לולאת while.

for או while

הבעיההלולאהדוגמה מהבגרות
מספר החזרות ידוע לפני הלולאהforקליטת num ציונים; 850 לקוחות; כל תא במערך
הלולאה נעצרת כשמשהו קורהwhilewhile (n > 0) עד ש-n מגיע ל-0
קלט עד ערך מיוחדwhile, לולאת זקיףקליטת גילים עד מבקר שאינו רשאי בשום מתקן
עד שמספר נעשה חד-ספרתיwhilewhile (num1 >= 10)

תבנית: לולאת זקיף

int count = 0;
int age = input.nextInt();      // קליטה ראשונה - לפני הלולאה
while (age >= 12)               // כל עוד הערך אינו הזקיף
{
    count++;                    // טיפול בערך שנקלט
    age = input.nextInt();      // קליטת הערך הבא - בסוף הגוף
}
System.out.println(count);

כאן הזקיף הוא כל גיל קטן מ-12: מבקר שאינו רשאי במקפצה אינו רשאי בשום מתקן. בעבור הקלט 13, 17, 25, 16, 12, 30, 19, 8 מודפס 7: הגיל 8 עוצר את הלולאה ואינו נספר.

דרך הפתרון

כתיבת לולאת זקיף

1.מזהים את הזקיף: מה מסמן את סוף הקלט ("הקלט מסתיים כאשר ייקלט מבקר שאינו רשאי להשתמש בשום מתקן").
2.קולטים את הערך הראשון לפני הלולאה, כדי שיהיה על מה לבדוק את התנאי.
3.התנאי: הערך שנקלט אינו הזקיף.
4.הגוף: קודם מטפלים בערך (סופרים, צוברים), ובהוראה האחרונה קולטים את הערך הבא.
5.אחרי הלולאה: מדפיסים או מחזירים את התוצאה. הזקיף עצמו לא טופל.
שים לב

לולאה אינסופית: אם שום הוראה בגוף לא משנה את המשתנים שבתנאי, התנאי נשאר true לתמיד. בלולאת זקיף זה קורה למי ששוכח לקלוט את הערך הבא בסוף הגוף.

שים לב

מי שקולט רק בתחילת הגוף (ולא לפני הלולאה) בודק את התנאי על ערך שעוד לא נקלט, וגם מטפל בזקיף כאילו היה נתון רגיל.

דוגמה א - מעקב אחר לולאה שמחסירה ריבועים שלמים

לפניכם קטע תוכנית:

int n = 23;
int steps = 0;
while (n > 0)
{
    int root = (int)(Math.sqrt(n));
    int square = (int)(Math.pow(root, 2));
    n = n - square;
    steps++;
}
System.out.println(steps);

א. עקבו בעזרת טבלת מעקב אחרי ביצוע קטע התוכנית, וכתבו את המספר שקטע התוכנית מדפיס. בטבלת המעקב יש לכלול עמודה בעבור כל אחד מן המשתנים n, steps, root, square.
ב. כתבו דוגמה למספר הגדול מ-1 שמוצב ב-n (בתחילת הקטע) שבעבורו קטע התוכנית מדפיס 1 (אין צורך להציג מעקב).

פתרון
1.מה קורה בכל סיבוב: root הוא החלק השלם של השורש של n (ההמרה (int) קוטעת, לא מעגלת), square הוא root בריבוע, ו-n קטן ב-square. steps סופר סיבובים.
2.מתי נעצרים: כש-n מגיע ל-0, התנאי n > 0 נכשל.
סיבובn לפניrootsquaren אחריsteps
אתחול---230
12341671
272432
331123
421114
511105
3.א: אחרי הסיבוב החמישי n > 0 לא מתקיים, והקטע מדפיס 5.
4.ב: הקטע מדפיס 1 רק אם הלולאה רצה פעם אחת, כלומר n מתאפס כבר בסיבוב הראשון. זה קורה כש-n הוא ריבוע שלם. למשל n = 4: root = 2, square = 4, n = 0, steps = 1.
תשובה

א. הקטע מדפיס 5.
ב. למשל n = 4 (כל ריבוע שלם הגדול מ-1: 4, 9, 16, ...).

דוגמה ב - ספירת מבקרים עד ערך זקיף

בבריכה יש 3 מתקנים: מקפצה (בני 12 ומעלה), ג'קוזי (בני 16 ומעלה) וסאונה (בני 18 ומעלה). נתונה הפעולה checkAge / CheckAge, שמקבלת גיל ומחזירה מערך בגודל 3: בתא 0 (מקפצה), בתא 1 (ג'קוזי) ובתא 2 (סאונה) הערך 1 אם המבקר רשאי להשתמש במתקן, ו-0 אם לא.
כתבו פעולה בשם count (ב-C# - Count) שתקלוט בעבור יום מסוים את גילו של כל מבקר בבריכה. הקלט מסתיים כאשר ייקלט מבקר שאינו רשאי להשתמש בשום מתקן. הפעולה תדפיס את מספר המבקרים שרשאים להשתמש בכל אחד מן המתקנים באותו יום. אין חשיבות לסדר ההדפסה. דוגמה להדפסה: 10,20,15

פתרון
1.הזקיף: מבקר ששלושת התאים שלו 0, כלומר allowed[0] + allowed[1] + allowed[2] == 0.
2.מונים: מערך counters בגודל 3, תא לכל מתקן, באותו סדר כמו במערך ש-checkAge מחזירה.
3.לולאת זקיף: קולטים גיל ומחשבים allowed לפני הלולאה. כל עוד הסכום גדול מ-0: מוסיפים allowed[i] ל-counters[i] (1 מגדיל, 0 לא משנה), ואז קולטים את הגיל הבא.
public static void count()
{
    int[] counters = new int[3];
    int age = input.nextInt();
    int[] allowed = checkAge(age);
    while (allowed[0] + allowed[1] + allowed[2] > 0)
    {
        for (int i = 0; i < 3; i++)
            counters[i] = counters[i] + allowed[i];
        age = input.nextInt();
        allowed = checkAge(age);
    }
    System.out.println(counters[0] + "," + counters[1] + "," + counters[2]);
}
4.בדיקה: בעבור הקלט 13, 17, 25, 16, 12, 30, 19, 8 מודפס 7,5,3: שבעה מבקרים לפני ה-8 רשאים במקפצה, חמישה (17, 25, 16, 30, 19) בג'קוזי, ושלושה (25, 30, 19) בסאונה. כשהגיל הראשון הוא 5 מודפס 0,0,0.
תשובה

לולאת זקיף עם checkAge: כל עוד המבקר רשאי במתקן כלשהו - counters[i] += allowed[i] לכל i, וקליטת הגיל הבא; בסוף מדפיסים את שלושת המונים.

4. צבירה, מנייה, ממוצע, מקסימום ומינימום

צובר, מונה, דגל וערך קיצון

הרבה שאלות מבקשות מספר אחד שמסכם הרבה נתונים: כמה לקוחות צריכים לשלם משלוח, מה הממוצע, האם הייתה ירייה של 10. לכל סוג כזה יש משתנה עם תפקיד קבוע, שמתעדכן בכל סיבוב של הלולאה.
במדויק: צובר - משתנה שמוסיפים לו בכל סיבוב (sum = sum + x). מונה - משתנה שגדל ב-1 כשתנאי מתקיים (count++). דגל - משתנה בוליאני שמתחיל false ונדלק כשמשהו קורה. ערך קיצון - הגדול ביותר (מקסימום) או הקטן ביותר (מינימום) עד עכשיו. ממוצע - הצובר חלקי מספר הערכים, מחושב אחרי הלולאה.

אותם משתנים עובדים על כל לולאה: קליטת num ערכים, תאי מערך, או המספרים בתחום. בשאלות על מערכים הם חוזרים שוב (ראו "סריקת מערך"), ומונה בכל תא של מערך הוא "מערך מונים".

ערך התחלתי ועדכון לכל תפקיד

תפקידלפני הלולאהבכל סיבובאחרי הלולאה
צובר (סכום)sum = 0sum = sum + x-
מונהcount = 0if (תנאי) count++-
דגלfound = falseif (תנאי) found = trueif (found)
מקסימוםהערך הראשוןif (x > max) max = x-
מינימוםהערך הראשוןif (x < min) min = x-
ממוצע--(double) sum / n

רוב, חצי וממוצע

בשאלה כתובבקוד
"בממוצע הניקוד הוא מעל ל-5.0"(double) sum / num > 5.0
"ברוב היריות" (יותר מחצי)countHigh > num / 2.0
"לפחות חצי מכמות כלי הרכב"count * 2 >= speeds.length
"בירייה אחת או יותר"דגל: hit10 = true

תבנית: צובר, מונה, דגל ומקסימום בלולאה אחת

int sum = 0;              // צובר
int count = 0;            // מונה
boolean found = false;    // דגל: האם היה לפחות אחד
int max = 0;
for (int i = 1; i <= n; i++)
{
    int x = input.nextInt();
    sum = sum + x;
    if (x >= 6)
        count++;
    if (x == 10)
        found = true;
    if (i == 1 || x > max)   // הערך הראשון מאתחל את max
        max = x;
}
double avg = (double) sum / n;

בעבור n = 5 והקלט 5, 7, 9, 3, 3: sum = 27, count = 2, found = false, max = 9, avg = 5.4.

שים לב

חלוקה של שני מספרים שלמים היא חלוקה בשלמים: 27 / 5 שווה 5, לא 5.4. בממוצע כותבים (double) sum / num, וב"רוב" כותבים num / 2.0.

שים לב

"לפחות חצי" עם count >= speeds.length / 2 שגוי: בשבעה כלי רכב 7 / 2 שווה 3, ו-3 קנסות (פחות מחצי) יחזירו true. בודקים count * 2 >= speeds.length.

שים לב

מחליטים רק אחרי שכל הקלט נקלט. מי שמחזיר true מתוך הלולאה ברגע שמופיע 10 משאיר ציונים שלא נקלטו.

שים לב

מקסימום ומינימום מאתחלים בערך הראשון ולא ב-0: אם כל הערכים שליליים, מקסימום שהתחיל ב-0 יישאר 0, ערך שלא היה בכלל בנתונים.

דוגמה - הצלחה במשחק קליעה לפי ממוצע, רוב או 10

במשחק קליעה למטרה, הניקוד בעבור כל ירייה הוא מספר שלם מ-0 עד 10. אדם מצליח במשחק אם מתקיים לפחות אחד מן המקרים:

•בממוצע הניקוד הוא מעל ל-5.0 נקודות.
•ברוב היריות הוא זכה ב-6 נקודות ומעלה.
•בירייה אחת או יותר הוא זכה ב-10 נקודות.

כתבו פעולה חיצונית ששמה success בשפת Java או Success בשפת C#, המקבלת מספר שלם num - מספר החיצים שהאדם ירה. הפעולה תקלוט את מספר הנקודות בעבור כל חץ, ותחזיר true אם האדם הצליח במשחק, אחרת false.
(ב-Java: הניחו שבתוכנית כתובה ההוראה Scanner scan = new Scanner(System.in);)

פתרון
1.לולאה: num ידוע מראש - for של num סיבובים, ובכל סיבוב קולטים ציון.
2.שלושה משתנים, אחד לכל מקרה: צובר sum (לממוצע), מונה countHigh (ציונים של 6 ומעלה), דגל hit10.
3.אחרי הלולאה: ממוצע (double) sum / num > 5.0; רוב countHigh > num / 2.0; ומחברים את שלושת התנאים ב-||.
public static boolean success(int num)
{
    int sum = 0;            // סכום הנקודות
    int countHigh = 0;      // מספר היריות של 6 נקודות ומעלה
    boolean hit10 = false;  // האם הייתה ירייה של 10
    for (int i = 0; i < num; i++)
    {
        int score = scan.nextInt();
        sum += score;
        if (score >= 6)
            countHigh++;
        if (score == 10)
            hit10 = true;
    }
    double avg = (double) sum / num;
    return avg > 5.0 || countHigh > num / 2.0 || hit10;
}
4.בדיקה:
ציוניםsumcountHighhit10מוחזר
5, 7, 9, 3, 327 (ממוצע 5.4)2falsetrue
7, 6, 1, 7, 8, 029 (ממוצע 4.83)4 מתוך 6falsetrue
2, 10, 0121truetrue
6, 6, 0, 012 (ממוצע 3)2 מתוך 4, לא רובfalsefalse
5, 510 (ממוצע 5.0, לא מעל)0falsefalse
תשובה

קולטים num ציונים, סוכמים, סופרים ציונים >= 6 ומסמנים אם היה 10; מחזירים (double) sum / num > 5.0 || countHigh > num / 2.0 || hit10.

5. פירוק מספר לספרות

פירוק מספר לספרות

מספר נרקיסיסטי, "קפרקר מאוזן", סכום ספרות עמוק, ספרת העשרות של כל תא: הרבה שאלות בשאלון 899371 עובדות על הספרות של מספר. אין צורך להפוך אותו למחרוזת: שתי פעולות חשבון מספיקות.
במדויק: בשלמים, num % 10 היא ספרת האחדות של num, ו-num / 10 הוא num בלי ספרת האחדות (חלוקה בשלמים). לולאת while (temp > 0) שבכל סיבוב לוקחת temp % 10 ומחלקת ב-10 עוברת על כל הספרות, מימין לשמאל, ונגמרת כש-temp מגיע ל-0. מספר הסיבובים הוא מספר הספרות.

החשבון של / ו-% עצמו נמצא בשיעור "פעולות חשבון: חלוקה בשלמים, שארית והמרת טיפוסים". כאן הוא בתוך לולאה. גם "סכום ספרות" ו"היפוך ספרות" חוזרים בפרק הרקורסיה.

הביטויים שחוזרים

מה רוציםביטוידוגמה
ספרת האחדותnum % 10324 % 10 = 4
המספר בלי ספרת האחדותnum / 10324 / 10 = 32
ספרת העשרות(num / 10) % 10(324 / 10) % 10 = 2
k הספרות הימניותnum % power, כש-power = 10 בחזקת k260043100 % 100000 = 43100
k הספרות השמאליותמחלקים ב-10, len - k פעמים260043100, k = 5: 26004
מספר מספרותhundreds * 100 + tens * 10 + units1, 2, 2 - 122
"חד-ספרתי" (מספר אי-שלילי)num < 10while (num1 >= 10)

תבנית: מעבר על כל הספרות

int count = 0;              // כמה ספרות
int sum = 0;                // סכום הספרות
int temp = num;             // עותק - num נשאר כמו שהוא
while (temp > 0)
{
    int digit = temp % 10;  // ספרת האחדות
    count++;
    sum = sum + digit;
    temp = temp / 10;       // מוחקים את ספרת האחדות
}

בעבור num = 942378: count = 6, sum = 9 + 4 + 2 + 3 + 7 + 8 = 33. בסוף temp שווה 0, ו-num לא השתנה.

דרך הפתרון

עבודה עם ספרות משמאל

הלולאה מגיעה לספרות מימין לשמאל. כשהשאלה מדברת על הספרות שמשמאל או על אמצע המספר:

1.סופרים קודם את הספרות בלולאה נפרדת על עותק: len.
2.מחשבים כמה ספרות להוריד מימין: כדי להשאיר k ספרות משמאל מורידים len - k.
3.מורידים בלולאת for של len - k סיבובים: num = num / 10.
4.לספרות מימין לא צריך את len: מחשבים בלולאה power = 10 בחזקת k, ומחזירים num % power.
שים לב

במספר חד-ספרתי num / 10 הוא 0, ולכן ספרת העשרות של 6 היא 0 (לא 6). בגלל זה בתא 0 מספר חד-ספרתי מקיים "ספרת העשרות שווה לאינדקס".

שים לב

את 10 בחזקת k מחשבים בלולאת כפל (power = power * 10) ולא ב-Math.pow: Math.pow מחזירה double, ואז num % power כבר לא בשלמים.

שים לב

בעבור num = 0 הלולאה while (temp > 0) לא רצה אף פעם, ומספר הספרות שיוצא הוא 0. בשאלות שבהן num חיובי זה לא משנה, אבל ב"חד-ספרתי" בודקים num1 >= 10, ו-0 מוחזר כמו שהוא.

דוגמה א - k הספרות משמאל ו-k הספרות מימין

num הוא מספר חיובי, ו-k הוא מספר חיובי הקטן מכמות הספרות של num.
א. ממשו את הפעולה public static int leftDigits(int num, int k) (ב-C# - LeftDigits). הפעולה תחזיר את המספר המיוצג על ידי k הספרות שמצד שמאל של num. דוגמה: עבור k = 5 ו-num = 260043100 הפעולה תחזיר 26004.
ב. ממשו את הפעולה public static int rightDigits(int num, int k) (ב-C# - RightDigits). הפעולה תחזיר את המספר המיוצג על ידי k הספרות שמצד ימין של num (הניחו שהמספר המוחזר תקין ואינו מתחיל ב-0). דוגמה: עבור k = 5 ו-num = 260043100 הפעולה תחזיר 43100.

פתרון
1.א - סופרים ספרות: לולאת while על העותק temp נותנת len.
2.א - מורידים מימין: כדי שיישארו k ספרות, מחלקים את num ב-10, len - k פעמים.
3.ב - חזקה של 10: לולאת for של k סיבובים בונה power = 10 בחזקת k.
4.ב - השארית: num % power היא בדיוק k הספרות הימניות.
public static int leftDigits(int num, int k)
{
    int len = 0;
    int temp = num;
    while (temp > 0)
    {
        len++;
        temp = temp / 10;
    }
    for (int i = 0; i < len - k; i++)
    {
        num = num / 10;
    }
    return num;
}

public static int rightDigits(int num, int k)
{
    int power = 1;
    for (int i = 0; i < k; i++)
    {
        power = power * 10;
    }
    return num % power;
}
5.בדיקה: 260043100 הוא בן 9 ספרות, ולכן בסעיף א מחלקים ב-10 ארבע פעמים: 26004310, 2600431, 260043, 26004. בסעיף ב: power = 100000, ו-260043100 % 100000 = 43100. גם leftDigits(81, 1) = 8, ו-rightDigits(24502500, 4) = 2500.
תשובה

א. סופרים ספרות len ומחלקים את num ב-10, len - k פעמים.
ב. return num % power, כש-power = 10 בחזקת k מחושב בלולאה.

דוגמה ב - מעקב אחר ספרת העשרות של כל תא

נתון המערך arr = {30, 141, 324, 623, 8004, 458, 6} ונתון קטע התוכנית:

int count = 0;
for (int i = 0; i < arr.length; i++)
{
    int num = arr[i] / 10;
    int digit = num % 10;
    if (digit == i)
        count++;
}

עקבו בעזרת טבלת מעקב אחר ביצוע קטע התוכנית עבור המערך arr, ורשמו את ערך המשתנה count לאחר ביצוע קטע התוכנית. בטבלת המעקב יש לכלול עמודה עבור כל אחד מן המשתנים count, i, num, digit.

פתרון
1.מה מחושב: arr[i] / 10 מוחק את ספרת האחדות, ולכן num % 10 היא ספרת העשרות של arr[i]. count סופר את התאים שבהם ספרת העשרות שווה לאינדקס.
סיבובiarr[i]numdigitdigit == icount
אתחול-----0
103033לא0
21141144לא0
32324322כן1
43623622לא1
5480048000לא1
65458455כן2
76600לא2
2.סיום: כש-i = 7 התנאי i < 7 לא מתקיים, ו-count נשאר 2.
תשובה

count = 2 (בתאים 2 ו-5 ספרת העשרות שווה לאינדקס).

6. לולאות מקוננות

לולאות מקוננות

בכל אות של הניחוש צריך לחפש את האות במחרוזת הסודית; בכל מספר בתחום צריך לעבור על כל המחלקים שלו. כשלכל פריט צריך לבצע לולאה שלמה, שמים לולאה בתוך לולאה.
במדויק: לולאה מקוננת היא לולאה (פנימית) שנמצאת בגוף של לולאה אחרת (חיצונית). בכל סיבוב של החיצונית, הפנימית רצה מההתחלה ועד הסוף. לכל לולאה משתנה מציין משלה (i בחיצונית, j בפנימית). גם קריאה, בתוך לולאה, לפעולה שיש בה לולאה (isPerfect(i) בתוך for) היא לולאה מקוננת, מבחינת מספר הצעדים.

מערך דו-ממדי עוברים בשתי לולאות מקוננות: החיצונית על השורות והפנימית על העמודות (ראו "מערך דו-ממדי").

כמה פעמים הגוף הפנימי מתבצע

כותרות הלולאותמספר הביצועים של הגוף הפנימי
חיצונית n סיבובים, פנימית m סיבוביםn · m
חיצונית i = 1..n, פנימית j = 1..i1 + 2 + ... + n
לולאה של n סיבובים שקוראת לפעולה עם לולאה של m סיבוביםn · m

למשל: אורך הניחוש וגם אורך המחרוזת הסודית הם 4 - הגוף הפנימי מתבצע 16 פעמים. משולש של 4 שורות - 1 + 2 + 3 + 4 = 10 כוכביות.

תבנית: לולאה בתוך לולאה

for (int i = 1; i <= n; i++)         // לולאה חיצונית: שורה
{
    for (int j = 1; j <= i; j++)     // לולאה פנימית: i כוכביות בשורה i
    {
        System.out.print("*");
    }
    System.out.println();            // ירידת שורה - אחרי הלולאה הפנימית
}

בעבור n = 4 מודפס משולש:

*
**
***
****

print / Write בתוך הפנימית לא יורד שורה; ה-println / WriteLine אחרי הפנימית יורד שורה פעם אחת לכל שורה של המשולש.

דרך הפתרון

כתיבת לולאה בתוך לולאה

1.החיצונית: על מה עוברים - כל אות בניחוש, כל מספר בתחום, כל שורה.
2.הפנימית: מה צריך לעשות לפריט אחד - לחפש אותו, לסכם את המחלקים שלו, להדפיס את השורה שלו.
3.איפוס: משתנה שהפנימית ממלאת (place = -1, sum = 0) מאתחלים בתוך החיצונית, לפני הפנימית - כך כל פריט מתחיל מאפס.
4.אחרי הפנימית, עדיין בתוך החיצונית: משתמשים בתוצאה של הפריט - מסווגים, סופרים, יורדים שורה.
שים לב

משתנה שמאותחל לפני הלולאה החיצונית (ולא בתוכה) לא מתאפס בין פריטים: אם place = -1 נכתב מחוץ ללולאה, אות שלא קיימת במחרוזת הסודית "יורשת" את המקום של האות הקודמת.

שים לב

קריאה לפעולה בתוך לולאה עולה כמו הלולאה שבתוך הפעולה. בפעולה isCorrect / IsCorrect יש 999999 סיבובים, ובכל אחד deepSum(i), שיש בה לולאה משלה.

דוגמה א - בול, פגיעה והחמצה בשתי לולאות

במשחק "בול פגיעה" בוחרים מחרוזת סודית מהאותיות A-Z, שבה כל אות מופיעה פעם אחת לכל היותר. השחקן מנחש מחרוזת, ובעבור כל אות בניחוש הוא מקבל: "בול" - האות נמצאת במחרוזת הסודית באותו מקום; "פגיעה" - האות נמצאת במחרוזת הסודית במקום אחר; "החמצה" - האות לא נמצאת במחרוזת הסודית.
לדוגמה: בעבור המחרוזת הסודית "FGAV" והניחוש "AGCF": G - בול (באינדקס 1 בשתיהן); A ו-F - פגיעה; C - החמצה.
כתבו פעולה חיצונית ששמה guess בשפת Java או Guess בשפת C#, המקבלת מחרוזת סודית secretStr ומחרוזת ניחוש playerStr (שתיהן תקינות). אם האורך של מחרוזת הניחוש שונה משל המחרוזת הסודית, הפעולה תדפיס "Size Error". אחרת היא תדפיס את מספר ציוני ה"בול", מספר ציוני ה"פגיעה" ומספר ציוני ה"החמצה" (כל הדפסה בשורה חדשה).

פתרון
1.בדיקת אורך: אם האורכים שונים - מדפיסים "Size Error" ולא ממשיכים.
2.החיצונית: על כל אות בניחוש, באינדקס i.
3.הפנימית: מחפשת את האות במחרוזת הסודית. place מאותחל ל--1 בתוך החיצונית, ומקבל j אם האות נמצאה במקום j.
4.אחרי הפנימית: place == i - בול; אחרת place != -1 - פגיעה; אחרת - החמצה. בודקים בול לפני פגיעה.
public static void guess(String secretStr, String playerStr)
{
    if (playerStr.length() != secretStr.length())
    {
        System.out.println("Size Error");
    }
    else
    {
        int bul = 0, hit = 0, miss = 0;
        for (int i = 0; i < playerStr.length(); i++)
        {
            int place = -1;   // המקום של האות במחרוזת הסודית
            for (int j = 0; j < secretStr.length(); j++)
            {
                if (secretStr.charAt(j) == playerStr.charAt(i))
                    place = j;
            }
            if (place == i)
                bul++;
            else if (place != -1)
                hit++;
            else
                miss++;
        }
        System.out.println(bul);
        System.out.println(hit);
        System.out.println(miss);
    }
}
5.בדיקה: "FGAV" ו-"AGCF": A - place = 2, פגיעה; G - place = 1 = i, בול; C - place = -1, החמצה; F - place = 0, פגיעה. מודפס 1, 2, 1. "ABCD" ו-"ABC" - Size Error. "ABCD" ו-"DCBA" - 0, 4, 0.

אפשר גם לכתוב את הפנימית בקריאה אחת: secretStr.indexOf(c) ב-Java או secretStr.IndexOf(c) ב-C#, שמחזירה את המקום של התו או -1.

תשובה

לכל i: place = המקום של playerStr.charAt(i) ב-secretStr (או -1); place == i - בול, place != -1 - פגיעה, אחרת החמצה. בדוגמה: 1, 2, 1.

דוגמה ב - לולאה שקוראת לפעולה עם לולאה

נתונה הפעולה digitSum / DigitSum, שמחזירה את סכום הספרות של מספר. "סכום הספרות העמוק" של מספר הוא המספר החד-ספרתי שמתקבל כשמחשבים את סכום הספרות שוב ושוב (למשל 942378: 33, ואז 6). את הפעולה deepSum / DeepSum כתבנו בסעיף קודם:

public static int deepSum(int num1)
{
    while (num1 >= 10)
    {
        num1 = digitSum(num1);
    }
    return num1;
}

יש הטוענים כי בטווח שבין 1 ל-999999 יש יותר מספרים בעלי "סכום ספרות עמוק" זוגי ממספרים בעלי "סכום ספרות עמוק" אי-זוגי. כתבו פעולה חיצונית ששמה isCorrect בשפת Java או IsCorrect בשפת C# המחזירה true אם הטענה נכונה, ואחרת מחזירה false. הערה: חובה להיעזר בפעולה deepSum.

פתרון
1.החיצונית: for על i מ-1 עד 999999.
2.הפנימית - בתוך פעולה: deepSum(i) רצה בלולאת while משלה, וקוראת ל-digitSum, שגם בה לולאה על הספרות.
3.שני מונים: countEven ו-countOdd, לפי deepSum(i) % 2.
4.אחרי הלולאה: מחזירים countEven > countOdd.
public static boolean isCorrect()
{
    int countEven = 0;
    int countOdd = 0;
    for (int i = 1; i <= 999999; i++)
    {
        if (deepSum(i) % 2 == 0)
            countEven++;
        else
            countOdd++;
    }
    return countEven > countOdd;
}
5.בדיקה: בהרצה מתקבל countEven = 444444 ו-countOdd = 555555, ולכן הפעולה מחזירה false.
תשובה

סופרים זוגי ואי-זוגי של deepSum(i) בעבור i = 1 עד 999999 ומחזירים countEven > countOdd. התוצאה: 444444 זוגיים לעומת 555555 אי-זוגיים, ולכן הפעולה מחזירה false.

כל האתר במבט אחד

קיצורי דרך לכל הכלים, הבגרויות והקורסים

GuyAI הוא המורה הפרטי המתקדם בישראל, המבוסס על מודלי הבינה המלאכותית החזקים בעולם בשילוב הידע הפדגוגי של GOOL. המערכת מספקת פתרונות לכל המקצועות ולכל הרמות - מיסודי ועד אקדמיה, וממתמטיקה ועד היסטוריה.