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

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

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

תודה...

[attachment deleted by admin]

ככה:

void f(const char* string);

רמז לאלגוריתם: בכל מקרה צריך לעבור על האותיות אחת אחת.

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

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

אתה מדבר על מצביעים ואני אמור לעשות את זה בלי מצביעים...

חשבתי יותר על משהו בסגנון:

void f(char s[])

אבל עדיין אין לי אלגוריתם לתוכנית... :'(

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

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

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

מה שאתה רשמת פשוט מתאר מצביע למערך תווים עם גודל קבוע מראש.

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

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

כלומר אני מתחיל לעבור בלולאה על המקומות במחרוזת שלי ומדפיס את הראשונה ואז אם הבאה בערך אסקי פחות זאת שהדפסתי בערך אסקי שווה ל-1 אני ממשיך לבדוק ובמידה ולא שווה ל-1 אני מדפיס גם אותה ?

ואם כן אז איך אני יודע מתי סוף המחרוזת?

ושכחתי אולי פרט באלגוריתם ? או שהוא ממש כזה כביכול פשוט ? :-\

את סוף המחרוזת אתה מזהה באמצעות התו '0\'.

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

בעניין מצביעים או מערכים, אל תשכח ש:

p[i]

-שקול ל

*(p+i)

את סוף המחרוזת אתה מזהה באמצעות התו '0\'.

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

יש בעיה קלה עם האלגוריתם....

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

מחרוזת = מערך שבתוכו תווים.

#include <stdio.h>
#include <string.h>

int main()

{
	s[]="dabcemoqmnopqrrtaduvwxaz";
	f(s);

	return 0;




}



void f(char s[])

{

	int i=0;
	while (s[i]!='\0')
	{
		if(('s[i+1]'-'s[i]')==1)
		{
			printf("%c-",s[i]);
			i++;

		}


		else(i++)



	}


}

אני איפשהו תקוע בתנאי ה-if של זה שאני חושב נכון אולי, אבל הבעיה שלי היא לעשות את ההדפסה של האות האחרונה ברצף....

קודם כל, עדיף להשתמש בלולאת for ולא while (ללולאה יש נקודת התחלה ונקודת סיום מוגדרות היטב).

חוץ מזה, למה ה-[s[i וה-[s[i+1 בגרשיים?

לגבי האלגוריתם, אני אחזור על עצמי:

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

הדבקתי כרגע רק את הפונקציה:

void f(char s[])

{

	for(i=0; s[i]!='\0'
	{
		if((s[i+1]-s[i])!=1)
		{
			printf("%c",s[i]);
			i++;
		}


		if((s[i+1]-s[i])==1)

		{
			printf("%c-",s[i]);
			i++
		}	

}

יש מצב שעכשיו זה אפילו מוכן ?

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

תגיד לי אתה.

חוץ מזה, למה את הקידום של i לא עשית ב-for?

בנוגע ל- ++i בלולאה, צודק באמת עדיף שיהיה בתנאי כי גם ככה רק אחד ה-if-ים יתקיים כל פעם.

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

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

הנה הפונק' שכתבתי נכון לעכשיו (אחרי תיקוני קומפילציות וקוסמטיקה):

void f(char s[])

{
int i=0;

	for(i=0; s[i]!='\0';i++)
	{

		if((s[i+1]-s[i])!=1)
		{
			printf("%c",s[i]);
		}


		if((s[i+1]-s[i])==1)
		{
			printf("%c-",s[i]);
			i++;
		}	
	}
}