לא מבין משהו במערך CHARים, בC

[Ghosthunter]

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

[ktbnus]

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

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

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

גם ב C++ אם אני לא טועה , לא בודק בשבילך גלישה בזכרון.

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

* הפונקצייה יכולה לקבל עוד משהו בנוסף למחרוזת?

ו

[שניצל]

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

כדאי לציין שב-C++ זה לא ככה (אפשר להגדיר משתנים איפה שרוצים).

[SweeT_EviL]

זה ידוע, ועד כמה שאני יודע יש בC++ פונקציה שנקראת GET_S והיא הולכת ככה

gets_s(veribel , size)

כלומר הוא כן מגביל.

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

[שניצל]

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

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

[Ghosthunter]

לא מצויין שאסור אבל עדין.

אם לא רשום שאסור - מותר.

בכל מקרה, בC++ יש גם את cin.getline(char *, int len, char del='\n');

שlenזה האורך וDEL זה התו שעד אליו הוא יקלוט.

[SweeT_EviL]

"אם לא רשום שאסור - מותר."

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

[ktbnus]

כמו שנאמר GET_S זו פקונצייה של מיקרוסופט, יש גם SCANF_S .

ב cin.getline ה len יכול להיות יותר גדול מאורך המערך בפועל.

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

בכל מקרה שימוש ב strlen ניראה לי סביר, לא רואה שום בעייה אם זה

[Ghosthunter]

זמן הריצה של STRLEN הוא o(n), ולכן זה לא כל כך נחמד לשים את זה בפתרון, כי אז הפתרון יהייה בדרך כלל o(n^2) או יותר, במקום o(n) בלבד.

וגם בגלל שבדרך כלל STRLEN היא פונקציה איטרטיבית.

[SweeT_EviL]

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

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

אבל תודה לכולכם בכל אופן.

[Ghosthunter]

משתנה סטטי?

[SweeT_EviL]

;D

משתנים גלובלים הם השטן!!!11

....

.....

.....

....

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

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

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

[Jaman]

לא נראה לי שאתה יכול לפתור את זה בלי STRLEN או משהו מקביל לה, כי אתה חייב למצוא את הערך של התו האחרון, וכדאי לדעת את מקום התו האחרון אתה חייב להשתמש בSTRLEN או כמו ש UnsignedInteger הציע - לעבור על המערך עד מגיעים ל\0, שזה בדיוק מה שstrlen עושה..

[ktbnus]

משתנה סטטי ברקורסיה... זה כבר לא רקורסיה.

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

תשתמש ב STRLEN.

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

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

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

[Ghosthunter]

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

void func(char *s)
{
	if(!s || !s[0] || !s[1])
		return;
char c = s[1];
	func(s+1);
	if(s[0]<s[1])
	{
		//print s[0]
	}
	s[0] = s[1]
s[1] = c;
}