דבר ראשון אני יודע שזו בשה מוזרה אבל יש לי בחינה ב++c ביום שני וקבלתי מהמרצה שלי בחינה לדוגמא

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

על המבחן הזה אני אודה לו מאוד...

(זה קצת נהרס פה אז אם מישו רוצה אני יוכל לשלוח לו את זה באי סי קיו מספר 264894804)

הנה המבחן:

מבחן בקורס מעבדת תכנות C/C++

שם המורה:

מועד א' תשס"ב

כל חומר כתוב מותר

משך הזמן: שעתיים

פולינום מוגדר ע"י הנוסחה:   

P(x) =  Σaixi

פולינום מדרגה n מוחזק במחשב ע"י מערך המקדמים שלו. לדוגמא הפולינום

P(x) =  5x4 + 3x2 x +3

מיוצג ע"י המערך   

3 -1 3 0 5

נגזרת של פולינום גם היא פולינום, מדרגה n-1, המוגדר ע"י הנוסחה:

P`(x) =  Σiaixi-1

בדוגמת הפולינום מעל הנגזרת היתה

P`(x) =  45x3 + 23x1 1 = 20x3 + 6x 1

מערך המקדמים של הנגזרת הוא

-1 6 0 20 0

הגדר תבנית (template) מחלקה להגדרת פולינום מדרגה כלשהי, כאשר מקדמי הפולינום יכולים להיות מכל תחום (שלמים, ממשיים, מרוכבים וכו'). שים לב!! לתבנית יהיו שני פרמטרים: סוג המקדמים ודרגת הפולינום.

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

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

       עבור חישוב זה השתמש בנוסחת ניוטון לחישוב ערך של פולינום:

p(x) = ((((anx + an-1) x + an-2) x + a1)x + a0

            הנך יכול להניח שפעולות הכפל והחיבור מוגדרות לכל סוגי הנתונים.

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

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

הערות:

הנך יכול להוסיף כל method או פונקציה נוספת שתמצא לנכון.

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

בהצלחה

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

/*

  ID: 200264463

  Name: Or Hen

  Description: P-Lab EX.13

  File Name: Test.cpp

*/

#include <iostream.h>

#include <string.h>

#include <math.h>

#include <complex>

class Complex

{

private:

double Real, Imag;

public:

Complex():Real(0),Imag(0){}

Complex(double i):Real(i),Imag(i){}

Complex(double R, double I):Real®,Imag(I){}

// Complex(const Complex &Comp):Real(Comp.Real),Imag(Comp.Imag){}

bool operator>(double i){if( (Real > i) && (Imag > i) ) return true; return false;}

bool operator>(const Complex &Comp){if( (Real > Comp.Real) && (Imag > Comp.Imag) ) return true; return false;}

bool operator<(double i){if( (Real < i) && (Imag < i) ) return true; return false;}

bool operator<(const Complex &Comp){if( (Real < Comp.Real) && (Imag < Comp.Imag) ) return true; return false;}

bool operator==(double i){if( (Real == i) && (Imag == i) ) return true; return false;}

bool operator==(const Complex &Comp){if( (Real == Comp.Real) && (Imag == Comp.Imag) ) return true; return false;}

Complex operator=(double i){Real= i; Imag = i; Complex A((Real),(Imag)); return A;}

Complex operator=(const Complex &Comp){Real = Comp.Real; Imag = Comp.Imag; Complex A((Real),(Imag)); return A;}

Complex operator*(double i){Complex A((Real*i),(Imag*i)); return A;}

Complex operator*(const Complex &Comp){Complex A((Real*Comp.Real),(Imag*Comp.Imag)); return A;}

Complex operator-(double i){Complex A((Real-i),(Imag-i)); return A;}

Complex operator-(const Complex &Comp){Complex A((Real-Comp.Real),(Imag-Comp.Imag)); return A;}

Complex operator+(double i){Complex A((Real+i),(Imag+i)); return A;}

Complex operator+(const Complex &Comp){Complex A((Real+Comp.Real),(Imag+Comp.Imag)); return A;}

Complex operator+=(const Complex &Comp){Real += Comp.Real; Imag += Comp.Imag; return *this;}

Complex operator+=(double i){Real += i; Imag += i; return *this;}

Complex operator-=(const Complex &Comp){Real -= Comp.Real; Imag -= Comp.Imag; return *this;}

Complex operator-=(double i){Real += i; Imag += i; return *this;}

Complex operator*=(const Complex &Comp){Real *= Comp.Real; Imag *= Comp.Imag; return *this;}

Complex operator*=(double i){Real += i; Imag += i; return *this;}

Complex operator/=(const Complex &Comp){Real /= Comp.Real; Imag /= Comp.Imag; return *this;}

Complex operator/=(double i){Real += i; Imag += i; return *this;}

friend ostream &operator<<(ostream &, const Complex &);

friend istream &operator>>(istream &, Complex &);

};

ostream &operator<<(ostream &file, const Complex &Comp)

{

file << "(" << Comp.Real << "," << Comp.Imag << ")";

return file;

}

istream &operator>>(istream &file, Complex &Comp)

{

cout << "------" <<endl;

file >> double(Comp.Real) >> double(Comp.Imag);

cout << "------" <<endl;

return file;

}

template <class KIND, int LEVEL>

class Polinom

{

private:

KIND *Array;

public:

Polinom(){Array=NULL; if (LEVEL < 0 ) throw "INVALID LEVEL VALUE";}

Polinom( KIND *);

Polinom( Polinom<KIND,LEVEL> &);

~Polinom(){if (Array != NULL) delete [] Array;}

KIND operator [](int i);

void operator =(const Polinom<KIND,LEVEL> &);

int level(){return LEVEL;}

friend ostream &operator<<(ostream &, Polinom<KIND,LEVEL>  &);

friend istream &operator>>(istream &, Polinom<KIND,LEVEL>  &);

};

template <class KIND, int LEVEL>

Polinom<KIND, LEVEL>::Polinom( KIND *array)

{

if (LEVEL < 0 )

throw "INVALID LEVEL VALUE";

Array = new KIND [LEVEL+1];

for (int i=0; i<(LEVEL+1); i++)

Array = array;

}

template <class KIND, int LEVEL>

Polinom<KIND, LEVEL>::Polinom( Polinom<KIND,LEVEL> &polinom)

{

if (LEVEL < 0 )

throw "INVALID LEVEL VALUE";

Array = new KIND [LEVEL+1];

for (int i=0; i<(LEVEL+1); i++)

Array = polinom.Array;

}

template <class KIND, int LEVEL>

KIND Polinom<KIND, LEVEL>::operator [](int i)

{

if ((i < 0) || (i > LEVEL))

throw "Invalid Request!";

else

return Array;

}

template <class KIND, int LEVEL>

void Polinom<KIND, LEVEL>::operator =(const Polinom<KIND,LEVEL> &polinom)

{

if (Array != NULL)

delete [] Array;

Array = new KIND [LEVEL+1];

for (int i=0; i<=LEVEL; i++)

Array = polinom.Array;

}

template <class KIND, int LEVEL>

ostream &operator<<(ostream &file, Polinom<KIND,LEVEL>  &polinom)

{

if (polinom.Array != NULL)

{

file << "(" << polinom.Array[0];;

for (int i=1; i <= LEVEL; i++)

file << "," << polinom.Array;

file << ")" << endl;

}

else

{

file << "THIS POLINOM IS EN EMPTY ONE!" << endl;

}

return file;

}

template <class KIND, int LEVEL>

istream &operator>>(istream &file, Polinom<KIND,LEVEL>  &polinom)

{

if (polinom.Array != NULL)

delete [] polinom.Array;

polinom.Array = new KIND [LEVEL + 1];

for (int i=0; i<=LEVEL; i++)

file >> polinom.Array;

return file;

}

template <class T,int level>

Polinom<T,level> PolinomNigzeret(Polinom<T,level> &A)

{

T array[level+1];

array[0]=A[0]-A[0];

for (int i=1; i< level+1; i++)

array = (A[i-1] * (level+1-i));

Polinom<T,level> Nigzeret(array);

return Nigzeret;

}

template <class T,int level>

T PolinomSum( Polinom<T,level> &A, T X)

{

T sum=A[0]-A[0];

T TEMP;

TEMP = 0;

for (int k=0,i=level; i>0; i--,k++)

{

TEMP = X;

for (int j=1; j<(level - k); j++)

TEMP = TEMP * X;

sum = sum +(A[k] * TEMP);

TEMP = 0;

}

sum = sum + A[level];

return sum;

}

template <class T,int level>

void GzorNigzeret( Polinom<T,level> &A, int &SUM,T X)

{

if (PolinomSum<T,level>(A,X) == 0)

{

SUM++;

GzorNigzeret<T,level>(PolinomNigzeret<T,level>(A),SUM,X);

}

}

template <class T,int level>

bool PolinomMax(Polinom<T,level> &A, T X)

{

Polinom<T,level> Nigzeret;

Nigzeret = PolinomNigzeret<T,level>(A);

if (PolinomSum<T,level>(Nigzeret,X) == 0)

{

if (PolinomSum<T,level>(PolinomNigzeret<T,level>(Nigzeret), X) < 0)

return true;

else if (PolinomSum<T,level>(PolinomNigzeret<T,level>(Nigzeret), X) == 0)

{

int SUM =0;

GzorNigzeret<T,level>(PolinomNigzeret<T,level>(Nigzeret),SUM,X);

if (SUM%2 == 0)

return true;

return false;

}

else

return false;

}

else

return false;

}

void main ()

{

try

{

Polinom<Complex, 4> *A;

try

{

A = new Polinom<Complex, 4>;

}

catch (char *ERROR)

{

cout << ERROR << endl;

A.~Polinom();

A = NULL;

}

if (A != NULL)

{

Polinom<Complex,4> *B;

try

{

B = new Polinom<Complex, 4>;

}

catch (char *ERROR)

{

cout << ERROR << endl;

B.~Polinom();

B = NULL;

}

if (B != NULL)

{

try

{

cin >> *A;

*B = PolinomNigzeret(*A);

cout << *A << *B;

cout << PolinomMax<Complex,4>(*A,-5)<< endl;

}

catch(char *ERROR)

{

cout << ERROR << endl;

}

}

}

}

catch(...)

{

cout << endl << "!!!UNKNOWN FATAL EROR!!!" << endl << endl;

}

}

ממש ממש ממש ממש תודה מראש לכל מי שבכלל יש לו כוח לקרא את זה...

אני מנסה לקרוא תקוד שלך אבל חסר לך תיעוד בטירוף פשוט!!! :-\

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

אם יש לך גירסא מתועדת זה מאוד יעזור

מקס.

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

template <class T,int level>

   Polinom<T,level> PolinomNigzeret(Polinom<T,level> &A)

   {

      T array[level+1];

      array

=A

-A

;

      for (int i=1; i< level+1; i++)

         array = (A[i-1] * (level+1-i));

      Polinom<T,level> Nigzeret(array);

      return Nigzeret;

   }

template <class T,int level>

   T PolinomSum( Polinom<T,level> &A, T X)

   {

      T sum=A

-A

;

      T TEMP;

      TEMP = 0;

      for (int k=0,i=level; i>0; i--,k++)

      {

         TEMP = X;

         for (int j=1; j<(level - k); j++)

            TEMP = TEMP * X;

         sum = sum +(A[k] * TEMP);

         TEMP = 0;

      }

      sum = sum + A[level];

      return sum;

   }

בשתיהין יש שורות כמו:

      T sum=A

-A

;

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

A--

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

עריכה:

הקומפיילר צועק גם על שורה 260:

*B = PolinomNigzeret(*A);

לא יצא לי להכנס לעומק אבל תוודא שאין לך בעיות של מצביעים שם..

מקווה שעזרתי קצת.

מקס.

תודה רבה למי שעזר...

אבל מה שמצאתם הם בעיות של העתקה...

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

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

אין בעד מה אני מקווה שהמבחן הלך בסדר!

מפני שהדיון נגמר אני רוצה להוסיף כמה מילים

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

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

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

תאמת המבחן היה ממש סבבה תודה...

ואני לא יודע מה איתך אבל אותי אישית מכל מה שלמדתי במחשבים זה הכי עניין אותי...

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

מעניינים אותם אבל זה כבר באמת עניין של טעם..

ושוב תודה...

חחח אני מסכים איתך 100% לכתוב קוד זה הכי אחלה! לא מעניין אותי בגרוש לכתוב אלגוריתמים כללים מעניין אותי לכתוב תכלס תוכניות...

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

כן אבל אחד גורר את השני...

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

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

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