1. Exams questions examples

2. Exam example 1 מה יהיה הפלט כתוצאה מזימון הפעולה what ?
( 10 נק' ) לפניך הפעולה הרקורסיבית what מקבלת כפרמטרים שני מספרים שלמים x ו - y .
מה יהיה הפלט כתוצאה מזימון הפעולה what ?
public static int what(int x, int y) {
if(x < 0)
return –what(-x, y);
if(y < 0)
return –what(x, -y);
if(x == 0 && y == 0)
return 0;
return 100 * what(x/10,y/10) + 10*(x%10) + y%10;
} // what
System.out.println(what(7,9));
System.out.println(what(-7,19));
System.out.println(what(17,-9));
System.out.println(what(-7,-19));

3. Exam example 1 - solution
what(-7,19) {
if(x<0) T
return –1* what(7,19);
if(y<0)
return –what(x, -y);
if(x==0 && y== 0)
return 0;
return 100*what(x/10,y/10) + 10*(x%10) + y%10;
} // what
-179
System.out.println(what(7,9));  79
System.out.println(what(-7,19));  -179
System.out.println(what(17,-9));  -1079
System.out.println(what(-7,-19));  179
what(7,19) {
if(x<0) F
return –what(-x,y);
if(y<0) F
return –what(x, -y);
if(x==0 && y== 0) F
return 0;
return 100*what(0,1) + 10*7+ 9;
} // what
179
what(0,1) {
if(x<0) F
return –what(-x,y);
if(y<0) F
return –what(x, -y);
if(x==0 && y== 0) F
return 0;
return 100*what(0,0) + 10*0+ 1;
} // what 1
what(0,0) {
if(x<0) F
return –what(-x,y);
if(y<0) F
return –what(x, -y);
if(x==0 && y== 0) T
return 0;
return 100*what(x/10,y/10) + 10*(x%10)+y%10;
} // what

4. Exam example 2
לפניך הפעולה הרקורסיבית kar מקבלת מספר שלם k , מערך arr שאיבריו מטיפוס שלם, ושני מספרים שלמים נוספים e, s ,כאשר s<=e.
( 20 נק' )
public static int kar(int k, int[ ] arr, int s, int e) {
if(s == e)
if(arr[s] > k)
return a[s];
else
return 0;
int p1 = kar(k, a, s, (s+e)/2);
int p2 = kar(k, a, ((s+e)/2) + 1, e);
return p1+p2;
} // outer if
} // kar

5. Exam example 2, cont. נתון מערך a : 2 8 4 14 5 18
א. ( 10 נק' ) לפניך זימון הפעולה kar :
System.out.println(kar( 6, a, 1, 5 ) (;
עקוב אחר ביצוע הפעולה בעבור המערך a והזימון הנתון, ורשום מה יהיה הפלט כתוצאה מזימון הפעולה.
ב. ( 10 נק' ) מה מבצעת הפעולה kar ?
הסבר את תשובתך.

6. Exam example 2 - solution
public static int kar(int k, int[ ] arr, int s, int e) {
if(s == e)
if(arr[s] > k)
return a[s];
else
return 0; {
int p1 = kar(k, a, s, (s+e)/2);
int p2 = kar(k, a, ((s+e)/2) + 1), e);
return p1+p2;
} // outer if
} //kar 18 5 14 4 8 2
סעיף ב. ( 10 נק' )
הפעולה מחזירה את סכום כל האיברי המערך בין המקומות s ו – e (כולל), הגדולים מ - k

7. Exam example 3
( 20 נק' ) כתוב פעולה public static char[ ] remStars(String sentence)
שמקבלת מחרוזת sentence שהיא משפט ומצמצמת כוכביות במשפט.
• אין להשאיר כוכביות לפני המילה הראשונה
• אין להשאיר כוכביות בסוף המשפט
• אסור שיהיו שתי כוכביות ברצף במשפט
הפעולה מחזירה מערך תווים ,כאשר כל איבר מהווה תו המתאים במחרוזת
המצומצמת.
דוגמה:
 הפעולה תהפוך את המחרוזת
“***this**is***an***example**of***sentence****” ל-
"this*is*an*example*of*sentence”

8. Exam example 3 ,cont. Formal parameter : String sentence
“***this**is***an***example**of***sentence****”
index
value t 1 h 2 i 3 s 4 * 5 6
Formal parameter : String sentence .
Returned value : reference to array of char 27 n 28 c 29 e

9. Exam example 3 - solution
public static char[ ] remStars(String str) { sentAr = new char[str.length()]; // help array for(int k = 0; k < str.length(); k++) sentArr[k] = str.charAt(k); int i = 0, j = 0, first = 0; // loop counters and help variable while( i < str.length() ) { if( sentArr[i] != ‘*‘ ) { first = 1; sentArr[j++] = sentArr[i++]; } // if else if(first != 0) { first = 0; i++; } // while char[ ] finArr = new char[j-1]; // returned array for(int k = 0; k < j -1; k++) finArr[k] = sentArr[k]; return finArr; } // remStars

10. Exam example 4

11. Exam example 4 - solution
public static int equalSum(int arr[ ]) {
int sumL = 0, sumR = 0;
for(int i = 0; i < arr.length; i++)
sumR += arr[i];
for(int j = 0; j < arr.length; j++)
sumR -= arr[j];
sumL += arr[j];
if(sumR == sumL)
return j;
} //for
return -1;
} // equalSum

12. השלם את הקטעים החסרים בפעולה
Exam example 5
( 20 נק' ) פעולה public static String find(String string) מקבלת כפרמטר מחרוזת string ומחפשת בה את תת-המחרוזת הארוכה ביותר המורכבת מאותיות בסדר אלפבית. הפונקציה מחזירה העתק של תת-המחרוזת הזאת. בתכנית הבאה הפלט הוא: ghijkl public static void main(String[] args) { String str = "cabcefghabcdeghijklabc"; String longstr = find(str); System.out.println(longstr); } // main
השלם את הקטעים החסרים בפעולה

13. public static String find(String string) { char start, end;
public static String find(String string) { char start, end; int s1= 0,s2 = 0,i=0, max = 0, ji = 0,jo = 0; boolean flag=false; String outString; while (??? 1 ???) { s1= i; start = string.charAt(i); end = (??? 2 ???) while (??? 3 ???) { flag=true; start = end; if(??? 4 ???) (??? 5 ???) end = string.charAt(i+1); } // inner while if(flag) { (??? 6 ???) if(s2-s1 > max) { max = (??? 7 ???) ji = s1; jo = s2; (??? 8 ???) } // inner if } // outer if (??? 9 ???) } // outer while if(jo==string.length() - 1) outString=string.substring(ji,(jo+1)); else (??? 10 ???) return outString; } // find
public static String find(String string) {
char start, end;
int s1=0,s2=0,i=0, max=0, ji = 0,jo = 0;
boolean flag=false; String outString;
while(i<string.length() - 1) {
s1= i;
start = string.charAt(i);
end = string.charAt(i+1);
while( start + 1 == end ) {
flag=true;
start = end;
if( i < string.length() - 2 )
i++;
} // inner while
if(flag) {
s2 = i+1;
if(s2 - s1 > max) {
max = s2 - s1;
ji = s1;
jo = s2;
flag = false;
} // inner if
} // outer if
} // outer while
if(jo == string.length() - 1)
outString = string.substring(ji,(jo+1));
else
outString = string.substring(ji,jo);
return outString; } // find

14. Exam example 6
רשימה L תיקרא רשימה משולשת אם היא מקיימת את התנאים האלה:
הרשימה אינה ריקה.
מספר האיברים בה מתחלק ב- 3 בלי שארית.
האיברים בשליש הראשון של הרשימה מכילים את אותם ערכים שמכילים האיברים בשליש השני של הרשימה ואותם ערכים שמכילים האיברים בשליש השלישי של הרשימה.
הערכים מסודרים באותו סדר בכל אחד מהשלישים.
לדוגמה: הרשימה L5 שלפניך היא רשימה משולשת באורך 9.
כתוב פעולה public static boolean isTripleList(List <Integer> list) שתקבל רשימה list
של מספרים שלמים כפרמטר בבודקת אם רשימה list היא רשימה משולשת.
אפשר להשתמש בפעולות של המחלקות Node<T> ,List<T> בלי לממש אותן.

15. Exam example 6 – help methods
--- פעולה המחזירה את המספר האיברים ברשימה --- //
public static int listSize(List <Integer> lst) {
int count = 0;
Node<Integer> pos = lst.getFirst();
while(pos != null)
count++;
pos = pos.getNext();
} // while
return count;
} // listSize
אם אתה משתמש בפעולות נוספות חובה עליך לממש ולתעד אותן.
--- פעולה המקבלת רשימה lst ומספר שלם n--- //
--- ומחזירה הפנייה לאיבר שנמצא במקום n ברשימה --- //
public static Node<Integer> nPlace(List <Integer> lst, int n) {
Node<Integer> pos = lst.getFirst();
while(pos != null && n > 0)
n--;
pos = pos.getNext();
} // while
return pos;
} // nPlace

16. Example 6 – isTripleList method
public static boolean isTripleList(List<Integer> list) { int num = listSize(list) / 3; if( num == 0 && num %3 != 0) return false; Node<Integer> pos1 = lst.getFirst(); Node<Integer> pos2 = nPlace(list, num); Node<Integer> pos3 = nPlace(list, 2*num); while (pos3 != null) if(pos1.getData() != pos2.geData() || pos1.getData() != pos3.getData()) pos1 = pos1.getNext(); pos2 = pos2.getNext(); pos3 = pos3.getNext(); } // while return true; } // isTripleList

17. Exam example 7
רשימה L מכילה מספרים שלמים שונים זה מזה וממוינים בסדר עולה. רשימת הטווחים של L היא רשימה חדשה שנבנית באופן הזה: • בעבור כל רצף של מספרים עוקבים ב- L יהיה ברשימת הטווחים איבר אחד שמכיל שני מספרים. מספר אחד הוא המספר הקטן ברצף, והמספר השני הוא המספר הגדול ברצף. • רצף יכול להיות באורך 1 או יותר .אם הרצף הוא באורך 1, הוא מיוצג ברשימת הטווחים על ידי איבר ששני המספרים בו שווים. לדוגמה, בעבור הרשיצה L שלפניך : רשימת הטווחים של L ,רשימה חדשה Lr ,תהיה : כתוב פעולה public static List<RangeNode> CreateRangeList(List<Integer> sourceList) שמקבלת כפרמטר רשימה לא ריקה של מספרים שלמים שונים זה מזה וממוינים בסדר עולה, ותחזיר את רשימת הטווחים שלה.

18. Exam example 7,cont.
לפניך תרשים חלקי UML של המכלקה RangeNode, המייצגת איבר ברשימת הטווחים:
RangeNode
private int from
private int to
public RangeNode(int from, int to)
• הנח שלכל אחת מהתכונות במחלקה RangeNode יש פעולות get ו – set .
אפשר להשתמש בפעולות אלה וגם בפעולה הבונה של המחלקה RangeNode
בלי לממש אותן.
• אפשר להשתמש בפעולות של המחלקות Node<T> ו – List<T> בלי לממש אותן.
• אם אתה משתמש בפעולות נוספות, עליך לממש אותן.

19. Exam example 7 - solution
public static List<RangeNode> createRangeList(List<Integer> sourceList) {
int from,to; // help variables
List<RangeNode> rangeList = new List<RangeNode>(); // List class constructor
Node<Integer> pos1 = sourceList.getFirst();
Node<RangeNode> pos2 = rangeList.getFirst();
while( pos1 != null ) {
from = pos1.getData();
to = from;
pos1 = pos1.getNext();
while( pos1 != null && pos1.getData() – 1 == to )
to = pos1.getData();
} // inner while
RangeNode rn = new RangeNode(from, to); // RangeNode class constructor
pos2 = rangeList.insert(pos2,rn);
} // outer while
return rangeList;
} // createRangeList

20. Exam example 8
קבוצה ממשית ( RealSet ) היא אוסף של מספרים ממשים בלי חזרות ובלי סדר מחייב של הערכים. לפניך עוסף חלקי של הפעלות במחלקה RealSet :
שם הפעולה
תיאור
RealSet()
הפעולה בונה קבוצה ממשית ריקה.
int size()
הפעולה מחזירה את מסםר האיברים בקבוצה.
void insert(double num)
הפעולה מוסיפה לקבוצה את המספר num אם הוא לא נמצא בקבוצה.
void remove(double num)
הפעולה מוחקת את המספר num אם הוא נמצא בקבוצה.
double findBiggest()
הפעלה מחזירה את המספר הגדול בקבוצה.
הנח שהקבוצה אינה ריקה.

21. Exam example 8 ,cont.
א. ( 10 נק' ) כתוב פעולה public static RealSet copySet(RealSet rs) שתקבל קבוצה ממשית rs לא ריקה, ותחזיר קבוצה ממשית חדשה שתכיל את כל האיברים שיש ב- rs . לאחר סיום ביצוע הפעולה, על rs להכיל את כל המספרים שהיא הכילה לפני ביצוע הפעולה, ורק אותם. ב. ( 10 נק' ) כתוב פעולה public static RealSet buidNegNum(RealSet rs) שתקבל קבוצה ממשית rs לא ריקה, ותחזיר קבוצה ממשית שתכיל רק את המספרים השליליים שנמצאים ב- rs. עליך להשתמש בפעולה copySet(RealSet rs) שכתבת בסעיף א. הערה: אתה יכול להשתמש בפעולות המחלקה RealSet בלי לממש אותן. אם אתה משתמש בפעולות נוספות, עליך לממש ולתעד אותן.

22. Exam example 8 - solution
public static RealSet copySet(RealSet rs) { RealSet rs1 = new RealSet(); RealSet rs2 = new RealSet(); int n = rs.size(); for( int i = 0; i < n; i++ ) double x = rs.findBiggest(); rs1.insert(x); rs2.insert(x); rs.remove(x); } // for for( int i = 0; i < n; i++ ) { double x = rs1.findBiggest(); rs.insert(x); rs1.remove(x); return rs2; } // copySet
סעיף א'

23. Exam example 8 - solution
public static RealSet buidNegNum(RealSet rs) { RealSet rs1 = copySet(rs); double x = rs1.findBiggest(); while ( rs1.size() > 0 && x > 0 ) rs1.remove(x); x = rs.findBiggest(); } // while return rs1; } // buidNegNum
סעיף ב'

24. Exam example 9 לפניך UML של המחלקה Point :
private double x
private double y
Point(double x, double y)
double getX( )
double getY( )
void setX(double x)
void setY(double y)
String toString( )
א. ( 10 נק' ) כתבו פעולה המקבלת כפרמטרים 3 נקודות ובודקת אם הן על אותו הישר.
חתימת הפעולה צריכה להיות: 
public static boolean inLine(Point p1, Point p2, Point p3)
תזכורת: הנקודות (x1,y1), (x2,y2), (x3,y3) הן על אותו ישר אם ורק אם:

25. Exam example 9, cont.
ב. (10 נק' ) כתבו פעולה המקבלת כפרמטר מערך של נקודות ומחזירה true אם במערך
קיימות 3 נקודות ששייכות לאותו הישר, אחרת הפונקציה תחזיר false.
חתימת הפעולה צריכה להיות:
public static boolean testLine(Point[ ] points)
הערות:
אפשר להשתמש בפעולות של המחלקה Point בלי לממש אותן.
חובה להשתמש בפעולה inLine של סעיף א' (אפילו אם לא כתבתם).

26. Exam example 9, cont.
סעיף א'
public static boolean inLine(Point p1, Point p2, Point p3) {
  double w1,w2;
w1 = (p1.getX() – p2.getX()) * (p1.getY() – p3.getY());
w2 = (p1.getX() – p3.getX()) * (p1.getY() – p2.getY());
return w1 == w2; 
} // inLine

27. Exam example 9 - solution
סעיף ב'
public static boolean testLine(Point[ ] points) {
for (int i = 0; i < points.length - 2; i++)
for(int j = i+1;j < points.length - 1; j++)
for(int k = j + 1;k < points.length; k++)
if( inLine(points[i], points[j], points[k] )
return true;
return false;
} // testLine

28. Exam example 10 כתובו את הפעולה הבאה:
public static boolean isListCont( List<Integer> lst1, List<Integer> lst2)
 הפעולה מקבלת כפרמטרים 2 הפניות לרשימות של מספרים שלמים lst1 ו – lst2.
הפעולה מחזירה true אם כל האיברים ברשימה lst1 נמצאים ברשימה lst2 ו-false אחרת.
 לדוגמה:
 עבור הרשימות הבאות הפעולה isListCont מחזירה true.
lst1: > 4 -> 1 -> 8 -> null
lst2: > 5 -> 6 -> 8 -> 8 -> 4 -> 15 -> 1 -> null
עבור הרשימות הבאות הפעולה isListCont מחזירה false כי הערך 1 לא מופיע ברשימה lst2.
lst1: 5 -> 4 -> 1 -> 8 -> null
lst2: 19 -> 5 -> 6 -> 8 -> 8 -> 4 -> 15 -> 33 -> null
הערה: מותר להשתמש - בלי לממש אותן - בפעולות של המחלקות List ו - Node שנלמדו. 

29. Exam example 10 - solution
public static boolean isListCont(List<Integer> lst1, List<Integer> lst2) { Node<Integer> node1 = lst1.getFirst(); while(node1 != null) boolean found = false; Node<Integer> node2 = lst2.getFirst(); while((node2 != null) && (! found)) if(node1.getData() == node2.getData()) found = true; node2 = node2.getNext(); } // inner while if( ! found) return false; node1 = node1.getNext(); } // outer while return true; } // isListCont

30. Exam example 11 לפניך מחלקה Book :
לפניך מחלקה Book :
כל ספר במחלקה מוגדר ע"י התכונות הבאות - שם הסופר (writer), מספר העמודים (pages) ומחיר (price).
public class Book {
private double price;
private int pages;
private String writer;
} // Book
כתוב פעולה public static Book[ ] nameWriterSort(List<Book> books)
המקבלת רשימת ספרים של המחברים Kipling ו – Swift ומחזירה מערך בו ספריו של Kipling יופיעו לפני ספריו של Swift. כלומר בתחילת המערך יופיעו כל ספריו של Kipling בסדר בו הם הופיעו ברשימה המקורית ולאחר מכן יופיעו כל ספריו של Swift בסדר בו הם הופיעו ברשימה המקורית.
הערה: אפשר להשתמש בכול הפעולות של מחלקות Node, String, List וגם בפעולות
של מחלקה Book (פעולה בונה, פעולות SET ו - GET ) בלי לממש אותן.

31. Exam example 11 - solution
public static Book[ ] nameWriterSort(List<Book> books) { int numK = 0; // number of Kipling's books int numS = 0; // number of Swift's books for( Node<Book> curr = books.getFirst(); curr != null; curr = curr.getNext()) if(curr.getData().getWriter().compareTo("Kipling") = = 0) numK++; if(curr.getData().getWriter().compareTo("Swift") = = 0) numS++; } // for Book [ ] arr = new Book [numK + numS]; // output array int indK = 0; // Kipling's books array index int indS = numS - 1; // Swift's books array index Node<Book> temp = books.getFirst(); while(temp != null) if(temp.getData().getWriter().compareTo("Kipling") = = 0) arr[indK++] = temp.getData(); else arr[indS++] = temp.getData(); return arr; } // nameWriterSort

32. Goodbye and Good luck !
I wish you all the very best for your exams ( not only Java ), my students !