דילוג לתוכן המרכזי

דף כללים במדעי המחשב לבגרות

כל הכללים לשינון לפי נושא. ההסברים, דרכי הפתרון והדוגמאות - בסיכום של כל נושא.

הורדת PDF

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

מבנה השאלונים כפי שהוא מודפס

899371: פרק א 2 מתוך 3 × 20, פרק ב 2 מתוך 3 × 30, שעתיים וחצי · 899271: פרק א 2 מתוך 3 × 25, פרק ב 2 מתוך 3 × 25 ממסלול אחד, שלוש שעות

מה במיקוד תשפ"ז ומה לא

תשפ"ז, 899371: בלי מערך של עצמים, עם מערך דו-ממדי · 899271: בלי מחסנית, בלי רשימה דו-כיוונית, בלי עץ חיפוש בינרי

מה כל שאלת מעקב מבקשת

מחזירה = טבלה + "הפעולה מחזירה..." · פלט = כל מה שמודפס בסדר · מה מבצעת = מטרה במשפט, לכל קלט · רקורסיה = שורה לכל קריאה

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

מחזירה = return · מדפיסה = void + הדפסה · חיצונית = public static · פנימית = בלי static, עם התכונות · "יש להשתמש בפעולה מסעיף..." = קוראים לה

Java מול C#: ההבדלים שחוזרים בבגרות

boolean/bool · String/string · length/Length · charAt(i)/s[i] · println/WriteLine · Queue<Integer>/Queue<int> · שמות פעולות באות קטנה/גדולה

סדרי הגודל הנפוצים

O(1) = פעולות הממשק · O(n) = מעבר אחד · O(n²) = לולאה בתוך לולאה או n קריאות ל-O(n) · O(log n) = חצייה בכל צעד

מושגי יסוד בתכנות: משתנים, ביטויים, קלט ופלט

הטיפוסים הבסיסיים

int = שלם · double = ממשי · char = תו בגרש בודד · boolean / bool = true או false · String / string = מחרוזת במירכאות

הגדרה, אתחול והשמה

הגדרה ואתחול: int count = 0; · השמה x = ביטוי; מעתיקה את ערך הביטוי ל-x · = השמה, == השוואה

מה הערך של הביטוי

7 / 2 = 3 · 7.0 / 2 = 3.5 · 7 % 2 = 1 · (double) sum / num = ממוצע ממשי · (int) 4.79 = 4, קטיעה

חלוקה ושארית על ספרות ועל התחלקות

n % 10 = ספרת האחדות · n / 10 = מוחקים את ספרת האחדות · n / 10 % 10 = ספרת העשרות · n % k == 0 = n מתחלק ב-k

סדר הפעולות וסוגריים

* / % לפני + - · אותה רמה: משמאל לימין · סוגריים קודם

קליטה והדפסה ב-Java וב-C#

קליטה: scan.nextInt() / int.Parse(Console.ReadLine()) · scan.nextDouble() / double.Parse(Console.ReadLine()) · println / WriteLine יורדות שורה, print / Write לא

שרשור מחרוזות: הסדר קובע

"sum: " + 1 + 2 = sum: 12 · "sum: " + (1 + 2) = sum: 3 · 1 + 2 + " is sum" = 3 is sum

הפעולות של Math

Math.abs · Math.max / Math.min · Math.pow(a, b) ו-Math.sqrt(x) מחזירות double · (int) Math.sqrt(n) = השורש השלם · ב-C# באות גדולה: Math.Sqrt, Math.Pow, Math.Max

תבנית: הגרלת מספר שלם בתחום

Java: rnd.nextInt(n) או (int) (Math.random() * n) = 0 עד n-1 · C#: rnd.Next(n) = 0 עד n-1, rnd.Next(a, b + 1) = a עד b

ביצוע מותנה וביצוע חוזר

פעולות השוואה ופעולות בוליאניות

== != > >= < <= · וגם && · או || · לא ! · && אמת רק אם שניהם אמת · || שקר רק אם שניהם שקר

המילים בשאלה והסימן בקוד

ומעלה / לפחות = >= · גדול מ / מעל = > · גבוה ב-10 לפחות מ-max = speed >= max + 10 · לפחות אחד מהמקרים = || · וגם = &&

ענפים נפרדים מול שרשרת else if

כמה if נפרדים = כל תנאי נבדק, כמה גופים יכולים להתבצע · if - else if - else = בדיוק גוף אחד, הראשון שמתקיים

כמה פעמים הלולאה רצה

i = 0; i < n → n סיבובים (0..n-1) · i = 1; i <= n → n סיבובים · i = low; i <= high → high - low + 1 · i < arr.length - 1 כשניגשים ל-arr[i+1]

for או while

ידוע כמה פעמים → for · נעצרת לפי תנאי או לפי ערך זקיף → while · while בודקת לפני כל סיבוב, ויכולה לא לרוץ אף פעם

תבנית: לולאת זקיף

זקיף: קליטה לפני הלולאה · while (הערך אינו הזקיף) · בגוף: טיפול, ואז קליטה של הבא כהוראה אחרונה · הזקיף לא נספר

ערך התחלתי ועדכון לכל תפקיד

צובר: 0, sum += x · מונה: 0, count++ בתנאי · דגל: false, = true בתנאי · מקסימום/מינימום: הערך הראשון · ממוצע: (double) sum / n אחרי הלולאה

רוב, חצי וממוצע

ממוצע = (double) sum / n · רוב = count > n / 2.0 · לפחות חצי = count * 2 >= n · "אחד או יותר" = דגל

הביטויים שחוזרים

ספרת אחדות = num % 10 · מוחקים אחדות = num / 10 · עשרות = (num / 10) % 10 · k ימניות = num % 10^k · k שמאליות = לחלק ב-10, len - k פעמים · חד-ספרתי = num < 10

תבנית: מעבר על כל הספרות

while (temp > 0) { digit = temp % 10; ... ; temp = temp / 10; } · מספר הסיבובים = מספר הספרות

כמה פעמים הגוף הפנימי מתבצע

n סיבובים × m סיבובים = n·m · פנימית עד i = 1 + 2 + ... + n · קריאה לפעולה עם לולאה בתוך לולאה - גם כפל

פעולות, מחרוזות ותווים

תבנית: פעולה שמחזירה ופעולה שקוראת לה

public static <טיפוס מוחזר> name(<טיפוס> p1, <טיפוס> p2) · void = לא מחזירה · return מסיים את הפעולה · בלי פרמטרים: ()

איך קוראים לפעולה, לפי מה שהיא מחזירה

int: x = f(a) · boolean: if (f(a)), !f(a) · מערך: int[] r = f(arr) · void: f(a); לבד · ארגומנטים באותו סדר וטיפוס כמו בכותרת

הפעולות של מחרוזת

אורך: s.length() / s.Length · תו: s.charAt(i) / s[i] · מקום: indexOf / IndexOf, לא נמצא = -1 · מכילה: contains / Contains · שרשור: +

תו מול מחרוזת

char: 'A' גרשיים, תו אחד, משווים ב-== · String: "A" מירכאות · s.charAt(i) / s[i] מחזירה char

מערכים

הגדרה, אתחול, גישה ואורך

int[] arr = new int[n]; - n תאים, בכולם 0 · int[] a = {2, 3, 5}; · התא הראשון a[0], האחרון a[a.length - 1] · אורך: length ב-Java, Length ב-C#

מערך כפרמטר וכערך מוחזר

מקבלת: int[] arr · מחזירה: טיפוס int[] · מערך חדש: new int[arr.length] ואחר כך return result;

משימות הסריקה

סכום sum += arr[i] · מנייה count++ · מקסימום מתחיל ב-arr[0] · קיום: return true בלולאה, false אחריה · כל: return false בלולאה, true אחריה · מקום: return i, אחרי הלולאה -1

תבנית: החלפה והזזה ימינה

החלפה: temp = a[i]; a[i] = a[j]; a[j] = temp; · הזזה ימינה: k מ-length - 1 יורד עד 1, a[k] = a[k - 1] · מערך עזר: temp[k] = ...; k++; ובסוף מעתיקים בחזרה

מה נכנס לתא, ואיזה תא

גודל = מספר הקטגוריות (קוד 0-99 → new int[100]) · מנייה: counters[x]++ · צבירה: sums[x] += value · new מאתחל ל-0

התחביר ב-Java וב-C#

Java: int[][] m = new int[r][c]; · m[i][j] · שורות m.length, עמודות m[0].length · C#: int[,] m = new int[r, c]; · m[i, j] · m.GetLength(0), m.GetLength(1)

תבנית: לולאה כפולה ואלכסונים

לפי שורות: חיצונית i, פנימית j · לפי עמודות: חיצונית j, פנימית i · אלכסון ראשי m[i][i] · אלכסון משני m[i][n - 1 - i]

מחלקות ועצמים

שלושה סוגי פעולות במחלקה

פעולה בונה = שם המחלקה, בלי טיפוס מוחזר · שאילתה = מחזירה ערך ולא משנה (get) · פקודה = void, משנה את מצב העצם (set)

this: התכונה מול הפרמטר

this.x = התכונה של העצם הנוכחי · x לבד = הפרמטר, כשיש פרמטר באותו שם

כמה פעולות בונות באותה מחלקה

כמה פעולות בונות = אותו שם, רשימות פרמטרים שונות · new בוחרת לפי הערכים שמעבירים

שאילתה או פקודה: איך כותבים כל אחת

שאילתה = טיפוס מוחזר + return, לא משנה תכונות · פקודה = void + הצבה בתכונה

toString: תיאור העצם כמחרוזת

Java: public String toString() · C#: public override string ToString() · מחזירה מחרוזת, לא מדפיסה

יצירה, זימון פעולות והפניות

new = עצם חדש · q = p = עוד הפניה לאותו עצם · == על עצמים = אותה הפניה, לא אותם ערכים

גישה לתכונות: מתוך המחלקה ומחוצה לה

בתוך המחלקה: this.x · עצם אחר: other.getX() · מחוץ למחלקה: רק get ו-set

שרשרת נקודות: מי מפעיל את מה

מחלקה מורכבת: this.birthdate.sameDate(other.getBirthdate()) · כל נקודה = פעולה של העצם שמשמאלה

רקורסיה ויעילות

תבנית: פעולה רקורסיבית שמחזירה ערך

if (תנאי עצירה) return תשובה ישירה; return צירוף(הערך הנוכחי, f(קלט קטן יותר)); · כל קריאה מתקרבת לתנאי העצירה

מה מקטינים ומה תנאי העצירה, לפי הקלט

מספר: n / 10 או n - 1, עצירה ב-n < 10 או n == 0 · שרשרת: getNext(), עצירה ב-null · עץ: getLeft() ו-getRight(), עצירה ב-null או בעלה

סוגי רקורסיה

זנב: return f(קטן) · הלוך-חזור: עבודה אחרי הקריאה · כפולה: שתי קריאות (עץ) · הדדית: A קוראת ל-B ו-B ל-A

לפני הקריאה ואחרי הקריאה

לפני הקריאה = בדרך למטה, בסדר הקריאות · אחרי הקריאה = בדרך חזרה, בסדר הפוך

מקרה גרוע ומקרה טוב בשאלות הבגרות

עונים על המקרה הגרוע ביותר, ומתארים את הקלט הגרוע · מקרה טוב = הקלט שבו הכי מעט צעדים

סכומים שחוזרים בנימוק

n+1 קריאות = O(n) · k·n = O(k·n), במקרה הגרוע O(n²) · (n−1)+(n−2)+...+1 = n(n−1)/2 = O(n²) · חלקים ברצף: הגדול ביניהם

יעילות של פעולה רקורסיבית

רקורסיה: מספר קריאות × עבודה בכל קריאה · קריאה על ההמשך + O(1) = O(n) · n קריאות × פעולה ב-O(n) = O(n²) · עץ, כל צומת פעם אחת = O(n)

תור

פעולות הממשק של Queue<T>

Queue: isEmpty()/IsEmpty() · insert(x)/Insert(x) - לסוף · remove()/Remove() - מחזיר ומוציא את הראש · head()/Head() - מחזיר את הראש בלי להוציא · כולן O(1) · אין size ואין גישה לפי מקום

הפעולות בפעולה

q.insert(q.remove()) = הראש עובר לסוף · n פעמים = סיבוב שלם, התור חוזר למצבו

תבנית: סריקה עם תור עזר והחזרת האיברים

while (!q.isEmpty()) { x = q.remove(); ...; temp.insert(x); } ואחר כך while (!temp.isEmpty()) q.insert(temp.remove());

שלוש דרכים לעבור על תור בלי לאבד אותו

תור עזר = תמיד · סימן עצירה = רק כשיש ערך שלא מופיע בתור · סיבוב = size פעמים q.insert(q.remove())

תבניות של בניית תור

פיצול = קבוצה א לתוצאה, קבוצה ב לעזר ואז לסוף התוצאה · איחוד = בכל סבב temp מחליף את התור, O(n²) · הכנסה לפי סדר = לפני הראשון שקטן ממנו, אחרת בסוף

שרשרת חוליות (רשימה חד-כיוונית)

הממשק של Node

Node<T>: new Node<T>(x) · new Node<T>(x, next) · getValue()/GetValue() · getNext()/GetNext() · hasNext()/HasNext() · setValue(x)/SetValue(x) · setNext(next)/SetNext(next) - כולן O(1)

מה אומר כל ביטוי

ריקה: lst == null · אחרונה: !p.hasNext() · הבאה: p.getNext() · הערך: p.getValue() · ערך הבאה: p.getNext().getValue() רק אם p.hasNext()

תבנית: סריקה עם הפניית עזר

Node<Integer> p = lst; while (p != null) { ... p.getValue() ...; p = p.getNext(); } · מקום: pos++ בכל סיבוב

איזה תנאי לולאה

p != null: כל החוליות · p.hasNext(): עוצרים על האחרונה · count < len && p != null: עד len או עד הסוף · שתי שרשרות: מקדמים את שתי ההפניות באותו סיבוב

תבנית: הוספה ומחיקה בקוד

בראש: lst = new Node<T>(x, lst) · אחרי p: p.setNext(new Node<T>(x, p.getNext())) · מחיקת הראש: lst = lst.getNext() · מחיקה אחרי p: p.setNext(p.getNext().getNext())

הסיבוכיות של הוספה ומחיקה

בראש או אחרי p נתון: O(1) · בסוף, לפי ערך או לפי מקום: O(n) - בגלל הסריקה

תבנית: מחזירה ערך, מחזירה שרשרת

בסיס: if (lst == null) · צעד: f(lst.getNext()) · מחזירה שרשרת: rest = f(lst.getNext()); מדלגים - return rest; או משאירים - lst.setNext(rest); return lst;

עצים בינריים

המינוח של עץ

שורש = בלי הורה · עלה = בלי בנים · רמה = קשתות מהשורש (השורש ברמה 0) · גובה = הרמה הגבוהה ביותר · עץ עם רמות 0 עד h = h + 1 רמות

פעולות הממשק BinNode

getValue/GetValue · getLeft, getRight/GetLeft, GetRight · hasLeft, hasRight/HasLeft, HasRight · setValue, setLeft, setRight · new BinNode<T>(x) · new BinNode<T>(left, x, right) · כולן O(1)

שלושת הסדרים על עץ אחד

תחילית = שורש, שמאל, ימין · תוכית = שמאל, שורש, ימין · סופית = שמאל, ימין, שורש · לרוחב = רמה אחרי רמה, בעזרת תור

מקרה הבסיס והצירוף לפי סוג השאלה

ספירה/סכום: null → 0, חיבור · גובה: null → -1, 1 + max · "האם כל": null → true, && · "האם קיים": null → false, ||

יעילות של פעולה על עץ

קריאה אחת לכל צומת = O(n) · פעולה של O(n) בכל צומת = עד O(n²)

נושא בחירה: אלגוריתמים (גרפים)

מושגים שחוזרים בשאלות

מלא: n(n−1)/2 קשתות · דו-צדדי: כל קשת בין שני הצדדים · עץ: קשיר ובלי מעגלים · קשיר היטב: מסלול מכוון בין כל שניים בשני הכיוונים

סכום הדרגות, עצים וגרף דו-צדדי

סכום הדרגות = 2·E · מכוון: סכום דרגות הכניסה = סכום דרגות היציאה = E · עץ: קשיר, בלי מעגלים, n−1 קשתות · דו-צדדי ⇔ אין מעגל באורך אי-זוגי

מטריצה מול רשימות: סיבוכיות הפעולות

מטריצה: זיכרון O(V²), בדיקת קשת O(1), שכני u ב-O(V) · רשימות: זיכרון O(V + E), שכני u ב-O(דרגת u), מעבר על כל הגרף O(V + E)

קריאת מטריצה וגרף הפוך

לא מכוון: מטריצה סימטרית · מכוון: שורה = יוצאות, עמודה = נכנסות · גרף הפוך: כל u→v הופכת ל-v→u, O(V²) במטריצה, O(V + E) ברשימות

BFS בצעדים וסיבוכיות

BFS: תור, מסמנים בכניסה לתור, d[v] = d[u] + 1 · O(V + E) ברשימות, O(V²) במטריצה · אורך מסלול = מספר קשתות

BFS כקופסה שחורה

קשירות: BFS אחד מגלה את כל V הקודקודים · רכיבים: BFS מכל קודקוד שלא סומן, סימון משותף · דו-צדדי: צביעה בשני צבעים בלי קשת באותו צבע

דייקסטרה בצעדים

דייקסטרה: בוחרים מ-T את d המינימלי, קובעים אותו, ומרפים: אם d[u] + w(u, v) < d[v] אז d[v] = d[u] + w(u, v), π[v] = u · רק משקלות אי-שליליים

סיבוכיות דייקסטרה

דייקסטרה: O(V²) במערך / מטריצה · O((V + E)·log V) עם תור עדיפויות

בלמן-פורד בצעדים וסיבוכיות

בלמן-פורד: V − 1 סבבים, בכל סבב מרפים את כל E הקשתות · O(V·E) · שינוי בסבב נוסף = מעגל שלילי

איזה אלגוריתם למסלולים קצרים ממקור יחיד

בלי משקלות: BFS · אי-שליליים: דייקסטרה · שליליים בגרף מכוון: בלמן-פורד · גמ"ל: מיון טופולוגי והרפיה, O(V + E)

DFS בצעדים וסיבוכיות

DFS: רקורסיה · O(V + E) ברשימות, O(V²) במטריצה · העץ תלוי בקודקוד ההתחלה ובסדר השכנים

BFS מול DFS

BFS: תור, שכבות, מסלולים קצרים · DFS: רקורסיה, לעומק, לא בהכרח קצר · בגרף מלא: עץ BFS כוכב, עץ DFS שרשרת

קשתות הגרף ביחס לעץ ה-DFS

לא מכוון: רק קשתות עץ וקשתות אחורה · מכוון: עץ, אחורה, קדימה, חוצות · מעגל ⇔ קשת אחורה

קשירות חזקה ורק"חים בעזרת DFS

קשיר היטב: סריקה מ-v ב-G ובגרף ההפוך מגלה את כל הקודקודים · רק"חים: DFS, גרף הפוך, DFS לפי סדר סיום יורד · גרף על: רק"ח = קודקוד, ואין בו מעגלים

מיון טופולוגי בעזרת DFS

מיון טופולוגי: DFS, וכל קודקוד שמסתיים נכנס לתחילת הרשימה · קיים רק בגמ"ל · קשת אחורה = מעגל · O(V + E) ברשימות, O(V²) במטריצה

מסלולים קצרים בגמ"ל

מסלולים קצרים בגמ"ל: מיון טופולוגי, ואז הרפיה של הקשתות היוצאות לפי הסדר · O(V + E) · גם עם משקלות שליליים

האלגוריתם של קרוסקל

קרוסקל: ממיינים קשתות בסדר עולה, מוסיפים כל קשת שלא סוגרת מעגל, עד V − 1 קשתות · O(E·log E)

עפ"מ מול עץ מסלולים קצרים

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

תכונות של עפ"מ שנשאלות

משקלות שונים ⇒ עפ"מ יחיד, אבל לא מסלול קל יחיד · משקלות שווים ⇒ ייתכנו כמה עפ"מים · הקשת הכבדה ביותר יכולה להיות בעפ"מ (כשהיא הדרך היחידה לקודקוד)

נושא בחירה: מודלים חישוביים

טבלת מעברים

אוטומט סופי דטרמיניסטי = א"ב Σ, קבוצה סופית של מצבים, מצב התחלתי, מצבים מקבלים, פונקציית מעברים: לכל מצב ולכל אות מעבר אחד בדיוק · מילה מתקבלת = המסלול מסתיים במצב מקבל

מה המצב זוכר: התבניות שחוזרות

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

פעולות על שפות

איחוד = או · חיתוך = וגם · משלים = Σ* פחות L · A·B = כל xy, x מ-A ו-y מ-B · L⁰ = {ε} · R(L) = ההיפוך של כל מילה

זהויות שכדאי לזכור

∅·L = ∅ · {ε}·L = L · R(A·B) = R(B)·R(A) · A·(B∪C) = A·B ∪ A·C · שרשור לא חילופי

רגולרית או לא: איך מזהים

שפה סופית ⇐ רגולרית · זוגיות, שארית, מונה חסום ⇐ רגולרית · השוואה בין שתי כמויות לא חסומות ⇐ לא רגולרית

תכונות הסגירות של השפות הרגולריות

הרגולריות סגורות למשלים, חיתוך, איחוד, הפרש, שרשור והיפוך · משלים = החלפת מקבלים ולא מקבלים באוטומט מלא · חיתוך ואיחוד = אוטומט מכפלה

מה לא נובע מהסגירות

חיתוך של שתי לא רגולריות יכול להיות רגולרי · תת-שפה של לא רגולרית יכולה להיות רגולרית · בודקים את השפה שיוצאת

מלא, לא מלא, לא דטרמיניסטי

מלא: בדיוק מעבר אחד · לא מלא: לכל היותר אחד, מעבר חסר = דחייה · לא דטרמיניסטי: כמה מעברים, מתקבלת אם יש מסלול מקבל · שלושתם מקבלים את אותן שפות

סימון המעברים

מעבר = אות, ראש המחסנית / דחוף X או שלוף או ללא שינוי · דטרמיניסטי: לכל מצב, אות וראש מחסנית לכל היותר מעבר אחד · מתקבלת = בסוף הקלט במצב מקבל

תבניות של מחסנית

שוויון: דוחפים על a, שולפים על b · סכום: שולפים על כל אות של הצד השני · משקל k: דוחפים k סימנים · חסום או זוגיות: במצבים · סימן ראשון מיוחד = יודעים מתי המחסנית מתרוקנת

טבלת מעברים וטבלת מעקב

x / y, R = קוראים x, כותבים y, זזים ימינה · עוצרת כשאין מעבר · מקבלת = עצרה במצב מקבל · Δ = תא ריק · אונרי: n = n אחדות

טכניקות שחוזרות

דילוג · חזרה עד תחילת הסרט · זוגיות בשני מצבים · סימון ב-x ו-Y · סבבים בזוגות · הזזה: מצב לכל אות

נושא בחירה: תכנות מונחה עצמים

העתקת הפניה מול יצירת עצם

b = a = אותו עצם · new X(a) = עצם חדש (פעולה בונה מעתיקה) · == על עצמים משווה הפניות · new X[n] = n הפניות null

הרשאות גישה

private = רק במחלקה · protected = גם ביורשת · public = בכל מקום · static = עותק אחד לכל העצמים, Class.x

תבנית: מונה עצמים

static int count גדלה בפעולה הבונה = מונה עצמים · number = count ברגע היצירה

מערך עם count

new X[n] = n הפניות null · סורקים עד count, לא עד length · הוספה: arr[count] = x; count++

ירושה ב-Java וב-C#

extends / : · super(...) שורה ראשונה / : base(...) בכותרת · super.f() / base.F() · בלי קריאה = הבונה בלי פרמטרים

דריסה מול העמסה

דריסה = אותה כותרת ביורשת, נבחרת בזמן ריצה (C#: virtual / override) · העמסה = אותו שם ופרמטרים אחרים, נבחרת בהידור

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

Base r = new Derived() תקין · (Derived) r עובר הידור, נכשל בריצה אם העצם אינו Derived · instanceof / is לפני המרה · המהדר בודק לפי טיפוס ההפניה

ירושה או הכלה

"סוג של" = ירושה, חץ ◁ אל הבסיס · "יש לו" = הכלה, תכונה מטיפוס המחלקה, ◆ בצד המכיל · תכונה משותפת = רק בבסיס

שני השלבים של כל זימון

הידור: טיפוס ההפניה + טיפוסי הארגומנטים = חתימה · ריצה: טיפוס העצם = גרסה דורסת · this.f() בתוך פעולה = לפי העצם · super.f() = הבסיס

כל האתר במבט אחד

קיצורי דרך לכל הכלים, הבגרויות והקורסים

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