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

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

יואב ציבין

(3.2.00 נק' )25, 4שאלה

כתבו פונקציה המקבלת מערך וגודלו ומחזירה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;

}

סעיף בבמערך דו-מימדי הוא ארבעה תאים סמוכים בצורת ריבוע

ריבוע. כתבו פונקציה המקבלת טבלה( table) ומחזירה TRUE אם

יש בטבלה לפחות שני ריבועים שונים בעלי אותו סכום של איבריהם. ריבועים שונים יכולים להיות חופפים חלקית.

:דוגמא

.10בכל אחד משלושת הריבועים סכום האיברים הוא

typedef int table[N][M];61

21223

3423

המשך סעיף ב

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

נקודות(15 )08/02/01מבחן

נתון:

. m ומספר שלם n, את אורכו aמערך שלמים

ממוין בסדר לא יורד.aידוע שהמערך

כתוב פונקציה שעונה על השאלה הבאה:

האיברים של הקבוצה כל מכיל את aהאם המערך

.O(1), זכרון נוסף O(n)דרישות סיבוכיות: זמן

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

}

2 2 2 21 ,2 ,3 , m

נקודות(15 )09/07/01מבחן a הוא מערך שלמים באורך n -ידוע ש .n.אי-זוגי

בסדר הבא משמאל לימין:aהבא כך שידפיס את אברי הרקורסיבי נק') השלימו את הקוד 8א. ( 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;}

בסדר הבא משמאל לימין:aהבא כך שידפיס את אברי הרקורסיבי נק') השלימו את הקוד 7 ב. ( 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;}

(28.2.00 נק' )25, 4שאלה מערךA בגודל size של מספרים שלמים חיוביים

כך i < size-1 ≥ 0 אם קיים אינדקס מאוזןהינו שווה לסכום A[i] עד ל A[0]שסכום כל האיברים מ

.A[size-1] עד A[i+1]האיברים מ כלומר

האינדקסi אינדקס האיזון נקרא. כתוב פונקציה המקבלת מערךA של מס' שלמים

חיוביים וגודלו ומחזירה את אינדקס האיזון אם המערך אחרת.1מאוזן ו -

1

0 1

[ ] [ ]i size

j j i

A j A j

סעיף ב מערךA מאוזן אם 1- של מספרים חיוביים הוא

הוא מאוזן. מערךA של מספרים חיוביים הוא k מאוזן )לכל-

k>1אם הוא מאוזן )

-מאוזןA[i] (k-1) עד A[0]וגם המערך מ

-מאוזן A[size-1] (k-1) עד A[i+1]וגם המערך מ

הוא אינדקס האיזון(. i)כאשר

מאוזן3דוגמא למערך -

561111113441011156

|_______________| |__________| |___________________________| |________________|מאוזן1מאוזן -1 מאוזן -1מאוזן -1 -

|___________________________| |_____________________________________________|מאוזן2מאוזן -2 -

סעיף ב

כתוב פונקציה רקורסיבית שמקבלת מערךA של מס' חיוביים, גודלו ומס' שלם k ,

0-מאוזן, ו- k הוא A אם 1הפונקציה מחזירה אחרת.

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

נקודות(13 )08/02/01מבחן הינו a[n-1] זוגי וש a[0]ידוע ש אי-זוגי.

כתוב פונקציה שמחזירה אינדקס :המקייםi)כלשהו(

הינו אי-זוגי. a[i +1] זוגי ושa[i]ש

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; } return low;}

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;

}

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

x=500 , y=600

x=700 , y=200

blabla(&x,&x)=800


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

helper(n/3, m*3);helper(n/3, m*3);helper(n/3, m*3);

מהי סיבוכיות הזמן והמקום שלf?

O(log n)מקום

O(logמקוםn)

O(n) זמן

O(n2) זמן

נקודות(16 )08/07/02מבחן נתון מערךa באורך N.הממויין בסדר עולה ממש נתון מערך דו-מימדיb בגודל NxN שכל אחת

מהשורות בו ממויינות בסדר עולה ממש. השלימו את הפונקציה הבאה כך שתחזיר את

אינדקס השורה שמספר האיברים בה המופיעים הוא מקסימלי (במידה ויש מספר aגם במערך

שורות כאלו, יש להחזיר אינדקס כלשהו של אחת מהן).

סיבוכיות: זמןO(N2) זכרון נוסף ,O(1) #define N 10

int f(int a[N], int b[N][N]) { …}

בדומה למיזוג


מוגדרת באופן הבא: הפונקציה

1)

שלםn>1ולכל (2

nf 11 f

1

1

*1n

i

infifnf

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;

}

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

חישוק קטן.n=2

n=2

פתרון

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

(2.10.2002 נק' )20, 4שאלה

כל השאלות מבחינות קודמות מופיעות באתר שלי

המשך

2המשך

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

}

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

נקודות(15 )02/10/02מבחן #define ALPHABET 4#define N 5void 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

מהספרות כל אחתשבהם 0ALPHABET-1

פעמים.N בדיוקמופיעה

int a[N*ALPHABET];int used[ALPHABET]={0};permutations(a,0,used);

הפעלה:

נקודות(20 )28/02/00מבחן מטרת השאלה לכתוב תכנית שמחשבת מסלול במבוךמשבצת ההתחלה היא השמאלית-עליונהמשבצת הסוף היא הימנית-תחתונה כתבו את ההכרזה והאתחול של מערך דו-ממדי

( נק'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;}

המשך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מה ייקרה אם נוריד שורה זו (

(3.2.00 נק' )20, 1שאלה השלימו את שלד התכנית הנתון למטה. התכנית מקבלת כקלט

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

מסמן את סוף הסדרה )ואינו נחשב חלק ממנה(.0/1המספר מונה ואחריו –שבר מיוצג בקלט ע"י זוג מספרים שלמים חיוביים

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

שמסמן את סוף הסדרה(.0/1 )פרט למספר 0גדולים ממש מ-

המשך

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

}

המשך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) {…}

Documents

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