Sahar Atias

Learn Java

In this page you will find plenty of Java questions and answers for first year students.
I hope you will find it useful, I put some effort into it :)
Feel free to contact me if you find any mistakes or encounter a problem.
The page is in hebrew for your convenience.

שאלה 1

כתוב תכנית המקבלת מספר בין 1-10 מהמשתמש (התכנית תדפיס הודעת שגיאה אם המספר לא בטווח).
אם המספר שהוזן בין 1-5 (כולל) התכנית תדפיס משולש של @
אם המספר בין 6-10 (כולל) התכנית תדפיס משולש של #
כאשר בשורה הראשונה יהיה תו אחד, בשורה השנייה שני תווים וכך הלאה.

הצג דוגמת הרצה
לדוגמה עבור הקלט 5, יודפס המשולש הבא:
@
@@
@@@
@@@@
@@@@@
עבור הקלט 7 יודפס המשולש הבא:
#
##
###
####
#####
######
#######
הצג פתרון
import java.util.Scanner;

public class Targil1
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      System.out.print("Enter a number between 1 to 10: ");
      int n = sc.nextInt();
      if (n >= 1 && n <= 10)
      {
         if (n < 6)
         {
            for (int i = 1;i <= n;i++)
            {
               for (int j = 0;j < i;j++)
                  System.out.print("@");
               System.out.println();
            }
         }
         else
         {
            for (int i = 1;i <= n;i++)
            {
               for (int j = 0;j < i;j++)
                  System.out.print("#");
               System.out.println();
            }
         }
      }
      else
         System.out.println("Error, only 1-10.");
      sc.close();
   }
}

שאלה 2

כתוב תכנית המוצאת את כל המספרים בין 100-500 המקיימים את התנאי הבא:
אם לוקחים כל ספרה במספר ומעלים אותה בחזקת 3 וסוכמים את התוצאות, מקבלים בחזרה את המספר המקורי.
הצג דוגמת הרצה
לדוגמה עבור המספר 153 מתקיים ש:
1^3 + 5^3 + 3^3 = 153
רמז: יש 4 מספרים כאלה בטווח הנתון.
הצג פתרון
public class Targil2
{
   public static void main(String[] args)
   {
      for (int i = 100;i <= 500;i++)
      {
         int ahadot = i % 10;
         int asarot = i / 10 % 10;
         int meot = i / 100 % 10;
         int pow = (int) (Math.pow(ahadot, 3) + Math.pow(asarot, 3) + Math.pow(meot, 3));
         if (pow == i)
            System.out.println("Found special number: " + i);
      }
   }
}

שאלה 3

כתוב תכנית המקבלת כקלט מספר גדול מ-0, לאחר מכן התכנית תציג את התפריט הבא:
1. התכנית תדפיס אם המספר שהוזן מתחלק ב-3 ללא שארית.
2. התכנית תדפיס את סכום הריבועים של הספרות של המספר שהוזן.
3. התכנית תדפיס אם המספר שהוזן הוא ראשוני או לא.
המשתמש יזין מספר נוסף לפיו התכנית תבצע פעולה מהתפריט על המספר הראשון שהוזן.
הנחיות: יש לבקש קלט עד שהוזן קלט תקין בשני המקרים, יש להשתמש ב- switch.
הצג דוגמת הרצה
Enter a number bigger than 0: -3
Enter a number bigger than 0: 3
Enter 1 to check if the number divides by 3.
Enter 2 to calculate sum of powed numbers.
Enter 3 to check if the number is prime.
3
The number 3 is prime.
הצג פתרון
import java.util.Scanner;

public class Targil3
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      int num;
      do
      {
         System.out.print("Enter a number bigger than 0: ");
         num = sc.nextInt();
      } while (num < 1);
      int choice;
      do
      {
         System.out.println("Enter 1 to check if the number divides by 3.");
         System.out.println("Enter 2 to calculate sum of powed numbers.");
         System.out.println("Enter 3 to check if the number is prime.");
         choice = sc.nextInt();
      } while (choice != 1 && choice != 2 && choice != 3);
      switch (choice)
      {
         case 1:
            if (num % 3 == 0)
               System.out.println("The number " + num + " is dividable by 3.");
            else
               System.out.println("The number " + num + " is not dividable by 3.");
            break;
         case 2:
            int copy = num;
            int sum = 0;
            while (copy > 0)
            {
               sum += Math.pow(copy % 10, 2);
               copy /= 10;
            }
            System.out.println("Sum of powed numbers of " + num + " is " + sum + ".");
            break;
         case 3:
            boolean isPrime = num > 1;
            for (int i = 2;i < num / 2 + 1 && isPrime;i++)
               if (num % i == 0)
                  isPrime = false;
            if (isPrime)
               System.out.println("The number " + num + " is prime.");
            else
               System.out.println("The number " + num + " is not prime.");
            break;
      }
      sc.close();
   }
}

שאלה 4

כתוב תכנית הקולטת שמות של 2 שחקנים, התכנית תרוץ במשך 10 סיבובים כאשר בכל סיבוב התכנית תגריל מספר אקראי בין 1-6 המייצג זריקת קובייה עבור כל שחקן.
בכל סיבוב יש להדפיס את מספר הסבב, את שמות השחקנים ואת המספר שהוגרל עבור כל אחד.
בכל סיבוב השחקן עם המספר הגדול יותר יקבל 2 נקודות, אם יש תיקו כל שחקן יקבל נקודה אחת.
בסוף ההרצה התכנית תדפיס את שם המנצח עם מספר הנקודות שצבר, או תיקו במידה ולשני השחקנים יש אותה כמות נקודות.
הצג דוגמת הרצה
Enter player 1 name: Moshe
Enter player 2 name: Danny
Round 1:
Moshe - 5, Danny - 1
Round 2:
Moshe - 1, Danny - 3
Round 3:
Moshe - 1, Danny - 6
Round 4:
Moshe - 2, Danny - 1
Round 5:
Moshe - 2, Danny - 3
Round 6:
Moshe - 4, Danny - 1
Round 7:
Moshe - 2, Danny - 1
Round 8:
Moshe - 1, Danny - 4
Round 9:
Moshe - 5, Danny - 1
Round 10:
Moshe - 2, Danny - 5
Tie, both players had the same amount of points.
הצג פתרון
import java.util.Random;
import java.util.Scanner;

public class Targil4
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      System.out.print("Enter player 1 name: ");
      String player1Name = sc.next();
      System.out.print("Enter player 2 name: ");
      String player2Name = sc.next();
      
      Random rnd = new Random();
      int player1Points = 0;
      int player2Points = 0;
      for (int i = 1;i <= 10;i++)
      {
         int player1Cube = rnd.nextInt(6) + 1;
         int player2Cube = rnd.nextInt(6) + 1;
         if (player1Cube > player2Cube)
            player1Points += 2;
         else if (player2Cube > player1Cube)
            player2Points += 2;
         else
         {
            player1Points++;
            player2Points++;
         }
         
         System.out.println("Round " + i + ":");
         System.out.println(player1Name + " - " + player1Cube + ", " + player2Name + " - " + player2Cube);
      }
      if (player1Points > player2Points)
         System.out.println(player1Name + " is the winner with " + player1Points + " points!");
      else if (player2Points > player1Points)
         System.out.println(player2Name + " is the winner with " + player2Points + " points!");
      else
         System.out.println("Tie, both players had the same amount of points.");
      sc.close();
   }
}

שאלה 5

כתוב תכנית המדפיסה לוח שחמט כך שכל ריבוע שחור יסומן ב- @ וכל ריבוע לבן יסומן ב- #
רמז: לוח שחמט הוא ריבוע 8*8 כך שאין שני ריבועים צמודים בעלי אותו צבע.
הצג דוגמת הרצה
#@#@#@#@
@#@#@#@#
#@#@#@#@
@#@#@#@#
#@#@#@#@
@#@#@#@#
#@#@#@#@
@#@#@#@#
הצג פתרון
public class Targil5
{
   public static void main(String[] args)
   {
      for (int i = 0;i < 8;i++)
      {
         for (int j = 0;j < 8;j++)
         {
            if (i % 2 == 0)
            {
               if (j % 2 == 0)
                  System.out.print("#");
               else
                  System.out.print("@");
            }
            else
            {
               if (j % 2 == 0)
                  System.out.print("@");
               else
                  System.out.print("#");
            }
         }
         
         System.out.println();
      }
   }
}

שאלה 6

כתוב תכנית בה אתה מכניס את שמך המלא למשתנה (2 מילים בדיוק), לאחר מכן על המשתמש לנסות לנחש שם זה.
יש לאמת שהמשתמש אכן הזין שם מלא, אם יש רווחים בתחילת או סוף המחרוזת יש להסירם, התכנית תבדוק את הדברים הבאים:
1. אם השמות תואמים באופן מושלם, התכנית תדפיס "Perfect match".
2. אם השמות תואמים רק עם שוני בין אותיות קטנות וגדולות, התכנית תדפיס "Almost perfect match".
3. אם השם שהמשתמש ניחש קצר יותר משמך, התכנית תדפיס "Guess too short".
4. אם השם שהמשתמש ניחש ארוך יותר משמך, התכנית תדפיס "Guess too long".
5. אם יש התאמה בין השם שלך לשם שהמשתמש הזין אך הסדר הפוך (לדוגמה "Sahar Atias" ו- "Atias Sahar") התכנית תדפיס "Reversed match".
לבסוף התכנית תדפיס את שמך המלא כאשר השם הפרטי והמשפחה מודפסים כל אחד בשורה משלו, השם משפחה באותיות גדולות והשם הפרטי באותיות קטנות.
לאחר מכן התכנית תדפיס שוב את שמך המלא, הפעם הכל בשורה אחת, כך שרווח מוחלף במקף.
הערות: אין להשתמש במערכים, השתמשו במתודות שבמחלקת String.
עבור שני הסעיפים האחרונים יש להשתמש במשתנה אותו הגדרתם בתחילת התכנים עם שמכם.
הצג דוגמת הרצה
למשל עבור השם "Sahar Atias" והקלט מהמשתמש "Atias Sahar" הפלט יהיה: Reversed match
The name was:
SAHAR
atias
Sahar_Atias
הצג פתרון
import java.util.Scanner;

public class Targil6
{
   public static void main(String[] args)
   {
      String nameToGuess = "Sahar Atias";
      
      Scanner sc = new Scanner(System.in);
      String guessedName;
      do
      {
         System.out.print("Guess my name, enter your full name: ");
         guessedName = sc.nextLine();
         if (guessedName.startsWith(" ") || guessedName.endsWith(" "))
            guessedName = guessedName.trim();
      } while (!guessedName.contains(" "));
      if (nameToGuess.equals(guessedName))
         System.out.println("Perfect match");
      else if (nameToGuess.equalsIgnoreCase(guessedName))
         System.out.println("Almost perfect match");
      else if (nameToGuess.length() > guessedName.length())
         System.out.println("Guess too short");
      else if (guessedName.length() > nameToGuess.length())
         System.out.println("Guess too long");
      else
      {
         int spaceIndex = guessedName.indexOf(" ");
         String reversedGuessedName = "";
         for (int i = spaceIndex + 1;i < guessedName.length();i++)
            reversedGuessedName += guessedName.charAt(i);
         reversedGuessedName += " ";
         for (int i = 0;i < spaceIndex;i++)
            reversedGuessedName += guessedName.charAt(i);
         if (nameToGuess.equalsIgnoreCase(reversedGuessedName))
            System.out.println("Reversed match");
      }
      
      System.out.println("The name was: ");
      int spaceIndex = nameToGuess.indexOf(" ");
      String firstPart = nameToGuess.substring(0, spaceIndex).toUpperCase();
      String secondPart = nameToGuess.substring(spaceIndex + 1).toLowerCase();
      System.out.println(firstPart);
      System.out.println(secondPart);
      String spaceToUnder = nameToGuess.replace(" ", "_");
      System.out.println(spaceToUnder);
      
      sc.close();
   }
}

שאלה 7

כתבו תכנית הקולטת מהמשתמש מספר בין 1-5 (יש לאמת זאת) המייצג את מספר המשולשים עבורם יש לחשב את השטח הכולל.
עבור כל משולש יש לקלוט את גובהו ואורך בסיסו (יש לאמת ערכים חיוביים בלבד), את משתנים אלה יש לשלוח כפרמטים למתודה triangleArea שתחשב את השטח בנפרד עבור כל משולש.
התכנית תדפיס בנפרד את שטחו של כל משולש, ולבסוף את השטח הכולל של כל המשולשים.
הצג דוגמת הרצה
Enter how many triangles are the to be calculated (1-5): 11
Wrong, (1-5)!
Enter how many triangles are the to be calculated (1-5): 2
Enter the height of triangle No.1 : -3
Wrong, must be a positive number!
Enter the height of triangle No.1 : 4
Enter the base of triangle No.1 : 5
Area of triangle No.1 is 10.
Enter the height of triangle No.2 : 3
Enter the base of triangle No.2 : 8
Area of triangle No.1 is 12.
The Area of all of the triangles is 22.
הצג פתרון
import java.util.Scanner;

public class Targil7
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      
      int numTriangles;
      do
      {
         System.out.print("Enter how many triangles are the to be calculated (1-5): ");
         numTriangles = sc.nextInt();
         if (numTriangles < 1 || numTriangles > 5)
            System.out.println("Wrong, (1-5)!");
      } while (numTriangles < 1 || numTriangles > 5);
      
      int totalArea = 0;
      for (int i = 1;i <= numTriangles;i++)
      {
         int height;
         int base;
         do
         {
            System.out.print("Enter the height of triangle No." + i + " : ");
            height = sc.nextInt();
            if (height < 1)
               System.out.println("Wrong, must be a positive number!");
         } while (height < 1);
         do
         {
            System.out.print("Enter the base of triangle No." + i + " : ");
            base = sc.nextInt();
            if (base < 1)
               System.out.println("Wrong, must be a positive number!");
         } while (base < 1);
         
         int area = triangleArea(height, base);
         System.out.println("Area of triangle No." + i + " is " + area + ".");
         
         totalArea += area;
      }
      System.out.println("The Area of all of the triangles is " + totalArea + ".");
      
      sc.close();
   }
   
   public static int triangleArea(int height, int base)
   {
      return (height * base) / 2;
   }
}

שאלה 8

כתבו תוכנית הקולטת סדרה של מספרים שלמים גדולים מ-0 (אם יש קלט שגוי, דלגו עליו), התוכנית תבדוק אם המספר הוא פלינדרום, ומדפיסה למסך את התשובה.
מספר הוא פלינדרום אם מתקבל אותו מספר בקריאה משמאל לימין וגם מימין לשמאל.
כל מספר בסדרה צריך להיבדק בנפרד ע"י המתודה isPalindrome.
התכנית תעצר כאשר היא תקבל את הקלט 0.
הצג דוגמת הרצה
Enter a positive integer to check for Palindrome: 8888
The number 8888 is palindrome.
Enter a positive integer to check for Palindrome: 9
The number 9 is palindrome.
Enter a positive integer to check for Palindrome: 121
The number 121 is palindrome.
Enter a positive integer to check for Palindrome: 579975
The number 579975 is palindrome.
Enter a positive integer to check for Palindrome: 2332
The number 2332 is palindrome.
Enter a positive integer to check for Palindrome: 234
The number 234 is not a palindrome.
הצג פתרון
import java.util.Scanner;

public class Targil8
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      int number;
      do
      {
         System.out.print("Enter a positive integer to check for Palindrome: ");
         number = sc.nextInt();
         if (number > 0)
         {
            if (isPalindrome(number))
               System.out.println("The number " + number + " is palindrome.");
            else
               System.out.println("The number " + number + " is not a palindrome.");
         }
      } while (number != 0);
      
      sc.close();
   }
   
   public static boolean isPalindrome(int number)
   {
      int palindrome = number;
      int reverse = 0;
      while (palindrome != 0)
      {
         int remainder = palindrome % 10;
         
         reverse = reverse * 10 + remainder;
         palindrome /= 10;
      }
      
      return number == reverse;
   }
}

שאלה 9

נגדיר שלשה פיתגורית: שלשת מספרים (שלמים וחיוביים) סדורה: c,a,b כך ש- a*a+b*b=c*c.
כתבו תוכנית אשר מקבלת כקלט פרמטר מספר חיובי k בין 10-100 (הניחו קלט תקין).
על התוכנית להדפיס את כל השלשות הפיתגוריות a,b,c כך ש:
c<=k. (שימו לב כי מעצם קיום המשוואה, חייב להתקיים כי c>a,b).
על כל שלשה להיות מודפסת פעם אחת בלבד, בשורה משלה!
מציאת והדפסת השלשות תיעשה על ידי מתודה בשם pythagorianTriplets.
במידה ואין כלל שלשות פיתגוריות העונות על הדרישות, ההודעה הבאה תודפס על המסך:
No pitagorian triplets found!
הצג דוגמת הרצה
Please enter a number between 10 and 100: 20
Found triplet: (3, 4, 5)
Found triplet: (6, 8, 10)
Found triplet: (5, 12, 13)
Found triplet: (9, 12, 15)
Found triplet: (8, 15, 17)
Found triplet: (12, 16, 20)
הצג פתרון
import java.util.Scanner;

public class Targil9
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      System.out.print("Please enter a number between 10 and 100: ");
      int k = sc.nextInt();
      pythagorianTriplets(k);
      
      sc.close();
   }
   
   public static void pythagorianTriplets(int k)
   {
      boolean foundTriplet = false;
      for (int c = 1;c <= k;c++)
      {
         for (int a = 1;a < c;a++)
         {
            for (int b = a;b < c;b++)
            {
               if (a * a + b * b == c * c)
               {
                  System.out.println("Found triplet: (" + a + ", " + b + ", " + c + ")");
                  foundTriplet = true;
               }
            }
         }
      }
      if (!foundTriplet)
         System.out.println("No pitagorian triplets found!");
   }
}

שאלה 10

כתבו תכנית המחשבת את השורשים הממשיים של המשואה הריבועית:
ax^2 + bx + c = 0 a, b, c הם מספרים ממשיים.
התוכנית תקלוט מהמשתמש ב main את ערכי המקדמים ותדפיס פלט בעזרת האלגוריתם הבא שימומש באמצעות פונקצית העזר calcQuadraticEquation:

אלגוריתם לחישוב השורשים הממשיים של משואה ריבועית:
ע"פ ערכי המקדמים a, b, c תודפס רק אחת מאפשרויות הפלט הבאות:

1. a=0 b!=0 הפתרון הוא -c מחולק ב b.
2. a=0 b=0 c!=0 המשואה לא חוקית, אין פתרון.
3. a=0 b=0 c=0 יש אינסוף פתרונות.
4. a!=0 b^2 - 4ac < 0 אין פתרון ממשי.
5. a!=0 b^2 - 4ac = 0 הפתרון הוא -b מחולק ב- 2a.
6. a!=0 b^2 - 4ac > 0 שני פתרונות:

הפתרון הראשון –
(-b + square root of (b^2 - 4ac)) / 2a
הפתרון השני –
(-b - square root of (b^2 - 4ac)) / 2a

כדי לחשב שורש ריבועי השתמשו בשיטה Math.sqrt.
הצג דוגמת הרצה
Please enter a,b,c to calculate result for: ax^2 + bx + c = 0
1
1
-2
There are two solutions to this equation:
1) 1.0
2) -2.0
הצג פתרון
import java.util.Scanner;

public class Targil10
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      System.out.println("Please enter a,b,c to calculate result for: ax^2 + bx + c = 0");
      double a = sc.nextDouble();
      double b = sc.nextDouble();
      double c = sc.nextDouble();
      calcQuadraticEquation(a, b, c);
      
      sc.close();
   }
   
   public static void calcQuadraticEquation(double a, double b, double c)
   {
      if (a == 0)
      {
         if (b != 0)
            System.out.println("Solution is: " + (-c / b));
         else if (c != 0)
            System.out.println("This equation is illegal.");
         else
            System.out.println("There are infinite solutions.");
      }
      else
      {
         double toSqrt = Math.pow(b, 2) - 4 * a * c;
         if (toSqrt < 0)
            System.out.println("There is no solution (cannot make sqrt root of negative number).");
         else if (toSqrt == 0)
            System.out.println("Solution is: " + (-b / (2 * a)));
         else
         {
            System.out.println("There are two solutions to this equation:");
            System.out.println("1) " + ((-b + Math.sqrt(toSqrt)) / (2 * a)));
            System.out.println("2) " + ((-b - Math.sqrt(toSqrt)) / (2 * a)));
         }
      }
   }
}

שאלה 11

המתודה switchArrays הינה מתודה המקבלת שני מערכים של מספרים שלמים בגודל זהה (אותו מספר איברים בכל מערך).
המתודה מחליפה בין המערכים באופן הבא: למערך הראשון היא מכניסה את כל איברי המערך השני בסדר הפוך, ולמערך השני היא מכניסה את כל איברי המערך הראשון בסדר הפוך.
המתודה תחזיר את המערך שנקבע בהגרלה רנדומאלית בטווח של 1-2, אם יוצא 1 המערך הראשון מוחזר, אם יוצא 2 המערך השני מוחזר.
כתבו את התכנית והמתודה המממשת פעולה זו.
הצג דוגמת הרצה
לדוגמה אם המערכים הם:
A={2,4,6,8}, B={1,3,5,7}
אחרי פעולת הפונקציה, המערכים יהיו:
A={7,5,3,1}, B={8,6,4,2}
הצג פתרון
import java.util.Random;

public class Targil11
{
   public static void main(String[] args)
   {
      int[] a = {2, 4, 6, 8};
      int[] b = {1, 3, 5, 7};
      int[] c = switchArrays(a, b);
      for (int i = 0;i < c.length;i++)
         System.out.print(c[i] + " ");
   }
   
   public static int[] switchArrays(int[] a, int[] b)
   {
      int[] temp = new int[a.length];
      System.arraycopy(a, 0, temp, 0, a.length);
      for (int i = b.length - 1;i >= 0;i--)
         a[b.length - i - 1] = b[i];
      for (int i = temp.length - 1;i >= 0;i--)
         b[temp.length - i - 1] = temp[i];
      
      Random rnd = new Random();
      if (rnd.nextInt(2) + 1 == 1)
         return a;
      
      return b;
   }
}

שאלה 12

המתודה checkEqualityInArrays הינה מתודה המקבלת שני מערכים של מספרים שלמים בגודל זהה (אותו מספר איברים בכל מערך), כאשר ניתן להניח כי בכל מערך איברי המערך שונים זה מזה, ונותנת הערכה מספרית לעד כמה שתי המערכים דומים אחד לשני, בכך שהיא מבצעת את הפעולות הבאות: אם בשני המערכים ישנם ערכים זהים בתאים עם אותו מיקום, להערכה נוספים 10 נקודות, אם לשני המערכים ישנם ערכים זהים אך בתאים עם מיקום שונה, להערכה נוספים 5 נקודות.
כל שני מערכים שעוברים את רף ה100 נקודות שוויון, מקבלים בונוס 30 נק' הערכה. בונוס זה הינו חד פעמי ולא חוזר על עצמו במקרה של מעבר נוסף של 100 הנקודות (לדוגמה עבור 210 נקודות שוויון, יהיה בונוס של 30 נק' בלבד).
כתבו את התכנית והמתודה המממשת פעולה זו.
הצג דוגמת הרצה
דוגמה להערכת שני מערכים, עבור:
A = {22,14,23,34,45}
B = {22,14,28,45,44}
ניקוד הערכת השוויון יהיה 25.
הצג פתרון
public class Targil12
{
   public static void main(String[] args)
   {
      int[] a = {22, 14, 23, 34, 45};
      int[] b = {22, 14, 28, 45, 44};
      checkEqualityInArrays(a, b);
   }
   
   public static void checkEqualityInArrays(int[] a, int[] b)
   {
      int points = 0;
      for (int i = 0;i < a.length;i++)
      {
         for (int j = 0;j < b.length;j++)
         {
            if (a[i] == b[j])
            {
               if (i == j)
                  points += 10;
               else
                  points += 5;
            }
         }
      }
      if (points > 100)
         points += 30;
      
      System.out.println("The equality value for the arrays is: " + points);
   }
}

שאלה 13

נתונים שני מערכים: action בגודל 18 ו – result בגודל 6.
במערך action מאוחסנים שש שלשות של מספרים שלמים. המספר הראשון בכל שלשה מייצג קוד של פעולה המתבצעת על שני המספרים הבאים אחריו.
הקודים האפשריים:
המספר 1 מייצג את פעולת החיבור , המספר 2 מייצג את פעולת החיסור.
כתוב תכנית המקבלת כקלט את מערך action. על התכנית לבצע את הפעולות הנדרשות בהתאם לקודים ולאחסן את התוצאות במערך result.
פלט התכנית: הדפסת שני המערכים.
הצג דוגמת הרצה
Please enter 1 to sum the next 2 numbers or 2 to sub them: 2
Please enter a number: 31
Please enter a number: 11
Please enter 1 to sum the next 2 numbers or 2 to sub them: 1
Please enter a number: -40
Please enter a number: 10
Please enter 1 to sum the next 2 numbers or 2 to sub them: 2
Please enter a number: 2
Please enter a number: 2
Please enter 1 to sum the next 2 numbers or 2 to sub them: 2
Please enter a number: 2
Please enter a number: 2
Please enter 1 to sum the next 2 numbers or 2 to sub them: 1
Please enter a number: 2
Please enter a number: 3
Please enter 1 to sum the next 2 numbers or 2 to sub them: 2
Please enter a number: 3
Please enter a number: 3
The action array was:
2 31 11 1 -40 10 2 2 2 2 2 2 1 2 3 2 3 3
The result array is:
20 -30 0 0 5 0
הצג פתרון
import java.util.Scanner;

public class Targil13
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      int[] action = new int[18];
      int[] result = new int[6];
      for (int i = 0;i < action.length;i++)
      {
         if (i % 3 == 0)
            System.out.print("Please enter 1 to sum the next 2 numbers or 2 to sub them: ");
         else
            System.out.print("Please enter a number: ");
         
         action[i] = sc.nextInt();
      }
      for (int i = 0;i < result.length;i++)
      {
         int j = i * 3;
         if (action[j] == 1)
            result[i] = action[j + 1] + action[j + 2];
         else
            result[i] = action[j + 1] - action[j + 2];
      }
      System.out.println("The action array was:");
      for (int i = 0;i < action.length;i++)
         System.out.print(action[i] + " ");
      System.out.println();
      System.out.println("The result array is:");
      for (int i = 0;i < result.length;i++)
         System.out.print(result[i] + " ");
      
      sc.close();
   }
}

שאלה 14

סדרה הנדסית הינה סדרה שבה המנה בין כל שני איברים עוקבים הינו קבוע.
לדוגמה, הסדרה הבאה היא סדרה הנדסית: 1,2,4,8,16,32,64,128
כאשר האיבר הראשון הוא a1 = 1 ומנת הסדרה היא q = 2.
כתבו תכנית המקבלת מהמשתמש את האיבר בראשון a, מנת הסדרה q ומיקום n ומדפיסה את כל המספרים בסדרה ההנדסית עד למיקום ה-n.
יש לבדוק כי המשתמש הזין מנה חוקית (q != 1) וכי האינדקס חוקי (גדול מ-0) במידה והערך לא תקין עליכם להדפיס הודעת שגיאה ולהמשיך לבקש קלט עד שייתקבל קלט תקין.
הצג דוגמת הרצה
Please enter the first element in the series: 1
Please enter the dose between elements: 1
The dose cannot be 1.
Please enter the dose between elements: 2
Please enter the amount of elements in the series: -3
The amount of elements must be bigger than 0.
Please enter the amount of elements in the series: 8
1 2 4 8 16 32 64 128
הצג פתרון
import java.util.Scanner;

public class Targil14
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      System.out.print("Please enter the first element in the series: ");
      int a = sc.nextInt();
      int q;
      int n;
      do
      {
         System.out.print("Please enter the dose between elements: ");
         q = sc.nextInt();
         if (q == 1)
            System.out.println("The dose cannot be 1.");
      } while (q == 1);
      do
      {
         System.out.print("Please enter the amount of elements in the series: ");
         n = sc.nextInt();
         if (n < 1)
            System.out.println("The amount of elements must be bigger than 0.");
      } while (n < 1);
      sc.close();
      
      for (int i = 0;i < n;i++)
      {
         System.out.print(a + " ");
         
         a *= q;
      }
   }
}

שאלה 15

כתוב תכנית הקולטת מספר בין 1-10 (עליכם לוודא זאת) ומדפיסה את כל המספרים בין 1 ל-1000 אשר סכום הספרות שלהם הינו המספר שנקלט.
הצג דוגמת הרצה
Please enter a number between 1-10: -3
Please enter a number between 1-10: 11
Please enter a number between 1-10: 2
2 11 20 101 110 200
הצג פתרון
import java.util.Scanner;

public class Targil15
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      int num;
      do
      {
         System.out.print("Please enter a number between 1-10: ");
         num = sc.nextInt();
      } while (num < 1 || num > 10);
      sc.close();
      
      for (int i = 1;i < 1000;i++)
      {
         int copy = i;
         int sum = 0;
         while (copy > 0)
         {
            sum += (copy % 10);
            copy /= 10;
         }
         if (sum == num)
            System.out.print(i + " ");
      }
   }
}

שאלה 16

כתבו את המתודה:
isPrime(int num)
המקבלת מספר שלם גדול מ-1 ומחזירה האם המספר ראשוני או לא.
כתבו את המתודה:
largestPrimesAverage(int num, int k)
המקבלת מספר שלם גדול מ-1 ומספר k נוסף גדול מ-0.
המתודה תחזיר את הממוצע של k המספרים הראשוניים הגדולים ביותר שקטנים ממש מ - num.
במידה וקיימים פחות מ- k מספרים ראשוניים הקטנים ממש מ- num על המתודה להחזיר את הממוצע שלהם.
במתודה זו יש להשתמש במתודה isPrime שיצרתם קודם לכן על מנת לבדוק אם מספר הוא ראשוני.
הצג דוגמת הרצה
דוגמאות:
isPrime(7) => true
isPrime(12) => false

largestPrimesAverage(8, 3) => 5.0 // (7+5+3)/3 = 5.0 largestPrimesAverage(8, 1) => 7.0 // 7/1 = 7.0 largestPrimesAverage(7, 3) => 3.3333… // (5+3+2)/3 = 3.33… largestPrimesAverage(20, 5) => 13.4 // (19+17+13+11+7)/5 = 13.4 largestPrimesAverage(12, 7) => 5.6 // (11+7+5+3+2)/5 = 5.6
הצג פתרון
public static boolean isPrime(int num)
{
   for (int i = 2;i < num / 2 + 1;i++)
      if (num % i == 0)
         return false;
   
   return true;
}

public static double largestPrimesAverage(int num, int k)
{
   int sum = 0;
   int count = 0;
   for (int i = num - 1;i >= 2 && count < k;i--)
   {
      if (isPrime(i))
      {
         sum += i;
         count++;
      }
   }
   
   return (double) sum / count;
}

שאלה 17

יהי A מערך של מספרים שלמים שונים (לא ממוין).
כתבו מתודה המקבלת מערך A ומחזירה true אם ורק אם:
∀x: 0≤x<n ∃y: 0≤y<n ∧ y≠x: A[x] > A[y] - 10
למתודה צריכה להיות החתימה הבאה:
public static boolean forAllExists(int[] a)
חישבו מה יש להחזיר במידה והמערך ריק או הינו יחידון (מכיל תא אחד בלבד).
הצג דוגמת הרצה
בהינתן הקלט:
A = {1, 2, 5, 7, 9, 3}
הפלט שיתקבל יהיה true.
בהינתן הקלט:
A = {1, 20, 40 , 60}
הפלט שיתקבל יהיה false.
הצג פתרון
public static boolean forAllExists(int[] a)
{
   if (a.length < 2)
      return false;
   
   for (int x = 0;x < a.length;x++)
   {
      boolean exists = false;
      for (int y = 0;y < a.length && !exists;y++)
      {
         if (y != x)
         {
            if (a[x] > a[y] - 10)
               exists = true;
         }
      }
      if (!exists)
         return false;
   }
   
   return true;
}

שאלה 18

יהי A מערך של מספרים שלמים שונים (לא ממוין).
כתבו מתודה המקבלת מערך A ומחזירה true אם ורק אם:
∃x: 0≤x<n ∀y: 0≤y<n ∧ y≠x: A[y] - 10 < A[x] < A[y] + 10
למתודה צריכה להיות החתימה הבאה:
public static boolean existsForAll(int[] a)
הצג דוגמת הרצה
בהינתן הקלט:
A = {1, 6, 15, 12}
הפלט שיתקבל יהיה true.
בהינתן הקלט:
A = {1, 20, 40 , 60}
הפלט שיתקבל יהיה false.
הצג פתרון
public static boolean existsForAll(int[] a)
{
   for (int x = 0;x < a.length;x++)
   {
      boolean existForAll = true;
      for (int y = 0;y < a.length && existForAll;y++)
      {
         if (y != x)
         {
            if (a[y] - 10 >= a[x])
               existForAll = false;
            else if (a[x] >= a[y] + 10)
               existForAll = false;
         }
      }
      if (existForAll)
         return true;
   }
   
   return false;
}

שאלה 19

יש לכתוב שיטה המקבלת שתי מחרוזות ומדפיסה שתי מחרוזות חדשות אחרות שהן אלו:
המחרוזת החדשה הראשונה מורכבת ממחציתה השנייה של המחרוזת הראשונה ומחציתה הראשונה של המחרוזת השנייה.
המחרוזת החדשה השנייה מורכבת ממחציתה הראשונה של המחרוזת הראשונה וממחציתה השנייה של המחרוזת השנייה.
לאחר הדפסת שתי המחרוזות החדשות, השיטה תדפיס את כל המספרים מ1 עד אורך שתי המחרוזות ביחד באותה שורה.
הצג דוגמת הרצה
לדוגמה, עבור קלט של המחרוזות bear, me התוכנית תדפיס:
arm
bee
1 2 3 4 5 6 
הצג פתרון
public static void changeAndPrint(String a, String b)
{
   String new1 = a.substring(a.length() / 2, a.length()) + b.substring(0, b.length() / 2);
   String new2 = a.substring(0, a.length() / 2) + b.substring(b.length() / 2, b.length());
   System.out.println(new1);
   System.out.println(new2);
   for (int i = 1;i <= new1.length() + new2.length();i++)
      System.out.print(i + " ");
}

שאלה 20

יש לכתוב שיטה המקבלת מחרוזת. השיטה מדפיסה כפלט את המחרוזת ללא אותיות זהות צמודות.
הצג דוגמת הרצה
עבור הקלט: apple הפלט יהיה aple.
עבור הקלט: Yellow balloon הפלט יהיה Yelow balon.
עבור הקלט: abbba הפלט יהיה aba.
הצג פתרון
public static void removeAndPrint(String s)
{
   String newS = s.substring(0, 1);
   for (int i = 1;i < s.length();i++)
      if (s.charAt(i) != s.charAt(i - 1))
         newS += s.charAt(i);
   
   System.out.println(newS);
}

חלמיש 1

נתונה המתודה בעלת החתימה הבאה:
public static int how_many(int[] array, int value)
המתודה סופרת כמה פעמים הערך value מופיע במערך array, כתבו את המתודה.
הצג דוגמת הרצה
לדוגמה עבור המערך 21 12 1 2 1 2 1 והמספר 1 המתודה תחזיר 3.
הצג פתרון
public static int how_many(int[] array, int value)
{
   int count = 0;
   for (int var : array)
      if (var == value)
         count++;
   
   return count;
}

חלמיש 2

נתונה המתודה בעלת החתימה הבאה:
public static boolean is_diff(int[] arr1, int[] arr2, int k)
אשר מקבלת שני מערכים עם מספרים שלמים בסדר עולה ומספר k כלשהו.
המתודה תחזיר אמת אם קיימים שני איברים במערך הראשון והשני כך ש- arr1[i] - arr2[j] = k.
שימו לב שהערך הראשון צריך להיות דווקא מהמערך הראשון והערך השני דווקא מעמרך השני, ולא להיפך.
במידה ולא קיימים שני איברים כאלו המתודה תחזיר שקר.
כתבו את המתודה.
הצג דוגמת הרצה
לדוגמא , עבור המערכים:
arr1 = {1, 5, 8, 20}
arr2 = {2, 15, 21}
המתודה תחזיר אמת עבור k = 5 ושקר עבור k = 4.
הצג פתרון
public static boolean is_diff(int[] arr1, int[] arr2, int k)
{
   for (int i = 0;i < arr1.length;i++)
      for (int j = 0;j < arr2.length;j++)
         if (arr1[i] - arr2[j] == k)
            return true;
   
   return false;
}

חלמיש 3

סעיף א
נתון הקטע קוד הבא:
public static int secret(int a, int b)
{
   while (a >= b)
      a -= b;
   
   return a;
}
מה משמעות הערך שהפונקציה מחזירה כשהיא מקבלת a ו- b חיוביים? נמקו בקצרה.
כמו-כן, תנו דוגמא לערכי a ו- b שעבורם תיווצר לולאה אינסופית.
הצג פתרון
משמעות הערך שהמתודה מחזירה הוא שארית החלוקה של a ב- b.
מחסרים את b מ- a עד אשר a נהיה קטן מ- b ואז יודעים שמה שיש כרגע ב-a הוא שארית החלוקה.
תהיה לולאה אינסופית עבור a > 0, b = 0.
סעיף ב
נתון הקטע קוד הבא:
public static boolean secret(int n)
{
   while (n > 1)
   {
      if (n % 2 == 1)
         return false;
      
      n /= 2;
   }
   
   return true;
}
מה עושה המתודה? נמקו בקצרה.
הצג פתרון
בהנחה ש n חיובי, המתודה בודקת האם המספר הוא חזקה של 2.
סעיף ג
נתון הקטע קוד הבא:
import java.util.Scanner;

public class Halamish3
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      int a[] = new int[10];
      int n = sc.nextInt();
      for (int i = 0;i <= n;i++)
         a[i] = i;
      sc.close();
   }
}
מה הבעיה בתוכנית הזאת?
אפיינו את הבעיה - קומפילציה או זמן ריצה, הסבירו ותקנו את הטעות.
הצג פתרון
הבעיה היא שעבור כל n גדול מ-9 התכנית תנסה לגשת לתא במערך שלא קיים (מחוץ לטווח של 10 תאים שהוגדרו).
טעות זו היא טעות זמן ריצה, כיוון שרק בהרצת התכנית ובהינתן קלט גדול מ-9 התכנית תצא עם שגיאה, ע"מ לתקן את הטעות יש להגביל את n למקסימום 9, או לחלופין לעשות שהמערך יהיה בעל n תאים ואז לרוץ מ-0 עד n (לא כולל).

חלמיש 4

מספר שלם חיובי יקרא "עולה" אם הספרות בו הן בערך עולה בהסתכלות מימין לשמאל.
מספר שלם חיובי יקרא "יורד" אם הספרות בו הן בערך יורד בהסתכלות מימין לשמאל.
מספר שלם חיובי יקרא "יציב" אם הספרות בו אינן שומרות על ערך עולה או יורד דווקא.
ממשו את המתודה:
public static int upDown(int n1)
המקבלת מספר שלם וחיובי, המתודה מחזירה 1 אם המספר עולה, 1- אם המספר יורד ו-0 אם הוא יציב.
הצג דוגמת הרצה
לדוגמה:
המספר 9764211 הוא עולה,
המספר 24566778 הוא יורד,
המספר 5124986 הוא יציב.
הצג פתרון
public static int upDown(int n1)
{
   boolean isUp = true;
   boolean isDown = true;
   
   int previousRemainder = n1 % 10;
   n1 /= 10;
   
   while (n1 > 0)
   {
      int remainder = n1 % 10;
      if (remainder < previousRemainder)
         isUp = false;
      else if (remainder > previousRemainder)
         isDown = false;
      
      if (!isUp && !isDown)
         return 0;
      
      previousRemainder = remainder;
      n1 /= 10;
   }
   
   return isUp ? 1 : -1;
}

חלמיש 5

מה יהיה הפלט של הקטע קוד הבא?
public class Halamish5
{
   static int x = 3;
   
   public static void main(String[] args)
   {
      for (int i = 0;i < 3;i++)
         System.out.println(fun(i * x));
   }
   
   public static int fun(int a)
   {
      x = 2;
      
      return a + fan(x);
   }
   
   public static int fan(int b)
   {
      int x = 1 + b;
      
      return b * x;
   }
}
הצג פתרון
6
8
10

חלמיש 6

ציין ע"פ הקטע הבא עבור אליו ערכים של e1,e2,e3 (true / false) יתבצע כל אחת מההדפסות.
if (e1 && e2)
   if (!(e2 && e3))
      System.out.println("s1");
   else if (e2 || e3)
      if (e1)
         System.out.println("s2");
      else if (e1 || !e2);
      else
         System.out.println("s3");
הצג פתרון
עבור e1,e2 = true ו- e3 = false התכנית תדפיס s1.
עבור e1,e2,e3 = true התכנית תדפיס s2.
אין תנאי שייקים את s3.

חלמיש 7

נתונים 3 משתנים a,b,c כתוב קטע של תכנית, יעילה ככל האפשר, המדפיסה אותם ע"פ סדר עולה, בלי שימוש במשתנים נוספים ובאמצעות if ו- else בלבד.
הצג פתרון
   if (a > b)
   {
      if (b > c)
         System.out.println(a + " " + b + " " + c);
      else if (a > c)
         System.out.println(a + " " + c + " " + b);
      else
         System.out.println(c + " " + a + " " + b);
   }
   else
   {
      if (a > c)
         System.out.println(b + " " + a + " " + c);
      else if (b > c)
         System.out.println(b + " " + c + " " + a);
      else
         System.out.println(c + " " + b + " " + a);
   }

חלמיש 8

נתון מערך של מספרים שלמים בגודל n, כתוב מתודה ההופכת את סדרו, בעזרת משתנה עזר אחד בלבד.
קחו בחשבון ש-n יכול להיות מספר זוגי או אי זוגי.
הצג פתרון
public static void reverse(int[] arr)
{
   for (int i = 0;i < arr.length / 2;i++)
   {
      int temp = arr[arr.length - i - 1];
      arr[arr.length - i - 1] = arr[i];
      arr[i] = temp;
   }
}

חלמיש 9

כתוב תכנית הקולטת שני מערכים ממויינים בסדר עולה, בכל מערך 5 מספרים.
התכנית מדפיסה את כל איברי המערכים בצורה ממויינת, ניתן להניח כי כל המספרים שונים זה מזה.
הצג פתרון
public class Halamish9
{
   public static void main(String[] args)
   {
      Scanner sc = new Scanner(System.in);
      int[] arr1 = new int[5];
      int[] arr2 = new int[5];
      System.out.println("Please enter 5 numbers for the first array in raising order.");
      for (int i = 0;i < arr1.length;i++)
         arr1[i] = sc.nextInt();
      System.out.println("Please enter 5 numbers for the second array in raising order.");
      for (int i = 0;i < arr2.length;i++)
         arr2[i] = sc.nextInt();
      sc.close();
      
      int x = 0;
      int y = 0;
      while (x < arr1.length && y < arr2.length)
      {
         if (arr1[x] < arr2[y])
         {
            System.out.print(arr1[x] + " ");
            x++;
         }
         else
         {
            System.out.print(arr2[y] + " ");
            y++;
         }
      }
      while (x < arr1.length)
      {
         System.out.print(arr1[x] + " ");
         x++;
      }
      while (y < arr2.length)
      {
         System.out.print(arr2[y] + " ");
         y++;
      }
   }
}

חלמיש 10

בהתאמת מחרוזות מחפשים מופע של מחרוזת אחת (התבנית) בתוך השנייה (הטקסט).
לעיתים מחפשים התאמה לא מושלמת, שיש בה מספר סתירות - מקומות בהן התבנית שונה מהטקסט.
לדוגמה: אם התבנית היא abac והטקסט הוא aabccc הרי במקום הראשון קיימת התאמה עם שתי סתירות (התו השני שונה a בטקסט ו- b בתבנית והתו השלישי שונה b בטקסט, a בתבנית).
לעומת זאת במקום השני יש התאמה עם סתירה אחת (התו השלישי שונה - c בטקסט ו- a בתבנית). זוהי גם ההתאמה הטובה ביותר - יש בה מספר מינימאלי של סתירות.
כתוב מתודה match המקבלת שתי מחרוזות - תבנית וטקסט ומחשבת את ההתאמה הטובה ביותר, המתודה תחזיר את מספר הסתירות בהתאמה זו.
הצג פתרון
public static int match(String pattern, String text)
{
   int bestConflictCount = text.length();
   for (int i = 0;i < text.length() - pattern.length();i++)
   {
      int countConflicts = 0;
      for (int j = 0;j < pattern.length();j++)
      {
         if (text.charAt(i + j) != pattern.charAt(j))
            countConflicts++;
      }
      if (countConflicts < bestConflictCount)
         bestConflictCount = countConflicts;
   }
   
   return bestConflictCount;
}

חלמיש 11

נתונה המתודה:
public static void strange(int[] numbers)
{
   int temp;
   for (int i = 0;i < numbers.length - 1;i++)
   {
      for (int j = numbers.length - 1;j > i;j--)
      {
         if (numbers[j - 1] > numbers[j])
         {
            temp = numbers[j - 1];
            numbers[j - 1] = numbers[j];
            numbers[j] = temp;
         }
      }
   }
}
איך יראה המערך numbers הבא לאחר הרצת המתודה ()strange עליו?
numbers = {0, 3, 4, 9, 8, 6, 5, 7, 2, 1}
הצג פתרון
0 1 2 3 4 5 6 7 8 9 

חלמיש 12

סדרת פיבונאצ'י היא סדרה בה האיברים הראשון והשני הם 1, ומהאיבר השלישי והלאה כל איבר שווה לסכום שני האיברים שלפניו.
כתוב מתודה המקבלת מספר טבעי n (גדול או שווה 1, הנח שהוא תקין) ומחזירה את האיבר ה-n בסדרת פיבונאצ'י.
הצג פתרון
public static int getValueAtIndex(int n)
{
   if (n < 3)
      return 1;
   
   int[] p = new int[n];
   p[0] = 1;
   p[1] = 1;
   for (int i = 2;i < n;i++)
      p[i] = p[i - 1] + p[i - 2];
   
   return p[n - 1];
}

חלמיש 13

כתוב מתודה המקבלת מערך כפרמטר ומחזירה את הערך הקטן ביותר במערך.
הצג פתרון
public static int findMinimum(int[] arr)
{
   int min = arr[0];
   for (int i = 1;i < arr.length;i++)
      if (arr[i] < min)
         min = arr[i];
   
   return min;
}

חלמיש 14

כתוב מתודה המקבלת 2 מספרים שלמים a,b.
(b ספרה אחת בלבד).
המתודה מדפיסה את כל המספרים בין 0 ל- a שמקיימים את אחד התנאים הבאים:
* המספר מכיל את b כאחד מספרותיו.
* המספר מתחלק ב- b.
הצג פתרון
public static void printNumbers(int a, int b)
{
   for (int i = 0;i < a;i++)
   {
      if (i % b == 0)
         System.out.println(i);
      else
      {
         int copy = i;
         boolean flag = false;
         while (copy != 0 && !flag)
         {
            int remainder = copy % 10;
            if (remainder == b)
            {
               System.out.println(i);
               flag = true;
            }
            
            copy /= 10;
         }
      }
   }
}

חלמיש 15

נתון הקטע קוד הבא:
public static void main(String[] args)
{
   int a = 3;
   int b = 7;
   int x;
   if (a++ != 0 || b -- != 0)
      x = 1;
   else
      x = 0;
   int y = (b--) * x;
   
   System.out.printf("%d %d %d %d", a, b, x, y);
}
רשום מהו הפלט של קטע קוד זה.
הצג פתרון
4 6 1 7

חלמיש 16

נתון הקטע קוד הבא:
public class Halamish16
{
   static int c = 0;
   
   public static void main(String[] args)
   {
      int a = 3;
      for (int i = 1;i < a;i += 2)
         func(a * 5);
   }
   
   public static void func(int x)
   {
      c++;
      
      for (int i = 1;i < x;i *= 2)
         System.out.printf("%d %d", i, c);
   }
}
רשום מהו הפלט של קטע קוד זה.
הצג פתרון
1 12 14 18 1

חלמיש 17

כתוב מתודה המחשבת עצרת של מספר טבעי חיובי (הנח שהוא תקין) המתודה מקבלת כפרמטר את n ומחזירה n!
הצג פתרון
public static int getAzeret(int n)
{
   int azeret = 1;
   for (int i = 2;i <= n;i++)
      azeret *= i;
   
   return azeret;
}

חלמיש 18

כתוב מתודה המקבלת מספר טבעי חיובי h ומדפיסה משולש שווה שוקיים בגובה המשתנה, לדוגמה עבור h = 4 יודפס:
   *
  ***
 *****
*******
הצג פתרון
public static void printTriangle(int h)
{
   for (int i = 1;i <= h;i++)
   {
      int spaces = h - i;
      
      for (int j = 0;j < spaces;j++)
         System.out.print(" ");
      for (int j = 0;j < i * 2 - 1;j++)
         System.out.print("*");
      System.out.println();
   }
}

מעקב 1

נתון הקוד הבא:
public static void main(String[] args)
{
   int number = 10;
   int d = 0;
   int sum = 0;
   while (number > 0)
   {
      number -= d;
      sum += number;
      d++;
      
      System.out.print(number + " ");
   }
   System.out.println();
   System.out.println("Sum is: " + sum);
   while (d >= 0)
   {
      d--;
      sum--;
   }
   System.out.println("Sum is: " + sum);
}
העזרו בטבלת מעקב וכתבו מה תדפיס התכנית.
הצג טבלת מעקב לחץ להגדלה
הצג פתרון
10 9 7 4 0
Sum is: 30
Sum is: 24

מעקב 2

נתון הקוד הבא:
public static int what(int a, int b)
{
   int something = 0;
   while (a-- > 0)
      something++;
   while (b > 0)
   {
      b--;
      something--;
   }
   
   return something;
}
העזרו בטבלת מעקב וכתבו מה תחזיר הקריאה למתודה:
what(4, 2)
what(2, 4)
מה מטרת המתודה?
הצג טבלת מעקב לחץ להגדלה
הצג פתרון
בקריאה הראשונה יחזור 2.
בקריאה השנייה יחזור 2-.
מטרת המתודה לעשות a - b.

מעקב 3

נתון הקוד הבא:
public static void main(String[] args)
{
   int x, y, z;
   for (x = 0; x < 3; x+=1)
   {
      switch (x)
      {
         case 1:
            System.out.print("One ");
         case 0:
            System.out.print("Zero ");
         case 2:
            System.out.print("Two ");
      }
      System.out.println();
      
      y = x;
      z = (y % 2) == 0 ? y++ : ++y;
      System.out.println("y= " + y + " z= " + z);
   }
}
העזרו בטבלת מעקב וכתבו מה יהיה פלט התכנית?
הצג טבלת מעקב לחץ להגדלה
הצג פתרון
Zero Two
y= 1 z= 0
One Zero Two
y= 2 z= 2
Two
y= 3 z= 2

מעקב 4

נתון הקוד הבא:
public class Maakav4
{
   static int k = 34;
   
   public static void main(String[] args)
   {
      int i = 33;
      int j = 42;
      i = func(i, j);
      System.out.println(i + " " + j + " " + k);
   }
   
   public static int func(int i, int j)
   {
      k = 4;
      k = i / k;
      j = i * k;
      i = k;
      
      return j;
   }
}
העזרו בטבלת מעקב וכתבו מה יהיה פלט התכנית?
הצג טבלת מעקב לחץ להגדלה
הצג פתרון
264 42 8

מעקב 5

נתון הקוד הבא:
public class Maakav5
{
   static int i;
   
   public static void main(String[] args)
   {
      int j;
      char[] str = "Software Systems".toCharArray();
      
      foo(str);
      j = goo(i, str);
      
      String s = new String(str);
      System.out.println(s + " " + i + " " + j);
   }
   
   public static void foo(char[] str)
   {
      int length = str.length;
      boolean found = false;
      for (int j = 0;!found && j < length;j++)
      {
         if (str[j] == ' ')
         {
            found = true;
            i = j;
         }
      }
      
      str[i] = '_';
   }
   
   public static int goo(int i, char[] str)
   {
      int j = 1;
      while (j < str.length)
      {
         str[j - 1] = str[j];
         j++;
      }
      i = j;
      
      return i;
   }
}
העזרו בטבלת מעקב וכתבו מה יהיה פלט התכנית?
הצג טבלת מעקב לחץ להגדלה
הצג פתרון
oftware_Systemss 8 16

מעקב 6

נתון הקוד הבא:
public static void main(String[] args)
{
   int a = 2;
   int b = 8;
   boolean ans = false;
   if (a == 1)
      ans = b == 1;
   else
      for (int n = 1;n <= b;n = n * a)
         if (n == b)
            ans = true;
   
   System.out.println(ans);
}
כתבו מה יהיה פלט התכנית?
במידה ונחליף בין a ו-b, מה יהיה פלט התכנית החדש?
מהי מטרת התכנית?
הצג טבלת מעקב לחץ להגדלה
הצג פתרון
הפלט הראשון יהיה true
הפלט השני יהיה false
התכנית בודקת האם ניתן לייצג את b כ-a בחזקת מספר מסויים.

מעקב 7

נתון הקוד הבא:
public static void fun(int num1, int num2)
{
   boolean flag = true;
   int min = num1 <= num2 ? num1 : num2;
   for (int i = min;i >= 1 && flag;i--)
   {
      if (num1 % i == 0 && num2 % i == 0)
      {
         System.out.printf("i = %d", i);
         flag = false;
      }
   }
}
רשמו מה יהיה הפלט של המתודה בקריאה:
fun(81, 54)
רשמו מהי משימת המתודה?
הצג טבלת מעקב
num1num2min
815454

flagii >= 1 && flagnum1 % i == 0 && num2 % i == 0
true54truefalse
true53truefalse
............
true27truetrue (syso here)
false26false-
הצג פתרון
הפלט יהיה i = 27.
המתודה מדפיסה את המספר הגדול ביותר שמחלק גם את num1 וגם את num2 ללא שארית.

שגיאות 1

תלמיד התבקש לכתוב תכנית שתחשב ממוצע עבור 10 ציוניו של המשתמש ותדפיס אותו למסך, להלן התכנית:
public static void main(String[] args)
{
   Scanner sc = new Scanner(System.in);
   int grade, sum;
   int average;
   System.out.print("Please enter 10 grades: ");
   for (i = 0; i <= 10; ++i)
   {
      grade = sc.nextInt();
      sum *= grade;
   }
   average = sum / 10;
   System.out.println("The average grade is: " + average);
}
בתכנית זו ישנם מספר שגיאות תחביריות ולוגיות, מצאו את כל השגיאות בקוד וסווגו אותם לשגיאות לוגיות או תחביריות.
הסבירו במשפט עבור כל שגיאה שמצאתם מדוע היא אכן שגיאה.
תזכורת:
שגיאה תחבירית הינה שגיאה בתחביר השפה ,לדוגמא בסוף פקודה לא שמים ; שגיאה כזו תגרום לכישלון בתהליך הקומפילציה.
שגיאה לוגית הינה שגיאה אשר מבחינה תחבירית תעבור את הקומפיילר אך היא שגיאה רעיונית ,לדוגמא :רוצים לחשב היקף מעגל אך רושמים נוסחה של שטח מעגל.
לבסוף רשמו את התכנית בצורה מתוקנת.
הצג פתרון
שגיאות תחביריות:
- לא הגדיר את המשתנה i בשום מקום - בשפת java חובה להגדיר סוג לכל משתנה.
- לא אתחל את sum לפני שבצע עליו פעולות - בשפת java אי אפשר לעשות פעולות על משתנה (כמו כפל לדוגמה) לפני התחלתו בערך כלשהו.
שגיאות לוגיות:
- הלולאה רצה מ-0 עד 10 (כולל) ולכן תרוץ סה"כ 11 פעמים במקום 10.
- בחישוב של הסכום הוא עושה כפל במקום חיבור.
הקוד המתוקן:
public static void main(String[] args)
{
   Scanner sc = new Scanner(System.in);
   int grade, sum = 0;
   int average;
   System.out.print("Please enter 10 grades: ");
   for (int i = 0; i < 10; ++i)
   {
      grade = sc.nextInt();
      sum += grade;
   }
   average = sum / 10;
   System.out.println("The average grade is: " + average);
}

שגיאות 2

תלמיד התבקש לכתוב תכנית אשר תחשב את היקפו ושטחו של מעגל עבור קלט של רדיוס.
על התכנית לבצע את החישוב 5 פעמים עבור 5 קלטים מהמשתמש ולהדפיס למסך את תוצאת ההיקף והשטח המקסימלים שהתקבלו מבין 5 הרדיוסים.
להלן קוד התלמיד:
import java.util.Scanner;

public class Errors2
{
   public static void main(String[] args)
   {
      int area perimeter;
      int radius;
      System.out.println("please enter 5 radiuses:");
      for (int i = 1; i < 5; i--)
      {
         radius = sc.nextDouble()
         perimeter = 2 * Math.PI * radius;
         area = Math.PI * radius * radius;
      }
      System.out.println("area: " area);
      System.out.println("perimeter: + perimeter");
      sc.close();
   }
}
בתכנית זו ישנם מספר שגיאות תחביריות ולוגיות, מצאו את כל השגיאות בקוד וסווגו אותם לשגיאות לוגיות או תחביריות.
הסבירו במשפט עבור כל שגיאה שמצאתם מדוע היא אכן שגיאה.
לבסוף רשמו את התכנית בצורה מתוקנת.
הצג פתרון
שגיאות תחביריות:
- חסר פסיק בין המילים area ו- perimeter, חובה להפריד בין הגדרת משתנים בפסיקים.
- חסר ; אחרי sc.nextDouble(), כל פקודה חייבת להסתיים ב;
- המשתנה sc לא הוגדר כלל, חובה להגדיר משתנה לפני שמשתמשים בו.
- לא ניתן לעשות nextDouble על משתנה radius כי הוא מסוג int הקטן יותר מ- double, לכן יש לשנות את סוגו ל-double.
- המשתנים area ו- perimeter גם כן חייבים להיות double, כיוון שהמשתנה PI הוא double ולא ניתן להמיר מ-double ל- int.
- חסר + בהדפסה של השטח ע"מ לשרשר בין המחרוזת למשתנה.
- חייב לתת ערך התחלתי כלשהו למשתנים area ו- perimeter לפני השימוש בהם, במקרה הזה בהדפסות.
שגיאות לוגיות:
- לולאה אין סופית כיוון שכתוב i-- במקום i++.
- לאחר השינוי ל- i++ הלולאה תרוץ רק 4 פעמים במקום 5 פעמים כמו שהתבקש.
- המשתנה perimeter בהדפסה האחרונה יודפס כמילה perimeter ולא כערך המשתנה, יש להורד בסוף ההדפסה את הגרש ולהוסיפו לפני התו +.
- התכנית לא מחשבת את מה שהתבקש, היא תדפיס את השטח וההיקף האחרונים שחושבו ולא את המקסימלים.
הקוד המתוקן:
import java.util.Scanner;

public class Errors2
{
   public static void main(String[] args)
   {
      double maxArea = 0, maxPerimeter = 0, radius;
      Scanner sc = new Scanner(System.in);
      System.out.println("Please enter 5 radiuses:");
      for (int i = 0; i < 5; i++)
      {
         radius = sc.nextDouble();
         double tempPerimeter = 2 * Math.PI * radius;
         if (tempPerimeter > maxPerimeter)
            maxPerimeter = tempPerimeter;
         double tempArea = Math.PI * radius * radius;
         if (tempArea > maxArea)
            maxArea = tempArea;
      }
      System.out.println("max area: " + maxArea);
      System.out.println("max perimeter: " + maxPerimeter);
      sc.close();
   }
}

מבחן 1

סעיף א
נתון מערך:
arr = {4, 6, 2, 0, 5, 1}
כתבו מה יהיה הפלט של התכנית הבאה:
int cell = 3;
while (cell >= 0 && cell <= 5)
{
   System.out.println(cell);
   cell = arr[cell];
}
מה יקרה אם משנים את cell ל- 2?
הצג פתרון
3
0
4
5
1
אם משנים את cell ל- 2 תתקבל לולאה אינסופית.
סעיף ב
מה יהיה הפלט של הקטע קוד הבא?
int sum = 0;
for (int i = 3;i <= 8;i++)
   if (i % 2 == 1)
      sum = sum + i * 2;
System.out.println(sum);
הצג פתרון
30

מבחן 2

כתבו מתודה:
public static boolean isEqualSum(int[] pos, int[] values)
הבודקת האם סכום המספרים ממערך values בכל מקום שבו במערך pos הערך הוא 1 שווה לסכום המספרים במערך values שבו בכל מקום במערך pos הערך הוא 0.
הצג פתרון
public static boolean isEqualSum(int[] pos, int[] values)
{
   int sumOnes = 0;
   int sumZeros = 0;
   for (int i = 0;i < pos.length;i++)
   {
      if (pos[i] == 1)
         sumOnes += values[i];
      else
         sumZeros += values[i];
   }
   
   return sumOnes == sumZeros;
}

מבחן 3

כתבו מתודה:
public static int evenOdd(int[] array, int[] arrEven, int[] arrOdd)
המקבלת מערך array עם מספרים שונים מ-0 ושני מערכים נוספים שכל הערכים בהם הם 0.
3 המערכים שווים בדוגלם.
המתודה צריכה להכניס את כל האיברים הזוגיים ממערך array למערך arrEven ואת כל האי-זוגיים למערך arrOdd.
אם הוכנסו יותר מספרים אי-זוגיים מזוגיים, המתודה תחזיר 2.
אם הוכנסו יותר מספרים זוגיים מאי-זוגיים, המתודה תחזיר 1.
אחרת, המתודה תחזיר 0 אם הם שווים.
הצג פתרון
public static int evenOdd(int[] array, int[] arrEven, int[] arrOdd)
{
   int iEven = 0;
   int iOdd = 0;
   for (int i = 0;i < array.length;i++)
   {
      if (array[i] % 2 == 0)
      {
         arrEven[iEven] = array[i];
         iEven++;
      }
      else
      {
         arrOdd[iOdd] = array[i];
         iOdd++;
      }
   }
   if (iOdd > iEven)
      return 2;
   if (iEven > iOdd)
      return 1;
   
   return 0;
}

מבחן 4

כתבו מתודה:
public static void update_arr(int[] arr, int i, int x)
המקבלת arr מערך ממויין.
המתודה צריכה להוסיף מספר x כלשהו לערך הקיים במקום ה- i במערך.
לאחר הכנסת הערך על המערך להשאר ממויין.
כתבו את המתודה שמוסיפה את הערך במקום המבוקש וממיינת את המערך.
הצג פתרון
public static void update_arr(int[] arr, int i, int x)
{
   arr[i] += x;
   while (i < arr.length - 1)
   {
      if (arr[i] > arr[i + 1])
      {
         int temp = arr[i + 1];
         arr[i + 1] = arr[i];
         arr[i] = temp;
      }
      i++;
   }
}

מבחן 5

נתון הקטע קוד הבא:
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String str1 = str.substring(0, str.length() / 2);
String str2 = str.substring((str.length() + 1) / 2, str.length());
if (str1.equals(str2))
   System.out.println("Yes");
else
   System.out.println("No");
סעיף א
מה יודפס עבור המחרוזות הבאים?
test string
abcabc
teststest
סעיף ב
מה עושה התכנית?
הצג פתרון
עבור test string תדפיס No
עבור abcabc תדפיס Yes
עבור teststest תדפיס Yes

התכנית בודקת האם החצי הראשון של המחרוזת שווה לחצי השני שלה.

אתגר 1

  1. צור enum בשם MatrixType עם הערכים הבאים: ZERO,I,OTHER.
  2. צור מחלקה בשם SquareMatrix המייצגת מטריצות ריבועיות המכילה את המשתנה הבא: private int[][] matrix
  3. צור getter / setter עבור המשתנה הנ"ל, שימו לב כי ב-setter יש לוודא שהמטריצה שהתקבלה אכן ריבועית, אחרת יש לזרוק שגיאת IllegalArgumentException.
  4. כתוב בנאי המקבל מטריצה אשר קורא למתודת ה- setter שיצרתם עם המטריצה שהתקבלה.
  5. כתוב בנאי המקבל מערך ובודק האם המערך יכול לייצג מטריצה ריבועית (מערך יכול לייצג מטריצה ריבועית אם ניתן להוציא שורש לאורך המערך בלי שארית), במידה ולא ניתן יש לזרוק IllegalArgumentException, אחרת יש להפוך את המערך למטריצה בהתאם.
  6. כתוב בנאי שלא מקבל פרמטרים, הבנאי ייצור מטריצה בגודל אקראי (בין 2 ל-4) עם ערכים אקראיים (בין 20- ל- 20).
  7. כתוב בנאי המקבל פרמטר מסוג MatrixType, הבנאי ייצור מטריצה כך שאם ייתקבל ZERO כפרמטר תווצר מטריצת אפסים, אם ייתקבל I תווצר מטריצת היחידה, אחרת תווצר מטריצה עם ערכים אקראיים (כמו בסעיף 6, גודל המטריצה אקראי בכל 3 המקרים).
  8. דרוס את מתודת equals הבודקת האם 2 אובייקטים מסוג SquareMatrix שווים, הם שווים רק כאשר המטריצות שהם מכילים שווים בגודלן ובערכיהן.
  9. דרוס את מתודת hashCode המחזירה את גודל המטריצה + סכום איברייה, לדוגמה עבור מטריצה בגודל 2x2 עם סכום איברים 17, המתודה תחזיר 21.
  10. דרוס את מתודת toString המחזירה מחרוזת המייצגת את המטריצה בצורה הבאה:
    לדוגמה עבור המטריצה:
    1  2  3
    A= 6  5  4
    7  8  9
    תחזור המחרוזת:
    [  1  2  3  ]
    [  4  5  6  ]
    [  7  8  9  ]
  11. יישם את מתודת clone ממחלקת Cloneable המעתיקה את האובייקט הנוכחי.
  12. יישם את מתודת compareTo ממחלקת Comparable הבודקת האם אובייקט מסוג SquareMatrix שהתקבל כפרמטר קטן/שווה/גדול מהאובייקט הנוכחי.
    אם המטריצה של האובייקט הנוכחי קטנה מהמטריצה שהתקבלה כפרמטר המתודה תחזיר 1-, אחרת אם היא גדולה תחזיר 1, אחרת 0.
    ההשוואה תעשה קודם על גודלי המטריצות, אם הגדלים שווים, תעשה השוואה נוספת על סכום איברי המטריצות.
    לדוגמה מטריצה עם גודל 3x3 גדולה ממטריצה עם גודל 2x2, אבל אם הגדלים שווים אז מטריצה עם סכום איברים 17 תהיה גדולה ממטריצה עם סכום איברים 12.
  13. כתוב מתודה הבודקת האם המטריצה הנוכחית היא מטריצה היחידה או מטריצת האפס ומחזירה I או ZERO בהתאמה, אחרת תחזיר OTHER.
  14. כתוב מתודה המשחלפת את המטריצה הנוכחית ומחזירה את המטריצה המשוחלפת באובייקט חדש מסוג SquareMatrix. (אין לעשות שינויים למטריצה הקיימת)
  15. כתוב מתודה הבודקת האם SquareMatrix שהתקבלה כפרמטר מחזיקה במטריצה המשוחלפת של המטריצה באובייקט הנוכחי, ומחזירה אמת או שקר בהתאמה.
  16. כתוב מתודה המחברת בין 2 מטריצות ומחזירה את התוצאה באובייקט חדש מסוג SquareMatrix (אין לשנות את המטריצות הנתונות), במידה ולא ניתן לחבר בין 2 המטריצות יש לזרוק שגאית ArithmeticException.
  17. כמו סעיף קודם, רק הכפלת מטריצות.
  18. כמו סעיף קודם, רק כפל בסקלר. (שימו לב כאן אין צורך לזרוק שגיאה כלשהי).
  19. כתוב מתודה הממיינת את המטריצה של האובייקט הנוכחי כך שכל המספרים השליליים יעברו להתחלת המטריצה וכל המספרים החיוביים יעברו לסוף המטריצה.
  20. כתוב מתודה הבודקת האם מטריצה היא אלכסונית ומחזירה אמת/שקר בהתאם.
  21. כתוב מתודה המקבלת מספר שורה/עמודת התחלה start ומספר שורה/עמודת סיום end ומחזירה תת מטריצה של המטריצה הנוכחית בטווח בין start ל- end כולל.
    אם ה- start או ה- end לא חוקיים (קטנים מ-0 או גדולים מגודל המטריצה או ש-start גדול מ-end) יש לזרוק שגיאת ArrayIndexOutOfBoundsException.
    לדוגמה עבור המטריצה הבאה עם start=1 ו- end=2:
    1  2  3
    A= 6  5  4
    7  8  9
    תחזור התת מטריצה:
    B= 5  4
    7  8
הצג MatrixType
public enum MatrixType
{
   ZERO,
   I,
   OTHER
}
הצג SquareMatrix
import java.util.Random;

public class SquareMatrix implements Cloneable, Comparable<SquareMatrix>
{
   private int[][] matrix;

   public SquareMatrix(int[][] matrix)
   {
      setMatrix(matrix);
   }

   public SquareMatrix(int[] vector)
   {
      int vectorSize = vector.length;
      double squaredSize = Math.sqrt(vectorSize);
      double remainder = squaredSize - (int) squaredSize;
      if (remainder != 0)
         throw new IllegalArgumentException("The given vector doesnt result in a perfect square!");

      int matrixSize = (int) squaredSize;
      matrix = new int[matrixSize][matrixSize];

      int outerIndex = 0;
      int innerIndex = 0;
      for (int i = 0;i < vectorSize;i++)
      {
         matrix[outerIndex][innerIndex] = vector[i];

         innerIndex++;
         if (innerIndex == matrixSize)
         {
            innerIndex = 0;
            outerIndex++;
         }
      }
   }

   public SquareMatrix()
   {
      matrix = generateRandomMatrix();
   }

   public SquareMatrix(MatrixType type)
   {
      if (type == MatrixType.OTHER)
         matrix = generateRandomMatrix();
      else
      {
         Random random = new Random();
         int matrixSize = random.nextInt(3) + 2;

         matrix = new int[matrixSize][matrixSize];
         if (type == MatrixType.I)
            for (int i = 0;i < matrixSize;i++)
               matrix[i][i] = 1;
      }
   }

   public void setMatrix(int[][] matrix)
   {
      for (int[] row : matrix)
         if (matrix.length != row.length)
            throw new IllegalArgumentException("The given matrix isnt square!");

      this.matrix = matrix;
   }

   public int[][] getMatrix()
   {
      return matrix;
   }

   public MatrixType getMatrixType()
   {
      boolean isZero = true;
      boolean isOne = true;
      for (int i = 0;i < matrix.length && (isZero || isOne);i++)
      {
         for (int j = 0;j < matrix[i].length && (isZero || isOne);j++)
         {
            if (matrix[i][j] != 0)
            {
               if (i != j)
                  isOne = false;

               isZero = false;
            }
            if (i == j && matrix[i][j] != 1)
               isOne = false;
         }
      }
      if (isZero)
         return MatrixType.ZERO;
      if (isOne)
         return MatrixType.I;

      return MatrixType.OTHER;
   }

   public SquareMatrix transposeMatrix()
   {
      int[][] tempMatrix = new int[matrix.length][matrix.length];
      for (int i = 0;i < matrix.length;i++)
         for (int j = 0;j < matrix[i].length;j++)
            tempMatrix[j][i] = matrix[i][j];

      return new SquareMatrix(tempMatrix);
   }

   public boolean isTranspose(SquareMatrix other)
   {
      int[][] otherMatrix = other.matrix;
      if (otherMatrix.length != matrix.length)
         return false;

      for (int i = 0;i < matrix.length;i++)
         for (int j = 0;j < matrix[i].length;j++)
            if (otherMatrix[i][j] != matrix[j][i])
               return false;

      return true;
   }

   public SquareMatrix addMatrix(SquareMatrix other)
   {
      int[][] otherMatrix = other.matrix;
      if (otherMatrix.length != matrix.length)
         throw new ArithmeticException("Given matrixes sizes are different and therefore they cannot be added.");

      int[][] addedMatrix = new int[matrix.length][matrix.length];
      for (int i = 0;i < matrix.length;i++)
         for (int j = 0;j < matrix[i].length;j++)
            addedMatrix[i][j] = matrix[i][j] + otherMatrix[i][j];

      return new SquareMatrix(addedMatrix);
   }

   public SquareMatrix mulMatrix(SquareMatrix other)
   {
      int[][] otherMatrix = other.matrix;
      if (otherMatrix.length != matrix.length)
         throw new ArithmeticException("Given matrixes sizes are different and therefore they cannot be muled.");

      int[][] muledMatrix = new int[matrix.length][matrix.length];
      for (int i = 0;i < matrix.length;i++) // Rows from matrix 1.
         for (int j = 0;j < otherMatrix[i].length;j++) // Columns from matrix 2.
            for (int k = 0;k < matrix[i].length;k++) // Columns from matrix 1.
               muledMatrix[i][j] += matrix[i][k] * otherMatrix[k][j];

      return new SquareMatrix(muledMatrix);
   }

   public SquareMatrix mulByScalar(int scalar)
   {
      int[][] tempMatrix = new int[matrix.length][matrix.length];
      for (int i = 0;i < matrix.length;i++)
         for (int j = 0;j < matrix[i].length;j++)
            tempMatrix[i][j] = scalar * matrix[i][j];

      return new SquareMatrix(tempMatrix);
   }

   public void sort()
   {
      for (int i = 0;i < matrix.length;i++)
      {
         for (int j = 0;j < matrix[i].length;j++)
         {
            // Positive, need to move to end.
            if (matrix[i][j] >= 0)
            {
               boolean replaced = false;
               for (int x = matrix.length - 1;x >= 0 && !replaced;x--)
               {
                  for (int y = matrix[x].length - 1;y >= 0 && !replaced;y--)
                  {
                     if (x == i && y == j)
                        return; // If we got to the same indexes from start and end, that means no more numbers to sort, exit.

                     // Negative, need to move to start.
                     if (matrix[x][y] < 0)
                     {
                        int temp = matrix[x][y];
                        matrix[x][y] = matrix[i][j];
                        matrix[i][j] = temp;

                        replaced = true;
                     }
                  }
               }
            }
         }
      }
   }

   public boolean isDiagonal()
   {
      for (int i = 0;i < matrix.length;i++)
         for (int j = 0;j < matrix[i].length;j++)
            if (i != j && matrix[i][j] != 0)
               return false;

      return true;
   }

   public SquareMatrix subMatrix(int start, int end)
   {
      if (start < 0 || end < 0 || start >= matrix.length || end >= matrix.length || start > end)
         throw new ArrayIndexOutOfBoundsException("Indexes cannot be smaller than 0 or bigger than matrix length, also start cannot be bigger than end.");

      int newSize = end - start + 1;
      int[][] newMatrix = new int[newSize][newSize];
      for (int x = 0;x < newSize;x++)
         for (int y = 0;y < newSize;y++)
            newMatrix[x][y] = matrix[x + start][y + start];

      return new SquareMatrix(newMatrix);
   }

   @Override
   public boolean equals(Object other)
   {
      if (!(other instanceof SquareMatrix))
         return false;

      SquareMatrix otherMatrixObject = (SquareMatrix) other;
      int[][] otherMatrix = otherMatrixObject.matrix;
      if (matrix.length != otherMatrix.length)
         return false;

      for (int i = 0;i < matrix.length;i++)
         for (int j = 0;j < matrix[i].length;j++)
            if (matrix[i][j] != otherMatrix[i][j])
               return false;

      return true;
   }

   @Override
   public int hashCode()
   {
      return sumElements() + matrix.length * 2;
   }

   @Override
   public String toString()
   {
      String matrixString = "";
      for (int i = 0;i < matrix.length;i++)
      {
         matrixString += "[\t";
         for (int j = 0;j < matrix[i].length;j++)
            matrixString += matrix[i][j] + "\t";
         matrixString += "]\n";
      }

      return matrixString;
   }

   @Override
   public SquareMatrix clone()
   {
      return new SquareMatrix(matrix.clone());
   }

   @Override
   public int compareTo(SquareMatrix other)
   {
      int[][] otherMatrix = other.matrix;
      if (otherMatrix.length < matrix.length)
         return 1;
      if (otherMatrix.length > matrix.length)
         return -1;

      int otherSum = other.sumElements();
      int mySum = sumElements();
      if (otherSum < mySum)
         return 1;
      if (otherSum > mySum)
         return -1;

      return 0;
   }

   private int[][] generateRandomMatrix()
   {
      Random random = new Random();
      int matrixSize = random.nextInt(3) + 2;
      int[][] matrix = new int[matrixSize][matrixSize];
      for (int i = 0;i < matrixSize;i++)
         for (int j = 0;j < matrixSize;j++)
            matrix[i][j] = random.nextInt(41) - 20;

      return matrix;
   }

   private int sumElements()
   {
      int sum = 0;
      for (int i = 0;i < matrix.length;i++)
         for (int j = 0;j < matrix[i].length;j++)
            sum += matrix[i][j];

      return sum;
   }
}
הצג Main
public class Main
{
   public static void main(String[] args)
   {
      int[][] matrix =
      {
         {-1, 2, -3},
         {4, -5, 6},
         {7, -8, -9}
      };
      int[] vector = {2, 5, 3, 4};
      int[] vector2 = {9, 8, 7, 6, 5, 4, 3, 2, 1};
      
      SquareMatrix one = new SquareMatrix(matrix);
      SquareMatrix two = new SquareMatrix(vector);
      SquareMatrix three = new SquareMatrix();
      SquareMatrix four = new SquareMatrix(MatrixType.I);
      SquareMatrix five = new SquareMatrix(vector2);
      
      System.out.println("Matrix 1:");
      System.out.println(one);
      System.out.println("Matrix 2:");
      System.out.println(two);
      System.out.println("Matrix 3:");
      System.out.println(three);
      System.out.println("Matrix 4:");
      System.out.println(four);
      System.out.println("Matrix 5:");
      System.out.println(five);
      System.out.println("Matrix 4 type:");
      System.out.println(four.getMatrixType());
      System.out.println("Matrix 1 transpose:");
      System.out.println(one.transposeMatrix());
      System.out.println("Matrix 1 transpose to matrix 3?");
      System.out.println(one.isTranspose(three));
      System.out.println("Add of matrix 1 and 5:");
      System.out.println(one.addMatrix(five));
      System.out.println("Mul of matrix 1 and 5:");
      System.out.println(one.mulMatrix(five));
      System.out.println("Mul of matrix 1 by scalar 3:");
      System.out.println(one.mulByScalar(3));
      System.out.println("Sort of matrix 1:");
      one.sort();
      System.out.println(one);
      System.out.println("Is matrix 3 diagonal?");
      System.out.println(three.isDiagonal());
      System.out.println("Sub matrix of matrix 5 with i=1 and j=2 is:");
      System.out.println(five.subMatrix(1, 2));
      System.out.println("Is matrix 4 equals to its transpose?");
      System.out.println(four.equals(four.transposeMatrix()));
      System.out.println("Matrix 2 hashCode is:");
      System.out.println(two.hashCode());
      System.out.println("Matrix 2 clone is:");
      System.out.println(two.clone());
      switch (two.compareTo(four))
      {
         case 1:
            System.out.println("Matrix 2 is bigger than matrix 4.");
            break;
         case -1:
            System.out.println("Matrix 2 is smaller than matrix 4.");
            break;
         default:
            System.out.println("Matrix 2 is equal to matrix 4.");
            break;
      }
   }
}