C Programming Answers for chapter 12

21תרגול פרק

רקורסיה – Cבשפת תכנות שייקה בילוד"ר כתב וערך:

14 מתוך 1 עמוד

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

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

להקטין את מימד הבעיה, לפתור את הבעיה על המימד היותר קטן ולהשתמש בפיתרון שמתקבל ע"מ לפתור תהיה

את הבעיה במימד אחד יותר גבוהה.

:חישוב עצרת -1דוגמה מס'

:יטרטיביבאופן א( )עצרת !nא( חישוב

int iterFactorial(int n)

{

int res=1;

while(n>0)

{

res*=n;

n--;

}

return res;

}

באופן רקורסיבי: !nב( חישוב

int recFactorial(int n)

{

if(n<=1)

return 1;

return n*recFactorial(n-1);

}

תרשים הסביבות יראה כך:, !3בעת שימוש בפונקציה זו לחישוב

void main()

{

recFactorial(3)

n=3

if(n<=1)

return 1;

return 3* recFactorial(2)

n=2

if(n<=1)

return 1;

return 2* recFactorial(1)

n=1

if(n<=1)

return 1;

1

6

2

21תרגול פרק



:משתנים סטאטיים –תזכורת

באופן הבאמגדירים : static int var;

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

המערכת תאתחל אותם אוטומטית לאפס.

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

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

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

:harmonic number – 2דוגמה מס'

1)(מוגדר באופן הבא: nמס' הרמוני של המס' השלם 2

1...

1

11nh

nn

למשל, . h(n)אשר תדפיס למסך את הפיתוח של rec_harmonic_num(n)לכתוב פונקציה רקורסיבית ברצוננו

, נקבל על המסך:rec_harmonic_num(5)עבור הקריאה

1/5+1/4+1/3+1/2+1=2.28

:פתרון

void rec_harmonic_sum(int n)

{

static double sum=1;

if(n==1)/*Stop condition*/

{

printf("1=%.2f\n",sum);

sum=1; /*Must initialize the static variable "sum" so

that we can call this function repeatedly in the same

program run. Make sure you understand why!!! */

return;

}

printf("1/%d+",n);

sum+=1./n; /*The "1." syntax is used in order to prevent

automatic casting to integer type (so that the expression "1/n"

will be evaluated as type double). */

rec_harmonic_sum(n-1); /*The recursive call. */

}

:abc - 3דוגמה מס'

, המקבלת מערך של void abc(char arr[],int lastPlace, int curPlace)כתוב פונקציה רקורסיבית בשם

char- ים, את אינדקס סוף המערך ומספר שלם שהוא המקום במערך ממנו אנו מעונינים להתחיל במילוי המערך

(.0 -בתווים )בקריאה ראשונה יהיה מס' זה שווה ל

21תרגול פרק



lastPlace, עד המקום curPlaceהפונקציה מדפיסה את כל האפשרויות למלא את המערך מהמקום שקיבלה,

. a,b,cבאותיות

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

a,b,c .

עבור התוכנית הבאה: ,למשל

void abcInvokingFun(char word[],int lengthOfWord)

{

abc(word, lengthOfWord,0);

}

void main()

{

char word[5];

abcInvokingFun(word,3);

}

נקבל את הפלט:

aaa aab aac aba abb abc aca acb acc baa bab

bac bba bbb bbc bca bcb bcc caa cab cac cba

cbb cbc cca ccb ccc

:פתרון

void abc(char arr[],int lastPlace, int curPlace)

{

if (curPlace == lastPlace)

{

arr[curPlace]='\0';

printf("%s\t",arr);

return;

}

arr[curPlace] = 'a';

abc (arr,lastPlace,curPlace+1);

arr[curPlace] = 'b';


arr[curPlace] = 'c';


}

כתובתו של

המקום הנוכחי תחילת המערך

שאנחנו משנים

תנאי העצירה:

אז שים במקום הנוכחי יש lastPlace -אם הגענו ל

' )הגענו לסוף(, הדפס את המחרוזת )מהתחלתה( \0'

וחזור.

במערך: curPlaceכעת אנחנו עובדים על המקום

הצב בוa 'וקרא לפונק ,abc עם כתובת(

המערך, ואינדקס המקום הבא( אשר תדאג

למילוי כל האפשרויות הקימות בשאר המערך.

לאחר שחזרת, הצב אתb במקוםa ושוב קרא ,

לפונק' עם המקום הבא במערך כפרמטר.

כנ"ל לגביc.

אינדקס סוף

המערך

21תרגול פרק



aab aac aba abb abc aca acb acc baa bab bac bba bbb bbc bca bcb bcc caa cab cac cba cbb cbc cca ccb ccc

aaa aab aac aba abb abc aca acb acc baa bab bac bba bbb bbc bca bcb bcc caa cab cac cba cbb cbc cca ccb ccc

aa? ab? ac? ba? bb? bc? ca? cb? cc?

a?? b?? c??

???

aaa

:הדפסה

נראה את תרשים הקריאות המתקבל מהרצת הדוגמא שלמעלה )בדומה לתרשים הקריאות שראינו בכתה(:

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

בצד ימין. ומצויןהוא משותף לכל רמה בתרשים curPlaceהפרמטר

שימו לב

-( אינה משתנה לאורך שרשרת הקריאות הרקורסיביות. מה שכן משתנהarrשהכתובת של המערך הנשלחת )

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

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

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

משולש. מתוך שורה תשרטט קריאה ובכל

.שלו העצרת את ומחשבת מספר המקבלת רקורסיבית פונקציה כתוב (2

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

י.n -כתוב פונקציה רקורסיבית במקבלת מספר בסדרת פיבונצ'י ומחזירה את המספר ה (4

.אחרת 0 או חיוביים המערך איברי כל אם 1 ומחזירה מערך המקבלת רקורסיבית פונקציה כתוב (5

.להתחלה מהסוף איבריו כל את ומדפיסה מערך המקבלת רקורסיבית פונקציה כתוב (6

.bפעמים את האות nולאחריה aפעמים את האות nומדפיסה nכתוב פונקציה רקורסיבית המקבלת מספר (7

אחרת 1הפונקציה תחזיר תו ובודקת האם הוא נמצא במחרוזת, אם כן המקבלת רקורסיבית פונקציה כתוב (8

.0תחזיר

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

:לה הקריאה בתום מחזירה שהפונקציה הערך משמעות מה והסבר ,הבא בקוד הבט (10

הבאה: תהרקורסיבינתונה הפונקציה (11

#include <stdio.h>

int secret( int n)

{

if( n<0 )

return 1 + secret ( -1 * n);

if ( n<10 )

curPlace=2

curPlace=0

curPlace=3

curPlace=1

21תרגול פרק



return 1;

return 1 + secret( n/10 );

}

? secret(123) -ו secret(-21)מה הערך של (א

עבור פרמטר חיובי ועבור פרמטר שלילי. secretהסבר בקצרה מה מבצעת הפונקציה (ב

כתוב אותה פונקציה בצורה לא רקורסיבית. (ג

בפונקציה הבאה:עיין (12

int sum_array(int array[], int size)

{

if (size==1)

return array[0];

return array[size-1] + sum_array(array,size-1);

}

בהנחה שהגדרת הפונקציה נכונה מצא מה היא מחשבת? הסבר כיצד היא מבצעת את החישוב?

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

)עוצרים כשנשאר איבר אחד(

:בתוכנית הכוללת פונקציה רקורסיביתעיין (13

#include <stdio.h>

int what(int a, int b)

{

if(!a && !b)

return 1;

if(a > b)

return a * what(a-1, b);

return b * what(a, b-1);

}

int main()

{

int num1=2,num2=1;

printf("%d\n",what(num1,num2));

}

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

התשובות(:

הפונקציה נכנסת לרקורסיה אינסופית. .א

.0תמיד הערך המוחזר של הפונקציה .ב

.1הערך המוחזר של הפונקציה תמיד .ג

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

אף לא אחת מהתשובות לעיל. .ה

21תרגול פרק



. Sומספר שלם arrנתונה סדרת ערכים שלמים )כמערך( כתוב תוכנית כאשר ידוע כי (14

. Sסדרה במערך כך שסכומה -צ"ל: האם קיימת תת

למשל:

.S=14 -ו

:האלגוריתם

במערך: iאפשרויות עבור כל איבר 2יש לנו כאן

'לוקחים את האיבר האפשרות א :- i ומנסים למצואSubsetSum בגודלS-arr[i] 1-במערך קטן יותר ב.

'לא לוקחים את האיבר האפשרות ב :- i ומנסים למצואSubsetSum בגודלS 1-במערך קטן יותר ב.

תנאי העצירה שלנו יהיו:

.1במערך ונחזיר SubsetSumאזי יש לנו S==0אם קיבלנו באיזשהו שלב (1

אזי S<0אזי הבחירות שלקחנו עד עכשיו אינן מובילות לפתרון )אם n==0או S<0אחרת אם קיבלנו (2

אזי עדיין לא הגענו לסכום ואין לרשותנו אברים מתוכם נוכל n==0עברנו את הסכום המבוקש ואם

.0לבחור( ונחזיר

, בהנחה שזו אכן קיימת?Sהסדרה שסכום איבריה הינו -יך ניתן למצוא את תתא (15

. i+1,...,n]במערך ] Sבגודל SubsetSumבמערך האם יש iנעבור פעם אחת על המערך ונשאל עבור כל איבר

. Sונמשיך לאיבר הבא עם i-אם יש אזי לא ניקח את האיבר ה

.S=S-arr[i],לכן ניקח אותו ונמשיך לאיבר הבא עם SubsetSum-בטוח ב i-אם אין אזי האבר ה

כתוב תוכנית הקולטת מספר, מחשבת את סכום ספרותיו באופן רקורסיבי. (16

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

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

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

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

בסיומה.

#include<stdio.h>

#include<string.h>

#include<conio.h>

int sumdgtrec(int n)

{

if (n>0)

return (n%10+sumdgtrec(n/10));

}

17 1 5 6 7

arr

21תרגול פרק



void main()

{

printf("%d",sumdgtrec(12345));

getch();

}

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

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

מה נכתבה התכנית, מה היא עושה בפועל ומה יודפס בסופה.

#include <stdio.h>

#include <conio.h>

#define TRUE 1

#define FALSE 0

#define SIZE 10

void mergsort(int vec[SIZE],int num1,int num2);

void merge(int vec[SIZE],int num1,int end,int num2);

void print(int vec [SIZE]);

void main()

{

int l1=0,r1=SIZE-1,vec[SIZE],mone;

printf("\nenter 10 values into the array\n");

for(mone=0;mone<=SIZE-1;mone++)

scanf("%d",&vec[mone]);

print(vec);

mergsort(vec,l1,r1);

printf("\n\n arranged vector by recursive

selection:");

printf("\n =====================================");

print(vec);

}

void print(int vec[SIZE])

{

int mone;

printf("\nThe 10 values in the vector are: ");

for(mone=0;mone<=SIZE-1;mone++)

printf("%3d",vec[mone]);

}

void mergsort(int vec[SIZE],int num1,int num2)

21תרגול פרק



{

int end;

end=(num1+num2)/2;

if(num1!=num2)

{

mergsort(vec,num1,end);

mergsort(vec,end+1,num2);

merge(vec,num1,end,num2);

}

}

void merge(int vec[SIZE],int num1,int end,int num2)

{

int vec2[SIZE];

int flag2=1,middle,mone,i,flag1=1,ind1;

middle=end+1;

i=num1;

ind1=num1;

for(ind1;ind1<=end&&(flag1==1);i++)

{

flag2=1;

for (middle;middle<=num2&&(flag2==1);i++)

{

if(vec[ind1]<=vec[middle])

{

vec2[i]=vec[ind1];

flag2=0;

ind1++;

}

else

if(vec[ind1]>vec[middle])

{

vec2[i]=vec[middle];

middle++;

}

if((middle>num2)||(ind1>end))

flag1=0;

}

i--;

}

if(middle>num2)

for(ind1;ind1<=end;ind1++)

{

21תרגול פרק



vec2[i]=vec[ind1];

i++;

}

else

if(ind1>end)

for(middle;middle<=num2;middle++)

{

vec2[i]=vec[middle];

i++;

}

for(mone=num1;mone<=num2;mone++)

vec[mone]=vec2[mone];

}

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

יודפס בסיום ריצתה.

#include<stdio.h>

#include<conio.h>

void astrx(int mis)

{

if (mis>1)

astrx(mis-1);

printf("*");

}

void main() /** MAIN PROGRAM **/

{

int num;

printf("enter a positive integer number:\n");

scanf("%d",&num);

printf("Here is printing of %d asterisks:",num);

astrx(num);

putchar('\n');

}

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

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

חלוקה, תוך שימוש בפונקציה רקורסיבית, של האחד בשני כתוב תכנית הקלטת שני מספרים חיוביים מבצעת (25

ומציגה את השארית של אותה חלוקה.

21תרגול פרק



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

בסיום ריצתה.

#include <stdio.h>

void count(int i)

{

if (i < 0)

return;

printf("%d\n", i);

count(i - 1);

}

void main()

{

count(10);

}

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

, -1תחזיר אם המספר לא נמצא במערך, הפונקציה )לא ממוין(.כתוב תכנית המאתרת מספר בתוך מערך נתון, (28

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

:פונקציה רקורסיביתכתוב זוגי.-אי n -ידוע ש .nהוא מערך שלמים באורך aידוע כי (29

void extreme_to_middle(int a[ ], int n)

בסדר הבא משמאל לימין: aברי יתדפיס את אהפונקציה

a[0] a[n-1] a[1] a[n-2] … a[(n-1)/2[

: עליכם לכתוב פונקציה רקורסיבית (30

void PrintReverseWordsOrder(char s[ ], int i ;(

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

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

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

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

0ערך משתנה העזר בקריאה הראשונה הינו תמיד . מחרוזת.מותר לשנות את ה

לדוגמה, עבור התכנית הבאה :

int main(void)

{

char str[] = "The book is on the table";

PrintReverseWordsOrder(str, 0);

return 0;

}

הפונקציה תדפיס:

table the on is book The

21תרגול פרק



רמזים:

' במהלך הרקורסיה.\0המחרוזת בתו ' החליפו את כל הרווחים של –

.printfבתוך %s -ניתן להדפיס מחרוזת ע"י שימוש ב –

(i=0אחרת )מתחילים מ str+iנסתכל כל פעם על תת מחרוזת iבאמצעות פרמטר

:str+i. אם עכשיו מסתכלים על תת המחרוזת 1

והדפסנו את כל ’ \0‘כבר החלפנו את כל הרווחים ב str+i+1. נניח שבמחרוזת 2

.הפוך המילים בסדר

(str[i] ) str+i. נותר רק לבדוק את התו הראשון בתת המחרוזת 3

’\0‘-נחליף אותו ב –אם זה רווח –

או האם התו i==0נבדוק האם זה התחלה של מילה, כלומר האם –אם לא –

( הוא רווח.s[i-1הקודם )]

תחלה של מילה נדפיס אותה אם זה ה –

נדפיס רווח כדי להפרידה מהמילה שתודפס אחריה –

כלומר זו המילה הראשונה במחרוזת המקורית ולכן האחרונה i==0, אבל אם –

בהדפסה לא צריך להדפיס רווח אחריה

המשפט הסתיים, חוזרים מהרקורסיה – s[i] == ‘\0‘. תנאי עצירה: אם 4

המקבלת כארגומנטים שני int recScalarProd(int *a, int *b, int len) הרקורסיביתכתבו את הפונקציה (31

ים המכיל את הרכיבים של וקטור כלשהו( ואת אורך שני -int)כל אחד מצביע למערך של int-מצביעים ל

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

ביניהם.

כפלה סקלרית בין שני וקטורים:מ

מסומנת ע"י: -ו

ומוגדרת באופן הבא:

int recScalarProd(int *a, int *b, int len)

{

if(len==1)

return (*a)*(*b);

return (*a)*(*b)+ recScalarProd(a+1,b+1, len-1);

}

היינו יכולים גם להגדיר את הפונק' כך:

int recScalarProd(int a[], int b[], int len)

!!!! a = a+1 או ++bרק אז לא היינו יכולים לעשות פעולות מהסוג של

),...,,( 21 nbbbb

),...,,( 21 naaaa

n

i

iibaba1

21תרגול פרק



מכפלה בין שתי מטריצות מוגדרת באופן הבא: .א

)(תהא , jiaA מטריצה מסדרmn ותהא ,)( , jibB מטריצה מסדרpm אז מכפלתן היא ,

המקיימת: pnמטריצה מסדר

הוא למעשה ערך וקטור השורה מספר ובעמודה נסביר זאת: כל איבר במטריצה, שנמצא בשורה

של המטריצה השנייה. נשים לב שמספר האיברים, הן -במטריצה הראשונה כפול וקטור העמודה ה

. -בשורה והן בעמודה, זהה ושווה ל

-במטריצה השנייה שורותלמספר הבמטריצה הראשונה יהיה זהה עמודותעל כן הדרישה שמספר ה

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

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

: 34במטריצה מסדר 42לדוגמה, התמונה שלמטה מראה כפל של מטריצה מסדר

במטריצה: 2,1AB. בתמונה מודגש כיצד מחושב האיבר 32המטריצה המתקבלת היא מסדר

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

אשר מקבלת int ** multMat(int **A, int **B, int n, int m, int p) עליכם לכתוב את הפונקציה

n, mואת ערכיהם של pmשמימדיה B, מצביע למטריצה mnשמימדיה Aכארגומנטים: מצביע למטריצה

. p -ו

במידה שארעה שגיאה! NULL, או B-ב Aהפונקציה תחזיר מצביע למטריצת המכפלה שמתקבלת מהכפלת

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

,למשלכתוב פונקציה רקורסיבית המקבלת מספר שלם חיובי ומחזירה כמות הספרות בו (32

. 5הפונקציה מחזירה 34218עבור מספר

כתוב פונקציה רקורסיבית המקבלת מספר שלם חיובי ומחזירה את סכום הספרות בו ,למשל

. 18הפונקציה מחזירה 34218עבור מספר

7 6 5 4

3 2 1 0A

11 10 9

8 7 6

5 4 3

2 1 0

B X

158 136 114

54 48 42AB

m

k

jkkiji baAB1

,,,

21תרגול פרק



כתוב פונקציה רקורסיבית המקבלת מספר שלם חיובי כדצימלי ומדפיסה אותו בבסיס בינארי,למשל (33

(PrintBinary 6)=> 110

(PrintBinary 37)=>

100101

למשל, פרמטרים ומחשבת כפל שלהם ע"' פעולת חיבור בלבד, 2כתוב פונקציה רקורסיבית המקבלת (34

Mult (2 ,5) => 10

Mult (5 ,2) => 10

למשל, פרמטרים ומחשבת חילוק שלהם ע"' פעולת חיסור בלבד, 2כתוב פונקציה רקורסיבית המקבלת

Mult (10 ,5) => 2

Mult (15 ,3) => 15

מחלק משותף גדול ביותר מספרים שלמים חיוביים ומחזירה את ה 2כתוב פונקציה רקורסיבית המקבלת (35

,למשל

Gcd(30 , 45 ) => 15

Gcd(13 , 6 ) => 1

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

int ar[]={3,5,2,1,8,1,9,7,3,6};

Print( ar,10) => 3 5 2 1 8 1 9 7 3 6

יש לשנות את הפונקציה הקודמת כדי שהיא תדפיס את המערך מהסוף להתחלה :

int ar[]={3,5,2,1,8,1,9,7,3,6};

Print( ar,10) => 6 3 7 9 1 8 1 2 5 3

שלמים ומחזירה את המספר המקסימלי בניהם,למשל כתוב פונקציה רקורסיבית המקבלת מערך של מספרים (37

int ar[]={3,5,2,1,8,1};

Max( ar,6) => 8

הוסף פונקציה המקבלת מערך מספרים ומחזירה את המספר המינימאלי, למשל

int ar[]={3,5,2,1,8,1};

Min( ar,6) => 1

שלכתוב פונקציה רקורסיבית המקבלת מחרוזת ומדפיסה אותה בסדר הפוך, למ (38

char str[]= "abcdefghijk"

PrintReverse( str) => "kjihgfedcba"

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

char str[]= "abcdefghijk"

PrintReverse( str) => "abcd"

21תרגול פרק



ייה,למשלמחרוזות ומעתיקה אחת מהמחרוזות לשנ 2כתוב פונקציה רקורסיבית המקבלת (39

char str1[]="xyz",str2[40];

CopyStr(str1,str2);

Puts(str2)=> "xyz"

כתוב פונקציה רקורסיבית המקבלת מחרוזת ומעבירה כל אות קטנה שלה לגדולה ,למשל (40

char str1[]="xAssR";

ToUpper(str1); => "XASSR"

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

char str1[]="XASSR ";

ToUpper(str1); => " xAssR "

כתוב פונקציה רקורסיבית המקבלת מחרוזת ומחשבת בה כמות הרווחים,למשל (41

char str1[]="x__y_z";

BlankCount(str1); => 3

C Programming Answers for chapter 12

Documents

Transcript of C Programming Answers for chapter 12