פעולות סטטיות ופונקציות

11.1 מבוא כללי לפעולות ולפונקציות

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

(שמות הפעולות והמשתנים נבחרו באופן שרירותי והם בבחינת דוגמאות)

(1) פעולת ההעלאה בריבוע: F(x) = x²

• שם הפעולה: F
• מטרת הפעולה (מה היא עושה): העלאה בחזקת 2 (העלאה בריבוע).
• הקלט: מספר ממשי אחד x
• הפלט (התוצאה): מספר הקלט מועלה בחזקת 2 ( x² )

(2) פעולת הממוצע: avg(x,y)=(x+y)/2

• שם הפעולה: avg
• מטרת הפעולה (מה היא עושה): חישוב הממוצע של שני מספרים.
• הקלט: שני מספרים ממשיים, והם: x,y
• הפלט (התוצאה): הממוצע של שני המספרים x ו-y

(3) פעולת הערך הקטן ביותר: H(x,y,z) = Min(x,y,z)

• שם הפעולה: H
• מטרת הפעולה (מה היא עושה): מציאת המספר הקטן ביותר.
• הקלט: 3 מספרים ממשיים x,y,z .
• הפלט (התוצאה): מחזירה את המספר הקטן ביותר מבין מספרי הקלט.

11.2 הפעולות בתכנות

פעולה (Method): היא קטע קוד שלם שיש לו שם והוא פועל למטרה מסוימת.

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

הערות:

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

סוגי הפעולות הסטטיות:

• (a) פעולות שאינן מקבלות קלט ואינן מחזירות פלט.
• (b) פעולות שאינן מקבלות קלט ומחזירות פלט.
• (c) פעולות שמקבלות קלט ואינן מחזירות פלט.
• (d) פעולות שמקבלות קלט ומחזירות פלט.

(a) דוגמה לפעולות שאינן מקבלות קלט ואינן מחזירות פלט:

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

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

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

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

static void Main(string[] args)
{
  stars();
  Console.WriteLine("Hammam");
  stars();
}

• stars(); — קריאה לפעולה stars
• stars(); — קריאה לפעולה stars

והתוצאה על המסך תהיה:

***********
***********
Hammam
***********
***********

(b) דוגמה לפעולות שאינן מקבלות קלט ומחזירות פלט:

פעולת "הטלת קובייה", למשל ניתן לה את השם nrd .

לפעולה הזאת אין קלט כלשהו אבל היא מחזירה ערך (יש לה ערך מוחזר). כשאנחנו קוראים לה היא נותנת לנו ערך מוחזר שהוא מספר אקראי מן הקבוצה הבאה (1,2,3,4,5,6)

בקריאה לפעולה הזאת (הפעלת הפעולה) נקבל ערך שלם מ-1 עד 6 (כולל 1 ו-6)

למשל, בקריאה לה נקבל את המספר 6, ובקריאה נוספת נקבל 2, וכך הלאה....

(c) דוגמה לפעולות שמקבלות קלט ואינן מחזירות פלט:

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

דוגמה:

דוגמה לקריאה לפעולה הזאת ולהפעלתה (הפעולה y) בתוך תוכנית:

static void Main(string[] args)
{
    int n = 2;
    y(3);
    Console.WriteLine("##########");
    y(n);
}

על המסך יודפס:

Hi
Hi
Hi
##########
Hi
Hi

דוגמה נוספת:

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

הפעולה הזאת אינה מחזירה ערך.

(d) דוגמה לפעולות שמקבלות קלט ומחזירות פלט:

פעולה שמקבלת מספר עשרוני ומחזירה את ערכו המוחלט, נקרא לה absolute. הפעולה הזאת מקבלת מספר עשרוני בקלט שלה ומחזירה מספר עשרוני בפלט שלה, שהוא הערך המוחלט של מספר הקלט.

למשל:

נבנה תוכנית שיש בה קריאה לפעולה absolute :

static void Main(string[] args)
{
    double x = 2.5, y= -7;
    double res;
    res = absolute(-6);
    Console.WriteLine("res={0}",res);
    res = absolute(x);
    Console.WriteLine("res={0}", res);
    Console.WriteLine("result is: {0}",absolute(y));
    Console.ReadLine();
}

התוצאה תהיה:

res=6
res=2.5
result is: 7

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

11.3 בניית הפעולה

נבנה את הפעולה מחוץ למסגרת הפעולה הראשית Main, והיא חייבת לכלול את הדברים הבאים:

לכל פעולה עלינו לקבוע את הדברים הבאים:

1. טיפוס הנתונים שהפעולה הזאת מחזירה.
2. שם הפעולה.
3. טיפוס הנתונים שהפעולה הזאת מקבלת ושם המשתנים שבהם נשמרים הנתונים האלה מן הקלט.
4. גוף ומבנה הפעולה (פקודות הפעולה).
5. אם יש ערך שהפעולה הזאת מחזירה, חייבת להיות פקודת return (החזרה) לערך הזה בתוך גוף ומבנה הפעולה.

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

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

static int Pow2(int x)
{
    return x * x;
}

• int — הפעולה מחזירה מספר שלם.
• Pow2 — שם הפעולה.
• (int x) — הפעולה מקבלת מספר שלם, שנשמר בתוך המשתנה x מטיפוס int.
• x * x — מספר שלם שהפעולה מחזירה.

(1) טיפוס הנתונים המוחזר:

זהו טיפוס הנתונים שהפעולה מחזירה למי שקרא לפעולה הזאת והפעיל אותה. טיפוס הנתונים המוחזר יכול להיות: int, double, char , string , int[] , bool , char[] ...

• int[] מערך שלם של מספרים שלמים.
• char[] מערך שלם של תווים.

אם הפעולה הזאת אינה מחזירה ערך, נציב את טיפוס הנתונים void .

(2) שם הפעולה:

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

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

(3) טיפוס הנתונים בקלט:

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

למשל:

static void example (int num, double avg, int[] arr, string name)
{

}

• int num — הפרמטר הראשון שהפעולה מקבלת וטיפוסו, שם הפרמטר הוא num.
• double avg — הפרמטר השני שהפעולה מקבלת וטיפוסו.
• int[] arr — הפרמטר השלישי שהפעולה מקבלת וטיפוסו.
• string name — הפרמטר הרביעי שהפעולה מקבלת וטיפוסו.
• , — פסיק.

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

(4) גוף ומבנה הפעולה (פקודות הפעולה):

גוף הפעולה הוא שורות תכנות ופקודות C#‎ (קוד), והפעולה מבצעת את השורות האלה כאשר קוראים לה.

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

(5) פקודת return והערך שהפעולה מחזירה:

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

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

דוגמה:

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

static double Avg3(int x, int y, int z)
{
    double avg;
    avg = (double)(x + y + z) / 3;
    return avg;
}

ובכתיבה מקוצרת אפשר לכתוב כך:

static double Avg3(int x, int y, int z)
{
    return (double)(x+y+z)/3;
}

הערות חשובות:

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

11.4 הפעלת הפעולות והשימוש בהן בתוך התוכנית הראשית Main

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

דוגמה:

static int Pow2(int x)
{
    return x * x;
}
static void Main(string[] args)
{
    int x, y, z;
    x = Pow2(4);     // x = 16
    z = Pow2(-3);    // z = 9
    y = Pow2(z);     // y = 81
    Console.WriteLine("{0}", Pow2(2)); // יודפס 4
    Console.WriteLine(Pow2(-5));       // יודפס 25
}

דוגמה:

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

static char Nxtchr(char x, int n)
{
    char newtav;
    newtav = (char)((x + n) % 128);   // %128 is for cycling
    return newtav;
}

(ב) כתוב תוכנית Main שמשתמשת בפעולה Nxtchr כדי לקלוט שם משתמש (user name) ולהדפיס על המסך שם משתמש חדש שזהה לשם שנקלט, אבל האות הראשונה במשתמש החדש אינה האות המקורית אלא האות שבאה מיד אחריה

דוגמאות: אם קלטנו Karem נדפיס Larem, אם קלטנו Abed נדפיס Bbed, אם קלטנו Samir נדפיס Tamir, ואם קלטנו rb7i נדפיס sb7i

static void Main(string[] args)
{
    string name;
    Console.Write("Insert your name: ");
    name = Console.ReadLine();
    name = Nxtchr(name[0], 1) + name.Substring(1, name.Length - 1);
    Console.WriteLine("your new name is: {0}",name);
}

Insert your name: rb7i
your new name is: sb7i
Press any key to continue . . .

11.5 יישום ודוגמאות לבניית פעולות מן הסוגים השונים ולקריאה להן

(a) פעולות שאינן מקבלות קלט ואינן מחזירות פלט:

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

static void Main( )
{
   Console.WriteLine("Hello everyone");
}

• void — אינה מחזירה ערך.
• Main — שם הפעולה.
• ( ) — אינה מקבלת קלט.

פעולה ששמה Main, והיא הפעולה הראשית, אינה מחזירה ערך (void) והיא רק מדפיסה על המסך את המשפט הבא: Hello everyone

דוגמה:

נבנה פעולה שמדפיסה על המסך מסגרת של כוכביות שכתוב בה Program By: Hammam, כחותמת שנוכל להשתמש בה בתוכנית הראשית. כלומר היא מדפיסה על המסך את הדברים הבאים:

*********************************************
***********   Program By: Hammam. ***********
*********************************************

ניתן לפעולה את השם stamp, והיא פעולה שאינה מקבלת קלט (אינה מקבלת נתונים) ואינה מחזירה ערך.

נבנה אותה כך:

static void stamp( )
{
    Console.WriteLine("*********************************************");
    Console.WriteLine("***********   Program By: Hammam. ***********");
    Console.WriteLine("*********************************************");
}

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

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

דוגמה לקריאה לפעולה בתוך התוכנית Main:

static void Main( )
{
    stamp();
    int x = 3;
    Console.WriteLine("our program is here ....");
    Console.WriteLine(x+2);
    stamp();
}

תוצאת הפעלת הפעולה Main היא:

*********************************************
***********   Program By: Hammam. ***********
*********************************************
our program is here ....
5
*********************************************
***********   Program By: Hammam. ***********
*********************************************

(b) פעולות שאינן מקבלות קלט ומחזירות פלט:

נבנה פעולת "הטלת קובייה", והיא פעולה שאינה מקבלת קלט אבל מחזירה לנו ערך (נותנת פלט), והוא מספר אקראי מ-1 עד 6. ניתן לה למשל את השם zhr (מן המילה הערבית לקובייה).

מבנה הפעולה הוא:

static int zhr( )
{
    int n;
    Random rnd = new Random();
    n = rnd.Next(1, 7);
    return n;
}

• int — טיפוס הנתונים המוחזר.
• zhr — שם הפעולה.
• ( ) — סוגריים ריקים, כלומר הפעולה אינה מקבלת פרמטרים (אינה מקבלת קלט).
• return n; — הפעולה מחזירה ערך (הערך של n) מטיפוס int.

נכתוב את הפעולה הזאת כפעולה עצמאית מחוץ לתוכנית הראשית שלנו Main ולא בתוכה.

כעת, בכל פעם שנרצה להטיל קובייה ולקבל מספר אקראי מ-1 עד 6, נוכל לקרוא לפעולה zhr() בלי לתת לה קלט (אין לה קלט).

דוגמה:

static void Main( )
{
    int n;
    Console.Write("First attempt: ");
    n = zhr();
    Console.WriteLine(n);
    Console.Write("Second attempt: ");
    Console.WriteLine(zhr());
}

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

התוצאה תהיה:

First attempt: 1
Second attempt: 3

(c) פעולות שמקבלות קלט ואינן מחזירות פלט:

נבנה פעולה שמקבלת שני מספרים שלמים ומדפיסה את שני המספרים האלה ובינהם התו &

class Program
{
    static void PrntWithTav(int x, int y)
    {
        Console.WriteLine("{0}&{1}", x, y);
    }

    static void Main(string[] args)
    {
        PrntWithTav(7, -4);
    }
}

7&-4
Press any key to continue . . .

(d) פעולות שמקבלות קלט ומחזירות פלט:

למשל, אם נבנה את פעולת הערך המוחלט ונקרא לה Absolute, היא מקבלת מספר עשרוני ומחזירה את הערך המוחלט של המספר הזה.

Absolute(x) מחזירה את הערך המוחלט (מספר חיובי) של המספר העשרוני x .

יש להגדיר את הטיפוס של הערך שהפעולה מחזירה (int, double, char, …), אבל כאן הפעולה מחזירה מספר עשרוני (double) כי היא מקבלת מספר עשרוני.

את הפעולה Absolute נבנה כך:

static double Absolute(double x)
{
    if (x >= 0)
        return x;
    else
        return -x;
}

אפשר להפעיל אותה כך:

static void Main(string[] args)
{
    Console.WriteLine(Absolute(-4));
}

4
Press any key to continue . . .

תרגיל:

נבנה את הפעולה הבאה:

static int Elakbr(int x, int y)
{
    if (x > y)
        return x;   // it returns x because x is bigger
    else
        return y;   // it returns y because y is bigger or equal
}

אם נרצה להשתמש בפעולה הזאת (הפונקציה) ולקרוא לה באמצעות התוכנית הבאה:

static void Main(string[] args)
{
    Console.WriteLine("***");
    Elakbr(3, 6);               // it returns 6
    Console.WriteLine("+++");
    Elakbr(-1, -11);            // it returns -1
}

מה יופיע על המסך אחרי הפעלת התוכנית Main ?

התוצאה שתופיע על המסך היא:

***
+++
Press any key to continue . . .

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

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

static void Main(string[] args)
{
    int num;
    Console.WriteLine("***");
    num = Elakbr(3, 6);         // it returns 6
    Console.WriteLine(num);
    Console.WriteLine("+++");
    num = Elakbr(-1, -11);      // it returns -1
    num += 10;
    Console.WriteLine(num);
}

כעת מהי תוצאת הפעלת התוכנית?

התוצאה היא:

***
6
+++
9
Press any key to continue . . .

11.6 פעולות ופונקציות שמטפלות במערכים ובמחרוזות

11.6.1 הפעולות והמערכים

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

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

static void Example(int[] arr)
 {
     //כאן נכתוב את מבנה הפעולה
 }

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

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

static int[] Example()
 {
     int[] msfofa = new int[10];
     //כאן נכתוב את מבנה הפעולה
     return msfofa;
 }

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

בדוגמה ראינו מערכים מטיפוס מספר שלם int [ ], אבל יכולנו לגרום לפעולה לקבל כל טיפוס של מערך double [ ] ו-char [ ] וכו' .. וכך גם המערך המוחזר יכול להיות מכל טיפוס.

כדי להבין את הנושא הלכה למעשה נביא דוגמאות לכך בעמוד הבא

11.6.2 הפעולות והמחרוזות string

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

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

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

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

static double MaxInArray(double[] nums)
{
    double max = nums[0];
    for(int i=1; i<nums.Length;i++)
    {
        if (nums[i] > max)
            max = nums[i];
    }
    return max;
}

static void Main(string[] args)
{
    double[] a = new double[12];
    double max;
    for(int i=0;i<12;i++)
    {
        Console.Write("Insert a number: ");
        a[i] = double.Parse(Console.ReadLine());
    }
    max = MaxInArray(a);
    Console.WriteLine("The maximum in the array is: {0}",max);
}

Insert a number: 11
Insert a number: 4
Insert a number: -2.5
Insert a number: 17.4
Insert a number: 32
Insert a number: -90
Insert a number: 32.7
Insert a number: -70
Insert a number: 1
Insert a number: 0
Insert a number: -1
Insert a number: 2
The maximum in the array is: 32.7

using System;
namespace ConsoleApp1
{
    class Program
    {
        static int[] BuildArr(int n)
         {
             int[] fib = new int[n];
             if (n == 1) fib[0] = 1;
             else if (n == 2)
             {
                 fib[0] = 1;
                 fib[1] = 1;
             }
             else
             {
                 fib[0] = 1;
                 fib[1] = 1;

                 for (int i = 2; i < n; i++)
                 {
                     fib[i] = fib[i - 1] + fib[i - 2];
                 }
             }
             return fib;
         }

        static void PrntArr(int[] arr)
        {
            for(int i=0;i<arr.Length;i++)
            {
                Console.Write("{0}|",arr[i]);
            }
            Console.WriteLine();
        }
        static void Main(string[] args)
        {
            int num;
            Console.WriteLine("Insert a number: ");
            num = int.Parse(Console.ReadLine());
            int[] arr = new int[num]; // A
            arr = BuildArr(num);      // B
            PrntArr(arr);             // C
            // we can remove rows A,B,C and use row D
            PrntArr(BuildArr(num));   // D
        }
    }
}

static int Appearance(char tav, string sentence)
{
    int cnt = 0;
    for (int i = 0; i < sentence.Length; i++)
    {
        if (sentence[i] == tav)
            cnt++;
    }
    return cnt;
}
static void Main(string[] args)
{
    string se;
    char c;
    Console.Write("Insert a char: ");
    c = char.Parse(Console.ReadLine());
    Console.Write("Insert a sentence: ");
    se = Console.ReadLine();
    Console.WriteLine("The char {0} appears in {1} {2} times!",c,se,Appearance(c,se));
}

Insert a char: m
Insert a sentence: Hammam
The char m appears in Hammam 3 times!

11.7 סיכום ותרגילים פתורים

ולבסוף נביא סיכום של הכלל:

יש להכריז על הפעולה (להגדיר אותה) ולכתוב את פקודותיה כך:

static int AreaRec(int a, int b)
{
    int s;
    s = a*b;
    return s;
}

static double AreaTri(int x, int y)
{
    double s;
    s = (x * y) / 2.0;
    return s;
}

static void Main(string[] args)
{
    char tav;
    int num1, num2;

    Console.Write("Insert the first number: ");
    num1 = int.Parse(Console.ReadLine());
    Console.Write("Insert the second number: ");
    num2 = int.Parse(Console.ReadLine());
    Console.Write("Shape area: for rectangle insert r for triangle insert t");
    tav = char.Parse(Console.ReadLine());
    if(tav=='r')
        Console.WriteLine("The area is: {0}",AreaRec(num1,num2));
    else if(tav=='t')
        Console.WriteLine("The area is: {0}", AreaTri(num1, num2));
    else
        Console.WriteLine("you inserted wrong letter!");
}

using System;

namespace ConsoleApp109
{
    class Program
    {
        // Part (A) **************************************
        static bool IsBin(int num)
        {
            int digit;
            digit = num % 10;
            while (num > 0)
            {
                if (digit != 1 && digit != 0)
                {
                    return false;
                }
                num = num / 10;
                digit = num % 10;
            }
            return true;
        }
        // Part (B) **************************************
        static int Bin2Dec(int num)
        {
            int dig = 0, weight = 1, result = 0;
            if (IsBin(num))
            {
                while (num > 0)
                {
                    dig = num % 10;
                    result += dig * weight;
                    num = num / 10;
                    weight *= 2;
                }
                return result;
            }
            else
            {
                Console.WriteLine("It`s can`t be binary");
                return -1;
            }
        }
        // Part (c) ***************************************
        static string Dec2Bin(int num)
        {
            int d;
            string res = "";
            while (num > 0)
            {
                d = num % 2;
                res = d + res;
                num = num / 2;
            }
            return res;
        }
        // Part (d) ***************************************
        static void Main(string[] args)
        {
            char x;
            Console.WriteLine("Press d for decimal or b for binary");
            x = char.Parse(Console.ReadLine());
            if (x =='d')
            {
                Console.Write("Enter a decimal number: ");
                Console.WriteLine("The number in binary is: {0}",Dec2Bin(int.Parse(Console.ReadLine())));
            }
            else if (x=='b')
            {
                Console.Write("Enter a binary number: ");
                Console.WriteLine("The number in decimal is: {0}", Bin2Dec(int.Parse(Console.ReadLine())));
            }
            else
                Console.WriteLine("You must press d or b");
        }
    }
}