ex5a1 תורים Queue

5a1.1 ספירת איברים בתור

link

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

1. queue - תור גנרי (מסוג Queue) המכיל איברים מכל סוג.

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

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

דגשים:

1. השתמשו במחלקה Queue מהספרייה Unit4.CollectionsLib.
2. כדי לשמר את התור המקורי, תצטרכו להשתמש בתור עזר או במבנה נתונים אחר.
3. עברו על התור המקורי באמצעות פעולות Remove() ו-Insert().
4. אל תשכחו להחזיר את האיברים למקומם בתור המקורי לאחר הספירה.

דוגמאות:

1. עבור תור המכיל את המספרים [1, 2, 3, 4, 5] (כאשר 1 בראש התור), הפונקציה תחזיר 5.
2. עבור תור ריק [], הפונקציה תחזיר 0.
3. עבור תור המכיל את המחרוזות [“apple”, “banana”, “cherry”] (כאשר “apple” בראש התור), הפונקציה תחזיר 3.

5a1.2 סכום איברי תור

link

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

1. queue - תור של מספרים שלמים (מסוג Queue).

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

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

דגשים:

1. יש להשתמש במחלקת Queue מתוך Unit4.CollectionsLib.
2. עליכם לכתוב תיעוד (Documentation) מתאים לפונקציה SumQueue.
3. עליכם לכתוב תוכנית ראשית (Main method) בתוך קובץ הבדיקות (_stacks_tests.cs) שתבדוק את הפונקציה עם מספר תורים שונים.

דוגמאות:

1. עבור התור [1, 2, 3, 4, 5], הפונקציה תחזיר 15. התור יישאר [1, 2, 3, 4, 5].
2. עבור התור [10, -5, 7], הפונקציה תחזיר 12. התור יישאר [10, -5, 7].
3. עבור תור ריק [], הפונקציה תחזיר 0. התור יישאר ריק.

5a1.3 בדיקת קיום איבר בתור

link

עליכם לממש פונקציה בשם IsElementInQueue אשר מקבלת שני פרמטרים:

1. queue - תור של מספרים שלמים (מסוג Queue)
2. element - מספר שלם לחיפוש בתור

הפונקציה צריכה לבדוק האם element נמצא בתוך queue.

דרישות:

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

הערה: יש להשתמש במחלקת Queue מהספרייה Unit4.CollectionsLib.

תיעוד

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

תוכנית ראשית

יש לכתוב תוכנית ראשית (Main method) שתבדוק את הפונקציה IsElementInQueue על ידי יצירת תורים שונים וקריאה לפונקציה עם איברים שונים. הדפיסו את התוצאות לקונסול.

דוגמאות:

1. עבור תור המכיל: [1, 2, 3, 4, 5] והאיבר 3, הפונקציה תחזיר: true
2. עבור תור המכיל: [10, 20, 30] והאיבר 5, הפונקציה תחזיר: false
3. עבור תור ריק: [] והאיבר 7, הפונקציה תחזיר: false

5a1.4 ספירת הופעות איבר בתור

link

עליכם לממש פונקציה בשם CountOccurrences אשר מקבלת שני פרמטרים:

1. queue - תור (מסוג Queue
2. item - איבר מטיפוס T לחיפוש בתור.

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

דגשים חשובים:

1. התור המקורי (queue) צריך להישאר ללא שינוי בתום הפעולה. כלומר, לאחר שהפונקציה מסיימת לרוץ, התור queue צריך להיות זהה למצבו לפני קריאה לפונקציה.
2. השתמשו במחלקת Queue מתוך Unit4.CollectionsLib.

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

תוכנית ראשית: יש לכתוב תוכנית ראשית (בתוך Main ב-_stacks_tests.cs) שבודקת את הפונקציה CountOccurrences עם מקרים שונים.

דוגמאות:

1. עבור התור [1, 2, 3, 2, 4] והאיבר 2, הפונקציה תחזיר 2.
2. עבור התור [5, 5, 5, 1] והאיבר 5, הפונקציה תחזיר 3.
3. עבור התור [10, 20, 30] והאיבר 15, הפונקציה תחזיר 0.

5a1.5 הזזת איברי תור קדימה

link

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

1. q - תור (מסוג Queue) המכיל מספרים שלמים.

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

דגשים:

1. התור הנתון מובטח להיות לא ריק.
2. השתמשו במחלקת Queue מתוך Unit4.CollectionsLib.
3. כתבו תיעוד (comments) לפעולה.
4. כתבו תוכנית ראשית (Main method) בתוך קובץ הבדיקות (_stacks_tests.cs) שבודקת את הפונקציה עם מספר תורים לדוגמה.

דוגמאות:

1. עבור התור [1, 2, 3, 4], לאחר הפעלת הפעולה, התור יהיה: [2, 3, 4, 1]
2. עבור התור [“a”, “b”, “c”], לאחר הפעלת הפעולה, התור יהיה: [“b”, “c”, “a”]
3. עבור התור [10], לאחר הפעלת הפעולה, התור יהיה: [10]

5a1.6 הכפלת איברי תור

link

עליכם לממש פונקציה בשם MultiplyQueueElements אשר מקבלת שני פרמטרים:

1. originalQueue - תור של מספרים שלמים (מסוג Queue)
2. factor - מספר שלם המייצג את גורם ההכפלה

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

דגשים חשובים:

1. התור המקורי (originalQueue) חייב להישאר ללא שינוי בתום הפעולה.
2. השתמשו במחלקת Queue מתוך Unit4.CollectionsLib.
3. יש לכתוב תיעוד (קומנטים) לפונקציה.
4. יש לכתוב תוכנית ראשית (ב-Main ב-_stacks_tests.cs) הבודקת את הפונקציה עם מספר דוגמאות.

דוגמאות:

1. עבור התור [1, 2, 3] וגורם הכפלה 2, הפונקציה תחזיר תור חדש [2, 4, 6]. התור המקורי יישאר [1, 2, 3].
2. עבור התור [5, 10] וגורם הכפלה 3, הפונקציה תחזיר תור חדש [15, 30]. התור המקורי יישאר [5, 10].
3. עבור התור [0, -1, 4] וגורם הכפלה 5, הפונקציה תחזיר תור חדש [0, -5, 20]. התור המקורי יישאר [0, -1, 4].

5a1.7 העתקת תור

link

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

1. originalQueue - תור (מסוג Queue) אותו יש להעתיק.

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

דרישות:

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

דוגמאות:

1. עבור התור: [1, 2, 3], הפונקציה תחזיר תור חדש: [1, 2, 3]. התור המקורי יישאר: [1, 2, 3].
2. עבור התור: [‘a’, ‘b’, ‘c’, ‘d’], הפונקציה תחזיר תור חדש: [‘a’, ‘b’, ‘c’, ‘d’]. התור המקורי יישאר: [‘a’, ‘b’, ‘c’, ‘d’].
3. עבור תור ריק: [], הפונקציה תחזיר תור ריק חדש: []. התור המקורי יישאר: [].

5a1.8 העתקת K איברים מתוך התור

link

עליכם לממש פונקציה בשם CopyKElementsFromQueue אשר מקבלת שני פרמטרים:

1. originalQueue - תור של מספרים ממשיים (מסוג Queue)
2. k - מספר שלם המציין את כמות האיברים שיש להעתיק

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

דגשים חשובים:

1. התור המקורי (originalQueue) חייב להישאר ללא שינוי לאחר הפעלת הפונקציה.
2. הנחה: k אינו גדול ממספר האיברים בתור המקורי.
3. יש לכתוב תיעוד (קומנטס) לפונקציה.

חתימת הפונקציה הנדרשת:

public static Queue

דוגמאות:

1. עבור התור [1.1, 2.2, 3.3, 4.4, 5.5] ו-K = 3, הפונקציה תחזיר תור חדש: [1.1, 2.2, 3.3]
2. עבור התור [10.0, 20.0, 30.0] ו-K = 2, הפונקציה תחזיר תור חדש: [10.0, 20.0]
3. עבור התור [7.7] ו-K = 1, הפונקציה תחזיר תור חדש: [7.7]

5a1.9 תור הפרשים

link

עליכם לממש פונקציה בשם CalculateDifferenceQueue אשר מקבלת תור של מספרים שלמים בשם Q.

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

1. ליצור תור חדש שיכיל את ההפרשים.
2. לעבור על התור המקורי Q בזוגות של איברים.
3. עבור כל זוג איברים (איבר ראשון, איבר שני), לחשב את ההפרש כ- איבר_שני - איבר_ראשון.
4. להוסיף את ההפרש המחושב לתור החדש.
5. לוודא שהתור המקורי Q נשאר ללא שינוי לאחר הפעולה.

הנחות

1. מספר האיברים בתור המקורי Q הוא תמיד זוגי.
2. התור Q יכיל רק מספרים שלמים.

החזרה

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

דוגמאות:

עבור התור Q שאיבריו הם: 3, 6, 9, 5, 2, 7 (כאשר 3 הוא ראש התור)הפונקציה תחזיר תור חדש שאיבריו הם: 3, -4, 5(6-3=3, 5-9=-4, 7-2=5)

עבור התור Q שאיבריו הם: 10, 2, 8, 4 (כאשר 10 הוא ראש התור)הפונקציה תחזיר תור חדש שאיבריו הם: -8, -4(2-10=-8, 4-8=-4)

עבור התור Q שאיבריו הם: 1, 1, 1, 1 (כאשר 1 הוא ראש התור)הפונקציה תחזיר תור חדש שאיבריו הם: 0, 0(1-1=0, 1-1=0)

5a1.10 הסרת כפילויות מתור

link

עליכם לממש פונקציה בשם RemoveDuplicatesFromQueue אשר מקבלת תור (מסוג Queue) כפרמטר.

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

1. ליצור תור חדש שבו יישמרו האיברים ללא כפילויות.
2. לעבור על האיברים בתור המקורי.
3. עבור כל איבר בתור המקורי, אם הוא אינו קיים כבר בתור החדש, יש להוסיף אותו לתור החדש.
4. יש לשמור על סדר ההופעה הראשון של כל איבר.
5. התור המקורי חייב להישאר ללא שינוי בתום הפעולה.

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

דגשים:

1. השתמשו במחלקת Queue מהספרייה Unit4.CollectionsLib.
2. ודאו שהתור המקורי נשאר שלם ולא משתנה.
3. יש לכתוב תיעוד מתאים לפונקציה.
4. יש לכתוב תוכנית ראשית (Main method) שבודקת את הפונקציה עם מספר תרחישים.

דוגמאות:

1. עבור התור: [1, 2, 3, 2, 1, 4], הפונקציה תחזיר: [1, 2, 3, 4]
2. עבור התור: [‘a’, ‘b’, ‘a’, ‘c’, ‘b’], הפונקציה תחזיר: [‘a’, ‘b’, ‘c’]
3. עבור התור: [7, 7, 7, 7], הפונקציה תחזיר: [7]
4. עבור תור ריק: [], הפונקציה תחזיר: []