מערך דו ממדי - C

[QttP]

הקליטה עבור כל תו רצה על לולאות for שתפקידן לרוץ על המערך הדו מימדי איבר איבר

עדיין לא רואה מה הבעיה?

[iem]

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

אני לא יכול להוציא את scanf החוצה, או יותר נכון להוסיף אחד כזה...

[QttP]

איפה אצלך אתה דואג להכנסה "למקום המתאים לפי הסדר" כלשונך?

[iem]

כאן:

matrix[i][j] = num;

עבור כל i,j בתחום...

[Dubliner]

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

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

לפי מה שאני מבין, זה מה שקורה פה:

התכנית שלך רצה ככה:

1. קלוט תו מהמשתמש

2. עבור על כל התאים במטריצה, לכל תא

2.1 הכנס את התו לתא הזה

במקום ככה (שזה מה שרצית, תקן אותי אם אני טועה):

1. עבור על כל התאים במטריצה, לכל תא

1.1. קלוט תו מהמשתמש

1.2 הכנס לתא הנוכחי

1.3 התקדם לתא הבא

[iem]

הכוונה למשהו כזה:

#include <stdio.h>
#define N 2 

int main()
{
 int matrix[N][N];
 int l,c,i=0, j=0,letter_counter=0;
 char num;

for(i = 0; i < N; i++)
{ 
  for(j = 0; j < N; j++) 

   while((scanf("%d",&num)) != (EOF))
 	{ 
		letter_counter++;

		if (letter_counter>N)
		{
		printf("Input overflow !");
		exit(EXIT_FAILURE);	
		}

		else if (!isdigit(num))
		{
		printf("NOT A DIGIT");
		exit(EXIT_FAILURE);	
		}

		else
		{
		matrix[i][j]=num;
		}
}
    }

for(l = 0; l < N; l++)
  { 
  for(c = 0; c < N; c++) 

   printf("%d\t", matrix[l][c]); 

  printf("\n");
  }



return 0;
}

??

[Access Denied]

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

תנסה להוסיף את השורה הבאה אחרי שאתה מסיים לולאת קלט (אחרי שאתה קולט מה שאתה צריך)

fflush (stdin);

זה מוחק את הבאפר של הקלט אחרי שאתה מסיים לקלוט מה שאתה צריך.

אני כמעט תמיד מעדיף לעבוד עם getchar כי scanf לא תמיד קולטת לפי מה שאתה מצפה.

[QttP]

הכוונה למשהו כזה:

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

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

תחשוב קצת לפני שאתה כותב!

[iem]

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

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

תחשוב קצת לפני שאתה כותב!

:-\

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

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

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

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#define N 2 

int main()
{
 int matrix[N][N];
 int l,c,i=0, j=0,letter_counter=0;
 char num;

for(i = 0; i < N; i++)
{ 
  for(j = 0; j < N; j++) 

   while( (num=getchar()) != (EOF))
 	{ 
		letter_counter++;

		if (letter_counter>(N*N))
		{
		printf("Input overflow !");
		exit(0);	
		}

		else if (!isdigit(num))
		{
		printf("NOT A DIGIT");
		exit(0);	
		}

		else
		{
		matrix[i][j]=num;
		fflush (stdin);
		}
}
    }


for(l = 0; l < N; l++)
  { 
  for(c = 0; c < N; c++) 

   printf("%d\t", matrix[l][c]); 

  printf("\n");
  }



return 0;
}

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

[Dubliner]

לדעתי לולאת ה-while בכלל מיותרת, אלא אם פיספסתי פה משהו מהותי.

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

למה לא לעשות משהו כזה:

-לולאת for ראשונה על השורות

-לולאת for שניה על העמודות

(עד כאן זה כמו שעשית)

-קליטת תו מהמשתמש, ללא לולאה, אלא פשוט פקודת getchar, scanf או מה שנוח לך להשתמש.

-בדיקות החוקיות של הקלט, אם זה רלוונטי.

-הכנסת האיבר לתא המתאים במטריצה.

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

[Ghosthunter]

מתי GETCHAR מחזיר EOF?

[iem]

לדעתי לולאת ה-while בכלל מיותרת, אלא אם פיספסתי פה משהו מהותי.

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

למה לא לעשות משהו כזה:

-לולאת for ראשונה על השורות

-לולאת for שניה על העמודות

(עד כאן זה כמו שעשית)

-קליטת תו מהמשתמש, ללא לולאה, אלא פשוט פקודת getchar, scanf או מה שנוח לך להשתמש.

-בדיקות החוקיות של הקלט, אם זה רלוונטי.

-הכנסת האיבר לתא המתאים במטריצה.

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

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

מתי GETCHAR מחזיר EOF?

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

[Ghosthunter]

כל עוד תקליד אות/מספר/משהו אחר, לא תקבל EOF.

איך אתה מתכוון להפריד בין הקלטים השונים?

[amitbl]

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

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

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

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

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

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

תחשוב שוב מה בדיוק אתה רוצה לעשות.

[iem]

מצטער על התגובה המאוחרת מאוד... לא הייתי בלימודים, ודווקא היום בדירה האינטרנט החליט למרוד בי... :'(

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

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

גודל המערך לא דינמי וגם אם כן היה זה לא היה צריך לשנות הרבה... עדיין הייתי חייב להשתמש עם EOF כי מבקשים לקלוט "במכה אחת" את הנתונים כלומר: אני יכול להכניס: 1 2 3 אנטר ואז 4 5 6 אנטר ואז 7 8 9 אנטר, ורק אז ללחוץ CTRL-D או לחילופין 1 2 3 4 5 6 7 8 9 ואז CTRL-D ושיהיה לכך אותו האפקט.

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

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

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

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

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

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

כל עוד תקליד אות/מספר/משהו אחר, לא תקבל EOF.

איך אתה מתכוון להפריד בין הקלטים השונים?

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

אפילו משהו נניח כזה:

if (isdigit(num) == 0)
{
printf("NaN Error !!");
exit(0);
}

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

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