תרגול חזרה לבוחן

1. תרגול חזרה לבוחן נמרוד מילוא

2. Decimal system: Ten digits: 0,1,2,3,…,9 3185 = 3*1000 + 1*100 + 8*10 + 5*1 = 3*10^3 + 1*10^2 + 8*10^1 + 5*10^0

3. Binary system: Two digits: 0,1 10110 1*(2^4) + 0*(2^3) + 1*(2^2) + 1*(2^1) + 0*(2^0)

4. Byte and Bit

5. Binary to Decimal 2^3 + 2^1 + 2^0 = 11

6. Decimal to Binary Right Left 25 (decimal) = 11001 (binary)

7. אינו פרימיטיבי vs. פרימיטיבי 7

8. מבנה של פונקציה • חתימה של פונקציה מורכבת משם הפונקציה ומרשימת טיפוסי הארגומנטים שהפונקציה מקבלת (מספר, סוגי טיפוסים וסדר) • לכל שתי פונקציות בתכנית חתימה שונה • הערך המוחזר וכן מאפיינים נוספים של פונקציה )כגון public ו- static ) אינם נכללים בחתימה של הפונקציה public staticint foo(int num){…} √ public staticint foo(int num1, double num2){…} √ public static int foo(double num){…} √ public static double foo(int num){…} X 8 public static <return type> <func name> (<arg1_type> <arg1>, <arg2_type> <arg2>, …) { <function body> }

9. publicclass Sum{ publicstaticvoid main(String[] args){ intlastInd = 10; int sum = sumNums(lastInd); System.out.println(“The sum of numbers from 1 to “+ lastInd+ “ = “ + sum); System.out.println(“The sum of numbers from 1 to “+ 8 + “ = “ + sumNums(8)); } // returns the sum of numbers from 1 to end publicstaticint sumNums(int end) { int sum = 0; for(int i = 1; i <= end; i = i+1) sum = sum + i; return sum; } } 9

10. Flow of previous func • בזמן קריאה לפונקציה: • השליטה של התכנית שומרת את המיקום הנוכחי שלה ועוברת לפונקציה. • נפתחת סביבה (טבלת משתנים) חדשה שבה מוגדרים הפרמטרים של הפונקציה והמשתנים שמוגדרים בתוך הפונקציה. • ההוראה return (או סיום הפונקציה במקרה של void) סוגרת את הסביבה ומחזירה את השליטה למקום בו היינו לפני הקריאה לפונקציה 10

11. public class Sum{ public static void main(String[] args){ int lastInd = 10; int sum = sumNums(lastInd); System.out.println(“The sum of numbers from 1 to “+ lastInd+ “ = “ + sum); System.out.println(“The sum of numbers from 1 to “+ 8 + “ = “ + sumNums(8)); } // returns the sum of numbers from 1 to end public static int sumNums(int end) { int sum = 0; for(int i = 1; i <= end; i = i+1) sum = sum + i; return sum; } } sumNums(10) main 1 55 11

12. העברת משתנים לפונקציה ב-Java מועברים בעת קריאה לפונקציה בעלת פרמטרים, הערכים הרשומים בטבלת המשתנים, בין אם מדובר בערך ממש או בכתובת: - אם הפרמטר הוא מטיפוס פרימיטיבי,מה שיעבור לפונקציה הוא הערך של המשתנה , ולכן הפונקציה לא תוכל לשנות את המשתנה המקורי. - אם הפרמטר הוא מטיפוס שאינו פרימיטיבי, כלומר מכיל מצביע לאובייקט (כגון מערך), אז הפונקציה מקבלת את הכתובת, ויכולה לשנות את האובייקט בזיכרון. 12

13. דוגמא להעברת פרמטרים מטיפוס פרימיטיבי: publicstaticvoid main(String[] args){ int x=8; System.out.println(x); add5(x); System.out.println (x); } publicstaticvoid add5(int x){ x = x+5; System.out.println (x); } 13

14. אם היינו רוצים לשנות את הערך של x מה היינו עושים? היינו צריכים לשנות את add5 כך שתחזיר ערך ואותו להכניס ל x : publicstaticvoid main(String[] args){ int x=8; System.out.println(x); x=add5(x); System.out.println(x); } publicstaticint add5(int x) { x = x+5; System.out.println(x); return x; } 14

15. דוגמא להעברת פרמטרים מטיפוס לא פרימיטיבי: publicstaticvoid main(String[] arg){ int [] x={1,2,3}; printArray(x); add5(x); printArray(x); } publicstaticvoid add5(int[] y) { for (int i=0 ; i<y.length ;i=i+1) y[i] = y[i]+5; printArray (y); } /*output 1 2 3 6 7 8 6 7 8 */ 15

16. מחרוזות הקדמה מחרוזת (String) היא מחלקה המייצגת טקסט (רצף של תווים). מיספור אינדקס התווים במחרוזת מתחיל מ 0 ונגמר באורך המחרוזת פחות 1. String "abcd" Index 0123 מבוא למדעי המחשב, בן גוריוןתשע"א 16

17. מחרוזות פעולות על מחרוזות: • הגדרה ואתחול String s1; String s2 = "abcd"; String s3 = null; String s4 = ""; String s5 = new String(); מבוא למדעי המחשב, בן גוריוןתשע"א 17

18. מחרוזות String s2 = "abcd"; String s3 = null; String s4 = ""; • אורך s2.length() 4 s3.length() NullPointerException s4.length() 0 מבוא למדעי המחשב, בן גוריוןתשע"א 18

19. מחרוזות String s2 = "abcd"; 'a' 'b' StringIndexOutOfBoundsException :String index out of range • תו במיקום (אינדקס) מסוים s2.charAt(0) s2.charAt(1) s2.charAt(5) מבוא למדעי המחשב, בן גוריוןתשע"א 19

20. מחרוזות String s2 = "abcd"; • תת-מחרוזת החל מאינדקס i ועד אינדקס j (לא כולל את j). s2.substring(1,3) "bc" s2.substring(1) "bcd" • השוואה בין תוכן שתי מחרוזות. התוצאה בוליאנית (true או false). s2.equals(s4) • שרשור+ s2+"efg" יוצר מחרוזת חדשה "abcdefg". המחרוזת s2 לא משתנה. מבוא למדעי המחשב, בן גוריוןתשע"א 20

21. מחרוזות דוגמה 1 – מחרוזת עם סדר תווים הפוך לפנינו פונקציה reverse המקבלת מחרוזת ומחזירה מחרוזת אחרת שבה התווים של reverse בסדר (מיקום) הפוך. הפונקציה הראשית מפעילה את reverse על המחרוזת "Hello" ומדפיסה את התוצאה (olleH). מבוא למדעי המחשב, בן גוריוןתשע"א 21

22. publicclass StringReverser { publicstatic String reverse( String data ) { String rev = new String(); for ( int j=data.length()-1; j>=0; j=j-1 ) rev = rev + data.charAt(j); return rev; } publicstaticvoid main ( String[] args ) { System.out.println( reverse( "Hello" ) ); } } מבוא למדעי המחשב, בן גוריוןתשע"א 22

23. מחרוזות דוגמה 2 – חיפוש של תת-מחרוזת במחרוזת לפנינו פונקציה isSubstring המקבלת שתי מחרוזת str ו- sub ובודקת האם sub מופיעה בתוך str כתת מחרוזת. הפונקציה מחזירה תשובה בוליאנית. למשל, המחרוזת "bc" מופיעה כתת-מחרוזת במחרוזת "abcd" באינדקס 1. String "abcd" Index 0123 נשווה את "bc" לתתי מחרוזות של "abcd" בעלות אורך זהה. מבוא למדעי המחשב, בן גוריוןתשע"א 23

24. publicstaticboolean isSubstring(String str,String sub){ boolean found = false; int lastInd = str.length()- sub.length(); for ( int i=0; i<=lastInd && !found; i=i+1) { String strSub = str.substring(i, i+sub.length()); if (strSub.equals(sub)) found = true; } return found; } מבוא למדעי המחשב, בן גוריוןתשע"א 24

25. טבלת ASCII

26. מחרוזות דוגמה 3 – צופן קיסר צופן (Cipher) הוא אלגוריתם הצפנה, המקבל טקסט קריא ומפתח - ומחזיר טקסט מוצפן. • צופן קיסר מבוסס על רעיון החלפת האותיות של הטקסט הקריא לשם יצירתו של הטקסט המוצפן: האלפבית המשמש להצפנה מוסט מעגלית במספר קבוע של 'מקומות' מן האלפבית הרגיל. • המפתח (key)= מספר מקומות ההסטה • לפי עדויות היסטוריות יוליוס קיסר עשה בשיטה זו שימוש נרחב. מבוא למדעי המחשב, בן גוריוןתשע"א 26

27. מחרוזות למשל, בהזזת של 3 מקומות המילהBABY תתורגם... למילה EDEB. מבוא למדעי המחשב, בן גוריוןתשע"א 27

28. publicstatic String encrypt(String str, int key) { String ans = ""; finalint NUM_OF_LETTERS_IN_ALPHABET = 26; for(int i = 0; i < str.length(); i=i+1) { int c = str.charAt(i); if ('A'<=c & c<='Z') { c = c - 'A'; c = ((c + key) % NUM_OF_LETTERS_IN_ALPHABET)+'A'; } elseif ('a'<=c & c<='z'){ c = c - 'a'; c = ((c + key) % NUM_OF_LETTERS_IN_ALPHABET)+'a'; } ans = ans + (char)c; } return ans; } מבוא למדעי המחשב, בן גוריוןתשע"א 28

29. מחרוזות כמה הערות: • בפקודה int c = str.charAt(i); מתרחשת המרת טיפוס אוטומאטית מ char ל int.כנ"ל בביטויים כמו'A'<=c ו-c - 'A'. • בפקודה ans = ans + (char)c; יש המרת טיפוס מפורשת מ int ל char. פעולה זו נחוצה מכיוון שנרצה לשרשר למחרוזת התוצאה ערך char ('A') ולא int (65). • הערכים המספריים של כל תו מסוכמים בטבלה (טבלת ASCII, תקן UNICODE). אין כלל צורך לזכור את הטבלה בע"פ. מבוא למדעי המחשב, בן גוריוןתשע"א 29

30. מחרוזות publicstaticvoid main(String[] args) { String str = "BEN GURION UNIVERSITY"; int key = 3; String encrypted = encrypt(str, key); System.out.println(encrypted);// "EHQ JXULRQ XQLYHUVLWB" String decrypted = decrypt(encrypted, key); System.out.println(decrypted);// "BEN GURION UNIVERSITY" } שאלה: מהי פעולת פענוח (decrypt) של צופן קיסר? תשובה: בדומה להצפנה, מלבד חיסור של מפתח ההזזה במקום חיבורו. מבוא למדעי המחשב, בן גוריוןתשע"א 30

31. מחרוזות פריצת צופן קיסר • בהינתן טקסט מוצפן כיצד ניתן לגלות את הטקסט הקריא מבלי לדעת את המפתח? • ניתן לנחש את המפתח בו הוצפן הטקסט באמצעות סטטיסטיקה על השכיחויות של אותיות האלף בית האנגלי בטקסט כלשהו. האות השכיחה ביותר בטקסט באנגלית היא E, שכיחותה 12%. • ב –quiz הבא תכתוב תוכנית המוצאת את האות השכיחה ביותר בטקסט נתון. סביר להניח שאות זו היא הקידוד של האות E וככה ניתן לחשב בכמה הזזנו את האותיות. מבוא למדעי המחשב, בן גוריוןתשע"א 31

32. מיונים מיון מערך (array sort) - הגדרת הבעיה: בהינתן מערך A של n מספרים שלמים חשב מערך ממוין של אותם מספרים. למשל: Input: 7 , 18, 28 , 4, 10 Output: 4, 7, 10 , 18 , 28 ישנם שיטות מיון רבות, כמו: מיון בחירה, מיון הכנסה ומיון בועות. מבוא למדעי המחשב, בן גוריוןתשע"א 32

33. מיונים מיון בועות (Bubble Sort) תיאור השיטה: תוך כדי המיון, החלק הימני של המערך כבר ממוין ("מעל פני הים") והחלק השמאלי של המערך אינו ממוין ("מתחת לפני הים"). בכל סבב, "בועה" מבעבעת עד שהיא מגיעה לפני הים. הבועה "סוחבת" איתה ערכים גדולים: בביעבוע הבועה, בכל שני תאים סמוכים בהן עוברת הבועה, מוחלפים הערכים אם הם לא בסדר המיון. מבוא למדעי המחשב, בן גוריוןתשע"א 33

34. מיונים 7 4 10 1828 4 7 10 1828 4 7 10 1828 4 7 10 1828 4 7 10 1828 וכן הלאה עד אשר המערך כולו מעל פני הים. http://www.youtube.com/watch?v=t_xkgcakREw&feature=related 18 7 28 4 10 7 18 28 4 10 7 18 28 4 10 7 18 4 28 10 7 18 4 10 28 7 18 4 10 28 7 18 4 10 28 7 4 18 10 28 7 4 10 1828 7 4 10 18 28 מבוא למדעי המחשב, בן גוריוןתשע"א 34

35. publicstaticvoid bubbleSort(int[] array){ int tmp; /* @pre: bbl=0 */ for (int bbl=0; bbl<array.length-1; bbl=bbl+1) { /* @inv: array[array.length-bbl.. array.length-1] is sorted * and all numbers array[array.length-bbl.. array.length-1] * are bigger than the numbers array[0 .. array.length-bbl-1] */ for (int index=0; index < array.length-1; index=index+1) { if (array[index] > array[index+1]) { tmp = array[index]; array[index] = array[index+1]; array[index+1] = tmp; } } } /* @post: array is sorted */ } מבוא למדעי המחשב, בן גוריוןתשע"א 35

36. מיונים שאלה: כמה השוואות מתבצעות? (array[index] > array[index+1]) תשובה: הלולאה הפנימית מבצעת n השוואות. הלולאה החיצונית מתבצעת n פעמים. סה"כ n2השוואות. שאלה: האם כל ההשואות נחוצות? תשובה: לא. • אם המערך כבר ממוין אין צורך להמשיך בלולאה. (לא צריך לבעבע עוד בועה) • השוואות הנעשות בחלק הממויין מיותרות. (פני הים יורדים, ויש להשוות איברים רק מתחת לפני הים) מבוא למדעי המחשב, בן גוריוןתשע"א 36

37. publicstaticvoid bubbleSort(int[] array){ boolean isSorted = false; int tmp; for (int bbl=0; !isSorted && bbl<array.length-1; bbl=bbl+1){ isSorted = true; for (int index=0; index<array.length-1-bbl; index=index+1){ if (array[index] > array[index+1]) { tmp = array[index]; array[index] = array[index+1]; array[index+1] = tmp; isSorted = false; } } } } מבוא למדעי המחשב, בן גוריוןתשע"א 37

38. מיון מהיר (Quick Sort) • חלוקת המערך לשני חלקים לפי ציר (pivot) שנבחר מחדש בכל שלב של הרקורסיה ומיון רקורסיבי של כל צד • הציר שנבחר הינו הערכה (ניחוש) של החציון של המספרים במערך • תזכורת: חציון הוא מדד למיקום המרכז של קבוצת נתונים מספריים. לדוגמא: החציון של קבוצת המספרים 1, 2, 22, 7, 19, 8, 16 הוא 8 • נבחר בקוד שלנו את האיבר הראשון כציר. 38

39. מיון מהיר (Quicksort) - דוגמא 39

40. מיון מהיר – הקוד import java.util.Scanner; publicclass QuickSort { publicstaticvoid main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("Enter number of elements to sort:"); int n = sc.nextInt(); int[] arr = newint[n]; // Initializes arr with random numbers // in [0..10*N) initRandomArray(arr); System.out.println("The input array:"); printArray(arr); quicksort(arr); System.out.println("The sorted array:"); printArray(arr); } //…. continued 40

41. מיון מהיר – הקוד (המשך) publicstaticvoid swap(int[] arr, int i, int j){ // swap arr[i] and arr[j] int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } publicstaticvoid initRandomArray(int[] arr){// shuffle the array arr int n = arr.length; for (int i = 0; i < n; i++) { arr[i] = (int) (Math.random() * 10 * n); } } publicstaticvoid printArray (int[] arr) { for (int i=0; i<arr.length; i=i+1) System.out.print (arr[i]+" "); System.out.println(); } 41

42. מיון מהיר – הקוד (המשך) publicstaticvoid quicksort(int[] arr){ quicksort(arr, 0, arr.length-1); } publicstaticvoid quicksort(int[] arr, int start, int end){ if (start<end){ int i = partition(arr, start, end); quicksort(arr, start, i-1); quicksort(arr, i+1, end); } } 42

43. מיון מהיר – הקוד (המשך) publicstaticint partition(int[] arr, int start, int end){ int pivot = arr[start]; int i = start; int j = end; while(i<j){ while(i<end && arr[i] <= pivot) i=i+1; while(arr[j] > pivot) j=j-1; if (i<j) swap(arr,i,j); } swap(arr,start,j); return j; } 43

44. הדפסת הפרמוטציות של מחרוזת • פרמוטציה של מחרוזת מוגדרת כמחרוזת המכילה את אותן אותיות, ייתכן שבשינוי סדר. נניח בדוגמה זו שכל האותיות שונות זו מזו. • למשל הפרמוטציות עבור המחרוזת bcd הם: • “bcd" • “bdc" • “cbd“ • “cdb” • “dbc“ • “dcb” 44

45. הרעיון של הרקורסיה i = האינדקס שלפיו מחלקים את המחרוזת ““, “a” + “b” + “c” +”d” i=1 i=0 d, “a” + “b” + “c” output: abcd cd, “a” + “b” i=0 cd, “a” + “b” bcd, “a” i=0 bcd, “a” i=0 abcd,”” abcd,”” 45

46. הרעיון של הרקורסיה ““, “a” + “b” + “c” +”d” i=1 d, “a” + “b” + “c” output: abcd cd, “a” + “b” i=1 i=0 cd, “a” + “b” i=0 bcd, “a” bcd, “a” i=0 abcd,”” abcd,”” 46

47. הרעיון של הרקורסיה ““, “a” + “b” + “c” +”d” d, “a” + “b” + “c” output: abcd i=1 i=2 cd, “a” + “b” cd, “a” + “b” “”, “a” + “b” + “d” + “c” i=0 c, “a” + “b” + “d” output: abdc bcd, “a” bcd, “a” i=0 abcd,”” abcd,”” 47

48. הרעיון של הרקורסיה ““, “a” + “b” + “c” +”d” d, “a” + “b” + “c” output: abcd i=1 cd, “a” + “b” cd, “a” + “b” i=1 “”, “a” + “b” + “d” + “c” i=1 c, “a” + “b” + “d” output: abdc bcd, “a” bcd, “a” i=0 abcd,”” abcd,”” bd, “a” + “c” bd, “a” + “c” d, “a” + “c” + “b” output: acbd “”, “a” + “c” + “b” + “d” 48

49. הרעיון של הרקורסיה ““, “a” + “b” + “c” +”d” d, “a” + “b” + “c” output: abcd cd, “a” + “b” cd, “a” + “b” “”, “a” + “b” + “d” + “c” i=3 c, “a” + “b” + “d” output: abdc bcd, “a” bcd, “a” abcd,”” abcd,”” bd, “a” + “c” bd, “a” + “c” d, “a” + “c” + “b” . . . bc, “a” + “d” output: acbd “”, “a” + “c” + “b” + “d” . . . 49

50. קוד של דוגמה 3: הדפסת הפרמוטציות של מחרוזת public static void perms(String s){ // We call the method perm(s,"") which prints // the empty string followed by each permutation // of s the empty string. perms(s,""); } 50