1. מה המשמעות המקובלת בתכנות של המילה VOID?
- מולטימדיה מאוד חכמה
- חלל או ריק
- טיפוס לא מוגדר
- בדיקה של עמידות
2. מה המשמעות המקובלת בתכנות של int?
- לייצג מספרים שלמים
- להגדרות בינלאומיות
- לצורכי בנקאות מקוונת
- לארגון הבריאות העולמי
5. נתונה הפונקציה הבאה, בסביבת 16bit:ב – C:
int f(unsigned char a, unsigned char b, unsigned char c)
{
return ((a*b)/c) == (a*(b/c));
}
בפסקל:
function f(a, b, c : byte) : boolean; var a0, b0, c0 : word; begin a0 := a; b0 := b; c0 := c; f := ( ((a0*b0) div c0) = (a0*(b0 div c0)) ); end;
פונקציה זו תחזיר "אמת" אם ורק אם:
- a=1 או (b mod c) = 0 או a=0
- a*(b mod c) < c
- (b mod c) = 0
- תחזיר אמת תמיד
7. דני ניסה לחשב ממוצע של רשימה של N מספרים (N > 2) בצורה הבאה: הוא חישב את הממוצע של שני המספרים הראשונים, ואז את הממוצע של התוצאה עם המספר השלישי, ואת הממוצע של התוצאה החדשה עם המספר הרביעי וכך הלאה. למרות ששיטה זו לחישוב ממוצע אינה נכונה בעוד שלדני לא היו טעויות חישוב, המורה (שיודע לחשב ממוצע בצורה נכונה) בדק את התוצאה ושיבח את דני על התשובה הנכונה. דני, שחשד שהשיטה שלו אינה נכונה עבור המקרה הכללי, החליף את אחד המספרים במספר אחר (וסיפר על כך למורה), חישב את הממוצע החדש (בדרכו השגויה), וביקש מהמורה שיבדוק את התוצאה. אך איזה פלא – שוב שיבח המורה את דני על התוצאה הנכונה! איזה טענה נכונה בהכרח?
- אם יוציאו את המספר שהוחלף, יהיה בין המספרים שנותרו מספר מספר השווה לממוצע של שאר המספרים (ללא המספר שהוצא)
- N הוא 4, 5 או 8
- המספר שהוחלף הוא המספר ה – lg(N)-י מסוף הרשימה (כאשר lg מייצג לוגריתם בבסיס 2)
- המצב המתואר אינו אפשרי
8. על גבי תמונה ברזולוציה של 8×8, פלטתי 64 פיקסלים, כל אחד במקום אקראי ובלתי תלוי. מהו הסיכוי שמילאתי בדיוק מחצית מהפיקסלים שבתמונה?
- פחות מ – 1 למיליון
- בערך 1 ל – 2,500
- בערך 1 ל – 100
- בדיוק 1 ל – 2
9. נתון הפסאודו-קוד הבא (עם שלוש פונקציות חסרות):
א <- 1000000000 כל-עוד (אמת) בצע: אם ק, אזי: א <- 1000000000 בצע פ אם א שווה ל - 0, אזי: בצע ס א <- 1-א
למה סביר להניח שהוא מיועד:
- הקצאת מספרים סידוריים
- פירוק מספרים גדולים לגורמים
- תפעול דלת הזזה אוטומטית
- הגרלת מספרי לוטו
10. (*) הפונקציה הבאה אמורה להחזיר את המיקום של האיבר שערכו x במערך A שמכיל N איברים ממוינים בסדר עולה (ומכיל איבר שערכו x). אבל יש בה באג.ב – C:
int get_index(int x, int A[], int N)
{
int L = 0, H = N-1;
while (L != H) {
int M = (L+H)/2;
if (x >= A[M])
L = M;
else
H = M-1;
}
return L;
}
בפסקל (כאשר האיבר הראשון במערך A הוא האיבר במיקום ה – 0):
function get_index(x : integer; A : array of integer; N : integer) : integer; var L, H, M : integer; begin L := 0; H := N-1; while L <> H do begin M := (L+H) div 2; if x >= A[M] then L := M else H := M-1; end; get_index := L; end;
עבור כמה ערכים של N, הפונקציה, בכל זאת, תחזיר תשובה נכונה תמיד?
11. מה עושה קטע הקוד הבא בשפת אסמבלי בסביבת 16bit?:
mov bx, offset var_ptr xor ax, ax l: xchg [bx], ax or ax, ax jz l
- מחשב את שורש שלוש
- תופס בעלות על משאב
- מבצע מיון בועות
- הופך רשימה מקושרת
12. מה עושה קטע הקוד הבא בשפת אסמבלי בסביבת 32bit?:
xor ebx, ebx start: test eax, eax jz end xchg ebx, [eax] xchg ebx, eax jmp start end:
- מחשב את שורש שלוש
- תופס בעלות על משאב
- מבצע מיון בועות
- הופך רשימה מקושרת
13. מהן שלוש הפונקציות הבאות בשפת C:
void a(type1* s)
{
p[0] = (type2*) malloc(sizeof(type2));
p[1] = (type2*) malloc(sizeof(type2));
p[0].a = p[1]; p[1].a = p[0];
p[1].b = s;
}
void b(type1* s)
{
type2* n = (type2*) malloc(sizeof(type2));
p[0].b = s;
n.a = p[0]; p[0].a = p[1]^n;
p[1] = p[0]; p[0] = n;
}
int c(int d)
{
if (p[!d].a != p[d]) {
p[d] ^= p[!d].a;
swap(p[d], p[!d]);
return 1;
}
return 0;
}
- מערכת Undo ו – Redo
- מימוש של ערימה
- מנגנון garbage collection
- בינה מלאכותית ל – "ארבע בשורה"
16. למה משמשות שלוש הפונקציות הבאות:
בשפת פסקל
void a()
{
x1 = x2 = 0;
}
procedure a; begin x1 := 0; x2 := 0; end;
int b()
{
if (x1) return F[--x1];
return x2++;
}
function b : integer; begin if x1 <> 0 then begin x1 := x1 - 1; b := F[x1]; end else begin b := x2; x2 := x2 + 1; end; end;
void c(int x)
{
F[x1++] = x;
}
procedure c(x : integer); begin F[x1] := x; x1 := x1 + 1; end;
- מימוש של תור מעגלי
- התמרת פוריה בדידה
- פעולות על מספרים גדולים
- טיפול יעיל בהקצאת זיכרון
17. (*) נתונה הפונקציה הבאה בסביבת 32bit:ב – C:
unsigned int div_by_17(unsigned int a)
{
return (MUL*a)>>SHIFT;
}
ניתן למצוא ערכים של MUL ו – SHIFT עבורם ערך החזרה של הפונקציה יהיה a חלקי 17 (מעוגל כלפי מטה), בהנחה ש – 16 הביטים העליונים של a כבויים.
מצא ערך מתאים של MUL:
19. (**) המורה של דני השתמש בשיטה הבאה כדי לכווץ הודעה המורכבת מ – 26 אותיות ה – ABC (אותיות גדולות בלבד):
הגדרה: מילון0 הוא מילון היודע לקחת מחרוזת ולמצוא מספר שהותאם לה קודם לכן (או להגיד שעדיין לא הותאם לה מספר) עבור כל אות מה - ABC, בצע: התאם למחרוזת המכילה את האות הזו בלבד את האינדקס שלה ב - ABC (כלומר, ל - "A" יותאם 1 ול - "Z" יותאם 26) הכנס למשתנה קוד0 את המספר 26 קרא את התו הראשון מהמסר ושמור אותו ב - מחרוזת0 כל עוד ישנם עדיין תווים במסר שלא נקראו, בצע: קרא את התו הבא מהמסר ושמור אותו ב - תו0 הכנס ל - מחרוזת1 את מחרוזת0 עם תו0 משורשר בסופה אם כבר הותאם מספר ל - מחרוזת1 ב - מילון0 אזי: החלף את הערך של מחרוזת0 בערך של מחרוזת1 אחרת: פלוט את המספר שהותאם ל - מחרוזת0 לפי מילון0 הוסף אחד לערך של קוד0 התאם במילון0 את המספר קוד0 למחרוזת מחרוזת1 החלף את הערך של מחרוזת0 בערך של תו0 פלוט את המספר שהותאם למחרוזת0 לפי מילון0
המסר המכווץ נראה כך (משמאל לימין):
3, 7, 27, 24, 29, 31, 7
דני רוצה לפענח את המסר, בתקווה שמשמעותו היא שהמורה מבטל את השיעור הקרוב. עזרו לדני!
מהו המסר המקורי אותו כיווץ המורה?
20. נתונות שתי דרכים לממש פונקציה מסוימת:ב – C:
unsigned int f1(unsigned int n)
{
unsigned int x = 1;
for (unsigned int i = 1; i <= n; i++) {
x *= i;
}
return x;
}
unsigned int f2(unsigned int n)
{
if (n == 0) return 1;
return n*f2(n-1);
}
בפסקל:
function f1(n : word) : word; var x, i : word; begin x := 1; for i := 1 to n do x := x*i; f1 := x; end; function f2(n : word) : word; begin if n = 0 then f2 := 1 else f2 := n*f2(n-1); end;
בחר את הטענה הנכונה:
- אחת הפונקציות גורמת לביצוע של פעולות כפל רבות יותר מהשנייה
- אחת הפונקציות עלולה לדרוש זיכרון רב יותר מהשנייה
- במקרה של overflow בתוצאה, ערך החזרה של הפונקציות עלול להיות שונה
- לא קיים הבדל מהותי בין המימושים, פרט לזמן הריצה
21. מה הקשר בין d – ממוצע הזמן בדקות בין פגיעת שני מטאורים, לבין m – ממוצע מספר המטאורים הפוגעים בדקה?
- תמיד מתקיים m = d
- יכול להיות ש m = 1/d
- אף פעם לא d = 1/m
- כל התשובות נכונות
22. אם תוכנת המגב (וישר) של מכונית פועלת על ידי מצמוץ אם ורק אם מספר השניות מאז 1.1.1970 מתחלק ב-d, כאשר d הוא מספר שלם בין 1 ל-10 הניתן לכיוונון על ידי הנהג. מהו קצב המצמוץ האיטי ביותר שניתן להשיג אם הנהג יכול לשנות את d כל שניה?
- 10 שניות
- 42 דקות
- 42 יום
- אינסוף
23. אני מחפש ספגטי מסוים בסופרמרקט, יש לי את ה-Bar-Code שלו ואני מנסה להשוות מול המוצרים שעל המדף. איזו שיטה יעילה יותר?
- לבדוק את הספרה הראשונה (msb) ורק אם מתאימה לבדוק את הספרות הבאות
- לבדוק את הספרה האחרונה (lsb) ורק אם מתאימה לבדוק את הספרות הבאות
- תלוי איזה רוטב אני מעדיף
- כל התשובות נכונות
24. ולמה?
- כי הספרות האחרונות הם ספרות ביקורת
- כי הספרות הראשונות קבועות למוצרים רבים
- כי יש קשר בין הרוטב המועדף ל-Bar-Code
- כל התשובות נכונות
25. להלן אלגוריתם הפעולה של מיקרוגל
start:
time = 0
loop:
if (time == 0 and program_time) time = user_input
if (time > 0) {heat; time--; wait_a_second; if (time == 0) beep_end}
goto loop
On cancel_pressed Interrupt:
if (time>0) beep_abort; time=0
goto loop
האם ניתן לעצור את המיקרוגל מרגע שהחל לחמם מבלי לצפצף?
- לא, כי סיום הזמן או הפסקה לפני סיום גורמת לצפצוף
- קימת שנייה בה ניתן לעשות זאת
- רק אם time הוא בן 32 ביט
- על ידי תכנות הזמן מחדש באמצע חימום
26. האם יכול להיות ש-30% מהגברים בגילאים 30 עד 40 הם רווקים ו-40% מהגברים בגילאי 40 עד 50 הם רווקים?
- לא, כי יציאה מרווקות היא תהליך בלתי הפיך (אלמן וגרוש אינם רווקים)
- לא, כי 50% מהאוכלוסייה הן נשים (ו 30+40 > 50)
- כן, כי המצב לא חייב להיות יציב (עוד 10 שנים המספרים ישתנו)
- כן, אבל רק אם מתמקדים באוכלוסיית תל-אביב בלבד
27. לפני קו עצירה של רמזור יש מספר גלאי מתכת. מה יקרה אם תוכנת הרמזור מתחשבת רק בגלאי המרוחק ביותר מהרמזור המגלה מתכת?
- נהגים שיעצרו רחוק מהרמזור יקבלו ירוק מהר יותר
- תנועת המכוניות תהיה רגישה פחות לשגיאות מדידה
- הרמזור עלול ל"התקע" לנצח באור ירוק
- כל התשובות נכונות
28. מה מחשבת הנוסחא הבאה?
(x0*y1-x1*y0)/sqrt((x0*x0+y0*y0)*(x1*x1+y1*y1))
- אורך של אלכסון במחומש משוכלל
- חוצה זווית של משולש שווה שוקיים
- מרחק ממנו רואים פסל בזוית מירבית
- קוסינוס של זוית שקודקודה בראשית
29. מה מחשב הקטע הבא
xm=0
for x = 0 to 100 {
xx = x*(y2-y1)/sqrt((x*x+y1*y1)*(x*x+y2*y2))
if (xx > xm) xm = xx; a=x
}
- אורך של אלכסון במחומש משוכלל
- חוצה זווית של משולש שווה שוקיים
- מרחק ממנו רואים פסל בזוית מירבית
- קוסינוס של זוית שקודקודה בראשית
30. נתון קטע הקוד (החסר) הבא בשפת C++:
class A { ... };
class B { ... };
class C { ... };
class Container {
Container() : a(), c(), b() {
c.start();
b.start();
a.start();
}
A a;
B b;
C c;
};
כאשר יוצרים מופע של המחלקה Container, באיזה סדר ייקראו הבונים (constructors) של האובייקטים המוכלים a, b, c?
- קודם a, אח"כ b ולבסוף c
- קודם c, אח"כ b ולבסוף a
- קודם a, אח"כ c ולבסוף b
- קודם b, אח"כ a ולבסוף c
31. כיצד ניתן לבצע TLB Priming?
- לקרוא את המילה האחרונה של העמוד ממנו רוצים לקרוא ומיד לקרוא את העמוד מתחילתו ועד סופו
- לקרוא מילה כלשהי מעמוד אותו רוצים לקרוא, ואז לעבוד על זיכרון אחר לפני שניגשים לעמוד הנ"ל
- לקרוא עמוד בצרור (burst) מתחילתו ועד סופו, ואז לעבור עליו מסופו לתחילתו
- לקרוא מילה אחת מכל שורת מטמון (cache line) בעמוד לפני שעוברים עליו
32. (*) מה תחזיר התוכנית הבאה?ב – C:
int f(int p, int p1)
{
int i,j,i1,j1;
i =p >>3; j =p &7;
i1=p1>>3; j1=p1&7;
return (i-i1)*(i-i1)+(j-j1)*(j-j1) == 5;
}
בפסקל:
function f(p, p1 : integer) : boolean; var i, j, i1, j1 : integer; begin i := p shr 3; j := p and 7; i1 := p1 shr 3; j1 := p1 and 7; f := (i-i1)*(i-i1)+(j-j1)*(j-j1) = 5; end;
- האם p גדול מ p1 כמספרים מרוכבים
- האם אפשר להגיע במהלך פרש מ – p אל p1
- האם p ניתן לייצוג כ p1 ספרות בבסיס 7
- כל התשובות נכונות
33. (**) מה תחזיר התוכנית הבאה?
int s(unsigned __int64 x){return (!x || x&(x-1));}
int r()
{
unsigned __int64 i,m1,m2;
int r = 0;
int j;
for (i=1; i; i++,r+=j==8)
for (j=0,m1=0xff,m2=0x101010101010101; j<8; j++,m1<<=8, m2<<=1)
if (s(i&m1) || s(i&m2)) break;
return r;
}
34. מה ספרת העשרות הנפוצה בין מליון חזקות 2 הראשונות?
- 1
- 2
- 9
- כולן מופיעות בערך בשכיחות שווה
35. מה הספרה הנפוצה ביותר כספרה ראשונה (Most Significant) בין מיליון חזקות 2 הראשונות?
- 1
- 2
- 9
- כולן מופיעות בערך בשכיחות שווה
36. מה מיוחד במספר 26334878?
- כשמתרגמים אותו לאוקטלית, לא מכיל את הספרות 0 ו-7
- תרגום של שם התחרות מאנגלית לספרות
- מכפלה של שני מספרים ראשוניים
- כל התשובות נכונות
37. מדוע השורה הבאה בשפת C גורמת לתוכנית לקרוס בארכיטקטורת x86?
void*x=(*((void*(*)())&(x=(void*)0xfdeb58)))();
- Access Violation
- Stack Underflow
- Invalid Opcode
- ביט Mod R/M משובש
38. מה זה 2001:0db8:85a3:08d3:1319:8a2e:0370:7334?
- כתובת בפרוטוקול IPv6
- נגטיב של חתול
- המספר הראשוני הגדול ביותר הידוע כיום, בייצוג הקסדצימלי
- בקשה לסנכרון, בפרוטוקול V.42 (מודם)
39. איזו מהאפשרויות הבאות אינה מבנה נתונים ידוע?
- ערימה בינארית
- ערימה מקושרת
- ערימה בינומית
- ערימת פיבונאצ'י
41. מה המקור של הביטוי SPAM?
- דואר זבל זה מגעיל כמו בשר משומר
- Shit Posing As Mail
- סקיצה של "מונטי פייטון"
- אף תשובה אינה נכונה
42. לאחר הרצת הקוד הבא בשפת C:
FILE* fp = fopen("1.txt", "w");
char ch = 0xa;
fwrite(&ch, sizeof(ch), 1, fp);
fclose(fp);
גודל הקובץ שנוצר היה שני בתים ולא בית אחד, מדוע?
- מכיוון ש – fwrite מיועד לכתיבת בלוקים
- מכיוון ש – fclose מוסיף בית מסיים
- מכיוון שהקובץ נפתח במצב כתיבה טקסטואלי
- מכיוון שהקוד רץ על מעבד AMD
43. (***) מה עושה הפונקציה הבאה, למה זה שימושי?ב – C:
int B[1<<7];
void f()
{
int c, i, j;
for (c = 0; c < (1<<7); c++) {
if (B[c] == 0) {
printf("%d\n", c);
B[c] = 1;
for (i = 1<<6; i != 0; i>>= 1) {
for (j = 1<<6; j != 0; j>>= 1) {
B[c^(i|j)] = 1;
}
}
}
}
}
בפסקל:
var b : array[0..(1 shl 7)] of integer; procedure f; var i, j, c : integer; begin for c := 0 to (1 shl 7)-1 do begin if B[c] = 0 then begin writeln(c); B[c] := 1; i := 1 shl 6; while i <> 0 do begin j := 1 shl 6; while j <> 0 do begin B[c xor (i or j)] := 1; j := j shr 1; end; i := i shr 1; end; end; end; end;
44. (****) מה עושה הפונקציה הבאה:ב – C:
int O[4] = {1, -1, 128, -128};
void f(unsigned char A[1<<14], int B[1<<14])
{
int C[1<<8] = {0x3F7E};
unsigned char X = 0, Y = 1;
int j, m;
for (j = 0; j < 1<<14; j++)
B[j] = -1;
while (X != Y) {
int c = C[X++];
for (j = 0; j < 4; j++) {
m = c + O[j];
if ((A[m] == 0) && (B[m] == -1) && (m != B[c]))
{B[m] = c; C[Y++] = m; }
}
}
}
בפסקל:
const O : array[0..3] of integer = (1, -1, 128, -128); type typeA = array[0..(1 shl 14)-1] of byte; typeB = array[0..(1 shl 14)-1] of integer; procedure f(var a : typeA; var b : typeB); var C : array[0..(1 shl 8)-1] of integer; X, Y : byte; j, m, k: integer; begin C[0] := $3F7E; X := 0; Y := 1; for j := 0 to (1 shl 14)-1 do B[j] := -1; while (X <> Y) do begin k := C[X]; X:=X+1; for j := 0 to 3 do begin m := k + O[j]; if (A[m] = 0) and (B[m] = -1) and (m <> B[k]) then begin B[m] := k; C[Y] := m; Y:=Y+1; end; end; end; end;