2 – הרזח תולאשprog172/wiki.files/review-sol-Prog171-2.pdf · 1 2 – הרזח תולאש...

1

2 –שאלות חזרה

קבצים - 3שאלה

נתונים שני קבצים: קובץ נתוני הסטודנטים של הקורס שלנו, כל שורה בקובץ מכילה את הפרטים הבאים: )1 תווים 20 - שם הסטודנט - תווים 20 - כתובת - ספרות 9 - מספר ת.ז. - ספרות 3 - קוד מחלקה - ספרות 3 - ציון סופי בקורס -

מסודר לפי מספר ת.ז. בסדר עולה.הקובץ ) קובץ פרטי כל המחלקות של האוניברסיטה, כל שורה בקובץ מכילה את הפרטים הבאים:2 תווים 10 - שם המחלקה - ספרות 3 - קוד מחלקה - תווים 20 - שם ראש המחלקה -

הקובץ מסודר לפי קוד מחלקה בסדר עולה.

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

שמקבלת כפרמטרים שני מצביעים לקבצים הנ"ל ויוצרת קובץ חדש בשם excellentכתוב פונקציה

"excellent.dat” הסטודנטים המצטיינים, כל שורה בקובץ מכילה:של כל ספרות 10 - שם המחלקה - ספרות 3 - קוד המחלקה - תווים 20 - שם הסטודנט - ספרות 9 - מספר ת.ז. -

הקובץ מסודר לפי קוד מחלקה בסדר עולה.

אין להעתיק קובץ למבנה נתונים אחר (מערך, רשימה משורשרת, ...) :הגבלה

2

תשובה:void excellent(FILE* student, FILE* department){ FILE* excel; char name[21],id[10], dp_name[11]; 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(1); } while(fscanf(department,"%10[^$]%3d%*21c",dp_name,&cod_d)==2){ max = -1; rewind(student); while(fscanf(student,"%*49c%3d%3d%*c",&cod_s,&grade)==2) if(cod_s==cod_d && grade>max) max = grade; if(max == -1)continue; rewind(student);

while(fscanf(student,"%20[^$]%*20c%9s%3d%3d%*c", name,id,&cod_s, &grade)==4)

if(cod_s==cod_d && grade==max) fprintf(excel,"%s%03d%s%s\n",dp_name,cod_d,name,id); } if(fclose(excel)== EOF){ printf("Error closing file excellent.dat\n"); exit(1); } }

3

קבצים - 5ה שאל

קבצים של כל האורחים לחתונה (אחד של אורחי הכלה ואחד של אורחי החתן). 2נתונים

כל שורה בקבצים מכילה את הפרטים הבאים: תווים 15 – שם פרטי

תווים 15 – שם משפחה )120עד 0-ספרות (מ 3 – גיל

תווים (מלל חפשי) 30 – הערות

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

שמקבלת כארגומנטים guest(FILE* f1, FILE* f2, char* filename1, char* filename2) כתוב פונקציה

מחרוזות שהן השמות של הקבצים החדשים שהפונקציה יוצרת.שני מצביעים לקבציים הנ"ל ושתי

שני הקבצים החדשים הם במבנה זהה לשני הקבצים הנתונים.

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

החדשים גם ממוינים לפי שם משפחה ושם פרטי.שני הקבצים

אין לקרוא קובץ יותר מפעם אחת. :הגבלה

...)קובץ אחר,עץ, רשימה משורשרת, מערך(אין להעתיק קובץ למבנה נתונים אחר

4

תשובה:

void guests(FILE* f1, FILE* f2, char *filename1, char *filename2 ){ char first1[16],last1[16], name1[31], details1[34], first2[16], last2[16], name2[31], details2[34]; FILE *twice, *once; int flag1, flag2; if(!(once = fopen(filename1, "w"))){ puts(" The program cannot open file"); exit(1); } if(!(twice = fopen(filename2, "w"))){ puts(" The program cannot open file"); exit(1); } flag1=fscanf(f1, "%15[^$]%15[^$]%[^\n]*c",first1,last1,details1); if(flag1==3){ strcpy(name1,last1); strcat(name1,first1); } flag2=fscanf(f2, "%15[^$]%15[^$]%[^\n]*c",first2, last2, details2); if(flag2==3){ strcpy(name2,last2); strcat(name2,first2); } while(flag1==3 || flag2==3) if(flag2==3 && flag1==3 && !strcmp(name1,name2)){ fprintf(twice,"%15s%15s%33s\n",first1,last1,details1); flag1=fscanf(f1, "%15[^$]%15[^$]%[^\n]*c",

first1,last1,details1); if(flag1==3){ strcpy(name1,last1); strcat(name1,first1); } flag2= fscanf(f2, "%15[^$]%15[^$]%[^\n]*c",

first2, last2, details2); if(flag2==3){ strcpy(name2,last2); strcat(name2,first2); } } else if(flag2!=3|| flag1==3 && strcmp(name1,name2)<0){ fprintf(once,"%15s%15s%33s\n",first1,last1,details1); flag1= fscanf(f1, "%15[^$]%15[^$]%[^\n]*c",

first1, last1, details1); if(flag1==3){ strcpy(name1,last1); strcat(name1,first1); } } else{ fprintf(once,"%15s%15s%33s\n",first2,last2,details2); flag2= fscanf(f2, "%15[^$]%15[^$]%[^\n]*c",

first2, last2, details2); if(flag2==3){ strcpy(name2,last2); strcat(name2,first2); } } fclose(once); fclose(twice); }

5

רשימות - 6ה שאל :נתונה ההגדרה הבאה

typedef struct node{ int value; struct node* next; }Node;

הפונקציה הבאה מחפשת את האמצע של הרשימה ושם חוצה את הרשימה לשתי רשימות.

Node* middle(Node* source){ Node *fast, *slow, *source2;

if (source==NULL || ??1 ?? ) return NULL; slow = source; fast = ?? 2 ?? ; while (?? 3 ??) { fast = fast->next; if ( ?? 4 ?? ) { slow = slow->next; fast = fast->next; } } source2 = slow->next; slow->next = ?? 5 ?? ; return ??6 ?? ; }

החסרים.השלם בדף התשובות את הקטעים

:פתרון

Node* middle(Node* source){ Node *fast, *slow, *source2; 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; } } source2 = slow->next; slow->next = NULL ; return source2; }

6

רשימות - 7ה שאל :נתונות ההגדרה הבאה שמאפשרת להגדיר מבנה של רשימה משורשרת

typedef struct item{ int digit; struct item *next; }item;

רשימה משורשרת.ניתן לייצג מספר טבעי גדול ע"י מיוצג ע"י הרשימה הבאה: 1234567890כל איבר ברשימה מכיל סיפרה כך שלמשל המספר

0 � 9 � 8 � 7 � 6 � 5 � 4 � 3 � 2 � 1 � NULL

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

.NULLהמספר אפס מיוצג פשוט ע"י רשימה ריקה

המקבלת את העוגן של שתי רשימות משורשרות שמייצגות void add(item* num1, item* num2)כתוב פונקציה שני מספריים טבעיים גדולים.

ידוע הפונקציה משנה את הרשימה הראשונה כך שהיא תייצג את סכום שני המספרים המיוצגים ע"י הארגומנטים.

מייצג. num2-מייצג גדול מהמספר ש num1- שהמספר ש

7

רשימות - 8ה שאל

להלן הגדרה:typedef struct node{ int val; struct node *next; } node;

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

void single(node* first){ node *temp, *p, *del; int i; temp = first; while(?? 1 ?? !=first){ p = temp; while(?? 2 ?? !=first){ if(?? 3 ?? == temp->val){ del = ?? 4 ??; ?? 5 ?? = del ->next; ?? 6 ??;

} else p = p -> next;

} ?? 7 ??; } }

לדוגמה, אחרי הביצוע של הפונקציה הנ"ל הרשימה הראשונה תהפוך לשניה:

8

רקורסיה ורשימות – 9ה שאל נתונה ההגדרה הבאה:

typedef struct item{ int val; struct item * next; }item;

והפונקציה הבאה:

item* what(item* list1, item* list2) { if(!list1) return list2; if(!list2) return list1; if(list1->val == list2->val) list1->next = what(list2->next, list1->next); else list1->next = what(list1->next, list2); return list1; }

מצביעים כל אחד על ראש רשימה משורשרת: list2-ו list1אם

עבור שתי הרשימות הבאות צייר בדף התשובות לאן מצביע ההחזר של הפונקציה ואת מצב הרשימות אחרי הקריה לפונקציה הנ"ל.

9

רקורסיה ועצים – 12שאלה

מה הפלט של התכנית הבאה:#include <stdio.h> #include <stdlib.h> typedef struct item item; struct item{ int data1, data2 ; item *left, *right; }; int what1(item* here, item* that){ if(!that) return 0; return (here->data2 == that->data2) +what1(here, that->left)+what1(here, that->right); } void what2(item *head){ if(!head)return; head->data1 = what1(head, head); what2(head->left);

what2(head->right); } item *insert(item *root, item *leaf){ if (!root)return leaf; if(leaf->data1 < root->data1) 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->data1, root->data2); print(root->right); } void main(){ item *root=NULL, *temp; int a[]= { 15,12,14,19,11,21,17,13,20,16,18,22}, b[]= { 12,23,12,31,23,33,11,12,22,12,23,11},i;

for(i=0; i<12; i++){ temp=(item*)malloc(sizeof(item)); temp->left=temp->right=NULL; temp->data1=a[i]; temp->data2=b[i]; root=insert(root,temp); } what2(root); print(root); }

Answer: What2 changes every node’s data1 to the number of nodes in both its subtrees having the same data2 value.

10

רשימות - 14שאלה הראשון מצביע על האיבר הראשון ברשימה והשני מצביע : י שני הפוינטרים הבאים"נתונה רשימה מקושרת רגילה מוגדרת ע

חדש תכניס איבר enqueueכך שהפונקציה ?? ?? -הקטעים המסומנים ב 7-השלם ב. על האיבר האחרון ברשימה .ברשימה

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 = ?? 1 ?? ; temp->value = ?? 2 ?? ; temp->next = ?? 3 ?? ; if ( ?? 4 ?? )

q.head = q.tail = ?? 5 ?? ; else { ?? 6 ?? ; q.tail = ?? 7 ?? ; } return q; }

פתרון:

?? 1 ?? = (item*) malloc(sizeof(item))

?? 2 ?? = number

?? 3 ?? = NULL

?? 4 ?? = !q.tail או !q.head או !q.tail&&!q.head

?? 5 ?? = temp

?? 6 ?? = q.tail->next = temp

?? 7 ?? = temp

11

רשימות - 15שאלה

הפונקציה משחררת מהרשימה את כל המבנים , headמקבלת את העוגן של רשימה משורשרת רגילה singleפונקצית ). הפונקציה משאירה כל ערך פעם אחת ברשימה. (מקודם ברשימהשהערך שבהם הופיע

.כך שהפונקציה תבצע את הנדרש ?? ?? -הקטעים המסומנים ב 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( ?? 1 ?? ){ ?? 2 ?? = 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

clang102bקבצים – 17שאלה

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

סכום מקסימאלי שנקבע הסוכן מועמד לקידום.הסוכן ואם סה"כ המכירות של הסוכן מעל נתון קובץ ראשי של כל הסוכנים של החברה, כל שורה בקובץ מכילה:

תווים 20 שם הסוכן •

ספרות 2 מספר הסניף •

ספרות 3 מספר הסוכן •

תווים 20 אזור פעילות •

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

כל שורה בכל קובץ מכילה את הפרטים הבאים:



ספרות 7 מכירות •

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

void report(FILE* agent, FILE* fp[12], int min, int max, char* name1, char* name2) שמקבלת כארגומנטים:

• agent ,מצביע לקובץ הראשי של פרטי הסוכנים

• fp מצביעים לקבציי המכירות החודשיים, 12מערך של

• min ו-max סכומים מינימאלי ומקסימאלי שנקבעו מראש

• name1 שם של קובץ חדש שהפונקציה יוצרת. הקובץ החדש הוא קובץ הסוכנים שסה"כ המכירות שלהם

הקובץ במבנה דומה לקובץ הראשי עם בסוף כל שורה סה"כ המכירות השנתיות של אותו . min-קטן מ

ספרות) , 9סוכן (

• name2 שם של קובץ חדש שהפונקציה יוצרת. הקובץ החדש הוא קובץ הסוכנים שסה"כ המכירות שלהם

הקובץ במבנה דומה לקובץ הראשי עם בסוף כל שורה סה"כ המכירות השנתיות של אותו . max-גדול מ

ספרות) , 9סוכן (

כל שורה בקובץ מכילה: •



תווים 20 שם הסוכן •

ספרות 9 סה"כ מכירות • שימו לב:

בכל הקבצים אין תווי הפרדה בין השדות •

אין לעבור על קובץ יותר מפעם אחת. •

...)קובץ אחר,עץ, רשימה משורשרת, מערך(אין להעתיק קובץ שלם למבנה נתונים אחר • #include<stdio.h> #include<stdlib.h> void report(FILE *agent, FILE* fp[12], int min, int max, char* name1, char* name2){

13

FILE *f1, *f2; int i,eof[12], id[12], idMain; long sales[12], total; char name[21]; if(!(f1=fopen(name1,"w"))) exit(1); if(!(f2=fopen(name2,"w"))) exit(1); for(i=0;i<12;i++) eof[i]=fscanf(fp[i],"%5d%7ld*c",id+i,sales+i); while(fscanf(agent, "%20[^$]%5d%*21*c",name, &idMain)==2){ total=0; for(i=0;i<12;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(f1, "%05d%s%09d\n", idMain, name, total); else if(total >= max) fprintf(f2, "%05d%s%09d\n", idMain, name, total); } fclose(f1); fclose(f2); }

14

Clang101b:שאלה 18 – קבצים פתרון

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

נקודת "מפגש רכבות" היא נקודה שבה קיימת מסילה אחת בין שתי נקודות ושתי רכבות מעוניינות לעבור באותה

, אחת הרכבות נאלצת להמתין עד שהרכבת השנייה תעבור.באותו הזמן בדיוקהמסילה (לכיוונים שונים כמובן) כל רכבת קיים קובץ מסלול יומי עם המבנה הבא:ל

בשורה הראשונה : •o ספרות 3 מספר קטר

מהשורה השנייה ואילך: •o ספרות במבנה 4 שעת הגעה למסילהhhmm שעות 24בפורמט של

)0830מיוצגת 8:30(השעה o תווים 10 נקודת התחלתית o תווים 10 נקודת סיום o ספרות 4 קוד מסילה o מסילה כפולה) -2מסילה יחידה , -1אחת ( ספרה סוג מסילה

(אם המסילה כפולה אז אין בעיה של מפגש רכבות).

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

void trainReport(FILE *trainArray[ ], int trainNum, char *outfile)כתוב פונקציה

גודלו של המערך, trainNumמערך של מצביעים לקבצים של נתוני מסלולי הרכבות, trainArrayהמקבלת outfile רשום מידע על "מפגשי רכבות" מבין כל הקבצים. של קובץ חדש שהפונקציה יוצרת. בקובץ החדש שם

כמובן שלא יכולים להגיע לאותה מסילה באותה שעה יותר משתי רכבות.

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

hhmmספרות במבנה 4שעת יציאה •

ספרות 4 קוד מסילה •

ספרות, הקטר עם המספר היותר קטן 3 1מספר קטר •

ספרות, הקטר עם המספר היותר גדול 3 2מספר קטר • מסילה.הקובץ החדש מוין בסדר עולה לפי שעת יציאה מנקודת המוצא ומיון משנה לפי מספר

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

כמובן שלא יכולים להגיע לאותה מסילה באותה שעה יותר משתי רכבות.

:הגבלות


...)קובץ אחר,עץ, רשימה משורשרת, מערך(אין להעתיק קובץ שלם למבנה נתונים אחר •

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=2500, ind1, ind2=-1; if(!(fout=fopen(outfile,"w"))) exit(1); arr = (train*)malloc(sizeof(train)*trainNum); if(!arr)exit(1); for(i=0; i<trainNum; i++){ fscanf(trainArray[i], "%d", &arr[i].loco); // search for the first line with way==1 in the file of trainArray[i] do arr[i].eof = fscanf(trainArray[i],"%4d%*20c%4d%d", &arr[i].time, &arr[i].num, &way); while(way==2 && arr[i].eof==3); } while(1){ for(i=0; i<trainNum; i++){ if(arr[i].eof!=3) continue; if(arr[i].time > minTime) continue; if(arr[i].time < minTime ){ minTime = arr[i].time; ind1 = i; ind2=-1; continue; } /* case of arr[i].time == minTime */ if(arr[i].num > arr[ind1].num) continue; // search for the minimal railway number if(arr[i].num < arr[ind1].num){ ind1 = i; ind2=-1; continue; } /* case of arr[i].time == minTime && arr[i].num == arr[ind1].num */ if(arr[i].loco < arr[ind1].loco){ ind2 = ind1; ind1 = i; } else ind2 = i; } // for if(minTime == 2500) break; // case of eof in all the files if(ind2 >=0){ // 2 locomotives on the same railway found fprintf(fout, "%04d%04d%03d%03d\n", minTime, arr[ind1].num, arr[ind1].loco, arr[ind2].loco);

16

do arr[ind2].eof = fscanf(trainArray[ind2],"%4d%*20c%4d%d", &arr[ind2].time,&arr[ind2].num,&way);

while(way==2 && arr[ind2].eof==3); ind2 = -1; } do arr[ind1].eof = fscanf(trainArray[ind1],"%4d%*20c%4d%d", &arr[ind1].time, &arr[ind1].num, &way); while(way==2 && arr[ind1].eof==3); minTime = 2500; } free(arr); fclose(fout); }

17

Clang091a Clang101b שאלה 19- רקורסיה

int S[M],מערך של מספרים שלמים וחיוביים int F[N][M]נתון מערך דו מימדי של מספרים שלמים וחיוביים

כך שאיחודם מכיל (F שורות של המערך k.אנו נרצה לבדוק האם קיימות לכל היותר k ומספר שלם .Sאת כל המספרים שבמערך

לדוגמה:

F =

1 5 7

3 2 9

1 2 3

S =

7 2 3

) 2 - ו 0(בעלי האינדקסים Fבמערך 3ושורה מספר 1אנו נקבל תשובה חיובית כי: שורה מספר k=2עבור

.Sהמכילות את כל מספרי המערך 1,5,7,2,3מכילות את המספרים:

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

אברי המערך הם אפס Mאם כל 1מחזירה 0אחרת מחזירה

int all_zero(int x[M]) ;

אשר xמאפסת את כל איברי המערך yמופיעים במערך

void x_zero( int x[M],int y[M]) ;

dest copy(int dest[M], int src[M]); voidלמערך srcמעתיקה את תוכן המערך

kע"י לכל היותר Sאם ניתן לכסות את כל המערך 1המחזירה covers הרקורסיביתאת הפונקציה השלם ית.- i-כאשר מתחילים מהשורה ה Fשורות מהמערך

int covers( int F[N][M], int S[M], int i, int k){ int temp[M] = {0};

if (?? 0 ??) ?? 1 ?? ;

if (?? 2 ?? ) ?? 3 ?? ; ?? 4 ?? ?? 5 ?? ;

?? 6 ?? ; ?? 8 ?? ;

?? 8 ?? ; }

פתרון:int covers(int F[N][M],int S[M],int i,int k){ int temp[M]={0}; if( all_zero(S)) return 1;

if( k==0 || i==N ) return 0; if(covers(F,S,i+1,k)) return 1;

copy(temp,S); x_zero(temp,F[i]); return covers(F,temp,i+1,k-1); }

18

prog041aרקורסיה – 22שאלה

- שממלאת את המערך הדו void shablul(int** ar, int row1, int col1, int row2, int col2) רקורסיביתכתוב פונקציה

) ועמודה row1, מס' שורה (arהפונק' מקבלת מצביע למערך .בצורת שבלול 1-במספרים עולים החל מ arמימדי )col1) של התא השמאלי עליון של המערך ומס' שורה (row2) ועמודה (col2 .של התא הימני תחתון של המערך (

. אין להגדיר פונקציה נוספת

shablul(ar, 0, 0, 3, 4) לדוגמא עבור :נקבל

:פתרון#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define ROWS 4

#define COLS 5

void shablul(int** ar, int row1, int col1, int row2, int col2)

{

int i;

static int num = 1;

if (row1<=row2 && col1<=col2)

{

/*Filling top row:*/

for (i=col1; i<=col2; i++)

ar[row1][i] = num++;

/*Filling right column: */

for (i=row1+1; i<=row2; i++)

ar[i][col2] = num++;

/*Filling bottom row: */

if (row2>row1)/*only when the array has more than one row. */

for (i=col2-1; i>=col1; i--)

ar[row2][i] = num++;

/*Filling left column:*/

if (col2>col1)/*only when the array has more than one column. */ for (i=row2-1; i>row1; i--)

ar[i][col1] = num++;

shablul(ar, row1+1, col1+1, row2-1, col2-1);

}

}

5 4 3 2 1 6 17 16 15 14 7 18 19 20 13 8 9 10 11 12

5 4 3 2 1 6 17 16 15 14 7 18 19 20 13 8 9 10 11 12

בעזרת רקורסיה:כורת לגבי פתרון בעיות תז

= +

פתרון הבעיה

המקורית בגודל קטן

. x-מ

מס' פעולות שיהוו חלק מן

הפתרון כך שיתר הבעיה היא בעצם אותה

בעיה בגודל קטן . x-מ

פתרון הבעיה

המקורית .xבגודל

col1 col2

0 1 2 3 4

row1 0

1

2

row2 3

19

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

shablul(1,1,2,3)הקריאה הרקורסיבית הראשונה נשאר אם הבעיה: 17 16 15 18 19 20

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

void main()

{

int i,j;

int **arr;

if(!(arr=(int **)malloc(ROWS*sizeof(int *))))

{

printf("Error allocating memory! Exitting…");

return;

}

for(i=0;i<ROWS;i++)

{

if(!(*(arr+i)=(int *)malloc(COLS*sizeof(int))))

{

printf("Error allocating memory! Exitting…");

return;

}

}

shablul(arr,0,0,ROWS-1,COLS-1);

/*Print the shablul array:*/

for(i=0;i<ROWS;i++)

{

for(j=0;j < COLS;j++)

printf("%d\t",arr[i][j]);

printf("\n");

}

}

20

clang032aרקורסיה – 23שאלה

שורות. lines-בכוכביות ב Vשמדפיסה את האות void V(int lines) רקורסיביתכתוב פונקציה יודפס:V(5) לדוגמא עבור

* * * * * * * * *

הכוכבית הראשונה חייבת להופיע בתחילת השורה הראשונה. אין להגדיר פונקציה נוספת.

:1פתרון

void V( int lines ){ static int firstSpace=0; int i; for (i=0; i < firstSpace; i++) printf(" "); printf ("*"); if (lines == 1){ printf("\n"); firstSpace =0; return ; } for (i=0; i< ((2*lines-3)) ; i++) printf(" "); printf("*\n"); firstSpace ++; V(lines-1); }

מוגבל) lines(עבור 2פתרון void V(int lines){ static int start=0; char str[]=" "; str[start]=str[2*lines-2+start++]='*'; puts(str); if(n==1){ start=0; return; } V(lines-1); }

21

prog032a –רקורסיה 24שאלה

-נתון אי linesשורות ( lines-בכוכביות ב Xשמדפיסה את האות void X(int lines) רקורסיביתכתוב פונקציה זוגי).

יודפס:X(9) לדוגמא עבור

* * * * * * * * * * * * * * * * *

הכוכבית הראשונה חייבת להופיע בתחילת השורה הראשונה. אין להגדיר פונקציה נוספת.

:פתרון

void X(int lines){ int static blank; int i;

if (lines < 1) return; for (i=0; i<blank; i++) putchar(' ');

putchar('*'); if(lines==1){ puts(""); return; } for (i=0; i<lines-2; i++) putchar(' '); puts("*"); blank++; X(lines -2); blank--; for (i=0; i<blank; i++) putchar(' '); putchar('*'); for (i=0; i<lines-2; i++) putchar(' '); puts("*"); }

22

קבצים - 25שאלה

בקובץ מכילה את הפרטים הבאים: נתון קובץ שבו פרטי עובדי החברה. כל שורה

תווים 30 - שם העובד •

ספרות 9 - ת.ז. •

ספרות 2 - מחלקה • הקובץ ממוין לפי ת.ז.

שמקבלת מצביע לקובץ הנ"ל ומצביע לקובץ חדש. doublesortכתוב פונקציה

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

אין להעתיק את הקובץ למבנה נתונים אחר.

תשובה:void doublesort(FILE *old, FILE *new){

int dept, i; char details[40]; for (i = 0; i <100; i++) { rewind(old); while(fscanf(old,”%39[^$]%2d%*c”,details,&dept) ==2) if (dept==i) fprintf(new, “%s%02d\n”, details, dept); } }

23

Clang121aקבצים – 25שאלה

מצלמות מהירות גלויות ונסתרות ם האדומים" כבישילאורך "הלאחרונה התקיןאגף התנועה של משטרת ישראל

ומצלמות רמזור.

numberעד 1-לכל מצלמה קובץ שבו מתועדים נתוני העברות, הקבצים ממוספרים מ

- number 1-ולכל אחד שם מתאים מ -הוא מספר המצלמות שהותקנו.txt עדnumber.txt . כל הקבצים במבנה דומה:

בשורה הראשונה של הקובץ מופיעים:

תווים 20 -מיקום המצלמה •

תווים 10 - סוג מצלמה • הבאים:עברות בהמשך כל שורה בקובץ מכילה את פרטי הו

)120216לדוגמה התאריך של היום מקודד yymmddספרת ( 6 – תאריך •

)0900מקודדת 9:00לדוגמה השעה hhmmות (ספר 4 – שעה •

ספרת 3 – מהירות •

ספרות 7 – מס' הרכב •

תווים 20 –שם קובץ תמונה •

כרונולוגי (מיון ראשי לפי תאריך, ומיון משנה לפי שעה)הקבצים ממוינים בסדר

שימו לב שאותו מספר רכב יכול להופיע מספר פעמים באותו קובץ ואפילו ברצף.

מספר המצלמות numberשמקבלת int radar(int number) ב פונקציהונכתמשטרת ישראל על מנת לעזור ל שהותקנו.

dat.רת קובץ ששמו מספר הרכב עם סיומת יוצהפונקציה עבריין תנועה עבור כל

כל שורה בקובץ מכילה:

)120216לדוגמה התאריך של היום מקודד yymmddספרת ( 6 – תאריך •

)0900מקודדת 9:00לדוגמה השעה hhmmות (ספר 4 – שעה •

ספרות 4 – מס' מצלמה •

תווים 20 –מיקום המצלמה •

ספרת 3 – מהירות •

תווים 20 –שם קובץ תמונה • הקבצים ממוינים בסדר כרונולוגי (מיון ראשי לפי תאריך, ומיון משנה לפי שעה)

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

שימו לב:שימו לב:שימו לב:שימו לב:

בכל הקבצים אין תווי הפרדה בין השדות •


...)קובץ אחר,עץ, רשימה משורשרת, מערך(אין להעתיק קובץ למבנה נתונים אחר •

24

תשובה:

typedef struct camera{

FILE *fp; int eof; char place[21], time[11]; } camera; int radar( int number){ camera *arr; FILE *fp; char filename[12] , *minTime="9913", photo[21]; int i, index=-1, speed, car,; if(!(arr=(camera*)malloc(sizeof(camera)*number)))exit(1); for(i=0; i<number; i++){ sprintf(filename, "%d.txt", i+1); if(!(arr[i].fp=fopen(filename, "r")))return 0; fscanf(arr[i].fp, "%20[^$]%*11c", arr[i].place);

arr[i].eof=fscanf(arr[i].fp, "%10s", arr[i].time); } while(1){ for(i=0; i<number; i++) if(arr[i].eof==1&& strcmp(arr[i].time, minTime)<0){ minTime = arr[i].time; index = i; } if(index==-1) break;

arr[index].eof = fscanf(arr[index].fp, "%3d%7d%20[^$]%*c", &speed, &car, photo);

sprintf(filename, "%d.dat", car); if(!(fp=fopen(filename, "a")))return 0;

fprintf(fp, "%s%04d%s%03d%s\n", minTime, index, arr[index].place, speed, photo);

if(fclose(fp)==EOF) return 0;

arr[index].eof=fscanf(arr[index].fp,"%10s", arr[index].time);

index=-1; minTime="9913"; } for(i=0; i<number; i++) if(fclose(arr[i].fp)==EOF) return 0; free(arr); return 1; }

25

נקודות) 20( 27שאלה

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

)נקודות 14( '.א סעיף

מספר את ומחזירה בסולם הכולל השלבים מספר את שמקבלת int ladderRec(int n) רקורסיבית פונקציה כתובו .בסולם לעלות יכול הפועל בהם האפשריים המסלולים

)נקודות 6( '.ב סעיף

מספר את ומחזירה בסולם הכולל השלבים מספר את שמקבלת int ladder(int n) איטרטיבית פונקציה כתובו .בסולם לעלות יכול הפועל בהם האפשריים המסלולים

)למגבלות לב שימו – איטרטיבי רק' א כמו(

:הגבלות

.כלל בלולאות להשתמש אין –' א בסעיף .ברקורסיה לא וכמובן אחת מלולאה ביותר להשתמש אין -' ב בסעיף

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

:)הסעיפים לשני רלוונטית( דוגמא מסלולים עוד שיש וכמובן 2 2 3 הוא אפשרי מסלול עוד. 3 1 3 האפשריים המסלולים אחד, שלבים 7 עם בסולם

).עצמם המסלולים את ולא האפשריים המסלולים מספר את להחזיר עליכם, לב שימו( אפשריים

:פתרון )נקודות 14( '.א סעיף

int ladderRec(int n){ if(n < 2) return 1; if(n == 2) return 2; return ladderRec(n-3) + ladderRec(n-2) + ladderRec(n-1); }

)נקודות 6( '.ב סעיףint ladder(int n){ int lad0=1, lad1=1, lad2=2, ladN, i; if(n < 2 ) return 1; if(n == 2) return 2; for(i= 3; i<=n; i++){ ladN = lad0 + lad1 + lad2; lad0 = lad1; lad1 = lad2; lad2 = ladN; } return ladN; }

26

:14/2/13מועד א'


:נתונה התכנית הבאה #include <stdio.h> int what(char* str1, char* str2){ int x, y; if (!*str1 || !*str2) return 0; if (*str1 == *str2) return 1 + what(str1+1, str2+1); x = what(str1, str2+1); y = what(str1+1, str2); return x > y ? x : y; } void main(){ char str1[ ] = "abacdecee"; char str2[ ] = "acdce"; char str3[ ] = "fchdeeaa"; char str4[ ] = "aabcedacdeecsb"; printf("%d, %d, %d\n",what(str1,str2),what(str1,str3),what(str1,str4)); }


מה הפלט של התכנית הנ"ל?


. whatהסבר במשפט אחד מה יעודה של הפונקציה על פי הנתונים של התכנית הנתונה הסבר כל פלט של הסעיף הקודם.

:פתרון


5, 4, 7


הפונקציה מחשבת את מספר האותיות הזהות (בסדרן המקורי) המקסימאלי המופיע בשתי המחרוזות.

str1[ ]= "abacdecee" str2[ ]= "acdce" � 5 str1[ ]= "abacdecee" str3[ ]= "fchdeeaa" � 4 str1[ ]= "abacdecee" str4[ ]= "aabcedacdeecsb" � 7

27


:נתונה התכנית הבאה#include<stdio.h> int what(int *arr, int n1, int val, int k, int flag, int *res, int n2){ int i, x, y=0, z=0; if (k==0) if (val==0){ for (i=0; i<n2; i++) printf("%d ",res[i]); printf("\n"); return 1; } else return 0; if (n1==0) return 0; x = what(arr+1, n1-1, val, k, 1, res, n2); if (flag){ res[n2] = *arr; y = what(arr+1, n1-1, val-*arr, k-1, 0, res, n2+1); res[n2] = -*arr; z = what(arr+1, n1-1, val+*arr, k-1, 0, res, n2+1); } return x+y+z; } void main(){ int arr[ ] = {5, -9, 3, 1, 7, 8, 4, 2, 5}; int res[5]; printf("%d\n",what(arr, 9, 10, 3, 1, res, 0) ); }

)נקודות 9( '.א סעיף ? ל"הנ התכנית של הפלט מה


what הפונקציה שליעודה מה בקצרה הסבר

:פתרון )נקודות 9( '.א סעיף

1 4 5 -3 8 5 9 -4 5 9 -1 2 5 7 -2 5 1 4 5 3 2 5 -3 8 8


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

28


ההגדרה הבאה: נתונהtypedef struct Node { int numOfNbrs; struct Node* neighbors[1000]; int color;

int tmp; // שדה עזר } Node;

לשכנים מצביעים של מערך מכיל צומת שכל כך, Node מטיפוס צמתים של מאוסף הבנוי נתונים מבנה נתון .שלו

. כן גם X של שכן Y אזי, Y של שכן הוא X אם: כלומר. כיוונית-כדו מוגדרת זה נתונים במבנה שכנות

של בתחילתו נמצאים השכנים שכל להניח ניתן. לצומת שיש השכנים מספר את מייצג numOfNbrs השדה .לצומת שכנים 1000מ יותר יהיו שלא וכן neighbors המערך

. הצומת של הצבע את המייצג color שדה גם מכיל צומת כל .כרצונכם שימוש בו לעשות ניתן 0-ל שמאותחל tmp עזר שדה קיים צומת בכל' לעיל לשדות בנוסף .משכניו שונה בצבע צבוע צומת שכל כך הצבעים ערכי כל קביעת היא ל"הנ הנתונים מבנה של חוקית צביעה

מבנה אם 1 ומחזירה n מסוים צומת מקבלת אשר int legalColoring(Node* n) הפונקציה את השלימו . אחרת 0-ו חוקי באופן צבוע הנתונים

.כרצונכם tempבשדה להשתמש מותר בקוד הבא. ) ?? N?? - את הקטעים החסרים (המסומנים ב השלימו

int legalColoring(Node* n){ int i;

if ( ?? 1 ?? ) ?? 2 ?? ; ?? 3 ?? ; for (i=0; ?? 4 ?? ; i++) if (?? 5 ?? || ?? 6 ??) ?? 7 ?? ; return ?? 8 ?? ; }

:פתרוןint legalColoring(Node* n){ int i;

if ( n->tmp )

return 1 ;

n->tmp = 1 ;

for (i=0; i<n->numOfNbrs ; i++)

if (n->color == n->neighbors[i]->color ||

!legalColoring(n-> neighbors[i]))

return 0 ;

return 1;

}

29

)נקודות 20( 4 שאלה :משורשרת ברשימה חוליה להגדיר שמאפשרת הבאה הגדרה נתונה

typedef struct node { int value; struct node* next; } Node;

:הגדרות

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

.הרשימות בשתי מופיעים

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

מופיע הוא אם גם בלבד אחת פעם יבחר איבר כל. השנייה בקבוצה וגם הראשונה בקבוצה גם מופיעים

.מהקבוצות אחת בכל

:דוגמא

הקבוצות הבאות: 2בהינתן

A = {1, 2, 6, 4, 5, 3} B = {1, 6, 7, 2}

C={1, 2, 6}אזי נקבל: B -ו Aהיא קבוצת החיתוך בין Cאם

D={1, 2, 6, 4, 5, 3, 7}אזי נקבל: B -ו Aהיא קבוצת האיחוד בין Dאם


אשר מקבלת מצביעים לשתי רשימות Node* intersection(Node* list1, Node* list2) כתבו פונקציה המהווה את רשימת החיתוך בין שתי הרשימות. רשימה חדשהומחזירה


אשר מקבלת מצביעים לשתי רשימות ומחזירה Node* union(Node* list1, Node* list2)כתבו פונקציה המהווה את רשימת האיחוד בין שתי הרשימות. רשימה חדשה

אין לשנות את הרשימות הנתונות דרך הארגומנטים. •

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

חיתוך.\אין חשיבות לסדר בו יופיעו האיברים ברשימות האיחוד •

30

:פתרון


Node* intersection(Node* list1, Node* list2){ Node* aux1, *aux2, *newNode, *newList=NULL; if (!list1 || !list2) return NULL; //copy list1 for (aux1=list1; aux1; aux1=aux1->next){ for (aux2=list2; aux2 && aux1->value!=aux2->value; aux2=aux2->next); if (aux2){ //found a common value for both lists newNode = (Node*)malloc(sizeof(Node)); newNode->value = aux1->value; newNode->next = newList; newList = newNode; } } return newList; }


Node* union(Node* list1, Node* list2){ Node* aux1, *aux2, *newNode, *newList=NULL; int tvalue = -1; if (!list1 && !list2)return NULL; if (!list1) return list2; if (!list2) return list1; //copy list1 aux1=list1; while (aux1){ newNode = (Node*)malloc(sizeof(Node)); newNode->value = aux1->value; newNode->next = newList; newList = newNode; aux1 = aux1->next; } aux2 = list2; while (aux2){ tvalue = aux2->value; for (aux1=list1; aux1 && aux1->value!=tvalue; aux1=aux1->next); if (!aux1){ //tvalue doesn't exists in list1 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 list1! aux2 = aux2->next; } return newList; }

31


:כלשהו בינארי עץ לייצג מאפשרת הבאה ההגדרהtypedef struct Node { …. struct Node *left, *right ; struct Node *parent, *next; } Node;

.right -ו leftנתון עץ בינארי בו עבור כל קודקוד מעודכנים שני בניו:

אשר מקבלת מצביע לעץ. Node* update(Node* tree)כתבו פונקציה רקורסיבית

יהיה מצביע לאב 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; }

32


.32-ל 1מפלגות לכל מפלגה קוד בין 32לכנסת התמודדו בבחירות תוצאות של קובץ יוצרת הקולות ספירת ולאחר קלפיות הישובים מכל מקבלת לכנסת הבחירות ועדת

. הקלפיות

:מכילה בקובץ שורה כל

תווים 20 הישוב שם �

ספרות 4 הישוב סמל �

ספרות 3 קלפי מספר �

תווי הפרדה בין השדות הנ"ל, אין

המספר. (מפלגה קוד לפי מסודרים הבחירות תוצאות שהם מספרים 32 ברצף מופיעים בשורה מכן לאחר רוח אין, רוח למספר מספר בן....) 2' מס מפלגה עבור השני, 1' מס מפלגה של קולות מספר הראשון

.השורה בסוף

ויוצרת) ועוד ימאים, החיילים של" (הכפולות המעטפות" של קולות סופרת הועדה הקלפיות לקולות בנוסף ".הכפולות המעטפות" של התוצאות קובץ

היו שעבורם הקלפיות של שורות ורק אך מופיעות אבל הקודם הקובץ למבנה זהה הקובץ מבנה ".כפולות מעטפות"

.עולה בסדר גם קלפי מספר לפי משנה ומיון עולה בסדר ישוב סמל לפי ממוינים הקבצים שני

של מצביע ballot שמקבלת int vote(FILE *ballot, FILE* doubled, char *updated) פונקציה כתובו .updated מחרוזת ו" הכפלות המעטפות" קובץ של מצביע doubled, הקלפיות קובץ

לפי המבנה שתואר לעיל, שמכיל את הפרטים של updatedהפונקציה יוצרת קובץ חדש ששמו במחרוזת

(של הקלפיות ושל המעטפות הכפולות). כל הקולות בכלל .עולה בסדר גם קלפי מספר לפי משנה ומיון עולה בסדר ישוב סמל לפי ממוין הקובץ

מספר בןמספרים שהם סיכום הקולות של כל מפלגה. 32בשורה האחרונה של הקובץ מופיע רצף של .השורה בסוף רוח אין, רוח למספר

.1, אחרת 0סגירה של קובץ הפונקציה תחזיר במקרה וארעה שגיאה בפתיחה או

!לב שימו


...)קובץ אחר,עץ, רשימה משורשרת, מערך(אין להעתיק קובץ למבנה נתונים אחר •

33

:פתרון

int vote(FILE *ballot, FILE* doubled, char *updated) {

char name[21]; int kalpiB, kalpiD, party[32], partyD, flag, i, total[32]={0}; FILE *fp;

if(!(fp=fopen(updated,"w"))) return 0; flag=fscanf(doubled, "%*20c%7d", &kalpiD);

while(fscanf(ballot, "%20[^\n]%7d", name, &kalpiB)!=EOF){ fprintf(fp, "%s%07d", name, kalpiB); for(i=0; i<32; i++) fscanf(ballot, "%d", party+i); fgetc(ballot); if(flag==1 && kalpiB==kalpiD){ for(i=0; i<32; i++){ fscanf(doubled, "%d", &partyD); party[i] += partyD; } flag=fscanf(doubled, "%*21c%7d", &kalpiD); } for(i=0; i<31; i++){ fprintf(fp, "%d ", party[i]); total[i] += party[i]; } fprintf(fp, "%d\n", party[31]); total[31] += party[31]; } for(i=0; i<31; i++) fprintf(fp, "%d ", total[i]); fprintf(fp, "%d\n", total[31]); if(fclose(fp)==EOF) return 0; return 1; }

34

רקורסיה - 11ה שאל

, אשר מקבלת מחרוזת ותו void startbychar(char *string, char letter)כתוב פונקציה רקורסיבית .ומדפיסה את כל הסיומות של המחרוזת המתחילות בתו הזה

ידפסו השורות הבאות:’ a‘והתו ” babcbabcbdbabcaלדוגמה עבור המחרוזת "

abcbabcbdbabca abcbdbabca abca a

:פתרון void startbychar(char string[ ], char letter){ if (!*string) return; if (*string==letter) puts(string); startbychar(string+1); }

35

עצים ורקורסיה – 13שאלה : הוגדר המבנה הבא, כדי לממש עץ חיפוש בינארי

typedef struct node {

struct {

int key;

char value[32];

} 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);

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;

}

סעיף א (10 נקודות)

root -בהינתן העץ הבינארי הבא ש :מצביע על השורש שלו

:צייר את העץ שהפונקציה תחזיר לאחר הקריאה What( root, 10, 20)

.Whatהסבר בקצרה מה יעודה של הפונקציה )נקודות 5(סעיף ב 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.

18

10 30

8 12

20 40

11

36

רקורסיה – 20שאלה נתון מערך של אורכי לבנים.

. int bricks[3]={1,2,3} מוגדר מערך 3 -ו 2, 1למשל עבור לבנים באורך של

.bricks ברצוננו לבנות פס באורך נתון מהלבנים של המערך

מקבלת כארגומנטים : )int *bricks, int size, int width) int HowManySets הפונקציה

• bricks - בסדר עולה, הלבנים, המערך ממוין מערך של אורכי

• size - ,גודל המערך

• width - .אורך הפס הנדרש . מספר הלבנים bricksמהלבנים של המערך width הפונקציה מחזירה את מספר האפשרויות לבנות פס באורך

אינו מוגבל. bricksשרשום במערך אורךמכל 7הפונקציה מחזירה 4 שווה width -למשל עבור מערך הדוגמה ו

הסידורים האפשריים הם:כי 1 1 1 1 2 1 1 1 2 1 3 1 1 1 2 2 2 1 3

. ?? N ?? -נים ב השלימו בדף התשובות הקטעים החסרים המסומint HowManySets (int *bricks, int size, int width){ int res=0,i;

if( ?? 1 ?? ) return 1;

for( ?? 2 ?? )

if( ?? 3 ?? >=bricks[i])

?? 4 ?? += HowManySets (?? 5 ?? , ?? 6 ?? , ?? 7 ??);

return ?? 8 ??; }

פתרון:

int HowManySets (int *bricks, int size, int width){ int res=0,i; if( ! width ) return 1; for( i=0; i<size; i++ ) if( width >=bricks[i]) res += HowManySets (bricks, size, width-bricks[i]); return res ; }

37

clang101a שאלה 21 – רקורסיה נתונה התכנית הבאה:

void what(char *s1, char *s2, char *temp, int index){ if (*s1 == '\0'){

strcpy(temp+index, s2); printf("%s\n", temp); return;

} if (*s2 == '\0'){

strcpy(temp+index, s1); printf("%s\n", temp); return;

} temp[index] = *s1; what(s1+1, s2, temp, index+1); temp[index] = *s2; what(s1, s2+1, temp, index+1);

}

int main(){ char *str1 = "AB"; char *str2 = "xyz"; char *temp= (char *)malloc(strlen(str1)+strlen(str2)+1); what(str1, str2, temp, 0); }

מה הפלט של התכנית? סעיף א'.

?whatהסבר בקצרה מה מטרתה של הפונקציה סעיף ב'. פתרון:

נקודות ) 10סעיף א (

ABxyz

AxByz

AxyBz

AxyzB

xAByz

xAyBz

xAyzB

xyABz

ayAzB

xyzAB

נקודות ) 5סעיף ב (

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

38


הבאות: הפונקציותשתי נתונות #define M 8

#define N 8

void What1( int mat[][M], int i, int j, int c){

int di, dj;

if (i < 0 || i > N – 1 || j < 0 || j > M-1 || mat[i][j])

return;

mat[i][j] = c;

for (di = -1; di<=1 ; di++)

for (dj = -1 ; dj<=1 ; dj++)

What1(mat, i+di, j+dj, c);

}

int What2(int mat[][M]) {

int count=1, i, j;

for (i=0; i < N; i++)

for (j=0; j < M; j++)

if (mat[i][j] == 0) {

count++;

What1(mat, i, j, count);

}

return count – 1;

}

נקודות) 6סעיף א (

המערך הבא :mat1 יהי

What1(mat1, 3, 2, 2) - יאה לרהקלאחר mat1 צייר את המערך

נקודות) 6( בסעיף

0 0 0 0 0 0 0 0

1 1 1 1 1 0 0 0

1 0 1 0 1 1 1 0

1 1 1 0 1 0 1 0

1 0 0 1 0 0 1 0

1 1 1 1 1 1 1 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

39

המערך הבא: mat2יהי

הערך שהפונקציה מחזירה. ואת What2(mat2) - יאה לרלאחר הק mat2צייר את המערך

נקודות) 4( גסעיף

.2What -ו 1Whatמה עושות הפונקציות בקצרה הסבר

:פתרון

אסעיף

What1(mat1, 3, 2, 2)

בסעיף

גסעיף

שמכילים אפסים map[i][j]את כל התאים השכנים שבגוש של map[i][j]"צובעת" מהנקודה what1הפונקציה ).paintbrush-ב fill-. (בדומה לcלצבע

).ומחזיר מספר הגושים paintbrush-ב fill-(בדומה ל 2"צובעת" כל גוש בצבע אחר מהצבע what2הפונקציה שצבעו.

0 0 0 0 0 0 0 0

1 1 1 0 0 0 0 0

1 0 1 0 1 1 1 0

1 0 1 1 1 0 1 0

1 0 0 1 1 0 1 0

1 1 1 1 1 1 1 0

0 0 0 0 0 1 0 0

0 0 0 0 0 1 0 0

0 0 0 0 0 0 0 0

1 1 1 1 1 0 0 0

1 0 1 2 1 1 1 0

1 1 1 2 1 2 1 0

1 2 2 1 2 2 1 0

1 1 1 1 1 1 1 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

2 2 2 2 2 2 2 2

1 1 1 2 2 2 2 2

1 3 1 2 1 1 1 2

1 3 1 1 1 4 1 2

1 3 3 1 1 4 1 2

1 1 1 1 1 1 1 2

5 5 5 5 5 1 2 2

5 5 5 5 5 1 2 2

2 – הרזח תולאשprog172/wiki.files/review-sol-Prog171-2.pdf · 1 2 – הרזח תולאש...

Documents

Transcript of 2 – הרזח תולאשprog172/wiki.files/review-sol-Prog171-2.pdf · 1 2 – הרזח תולאש...