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

Transcription

1 שאלות חזרה שאלה - 3 קבצים נתונים שני קבצים: ) קובץ נתוני הסטודנטים של הקורס שלנו, כל שורה בקובץ מכילה את הפרטים הבאים: תווים - שם הסטודנט - תווים - כתובת - 9 ספרות - מספר ת.ז. - 3 ספרות - קוד מחלקה - 3 ספרות - ציון סופי בקורס - הקובץ מסודר לפי מספר ת.ז. בסדר עולה. ) קובץ פרטי כל המחלקות של האוניברסיטה, כל שורה בקובץ מכילה את הפרטים הבאים: - תווים שם המחלקה ספרות קוד מחלקה - שם ראש המחלקה - תווים - הקובץ מסודר לפי קוד מחלקה בסדר עולה. האוניברסיטה החליטה לפרסם שמות הסטודנטים המצטיינים בקורס שלנו. סטודנט מצטיין הוא סטודנט שקיבל את הציון הגבוה ביותר במחלקה שלו. באותה מחלקה יכולים להיות כמה סטודנטים מצטיינים. כתוב פונקציה excellent שמקבלת כפרמטרים שני מצביעים לקבצים הנ"ל ויוצרת קובץ חדש בשם excellent.dat" של כל הסטודנטים המצטיינים, כל שורה בקובץ מכילה: ספרות - שם המחלקה - 3 ספרות - קוד המחלקה - תווים - שם הסטודנט - 9 ספרות - מספר ת.ז. - הקובץ מסודר לפי קוד מחלקה בסדר עולה. הגבלה: אין להעתיק קובץ למבנה נתונים אחר (מערך, רשימה משורשרת,...)

2 void excellent(file* student, FILE* department){ FILE* excel; char name[],id[], dp_name[]; int cod_s, cod_d, grade, max; rewind(department); if((excel=fopen("excellent.dat","w"))== NULL){ printf("error in access to file department\n");exit(); while(fscanf(department,"%[^$]%3d%*c",dp_name,&cod_d)==){ max = -; rewind(student); while(fscanf(student,"%*49c%3d%3d%*c",&cod_s,&grade)==) if(cod_s==cod_d && grade>max) max = grade; if(max == -)continue; rewind(student); while(fscanf(student,"%[^$]%*c%9s%3d%3d%*c", name,id,&cod_s, &grade)==4) if(cod_s==cod_d && grade==max) fprintf(excel,"%s%3d%s%s\n",dp_name,cod_d,name,id); if(fclose(excel)== EOF){ printf("error closing file excellent.dat\n"); exit(); תשובה:

3 שאלה - 5 קבצים נתונים קבצים של כל האורחים לחתונה (אחד של אורחי הכלה ואחד של אורחי החתן). 5 תווים 5 תווים 3 ספרות (מ- עד ) 3 תווים (מלל חפשי) כל שורה בקבצים מכילה את הפרטים הבאים: שם פרטי שם משפחה גיל הערות הקבצים ממוינים לפי שם משפחה בסדר אלפבית ועבור אותו שם משפחה לפי שם פרטי גם לפי סדר אלפבית. (שימו לב שבקבצים שם המשפחה מופיע אחרי השם הפרטי). כתוב פונקציה filename) guest(file* f, FILE* f, char* filename, char* שמקבלת כארגומנטים שני מצביעים לקבציים הנ"ל ושתי מחרוזות שהן השמות של הקבצים החדשים שהפונקציה יוצרת. שני הקבצים החדשים הם במבנה זהה לשני הקבצים הנתונים. הקובץ החדש הראשון מכיל את רשימת האורחים שמופיעים באחד בלבד משני הקבצים, והקובץ החדש השני מכיל את רשימת האורחים המשותפים לחתן ולכלה. שני הקבצים החדשים גם ממוינים לפי שם משפחה ושם פרטי. הגבלה: אין לקרוא קובץ יותר מפעם אחת. אין להעתיק קובץ למבנה נתונים אחר (מערך, רשימה משורשרת, עץ,קובץ אחר...) 3

4 תשובה: void guests(file* f, FILE* f, char *filename, char *filename ){ char first[6],last[6], name[3], details[34], first[6], last[6], name[3], details[34]; FILE *twice, *once; int flag, flag; if(!(once = fopen(filename, "w"))){ puts(" The program cannot open file"); exit(); if(!(twice = fopen(filename, "w"))){ puts(" The program cannot open file"); exit(); flag=fscanf(f, "%5[^$]%5[^$]%[^\n]*c",first,last,details); if(flag==3){ strcpy(name,last); strcat(name,first); flag=fscanf(f, "%5[^$]%5[^$]%[^\n]*c",first, last, details); if(flag==3){ strcpy(name,last); strcat(name,first); while(flag==3 flag==3) if(flag==3 && flag==3 &&!strcmp(name,name)){ fprintf(twice,"%5s%5s%33s\n",first,last,details); flag=fscanf(f, "%5[^$]%5[^$]%[^\n]*c", first,last,details); if(flag==3){ strcpy(name,last); strcat(name,first); flag= fscanf(f, "%5[^$]%5[^$]%[^\n]*c", first, last, details); if(flag==3){ strcpy(name,last); strcat(name,first); else if(flag!=3 flag==3 && strcmp(name,name)<){ fprintf(once,"%5s%5s%33s\n",first,last,details); flag= fscanf(f, "%5[^$]%5[^$]%[^\n]*c", first, last, details); if(flag==3){ strcpy(name,last); strcat(name,first); else{ fprintf(once,"%5s%5s%33s\n",first,last,details); flag= fscanf(f, "%5[^$]%5[^$]%[^\n]*c", first, last, details); if(flag==3){ strcpy(name,last); strcat(name,first); fclose(once); fclose(twice); 4

5 typedef struct node{ int value; struct node* next; Node; שאלה - 6 רשימות נתונה ההגדרה הבאה: Node* middle(node* source){ Node *fast, *slow, *source; הפונקציה הבאה מחפשת את האמצע של הרשימה ושם חוצה את הרשימה לשתי רשימות. if (source==null???? ) return NULL; slow = source; fast =???? ; while (?? 3??) { fast = fast->next; if (?? 4?? ) { slow = slow->next; fast = fast->next; source = slow->next; slow->next =?? 5?? ; return?? 6?? ; השלם בדף התשובות את הקטעים החסרים. פתרון: Node* middle(node* source){ Node *fast, *slow, *source; if (source==null source->next==null) return NULL; slow = source; fast = source->next; while (fast) { fast = fast->next; if (fast) { slow = slow->next; fast = fast->next; source = slow->next; slow->next = NULL ; return source; 5

6 שאלה - 7 רשימות נתונות ההגדרה הבאה שמאפשרת להגדיר מבנה של רשימה משורשרת: typedef struct item{ int digit; struct item *next; item; ניתן לייצג מספר טבעי גדול ע"י רשימה משורשרת. כל איבר ברשימה מכיל סיפרה כך שלמשל המספר מיוצג ע"י הרשימה הבאה: NULL שימו לב שהאיבר הראשון מכיל את ספרת היחידות של המספר, השני ספרת ההעשרות,... והאיבר האחרון מצביע ל- NULL. המספר אפס מיוצג פשוט ע"י רשימה ריקה.NULL כתוב פונקציה num) void add(item* num, item* המקבלת את העוגן של שתי רשימות משורשרות שמייצגות שני מספריים טבעיים גדולים. הפונקציה משנה את הרשימה הראשונה כך שהיא תייצג את סכום שני המספרים המיוצגים ע"י הארגומנטים. ידוע שהמספר ש- num מייצג גדול מהמספר ש- num מייצג. 6

7 שאלה - 8 רשימות typedef struct node{ int val; struct node *next; node; להלן הגדרה: עבור רשימה מעגלית השלם את החלק החסר בקוד הבא כך שהפונקציה תמחק את כל איברים הכפולים שברשימה. (עבור האיברים הכפולים הפונקציה משאירה רק את ההופעה הראשונה). void single(node* first){ node *temp, *p, *del; int i; temp = first; while(????!=first){ p = temp; while(????!=first){ if(?? 3?? == temp->val){ del =?? 4??;?? 5?? = del ->next;?? 6??; else p = p -> next;?? 7??; לדוגמה, אחרי הביצוע של הפונקציה הנ"ל הרשימה הראשונה תהפוך לשניה: 7

8 typedef struct item{ int val; struct item * next; item; שאלה 9 רקורסיה ורשימות נתונה ההגדרה הבאה: והפונקציה הבאה: item* what(item* list, item* list) { if(!list) return list; if(!list) return list; if(list->val == list->val) list->next = what(list->next, list->next); else list->next = what(list->next, list); return list; אם list ו- list מצביעים כל אחד על ראש רשימה משורשרת: עבור שתי הרשימות הבאות צייר בדף התשובות לאן מצביע ההחזר של הפונקציה ואת מצב הרשימות אחרי הקריה לפונקציה הנ"ל. 8

9 שאלה רקורסיה ועצים #include <stdio.h> #include <stdlib.h> typedef struct item item; struct item{ int data, data ; item *left, *right; ; מה הפלט של התכנית הבאה: int what(item* here, item* that){ if(!that) return ; return (here->data == that->data) +what(here, that->left)+what(here, that->right); void what(item *head){ if(!head)return; head->data = what(head, head); what(head->left); what(head->right); item *insert(item *root, item *leaf){ if (!root)return leaf; if(leaf->data < root->data) root->left=insert(root->left, leaf); else root->right=insert(root->right, leaf); return root; void print(item *root){ if(!root)return; print(root->left); printf("%d %d\n",root->data, root->data); print(root->right); void main(){ item *root=null, *temp; int a[]= { 5,,4,9,,,7,3,,6,8,, b[]= {,3,,3,3,33,,,,,3,,i; for(i=; i<; i++){ temp=(item*)malloc(sizeof(item)); temp->left=temp->right=null; temp->data=a[i]; temp->data=b[i]; root=insert(root,temp); what(root); print(root); Answer: What changes every node s data to the number of nodes in both its subtrees having the same data value. 9

10 שאלה - 4 רשימות נתונה רשימה מקושרת רגילה מוגדרת ע"י שני הפוינטרים הבאים: הראשון מצביע על האיבר הראשון ברשימה והשני מצביע חדש השלם ב- 7 הקטעים המסומנים ב-???? כך שהפונקציה enqueue תכניס איבר על האיבר האחרון ברשימה. ברשימה. typedef struct Queue { item *head, *tail; Queue; typedef struct item item; struct item { int value; item *next; ; Queue enqueue(queue q, int number) { item *temp =???? ; temp->value =???? ; temp->next =?? 3?? ; if (?? 4?? ) q.head = q.tail =?? 5?? ; else {?? 6?? ; q.tail =?? 7?? ; return q; פתרון:???? = (item*) malloc(sizeof(item))???? = number?? 3?? = NULL?? 4?? =!q.tail או!q.head או!q.tail&&!q.head?? 5?? = temp?? 6?? = q.tail->next = temp?? 7?? = temp

11 שאלה - 5 רשימות פונקצית single מקבלת את העוגן של רשימה משורשרת רגילה,head הפונקציה משחררת מהרשימה את כל המבנים שהערך שבהם הופיע מקודם ברשימה. (הפונקציה משאירה כל ערך פעם אחת ברשימה). השלם בדפי התשובות את 7 הקטעים המסומנים ב-???? כך שהפונקציה תבצע את הנדרש. typedef struct item{ int value; struct item *next; item; void single(item *head){ item *prev, *temp; while( head ){ prev = head; temp = head -> next; while( temp ) if(???? ){???? = temp -> next; free(?? 3?? ); temp =?? 4?? ; else{ prev =?? 5?? ; temp =?? 6?? ;?? 7?? ; פתרון: void single(item *head){ item *prev, *temp; while( head ){ prev = head; temp = head -> next; while( temp ) if( head ->value == temp->value ){ prev -> next = temp -> next; free( temp ); temp = prev -> next; else{ prev = temp ; temp = temp-> next; head = head -> next;

12 שאלה 7 קבצים clangb בסוף כל שנה חברת "פוקסי בע"מ" מסכמת את המכירות של סוכניה. אם סה"כ המכירות של סוכן מסוים קטן מסכום מינימאלי שנקבע מראש החברה תבדוק המשך פעילותו של הסוכן ואם סה"כ המכירות של הסוכן מעל סכום מקסימאלי שנקבע הסוכן מועמד לקידום. נתון קובץ ראשי של כל הסוכנים של החברה, כל שורה בקובץ מכילה: תווים שם הסוכן ספרות מספר הסניף 3 ספרות מספר הסוכן תווים אזור פעילות הקובץ ממוין לפי מספר סניף בסדר עולה ובתוך אותו סניף לפי מספר סוכן גם בסדר עולה. עבור כל חודש לחברה קובץ עם נתוני המכירות של הסוכנים שעבדו באותו חודש. כל שורה בכל קובץ מכילה את הפרטים הבאים: ספרות מספר הסניף 3 ספרות מספר הסוכן 7 ספרות מכירות הקבצים ממוינים לפי מספר סניף בסדר עולה ובתוך אותו סניף לפי מספר סוכן גם בסדר עולה. כתוב פונקציה void report(file* agent, FILE* fp[], int min, int max, char* name, char* name) שמקבלת כארגומנטים: agent מצביע לקובץ הראשי של פרטי הסוכנים, fp מערך של מצביעים לקבציי המכירות החודשיים, min ו- max סכומים מינימאלי ומקסימאלי שנקבעו מראש name שם של קובץ חדש שהפונקציה יוצרת. הקובץ החדש הוא קובץ הסוכנים שסה"כ המכירות שלהם קטן מ- min. הקובץ במבנה דומה לקובץ הראשי עם בסוף כל שורה סה"כ המכירות השנתיות של אותו סוכן (9 ספרות), name שם של קובץ חדש שהפונקציה יוצרת. הקובץ החדש הוא קובץ הסוכנים שסה"כ המכירות שלהם גדול מ- max. הקובץ במבנה דומה לקובץ הראשי עם בסוף כל שורה סה"כ המכירות השנתיות של אותו סוכן (9 ספרות), #include<stdio.h> #include<stdlib.h> כל שורה בקובץ מכילה: ספרות מספר הסניף 3 ספרות מספר הסוכן תווים שם הסוכן 9 ספרות סה"כ מכירות שימו לב: בכל הקבצים אין תווי הפרדה בין השדות אין לעבור על קובץ יותר מפעם אחת. אין להעתיק קובץ שלם למבנה נתונים אחר (מערך, רשימה משורשרת, עץ,קובץ אחר...) void report(file *agent, FILE* fp[], int min, int max, char* name, char* name){

13 FILE *f, *f; int i,eof[], id[], idmain; long sales[], total; char name[]; if(!(f=fopen(name,"w"))) exit(); if(!(f=fopen(name,"w"))) exit(); for(i=;i<;i++) eof[i]=fscanf(fp[i],"%5d%7ld*c",id+i,sales+i); while(fscanf(agent, "%[^$]%5d%**c",name, &idmain)==){ total=; for(i=;i<;i++) if(eof[i]!=eof && id[i]==idmain){ total += sales[i]; eof[i]=fscanf(fp[i],"%5d%7ld*c", id+i, sales+i); if(total < min) fprintf(f, "%5d%s%9d\n", idmain, name, total); else if(total >= max) fprintf(f, "%5d%s%9d\n", idmain, name, total); fclose(f); fclose(f); 3

14 שאלה 8 קבצים פתרון: Clangb חברת הרכבות מעוניינת לשפר את זמני הנסיעה של הרכבות על ידי מציאת נקודות "מפגש הרכבות" שקיימות. נקודת "מפגש רכבות" היא נקודה שבה קיימת מסילה אחת בין שתי נקודות ושתי רכבות מעוניינות לעבור באותה המסילה (לכיוונים שונים כמובן) באותו הזמן בדיוק, אחת הרכבות נאלצת להמתין עד שהרכבת השנייה תעבור. לכל רכבת קיים קובץ מסלול יומי עם המבנה הבא: בשורה הראשונה : o מספר קטר 3 ספרות 4 ספרות במבנה hhmm בפורמט של 4 שעות (השעה 8:3 מיוצגת 83) תווים תווים 4 ספרות ספרה אחת (- מסילה יחידה, - מסילה כפולה) (אם המסילה כפולה אז אין בעיה של מפגש רכבות). מהשורה השנייה ואילך: o שעת הגעה למסילה o o o o נקודת התחלתית נקודת סיום קוד מסילה סוג מסילה כל קובצי הרכבות ממוינים בסדר עולה לפי שעת יציאה מנקודת המוצא. כתוב פונקציה *outfile) void trainreport(file *trainarray[ ], int trainnum, char המקבלת trainarray מערך של מצביעים לקבצים של נתוני מסלולי הרכבות, trainnum גודלו של המערך, outfile שם של קובץ חדש שהפונקציה יוצרת. בקובץ החדש רשום מידע על "מפגשי רכבות" מבין כל הקבצים. כמובן שלא יכולים להגיע לאותה מסילה באותה שעה יותר משתי רכבות. בקובץ החדש כל שורה מכילה את הנתונים הבאים: 4 ספרות במבנה hhmm שעת יציאה 4 ספרות קוד מסילה 3 ספרות, הקטר עם המספר היותר קטן מספר קטר 3 ספרות, הקטר עם המספר היותר גדול מספר קטר הקובץ החדש מוין בסדר עולה לפי שעת יציאה מנקודת המוצא ומיון משנה לפי מספר מסילה. שימו לב: בכל הקבצים אין תווי הפרדה בין השדות כמובן שלא יכולים להגיע לאותה מסילה באותה שעה יותר משתי רכבות. הגבלות: אין לעבור על קובץ יותר מפעם אחת. אין להעתיק קובץ שלם למבנה נתונים אחר (מערך, רשימה משורשרת, עץ,קובץ אחר...) 4

15 #include<stdio.h> #include <stdlib.h> typedef struct train{ int eof, loco, time, num; train; void trainreport(file *trainarray[ ], int trainnum, char *outfile){ train *arr; FILE * fout; int i, way, mintime=5, ind, ind=-; if(!(fout=fopen(outfile,"w"))) exit(); arr = (train*)malloc(sizeof(train)*trainnum); if(!arr)exit(); for(i=; i<trainnum; i++){ fscanf(trainarray[i], "%d", &arr[i].loco); // search for the first line with way== in the file of trainarray[i] do arr[i].eof = fscanf(trainarray[i],"%4d%*c%4d%d", &arr[i].time, &arr[i].num, &way); while(way== && arr[i].eof==3); while(){ for(i=; i<trainnum; i++){ if(arr[i].eof!=3) continue; if(arr[i].time > mintime) continue; if(arr[i].time < mintime ){ mintime = arr[i].time; ind = i; ind=-; continue; /* case of arr[i].time == mintime */ if(arr[i].num > arr[ind].num) continue; // search for the minimal railway number if(arr[i].num < arr[ind].num){ ind = i; ind=-; continue; /* case of arr[i].time == mintime && arr[i].num == arr[ind].num */ if(arr[i].loco < arr[ind].loco){ ind = ind; ind = i; else ind = i; // for if(mintime == 5) break; // case of eof in all the files if(ind >=){ // locomotives on the same railway found fprintf(fout, "%4d%4d%3d%3d\n", mintime, arr[ind].num, arr[ind].loco, arr[ind].loco); 5

16 do do arr[ind].eof = fscanf(trainarray[ind],"%4d%*c%4d%d", &arr[ind].time,&arr[ind].num,&way); while(way== && arr[ind].eof==3); ind = -; arr[ind].eof = fscanf(trainarray[ind],"%4d%*c%4d%d", &arr[ind].time, &arr[ind].num, &way); while(way== && arr[ind].eof==3); mintime = 5; free(arr); fclose(fout); 6

17 שאלה -9 רקורסיה Clang9a Clangb נתון מערך דו מימדי של מספרים שלמים וחיוביים F[N][M] int,מערך של מספרים שלמים וחיוביים S[M] int ומספר שלם k.אנו נרצה לבדוק האם קיימות לכל היותר k שורות של המערך ) F כך שאיחודם מכיל את כל המספרים שבמערך S. F = S = לדוגמה: עבור =k אנו נקבל תשובה חיובית כי: שורה מספר ושורה מספר 3 במערך F (בעלי האינדקסים ו- ) מכילות את המספרים:,5,7,,3 המכילות את כל מספרי המערך S. אולם עבור נקבל כי התשובה שלילית, כיוון שאין שורה אחת במערך F שמכילה כל אברי המערך S. שיש ברשותך את הפונקציות הבאות: הניח int all_zero(int x[m]) ; void x_zero( int x[m],int y[m]) ; void copy(int dest[m], int src[m]); מחזירה אם כל M אברי המערך הם אפס אחרת מחזירה אשר x מאפסת את כל איברי המערך מופיעים במערך y מעתיקה את תוכן המערך src למערך dest השלם את הפונקציה הרקורסיבית covers המחזירה אם ניתן לכסות את כל המערך S ע"י לכל היותר k שורות מהמערך F כאשר מתחילים מהשורה ה- i -ית. int covers( int F[N][M], int S[M], int i, int k){ int temp[m] = {; if (????)???? ; if (???? )?? 3?? ;?? 4???? 5?? ;?? 6?? ;?? 8?? ;?? 8?? ; int covers(int F[N][M],int S[M],int i,int k){ int temp[m]={; if( all_zero(s)) return ; if( k== i==n ) return ; if(covers(f,s,i+,k)) return ; copy(temp,s); x_zero(temp,f[i]); return covers(f,temp,i+,k-); פתרון: 7

18 שאלה רקורסיה prog4a כתוב פונקציה רקורסיבית col) void shablul(int** ar, int row, int col, int row, int שממלאת את המערך הדו- מימדי ar במספרים עולים החל מ- בצורת שבלול. הפונק' מקבלת מצביע למערך,ar מס' שורה (row) ועמודה (col) של התא השמאלי עליון של המערך ומס' שורה (row) ועמודה (col) של התא הימני תחתון של המערך. אין להגדיר פונקציה נוספת לדוגמא עבור 4) shablul(ar,,, 3, נקבל: תזכורת לגבי פתרון בעיות בעזרת רקורסיה: = + פתרון הבעיה המקורית בגודל קטן מ- x. מס' פעולות שיהוו חלק מן הפתרון כך שיתר הבעיה היא בעצם אותה בעיה בגודל קטן מ- x. פתרון הבעיה המקורית בגודל x. #include <stdio.h> #include <string.h> #include <stdlib.h> פתרון: #define ROWS 4 #define COLS 5 void shablul(int** ar, int row, int col, int row, int col) { int i; static int num = ; if (row<=row && col<=col) col { /*Filling top row:*/ row 3 for (i=col; i<=col; i++) ar[row][i] = num++; 3 9 /*Filling right column: */ row 3 for (i=row+; i<=row; i++) ar[i][col] = num++; /*Filling bottom row: */ if (row>row)/*only when the array has more than one row. */ for (i=col-; i>=col; i--) ar[row][i] = num++; /*Filling left column:*/ if (col>col)/*only when the array has more than one column. */ for (i=row-; i>row; i--) ar[i][col] = num++; col shablul(ar, row+, col+, row-, col-); 8

19 העקרון הוא למלא במספרים את השורה העליונה, את העמודה הימנית, את השורה התחתונה ואת העמודה השמאלית ואחר כך לקרוא לרקורסיה שתפתור לנו את הבעיה שנשארת ללא התאים שמלאנו. למשל, אחרי הקריאה הרקורסיבית הראשונה נשאר אם הבעיה: shablul(,,,3) void main() { int i,j; int **arr; תוכנית ראשית שממחישה את השימוש בפונקציה: if(!(arr=(int **)malloc(rows*sizeof(int *)))) { printf("error allocating memory! Exitting "); return; for(i=;i<rows;i++) { if(!(*(arr+i)=(int *)malloc(cols*sizeof(int)))) { printf("error allocating memory! Exitting "); return; shablul(arr,,,rows-,cols-); /*Print the shablul array:*/ for(i=;i<rows;i++) { for(j=;j < COLS;j++) printf("%d\t",arr[i][j]); printf("\n"); 9

20 שאלה 3 רקורסיה clang3a * * * * * * * * * כתוב פונקציה רקורסיבית lines) void V(int שמדפיסה את האות V בכוכביות ב- linesשורות. לדוגמא עבור (5)V יודפס: הכוכבית הראשונה חייבת להופיע בתחילת השורה הראשונה. אין להגדיר פונקציה נוספת. פתרון : void V( int lines ){ static int firstspace=; int i; for (i=; i < firstspace; i++) printf(" "); printf ("*"); if (lines == ){ printf("\n"); firstspace =; return ; for (i=; i< ((*lines-3)) ; i++) printf(" "); printf("*\n"); firstspace ++; V(lines-); פתרון (עבור lines מוגבל) void V(int lines){ static int start=; char str[]=" "; str[start]=str[*lines-+start++]='*'; puts(str); if(n==){ start=; return; V(lines-);

21 שאלה 4 רקורסיה prog3a כתוב פונקציה רקורסיבית lines) void X(int שמדפיסה את האות X בכוכביות ב- linesשורות ) lines נתון אי- זוגי). * * * * * * * * * * * * * * * * * לדוגמא עבור (9)X יודפס: הכוכבית הראשונה חייבת להופיע בתחילת השורה הראשונה. אין להגדיר פונקציה נוספת. פתרון: void X(int lines){ int static blank; int i; if (lines < ) return; for (i=; i<blank; i++) putchar(' '); putchar('*'); if(lines==){ puts(""); return; for (i=; i<lines-; i++) putchar(' '); puts("*"); blank++; X(lines -); blank--; for (i=; i<blank; i++) putchar(' '); putchar('*'); for (i=; i<lines-; i++) putchar(' '); puts("*");

22 שאלה - 5 קבצים נתון קובץ שבו פרטי עובדי החברה. כל שורה בקובץ מכילה את הפרטים הבאים: 3 תווים 9 ספרות ספרות שם העובד ת.ז. מחלקה הקובץ ממוין לפי ת.ז. כתוב פונקציה doublesort שמקבלת מצביע לקובץ הנ"ל ומצביע לקובץ חדש. הפונקציה מעתיקה לקובץ החדש את כל השורות של הקובץ המקורי אבל ממויין לפי מספר מחלקה ובתוך אותה מחלקה ממוין לפי ת.ז. אין להעתיק את הקובץ למבנה נתונים אחר. void doublesort(file *old, FILE *new){ int dept, i; char details[4]; תשובה: for (i = ; i <; i++) { rewind(old); while(fscanf(old, %39[^$]%d%*c,details,&dept) ==) if (dept==i) fprintf(new, %s%d\n, details, dept);

23 שאלה 5 קבציםClanga אגף התנועה של משטרת ישראל התקין לאחרונה לאורך "הכבישים האדומים" מצלמות מהירות גלויות ונסתרות ומצלמות רמזור. לכל מצלמה קובץ שבו מתועדים נתוני העברות, הקבצים ממוספרים מ- עד number.number.txt עד הוא מספר המצלמות שהותקנו - ולכל אחד שם מתאים מ-.txt number - כל הקבצים במבנה דומה: בשורה הראשונה של הקובץ מופיעים: מיקום המצלמה - תווים סוג מצלמה - תווים ובהמשך כל שורה בקובץ מכילה את פרטי העברות הבאים: 6 ספרת yymmdd) לדוגמה התאריך של היום מקודד 6) תאריך 4 ספרות hhmm) לדוגמה השעה 9: מקודדת (9 שעה 3 ספרת מהירות 7 ספרות מס' הרכב שם קובץ תמונה תווים הקבצים ממוינים בסדר כרונולוגי (מיון ראשי לפי תאריך, ומיון משנה לפי שעה) שימו לב שאותו מספר רכב יכול להופיע מספר פעמים באותו קובץ ואפילו ברצף. על מנת לעזור למשטרת ישראל נכתוב פונקציה number) int radar(int שמקבלת number שהותקנו. עבור כל עבריין תנועה הפונקציה יוצרת קובץ ששמו מספר הרכב עם סיומת.dat מספר המצלמות כל שורה בקובץ מכילה: 6 ספרת yymmdd) לדוגמה התאריך של היום מקודד 6) תאריך 4 ספרות hhmm) לדוגמה השעה 9: מקודדת (9 שעה 4 ספרות מס' מצלמה תווים מיקום המצלמה 3 ספרת מהירות שם קובץ תמונה תווים הקבצים ממוינים בסדר כרונולוגי (מיון ראשי לפי תאריך, ומיון משנה לפי שעה) במקרה וארעה שגיאה בפתיחה או סגירה של אחד הקבצים הפונקציה תחזיר, אחרת. לב: שימו בכל הקבצים אין תווי הפרדה בין השדות אין לעבור על קובץ יותר מפעם אחת. אין להעתיק קובץ למבנה נתונים אחר (מערך, רשימה משורשרת, עץ,קובץ אחר...) 3

24 תשובה: typedef struct camera{ FILE *fp; int eof; char place[], time[]; camera; int radar( int number){ camera *arr; FILE *fp; char filename[], *mintime="993", photo[]; int i, index=-, speed, car,; if(!(arr=(camera*)malloc(sizeof(camera)*number)))exit(); for(i=; i<number; i++){ sprintf(filename, "%d.txt", i+); if(!(arr[i].fp=fopen(filename, "r")))return ; fscanf(arr[i].fp, "%[^$]%*c", arr[i].place); arr[i].eof=fscanf(arr[i].fp, "%s", arr[i].time); while(){ for(i=; i<number; i++) if(arr[i].eof==&& strcmp(arr[i].time, mintime)<){ mintime = arr[i].time; index = i; if(index==-) break; arr[index].eof = fscanf(arr[index].fp, "%3d%7d%[^$]%*c", &speed, &car, photo); sprintf(filename, "%d.dat", car); if(!(fp=fopen(filename, "a")))return ; fprintf(fp, "%s%4d%s%3d%s\n", mintime, index, arr[index].place, speed, photo); if(fclose(fp)==eof) return ; arr[index].eof=fscanf(arr[index].fp,"%s", arr[index].time); index=-; mintime="993"; for(i=; i<number; i++) if(fclose(arr[i].fp)==eof) return ; free(arr); return ; 4

25 שאלה ( 7 נקודות) פועל מסוגל לטפס בסולם כך שבכל פעם הוא מתקדם שלב אחד או שני שלבים או שלושה שלבים. סעיף א'. (4 נקודות) כתובו פונקציה רקורסיבית (n int ladderrec(int שמקבלת את מספר השלבים הכולל בסולם ומחזירה את מספר המסלולים האפשריים בהם הפועל יכול לעלות בסולם. סעיף ב'. (6 נקודות) כתובו פונקציה איטרטיבית (n int ladder(int שמקבלת את מספר השלבים הכולל בסולם ומחזירה את מספר המסלולים האפשריים בהם הפועל יכול לעלות בסולם. (כמו א' רק איטרטיבי שימו לב למגבלות) הגבלות: בסעיף א' אין להשתמש בלולאות כלל. בסעיף ב' - אין להשתמש ביותר מלולאה אחת וכמובן לא ברקורסיה. בשני הסעיפים - אין להשתמש בפונקצית עזר או בפונקצית ספריה. דוגמא (רלוונטית לשני הסעיפים): בסולם עם 7 שלבים, אחד המסלולים האפשריים 3. 3 עוד מסלול אפשרי הוא 3 וכמובן שיש עוד מסלולים אפשריים (שימו לב, עליכם להחזיר את מספר המסלולים האפשריים ולא את המסלולים עצמם). פתרון: סעיף א'. (4 נקודות) סעיף ב'. (6 נקודות) int ladderrec(int n){ if(n < ) return ; if(n == ) return ; return ladderrec(n-3) + ladderrec(n-) + ladderrec(n-); int ladder(int n){ int lad=, lad=, lad=, ladn, i; if(n < ) return ; if(n == ) return ; for(i= 3; i<=n; i++){ ladn = lad + lad + lad; lad = lad; lad = lad; lad = ladn; return ladn; 5

26 #include <stdio.h> מועד א' 4//3: שאלה ) 5 נקודות) נתונה התכנית הבאה : int what(char* str, char* str){ int x, y; if (!*str!*str) return ; if (*str == *str) return + what(str+, str+); x = what(str, str+); y = what(str+, str); return x > y? x : y; void main(){ char str[ ] = "abacdecee"; char str[ ] = "acdce"; char str3[ ] = "fchdeeaa"; char str4[ ] = "aabcedacdeecsb"; printf("%d, %d, %d\n",what(str,str),what(str,str3),what(str,str4)); סעיף א'. (6 נקודות) מה הפלט של התכנית הנ"ל? סעיף ב'. (9 נקודות) הסבר במשפט אחד מה יעודה של הפונקציה. what על פי הנתונים של התכנית הנתונה הסבר כל פלט של הסעיף הקודם. פתרון: נקודות) 5, 4, 7 סעיף א'. (6 סעיף ב'. (9 נקודות) הפונקציה מחשבת את מספר האותיות הזהות (בסדרן המקורי) המקסימאלי המופיע בשתי המחרוזות. str[ ]= "abacdecee" str[ ]= "acdce" 5 str[ ]= "abacdecee" str3[ ]= "fchdeeaa" 4 str[ ]= "abacdecee" str4[ ]= "aabcedacdeecsb" 7 6

27 שאלה (5 נקודות) נתונה התכנית הבאה: #include<stdio.h> int what(int *arr, int n, int val, int k, int flag, int *res, int n){ int i, x, y=, z=; if (k==) if (val==){ for (i=; i<n; i++) printf("%d ",res[i]); printf("\n"); return ; else return ; if (n==) return ; x = what(arr+, n-, val, k,, res, n); if (flag){ res[n] = *arr; y = what(arr+, n-, val-*arr, k-,, res, n+); res[n] = -*arr; z = what(arr+, n-, val+*arr, k-,, res, n+); return x+y+z; void main(){ int arr[ ] = {5, -9, 3,, 7, 8, 4,, 5; int res[5]; printf("%d\n",what(arr, 9,, 3,, res, ) ); סעיף א'. (9 נקודות) מה הפלט של התכנית הנ"ל? סעיף ב'. (6 נקודות) הסבר בקצרה מה יעודה של הפונקציה what פתרון: סעיף א'. (9 נקודות) סעיף ב'. (6 נקודות) הפונקציה מדפיסה כל האפשרויות להגיע למספר val עם k איברים של המערך,arr ללא איברים שכנים רק עם פעולות חיבור וחיסור, הפונקציה מחזירה את מספר האפשרויות. 7

28 שאלה (5 3 נקודות) נתונה ההגדרה הבאה: typedef struct Node { int numofnbrs; struct Node* neighbors[]; int color; שדה עזר // tmp; int Node; נתון מבנה נתונים הבנוי מאוסף של צמתים מטיפוס,Node כך שכל צומת מכיל מערך של מצביעים לשכנים שלו. שכנות במבנה נתונים זה מוגדרת כדו-כיוונית. כלומר: אם X הוא שכן של Y, אזי Y שכן של X גם כן. השדה numofnbrs מייצג את מספר השכנים שיש לצומת. ניתן להניח שכל השכנים נמצאים בתחילתו של המערך neighbors וכן שלא יהיו יותר מ שכנים לצומת. כל צומת מכיל גם שדה color המייצג את הצבע של הצומת. בנוסף לשדות לעיל' בכל צומת קיים שדה עזר tmp שמאותחל ל- ניתן לעשות בו שימוש כרצונכם. צביעה חוקית של מבנה הנתונים הנ"ל היא קביעת כל ערכי הצבעים כך שכל צומת צבוע בצבע שונה משכניו. השלימו את הפונקציה (n int legalcoloring(node* אשר מקבלת צומת מסוים n ומחזירה אם מבנה הנתונים צבוע באופן חוקי ו- אחרת. מותר להשתמש בשדה temp כרצונכם. השלימו את הקטעים החסרים (המסומנים ב-?? N?? ( בקוד הבא. int legalcoloring(node* n){ int i; if (???? )???? ;?? 3?? ; for (i=;?? 4?? ; i++) if (?? 5???? 6??)?? 7?? ; return?? 8?? ; int legalcoloring(node* n){ int i; if ( n->tmp ) return ; n->tmp = ; פתרון: for (i=; i<n->numofnbrs ; i++) if (n->color == n->neighbors[i]->color!legalcoloring(n-> neighbors[i])) return ; return ; 8

29 typedef struct node { int value; struct node* next; Node; שאלה ( 4 נקודות) נתונה הגדרה הבאה שמאפשרת להגדיר חוליה ברשימה משורשרת: הגדרות: א. בהינתן שתי קבוצות ערכים, פעולת חיתוך בין שתי הקבוצות מוגדרת כחישוב קבוצת הערכים אשר מופיעים בשתי הרשימות. ב. בהינתן שתי קבוצות ערכים, פעולת איחוד בין שתי הקבוצות מוגדרת כחישוב קבוצת הערכים אשר מופיעים גם בקבוצה הראשונה וגם בקבוצה השנייה. כל איבר יבחר פעם אחת בלבד גם אם הוא מופיע בכל אחת מהקבוצות. דוגמא: בהינתן הקבוצות הבאות: A = {,, 6, 4, 5, 3 B = {, 6, 7, C={,, 6 אזי נקבל: B ו- A אם C היא קבוצת החיתוך בין D={,, 6, 4, 5, 3, 7 אזי נקבל: B ו- A אם D היא קבוצת האיחוד בין סעיף א'. (8 נקודות) כתבו פונקציה list) Node* intersection(node* list, Node* אשר מקבלת מצביעים לשתי רשימות ומחזירה רשימה חדשה המהווה את רשימת החיתוך בין שתי הרשימות. סעיף ב'. ( נקודות) כתבו פונקציה list) Node* union(node* list, Node* אשר מקבלת מצביעים לשתי רשימות ומחזירה רשימה חדשה המהווה את רשימת האיחוד בין שתי הרשימות. אין לשנות את הרשימות הנתונות דרך הארגומנטים. ניתן להניח כי בכל רשימה הערכים מופיעים בדיוק פעם אחת ללא כפילויות. אין חשיבות לסדר בו יופיעו האיברים ברשימות האיחוד\חיתוך. 9

30 פתרון: סעיף א'. (8 נקודות) Node* intersection(node* list, Node* list){ Node* aux, *aux, *newnode, *newlist=null; if (!list!list) return NULL; //copy list for (aux=list; aux; aux=aux->next){ for (aux=list; aux && aux->value!=aux->value; aux=aux->next); if (aux){ //found a common value for both lists newnode = (Node*)malloc(sizeof(Node)); newnode->value = aux->value; newnode->next = newlist; newlist = newnode; return newlist; סעיף ב'. ( נקודות) Node* union(node* list, Node* list){ Node* aux, *aux, *newnode, *newlist=null; int tvalue = -; if (!list &&!list)return NULL; if (!list) return list; if (!list) return list; //copy list aux=list; while (aux){ newnode = (Node*)malloc(sizeof(Node)); newnode->value = aux->value; newnode->next = newlist; newlist = newnode; aux = aux->next; aux = list; while (aux){ tvalue = aux->value; for (aux=list; aux && aux->value!=tvalue; aux=aux->next); if (!aux){ //tvalue doesn't exists in list and we need to add it newnode = (Node*)malloc(sizeof(Node)); newnode->value = tvalue; newnode->next = newlist; newlist = newnode; // else do nothing. tvalue already exist in list! aux = aux->next; return newlist; 3

31 שאלה ) 5 נקודות) typedef struct Node {. struct Node *left, *right ; struct Node *parent, *next; Node; ההגדרה הבאה מאפשרת לייצג עץ בינארי כלשהו: נתון עץ בינארי בו עבור כל קודקוד מעודכנים שני בניו: left ו-.right כתבו פונקציה רקורסיבית tree) Node* update(node* אשר מקבלת מצביע לעץ. על הפונקציה לעדכן את השדות ה- parent וה- next של כל קודקוד בעץ, כך ששדה parent יהיה מצביע לאב של הצומת. עדכון שדות ה- next יתבצע כך שהרשימה המקושרת המתקבלת מהם תהיה סריקת ה- post-order של העץ. על הפונקציה להחזיר את ראש רשימת ה- post-order. שימו לב: אין להשתמש בלולאה אין להשתמש בפונקצית ספריה אין להשתמש בפונקצית עזר Node *update(node* tree){ Node *head, *temp; פתרון: if(!tree) return tree; head =tree; tree->next = NULL; if(tree->right){ tree->right->parent = tree; head = update(tree->right); tree->right->next = tree; if(tree->left){ tree->left->parent = tree; temp = head; head = update(tree->left); tree->left->next = temp; return head; 3

32 שאלה ( 6 נקודות) התמודדו בבחירות לכנסת 3 מפלגות לכל מפלגה קוד בין ל- 3. ועדת הבחירות לכנסת מקבלת מכל הישובים קלפיות ולאחר ספירת הקולות יוצרת קובץ של תוצאות הקלפיות. כל שורה בקובץ מכילה: שם הישוב תווים 4 ספרות 3 ספרות סמל הישוב מספר קלפי אין תווי הפרדה בין השדות הנ"ל, לאחר מכן בשורה מופיעים ברצף 3 מספרים שהם תוצאות הבחירות מסודרים לפי קוד מפלגה. (המספר הראשון מספר קולות של מפלגה מס', השני עבור מפלגה מס'...) בן מספר למספר רוח, אין רוח בסוף השורה. בנוסף לקולות הקלפיות הועדה סופרת קולות של "המעטפות הכפולות" (של החיילים, ימאים ועוד) ויוצרת קובץ התוצאות של "המעטפות הכפולות". מבנה הקובץ זהה למבנה הקובץ הקודם אבל מופיעות אך ורק שורות של הקלפיות שעבורם היו "מעטפות כפולות". שני הקבצים ממוינים לפי סמל ישוב בסדר עולה ומיון משנה לפי מספר קלפי גם בסדר עולה. כתובו פונקציה *updated) int vote(file *ballot, FILE* doubled, char שמקבלת ballot מצביע של קובץ הקלפיות, doubled מצביע של קובץ "המעטפות הכפלות" ו מחרוזת.updated הפונקציה יוצרת קובץ חדש ששמו במחרוזת updated לפי המבנה שתואר לעיל, שמכיל את הפרטים של כל הקולות בכלל (של הקלפיות ושל המעטפות הכפולות). הקובץ ממוין לפי סמל ישוב בסדר עולה ומיון משנה לפי מספר קלפי גם בסדר עולה. בשורה האחרונה של הקובץ מופיע רצף של 3 מספרים שהם סיכום הקולות של כל מפלגה. בן מספר למספר רוח, אין רוח בסוף השורה. במקרה וארעה שגיאה בפתיחה או סגירה של קובץ הפונקציה תחזיר, אחרת. שימו לב! אין לעבור על קובץ יותר מפעם אחת. אין להעתיק קובץ למבנה נתונים אחר (מערך, רשימה משורשרת, עץ,קובץ אחר...) 3

33 פתרון: int vote(file *ballot, FILE* doubled, char *updated) { char name[]; int kalpib, kalpid, party[3], partyd, flag, i, total[3]={; FILE *fp; if(!(fp=fopen(updated,"w"))) return ; flag=fscanf(doubled, "%*c%7d", &kalpid); while(fscanf(ballot, "%[^\n]%7d", name, &kalpib)!=eof){ fprintf(fp, "%s%7d", name, kalpib); for(i=; i<3; i++) fscanf(ballot, "%d", party+i); fgetc(ballot); if(flag== && kalpib==kalpid){ for(i=; i<3; i++){ fscanf(doubled, "%d", &partyd); party[i] += partyd; flag=fscanf(doubled, "%*c%7d", &kalpid); for(i=; i<3; i++){ fprintf(fp, "%d ", party[i]); total[i] += party[i]; fprintf(fp, "%d\n", party[3]); total[3] += party[3]; for(i=; i<3; i++) fprintf(fp, "%d ", total[i]); fprintf(fp, "%d\n", total[3]); if(fclose(fp)==eof) return ; return ; 33

34 שאלה - רקורסיה כתוב פונקציה רקורסיבית letter) void startbychar(char *string, char אשר מקבלת מחרוזת ותו, ומדפיסה את כל הסיומות של המחרוזת המתחילות בתו הזה. abcbabcbdbabca abcbdbabca abca a לדוגמה עבור המחרוזת babcbabcbdbabca" פתרון: והתו a ידפסו השורות הבאות: void startbychar(char string[ ], char letter){ if (!*string) return; if (*string==letter) puts(string); startbychar(string+); 34

35 typedef struct node { struct { int key; char value[3]; info; struct node *left, *right; node; node* What(node* root, int a, int b) { node *new = root; if (root) { if (root->info.key < a) new = What (root->right, a, b); else if (root->info.key > b) new = What (root->left, a, b); שאלה 3 עצים ורקורסיה כדי לממש עץ חיפוש בינארי, הוגדר המבנה הבא : נתונה הפונקציה הבאה : else if ((new = (node*) malloc(sizeof(node)))) { new->info = root->info; new->left = What (root->left, a, b); new->right = What (root->right, a, b); else new = NULL; return new; סעיף א ( נקודות) מצביע על השורש שלו : root בהינתן העץ הבינארי הבא ש ( root,, What( צייר את העץ שהפונקציה תחזיר לאחר הקריאה : סעיף ב (5 נקודות) הסבר בקצרה מה יעודה של הפונקציה.What The What function returns a new tree which is a subtree of the original tree, and for every value x of the new tree, a<=x<=b. 35

36 שאלה רקורסיה נתון מערך של אורכי לבנים. למשל עבור לבנים באורך של, ו- 3 מוגדר מערך bricks[3]={,,3. int ברצוננו לבנות פס באורך נתון מהלבנים של המערך.bricks הפונקציה width) int HowManySets( int *bricks, int size, int מקבלת כארגומנטים : bricks - מערך של אורכי הלבנים, המערך ממוין בסדר עולה, - גודל המערך, size width - אורך הפס הנדרש..bricks מספר הלבנים הפונקציה מחזירה את מספר האפשרויות לבנות פס באורך width מהלבנים של המערך אינו מוגבל. bricks מכל אורך שרשום במערך 7 שווה 4 הפונקציה מחזירה width למשל עבור מערך הדוגמה ו- כי הסידורים האפשריים הם: 3 3 השלימו בדף התשובות הקטעים החסרים המסומנים ב -?? N??. int HowManySets (int *bricks, int size, int width){ int res=,i; if(????) return ; for(???? ) if(?? 3?? >=bricks[i])?? 4?? += HowManySets (?? 5??,?? 6??,?? 7??); return?? 8??; פתרון: int HowManySets (int *bricks, int size, int width){ int res=,i; if(! width ) return ; for( i=; i<size; i++ ) if( width >=bricks[i]) res += HowManySets (bricks, size, width-bricks[i]); return res ; 36

37 void what(char *s, char *s, char *temp, int index){ if (*s == '\'){ strcpy(temp+index, s); printf("%s\n", temp); return; if (*s == '\'){ strcpy(temp+index, s); printf("%s\n", temp); return; temp[index] = *s; what(s+, s, temp, index+); temp[index] = *s; what(s, s+, temp, index+); שאלה רקורסיה clanga נתונה התכנית הבאה: int main(){ char *str = "AB"; char *str = "xyz"; char *temp= (char *)malloc(strlen(str)+strlen(str)+); what(str, str, temp, ); סעיף א'. מה הפלט של התכנית? סעיף ב'. הסבר בקצרה מה מטרתה של הפונקציה?what פתרון: ABxyz AxByz AxyBz AxyzB xabyz xaybz xayzb xyabz ayazb xyzab סעיף א ( נקודות ( סעיף ב (5 נקודות ( הפונקציה מדפיסה את כל הצירופים האפשריים בין שתי המחרוזות שהיא מקבלת תוך כדי שמירת סדר האותיות היחסי של כל אחד מהמחרוזות המקוריות. 37

38 #define M 8 #define N 8 void What( int mat[][m], int i, int j, int c){ int di, dj; if (i < i > N j < j > M- mat[i][j]) return; mat[i][j] = c; for (di = -; di<= ; di++) for (dj = - ; dj<= ; dj++) What(mat, i+di, j+dj, c); שאלה (6 6 נקודות) נתונות שתי הפונקציות הבאות: int What(int mat[][m]) { int count=, i, j; for (i=; i < N; i++) for (j=; j < M; j++) if (mat[i][j] == ) { count++; What(mat, i, j, count); return count ; סעיף א (6 נקודות) יהי mat המערך הבא : צייר את המערך mat לאחר הקריאה ל- ( What(mat,,3, סעיף ב (6 נקודות) 38

39 39 יהי :אבה ךרעמה mat mat ךרעמה תא רייצ -ל האירקה רחאל What(mat).הריזחמ היצקנופהש ךרעה תאו ףיעס ג 4) (תודוקנ רבסה תויצקנופה תושוע המ הרצקב What.What -ו :ןורתפ א ףיעס What(mat, 3,, ) ב ףיעס ףיעס ג היצקנופה what הדוקנהמ "תעבוצ" לש שוגבש םינכשה םיאתה לכ תא map[i][j] םיספא םיליכמש map[i][j] עבצל fill-ל המודב).c.(paintbrush-ב היצקנופה what עבצהמ רחא עבצב שוג לכ "תעבוצ" fill-ל המודב) םישוגה רפסמ ריזחמו.(paintbrush-ב.ועבצש