פתרון 2000 א. טבלת מעקב אחר ביצוע האלגוריתם הנתון עבור הערכים : פלט num = 37, sif = 7 r האם ספרת האחדות של sif שווה ל- num num 37 sif 7 שורה (1)-(2) (

תמליל

1 פתרון 000 א. טבלת מעקב אחר ביצוע האלגוריתם הנתון עבור הערכים : num = 3, sif = r האם ספרת האחדות של sif שווה ל- num num 3 sif (1)-() (3) () אמת ) = ( 3 3 יודפס: 3. ב. פתרון שאלה 11 עבור הערכים: עבור סעיף ב : = sif,num = 5, תתבצע שורת האלגוריתם )3.1( ויודפס.5 r האם ספרת האחדות של sif שווה ל- num num 5 sif (1)-() (3) () אמת ) = ( 5 5 כדי שתתבצע שורת האלגוריתם (3.1) התנאי צריך להתקיים, כלומר ספרת האחדות של num צריכה להיות זהה ל- sif מ. אחר וספרת האחדות של 5 היא התנאי מתקיים. ג. עבור הערכים: עבור סעיף ג : = 1 sif,num = 5, תתבצע שורת האלגוריתם )3.( ויודפס.3 r האם ספרת האחדות של sif שווה ל- num num 5 sif 1 (1)-() (3) () ) 3 = 1 ( + שקר 1) = ( 3 כדי שתתבצע שורת האלגוריתם (3.) התנאי לא צריך להתקיים, כלומר ספרת האחדות של num צריכה להיות שונה מ-.sif מאחר וספרת האחדות של 5 היא התנאי לא מתקיים. 1 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

2 פתרון שאלה 1 א. טבלת מעקב אחר ביצוע האלגוריתם הנתון עבור : הערכים יודפס: x=, y=3 pull x y 3 5 x > y (1)-()-(3) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) () (5) אמת (3<) אמת (<) אמת (5<) שקר (<) ב. הלולאה לא תתבצע כלל עבור הערכים: = 8 y x. =, במקרה זה יודפס: טבלת מעקב אחר ביצוע האלגוריתם הנתון עבור : הערכים = 8 y x =,.0 8 pull 0 x y 8 x > y (1)-()-(3) () (5) שקר (8<) 0 8 יודפס:.0 8 כדי שהלולאה לא תתבצע כלל צריך תנאי הלולאה ב-( ) לא להתקיים כבר בפעם הראשונה. לכן הקלט צריך להיות כזה כך ש- y x. => במקרה זה pull לא מתעדכן כלל ונשאר 0, וכן המשתנים x ו- y נשארים זהים לקלט. פתרון שאלה 13 n = 3 n = טבלת מעקב עבור האלגוריתם של זיו טבלת מעקב עבור האלגוריתם שלזיו n i 1 3 b n i b (1) ()-(.1)-(.) ()-(.1)-(.) (1) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) 3 1 האלגוריתם של זיו מבצע את הנדרש. עבור כל ערך שלn, הלולאה מתבצעת n פעמים, כלומר יודפסו n ערכים כפי. שצריךb המודפס למעשה גדל תמיד ב-. 1 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

3 טבלת מעקב אחר ביצוע האלגוריתם שללילך עבור: = n n x 0 x < n * אמת (*>0) אמת (*>) שקר (*>) טבלת מעקב אחר ביצוע האלגוריתם שללילך עבור: = 3 n n 3 x 0 x < n * אמת (*3>0) אמת (*3>) שקר (*3>) שקר (*3>) (1)-() (3)-(3.1)-(3.) (3)-(3.1)-(3.) (3) (1)-() (3)-(3.1)-(3.) (3)-(3.1)-(3.) (3)-(3.1)-(3.) (3) האלגוריתם שללילךמבצע את הנדרש. עבור כל ערך שלn, הלולאה מתבצעתn פעמים, כלומר יודפסוn ערכים כפי שצריך. x המודפס גדל תמיד ב- ואז מודפס. בפעם האחרונה שהלולאה מתבצעתx<*n, אך גדל בפנים בדיוק לערך האחרון : הנכון *n ומודפס. על פי דרישות השאלה מספיקה טבלת מעקב אחת עבור כל. אלגוריתםמאחר ועל פי מטרת האלגוריתם יתכן שיהיה הבדל ביןn זוגי ל- n אי-זוגי, מוטב לבדוק עבור קלטים. כאלו פתרון שאלה 1 טבלת משתנים שם המשתנה a i טבלת תת-משימות מערך חד מימדי מטרת תת -המשימה /תפקיד אחסון נתונים נדרשים מציין במערךa לולאה השמת ערכים אקראיים בתחום 1-0 בתאי המערך לולאה הדפסת איברי המערך מן הראשון עד לאחרון לולאה הדפסת איברי המערך מן האחרון ועד הראשון סוג הפעולה אלגוריתם לפתרון הבעיה עבורi מ- 0 עד 99 בצע )1( צור מספר אקראי בתחום בין 1 ל- 0 והשם אותו ב-[ i ] a )1.1( הצג כ 'אברי המערך מן הראשון לאחרון :' )( עבורi מ- 0 עד 99 בצע )3( הצג כ את [i] a )1.3( הצג כ 'אברי המערך מן האחרון לראשון :' )( )5( עבורi מ- 99 עד 0 בצע )1.5( הצג כ את [i] a מימוש האלגוריתם שלמים פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

4 א) ב) ג) ד) ב) // q1t00.c /* /* קלט: הגדרת מערך חד-מימדי בגודל 100 */ /* : התכנית משימה ערכים אקראיים בתחום 0..1 במערך, using System; ומדפיסה אותו לפי הסדר מראשון לאחרון ומאחרון לראשון */ /* public static void Main() int a = new a[100]; int i; Random rnd = new Random(); i++) for ( i = 0; i < a.length; */ לולאה לבניית המערך /* 1); rnd.next(1, a [i] = */ הגרלת ערך בתחום 1..0 והשמתו במערך /* Console.WriteLine ("The array elements from first to last : \n"); */ הדפסת המערך מראשון עד אחרון /* i++) for ( i = 0; i <a.length; Console.Write (a[i] + " "); Console.WriteLine ("\nthe array elements from last to first : \n"); */ הדפסת המערך מאחרון עד ראשון /* i--) for ( i = a.length - 1; i >= 0; Console.Write (a[i] + " "); מחזירה הפעולה (y Random.Next(x, חום יש לייצר מספרים אקראיים שלמים בת ערכים שלמים מ- x )כולל( ועדy )לא כולל(. כל לולאת for בלולאה בסדר יורד. הלולאה פועלת בדיוק כמו פעמים רבות לא משתמשים ב- 1. רגילה, אלא שבכל פעם קטן ערכו שלi פתרון נוסף: ניתן לכתוב את הלולאה היורדת גם ללא שימוש בלו לאת for עם מציין יורד, אלא על ידי שימוש בלולאת while עם מונה ידני יורד : i = a.length - 1; */ הדפסת המערך מאחרון עד ראשון /* ) 0 >= i while ( Console.Write (a[i] + " "); הכללת i --; בשאלה בה יש דרישה לפיתוח ויישום של אלגוריתם יש לפעול על פי השלבים הבאים: חלוקה לתת-משימות. ) הגדרת משתנים עיקריים. ) פיתוח אלגוריתמים לתת-המשימות. ) מימוש האלגוריתם על ידי תכנית. ) ) יכולים להיות חלופיים. השלבים )א( בדרך כלל אין דרישה לכתוב אלגוריתם וגם תכנית אך אם כתוב פתח ויישם ללא הקלות יש לכתוב את שניהם. בבעיות מורכבות המופיעות בדרך כלל בחלק ג של הבחינה תמומש כל תת-משימה על תכניות לכל תת- משימה כי הן מסרבלות את ידי פונקציה. בשאלות קטנות אין צורך להגדיר תת- )אך ניתן לעשות זאת(. 19 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

5 פתרון שאלה 15 טבלת משתנים שם המשתנה num1 num i /תפקיד מספר ראשון בזוג המושווה מספר שני בזוג המושווה קלט אחריnum1 מונה לולאה מונה קלטים שלמים שלמים טבלת תת-משימות מטרת תת -המשימה קליטת האיבר הבא, השוואה, לקודמו אם הוא גדול יותר, להדפיסו החלפת סדר המשתנים. אלגוריתם לפתרון הבעיה קלוט מספר למשתנה num1 )1( עבורi מ- עד 100 בצע )( קלוט מספר למשתנה num )1.( אזי אם num > num1 ).( הצג כ את num )1..( ב- num1 השם את num )3.( סוג הפעולה לולאה // q15t00.c public static void Main() int i, num1, num; /* /* מימוש האלגוריתם /* קלט: 100 מספרים שלמים /* : מספרי הקלט הגדולים מן המספר שנקלט לפניהם */ קלט נתון ראשון /* int.parse(console.readline()); num1 = */ לולאה לקליטת שאר 99 הנתונים /* ) i++ for ( i = 1; i < 100; */ קלט נתון שני /* int.parse(console.readline()); num = */ אם הקלט האחרון גדול מקודמו /* ) num1 if ( num > */ אזי הדפס את הקלט האחרון /* \n"); Console.WriteLine (" --> " + num + " /* "גלגל" את הנתונים האחרון הופך להיות ה"לפני אחרון */ num; num1 = מאחר והנתון הראשון נקלט מחוץ ללולאה, יש לבצע את הלולאה פעם אחת פחות בכדי לקלוט 100 נתונים. תבנית "גילגול" המשתנים חוזרת על עצמה בבעיות רבות. כדי להשוות בין כל זוג של איברים, בכל פעם מעבירים את "האחרון" להיות "הלפני אחרון " וקולטים "אחרון" חדש. ראה במעקב בטבלת המעקב הבאה עבור קלט של נתונים בלבד משמאל לימין : 1,3.,,,, i num1 num num > num1 130 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

6 (1) ()-(.1)-(.) (.3) ()-(.1)-(.) (.3) ()-(.1)-(.) (.3) ()-(.1)-(.) (.3) ()-(.1)-(.) (.3) אמת (3<) שקר (<) אמת (<) אמת (<) שקר (<1) שים : "גילגול" טעות נפוצה הנתונים חייב להתבצע בכל מקרה לכן אסור שיהיה בתוך. התנאי ביצוע קלט של זוג נתונים בתוך הלולאה והשוואה ביניהם. במקרה כזה ההשוואה היא רק בין צמדים ולא בין כל הזוגות בקלט. כל נתון צריך להיות מושווה לקודמו! )גם השלישי לשני(. פתרון שאלה 1 א. טבלת מעקב אחר ביצוע האלגוריתם I n sum gil )gil < 1( או )gil > ( אמת (אמת או אמת) (<15 או 1>15) אמת (אמת או אמת) (<10 או 1>10) אמת (אמת או שקר) (<19 או 1>19) אמת (אמת או שקר) (<18 או 1>18) אמת (אמת או אמת) (< או 1>) אמת (אמת או שקר ( (<1 או 1>1) אמת (אמת או אמת) (<8 או 1>8) (1) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) (3) אלגוריתם זה מונה ומדפיס למעשה את מספר הקלטים שהוא n. כל מספר שייקלט יהיה גדול מ- או קטן מ- 1. לכן אלגוריתם זה לא מבצע את המטרה בשאלה. 131 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

7 חמה טבלת מעקב אחר ביצוע האלגוריתם II n sum 0 1 gil )gil < 1( וגם )gil > ( אמת (אמת וגם אמת) (<15 וגם 1>15) אמת (אמת וגם אמת) (<10 וגם 1>10) שקר (אמת וגם שקר) (<19 וגם 1>19) שקר (אמת וגם שקר) (<18 וגם 1>18) אמת (אמת וגם אמת) (< וגם 1>) שקר (אמת וגם שקר) (<1 וגם 1>1) אמת (אמת וגם אמת) (<8 או 1>8) (1) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) ()-(.1)-(.) (3) אלגוריתם זה כן מונה ומדפיס כמה תלמידים הם בין הגילים עד 1 )לא כולל(. גיל שיענה על התנאי הכפול ויביא לקידום המונה עונה למעשה על התנאי : ) > )gil וגם )1 < )gil ללא שוויון באף קצה. המקרה היחיד בו ערכו של תנאי מורכב עם הקשר או יהיה שקר הוא כאשר כל שים מרכיביו הם שקר. המקרה היחיד בו ערכו של תנאי מורכב עם הקשרוגם יהיה אמת הוא כאשר כל מרכיביו הם אמת. פינה הקשר הלוגי המתקיים בין תנאים מכוננים הוא קשרוגם, יש להקפיד ולהתייחס כך לחישוב ערכי הביטוי. הלוגי ב. פיתוח ויישום של האלגוריתם טבלת משתנים שם המשתנה /תפקיד n מספר נתוני הגילים המתקבלים חיובי sum מונה מספר התלמידים שגילם בין ל- 1 לא כולל 0..n חיובי gil קלט תורן של גיל תלמיד max הגיל המקסימלי המתקבל מן הקלט בטווח הגילים בין ל- 1, לא כולל..15 טבלת תת-משימות מטרת תת -המשימה סוג הפעולה לולאה ביצוע לולאה עבורn קלטים תנאי מניית הגילים העונים על התנאי השמה בתוך תנאי עדכון המקסימלי מבין הנתונים העונים על התנאי תנאי מחוץ ללולאה הדפסת המקסימלי אם התקבל 13 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

8 אלגוריתם לפתרון הבעיה אתחל את sum ל- 0 )1( אתחל את max ל- 0 )( פעמים: בצע n )3( קלוט מספר למשתנה gil )1.3( אזי אם ( > )gil וגם )gil<1( ).3( הגדל אתsum ב- 1 )1..3( אזי אם gil>max )..3( השם ב- max )1...3( הצג כ 'מספר התלמידים בתחום הוא : ' sum, )( אזי אם > 0 max )5( הצג כ )1.5( את gil 'הערך הכי גדול בתחום הוא : ' max, שים טעות נפוצה האלגוריתם בנוי על אלגוריתם II מן השאלה. אלגוריתם זה עונה על תנאי המניה. התנאי. כמו כן בתוך התנאי יש כאן הוא תנאי מורכב עם הקשר הלוגי וגם במקום תנאי מכונן בדיקה ועדכון של המקסימלי, והדפסתו בתום תהליך הקלט אם קיים. פתרון נקי חייב לקחת בחשבון את המקרה בו לא התקבל כלל ערך בתחום הנדרש. במקרה כזה אין להדפיס את המקסימלי אחרת יודפס ערך האתחול שלו 0. היא רק על ערכים בתחום, בדיקת המקסימלי טעות לבדוק את המקסימלי לגבי כל קלט הנדרש. מימוש האלגוריתם // q1t00.c /* קלט: n גילים של תלמידים */ /* : מספר התלמידים בין הגילים ל- 1 לא כולל, והמקסימליביניהם */ void public static Main() int n, sum, max, gil, i; */ קליטת מספר הגילים /* int.parse(console.readline()); n = /* אתחול מונה מספר התלמידים בתחום */ ;0 = sum */ אתחול הגיל המקסימלי בתחום /* 0; = max */ לולאת קלט וטיפול בכל גיל /* ) i++ for ( i = 0; i < n; */ קלט גיל תורן /* int.parse(console.readline()); gil = */ תנאי על תחום הגילים הנדרש /* 1)) < (gil if ( (gil > ) && /* קידום מונה התלמידים בתחום */ ;++ sum */ בדיקה ועדכון של המקסימלי בתחום /* max) if (gil > max = gil; Console.WriteLine ("The number of students in age between to 1 is 0 \n", sum); /* /* של המונה */ מקסימלי אם קיים /* 0) > (max if Console.WriteLine ("The max age between -15 is 0 \n", max); 133 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

9 פתרון שאלה 1 טבלת משתנים שם המשתנה a i k sum1 sum /תפקיד מערך הנתונים בגודל 80 מציין בתוך מערךa מספר מציין בתחום המערך סכוםk האיברים הראשונים במערך סכום שאר האיברים במערך טבלת תת-משימות סוג הפעולה מטרת תת-המשימה לולאת מונה קליטת 80 ערכים למערך קליטתk כולל בדיקת תקינות המשך קלט עד לקבלת קלט תקין לולאת תנאי חישוב סכוםk המספרים הראשונים במערך לולאת מונה לולאת מונה חישוב סכום יתר המספרים במערך תנאי השוואה בין הסכומים והצגת הודעה ב אלגוריתם לפתרון הבעיה עבורi מ- 0 עד 9 בצע )1( קלוט מספר למשתנה [i] a )1.1( קלוט מספר למשתנה k )( בצע 9( > k ) כל עוד ( 0 < k ) או )3( קלוט מספר למשתנה k )1.3( אתחל את sum1 ל- 0 )( ) בצע עבורi מ- 0 עד 1( - k )5( ב- [i] a הגדל את sum1 )1.5( אתחל את sum ל- 0 )( 9 בצע עד עבורi מ- k )( ב- [i] a הגדל את sum )1.( אזי אם sum1 > sum )8( )1.8( הצג כ: sum1 טעות נפוצה יש לבצע בדיקת תקינות על הקלט k. טווח הערכים שלו הוא בין הקצוות בהחלט תקינים: עבור = 0 k יש 0 איברים בחלק הראשון ו- 80 איברים בחלק השני; עבור 9 = k יש 80 איברים בחלק הראשון ו- 0 איברים בחלק השני. לולאת הקלט ב- 3 תתבצע שוב ושוב כל עוד הערך יהיה קטן מן הנדרש או גדול מן. הנדרש יש לשים לב שהלולאה הראשונה מסתיימת באיבר שמספרו הסידורי )1-k( והלולאה השנייה מתחילה באיבר שמספרו הסידוריk, אחרת האיבר שמציינו k ייצבר בשני הסכומים. 13 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

10 מימוש האלגוריתם // q1t00.c /* קלט: מערך בגודל 80 ומציין k במערך */ /* : הדפסת סכוםk האיברים הראשונים במערך אם הוא גדול מסכוםk האיברים האחרונים */ public static void Main() int a[] = new int[80]; int k, i; */ אתחול סכום "האיברים הראשונים " וסכום "שאר האיברים" במערך /* 0; = sum int sum1 = 0, */ קלט למערך /* i++) for (i = 0; i < a.length; a[i] = int.parse(console.readline()); Console.WriteLine ("Enter k : "); /* קליטתk עד לקבלת ערך בתחום הנדרש */ int.parse(console.readline()); k = while ( (k < 0) (k >= 80) ) Console.WriteLine ("Enter k : "); k = int.parse(console.readline()); */ לולאה לצבירת הסכום של האיברים הראשונים במערך /* i++) for (i = 0; i < k; sum1 += a [i]; */ לולאה לצבירת הסכום של שאר המערך /* i++) for (i = k ; i < a.length; sum += a [i]; */ השוואה הסכומים ו נדרש /* sum) if (sum1 > Console.WriteLine ("%d \n", sum1); שים : אם = 0 k אזי הלולאה הראשונה צריכה להתבצע בין 1 ל- 0, מאחר וזה טווח לא חוקי היא לא תתבצע כלל וערכו שלsum1 יישאר 0 כפי שצריך. 135 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

11 פתרון שאלה 18 טבלת משתנים שם המשתנה num counter price sum /תפקיד מספר אישי של תלמיד -קלט מונה את מספר התלמידים היוצאים לטיול מחיר מחושב לתלמיד לפי כמות התלמידים סך כל הוצאות ביה"ס עבור הטיול ,10,150 חיובי טבלת תת-משימות מטרת תת -המשימה סוג הפעולה לולאת זקיף קליטת המספרים האישיים של התלמידים ומניית מספר היוצאים תנאי מקונן בדיקת המחיר לתלמיד על פי מספר היוצאים השמה חישוב הסכום הכולל הדפסה הדפסת מספר התלמידים,המחיר לתלמיד ומחיר הטיול תנאי בדיקת חריגה מתקציב ביה "ס והדפסה בהתאם אלגוריתם לפתרון הבעיה ב- counter השם 0 )1( קלוט מספר אישי למשתנהnum )( בצע וגם num( <= )1000 כל עוד 5000( )num<= )3( ב- 1 הגדל את counter )1.3( קלוט מספר אישי למשתנהnum ).3( אזי אם <= 100 counter )( ב- price השם 150 )1.( אחרת אזי אם <= 00 counter ).( ב- price השם 10 )1..( אחרת ב- price השם 100 )..( ב- sum counter*price השם )5( הצג כ 'מספר התלמידים שנרשמו לטיול : ', counter )( הצג כ 'המחיר לתשלום לתלמיד: ', price )( הצג כ 'עלות הטיול הכוללת: ' sum, )8( אזי אם < sum 5000 )9( הצג כ 'יש חריגה מן התקציב ב-:', (5000 )sum )1.9( 13 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

12 מימוש האלגוריתם /* קלט: מספרים אישיים של תלמידי ביה "ס היוצאים לטיול */ /* : מספר התלמידים, שנרשמו מחיר לתלמיד, עלות */ /* /* כוללת לטיול, חריגה מן התקציב אם יש // q18t00.c void main() int counter, num, price, sum; */ אתחול מונה מספר התלמידים /* 0; = counter Console.WriteLine ("Enter student numbers:"); /* קליטת מספר אישי של תלמיד */ int.parse(console.readline()); num = /* כל עוד המספר האישי הנקלט בתחום */ num)&&(num<=5000)) while =>1000)) /* קדם את מונה התלמידים */ ;++ counter /* קליטת מספר אישי של תלמיד */ int.parse(console.readline()); num = */ אם מספר התלמידים קטן או שווה ל /* 100) <= (counter if /* המחיר לתלמיד הוא 150 ש "ח */ ;150 = price else /* אם מספר התלמידים גדול מ -100 אך קטן או שווה 00 */ (00 => (counter if /* המחיר לתלמיד הוא 10 ש "ח */ ;10 = price else /* אם מספר התלמידים הוא מעל 00 המחיר לתלמיד הוא 100 ש "ח */ ;100 = price */ חישוב עלות הטיול הכוללת /* price; sum = counter * */ הדפסת מספר התלמידים counter);/* Console.WriteLine ("number of students: 0\n", */ הדפסת המחיר לתלמיד /* price); Console.WriteLine ("price for student : 0 \n", */ הדפסת הסכום הכולל /* sum); Console.WriteLine ("total sum is : 0 \n", /* אם יש חריגה מן התקציב, הדפס אותה */ (5000 > (sum if Console.WriteLine ("There is an exception of : %d \n", (sum )); שים טעות נפוצה בשאלה מצוין במפורש תנאי סיום הקלט: " הקליטה תסתיים כאשר מספר התלמיד הנקלט הוא מחוץ לתחום", כלומר לא ערך מסוים המשמש כזקיף. לכן תנאי הלולאה צריך להיות: "כל עוד נקלט מספר בתחום המשך לבצע". הקשר הלוגי בין התנאים חייב להיות 'וגם' כדי לתאר מספר בתחום. מבנה התנאי מתבסס על שימוש בתנאי מ קונן כלומר שימוש ב.else במבנה זה אין צורך להשתמש בתנאי מורכב. אם משתמשים בתנאים פשוטים באופן לא מ קונן תתקבל טעות. למשל אם רושמים את התנאים באופן הבא: if ( counter <= 100 ) price = 150; if ( counter <= 00 ) price = 10; עבור ערך הקטן מ- 100, יתקיים התנאי הראשון וגם התנאי השני אחריו, והערך הסופי של price יהיה 10 במקום.150 אם כותבים תנאים לא מקוננים הם חייבים להיות מורכבים למשל: if (counter <= 100) price = 150; if ( (counter > 100) && (counter <= 00) ) price = 10; 13 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

13 א. פתרון שאלה 19 פיתוח ויישום של פונקציה שמקבלת מספר תלת ספרתי ומחזירה את המשקל שלו טבלת משתנים לפונקציה numbe rweight /תפקיד שם המשתנה פרמטר, מספר תלת-ספרתי num 0..9 num ספרת האחדות של תחום dig num ספרת העשרות של תחום dig 0..9 num ספרת המאות של תחום dig3 טבלת תת-משימות לפונקציה numberweight סוג הפעולה מטרת תת-המשימה חישוב פירוק ספרת האחדות חישוב פירוק ספרת העשרות חישוב פירוק ספרת המאות חישוב הרכבת המשקל של הפרמטר אלגוריתם לפתרון הפונקציה השם את ספרת האחדות ב- dig1 )1( השם את ספרת העשרות ב- dig )( השם את ספרת המאות ב- dig3 )3( החזר את dig3 * dig + dig * dig1 )( מימוש הפונקציה public static int numberweight(int num) /* טענת כניסה : הפונקציה מקבל מספר תלת-ספרתי */ num /* טענת יציאה : הפונקציה מחזירה את המשקל שלnum */ int dig1, dig, dig3; */ פירוק ספרת האחדות /* 10; dig1 = num % */ פירוק ספרת העשרות /* 10; 10) % / (num dig = */ פירוק ספרת המאות /* 100; / num dig3 = */ החזרת משקל המספר /* dig1)); return ((dig3 * dig) + (dig * ב. פיתוח ויישום של אלגוריתם שמקבל מספרים תלת ספרתי ומחשב את המשקל שלהם טבלת משתנים לתכנית הראשית שם המשתנה number sum /תפקיד נתון קלט תורן מספר תלת-ספרתי סכום המשקלים של משתני הקלט פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

14 טבלת תת-משימות מטרת תת -המשימה סוג הפעולה לולאת תנאי קליטת מספרים תלת -ספרתיים עד שסכום משקליהם עולה על 100 פונקציה חישוב "משקל" של מספר אלגוריתם לפתרון הבעיה ב- sum השם 0 )1( בצע כל עוד sum<= 100 )( קלוט מספר תלת-ספרתי למשתנה number )1.( הגדל אתsum ב- "משקל" המספר number ).( הצג כ את סכום המשקלים שהתקבל ב- sum )3( /* מימוש האלגוריתם /* קלט: מספרים תלת ספרתיים */ /* : הדפסת סכום המשקלים של מספרי הקלט עד שהוא עולה על */ 100 /* הגדרה של משקל: )מכפלת ספרה ראשונה בספרה ) שנייה+ )מכפלת ספרה שניה בספרה שלישית ) // q19t00.c */ הפונקציה מסעיף א /* num) public static int numberweight (int int dig1, dig, dig3; dig1 = num % 10; dig = (num / 10) % 10; dig3 = num / 100; return ((dig3 * dig) + (dig * dig1)); public static void Main() int number, sum = 0; /* אתחל הסכום ל 0- */ */ כל עוד הסכום קטן או שווה ל /* 100) <= (sum while Console.WriteLine ("Enter number : \n"); */ קלוט נתון תורן /* int.parse(console.readline()); number = /* הוסף את משקל הנתון התורן לסכום המצטבר */ (number); sum =+ numberweight */ הדפס את הסכום שהתקבל /* sum); Console.WriteLine ("The weights sum is: 0\n", הלולאה הראשית באלגוריתם היא לולאת תנאי. למרות שבכל ביצוע של הלולאה יש קלט של נתון חדש אין זו לולאת זקיף. סיום הלולאה אינו מותנה בקבלת קלט חריג )זקיף( אלא בקיום תנאי על הסכום המצטבר של "משקלי" מספרי הקלט. על פי נתוני השאלה "הקליטה תסתיים כאשר סכום המשקלים יהיה גדול מ- 100" כלומר בפעם הראשונה שסכום המשקלים גדול מן הערך 100 תיפסק קליטת הנתונים. מכאן שאם הסכום האחרון עדיי ן קטן או שווה ל- 100, יש לקלוט מספר חדש ולהוסיף את משקלו לסכום. 139 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

15 א. פתרון שאלה 0 פיתוח ויישום של פונקציה שמקבלת כקלט מערך בן 10 איברים... טבלת משתנים לפונקציה up1 )גרסת פתרון 1( שם המשתנה a i מערך /תפקיד פרמטר, מערך בן 10 איברים מציין המתקדם על המערך שלמים 0..9 ok מסמן האם המערך עולה או לא -דגל. כל זמן שחלק המערך הנבדק הוא עולה יהיה ערכו 1, כאשר מתגלה כי המערך אינו עולה יהיה ערכו 0. 1, 0 אלגוריתם לפתרון הבעיה מערך עולה )a( */ /* טענת כניסה: הפעולה מקבלתמערך חד-מימדי בגודל 10 של מספרים שלמים */ /* טענת יציאה: הפעולהמחזירה 1 אם המערך ממוין בסדר עולה ו 0 אחרת ב- ok השם 1 )1( ב- i השם 1 )( בצע ok כל עוד ( 10 < i ) וגם )3( אזי אם a[i+1] a[i] >= )1.3( ב- ok השם 0 )1.1.3( אחרת ב- 1 הגדל את i ).1.3( החזר את ok )( מימוש האלגוריתם /* טענת כניסה: הפונקציה מקבלת מערך חד-מימדיa בגודל 10 (a public static int up1(arr */ /* טענת יציאה: הפונקציה מחזירה'אמת' אם המערך עולה ו'שקר' אחרת */ int i, ok; */ אתחול הדגל ל 'אמת ' /* 1; = ok */ אתחולi לסריקת המערך /* 0; = i */ כל עוד המערך תקין וגם יש עוד זוג לבדוק /* ) ==1) (ok while ( (i < 9) && */ אם הזוג הנוכחי אינו מסודר עדכן הדגל ל 'שקר ' /* ) [i+1] if ( a [i] >= a ok = 0; /* אחרת התקדם לזוג הבא */ else i ++; */ החזרת ערך המסקנה return ok; /* ok משתמש במשתנה סימון ok מקומי לפונקציה, המעיד על תקינות המערך עד למיקוםi בהתאמה. כאשר מתגלה אי- תקינות הוא מקבל ערך 'שקר' - 0, הלולאה מסתיימת וערכו מוחזר על ידי הפונקציה. 10 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

16 שלמים 0..9 טבלת משתנים לפונקציה up )גרסת פתרון ( /תפקיד שם המשתנה פרמטר, מערך בן 10 איברים מערך a מציין המתקדם על המערך i אלגוריתם לפתרון הבעיה )1( השם 0 ב- i )( כל עוד )i<10( וגם [i+1]) (a [i] < a )1.( הגדל את i ב- 1 )3( אם = 10 i אזי )1.3( החזר 1 אחרת ).3( החזר 0 בצע public static int up(arr a) /* /* מימוש האלגוריתם /* טענת כניסה: הפונקציה מקבלת מערך חד-מימדי a בגודל 10 /* טענת יציאה: הפונקציה מחזירה'אמת' אם המערך עולה ו'שקר' אחרת int i; */ אתחול i לסריקת המערך /* 0; = i */ כל עוד המערך עולה ואין חריגה מגבולות המערך /* 9)) < (i while ( (a[i] < a [i+1]) && */ התקדם במערך /* ++; i */ אם הגעת לסוף הסריקהאזי החזר 'אמת ' /* ) 9 == i if ( return 1; */ אחרת החזר 'שקר ' /* else return 0; ב. פתרון זה אינו משתמש במשתנה נוסף. בדיקת הרצף העולה נעשית בתוך תנאי הלולאה. כאשר הלולאה מסתיימת לא ידוע האם היא הסתיימה כי נבדקו כל הערכים או כי התגלתה אי תקינות. מאחר והזוג האחרון הנבדק הוא עבור 8 = i, כלומר נבדקים האיברים במקומות 9,8, ואז ערכו של i מקודם ל- 9. כלומר, ערכו של i מעיד על תקינות כל המערך. אם ערכו הגיע ל- 10, אזי המערך תקין ומוחזר'אמת'. אחרת המערך אינו תקין ומוחזר'שקר'. פיתוח ויישום אלגוריתם שקולט מספרים למערך בן 10 איברים. פתרון גרסה 1: פתרון זה מבוסס על פיתוח הפונקציה שנדרשה בסעיף א כלשונה. כלומר הפונקציה מקבלת מערך בגודל 10 ובודקת האם הוא עולה. מאחר והתכנית הראשית משתמשת במערך גדול יותר, ויש לבצע את העיבוד על חלקים שלו. לכן יש שימוש במערך עזרa בגודל 10 שמטרתו להעביר את קבוצת הנתונים הנדרשת לבדיקה. לפונקציה 11 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

17 טבלת תת-משימות סוג הפעולה מטרת תת -המשימה פונקציה בדיקה האם במערך בגודל 10 מתקיים סדר עולה לולאה קליטת מערך בגודל 10 1 פעמים( 10/10 ) יש לבצע: לולאה ראשית: - לולאה - העתקת 10 נתונים מן המערך הגדול לתוך מערך בן 10 איברים - הפעלת הפונקציה לצורך בדיקת הסדר העולה. - בדיקת הסדר העולה ב- 10 הערכים התורנים. - תנאי וקידום - קידום מונה מספר הסדרות העולות. הדפסת מונה מספרהסדרות העולות טבלת משתנים לאלגוריתם הראשי שם המשתנה biga a i j counter /תפקיד המערך הנבדק בגודל 10 מערך מערך בן 10 איברים לצורך העברת נתונים לפונקציה מערך מציין את מספר סדרת הנתונים הנבדקת מציין במערך a מונה את מספר הסדרות העולות במערךbiga אלגוריתם לפתרון הבעיה קלוט 10 נתונים למערך biga )1( אתחל את counter ל- 0 )( מ- 0 עד 11 בצע עבורi )3( ממערך biga למערךa העתק את קבוצת הנתונים ה- i )1.3( אם קבוצת הנתונים במערךa היא עולה ).3( קדם את counter ב- 1 )1..3( הצג כ את counter )( מימוש האלגוריתם /* קלט: מערך בגודל 10 שלמים /* : מספר תתי המערכים בגודל 10 המקיימים סדר עולה /* הפונקציה מסעיף א על פי הגרסה הנבחרת */ שלמים שלמים // q0at00.c public static int up1(int[] a) int i, ok; ok = 1; i = 0; while ( (i < 9) && (ok == 1) ) if ( a[i] >= a [i+1] ) ok = 0; else i ++; return ok; public static int up(int[] a) int i; /* /* 1 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '

18 /* טענת כניסה ויציאה : הפונקציהקולטת ערכים למערךa המועבר כפרמטר */ i = 0; while ( (a [i] < a [i+1]) && (i <9) ) i ++; if ( i ==9 ) return 1; else return 0; public static void readarr (int[] a) int i; Console.WriteLine ("Enter big array elements "); for ( i = 0; i < 10; i ++ ) a[i] = int.parse(console.readline()); public static void Main () int a = new int[10]; int[] biga = new int[10]; int counter, i, j; טבלת תת-משימות */ קליטת נתונים למערךהגדול /* (biga); readarr counter = 0; /* אתחול המונה ל- */ 0 */ טיפול בכל אחת מ- 1 קבוצות הנתונים /* ) i++ for ( i = 0; i < 1; ) j++ for ( j = 0; j < 10; */ העתקת קבוצת הנתונים הנוכחית למערך עזר לצורך בדיקתה /* a [j] = biga [i*10 + j] ; if (up (a) == 1) /* זימון הפונקציהup לצורך בדיקה האם a מקיים את התנאי */ counter ++; /* אם התנאי מתקיים קידום המונה ב - 1 */ */ הדפסת המונה );/* counter Console.WriteLine ("Number of getting up arrays is : 0 ", פתרון גרסה : פתרון זה מבוסס על פיתוח הפונקציה שנדרשה בסעיף א באופן המותאם לביצוע המשימה הכוללת איברים והיא תקבל פרמטר נוסף 10 כאן הפונקציה תפעל על מערך בגודל של האלגוריתם. שמטרתו לציין את תחילת הקטע הנבדק. גם כאן הבדיקה תהיה בכל פעם האם קטע של 10 נתונים איברים לצורך התאמה 10 פתרון זה משחרר מן הצורך להשתמש במערך קטן בן הוא עולה. לפונקציה, ומן הצורך להעתיק בכל פעם 10 נתונים. סוג הפעולה מטרת תת -המשימה פונקציה בדיקה האם בקטע מערך בגודל 10 מתקיים סדר עולה לולאה קליטת מערך בגודל 10 לולאה: - הפעלת הפונקציה - תנאי וקידום 1 פעמים( 10/10 ) יש לבצע: - בדיקת הסדר העולה בתת המערך התורן בגודל 10. ק- ידום מונה מספר הסדרות העולות. הדפסת מונה מספר הסדרות העולות טבלת משתנים לאלגוריתם הראשי שם המשתנה /תפקיד 13 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות'

19 // q0b00; שלמים typedef int bigarr [10]; המערך הנבדק בגודל 10 מערך biga מציין את מספר סדרת הנתונים הנבדקת i מונה את מספר הסדרות העולות במערךbiga counter אלגוריתם לפתרון הבעיה קלוט 10 נתונים למערך biga )1( אתחל את counter ל- 0 )( עבורi מ- 1 עד 1 בצע )3( אם קבוצת הנתונים במערךa היא עולה )1.3( קדם את counter ב- 1 )1.1.3( הצג כ את counter )( public static int up (int[] a, int p) /* טענת כניסה : הפונקציה מקבלת מערךa ומצייןp במערך */ /* טענת יציאה: הפונקציה מחזירה'אמת' אם 10 הנתונים במערך החל ממקום p מסודרים בסדר עולה */ int i; /* התחל את בדיקת הקטע ממיקוםp i = ;p */ */ כל עוד הערכים עולים ולא נבדקו 10 נתונים /* ) p+9) while ( (a [i]< a [i+1]) && (i < */ התקדם בבדיקה /* ++; i */ אם הבדיקה הסתיימה בהצלחה החזר 'אמת ' /* ) p+9 if ( i == return 1; */ אחרת החזר 'שקר ' /* else return 0; public static void readarr (bigarr a) /* /* קלט: מערך בגודל 10 שלמים /* : מספר תתי המערכים בגודל 10 המקיימים סדר עולה */ int i; טענת כניסה ויציאה: הפונקציהקולטת ערכים למערךa המועבר כפרמטר */ /* Console.WriteLine("Enter big array elements \n"); for ( i = 0; i <10; i++ ) a[i] = int.parse(console.readline()); public static void Main() int[] biga = new int[10]; int counter, i; (biga); readarr */ קליטת מערך הנתונים /* counter = 0; /* אתחול מונה מספר הסדרות ל - 0 */ i++) for ( i = 0; i <1; */ טיפול בכל אחת מ 1- סדרות הנתונים /* (1 == (10*i if ( up(biga, /* בדיקה האם הקבוצה התורנית מקיימת את י התנא */ ++; counter */ אם כן, קידום המונה /* */ הדפסת המונה /* ); counter Console.WriteLine("\nNumber of getting up arrays 0 ", 1 פתרון בגרות 000 -שאלון 899 כל הזכויות שמורות להוצאת 'מבט לחלונות '