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

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

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

4. Byte and Bit 1

5. Binary to Decimal 1 2^3 + 2^1 + 2^0 = 11 * 2^7 2^6 2^5 2^4 2^3 2^2 2^11 *
2^7
2^6
2^5
2^4
2^3
2^2
2^1
2^0
0*(2^7)
0*(2^6)
0*(2^5)
0*(2^4)
1*(2^3)
0*(2^2)
1*(2^1)
1*(2^0)
2^3 + 2^1 + 2^0 = 11

6. Decimal to Binary 25 1 [25%2=1] 12 [25/2=12] 0 [12%2=0] 6 [12/2=6]
0 [6%2=0]
3 [6/2=2]
1 [3%2=1]
1 [3/2=1]
1 [1%2=1]
0 [1/2=0]
Right
Left
25 (decimal) = (binary)

7. אינו פרימיטיבי vs. פרימיטיבי
משתנה שאינו פרימיטיבי
משתנה פרימיטיבי
הכתובת
הערך עצמו
מה נמצא בטבלת המשתנים
הכתובת מועתקת
הערך מועתק
השמה
השוואה בין כתובות
השוואה בין ערכים
(==) השוואה
עם טבלת משתנים על הלוח 7 7

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

9. public static void main(String[] args){ int lastInd = 10;
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; 9

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

11. end int sum int lastInd int i int 1 sum int sum int
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)
end
int 10
main
sum
int 1 55
lastInd
int 10 11 i
int 1
sum
int
sum
int 55

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

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

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

15. דוגמא להעברת פרמטרים מטיפוס לא פרימיטיבי:
public static void main(String[] arg){
int [] x={1,2,3};
printArray(x);
add5(x); }
public static void add5(int[] y) {
for (int i=0 ; i<y.length ;i=i+1)
y[i] = y[i]+5;
printArray (y); 1 2 3
/* output
1 2 3
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";
תו במיקום (אינדקס) מסוים
s2.charAt(0)
s2.charAt(1)
s2.charAt(5)
'a'
'b'
StringIndexOutOfBoundsException
:String index out of range
מבוא למדעי המחשב, בן גוריון תשע"א 19

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

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

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

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

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

25. טבלת ASCII

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

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

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

35. מבוא למדעי המחשב, בן גוריון תשע"א
public static void bubbleSort(int[] array){ int tmp; bbl=0 */ for (int bbl=0; bbl<array.length-1; bbl=bbl+1) { 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; } array is sorted */
מבוא למדעי המחשב, בן גוריון תשע"א 35

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

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

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

39. מיון מהיר (Quicksort) - דוגמא4 17 21 12 3 9 1 15 6 1 3 4 12 9 17 21 15 3 1 9 12 21 17 3 9 21 4 3 1 6 12 9 15 21 17 39 39

40. מיון מהיר – הקוד import java.util.Scanner; public class QuickSort {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("Enter number of elements to
sort:");
int n = sc.nextInt();
int[] arr = new int[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:"); }
//…. continued 40

41. מיון מהיר – הקוד (המשך)
public static void swap(int[] arr, int i, int j){ // swap arr[i] and arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp; }
public static void 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);
public static void printArray (int[] arr) {
for (int i=0; i<arr.length; i=i+1)
System.out.print (arr[i]+" ");
System.out.println(); 41

42. מיון מהיר – הקוד (המשך) public static void quicksort(int[] arr){
quicksort(arr, 0, arr.length-1); }
public static void 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. מיון מהיר – הקוד (המשך)
public static int 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 = האינדקס שלפיו מחלקים את המחרוזת
הרעיון של הרקורסיה
i = האינדקס שלפיו מחלקים את המחרוזת
i=0
i=1
““, “a” + “b” + “c” +”d”
d, “a” + “b” + “c”
output:
abcd
i=0
cd, “a” + “b”
cd, “a” + “b”
i=0
bcd, “a”
bcd, “a”
i=0
abcd,””
abcd,”” 45

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

47. הרעיון של הרקורסיה ““, “a” + “b” + “c” +”d” d, “a” + “b” + “c” output:
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:
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 50

51. קוד של דוגמה 3: הדפסת הפרמוטציות של מחרוזת
/** Function prints all the permutation of a string.
* Note: assume the string is a set (no duplicate
* chars) */
// Prints string acc followed by all permutations of
// string s1
public static void perms(String s1, String acc){
if (s1.length()==0)
System.out.println(acc);
else
for (int i=0; i<s1.length(); i=i+1)
perms(delete(s1, i), acc +s1.charAt(i)); }
אם יש זמן 51 51

52. פונק' עזר: delete // This function returns the string s with the i-th
// character removed
public static String delete(String s, int i){
// Assumes that i is a position in the string
return s.substring(0,i) s.substring(i+1,s.length()); } 52 52

53. דוגמה 4 - הרכבת סכום נתון ממשקולות
דוגמה 4 - הרכבת סכום נתון ממשקולות
בהינתן מערך משקולות אי-שליליים ומשקל נוסף (משקל סכום), נרצה לבדוק האם ניתן להרכיב מהמשקולות משקל השווה למשקל הסכום הנתון.
דוגמא לקלט: weights={1,7,9,3} Sum = 12 במקרה זה הפונקציה תחזיר true כי ניתן לחבר את המשקולות 9 ו 3 ולקבל את הסכום 12.
דוגמא לקלט: weights={1,7,9,3} Sum = 15 במקרה זה הפונקציה תחזיר false כי לא ניתן לחבר משקולות לקבלת הסכום 15. 53 53

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

55. תיאור פתרון - המשך
פתרון זה קל להציג כפונקציה רקורסיבית , boolean calcWeights(int[] weights, int i, int sum )
הפונקציה מחזירה ערך אמת האם ניתן להרכיב את הסכום מבין קבוצת המשקולות שבתת המערך.
הפרמטרים:
weights – מערך המשקולות
sum – הסכום שיש להרכיב מהמשקולות
i – פרמטר נוסף הנחוץ עבור הרקורסיה. i הוא אינדקס במערך weights ויסמן את האיבר הנוכחי במערך עליו מתבצעת הקריאה הרקורסיבית. 55 55

56. i=0 i=1 i=2 i=3 50: [10,20,30] 40: [20,30] 50: [20,30] 20: [30]
40: [30]
עבור כל משקולת יש את האפשרות לבחור אותה לסכום או לא לבחור אותה. עובדה זו באה לידי ביטוי בקריאה הרקורסיבית.
i=3
-10 []
20: []
10: []
40: [] 56 56

57. i=0 i=1 i=2 i=3 האם צריך לחשב ענף ימני? 50: [10,20,30] 40: [20,30] 50:
[30]
i=2
30:
[30]
עבור כל משקולת יש את האפשרות לבחור אותה לסכום או לא לבחור אותה. עובדה זו באה לידי ביטוי בקריאה הרקורסיבית.
i=3
50: [] 0: []
30: []
20: [] 57 57

58. קוד דוגמה 4: calcWeights
הארגומנט i נחוץ עבור הרקורסיה – אך אינו באמת חלק מהקלט של הבעיה. בקריאה הראשונה ל calcWeights ערכו הוא 0. לכן נוסיף פונקצית מעטפת עם חתימה פשוטה יותר.
// An envelope function, without i argument
// A simpler signature
public static boolean calcWeights(int[] weights, int sum) {
return calcWeights(weights , 0, sum); } 58

59. פתרון (המשך)
public static boolean calcWeights(int[] weights, int i, int sum) { boolean res = false; if (sum == 0) res = true; else if (i >= weights.length) res = false; else res = calcWeights(weights,i+1,sum-weights[i]) || calcWeights(weights, i + 1, sum); return res; } 59