# data[].attributes.headline
רשמו תת-משימות של הבעיה וסדרו אותן על פי סדר ביצוען בתוכנית

# data[].attributes.subject
רשמו תת-משימות של הבעיה וסדרו אותן על פי סדר ביצוען בתוכנית

# data[].attributes.body
קלט סימן
קלט מספרים
בדיקה שהסימן תקין ושהמספרים עומדים בתנאים הרלונטים
חישוב בפונקציות
פרינט
התחלת הלולאה מחדש עד תנאי עצירה כלשהוא

# data[].attributes.body
1. בקשת קלט תקין של שני מספרים שלמים
2. בקשת פעולת חשבון תקינה על פי האינדקס שלה
3. פונקציות המבצעות את הפעולות החשבון
4. הצגת הפלט
5. סידור לתוך לולאה

# data[].attributes.headline
פירוק המשימה לתתי משימות

# data[].attributes.subject
פירוק המשימה לתתי משימות

# data[].attributes.body
1.יצירת 4 פונקציות שונות: כל פונקציה לפעולה ספציפית
2. יצירת תפריט של פעולות אפשריות
3. קליטת שני מספרים ופעולת חשבון רצויה
4. בדיקת תקינות הקלט, במידה ולא- יש להציג הודעה מתאימה
4. ביצוע החישובים
5. הצגת התוצאה

# data[].attributes.headline
מחשבון פשוט - תת משימות

# data[].attributes.subject
מחשבון פשוט - תת משימות

# data[].attributes.body
1. כתיבת התפריט ולהדפיס אותו.
2. קליטת תו מהמשתמש לצורך פעולת חשבון.
3. בדיקת תקינות הפלט, כלומר שהתו תקין. אם לא - לבצע פעולה פעם נוספת.
2. קליטת 2 מס' שלמים מהמשתמש.
3. בדיקת תקינות הפלט (שאכן 2 המספרים שלמים)
4. בדיקת תנאי - איזה פעולת חשבון נבחרה?
5. ביצוע הפעולה והדפסת התוצאה.

# data[].attributes.headline
1. הגדרת פונקציה לקב

# data[].attributes.body
1. הגדרת פונקציה לקבלת קלט מהמשתמש למספר סידורי של פעולת חשבון והחזרה של הקלט, ופונקציה לכל פעולה מתמטית כשבתוך כל פונקציה מתמטית יש קליטת 2 מספרים שלמים ובדיקת תקינות הקלט
2. השמת הפונקציה לתוך משתנה
3. פתיחת לולאה שבודקת אם המשתמש ביקש לצאת מהמחשבון
4. כתיבת תוכן הלולאה והרצת פונקציות בהתאם לקלט שנכנס מהמשתמש, כשבסוף כל הרצת פונקציה מתמטית, תרוץ שוב פונקצית ההשמה למשתנה של מספר סידורי לפעולה מתמטית

# data[].attributes.headline
לכתוב את התפריט ולהדפיס אותו 

# data[].attributes.subject
לכתוב את התפריט ולהדפיס אותו 

# data[].attributes.body
לקלוט שני מספרים שלמים
לקלוט פעולות חשבון
לולאה שתבצע בהתאם לבחור שם משתמש עם הפונקציות

# data[].attributes.headline
1.להציג למשתמש תפריט ממנו הוא  יבחר את פעולת החשבון אותה הוא מעוניין לבצע.

# data[].attributes.subject
1.להציג למשתמש תפריט ממנו הוא  יבחר את פעולת החשבון אותה הוא מעוניין לבצע.

# data[].attributes.body
2.לבקש מהמשתמש להכניס שני מספרים.
3.לבדוק את תקינות הקלט
4.במידה והקלט לא תקין לנסח הודעה מתאימה ולבקש מהמשתמש להקליד ערכים אחרים.
5.ליצור פונקציות המתאימות לכל פעולת חשבון.
6."לקרוא" לפונקציה בהתאם לבחירת המשתמש.
7.להחזיר את את תוצאת הפונקציה ולהציגה למשתמש.
8.יבצע שוב את כל הפעולות.

# data[].attributes.body
בניית ארבעה פונקצויות לכל אחת מפעולות החשבון
הצגת תפריט בחירה לקלט מהמשתמש בין1 ל4
אם המספר שהקליד המשתמש אינו בתפריט הוא יקבל הודעת שגיאה ודרישה לקלט חדש.
לאחר הקלדת קלט תקין של פעולה מהמשתמש נבקש מהמשתמש להקליד שני מספרים שונים עליהם ירצה לבצע את הפעולה.
בעזרת תנאים לכל אחת מפעולות החשבון יופנו המספרים שנקלטו מהמשתמש לפונקציה הרלוונטית לפעולת החשבון אשר ביקש המשתמש.
תוחזר התוצאה במסך הפלט והשאלה האם ירצה לבצע חישוב נוסף

# data[].attributes.headline
1) הצגת פעולות חשבון

# data[].attributes.body
1) הצגת פעולות חשבון שהמחשבון יודע לעשות.
2)קליטת מספרים מהמשתמש
3)בדיקת תקינות של המספרים
4)הצגת תשובה לפי המספרים והפעולה שבחר המשתמש.

# data[].attributes.headline
1. חשיבה על אלגוריתם

# data[].attributes.subject
1. חשיבה על אלגוריתם

# data[].attributes.body
2. פתרון לבעיות של אי תקינות פלט
3. קידוד:
א. לולאה שתפסיק כשהמשתמש ירצה לסיים לעבוד.
ב. הצגת תפריט אפשרויות וקליטת קלטים.
ג. בדיקת תקינות הקלטים
ד. הצגת הפלט

# data[].attributes.body
1. מקבלים 2 ובודקים את תקינותם (אם לא תקין להחליף מספר)
2.הצגת תפריט ובחירת פעולה מתאימה (גם פה תקינות פלט)
3. איך לקרוא לפעולה המתאימה

# data[].attributes.headline
1) לקלוט שני מספרים שלמים   2)פונקציות ל- פעולת חשבון                 3)לולאה לתרגיל כל עוד המספר שונה ממספר שנבחר שיעצור את התוכנית לולאת המחשבון תתבצע . וכל פעם בסוף פעולת חשבון תחזיר ל input.)                          4)בפעולת חילוק if לתקינות הקלט שיכנס לחילוק ק' אם המספר השני שמחלקים בו שונה מאפס , אם הקלט לא תקין  זה מחזיר לinput וקולט מחדש מספרים        

# data[].attributes.subject
1) לקלוט שני מספרים שלמים   2)פונקציות ל- פעולת חשבון                 3)לולאה לתרגיל כל עוד המספר שונה ממספר שנבחר שיעצור את התוכנית לולאת המחשבון תתבצע . וכל פעם בסוף פעולת חשבון תחזיר ל input.)                          4)בפעולת חילוק if לתקינות הקלט שיכנס לחילוק ק' אם המספר השני שמחלקים בו שונה מאפס , אם הקלט לא תקין  זה מחזיר לinput וקולט מחדש מספרים        

# data[].attributes.headline
 1 הצגת קלט למשתמש 2

# data[].attributes.body
1 הצגת קלט למשתמש 2. קליטת 2 מספרים ו פעולה 3. לעשות לולאה לבדיקת תקינות המספרים הפעולה ו אם היא לא נכונה לבקש מהמשתמש קלט חדש ....4. לולאה שתבצע הכל ו תסתיים כשהמשתמש יסתיים

# data[].attributes.body
קבלת ערכים מהמשתמש                       2. בדקת תקינות הקלט                       3. אם הקלט אינו תקין , יבקש מהמשתמש להכניס קלט חדש                4. אם הקלט תקין , תבצע את פעולת החישוב של שני המספרים שדרש המשתמש                                              5. התוכנית תריץ כל עוד המשתמש לא ביקש אחרת

# data[].attributes.headline
1.הצגה למשתמש וקלט

# data[].attributes.subject
1.הצגה למשתמש וקלט

# data[].attributes.body
2.בדיקת תקינות הקלט.
3.פירוק ל4 פונקציות (חיבור חיסור וכו')
4.לולאה שתרוץ ותבצע בהתאם לבחירת המשתמש עם הפונקציות שמומשו.

# data[].attributes.headline
לפרק את התת משימות !

# data[].attributes.body
לפרק את התת משימות !

# data[].attributes.headline
שלבים לפיתוח מחשבון

# data[].attributes.subject
שלבים לפיתוח מחשבון

# data[].attributes.body
1)הכנסת קלט לבחירת פעולות אפשריות.
2)ביצוע תקניות קלט לקלט שהוכנס לבחירת פעולה.
3)הכנסת המספרים עליהם המשתמש רוצה לבצע את הפעולה שנבחרה.
4)לבדוק שהקלט שהוכנס הוא קלט מספרי(כלומר לא תו אחר שהוא לא מספר)
5)פונקציה המוגדרת לכל פעולת חשבון אפשרית המקבלת את שני המספרים ומחזירה את התוצאה.
6)לולאה בתוך התכנית הראשית אשר מזמנת כל אחת מהפונקציות בהתאם לבחירה של המשתמש.
7)הלולאה תדפיס את הערך שהוחזר מהפונקציה.
8)הלולאה תמשיך לרוץ עוד פעם כל עוד לא הוכנס מהמשתמש תנאי עצר לסיום התכנית.

# data[].attributes.headline
פירוק המשימה לתת משימות

# data[].attributes.subject
פירוק המשימה לתת משימות

# data[].attributes.body
ירוץ בתוך לולואה אשר היה לה תו להפסקת פועלת התוכנית:
המשתמש יכניס 2 מספרים
המשתמש יכניס פעולה אשר רוצה לבצע (+\-\*\/)
המחשב יבצע את הפועולת ויחזר פלט

# data[].attributes.headline
קליטת שני מספרים , 

# data[].attributes.subject
קליטת שני מספרים , 

# data[].attributes.body
בדיקת הממספרים

# data[].attributes.body
1) הצגת הפעולות למשתמש, קליטת קלט כלשהו ובדיקת תקינותו.
2) פירוק ל4 פעולות חשבון וחישוב הפעולה הנדרשת.
3) הצגת הפלט המתאים למשתמש וקליטה של הפעולה הבאה.

# data[].attributes.headline
אניגמה בינארית

# data[].attributes.subject
אניגמה בינארית

# data[].attributes.headline
מה זה הפלגן לרגע חשבתי שאורנה פרצה לי המחשב

# data[].attributes.subject
מה זה הפלגן לרגע חשבתי שאורנה פרצה לי המחשב

# data[].attributes.headline
1.קלט של שני מספרים שלמים,אם תפריט לבחירת הפעולות

# data[].attributes.subject
1.קלט של שני מספרים שלמים,אם תפריט לבחירת הפעולות

# data[].attributes.body
2.לבנות תנאי של מה קורה אם הוקלד משהו תקין, ומשהו לא תקין
3.במידה ותקין לבנות עוד תת לולאה של WHILE עם תנאי ואז לבנות בתוכו 4 פונקציות של פעולות החשבון, ובין כל פונקציה ELIF
4.תדפיס לי למסך במידה ונבחרה אחת הפונקציות

# data[].attributes.body
1. הכנסת קלט
2 הכנסת פעולה
3 בדיקת תקינות קלט
4 לולאה שתרוץ ותבצע בהתאם עד לבחירת המשתמש לסיים

# data[].attributes.headline
1)כתיבת פונקציות המתאימות לפעולות החיבור השונים

# data[].attributes.subject
1)כתיבת פונקציות המתאימות לפעולות החיבור השונים

# data[].attributes.body
2) הצגת הפעולות למשתמש
3)קליטת מספרים
4)בדיקת תקינות מספרים
5)התאמת פונקציות למצבים השונים תחת לולאת if
6)לתת בסוף כל פעולה את האופציה להכניס מספר נוסף או לצאת

# data[].attributes.headline
1. הצגת תפריט הפעולו

# data[].attributes.body
1. הצגת תפריט הפעולות למשתמש.
2.קליטת תו ושני מספרים ובדיקת תקינות הקלט
3.אם אחד הקלטים לא תקין נבקש מהמשתמש להכניס קלט חדש, אחרת נחשב ונדפיס את התוצאה.
4.התוכנית תרוץ בלולאה כל עוד המשתמש לא ביקש לסיים

# data[].attributes.headline
1.קליטת שני מספרים שלמים 

# data[].attributes.subject
1.קליטת שני מספרים שלמים 

# data[].attributes.body
2. בדיקת תקינות הפלט
3. לבקש מהמשתמש להקליד את פעולת החשבון שירצה
4. בדיקת תקינות הקלט( אם לא תקין יתבקש להכניס קלט חדש)
5.לבדוק אם המשתמש רצה עוד פעולות
6. הרצה והדפסה

# data[].attributes.headline
1. קבלת קלט 1 מהמשתמ

# data[].attributes.body
1. קבלת קלט 1 מהמשתמש
2. בקשת הביצוע op
3. קבלת קלט 2 מהשתמש
3. ותנאים לביצוע ה=פעולות המחשבון

# data[].attributes.headline
1.בניית הפונקציות

# data[].attributes.subject
1.בניית הפונקציות

# data[].attributes.body
2. בחירת פונקצייה רצויה על ידי המשתמש(בניית אפשרות סיום)
3. קליטת שני המספרים
4.בדיקת תקינות הקלט
5.זימון הפונקציה וחישוב המספרים
6.הדפסת הפלט
7.חזרה לאופצית הפעולות.

# data[].attributes.headline
בדיקת המספרים

# data[].attributes.body
בדיקת המספרים

# data[].attributes.headline
1 יצירת 4 פונקציות מ

# data[].attributes.body
1 יצירת 4 פונקציות מסודרות לפי הסדר בשאלה
2 יצירת פונקציה ראשית שקולטת שני מספרים ממשיים
3 לעשות לולאה ותעבור על כל הפונקציות
4 תפתור את השני מספרים לפי מה שרוצים( חיבור תחבר ) וכך ..

# data[].attributes.headline
1. כתיבת פונקציות לפעולות החשבון

# data[].attributes.subject
1. כתיבת פונקציות לפעולות החשבון

# data[].attributes.body
2. תפריט+ קליטת מספרים ובדיקת תקינותם
3. כניסה ללולאה וביצוע פעולות החשבון והדפסה
4.המשך הלולאה עד שהמשתמש יחליט להפסיק

# data[].attributes.headline
1.לכתוב פונקציה בקלט שמצייגה את אודות הפונקצייה 

# data[].attributes.subject
1.לכתוב פונקציה בקלט שמצייגה את אודות הפונקצייה 

# data[].attributes.body
2. בחירת פונקצייה רצויה על ידי המשתמש . 3. אחרי כך תתבציע בפלט את החישוב ולא תפסיק הפעולה

# data[].attributes.headline
1. קליות פעילות החשבון

# data[].attributes.subject
1. קליות פעילות החשבון

# data[].attributes.body
2. בדיקת הפעילות
3. קלטת שני מספרים
4. בדקת המספרים
5. נעשה פונקציות בנפרד לכל פעולה.
6.בודקיפ הפעולה ואז מזמנים הפונקציות

# data[].attributes.headline
1. קליטת שני מספרים 

# data[].attributes.subject
1. קליטת שני מספרים 

# data[].attributes.body
2.בדיקת נכונות הקלט
3. נתאים לולאה לתנאים שלנו עד שהמשתנה ירצה לעצור + חישוב לפי הסדר עם הצגת הסכום.