שלום חברים. קיבלנו תרגיל בC שכלל כמה סעיפים, הצלחתי לפתור את כלום חוץ מאחד:
אני צריך לכתוב פונקציה רקורסיבית שמקבלת שתי מחרוזות (בגודל זהה, אך לא חובה שמשתמשת בכל הגודל), הפונקציה מכניסה למחרוזת השנייה את התוכן ההפוך של המחרוזת הראשונה.
לדוגמא:str1="Hello World"
צריך לגרום לכך שבמחרוזת השנייה יופיע "dlroW olleH"
ההכרזה על הפונקציה חייבת להיראות ככה:

void strReverse(char*,char*)

אסור להוסיף משתנים להרכזה, אסור להשתמש בפונקציות אחרות (לדוגמא, פונקציה שמוצאת אורך מחרוזת) אסור להשתמש במשתנה סטטי או בDefine.
בקיצור, זה חייב להיות רקורסיבי בלבד
כמובן שצריך להוסיף '\0'בסוף המחרוזת
מותר להשתמש בפונקציות ספריה של stdio.h ושל conio.h

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

תודה מראש.

הגלריה שלי בפליקר

מותר שימוש בפונק' עזר שאתה מגדיר?

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

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

הגלריה שלי בפליקר

את מחרוזת המקור מותר לשנות?

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

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

הגלריה שלי בפליקר

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

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

כדי שזה יקרה, אתה צריך מידע שאתה לא יכול להעביר על המחסנית, לכן נאלץ לעשות מניפולציה קטנה:
תנאי סיום הרקורסיה: הגענו לסוף מחרוזת היעד (הנתון החשוב)
תחילת הרקורסיה תהיה לולאה שתרוץ עד לסוף מחרוזת המקור.
כעת אתה מעביר את התו האחרון לתחילת היעד.
כעת אתה רוצה לבטל תווים שכבר ניצלנו - לכן אתה כותב \0 במקום התו שכרגע כתבת...
ועכשיו אתה מתקדם במשחקי פויינטרים מהסוף להתחלה במחרוזת המקור ומההתחלה לסוף במחרוזת היעד...

פתרון בקוד:

זהירות - ספויילר!

קוד:

void strReverse(char* source, char* dest) {
    char* c = source;
    if (*dest == '\0') return; // THIS is the use of the initial condition..
    while (*c != '\0') ++c; //Run till the end of the source.
    *dest = *(--c); // You don't need the \0 char...
    *c = '\0';
    strReverse(--c, ++dest);
}

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

תודה רבה על ההשקעה.

זה בהחלט פותר את השאלה, רק יש שתי בעיות:
א. זה לא שם null בסוף המחרוזת (המחרוזת היא בגודל 256, אם אני מכניס מחרוזת של 16 תווים אני צריך NULL במקום ה17)
ב. זה מוחק את המחרוזת המקורית, שכפי שאמרתי, אני לא בטוח שזה בעיה או לא.

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

חשבתי על רעיון קצת מוזר, לא יודע אם אפשר ליישם אותו - בascii יש 255 תווים (אם מורידים את NULL), אולי אני יכול להעזר במחרוזת השנייה על ידי הכנסת תווי אסקי לתוכה וככה אני יכול לבנות קאונטר בתוך המחרוזת. הבעיה שאני מסתכן בזה שאני מכניס "זבל" לתוך המחרוזת.

הגלריה שלי בפליקר

הסתמכתי על הנתון שהקלט הוא 2 מחרוזות באורך שווה => בשניהם תו ה-0\ נמצא באותו המקום.
לכן אין צורך לטפל בו באופן מיוחד...

גם אני חשבתי על רעיון של שימוש בבית או ב-4 הבתים הראשונים כמונה, אולם זה פתרון בעייתי שכן א': אתה תדרוס בסופו של דבר את המונה שלך והמידע יאבד, ו-ב' אי אפשר להניח דבר על אורך המחרוזת...
אם תקבל מחרוזת באורך 1 כשאתה עובד על 4 בתים אתה מסתכן ב-segmentation fault, ואם אתה עובד עם בית אחד אתה לא תוכל לטפל במחרוזות באורך של למעלה מ-256 תווים...

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

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

קוד:

void strReverse(char* source, char* dest) {
	char* c = source;
	if (*dest == '\0') return; // THIS is the use of the initial condition..
	while (*c != '\0') ++c; //Run till the end of the source.
	*dest = *(--c); // You don't need the \0 char...
	*c = '\0';
	strReverse(--c, ++dest);
	*(c+1) = *(dest -1);
}

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

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

הראל

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

הרעיון הכללי שלי היה לרוץ עד סוף המחרוזת (עד ה'\0') הראשונה בעזרת רקורסיה (לקרוא כל פעם לאיבר הבא של המחרוזת הראשונה, אבל לקרוא רק לאיבר הראשון של המחרוזת השנייה) ואז כשהוא ממשיך את הפונקציה להכניס את האיבר של הפויינטר הראשון לאייבר של הפויינטר השני ולהעביר את המיקום של הפויינטר השני קדימה. הבעיה שאני לא מצליח לחשוב על שום דרך שתגרום לזה לעבוד בלי שיהיה לי משתנה סטטי.

הגלריה שלי בפליקר

לפני זה, קטע קטן:

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

הבעיה שלך היא המגבלה המלאכותית שהוסיפו בתרגיל - שאתה לא יודע את אורך המחרוזות. אסור לך להשתמש ב-strlen. לכן, אתה לא יכול להשתמש בפיתרון כמו זה ש-rlsf הציע - כי אתה לא יודע איפה נמצא התו האחרון (הוא נמצא ב-str1[len-1]‎, אבל אתה לא יודע מהו len).
אסור לך ללכת עד ה-NULL כדי לגלות את אורך המחרוזת, זה שקול לקריאה ל-strlen.

אז מה אתה יכול לעשות?

יש קטגוריה של פיתרונות רקורסיביים שבהם מבצעים פעולה על חלק ממערך (לדוגמה, ההתחלה), ואז קוראים לעצמך רקורסיבית על שאר המערך. לדוגמה, אתה רוצה להכפיל כל מספר בערך פי 2 - אתה מכפיל את המספר הראשון במערך פי 2, וקורא לעצמך על המערך ללא התו הראשון:

קוד:

void doubleArray(int*arr, size_t size) {
	if (size == 0) return;
	arr[0] = arr[0] * 2;
	doubleArray(arr+1, size-1);
};

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

איך הוא יכול לדעת מהו עומק הכניסה?
אסור לו 'לסחוב' איתו עוד משתנה... רק 2 מחרוזות..
אפשר לנסות להשתמש ב-4 הבתים הראשונים במחרוזת כ-int, אבל ברגע שתתחיל להעתיק לא תוכל לדעת את הנתונים לקריאות החיצוניות יותר...
זו בדיוק הבעיה...

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

אני חייב לשבח אותך על ההסבר, הוא טוב בהרבה מההסבר של המרצה שלי.
כבר הבנתי שזה הכיוון שאני צריך ללכת בו - לעבור בעזרת רקורסיה על המערך הראשון על לNULL ואז לבצע את הפעולות, הבעיה שברגע שאני מגיע לסוף אין לי דרך לשמור על הערך הזה שלא יעלם לי ברגע שאני חוזר לפונקציה הקודמת (אני מקווה שהניסוח ברור).

הגלריה שלי בפליקר

קוד:

void strReverse(char *s, char *d) {
	if (*(s + 1)) {
		strReverse(s + 1, d);
		while (*d) d++; 
		*d = *s;		
		*(d + 1) = '\0';
	}
	else { 
		*d = *s;
		*(d + 1) = '\0';
	}
}

int main() {
	char a[30] = "Hello World"; 
	char b[30] = "Whats up?"; 
	strReverse(a, b);
	printf("Result: %s\n", b);
	
	return 0;
}

או

קוד:

void strReverse(char *s, char *d) {
	if (*(s + 1)) {
		strReverse(s + 1, d);
		char ret = *(s + 1);
		*(d + ret) = *s;
		*(d + ret + 1) = '\0';
		*s = ret + 1; 
	}
	else { 
		*d = *s;
		*(d + 1) = '\0';
		*s = 1; 
	}
}

שיותר יעיל אבל תומך רק עד מחזורת בגודל 255 תווים.

Error: Keyboard not found

Press F1 to continue

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

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

הגלריה שלי בפליקר

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

אתה מחונן?

לא עברתי על התגובות כאן אבל הנה פיתרון שלי:

קוד:

void strReverse(char* src,char* target)
{
	for(int i=0; src[i]!='\0'; i++)
	{
		for (int j=i; j>0; j--)
		{
			target[j]=target[j-1];
		}
		target[0] = src[i];
	}
}

עריכה: לא שמתי לב שצריך ברקורסיה.

Your signature did not follow Fresh's signatures policy, therefore it was automatically erased. Please see the E-Mail which has been sent to you, to learn how to fix this.