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

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

שפת התכנות java

הדפסת 'שלום עולם' ב-Java

משימתך היא לכתוב את תוכנית ה'שלום עולם' הקלאסית ב-Java. סדר את שורות הקוד כך שיודפס המסר 'Hello, World!' למסך.

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

יש לפעול בהתאם לקובץ ה google docs

שאלות בסיסיות על java

משתנים בשפת Java

קלט פלט ב-Java: המדריך השלם

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

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

אופרטורים מתמטיים java

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

קלטו 2 מספרים והדפיסו את סכומם

הכרת משתנים ב-Java

יסודת מדעי המחשב java משתנים

פעולות מתמטיות על int

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

קליטת 3 מספרים וחישוב הממוצע שלהם

כתבו קוד הקולט מהמשתמש 3 מספרים, מחשב ומדפיס את הממוצע שלהם.

עיגול לאלפים

כתוב תכנית שמגרילה מספר שלם בין 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"]]} ```

חילוק של שני מספרים שלמים

בצע חילוק של שני מספרים

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

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

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

כתוב פעולה שמקבלת מספר שלם חיובי. אם המספר דו-ספרתי, הפעולה תבדוק אם ספרת האחדות שווה לספרת העשרות ותדפיס 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"]]} ```

חזקה בלולאה

כתוב פעולה שמקבלת שני מספרים שלמים, בסיס ומעריך, ומחזירה את הבסיס בחזקת המעריך. המעריך אינו שלילי. דוגמאות: 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"]]} ```

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

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

מציאת המספר המקסימלי מבין שניים

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

תנאים ב-Java — חידון סיכום

איזה סוג של תו

כתוב פעולה שמקבלת תו ומדפיסה מה הוא: 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"]]} ```

כביש אגרה

כביש אגרה מחולק לקטעים. מחיר הנסיעה בכל קטע הוא 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"]]} ```

מתחלק ב-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"]]} ```

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

כדי להתקבל לקורס טייס אזרחי, על המועמד לעמוד באחת משתי הדרישות: • מעל 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"]]} ```

קנס מהירות

כתוב פעולה שמקבלת את מהירות הנסיעה ואת מספר נקודות החובה שצבר הנהג. אם המהירות גבוהה מ-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"]]} ```

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

כתוב פעולה שמקבלת שלושה מספרים שלמים ומדפיסה: 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"]]} ```

שנה מעוברת

כתוב פעולה שמקבלת שנה ומחזירה 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"]]} ```

מרתון הלולאות

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

הקוד אמור להדפיס את המספרים 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"]]} ```

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

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

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

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

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

כתוב פעולה שמקבלת שני מספרים שלמים ומדפיסה את סכום כל המספרים השלמים שביניהם, כולל שני הקצוות. לא ידוע מי משני המספרים גדול. דוגמאות: 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"]]} ```

ספירת ספרות שמתחלקות ב-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"]]} ```

עצרת בלולאה

כתוב פעולה שמקבלת מספר שלם אי-שלילי ומחזירה את העצרת שלו. עצרת של מספר היא מכפלת כל המספרים מ-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"]]} ```

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

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

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

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

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

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

לולאות ב-Java — חידון סיכום

אחוז המספרים מעל 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","לא"]]} ```

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

נתון מערך של מספרים שלמים חיוביים שמסתיים באיבר 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"]} ```

כמה הטלות עד שיצא 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 הטלות"]]} ```

כמה צעדים עד 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"]]} ```

מספר משוכלל

מספר משוכלל הוא מספר ששווה לסכום מחלקיו (חוץ מעצמו). למשל 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","לא"]]} ```

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

כתוב פעולה בשם 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"]]} ```

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

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

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

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

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

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

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

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

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

מדריך רקורסיה ב-Java

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

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

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

כתוב שתי פעולות: 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 אינם ראשוניים. • הפעולה השנייה חייבת להשתמש בראשונה — זה עיקר התרגיל.

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

כתוב פעולה שמקבלת מערך של מספרים שלמים ומחזירה את הערך השני בגודלו. דוגמאות: {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"]} ```

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

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

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

כתוב פעולה שמקבלת מערך של מספרים שלמים, לא ממוין, ומחזירה את המספר החיובי הקטן ביותר שאינו נמצא בו. המספרים במערך יכולים להיות שליליים, אפס או כפולים. התשובה תמיד מספר חיובי, כלומר 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, 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"]]} ```

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

כתוב פעולה שמקבלת מטריצה של מספרים שלמים וערך לחיפוש, ומדפיסה את המיקום של המופע הראשון של הערך בפורמט: שורה,עמודה הסריקה היא שורה אחר שורה, ובכל שורה משמאל לימין. אם הערך אינו נמצא — הדפס: 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"]]} ```