איך לתרגל שאלות גנרטורים במבוא למדעי המחשב?

באתר prepd תמצאו שאלות גנרטורים במבוא למדעי המחשב ממבחנים אמיתיים של האוניברסיטה הפתוחה, אוניברסיטת תל אביב, אוניברסיטת בר-אילן, הטכניון. השאלות ממוינות לפי רמת קושי.

כמה שאלות גנרטורים יש במבוא למדעי המחשב?

באתר prepd יש עשרות שאלות גנרטורים במבוא למדעי המחשב ממבחנים, עם פתרונות לבדיקה עצמית. ניתן לסנן לפי רמת קושי, לאתר שאלות חוזרות ולתרגל ממוקד על נושא זה.

מה חשוב לדעת על גנרטורים לקראת מבחן במבוא למדעי המחשב?

גנרטורים הוא אחד הנושאים המרכזיים במבוא למדעי המחשב. תרגול שאלות ממבחנים בנושא גנרטורים הוא הדרך הכי יעילה להבין את הסגנון והדרישות של המרצים - ניתן למצוא שאלות כאלה ב-prepd, ממוינות לפי רמת קושי ואוניברסיטה.

מבוא למדעי המחשב - גנרטורים

תכנות, רקורסיה, מערכים, מחרוזות, עצים בינאריים ורשימות מקושרות

סטטיסטיקות מבחנים

רמת קושי:

שאלה 1 - סעיף א (10 נקודות)

נתון הממשק Filter<T> המכיל שיטה בוליאנית accept(T element) המחזירה ערך true אם"ם האיבר element מתקבל על ידי הפילטר.

השלימו את השיטה הבאה המקבלת עצם מטיפוס Iterable בשם someElements ועצם מטיפוס Iterable בשם someFilters. השיטה מחזירה true אם ורק אם כל אחד מהאיברים ב-someElements מתקבל על ידי לפחות מסנן אחד ב-someFilters.

ניתן להניח כי הארגומנטים אינם null, העצם someFilters מכיל לפחות איבר אחד והעצם someElements מכיל לפחות איבר אחד.

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת בן גוריוןמועד ב · 2026 · סמסטר א

★★★★★

לולאותתנאיםתכנות מונחה עצמיםשיטות סטטיותגנרטורים

שאלה 3 (25 נקודות)

תזכורת: בייצוג של גרפים בקורס זה כל קודקוד מיוצג כמספר – ומספר זה הוא השם שלו.

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

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

v

בגרף

G

, "מסלול שכן מינימלי מ-

v

" הוא סדרת קודקודים

⟨ v_{0}, v_{1}, v_{2}, \dots, v_{k} ⟩

כך ש:

•

v_{0}

הוא הקודקוד הראשון בסדרה (כלומר

v_{0} = v

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

v_{k}

, אין שכנים שלא מופיעים כבר בסדרה.
• לכל קודקוד

v_{i}

שמספרו הוא שמי במסלול שאינו הקודקוד האחרון, הקודקוד העוקב

v_{i + 1}

הוא שכן של

v_{i}

שערכו הנמוך ביותר מבין השכנים שלא הופיעו כבר לפניו במסלול.

דוגמאות: בהנתן הגרף

G

באיור משמאל וקודקוד

v

ב-

G

• עבור

v = 1

מסלול שכן מינימלי מ-1 יהיה:

⟨ 1, 0, 5 ⟩

• עבור

v = 2

מסלול שכן מינימלי מ-2 יהיה:

⟨ 2 ⟩

• עבור

v = 6

מסלול שכן מינימלי מ-6 יהיה:

⟨ 6, 3, 1, 0, 5 ⟩

• עבור

v = 3

הסדרה

⟨ 3, 1, 0 ⟩

אינה מסלול שכן מינימלי מ-3 כיוון שניתן להוסיף אליה את 5.
• עבור

v = 3

הסדרה

⟨ 3, 4, 1, 6 ⟩

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

בשאלה זו תשלימו את המחלקה GraphMinimalNeighbourPathIterator המממשת את הממשק Iterator ומייצגת איטראטור של מספרים בגרף לא מכוון

G

.

בנאי האיטרטור מקבל גרף

G

וקודקוד

v

ב-

G

. האיטרטור מחזיר בכל קריאה ל-next() את הקודקוד הבא ב-"מסלול שכן מינימלי מ-

v

".

למחלקה 3 שדות: גרף graph, מספר שלם nextVertex ושדה נוסף אותו עליכם להגדיר.

סעיף א (3 נקודות) - השלימו את בנאי המחלקה המקבל גרף graph וקודקוד vertex. יש להניח כי בגרף יש לפחות קודקוד אחד.

סעיף ב (2 נקודות) - השלימו את השיטה hasNext().

סעיף ג (15 נקודות) - השלימו את השיטה findNextVertex() המעדכנת את השדה nextVertex. קריאה לשיטה זו מתרחשת בעת קידום האיטרטור – בשיטה next().

סעיף ד (5 נקודות) - השלימו את השיטה next().

מה מייצג המשתנה?
_______________________________

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת בן גוריוןמועד א · 2026 · סמסטר א

★★★★★

גרפיםמחלקותתכנות מונחה עצמיםמעקב אחר קודגנרטורים

בשאלה הבאה נממש מחלקה שמגדירה דמיון (similarity) בין מילים. לנוחיותכם, בסוף השאלה צרפנו תיעוד של מחלקות נבחרות בפייתון שעשוי להועיל לכם.

מונחים:

כשנאמר "מילה" בשאלה, נתכוון למחרוזת של אותיות באנגלית; לצורך ניתוח סיבוכיות נניח כי אורכן של מילים חסום ע"י קבוע.
כשנאמר "קורפוס" נתכוון לרצף של מילים (ייתכן כי חוזרות על עצמן) המופרדות ברווחים בלבד.

הגדרות:

"שכונה" של מילה: בהינתן קורפוס $C$ ומילה $w$ מהקורפוס, נסמן ב- $S_{w}$ את השכונה של $w$ , שתוגדר כקבוצת כל המילים שמופיעות מייד לפני $w$ או מייד אחרי $w$ בקורפוס, וכן את $w$ עצמה. למשל, לקורפוס $" t h ec a t s a t o n t h e ma t "$ השכונה של $" t h e "$ היא ${" t h e ", " c a t ", " o n ", " ma t "}$ .
דמיון בין מילים: $s im (w_{1}, w_{2}) = \frac{∣ S _{w_{1}} \cap S _{w_{2}} ∣}{∣ S _{w_{1}} \cup S _{w_{2}} ∣}$

סעיף א. עבור הקורפוס

" t h ec a t s a t o n t h e ma t "

, תנו דוגמאות לזוגות מילים שיובילו לציוני הדמיון הנתונים:

$s im (__,__) = 1.0$
$s im (__,__) = 0.0$
$s im (__, " o n ") = 0.4$

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

m

. הניחו כי האיברים בכל רשימת קלט שונים זה מזה, כלומר רשימות הקלט הן ללא חזרות.

$f in d_in t er sec t i o n (l s t 1, l s t 2)$ — מחזירה רשימה חדשה של האיברים שנמצאים בשתי הרשימות. כל איבר יופיע פעם אחת בלבד. הפונקציה צריכה לרוץ ב- $O (m lo g m)$ במקרה הגרוע.

$f in d_u ni o n (l s t 1, l s t 2)$ — מחזירה רשימה חדשה של האיברים שנמצאים לפחות באחת הרשימות.

עליכם להשלים את המימוש של

f in d_in t er sec t i o n

, ולנתח את סיבוכיות הזמן של

f in d_u ni o n

(שכבר מומשה עבורכם) בממוצע ובמקרה הגרוע, כתלות ב-

m

.

סעיף ג. השלימו את המחלקה

W or d S im

שתייצג את הגדרת הדמיון הנ"ל. כדאי להשתמש בפונקציות העזר מסעיף ב'. עליכם להשלים את שתי המתודות

__ini t__(se l f, cor p u s)

ו-

s im_b e tw ee n (se l f, w 1, w 2)

. ב-

__ini t__

יש לאתחל את

se l f . w or d s_se t

(set של מילי הקורפוס) ואת

se l f . nb r s

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

סעיף ד. הגדרה: עבור

0 < t < 1

ומילים

w_{1}, w_{2}

נגדיר שרשרת-דמיון-

t

בין

w_{1}

ל-

w_{2}

כרצף מילים

w_{1}, u_{1}, u_{2}, \dots, u_{k}, w_{2}

, עבור

k \geq 0

, כאשר כל צמד מילים עוקב ברצף הוא בעל דמיון

\geq t

. המתודה הבאה

ha s_s im_c hain

בודקת אם קיימת שרשרת-דמיון-

t

בין

w_{1}, w_{2}

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

סעיף ה. נתונה מתודה נוספת

G e n

שמחזירה גנרטור:

(1) נתון אובייקט

w or d_s im

מהמחלקה

W or d S im

, מילה

w

מטיפוס

s t r

ופרמטר מספרי

0 < t < 1

. תארו במדויק את הקבוצה של האיברים,

s

, שתודפס בסיום קטע הקוד הבא:

(2) נסמן ב-

s_{j}

את אוסף האיברים ב-

s

לאחר

j

איטרציות של

n e x t

. הקיפו את הטענה הנכונה בהכרח:

a. $s_{j}$ מוכל ב- $s_{j + 1}$ או שהם שווים
b. $s_{j}$ מוכל ממש ב- $s_{j + 1}$
c. $s_{j}$ זר ל- $s_{j + 1}$ (אין להם איברים משותפים)
d. אף תשובה מהנ"ל אינה נכונה

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד א · 2024 · סמסטר א

★★★★★

מחלקותתכנות מונחה עצמיםמחרוזותסיבוכיות זמןרקורסיהגנרטורים

בשאלה זו שני חלקים: בחלק הראשון נפתור בעיית ספירה עם גנרטור, ובחלק השני נרחיב את אלגוריתם CYK.

סעיף א (12 נק'). ממשו את פונקציית הגנרטור

a sc_in d

המקבלת כקלט שלושה מספרים שלמים

i, j, k

ונתון כי

0 \leq i < j

וגם

k \geq 2

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

k

בדיוק מהצורה

[a_{1}, a_{2}, \dots, a_{k}]

המקיימות:
1.

a_{1} = i

a_{k} = j

.
2. לכל

1 < r \leq k

מתקיים

a_{r - 1} < a_{r}

.
3. לכל

1 \leq r \leq k

a_{r}

הוא מספר שלם.

במילים: כל סדרות המספרים העולים ממש באורך

k

בדיוק שמתחילים ב-

i

ומסתיימים ב-

j

.

סעיף ב (13 נק'). בסעיף זה נעסוק בדקדוקים חסרי הקשר. כרגיל, נשתמש באותיות גדולות לייצוג משתנים, באותיות קטנות לייצוג טרמינלים וב-

ϵ

לייצוג המחרוזת הריקה.

נתון דקדוק

t

-CNF ודקדוק כלשהו, השלימו את הפונקציה

n e w_cy k_e n v

שמשמשת כפונקציית מעטפת ל-

n e w_cy k_r ec

. הקלט: מחרוזת

s t

, מילון

r u l e_d i c t

שכל כלל בו הוא ברצורת

t

-CNF, ומשתנה ההתחלה

s t a r t_v a r

. הפלט:

T r u e

אם

s t

בשפת הדקדוק ו-

F a l se

אחרת. ניתן וצריך להשתמש בפונקציית הגנרטור

a sc_in d

כפונקציה מעטפת.

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד א · 2023 · סמסטר א

★★★★★

גנרטוריםרקורסיהדקדוק חסר-הקשר

יהא

C : {0, 1}^{k} \to {0, 1}^{n}

קוד לתיקון שגיאות. נאמר כי גנרטור

g

מייצר את

C

אם אוסף האיברים שהגנרטור מייצר הוא אוסף מילות הקוד של

C

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

n

מעל התווים

"1", "0"

.

סעיף א. לפניכם הפונקציה

d i s t an ce

המקבלת כקלט פונקציית גנרטור

co d e_g e n

, ומספר שלם חיובי

n

. הפקודה

g = co d e_g e n ()

מחזירה גנרטור

g

המייצר קוד

C

כלשהו שאורך מילות הקוד שלו הוא

n

(אין צורך לבדוק זאת). עליכם לממש את הפונקציה

d i s t an ce

כך שתחזיר את מרחק הקוד

C

.

הנחיות: (1) על הפונקציה לפעול בזיכרון

O (n)

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

co d e_g e n

דורש

O (n)

זיכרון.

סעיף ב. בסעיף זה ננתח את זמן הריצה של הפונקציה שכתבתם בסעיף א' כפונקציה של

n, k

. ניתן להניח כי שליפה של איבר בודד מהגנרטור הנוצר מהפעלה של הפונקציה

co d e_g e n

מתבצעת בזמן

O (n)

.

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

1. סיבוכיות זמן הריצה אקספוננציאלית ב-

n

ואקספוננציאלית ב-

k

2. סיבוכיות זמן הריצה פולינומיאלית ב-

n

ופולינומיאלית ב-

k

3. סיבוכיות זמן הריצה אקספוננציאלית ב-

k

ופולינומיאלית ב-

n

4. סיבוכיות זמן הריצה פולינומיאלית ב-

k

ואקספוננציאלית ב-

n

נזכיר כעת מעט מושגים הרלוונטיים לסעיפים הבאים:

קוד $(n, k, d)$ — קוד $C : {0, 1}^{k} \to {0, 1}^{n}$ המקיימת שלכל שתי מילות קוד שונות, מרחק האמינג בין מילות הקוד הוא לפחות $d$ .
תמונת הקוד — אוסף מילות הקוד: $I m C = {C (x) : x \in {0, 1}^{k}}$ .
כדור האמינג ברדיוס $r$ סביב מילה $z \in {0, 1}^{n}$ : $B (z, r) = {x \in {0, 1}^{n} : Δ (z, x) \leq r}$ .
קוד $(n, k, d)$ הוא לא טריוויאלי אם $d > 1$ .

סעיף ג. יהי

t = ⌊ \frac{d - 1}{2} ⌋

. אם

C

הוא קוד

(n, k, d)

לא טריוויאלי אזי לכל

z \in {0, 1}^{n}

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

t

מ-

z

. פורמלית:

∣ B (z, t) \cap I m C ∣ = 1

. נכון / לא נכון?

סעיף ד. אם

C

הוא קוד

(n, k, d)

לא טריוויאלי ו-

ℓ

מספר שלם המקיים כי

ℓ > ⌊ \frac{d - 1}{2} ⌋

, אזי לכל

z \in {0, 1}^{n}

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

ℓ

מ-

z

. פורמלית:

∣ B (z, ℓ) \cap I m C ∣ > 1

. נכון / לא נכון?

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד ב · 2021 · סמסטר א

★★★★★

קידודגנרטוריםסיבוכיות זמן

בשאלה זו נרצה לפתור בכמה דרכים שונות את הבעיה הבאה: בהינתן אוסף

A

של מספרים שלמים שונים זה מזה, וערך נוסף

z

, האם קיים — יחזיר

T r u e

. אחרת יחזיר

F a l se

.

בכל סעיף קבוצת האיברים ניתנת לנו בייצוג שונה.

א. ממשו את הפונקציה הבאה, הפותרת את הבעיה כאשר קבוצת האיברים ניתנת לנו כקבוצה (set) של פייתון. על זמן הריצה להיות ליניארי בגודל הקבוצה במקרה הממוצע.

ב. אם קבוצת האיברים ניתנת לנו כרשימה ממוינת

L

ואורך נוסף

z

, ניתן להפעיל את האלגוריתם הבא:

קלט: רשימה ממוינת

L

וערך נוסף

z

.
1. נגדיר משתנה

l o w = 0

.
2. נגדיר משתנה

hi g h = l e n (L) - 1

.
3. כל עוד

l o w < hi g h

3.1 אם סכום האיברים של $L$ במיקומים $l o w$ ו- $hi g h$ שווה ל- $z$ : נחזיר $T r u e$ .
3.2 אחרת אם סכום זה קטן מ- $z$ : נעדכן $l o w + = 1$ .
3.3 אחרת: נעדכן $hi g h - = 1$ .

4. נחזיר

F a l se

.

מהו זמן הריצה במונחי

O

של אלגוריתם זה כתלות באורך הרשימה

L

?

ג. כעת, הקבוצה נתונה לנו כמפתחות בעץ חיפוש בינארי

T

(כלומר אובייקט מהמחלקה

B ina r y_S e a r c h_T r ee

שראינו בכיתה). פתרון פשוט לבעיה הוא לעבור על כל איברי העץ באמצעות סיול inorder, ולכל איבר

x

שנבקר בו לבצע חיפוש כרגיל בעץ חיפוש בינארי לצומת אחר בעל מפתח

z - x

. מהי סיבוכיות הזמן של פתרון זה במקרה הגרוע כתלות ב-

n

(מספר הצמתים בעץ)?

ד. אם הקבוצה נתונה לנו כמפתחות בעץ חיפוש בינארי, ניתן לפתור את הבעיה עם אלגוריתם דומה מאוד לזה של סעיף ב, בפרט באותה סיבוכיות זמן. לשם כך נניח כי ישנן בידינו את שתי הפונקציות הגנרטור הבאות:

in or d er_g e n (T)

מחזירה גנרטור המייצר את מפתחות

T

בסדר

in or d er

. ו-

r e v or d er_g e n (T)

מחזירה גנרטור המייצר את המפתחות

T

בסדר הפוך ל-

in or d er

.

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

T

הוא עץ חיפוש בינארי. הנחיות:

עליכם לממש רעיון דומה מאוד לזה של סעיף ב.
יש להשתמש בשתי הפונקציות שבסעיף ד.
על הפתרון לעבוד בסיבוכיות זיכרון נוסף של $O (1)$ . כלומר בכל שלב על האלגוריתם לשמור בזיכרון כמות קבועה של איברים מתוך הקלט.
שימו לב: קיים פתרון פשוט שלא מייצר שום StopIteration ואליו אנו מכוונים.

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד א · 2021 · סמסטר א

★★★★★

חיפושעצים בינארייםעץ חיפוש בינאריסיבוכיות זמןגנרטורים

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

א. בהמשך מופיע מימוש פונקציית הגנרטור tree_keys_gen שמקבלת כקלט אובייקט מטיפוס עץ חיפוש בינארי (Binary_search_tree). הפונקציה מחזירה גנרטור שמייצר את כל המפתחות של צמתי העץ בסדר ממוין.

הפונקציה tree_keys_gen מפעילה פונקציית רקורסיבית tree_keys_gen_rec: כלומר פונקציה רקורסיבית שהפעלה שלה מחזירה גנרטור, קריאת ל-next() שמגיעה לפקודת return מזריקה StopIteration.

האיברים מוחזרים באמצעות הגנרטור בצורה עצלנית של קריאות ל-next().

שימו לב: בהינתן גנרטור שמתקבל מהריצה של tree_keys_gen_rec, קריאה ל-next() שמגיעה לפקודת return מזריקה StopIteration.

עבור העץ

t

שמתקבל מהכנסת המפתחות [40, 12, 60, 1, 31, 50, 70]:

השלימו את מימוש tree_keys_gen כך שסיבוכיות הזמן של שורת הקוד הבאה תהיה

O (n)

כאשר

n

הוא מספר הצמתים בעץ

t

:

דרישה מחייבת: בכל רגע נתון, הגנרטור ישמור בזיכרון את עותק של כל האיברים מהעץ (בפורט, אסור למשול לשמור בבת אחת עותק של כל האיברים).

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד א · 2020 · סמסטר א

★★★★★

גנרטוריםעץ חיפוש בינארירקורסיה

מהי סיבוכיות הזמן לייצור כל האיברים ע"י הגנרטור של many_trees_key_gen2(lst), בהנחה שהרשימה lst מכילה

k

עצים בעלי

n

צמתים כל אחד?

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד א · 2020 · סמסטר א

★★★★★

גנרטוריםסיבוכיות זמן

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

דוגמה הרצה עבור העץ

t

שמוגדר קודם והעץ

t 1

שמתקבל מהכנסת [41, 11, 56, 2, 28]:

השלימו את מימוש two_trees_keys_gen כך שסיבוכיות הזמן של שורת הקוד הבאה תהיה

O (n)

, בהנחה שכל אחד מהעצים מכיל צומת פנימי בעץ:

רמז: השתמשו בפונקציה merge2 מהסרטוות שמופיעה מטה. שימו לב שהוספנו פקודות print לפונקציה.

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד א · 2020 · סמסטר א

★★★★★

גנרטוריםעץ חיפוש בינארימיון

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

דוגמה עבור העצים

t

t 1

t 2

(כאשר

t 2

מתקבל מהכנסת [-41, 500, 110]):

להלן המימוש של הפונקציה:

עבור רשימה lst שמכילה

k

עצים בעלי

n

צמתים כל אחד, מהי סיבוכיות הזמן?

עבור קטע הקוד הבא מה יודפס (ע"י פקודות ה-print המוגדרות ב-merge2):

העתק שאלה

שתף שאלה

סמן כחשוב

סמן כבוצע

אוניברסיטת תל אביבמועד א · 2020 · סמסטר א

★★★★★

גנרטוריםעץ חיפוש בינאריסיבוכיות זמן

שאלות גנרטורים במבוא למדעי המחשב עם פתרונות

שאלות תרגול במבוא למדעי המחשב בנושא גנרטורים ממבחנים של האוניברסיטה הפתוחה, אוניברסיטת תל אביב, אוניברסיטת בר-אילן, הטכניון. השאלות ממוינות לפי רמת קושי, עם פתרונות לבדיקה עצמית - כך שניתן ללמוד מטעויות ולהבין את דרך הפתרון לפני הבחינה. ניתן לאתר שאלות חוזרות ולהריץ מבחני סימולציה ממוקדים בנושא גנרטורים.