של 10 שעורים, לא עברתי עליהם מאז שכתבתי אותם, ככה שאם אתם מוצאים פאקים אני אשמח לדעת.
Pascal:
חוקים בסיסיים:
בשפת פסקל (pascal) צריך להחריז על משתנים, ואחרי כל פקודה (לפחות אחרי רוב
הפקודות) צריך לכתוב ";" (נקודה פסיק) סוגריים זה begin ו-end
כל תוכנית מתחילה במילה program וב begin ו-end
מממ... זהו לא ניראה לי שיש עוד משהו חשוב..
שיעור מסƇ –הכרזה על משתנים:
בפסקל (כמו בהרבה שפות תיכנות אחרות) צריך ל"הצהיר" על משתנים כדי שהקומפיילר ידע מה זה משתנה ומה לא ואיך עושים את זה? על ידי הפקודה var
עכשיו, יש כמה סוגים של משתנים כגון, כאלה ששומרים מספרים שלמים, כאלה ששומרים על תווים, כאלה ששומרים על כתובות וכו' וכו' וכו'...
עכשיו אם נגיד אנחנו רוצים ל"הכריז" על המשתנה "A" שישמור מספר שלם
אז נכתוב את זה ככה:
Var
A:integer;
(הinteger זה הסוג של המשתנה,שימו לב שכתבתי אחריו ";")
עכשיו אפשר אם אנחנו רוצים ל"הצהיר" על כמה משתנים מאותו סוג נכתוב את זה ככה:
(A ו-B הם משתנים ששומרים תווים)
A,B:string;
)הstring זה הסוג של המשתנה)
Integer= מספר שלם
Real= מספר ממשי
Boolean=אמת או שקר
Char=תו
String=מחרוזת תווים.
---------------------------MADE BY cp77fk4r -----------------------------------
Pascal:
שיעור מסƈ - משפטי השמה:
משפתי השמה הם פקודות שמציבות משהו במשתנה
דוגמה: אנחנו רוצים לשים את הערך 10 במשתנה "A" אז נכתוב ככה:
A:=10
(רק במקרה ש"A" הוא מסוג שיכול לקלוט מספר כמו integer/real)
עכשיו אם "A" או מסוג שיכול לקלוט תו (כמו string/char)
אז אפשר לשים את התו "$" במשתנה "A" נכתוב את זה ככה:
'$'=:A
אפשר להכניס גם לתוך משתנה ערך של משתנה אחר, אם נגיד אנחנו רוצים תשים את הערך
של המשתנה B בתוך הערך של המשתנה A אז נכתוב את זה ככה:
A:=B
(שימו לב שהמשתנים חייבים להיות מאותו סוג!)
אפשר לכתוב לשים במשתנה אחד ערכים של כמה משתנים נכתוב את זה ככה:
a:=b+c+d
(פה זה לא משנה אם זה תווים או מספרים כותבים את זה אותו דבר)
אם אנחנו רוצים להציב ב"A" (מסוג string) כמה תווים אפשר לעשות את זה גם ככה:
A:='a'+'b'+'c'
ואפשר לעשות את זה גם ככה:
A:='abc'
אבל אם נכתוב את זה במשתנה שקולט מספרים (מסוג integer לדוגמה)
אז אם נכתוב ככה:
A:=1+2+3;
אז "A" יהיה שווה 6
אבל אם נכתוב את זה ככה:
A:=123;
אז "A" יהיה שווה 123
-----------------------------------cp77fk4r MADE BY----------------------------
Pascal:
שיעור מסƉ – קלט ופלט:
קלט: מה שהמשתמש מכניס לתוכנה
פלט: מה שהתוכנה מחזירה למשתמש
קלט:
כדי לקלוט לתוכנה ערך צריך שיהיה משהו שישמור אותו ולכן כשאומרים לתוכנה לקלוט משהו אז צריך להגיד לה גם לאן...
כדי לקלוט נשתמש בפקודה :
Read (כדי לקלוט)
Readln (כדי לקלוט ולרדת שורה)
נשתמש בה ככה:
Read (a);
Read=לקלוט
(a)=לתוך משתנה "a"
פלט:
כדי להציג על המסך שלנו פלט מתוך משתנה או סתם משהו נשתמש בפקודה:
Write (כדי לפלוט)
Writeln (כדי לפלוט ולרדת שורה)
נשתמש בה ככה כדי לפלוט סתם מישפט:
Writeln ('cp77fk4r');
(שימו לב שכתבתי את המשפט בתוך ' כי זה לא ערך)
ונשתמש בה ככה כדי לפלוט מתוך משתנה:
Writeln(a);
(שימו לב שלא כתבתי את זה בתוך ' כי זה ערך (הערך של "a")
עכשיו אפשר לכתוב גם סתם תרגיל כמו 1+2 אם נכתוב:
Write (1+2);
זה יוצג לנו כפלט על המסך: 3 (כי 1+2 שווה 3)
אבל אם נכתוב
Writeln(Ƈ+2')
אז יוצג לנו כפלט על המסך 1+2 (כי כתבנו את זה בתוך ' )
עכשיו אם נכתוב:
Readln (a,b);
Writeln (b,a);
אז זה יציג לנו את המספרים שקלטנו רק בסדר הפוך...
-------------------------------MADE cp77fk4r BY -------------------------------
Pascal:
שיעור מס' 4 - משפטי תנאי:
עד עכשיו למדנו לתכנת תוכנית שעושה את כל הפקודות לפי הסדר מהתחלה עד הסוף רגיל אבל בשיעור הזה נלמד לתכנת תוכנית שתעשה את הפקודות לא חובה לפי הסדר אני יסביר:
אם נגיד אנחנו רוצים לעשות תוכנה שתקלוט מספר ואם המספר יותר קטן מ100 אז היא תכתוב לנו "small" ואם המספר יותר גדול את היא תכתוב לנו "big" אז איך אנחנו עושים את זה?
נשתמש בפקודה:
Then(ביטויIf (
עכשיו הביטוי יכול להיות הרבה דברים כמו למשל
If a>100 then
Writeln('big');
עכשיו אם הקלט של המשתנה "A" יהיה גדול מ100 (a>100) אז זה יכתוב big
אבל לא אמרנו לא מה אנחנו רוצים אם המשפט לא יתקיים, כדי לעשות את זה נכתוב ככה:
If a>100 then
Writeln('big')
Else
Writeln('small');
(שימו לב שלפני הפקודה else (אחרת) לא כתבתי ";")
עכשיו אם אנחנו רוצים לעשות שיהיה יותר מפקודה אחת אז נכתוב את הפקודות בתוך begin ו-end דוגמה:
If a=10 then
Begin
Write(a);
Write(a+1);
End;
(שימו לב שאחרי הend שמתי ";" ולא "." כמו שend של סוף תוכנית)
עכשיו אם אנחנו רוצים לעשות תוכנית שהיא תקלוט שני מספרים ואם אחד המספרים גדול מ100 אז היא תכתוב big, עושים את זה ככה:
If a>100 or b>100 then
Write('big');
אפשר לכתוב במקום הor ככה:
Or=או זה או זה
And=גם זה וגם זה
----------------------------MADE BY cp77fk4r-----------------------------------
Pascal:
שיעור מס' 5 – לולעת for (מונה)
אם נגיד אתם רוצים לעשות תוכנה שתכתוב את כל המספרים בסדר עולה מ1 עד 1000
אז לפי מה שלמדנו פשוט נכתוב תוכנית בת 1000 שורות שתכתוב לנו את המספרים
אבל מה? אנחנו פריירים? לא!
נשתמש בלולעה! נכתוב 3 שורות במקום 1000 איך? ככה!
נשתמש בלולעת מונה (כל פעם שהלולעה חוזרת המשתנה יהיה גדול ב1 מהפעם הקודמת)
ככה:
For i:=1 to 1000 do
Begin
Writeln (i);
End;
עכשיו מה זה יעשה?
זה בהתחלה יכנס ללולעה (בשורה מסƇ)
אחרי זה, זה יעבוד לשורה מס' 2 (כשהמשתנה "I" יהיה שווה 1)
ואז זה יעבוד לשורה מסƉ ויכתוב את הערך של המשתנה "I" (1)
עכשיו זה ירד לשורה מסƊ ויחזור שוב לשורה מסƇ
עכשיו זה ירד שוב לשורה מסƈ (כשהמשתנה "I" יהיה שווה 2)
ואז זה יעבוד לשורה מסƉ ויכתוב את הערך זה המשתנה "I" (2)
וכו' וכו' וכו' ככה עד 2000
שווה לא?
עכשיו אפשר לעשות גם משהו כזה:
אנחנו רוצים שהתוכנה תכתוב לנו מהמספר 1 עד 10 בקפיצות של 2 מספרים
(יענו 2-4-6...) אז נכתוב את זה ככה:
For i:=1 to 20 do
Begin
Writln (i)
i:=i+1;
end;
(שימו לב שהלולעה תקפוץ ב2 בגלל מה שכתבתי בשורה מסƊ (משפט השמה)
למשתנה "I " (הוא יכול להיות כל אות) קוראים "משתנה בקרה" והוא חייב
א)מסוג הוא integer או char (אם הוא יהיה מסוג char אז צריכים שהלולעה תיהיה מאות כל
שהיא עד אות כל שהיא (ואז הוא יקפוץ בסדר של הabc)
ב)חייבים להכריז עליו! (כשמכריזים מvar)
------------------------MADE BY cp77fk4r------------------------
Pascal:
שיעור מס' 6 - לולאת while (בזמן ש)
אם נגיד אנחנו רוצים לכתוב תוכנית שהיא לא תפסיק לרוץ עד שיכניסו לה את המספר 3
עכשיו איך אנחנו עושים את זה?
טוב ברור שאנחנו צריכים להשתמש בלולאה... אבל איך?
נשתמש בלולעת while ככה:
Do(תנאיWhile (
משהו כזה:
נקבע שהמשתנה "a" שווה 1
ואז נגיד: בזמן שהמשתנה a שווה ל1 אז תעשה ככה:
תבקש קלט לb ואם b שווה 3 אז תפסיק את הלולעה
איך נכתוב את זה?
A:=1
While (a=1) do
begin
Readln (b);
If (b=3) then
A:=0;
End;
הסבר:
שורה 1: אנחנו קובעים שמשתנה a יהיה שווה ל1
שורה 2: תחילת הלולאה (שימו לב לתנאי)
שורה 3: הbegin של נלולאה (חובה, בגלל שיש יותר מפקודה אחת (כמו בfor))
שורה 4: בקשת קלט לb
שורה 6/5: שתפט תנאי (שאם הוא מתקיים אז a יהיה שווה ל0 (ואז הלולאה תיגמר)
שורה 7: חזרה לתחילת הלולאה (לbegin)
אפשר לעשות אם זה כל מיני דברים וזה חלק ממש חשוב!
--------------------------MADE BY cp77fk4r------------------------------------
Pascal:
שיעור מס' 7 – פקודות :
יש בפסקל כל מיני סוגי פקודות (כאלה שפועולת על משתנים מסוג תו משתנים מסוג ממשי/פט/סוגי קלט וכו') כאן אני ילמד אותכם את שני הפקודות succ ו pred
הם פועלות רק על משתנה מסוג תווי (מסוג char) בכך שלכל אות יש מספר על המקלדת (מספר אסקי) אני מדבר על מספר סידורי,
Succ:
צריך לקבוע גם על איזה משתנה היא תשפיע, אם נגיד נכתוב ככה:
A:='a'
A:=succ(a);
אז המשתנה "a" יהיה שווה b
אבל אם נכתוב
writeln succ('z');
אז זה ידפיס לנו את התו הסידורי הבא ("!")
Pred:
כמו בsucc גם פה צריך לקבוע על מה היא תשפיע וגם כמו שם צריך לשים את המשתנה/או הערך בתוך סוגריים,
אבל מה שקורה פה זה בדיוק ההפך!
אם נכתוב ככה:
A:='b'
A:=pred(b);
אז המשתנה "a" יהיה שווה a
אבל אם נכתוב
writeln pred('z');
אז זה ידפיס לנו את התו הסידורי הבא ("y")
ואותו דבר גם על מספרים
(שימו לב שהמשתנה חייב להיות מסוג תווי! (מסוג char)
---------------------------MADE BY cp77fk4r------------------------------------
Pascal
שיעור מס' 8 –סוגים של משתנים
1- מונה
2- שומר
3- אוגר
מונה:
מונה הוא משתנה מסוג ממשי (real)
יעשו מספר פקודות וכל מספר פעולות קבוע הוא יעלה עוד נגיד יהיה תוכנה
שבודקת כמה אנשים קיבלו מעל 80 במבחן אז כל ילד שיהיה יותר מ80 אז הוא יעלה ב1
משהו כזה:
If a>80 then
B:=B+1
(שימו לב שהמונה פה הוא B)
רב הפעמים המונה יבוא אם משפט if אז שימו לב לזה
שומר:
שומר הוא משתנה רגיל שכל מה שיכניסו הוא ישמור...
משהו כזה:
Read (a)
B:=a
(שימו לב שהשומר פה הוא b )
אוגר:
אוגר הוא משתנה מסוג real (אבל זה תלוי למה צריך אותו)
הוא יעבוד ככה:
יעשו מספר פקודות של קלט
משהו כזה:
Read (a,b,c,d)
והאוגר יאגור את סכומם
(שימו לב שהוא לא כמו השומר שמתאפס כל הזמן)
רב הפעמים זה יהיה בלולאה...
משהו כזה:
For i=1 to 10 do
begin
Readln (a)
B:=b+a
end
(שימו לב שכתוב b:=b+a ולא כתוב b:=a)
-----------------------------------MADE BY cp77fk4r----------------------------
Pascal
שיעור מסƏ –שורש ריבועי ובריבוע
לפעמים אתם מתבקשים לעשות תוכנות שהקלט שלהם הוא מספר שלם והפלט
שלהם הוא המספר בריבוע אז יש כמה דרכים לעשות את זה אני יתן פה שתי דרכים ואני גם רוצה להסביר פה משהו במהלך השיעור.
שיטה מס'-1:
Begin
Read(a)
Write (a*a)
End
ועכשיו יש עוד דרך אבל כדי לדעת אותה אנחנו חייבים להכיר את הפקודה:
Sqr (העלה בריבוע)
התוכנה שלנו תיראה ככה:
Begin
Read(a)
Write sqr(a)
End
במיקרה שלנו אז אין כ"כ הרבה הבדל בין התוכניות אבל יש מצבים שאי אפשר לעשות את השיטה של התוכנה הראשונה אז חייבים להשתמש בשיטה של התוכנה השינה...
שימו לב משתמשים בפקודה ככה: sqr (a)
אפשר גם לכתוב ככה:
A:=sqr(a)
Write sqr(a)
יש פקודה שמקבילה לsqr וקוראים לה:
Sqrt (שורש ריבועי)
הפקודה הזאת עובדת בדיוק כמו השניה ככה:
Sqrt(a)
אם a שווה 9 אז הערך יהיה 3
אם a שווה 25 אז הערך יהיה 5
וכו'... ואפשר להשתמש בה בדיוק כמו בפקודה sqr
A:=sqrt(a)
Write sqrt(a)
אבל מה שרציתי להסביר בשיעור הזה, זה שיש כמה פקודות בpascal שאפשר לעשות אותן גם בלי הפקודה עצמה (ע"ע sqr) אבל יותר כדי להשתמש הפדוקה הנוחה...
------------------------------MADE BY cp77fk4r---------------------------------
שיעור מס'-10
מערכים:
אם נגיד אנחנו צריכים לקלט משהו כמו 1000 מספרים שונים
אז לא נעשה לנו 1000 משתנים, זה יהיה טיפשי, לשם כך נשתמש במערך.
זה מעיין קבוצה של משתנים באותו ומאותו סוג.
נצהיר על זה ככה:
var
a[1..10] of integer
הסבר קצר:
a=שם המערך
1..10=יהיה מ1 עד 10 תאים במערך
of integer= הסוג של התאים (במקרה שלנו זה שלמים)
(אפשר לעשות גם תאים מסוג תו)
כדי להגיד למחשב איך להתייחס לתא אחת במערך נעשה ככה:
(נגיד אנחנו רוצים להציב בתא מס' 3 את הערך "4")
a[3]:=4
הסבר:
a=שם המערך
[3]=המיקום של התא
:=4 = אנחנו יודעים כבר שזה להציב
אפשר לעשות דבר כזה:
for i:=1 to 100
read a
ככה נכניס לכל תא ותא במערך (של 100) ערך בדרך הכי מהירה...
-----------------------------MADE BY cp77fk4r----------------------------------
טוף.. אני מקווה שאין פה הגבלת תווים ושתהנו מהמדריך, הוא נכתב על רגל אחת, פעם, עוד כשהייתי צעיר