int f(int n)
{
	int k = sqrt(n);
	int i;
	for (i = 2; i <= k; i++)
		if (!(n%i))
			return 0;
	return 1;
}

function f(n : integer) : boolean;
var
	k, i : integer;
begin
	k := trunc(sqrt(n));
	f := true;
	for i := 2 to k do
		if (n mod i) = 0 then
			f := false;
end;

• בודקת האם מספר הוא מספר מושלם

• בודקת האם מספר הוא חזקה של 2

• בודקת האם מספר הוא ריבוע שלם

• בודקת האם מספר הוא ראשוני

• בנים

• בנות

• אותו דבר

• ג' לא נכון

• פרס "אתר השנה" האמריקאי

• שרתי פרוקסי

• מנוע חיפוש

• Spyware ו – Adware

• כן, כי בית הספר גדול

• כן, כי מספר הילדים הוא 1+ מספר האחים

• לא, כי אין ייצוג למשפחות ללא ילדים

• תלוי בכמות המשפחות החד-הוריות

void f(int n)
{
	int i, s;
	for(s = i = 1; i <= n; i++) {
		printf("%d\n", s);
		s += 2*i+1;
	}
}

procedure f(n : integer);
var
	i, s : integer;
begin
	s := 1;
	for i := 1 to n do
	begin
		writeln(s);
		s := s + 2*i+1;
	end;
end;

• מדפיסה סדרה חשבונית

• מדפיסה מספרים מהצורה: 2ⁿ-1

• מדפיסה ריבועים עוקבים

• מדפיסה סדרה הנדסית

• המתנה ללחיצת מקש בכל פעם שהפלט ממלא את המסך

• חילוץ שדות המופרדים באמצעות מרווח-לבן

• הפעלת שתי פקודות (או יותר) בשורה אחת

• העברת הפלט כקלט של פקודה נוספת

• זה לא יכול להיות

• יש מים גם בקליפה

• לסוכר משקל שלילי

• יש גם גרעינים

unsigned int find_max(unsigned int A[20])
{
	unsigned int max = 0;
	unsigned int imax;
	int i;
	for (i = 0; i < 20; i++) { if (A[i]> max) {
			imax = i;
			max = A[i];
		}
	}
	return imax;
}

type
	word20 = array[0..19] of word;
function find_max(A : word20) : word;
var
	max, imax : word;
	i : integer;
begin
	max := 0;
	for i := 0 to 19 do
	begin
		if A[i] > max then
		begin
			imax := i;
			max := A[i];
		end;
	end;
	find_max := imax;
end;

• מבעל הכד הגדול (שימלא ראשון) ועד לבעל הכד הקטן (שימלא אחרון)

• מבעל הכד הקטן (שימלא ראשון) ועד לבעל הכד הגדול (שימלא אחרון)

• הסדר לא משנה, הזמן הממוצע יישאר זהה

• מסתדרים לפי גודל הכדים ואז לוקחים אחד מההתחלה ואחד מהסוף לסירוגין

• תמיד קטן מ 200 מעלות

• 200 מעלות

• תמיד גדול מ 180 מעלות

• 270 מעלות

• interpreted, byte code, machine code

• byte code, interpreted, machine code

• interpreted, machine code, byte code

• byte code, machine code, interpreted

• 1/4

• 1/2

• 0

• 3/8

void be_useless(unsigned int n)
{
	while (n) n *= n;
}

procedure be_useless(n : word);
begin
	while (n <> 0) do n := n * n;
end;

y1*x2-y2*x1 > 0

• חישוב היקף של מקבילית

• בדיקה האם וקטורים נמצאים באותו הרביע

• בדיקת כיוון של פניה

• השוואה בין גדלי וקטורים

(15 * X) mod 17 = 1

• פתרון יחיד

• אינסוף פתרונות

• אין פתרונות בכלל – כי 15 > 1

• אין פתרונות כי Z₁₇ אינו שדה

• NASDAQ

• הבורסה בטוקיו

• NYSE

• הבורסה בת"א

• לחלק הקדמי

• לחלק האחורי

• לחלק הימני

• תלוי בכיוון הסיבוב

mov ax, 3
int 10

• מאתחל התקשרות סיריאלית

• מקצה מערך בגודל 30 בתים

• מקצה מערך בגודל 3 בתים

• עובר למצב טקסט

• 27

• 54

• 81

• 108

• כן, כן

• כן, לא

• לא, כן

• לא, לא

/codeguru6/stage_a/contestant[@score>55]

• Python

• TCShell

• XPath

• Perl

• יותר מ – 140 שעות עבודה

• פחות מ – 53 שעות עבודה

• אף פעם

• אף אחת מהתשובות א'-ג' אינה נכונה

xor ax, bx
xor bx, ax
xor ax, bx

• מפעיל פונקציית גיבוב פשוטה

• שוזר את ax ו – bx

• מחליף בין ערכי אוגרים

• מבצע פעולת איפוס מהירה

• x^xln(x + 1)

• x^x(ln(x) + 1)

• xln(x + 1)

• x(ln(x) + 1)

• בערך 30 ס"מ

• בערך 2 מטר

• בערך 900 מטר

• בערך 12 ק"מ

• בעזרת קודי האפמן (Huffman Coding)

• בעזרת קודי ריד-סולומון (Reed-Solomon Coding)

• בעזרת קוד אריתמטי (Arithmetic Coding)

• בעזרת קוד דה-וינצ'י (Da-Vinci Code)

רבםו חציקטצ בםגקעורו

• אצבעות זזו בכתיבה עיוורת

• ביט lsb התהפך

• כתיבת אנגלית באותיות עבריות

• לכל מילה תשובה אחרת

unsigned char i;
for (i = 0; i <= 255; i++)
	printf("*");

• 255

• 256

• אינסוף

• 0

8, 49, 216, 625, 1024, 729, ..

• לא ניתן לשנות את הקוד שלהן בזמן ריצה

• הן מפחיתות את כמות הזכרון המוקצה להחזקת קוד

• הן אינן יכולות לשנות את הפרמטרים המוכנסים אליהן

• הן אינן יכולות לגשת למשתנים חברים במחלקה שלהן

• 1 ל – 64000

• 1 ל – 64000!

• 1 ל – 64000⁶⁴⁰⁰⁰

• 64000! ל – 64000⁶⁴⁰⁰⁰

struct node {
	node* left;
	node* right;
	int val;
};
int traverse(node* root)
{
	int current_max = root->val;
	if (root->left != NULL)
		current_max = max(current_max, traverse(root->left));
	else if (root->right != NULL)
		current_max = max(current_max, traverse(root->right));
	return current_max;
}

type
	nodeptr = ^node;
	node = 	record
			left, right : nodeptr;
			val : integer;
		end;
function traverse(root : nodeptr) : integer;
var
	current_max : integer;
begin
	current_max := root^.val;
	if root^.left <> NIL then
		current_max := max(current_max, traverse(root^.left))
	else if root^.right <> NIL then
		current_max := max(current_max, traverse(root^.right));
	traverse := current_max;
end;

• מוצאת את הערך המקסימלי בעץ בינארי

• מוצאת את הצומת השמאלי ביותר מבין הצמתים שערכם מקסימלי

• מוצאת את הערך המקסימלי במעטפת הימנית של עץ בינארי

• אף אחת מהתשובות הקודמות אינה נכונה

• לא, משום שחלק מהמים מתאדה (בדומה לחוסר יעילות בתכנות)

• לא, כי תוספת הנוזלים הנובעת מהשימוש בשירותים זניחה

• כן (זמנית), בגלל מתקני ה"ניאגרה" (או בעברית: מיכלי ההדחה) המתפקדים כחוצצים (buffers)

• כן (באופן מתמשך), כפי שאפשר לשחרר יותר זיכרון מאשר הוקצה

• להכניסם מהכביסה בצד שמאל של המגרה ולהוציא מצד ימין (כמו תור)

• להכניסם מהכביסה בצד שמאל של המגרה ולהוציא מצד שמאל (כמו מחסנית)

• להכניסם מהכביסה בצד שמאל של המגרה ולהוציא באופן מקרי

• להכניסם מהכביסה באופן מקרי ולהוציאם באופן מקרי

struct node {
	int data;
	node* next;
};
int f(node* h, int c)
{
	node* p = h;
	int i;
	while (1) {
		for (i = 0; i < c; i++) { if (p == NULL) return h->data;				
			p = p->next;
		}
		h = h->next;
	}	
}

type
	nodeptr = ^node;
	node = record
 data : integer;
		 next : nodeptr;
	 end;
function func(h : nodeptr; c : integer) : integer;
var
	p : nodeptr;
 i : integer;
begin
	p := h;
	while true do
	begin
		for i := 0 to c-1 do
		begin
			if p = NIL then
			begin
				func := h^.data;
				exit;
			end;
			p := p^.next;
		end;
		h := h^.next;
	end;
end;

int A[N];

var
	A : array[0..N-1] of integer;

• ב – C: A[N%c], בפסקל: A[N mod c]

• ב – C: A[N-c], בפסקל: A[N-c]

• ב – C: A[N/c], בפסקל: A[N div c]

• ב – C: A[c%N], בפסקל: A[c mod N]

• להשתמש רק במספרים דו ספרתיים נמוכים

• לוודא שרק מעט מבין המספרים יתחלקו ב – 37

• לוודא שרק מעט מבין המספרים לא יתחלקו ב – 13

• לשים את המספר 111 בעשרה מוצרים בלבד

• כמעט אחוז אחד

• אחוז אחד

• כשלושים אחוז

• חמישים אחוז

• 30 אגורות

• או 0 או 50 אגורות

• 70 אגורות

• כל עשרת האפשרויות שוות הסתברות

• 225, כי שטח הוא כפולת אורך ברוחב

• 15, כי x כפול y = y כפול x

• 8, כי אפשר לייצג 2^x אפשרויות ב x ביטים

• 7, כי 120 קטן מ 128

• לפחות 4, כי יש גם בנים בכיתה

• בדיוק 2, כי 100-98=2

• לכל היותר 2, כי יהושוע הוא בן

• אפס, כי אין כיתה מעל 50 תלמידים

• בין שנת 0 לשנת 314

• בין שנת 314 לשנת 5000

• בשנת התשס"ה

• לעולם לא

• שכבת האטמוספרה העבה יותר קרוב לאופק משמשת כעדשה המגדילה את מראה השמש והירח

• בגלל הכבידה השמש והירח גדלים כאשר הם מתקרבים לאדמה

• זה סתם נדמה לנו. הם לא באמת נראים גדולים יותר – הכל פסיכולוגיה!

• העין שלנו רואה גופים בעלי גוון אדמדם כגדולים יותר

• חיים נחמן ביאליק

• רבינדרנט טאגור

• סמואל בקט

• שאול טשרניחובסקי