Docstoc

procedural

Document Sample
procedural Powered By Docstoc
					‫דורית כהן‬                                    ‫1‬                           ‫יסודות מדעי המחשב‬


            ‫פתרון בגרות 7002 – יסודות מדעי המחשב 222998‬
                                                                                  ‫שאלה 1‬

                  ‫פלט‬        ‫‪ b‬זוגי‬     ‫‪b‬‬        ‫‪k‬‬   ‫‪mul‬‬       ‫‪a‬‬     ‫ההוראה הבאה לביצוע‬
                                                                      ‫קלוט מספר למשתנה ‪a‬‬
                                                               ‫3‬                 ‫1← ‪mul‬‬
                                                      ‫1‬               ‫עבור ‪ k‬מ-1 עד ‪ a‬בצע‬
                                                 ‫1‬                    ‫קלוט מספר למשתנה ‪b‬‬
                                        ‫5‬                                    ‫אם ‪ b‬זוגי אזי‬
                              ‫שקר‬                                     ‫אחרת ‪mul←mul*b‬‬
                                                      ‫5‬                           ‫עבור ‪...k‬‬
                                                 ‫2‬                    ‫קלוט מספר למשתנה ‪b‬‬
                                        ‫8‬                                    ‫אם ‪ b‬זוגי אזי‬
                              ‫אמת‬                                         ‫2/‪mul←mul*b‬‬
                                                     ‫02‬                           ‫עבור ‪...k‬‬
                                                 ‫3‬                    ‫קלוט מספר למשתנה ‪b‬‬
                                        ‫4‬                                    ‫אם ‪ b‬זוגי אזי‬
                              ‫אמת‬                                         ‫2/‪mul←mul*b‬‬
                                                     ‫04‬              ‫הצג כפלט את הערך של‬
                                                                                       ‫‪mul‬‬
                  ‫04‬

                                                                            ‫הפלט יהיה: 04‬


                                                                                  ‫שאלה 2‬
                                                                                   ‫סעיף א:‬
            ‫פלט‬         ‫‪ x‬בין 05 ל-07‬       ‫0=>‪x‬‬     ‫‪x‬‬     ‫‪m‬‬        ‫ההוראה הבאה לביצוע‬
                                                                                    ‫0←‪m‬‬
                                                           ‫0‬          ‫קלוט מספר למשתנה ‪x‬‬
                                                     ‫01‬                   ‫כל עוד 0=>‪ x‬בצע‬
                                            ‫אמת‬                       ‫אם ‪ x‬בין 05 ל-07 אזי‬
                             ‫שקר‬                                      ‫קלוט מספר למשתנה ‪x‬‬
                                                     ‫46‬                   ‫כל עוד 0=>‪ x‬בצע‬
                                            ‫אמת‬                       ‫אם ‪ x‬בין 05 ל-07 אזי‬
                             ‫אמת‬                                                ‫1+‪m←m‬‬
                                                           ‫1‬          ‫קלוט מספר למשתנה ‪x‬‬
                                                     ‫15‬                   ‫כל עוד 0=>‪ x‬בצע‬
                                            ‫אמת‬                       ‫אם ‪ x‬בין 05 ל-07 אזי‬
                             ‫אמת‬                                                ‫1+‪m←m‬‬
                                                           ‫2‬          ‫קלוט מספר למשתנה ‪x‬‬
                                                     ‫03‬                   ‫כל עוד 0=>‪ x‬בצע‬
                                            ‫אמת‬                       ‫אם ‪ x‬בין 05 ל-07 אזי‬
                             ‫שקר‬                                      ‫קלוט מספר למשתנה ‪x‬‬
                                                     ‫4-‬                   ‫כל עוד 0=>‪ x‬בצע‬
                                            ‫שקר‬                    ‫הצג כפלט את הערך של ‪m‬‬
             ‫2‬

                                                                              ‫הפלט יהיה 2.‬
‫דורית כהן‬                                     ‫2‬                             ‫יסודות מדעי המחשב‬


                                       ‫סעיף ב: דוגמה לקלט שעבורו הלולאה לא תתבצע כלל: 5-‬
                      ‫ובתיאור כללי: לכל קלט שהוא מספר שלילי, הלולאה לא תתבצע כלל.‬
                        ‫(הסבר: תנאי הכניסה ללולאה לא מתקיים כבר בנתון הקלט הראשון)‬

         ‫סעיף ג: דוגמה לקלט שעבורו הלולאה תתבצע פעם אחת לפחות, ובסיום הביצוע הפלט יהיה 0 :‬
                                                       ‫5- 5 21 8 (משמאל לימין)‬
     ‫הסבר: תנאי הכניסה ללולאה אמנם מתקיים בשלושת שנתוני הקלט הראשונים, אך התנאי‬
‫הפנימי, שאמור לגרום להגדלת הערך של ‪ m‬שיוצג כפלט, לא מתקיים, כי אף אחד מנתוני הקלט‬
                                                               ‫לא נמצא בין 05 ל-07.‬


                                                                                      ‫שאלה 3‬
‫;)(‪Random rnd = new Random‬‬
‫;‪int eight = 0, k‬‬
‫)++‪for (k=0; k<36; k‬‬
‫{‬
       ‫;)31 ,5(‪numArr[k] = rnd.Next‬‬
       ‫)8 = = ]‪if (numArr[k‬‬
               ‫;++‪eight‬‬
‫}‬
‫;)"8 ‪Console.WriteLine ("in "+ eight + " cells of the array there is the number‬‬


                                                                                      ‫שאלה 4‬
                                                                              ‫‪ - i‬הזימון תקין.‬
 ‫‪ – ii‬הזימון תקין. הסבר (למרות שלא נדרש): נתון ש-‪ b‬הוא משתנה מטיפוס שלם, ולכן, ניתן להעבירו‬
                                                  ‫את ערכו לפרמטרים ‪ x‬ו- ‪ y‬של הפעולה...‬
‫‪ – iii‬הזימון לא תקין. הפעולה צריכה לקבל 3 ערכים לשלושת הפרמטרים שלה, אך בזימון זה מועבר רק‬
                                                                                ‫ערך אחד.‬
‫‪ – iv‬הזימון לא תקין. הפרמטר השני של הפעולה מוגדר כשלם, ולכן הוא חייב/יכול לקבל רק ערך שלם,‬
                                                       ‫ואילו בזימון זה מועבר לו ערך ממשי.‬
                                                                             ‫‪ – v‬הזימון תקין.‬


                                                                                      ‫שאלה 5‬
‫;0 = ‪int count‬‬
‫)++‪for (int k=0; k < st.Length-1; k‬‬
        ‫)' ' = =]1+‪if (st[k]= = 'Y' && st[k‬‬
                 ‫;++‪count‬‬
‫;)"‪Console.WriteLine (count + " words ends with Y‬‬
‫דורית כהן‬                                   3                            ‫יסודות מדעי המחשב‬


                                                                                  6 ‫שאלה‬
static void Main(string[] args)
// .100 -‫קלט: מדידות יומיות של טמפרטורות במשך תקופה, המסתיימות בטמפרטורה גדולה מ‬
//          .‫פלט: מספר הימים המקסימלי שעבר בין שתי מדידות של טמפרטורה זהה לראשונה‬
{
    double firstTemp, nextTemp;
    int diff = 0, max = 0;
    Console.WriteLine ("Enter first temperature (less than 100): ");
    firstTemp = double.Parse (Console.ReadLine());
    while (firstTemp<=100)
    {
         Console.WriteLine ("Enter next temperature (over 100 to quit): ");
         nextTemp= double.Parse (Console.ReadLine());
         while (nextTemp<=100 && nextTemp!=firstTemp)
         {
                  diff++;
                  Console.WriteLine ("Enter next temperature (over 100 to quit): ");
                  nextTemp=double.Parse(Console.ReadLine());
         }
         if (nextTemp<=100)
                  if (diff>max)
                           max=diff;
         diff = 0;
         firstTemp = nextTemp;
    }
    if (max>0)
         Console.WriteLine (max);
    else
         Console.WriteLine (-1);
}
      ‫דורית כהן‬                                ‫4‬                             ‫יסודות מדעי המחשב‬


                                                                                       ‫שאלה 7‬
                                                                                       ‫סעיף א:‬
                                                                      ‫מעקב עבור המערך הנתון ‪:a‬‬
         ‫3‬        ‫6‬       ‫-21‬        ‫-8‬       ‫-73‬           ‫-6‬       ‫2‬          ‫-9‬       ‫31‬


   ‫‪ n i a[i] a[i+1] a[i+2] ans‬הוראה לביצוע‬          ‫2-‪i<n‬‬    ‫)]2+‪(a[i+1]>a[i])&&(a[i+1]>a[i‬‬
‫;9=‪n‬‬
‫;0=‪ans‬‬          ‫9‬
‫;0=‪i‬‬                                    ‫0‬
‫)2-‪while (i<n‬‬     ‫0‬
‫.…‪if‬‬                 ‫3‬      ‫6‬    ‫21-‬                ‫‪true‬‬
‫;++‪ans‬‬                                                                    ‫‪True‬‬
‫;2+‪i=i‬‬                                  ‫1‬
‫)2-‪while (i<n‬‬     ‫2‬
‫.…‪if‬‬                ‫21-‬    ‫8-‬    ‫73-‬                ‫‪true‬‬
‫;++‪ans‬‬                                                                    ‫‪True‬‬
‫;2+‪i=i‬‬                                  ‫2‬
‫)2-‪while (i<n‬‬     ‫4‬
‫.…‪if‬‬                ‫73-‬    ‫6-‬      ‫2‬                ‫‪true‬‬
‫;2+‪i=i‬‬                                                                   ‫‪False‬‬
‫)2-‪while (i<n‬‬     ‫6‬
‫.…‪if‬‬                 ‫2‬     ‫9-‬     ‫31‬                ‫‪true‬‬
‫;2+‪i=i‬‬                                                                   ‫‪False‬‬
‫)2-‪while (i<n‬‬     ‫8‬
                                                    ‫‪false‬‬

                                    ‫לאחר הרצת קטע התכנית, יהיה ערכו של המשתנה ‪ ans‬שווה ל- 2.‬

                                                                                    ‫סעיף ב:‬
                    ‫עבור המערך ‪ a‬הבא, יהיה תוכן המשתנה ‪ ans‬שווה ל- 3 לאחר הרצת קטע התכנית :‬
         ‫3‬        ‫6‬         ‫-21‬       ‫-8‬       ‫-73‬       ‫-6‬       ‫21-‬         ‫-9‬      ‫31‬
‫דורית כהן‬                                   5                             ‫יסודות מדעי המחשב‬


                                                                                   8 ‫שאלה‬
                                                                                   :‫סעיף א‬
public static int Check(int standardDiameter, int numOfPkaks)
// ‫ט.כניסה: הפעולה מקבלת קוטר תקני של מכונה ואת מספר הפקקים שהיא ייצרה ביום אחד‬
// )‫ט.יציאה: יוחזר מספר הפקקים התקניים שייצרה המכונה ביום זה (על סמך הקטרים שייקלטו בפעולה‬
{
     int count = 0, madeDiameter;
     for (int k = 0; k < numOfPkaks; k++)
    {
         Console.WriteLine("Enter diameter of next pkak");
         madeDiameter = int.Parse(Console.ReadLine());
         if (Math.Abs(standardDiameter - madeDiameter) <= 1)
               count++;
     }
     return count;
 }

                                                                                   :‫סעיף ב‬

public static void SecondPart()
{
  int i, standardDiameter, pkaksMade;
  for (i = 1; i <= 50; i++)
  {
     Console.WriteLine("enter the standard diameter for machine no." + i);
     standardDiameter = int.Parse(Console.ReadLine());
     Console.WriteLine("enter the number of pkaks made by machine " + i);
     pkaksMade = int.Parse(Console.ReadLine());
     Console.WriteLine("Machine " + i + " made " + Check(standardDiameter,
                            pkaksMade));
}
‫דורית כהן‬                                    ‫6‬                            ‫יסודות מדעי המחשב‬


                                                                                   ‫שאלה 9‬
                                                                                   ‫סעיף א:‬
                                                                 ‫‪ - i‬הגדרת משתנים עיקריים:‬
                     ‫תפקיד‬                                 ‫טיפוס‬               ‫שם המשתנה‬
‫ישמור בכל מקום בין 1 ל-813 את שעת הכניסה של‬       ‫מערך של שלמים בגודל 913‬         ‫‪parking‬‬
‫הרכב שחונה בו, או 0 אם פנוי. מקום 0 ישמור את‬
‫סה"כ הכסף שנגבה במהלך היום עבור חניית מכוניות‬
                       ‫ישמור שעת כניסה של רכב‬                          ‫שלם‬          ‫‪timeIn‬‬
                       ‫ישמור שעת יציאה של רכב‬                          ‫שלם‬        ‫‪timeOut‬‬
                               ‫ישמור מקום חניה‬                         ‫שלם‬            ‫‪place‬‬
              ‫ישמור סכום לתשלום של מכונית אחת‬                          ‫שלם‬              ‫‪pay‬‬

                                                                     ‫‪ – ii‬פירוק לתת-משימות:‬
‫)‪public static void OpenDay(int[] parking‬‬
‫ט.כניסה: מקבלת מערך המייצג את הקופה ואת כל מקומות החניה //‬
‫ט.יציאה: מאפסת את הקופה ומסמנת את כל המקומות כפנויים //‬
‫{‬
    ‫)++‪for (int i = 0; i < parking.Length; i‬‬
        ‫;0 = ]‪parking[i‬‬
‫}‬

‫)‪public static void CarEntrance(int[] parking‬‬
‫//‬        ‫ט.כניסה: מקבלת את מגרש החניה. קולטת שעת כניסה של רכב בין 6 ל-22. הנחה: הקלט תקין.‬
‫ט.יציאה: מדפיסה מקום חניה שהיה פנוי לרכב הנכנס ומעדכנת את מגרש החניה. אם אין מקום-מודיעה //‬
‫{‬
    ‫;)")22-6( ‪Console.WriteLine("Enter entrance time‬‬
    ‫;))(‪int timeIn = int.Parse(Console.ReadLine‬‬
    ‫;1 = ‪int place‬‬
    ‫)0 =! ]‪while (place < parking.Length && parking[place‬‬
             ‫;++‪place‬‬
    ‫)1-‪if (place <= parking.Length‬‬
    ‫{‬
              ‫;‪parking[place] = timeIn‬‬
              ‫;)‪Console.WriteLine("Your parking place is: " + place‬‬
    ‫}‬
    ‫‪else‬‬
              ‫;)"‪Console.WriteLine("Sorry, we're full... come back another time‬‬
‫}‬

 ‫)‪public static void CarRelease(int[] parking‬‬
‫ט.כניסה: מקבלת את מגרש החניה. קולטת מספר מספר מקום חניה של רכב ושעת עזיבה. //‬
‫הנחות: הקלט תקין. מקום חניה בין 1 ל-813 ושעת עזיבה בין 7 ל-32 (כולל). //‬
‫//‬     ‫ט.יציאה: מדפיסה את הסכום לתשלום, מעדכנת את הקופה ומעדכנת את מגרש החניה.‬
‫{‬
    ‫;)"?)813-1( ‪Console.WriteLine("Where did you park your car‬‬
    ‫;))(‪int place = int.Parse(Console.ReadLine‬‬
    ‫;)"?)32-7(‪Console.WriteLine("What's the time now‬‬
    ‫;))(‪int timeOut = int.Parse(Console.ReadLine‬‬
    ‫;41 * )]‪int pay = (timeOut - parking[place‬‬
    ‫;)".‪Console.WriteLine("You have to pay " + pay + " sheqels‬‬
    ‫;‪parking[0] = parking[0] + pay‬‬
    ‫;0 = ]‪parking[place‬‬
‫}‬
‫דורית כהן‬                                    7                             ‫יסודות מדעי המחשב‬


public static void CloseDay(int[] parking)
//                                       .‫ט.כניסה: מקבלת את מגרש החניה והקופה‬
// .‫ט.יציאה: משחררת מכוניות אם עוד נמצאות בחניון. מדפיסה את סכום הגבייה היומי‬
{
     for (int i = 1; i < parking.Length; i++)
     {
         if (parking[i] != 0)
         {
              Console.WriteLine("Please release car in place " + i);
              CarRelease(parking);
         }
      }
     Console.WriteLine("Total amount collected today is: " + parking[0]);
}

public static void PrintMenu()
//                                          .‫ט.כניסה: אין‬
// .‫ט.יציאה: מודפס התפריט להפעלת התכנית/ניהול מגרש החניה‬
{
    Console.WriteLine("Enter your choice:");
    Console.WriteLine("1 if you want to enter, ");
    Console.WriteLine("2 if you want to leave,");
    Console.WriteLine("-1 if you want to close the parking lot");
 }

                                                                                    :‫סעיף ב‬
static void Main(string[] args)
//                                   .‫קלט: לכל רכב קוד פעולה. הנחה: הקלט תקין‬
//                  .‫פלט: לכל רכב נכנס – מקום חניה מתאים או הודעה אם אין מקום‬
// .‫לכל רכב יוצא – סכום לתשלום. ובסוף היום – סה"כ הכסף שנגבה במהלך היום‬
{
    int[] parking = new int[319];
    int code;

    OpenDay(parking);
    PrintMenu();
    code = int.Parse(Console.ReadLine());
    while (code != -1)
    {
           if (code == 1)
              CarEntrance(parking);
           else
              CarRelease(parking);
           PrintMenu();
           code = int.Parse(Console.ReadLine());
    }
    CloseDay(parking);
}
‫דורית כהן‬                                    ‫8‬                             ‫יסודות מדעי המחשב‬


                                                                                   ‫שאלה 01‬
                                                                                    ‫סעיף א:‬
‫)‪public static int Seven(int[] a‬‬
‫//‬                                                         ‫ט.כניסה: מערך של שלמים.‬
‫ט.יציאה: יוחזר 1 אם יש במערך 7 איברים ברצף שערך כל אחד מהם הוא אפס, אחרת יוחזר 0. //‬
‫{‬
         ‫;0 = ‪int i=0, count‬‬
         ‫)7 =! ‪while (i < a.Length - 1 && count‬‬
         ‫{‬
            ‫)]1 + ‪if (a[i] == 0 && a[i] == a[i‬‬
               ‫;++‪count‬‬
            ‫;0 = ‪else count‬‬
            ‫;++‪i‬‬
         ‫}‬
         ‫;1 ‪if (count == 7) return‬‬
         ‫;0 ‪else return‬‬
‫}‬

                                                                                    ‫סעיף ב:‬
‫)‪public static void Shift(int[] a, int k‬‬
‫//‬                                     ‫ט.כניסה: מערך של שלמים ומספר שלם נוסף בין 1 ל-4.‬
‫ט.יציאה: בוצעה הזזה שמאלה של ערכי המערך לפי המספר שהתקבל. במקומות הימניים הוצב 0.//‬
‫{‬
         ‫;‪int i‬‬
         ‫)++‪for (i = 0; i < a.Length-k; i‬‬
            ‫;]‪a[i] = a[i + k‬‬
         ‫)++‪for (i = a.Length - k ; i < a.Length; i‬‬
            ‫;0 = ]‪a[i‬‬
‫}‬

                                                                                    ‫סעיף ג:‬
‫)‪static void Main(string[] args‬‬
‫קלט: נתון מערך בגודל 501 המכיל מספרים שלמים. אם אין בו 7 איברים ברצף שערכם 0, ייקלט //‬
‫//‬     ‫מספר שלם בין 1 ל-4 (כולל), עד שיהיו לפחות 7 איברים ברצף שערכם 0. הנחה: קלט תקין‬
‫//‬                      ‫פלט: המערך לאחר כל ההזזות. התכנית משתמשת בפעולת עזר שתוגדר בהמשך‬
‫שימו לב: לצורך הרצה יש להגדיר את המערך ולקלוט לתוכו ערכים, אך לפי השאלה הוא כבר נתון // {‬
         ‫;‪int k‬‬
         ‫)1 =! )‪while (Seven(a‬‬
         ‫{‬
            ‫;)"?‪Console.WriteLine("How many places to shift to the left‬‬
            ‫;))(‪k = int.Parse(Console.ReadLine‬‬
            ‫;)‪Shift(a, k‬‬
         ‫}‬
         ‫;)‪PrintArray(a‬‬
 ‫}‬

‫)‪public static void PrintArray(int[] a‬‬
‫פעולת עזר: הפעולה מדפיסה את ערכי המערך שקיבלה כפרמטר //‬
‫{‬
        ‫)++‪for (int i = 0; i < a.Length; i‬‬
           ‫;)"," + ]‪Console.Write(a[i‬‬
        ‫;)(‪Console.WriteLine‬‬
‫}‬

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:11/21/2011
language:Hebrew
pages:8