C תפשב םדקתמ תונכת םיליגרת תרבוח - - 1

Transcript

1 תכנות מתקדם בשפת C חוברת תרגילים - 1 -

2 קלט פלט. MaxMult MaxMult שאלה א. כתבו תוכנית המדפיסה לוח כפל בגודל 10 ב. כתבו תוכנית המקבלת מספר,,MaxMult ומדפיסה לוח כפל בגודל לדוגמא עבור: MaxMult=4 יודפס: הנחיות לשני הסעיפים ההדפסות צריכות להיות בצורת טבלה ועל כל שדה בטבלה להיות מיושר לימין (כך שבכל טור ספרת האחדות תהיינה אחת מעל השנייה, ספרת העשרות תהיינה אחת מעל השנייה, וכך הלאה עבור כל הספרות) הקפידו לא להכניס רווחים מיותרים (לפני המספר שבפינה הימנית תחתונה צריך להופיע רווח אחד בדיוק). שאלה כתבו את הפונקציה: void printformattedintegers(char* format, char* numbers) הפונקציה מקבלת כקלט מחרוזת,,format המכילה פורמט להדפסה של מספרים וכן מחרוזת,,numbers המכילה מספרים שלמים בבסיס דצימלי מופרדים במספר כלשהו של רווחים לבנים. על הפונקציה להדפיס את המספרים מהמחרוזת,numbers בהתאם לתווי ההסבה שב- format. כך שתו ההסבה הראשון ב- format יקבע כיצד ייוצג המספר הראשון ב- numbers, תו ההסבה השני יקבע כיצד ייוצג המספר השני וכך הלאה (בדומה ל- printf ). מחרוזת הפורמט יכולה להכיל את תווי ההסבה הבאים (כמו ב- :(printf d% ממיר int לטקסט המכיל ייצוג עשרוני של המספר x% ממיר int לטקסט המכיל ייצוג הקסהדצימלי (בסיס 16) של המספר o% ממיר int לטקסט המכיל ייצוג אוקטלי (בסיס 8) של המספר וכן מחרוזת הפורמט יכולה להכיל את תווי ההסבה הבאים אשר אינם חוקיים ב- :printf b% ממיר int לטקסט המכיל ייצוג בינארי (בסיס ) של המספר r% ממיר int לטקסט המכיל ייצוג רומי של המספר כמו כן מחרוזת הפורמט יכולה להכיל תווים שאינם תווי הסבה, אשר מודפסים כמו שהם. - -

3 דוגמאות: הקריאה: printformattedintegers("dec: %d Hex: %x Roman: %r"," ") תגרום להדפסת הפלט: Dec: 13 Hex: A Roman: IX הקריאה: printformattedintegers("%b in Binary is %o in Octal","18 18") תגרום להדפסת הפלט: in Binary is in Octal היעזרו בוויקיפדיה כדי למצוא את התיאור המלא של שיטת הספירה הרומית: חפשו את הערך:"ספרות רומיות" הניחו כי הקלט לפונקציה תקין, כלומר הניחו כי המחרוזת numbers אכן מכילה מספרים שלמים מיוצגים בבסיס 10 ומופרדים ברווח לבן וכי format מכיל מחרוזת פורמט חוקית וכן שמספר תווי ההסבה במחרוזת הפורמט מתאים למספר המספרים שהתקבלו במחרוזת.numbers השתמשו ככל הניתן בפונקציות הקלט/פלט שנלמדו בשיעור printf,scanf,sscanf,sprintf וכו'. ניתן להיעזר בפונקציה strtok (חפשו תיעוד המסביר כיצד להשתמש בה) אך בהחלט ניתן להסתדר גם בלעדיה. הגדירו פונקציות עזר וחלקו את הבעיה לתת בעיות. הנחיות:

4 מצביעים והקצאות דינאמיות int** pointersort(int* arr, int size); שאלה 1 א. כתבו את הפונקציה: הפונקציה מקבלת כקלט מערך של מספרים שלמים,,arr ואת גודלו,.size על הפונקציה להחזיר מערך של מצביעים, כך שהמצביעים במערך יצביעו על איברי arr בצורה ממוינת מהקטן לגדול. כלומר, המצביע בתא ה- 0 של המערך המוחזר מצביע לאיבר המינימלי. הערה: ממשו את המיון בשיטת.merge-sort arr = לדוגמא: אם המערך arr הוא אז המערך המוחזר יהיה: ב. כתבו גרסא נוספת לפונקציה. הפעם כותרת הפונקציה תהיה: void pointersort(int* arr, int size, int*** pointers); הפונקציה מקבלת מערך של מספרים שלמים,,arr ואת גודלו,.size הפעם על הפונקציה להחזיר כפרמטר פלט את מערך המצביעים. שאלה בהינתן פולינום עם מקדמים שלמים מהצורה: n CX + C X CX + C n n 1 1 n כל איבר בפולינום נקרא מונום. נגדיר רשומה לייצוג מונום כנ"ל באופן הבא: typedef struct monom{ המקדם// coefficient; int int power; החזקה// }Monom; מבנה הנתונים לייצוג פולינומים: מערך של רשומות מטיפוס,Monom המקיים: המערך לא יכיל מונום שמקדמו 0. המונומים במערך יופיעו בסדר חזקות יורד ממש (כלומר המונום עם החזקה הגדולה ביותר יופיע בתא הראשון במערך). כתבו תוכנית הקולטת מהמשתמש שני פולינומים, ומדפיסה את פולינום הסכום שלהם ואת פולינום המכפלה שלהם, כל אחד בשורה נפרדת. הערות: 1. כל פולינום בקלט יהיה שורה באורך לא ידוע של זוגות (מקדם וחזקה). כך למשל השורה: מייצגת את הפולינום: 5x 8. 8x + 7x. הדפסת פולינום צריכה להיות בסדר חזקות יורד, ללא מקדמים שהם x^4 + 7x^3-5x - 8 יש להדפיס: 8x + 7x 5x 8 למשל את הפולינום : - 4 -

5 שאלה 3 כתוב תוכנית הקולטת שורות טקסט מהמשתמש ואוגרת אותן במערך של מחרוזות. התוכנית תקלוט בהתחלה מספר הקובע את גודל המאגר, ולאחר מכן תקלוט שורות אותן תכניס למאגר. במידה והמאגר מתמלא, יש "לזרוק" את השורה הותיקה ביותר. בנוסף לתחזוקה של מבנה הנתונים המתואר לעיל, על התוכנית לאפשר למשתמש לשחזר שורות מתוך פקודות השחזור ניתנות כאן: המאגר. משחזרת את השורה האחרונה שהוכנסה למאגר.!! במידה ואין כזו - תודפס הודעת שגיאה. משחזרת את שורה מספר n.!n (מספרי השורות ניתנים באופן רציף מתחילת התוכנית ועד סיומה) במידה ואין משחזרת את השורה האחרונה שהתחילה ב- str מהמאגר.!str כזו, תודפס הודעת שגיאה. כל שורה תופיע אחרי מספר השורה. מדפיסה את תוכן המאגר.!print (מספרי השורות ניתנים באופן רציף מתחילת התוכנית ועד סיומה) יציאה.!quit שחזור שורה פירושו להדפיס את השורה המשוחזרת. אם השחזור הצליח, יש להכניס למאגר את השורה המשוחזרת כולה. אחרת, אין להכניס דבר למאגר. דוגמת הרצה (הקלט מהמשתמש מופיע בפונט מודגש ונטוי והפלט שהתוכנית מדפיסה מופיע בפונט רגיל) Please enter the history storage size > 5 The storage size was set to 5 > some text > some more text > and more text >! some more text > hello world >!! hello world >!! hello world >! Could not restore line number, currently lines 3-7 are in the storage >!print 3. and more text 4. some more text 5. hello world 6. hello world 7. hello world >!some some more text >!quit Thanks for using the history application, bye bye הערות 1. לא ניתן להניח אורך שורה מקסימאלי. ניתן להניח כי כל שורה שאינה פקודת שחזור תתחיל באות אנגלית 3. פתרון יעיל הוא פתרון אשר פעולת הכנסה למאגר תתבצע בזמן (1)O - 5 -

6 שאלה 4 כתוב פונקציה המקבלת שני פרמטרים שהם שתי מחרוזות. הפונקציה מוציאה מן המחרוזת הראשונה את כל התווים המופיעים במחרוזת השנייה. הפונקציה מחזירה מחרוזת חדשה המכילה את הרצף המכווץ. heo word" לדוגמא: l ) strsqz ("hello world", תוציא אם הפונקציה הופעלה בשנית, עם פרמטר ראשון שהוא המחרוזת הריקה ("" או,(NULL יש לבצע את הכיווץ על תוצאת ההפעלה הקודמת של הפונקציה. תוציא wd". he לדוגמא: strsqz (NULL, "or") - 6 -

7 רשימות מקושרות שאלה 1 נתונים המבנים הבאים לייצוג רשימה מקושרת של תווים: typedef struct list_node { char* dataptr; struct list_node* next; }ListNode; typedef struct list { ListNode* head; ListNode* tail; }List; נתונה רשימה מקושרת שנתוניה הם ספרות, ואותיות אנגליות קטנות בלבד. הרשימה המקושרת במקורה הכילה את המידע הבא על תלמיד: שמו הפרטי של התלמיד (המופיע באותיות קטנות) אות אחר אות ברשימה, ואחריו מופיע ציונו הממוצע (הניתן בספרות המייצגות מספר חיובי שלם) סיפרה אחר סיפרה ברשימה. לרוע המזל, כתוצאה מבאג במחשב, נשזרו התווים אלו באלו, והתקבלה רשימה מעורבלת. דוגמה: רשימה שבמקור הכילה את התווים mully94 כאשר m היה הנתון בצומת הראשון, u היה הנתון בצומת השני, וכ"ו (כלומר שמו הפרטי הוא,mully וציונו 94), שונתה וכעת היא מכילה את התווים: m9ul4ly (כאשר m הוא הנתון בצומת הראשון, 9 הוא הנתון בצומת השני, וכ"ו). שימו לב כי סדר התווים והספרות המקורי נשמר בתוך הערבול. (לדוגמא, u יבוא אחרי l m, יבוא אחרי u, וכו'). כתבו פונקציה המקבלת רשימה מעורבלת ומחזירה מבנה לייצוג תלמיד (שיוגדר להלן) המכיל את שמו הפרטי ואת ציונו הממוצע של התלמיד המתקבלים מהפרדת המילים ברשימה המעורבלת. Student unscramble (List lst); ה prototype של הפונקציה הוא: כאשר מבנה של תלמיד מוגדר להלן: השדה והשדה typedef struct student { List first; int grade; } Student; first הוא רשימה המייצגת את שמו הפרטי של הסטודנט אות אחר אות. grade הוא מספר המייצג את ממוצע ציוניו של הסטודנט. אין להשתמש בהקצאה דינאמית, אלא לשנות מצביעים ברשימת הקלט. הערות: - 7 -

8 שאלה נתונה ההגדרה הבאה לייצוג רשימה מקושרת של מספרים שלמים: typedef struct listnode{ int* dataptr; struct listnode* next; }ListNode; typedef struct list { ListNode* head; ListNode* tail; }List; List merge(list lst1, List lst); כתבו את הפונקציה הבאה, בארבע גרסאות: הפונקציה מקבלת כקלט lst1 ו- lst, שתי רשימות מקושרות ממוינות בסדר עולה של ערכים עליהם מצביעים השדות.dataPtr על הפונקציה למזג את שתי הרשימות לרשימה ממוינת אחת המכילה את כל האיברים של רשימות הקלט. על הפונקציה להחזיר את הרשימה הממוזגת. א. ב. ג. בגרסא זו, הפונקציה איננה רקורסיבית ועליה ליצור רשימה חדשה. הפונקציה לא תשנה הצבעות ברשימות lst1 ו- lst (בסוף ריצת הפונקציה שתי הרשימות נותרות ללא שינוי). בגרסא זו, הפונקציה איננה רקורסיבית ועליה למזג את שתי הרשימות לרשימה אחת ממוינת ע"י שינוי מצביעים בלבד (ללא שימוש בהקצאות חדשות). בגרסא זו, הפונקציה רקורסיבית ועליה ליצור רשימה חדשה. ד. בגרסא זו, הפונקציה רקורסיבית ועליה למזג את שתי הרשימות ע"י שינוי מצביעים. הערה: בסעיפים ג' ו- ד' הפונקציה אינה חייבת להיות רקורסיבית בעצמה, היא יכולה להיות פונקציה העוטפת פונקציה רקורסיבית (פונקציה אשר מפעילה לפונקציה רקורסיבית)

9 שאלה 3 נתונה ההגדרה הבאה לייצוג רשימה מקושרת של מספרים שלמים: typedef struct listnode{ int* dataptr; struct listnode* next; } ListNode; typedef struct list { ListNode* head; ListNode* tail; } List; ניתן לייצג מספר טבעי גדול בעזרת רשימה של ספרותיו לפי הסדר כאשר הצומת הראשון ברשימה מכיל מצביע לספרה הימנית והצומת האחרון מכיל מצביע לספרה השמאלית. למשל את המספר 197 נייצג ברשימה: א. כתבו את הפונקציה: num); void printnumber(list שמקבלת מספר המיוצג ברשימה כפי שתואר, ומדפיסה אותו. (הפונקציה יכולה להיות רקורסיבית או איטרטיבית לפי בחירתכם). ב. כתבו את הפונקציה: sum); void addnumbers(list n1, List n, List* שמקבלת רשימות שמייצגות שני מספרים ומצביע לרשימה שלישית ומעדכנת את sum להצביע על רשימה השלישית המייצגת את סכום המספרים. ג. כתבו את הפונקציה: prod); void multnumbers(list n1, List n, List* שמקבלת רשימות שמייצגות שני מספרים ומצביע לרשימה שלישית, ומעדכנת את prod להצביע על רשימה השלישית המייצגת את מכפלת המספרים. הערה: בסעיפים ב' ו- ג' אין להשתמש באלגוריתם הממיר את המספרים המיוצגים ברשימות למשתנים מטיפוס int או double ולבצע את החיבור והכפל עליהם (גישה כזו מחמיצה את המטרה של ייצוג המספרים ברשימה)

10 typedef struct dlistnode{ int* dataptr; struct dlistnode* next; struct dlistnode* prev; }DListNode; שאלה 4 נתון המבנה הבא לייצוג רשימה מקושרת דו-כוונית: typedef struct dlist { DListNode* head; DListNode* tail; }DList; כתבו את הפונקציה: void removeduplicates(dlist* lst); הפונקציה מקבלת מצביע לרשימה דו-כוונית של ציוני מבחן פסיכומטרי, בה כל צומת מכיל מצביע לציון של מבחן (כל ציון הינו מספר שלם בין 00 ל- 800). כל ציון יכול להופיע יותר מפעם אחת. על הפונקציה לשנות את הרשימה המקורית כך שכל ציון יופיע בה פעם אחת בלבד. על הפונקציה לעדכן את lst להכיל את הרשימה המצומצמת ולשחרר את הזיכרון של הצמתים שהוסרו. הערה: ממשו פתרון יעיל ככל הניתן

11 typedef struct letterencrypt{ char letter; int count; }LetterEncrypt; שאלה 5 נתונות ההגדרות הבאות: typedef struct listnode{ LetterEncrypt* sequenceptr; struct listnode* next; }ListNode; typedef struct list { ListNode* head; ListNode* tail; }List; רוצים לקודד (encode) מחרוזת של אותיות lower case (קטנות), ברשימה של נתונים מהטיפוס.LetterEncrypt כל רצף של אותיות זהות סמוכות, נייצג ברשומה אחת, מסוג,LetterEncrypt שתכיל בשדה letter את האות ובשדה count את אורך הרצף. למשל את הרצף eeee נייצג ברשומה שבה: letter= e, ו-.count=4 בצורה זו ניתן לקודד מחרוזות שלמות: עבור כל רצף באורך מקסימאלי של אותיות זהות סמוכות במחרוזת המקורית, תופיע רשומה אחת שתייצג את הקידוד של רצף זה. את סידרת הרשומות נשמור ברשימה של רשומות. לדוגמא, הרשימה הבאה מייצגת קידוד של המחרוזת :"aaaabbaaac a b a c כתבו פונקציה List encode(char* str); המקבלת כקלט מחרוזת.str על הפונקציה להחזיר רשימה של רשומות מטיפוס.str רשימה זו מייצגת את הקידוד של המחרוזת.LetterEncrypt כתבו את הפונקציה: int encodedstrcmp(list str1, List str); אשר מקבלת שתי מחרוזות בייצוג מקודד, ומשווה ביניהן לקסיקוגרפית (סדר מילוני), כמו ש- strcmp משווה בין שתי מחרוזות רגילות. על הפונקציה להחזיר: מספר שלילי אם str1 קטנה לקסיקוגרפית מ-.str מספר חיובי אם str1 גדולה לקסיקוגרפית מ-.str אפס אם הן שוות. א. ב

12 עצים בינאריים typedef struct treenode{ int data; struct treenode* left; struct treenode* right; } TreeNode; שאלה 1 עץ בינארי מוגדר כך: typedef struct tree{ TreeNode* root; } Tree; float averageofvalues(tree tr); כתבו את פונקציה: המקבלת עץ בינארי, ומחזירה את הממוצע של כל הערכים הנמצאים בצמתי העץ. על הפונקציה לרוץ ביעילות ) ( On, כאשר n הוא מספר הצמתים הכולל בעץ. למשל עבור העץ: ( = 4 הפונקציה תחזיר 4.5 (כי: הערה: אין להשתמש במשתנים סטאטיים

13 typedef struct treenode { int data; struct treenode* left; struct treenode* right; }TreeNode; שאלה בהינתן ההגדרה הבאה למבנה עבור עץ בינארי: typedef struct tree{ TreeNode* root; } Tree; אם T הוא עץ בינארי נגדיר כי T "מאוזן עפ"י גובה" כאשר לכל צומת, גובה תת העץ השמאלי וגובה תת העץ הימני שווים או שהפרשם לא גדול מ - 1. למשל העץ הבא מאוזן עפ"י גובה: כתבו פונקציה isheightbalanced המקבלת עץ בינארי ומחזירה גובה. true אם"ם העץ מאוזן לפי הערות: 1. אין להשתמש במשתנים סטטיים.. גובה של עץ עם צומת יחיד מוגדר להיות עץ ריק הוא מאוזן לפי גובה

14 שאלה 3 נתונים המבנים הבאים עבור עץ בינארי ועבור רשימה מקושרת: typedef struct treenode { int data; struct treenode* left; struct treenode* right; } TreeNode; typedef struct tree{ TreeNode* root; } Tree; typedef struct listnode { int data; struct listnode* next; } ListNode; typedef struct list { ListNode* head; ListNode* tail; } List; כתבו את הפונקציה הבאה: int leaveslist (Tree tr, List* reslst); הפונקציה מקבלת עץ בינארי, כפרמטר קלט, ומצביע לרשימה,כפרמטר פלט. על הפונקציה להחזיר בפרמטר הפלט את רשימת נתוני העלים של העץ. סדר אברי הרשימה יהיה כסדר העלים מימין לשמאל. כמו כן, על הפונקציה להחזיר, את סכום ערכי העלים בעץ, כערך מוחזר. לדוגמא עבור העץ: הפונקציה תיצור את הרשימה: ותחזיר את הערך 1. הערה: אין להשתמש במשתנים סטאטיים

15 שאלה 4 קוטר של עץ בינארי מוגדר להיות מספר הקשתות במסלול הארוך ביותר בין כל שני צמתים בעץ. למשל, בעץ הנ"ל המסלול המודגש הוא המסלול הארוך ביותר בין שני צמתים בעץ, ולכן קוטר העץ הנ"ל הוא 6. typedef struct treenode{ int data; struct treenode* left; struct treenode* right; } TreeNode; עץ בינארי מוגדר כך: typedef struct tree{ TreeNode* root; } Tree; int treediameter(tree tr); כתבו את פונקציה: הפונקציה מקבלת כקלט עץ בינארי, ומחזירה את הקוטר של העץ. על הפונקציה לרוץ ביעילות (n, )Θ כאשר n הוא מספר הצמתים הכולל בעץ. הערה: אין להשתמש במשתנים סטאטיים

16 typedef struct treenode{ int data; struct treenode* left; struct treenode* right; } TreeNode; שאלה 5 עץ בינארי מוגדר כך: typedef struct tree{ TreeNode* root; } Tree; void printbylevels(tree tr); כתבו את פונקציה: המדפיסה את הנתונים בעץ tr לפי רמות (קודם את הנתון ברמה 0, אחריו את נתונים ברמה 1, אחריהם את הנתונים ברמה, וכך הלאה), כל רמה תודפס משמאל לימין. על הפונקציה לרוץ ביעילות (n, )Θ כאשר n הוא מספר הצמתים הכולל בעץ. למשל עבור העץ: יודפס: הערות: 1. בכדי לעמוד בדרישות היעילות ייתכן ותרצו להשתמש במבנה נתונים נוסף.. אין להשתמש במשתנים סטאטיים

17 קבצים שאלה 1: כתבו תוכנית המקבלת כפרמטר שם של קובץ טקסט. הקובץ מכיל אינפורמאציה על מלאי של מוצרים בחנות. בשורה הראשונה יופיע מספר המייצג את מספר המוצרים במאגר. בכל שורה החל מהשורה השנייה יופיעו הנתונים על מוצר אחד. עבור כל מוצר במאגר יישמרו (משמאל לימין בשורה): שם המוצר, מחיר של יחידה אחת, מספר היחידות הזמינות. בין כל שדה בשורה יכולים להופיע מספר כלשהו של סימני.tab שימו לב: שם של מוצר יכול להיות יותר ממילה אחת. להלן דוגמא לקובץ עפ"י הפורמט המתואר: 4 ipod nano iriver Sony play station Xbox על התוכנית להמיר קובץ זה לקובץ בינארי הבנוי לפי הפורמט הבא: מספר מטיפוס int המייצג את מספר המוצרים השונים במאגר עבור כל מוצר במאגר (שורה בקובץ הטקסט) ישמרו בקובץ הבינארי המיוצר, הנתונים הבאים: מספר מטיפוס int המייצג את מספר התווים בשם המוצר (ללא ה- '0\'). 1. רצף (באורך זה) של char -ים המכיל את שם המוצר.. מספר מטיפוס int המייצג את מחירו של המוצר. 3. מספר מטיפוס int המייצג את מספר היחידות הזמינות מהמוצר. 4. שמו של הקובץ המיוצר הוא כשמו של קובץ הקלט, בתוספת ".bin" בסוף. למשל: נניח ששם קובץ הקלט הוא "stock.txt" שם הקובץ שיווצר יהיה."stock.txt.bin"

18 שאלה א. בסעיף זה נרצה להמיר תמונה צבעונית לתמונה בגווני אפור. תמונה צבעונית מורכבת מפיקסלים (נקודות) בצבעים שונים. מספר הפיקסלים בתמונה (רזולוציה) הוא רוחב התמונה כפול גובה התמונה. כל פיקסל בתמונה מיוצג על ידי שלשת מספרים (R,G,B) הקובעת את עוצמת האדום, הירוק והכחול בהתאמה. הערכים השונים אותם יכולים לקבל,G,R ו- B נקבעים בהתאם לעומק התמונה,.depth בתמונה בעומק 3 ). x מספר הגוונים האפשריים בתמונה הוא (וכך לקבל ערך בין 0 ל- x יכול ו- B,G,R כל אחד מבין x לדוגמא בתמונה צבעונית בעומק 55 כל אחד מבין R,G,B הוא מספר בין 0 ל- 55 כאשר 0 מציין כי הגוון אינו מופיע כלל, ו- 55 מציין כי הגוון מופיע במלואו. כל ערך בין 0 ל- 55 קובע עוצמה עבור הגוון. השלשה (55,0,0) תציין את הצבע אדום (אדום מופיע במלואו, ירוק וכחול אינם מופיעים כלל) השלשה (0,55,0) תציין את הצבע ירוק (אדום וכחול אינם מופיעים כלל, ירוק מופיע במלואו) השלשה (55,0,55) תציין את הצבע סגול (אדום וכחול מופיעים במלואם, ירוק אינו מופיע כלל) השלשה (55,55,55) תציין את הצבע לבן (כל הצבעים מופיעים במלואם) השלשה (0,0,0) תציין את הצבע שחור (כל הצבעים אינם מופיעים כלל) השלשה (30,160,15) תציין גוון של הצבע כתום (בהתאם ליחס בין מרכיבי הצבע השונים) תמונה בגווני אפור מורכבת מפיקסלים בגווני אפור שונים. אלא שהפעם כל פיקסל בתמונה מיוצג על ידי מספר בודד המציין את רמת האפור של הפיקסל. גם כאן לתמונה יש עומק הקובע את מספר הגוונים (הפעם גווני האפור) האפשריים בתמונה. בדומה לתמונה צבעונית, בתמונה בעומק x פיקסל בעל ערך 0 הוא שחור, ופיקסל בעל ערך x הוא לבן. כל ערך בטווח מייצג גוון אפור (וכך מספר הגוונים האפשריים בתמונה הוא ). x לדוגמא בתמונה בגווני אפור בעומק 55 כל פיקסל הוא מספר בין 0 ו- 55 הפיקסל 0 שחור הפיקסל 55 לבן הפיקסל 00 אפור בהיר הפיקסל 50 אפור כהה אלגוריתם להמרת תמונה צבעונית לתמונה בגווני אפור - בכדי להמיר תמונה צבעונית לתמונה בגווני אפור עלינו להחליט עבור כל פיקסל צבעוני באיזה פיקסל בגוון אפור הוא יוחלף. האלגוריתם בו נשתמש הוא כזה הלוקח את הממוצע של ערכי R,G ו- B להיות ערך גוון האפור. כלומר גוון האפור של פיקסל r1+ g1+ b1 צבעוני r 1 g, 1 b, 1 יקבע להיות:. שימו לב שהתמונה אותה מייצר האלגוריתם היא תמונה 3 בגווני אפור בעלת אותם המימדים ואותו העומק כמו התמונה הצבעונית. עליכם לכתוב תוכנית המקבלת כפרמטר שם של קובץ תמונה צבעונית בפורמט PPM עם Magic P3. :Number התוכנית טוענת את התמונה לזיכרון, ממירה אותה לתמונה בגווני אפור לפי האלגוריתם שתואר לעיל ומייצרת קובץ בפורמט PGM עם P :Magic Number מתאים לתמונה. שם קובץ הפלט ללא הסיומת יהיה זהה לשם קובץ הקלט (ללא הסיומת), והסיומת של שם קובץ הפלט תהיה.PGM הערה: הסבר על הפורמטים PPM ו- PGM יובא בהמשך

19 ב. בסעיף זה נרצה להמיר תמונה בגווני אפור לתמונה בשחור לבן. תמונה בשחור לבן היא מקרה פרטי של תמונה בגווני אפור. תמונה בשחור לבן היא תמונה בגווני אפור בעומק 1. נשים לב שבמקרה זה ישנם שני ערכים אפשריים בלבד לכל פיקסל. 0 המייצג את הצבע שחור ו- 1 המייצג את הצבע לבן. אלגוריתם להמרת תמונה בגווני אפור לתמונה בשחור לבן - בכדי להמיר תמונה בגווני אפור לתמונה בשחור לבן נצטרך להחליט עבור כל פיקסל מהתמונה בגווני אפור, האם לצבעו בשחור או לצבעו בלבן. מסתבר שהאלגוריתם הנאיבי אשר מחליף את המחצית הנמוכה של גווני האפור לשחור ואת המחצית הגבוהה של גווני האפור ללבן, משיג תוצאת גרועות (אתם מוזמנים אך לא חייבים לבדוק זאת) אנחנו נשתמש באלגוריתם אחר, האלגוריתם נקרא.dithering הרציונל מאחורי האלגוריתם dithering הוא מניעת מצב בו אזורים כהים יצבעו במלואם בשחור ואזורים בהירים יצבעו במלואם בלבן, האלגוריתם רוצה להוסיף מידה של "אקראיות", לפיה ישתלבו באזורים הכהים גם נקודות לבנות ולהיפך. בשלב הראשון מחלקים את גווני האפור ל- k מספר בין 0 ל- 1 k לפי הסדר חלקים שווי גודל (פרט אולי לאחרון), לכל חלק מתאימים לדוגמא תמונה מעומק 55 ממופה עבור = 3 k לתשעת החלקים : בשלב השני מתאימים לכל פיקסל בתמונת גווני האפור המקורית מספר בין 0 ל- 1 הוא משתייך. k לפי החלק אליו לדוגמא: תמונה מעומק 8 בגווני אפור (3=k) B - A תמונה מעומק 55 בגווני אפור

20 k שבה מופיעים המספרים מ- 0 עד בשלב השלישי נעזרים במטריצה מסיכה (mask) בגודל k 1 k. את המטריצה "פורשים" על התמונה שהתקבלה מהשלב הראשון (B), כלומר משכפלים ללא חפיפות את המטריצה החל מהפינה השמאלית העליונה של התמונה לאורך ולרוחב. לדוגמא פרישת מטריצת המסיכה הבאה: על התמונה B תיתן: בשלב הרביעי מייצרים תמונה בשחור לבן כך שהפיקסלים שערכם גדול מערך התא שהותאם להם במסיכה יצבעו בלבן (ערך 1) והפיקסלים שערכם קטן או שווה לערך התא שהותאם להם במסיכה יצבעו בשחור (ערך 0). ומכאן שבדוגמא הנ"ל נקבל את התמונה הבאה בשחור לבן: C תוצאה- תמונה מעומק 1 (שחור לבן) - 0 -

21 עליכם לכתוב תוכנית המקבלת כפרמטר שם של קובץ תמונה בגווני אפור בפורמט PGM עם Magic P. :Number התוכנית טוענת את התמונה לזיכרון, ממירה אותה לתמונה בשחור לבן לפי האלגוריתם שתואר לעיל ומייצרת קובץ (גם הוא בפורמט PGM עם P) :Magic Number מתאים לתמונה. שם קובץ הפלט ללא הסיומת יהיה זהה לשם קובץ הקלט (ללא הסיומת) אך בתוספת,"bw" והסיומת של שם קובץ הפלט תשאר.PGM הריצו תוכנית זו עם מטריצות המסיכה הבאות: k=4 k=3 k= הערה: במימוש האלגוריתם אין הכרח לעבור מעשית דרך כל השלבים. מימוש חכם יתייחס אליהם כאל שלבים לוגיים בלבד. (לא באמת צריך ליצור את המטריצה B, ואין צורך לשכפל מעשית מטריצה) ניתן לממש את האלגוריתם במעבר אחד על התמונה ובעזרת פחות מ- 15 שורות קוד, חישבו איך). ג. חזרו על הסעיפים א' ו-ב' אך הפעם במקום קובץ PPM עם P3 :Magic Number השתמשו בקובץ PPM עם P6 :Magic Number ובמקום קובץ PGM עם P :Magic Number השתמשו בקובץ.P5 :Magic Number עם PGM הנחיות לכל הסעיפים: על התוכניות השונות להתמודד עם כל קובץ PPM,PGM חוקי. בכדי לייצר קבצי קלט מטיפוס PPM לבדיקת התוכנית, ניתן להשתמש בתוכנות הממירות תמונות מפורמטים נפוצים (לדוגמא (jpeg, bmp, gif לפורמטים.PGM, PPM האתר: / מספק שירות המרה בין פורמטים שונים בחינם, אולם הוא ממיר לפורמטים P6 ו- P5 בלבד. מכאן תוכלו לייצר בעצמכם את הפורמטים החסרים

22 PPM File Format This note describes the format of PPM (Portable PixMap) file. This format is a convenient (simple) method of saving a color image data. A PPM file consists of two parts, the header and the image data. The header consists of three parts that are delimitated by white space (usually linefeeds - '\n'). Header format: The first part is a magic PPM identifier; it can be the string "P3" or the string "P6" (not including the double quotes!). The next part consists of the width and height of the image as ASCII numbers. The last part of the header gives the maximum value of the color components (depth) for the pixels. This value must be smaller than 56 and greater than 0. In addition to the above required lines, a comment can be placed anywhere before the depth starting with a "#" character, the comment extends to the end of the line. The following are all valid PPM headers. example 1: Header P example : Header P # A comment 55 example 3: Header P3 104 # the image width 788 # the image height # A comment 15 Image data format: The format of the image data itself depends on the magic PPM identifier. If it is "P3" then the image is given as ascii text, the numerical value of each pixel ranges from 0 to the depth given in the header. example 4: PPM P3 P3 # example from the man page If the PPM magic identifier is "P6" then the image data is stored in binary format, one byte per color component (r,g,or b). Comments can not appear in the image data section. Only one byte of a whitespace may appear after the last header field, normally a '\n'. - -

23 PGM File Format This format is identical to the above except it stores greyscale information, that is, one value per pixel instead of 3 (r,g,b). The only difference in the header section is the magic identifiers which are "P" and "P5", these correspond to the ascii and binary form of the data respectively. PGM example An example of a PGM file of type "P" is given below P 4 7 #dimension

24 Summary of the PPM/PGM file formats: 1. A "magic number" for identifying the file type. Consist of two ASCII characters (one of the following): "P6" for PPM (color) Binary image data "P3" for PPM (color) ASCII image data "P5" for PGM (grayscale) Binary image data "P" for PGM (grayscale) ASCII image data. Whitespaces (blanks, TABs, CRs, LFs). 3. A width, formatted as ASCII characters in decimal. 4. Whitespaces. 5. A height, again in ASCII decimal. 6. Whitespaces. 7. The maximum color value (depth), again in ASCII decimal. Must be less than 56 and more than zero. 8. A single whitespace character. 9. In P6 magic number: A block of Height rows, in order from top to bottom. Each row consists of Width pixels, in order from left to right. Each pixel is a triplet of red, green, and blue samples, in that order. Each sample is represented in pure binary using one byte. In P3 magic number: A block of Height rows, in order from top to bottom. Each row consists of Width pixels, in order from left to right. Each pixel is a triplet of red, green, and blue samples, in that order. Each sample is represented as an ASCII decimal number. Each sample has white space before and after it. There must be at least one character of white space between any two samples, but there is no maximum. There is no particular separation of one pixel from another -- just the required separation between the blue sample of one pixel from the red sample of the next pixel. In P5 magic number: A block of Height rows, in order from top to bottom. Each row consists of Width pixels, in order from left to right. The gray level of each pixel is represented in pure binary using exactly one byte. In P magic number: A block of Height rows, in order from top to bottom. Each row consists of Width pixels, in order from left to right. The gray level of each pixel is represented as an ASCII decimal number. Each gray level has white spaces before and after it. There must be at least one character of white space between any two gray levels, but there is no maximum. 10. In general, characters from a "#" to the next end-of-line, before the depth line, are comments and are ignored

25 typedef struct student{ char* name; int average; }STUDENT; שאלה 3 נתונה ההגדרה הבאה של רשומה שמירת נתונים על תלמיד: ב. מאגר של תלמידים נשמר בקובץ בינארי לפי הפורמט הבא: המציין את מספר רשומות התלמידים הנמצאות בקובץ, נסמנו ב- n. מספר מטיפוס short int רצף של n רשומות, כאשר כל רשומה בנויה באופן הבא: המייצג את מספר התווים בשמו של התלמיד הנוכחי, נסמנו short int מספר מטיפוס מ-.len רצף של len תווים, המייצגים את שמו של התלמיד הנוכחי (אין '0\' בסוף רצף התווים הנ"ל). מספא מטיפוס int המייצג את ממוצע ציוניו של התלמיד הנוכחי. א. כתבו תוכנית המקבלת כפרמטר שם של קובץ המכיל נתוני תלמידים עפ"י הפורמט לעיל. התוכנית תיצור עבור קובץ התלמידים קובץ אינדקסים (קובץ המכיל נתונים של היסט יחסית לתחילת קובץ התלמידים), כך שאם נעבור על ההיסטים ברצף נקבל את התלמידים בסדר לקסיקוגראפי עולה של שמות. על שמו של קבוץ האינדקסים להיות השם של הקובץ המקורי בתוספת הסיומת.".ind" הערה: את המיון יש לבצע ע"י אלגוריתם יעיל ככל האפשר. כתבו את הפונקציה הבאה: int findaveragegrade(char* database, char* studname); הפונקציה מקבלת כקלט מחרוזת,database המייצגת שם של קובץ המכיל נתוני תלמידים (לפי הפורמט שהוצג בתחילת השאלה), ומחרוזת,studName המכילה שם של תלמיד. על הפונקציה להחזיר את ממוצע הציונים של התלמיד ששמו studname או 1- אם אין תלמיד כזה ב-.database הערות: 1. הניחו שהפונקציה הנ"ל נקראת רק אחרי שכבר נוצר קובץ אינדקסים, כפי שהוגדר בסעיף א', עבור הקובץ.database. הניחו שבקובץ ישנו לכל היותר תלמיד אחד עם השם.studName 3. שימו לב ליעילות זמן הריצה של הפונקציה אותה אתם כותבים

26 ביטים שאלה 1 חיפוש בספר טלפונים. נניח כי לכל לקוח בספר טלפונים יש מחרוזות: typedef struct client { char id[9]; // char phone[11]; // 03: }t_client; בשדה ת.ז. ישנן 8 ספרות (ללא ספרת ביקורת) ובסוף 0\. בשדה טלפון יש שתי ספרות קידומת, סימן הפרדה : (נשים לב כי בטבלת ascii הוא מופיע מיד לאחר 9 ), אח"כ 7 ספרות המספר עצמו ו 0\ בסוף. בסה"כ נשמרים 0 בתים ללקוח. נרצה להקטין את כמות הבתים הנשמרת ללקוח, מבלי לאבד אינפורמציה. נשתמש במבנה הבא: typedef struct short_client { unsigned char shorted[4]; unsigned char short_phone[5]; }t_short_client; כל התווים המשתתפים במידע שנשמר ללקוח הינם עוקבים בטבלת.ascii, 1, 0 9, :, מדובר בתווים: ישנם בסה"כ 11 תווים. ניתן לקודד מחדש כל תו ב 4 סיביות באופן הבא: : קידוד זה מאפשר לשמור את המידע הרצוי במבנה החדש.t_short_client א. כתוב פונקציה המקבלת מספר n ומבצעת את הפעולות הבאות: הקצאת מערך דינאמי של n רשומות מסוג t_client 1. קליטת נתונים לתוך אברי המערך.. דחיסת הנתונים במערך למערך דינאמי של רשומות מסוג t_short_client תוך שחרור 3. המערך הישן. החזרת המערך הדחוס. 4. כתוב פונקציה המאפשרת חיפוש בספר טלפונים ב. קלוט מספר ת.ז. כמחרוזת של 9 תווים. 1. העבר אותו לצורה הדחוסה. כאשר החיפוש מצליח, על הפונקציה להחזיר את המחרוזת חפש אותו בלולאה במערך הדחוס. 3. המציינת מהו מספר הטלפון של הלקוח. (המחרוזת הינה בצורה המקורית ולא הדחוסה.) כתוב תוכנית המאפשרת ביצוע הפעולות הנ"ל ג

27 שאלה א. על מנת לצמצם את המקום הנדרש לייצג מחרוזות בת n תווים, שבה מספר התווים השונים הוא לכל n היותר 16. במקום שנידרש ל- n בתים כדי לשמור אותה עפ"י קוד,ascii נצטמצם ל- : לכל תו נצמיד מספר בין 0 ל- (4 15 ביטים). כך שבכל byte יהיו שני תווים. a c תצטמצם להיות: 'a' למשל המחרוזת: b a 'c' 'b' 'a' '\0' אם נסתכל בסדרת התווים השונים מהמחרוזת המקורית, מסודרים לפי סדר הופעתם הראשונה, הערך שיוצמד לכל תו יהיה מיקומו בסדרה זו (החל מ- 0). למשל: אם המחרוזת המקורית היא: :"acba" ל- a, יוצמד הערך 0. ל- c, יוצמד הערך 1. ל- b, יוצמד הערך ולכן המחרוזת המצומצמת תהיה: ממשו ראשית את הפונקציה: char* getuniqueletters(char* text, int* size); המקבלת מחרוזת,text ומחזירה מערך המכיל את התווים השונים המופיעים ב-,text מסודרים במערך לפי סדר הופעתם הראשונה ב-.text הפונקציה גם מעדכנת בכתובת שנשלחה לה במשתנה,size את גודלו של המערך המוחזר. למשל: אם תופעל הפונקציה עם,text="mullyllum" היא תחזיר את המערך: 'y'],['m', 'u', 'l', ותעדכן בכתובת של size את הערך.4 שימו לב: הערך המוחזר של הפונקציה הוא מערך של תווים, ולא מחרוזת (לא מסתיים ב- '0\'). כתבו תוכנית המקבלת כפרמטר שם של קובץ טקסט. ידוע שהקובץ הנ"ל מורכב משורות באורך זוגי של תווים, שבכל שורה יש לכל היותר 16 תווים שונים. על התוכנית להמיר קובץ זה לקובץ בינארי הבנוי לפי הפורמט הבא: עבור כל שורה בקובץ הטקסט, ישמרו בקובץ הבינארי המיוצר, הנתונים הבאים: 1. מספר מטיפוס unsigned char המייצג את מספר התווים השונים בשורה.. רצף (באורך זה) של char -ים המכיל את סדרת התווים השונים בשורה, מסודרים לפי סדר הופעתם הראשונה באותה שורה. 3. מספר מטיפוס unsigned int המייצג את מספר הבתים בהם נשמרים התווים המכווצים של השורה. 4. רצף (באורך זה) של בתים המכילים את הכווץ של השורה. שמו של הקובץ המיוצר הוא כשמו של קובץ הקלט, בתוספת ".rds" בסוף

28 למשל: נניח ש- "stam.txt" הוא קובץ טקסט, המכיל את שתי השורות: acba mbbmbmmb אם תועבר לתוכנית, כפרמטר בשורת ההפעלה, המחרוזת,"stam.txt" יווצר הקובץ."stam.txt.rds" קובץ זה יכיל: שורה I שורה II 3 'a' 'c' 'b' 'm' 'b'

29 ב. כעת נרצה לשחזר מחרוזת מכווצת המכילה לכל היותר 16 תווים שונים, למחרוזת רגילה. כל בית במחרוזת המכווצת מכיל שני תווים מהמחרוזת הרגילה. כל תו תופס 4 ביטים. ארבעת הביטים השמאליים מייצגים את התו הראשון (שנשמר בבית הזה), וארבעת הביטים הימניים מייצגים את התו השני (שנשמר בבית הזה). את השחזור נבצע בעזרת מערך code המכיל את כל התווים השונים של המחרוזת, כל תו בדיוק פעם אחת. במחרוזת המכווצת במקום כל תו שומרים 4 ביטים המייצגים את המיקום של אותו תו במערך.code (מכילה 4 תווים), למשל אם המחרוזת המכווצת היא: והמערך 'b'],code = ['a', 'c', אזי המחרוזת המשוחזרת תהיה:."acbb" כתבו תוכנית המקבלת כפרמטר שם של קובץ בינארי השומר בצורה מכווצת, בפורמט שיוגדר בהמשך, שורות באורך זוגי של תווים, שבכל שורה לכל היותר 16 תווים שונים. על התוכנית להמיר קובץ זה לקובץ טקסט. שמו של הקובץ המיוצר הוא כשמו של קובץ הקלט, בתוספת ".xpd" בסוף. פרמט הקובץ הבינארי (שהתקבל כקלט): עבור כל שורה מכווצת נשמרים הנתונים הבאים: 1. מספר מטיפוס unsigned char המייצג את מספר התווים השונים בשורה.. רצף (באורך זה) של char -ים המכיל את סדרת התווים השונים בשורה. 3. מספר מטיפוס unsigned int המייצג את מספר הבתים בהם נשמרים התווים המכווצים של השורה. 4. רצף (באורך זה) של בתים המכילים את הכווץ של השורה. שימו לב: בקובץ הבינארי נשמרים נתונים המייצגים מחרוזת מכווצת, כמו שתואר בסעיף הקודם. 3 'a' 'c' 'b' 'm' 'b' לדוגמא: אם "stam.rds" הוא הקובץ הבינארי הבא: שורה I שורה II acba mbbmbmmb אז התוכנית תיצור את הקובץ,"stam.rds.xpd" אשר יכיל את שתי השורות: - 9 -

30 שאלה 3 א. נתון תו מוצפן,.ch על מנת לפענח אותו יש לשנות את מיקום הביטים בו. השינוי יעשה בעזרת תמורה ] 7 [a 0, a 1,, a של המספרים.0-7 תהליך הפענוח יעשה באופן הבא: את הביט האפס של התו ch נשים בביט שנמצא במקום ה- a 0 בתו המפוענח. את הביט האחד של התו ch נשים בביט שנמצא במקום ה- a 1 בתו המפוענח. וכך הלאה... הערה חשובה: הביט ה- 0 הוא הביט הימני ביותר. למשל אם נרצה לפענח את התו שמיוצג בינארית: בעזרת התמורה: [3,,1,0,7,6,5,4] נקבל את התו המפוענח שמיוצג בינארית: (למשל הביט האפס של התו המקורי (1) עבר לביט ה- 3 בתו המפוענח, וכו'). char decode(char ch, int* key); כתבו את הפונקציה: הפונקציה מקבלת תו מוצפן,ch ומערך key בגודל 8 המכיל תמורה כלשהי של המספרים 0-7. הפונקציה תפענח את התו,ch עפ"י השיטה שתוארה לעיל, ותחזיר את התו המפוענח. ב. השתמש בפונקציה מסעיף א' על מנת לכתוב את הפונקציה: char* decodestring(char* name, int* key); הפונקציה מקבלת מחרוזת name המכילה שם מקודד, ומערך key בגודל 8 המכיל תמורה כלשהי של המספרים 0-7. הפונקציה תיצור ותחזיר מחרוזת חדשה שתכיל את השם המפוענח. פענוח השם יתבצע ע"י פענוח כל אחד מתווי name עפ"י התמורה.key ג. שירות הביטחון הכללי שומר שני קבצים עבור כל פעולה שהוא מבצע. 1. קובץ בינארי (שאותו ניתן אפילו לשלוח ב- (mail המחזיק בצורה מוצפנת שמות של הסוכנים המשתתפים במבצע.. קובץ טקסט (שנשמר בכספת) המכיל את התמורות שבעזרתן ניתן לפענח את השמות המקודדים בקובץ הבינארי. פורמט קובץ השמות המקודדים (הקובץ הבינארי): שמות הסוכנים נשמרים ברצף. כל שם (מקודד) נשמר באופן הבא: מספר שלם int) (short המייצג את אורך שמו של הסוכן ואחריו רצף באורך זה של תווים מוצפנים המרכיבים יחד את שמו. פורמט קובץ המפתחות (קובץ הטקסט): הקובץ מורכב משורות. בכל שורה תופיע תמורה של המספרים 0-7 המופרדים ברווחים. סדר השורות בקובץ מתאים לסדר בו נשמרו השמות המקודדים בקובץ השמות. בפרט מספר השורות הוא כמספר הסוכנים בקובץ השמות. בהינתן ההגדרה הבאה למבנה עבור רשימה מקושרת: typedef struct list{ LNODE* head; LNODE* tail; }LIST; typedef struct l_node{ char* name; struct l_node* next; }L_NODE; כתבו את הפונקציה: LIST decodemission(file* agents, FILE* keys); הפונקציה מקבלת מצביעים לשני קבצים: agents - קובץ בינארי המכיל שמות מקודדים של סוכנים בפורמט שתואר לעיל. keys - קובץ טקסט המכיל מפתחות בפורמט שתואר לעיל. הפונקציה תחזיר רשימה, שתכיל את שמותיהם המפוענחים של הסוכנים המופיעים בקובץ.agents על הרשימה להכיל את הסוכנים לפי סדר הופעתם בקובץ

31 שאלה 4 א. כתבו את הפונקציה: int* filter(int* Numbers, int size, unsigned char* pred, int* new_size); הפונקציה מקבלת מערך Numbers של מספרים שלמים שונים זה מזה, ואת גודלו.size כמו כן היא size בתים. כל ביט במערך,pred מייצג נתון אחד של מקבלת מערך pred של ביטים, בגודל 8 המערך,Numbers באופן הבא: הביט ה- 0 בבית ה- 0 של המערך,pred מייצג את הנתון באינדקס 0 במערך.Numbers הביט ה- 1 בבית ה- 0 של המערך,pred מייצג את הנתון באינדקס 1 במערך.Numbers הביט ה- 0 בבית ה- 1 של המערך,pred מייצג את הנתון באינדקס 8 במערך.Numbers וכך הלאה. הפונקציה תייצר ותחזיר את תת המערך המכיל אך ורק את הנתונים מהמערך,Numbers אשר הביט המתאים להם במערך,pred הוא 1. כמו כן, הפונקציה תעדכן במשתנה הפלט new_size את גודלו של תת המערך שייצרה. Numbers למשל, אם המערכים Numbers ו-,pred מוגדרים באופן הבא: pred הקריאה size),filter(numbers, pred,,16 תייצר את המערך: וכן תעדכן במשתנה אליו מצביע new_size את הערך הערות: הניחו ש-,size מספר הנתונים במערך,Numbers מתחלק ב- 8. שימו לב כי בציור, האינדקסים במערך המספרים מתקדמים משמאל לימין, ואילו הביטים בכל בית נספרים מימין לשמאל (מה- LSB אל ה-.(MSB ב. השתמשו בפונקציה מסעיף א', על מנת לכתוב הפונקציה הבאה: int* xorfilter(int* Numbers, int size, unsigned char* pred1, unsigned char* pred, int* new_size); הפונקציה מקבלת מערך Numbers של מספרים שלמים שונים זה מזה, ואת גודלו.size כמו כן היא size בתים. כל אחד מקבלת שני מערכים pred1 ו- pred של ביטים, כל אחד מהם בגודל 8 מהביטים, בכל אחד מהמערכים pred1 ו-,pred מייצג נתון מסוים של המערך,Numbers לפי ההתאמה שתוארה בסעיף א'. הפונקציה תייצר ותחזיר את תת המערך המכיל אך ורק את נתונים מהמערך.Numbers נתון מסוים יופיע במערך התוצאה אם"ם בדיוק אחד מביו הביטים המתאימים לו במערך,pred1 ו-,pred הוא 1. כמו כן, הפונקציה תעדכן במשתנה הפלט new_size את גודלו של תת המערך שייצרה. הערה: הניחו ש-,size מספר הנתונים במערך,Numbers מתחלק ב

32 פויינטרים לפונקציות שאלה 1 כתבו את הפונקציה: void* scramble(void* arr, int ElemSize, int n, int* indarr); הפונקציה מקבלת: arr - מערך של איברים מטיפוס כלשהו. arr גודל של כל אלמנט במערך - ElemSize.arr מספר האיברים במערך - n. 0,1,,( n 1) מערך המכיל תמורה של המספרים: - indarr על הפונקציה ליצור מערך חדש שבו סדר האיברים נקבע על פי המערך indarr באופן הבא: האיבר ה - i במערך החדש יהיה האיבר שהאינדקס שלו במערך הישן הוא.indArr[i] למשל, אם = 3 n ו- [,0,1] = indarr אז: במקום ה- 0 של המערך החדש ימצא האיבר מהמקום ה- של.arr במקום ה- 1 של המערך החדש ימצא האיבר מהמקום ה- 0 של.arr במקום ה- של המערך החדש ימצא האיבר מהמקום ה- 1 של.arr שאלה נתון האלגוריתם הבא למימוש חיפוש בינארי של נתון במערך: קלט: פלט: מערך של נתונים.Arr גודל המערך - Size נתון לחיפוש.Item.(Arr מופיע במערך Item) אם"ם (true) found false left 0 right (Size-1) (! found ( left right) ) כל עוד place ( (left+right) div ) 4.1 (Arr[place]=Item) 4. אם found true 4..1 (Arr[place]<Item) 4.3 אחרת אם left (place+1) אחרת right (place-1) found החזר את

33 א. כתבו את הפונקציה הבאה: int binsearch(void* Arr, int Size, int ElemSize, void* Item, int (*compare)(void*, void*)); על הפונקציה לממש אלגוריתם זה, למערכים מטיפוסים שונים (מערכים של מחרוזות, מערכים של int -ים וכו'). הפונקציה מקבלת: - Arr כתובת התחלה של מערך. - Size מספר הנתונים בו. - ElemSize מספר הבתים שתופס כל אחד מהנתונים. - Item כתובת של נתון שלגביו יש להכריע האם הוא נמצא במערך. טיפוס הנתון הוא כטיפוס נתוני המערך. - compare פויינטר לפונקציה המשווה בין שני נתונים (מהטיפוס של הנתונים מהמערך). על הפונקציה להחזיר את הערך 1 אם הנתון עליו מצביע Item שווה לאחד מנתוני המערך, או 0 אחרת. הערה: הניחו שהפונקציה,compare מקבלת כתובות של שני נתונים אותם היא משווה. ומחזירה: אפס - אם שני הפרמטרים מצביעים על נתונים שווים. מספר שלילי - אם הפרמטר הראשון מצביע על נתון קטן יותר מהנתון שמוצבע ע"י הפרמטר השני. מספר חיובי - אם הפרמטר הראשון מצביע על נתון גדול יותר מהנתון שמוצבע ע"י הפרמטר השני. ב. השתמשו בפונקציה BinSearch,שכתבתם, על מנת לכתוב את הפונקציה: int stringbinsearch(char** strings, int size, char* str); המקבלת מערך strings של מחרוזות ממוינות בסדר לקסיקוגרפי, את גודלו,size ומחרוזת נוספת.str על הפונקציה להחזיר את הערך 1 אם המחרוזת str מופיעה במערך,strings או 0 אחרת. למשל אם strings הוא המערך: abcdefg "good-luck" "mully" "stam" אז ההפעלה: stringbinsearch(strings,4,"good-luck") תחזיר

34 שאלה 3 מאגר של נתונים על מוצרים נשמר בקובץ בינארי. הקובץ בנוי בפורמט הבא: מספר מטיפוס,int המייצג את מספר המוצרים בקובץ. נסמן את ערכו ב- N. 1. רצף באורך N של נתונים של מוצרים. כל מוצר מופיע בקובץ בפורמט הבא:. מספר מטיפוס,int המייצג את מספר התווים בשמו של המוצר. נסמן את ערכו ב-.len רצף של len תווים, המכיל את שמו של המוצר (ללא '0\' בסופו). מספר מטיפוס,int המייצג את מחירו של המוצר. נרצה לייצר שני קבצי אינדקס לקובץ המאגר הנ"ל: מכיל את ההיסטים (offsets) למוצרים בקובץ המאגר, ממוינים לפי שם המוצר (מהקטן לגדול). מכיל את ההיסטים למוצרים בקובץ המאגר, ממוינים לפי המחירים שלהם (מהקטן לגדול). על מנת למנוע שכפול קוד ביצירת שני קבצי האינדקס, נגדיר פונקציה כללית ליצירת קובץ אינדקס ממוין, ונפעיל אותה פעמיים ליצירת כל אחד מקבצי האינדקס. בסעיף א' של השאלה נגדיר את הפונקציה הכללית ליצירת קובץ אינדקס ממוין, ובסעיף ב' נייצר את שני קבצי האינדקס הרצויים לנו. א. כתבו את הפונקציה: void createsortedindex(char* DB_Name, char* IndexFileName, int (*compare) (void*, void*)); הפונקציה מקבלת מחרוזת DB_Name המכילה את שמו של קובץ בינארי. הקובץ מכיל מאגר של נתוני מוצרים (לא ממוינים) בפורמט שהוגדר לעיל. הפונקציה מייצרת קובץ אינדקסים, בשם,IndexFileName המכיל רצף של נתונים מטיפוס,long int כל נתון בקובץ האינדקס, מייצג היסט מתחילת קובץ המאגר (DB_Name) לתחילת נתוניו של מוצר מסוים. אם נעבור על קובץ המאגר, לפי רצף ההיסטים בקובץ האינדקסים, המיוצר ע"י הפונקציה, נקבל את נתוני המאגר ממוינים מהקטן לגדול, עפ"י הסדר המושרה מפונקצית ההשוואה.compare הערה: הפונקציה compare הינה פונקצית השוואה כללית, המקבלת מצביעים לשני נתונים ומשווה ביניהם. הפונקציה משרה סדר באופן הבא: אם הנתון עליו מצביע הפרמטר הראשון קטן מזה שעליו מצביע הפרמטר השני, היא תחזיר מספר שלילי. אם הנתון עליו מצביע הפרמטר הראשון גדול מזה שעליו מצביע הפרמטר השני, היא תחזיר מספר חיובי. אם הנתון עליו מצביע הפרמטר הראשון שווה לזה שעליו מצביע הפרמטר השני, היא תחזיר את הערך 0. לצורך כתיבת הפונקציה,createSortedIndex ממשו (בין היתר) את הפונקציה: void sort(void* Arr, int elem_size, int num_elems, int (*compare) (void*, void*)); הפונקציה sort מקבלת מצביע Arr לתחילת מערך, מספר שלם elem_size המייצג את גודלו של כל נתון במערך, ומספר שלם נוסף num_elems המייצג את מספר הנתונים במערך. הפונקציה ממיינת את הנתונים במערך,Arr עפ"י הסדר המושרה מפונקצית ההשוואה הכללית.compare

35 ב. השתמשו בפונקציה שכתבתם בסעיף א', על מנת לכתוב את שתי הפונקציות הבאות: void indexsortedbyname(char* DB_Name, char* IndexFileName); void indexsortedbyprice(char* DB_Name, char* IndexFileName); כל אחת מהפונקציות מקבלת שם של קובץ DB_Name המכיל מאגר של נתונים על מוצרים, בפורמט שפורט בתחילת השאלה. כל אחת מהפונקציות מייצרת קובץ אינדקסים בשם indexfilename (לפי הפורמט שהוגדר בסעיף א'). אם נעבור על קובץ המאגר, לפי רצף ההיסטים בקובץ אשר מייצרת הפונקציה הראשונה, נקבל את נתוני המאגר ממוינים לפי שם המוצרים, מהקטן לגדול. אם נעבור על קובץ המאגר, לפי רצף ההיסטים בקובץ אשר מייצרת הפונקציה השנייה, נקבל את נתוני המאגר ממוינים לפי מחיר המוצרים, מהקטן לגדול