נושאים מחרוזות מיון (מיון בועות) רקורסיה תרגול מס' 5  נושאים מחרוזות מיון (מיון בועות) רקורסיה מבוא למדעי המחשב, בן גוריון תשע"א

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

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

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

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

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

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

מבוא למדעי המחשב, בן גוריון תשע"א public class StringReverser { public static 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; } public static void main ( String[] args ) { System.out.println( reverse( "Hello" ) ); מבוא למדעי המחשב, בן גוריון תשע"א

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

מבוא למדעי המחשב, בן גוריון תשע"א public static boolean 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; מבוא למדעי המחשב, בן גוריון תשע"א

טבלת ASCII

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

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

מבוא למדעי המחשב, בן גוריון תשע"א public static String encrypt(String str, int key) { String ans = ""; final int 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'; } else if ('a'<=c & c<='z'){ c = c - 'a'; c = ((c + key) % NUM_OF_LETTERS_IN_ALPHABET)+'a'; ans = ans + (char)c; return ans; מבוא למדעי המחשב, בן גוריון תשע"א

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

מבוא למדעי המחשב, בן גוריון תשע"א מחרוזות public static void 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) של צופן קיסר? תשובה: בדומה להצפנה, מלבד חיסור של מפתח ההזזה במקום חיבורו. מבוא למדעי המחשב, בן גוריון תשע"א

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

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

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

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

מבוא למדעי המחשב, בן גוריון תשע"א public static void 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 */ מבוא למדעי המחשב, בן גוריון תשע"א

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

מבוא למדעי המחשב, בן גוריון תשע"א public static void 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; } מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה פונקציה רקורסיבית היא פונקציה שקוראת לעצמה. פונקציה רקורסיבית מחושבת כמו כל פונקציה אחרת (העברת פרמטרים, משתנים לוקאליים, תחום חיים של המשתנים וכו'). מוטיבציה: ישנן בעיות רבות עבורן פתרון רקורסיבי פשוט יותר מפתרון איטרטיבי.   דוגמה 1: סכום המספרים הטבעיים נרצה לחשב את הסכום 1 + 2 + .... + n עבור n נתון. מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה אפשר בלולאה (פיתרון איטראטיבי): public static int sum(int n) { int ans = 0; for (int i = 1; i <= n; i = i + 1) ans = ans + i; return ans; } מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה ואפשר גם בדרך אחרת: נניח שיש לנו פונקציה אחרת בשם magic שמחזירה את הסכום 1 + 2+ ... + (n-1). אז sum יכולה להראות כך: public static int sum(int n) { int ans = magic(n)+ n; return ans; } אבל magic(n) מחזירה בדיוק מה ש-sum(n-1) הייתה מחזירה. מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה ניתן להגדיר נוסחה עבור החישוב: sum(n) = sum(n-1)+n … int ans = sum(n-1)+ n; מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה התוצאה היא פונקציה אחת שתקרא לעצמה: // @pre: n>=1 public static int sum(int n) { int ans; if (n == 1) // stop condition ans = 1; else // recursive call i=1..ni = i=1..(n-1)i + n ans = sum(n - 1) + n; return ans; } // @post: returns i=1..ni *** מעקב על דוגמת הרצה וציור טבלאות מעקב משתנים. מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה נכונות: טענה 1: התוכנית sum עוצרת לכל n ≥ 1. בכל קריאה רקורסיבית n קטן ב-1. בכל קריאה לפונקציה בודקים האם n == 1. מ-1 ו-2 האלגוריתם עוצר.   מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה טענה 2: לכל n המקיים 1≤n, האלגוריתם מחזיר את הערך 1 + 2 + … + n. מכיוון שבפתרון רקורסיבי בכל קריאה אנו מקטינים את הבעיה, אינדוקציה על גודל הקלט מתאימה מאוד להוכחת נכונות של אלגוריתמים רקורסיביים.   הוכחה באינדוקציה על n. מקרה בסיס: כאשר n=1, האלגוריתם מחזיר 1 כנדרש. הנחת האינדוקציה: נניח כי הטענה נכונה עבור 1≤k כלשהו. צעד האינדוקציה: כאשר האלגוריתם מופעל על קלט k+1, הקריאה הרקורסיבית היא על קלט k. על-פי הנחת האינדוקציה, הקריאה הרקורסיבית תחזיר את הסכום 1 + 2 + … + k. לכך מוסיף האלגוריתם את k+1 (הקלט של הקריאה הנוכחית) ומתקבל הסכום 1 + 2 + … + k + (k+1), אותו מחזיר האלגוריתם, כנדרש. מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה שלושת הכללים לבניית פונקציה רקורסיבית תנאי עצירה שניתן לענות עליו ללא קריאה רקורסיבית. אם לא נשים תנאי עצירה התוכנית עלולה להיכנס ללולאה אינסופית. קריאה רקורסיבית עם קלט הקרוב יותר לתנאי העצירה ("הקטנת הבעיה") אם לא מקטינים את הבעיה אז לא נגיע לתנאי העצירה, כלומר שוב תהיה לולאה אינסופית. שימוש בתוצאת הקריאה הרקורסיבית לחישוב התוצאה המוחזרת. (הנחת האינדוקציה). מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה דוגמה 2 – משולש פסקל: תזכורת: משולש פסקל הוא סידור של מספרים בצורת משולש, הנבנה באופן הבא: הקודקוד העליון של משולש זה מכיל את המספר 1, וכל מספר במשולש מהווה את סכום שני המספרים שנמצאים מעליו (המספרים שנמצאים על שוקי המשולש הם כולם 1). n 0 1 1 1 1 2 1 2 1 3 1 3 3 1 4 1 4 6 4 1 5 1 5 10 10 5 1 m 0 1 2 3 4 5 המספר ה-m בשורה ה- n, נותן את התשובה לשאלה "בכמה דרכים שונות אפשר לבחור m עצמים מתוך n עצמים?" (מקדם בינומי). מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה נכתוב פונקציה רקורסיבית pascal(int n, int m) שתחשב את המספר המופיע בשורה n ובעמודה m במשולש פסקל. תאור האלגוריתם תנאי עצירה: אם m הוא 0 נחזיר ערך 1. אם n=m נחזיר ערך 1. חוקיות הקלט: n ו- m הם שלמים אי-שליליים. אם m>n נציין שיש שגיאה בקלט. קריאות רקורסיביות עם קלט קטן יותר: קריאה אחת עם n-1 ו- m (המספר מעליו) קריאה שנייה עם n-1 ו m-1 (המספר מעל ומשמאל) שילוב התוצאות לקבלת תשובה: החזרת סכום של הערכים שהתקבלו משני הקריאות הרקורסיביות. מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה // Pascal number in row n and column m. public static int pascal(int n, int m){ int ans; if ((m<0) || (n<0) || (m>n)) ans = -1; else if ((m==0) || (n == m)) ans = 1; ans = pascal(n-1,m) + pascal(n-1,m-1); return ans; } מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה דוגמה 3 – זוגיים ואי זוגיים: רוצים לבדוק האם מספר טבעי n זוגי או אי זוגי באמצעות הפונקציות even ו- odd (ללא פעולות חלוקה ושארית) public static boolean even(int n) { boolean ans; if (n == 0) ans = true; else ans = odd(n - 1); return ans; } public static boolean odd(int n) { if (n == 1) ans = even(n - 1); מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה מה קורה כאשר מפעילים את even על מספר אי-זוגי גדול מ-0? ניסיון שני: public static boolean odd(int n) { boolean ans; if (n == 0) ans = false; else ans = even(n - 1); return ans; } רקורסיה הדדית: even קוראת לעצמה דרך odd, ו- odd קוראת לעצמה דרך even. מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה דוגמה 4 – פונקציה מסתורית*:  מצא מה התוכנית הבאה מחשבת.   public static int mystery(int a, int b) { int ans; if (b == 0) ans = 0; else if (b % 2 == 0) ans = mystery(a+a, b/2); ans = mystery(a+a, b/2) + a; return ans; } mystery(4,10) mystery(8,5) mystery(16,2)+8 mystery(32,1)+8 mystery(64,0)+8+32 0+40 40=4*10 תשובה: a*b. ניתן להדגים עם mystery(4,10) מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה מצא מה התוכנית הבאה עושה ?   public static int mystery(int a, int b) { int ans; if (b == 0) ans = 1; else if (b % 2 == 0) ans = mystery(a*a, b/2); ans = mystery(a*a, b/2) * a; return ans; } mystery(2,5) mystery(4,2)*2 mystery(16,1)*2 mystery(256,0)*32 1*32 32=2^5 תשובה: ab. ניתן להדגים עם mystery(2,5) מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א רקורסיה דוגמה 5 – הסדרה ההרמונית*: הסדרה ההרמונית היא הסדרה . הסבר מתחום המוסיקה: הסדרה קרויה כך בגלל הצלילים העיליים (אוברטונים, הרמוניות). אורכי המיתרים שיוצרים את הצלילים העיליים פרופורציונליים לסדרה אחת, חצי, שליש וכו'. כתוב תוכנית שתחשב את הסכום של n איברים מהטור ההרמוני. public static double harmony(int n) { double ans; if (n == 1) ans = 1.0; else ans = harmony(n-1) + 1.0/n; return ans; } מבוא למדעי המחשב, בן גוריון תשע"א

מבוא למדעי המחשב, בן גוריון תשע"א סיכום מחרוזות: length, charAt, substring, equals, + מיון בועות רקורסיה: הרכיבים: תנאי עצירה קריאות רקורסיביות עם קלט קרוב יותר לתנאי העצירה שילוב התוצאות של הקריאות הרקורסיביות לקבלת התוצאה. הוכחות נכונות: עצירה, נכונות החישוב (אנדוקציה) רקורסיה הדדית מבוא למדעי המחשב, בן גוריון תשע"א