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

סיכום מושגי יסוד בתכנות: משתנים, ביטויים, קלט ופלט

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

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

תוכנית, משתנה וביטוי

תוכנית מחשב מקבלת נתונים, מחשבת ומוציאה תוצאה. כדי לחשב היא שומרת ערכים במשתנים ומצרפת אותם לביטויים, כמו במתמטיקה.
במדויק: משתנה - מקום בזיכרון שיש לו שם, טיפוס וערך. טיפוס - סוג הערכים שהמשתנה יכול להכיל: int, double, char, boolean (ב-C# bool) ו-String (ב-C# string). ביטוי - צירוף של משתנים, קבועים, פעולות חשבון וזימוני פעולות; לכל ביטוי יש ערך וטיפוס. קלט - ערכים שהתוכנית קולטת בזמן הריצה; פלט - מה שהיא מדפיסה. בבגרות הנושא הזה מופיע בתוך שאלות מעקב וכתיבת קוד: חלוקה בשלמים, שארית, המרה בין טיפוסים, קליטה והמחלקה Math.

1. משתנים, טיפוסים והשמה: int, double, char ו-boolean

משתנה וטיפוס

משתנה הוא כמו קופסה עם תווית: התווית היא שם המשתנה, ובקופסה יש ערך אחד. הטיפוס קובע איזה ערך מותר לשים בקופסה - מספר שלם, מספר עם נקודה עשרונית, תו, או אמת ושקר.
במדויק: בהגדרה כותבים טיפוס ושם, ואפשר גם לאתחל: int count = 0;. הטיפוס והשם נקבעים בהגדרה ולא משתנים; הערך משתנה במהלך הריצה. בבחינה צריך לבחור טיפוס מתאים לכל משתנה, לאתחל צוברים, מונים ודגלים, ולעקוב אחרי הערכים בטבלת מעקב.

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

הטיפוסים הבסיסיים

טיפוסJavaC#ערכים לדוגמהמתי משתמשים
שלםintint0, 23, -8מונה, סכום של שלמים, אינדקס, ספרה
ממשיdoubledouble5.4, 150.0ממוצע, מחיר, התוצאה של Math.sqrt
תוcharchar'A', '7'תו אחד, בגרש בודד
בוליאניbooleanbooltrue, falseדגל: האם משהו קרה, תוצאה של תנאי
מחרוזתStringstring"Dana"רצף של תווים, במירכאות

הגדרה, אתחול והשמה

int count = 0;            // שלם
double avg = 7.5;         // ממשי
boolean found = false;    // בוליאני: true או false
char grade = 'A';         // תו אחד, בגרש בודד
String name = "Dana";     // מחרוזת, במירכאות

int a = 5;
int b = a;                // השמה: b מקבל עותק של הערך של a
a = 7;                    // b לא משתנה
System.out.println(a + " " + b);

הקטע מדפיס 7 5. השמה מעתיקה את הערך: אחרי b = a יש ל-b עותק של 5, ושינוי של a אחר כך לא משנה את b.

דרך הפתרון

בחירת טיפוס מתוך תיאור מילולי

1.סופרים או צוברים שלמים? int: מספר חיצים, מספר ילדים, ניקוד, גיל.
2.יכול להיות שבר? double: ממוצע, מחיר.
3.כן או לא? boolean / bool: האם מקום העבודה בעיר, האם הייתה ירייה של 10 נקודות.
4.אתחול: צובר ומונה מתחילים ב-0. דגל מתחיל ב-false ומקבל true כשהדבר קורה. משתנה שיש לו ערך ברירת מחדל בשאלה מתחיל בו, ומשתנה רק כשהתנאי מתקיים.
שים לב

= היא השמה ו-== היא השוואה. משתנה בוליאני הוא כבר תנאי: if (city) מספיק, ואין צורך לכתוב city == true.

שים לב

"הפעולה מחזירה מספר שלם תלת-ספרתי" פירושו ערך int, כמו 122, ולא המחרוזת "122". את המספר בונים בחשבון: hundreds * 100 + tens * 10 + units.

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

מועצת העיר מזכה את תושביה בהנחות:

•תושב שגילו 70 ומעלה זכאי להנחה בארנונה.
•תושב שיש לו 3 ילדים ומעלה זכאי להנחה בגני הילדים.
•תושב שמקום עבודתו בעיר זכאי להנחה בחניה.

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

פתרון
1.טיפוסים: age ו-num שלמים, city בוליאני, והערך המוחזר int.
2.שלושה משתנים לספרות, כל אחד מאותחל ל-2 (לא זכאי).
3.כל תנאי משנה ספרה אחת ל-1: age >= 70 ("70 ומעלה" כולל 70), num >= 3, ו-city עצמו.
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.בדיקה (הרצה):
קריאהagenumcityמוחזר
1751false122
2403true211
3704true111
4692false222
5300true221
תשובה

ספרת המאות 1 אם age >= 70 ואחרת 2; ספרת העשרות 1 אם num >= 3 ואחרת 2; ספרת האחדות 1 אם city ואחרת 2. מחזירים hundreds * 100 + tens * 10 + units, למשל 122 בעבור גיל 75, ילד אחד ועבודה מחוץ לעיר.

2. פעולות חשבון: חלוקה בשלמים, שארית והמרת טיפוסים

פעולות חשבון וטיפוס התוצאה

המחשב מחשב כמו מחשבון, עם הבדל אחד חשוב: התוצאה תלויה בטיפוסים. 7 חלקי 2, כששניהם שלמים, הוא 3 ולא 3.5.
במדויק: פעולות החשבון הן חיבור +, חיסור -, כפל *, חילוק / ושארית %. כששני האופרנדים שלמים, / היא חלוקה בשלמים (המנה, בלי החלק העשרוני) ו-% היא השארית. אם לפחות אחד מהם double, התוצאה double. המרה: (double) x הופכת שלם לממשי, ו-(int) x הופכת ממשי לשלם וקוטעת את החלק העשרוני. בבחינה חלוקה בשלמים ושארית חוזרות בכל פירוק של מספר לספרות, והמרה - בכל חישוב ממוצע.

פירוק מספר שלם לספרות בלולאה (% 10 ו-/ 10 שוב ושוב, עד 0) מורחב בשיעור על פירוק מספר לספרות. כאן - מה ביטוי אחד מחשב.

מה הערך של הביטוי

ביטויערךלמה
7 / 23שני שלמים: חלוקה בשלמים
7.0 / 23.5אחד ממשי: חלוקה רגילה
7 % 21השארית של 7 חלקי 2
2 % 72המספר קטן מהמחלק: השארית היא המספר עצמו
6 / 100מספר חד-ספרתי חלקי 10
(double) 7 / 23.5ההמרה לפני החלוקה
(double) (7 / 2)3.0ההמרה אחרי חלוקה בשלמים: מאוחר מדי
(int) 4.794המרה ל-int קוטעת, לא מעגלת
1 + 2.53.5שלם ועוד ממשי: המרה אוטומטית ל-double

חלוקה ושארית על ספרות ועל התחלקות

מה רוציםביטויבעבור n = 324
ספרת האחדותn % 104
המספר בלי ספרת האחדותn / 1032
ספרת העשרותn / 10 % 102
ספרת המאות של מספר תלת-ספרתיn / 1003
האם n זוגיn % 2 == 0true
האם n מתחלק ב-7n % 7 == 0false

סדר הפעולות וסוגריים

•*, / ו-% לפני + ו--, כמו במתמטיקה: 3 + 4 * 2 הוא 11, ו-10 - 4 / 2 הוא 8.
•פעולות באותה רמה - משמאל לימין: n / 10 % 10 מחושב כ-(n / 10) % 10.
•סוגריים קודם: (3 + 4) * 2 הוא 14. בממוצע הסוגריים סביב הסכום חובה: (3 + 3 + 9 + 7 + 5) / 5 הוא 5 בשלמים, ו-(3 + 3 + 9 + 7 + 5) / 5.0 הוא 5.4.

תבנית: ממוצע עם המרה, מנה ושארית

int sum = 27;
int num = 5;
double wrong = sum / num;           // חלוקה בשלמים: 5, ואז 5.0
double avg = (double) sum / num;    // 5.4
int units = sum % 10;               // ספרת האחדות: 7
int rest = sum / 10;                // בלי ספרת האחדות: 2
System.out.println(wrong + " " + avg + " " + units + " " + rest);

ב-Java הקטע מדפיס 5.0 5.4 7 2. הערכים זהים בשתי השפות: ב-wrong נשמר 5, בלי חלק עשרוני, כי החלוקה בשלמים קרתה לפני ההשמה ל-double; avg הוא 5.4, units הוא 7 ו-rest הוא 2.

שים לב

בממוצע של ניקודים שלמים, sum / num הוא חלוקה בשלמים. במשחק הקליעה של קיץ 2023 הניקודים 5, 7, 9, 3, 3 נותנים 27 / 5 = 5 ולא 5.4, והתנאי "בממוצע מעל 5.0" נכשל. כותבים (double) sum / num.

שים לב

double wrong = sum / num; לא מציל: החלוקה בשלמים מתבצעת קודם, ורק התוצאה 5 הופכת ל-5.0. ההמרה צריכה להיות על אחד האופרנדים, לפני החלוקה.

שים לב

arr[i] / 10 % 10 היא ספרת העשרות של arr[i]: % 10 פועל על המנה, לא על המספר המקורי. בעבור מספר חד-ספרתי כמו 6 מתקבל 0, לא 6.

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

נתון מערך arr, המכיל מספרים שלמים חיוביים:

תא0123456
ערך3014132462380044586

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

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 היא ספרת האחדות של num - כלומר ספרת העשרות של arr[i].
2.מה סופרים: count גדל כשספרת העשרות שווה לאינדקס של התא.
סיבובiarr[i]numdigitdigit == icount
אתחול-----0
103033false0
21141144false0
32324322true1
43623622false1
5480048000false1
65458455true2
76600false2
סיום7----2
3.הסיום: כש-i = 7 התנאי i < arr.length לא מתקיים. ההרצה של הקטע על המערך נתנה count=2.
4.שימו לב לתא 6: 6 / 10 הוא 0, ולכן digit = 0 ולא 6.
תשובה

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

3. קלט ופלט: קליטת ערכים והדפסה

קלט ופלט

פלט הוא מה שהתוכנית מראה למשתמש; קלט הוא מה שהמשתמש מקליד לה. כשבשאלה כתוב "הפעולה תקלוט", אתם כותבים את הוראת הקליטה בעצמכם.
במדויק: הדפסה: ב-Java System.out.println(x) עם ירידת שורה ו-System.out.print(x) בלי; ב-C# Console.WriteLine(x) ו-Console.Write(x). קליטה ב-Java בעזרת עצם Scanner. בשאלון כתוב: "הניחו שבתוכנית כתובה ההוראה: Scanner scan = new Scanner (System.in);", וקולטים scan.nextInt() או scan.nextDouble(). קליטה ב-C#: קולטים שורה וממירים אותה: int.Parse(Console.ReadLine()), double.Parse(Console.ReadLine()). שרשור: + בין מחרוזת לערך מצרף אותם למחרוזת אחת.

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

קליטה והדפסה ב-Java וב-C#

מהJavaC#
קליטת מספר שלםscan.nextInt()int.Parse(Console.ReadLine())
קליטת מספר ממשיscan.nextDouble()double.Parse(Console.ReadLine())
הדפסה וירידת שורהSystem.out.println(x)Console.WriteLine(x)
הדפסה בלי ירידת שורהSystem.out.print(x)Console.Write(x)
הדפסה של טקסט וערךSystem.out.println("sum: " + sum)Console.WriteLine("sum: " + sum)

תבנית: קליטת ערכים והדפסת תוצאה

// Scanner scan = new Scanner(System.in);  - כתובה בתוכנית, לפי הוראות השאלון
int num = scan.nextInt();            // קליטת מספר שלם
double price = scan.nextDouble();    // קליטת מספר ממשי
System.out.print("total: ");         // בלי ירידת שורה
System.out.println(num * price);     // עם ירידת שורה

בקלט 3 ואחריו 2.5 הקטע מדפיס total: 7.5 בשורה אחת: print לא ירדה שורה.

שרשור מחרוזות: הסדר קובע

int x = 1;
int y = 2;
System.out.println("sum: " + x + y);     // sum: 12
System.out.println("sum: " + (x + y));   // sum: 3
System.out.println(x + y + " is sum");   // 3 is sum

+ מחושב משמאל לימין. אחרי שמופיעה מחרוזת, כל + הוא שרשור, ולכן "sum: " + x + y נותן sum: 12. כדי לחבר קודם - סוגריים. כשהמספרים באים לפני המחרוזת, הם מחוברים קודם: 3 is sum.

דרך הפתרון

פעולה שקולטת נתונים

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

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

שים לב

בבחינה לדוגמה הוראת הקליטה היא Scanner input = new Scanner(System.in);, ובשאלוני 2023-2026 היא Scanner scan = new Scanner (System.in);. כותבים input.nextInt() או scan.nextInt() לפי השאלון שלפניכם.

שים לב

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

דוגמה - קליטת ניקודים במשחק קליעה למטרה

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

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

דוגמאות: 5, 7, 9, 3, 3 - ממוצע 5.4, הצליח. 7, 6, 1, 7, 8, 0 - בארבע יריות מתוך שש 6 ומעלה, הצליח. 2, 10, 0 - יש 10, הצליח.
כתבו פעולה חיצונית ששמה success בשפת Java או Success בשפת C#, המקבלת מספר שלם num - מספר החיצים שהאדם ירה. הפעולה תקלוט את מספר הנקודות בעבור כל חץ, ותחזיר true אם האדם הצליח במשחק, אחרת false.

פתרון
1.מה מתקבל ומה נקלט: num מתקבל כפרמטר; num הניקודים נקלטים, אחד בכל סיבוב.
2.שלושה משתנים: sum (int, סכום), countHigh (int, כמה ניקודים של 6 ומעלה), hit10 (בוליאני, האם היה 10).
3.אחרי הלולאה: ממוצע (double) sum / num - בלי ההמרה 27 / 5 הוא 5. "רוב" הוא 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.בדיקה (הרצה): 5, 7, 9, 3, 3 - true; 7, 6, 1, 7, 8, 0 - true; 2, 10, 0 - true. ועוד: 6, 6, 0, 0 - בדיוק חצי, לא רוב - false; 5, 5 - ממוצע 5.0, לא מעל - false.
תשובה

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

4. המחלקה Math ומספרים אקראיים

המחלקה Math

אין צורך לכתוב בעצמכם שורש או חזקה: הפעולות האלה כבר כתובות במחלקה Math. קוראים להן בשם המחלקה, נקודה ושם הפעולה.
במדויק: המחלקה Math היא ספרייה של פעולות מתמטיות, וזימון פעולה נכתב כך: Math.sqrt(n) ב-Java ו-Math.Sqrt(n) ב-C#. הפעולות שבתכנית: abs, max, min, pow, round, sqrt ו-random. בבחינה צריך לדעת מה כל פעולה מחזירה ומאיזה טיפוס: Math.sqrt ו-Math.pow מחזירות double, ולכן שמירה במשתנה int דורשת המרה. צריך גם לדעת להגריל מספר שלם בתחום.

Math.max מופיעה גם בשאלות מעקב על מערכים, למשל בפעולה what של קיץ 2025, שמחזירה את הסכום הגדול ביותר של רצף איברים צמודים.

הפעולות של Math

פעולהJavaC#מחזירהדוגמה
ערך מוחלטMath.abs(x)Math.Abs(x)אותו טיפוס כמו xMath.abs(-7) = 7
הגדול מבין שנייםMath.max(a, b)Math.Max(a, b)אותו טיפוס כמו a ו-bMath.max(3, 8) = 8
הקטן מבין שנייםMath.min(a, b)Math.Min(a, b)אותו טיפוס כמו a ו-bMath.min(3, 8) = 3
חזקהMath.pow(a, b)Math.Pow(a, b)doubleMath.pow(2, 3) = 8.0
שורש ריבועיMath.sqrt(x)Math.Sqrt(x)doubleMath.sqrt(23) ≈ 4.796
עיגולMath.round(x)Math.Round(x)ב-Java שלם מטיפוס longMath.round(4.6) = 5
מספר אקראיMath.random()אין: משתמשים בעצם Randomdouble מ-0 עד 1, בלי 1-

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

// בראש הקובץ: import java.util.Random;
Random rnd = new Random();               // עצם אחד, לפני הלולאה
int r1 = rnd.nextInt(n);                 // 0 עד n-1
int r2 = rnd.nextInt(b - a + 1) + a;     // a עד b
int r3 = (int) (Math.random() * n);      // 0 עד n-1, בלי עצם Random
int r4 = (int) (Math.random() * (b - a + 1)) + a;   // a עד b

בהרצה של 200000 הגרלות עם n = 6, a = 1, b = 1000: r1 ו-r3 קיבלו ערכים מ-0 עד 5, ו-r2 ו-r4 מ-1 עד 1000.

דרך הפתרון

הגרלה שנספרת רק כשהיא תקפה

1.עצם Random אחד לפני הלולאה. ב-Java צריך בראש הקובץ import java.util.Random;.
2.בוחרים לולאה: כשהשאלה אומרת שהגרלה מסוימת "לא תיחשב", משתמשים ב-while עם מונה, ולא ב-for עם מספר קבוע של סיבובים.
3.בכל סיבוב: מגרילים, בודקים את התנאי, ורק אם הוא מתקיים - מבצעים את הפעולה ומגדילים את המונה.
4.אחרי הלולאה: מה שהשאלה מבקשת - הדפסה או החזרה.
שים לב

(int) קוטעת את החלק העשרוני, לא מעגלת: (int)(Math.sqrt(23)) הוא 4, אף ש-Math.sqrt(23) ≈ 4.79.

שים לב

Math.pow מחזירה double, ולכן int x = Math.pow(2, 3); לא עובר קומפילציה. כותבים (int)(Math.pow(root, 2)), כמו בקיץ 2026, או מחשבים חזקה של שלמים בכפל בלולאה.

שים לב

ב-C# אין Math.Random: מגרילים בעזרת Random rnd = new Random(); ו-rnd.Next(...). ב-rnd.Next(a, b) הגבול העליון b לא נכלל, ולכן לתחום 1 עד 1000 כותבים rnd.Next(1, 1001).

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

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

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.מה עושה סיבוב: (int)(Math.sqrt(n)) הוא השורש השלם של n (קטיעה). square הוא הריבוע שלו - הריבוע השלם הגדול ביותר שאינו גדול מ-n. מחסירים אותו מ-n וסופרים צעד.
שלבMath.sqrt(n)rootsquarensteps
אתחול---230
14.79...41671
22.64...2432
31.73...1123
41.41...1114
51.01105
2.הסיום: n = 0, התנאי n > 0 לא מתקיים, ומודפס steps. ההרצה הדפיסה 5.
3.ב: כדי שיודפס 1 הלולאה צריכה לרוץ פעם אחת, כלומר כבר בסיבוב הראשון n - square = 0: n הוא ריבוע שלם. בעבור n = 4: root = 2, square = 4, n = 0, steps = 1. בהרצה על 2 עד 100 הודפס 1 בדיוק בעבור 4, 9, 16, 25, 36, 49, 64, 81, 100.
תשובה

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

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

"מערך מעורבל" הוא מערך מטיפוס שלם שהתהליך שלהלן בוצע בו 30 פעמים:

1.מוגרלים שני מספרי אינדקס תקינים (בגבולות גודל המערך).
2.הערכים שבתאים שמספריהם עלו בהגרלה מתחלפים ביניהם.

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

פתרון
1.הגרלת אינדקס תקין: rnd.nextInt(arr.length) / rnd.Next(arr.Length) - שלם מ-0 עד אורך המערך פחות 1.
2.הלולאה: הגרלה של שני אינדקסים זהים לא נספרת, ולכן while עם מונה count שגדל רק כש-i != j.
3.ההחלפה: בעזרת משתנה עזר temp.
4.הפלט: לולאה שמדפיסה כל ערך בשורה נפרדת.
public static void shuffle(int[] arr)
{
    Random rnd = new Random();
    int count = 0;
    while (count < 30)
    {
        int i = rnd.nextInt(arr.length);
        int j = rnd.nextInt(arr.length);
        if (i != j)
        {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            count++;
        }
    }
    for (int k = 0; k < arr.length; k++)
    {
        System.out.println(arr[k]);
    }
}
5.בדיקה (הרצה): במערך {1, 2} כל החלפה תקפה מחליפה את שני התאים, ואחרי 30 החלפות (מספר זוגי) הודפסו 1 ו-2 - בדיוק 30 החלפות נספרו. במערך {10, 20, 30, 40, 50, 60, 70} הודפסו 7 שורות באותם ערכים בסדר אחר.
תשובה

לולאת while עם מונה שגדל רק כאשר שני האינדקסים המוגרלים שונים (30 החלפות תקפות), ואחריה הדפסת המערך, ערך בכל שורה.

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

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

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