מדעי המחשב - יסודות C#

שיעור ראשון במדעי המחשב

הדפסת שלום עולם · C#

השלבים של תכנית C# ראשונה התערבבו. סדרו אותם.

שפת התכנות C# · מבצע הפתיחה

תשבץ · יסודות C#

משימת תכנות ראשונה

המשימה הראשונה שלכם. המטרה היא לוודא שסביבת העבודה פועלת ושאתם יודעים להריץ תכנית, לא לכתוב אלגוריתם מסובך. כתבו תכנית שמדפיסה שלוש שורות: 1. את שמכם 2. את שם הכיתה 3. את המשפט: אני מתחיל ללמוד C# הנחיות: • השתמשו ב-Console.WriteLine לכל שורה. • לחצו הרץ, ורק אחר כך הגישו.

שטח והיקף מלבן

כתוב פעולה שמקבלת אורך ורוחב של מלבן ומדפיסה את השטח ואת ההיקף שלו, כל אחד בשורה נפרדת ובסדר הזה. דוגמה עבור אורך 5 ורוחב 3: 15 16 הנחיות: • האורך והרוחב הם מספרים שלמים חיוביים. • השתמש במשתנים לשמירת התוצאות, לא בחישוב בתוך ההדפסה.

משניות לשעון

כתוב פעולה שמקבלת מספר שניות ומדפיסה אותו בפורמט שעות:דקות:שניות, מופרד בנקודתיים, בלי ריפוד באפסים. דוגמאות: 3661 → 1:1:1 7325 → 2:2:5 59 → 0:0:59 הנחיות: • השתמש באופרטורים / ו-% על מספרים שלמים. • המספר הנתון אינו שלילי. ```ds:table {"title":"דוגמאות","rows":[["שניות","פלט"],["3661","1:1:1"],["7325","2:2:5"],["59","0:0:59"],["0","0:0:0"]]} ```

החלפת ערכים

כתוב פעולה שמקבלת שני מספרים a ו-b ומדפיסה אותם אחרי החלפה — קודם b ואז a, כל אחד בשורה נפרדת. דוגמה עבור a=7, b=2: 2 7 הנחיות: • בצע את ההחלפה בעזרת משתנה עזר, ואל תדפיס פשוט בסדר הפוך. • זו הנקודה של התרגיל: להבין שהשמה מוחקת את הערך הקודם.

ממוצע שלושה מספרים מהמשתמש

כתוב תכנית שקולטת מהמשתמש שלושה מספרים שלמים ומדפיסה את הממוצע שלהם. התכנית חייבת להיות ידידותית למשתמש: הודעה שמסבירה מה להזין לפני הקליטה, ומשפט תוצאה מנוסח ולא מספר עירום. ריצה לדוגמה (הקלט הוא שלוש השורות באמצע): Please enter 3 int numbers 3 5 6 The average of 3, 5 and 6 is 4.666666666666667 הנחיות: • כל מספר מוזן בשורה נפרדת. בכרטיסיית הקלט של העורך יש להזין שלוש שורות. • סכום של שלושה מספרים שלמים הוא שלם, וחלוקה שלמה ב-3 תמחק את השארית. עבור 3, 5 ו-6 יתקבל 4 במקום 4.666. יש לחלק ב-3.0. • משפט התוצאה צריך לכלול את שלושת המספרים שנקלטו ואת הממוצע. ```ds:table {"title":"דוגמאות","rows":[["מספרים","סכום","ממוצע"],["3, 5, 6","14","4.666666666666667"],["10, 20, 30","60","20.0"],["1, 1, 2","4","1.3333333333333333"]]} ```

משתנים וטיפוסי נתונים ב-C#

קלט ופלט ב-C# — מהמסך למשתנה וחזרה

משתנים וטיפוסים ב-C# — חידון סיכום

קליטה והצגת שם משתמש · C#

התכנית אמורה לבקש שם מהמשתמש ולהדפיס ברכה אישית. סדרו את השלבים.

קליטת שני מספרים והדפסת סכומים

קלטו מהמשתמש שני מספרים שלמים והדפיסו עליהם ארבע תוצאות. הפלט הנדרש, כל אחד בשורה נפרדת: • הסכום • ההפרש (הראשון פחות השני) • המכפלה • הממוצע הנחיות: • הקליטה בעזרת Console.ReadLine והמרה ל-int. • שימו לב לחישוב הממוצע — שני שלמים מתחלקים בחילוק שלם. ```ds:table {"title":"דוגמה","rows":[["קלט","פלט"],["7 ו-3","10, 4, 21, 5"],["4 ו-5","9, -1, 20, 4.5"]]} ```

תשבץ · משתנים וטיפוסים ב-C#

שטח משולש

כתוב פעולה שמקבלת בסיס וגובה של משולש (שני מספרים שלמים) ומדפיסה את שטחו. הנוסחה: (בסיס כפול גובה) חלקי 2 דוגמאות: בסיס 6, גובה 4 → 12.0 בסיס 7, גובה 3 → 10.5 בסיס 5, גובה 1 → 2.5 הנחיות: • מכפלה של שני מספרים שלמים היא מספר שלם, וחלוקה שלמה מוחקת את החצי. הביטוי base * height / 2 יחזיר 10 עבור 7 ו-3, ולא 10.5. • הפתרון: לחלק ב-2.0, או להמיר אחד הגורמים לטיפוס עשרוני לפני החלוקה. • זו אותה מלכודת שתחזור בכל חישוב ממוצע — כדאי להבין אותה כאן. ```ds:table {"title":"דוגמאות","rows":[["בסיס","גובה","שטח"],["6","4","12.0"],["7","3","10.5"],["5","1","2.5"]]} ```

שטח מעגל

כתוב פעולה שמקבלת רדיוס (מספר עשרוני) ומדפיסה את שטח המעגל. הנוסחה: פאי כפול הרדיוס בריבוע. דוגמאות: רדיוס 1 → 3.141592653589793 רדיוס 2 → 12.566370614359172 רדיוס 0 → 0.0 הנחיות: • יש להשתמש בקבוע פאי של הספרייה המתמטית ולא בקירוב 3.14 שנכתב ביד — הקירוב סוטה כבר בספרה השלישית אחרי הנקודה. • את הריבוע אפשר לכתוב כמכפלה של הרדיוס בעצמו, או בעזרת פעולת החזקה של הספרייה המתמטית. שתי הדרכים תקינות. ```ds:table {"title":"דוגמאות","rows":[["רדיוס","שטח"],["1","3.141592653589793"],["2","12.566370614359172"],["0","0.0"]]} ```

מרחק בין שתי נקודות

כתוב פעולה שמקבלת ארבעה מספרים — x1, y1, x2, y2 — ומדפיסה את המרחק בין שתי הנקודות במישור. הנוסחה: שורש של ((x2-x1)² + (y2-y1)²) דוגמאות: (0,0) ו-(3,4) → 5.0 (1,1) ו-(1,1) → 0.0 (-2,0) ו-(2,0) → 4.0 הנחיות: • השתמש ב-Math.sqrt לחישוב השורש. • שמור את ההפרשים במשתנים לפני החישוב — כך הביטוי נשאר קריא. • תוצאה שלילית אינה אפשרית כאן; אם קיבלת כזו, יש טעות בסדר הפעולות. ```ds:table {"title":"דוגמאות","rows":[["נקודה א","נקודה ב","מרחק"],["(0,0)","(3,4)","5.0"],["(1,1)","(1,1)","0.0"],["(-2,0)","(2,0)","4.0"]]} ```

עיגול לאלפים

כתוב תכנית שמגרילה מספר שלם בין 1000 ל-10000 (כולל), ומדפיסה שתי שורות: את המספר לפני העיגול, ואת אותו מספר מעוגל לאלף הקרוב. דוגמאות: 1773 → 2000 5006 → 5000 5500 → 6000 9500 → 10000 הנחיות: • השארית מחלוקה ב-1000 היא שקובעת. אם היא 500 או יותר — מעגלים כלפי מעלה, ואחרת כלפי מטה. • חצי בדיוק, כלומר שארית של 500, מתעגל כלפי מעלה. זה מה שקורה עם 5500. • אין להשתמש בפעולת העיגול של הספרייה המתמטית על תוצאת חלוקה שלמה — החלוקה השלמה כבר מחקה את השארית, ואין מה לעגל. אם משתמשים בעיגול של הספרייה, החלוקה שלפניו חייבת להיות עשרונית. • התחום 1000 עד 10000 כולל את שני הקצוות. • הפלט משתנה בכל הרצה. ```ds:table {"title":"דוגמאות","rows":[["מספר","שארית מ-1000","מעוגל"],["1773","773","2000"],["5006","6","5000"],["5500","500","6000"],["9500","500","10000"]]} ```

חמש הפעולות על מספרים שלמים

הגדירו שני משתנים שלמים והציבו בהם ערכים לבחירתכם. בצעו עליהם את חמש הפעולות והדפיסו כל תוצאה בשורה משלה: 1. חיבור (+) 2. חיסור (-) 3. כפל (*) 4. חילוק (/) 5. שארית (%) הנחיות: • הדפיסו לצד כל תוצאה את התרגיל עצמו, למשל: 17 / 5 = 3 • בחרו ערכים שבהם החילוק אינו יוצא שלם — כך תראו מה החילוק באמת עושה.

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

כתוב פעולה שמקבלת מספר שלם תלת-ספרתי ומדפיסה את ספרותיו, כל אחת בשורה נפרדת, מספרת האחדות לספרת המאות. דוגמה עבור 347: 7 4 3 דוגמה עבור 100: 0 0 1 הנחיות: • ספרת האחדות היא השארית מחלוקה ב-10. • ספרת המאות היא התוצאה של חלוקה שלמה ב-100. • ספרת העשרות היא השילוב של השניים — קודם חלוקה שלמה ב-10, ואז שארית. • בפעולות חשבון בלבד: בלי המרה למחרוזת, בלי לולאה ובלי מערך. המספר ידוע כתלת-ספרתי, ולכן אין צורך בתנאים. ```ds:table {"title":"דוגמאות","rows":[["מספר","אחדות","עשרות","מאות"],["347","7","4","3"],["100","0","0","1"],["999","9","9","9"]]} ```

היפוך מספר תלת-ספרתי

כתוב פעולה שמקבלת מספר שלם תלת-ספרתי ומדפיסה את המספר ההפוך שלו, כמספר אחד. דוגמאות: 369 → 963 120 → 21 100 → 1 הנחיות: • יש לחלץ את שלוש הספרות, ואז להרכיב מהן מספר חדש: ספרת האחדות כפול 100, ועוד ספרת העשרות כפול 10, ועוד ספרת המאות. • שים לב לדוגמה השנייה: ההיפוך של 120 הוא 021, וכמספר שלם זה 21. אפס מוביל אינו קיים במספר — התוצאה נכונה גם אם היא דו-ספרתית. • התוצאה היא מספר אחד בשורה אחת, לא שלוש הדפסות של ספרות. ```ds:table {"title":"דוגמאות","rows":[["מספר","הפוך"],["369","963"],["120","21"],["100","1"],["505","505"]]} ```

תו וקוד אסקי

כתוב פעולה שמקבלת תו ומדפיסה שלוש שורות: 1. התו עצמו. 2. קוד האסקי שלו (מספר שלם). 3. התו שאחריו בטבלת האסקי. דוגמה עבור התו a: a 97 b דוגמה עבור התו A: A 65 B הנחיות: • תו הוא בפועל מספר. המרה מתו למספר מתבצעת בהמרה מפורשת לטיפוס שלם. • כדי לקבל את התו הבא צריך להוסיף 1 ואז להמיר חזרה לטיפוס תו — בלי ההמרה חזרה תודפס התוצאה כמספר. • אין להשתמש בטבלת המרה ידנית ואין להניח שהאותיות רצופות מעבר לאלפבית האנגלי — התרגיל בודק את ההמרה עצמה. ```ds:table {"title":"דוגמאות","rows":[["תו","קוד","התו הבא"],["a","97","b"],["A","65","B"],["y","121","z"]]} ```

ספרות שוות במספר דו-ספרתי

כתוב פעולה שמקבלת מספר שלם חיובי. אם המספר דו-ספרתי, הפעולה תבדוק אם ספרת האחדות שווה לספרת העשרות ותדפיס YES או NO בהתאם. אם המספר אינו דו-ספרתי, הפעולה תדפיס NOT TWO. דוגמאות: 44 → YES 47 → NO 5 → NOT TWO 123 → NOT TWO הנחיות: • זה תנאי מקונן: הבדיקה הפנימית (האם הספרות שוות) מתבצעת רק בתוך התנאי החיצוני (האם המספר דו-ספרתי). • מספר דו-ספרתי הוא מספר בין 10 ל-99 כולל. • אם תבדוק את שוויון הספרות לפני בדיקת האורך, מספר חד-ספרתי יסווג בטעות כ-YES — ספרת האחדות וספרת העשרות שלו שתיהן אפס. ```ds:table {"title":"דוגמאות","rows":[["מספר","דו-ספרתי?","פלט"],["44","כן","YES"],["47","כן","NO"],["5","לא","NOT TWO"],["123","לא","NOT TWO"],["99","כן","YES"]]} ```

פירוט סכום למטבעות

כתוב פעולה שמקבלת סכום באגורות ומדפיסה בכמה מטבעות מכל סוג אפשר לשלם אותו, כשמעדיפים תמיד את המטבע הגדול ביותר האפשרי. המטבעות: 100, 50, 10, 5 אגורות. ההדפסה — ארבע שורות, בסדר הזה, רק המספר בכל שורה. דוגמה עבור 165: 1 1 1 1 כלומר מטבע אחד של 100, אחד של 50, אחד של 10 ואחד של 5. הנחיות: • בכל שלב: כמה מטבעות נכנסים = מה שנשאר / ערך המטבע. ומה שנשאר אחרי זה = מה שנשאר % ערך המטבע. • הסכום הנתון מתחלק ב-5 ללא שארית. ```ds:table {"title":"מעקב עבור 165","rows":[["מטבע","כמות","נשאר"],["100","1","65"],["50","1","15"],["10","1","5"],["5","1","0"]]} ```

חילוק שלם ושארית

קלטו שני מספרים שלמים חיוביים והדפיסו את המנה השלמה ואת השארית. דוגמאות: 17 ו-5 → מנה 3, שארית 2 20 ו-4 → מנה 5, שארית 0 3 ו-7 → מנה 0, שארית 3 הנחיות: • אין להשתמש בחילוק עשרוני. • השתמשו באופרטורים / ו-% בלבד. • הניחו שהמספר השני גדול מאפס. ```ds:table {"title":"דוגמאות","rows":[["מחולק","מחלק","מנה","שארית"],["17","5","3","2"],["20","4","5","0"],["3","7","0","3"]]} ```

אופרטורים מתמטיים · C#

הגרלת אות באסקי

כתוב תכנית שמגרילה מספר שלם בין 65 ל-90 (כולל שני הקצוות), ומדפיסה שתי שורות: את המספר שהוגרל, ואת התו המתאים לו בטבלת האסקי. התחום 65 עד 90 הוא בדיוק האותיות הגדולות מ-A ועד Z. ריצה לדוגמה: 72 H ריצה אחרת: 90 Z הנחיות: • שים לב לנוסחת ההגרלה. שני הקצוות חייבים להיות אפשריים — גם 65 וגם 90. יש 26 ערכים אפשריים, לא 25. • פעולת ההגרלה בשפה מחזירה תחום שמתחיל באפס, ולכן צריך להזיז אותו: ההתחלה ועוד הגרלה על גודל התחום. • ההמרה מקוד לתו היא המרה מפורשת. בלעדיה יודפס המספר פעמיים. • הפלט משתנה בכל הרצה — זה תקין. ```ds:table {"title":"הקשר בין קוד לתו","rows":[["קוד","תו"],["65","A"],["72","H"],["90","Z"]]} ```

הטלת שתי קוביות

כתוב תכנית שמגרילה שתי קוביות. ערך כל קובייה הוא בין 1 ל-6 (כולל). התכנית תציג את תוצאות ההגרלה בצורה ברורה, ואז: • אם התוצאה היא דאבל (שתי הקוביות זהות) תדפיס בנוסף: good for you • אחרת תדפיס: This is a regular result ריצה לדוגמה: 4 4 good for you ריצה אחרת: 2 5 This is a regular result הנחיות: • כל קובייה מוגרלת בנפרד. הגרלה אחת שמשמשת לשתי הקוביות תיתן דאבל בכל הרצה — זו לא הטלה של שתי קוביות. • התחום 1 עד 6 כולל את שני הקצוות. פעולת ההגרלה מחזירה תחום שמתחיל באפס, ולכן צריך להוסיף 1. • הפלט משתנה בכל הרצה. כדאי להריץ כמה פעמים ולוודא ששני המקרים מופיעים. ```ds:table {"title":"ריצות לדוגמה","rows":[["קובייה א","קובייה ב","פלט"],["4","4","good for you"],["2","5","This is a regular result"],["6","6","good for you"]]} ```

חזקה בלולאה

כתוב פעולה שמקבלת שני מספרים שלמים, בסיס ומעריך, ומחזירה את הבסיס בחזקת המעריך. המעריך אינו שלילי. דוגמאות: 2 בחזקת 5 → 32 7 בחזקת 1 → 7 5 בחזקת 0 → 1 0 בחזקת 3 → 0 הנחיות: • יש לפתור בלולאה. אין להשתמש ברקורסיה ואין להשתמש בפעולת החזקה של הספרייה המתמטית. • יש לאתחל את התוצאה ל-1 ולא ל-0 — התוצאה נבנית בכפל, וכפל באפס מאפס הכול. • כל מספר בחזקת אפס הוא 1. אם אתחלת נכון, המקרה הזה מסתדר מעצמו והלולאה פשוט לא מתבצעת. • הפעולה מחזירה ערך ואינה מדפיסה. ההדפסה נעשית ב-main על הערך המוחזר — זימון הפעולה בלי הדפסה יחשב את התוצאה ויזרוק אותה. ```ds:table {"title":"מעקב עבור 2 בחזקת 5","rows":[["מעבר","תוצאה"],["התחלה","1"],["1","2"],["2","4"],["3","8"],["4","16"],["5","32"]]} ```

זוגי או אי-זוגי

כתוב פעולה שמקבלת מספר שלם ומדפיסה: The number is even אם המספר זוגי The number is odd אם המספר אי-זוגי דוגמאות: 10 → The number is even 3 → The number is odd 0 → The number is even -4 → The number is even הנחיות: • מספר זוגי הוא מספר שהשארית שלו מחלוקה ב-2 היא אפס. • האפס עצמו זוגי. • שים לב למספרים שליליים: השארית של מספר שלילי מחלוקה ב-2 יכולה להיות מינוס אחת ולא אחת, ולכן ההשוואה חייבת להיות לאפס — בדיקה של שוויון לאחת תיכשל על מספרים שליליים אי-זוגיים. ```ds:table {"title":"דוגמאות","rows":[["מספר","פלט"],["10","The number is even"],["3","The number is odd"],["0","The number is even"],["-7","The number is odd"]]} ```

סימן המספר

כתוב פעולה שמקבלת מספר שלם ומדפיסה סימן אחד: + אם המספר חיובי - אם המספר שלילי 0 אם המספר הוא אפס דוגמאות: 5 → + -3 → - 0 → 0 הנחיות: • שלושה מקרים זרים זה לזה — שרשרת של תנאי, אחרת-אם, ואחרת. • האפס אינו חיובי ואינו שלילי. אם בנית שני תנאים בלבד, אחד מהם יבלע את האפס בטעות. • הפלט הוא תו בודד בשורה, בלי טקסט נוסף. ```ds:table {"title":"דוגמאות","rows":[["מספר","פלט"],["5","+"],["-3","-"],["0","0"],["-1","-"]]} ```

הגדול מבין שלושה

כתוב פעולה שמקבלת שלושה מספרים שלמים ומחזירה את הגדול מביניהם. דוגמאות: 4, 9, 2 → 9 7, 7, 7 → 7 -5, -2, -9 → -2 הנחיות: • השתמש בתנאים בלבד, בלי Math.max ובלי מערכים. • שים לב למקרה שבו שניים מהמספרים שווים.

מתחלק ב-2 או ב-3

כתוב פעולה שמקבלת מספר שלם ומדפיסה YES אם הוא מתחלק ב-2 ללא שארית או מתחלק ב-3 ללא שארית. אחרת תדפיס NO. דוגמאות: 6 → YES (מתחלק בשניהם) 8 → YES (מתחלק ב-2 בלבד) 9 → YES (מתחלק ב-3 בלבד) 7 → NO הנחיות: • זהו תנאי אחד עם אופרטור או לוגי, לא שני תנאים נפרדים. • מספיק שאחד מהשניים מתקיים — אין דרישה ששניהם יתקיימו. • האפס מתחלק בכל מספר ללא שארית, ולכן עבורו הפלט YES. ```ds:table {"title":"דוגמאות","rows":[["מספר","שארית מ-2","שארית מ-3","פלט"],["6","0","0","YES"],["8","0","2","YES"],["9","1","0","YES"],["7","1","1","NO"]]} ```

ציון לדרגה

כתוב פעולה שמקבלת ציון בין 0 ל-100 ומחזירה מחרוזת לפי הטבלה: 90 ומעלה → "מצוין" 80 עד 89 → "טוב מאוד" 70 עד 79 → "טוב" 55 עד 69 → "מספיק" מתחת ל-55 → "לא עבר" הנחיות: • השתמש בשרשרת else-if, לא בסדרת if נפרדים. • שים לב לגבולות: 90, 80, 70 ו-55 שייכים לדרגה הגבוהה יותר. ```ds:table {"title":"טבלת הדרגות","rows":[["ציון","דרגה"],["90 עד 100","מצוין"],["80 עד 89","טוב מאוד"],["70 עד 79","טוב"],["55 עד 69","מספיק"],["0 עד 54","לא עבר"]]} ```

סוג המשולש

כתוב פעולה שמקבלת שלושה מספרים חיוביים — אורכי צלעות — ומדפיסה: none — אם לא ניתן לבנות מהם משולש כלל equilateral — משולש שווה צלעות isosceles — משולש שווה שוקיים (בדיוק שתי צלעות שוות) scalene — משולש שכל צלעותיו שונות דוגמאות: 1, 2, 10 → none 5, 5, 5 → equilateral 5, 5, 8 → isosceles 3, 4, 5 → scalene הנחיות: • תנאי קיום משולש: סכום כל שתי צלעות גדול ממש מהשלישית. שלושת התנאים חייבים להתקיים. • בדוק את הקיום קודם — משולש שאינו קיים אינו שווה צלעות גם אם שלוש הצלעות שוות בגודלן... אבל שים לב שמקרה כזה בכלל לא אפשרי. למה? ```ds:table {"title":"דוגמאות","rows":[["צלעות","פלט"],["1, 2, 10","none"],["1, 2, 3","none"],["5, 5, 5","equilateral"],["8, 5, 5","isosceles"],["3, 4, 5","scalene"]]} ```

שנה מעוברת

כתוב פעולה שמקבלת שנה ומחזירה true אם היא מעוברת. הכלל המלא: • שנה שמתחלקת ב-4 היא מעוברת, • אלא אם היא מתחלקת ב-100, • אלא אם היא מתחלקת גם ב-400 — ואז היא כן מעוברת. דוגמאות: 2024 → true 1900 → false (מתחלקת ב-100 ולא ב-400) 2000 → true (מתחלקת ב-400) 2023 → false ```ds:table {"title":"למה כל שנה נופלת איפה שהיא נופלת","rows":[["שנה","מעוברת?","הכלל שקובע"],["2024","כן","מתחלקת ב-4"],["1900","לא","מתחלקת ב-100 ולא ב-400"],["2000","כן","מתחלקת ב-400"],["2100","לא","מתחלקת ב-100 ולא ב-400"],["2023","לא","לא מתחלקת ב-4"]]} ```

איזה סוג של תו

כתוב פעולה שמקבלת תו ומדפיסה מה הוא: digit — אם התו הוא ספרה '0' עד '9' letter — אם התו הוא אות אנגלית, גדולה או קטנה other — בכל מקרה אחר דוגמאות: '7' → digit 'k' → letter 'K' → letter '#' → other ' ' → other הנחיות: • תו הוא מספר — אפשר להשוות אותו לתווים אחרים באמצעות <= ו->=. • 'a' <= c && c <= 'z' בודק שהתו נמצא בטווח האותיות הקטנות. • פתור בעזרת השוואות בלבד, בלי פעולות מוכנות מהספרייה. ```ds:table {"title":"דוגמאות","rows":[["תו","פלט"],["'7'","digit"],["'k'","letter"],["'K'","letter"],["'#'","other"],["' '","other"]]} ```

קנס מהירות

כתוב פעולה שמקבלת את מהירות הנסיעה ואת מספר נקודות החובה שצבר הנהג. אם המהירות גבוהה מ-90: • תודפס ההודעה PAY • ואם מספר הנקודות גדול מ-6, תודפס בנוסף ההודעה COURSE אם המהירות אינה גבוהה מ-90, תודפס ההודעה OK בלבד. דוגמאות: מהירות 100, נקודות 8 → PAY ואחריו COURSE מהירות 100, נקודות 3 → PAY מהירות 80, נקודות 9 → OK מהירות 90, נקודות 9 → OK הנחיות: • בדיקת הנקודות נמצאת בתוך בדיקת המהירות, לא לצידה. • נהג שנסע במהירות מותרת אינו נבדק על נקודות כלל — גם אם צבר תשע. • שים לב לגבול: מהירות של 90 בדיוק אינה גבוהה מ-90. ```ds:table {"title":"דוגמאות","rows":[["מהירות","נקודות","פלט"],["100","8","PAY, COURSE"],["100","3","PAY"],["80","9","OK"],["90","9","OK"]]} ```

קבלה לקורס טייס

כדי להתקבל לקורס טייס אזרחי, על המועמד לעמוד באחת משתי הדרישות: • מעל 15 שנות השכלה • או: מעל 12 שנות השכלה וגם ציון בגרות ממוצע מעל 90 כתוב פעולה שמקבלת את מספר שנות ההשכלה ואת ציון הבגרות, ומדפיסה OK אם המועמד התקבל, ו-NO אם לא. דוגמאות: 16 שנים, ציון 70 → OK (הדרישה הראשונה) 13 שנים, ציון 95 → OK (הדרישה השנייה) 13 שנים, ציון 80 → NO 12 שנים, ציון 100 → NO (12 אינו מעל 12) הנחיות: • זה תנאי מורכב אחד: או בין שתי דרישות, כשהדרישה השנייה עצמה מורכבת משני תנאים המחוברים בוגם. • הסוגריים סביב הוגם הכרחיים. בלעדיהם סדר הקדימויות עלול לשנות את משמעות התנאי. • כל ההשוואות הן מעל ממש, לא מעל או שווה. ```ds:table {"title":"דוגמאות","rows":[["שנות השכלה","ציון","פלט"],["16","70","OK"],["13","95","OK"],["13","80","NO"],["12","100","NO"],["15","95","OK"]]} ```

כביש אגרה

כביש אגרה מחולק לקטעים. מחיר הנסיעה בכל קטע הוא 30 שקלים. נהג שעובר יותר משמונה קטעים מקבל הנחה של 10 שקלים מהסכום הכולל. כתוב פעולה שמקבלת את מספר הקטעים ומדפיסה את הסכום שעל הנהג לשלם. דוגמאות: 5 קטעים → 150 8 קטעים → 240 9 קטעים → 260 0 קטעים → 0 הנחיות: • ההנחה היא סכום קבוע מהמחיר הכולל, ולא הנחה לכל קטע. • שים לב לגבול: שמונה קטעים בדיוק אינם מזכים בהנחה. הדרישה היא יותר משמונה. • קודם מחשבים את הסכום המלא, ואז מפחיתים אם התנאי מתקיים. ```ds:table {"title":"דוגמאות","rows":[["קטעים","לפני הנחה","הנחה","לתשלום"],["5","150","0","150"],["8","240","0","240"],["9","270","10","260"],["0","0","0","0"]]} ```

מחשבון ארבע פעולות

כתוב פעולה שמקבלת מספר שלם ומספר פעולה, ומדפיסה את התוצאה: פעולה 0 → המספר ועוד 2 פעולה 1 → המספר פחות 2 פעולה 2 → המספר כפול 2 פעולה 3 → המספר חלקי 2, כמספר עשרוני כל ערך אחר → ERROR דוגמאות עבור המספר 7: פעולה 0 → 9 פעולה 1 → 5 פעולה 2 → 14 פעולה 3 → 3.5 פעולה 9 → ERROR הנחיות: • השתמש בשרשרת של תנאי ואחרת-אם. סדרה של תנאים נפרדים תעבוד גם היא כאן, אבל היא בודקת את כל התנאים גם אחרי שנמצאה התאמה — וברגע שהענפים ישנו את אותו משתנה, זה יהפוך לבאג. • בחלוקה: המספר שלם, ולכן חלוקה ב-2 תיתן 3 ולא 3.5. יש לחלק ב-2.0. • הענף האחרון תופס כל ערך פעולה שאינו בין 0 ל-3. ```ds:table {"title":"הפלט עבור המספר 7","rows":[["קוד פעולה","משמעות","פלט"],["0","ועוד 2","9"],["1","פחות 2","5"],["2","כפול 2","14"],["3","חלקי 2","3.5"],["9","לא חוקי","ERROR"]]} ```

שלושה מספרים — כמה מהם שווים

כתוב פעולה שמקבלת שלושה מספרים שלמים ומדפיסה: all equal אם שלושת המספרים שווים only two are equal אם רק שניים מבין השלושה שווים different numbers אם כל המספרים שונים זה מזה דוגמאות: 4, 4, 4 → all equal 4, 4, 7 → only two are equal 4, 7, 4 → only two are equal 7, 4, 4 → only two are equal 1, 2, 3 → different numbers הנחיות: • בדוק קודם את המקרה החזק ביותר — שלושתם שווים. אם תבדוק קודם שוויון של זוג, גם שלושה מספרים שווים ייכנסו לענף הזה. • השניים השווים אינם בהכרח צמודים. שלוש ההשוואות הזוגיות האפשריות הן ראשון-שני, שני-שלישי וראשון-שלישי, וצריך לכסות את שלושתן. • השתמש בשרשרת אחרת-אם כדי שרק הודעה אחת תודפס. ```ds:table {"title":"דוגמאות","rows":[["א","ב","ג","פלט"],["4","4","4","all equal"],["4","4","7","only two are equal"],["7","4","4","only two are equal"],["4","7","4","only two are equal"],["1","2","3","different numbers"]]} ```

תנאים ב-C# — חידון סיכום · C#

המקסימלי מבין שניים · C#

התכנית קולטת שני מספרים ומדפיסה את הגדול. סדרו את השלבים.

הגדול מבין שלושה — סדרו · C#

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

ספירה לאחור

כתוב פעולה שמקבלת מספר שלם ומדפיסה בשורה אחת את כל המספרים ממנו עד 1, בסדר יורד, מופרדים ברווח. דוגמאות: 5 → 5 4 3 2 1 1 → 1 0 → לא מודפס דבר הנחיות: • שלושת חלקי הלולאה מתהפכים: מתחילים מהמספר, התנאי הוא גדול או שווה ל-1, והצעד הוא הקטנה באחד. • ההדפסה בתוך הלולאה היא הדפסה בלי ירידת שורה, וירידת שורה אחת מתבצעת בסוף — אחרי הלולאה. • עבור קלט שאינו חיובי הלולאה לא מתבצעת אף פעם, וזו התנהגות נכונה. ```ds:table {"title":"דוגמאות","rows":[["קלט","פלט"],["5","5 4 3 2 1"],["1","1"],["0","שורה ריקה"]]} ```

סכום המספרים בתחום

כתוב פעולה שמקבלת שני מספרים שלמים ומדפיסה את סכום כל המספרים השלמים שביניהם, כולל שני הקצוות. לא ידוע מי משני המספרים גדול. דוגמאות: 4 ו-12 → 72 (כי 4+5+6+7+8+9+10+11+12) 12 ו-4 → 72 (אותו תחום, סדר הפוך) 5 ו-5 → 5 -2 ו-2 → 0 הנחיות: • קודם קובעים מי הקטן ומי הגדול, ורק אז רצים בלולאה מהקטן לגדול. • לולאה שרצה מהראשון לשני בלי לבדוק את הסדר לא תתבצע אף פעם כאשר הראשון גדול, והתוצאה תהיה 0. • יש לפתור בלולאה ולא בנוסחת הסדרה החשבונית — הכוונה כאן היא לתרגול הלולאה עצמה. ```ds:table {"title":"דוגמאות","rows":[["ראשון","שני","סכום"],["4","12","72"],["12","4","72"],["5","5","5"],["-2","2","0"]]} ```

לוח הכפל

כתוב פעולה שמקבלת מספר n ומדפיסה את לוח הכפל בגודל n×n. כל שורה מכילה n מכפלות מופרדות ברווח, בלי רווח מיותר בסוף השורה. דוגמה עבור n=3: 1 2 3 2 4 6 3 6 9 הנחיות: • לולאה חיצונית על השורות, לולאה פנימית על העמודות. • ההדפסה בתוך הלולאה הפנימית היא הדפסה בלי ירידת שורה (print), וירידת השורה מתבצעת בסוף כל מעבר של הלולאה החיצונית. • זו הנקודה של התרגיל: להבין ששני המשתנים i ו-j חיים בשני קצבים שונים. ```ds:table {"title":"הפלט עבור n=3","rows":[["1","2","3"],["2","4","6"],["3","6","9"]]} ```

מלבן כוכביות

כתוב פעולה שמקבלת גובה ורוחב, ומשרטטת מלבן כוכביות בגודל הזה. דוגמה עבור גובה 2 ורוחב 4: **** **** דוגמה עבור גובה 3 ורוחב 1: * * * הנחיות: • הלולאה החיצונית אחראית על השורות, והפנימית על העמודות בתוך כל שורה. • ההדפסה בתוך הלולאה הפנימית היא הדפסה בלי ירידת שורה. ירידת השורה מתבצעת בסוף כל מעבר של הלולאה החיצונית, מחוץ לפנימית. • זו הנקודה של התרגיל: להבין ששני המשתנים חיים בשני קצבים — הפנימי מסיים מחזור שלם בכל צעד בודד של החיצוני. ```ds:table {"title":"הפלט עבור גובה 2 ורוחב 4","rows":[["*","*","*","*"],["*","*","*","*"]]} ```

משולש כוכביות

כתוב פעולה שמקבלת מספר שורות ומשרטטת משולש כוכביות: בשורה הראשונה כוכבית אחת, בשנייה שתיים, וכן הלאה. דוגמה עבור 5 שורות: * ** *** **** ***** הנחיות: • זהו ההבדל מהמלבן, וזו כל הנקודה של התרגיל: הגבול של הלולאה הפנימית אינו קבוע אלא תלוי במונה של הלולאה החיצונית. • אם הלולאה הפנימית רצה עד מספר השורות, יתקבל מלבן ולא משולש. • ההדפסה בפנימית בלי ירידת שורה, וירידת שורה בסוף כל שורה. ```ds:table {"title":"הפלט עבור 5 שורות","rows":[["שורה","כוכביות"],["1","*"],["2","**"],["3","***"],["4","****"],["5","*****"]]} ```

משולש מספרים עולה

כתוב פעולה שמקבלת מספר שורות ומדפיסה משולש מספרים: בכל שורה הספרות מ-1 ועד מספר השורה. דוגמה עבור 4 שורות: 1 12 123 1234 הנחיות: • המבנה זהה למשולש הכוכביות — לולאה מקוננת שבה הגבול הפנימי תלוי בחיצוני. • ההבדל היחיד: במקום להדפיס תו קבוע, מדפיסים את המונה של הלולאה הפנימית עצמה. • המספרים מודפסים ברצף בלי רווחים ובלי מפרידים. • מספר השורות אינו עולה על 9, ולכן אין צורך לטפל במספרים דו-ספרתיים. ```ds:table {"title":"הפלט עבור 4 שורות","rows":[["שורה","פלט"],["1","1"],["2","12"],["3","123"],["4","1234"]]} ```

משולש מספרים יורד

כתוב פעולה שמקבלת מספר שורות ומדפיסה משולש מספרים יורד: בכל שורה הספרות ממספר השורה ועד 1. דוגמה עבור 4 שורות: 1 21 321 4321 הנחיות: • שים לב להבדל מהמשולש העולה: כאן הלולאה הפנימית מתחילה במונה של הלולאה החיצונית, ויורדת עד 1. • זהו השילוב של שני הרעיונות — לולאה מקוננת עם גבול תלוי, ולולאה יורדת. • אין להשתמש בבניית מחרוזת והיפוכה. הפתרון צריך להיות בשתי לולאות. • מספר השורות אינו עולה על 9. ```ds:table {"title":"הפלט עבור 4 שורות","rows":[["שורה","פלט"],["1","1"],["2","21"],["3","321"],["4","4321"]]} ```

עצרת בלולאה

כתוב פעולה שמקבלת מספר שלם אי-שלילי ומחזירה את העצרת שלו. עצרת של מספר היא מכפלת כל המספרים מ-1 עד המספר עצמו: 3 עצרת = 3 כפול 2 כפול 1 = 6 4 עצרת = 4 כפול 3 כפול 2 כפול 1 = 24 דוגמאות: 5 → 120 1 → 1 0 → 1 10 → 3628800 הנחיות: • יש לפתור בלולאה. אין להשתמש ברקורסיה. • יש לאתחל את התוצאה ל-1 ולא ל-0 — הצבירה היא בכפל. • עצרת של 0 היא 1. זו הגדרה מתמטית ולא מקרה קצה שרירותי, והיא מסתדרת מעצמה כשהאתחול נכון והלולאה פשוט לא מתבצעת. • הפעולה מחזירה ערך ואינה מדפיסה. ```ds:table {"title":"מעקב עבור 5","rows":[["מעבר","תוצאה"],["התחלה","1"],["כפול 2","2"],["כפול 3","6"],["כפול 4","24"],["כפול 5","120"]]} ```

ספירת ספרות שמתחלקות ב-3

כתוב פעולה שמקבלת מספר שלם אי-שלילי, וסופרת כמה מספרותיו מתחלקות ב-3 ללא שארית. הפעולה תדפיס את המספר שהתקבל. הספרות שמתחלקות ב-3 הן 0, 3, 6 ו-9. דוגמאות: 3630 → 4 1247 → 0 9 → 1 0 → 1 הנחיות: • בכל מעבר: מחלצים את הספרה האחרונה כשארית מחלוקה ב-10, בודקים אותה, ואז מקטינים את המספר בחלוקה שלמה ב-10. • האפס מתחלק ב-3 ללא שארית ולכן הוא נספר. • שים לב לקלט 0: לולאה שתנאי הכניסה שלה הוא שהמספר גדול מאפס לא תתבצע אף פעם ותחזיר 0, אבל למספר 0 יש ספרה אחת והתשובה הנכונה היא 1. ```ds:table {"title":"דוגמאות","rows":[["מספר","ספרות מתאימות","תשובה"],["3630","3, 6, 3, 0","4"],["1247","אין","0"],["9","9","1"],["0","0","1"]]} ```

מרתון הלולאות · C#

הדפסה 1 עד 10 — משהו כאן פספס · C#

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

הדפסת זוגיים

יש לכתוב קוד בפעולה הראשית המדפיסה את כל המספרים הזוגיים בין 1 ל-100. כמו כן יש להשתמש בלולאת for.

סכום ספרות

כתוב פעולה שמקבלת מספר שלם חיובי ומחזירה את סכום ספרותיו. דוגמאות: 472 → 13 (4+7+2) 9 → 9 1000 → 1 הנחיות: • השתמש בלולאה, לא בהמרה למחרוזת. • המספר הנתון גדול מ-0. ```ds:table {"title":"דוגמאות","rows":[["קלט","סכום הספרות"],["472","13"],["9","9"],["1000","1"]]} ```

בחינה חוזרת עד ציון עובר

כתוב תכנית שקולטת ציונים בבחינה. כל עוד הציון קטן מ-55 התלמיד נכשל, מודפסת ההודעה FAIL, והתכנית קולטת ציון נוסף. כאשר מתקבל ציון של 55 ומעלה מודפסת ההודעה PASS והתכנית מסתיימת. ריצה לדוגמה (הקלט הוא המספרים): 40 FAIL 52 FAIL 70 PASS ריצה שבה עוברים מיד: 90 PASS הנחיות: • הציון הראשון נקלט לפני הבדיקה הראשונה — או קליטה לפני הלולאה, או לולאה שהקליטה היא הפעולה הראשונה בה. • הקליטה חייבת להתבצע גם בתוך הלולאה. אם הציון נקלט רק פעם אחת והלולאה בודקת את אותו משתנה שוב ושוב, התכנית תדפיס FAIL לנצח. • הציון 55 בדיוק הוא ציון עובר. • PASS מודפס פעם אחת בלבד, בסוף. ```ds:table {"title":"ריצה לדוגמה","rows":[["ציון שנקלט","פלט"],["40","FAIL"],["52","FAIL"],["70","PASS"]]} ```

ממוצע ציונים עד סמן סיום

כתוב תכנית שקולטת ציונים (מספרים שלמים בין 0 ל-100) עד שמוזן הערך מינוס 1. התכנית תחשב ותדפיס את ממוצע הציונים שנקלטו. הערך מינוס 1 הוא סמן סיום בלבד — הוא אינו ציון ואינו נכנס לחישוב. אם לא נקלט אף ציון (הקלט הראשון הוא כבר מינוס 1), התכנית תדפיס NO GRADES. ריצה לדוגמה: 80 90 70 -1 80.0 ריצה בלי ציונים: -1 NO GRADES הנחיות: • צוברים שני דברים במקביל: סכום ומונה. • הסמן נבדק לפני הצבירה, לא אחריה. אם הוא נכנס לסכום, הממוצע יסטה. • מספר הציונים אינו ידוע מראש, ולכן אין צורך במערך — סכום ומונה מספיקים. • חלוקה במונה כשהוא אפס תיתן שגיאה או תוצאה חסרת משמעות. זו הסיבה להודעה NO GRADES, וחייבים לבדוק את המקרה הזה לפני החלוקה. • הממוצע עשרוני. ```ds:table {"title":"ריצה לדוגמה","rows":[["קלט","סכום","מונה"],["80","80","1"],["90","170","2"],["70","240","3"],["-1","עצירה","ממוצע 80.0"]]} ```

כמה הטלות עד שיצא 6

כתוב תכנית שמגרילה תוצאה של הטלת קובייה (בין 1 ל-6 כולל) שוב ושוב, עד שמתקבלת התוצאה 6. התכנית תדפיס את תוצאת כל הטלה, ובסוף תדפיס כמה הטלות בוצעו בסך הכול. ההטלה שהניבה 6 נספרת גם היא. ריצה לדוגמה: 2 4 1 6 4 ריצה שבה 6 יצא מיד: 6 1 הנחיות: • ההגרלה חייבת להתבצע בתוך הלולאה. הגרלה אחת לפני הלולאה תיצור לולאה אינסופית או לולאה שלא מתבצעת כלל. • זו לולאה שמספר המעברים שלה אינו ידוע מראש — התנאי הוא על הערך שהוגרל ולא על מונה. • המונה מתחיל ב-0 וגדל בכל הטלה, כולל האחרונה. • הפלט משתנה בכל הרצה. ```ds:table {"title":"ריצה לדוגמה","rows":[["הטלה","תוצאה"],["1","2"],["2","4"],["3","1"],["4","6"],["סה״כ","4 הטלות"]]} ```

קליטה מסוננת בתחום

כתוב פעולה בשם getNum שמקבלת מספר שלם max, וקולטת מהמשתמש מספר שלם בין 1 ל-max (כולל). אם המספר שהוזן מחוץ לתחום — הפעולה תקלוט שוב ושוב, עד שייקלט מספר תקין. לבסוף היא תחזיר את הקלט התקין. זוהי תבנית מסננת קלט, והיא חוזרת בכל תכנית שמקבלת נתונים ממשתמש. ריצה לדוגמה עבור getNum(50): 120 Invalid, try again -3 Invalid, try again 17 והערך המוחזר הוא 17. הנחיות: • הפעולה מחזירה את הערך ואינה מדפיסה אותו. ההדפסה נעשית ב-main על הערך המוחזר. פעולה שמדפיסה במקום להחזיר אינה שמישה מחדש. • מותר ורצוי להדפיס הודעת שגיאה בין ניסיונות — זה חלק מהממשק, לא התוצאה. • הקליטה הראשונה מתבצעת לפני הבדיקה הראשונה. אין דרך לבדוק ערך שלא נקלט עדיין. • הקליטה חייבת להתבצע שוב בתוך הלולאה, אחרת התכנית תיתקע. • הגבולות 1 ו-max עצמם תקינים. ```ds:table {"title":"ריצה לדוגמה עבור max=50","rows":[["קלט","בתחום?","פעולה"],["120","לא","קולטים שוב"],["-3","לא","קולטים שוב"],["17","כן","מחזירים 17"]]} ```

קליטה עד שהסדרה מפסיקה לעלות

כתוב תכנית שקולטת מספרים עשרוניים. הקליטה נפסקת כאשר נקלט מספר שאינו גדול מהמספר שקדם לו. התכנית תדפיס כמה מספרים תקינים נקלטו. מספר תקין הוא מספר שגדול מקודמו. המספר הראשון תקין תמיד, ואילו המספר שגרם לעצירה אינו נספר. ריצה לדוגמה, עבור הקלט: -2.0 0 4.3 16.8 40.1 1.2 הקליטה נפסקת אחרי 1.2 (שאינו גדול מ-40.1), והפלט הוא: 5 הנחיות: • יש לשמור את הערך הקודם במשתנה נפרד, ולעדכן אותו בכל מעבר. • אל תאתחל את הקודם לאפס — הסדרה עשויה להתחיל במספרים שליליים, ואז המספר הראשון ייחשב בטעות לעצירה. הראשון תקין תמיד, ולכן קולטים אותו בנפרד לפני הלולאה. • התנאי לעצירה הוא לא גדול, כלומר קטן או שווה. שני מספרים שווים עוצרים את הקליטה. • המספר שעצר אינו נספר. ```ds:table {"title":"מעקב על הסדרה","rows":[["נקלט","קודם","גדול מקודם?","מונה"],["-2.0","אין","הראשון","1"],["0","-2.0","כן","2"],["4.3","0","כן","3"],["16.8","4.3","כן","4"],["40.1","16.8","כן","5"],["1.2","40.1","לא — עצירה","5"]]} ```

אחוז המספרים מעל 100

כתוב תכנית שמגרילה 100 מספרים שלמים בין 50 ל-150 (כולל), מדפיסה אותם כולם בשורה אחת מופרדים ברווח, ובסוף מדפיסה בשורה נפרדת כמה מהם, באחוזים, גדולים מ-100. ריצה לדוגמה (מקוצרת): 73 128 50 150 99 ... 112 47.0 הנחיות: • התחום 50 עד 150 כולל את שני הקצוות: 101 ערכים אפשריים, לא 100. זו טעות קלה לעשות דווקא כאן, כי מספר ההגרלות הוא גם 100. • התנאי הוא גדול ממש מ-100. המספר 100 עצמו אינו נספר. • מכיוון שיש בדיוק 100 מספרים, המונה שווה מספרית לאחוז — אבל אין להסתמך על כך. חשב את האחוז כיחס בין המונה לכמות הכוללת כפול 100, כדי שהפתרון יישאר נכון גם אם הכמות תשתנה. • האחוז חייב להיות עשרוני. חלוקה שלמה של המונה בכמות תיתן תמיד 0. • ההדפסה בלולאה היא בלי ירידת שורה, וירידת השורה אחרי הלולאה. ```ds:table {"title":"נקודות שבירה","rows":[["ערך שהוגרל","נספר?"],["150","כן"],["101","כן"],["100","לא"],["50","לא"]]} ```

כמה צעדים עד 1

נתון מספר שלם חיובי n. בכל צעד: • אם n זוגי — מחלקים אותו ב-2. • אם n אי-זוגי — מכפילים ב-3 ומוסיפים 1. כתוב פעולה שמחזירה כמה צעדים דרושים כדי להגיע ל-1. דוגמה עבור 6: 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 שמונה צעדים. הנחיות: • מספר הצעדים אינו ידוע מראש, ולכן זו לולאת while ולא for. • עבור n=1 התשובה היא 0 — כבר הגענו. • אל תדפיס בתוך הפעולה, רק החזר את המספר. ```ds:table {"title":"דוגמאות","rows":[["n","צעדים"],["1","0"],["2","1"],["6","8"],["7","16"],["27","111"]]} ```

המספר הדו-ספרתי הגדול ביותר

נתון מערך של מספרים שלמים חיוביים שמסתיים באיבר 0. האפס הוא סמן סיום בלבד ואינו חלק מהנתונים, וייתכן שיש אחריו איברים נוספים שאין לסרוק. כתוב פעולה שמדפיסה את המספר הדו-ספרתי הגדול ביותר מבין המספרים שנסרקו. מספר דו-ספרתי הוא מספר בין 10 ל-99 כולל. אם לא נמצא מספר דו-ספרתי כלל, הפעולה תדפיס NONE. דוגמאות: 5, 47, 120, 83, 9, 0 → 83 5, 120, 9, 0 → NONE 10, 99, 0 → 99 0 → NONE הנחיות: • הלולאה נעצרת ברגע שנתקלת ב-0. אל תסרוק את שארית המערך. • אל תאתחל את המקסימום לאיבר הראשון — ייתכן שהוא אינו דו-ספרתי כלל, או שהמערך מתחיל ישר ב-0. • השתמש בדגל שמסמן אם נמצא בכלל מספר מתאים, או אתחל את המקסימום לערך שאי אפשר להגיע אליו ובדוק אותו בסוף. ```ds:array {"title":"הדו-ספרתי הגדול כאן הוא 83","items":["5","47","120","83","9","0"]} ``` ```ds:array {"title":"כאן אין אף דו-ספרתי — התשובה NONE","items":["5","120","9","0"]} ```

מחלק משותף מקסימלי

כתוב פעולה שמקבלת שני מספרים שלמים חיוביים ומחזירה את המחלק המשותף המקסימלי שלהם. דוגמאות: 12, 18 → 6 7, 13 → 1 10, 10 → 10 רמז — אלגוריתם אוקלידס: כל עוד b אינו 0, החלף את הזוג (a, b) בזוג (b, a%b). כשb מתאפס, a הוא התשובה.

מספר משוכלל

מספר משוכלל הוא מספר ששווה לסכום מחלקיו (חוץ מעצמו). למשל 6 = 1+2+3, ולכן 6 משוכלל. כתוב **שתי** פעולות: 1. sumOfDivisors(n) — מחזירה את סכום המחלקים של n, לא כולל n עצמו. 2. isPerfect(n) — משתמשת בראשונה ומחזירה true אם n משוכלל. דוגמאות: 6 → true 28 → true 12 → false הנחיות: • הפעולה השנייה חייבת לקרוא לראשונה. זו מטרת התרגיל — פירוק לתת-בעיות. ```ds:table {"title":"איך זה נראה","rows":[["n","המחלקים בלי n","סכומם","משוכלל?"],["6","1 · 2 · 3","6","כן"],["12","1 · 2 · 3 · 4 · 6","16","לא"],["28","1 · 2 · 4 · 7 · 14","28","כן"],["1","אין","0","לא"]]} ```

לולאות ב-C# — חידון סיכום · C#

קליטה עד 0 — תכנן לפני שאתה כותב · C#

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

ממוצע של n מספרים — מתי זה מתפוצץ · C#

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

היפוך מחרוזת

כתוב פעולה שמקבלת מחרוזת ומחזירה אותה בסדר הפוך. דוגמאות: "abc" → "cba" "level" → "level" "" → "" הנחיות: • בנה את התוצאה בלולאה מהתו האחרון לראשון. • בלי StringBuilder.reverse ובלי פונקציות מוכנות להיפוך.

ספירת תנועות

כתוב פעולה שמקבלת מחרוזת באנגלית ומחזירה כמה תנועות (a, e, i, o, u) יש בה. דוגמאות: "hello" → 2 "rhythm" → 0 "AEIOU" → 5 הנחיות: • יש לספור גם אותיות גדולות וגם קטנות. • עבור על המחרוזת בלולאה עם charAt.

ספירת מילים במשפט

כתוב פעולה שמקבלת משפט ומחזירה כמה מילים יש בו. מילה = רצף תווים שאינם רווח. המשפט עשוי להתחיל ברווחים, להסתיים ברווחים, ולהכיל כמה רווחים ברצף. דוגמאות: "hello world" → 2 " a b c " → 3 "" → 0 " " → 0 "one" → 1 הנחיות: • פתור במעבר אחד על התווים, בלי split ובלי פעולות מוכנות לחלוקת מחרוזת. • הרעיון: מילה חדשה מתחילה כשהתו הנוכחי אינו רווח והתו שלפניו כן היה רווח (או שזה התו הראשון). ```ds:table {"title":"דוגמאות","rows":[["מחרוזת","מילים"],["\"hello world\"","2"],["\" a b c \"","3"],["\"\"","0"],["\" \"","0"],["\"one\"","1"]]} ```

המילה הארוכה במשפט

כתוב פעולה שמקבלת משפט שמילותיו מופרדות ברווח בודד, ומחזירה את המילה הארוכה ביותר בו. אם יש כמה באותו אורך — החזר את הראשונה. דוגמאות: "the quick brown fox" → "quick" "a bb ccc" → "ccc" "one two" → "one" הנחיות: • עבור על המחרוזת בלולאה וזהה רווחים בעצמך, בלי split. ```ds:table {"title":"דוגמאות","rows":[["משפט","המילה הארוכה"],["the quick brown fox","quick"],["a bb ccc","ccc"],["one two","one — תיקו נשבר לטובת הראשונה"]]} ```

התו השכיח ביותר

כתוב פעולה שמקבלת מחרוזת של אותיות קטנות ומחזירה את התו שמופיע בה הכי הרבה פעמים. אם יש כמה תווים עם אותה שכיחות מקסימלית — החזר את זה שמופיע ראשון במחרוזת. דוגמאות: "aabbbcc" → b "abcabc" → a (שלושתם מופיעים פעמיים; a הראשון) "z" → z הנחיות: • שתי דרכים אפשריות: לולאה מקוננת שסופרת לכל תו את מופעיו, או מערך מונים בגודל 26. שתיהן מקובלות — נסה לחשוב מה ההבדל ביניהן ביעילות. • המחרוזת אינה ריקה. ```ds:table {"title":"דוגמאות","rows":[["מחרוזת","תו שכיח"],["\"aabbbcc\"","b"],["\"abcabc\"","a"],["\"z\"","z"],["\"xxxx\"","x"]]} ```

האם שתי מחרוזות אנגרמה

שתי מחרוזות הן אנגרמה זו של זו אם הן מורכבות מאותן אותיות בדיוק, כל אחת באותה כמות, בסדר אחר. כתוב פעולה שמקבלת שתי מחרוזות של אותיות קטנות ומחזירה true אם הן אנגרמה. דוגמאות: "listen", "silent" → true "aab", "abb" → false "abc", "abcd" → false "", "" → true הנחיות: • אורך שונה — אפשר לפסול מיד. • הדרך המקובלת: מערך מונים בגודל 26. סופרים את אותיות המחרוזת הראשונה, מחסירים את אותיות השנייה, ובודקים שכל המונים אפס. • שים לב שכמות חשובה: "aab" ו-"abb" מכילות את אותן אותיות אבל אינן אנגרמה. ```ds:table {"title":"דוגמאות","rows":[["א","ב","אנגרמה?"],["listen","silent","כן"],["aab","abb","לא"],["abc","abcd","לא"],["(ריקה)","(ריקה)","כן"]]} ```

ספירת האותיות a במחרוזת — שלב חסר · C#

האלגוריתם סורק מחרוזת וסופר כמה פעמים מופיעה האות a. שלב אחד הוצא — השלם אותו.

מחרוזות ומערכים ב-C# — חידון סיכום

מחרוזת פלינדרום

כתוב פעולה שמקבלת מחרוזת ומחזירה true אם היא פלינדרום — כלומר נקראת אותו דבר מימין לשמאל ומשמאל לימין. דוגמאות: "abba" → true "abcba" → true "abc" → false "a" → true "" → true הנחיות: • השווה תווים משני קצות המחרוזת פנימה. • אין צורך להתעלם מרווחים או מאותיות גדולות/קטנות. ```ds:table {"title":"דוגמאות","rows":[["מחרוזת","פלינדרום?"],["abba","כן"],["abcba","כן"],["abc","לא"]]} ```

ברכה בשם

כתוב פעולה שמקבלת שם של אדם (מחרוזת) ומדפיסה ברכה. דוגמאות: Almog → Hello Almog! Dana → Hello Dana! הנחיות: • יש לשרשר את ערך הפרמטר לתוך מחרוזת קבועה — לא להדפיס את שם הפרמטר כטקסט. • הפורמט מדויק: המילה Hello, רווח אחד, השם, וסימן קריאה צמוד לשם בלי רווח לפניו. • הפעולה מדפיסה ואינה מחזירה ערך. ```ds:table {"title":"דוגמאות","rows":[["שם","פלט"],["Almog","Hello Almog!"],["Dana","Hello Dana!"]]} ```

הפרש בערך מוחלט

כתוב פעולה שמקבלת שני מספרים שלמים ומדפיסה את ההפרש ביניהם בערך מוחלט. דוגמאות: 3 ו-10 → 7 10 ו-3 → 7 -5 ו-5 → 10 4 ו-4 → 0 הנחיות: • השתמש בפעולת הערך המוחלט של הספרייה המתמטית — בלי תנאי ובלי בדיקה מי משני המספרים גדול. • סדר המספרים אינו משנה את התוצאה, וזו בדיוק הנקודה. • התוצאה לעולם אינה שלילית. אם קיבלת מספר שלילי, הערך המוחלט לא הופעל. ```ds:table {"title":"דוגמאות","rows":[["א","ב","הפרש"],["3","10","7"],["10","3","7"],["-5","5","10"],["4","4","0"]]} ```

ערך פולינום

נתונה הפונקציה: y = x בשלישית, ועוד 6 כפול x, פחות 10 כתוב פעולה שמקבלת מספר עשרוני x ומדפיסה את ערך y המתאים לו. דוגמאות: x = 2 → 10.0 (8 ועוד 12 פחות 10) x = 0 → -10.0 x = 1 → -3.0 x = -1 → -17.0 הנחיות: • את החזקה אפשר לחשב בפעולת החזקה של הספרייה המתמטית או כמכפלה של x בעצמו שלוש פעמים. שתי הדרכים תקינות. • שים לב לסדר הפעולות: החזקה והכפל מתבצעים לפני החיבור והחיסור, אבל כדאי לכתוב את הביטוי בצורה קריאה. • התוצאה עשרונית גם כאשר היא מספר שלם. ```ds:table {"title":"דוגמאות","rows":[["x","y"],["2","10.0"],["0","-10.0"],["1","-3.0"],["-1","-17.0"]]} ```

מתודה אחת ארוכה או ארבע קצרות? · C#

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

הדפסת מערך מהסוף להתחלה

כתוב **שתי** פעולות רקורסיביות שמקבלות מערך ואינדקס התחלה: 1. פעולה שמדפיסה את המערך מההתחלה לסוף. 2. פעולה שמדפיסה אותו מהסוף להתחלה. כל איבר בשורה נפרדת. אסור להשתמש בלולאה בכלל. הנחיות: • שתי הפעולות כמעט זהות. ההבדל היחיד: האם ההדפסה מתבצעת **לפני** הקריאה הרקורסיבית או **אחריה**. • זו הנקודה של התרגיל, ולכן כדאי לכתוב את הראשונה, להריץ, ואז לשנות רק את סדר שתי השורות ולראות מה קורה. • מקרה הבסיס: האינדקס הגיע לאורך המערך — אין מה להדפיס. ```ds:array {"title":"הקלט — הפלט ההפוך יהיה 9, 7, 5, 3","items":["3","5","7","9"]} ```

חזקה ברקורסיה

כתוב פעולה **רקורסיבית** שמקבלת בסיס base ומעריך exp (שלם ואי-שלילי) ומחזירה את base בחזקת exp. דוגמאות: 2, 5 → 32 7, 1 → 7 5, 0 → 1 0, 3 → 0 הנחיות: • מקרה הבסיס: כל מספר בחזקת 0 שווה 1. • צעד הרקורסיה: base בחזקת exp = base כפול (base בחזקת exp-1). • שים לב שרק exp קטן בכל קריאה — base נשאר כפי שהוא. זה ההבדל מהעצרת, שבה הפרמטר היחיד הוא זה שקטן. • אסור להשתמש בלולאה וב-Math.pow. ```ds:table {"title":"פריסת הקריאות עבור 2 בחזקת 3","rows":[["קריאה","מחזירה"],["power(2,3)","2 * power(2,2) = 8"],["power(2,2)","2 * power(2,1) = 4"],["power(2,1)","2 * power(2,0) = 2"],["power(2,0)","1"]]} ```

ספירת ראשוניים בתחום

כתוב שתי פעולות: 1. פעולה שמקבלת מספר שלם ומחזירה true אם הוא ראשוני. 2. פעולה שמקבלת שני מספרים a ו-b ומחזירה כמה מספרים ראשוניים יש בתחום שביניהם (כולל שניהם), תוך שימוש בפעולה הראשונה. דוגמאות: countPrimes(1, 10) → 4 (2, 3, 5, 7) countPrimes(10, 20) → 4 (11, 13, 17, 19) countPrimes(0, 1) → 0 הנחיות: • 0 ו-1 אינם ראשוניים. • הפעולה השנייה חייבת להשתמש בראשונה — זה עיקר התרגיל.

עצרת ברקורסיה

כתוב פעולה **רקורסיבית** שמקבלת מספר שלם n ומחזירה את n! (עצרת). n! = n × (n-1) × (n-2) × ... × 1 0! = 1 דוגמאות: 5 → 120 1 → 1 0 → 1 הנחיות: • בלי לולאות בכלל. הפעולה חייבת לקרוא לעצמה. • התחל מהשאלה: מהו מקרה הבסיס שבו הרקורסיה נעצרת? ```ds:table {"title":"מה הפעולה מחזירה","rows":[["n","התוצאה"],["0","1 — מקרה הבסיס"],["1","1"],["3","6"],["5","120"]]} ```

מדריך רקורסיה ב-C#

המינימום ומקומו

כתוב פעולה שמקבלת מערך של מספרים שלמים ומדפיסה שתי שורות: הערך הקטן ביותר במערך, ואחריו האינדקס שבו הוא נמצא. אם הערך הקטן מופיע כמה פעמים — החזר את האינדקס הראשון שלו. דוגמה עבור [4, 1, 7, 1, 9]: 1 1 הנחיות: • אתחל את המינימום לאיבר הראשון במערך, לא לאפס ולא למספר קבוע. אתחול ל-0 שובר את כל המקרים שבהם כל האיברים חיוביים. • שמור את האינדקס יחד עם הערך — שני משתנים שמתעדכנים ביחד. • המערך אינו ריק. ```ds:array {"title":"המינימום 1, והאינדקס הראשון שלו הוא 1","items":["4","1","7","1","9"]} ```

האם המערך ממוין

כתוב פעולה שמקבלת מערך ומחזירה true אם הוא ממוין בסדר עולה (כל איבר גדול או שווה לקודמו). דוגמאות: [1, 3, 3, 7] → true [1, 5, 2] → false [4] → true הנחיות: • מספיק מעבר אחד על המערך. • ברגע שנמצאה הפרה אפשר להפסיק. ```ds:array {"title":"ממוין → true (שים לב ש-3 חוזר, וזה עדיין ממוין)","items":["1","3","3","7"]} ``` ```ds:array {"title":"לא ממוין → false (ההפרה בין 5 ל-2)","items":["1","5","2"]} ```

היפוך מערך במקום

כתוב פעולה שמקבלת מערך והופכת את סדר איבריו — בתוך אותו מערך, בלי ליצור מערך חדש. דוגמה: [1, 2, 3, 4] → [4, 3, 2, 1] [1, 2, 3] → [3, 2, 1] הנחיות: • השתמש בשני אינדקסים שמתקדמים זה לקראת זה. • הפעולה אינה מחזירה ערך — היא משנה את המערך שהתקבל. ```ds:array {"title":"לפני","items":["1","2","3","4"]} ``` ```ds:array {"title":"אחרי — אותו מערך, לא חדש","items":["4","3","2","1"]} ```

מערך מונים

נתון מערך של מספרים שלמים בטווח 0 עד 9. כתוב פעולה שמדפיסה עבור כל ערך שמופיע במערך שורה בפורמט: ערך:כמות השורות בסדר עולה של הערך. ערך שאינו מופיע כלל — אינו מודפס. דוגמה עבור [3, 1, 3, 7, 1, 3]: 1:2 3:3 7:1 הנחיות: • בנה מערך מונים בגודל 10. האינדקס הוא הערך, והתוכן הוא הכמות. זה הרעיון המרכזי כאן: להשתמש בערך כאינדקס. • מעבר אחד לספירה, מעבר אחד להדפסה. אין צורך בלולאה מקוננת. • ההדפסה בסדר עולה מתקבלת מעצמה כשעוברים על מערך המונים מ-0 ל-9. ```ds:array {"title":"הקלט","items":["3","1","3","7","1","3"]} ``` ```ds:table {"title":"מערך המונים שנבנה","rows":[["אינדקס","0","1","2","3","4","5","6","7","8","9"],["מונה","0","2","0","3","0","0","0","1","0","0"]]} ```

הרצף העולה הארוך ביותר

כתוב פעולה שמקבלת מערך של מספרים שלמים ומחזירה את אורך הרצף העולה ממש הארוך ביותר בתוכו. רצף עולה ממש = איברים סמוכים שכל אחד גדול מקודמו. דוגמאות: [1, 2, 5, 3, 4, 9, 2] → 3 (הרצף 3,4,9) [5, 4, 3] → 1 [1, 2, 3, 4] → 4 [7] → 1 הנחיות: • החזק שני מונים: אורך הרצף הנוכחי, ואורך הרצף הטוב ביותר עד כה. • כשהעלייה נשברת — הרצף הנוכחי מתאפס ל-1, לא ל-0. האיבר שבו נשברה העלייה הוא כבר תחילתו של הרצף הבא. • עדכן את המקסימום גם בסוף הלולאה, לא רק ברגע השבירה. • המערך אינו ריק. ```ds:array {"title":"הרצף הארוך הוא 3,4,9 — אורך 3","items":["1","2","5","3","4","9","2"]} ```

כמה מעל הממוצע

כתוב פעולה שמקבלת מערך של מספרים שלמים ומחזירה כמה מאיבריו גדולים מהממוצע של המערך. דוגמאות: [1, 2, 3, 4] → 2 (הממוצע 2.5, גדולים ממנו: 3 ו-4) [5, 5, 5] → 0 [10, 0, 0, 0] → 1 הנחיות: • נדרשים שני מעברים על המערך: אחד לסכום, אחד לספירה. • שים לב לחלוקה — הממוצע אינו בהכרח מספר שלם. ```ds:array {"title":"הממוצע כאן 2.5 — שני איברים גדולים ממנו","items":["1","2","3","4"]} ```

החיובי הקטן החסר

כתוב פעולה שמקבלת מערך של מספרים שלמים, לא ממוין, ומחזירה את המספר החיובי הקטן ביותר שאינו נמצא בו. המספרים במערך יכולים להיות שליליים, אפס או כפולים. התשובה תמיד מספר חיובי, כלומר 1 ומעלה. דוגמאות: [3, 4, -1, 1] → 2 [1, 2, 3] → 4 [-5, -2, 0] → 1 [] → 1 [1, 1, 2] → 3 הנחיות: • דרך פשוטה: לבדוק ברצף האם 1 נמצא, האם 2 נמצא, וכן הלאה, עד שנמצא מספר שאינו במערך. לכל בדיקה — מעבר על המערך. • התשובה לעולם לא תעלה על אורך המערך ועוד אחד. נסה להבין למה — זה מה שמבטיח שהלולאה עוצרת. • פתרון יעיל יותר קיים, אבל אינו נדרש כאן. ```ds:array {"title":"1 נמצא, 2 אינו נמצא — התשובה 2","items":["3","4","-1","1"]} ```

חיפוש סדרתי

כתוב פעולה שמקבלת מערך של מספרים שלמים וערך לחיפוש, ומחזירה את האינדקס של המופע הראשון של הערך. אם הערך אינו במערך — החזר 1-. דוגמאות עבור [8, 3, 9, 3]: חיפוש 9 → 2 חיפוש 3 → 1 (המופע הראשון) חיפוש 5 → -1 הנחיות: • המערך אינו ממוין, ולכן אין ברירה אלא לעבור עליו. • צא מהפעולה ברגע שנמצא — אין טעם להמשיך. • 1- הוא ערך מוסכם ל"לא נמצא", כי הוא לעולם אינו אינדקס חוקי. אחרי שתפתור, שים לב: כמה השוואות בממוצע דורש החיפוש הזה על מערך בגודל n? השווה למספר ההשוואות בחיפוש הבינארי. ```ds:array {"title":"המופע הראשון של 3 הוא באינדקס 1","items":["8","3","9","3"]} ```

האיבר השני בגודלו

כתוב פעולה שמקבלת מערך של מספרים שלמים ומחזירה את הערך השני בגודלו. דוגמאות: {3, 9, 4, 9, 1} → 4 (הגדול הוא 9, השני בגודלו הוא 4) {5, 5, 5} → 5 {7, 2} → 2 הנחיות: • עבור על המערך פעם אחת בלבד — בלי מיון. • במערך יש לפחות שני איברים. • שים לב לערכים כפולים: {9, 9, 4} מחזיר 4, לא 9. ```ds:array {"title":"הגדול הוא 9, והשני בגודלו הוא 4","items":["3","9","4","9","1"]} ``` ```ds:array {"title":"ערכים כפולים — כאן התשובה 4, לא 9","items":["9","9","4"]} ```

חיפוש בינארי

כתוב פעולה שמקבלת מערך **ממוין** וערך לחיפוש, ומחזירה את האינדקס שבו הערך נמצא, או -1 אם אינו במערך. הרעיון: השווה לאיבר האמצעי. אם הוא גדול מדי — המשך לחפש בחצי השמאלי, אם קטן מדי — בחצי הימני. כך בכל צעד נחתך חצי מהמערך. דוגמאות עבור [1, 3, 5, 7, 9]: 5 → 2 1 → 0 4 → -1 הנחיות: • אסור לעבור על המערך בלולאה רגילה מההתחלה לסוף. ```ds:array {"title":"המערך הממוין — האינדקס שמתחת לכל תא הוא מה שמוחזר","items":["1","3","5","7","9"]} ```

מיון בועות

כתוב פעולה שממיינת מערך בסדר עולה בשיטת מיון בועות (Bubble Sort), בתוך אותו מערך. הרעיון: עוברים על המערך שוב ושוב, ובכל מעבר מחליפים כל זוג שכנים שאינם בסדר הנכון. אחרי כל מעבר, האיבר הגדול ביותר שנותר "צף" לסוף. דוגמה: [5, 1, 4, 2] → [1, 2, 4, 5] הנחיות: • בלי פונקציות מיון מוכנות. • הפעולה אינה מחזירה ערך — היא משנה את המערך. ```ds:array {"title":"לפני","items":["5","1","4","2"]} ``` ```ds:array {"title":"אחרי","items":["1","2","4","5"]} ```

מיזוג שני מערכים ממוינים

נתונים שני מערכים ממוינים בסדר עולה. כתוב פעולה שמחזירה מערך חדש שמכיל את כל האיברים של שניהם, ממוין בסדר עולה. דוגמה: [1, 4, 9] ו-[2, 3, 10] → [1, 2, 3, 4, 9, 10] הנחיות: • אסור לשרשר את שני המערכים ולמיין. הפתרון חייב לנצל את העובדה ששניהם כבר ממוינים, ולעבור על כל אחד מהם פעם אחת בלבד. • החזק שני מדדים, אחד לכל מערך. בכל צעד קח את הקטן מבין שני האיברים הנוכחיים וקדם רק את המדד שממנו לקחת. • כשאחד המערכים נגמר — העתק את שארית השני. אל תשכח את השלב הזה. • מערך יכול להיות ריק. ```ds:array {"title":"מערך א","items":["1","4","9"]} ``` ```ds:array {"title":"מערך ב","items":["2","3","10"]} ``` ```ds:array {"title":"התוצאה","items":["1","2","3","4","9","10"]} ```

סכום איברי מטריצה

כתוב פעולה שמקבלת מערך דו-ממדי של מספרים שלמים ומחזירה את סכום כל איבריו. דוגמה: [[1, 2], [3, 4]] → 10 הנחיות: • השתמש בלולאה מקוננת. • אל תניח שהמטריצה ריבועית — קרא את מספר השורות ואת מספר העמודות מהמערך עצמו. ```ds:table {"title":"המטריצה שבדוגמה — הסכום 10","rows":[["","עמודה 0","עמודה 1"],["שורה 0","1","2"],["שורה 1","3","4"]]} ```

המקסימום בכל שורה

כתוב פעולה שמקבלת מערך דו-ממדי ומדפיסה את האיבר הגדול ביותר בכל שורה, שורה אחת בכל פלט, לפי סדר השורות. דוגמה: [[3, 9, 1], [8, 2, 5]] פלט: 9 8 הנחיות: • אתחל את המקסימום לאיבר הראשון בשורה, לא לאפס — יש שורות שכל איבריהן שליליים. ```ds:table {"title":"המקסימום בכל שורה: 9 ואז 8","rows":[["","עמודה 0","עמודה 1","עמודה 2"],["שורה 0","3","9","1"],["שורה 1","8","2","5"]]} ``` ```ds:table {"title":"המקרה שמפיל אתחול לאפס — כל השורה שלילית","rows":[["","עמודה 0","עמודה 1","עמודה 2"],["שורה 0","-4","-9","-1"]]} ```

סכום האלכסון הראשי

האלכסון הראשי של מטריצה ריבועית הוא כל האיברים שבהם מספר השורה שווה למספר העמודה. כתוב פעולה שמקבלת מטריצה ריבועית ומחזירה את סכום האלכסון הראשי. דוגמה: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] → 15 (1+5+9) הנחיות: • מספיקה לולאה אחת, לא מקוננת. זו הנקודה של התרגיל. ```ds:table {"title":"האלכסון הראשי הוא 1 · 5 · 9 — הסכום 15","rows":[["","עמודה 0","עמודה 1","עמודה 2"],["שורה 0","1","2","3"],["שורה 1","4","5","6"],["שורה 2","7","8","9"]]} ```

חיפוש ערך במטריצה

כתוב פעולה שמקבלת מטריצה של מספרים שלמים וערך לחיפוש, ומדפיסה את המיקום של המופע הראשון של הערך בפורמט: שורה,עמודה הסריקה היא שורה אחר שורה, ובכל שורה משמאל לימין. אם הערך אינו נמצא — הדפס: not found דוגמה עבור המטריצה 1 5 3 9 5 2 וחיפוש 5: 0,1 הנחיות: • ברגע שהערך נמצא — הפסק לחפש. אין טעם להמשיך לסרוק. • שים לב לא להדפיס פעמיים כשהערך מופיע יותר מפעם אחת. • מספר העמודות זהה בכל השורות. ```ds:table {"title":"המטריצה — 5 הראשון נמצא בשורה 0 עמודה 1","rows":[["1","5","3"],["9","5","2"]]} ```

שחלוף מטריצה

שחלוף (Transpose) של מטריצה ריבועית = החלפת כל תא [i][j] עם התא [j][i]. כתוב פעולה שמקבלת מטריצה ריבועית ומשחלפת אותה **בתוך אותה מטריצה**, בלי לבנות מטריצה חדשה. אחר כך הדפס אותה שורה-שורה, המספרים מופרדים ברווח. דוגמה: לפני: אחרי: 1 2 3 1 4 7 4 5 6 2 5 8 7 8 9 3 6 9 הנחיות: • הלולאה הפנימית מתחילה ב-j = i + 1, לא ב-0. חשוב על מה קורה אם היא מתחילה ב-0 — כל זוג מוחלף פעמיים, והמטריצה חוזרת למצבה המקורי. • האלכסון הראשי אינו זז. • ההחלפה מצריכה משתנה עזר, בדיוק כמו החלפת שני משתנים רגילים. ```ds:table {"title":"לפני","rows":[["1","2","3"],["4","5","6"],["7","8","9"]]} ``` ```ds:table {"title":"אחרי","rows":[["1","4","7"],["2","5","8"],["3","6","9"]]} ```

סכום מטריצה — מה מיותר כאן · C#

האלגוריתם מחשב את סכום כל איברי המטריצה. חלק מהשלבים מיותרים ולא תורמים דבר. סמן אותם.

מספר שמח

מספר נקרא **שמח** אם כאשר מחליפים אותו שוב ושוב בסכום ריבועי ספרותיו, מגיעים בסופו של דבר ל-1. דוגמה עבור 19: 19 → 1² + 9² = 82 82 → 8² + 2² = 68 68 → 6² + 8² = 100 100 → 1² + 0² + 0² = 1 ✓ שמח מספר שאינו שמח נכנס למחזור אינסופי שעובר תמיד דרך 4. כתוב **שתי** פעולות: 1. פעולה שמקבלת מספר ומחזירה את סכום ריבועי ספרותיו. 2. פעולה שמקבלת מספר ומחזירה true אם הוא שמח, בעזרת הפעולה הראשונה. הנחיות: • תנאי עצירה: הגענו ל-1 (שמח) או הגענו ל-4 (לא שמח). • זו הנקודה של התרגיל — הפירוק לשתי פעולות. פתרון בפעולה אחת ארוכה אינו עונה על המשימה. ```ds:table {"title":"המסלול של 19","rows":[["שלב","מספר","סכום ריבועי הספרות"],["1","19","82"],["2","82","68"],["3","68","100"],["4","100","1"]]} ```

ראשוני גם הפוך

מספר נקרא **ראשוני-הפיך** אם גם הוא וגם המספר שמתקבל מהיפוך ספרותיו הם ראשוניים, והם שונים זה מזה. דוגמאות: 13 → 31, שניהם ראשוניים ושונים → true 17 → 71, שניהם ראשוניים → true 11 → 11, ראשוני אבל זהה להיפוך → false 23 → 32 אינו ראשוני → false 15 → אינו ראשוני → false כתוב **שלוש** פעולות: 1. פעולה שבודקת אם מספר ראשוני. 2. פעולה שמחזירה את המספר ההפוך. 3. פעולה שמשתמשת בשתיהן ומחזירה את התשובה. הנחיות: • 1 אינו ראשוני. 2 כן. • לבדיקת ראשוניות מספיק לבדוק מחלקים עד השורש של המספר. • זו הנקודה של התרגיל: כל אחת משלוש הפעולות כבר תורגלה בנפרד, והמשימה כאן היא להרכיב אותן. ```ds:table {"title":"דוגמאות","rows":[["מספר","הפוך","תשובה"],["13","31","true"],["17","71","true"],["11","11","false"],["23","32","false"],["15","51","false"]]} ```

ראיון עבודה — ג'וניור בהייטק

להסביר באנגלית פשוטה מה ההבדל בין for ל-while, ולתאר באג שפתרת ואיך מצאת אותו.