- ריבוע.
- מלבן ביחס פיבונאצ"י.
- תלוי ביחידות המדידה.
- כולם זהים.
- פורטיס מחברת סי.די.סי.
- ג"ון מחברת י.ב.מ.
- צוות קוד פתוח.
- כל התשובות נכונות.
- כינוי לאחד מהתקני האחסון ששימשו במחשב מיינפריים מסוג IBM System/370.
- מאכל איטלקי מועדף על מתכנתים.
- מחשב תעשייתי שטוח להתקנה במסד.
- כל התשובות נכונות.
- שקל
- עשרה שקלים
- מאה שקלים
- אלף שקלים
- לאותו המקום
- קצת יותר
- קצת פחות
- תלוי במחיר ההתחלתי
- חלוקה ב-0.
- שימוש במשתנה מטיפוס לא מתאים לערך המוכל בו.
- race condition.
- נקודה-פסיק חסרה בקוד C.
- Linux
- OS/2
- Windows NT
- Windows 95
011111
100000
100000
100000
100000
- עיגול
- משולש
- כוכב
- לב
char *codeguru = "CodeGuru";
cout << 4 + codeguru;
- התכנית תדפיס את הכתובת של התו G.
- התכנית תקרוס, בשל גישה לא חוקית לזיכרון.
- השורה תדפיס G.
- השורה תדפיס Guru.
int X = 1;
char c = "\\";
// See if the char is \\
if (c == "\\")
X++;
else
X=0;
- X יגדל ב-1 (ויהיה שווה ל-2).
- X יהיה שווה ל-0.
- הערך של X לא ישתנה.
- קטע הקוד לא יתקמפל.
define INC(num) \\
{ \\
int x=1; \\
num+=x; \\
}
int x = 0;
if (x == 0)
INC(x);
- 1
- 2
- 0
- קטע הקוד לא יתקמפל.
- יניח שההודעה התקבלה שלא בסדרה, ישלח את ה-Ack האחרון התקין שלו שוב ויזרוק את ההודעה החדשה.
- יניח שמדובר בזיוף של ההודעה, וישלח RST לצד השני על מנת לסגור את החיבור.
- יניח שההודעות הקודמות לא התקבלו עדיין, ישלח את ה-Ack האחרון התקין שלו שוב וישמור את ההודעה החדשה אם היא בגבולות החלון שלו.
- יניח שההודעות הקודמות לא התקבלו עדיין, ישמור את ההודעה החדשה ואם יש צורך, ייקצה חלון גדול יותר על מנת לקבל את ההודעה.
- נגדיר לנתב הקרוב ל-A כתובת ש-A אמור לדבר איתה, וניתוב של ההודעות לרשת המרוחקת.
- נגדיר לנתב הקרוב ל-ARP Proxy A של כתובות ברשת המרוחקת וניתוב אליה.
- נגדיר לנתב הקרוב ל-tunnel A לרשת המרוחקת.
- נגדיר VPN בין הרשת המרוחקת ל-A בעזרת הנתבים.
- בחתימה דיגיטלית למען אבטחת התקשורת.
- ריבוב של תתי-ערוצים בתוך אותו חיבור.
- כתיבה בחתיכות.
- שימוש בכתובות מרובות לאותו מחשב.
- מאפה סיני, מכילה פתק המעיד על מזל הנוגס בה
- פריט קטן של מידע שנשמר בעת גלישה באינטרנט על הדיסק הקשיח
- הצפה של מחשב בחיבורים סתמיים
- מנגנון שמונע פתיחה סתמית של חיבורי TCP
- חלוקה ב-0
- המרה לא נכונה של טיפוס משתנה
- race condition
- נקודה-פסיק חסרה בקוד C
- 1024
- 1336
- 1337
- 1573
- 34
- 111
- 495
- 1514
- גליל
- כדור
- ביצה
- אליפסה
- מספר ראשוני גדול.
- ייצוג ל-π באחד מהפורמטים התקניים.
- 25!
- 284
- הרחבת מספר החיבורים החשמליים לחריץ רחב יותר – מאפשר להעביר יותר נתונים בו זמנית.
- הגדלת קצב העברת הנתונים באמצעות הערוץ ל-8 ג"יגה בתים לשנייה.
- הרחבת מספר ההתקנים האפשריים לחיבור למחשב, בין היתר אנדרואיד של גוגל לצורך סינכרון מהיר במיוחד.
- דור 2.0 מאפשר להתקנים מדור 1.1 לעבוד בקצב מהיר פי שניים.
- בכל מקרה במעבד iCore7 מכיוון שהוא יעיל יותר ומנגנון ה-HyperThreading ייתן שיפור ביצועים.
- בארכיטקטורת Core2, מכיוון שבמעבדי iCore7 המתח המגיע למעבד הוקטן על חשבון הביצועים, המעבד אמנם חסכוני יותר, אך מספק פחות ביצועים לאותו תדר שעון.
במעבד - Core2 בו כל הליבות בעלות יכולות זהות, כאשר ב-iCore7 שמונה הליבות הן וירטואליות אך גורמות ליתירות (overhead) הפוגעת בביצועים.
- קשה לומר, מעבד
iCore7 משפר ביצועים בתחומים מסויימים, אך פוגע באיזורים אחרים. לכן צריך לבדוק את האלגוריתם בקפידה.
- 720
- 1440
- 2856
- 86400
- פחות מפטה-בית.
- בערך טרה-בית.
- יותר מאקסה-בית.
- כל התשובות נכונות.
262
(לא כולל) – כמה פעמים יתהפכו כל הביטים?
- 261
- 262
- 263 – 1
- 263
- 100
- 127
- 256
- 32767
21023 + 1
- 21023 + 1
- 21023 + 2511
- 21023 + 2972
- 21024
- 1.2599
- 1.7071
- 1.7321
- 2
העוצמה שלה נחלשת בתור
q-l * s
, כאשר q הוא קבוע ידוע מראש, l הוא אורך הקרן בתוך המשבצת, ו-s הוא רמת האפור (בין 0 ל-1). אם כל המשבצות אפורות (אף אחת לא מעבירה אור באופן מושלם, ואף אחת לא בולעת את הקרן כך שלא נוכל לקלוט אותה), כמה קרניים נצטרך לשלוח לכל הפחות כדי לדעת את רמות האפור של כל המשבצות?
- 1
- 25
- 50
- 51
#include <stdio.h>
void f() {
long i = 0;
long p[1] = {0xF00DBEEF};
for(i = 0; i < 0x8; i++) {
printf("%04lx %016lx\\n", i*sizeof(long), p[i]);
}
}
void g() {
f();
}
int main() {
long t[10];
g();
return 0;
}
התקבל (לינוקס, ארכיטקטורת x86_64) הפלט הבא:
0000 00000000f00dbeef
0008 0000000000000001
0010 00007fff6cee0800
0018 000000000040052e
0020 00007fff6cee0860
0028 0000000000400542
0030 0000000000000000
0038 00000000004003ab
בזמן ריצת התוכנית, מה הייתה הערך של p?
- 0xf00dbeef
- 0x7fff6cee07e0
- 0x7fff6cee07f0
- 0x7fff6cee0800
mov eax,esp
push eax
jmp my_func
lock lahf
My_func:
push ebx
push ecx
rdtsc
retn 8
- לא יעבוד אף פעם: הפקודה lock lahf אינה חוקית ב X86
- יעבוד רק בחלק מהמעבדים: הפקודה lock lahf חוקית רק במעבדים של AMD
- יעבוד רק במעבדים בהם אין תמיכה ב- Non Executable Stack
- יעבוד רק מתוך Ring() שכן הפקודה rdtsc הינה Privilaged Instruction
ב-
5!:
int fact5(int a)
{
int count = 5;
while (count--) {a/=count;}
return a;
}
דני אומר שבפונקציה יש באג.
- דני צודק. הפונקציה תעלה שגיאה בעת קומפילציה.
- דני צודק. הפונקציה תעלה שגיאה בעת הריצה.
- דני צודק. הפונקציה תחזיר ערך שגוי.
- דני טועה. אין שגיאה בפונקציה.
- לא נקבל ARP reply מכתובת MAC שלא הוגדרה לנו סטטית.
- לא נקבל ARP reply מכתובת IP שלא הוגדרה לנו סטטית.
- לא נשלח ARP request לכתובת IP שלא הוגדרה לנו סטטית.
- לא נקבל ARP reply על request שלא שלחנו.
כרגע היא
100%-90% = 10%
)?
- מבלי לשדר את אותו המידע יותר פעמים (הוספת יתירות), אי אפשר לשפר את המצב.
- ניתן להעלות בריבוע את הסיכון לתקלה, ל-81%, אך לא יותר מזה.
- ניתן לשפר את הסיכוי ל-10%, אך לא יותר מזה.
- ניתן לשפר פי כמה שבא לנו על-ידי שימוש בתיקון שגיאות מקדים (Forward Error Correction)
- r-xrwx–x
- 377
- 0x179
- כל התשובות נכונות
- הגדרות פרוקסי;
- המלצות של ועד לפעולה פוליטית;
- מיפוי עומק באוקיינוס השקט (Pacific);
- פרטי משלוח בפורמט אגודת האורזים הקנדית (Packaging Association of Canada).
- אי אפשר לשפר את הסיכוי;
- ניתן להעלות בריבוע את הסיכון לתקלה, ל-1%, אך לא יותר מזה;
- ניתן לשפר ל-0.31%, בהתאם למשפט שנון;
- בתנאים אלה, לכל הסתברות שגיאה גדולה מ-0 קיים מנגנון FEC שמשיג אותה;
- Object
- boolean
- CountDownLatch
- כולם יכולים
List<String> sl = new LinkedList<String>();
List<Object> ol = sl;
- כן, כי כל String הוא Object.
- לא, כי לא ניתן להציב LinkedList ב-List.
- לא, כי הרשימה הראשונה עלולה להשתבש.
- לא, כי Generics לא נמצאים בזמן ריצה.
int i = 255;
byte b = i;
i = b;
System.out.println(i);
- לא יתקמפל, כי byte הוא signed.
- 127 – כי byte הוא signed.
- 255, כי 255 קטן מ-256.
- 128, כי byte הוא unsigned.
short x=-32768;
short y;
y = -x;
printf("%d", y);
בהנחה שגודל של short הוא 16bit.
- 1
- 0
- 32768-
- 32768
List<Integer> l = new LinkedList<Integer>();
l.add(1);
l.add(2);
l.add(3);
l.add(4);
for (int i : l)
if (i % 2 == 0)
l.remove((Integer) i);
- i צריך להיות מטיפוס Integer.
- ה-cast מיותר כי מתבצע auto-boxing.
- נקבל ConcurrentModificationException בגלל שלא השתמשנו ב-Iterator.remove.
- מתבצעת קריאה למתודה List.remove לפי אינדקס ולא לפי האובייקט שיש למחוק.
- להעברת פרמטרים למתודות by-reference ולא by-value.
- למימוש מנגנוני cache שקופים למשתמש.
- מימוש של מצביעים ב-Java משום שהם לא קיימים בשפה.
- הרצת ה-Garbage Collector על אובייקט מסוים שברשותינו.
public boolean isOdd(int i) {
return i % 2 == 1;
}
- הקטע מחזיר תשובה הפוכה מהמצופה בכל המקרים.
- מתבצע auto-boxing שגורם לחישובים להיות שגויים לפעמים.
- הקטע מחזיר תשובה לא נכונה עבור חלק מהמספרים השליליים.
- אין שום בעיה.
\\u0070\\u0075\\u0062\\u006c\\u0069\\u0063\\u0020\\u0020\\u0020\\u0020
\\u0063\\u006c\\u0061\\u0073\\u0073\\u0020\\u0055\\u0067\\u006c\\u0079
\\u007b\\u0070\\u0075\\u0062\\u006c\\u0069\\u0063\\u0020\\u0020\\u0020
\\u0020\\u0020\\u0020\\u0020\\u0073\\u0074\\u0061\\u0074\\u0069\\u0063
\\u0076\\u006f\\u0069\\u0064\\u0020\\u006d\\u0061\\u0069\\u006e\\u0028
\\u0053\\u0074\\u0072\\u0069\\u006e\\u0067\\u005b\\u005d\\u0020\\u0020
\\u0020\\u0020\\u0020\\u0020\\u0061\\u0072\\u0067\\u0073\\u0029\\u007b
\\u0053\\u0079\\u0073\\u0074\\u0065\\u006d\\u002e\\u006f\\u0075\\u0074
\\u002e\\u0070\\u0072\\u0069\\u006e\\u0074\\u006c\\u006e\\u0028\\u0020
\\u0022\\u0048\\u0065\\u006c\\u006c\\u006f\\u0020\\u0077\\u0022\\u002b
\\u0022\\u006f\\u0072\\u006c\\u0064\\u0022\\u0029\\u003b\\u007d\\u007d
- קטע byte-code של תכנית ב-Java.
- תכנית שמדפיסה "Hello World".
- סימון ל-Java להשתמש בקידוד Unicode.
- אוסף של סימנים ללא משמעות.
- יש לסדר מחדש את האיברים ב-switch
- יש להתחיל להשתמש בטבלת hash שמכילה מצביעים לפונקציות.
- יש להוציא את הערכים השכיחים מה-switch, ולעשות if או switch מיוחדים שמתייחס אליהם בהתחלה.
- switch הוא תמיד יעיל באופן מרבי, אין פה מה לשפר.
- נשלח ACK עם אותו sequence number פעמיים. זאת תופעת Keep-alive תקנית
- הצד השני ניתק את החיבור באופן תקני
- יש עומס ברשת
- לא התקבל מידע במשך פרק זמן מסויים, אך החיבור עדיין קיים
- תופעה שגורמת ליצירת תעבורת TCP מיותרת כאשר הצד המקבל אינו מסוגל לקבל את המידע בקצב המתאים
- תופעה שגורמת להאטת חיבור TCP כאשר מופעל גם האלגוריתם של Nagle וגם המנגנון DELAYED ACK
- תחושת זעזוע אילם בעת מעבר על חדשות תרבות בדפדפן
- בעית תקיעה אופיינית לחלונות בסביבת Windows, שמתרחשת כאשר החלון אינו מתייחס להודעות WM_PAINT
- להמתנה של תהליך לקלט.
- בחירת שורות מתוך מסד נתונים מובנה (Berkley DB).
- להתקנת חבילות תוכנה בפורמט RPM או deb.
- כל התשובות נכונות.
6d 6f 76 20
61 78 2c 20
5b 62 78 5d
3b 0d 0a 69
- EIP
- MM0
- EFLAGS
- ESI
lea di, [4*ebx+ebx]
shl di, 5
add di, cx
stosw
למה כנראה שווה ES?
- 0x0040
- 0xA800
- 0xB800
- 0xF00F
lea di, [4*ebx+ebx]
shl di, 6
add di, cx
stosb
למה כנראה שווה ES?
- 0x0000
- 0xA000
- 0xF000
- 0xF00F
start:
push offset end
jmp Foo
- הקוד אינו תקין, שכן לא ניתן לקרוא לפרוצדורה בעזרת jmp.
- הקוד תקין, ושקול לפקודה call Foo.
- הקוד תקין, אך ה-push מיותר וניתן להגיע לקוד שקול בלעדיו.
- הקוד אינו תקין, שכן לאחר סיום פרוצדורת Foo בעזרת פקודת ret, המעבד לא ידע לאן יש לחזור.
- 17218
- 75266
- 412!
- 5*819216
0100000100000
1010000000000
0101000000000
0010100000000
0001010000000
0000101000000
0000010100000
1000001000000
0000000000000
0000000000000
0000000000000
0000000000001
0000000000010
- דרקון
- בית
- כוכב
- פרצוף
איזו מהטענות הבאות נכונה:
- אי אפשר להגיע להסדר.
- תמיד אפשר להגיע להסדר.
- אפשר היה להגיע להסדר באופן וודאי רק עבור פחות מ-10 ערים.
- זה תלוי במפת הערים הספציפית – ייתכן שעבור מפה מסויימת ניתן להגיע להסדר, ועבור מפה אחרת לא.
sum [] = 0
sum (a:x) = a + sum x
product [] = 0
product (a:x) = a * product x
reverse [] = []
reverse (a:x) = reverse x ++ [a]
threads שמבצעים את הקוד הבא, כאשר המשתנה c מוקצה על ה-heap ומשותף לשניהם:
c = 0;
c = c+1;
c = c+1;
c = c+1;
איזה ערך לא יוכל c לקבל (באף אחד מהם)?
- 0
- 3
- 4
- 6
- 3 MB/s
- 6.25 MB/s
- 6.25 MB/s
- 100 MB/s
- PFW
- ניתוב IP
- LAN switching
- NAT
- SYN, RST
- ACK, FIN
- SYN, ACK
- RST, FIN
- scanf
- memset
- printf
- realloc
int f(int r) {
int i = 0, s = 0;
int array[16] = { ?????, 0, 0, .., 0 };
for(i = 0; i < 5; i++) {
if (array[i])
s += (r << i);
}
return s;
}
מה אמור להופיע במקום סימני השאלה (שאר האיברים במערך הם 0):
- 0, 1, 1, 1
- 1, 0, 0, 1, 1
- 1, 0, 0, 0
- 1, 3, 2
OPTION.
int l;
char output[33];
while(k) {
#ifdef OPTION
output[l++] = (k & 1) + 0x30;
#else
if(k & 1)
output[l] = ''0'';
else
output[l] = ''1'';
l++;
#endif
k >>= 1;
}
output[l] = ''\\0'';
מריצים את הקוד ב-4 תצורות – שני מעבדים שונים, וכאשר k מוגרל באופן אקראי בתחומים שונים. מתי ההדלקה של OPTION תעשה הבדל?
- מריצים על מעבד Core 2 Duo; בעוד
k נבחר בתחום
המספרים 983040..983056 - מריצים על מעבד Core 2 Duo; בעוד
k נבחר בתחום 0..983056 - מריצים על מעבד 486;
בעוד
k מוגרל בתחום המספרים 983040..983056 - מריצים על מעבד 486;
בעוד
k מוגרל בתחום 0..983056
Disk On Key בגודל 4 ג"יגה-בייט, מפורמט במערכת הקבצים FAT32.
דני החליט לשמור על הקובץ את אוסף המילים לשירים האהובים עליו, כאשר הגודל של כל קובץ עם מילים הוא כ-1000 בתים.
דני אוסף שירים מכל רחבי העולם, ויש לו מיליון שירים. כמה מקום פנוי יש לדני על הדיסק, בהנחה שמשתמש בהגדרות ברירות המחדל של מערכת הקבצים?
- 0 GB
- 1 GB
- 2 GB
- 3 GB