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

1 1 2 4 8 16

int Sum_array1(int *a, int n)

{

int i,S;

int *p;

for(i=0,p=a,S=0; i<n; i++)

S=S+*(p+i);

return ( S);

}

void Sum_kodem(int N)

{

int *p;

int i;

int b[N];

p=b;

*p=1;

for(i=1; i<N; i++, p++)

{

*p=Sum_array1(b, i);

}

Print(b);

}

כאשר N=6

א. כשאת כותבת קוד, תשתמשי בכפתור לקוד (כפתור # למעלה).

ב. שימי לב שבפעם הראשונה שאת נכנסת ללולאה, p עדיין מצביע על b, במקום להצביע על b+1.

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

ד. מה עושה הפונקציה Print? היא "יודעת" שהיא צריכה להדפיס רק N מספרים?

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

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

א. כשאת כותבת קוד, תשתמשי בכפתור לקוד (כפתור # למעלה).

ב. שימי לב שבפעם הראשונה שאת נכנסת ללולאה, p עדיין מצביע על b, במקום להצביע על b+1.

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

ד. מה עושה הפונקציה Print? היא "יודעת" שהיא צריכה להדפיס רק N מספרים?

העלתי את הקובץ לפה שתראה...

[attachment deleted by admin]

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

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

ברור, אבל זו כנראה לא המטרה של התרגיל.

חוץ מזה, אם לא שמת לב, זו בחורה.

העלתי את הקובץ לפה שתראה...

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

במקרה שהצגת, את למעשה רוצה למלא את אברי המערך באמצעות תכונה רקורסיבית, כלומר האיבר ה-i תלוי בערכי האיברים הקודמים לו.

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

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

int TotalSum=first;
Arr[0]=TotalSum;
for (i=1; i<ArrSize; i++){
Arr[i]=TotalSum;
TotalSum+=Arr[i];
}
Print (Arr, ArrSize);
}

void FillArray(int Arr[], int ArrSize,int first){

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

בפתרון זה, גם קל לראות כיצד כל איבר עוקב במערך מכפיל את ערכו ב-2 לעומת קודמו.

1) אחרי

*p=1;

את צריכה לקדם את p.

2) בלולאה של הסכימה, כדאי להוסיף סוגריים כדי שהקוד יהייה קריא יותר.

S += (*(p+i));

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

תודה שעזרתם

עכשיו אני אצטרך לתקן

רק עכשיו שמתי לב לזה:

int b[N];

אי אפשר לעשות את זה, מכיוון שN הוא לא קבוע.

את חייבת להגדיר את N כקבוע, או להקצות את b דינאמית.

N הוא כן קבוע, הוא הוגדר ב-define בתחילת התכנית (קרא את קובץ ה-txt שהיא צרפה).

אוףףף הסתבכתי!

איך אני יכולה לקלוט למערך מספר איברים שונה כל פעם אם אני חייבת להגדיר את מספר האיברים של המערך?[br]פורסם בתאריך: 5.11.2007 בשעה 19:53:44

---

הצלחתי!!!!

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

#include<stdio.h>
# define N 6

//void Keep()           ;
void Play()            ; 
void Swap(int *p, int *q)     ;
void Zero_Print(int *a)      ;
void Print(int *a)         ;
int Sum_Array(int *a, int n)   ;
void Max(int *a)          ;
void Kelet( int *a)        ;
void Hipoh(int *a)         ;
void Hipoh2(int *a)        ;
void Zooz(int *a)         ;
void Maxi(int *a)         ;
int Ole(int *a)          ;
int Search_eivar(int *a, int eivar);
void Sum_kodem()          ;




void main()
{

int a[N]={5,8,9,2,4,1};
int *p;
int i,x;
char ch='y';

Play();

}

/*
void Keep()
{
	int number;
	printf("if you want to play enter 1 else 0\n");
	scanf("%d",&number);
	if (number=1)
		Play();
}
*/

void Play()
{
	int a[N]={5,8,9,2,4,1};
	int up,x, y, eivar,n;

	printf("choose int between 1-10\n\n");
	scanf("%d", &x);


	switch(x) 
			{ 
				case 1 : printf("\n"); Print(a);										break;
				case 2 : printf("\n"); Zero_Print(a);								  break; 
				case 3 : printf("\n"); printf("enter number 1-6"); 
									  scanf("%d",&n);
					          Sum_Array(a,n);								  break;
				case 4 : printf("\n"); Max(a);									    break;
				case 5 : printf("\n"); Kelet(a);										break;
				case 6 : printf("\n"); Hipoh(a);										break;
				case 7 : printf("\n"); Hipoh2(a);										break;
				case 8 : printf("\n"); Zooz(a);						  				break;
				case 9 : printf("\n"); Maxi(a);											break;
				case 10: printf("\n"); up=Ole(a);
									  printf("Ole 1, else 0, the array is=%d", up);  break;      
				case 11: printf("\n"); printf("enter num you want to search");
									  scanf("%d",&eivar);
									  y=Search_eivar(a,eivar);
									  printf("%d",y);    							break;
				case 12: printf("\n"); Sum_kodem();                   break;

			}
	//Keep();

}

void Swap(int *p, int *q)
{
	int temp;
	temp=*p;
	*p=*q;
	*q=temp;
}

void Zero_Print(int *a)
{
	int *p;
	int i;

	printf("2. I am going to Zero a and then print a\n\n");
	for(i=0, p=a; i<N; i++)
		*(p+i)=0;
	for(i=0, p=a; i<N; i++)
		printf("%d", *(p+i));

}

void Print(int *a)
{
	int i;
	int *p;

	printf("1. I am going to print the array \n\n");
	for(i=0, p=a; i<N; i++)
		printf("%d", *(p+i));
	printf("\n\n");
}


int Sum_Array(int *a, int n)
{
	int i,S;
	int *p;

	for(i=0,p=a,S=0; i<n; i++)
		S=S+*(p+i);

	return S;

}

void Max( int *a)
{
	int big,i;
	int *p;

	for(i=0,p=a,big=*p;i<N; i++, p++)
		if (big<*p)
			big=*p;

	printf("4. The Max is %d \n\n", big);
}

void Kelet(int *a)
{
	int i;
	int *p;


	printf("enter %d number", N);
	for(i=0, p=a; i<N;i++)
		scanf("%d", p+i);
	Print(a);

}

void Hipoh(int *a)
		{
			int b[N];
			int *p, *q;
			int i, J;
			q=b;
			p=a;

			for(i=(N-1),J=0; i>=0; i--, J++)
			{
				*(q+J) = *(p+i);
			}

			Print(b);
		}

void Hipoh2(int *a)
{
	int *p, *q;
	int i;

	for(i=0, p=a, q=a+(N-1); i<3 ; i++, p++, q--)
	{
		Swap(p,q);
	}
	 Print(a);
}

void Zooz(int *a)
{
	int *p;
	int i, temp;

	p=a+(N-1);
	temp=*p;

	for(i=N-1; i>0; i--, p--)
		*p=*(p-1);
	*p=temp;
	Print(a);
}

void Maxi(int *a)
{
	int *p;
	int max, index, i;

	max=*p;
	for(i=0; i<N; i++, p++)
	{
		if (max>*p)
		{
			max=*p;
			index=i;
		}
	}
	printf("the index is=%d, and the max adress=%d", index, max);
}

int Ole(int *a)
{
	int *p;
	int i, count, num, flag;

	p=a;
	num=*p;
	for(i=1;i<N-1;i++)
	{
		if (num<*(p+i))
			flag=1;
		else
			return 0;
    num=*(p+i);
	}
	return 1;
}

int Search_eivar(int *a, int eivar)
{
	int *p;
	int i;



	p=a;
	for(i=0; i<N; i++, p++)
	{

		if(*p==eivar)
			return i;
	}
	return (-1);
}

void Sum_kodem()
{

	int *p;
	int i;
	int b[N];

	 p=b;
	*p=1;

	p++;

	for(i=1; i<N; i++, p++)
	{
		*p=Sum_Array(b, i);
	}

	Print(b);
}

N הוא כן קבוע, הוא הוגדר ב-define בתחילת התכנית (קרא את קובץ ה-txt שהיא צרפה).

אה.. אני התייחסתי להודעה הראשונה.

1 1 2 4 8 16

void Sum_kodem(int N)

{

int *p;

int i;

int b[N];

כאשר N=6

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

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

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