שלום,

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

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

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

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

האים יש פונקציה שקולטת עד רווח? (מתוך קובץ?)

תודה מראש,

אם אתה לא רוצה לקלוט תו תו אז אין לך ברירה אלה להגדיר מראש מחרוזת גדולה ולקוות שהקלט לא יהיה יותר ארוך מהאורך שלה

אם אתה מתכנת ב-C++ אתה יכול לקלוט שורה ואז לפרק אותה למילים בעזרת הפונקציה strtok

יש דבר שנקרא "אלגוריתם מערך דינאמי ב (1)O " שמאפשר לעשות את זה (בערך).

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

2)מקבלים קלט עד למילוי המערך.

3)ברגע שהוא מתמלא (לגבי קובץ אפשר לבדוק שעוד לא הגענו ל EOF) מקצים מערך

בגודל כפול .

4)כעת מעבירים את תוכן המערך הישן לחצי הראשון של מערך החדש (אמור להיות איבר איבר במקביל

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

5)קולטים תווים חדשים לחצי המערך השני.

6)כאשר המערך השני מתמלא וכל המידע הועבר מהמערך הראשון אל השני, משחררים את הזכרון

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

וכן הלאה וכן הלאה....

בהצלחה.

אם כבר אז הסיבוכיות זמן שלו היא (O(n

נגיד אורך הקלט n והגדרת מארך בגודל n/p

בשלב ראשון שאתה קולט n/p תווים

בשלב שני אתה קולט עוד n/p תווים ומעתיק את n/p התוים הקודמים סה"כ 2n/p

בשלב השלישי אתה קולט 2n/p תווים ומעתיק את 2n/p התווים הקודמים סה"כ 4n/p

וכו...

סה"כ n/p + 2n/p + 4n/p + 8n/p + ...pn/p

שזה בין n ל-2n

לכן הסיבוכיות (O(n

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