שאלות מבחינות קודמות

1. שאלות מבחינות קודמות יואב ציבין

2. שאלה 4, 25 נק' (3.2.00) • כתבו פונקציה המקבלת מערך וגודלו ומחזירה TRUE אם יש במערך שני איברים שווים בערכם (מחזירה FALSE אחרת). השתדלו למצוא פתרון יעיל מבחינת סיבוכיות זמן. typedef enum {FALSE,TRUE} bool; bool Yesh1(int ar[], int len) { int i; merge_sort(ar, len); for (i=1; i<len; i++) if (a[i-1]==a[i]) return TRUE; return FALSE; }

3. סעיף ב • ריבוע במערך דו-מימדי הוא ארבעה תאים סמוכים בצורת ריבוע. • כתבו פונקציה המקבלת טבלה (table) ומחזירה TRUE אם יש בטבלה לפחות שני ריבועים שונים בעלי אותו סכום של איבריהם. ריבועים שונים יכולים להיות חופפים חלקית. • דוגמא: בכל אחד משלושת הריבועים סכום האיברים הוא 10. typedef int table[N][M];

4. המשך סעיף ב bool Yesh2(table t) { int helper[N-1][M-1]; int i,j; for (i=0; i<N-1; i++) for (j=0; j<N-1; j++) helper[i][j] = t[i][j]+ t[i+1][j]+ t[i][j+1]+ t[i+1][j+1]; return Yesh1(&helper[0][0], (N-1)*(M-1) ); }

5. מבחן 08/02/01 (15 נקודות) נתון: מערך שלמים a, את אורכו n ומספר שלם m. ידוע שהמערך a ממוין בסדר לא יורד. כתוב פונקציה שעונה על השאלה הבאה: האם המערך a מכיל את כל האיברים של הקבוצה דרישות סיבוכיות: זמן O(n), זכרון נוסף O(1). int f4(int a[], int n, int m) { int i=0, j=1; while (i<n && j<=m){ if(a[i] > j*j) return 0; if(a[i] == j*j) { ++i; ++j; } else ++i; } return (j>m); }

6. מבחן 09/07/01 (15 נקודות) a הוא מערך שלמים באורך n. ידוע ש- n אי-זוגי. א. (8 נק') השלימו את הקודהרקורסיביהבא כך שידפיס את אברי a בסדר הבא משמאל לימין: a[0], a[n-1], a[1], a[n-2], …, a[(n-1)/2] בכל מלבן יש לכתוב פסוק פשוט (simple statement) אחד בלבד. void extreme_to_middle(int a[], int n) if (n== ){ return; } return; } ב. (7 נק') השלימו את הקוד הרקורסיביהבא כך שידפיס את אברי a בסדר הבא משמאל לימין: a[(n-1)/2], a[(n-1)/2 - 1], a[(n-1)/2 + 1], …, a[0], a[n-1] בכל מלבן יש לכתוב פסוק פשוט(simple statement) אחד בלבד. void middle_to_extreme(int a[], int n) if (n== ){ return; } return; }

7. שאלה 4, 25 נק' (28.2.00) • מערך A בגודל size של מספרים שלמים חיוביים הינו מאוזן אם קיים אינדקס 0 ≤ i < size-1 כך שסכום כל האיברים מ A[0] עד ל A[i] שווה לסכום האיברים מ A[i+1] עד A[size-1]. • כלומר • האינדקס i נקרא אינדקס האיזון. • כתוב פונקציה המקבלת מערך A של מס' שלמים חיוביים וגודלו ומחזירה את אינדקס האיזון אם המערך מאוזן ו -1 אחרת.

8. סעיף ב • מערך A של מספרים חיוביים הוא -1מאוזן אם הוא מאוזן. • מערך A של מספרים חיוביים הוא k-מאוזן (לכל k>1) אם הוא מאוזן וגם המערך מ A[0] עד A[i] (k-1)-מאוזן וגם המערך מ A[i+1] עד A[size-1](k-1)-מאוזן (כאשרi הוא אינדקס האיזון). |________________| |___________________________| |__________| |_______________| -1מאוזן -1 מאוזן -1מאוזן -1מאוזן |_____________________________________________| |___________________________| -2מאוזן -2מאוזן דוגמא למערך -3מאוזן

9. סעיף ב • כתוב פונקציה רקורסיבית שמקבלת מערך A של מס' חיוביים, גודלו ומס' שלם k, הפונקציה מחזירה 1 אם A הוא k-מאוזן, ו- 0 אחרת.

11. שאלות שפתרתי בהרצאה

12. מבחן 08/02/01 (13 נקודות) ידוע ש a[0] זוגי וש a[n-1] הינו אי-זוגי. כתוב פונקציה שמחזירה אינדקס (כלשהו) iהמקיים: ש a[i] זוגי ושa[i +1] הינו אי-זוגי. int f(int a[ ], int n) { int low, mid, high; low = 0; high = n – 1; while( low < high-1 ) { mid = (low + high) / 2; if (a[mid] % 2 == 0) low = mid; else high = mid; } returnlow; }

13. #include <stdio.h> int x=1;  int blabla(int *p1, int *p2){ int y = 300; *p2 = 400; x = x + 300; return (*p1 + 100); } ששאלה ממבחן08/02/01 (10 נקודות) int main(void){ int y=100; x = 200; y = blabla(&x, &y); printf(“x = %d, y = %d\n”, x, y); x = 300; y = 200; blabla(&y, &x); printf(“x = %d, y = %d\n”, x, y); x = 500; printf(“blabla(&x,&x)=%d.\n”, blabla(&x, &x)); return 0; } x=500 , y=600 x=700 , y=200 blabla(&x,&x)=800

14. מבחן 29/01/03 (8 נקודות) מהי סיבוכיות הזמן והמקום שלf ? void helper(int n, int m){int i;if(n <= 1) {for(i = 0; i < m; i++)printf("%d", i);return;}helper(n/3, m*3);} void f(int n){helper(n, 1);} מקוםO(log n) זמן O(n) helper(n/3, m*3); helper(n/3, m*3); helper(n/3, m*3); מקוםO(log n) זמן O(n2)

15. מבחן 08/07/02 (16 נקודות) • נתון מערך a באורך N הממויין בסדר עולה ממש. • נתון מערך דו-מימדי b בגודל NxN שכל אחת מהשורות בו ממויינות בסדר עולה ממש. • השלימו את הפונקציה הבאה כך שתחזיר את אינדקס השורה שמספר האיברים בה המופיעים גם במערך a הוא מקסימלי (במידה ויש מספר שורות כאלו, יש להחזיר אינדקס כלשהו של אחת מהן). • סיבוכיות: זמן O(N2), זכרון נוסף O(1) #define N 10 int f(int a[N], int b[N][N]) { … } בדומה למיזוג

16. int f(int n) { int sum=1,i; if (n==1) return 1; for (i=1; i<n; ++i) sum += f(i) * f(n-i); return sum; } מבחן 08/02/01 (12 נקודות) הפונקציה מוגדרת באופן הבא: 1) 2)ולכל n>1 שלם

17. מבחן 08/07/02 (8 נקודות) • מגדלי הנוי עם צבעים • כרגיל, אסוק שחישוק גדול יונח על גבי חישוק קטן. n=2 n=2

18. פתרון void colored_hanoi(int n, tower_t from, tower_t to_1, tower_t to_2, tower_t via) { if (n== 0) return; hanoi(2*n-2, from, via, to_1); move(from, to_1); move(from, to_2) colored_hanoi(n-1, via, to_1, to_2, from); }

19. שאלה 4, 20 נק' (2.10.2002) כל השאלות מבחינות קודמות מופיעות באתר שלי

20. המשך

21. המשך 2

22. חורף תשס"א – מועד ב, שאלה 4, 16 נק' • השלם את המימוש הרקוסיבי של pivot • הפונקציה מחזירה את מספר האיברים הקטנים מ- x • סיבוכיות זמן O(n) int pivot(int a[], int n, int x) { if ( n==0 ) return 0; if ( a[0] < x ) return 1 + pivot(a+1,n-1,x); if ( a[n-1] >= x ) return pivot(a,n-1,x); swap( &a[0], &a[n-1] ); return 1+pivot(a+1, n-2, x); }

23. שאלה 1, 20 נק' (29.1.03)

24. מבחן 02/10/02 (15 נקודות) #define ALPHABET 4#define N 5 void vectors(int word[], int index, int used[]) { int i; if(index == N*ALPHABET) { print_array(word); return; } for(i = 0; i < ALPHABET; i++) { if(used[i] < N){ word[index] = i; used[i]++; permutations(word, index + 1, used); used[i]--; } } } כתבו תוכנית המדפיסה את כל הוקטורים באורך N*ALPHABET שבהם כל אחת מהספרות 0ALPHABET-1מופיעה בדיוקN פעמים. הפעלה: int a[N*ALPHABET];int used[ALPHABET]={0};permutations(a,0,used);

25. מבחן 28/02/00 (20 נקודות) • מטרת השאלה לכתוב תכנית שמחשבת מסלול במבוך • משבצת ההתחלה היא השמאלית-עליונה • משבצת הסוף היא הימנית-תחתונה • כתבו את ההכרזה והאתחול של מערך דו-ממדי שמייצג את הטבלה שבדוגמא. (3 נק') #define N 3#define M 6 int main() {int maze[N][M] = { {0,0,0,1,1,0}, {0,0,0,1,1,0}, {0,0,0,1,1,0} }; findPath(maze, 0, 0); return 0;}

26. מבחן 28/02/00 המשך • int findPath(int maze[N][M], int x, int y) { • int success=FALSE; • if (x < 0 || x >= N || y < 0 || y >= M) return FALSE; • if (maze[x][y] == 1) return FALSE; • maze[x][y]=1; • if ( (x==N–1 && y==M–1) || • findPath(maze, x , y – 1) || • findPath(maze, x - 1, y ) || • findPath(maze, x + 1, y ) || • findPath(maze, x , y + 1) ){ • printf(“%d, %d\n”, x, y); • success = TRUE; • { • maze[x][y]=0; • return success; • } מה ייקרה אם נוריד שורה זו (3 נקודות) מה הפלט (3 נקודות) מה ייקרה אם נוריד שורה זו (3 נקודות)

27. שאלה 1, 20 נק' (3.2.00) • השלימו את שלד התכנית הנתון למטה. התכנית מקבלת כקלט (מהקלט הסטנדרטי) מספר לא ידוע של מספרים רציונליים חיוביים ומדפיסה את מכפלת כולם כשבר מצומצם. • המספר 0/1 מסמן את סוף הסדרה (ואינו נחשב חלק ממנה). • שבר מיוצג בקלט ע"י זוג מספרים שלמים חיוביים – מונה ואחריו מכנה , מופרדים ע"י '/'. • דוגמא: הקלט (משמאל לימין) 0/1 5/21 12/8 4/5 • הפלט 2/7 • ניתן להניח שהקלט חוקי ושהמונה והמכנה הם מספרים חיוביים גדולים ממש מ- 0 (פרט למספר 0/1 שמסמן את סוף הסדרה).

28. #include <stdio.h> struct rational { int num, denom; }; typedef struct rational Rational; /* functions declarations*/ Rational calc(void); void printRational(Rational); int main() { Rational res = calc(); printRational(res); return 0; } המשך

29. int gcd(int a, int b) {…} void printRational(Rational) {…} Rational readRational(void) {…} Rational reduceRational(Rational r) { int cd = gcd(r.num, r.denom); r.num /= cd; r.denum /= cd; return r; } Rational multiplyRational(Rational r1, Rational r2) { r1.num *= r2.num; r1.denum *= r2.denum; return reduceRational(r1); } Rational calc(void) {…} המשך