1. לצמצם Control hazards
2. להוריד כמות interrupts
3. לבצע מספר Branchים בפקודה אחת
4. להעלים לחלוטין Instruction cache misses

1. XOR
2. AND
3. OR
4. NOT
5. NAND

1. הגדרת מדפסות
2. קולות ינשופים
3. כלי נשק
4. קובץ אצווה

1. Int 21h ל-DOS
2. Int 1h ל-Windows
3. Int 0x80 ל-Windows
4. Int 13h ל-DOS

int min1(int [] arr, int first, int last)
{
	int m, i;
	m = arr[first];
	
	for (i = first + 1; i <= last; i++) {
		if (arr[i] < m) {
			m = arr[i];
		}
	}
	
	return m;
}
int min2(int [] arr, int first, int last)
{
	int m;
	
	if (first == last) {
		return arr[first];
	}
	
	m = min2(arr, first + 1, last);
	if (arr[first] < m) {
		return arr[first];
	}
	
	return m;
}

1. שתיהן טובות באותה המידה
2. הראשונה, כי השנייה עלולה לגלוש מהמחסנית
3. השנייה, כי היא רצה מהר יותר עבור מערכים גדולים
4. תלוי במהדר (קומפיילר)

1. כינוי לבעיות תאימות וגרסאות בין ספריות הרצה ב- Windows
2. וירוס שמדביק קבצי DLL שהיה נפוץ באינטרנט בשנת 2002
3. כינוי לבאג ידוע בטעינה של קבצי DLL שלא תוקן עד היום
4. שם של אחד מהספרים בסדרת Win32 Programming של Microsoft Press

1. אם A גורם ל-B, אזי B מעולם לא יגרום ל-A
2. אם A גורם ל-B, אזי B בהכרח גורם ל-A
3. אם A גורם ל-B, ו-B גורם ל-C, אזי בהכרח C גורם ל-A
4. אם A גורם ל-B, אזי B לא בהכרח גורם ל-A

1. DnsHostnameToComputerName
2. gethostbyname
3. gethostbyaddr
4. connect, ואז getpeername

1. פרגמנטציה
2. Deadlock
3. Page Fault
4. בעיות סנכרון בין Processים שונים הניגשים לאותו Heap

1. מנגנוני סנכרון מתאימים
2. הקצאת מספר Heapים, כשבכל Heap מקצים זיכרון בגודל קבוע
3. יצירת Thread ייעודי לטיפול ב- Heap
4. הגדלת כמות זיכרון ה- RAM במחשב

1. bash
2. expect
3. grep
4. perl

user code
331  Give me your password, please
Pass guru
230  Logged in successfully
TYPE I
200  Type is Image (Binary)
port 220,5,211,3,5,42
200  PORT command okay
RETR codeguru

באיזה פרוטוקול הם מתקשרים?

1. SMTP
2. POP3
3. FTP
4. HTTP
5. SSL
6. NFS
7. SNMP
8. ICMP

1. לכל Process מרחב זכרון משלו
2. כל Process יכול להכיל כמה Threads, אבל כל Thread משויך לProcess בודד
3. Process הינו סוג של Thread, שלא מתבצע בו Context Switch. (Uninteruptable thread)
4. ניתן לתקשר בין Processים ע"י מנגנוני IPC

1. Pipeline
2. Cache
3. DMA
4. זיכרון וירטואלי

1. varchar מאפשר הגדרת גודל שונה עבור כל תו במחרוזת; char מגדיר גודל קבוע לכל תו
2. char מייצג מחרוזת באורך קבוע, בעוד ש- varchar מייצג מחרוזת באורך משתנה
3. בשמירה הפיזית של הנתונים char תמיד יתפוס מקום כגודל מקסימלי של המחרוזת, בעוד ש- varchar יתפוס מקום רק כאורך המחרוזת
4. char הינו ייצוג ASCII בעוד ש- varchar הינו ייצוג Unicode

1. דחיסה שקופה
2. יוצר מערכת קבצים וירטואלית בזיכרון
3. מאפשר להריץ דברים עם הרשאות של Driver
4. מסדר את המקום הפנוי על הדיסק הקשיח בסדר רציף

1. x*y-x
2. x*y-y
3. x+y-x*y
4. modulo 2 (x*x+y*y)

1. איגוד תקינה אירופאי, אחראי בין השאר על RFCs
2. מילה בגרמנית שפירושה "לתקוף"
3. "change region", תוכנה שפורצת הגנה של כונן DVD
4. שרת ששולח רצפי תוים בלולאה אינסופית

1. select phone from table once;
2. select distinct phone from table;
3. select count(phone) from table;
4. select phone unique from table;

1. תמיכה במצב עבודה Real Mode בלבד
2. תמיכה במרחב זיכרון של 1MB בלבד
3. קיים זיכרון מטמון פנימי בתוך ה CPU, וזיכרון מטמון חיצוני על לוח האם
4. רוחב המילה של מעבד הוא שמונה סיביות בלבד. (אמנם 80X86 תמך ב- 16 סיביות, אך רק שמונה סיביות באו לידי ביטוי)

 Volume in drive C is Codeguru
 Volume Serial Number is C001-C0DE
 Directory of C:
File Not Found

לאיזה Standard file descriptors נשלחת ההדפסה?

1. STDOUT
2. STDERR
3. חלק ל-STDOUT, וה-File Not Found ל-STDERR
4. חלק ל-STDOUT, וה-File Not Found תמיד נשלח למסך (Con)
5. הכל תמיד נשלח למסך

1. הכרזה על משתנה שערכו קבוע ולא יכול להשתנות
2. הכרזה על משתנה שה-GC לא יכול להזיז בזיכרון
3. הכרזה על בלוק קוד שלא ניתן לבצע לו JIT
4. אף אחת מהתשובות לא נכונה

1. 1980
2. 1986
3. 1981
4. 1978

MOV DX, 0F8FAH
MOV CX, 1
MOV BX, 1EA0H
MOV AX, 0B8B8H
INC AX
INC AX

עליך להוסיף פקודת אסמבלי אחת בלבד בסוף הקטע, על מנת לגרום לערך שבAX להיות 4040H בסוף הריצה. איזה פקודה לא תוכל לבצע זאת?

1. ADD
2. SUB
3. MUL
4. XOR
5. LOOP

1. Minimax
2. Prim
3. חיפוש בינארי
4. Fuzzy-Logic

1. קריאה לפונקציה MoveFile
2. קריאה לפונקציה RenameFile
3. קריאה לפונקציה CreateFile עם פרמטר מתאים
4. אין דרך מסודרת – יש לקרוא את הקובץ, לכתוב אותו מחדש בשם אחר, ולמחוק את העותק המקורי

1. Hit rate גבוה, Miss rate נמוך, וMiss time גבוה
2. Hit rate גבוה, Miss rate נמוך, וMiss time נמוך
3. Hit rate נמוך, Miss rate גבוה, וMiss time נמוך
4. Hit rate נמוך, Miss rate גבוה, וMiss time גבוה

1. מיקרוסופט
2. י.ב.מ.
3. אלאדין
4. מכון ויצמן למדע

1. חלוקה ב-0
2. שינוי ה Program Counter(Instruction Pointer)
3. קריאה לפסיקת תוכנה
4. שינוי טבלת הפסיקות

1. 21
2. 20
3. 2121
4. 1024

1. שהמשתמש שמריץ אותו מקבל את ההרשאות של המשתמש שלו שייך הקובץ
2. שרק משתמש ה-Root יכול לקרוא את הקובץ
3. שהקובץ הוא קובץ Device מיוחד המפנה לממשק פיסי במערכת
4. שהקובץ בלתי ניתן למחיקה רגילה

not dx
not cx
not bx
neg ax
sbb bx, FFFFH
sbb cx, FFFFH
sbb dx, FFFFH

1. ספירת כמות הביטים הדולקים ב-4 האוגרים ax-dx
2. NOT למספר בן 64 ביט
3. שלילה למספר בן 64 ביט
4. Sign extension ממספר בן 16 ביט למספר בן 64 ביט
5. בדיקת ה-Parity של מספר בן 64 ביט

1. socket
2. pipe
3. file
4. posix semaphore

1. 802.11
2. 802.15
3. 802.3
4. 802.16

1. משתמשים בעמודים מיוחדים במנועי חיפוש שנותנים מידע על מי חיפש מה
2. מתשאלים את ה- browser שלך באמצעות JavaScript
3. משתמשים ב- Referrer Header
4. תשובות ב' וג' נכונות

1. להפריד את Hash ססמאות המשתמשים מקובץ ה-passwd, כך שמשתמשים רגילים אינם יכולים לקרוא קובץ זה
2. עותק Mirror של קובץ הססמאות, למקרה שימחק בטעות
3. קובץ בלתי נראה למשתמשים רגילים המכיל את ססמאות המשתמשים במערכת
4. גיבוי לקבצי מערכת ההפעלה
5. העתקת הBIOS מהROM לRAM

public boolean getBoolean() {
	try {
		return true;
	} finally {
		return false;
	}
}

1. true
2. false
3. תיזרק RuntimeException
4. הקוד לא מתקמפל

1. שימוש ב- incremental backup לטייפ גיבוי כל כמה שעות
2. שימוש ב- shadow copies המתרעננים כל כמה שעות
3. סקריפט המעתיק את הקבצים הקריטיים למקום בטוח כל מספר שעות
4. שימוש ב- RAID

1. FIND
2. GREP
3. FC
4. COM

char *c();

1. מצביע למערך תווים
2. מצביע לפונקציה שמחזירה תו
3. פונקציה שמחזירה מצביע לתו
4. כל התשובות נכונות

MOV AX, 0xF00D
PUSH AX
PUSH SP
MOV AX, SP
POP SP
PUSH AX
MOV CX, _____
GetOverHere:
POP SP
LOOP GetOverHere

איזה ערך ניתן לשים ב – CX על מנת שבסיום הריצה SP יכיל את הערך 0xF00D?

1. 1
2. 2
3. 3
4. 4
5. 5
6. אין ערך כזה

1. FF-FF-FF-FF-FF-FF
2. 00-00-00-00-00-00
3. 80-00-00-00-00-00
4. אי אפשר לשלוח הודעה כזו: ב Ethernet, בניגוד לIP, אין תמיכה בMulticast וBroadcast

1. פקודת IN
2. פקודת INT FF
3. פקודת CPUID
4. פקודת MOV (מכתובת קבועה)

1. 12 (מוחזר ב-3 רגיסטרים של 32 ביט)
2. 512 (מוחזר מצביע ל- sector המכיל את המחרוזת)
3. 4096 (מוחזר מצביע ל- page המכיל את המחרוזת)
4. אין מגבלה על האורך, מוחזר מצביע זיכרון חופשי

1. בכל מערכת מוגדר משתמש LocalSystem, והוא נשמר בהעתקה עם אותה סיסמה, כך שאפשר להשתמש בו כדי להיכנס
2. למרות שסיסמת administrator שונתה, ה- SID של המשתמש נשאר זהה בהעתקה
3. יצירת GUID מבוססת על כתובת ה- MAC של כרטיס הרשת, ומכיוון שה- MAC הועתק יש סיכוי ש- GUID -ים ייוצרו בצורה זהה בשתי התחנות
4. הזדהות בין מחשבים מתבצעת באמצעות כתובות ממשקי התקשורת, ומכיוון שאלו עברו בהעתקה המחשב המועתק "יסמוך" אוטומטית על המקורי כי הוא חושב שזה הוא עצמו

1. כולם דגלי TCP/IP
2. כולם מסייעים במניעת עומס ברשת
3. כולם משתמשים באסמבלי מיועל בכל המימושים
4. אין משותף לשלושה

delegate void functions();
static void f1() {
	Console.WriteLine("1");
}
static void f2() {
	Console.WriteLine("2");
}
static void Main(string args[]) {
	functions fs=new functions(f1);
	
	fs+=f2;
	fs();
}

מה יודפס על המסך בעת הרצת הקוד הנ"ל?

1. המספר 1, ומתחתיו המספר 2
2. המספר 1 בלבד, ב-delegates רגילים לא ניתן לקרוא ליותר מפונקציה אחת
3. המספר 2, ההצבה השניה דורסת את ההגדרה הראשונה בגלל שמדובר ב-delegates רגילים
4. לא ניתן לקבוע את סדר הריצה של הפונקציות ולכן אי אפשר לדעת באיזה סדר יופיעו ההדפסות על המסך

1. 64 לבנים ו-32 שחורים
2. 52 לבנים ו-36 שחורים
3. 38 שחורים ו-44 לבנים
4. 86 קלידים סה"כ

1. לא להשתמש בCascading style sheets בכלל
2. להחליף את התווים < ו > ב&gt ו-&lt במערכת שליחת ההודעות
3. להגביל את זמן החיים של ה-cookies הנשלחים אל הלקוחות בכניסה למערכת
4. למנוע הכנסת תווים מיוחדים לשאילתות SQL

1. בתוך /mnt/proc
2. בסקטור השלישי של הדיסק הראשון
3. תלוי בהגדרות ה mount לפי קובץ ה /etc/fstab
4. המידע איננו שמור על הדיסק, אלא מיוצר בזמן ריצה על ידי הקרנל

1. לפי הסטנדרט, הכתובת היא mail.example.com
2. נסתכל בכותרות של הודעה נכנסת כלשהי מאותו חבר, שם רשום שם השרת שלו
3. נחפש רשומת MX לדומיין
4. אין דרך חד-משמעית לדעת את כתובת השרת

1. פי 0.1
2. פי 1
3. פי 5
4. פי 25

1. hashCode()
2. clone()
3. toString()
4. אף אחת

1. Win98
2. Win2K
3. WinXP
4. WinNT

1. לחכות עד שתהליך כלשהו שרץ ברקע יסתיים
2. לחכות עד שתסתיים שליחת מידע ברשת
3. לחכות פרק זמן ידוע מראש
4. כל התשובות נכונות

1. מספר הבתים
2. האוגר שמתאפס
3. הסימן של ax
4. אין הבדל

1. ע"מ להקטין את הסיכון במקרה של קלט ממוין מראש
2. ע"מ להקל על האלגוריתם במקרה של קלט גדול
3. ע"מ שהפלט יהיה שונה גם עבור קלטים זהים
4. משיקולי יעילות, רנדום מאפשר קבועים קטנים יותר

1. Unit Testing
2. Code Review
3. Regression testing
4. Site Acceptance Tests
5. Integration Tests
6. Static code analysis

1. טווח מירבי של "שן כחולה" הוא שישה מטרים
2. זמן חיים מירבי של חבילת תקשורת הוא שש שניות
3. כל שני אנשים מחוברים דרך לכל היותר שישה חברים
4. לרשת טיפוסית יש שישה מרכיבי קשירות

1. const_cast
2. dynamic_cast
3. reinterpret_cast
4. static_cast

1. יש נסיון לגשת לאזור זכרון שאיננו ממופה לCache
2. יש נסיון לגשת לאזור זכרון וירטואלי שאיננו ממופה לRAM
3. יש קפיצה לאזור בקוד שאיננו בCache
4. יש הוראה התלויה בתוצאה של הוראה אחרת, שטרם הושלם ביצועה בPipeline

1. ע"י קריאה לפונקציה של ה- Kernel, הדואגת לסנכרון ה- Threads
2. ע"י נעילת פסיקות ו- Context Switches, עד שתושלם הפעולה
3. ע"י Mutex המגן על המידע
4. באמצעות פקודות אסמבלי מיוחדות של המעבד המתבצעות בצורה אטומית

INSERT INTO Person (TeudatZehut, Name) VALUES (12345678, ‘Arik’);
INSERT INTO Car (OwnerTeudatZehut, CarNumber) VALUES (12345678, 2388841);

1. שתי השאילתות יורצו בפעולה אטומית אחת, כך שאין סיכוי שמשתמש אחר יתערב בטבלאות תוך כדי
2. אם השאילתה השנייה תיכשל, הראשונה תבוטל
3. אין משמעות מאחר ואין מספר פעולות על אותה טבלה
4. לא ניתן להריץ שאילתות על מספר טבלאות בתוך transaction אחד

1. Sockets
2. Named Pipes
3. DCOM
4. הודעות WM_COPY

int *x=new int[100];
int *p=x;
*p++=*p++=1;
for (int i=2; i<100; p++){
	*p=p[-1]+p[-2];
}

מה יכיל המערך x לאחר הריצה שלו?

1. סדרה חשבונית עולה, אשר איבר הקידום שלה נמצא ב-x[2]
2. כל האיברים יכילו את הערך 1
3. שני האיברים הראשונים יכילו את הערך 1, כל היתר את הערך 0
4. סדרת פיבונצ'י

1. קפיצת חלונות שמבקשים מהמשתמש לאשר ביצוע פעולות שדורשות הרשאות גבוהות מההרשאות הנוכחיות שלו
2. Windows Messages יכולים להישלח בין desktopים שונים
3. אלא אם למשתמש יש כרטיס גרפי טוב, חלק גדול מזמן הCPU מוקדש לחישוביים גרפיים
4. חברים בקבוצת הAdministrators לא מורשים לטעון דרייברים חתומים

1. 100.0.0.1
2. 194.2.5.1
3. 201.0.1.211
4. 230.0.1.1

1. לעבור לג'אווה, אין פיתרון בC++
2. להגדיר את הירושה של istream ו-ostream כוירטואלית
3. להגדיר את הירושה של iostream כוירטואלית
4. להגדיר את שלושת הירושות המצויינות ב-ב' ו-ג' כוירטואליות

1. סינכרון חיבורי XML ב-Java
2. הצגה גרפית של עץ ב-XML
3. יצירת עמוד web בעל תוכן דינאמי המתעדכן מהשרת
4. עיצוב עמוד web בעזרת גירסאות CSS חדשות ופורמט SVG

1. תמיד נשמר גיבוי למידע שאתה רושם בזכרון בכתובת קרובה
2. Parity bit מקולקל
3. הצלבה של קווים בData bus, וקיצור של קווים בAddress bus
4. חיבור תמידי של הLSB בData bus ל-1
5. אין לי מושג, אבל לך תקנה מחשב חדש

1. למצוא מימוש יעיל של פונקציה בוליאנית
2. לנווט בGoogle Earth
3. לבחור מה סוג הFlip flop שבו צריך להשתמש
4. לחשב פעולות אריתמטיות על מספרים בינאריים

for (i=0; i<10; i++);
    putchar('-');

1. מדפיס עשרה מקפים
2. מדפיס תשעה מקפים
3. מדפיס מקף אחד
4. מחשב את היקף המעגל

class A {
public:
	A() {};
	A(const A& a) {cout<<"in copy cons"<<endl; }
	A(const A* a) {cout<<"in simple function"<<endl; }
};
void main() {
	A a;
	A b(&a);
}

מה יודפס לאחר הרצת הקוד הבא?

1. in simple function
2. in copy cons
3. שגיאת קומפילציה, הקומפיילר לא יכול להבין לאיזו מבין הבנאים להתייחס
4. אף אחת מהתשובות אינה נכונה

1. כן, הזיכרון לא מוקצה מראש בהינתן אובייקט כזה
2. לא, זה היה אפשרי אם הזיכרון לא היה מוקצה מראש, אך זה נוגד את אלגוריתמי הקצאת הזיכרון בהם משתמשים ה-containerים.
3. כן, באמצעות placement new
4. כן, באמצעות set_new_handler

1. לפי הUser-Agent שלהם
2. בעזרת שאילתה מיוחדת של פרוטוקול http
3. הוא יכול להציג דפים עם קוד DHTML שיעבוד נכון רק בIE ולערוך סטטיסטיקה ע"פ מספר המיילים הזועמים שמגיעים למערכת
4. המידע הזה נשלח כחלק מפרוטוקול PPPoE

1. שעה
2. יום
3. חודש
4. שנה

srand(time(NULL));
a=250;
cnt=0;
for (int i=0 ; i<31337 ; i++){
	int n=(rand()%(a*2))-a;
	int m=(rand()%(a*2))-a;
	if (n*n+m*m<=a*a){
		cnt++;
	}
}

1. PI
2. e
3. phi (חתך הזהב)
4. i

The system has detected an IP address conflict with another system on the network.
Network operations on this system may be disrupted as a result. 
More details are available in the system event log. 
Consult your network administrator immediately to resolve the conflict.

איך Windows יודע לזהות קונפליקט כזה?

1. ניתוח הודעות ARP העוברות ברשת
2. ניתוח הודעות DHCP העוברות ברשת
3. הוא קיבל הודעת ICMP עם Type 15(Address conflict)
4. הוא שלח הודעת Ping, אבל לא קיבל תשובה. מכאן הוא מסיק שהתשובה הגיעה למחשב אחר

1. 17
2. 18
3. 19
4. 20

1. Critical Section
2. File
3. Mutex
4. Semaphore
5. Thread
6. Process
7. Event
8. Pipe

1. לא צריך לבצע ring transition בעת שימוש באובייקט
2. לא ניתן לחלוק את האובייקט בין processים שונים
3. לא ניתן להשתמש ב- WaitForMultipleObjects על האובייקט
4. תשובות א-ג נכונות
5. אף תשובה אינה נכונה

1. מאה עצרת
2. מאה בחזקת מאה
3. שווים
4. תלוי בבסיס הספירה

1. לחסר 0101b
2. להפוך לייצוג המשלים ל-2
3. לחבר 0110b
4. השגיאה שונה בכל חיבור של שתי ספרות שונות

int f(int x) return x^(x>>1);

איזו g מקיימת את התכונה: g(f(x))==x לכל x?

1. int g(int x){
   	for (int i=16 ; i ; x^=x+i , i>>=1);
   	return x;
   }

2. 
   

   int g(int x){
   	for (int i=16 ; i ; x^=x>>i , i>>=1);
   	return x;
   }

    

3. int g(int x) return x^(x<<1);

4. int g(int x){
   	for (int i=0 ; i<=16 ; x^=x>>i , i<<=1);
   	return;
   }

1. Hamming
2. Gray
3. Manchester
4. NRZ

1. bss
2. code
3. text
4. data

1. לכל היותר 1.5 מ"ר
2. בדיוק 1 מ"ר
3. לכל הפחות 2 מ"ר
4. לכל היותר 2.1 מ"ר

המקבילה בשפת C לפקודות הללו מתואר כאן:

סלט – p++
כרוב – p–
חומוס – (*p)++
צ'יפס – (*p)–
חריף – while(*ptr){
טחינה – {
פיתה – putchar(*p)
פלאפל – *p = getchar()
שים לב כי מטרת פקודות הטחינה-חריף היא ליצור לולאות, בדומה ללולאות הWhile בשפת C.
כמו כן, לכל פקודת חריף חייבת להיות פקודת טחינה מתאימה.
הפקודות בשפה מבוצעות שורה שורה, למעט פקודות החריף-טחינה, אשר משנות את הFlow של התוכנית.
לפניך קטע קוד בשפת חומוס-צ'יפס-סלט. מעברי השורות והרווחים הם למטרות קריאות בלבד, והמהדר מתעלם מהם.
מה ידפיס קטע הקוד?
חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס
חריף
סלט חומוס חומוס חומוס חומוס חומוס חומוס
סלט חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס
סלט חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס חומוס
כרוב כרוב כרוב צ'יפס
טחינה
סלט חומוס פיתה
סלט סלט חומוס פיתה
כרוב חומוס פיתה חומוס פיתה
כרוב חומוס חומוס חומוס חומוס פיתה
סלט סלט חומוס חומוס חומוס חומוס חומוס חומוס פיתה
צ'יפס צ'יפס צ'יפס פיתה
חומוס חומוס חומוס פיתה

1. 1. לא, אין פקודת השוואה בשפה
   2. לא, מיון דורש יכולת העתקה / החלפה בין בתים

1. כן, אבל אך ורק אם נוסיף פקודה נוספת – חמוצים, אשר מבצעת swap בין ערך תא בזכרון לערך שנמצא ישר אחריו
2. כן, כי חומוס-צ'יפס-סלט היא Turing complete