תרגול 13: אלגוריתמי מיון, שאלות ממבחנים

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

מה היה שבוע שעבר?

•backtracking

13מבוא למדעי המחשב מ' - תירגול

והיום נלמד

•Max sort•Bubble sort•Merge sort•Quick sortבמיון • העוסקות ממבחנים שאלות

אלגוריתמי מיון

13מבוא למדעי המחשב מ' - תירגול 4

אלגוריתמי מיון – מוטיבציה

•. מיון אלגוריתמי של רבים סוגים קיימים

•? - יעיל באופן למיין רוצים כך כל אנחנו בעצם למה

חיפוש - • מאפשרת ממוינים נתונים שמירת רבות שאילתותמהיר.

13מבוא למדעי המחשב מ' - תירגול 6

Max Sortתזכורת -

• . לסוף אותו ומעבירים במערך המקסימום את מוצאים

• , כלומר מיינו לא שעדיין המערך בקטע התהליך על חוזריםקטע iבאיטרציה על התהליך את .n-i-1..0נבצע

' מס, איטרציה מ) – 2דוגמא :(0מתחילים

14 566137 2214 56 61372245

sorted

Not sorted

14 566137 2214 56 61372245

sorted

Not sorted

Maximum!

? . עדיף מה ברקורסיה או בלולאה לממש ניתן

14 566137 2214 56 6137 22 45

sorted

Not sorted

Maximum!

Max Sortמימוש בלולאה מההרצאה –

int index_of_max(int a[], int n) { int i, i_max = 0; for(i = 1; i < n; i++) if(a[i] > a[i_max]) i_max = i; return i_max;}

void max_sort(int a[], int n) { int length; for(length = n ; length > 1; length--) { int i_max = index_of_max(a, length); swap(&a[length-1], &a[i_max]); }}

Max Sortמימוש ברקורסיה –

?... עדיף מה אז : . : נוסף: מקום סיבוכיות זמן סיבוכיות O(1)בלולאה

: . : : נוסף מקום סיבוכיות זמן סיבוכיות O(n)ברקורסיה

void max_sort(int a[], int n) { if (n==1)

return; int i_max = index_of_max(a, n);

swap(&a[n-1], &a[i_max]); max_sort(a, n-1);}

Bubble Sortתזכורת -

צמודים • איברים בין ומחליפים המערך על עוברים איטרציה בכלכלומר ) נכון לא בסדר נמצאים (.a[i]>a[i+1]אשר

•. החלפות דרשה לא אשר איטרציה אחרי מסיימים

•? היותר לכל יהיו איטרציות כמה•: לדוגמא איטרציה

14 566137 2214 5661 37 2245<

14 566137 2214 5661 37 2245 > <

14 566137 2214 566137 2245 <

14 566137 2214 5637 2245 <

14 566137 2214 5637 2245

היותר • :n-1לכל איטרציות ה – • האיטרציה יהיו i, iבסיום במערך הגדולים המספרים

הנכון במיקומם– , המקסימום בדוגמא .61כמו " המערך, " לסוף הדרך כל בעבע

מסקנות:•זמן – : bubble sortסיבוכיותאיטרציה – אינדקס iבכל עד להריץ .n-i-1מספיקנוסף – מקום .O(1)סיבוכיות

Bubble Sortמימוש מההרצאה –

int bubble(int a[], int n) { int i, swapped = 0; for(i = 1; i < n; i++) if(a[i-1] > a[i]) { swap(&a[i], &a[i-1]); swapped = 1; } return swapped;}

void bubble_sort(int a[], int n) { int not_sorted = 1; while( (n > 1) && not_sorted ) not_sorted = bubble(a, n--);}

2012שאלה מתוך מועד ב' חורף

המערך • כי נניח זו שני][ aבשאלה של החלפה שבו כזה הואהפונקציה ) באמצעות . swapאיברים ביניהם( במרחק תלויה

האיבר, • החלפת , a[j]והאיבר a[i]ספציפית פעולות לוקחת. O(1)במקום על הפעולות שיתר לב שימו כה עד שהנחנו כפי

, , איברים שני של השוואה ובפרט שינוי ללא נותרות המערך(.O(1)לוקחת כרגיל ) בלבד

• , של הזמן סיבוכיות תהיה מה המתואר מהסוג מערך עבורהמיון , max sort, bubble sortאלגוריתמי מבין? איזה זאת ולאור

?) זמן ) סיבוכיות מבחינת זה במצב עדיף האלגוריתמים שני

•Max sort :האיבר לבין במערך המקסימלי האיבר בין מתבצעות החלפות

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

. פעולות תדרוש

, n-1מתבצעות max sortבאלגוריתם • איטרציה בכל מוצאים iאיטרציות

: המקסימום באינדקס, O(n-i)את לאיבר המקסימום בין , n-i-1ומחליפים

בסיבוכיות .

•: כ" סה

•Bubble sort , איברים: שני בין החלפה בועות מיון באלגוריתם , ולכן לזה זה סמוכים איברים שני בין רק מתבצעת במערך

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

הוא, • העדיף האלגוריתם .bubble sortלפיכך

Merge Sortתזכורת -

•. המערך חצאי את רקורסיבית ממיינים•." מיזוג – " מיון השם מכאן הממוינים החצאים בין ממזגים

דוגמא:•

22 56 37 61 14 45

61 14 45 22 56 37

14 45 61 56 37 22

45 14 61 37 56 22

mergemerge

Merge Sortתזכורת -

•: המשך- דוגמא

45 14 61 56 37 22

45 14 61 37 56 22

61 45 14 56 37 22

61 56 45 37 22 14

Merge Sortמימוש מיזוג מערכים –

void merge(int a[], int na, int b[], int nb, int c[]) { int ia, ib, ic; for(ia = ib = ic = 0; (ia < na) && (ib < nb); ic++) {

if(a[ia] < b[ib]) { c[ic] = a[ia]; ia++; } else { c[ic] = b[ib]; ib++; } } for(;ia < na; ia++, ic++) c[ic] = a[ia]; for(;ib < nb; ib++, ic++) c[ic] = b[ib];}

בין ממזגת a,bהפונקציה , והתוצאה ממוינים מערכים

במערך גדלי. cנשמרת. כפרמטרים נתונים המערכים

Merge Sortמימוש מיון מיזוג רקורסיבית – void merge_sort(int a[], int n){ int *tmp_array = malloc(sizeof(int) * n); internal_msort(a, n, tmp_array); free(tmp_array);}

void internal_msort(int a[], int n, int helper_array[]){ int left = n / 2, right = n – left; if (n < 2) return; internal_msort(a, left, helper_array); internal_msort(a + left, right, helper_array); merge(a, left, a + left, right, helper_array); memcpy(a, helper_array, n * sizeof(int));}

Merge Sortסיבוכיות -

מבצעים • שלב , O(n)בכל רקורסיבית וקוראים פעולותבגודל מערך עם .n/2לפונקציה

•: " הנסיגה נוסחת י ע ניתנת ריצה זמן סיבוכיות T(n)=2T(n/2)+O(n) כאשרT(1)=O(1).

•. : מיזוג, מיון של זמן סיבוכיות לכן

• : נוסף מקום עזר – O(n)סיבוכיות מערך מקצים שאנו כיווןהוא, nבגודל הרקורסיה log n: O(n+log n)=O(n)ועומק

)log( 2 nn

Quick Sort

.pivotבוחרים "• באקראי"

מ – • הגדולים האיברים שכל כך המערך את יהיו pivotמסדרים. לפניו, ממנו הקטנים האיברים וכל אחריו

• , זו פעולה , pivotאחרי אך המערך הנכון במיקומו יהיהמבולגנים להיות עלולים ממנו הגדולים או הקטנים האיברים

. שלהם באזור

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

Quick Sortמימוש -

ה – • בחירת הראשון, pivotלאחר האיבר עם אותו נחליףבמערך.

• – , ה לערך איבר כל ונשווה הכיוונים משני המערך את נסרוקPivot .

מה – • גדול איבר מצאנו לסוף מההתחלה בכיוון , pivotאם – ) מה ) קטן איבר להתחלה מהסוף השני בכיוון Pivotנחפש

. ביניהם ונחליף

22 56 37 61 14 45

22 45 37 61 14 56

Quick Sortמימוש -

ה – • בחירת הראשון, pivotלאחר האיבר עם אותו נחליףבמערך.

• – , ה לערך איבר כל ונשווה הכיוונים משני המערך את נסרוקPivot .

מה – • גדול איבר מצאנו לסוף מההתחלה בכיוון , pivotאם – ) מה ) קטן איבר להתחלה מהסוף השני בכיוון Pivotנחפש

. ביניהם ונחליף

• , , את לשים ואפשר סיימנו כזה אין .pivotאם הנכון מיקומו13מבוא למדעי המחשב מ' - תירגול

22 56 37 61 14 45

22 45 37 61 14 56

61 45 37 22 14 56

Quick Sortמימוש – void quick_sort(int a[], int n){ int p, b = 1, t = n - 1; if (n < 2) return; swap(&a[0], &a[n/2]); p = a[0]; while(b <= t) { while(t >= b && a[t] >= p ) t--; while(b <= t && a[b] < p) b++; if ( b < t) swap(&a[b++], &a[t--]); } swap(&a[0], &a[t]); quick_sort(a, t); quick_sort(a + t + 1, n – t - 1);}

Quick Sortסיבוכיות -

של • היא .quick sortהסיבוכיות הממוצע במקרה

פעם ) • כל אם למשל של ריצה בסיבוכיות מדובר הגרוע במקרה(.pivotה – המינימלי האיבר יהיה שנבחר

הממוצע – • במקרה מקום הגרוע, O(log n)סיבוכיות במקרהO(n).

)log( 2 nn

אלגוריתמי מיון - סיכום

• . בעלי הם השונים האלגוריתמים מיון שיטות מספר למדנו: שונים מאפיינים

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

זמן סיבוכיות סיבוכיות נוסף מקום

Max Sort O(1)

Bubble Sort O(1)

Merge Sort O(n)

Quick Sort : הגרוע במקרהO(nlog n)בממוצע:

: הגרוע במקרהO(log n)בממוצע:

2013שאלה מתוך מועד א' אביב

•: , שחתימתה הבאה הפונקציה את ממשוint limit_and_sort(int a[], int n, int m, int p[]);

מערך • כקלט מקבלת מספרים aהפונקציה וחיוביים של עוד, nבאורך שלמיםמצביע m>1מספר לפחות pוכן של מוקצה תאים )mלמערך כבר על(. המערך

ב – המספרים כל את למצוא היותר aהפונקציה לכל אותם mשערכם ולכתובלמערך חזרות ובלי ממוינת .pבצורה

• - ל שנכתבו המספרים מספר את להחזיר הפונקציה , pעל אם. הוא aלדוגמא: הבא המערך

int a[7] = {4, 7, 5, 4, 3, 30, 201};לתוך, n=7, m=200וכן לכתוב הפונקציה על המערך 5אז של הראשונים את pהתאים

:) לימין ) משמאל הבא התוכן

המספר את להחזיר .5וכןזמן דרישות: • נוסף O(m+n)סיבוכיות מקום O(m)וסיבוכיות

30 7 5 4 3

של • זמן בסיבוכיות למיין .O(m+n)עלינו

• . עלינו הזו בסיבוכיות עומדים לא שהכרנו המיון אלגוריתמיבתחום חסומים למיין רוצים שאנו שהמספרים בעובדה 1להשתמש

להשתמש, - mעד לנו מותר בו הנוסף המקום .O(m)ובסיבוכיות

באורך • מערך לשמור ה, – mנוכל שבמקום מספר iכך את נשמורשל . iהמופעים המערך על לעבור נוכל בסוף המקורי במערך

, . אין אז חזרות אין הזה במקרה הסדר לפי המספרים את ולהחזיררק אלא המופעים מספר את לשמור .0או 1צורך

נקרא: • אשר נפוץ מיון של פרטי מקרה למעשה זה bucketהערהsort.

int limit_and_sort(int a[], int n, int m, int p[]) {int exists[m+1];for (int i=1; i <= m; i++) // initialize exists

???// Build existsfor (int i=0; i<n; i++)

???// Fill p[]int num=0;for (int i=1; i <= m; i++)

???return num;

int limit_and_sort(int a[], int n, int m, int p[]) {int exists[m+1];for (int i=1; i <= m; i++)

exists[i] = 0;// Build indicator arrayfor (int i=0; i<n; i++)

if (a[i] <= m)exists[a[i]] = 1;

// Fill p[]int num=0;for (int i=1; i <= m; i++)

if (exists[i])p[num++]=i;

return num;}

2013/14שאלה מתוך מועד א' חורף

ישנן • רחוקה , Nבממלכה בדיוק עיר ובכל )Kערים כאשר Nתושביםכ K-ו מיסים (.define-#מוגדרים גביית מערכת קיימת בממלכה

: המערך הבאים הנתונים את המס a[N]המאחסנת סכומי את מכיל , כאשר עיר כל ה a[i]שמשלמת העיר שמשלמת הסכום .i-הוא

, id[N][K]המערך עיר כל תושבי של הזהות תעודת מספרי את מכילה השורה , i- כאשר המערך מספרי id[i][0..K-1]של את מכילה

ה בעיר התושבים של הזהות .i- תעודתסכום • פי על הערים את הממיינת פונקציה לכתוב נרצה זו בשאלה

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

המערך . aהמיון על לשמור יש זה בתהליך עולה בסדר יהיה , , ה השורה המיון לאחר גם כלומר המערכים בין במערך i- ההתאמה

id בגובה מס שמשלמת בעיר התושבים רשימת את להכיל .a[i]צריכה

• : מערכים ברשותנו המקוצרת - a[N]הגרסה עלינו. id[N][K]ו מערך את , aלמיין הסדר את לשנות כן וכמו עולה בסדר

.aלפי idבמערך

מיון • לאחר באינדקס, aאם לאינדקס iהפריט : jעבר אז, new_id[j]=old_id[i].

• : גבוהה שבסבירות כיוון סיבוכיות מ – Kדרישות נרצה, Nגדולל ביחס האפשר ככל קטנה דרישות, . K- סיבוכיות לפיכך

: הינן נוסף , הסיבוכיות זיכרון .O(1)זמן

)( 2 NKNO

• ? לדרישות בהתאם נבחר להשתמש עדיף מיון אלגוריתם באיזההסיבוכיות.

במערך • שורות שתי בין שחילוף לב זמן idנשים בסיבוכיות יהיהO(K) , לבצע. לנו מותר .O(N)לכן כאלה חילופים

יש • מיון אלגוריתם ?O(N)באיזה חילופים

•Max Sort!

במערך • פריטים בין חילופים לבצע נצטרך בוודאי , aבמימושבמטריצה שורות בין חילופים לבצע כן :idוכמו

void swap(int *a, int *b){

int tmp=*a;*a=*b;*b=tmp;

void swap_rows(int k, int town1[], int town2[]){

for(int i=0;i<k; ++i)swap(town1+i, town2+i);

•: עצמו המיון מימוש את נשלים

void sort(int a[], int id[][K]) {for(int i=N; i>1; i--) {

int max=find_max_idx(a, i);swap(a+max, a+i-1);swap_rows(K, id[max], id[i-1]);

int find_max_idx(int a[], int n) {int max = 0;for(int i=1; i<n; ++i)

if(a[i]>a[max])max=i;

return max;{

של • : swapסיבוכיות–O(1).

של • : swap_rowsסיבוכיות–O(k) עם לולאה שיש , kכיוון איטרציה כל .O(1)איטרציות

של • : find_max_idxסיבוכיות–O(n) עם לולאה שיש , nכיוון איטרציה כל .O(1)איטרציות

של • :sort: Nסיבוכיות , איטרציה בכל איטרציותל – – .O(i)<=O(N)ב - find_max_idxקריאהל – – .O(1)ב – swapקריאהל – – .O(K)ב – swap_rowsקריאהכ" – כנדרש O(N(N+K))סה

2013/14שאלה מתוך מועד ב' חורף

מערך • , sנתון אורך][ בעלות בו המחרוזות שכל ידוע כאשר מחרוזות שלהיותר לכל אותו. mשל בעלות מחרוזות כמה ייתכנו זה שבסעיף לב שימובמערך המערך. sהאורך את המקבלת פונקציה לממש את, sעליכם

המקסימאלית, nאורכו המחרוזת אורך את את, mוכן בסדר sוממיינת: , . הבא המערך עבור למשל המחרוזת אורך לפי עולה

char* s[] = { "abcde", "aa", "bc", "234114" };

את מחדש למיין צריכה :sהפונקציה הבא באופן

char* s[] = { "aa", "bc", "abcde", "234114" };

. זהה שאורכן מחרוזות בין לסדר חשיבות שאין לב שימו

סיבוכיות • זמן: דרישות בסיבוכיות לעמוד הפונקציה O(n*m)עלמקום .O(n+m)וסיבוכיות

•: מחרוזת של אורך המחזירה עזר בפונקציית להשתמש ניתןint strlen(char* str);

void sort(char* s[], int n, int m) { char *helper[n]; int lengths[n], curr=0;

for(int i=0; i<n; ++i) { helper[i]=s[i]; lengths[i]=strlen(s[i]); } for(int k=0; k<=m; ++k)//for each length for(int i=0; i<n; ++i) //copy strings of length k to s

{if(lengths[i]==k)

s[curr++]=helper[i]; }}

2008שאלה מתוך מועד א' חורף

מטיפוס • מערכים שני bומערך naבאורך aמערך: Intנתוניםכי. nbבאורך מערך, na<=nbנניח עצמו ושבכל .בפני חזרות אין

• , גודלם ואת המערכים שני את מקבלת אשר פונקציה לממש ישב – גם מופיעים אשר הערכים מספר את ב – aומחזירה bוגם

: .) המערכים) עבור לדוגמא החיתוך קבוצת גודל כלומר

תחזיר .2הפונקציה

. בכיתה שנלמדו בפונקציות להשתמש ניתן

4 5 9 1 3 1 18 10 5

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

בסיבוכיות • השאלה את לפתור בקלות בלולאה – O(na*nb)ניתןאיברים, זוג כל עבור .a[i], b[j]מקוננת שווים הם האם נבדוק

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

• , את לחפש שהצענו .O(nb)ייקח bבמערך a[i]בפתרון פעולות • , ונחפש המערכים אחד את נמיין אם החיפוש את לייעל נוכל

זמן בסיבוכיות בינארי חיפוש . O(log n)בעזרת

•? ? למיין עדיף מהמערכים איזה להשתמש נרצה מיון באיזה

• , מכירים שאנו יעיל הכי .O(n*log n)בסיבוכיות merge-sortהמיון : שלנו האפשרויות בין נשווה

" a: O(na*log na)מיון – מערך, על נעבור כ ב – bאח איבר כל . aונחפש : כ" .O(na*log na + nb*log na)=O(nb*log na)סה

" b: O(nb*log nb)מיון – מערך, על נעבור כ ב – aאח איבר כל . bונחפש : כ" .O(nb*log nb + na*log nb)=O(nb*log nb)סה

The chosen one!

int intersect(int a[], int b[], int na, int nb){

int i, count=0;merge_sort(a, na);for (i=0; i<nb; i++)}

if (binary_search(a, na, b[i]))count++;

}return count;

• . " הוא " המערך גודל שלמים מספרים של מיוחד מערך למיין ישk+m ,כאשרk , במקומות הראשונים מאוחסנים, k-1..0האיברים

. , רגיל בזיכרון מאוחסן המערך ושאר לכתיבה איטי בזיכרון

פעולות • של מינימלי מספר לבצע עלינו kל – כתיבהבעצם . המיון של הכוללת הזמן סיבוכיות במערך הראשונים האיברים

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

• : נדרשת מקום O(m)סיבוכיות

void sort_mixed(int a[], int k, int m) {int i;// the following loop performs “min sort” of// only k iterationsfor (i=0; i<k; i++) {int min_ind = find_min(a+i,k+m-i); //members in place.swap(&a[i], &a[min_ind]);

}mergesort(a+k, m);

: איטי לזיכרון כתיבות . kמספר

O(k*(k+m)+m*logסיבוכיות: m)

We can do better…

void sort_mixed(int a[], int k, int m) {int i;mergesort(a+k,m);for (i=0; i<k; i++) {

int len = min(k+1, k+m-i);ind min_ind = find_min(a+i,len);swap(&a[i], &a[min_ind+i]);

}mergesort(a+k, m);

O(k^2+m*log m)סיבוכיות:

! , לשפר אפשר עדיין מעולה זה

void sort_mixed(int a[], int k, int m) {int i;if (m>=k){

int* a_copy =(int*)malloc(sizeof(int)*(k+m));for (i=0; i<k+m; i++)

a_copy[i] = a[i];mergesort(a_copy, m+k);for (i=0; i<k+m; i++)

a[i] = a_copy[i];free(a_copy);

} else // k>m

max_sort(a, k+m);{

נובעת למקרים החלוקההמקום – סיבוכיות מדרישות

אם: .m>=k: O(m*log m)סיבוכיותניתן. k>m: O(k^2)אם לא

, זוהי לכן אחר למערך להעתיק. אופטימלית סיבוכיות

מספרים • מערך להגדיר aעבור הפרשים ניתן dif_a מערך: הבא באופן

–dif_a[0] = a[0]..dif_a[i] = a[i]-a[i-1]מתקיים i=1..n-1עבור –

לדוגמא:•

a: dif_a:

ערכים • עם מערכים לייצג ניתן הפרשים מערך שבעזרת לב שימו , למערכים הפרשים מערכי להמיר אין לכן הייצוג לתחום מחוץ

. אותם שיצרו

15 11 17 9 5 7 4 -6 8 4 -2 7

•' א פונקציה: סעיף , swapכתבו את הפרשים מערך המקבלתואינדקס שבמערך, iאורכו כך ההפרשים מערך את ומשנה

במקומות האיברים הוחלפו לו המתאים .i, i+1המספרים

עבור • : swap(dif_a, 6, 2)למשל a:

•dif:

ומקום • זמן סיבוכיות .O(1)דרישות13מבוא למדעי המחשב מ' - תירגול

4 2 -8 12 -2 74 -6 8 4 -2 7

15 11 17 9 5 7 15 11 9 17 5 7

/* note: this function assumes i < n-1 */void swap (int dif_a[],unsigned int n, int i) {

int first_val = dif_a[i];int next_val = dif_a[i] + dif_a[i+1];dif_a[i] = next_val;dif_a[i+1] = first_val – next_val;if (i < n-2) {

dif_a[i+2] += next_val - first_val;}

•' ב פונקציה: סעיף ואת sortDifכתבו הפרשים מערך המקבלתלמערך, שיתאים כך ההפרשים מערך את ומשנה אורכו

. הממוין המספרים

בדוגמא:• a:

•dif:

זמן • סיבוכיות : O(n^2)דרישות נוסף, מקום .O(1)סיבוכיות13מבוא למדעי המחשב מ' - תירגול

2 4 2 2 2 54 -6 8 4 -2 7

15 11 17 9 5 7 17 15 11 9 7 5

int bubbleDif (int dif_a[], unsigned int n) {unsigned int i;for (i=0; i<n-1; i++)

if (dif_a[i+1] < 0)swap(dif_a,n,i);

int sortDif (int dif_a[], unsigned int n) {unsigned int i;for (i=0; i<n; i++)

bubbleDif(dif_a,n-i);{

תרגול 13: אלגוריתמי מיון, שאלות ממבחנים

Documents

אלגוריתמי חיפוש לא מיודעים

מבחני מיון

בנית עצים פילוגנטיים מיון- taxonomy (...

ירקות ופירות מיון

שאלות ממבחנים - c++. מבנה הנתונים...

מיון (sorting) קלט : מערך בן n מספרים....

מערכות מיון להשכלה גבוהה ברחבי...

מיון מחרוזות

1 מבוא למדעי המחשב תרגול מספר 14...

שאלות ממבחנים לי-טל משיח...

מגישים: אנדרי זמנסקי 316931112 יבגני...

מדיניות המשרד לטיפול בפסולת קול...

איחזור מידע אלגוריתמי חיפוש ...

הכנה למבחני מיון לעבודה - מכון...

תזכיר קאפ בריאות להפצה.docx · web...