1. הרצאה 3 אלמנטים בסיסיים בשפה
מבוא למדעי המחשב
הרצאה 3
אלמנטים בסיסיים בשפה
סדר יום:
חזרה מסודרת על התכניות שראינו בשיעור הקודם:
משתנים - טיפוסים בסיסיים,
ביטויים אריתמטיים
אופרטורים (אריתמטיים, לוגיים)
ביטויים שונים (חישוב, השמה)
בקרת זרימה (לולאות if, while, for)
אפשר להתחיל את ההרצאה מהפונקציה מסוף השיעור שעבר,
שתשאר על הלוח כל השיעור:
int m = sc.nextInt();
boolean isPrime = true;
int i = 2;
while (i<m) {
if ( m%i==0) {
isPrime = false; }
i=i+1;
System.out.println(isPrime); 1

2. יצוג בינארי שימוש בשני ערכים בלבד סיביות ובתים: bits & bytes
כמה ביטים דרושים על מנת לייצג ערך אמת/שקר?
כמה ביטים דרושים על מנת לייצג אחת מבין 4 אפשרויות?
כמה ביטים דרושים על מנת לייצג אחת מבין 10 אפשרויות?
מהו גודל המספר שניתן לייצג באמצעות n ביטים? ומה עם שליליים?
* גם תוים יהיו מיוצגים כמספרים – מוסכמויות שונות (unicode, ascii)

3. משתנים משתנה הוא "פתק" בו אנו רושמים מידע שנרצה להשתמש בו מאוחר יותר.
לכל משתנה יש שם וטיפוס (סוג)
הכרזה על משתנה:
<טיפוס> <שם>
לדוגמא
int m;
int x,y;
מכריזים על משתנה רק פעם אחת.
משתנים הם בחינם. אם צריך עוד משתנה כדי שהתכנית תהיה יותר פשוטה לא צריך לחשוב פעמיים.

4. טיפוסי משתנים בשפה java ישנם 8 טיפוסים בסיסים (פרימיטיביים)
טיפוסים שונים: שלמים, ממשים, תווים, בוליאניים. נועדו לייצג ישויות שונות.
בשפה java ישנם 8 טיפוסים בסיסים (פרימיטיביים)
בשיעור העבר ראינו שניים: boolean, int
שלמים: long, int, short, byte
ממשיים: double, float
אמת שקר: boolean
תו: char, לכל תו יש יצוג בינארי
הסבר – בוליאני
יש הבדל בין המספר 12 לבין סדרת התוים '2' '1'
int  2^31-1 4

5. השמה כדי לרשום ערך לתוך משתנה יש להשתמש בסימן "=". "=" זה לא שווה!
משמעות הסימן "=" היא: "חשב את ערך הביטוי שבצד ימין ורשום אותו במשתנה שבצד שמאל (חייב להיות משתנה בודד בצד שמאל)
דוגמאות
int a=5;
int b=7*9;
int c=a+b;
int x=6;
int y=x;
x=5;
when we introduce variables, we also have a variable table, in which all "living variables" can be found.
) next lecture, when we introduce arrays, we will also have the general "memory", where the array data is stored.)

6. ביטויים אריתמטיים אופרטורים: + , - , * , / , %
(חיבור, חיסור, כפל, חילוק, שארית חלוקה)
ליטרלים – יחידות בסיסיות
ביטוים אריתמטיים:
<ליטרל>
<משתנה>
<ביטוי אריתמטי> <אופרטור> <ביטוי אריתמטי>
טיפוסים מתאימים במשפטי השמה
מה נצפה למצוא עם משתנה בוליאני? 6

7. הפעלת אופרטורים ישנם אופרטורים ה"פועלים" בצורה שונה על טיפוסים שונים:
double x = 5.0/2.0
X=2.5
int x = 5/2
X=2
double x = 5/2
X=2.0
double x = 5.0/2
int x = (int)(5.0/2.0)
Discuss casting: explicit vs. implicit

8. ביטויים בוליאניים פעולות השוואה: == , =! , => , =< , > , <
פעולות לוגיות: && , || , !
סדר הקדימויות של האופרטורים מוגדר בצורה חד משמעית.
לא מדברים בקורס על & ו- | 8

9. הוראות קלט ופלט
במהלך הרצת תוכנית מחשב ההוראות מבוצעות לפי סדר (אחת אחר השנייה).
פלט: הדפסה: System.out.println(i);
קלט: sc.nextInt();
מחייב שורות קוד נוספות, כפי שראינו בשיעור שעבר

10. בקרת זרימה – משפט תנאי מאפשר פיצול בתוכנית לפי תנאי לוגי:
if : מבנה בסיסי:
if(<boolean condition>)
statement
if else : מבנה בסיסי:
else
nested if: דיון בדו משמעיות: if, else if, else
If cond1 if cond2 else s1
( )
הסבר statement 10

11. if and if-else import java.util.Scanner; class Grade{
public static void main (String[] args){
Scanner sc = new Scanner(System.in);
int grade;
grade= sc.nextInt();
if (grade<56)
System.out.println("Failed");
else
if (grade>=56 && grade<=79)
System.out.println("Passed");
System.out.println("Good grade"); }
הוכחת נכונות: צריך להראות שהאלגוריתם נכון גם כאשר התנאי מתקיים וגם כאשר הוא לא מתקיים, עם או בלי else

12. While loop <stat1>; while(<תנאי>){ <stat2>;}
<stat4>;
לחזור: הוכחת הנכונות שראינו בשיעור שעבר:
דומה להוכחה מ"התיכון" (באינדוקציה).
מקרה הבסיס הוא הטענה הנשמרת ללא כניסה ללולאה (0)LOOP

14. while loop – guessing example
import java.util.Scanner;
class Guess{
public static void main (String[] args){
Scanner sc = new Scanner(System.in);
int solution, guess = 0;
solution = 1 + (int)(Math.random() * 100);
while ( guess != solution ){
guess= sc.nextInt();
if ( guess < solution )
System.out.println ( "too small" );
else if ( guess > solution )
System.out.println ( "too big" ); }
System.out.println ( "You guessed it!" );
לדבר על Math.random()
המרה מפורשת של ממשי לשלם

15. for loop stat1; stat2; stat3; } stat4;
for ו while הם שקולים מבחינת יכולת הביטוי שלהן (איך ממירים)
הביטויים בהגדרת ה for יכולים להיות מורכבים/ ריקים.

16. for loop  example class FirstFor{
public static void main (String[] args){
int i=0;
System.out.println ("* "+i);
for (i=0;i<4;i=i+1){
System.out.println ("** "+i); }
System.out.println ("*** "+i);
אין צורך ב Scanner sc = new Scanner(System.in); וכו'
כי אין קליטת קלט מהמשתמש

17. Nested loop class NestedLoop{ public static void main (String[] args){
int i=0,j=0;
for (i=0;i<4;i=i+1){
System.out.println ("* "+i+”,”+j);
for (j=0;j<3;j=j+1) {
System.out.println ("** "+i+”,”+j);
System.out.println ("*** "+i+”,”+j); }
System.out.println ("**** "+i+”,”+j);

18. Example: hand shakes
בלוויה נפגשו 10 אנשים (לא כולל המנוח). כל אדם לחץ את ידו של כל אדם אחר (לא כולל המנוח)
הדפס את כל הלחיצות שנלחצו, וחשב את מספרן

19. Example: hand shakes class HandShakes{
public static void main (String[] args){
int i,j,counter=0;
for (i=0;i<10;i=i+1){
for (j=i+1;j<10;j=j+1){
System.out.println(i+" handshaked "+j);
counter=counter+1; }
System.out.println(“There were "+counter+" handshakes");
// n people  n*(n-1)/2 handshakes
טענה נשמרת FOR חיצוני: כל X<I כבר לחץ את ידם של כל השאר
טענה נשמרת FOR פנימי: כל X<I כבר לחץ את ידם של כל השאר, ו-I כבר לחץ את ידו של כל y<J (פרט אליו)

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

21. Example: punches class Punches{
public static void main (String[] args){
int i,j,counter=0;
for (i=0;i<10;i=i+1)
for (j=0;j<10;j=j+1)
if (i!=j){
System.out.println(i+" punched "+j);
counter=counter+1; }
System.out.println("there were "+counter+" punches");
// n people  n*(n-1) punches
טענה נשמרת FOR חיצוני: כל X<I כבר הלם בפרצופם של כל השאר
טענה נשמרת FOR פנימי: כל X<I כבר הלם בפרצופם של כל השאר, ו-I כבר הלם בפרצופו של כל y<J (פרט אליו)

22. בעיה: מספרים ראשונים קבע האם מספר טבעי (גדול מ-1) הינו ראשוני
אלגוריתם במילים

23. מספרים ראשונים ב Java int m = sc.nextInt(); boolean isPrime = true;
int i = 2;
while (i<m) {
if ( m%i==0) {
isPrime = false; }
i=i+1;
System.out.println(isPrime);
דיון בתנאי שבלולאה – אפשר ליעל על ידי הוספה של
&& isPrime
נבדוק נכונות
ננסה לשפר:
יעיל יותר: מהיר יותר – פחות פעולות חישוב.
פשוט יותר: לתכנות .
טענה נשמרת (בלי && isPrime): isPrime הוא FALSE אמ"מ קיים X<I שמחלק את M.
טענת בתר: isPrime אמ"מ M הוא ראשוני (כלומר, לא קיים X<M שמחלק את M)
הוכחת שמירות הטענה הנשמרת: נוכיח לגבי I+1:
אם קיים X<I שמחלק את M אזי קיים X<I+1 שמחלק את M ואז isPrime הוא FALSE (מהנחת האינדוקציה) וסיימנו.
אם I מחלק את M, אז באיטרציה הקודמת שינינו את isPrime להיותFALSE וגם קיים X<I+1 שמחלק את M
אם לא קיים X<I שמחלק את M וגם I לא מחלק את M, אז מהנחת האינדוקציה isPrime הוא TRUE ומכיון ש I לא מחלק את M לא שינינו את isPrime

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

25. הדפסת כל הראשוניים עד n int n = sc.nextInt(); int m = 2;
while (m<=n) {
boolean isPrime = true;
int i=2;
while (i<m && isPrime) {
if ( m%i==0) {
isPrime = false;
} // if
i=i+1;
} // while
if(isPrime) {
System.out.println(m); }
m=m+1;
טענה נשמרת (לולאה חיצונית): כל הראשוניים עד m כבר הודפסו
output:
enter natural max number: 40
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37
צמצום מרחב המועמדים (אפשר לוותר על מספרים זוגיים).
צמצום מרחב המועמדים לחלוקה:
מספיק לבדוק עד השורש
מספיק לבדוק ראשוניים!
שמירת רשימת ראשוניים עד עתה!