מבני בקרה
עד עכשיו כל הוראה בתוכנית התבצעה פעם אחת, לפי הסדר. מבני הבקרה משנים את זה: הם מחליטים אם הוראה תתבצע וכמה פעמים. כמעט כל שאלה בשאלון 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 | רק הגוף הראשון שתנאו מתקיים | בדיוק מקרה אחד: מהירות היא "מהירה מדי", "איטית מדי" או "תקינה" |
תרגום תנאי מילולי לקוד
> או >=.&& או ב-||.if נפרדים; אם בדיוק אחד - שרשרת else if, או return בכל ענף.שרשרת 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 קמ"ש לפחות מהמהירות המינימלית המותרת;speed - max >= 10, כלומר speed >= max + 10.speed <= min - 10.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;
}| מהירות | הבדיקה | מוחזר |
|---|---|---|
| 80 | 80 >= 80 | 1 |
| 79 | אף תנאי לא מתקיים | 0 |
| 20 | 20 <= 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 (האם מקום העבודה בעיר, בוליאני), ומחזירה את המספר התלת-ספרתי.
if נפרדים, לא שרשרת.age >= 70; "3 ילדים ומעלה" - num >= 3.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;
}לכל ספרה ערך 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 - 1 | n |
for (int i = 1; i <= n; i++) | 1, 2, ..., n | n |
for (int i = 0; i < arr.length - 1; i++) | 0, ..., arr.length - 2 | arr.length - 1 |
for (int i = low; i <= high; i++) | low, ..., high | high - low + 1 |
for (int i = 3; i <= 999999; i = i + 2) | 3, 5, 7, ..., 999999 | 499999 |
הבדיקה האחרונה של התנאי נעשית עם הערך הראשון של 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
i <= high; אינדקסים של מערך - i < arr.length.i++, או i = i + 2 כשעוברים רק על האי-זוגיים.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.
sum = arr[0], כלומר 3. הלולאה מתחילה ב-i = 1 ורצה כל עוד i < 7: שישה סיבובים.arr[i] מקבל את arr[i] - sum, ורק אחר כך מוסיפים ל-sum את הערך החדש של arr[i].| סיבוב | i | i < 7 | arr[i] אחרי ההשמה | sum אחרי ההוספה |
|---|---|---|---|---|
| אתחול | - | - | - | 3 |
| 1 | 1 | true | 4 - 3 = 1 | 4 |
| 2 | 2 | true | 9 - 4 = 5 | 9 |
| 3 | 3 | true | 6 - 9 = -3 | 6 |
| 4 | 4 | true | 8 - 6 = 2 | 8 |
| 5 | 5 | true | 4 - 8 = -4 | 4 |
| 6 | 6 | true | 2 - 4 = -2 | 2 |
| סיום | 7 | false | - | 2 |
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.
i = i + 2. 999999 אי-זוגי, ולכן i <= 999999 מגיע אליו בדיוק.isPerfect(i) מחזירה true - מצאנו מספר מושלם אי-זוגי, ומחזירים false מיד.public static boolean noOdd()
{
for (int i = 3; i <= 999999; i = i + 2)
{
if (isPerfect(i))
{
return false; // נמצא מספר מושלם אי-זוגי
}
}
return 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 לקוחות; כל תא במערך |
| הלולאה נעצרת כשמשהו קורה | while | while (n > 0) עד ש-n מגיע ל-0 |
| קלט עד ערך מיוחד | while, לולאת זקיף | קליטת גילים עד מבקר שאינו רשאי בשום מתקן |
| עד שמספר נעשה חד-ספרתי | while | while (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 עוצר את הלולאה ואינו נספר.
כתיבת לולאת זקיף
לולאה אינסופית: אם שום הוראה בגוף לא משנה את המשתנים שבתנאי, התנאי נשאר 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 (אין צורך להציג מעקב).
(int) קוטעת, לא מעגלת), square הוא root בריבוע, ו-n קטן ב-square. steps סופר סיבובים.n > 0 נכשל.| סיבוב | n לפני | root | square | n אחרי | steps |
|---|---|---|---|---|---|
| אתחול | - | - | - | 23 | 0 |
| 1 | 23 | 4 | 16 | 7 | 1 |
| 2 | 7 | 2 | 4 | 3 | 2 |
| 3 | 3 | 1 | 1 | 2 | 3 |
| 4 | 2 | 1 | 1 | 1 | 4 |
| 5 | 1 | 1 | 1 | 0 | 5 |
n > 0 לא מתקיים, והקטע מדפיס 5.א. הקטע מדפיס 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
allowed[0] + allowed[1] + allowed[2] == 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]);
}לולאת זקיף עם checkAge: כל עוד המבקר רשאי במתקן כלשהו - counters[i] += allowed[i] לכל i, וקליטת הגיל הבא; בסוף מדפיסים את שלושת המונים.
4. צבירה, מנייה, ממוצע, מקסימום ומינימום
צובר, מונה, דגל וערך קיצון
הרבה שאלות מבקשות מספר אחד שמסכם הרבה נתונים: כמה לקוחות צריכים לשלם משלוח, מה הממוצע, האם הייתה ירייה של 10. לכל סוג כזה יש משתנה עם תפקיד קבוע, שמתעדכן בכל סיבוב של הלולאה.
במדויק: צובר - משתנה שמוסיפים לו בכל סיבוב (sum = sum + x). מונה - משתנה שגדל ב-1 כשתנאי מתקיים (count++). דגל - משתנה בוליאני שמתחיל false ונדלק כשמשהו קורה. ערך קיצון - הגדול ביותר (מקסימום) או הקטן ביותר (מינימום) עד עכשיו. ממוצע - הצובר חלקי מספר הערכים, מחושב אחרי הלולאה.
אותם משתנים עובדים על כל לולאה: קליטת num ערכים, תאי מערך, או המספרים בתחום. בשאלות על מערכים הם חוזרים שוב (ראו "סריקת מערך"), ומונה בכל תא של מערך הוא "מערך מונים".
ערך התחלתי ועדכון לכל תפקיד
| תפקיד | לפני הלולאה | בכל סיבוב | אחרי הלולאה |
|---|---|---|---|
| צובר (סכום) | sum = 0 | sum = sum + x | - |
| מונה | count = 0 | if (תנאי) count++ | - |
| דגל | found = false | if (תנאי) found = true | if (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. אדם מצליח במשחק אם מתקיים לפחות אחד מן המקרים:
כתבו פעולה חיצונית ששמה success בשפת Java או Success בשפת C#, המקבלת מספר שלם num - מספר החיצים שהאדם ירה. הפעולה תקלוט את מספר הנקודות בעבור כל חץ, ותחזיר true אם האדם הצליח במשחק, אחרת false.
(ב-Java: הניחו שבתוכנית כתובה ההוראה Scanner scan = new Scanner(System.in);)
for של num סיבובים, ובכל סיבוב קולטים ציון.(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;
}| ציונים | sum | countHigh | hit10 | מוחזר |
|---|---|---|---|---|
| 5, 7, 9, 3, 3 | 27 (ממוצע 5.4) | 2 | false | true |
| 7, 6, 1, 7, 8, 0 | 29 (ממוצע 4.83) | 4 מתוך 6 | false | true |
| 2, 10, 0 | 12 | 1 | true | true |
| 6, 6, 0, 0 | 12 (ממוצע 3) | 2 מתוך 4, לא רוב | false | false |
| 5, 5 | 10 (ממוצע 5.0, לא מעל) | 0 | false | false |
קולטים 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 % 10 | 324 % 10 = 4 |
| המספר בלי ספרת האחדות | num / 10 | 324 / 10 = 32 |
| ספרת העשרות | (num / 10) % 10 | (324 / 10) % 10 = 2 |
| k הספרות הימניות | num % power, כש-power = 10 בחזקת k | 260043100 % 100000 = 43100 |
| k הספרות השמאליות | מחלקים ב-10, len - k פעמים | 260043100, k = 5: 26004 |
| מספר מספרות | hundreds * 100 + tens * 10 + units | 1, 2, 2 - 122 |
| "חד-ספרתי" (מספר אי-שלילי) | num < 10 | while (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 לא השתנה.
עבודה עם ספרות משמאל
הלולאה מגיעה לספרות מימין לשמאל. כשהשאלה מדברת על הספרות שמשמאל או על אמצע המספר:
len - k.for של len - k סיבובים: num = num / 10.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.
while על העותק temp נותנת len.len - k פעמים.for של k סיבובים בונה power = 10 בחזקת k.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;
}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.
arr[i] / 10 מוחק את ספרת האחדות, ולכן num % 10 היא ספרת העשרות של arr[i]. count סופר את התאים שבהם ספרת העשרות שווה לאינדקס.| סיבוב | i | arr[i] | num | digit | digit == i | count |
|---|---|---|---|---|---|---|
| אתחול | - | - | - | - | - | 0 |
| 1 | 0 | 30 | 3 | 3 | לא | 0 |
| 2 | 1 | 141 | 14 | 4 | לא | 0 |
| 3 | 2 | 324 | 32 | 2 | כן | 1 |
| 4 | 3 | 623 | 62 | 2 | לא | 1 |
| 5 | 4 | 8004 | 800 | 0 | לא | 1 |
| 6 | 5 | 458 | 45 | 5 | כן | 2 |
| 7 | 6 | 6 | 0 | 0 | לא | 2 |
i < 7 לא מתקיים, ו-count נשאר 2.count = 2 (בתאים 2 ו-5 ספרת העשרות שווה לאינדקס).
6. לולאות מקוננות
לולאות מקוננות
בכל אות של הניחוש צריך לחפש את האות במחרוזת הסודית; בכל מספר בתחום צריך לעבור על כל המחלקים שלו. כשלכל פריט צריך לבצע לולאה שלמה, שמים לולאה בתוך לולאה.
במדויק: לולאה מקוננת היא לולאה (פנימית) שנמצאת בגוף של לולאה אחרת (חיצונית). בכל סיבוב של החיצונית, הפנימית רצה מההתחלה ועד הסוף. לכל לולאה משתנה מציין משלה (i בחיצונית, j בפנימית). גם קריאה, בתוך לולאה, לפעולה שיש בה לולאה (isPerfect(i) בתוך for) היא לולאה מקוננת, מבחינת מספר הצעדים.
מערך דו-ממדי עוברים בשתי לולאות מקוננות: החיצונית על השורות והפנימית על העמודות (ראו "מערך דו-ממדי").
כמה פעמים הגוף הפנימי מתבצע
| כותרות הלולאות | מספר הביצועים של הגוף הפנימי |
|---|---|
| חיצונית n סיבובים, פנימית m סיבובים | n · m |
חיצונית i = 1..n, פנימית j = 1..i | 1 + 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 אחרי הפנימית יורד שורה פעם אחת לכל שורה של המשולש.
כתיבת לולאה בתוך לולאה
place = -1, sum = 0) מאתחלים בתוך החיצונית, לפני הפנימית - כך כל פריט מתחיל מאפס.משתנה שמאותחל לפני הלולאה החיצונית (ולא בתוכה) לא מתאפס בין פריטים: אם 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 בתוך החיצונית, ומקבל j אם האות נמצאה במקום j.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);
}
}-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.
for על i מ-1 עד 999999.deepSum(i) רצה בלולאת while משלה, וקוראת ל-digitSum, שגם בה לולאה על הספרות.deepSum(i) % 2.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;
}סופרים זוגי ואי-זוגי של deepSum(i) בעבור i = 1 עד 999999 ומחזירים countEven > countOdd. התוצאה: 444444 זוגיים לעומת 555555 אי-זוגיים, ולכן הפעולה מחזירה false.