lesson11

Report
‫קורס תכנות‬
‫שיעור ‪ :11‬הסוף‬
‫‪1‬‬
‫מה היום?‬
‫•‬
‫•‬
‫•‬
‫•‬
‫‪2‬‬
‫הצצה לשפת תכנות אחרת (פייתון)‬
‫הרצאה "פופולרית" בנושא ראייה חישובית‬
‫סיכום הקורס והמבחן‬
‫דוגמאות לשאלות מבחינות‬
‫הצצה לתכנות בפייתון‬
‫‪3‬‬
Python
• Python is a general-purpose, high-level
programming language
• Conceived in the late 1980’s by Guido van
Rossum at CWI in the Netherlands
• Numerous users in many domains
• Used as a first programming language in many
universities (MIT, TAU CS)
• the origin of the name is based on the television
series Monty Python's Flying Circus
4
Hello World!
5
Hands On
6
Functions
Spaces / indentation!!
7
Passing Arguments to Functions
8
If/Else
9
Logical Operators
10
Python is Lazy…
11
String Type
http://docs.python.org/tutorial/introduction.html#strings
12
Strings Structure
13
Strings Built In Methods
http://docs.python.org/release/2.5.2/lib/string-methods.html
14
Slicing
H
e
l
l
o
0
1
2
3
4
-5
-4
-3
-2
-1
15
Lists
16
Iterating Over Lists
for var in list:
value in list
print(var)
17
Lists Built In Methods
18
Range, Sum
19
‫ראייה חישובית על קצה המזלג‬
‫‪20‬‬
‫סיכום הקורס והמבחן‬
‫‪21‬‬
‫מה למדנו בקורס‬
‫• מבוא‪ :‬מה זה בעצם מחשב ומה זה תכנות‬
‫• שפת התכנות ‪ ,C‬בפרט‪:‬‬
‫•‬
‫•‬
‫•‬
‫•‬
‫פקודות קיימות בשפה (כולל פונקציות‪-‬ספריה נפוצות)‬
‫אופן יצירת "פקודות חדשות" (פונקציות)‬
‫דרכים קיימות לייצוג ועיבוד מידע (טיפוסי‪-‬משתנים‪ ,‬מערכים‪ ,‬מחרוזות‪,‬‬
‫מצביעים)‬
‫יצירת טיפוסים חדשים לייצוג מידע (מבנים‪ ,‬רשימות מקושרות)‬
‫• שימוש בתכנות ב‪ C-‬לאפליקציות שונות‪:‬‬
‫• סימולציה‬
‫• ייצוג ועיבוד תמונה‬
‫• תיקון טעויות‬
‫‪22‬‬
‫רשימת נושאי הקורס‬
‫•‬
‫•‬
‫•‬
‫•‬
‫•‬
‫•‬
‫•‬
‫•‬
‫•‬
‫•‬
‫•‬
‫משתנים וסוגיהם‪ ,‬קלט‪/‬פלט ופעולות •‬
‫חשבון‬
‫•‬
‫משפטי ‪ if‬ו‪ switch -‬ופעולות השוואה •‬
‫לולאות ‪while, for, do-while‬‬
‫•‬
‫פונקציות‬
‫•‬
‫מערכים‪ ,‬מערכים דו‪-‬ממדיים‬
‫מחרוזות‬
‫רקורסיה‬
‫מצביעים‬
‫מבנים‬
‫הקצאת זיכרון דינאמית‬
‫רשימות מקושרות‬
‫‪23‬‬
‫אלגוריתמי חיפוש ומיון‬
‫סימולציה‬
‫ייצוג ועיבוד תמונה‬
‫תיקון טעויות‬
‫הצצה לתכנות בפייתון‬
‫הבחינה‬
‫• הבחינה תערך ביום שני‪ ,5.7.12 ,‬בשעה ‪9:00‬‬
‫• משך הבחינה שלוש שעות (כלומר עד ‪)12:00‬‬
‫• אין הארכות!‬
‫• הבחינה בכתב (אין קומפיילר)‬
‫• ניתן להביא דף עזר בגודל ‪ A4‬כתוב בכתב יד משני צידי‬
‫הדף‪ .‬על כל תלמיד להכין לעצמו\ה את דף העזר‪ ,‬אין‬
‫להביא צילום‪.‬‬
‫‪24‬‬
‫החומר למבחן‬
‫החומר כולל את כל מה שלמדנו‬
‫בהרצאות (למעט מה שנלמד היום)‪ ,‬בתרגולים‬
‫ובתרגילי הבית‬
‫‪25‬‬
‫דגשים להכנה למבחן‬
‫• חזרה על המצגות והתוכניות‪ ,‬במטרה להבין את‬
‫כל הכללים‪ ,‬הדוגמאות‪ ,‬והפתרונות לתרגילים‬
‫• בחינות קודמות‬
‫• מופיעות באתר הקורס בחינות משנים קודמות‪ ,‬לחלקן מצורף‬
‫פתרון‬
‫• המבחן ללא מחשב‪ ,‬נסו לדמות את התנאים‬
‫• פתרו על דף ורק לאחר מכן בידקו את עצמכם במחשב‬
‫‪26‬‬
‫עצות כלליות למבחן עצמו‬
‫• קראו בעיון את השאלות‪ .‬הבנה של השאלה היא קריטית!‬
‫• אם תהיה אי‪-‬בהירות כלשהי לגבי ניסוח אפשר לשאול את‬
‫המרצה או את המתרגלים (שיעברו בין חדרי המבחן)‬
‫• חלקו את הזמן‪ :‬שאלות ב‪ 3-‬שעות = בערך שעה לשאלה‬
‫• סעיפים בשאלה בדר"כ קשורים אחד לשני‪ .‬ברב הפעמים‬
‫עליכם להשתמש בפתרונות לסעיפים מוקדמים ע"מ‬
‫לפתור סעיפים מאוחרים באותה שאלה‪.‬‬
‫• מותר (ורצוי) להשתמש בפתרון לסעיף בסעיפים הבאים‬
‫אפילו אם לא פתרתם אותו‪.‬‬
‫• התמודדות עם לחץ \ חרדת בחינות‪.‬‬
‫‪27‬‬
‫דוגמאות לשאלות ממבחן‬
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫שאלה ‪ 25( 5‬נקודות)‬
‫‪9‬‬
‫‪0‬‬
‫‪3‬‬
‫‪4‬‬
‫סעיף א' (‪ 5‬נקודות)‪:‬‬
‫הגדירו מבנה (‪ )structure‬אשר ישמש לייצוג רשימה מקושרת אשר תכיל‬
‫מספרים שלמים (כמו בציור)‪.‬‬
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫סעיף א' (‪ 5‬נקודות)‪:‬‬
‫הגדירו מבנה (‪ )structure‬אשר ישמש לייצוג רשימה מקושרת אשר תכיל‬
‫מספרים שלמים (כמו בציור)‪.‬‬
‫פתרון‪:‬‬
‫‪struct item‬‬
‫{‬
‫;‪int data‬‬
‫;‪struct item *next‬‬
‫;}‬
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫סעיף א' (‪ 5‬נקודות)‪:‬‬
‫הגדירו מבנה (‪ )structure‬אשר ישמש לייצוג רשימה מקושרת אשר תכיל‬
‫מספרים שלמים (כמו בציור)‪.‬‬
‫פתרון עם כתיב מקוצר‪:‬‬
‫‪typedef struct item_t‬‬
‫{‬
‫;‪int data‬‬
‫;‪struct item_t *next‬‬
‫;‪} item‬‬
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫סעיף ב' (‪ 10‬נקודות)‪:‬‬
‫כתבו פונקציה המקבלת מצביע לראש הרשימה ומחזירה את סכום המספרים‬
‫ברשימה‪.‬‬
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫סעיף ב' (‪ 10‬נקודות)‪:‬‬
‫כתבו פונקציה המקבלת מצביע לראש הרשימה ומחזירה את סכום המספרים‬
‫ברשימה‪.‬‬
‫פתרון‪:‬‬
‫מתקדמים על איברי‬
‫הרשימה וסוכמים את‬
‫הערכים שנמצאים בהם‬
‫)‪int sum_list(item *list‬‬
‫{‬
‫;‪int sum=0‬‬
‫)‪while (list != NULL‬‬
‫{‬
‫;‪sum=sum+list->data‬‬
‫;‪list=list->next‬‬
‫}‬
‫;‪return sum‬‬
‫}‬
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫סעיף ב' (‪ 10‬נקודות)‪:‬‬
‫כתבו פונקציה המקבלת מצביע לראש הרשימה ומחזירה את סכום המספרים‬
‫ברשימה‪.‬‬
‫איך ניתן היה לפתור את סעיף זה בצורה רקורסיבית?‬
‫(לא היה בשאלה המקורית – אבל היה יכול להיות‪)...‬‬
‫סכום רשימה – פתרון רקורסיבי‬
‫• תנאי עצירה‪:‬‬
‫• אם הרשימה ריקה נחזיר ‪.0‬‬
‫• קידום‪:‬‬
‫• נחשב (רקורסיבית) את סכום הרשימה שמתחילה מהאיבר השני‬
‫(אורכה קטן ב‪ 1-‬מהרשימה המקורית)‬
‫• נוסיף לסכום שקיבלנו את ערך האיבר הראשון ונחזיר את התוצאה‪.‬‬
‫‪9‬‬
‫‪0‬‬
‫‪3‬‬
‫‪4‬‬
‫סכום רשימה – פתרון רקורסיבי‬
int sum_list(item *list)
{
int sum;
if (list == NULL)
return 0;
sum = sum_list(list->next);
sum += list->data;
return sum;
}
‫תנאי עצירה‬
"‫פתרון בעיה "קטנה‬
"‫פתרון הבעיה "הגדולה‬
‫סכום רשימה – פתרון רקורסיבי‬
int sum_list(item *list)
{
if (list == NULL)
return 0;
...‫או בקיצור‬
return list->data + sum_list(list->next);
}
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫סעיף ג' (‪ 10‬נקודות) ‪:‬‬
‫כתבו פונקציה אשר תקבל מצביע לראש הרשימה‪ ,‬תשכפל את‬
‫הרשימה ותחזיר מצביע לתחילת הרשימה המשוכפלת‪.‬‬
‫שאלה ‪ 5‬ממועד א' תשס"ד‬
‫סעיף ג' (‪ 10‬נקודות) ‪:‬‬
‫כתבו פונקציה אשר תקבל מצביע לראש הרשימה‪ ,‬תשכפל את‬
‫הרשימה ותחזיר מצביע לתחילת הרשימה המשוכפלת‪.‬‬
‫שלבי הפתרון‪:‬‬
‫• נתקדם על הרשימה המקורית עד שנגיע ל‪.NULL -‬‬
‫• בכל פעם נשכפל את האיבר הנוכחי‪ ,‬ונוסיף אותו בסוף הרשימה החדשה‬
‫משתנים שנצטרך‪:‬‬
‫• מצביע לאיבר החדש (‪)new_item‬‬
‫• מצביע לראש הרשימה החדשה (‪)new_head‬‬
‫• מצביע לאיבר האחרון שהוספנו לרשימה החדשה (‪.)new_last‬‬
‫ שיכפול רשימה‬:)‫ נקודות‬10( '‫פתרון סעיף ג‬
item *duplicate(item *head)
{
item *new_item, *new_last=NULL, *new_head=NULL;
while (head != NULL)
‫מתקדמים על הרשימה המקורית‬
{
new_item=(item *) malloc(sizeof(item));
if (new_item== NULL)
‫שכפול האיבר הנוכחי‬
{
printf(“memory allocation error\n”);
exit(1);
}
new_item->data=head->data;
new_item->next=NULL;
‫אם אין עדיין איברים ברשימה‬
if (new_head == NULL)
‫ אז זה ראש הרשימה‬,‫החדשה‬
new_head=new_item;
else
new_last->next=new_item;
‫אחרת האחרון יצביע עליו‬
new_last=new_item;
‫האיבר שהוספנו הוא עכשיו האחרון‬
head=head->next;
}
return new_head;
‫מחזירים את ראש הרשימה החדשה‬
}
‫שאלה ‪ 1‬ממועד א' תשס"ח‬
‫סעיף א' (‪ 7‬נקודות)‪:‬‬
‫כתבו פונקציה בעלת המפרט (‪ )prototype‬הבא‪:‬‬
‫)‪void arr_copy(int a[], int b[], int n‬‬
‫•‬
‫•‬
‫•‬
‫•‬
‫הפונקציה מקבלת שני מערכים המכילים מספרים שלמים‪,‬‬
‫ומספר שלם אי‪-‬שלילי ‪( n‬הניחו שזה אכן מה שהיא מקבלת)‪.‬‬
‫על הפונקציה להעתיק את ‪ n‬הערכים הראשונים במערך ‪a‬‬
‫ל‪ n-‬המקומות הראשונים במערך ‪.b‬‬
‫הניחו ששני המערכים הם בגודל ‪ n‬לפחות‪.‬‬
‫ ממועד א' תשס"ח‬1 ‫שאלה‬
:)‫ נקודות‬7( '‫סעיף א‬
void arr_copy(int a[], int b[], int n){
int i;
for (i = 0; i < n; i++){
b[i] = a[i];
{
{
‫שאלה ‪ 1‬ממועד א' תשס"ח‬
‫סעיף ב' (‪ 15‬נקודות)‪:‬‬
‫כתבו פונקציה בעלת המפרט (‪ )prototype‬הבא‪:‬‬
‫‪void merge( int a[], int size_a, int b[],‬‬
‫;) ‪int size_b, int *dest‬‬
‫• הפונקציה מקבלת שני מערכים של מספרים שלמים שממויינים בסדר‬
‫לא‪-‬יורד (כלומר מקטן לגדול)‪ .‬כמו‪-‬כן‪ ,‬היא מקבלת את גדלי המערכים‪,‬‬
‫ומערך נוסף ‪.dest‬‬
‫• על הפונקציה להעתיק בצורה ממויינת את הערכים משני המערכים‪a ,‬‬
‫ו‪ ,b -‬לתוך המערך ‪.dest‬‬
‫• כלומר‪ ,‬בסיום הפונקציה המערך ‪ dest‬צריך להכיל את כל‬
‫‪ size_a + size_b‬הערכים הללו‪ ,‬והוא צריך להיות ממויין‬
‫בסדר לא‪-‬יורד (מקטן לגדול)‪.‬‬
‫• הניחו כי יש במערך ‪ dest‬מספיק מקום עבור כל הערכים המועתקים‪.‬‬
‫שאלה ‪ 1‬ממועד א' תשס"ח‬
‫‪void merge( int a[], int size_a, int b[], int size_b,‬‬
‫{) ‪int *dest‬‬
‫נשמור אינדקס נפרד לכל מערך‬
‫;‪int ia = 0, ib = 0, id = 0‬‬
‫{)‪while (ia < size_a && ib < size_b‬‬
‫{)]‪if (a[ia] > b[ib‬‬
‫;]‪dest[id] = b[ib‬‬
‫כל עוד לא הגענו לסוף אחד‬
‫;‪ib++‬‬
‫המערכים נשווה בין שני התאים‬
‫{‬
‫ונעתיק את הערך הקטן יותר‬
‫{‪else‬‬
‫;]‪dest[id] = a[ia‬‬
‫;‪ia++‬‬
‫{‬
‫;‪id++‬‬
‫{‬
‫נותר לנו להעתיק את התאים‬
‫……‬
‫שנשארו אחרי השלב הקודם‪...‬‬
‫}‬
‫ ממועד א' תשס"ח‬1 ‫שאלה‬
void merge( int a[], int size_a, int b[], int size_b,
int *dest ){
...
while (ia < size_a){
dest[id] = a[ia];
ia++;
id++;
}
while (ib < size_b){
dest[id] = b[ib];
ib++;
id++;
}
}
‫נותר לנו להעתיק את התאים‬
...‫שנשארו אחרי השלב הקודם‬
‫שאלה ‪ 1‬ממועד א' תשס"ח‬
‫סעיף ג' (‪ 12‬נקודות)‪:‬‬
‫• לפניכם הפונקציה הרקורסיבית ‪ ,merge_sort‬שממיינת את‬
‫המערך ‪ ,a‬שגודלו ‪.size‬‬
‫• הפונקציה משתמשת בפונקציות מסעיפים א' ו‪ -‬ב'‪.‬‬
‫• עליכם להשלים את הקטעים החסרים בפונקציה‪ ,‬בתוך‬
‫המסגרות (כל מסגרת היא שורת קוד)‪.‬‬
‫• הערה‪ :‬הניחו שהקצאת הזיכרון הצליחה‪.‬‬
‫תנאי‬
‫עצירה‬
return;
!‫רקורסיה‬
right, size - size/2
(int*)
size*sizeof(int)
right, size - size/2, temp
size
free(temp);
48

similar documents