Exams questions examples

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));

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

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

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

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

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

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

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

Exam example 4

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

השלם את הקטעים החסרים בפעולה 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 השלם את הקטעים החסרים בפעולה

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

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

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

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

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

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> בלי לממש אותן. • אם אתה משתמש בפעולות נוספות, עליך לממש אותן.

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

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

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 בלי לממש אותן. אם אתה משתמש בפעולות נוספות, עליך לממש ולתעד אותן.

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 סעיף א'

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 סעיף ב'

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) הן על אותו ישר אם ורק אם:

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

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

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

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

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

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 ) בלי לממש אותן.

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

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