Posts on the subject:שאלות ותשובות מדעי המחשב בגרות



דוגמאות ללולאת while ב c#:

כתוב תכנית אשר קולטת מספר, עד אשר נקלט מספר שלילי:

Console.WriteLine("Please enter int number:");
int x = int.Parse(Console.ReadLine());
while(x>=0) // כל עוד המספר חיובי או אפס המשך לקלוט
{
Console.WriteLine("Please enter int number:");
x = int.Parse(Console.ReadLine());
}
ברגע שהמספר יהיה שלילי נצא מלולאת ה-while.


Another exmaple:
Create program which get grade (int) from user. if the grade is illegal, repeat and continue to get grade from user.. and if the grade is legal, print: "Thanks".


solution:

Console.WriteLine("Please enter int grade:");
int grade = int.Parse(Console.ReadLine());
while( grade<0 || grade>100 )
{
Console.WriteLine("Please enter int grade:");
grade = int.Parse(Console.ReadLine());
}
Console.WriteLine("Thanks");



More example for using while:
create function that get string, and count how many char 'a' exists until the first space.
Any string has one space at least.

for example:
"abbaacsd asdae" has 3 times 'a' before the first space.

Full post

94 weeks ago

1👍

0👎



שאלות בנושא מחרוזות, פתרונות בשפת C#.

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


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


שאלה שלישית:
כתבו פעולה המקבלת מחרוזת ובודקת איזה תו הוא השכיח ביותר. כמו כן הפעולה מחזירה תו זה. ידוע כי התווים האפשריים הם a,b,c,d בלבד.





פתרון שאלה ראשונה:


public static bool palindrom(string text)
{
for(int i=0; i<text.Length/2;i++)
{
int s = i;
int e = text.Length-1-s;
if( text[s] != text[e] )
return false;
}

return true;
}

Full post

94 weeks ago

1👍

0👎



מדעי המחשב, קיץ תש"ף, מס' 899381 מדעי המחשב בגרות פתרו בשפת JAVA
באכסניית הנוער "חלומות טובים" יש 3 קומות, 3-1 . באכסניה 200 חדרים סך הכול.
תרגיל מספר 3

סעיף א
public int income()
{
int price = 50;
if(roomType == 2)
price = 100;

return nightsReserved*price;
}

פתרון סעיף ב

public int orderRoom(int type, int nights) {
for(int i=0; i<allRooms.length; i++)
{
Room r = allRooms[i]];
if( type == r.type && r.night==0)
{
r.nights = nights;
return room.getNumber();
}
}
return -1;
}


סעיף ג
public int [] floorIncode()
{
int sum = 0;
int [] arr = new arr[3];

for(int i=0; i<allRooms.length; i++)
{
int floor = allRooms[i].getRoomNum()/100;
arr[floor] += allRooms[i].income();
}
return arr;
}

Full post

94 weeks ago

1👍

0👎



פתרון בחינת בגרות שאלון 271 מדעי המחשב תשפ"ד 2024 שאלה 13 בנושא תכנות מונחה עצמים


public class AA{
private int x;
public AA()
{
this.x= 2;
}

public AA(int x)
{
this.x=x;
}

public AA(AA a)
{
this.x = a.x;
}

}

public class BB{
private AA f;

public BB()
{
super(1);
}

public BB(int x, AA a)
{
super(x);
this.f = new AA(a); // יוצרים משתנה חדש
}

public BB (AA a)
{
super(x);
this.f = a; // יש הצבעה
}
}

Full post

94 weeks ago

0👍

0👎



כללי אצבע בהורשה בשפת java - תכנות מונחה עצמים.

כלל ראשון
כל המחלקות יורשות בצורה זו או אחרת מהמחלקה: Object.
לכן כל מחלקה שניצור, תיצור גם אובייקט מטיפוס Object.

למשל שני הביטויים יהיו שקולים:
ביטוי ראשון:
public class Student{
}
ביטוי שני:
public class Student extends Object{
}

לכל מחלקה בשפה יש את הפעולות של המחלקה Object, למשל:
toString()
equals()


ניצור לדוגמה את המחלקה Person:
public class Person{
private String name;
public Person(String name)
{
this.name = name;
}
}
ניצור לדוגמה את המחלקה Student:
public class Student{
private String name;
private int grade;

public Student(String name, int grade)
{
this.name = name;
this.grade = grade;
}
}
ניתן לראות שגם ל Person וגם ל Student יש את אותה תכונה: name, קוד שחוזר על עצמו זה קוד לא טוב!


לכן נשתמש בפתרון שיש לשפה להציע והוא: ירושה.

public class Student extends Person{
private int grade;

public Student(String name, int grade)
{
super(name);
this.grade = grade;
}

}

עכשיו המחלקה Student יורשת מהמחלקה Person.

בעצם שאנחנו יוצרים Student מה באמת נוצר? ומה הסדר של היצירה?
הראשון שנוצר: Object
השני שנוצר: Person
השלישי שנוצר: Student.

לכן לתלמיד בזמן ריצה יהיו את כל הפעולות שיש ל-Object, ל Person ול-Student.

Full post

94 weeks ago

0👍

0👎



כתוב פעולה רקורסיבית המקבלת שרשרת חוליות מטיפוס מספר שלם ושני מספרים שלמים: מספר x ומספר y. הפעולה תגדע (תסיר) את כל האיברים בין שני מספרים אלו. ידוע כי ברשימה קיימים שני המספרים כך שהמספר x יופיע ברשימה לפני המספר y. אין למחוק את המספר x ואת המספר y, אלא מה שביניהם.
שם הפונקציה יהיה remove. ניתן להשתמש בהעמסה.
ידוע ש-x ו-y שונים זה מזה.

lst → 1 → 2 → 3 →4 → 5 → 6 → 7 → 8 → null
x=3
y=7

הרשימה תיראה לאחר הפעלת הפונקציה כך:
lst → 1 → 2 → 3 → 7 → 8 → null

פתרון מלא בשפת C#:
public static void Remove(Node<int> lst , int x, int y)
{
Remove( lst, x,y, null)

}

הפרמטרים לא מספיקים לנו, לכן נבצע העמסה:

public static void Remove(Node<int> lst , int x, int y, Node<int> xNode)
{
if( xNode == null && lst.GetValue()==x)
{
xNode = lst;
}
else if( xNode != null && lst.GetValue()==y )
{
xNode.SetNext(lst); //removing numbers between x and y
return;
}

Remove(lst.GetNext() , x, y ,nodeX);
}

Full post

95 weeks ago

0👍

0👎



שאלה בנושא תור מדע המחשב
כתוב פעולה בשפת C# המקבלת תור של מחרוזות. תור מנצח הוא תור שבו סוף כל מחרוזת היא התחלה של המחרוזת הבאה אחריה בתור. הפעולה תחזיר אמת אם התור שהתקבל הוא תור מנצח, אחרת שקר. שם הפונקציה יהיה Victory.
אין חובה לשמור על התור!

דוגמה לתור מנצח:
ראש התור← "ALMOG" ← "GOMLA" ← "APPPLE ← "EGG"←סוף התור

פתרון מלא:
public static bool Victory (Queue<string> q)
{
string pre="",cur="" ; //previous, current
if(!q.IsEmpty())
{
pre = q.Remove();

}

while( !q.IsEmpty())
{
cur = q.Remove();
char first = cur[0];
char last = pre[pre.Length-1];

if(first != last)
return false;
pre = cur; // הנוכחי כרגע הופך להיות הקודם של הבא בתור
}
return true;
}

Full post

95 weeks ago

0👍

0👎



שאלות במדעי המחשב בנושא מחרוזות:
סעיף א'
כתבו פעולה המקבלת מחרוזת ובודקת אם הוא פלינדרום. פלינדרום הוא טקסט שנכתב מימין ומשמאל באופו זהה. למשל: aba, 123321...
אם הוא פלינדרום נחזיר אמת, אחרת שקר.

סעיף ב'
כתבו פעולה המקבלת מערך של מחרוזות ומחזירה כמה מתוכן הם פלינדרומים.

פתרון סעיף א'
public static bool IsPali (string str)
{
for( int i=0 , j=str.Length-1; i<j ; i++,j--)
{
if(str[i] != str[j])
return false;
}
return true;

}



פתרון סעיף ב'

public static int CountPali( string [] str )
{
int counter=0;
for(int i=0; i<str.length; i++)
{
if(IsPali(str[i]))
counter++
}
return counter;
}

Full post

95 weeks ago

0👍

0👎



שאלה בנושא מחרוזות סעיף א:
כתבו פעולה אשר מקבלת מחרוזת ותחזיר מחרוזת חדשה המכילה את כל התווים במקומות הזוגיים.
למשל עבור המחרוזת הבאה: "ABCDEFG" המחרוזת שתוחזר: "ACEG".

פתרון בשפת C#
// Even זה זוגי
public static string Even (string st)
{
string result = "";
for( int i=0; i< st.Length ; i++)
{
if(i%2==0) // בודק האם הערך הוא זוגי
result=result+st[i]; // משרשר את התו לתוצאה
}
return result;
}

בסעיף ב'
כתוב פעולה שתקבל מערך של מחרוזות. הפעולה תחזיר מחרוזת אחת גדולה המורכבת מכל המקומות הזוגיים בכל המחרוזות. ניתן להשתמש בסעיף א'.

public static string Even(string [] st)
{
string result="";
for (int i=0; st.Length; i++)
{
result=result+Even(st[i]); // שימוש בפונקציה מסעיף א
}
return result;
}

Full post

95 weeks ago

0👍

0👎



מועד קיץ נבצרים תשפ"א 2021 פתרון בשפת C# מדעי המחשב בגרות 899381
שאלה 1 בנושא מחרוזות

public static bool IsDouble (string str )
{
int size = str.Length;
if ( size%2 == 1 )
return false;

int i=0, j=size/2;
while(j< size )
{
if( str[i] != str[j])
return false;
i++;
j++;
}
return true;
}

Full post

95 weeks ago

0👍

0👎



בעיית שמונה המלכות היא חידת שחמט שבה יש למקם שמונה מלכות על לוח שחמט כך שאף אחת מהן לא מאיימת על אף אחת מחברותיה.

כתוב פעולה המקבלת מערך דו ממדי של טקסט מחרוזות, המייצג לוח של 8 מלכות.
מיקום של מלכה יסומן ב "QUEEN" ואילו מיקום ריק יסומן ב "".

הפעולה תחזיר אמת אם אף מלכה לא מאיימת על אף מלכה אחרת, אחרת שקר.

על חתימת הפונקציה להיראות כך:
public static bool IsEightQueensOk(string[,] chess)


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

// האם קיימת מלכה מצד ימין שלי
public static bool Right(string[,] chess, i,j)
{
j++;
while(j<8)
{
if( chess[i,j] == "QUEEN")
return true;
j++;
}
return false;
}


// האם קיימת מלכה מצד שמאל שלי
public static bool Left(string[,] chess, i,j)
{
j--;
while(j>=0)
{
if( chess[i,j] == "QUEEN")
return true;
j--;
}
return false;
}



// האם קיימת מלכה מעליי
public static bool Up(string[,] chess, i,j)
{
i--;
while(i>=0)
{
if( chess[i,j] == "QUEEN")
return true;
i--;
}
return false;
}


// האם קיימת מלכה מעליי
public static bool Down(string[,] chess, i,j)
{
i++;
while(i<8)
{
if( chess[i,j] == "QUEEN")
return true;
i++;
}
return false;
}



// האם קיימת מלכה בצד האלכסון הימני עליון
public static bool DiagonUpRight(string[,] chess, i,j)
{
i--; j++;
while(i>=0 && j<8)
{
if( chess[i,j] == "QUEEN")
return true;
i--; j++;
}
return false;
}



// האם קיימת מלכה בצד האלכסון השמאלי עליון
public static bool diagonUpLeft(string[,] chess, i,j)
{
i--; j--;
while(i>=0 && j>=0)
{
if( chess[i,j] == "QUEEN")
return true;
i--; j--;
}
return false;
}


// האם קיימת מלכה בצד האלכסון ימני תחתון
public static bool DiagonDownRight(string[,] chess, i,j)
{
i++; j++;
while(i<8 && j<8)
{
if( chess[i,j] == "QUEEN")
return true;
i++; j++;
}
return false;
}



// האם קיימת מלכה בצד האלכסון שמאלי תחתון
public static bool diagonDownLeft(string[,] chess, i,j)
{
i++; j--;
while(i<8 && j>=0)
{
if( chess[i,j] == "QUEEN")
return true;
i++; j--;
}
return false;
}

לאחר כל פעולות העזר, נבנה את הפעולה הראשית:

public static bool IsEightQueensOk(string[,] chess){

for(int i=0; i<8; i++)
for(int j=0; j<8; j++)
{
if( chess[i,j] =="Queen")
if( Right(chess, i, j) || Left(chess, i, j) || Up(chess, i, j) || Down(chess, i, j) || DiagonUpRight(chess,i,j) || DiagonUpLeft(chess,i,j) || DiagonDownRight(chess, i, j) || DiagonDownLeft(chess, i , j) )
return false; // נמצאה מלכה מאיימת

}

return true; // אין איום אחד על השני
}

Full post

95 weeks ago

0👍

0👎



שאלון 899381 מדעי המחשב ב' קיץ תשע"ו 2015 שאלה מספר שלוש פתרון בשפת C#



שאלה 3 סעיף א' נבנה פעולה בונה
public TvProgram(int code, int day, bool isSport)
{
this.code= code;
this.day = day;
this.isSport = isSport;
}


סעיף ב' (1) - נבנה את כותרת המחלקה TvWeek ואת התכונות שלה:

public class TvWeek{

private TvProgram [] arrProg = new TvProgram[100]; // 0-99
private int current = 0;

}

סעיף ב' (2) פעולה המוסיפה תכנית

public void AddTvProgram(TvProgram program )
{
arrPro[current] = program;
current++;
}

סעיף ב' (3) ספירת כל תכניות הספורט שיש בשבוע

public int CountSport()
{
int counter=0;
for(int i=0; i<current ; i++)
if(arrProg[i].GetIsSport())
counter++;
return counter;
}

Full post

95 weeks ago

0👍

0👎



שאלון 899381 מדעי המחשב ב' קיץ תשע"ו שאלה מספר שלוש פתרון בשפת C#


סעיף א' נבנה פעולה בונה למחלקה Game:
public Game(string gameName, int numPlayers, bool isWater)
{
this.gameName = gameName;
this.numPlayers = numPlayers;
this.isWater = isWater;
}


סעיף ב' (1)- נבנה את כותרת המחלקה Country ואת התכונות שלה

public class Country{
private string countryName;
private Game [] games;
}

סעיף ב' (2)- נבנה פעולה בונה
public Country (string countryName){
this.countryName = countryName;
games = new Game[43];
}

סעיף ב' (3)

public bool IsPlaying(string gameName)
{
for(int i=0; i<games.Length;i++)
{
// if(games[i]!=null && games[i].GetGameName()==(gameName) )
if(games[i]!=null && games[i].GetGameName().Equals(gameName) )
return true;

}
return false;
}

Full post

95 weeks ago

0👍

0👎



דוגמה למחלקה מורכבת / טיפוס מורכב בשפת C#:
המחלקה Classroom היא אוסף של Student

public class Student{
private String name;
private String lName;
private String id;


public Student (String name, String lName, String id)
{
this.name = name;
this,lName = lName;
this.id = id;
}
}




public class Classroom{
private Student [] students;
private int count;

public Student()
{
students = new Student[30];
count= 0;
}

public bool addStudent(Student s)
{
if(s.Length =< count)
return bool; //not enough space
students[count] = s;
count++;

}

// print all names of Students
@override
public override string Tostring()
{
string s = "";
for(int i=0; i<count ; i++)
{
s+="full name: "+ students[i].GetName() +" "+students[i].GetLName();+"\n";
}
return s;
}

}

Full post

95 weeks ago

0👍

0👎



פתרון בגרות מדעי המחשב 2024 קיץ מדעי המחשב, קיץ תשפ"ד, מס' 899381
שאלה מספר 1 שאלה ראשונה פתרון בשפת C#

public static int BiggestSum(int [] arr)
{
int max = 0;
int sum=0;
bool f=false; //first;
for(int i=0; i<arr.Length; i++)
{
// פעם ראשונה שפוגשים אפס
if(arr[i] == 0 && !f )
{
f=true;
}
else if ( f && arr[i] != 0)
{
sum+=arr[i];
}
else if (f && arr[i]==0)
{
if(sum>max)
max = sum;
sum=0;
}

}


}

Full post

95 weeks ago

0👍

0👎



סוגי משתנים בשפת C#
int = מספרים שלמים
דוגמאות: 3,0,3-

double = מספרים עשרוניים
דוגמאות: 0.0, 3.14

char = תו בודד
דוגמאות: '3','?',' '

sting = אוסף של תווים או מחרוזת
דוגמאות: "a","Almog"...

bool = משתנה בוליאני
דוגמאות: true, false

דוגמה להגדרת משתנה בוליאני:
bool f = false;
f= true;
if (f ) // האם אמת
if( f ==true ) האם אמת
if (!f) האם שקר
if(f == false)

Full post

95 weeks ago

0👍

0👎



תוצאות סקר מדעי המחשב על בחינת הבגרות בו השתתפו מורים ותלמידים מכל רחבי הארץ. הבחינה התקיימה בתאריך 23.5.2024 בזמן מלחמת חרבות ברזל. השאלונים שבהם התלמידים נבחנו הם :899271 ו-899381 שנערכו ב-23 במאי 2024.


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


להלן התוצאות:

ניתוח

רמת קושי לפי תפקיד

  1. רוב התלמידים ציינו שהמבחן היה קשה (hard) או מאוד קשה (very_hard).
  2. המורים מציינים גם כן שהמבחן היה קשה, אך ישנם גם מורים שציינו רמה בינונית.

הערות לפי רמת קושי

  1. ברמת הקושי הגבוהה ביותר (very_hard), הערות רבות מתארות את הבחינה כלא הוגנת, במיוחד לאור המצב הביטחוני והמלחמה.
  2. ברמת הקושי הקשה (hard), התלונות מתמקדות בעיקר בניסוח לא ברור ושאלות מסובכות.
  3. ברמת הקושי הבינונית (medium), התלמידים והמורים מציינים כי היו שאלות קשות, אך גם שאלות מאוזנות.

התפלגות רמת הקושי לפי יישוב

  1. תלמידים מחדרה ואשקלון ציינו את המבחן כקשה במיוחד.
  2. בתל אביב היו תלמידים שהעריכו את המבחן כרמה בינונית, אך היו גם תלמידים שהעריכו אותו כרמה קשה או קשה מאוד.
  3. גם באשדוד העריכו את המבחן כרמה קשה מאוד.

מסקנות

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

Full post

95 weeks ago

0👍

0👎




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

פתרון בשפת JAVA:
public static void delete(Node<Integer> lst , int num)
{
Node<Integer> p= lst;
if(p==null)
return;

while( p.hasNext()) // p.getNext() !=null
{
if(p.getNext().getValue() == num)
{
p.setNext(p.getNext().getNext()); //remove delete
return;
}
p=p.getNext();
}

}


Full post

96 weeks ago

0👍

0👎



תרגיל בחוליות שרשרת חוליות
כתבי פעולה בשם getPosition שתקבל כפרמטר רשימה של מספרים שלמים ומספר שלם, ותחזיר הפניה למקומו של האיבר הראשון ברשימה שערכו מספר זה, אם הערך לא קיים ברשימה יוחזר null.

פתרון בשפת JAVA:
public static Node<Integer> getPosition (Node<Integer> lst, int num)
{
Node<Integer> p = lst;

while(p!=null)
{
if(p.getValue() == num)
return p; //הפנייה לחוליה

p=p.getNext();
}

return null;

}


Full post

96 weeks ago

0👍

0👎



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

פתרון בשפת java ג'אווה:
public static boolean exist ( Node<Integer> lst , int num )
{
Node<Integer> p = lst;
while(p!=null)
{
if( p.getValue() == num)
return true;
p=p.getNext(); // לקדם את המצביע
}
return false;
}

Full post

96 weeks ago

0👍

0👎



בנייה והצגת רשימה:
תרגיל 1: פעולה בשם build הבונה ומחזירה רשימה של מספרים שלמים לפי קלט המשתמש. אורך הרשימה לפחות 10 איברים.
תרגיל 2: פעולה בשם build המקבלת כפרמטר 3 מספרים שלמים: len, from, to יוצרת ומחזירה רשימה של מספרים שלמים אקראיים באורך len איברים. כל האיברים יהיו בין הערכים from עד to.

פתרון תרגיל 2 בשפת java:

import java.util.Random();
public static Node<Integer> build(int len, int from , int to)
{

Random rnd = new Random();

Node<Integer> result = new Node<Integer>(-1,null); //נשאר בהתחלה
Node<Integer> p = result; //תמיד יהיה בסוף הרשימה
for( int i=0; i<len;i++)
{

int value = rnd.nextInt(from,to+1); // from : to
Node<Integer> n = new Node<Intger>( value, null ); //new node
p.setNext(n);
p =p.getNext(); // מקדמים את המצביע צעד אחד קדימה

}

return result.getNext();

}





Full post

96 weeks ago

0👍

0👎



מהי רשימה מקושרת בשפת Java?
רשימה מקושרת בשפת Java היא מבנה נתונים דינמי אשר באמצעותו אפשר לשמור אוסף של נתונים מאותו טיפוס בצורה מפוזרת בזיכרון.
בניגוד למערך, שהוא מבנה נתונים סטטי (קבוע), שבו הנתונים יושבים בזה אחר זה, אחד ליד השני, וגודלו של המערך ידוע, ברשימה אין אנו יודעים את הגודל והאיברים בזיכרון יושבים באופן אקראי.

בעצם רשימה מקושרת בנויה מחוליות (nodes), כאשר כל חולייה מכילה שני דברים:
  1. Value - ערך בעל טיפוס: Integer, Character, String או כל עצם אחר
  2. Next - מצביע לחוליה הבאה.

lst --> [ 4 ] --> [2] --> null

if we will do:
lst = lst.getNext();
we get:
lst --> [2] --> null

if we will do:
int x = lst.getValue(); // 2

Full post

96 weeks ago

0👍

0👎



פתרון מלא בגרות מדעי המחשב, קיץ תשפ"ד, שאלון מספר 899381
שאלה מספר 2

פתרון בשפת Java
public class Member{
private String name;
private boolean isCoal;

public boolean getIsCoal()
{
return isCoal;
}

}

public class Committee{
private String name;
private Member [] members;
private int count;

// סעיף ב
public int total(boolean belong)
{
int counter=0;
for(int i=0; i<count ; i++)
{
if(members[i].getIsCoal()==belong)
counter++;
}
return counter;
}

public int getCount()
{
return count;
}
}


// סעיף ג נכתב במחלקה חיצונית

public static int amount ( Committee [] arr , Member m )
{
int counter=0;

for(int i=0; i<arr.length;i++)
{
if( arr[i].getCount()<16 )
{
int coal = arr[i].belong(true);
int notCoal = arr[i].belong(false);

if(m.getIsCoal())
counter++;

else if( notCoal+1 <coal )
counter++;
}

}

return counter;
}

Full post

97 weeks ago

0👍

0👎



תרגיל 22: הזוג הכי גדול פתרון בשפת Java:

int counter=0;
int max=0;

System.out.println("Please enter pair of numbers:");
int x= reader.nextInt(); // or input.nextInt();
int y= reader.nextInt(); // or input.nextInt();


int xMax = 0;
int yMax=0;
while( x%2 == y%2 ) // כל עוד שניהם זוגיים או שניהם אי זוגיים
{

if(counter ==0 || (x+y) > max)
{
xMax = x;
yMax = y;

max = xMax + yMax;
}
counter++;

System.out.println("Please enter pair of numbers:");
x= reader.nextInt(); // or input.nextInt();
y= reader.nextInt(); // or input.nextInt();

}

System.out.println("The number of pairs is "+counter+" and the biggest is "+xMax+" and "+yMax);


Full post

97 weeks ago

0👍

0👎



שאלה שטיחי דשא (גיא החלקאי.. דן הגנן):

פתרון ב-Java:

int size =0;
int quantity = 0;

while( size<200 )
{
System.out.println("Please enter width and height:");
int w = reader.nextInt();
int h = reader.nextInt(); // or input.nextInt();
quantity++;
size=size+w*h;
}
System.out.println("The quantity is "+quantity+", the price is "+30*quantity);




פתרון ב-C#:

int size =0;
int quantity = 0;

while( size<200 )
{
Console.WriteLine("Please enter width and height:");
int w = int.Parse(Console.ReadLine());
int h = int.Parse(Console.ReadLine());
quantity++;
size=size+w*h;
}
Console.WriteLine("The quantity is "+quantity+", the price is "+30*quantity);

Full post

97 weeks ago

0👍

0👎



מהי לולאת while?
לולאת while היא בלוק (תחום בסוגריים מסולסלות) שיכול לקרות: 0 פעמים, פעם אחת... פעמיים.. שלוש פעמים.. עד אינסוף.
בעצם מדובר בקוד שחוזר על עצמו.

דוגמה ללולאה while אינסופית:
while( 1==1)
{
//...
}

דוגמה נוספת
while(true)
{
//...
}


דוגמה לולאת while שתקרה 4 פעמים (עדיף להשתמש בלולאת for בשביל זה):

int i=0;
while(i<4)
{
i++;
}

דוגמה ללולאת for שתקרה 4 פעמים:
for(int i=0; i<4;i++)
{
//..
}


נהוג להשתמש בלולאת while כאשר אפשר להכניס את הביטוי "כל עוד" (=while).
למשל כל עוד הכנסת ציון לא תקין, קלוט שוב!

int grade =-1;
while( grade<0 && grade>100 )
{
System.out.println("Please enter grade: "); // C# Console.WriteLine("Please enter grade: ");
grade = input.nextInt(); // C# grade = int.Parse(Console.ReadLine());
}

דוגמה לשימוש בלולאת while:
קלוט מספרים עד אשר יכניסו את המספר מינוס אחד.
int x = 0;
while(x!=-1)
{
// קלוט את איקס
}

Full post

97 weeks ago

0👍

0👎




לשאלה המלאה לחצו כאן

מחיר כרטיס לסרט שובר קופות הוא 45 שקלים

פתרון סעיף א בשפת C#
public static int prices()
{
int pricePerOne = 45;
int max = 0; // שומר את המקסימום
int position = 0; // מחזיק במיקום התור של המקסימום

for(int i=1; i<=10; i++)
{
Console.WriteLine("How many tickets do you want?);
int tickets = int.Parse(Console.ReadLine());
int price = tickets*pricePerOne ;

if( price >max )
{
max = price;
position = i;
}

Console.WriteLine("The final price is: "+price);

}

return position;
}


פתרון סעיף ב' בשפת C#

int counter=0;
for(int i=0; i<7; i++)
{
for(int j=0; j<10; j++)
{
if( prices()==1)
counter++;

}


Console.WriteLine("The answer is:"+counter);
}

Full post

98 weeks ago

0👍

0👎



שאלה ראשונה (מבוסס על מצגת הסרטונים שנערכה על ידי תומר לביא)
כתבו פעולה בשם getNum אשר מקבלת פרמטר מספר שלם num וקולטת מהמשתמשים מספר שלם בין 1 ל-num. אם המספר שהוזן מחוץ לתחום - יתבצע קלט נוסף עד שייקלט מספר תקין. לסיום, החזירו (=return) את הקלט התקין.
בדקו את עצמיכם על ידי זימון הפעולה getNum(50.

import java.util.Scanner;

public class Main
{
public static Scanner input = new Scanner (System.in);



public static int getNum(int num)
{
System.out.println("Please enter number between 1 to "+ num);
int x = input.nextInt();
while( x<1 || x>num ) //כל עוד המספר לא בתחום, צריך לקלוט מחדש
{
//קליטה נוספת
System.out.println("Please enter number between 1 to "+ num);
x = input.nextInt();
}
return x;
}
public static void main(String[] args) {
System.out.println("Hello World");
int reuslt = getNum(50);
System.out.println(result);
}
}

Full post

98 weeks ago

0👍

0👎



מדעי המחשב, קיץ תשפ"ד, שאלון 899381 בגרות, שאלה שנייה שאלה 2 פתרון בשפת java ובשפת C# סי שארפ

שאלה 2 סעיף א' שפת java:
public class Member 
{ 
private String name; 
private boolean isCoal; 
}

public class Committee 
{ 
private String name; 
private Member[] members; 
private int count;
}

שאלה 2 סעיף ב' שפת C#:
public class Member 
{ 
private string name; 
private bool isCoal; 
}

public class Committee 
{ 
private string name; 
private Member[] members; 
private int count;
}


שאלה 2 סעיף ב' שפת java
פעולה פנימית במחלקה total:
public int total(boolean belong)
{
int sum = 0;
for (int i = 0; i < this.count; i++)
if (this.members[i].getIsCoal())
sum++;

if (belong)
return sum;

return count - sum;
}


שאלה 2 סעיף ב' שפת C# סי שארפ
פעולה פנימית במחלקה total:
public int Total(bool belong)
{
int sum = 0;

for (int i = 0; i < this.count; i++)
if (this.members[i].GetIsCoal())
sum++;

if (belong)
return sum;

return count - sum;
}



שאלה 2 סעיף ג
פעולה חיצונית בשפת java:
public static int amount(Committee[] arr, Member m) 
{ 
int count = 0; 

for (int i = 0; i < arr.length; i++) 
{
Member[] members = arr[i].getMembers(); 
int index = 0; 

for (int j = 0; j < arr[i].getCount(); j++) 
if (members[j].getName().equals(m.getName())) 
index = j; 

boolean isCoal = members[index].getIsCoal(); 

if (arr[i].getCount() < 16) 
if (isCoal || arr[i].total(true) > arr[i].total(false) + 1) 
count++; 
} 

return count; 
} 


שאלה 2 סעיף ג
פעולה חיצונית בשפת C#:
public static int Amount(Committee[] arr, Member m) 
{ 
int count = 0; 

for (int i = 0; i < arr.Length; i++) 
{
Member[] members = arr[i].GetMembers(); 
int index = 0; 

for (int j = 0; j < arr[i].GetCount(); j++) 
if (members[j].GetName().Equals(m.GetName())) 
index = j; 

bool isCoal = members[index].GetIsCoal(); 

if (arr[i].GetCount() < 16) 
if (isCoal || arr[i].Total(true) > arr[i].Total(false) + 1) 
count++; 
} 

return count; 
} 

Full post

98 weeks ago

0👍

0👎



מדעי המחשב, קיץ תשפ"ד, שאלון 899381 בגרות, שאלה ראשונה שאלה 1 פתרון בשפת java ובשפת C# סי שארפ

Java:
public static int biggestSum(int[] arr)
{
int max = 0, i = 0;
while (arr[i] != 0)
i++;

i++;

while (i < arr.length && arr[i] != 0)
{
int sum = 0;
while (i < arr.length && arr[i] != 0)
{
sum += arr[i];
i++;
}
if (i < arr.length && sum > max)
max = sum;

i++;
}

return max;
}


C#:
public static int BiggestSum(int[] arr)
{
int max = 0, i = 0;
while (arr[i] != 0)
i++;

i++;

while (i < arr.Length && arr[i] != 0)
{
int sum = 0;
while (i < arr.Length && arr[i] != 0)
{
sum += arr[i];
i++;
}
if (i < arr.Length && sum > max)
max = sum;

i++;
}

return max;
}

Full post

98 weeks ago

0👍

0👎



סקר מדעי המחשב הגדול בישראל

אני מזמין אתכם להשתתף בסקר הפרטי שיצרתי (מטעמי בלבד) ושמו "סקר מדעי המחשב הגדול בישראל". הסקר מיועד לתלמידים שניגשו לשאלונים 899271 ו-899381 שנערכו ב-23 במאי 2024. מטרת הסקר היא לאסוף משוב על רמת הקושי של הבחינות וההוגנות שלהן, במיוחד בהתחשב בכך שחלק גדול מהתלמידים היו מיישובים מפונים.הסקר נועד לסייע להבין את החוויה שלכם כתלמידים ובתקווה לעזור בשיפור תהליך ההוראה וההבחנות בעתיד. חשוב לקבל משוב מגוון מכל רחבי הארץ כדי שנוכל לבחון האם הבחינות היו הוגנות ומתאימות לרמת הלימודים שלכם.כולי תקווה שעל ידי השתתפותכם בסקר, תוכלו לתרום לשיפור מערכת החינוך במדעי המחשב ולהבטיח שהתלמידים בעתיד יזכו לבחינות הוגנות ומאוזנות יותר.

סקר בחינות במדעי המחשב - שאלונים 899271 ו-899381




















Full post

98 weeks ago

0👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 2024 פתרון מלא שאלה אחת בשפת Java שאלון בגרות שאלה מספר 3 Java שאלה שלוש מעקב רקורסיה שפת C#



3.א.2.
הפעולה what מסירה את כל החוליות שערכן x ומחזירה את הרשימה החדשה.
3.א.3.
הסיבוכיות של הפעולה what היא O(n) כאשר n הוא אורך שרשרת החוליות.

3.ב.2.
הפעולה guess מסירה את כל האיברים הכפולים, כלומר משאירה עותק ראשון (זה שהכי קרוב לראש הרשימה lst) ואת שאר העותקים היא מסירה.
3.ב.3:
הפעולה guess עצמה סורקת את כל n חוליות (כאשר n הוא אורך הרשימה). בכל סריקה של חוליה היא מבצעת את הפעולה what שהיא בעצמה בעלת סיבוכיות O(n) לכן סך כל הסיבוכיות הוא O(n^2)

Full post

99 weeks ago

1👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 פתרון מלא שאלה אחת בשפת Java שאלון בגרות שאלה מספר 14 Java שאלה 14 תכנות מונחה עצמים שאלה 17 שפת C#



שאלה 14 תכנות מונחה עצמים

סעיף א



items[0]: AA --> x=4
items[1]: AA --> x=4 , y=2
items[2]: AA --> x=2
items[3]: AA --> x=2, y=4
items[4]: AA --> x=1, y=22
items[5]: AA -->items[4]

x = 4
x = 4 y = 2
x = 2
x = 2 y=4
x = 1 y=22
x = 1 y=22


ב
items[0]: AA --> x=3
items[1]: AA --> x=4 , y=3
items[2]: AA --> temp
items[3]: AA --> x=2, y=1
items[4]: AA --> x=1, y=0
items[5]: AA -->items[4]

temp: BB-->x=1, y=10


פלט
Temp: x = 1 y = 0
x = 2
x = 4 y = 3
x=1, y=10
x = 2 y=1
x = 1 y=0
x = 1 y=0




Full post

99 weeks ago

1👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 פתרון מלא שאלה אחת בשפת Java שאלון בגרות שאלה מספר 13 Java שאלה 13 תכנות מונחה עצמים



public class AA{
private int x;
public class AA()
{
x=2;
}
public AA(int x)
{
this.x=x;
}
public AA(AA a)
{
this.x=a.x;
}
}




public class BB{
private AA f;
public BB()
{
super(1);
f=null;
}
public BB(int a,AA a)
{
super(a);
f = a;
}
public BB(AA a)
{
super(0);
f = super(a4);
}
}


Full post

99 weeks ago

1👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 פתרון מלא שאלה אחת בשפת Java שאלון בגרות שאלה מספר 5 Java שאלה חמישית



//5.א
public static int width(Node<Integer> lst,int num)
{
Node<Integer> p = lst;
int counter=0;
boolean found1 = false;
boolean found2 = false;
while(p!=null)
{
if(p.getValue() == num || p.getValue()==num*(-1))
{
if(!found1)
found1=true;
else
found2 =true;
}
if(found1)
counter++;
if(found2)
return counter;
p=p.getNext();
}
return -1;

}
//5.ב
public static int longest(Node<Integer> lst)
{
Node<Integer> p = lst;
int max = -1;
while(p!=null)
{
int size = width(p);
if(size>max)
max = size;
p=p.getNext();
}
return max;
}

Full post

99 weeks ago

0👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 פתרון מלא שאלה אחת בשפת Java שאלון בגרות שאלה מספר 3 Java שאלה שלישית

public class BusStation{

private int num;
private int [] arr = new int [10]; // מי שעוצר בתחנה
private int amount=0;

public int[] getArr(){
return arr;
}

public boolean isStopping(int n)
{
for(int i=0; i<amount;i++)
{
if(arr[i]==n)
return true;
}
return false;
}
}



//3.ב
public static Node<Integer> allStation(BusStation [] buses)
{
Node<Integer> result = new Node<Integer>(0,null);
Node<Integer> p = result;


BusStation b = buses[0];
int [] arr = b.getArr();


for(int i=0; i<arr.length;i++)
{
boolean correct = true;
for(int j=1; j<buses.length; j++)
{

if( !buses[j].isStopping(arr[i]) )
correct =false;
}
if(correct==true)
{
Node<Integer> n = new Node<Integer>(arr[i]);
p.setNext(n);
p=p.getNext();
}

}

return result.getNext();
}

Full post

99 weeks ago

0👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 פתרון מלא שאלה אחת בשפת Java שאלון בגרות שאלה מספר 3 Java שאלה שלישית

public class BusStation{
private int num;
private int [] arr = new int [10]; // מי שעוצר בתחנה
private int amount=0;
public int[] getArr(){
return arr;
}
public boolean isStopping(int n)
{
for(int i=0; i<amount;i++)
{
if(arr[i]==n)
return true;
}
return false;
}
}



//3.ב
public static Node<Integer> allStation(BusStation [] buses)
{
Node<Integer> result = new Node<Integer>(0,null);
Node<Integer> p = result;
BusStation b = buses[0];
int [] arr = b.getArr();
for(int i=0; i<arr.length;i++)
{
boolean correct = true;
for(int j=1; j<buses.length; j++)
{
if( !buses[j].isStopping(arr[i]) )
correct =false;
}
if(correct==true)
{
Node<Integer> n = new Node<Integer>(arr[i]);
p.setNext(n);
p=p.getNext();
}
}
return result.getNext();
}

Full post

99 weeks ago

0👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 פתרון מלא שאלה אחת בשפת Java שאלון בגרות

פתרון שאלה שנייה:

public class Patient{
private int id;
private int priority; //1-10
public int getPriority()
{
return priority;
}
public int getId()
{
return id;
}
public void setPriority(int p)
{
this.priority = p ;
}
}





public class PriorityQueue{
private Queue<Patient> q = new Queue<Patient>();
public void priorityInsert(Patient p)
{
Queue<Patient> temp = new Queue<Patient>();
if(q.isEmpty())
{
q.insert(p);
return ;
}
while(!q.isEmpty() && q.head().getPriority() >= p.getPriority())
temp.insert(q.remove());
temp.insert(p);
while(!q.isEmpty())
temp.insert(q.remove());
while(!temp.isEmpty())
q.insert(temp.remove());
}
public void update(int id, int pri)
{
Queue<Patient> temp = new Queue<Patient>();
while(!q.isEmpty() && q.head().getId()!= pri)
temp.insert(q.remove());
Patient p = q.remove(); //remove the patient
p.setPriority(pri);
while(!q.isEmpty())
temp.insert(q.remove());
while(!temp.isEmpty())
q.insert(temp.remove());
priorityInsert(p);
}
}

Full post

99 weeks ago

0👍

0👎



מדעי המחשב קיץ תשפ"ד 899271 פתרון מלא שאלה אחת בשפת Java שאלון בגרות


public class Main
{
public static boolean isMagic(Queue<Integer> q, int m)
{
boolean correct = true;
Queue<Integer> temp = new Queue<Integer>();
if(q.isEmpty())
{
return false;
}
if(m==1)
return false;
int before=0;
int after=0;
for(int i=0; i<m-1;i++)
{
before = q.head();
temp.insert(q.remove());
}
int mid = q.head();
temp.insert(q.remove());

if(q.isEmpty())
correct = false;
after = q.head();
temp.insert(q.remove());
while(!q.isEmpty())
temp.insert(q.remove());

while(!temp.isEmpty())
q.insert(temp.remove());
return after+before==mid && correct;
}
public static void main(String[] args) {

Queue<Integer> q = new Queue<Integer>();
q.insert(5);
q.insert(11);
q.insert(6);

q.insert(9);
q.insert(3);
q.insert(6);


System.out.println(isMagic(q,2)); //true
System.out.println(isMagic(q,3)); // false
System.out.println(isMagic(q,4)); //true

}
}

Full post

99 weeks ago

0👍

0👎



שאלות כלליות מדעי המחשב בגרות בנושא תכנות מונחה עצמים, תמ"ע

שאלה ראשונה:

נניח וכל אחת מהמחלקות הבאות מקיימות את הירושה הבאה:
A extends Object
B extends A
C extends B
D extends C

בנוסף ידוע כי לכל מחלקה יש פעולה ייחודית:
A- print()
B-max()
C-min()
D-next()

כשמשנים נקות מבט למחלקה מסוימת, ואני רוצה להפעיל פעולה שיש רק למחלקה אחת, אז המחלקה תהיה חייבת להיות המחלקה שיש לה את הפעולה או שזו יכולה להיות מחלקה שיורשת ממנה, ולכן גם לה יש את הפעולה

לדוגמה:
A ac=new C()
ואני רוצה להפעיל על ac את הפעולה max של B אז איך אני עושה את זה באופן חוקי?

תשובה ראשונה:
באופן עקרוני כן, אם את יוצרת משתנה מטיפוס C אזי אז יוצרת משתנה מטיפוס Object,A,B,C ולכן באופן פוטנציאלי את יכולה להשתמש בכל אחת ואחת מהפונקציות שיש בכל אחד מהמחלקות הללו.
יש להתחשב בעקרונות ההורשה והפולימורפיזם:
העמסה / דריסה.. כך שאם במקרה למחלקה C יש גם פונקציית max עם החתימה הזהה בידיוק לזו שיש במחלקה C, אזי היא תדרוס אותה בזמן ריצה.

דבר נוסף חשוב גם להתחשב בעקרונות הכימוס:
כל פונקציה תכונה אשר מוגדרת כ-private לשימוש אך ורק במחלקה בה היא נכתבה.
כך פונקציה או תכונה אשר מוגדרת כ-protected ניתנת לשימוש אך ורק במחלקה בה היא נכתבה או במחלקות היורשות.
כל פונקציה או תכונה אשר מוגדרת כ public ניתנת לשימוש מכל מקום.

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

תשובה שנייה:
כעיקרון אם מדובר במשתנה מטיפוס C, אזי ניתן להמיר אותו ל-Object,A,B,C במידת הצורך.

בכל מקרה נהוג להשתמש במילה השמורה instanceof על מנת לוודא באמת האם אותו משתנה שייך למחלקה מסוימת (על מנת למנוע שגיאת זמן ריצה).

שאלה שלישית:
כשאני מנסה להמיר, הטיפוס שאני ממירה אליו חייב להיות תואם את הזמן קומפילציה?

תשובה שלישית:
זה לא חייב להיות תואם את זמן הקומפילציה. כמו בדוגמה הקודמת:
A ac = new C();
ניתן לבצע המרה:
((B) ac)

שאלה רביעי:
מה הכוונה כשמשווים שמות של עצמים? לדוגמה:
A a1=new A();
A ab =new B();
a1=ab;
אז עכשיו a1 הוא בעצם שווה לזמן קומפילציה של ab? לא הצלחתי להבין פשוט מה זה אומר כשמשווים בין עצמים, ואיזה עצם זה משנה.

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

עצם ההשוואה a1=ab, לא יוצרת שום דבר חדש, וגורמת לכך ש-a1 יחזיק ברפרנס של המשתנה ab.
צריך לזכור ש reference של הבן לא יכול להצביע על reference של אביו/סביו..

כלומר מצב תקין הוא:
father = father
father = son

ומצב לא תקין
son = father

שאלה חמישית:
בנוגע לדריסת פעולות, מיד הולכים לפונקציה שהכי נמוכה ?

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

שאלה שישית:
אם יש לי במחלקה שמורישה למחלקה אחרת ובאותה מחלקה שיורשת (נגיד a ו-b ) ולשתי המחלקות יש את אותה תכונה int x לדוגמה אז כשיש לי משהו כמו- A ab=new B (1,2); ואני רוצה להשתמש בפעולה שיש ב A והיא מקבלת את x ולשתי התכונות קוראים x בשתי המחלקות אז היא תפעל על ה-x של a או של b?

תשובה שישית:
נניח וקיימת המחלקות הבאות:
public class A{
protected int x;
public A(int x)
{
this.x=x;
}
}

public class B extends A{
protected int x;
public B(int x1,int x2)
{
super(x1);
this.x2=x2;
}
}

מבחינת בנאים.. הבעיה נפתרה (ראי כיצד בנינו את הבנאים ושלחנו את ה-x המתאים מבחינתנו לאבא.

מכיוון שבמקרה זה התכונה מוגדרת כ protected ניתן לגשת ישירות לתכונה x של A מתוך B וזאת על ידי שימוש במילה super.
בתוך B: אם נשתמש ב super,x נתכוון ל-x של האבא, ואם נשתמש ב x או this.x נתכוון ל-x של B.

במידה והתכונה x של A הייתה private היינו צריכים להיעזר ב getters או setters של האב (בתקווה שהם protected או public) בשביל לגשת לתכונה x של A מתוך B.

Full post

99 weeks ago

0👍

0👎



לחצו כאן עבור השאלה המלאה


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

האיבר בראש התור הוא 50 והוא שווה לסכום כל האיברים שבאים אחריו...

"תור מדהים" הוא תור שבו כל איבר הוא תור מופלא, וסדר הופעת האיברים בו בסדר יורד מהסכום הגדול ביותר של התור המופלא....

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

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

נכתוב פעולה אשרת מקבלת Queue תור של מספרים שלמים ומחזירה אמת אם וכאשר מדובר בתור מופלא. אחרת מחזירה שקר. נשים לב כי הפעולה איננה הורסת את התור!

נבנה פונקציית עזר בשם copy אשר מקבלת תור של מספרים שלמים ומחזירה העתק שלו. (וזאת מבלי להרוס את התור המקורי).

נשתמש בפעולת עזר של copy:
הסיבוכיות של פעולת השכפול היא: O(n) כאשר n הוא אורך התור (=כמותה האיברים בתור). בעצם אנחנו מרוקנים ומחזירים את כל התור כמה וכמה פעמים.
C#
public static Queue<int> Copy (Queue<int> q)
{
Queue<int> temp = new Queue<int>(); //empty Queue
Queue<int> result= new Queue<int>(); //empty Queue
while(!q.IsEmpty())
{
result.Insert(q.Head());
temp .Insert(q.Remove());
}

while(!temp.IsEmpty())
q.Insert(temp.Remove());

return result;
}

Java
public static Queue<Integer> copy (Queue<Integer> q)
{
Queue<Integer> temp = new Queue<Integer>(); //empty Queue
Queue<Integer> result= new Queue<Integer>(); //empty Queue
while(!q.isEmpty())
{
result.insert(q.head());
temp .insert(q.remove());
}

while(!temp.isEmpty())
q.insert(temp.remove());

return result;
}


מה הסיבוכיות של AmazingQueue:
קודם כל הסיבוכיות היא מינימום O(n) משום שהשתמשנו בפעולה הזאת פעם אחת בהתחלה.
בהמשך אנחנו מרוקנים את תור השכפול, פעולה שעלותה O(n), לכן סך הכל הסיבוכיות היא O(n)
C#:
public static bool AmazingQueue (Queue<int> queue)
{
Queue<int> q= copy(queue);

int f = 0; //first

if(!q.IsEmpty())
f = q.Remove();
else
return false;

int sum=0;

while(!q.IsEmpty())
sum+=q.Remove(); //sum=sum+q.Remove();
return sum==f;

}


Java:
public static boolean amazingQueue (Queue<Integer> queue)
{
Queue<Integer> q= copy(queue);

int f = 0; //first

if(!q.isEmpty())
f = q.remove();
else
return false;

int sum=0;

while(!q.isEmpty())
sum+=q.remove(); //sum=sum+q.remove();

return sum==f;

}


כעת נכתוב את הפעולה של סעיף א':
C#:
public static bool Awesome(Queue<Queue<int>> q)
{
Queue<Queue<int>> temp = new Queue<Queue<int>> ();
bool correct =true;
bool first = true;
int pre = 0;
while(!q.IsEmpty())
{
Queue<int> q1 = q.Remove();
if( !AmazingQueue(q1))
correct = false;
else if(first)
{
pre = q1.Head();
first = false;
}
else {
if( q1.Head() >= pre)
correct = false;
pre = q1.Head();
}

temp.Insert(q1);
}

// מחזיר את התור למצבו הראשון
while(!temp.IsEempty())
q.Insert(temp.Remove());
return correct;

}


Java:
public static bool awesome(Queue<Queue<Integer>> q)
{
Queue<Queue<Integer>> temp = new Queue<Queue<Integer>> ();
bool correct =true;
bool first = true;

int pre = 0;
while(!q.isEmpty())
{
Queue<Integer> q1 = q.remove();

if( !amazingQueue(q1))
correct = false;
else if(first)
{
pre = q1.head();
first = false;
}
else {
if( q1.head() >= pre)
correct = false;
pre = q1.head();
}

temp.insert(q1);
}

// מחזיר את התור למצבו הראשון
while(!temp.isEempty())
q.insert(temp.remove());

return correct;

}

סעיף ב
הסיבוכיות של הפעולה Awesome היא O(n*m) כאשר m הוא אורך התור של התורים (המתקבל בפונקציה Awesome ), ו-n הוא אורך התור המקסימלי שקיים מבין כל התורים של תור התורים.
עבור כל תור בתוך תור התורים, אנו מבצעים סריקה, מכאן הסיבוכיות. (ליד כל פעולת עזר הצגנו את הסיבוכיות הרלוונטית).

Full post

99 weeks ago

0👍

0👎



לשאלה המלאה לחצו כאן

נתונה המחלקה פרסומת Adv, המכילה את התכונות הבאות בהרשאת private:
תכונה ראשונה: שם הפרסומת - name מטיפוס מחרוזת
תכונה שנייה: כמות הקלקות בשבוע האחרון - clickCount

בנוסף נתונה המחלקה עשרת הגדולים TopTen המכילה את נתוני הפרסומות הכי מוצלחות של השבוע (אלו שהיו להן הכי הרבה הקלקות). למחלקה יש שתי תכונות בהרשאת private:
הראשונה: מערך של פרסומות בשם advArr
השנייה: מספר שלם המייצג את מספר השבוע בו נמדדו כמות ההקלקות weekNum.

המשך השאלה בקישור...

C#
public class TopTen{
private Adv [] arrAdv;
private int weekNum;


//פתרון סעיף א
C#
public void Add (Adv adv)
{
//check if there is an empty cell in array
for(int i=0; i<arrAdv.Length;i++)
{
if(arrAdv[i] == null)
{
arrAdv[i] = adv;
return; //fnish the function
}

}
int clicks = adv.GetClickCount();
int minIndex = 0;
int min = arrAdv[0].GetClickCount();
for(int i=1; i<arrAdv.Length;i++)
{
if( arrAdv[i].GetClickCount() <min)
{
min = arrAdv[i].GetClickCount() ;
minIndex = i;
}

}
if(adv.GetClickCount() > min) //רק אם מה שקיבלנו גדול יותר מהמינימום אז נחליף
arrAdv[minIndex] = adv;
}




//פתרון סעיף א
Java
public void add (Adv adv)
{
//check if there is an empty cell in array
for(int i=0; i<arrAdv.length;i++)
{
if(arrAdv[i] == null)
{
arrAdv[i] = adv;
return; //fnish the function
}

}
int clicks = adv.getClickCount();

int minIndex = 0;
int min = arrAdv[0].getClickCount();
for(int i=1; i<arrAdv.length;i++)
{
if( arrAdv[i].getClickCount() <min)
{
min = arrAdv[i].getClickCount() ;
minIndex = i;
}

}
if(adv.getClickCount() > min) //רק אם מה שקיבלנו גדול יותר מהמינימום אז נחליף
arrAdv[minIndex] = adv;
}


Full post

99 weeks ago

0👍

0👎



כתבו פעולה חיצונית בשם TillTen המקבלת מערך arr של מספרים שלמים. הפעולה מחזירה true אם כל המספרים מ-0 עד 10 (כולל) מופיעים בתאי המערך, אחרת מחזירה false.

שימו לב יכולים להיות מספרים בתאי המערך arr השונים מ-0 עד 10!

בעצם הבנו כי השאלה מכוונת לידי כך שנשתמש במערך מונים.

C#:
public static bool TillTen(int [] arr )
{
// מערך מונים
int [] counters = new int[11]; // 0-10

for(int i=0; i < counters.Length; i++)
counters[i] = 0;

for(int i=0; i<arr.Length; i++)
if(arr[i] >=0 && arr[i]<=10)
counters[arr[i]]++;

for(int i=0; i<counters.Length;i++)
if(counters[i] ==0)
return false;

return true;
}


Java:
public static bool tillTen(int [] arr )
{
// מערך מונים
int [] counters = new int[11]; // 0-10

for(int i=0; i < counters.length; i++)
counters[i] = 0;

for(int i=0; i<arr.length; i++)
if(arr[i] >=0 && arr[i]<=10)
counters[arr[i]]++;

for(int i=0; i<counters.length;i++)
if(counters[i] ==0)
return false;

return true;
}

Full post

99 weeks ago

0👍

0👎



מה מומלץ להביא כחומר עזר לבגרות במדעי המחשב?

אם יש ספר לימוד או חוברת מומלץ להביא!!

דבר ראשון:
מחלקה לדוגמה מההתחלה ועד הסוף כוללת: שם המחלקה, תכונות (private), מספר בנאים, פעולות מאחזרות וקבועות, פעולת תיאור עצם (toSting).

דבר שני:
פעולות עזר פופולריות כמו:
שכפול תור
ספירת איברים ברשימה

דבר שלישי:
כל הפעולות המותרות על מבנה נתונים כמו חולייה, תור ועוד...

דבר רביעי:
פתרונות משאלות קודמות

Full post

99 weeks ago

0👍

0👎



טיפים בנושא תכנות מונחה עצמים שפת C# ושפת Java


בנאי ריק קיים באחת משני הדרכים הבאות:
א. יצרו אותו
ב. אין שום בנאי אחר, אז הוא מתקיים "בלי שרואים אותו"


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

ב-Java, המושג Overloading, או בעברית "העמסה", מתייחס ליכולת ליצור מספר שיטות (methods) באותה מחלקה (class) עם אותו שם אך עם חתימות (signatures) שונות. החתימה של שיטה כוללת את שם השיטה ואת רשימת הפרמטרים שלה, כולל סוג הפרמטרים וסדרם.
כאשר מגדירים שיטות עם אותו שם אך עם רשימות פרמטרים שונות, המהדר של Java יודע להבחין בין השיטות לפי מספר הפרמטרים, סוגי הפרמטרים, והסדר שלהם. חשוב לציין שהחזרה של סוג שונה בלבד אינה מספיקה כדי לבצע Overloading - חייבים לשנות את רשימת הפרמטרים.


public class Calculator {
// שיטה לחיבור שני מספרים שלמים
public int add(int a, int b) {
return a + b;
}

// שיטה לחיבור שלושה מספרים שלמים
private int add(int a, int b, int c) {
return a + b + c;
}

// שיטה לחיבור שני מספרים מסוג double
public double add(double a, double b) {
return a + b;
}

// שיטה לחיבור מספרים double ומספר שלם
public double add(double a, int b) {
return a + b;
}
}


מהו המושג Override
ב-Java, המושג Override, או בעברית "דריסה", מתייחס למנגנון שבו מחלקה יורשת (subclass) מספקת מימוש (implementation) חדש לשיטה שכבר הוגדרה במחלקת האב (superclass). השיטה במחלקה היורשת חייבת להיות בעלת אותה חתימה כמו השיטה במחלקת האב, כלומר, אותו שם שיטה, אותם פרמטרים ואותו סוג חזרה. השימוש ב-Override מאפשר להתאים או לשנות את ההתנהגות של שיטות בירושה כדי לעמוד בדרישות המחלקה היורשת.

Full post

99 weeks ago

0👍

0👎



קישור לשאלה המלאה

סעיף א'
כתבו פעולה שמקבלת רשימה של רשימות של מספרים שלמים, בכל רשימה של מספרים שלמים יש ספרות (0-9) היוצרות מספרים שלם.
ראש הרשימה הוא האחדות, אחר כך עשרות וכו'.
כל המספרים כמובן חיוביים.

סעיף ב',
מהי הסיבוכיות (שימו לב חובה להתייחס לפעולות עזר שכתבתם)

ראשית נבנה פעולת עזר אשר תקבל רשימה של מספרים שלמים ותחזיר מספר שלם, הסיבוכיות של הפעולה:
O(n)
כאשר n הוא מספר החוליות ברשימה המקושרת.

פתרון בשפת Java:
Java:
public static int convertListToInt(Node<Integer> lst)
{
Node<Integer> p = lst;
int result=0;
int mul = 1;
while(p!=null)
{
result+=p.getValue()*mul; // result=result + p.getValue()*mul;
mul*=10; //mul=mul*10;
p=p.getNext();
}
return result;
}


C#:
public static int ConvertListToInt(Node<int> lst)
{
Node<int> p = lst;
int result=0;
int mul = 1;
while(p!=null)
{
result+=p.GetValue()*mul; // result=result + p.GetValue()*mul;
mul*=10; //mul=mul*10;

p=p.GetNext();
}
return result;
}

כעת נפתור את השאלה עצמה בשימוש פעולת העזר:

Java:
public static int findMax( Node<Node<Integer>> lst )
{
Node<Node<Integer>> p = lst;

int max=-1;
if(p!=null)
{
max = convertListToInt ( p.getValue());
p = p.getNext();
}
while(p!=null)
{
Node<Integer> h = p.getValue();
int n = convertListToInt (h);
if(n>max)
max = n;

p = p.getNext();
}
return max;
}


C#:
public static int FindMax( Node<Node<int>> lst )
{
Node<Node<int>> p = lst;

int max=-1;
if(p!=null)
{
max = ConvertListToInt ( p.GetValue());
p = p.GetNext();
}
while(p!=null)
{
Node<int> h = p.GetValue();
int n = ConvertListToInt (h);

if(n>max)
max = n;

p = p.GetNext();
}
return max;
}

סעיף ב
הסיבוכיות של פעולת העזר ConvertListToInt שלנו היא O(n) כאשר n הוא אורך הרשימה.
בפעולה FindMax אנו סורקים רשימה של רשימות, נניח שאורכה הוא m. עבור כל איבר ברשימה זו אנו מבצעים קריאה לפעולת העזר.
נניח שמתוך רשימת הרשימות, אורכה המקסימלי n, אזי נוכל להגיד: שהסיבוכיות היא O(n*m).
כלומר על כל רשימה מתוך רשימת הרשימות ביצענו את פעולת העזר.

Full post

99 weeks ago

0👍

0👎



פעולות עזר חשובות ברשימות בשפת C#

פעולה המקבלת רשימה של מספרים שלמים ומוחקת את האיבר הראשון שהיא רואה בעל הערך x ומחזירה הפנייה לרשימה המתוקנת.

C#:
public static Node<int> Remove(Node<int> lst, int x)
{

//empty list
if(lst ==null)
return lst;

// מחיקה מההתחלה
if(lst.GetValue()==x)
return lst.GetNext();

Node<int> p = lst;
//מחיקה מהאמצע או מהסוף
while( p.HasNext() )
{
if( p.GetNext().GetValue() == x)
{
p.SetNext( p.GetNext().GetNext() );
return lst;
}
p=p.GetNext();
}
return lst;
}




Java:
public static Node<Integer> remove(Node<Integer> lst, int x)
{

//empty list
if(lst ==null)
return lst;

// מחיקה מההתחלה
if(lst.getValue()==x)
return lst.getNext();

Node<Integer> p = lst;
//מחיקה מהאמצע או מהסוף
while( p.hasNext() )
{
if( p.getNext().getValue() == x)
{
p.setNext( p.getNext().getNext() );
return lst;
}
p=p.getNext();
}
return lst;
}



פעולה המקבלת רשימה של מספרים שלמים ומוחקת את כל אברי ה-x שהיא רואה ומחזירה הפנייה לרשימה המתוקנת.
C#:
public static Node<int> RemoveAllX(Node<int> lst, x)
{
Node<int> f = new Node<int> (-1, lst); // איבר מזויף

Node<int> p = f;

while(p.HasNext())
{
if(p.GetNext().GetValue() ==x) //delete x
p.SetNext( p.GetNext().GetNext() );
else
p = p.GetNext();
}

return f.GetNext();

}



java:
public static Node<Integer> removeAllX(Node<Integer> lst, x)
{
Node<Integer> f = new Node<Integer> (-1, lst); // איבר מזויף

Node<Integer> p = f;

while(p.hasNext())
{
if(p.getNext().getValue() ==x) //delete x
p.setNext( p.getNext().getNext() );
else
p = p.getNext();
}

return f.getNext();
}
}



הוספת איבר בתחילת הרשימה:
C#
public static Node<int> Add (Node<int> lst, x)
{
Node<int> n = new Node<int>( x, lst );
return n;
}



Java:
public static Node<Integer> add (Node<Integer> lst, x)
{
Node<Integer> n = new Node<Integer>( x, lst );
return n;
}


פעולת אשר מוסיפה איבר לרשימה בסדר עולה :
C#:
public static Node<int> Add (Node<int> lst , int x)
{
Node<int> n = new Node<int> (x,null); // יצירת חולייה חדשה שהערך שלה הוא איקס

if(lst==null) //empty list
return n;

if(lst.GetValue() >= x)
{
n.SetNext(lst);
return n;
}
Node<int> p = lst;


while( p.HasNext())
{
if(p.GetNext().GetValue()>=x)
{
n.SetNext( p.GetNext());
p.SetNext(n );
return lst;
}
}

p.SetNext(n); //הוספה לסוף

return lst;

}



java:
public static Node<Integer> add (Node<Integer> lst , int x)
{
Node<Integer> n = new Node<Integer> (x,null); // יצירת חולייה חדשה שהערך שלה הוא איקס

if(lst==null) //empty list
return n;

if(lst.getValue() >= x)
{
n.setNext(lst);
return n;
}
Node<Integer> p = lst;


while( p.hasNext())
{
if(p.getNext().getValue()>=x)
{
n.setNext( p.getNext());
p.setNext(n );
return lst;
}
}

p.setNext(n); //הוספה לסוף

return lst;

}

Full post

99 weeks ago

0👍

0👎



פתרון מלא מדעי המחשב, קיץ תשפ"ג, שאלון מספר 899381 2023
שאלה מספר 5

קישור לשאלה

c#:

public class NumCount
{
private int num;
private int count;

public NumCount(int num, int count)
{
this.num = num;
this.count = count;
}

public int GetNum()
{
return num; // return this.num;
}


public int SetCount(int count)
{
this.count = count;
}
}

נבחין כי קיימות שלוש אפשרויות:
אפשרות ראשונה: הרשימה ריקה, לכן ראש הרשימה lst יהיה חולייה חדשה.
אפשרות שנייה: קיימת חולייה שבה ה-num שלה שווה ל-x ואז נותר להעלות רק את count.
אפשרות שלישית: לא קיימות חולייה כזאת, וצריך להכניס את החולייה החדשה, כך שהסדר העולה ממש לא ייפגע.
אפשרות רביעית: החולייה החדשה צריכה להיות הראשונה.
אפשרות חמישית: להוסיף בסוף הרשימה.

public class OrderedList{
private Node<NumCount> lst;

public void InsertNum(int x)
{
Node<NumCount> n = new Node<NumCount>( new NumCount(x,1) , null);

if(lst == null || ( lst!=null && lst.GetValue().GetNum()> x ) ) //first option , fourth option
{
n.SetNext(lst);
lst = n;
return; //stop the function
}

Node<NumCount> p = lst; //מצביע חדש על מנת לא להרוס את ראש הרשימה


while( p !=null )
{
NumCount nC = p.GetValue();
if( nC.GetNum() == x) //option 2
{
nC.SetCount( nC.GetCount()+1 );
return; //finish the function
}

//options 3 and option 5
if( !p.HasNext() || ( p.HasNext() &&p.GetValue().GetNum()> x ) )
{
n.SetNext( p.GetNext() );
p.SetNext(n);
return;
}

p = p.GetNext();
}

}

}

Full post

99 weeks ago

0👍

0👎



כללי אצבע לבגרות במדעי המחשב:

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

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

כללת מספר שלוש:
השוואת מחרוזות:
java:
String name1 ="almog";
String name2 = "almog";

דרך לא טובה: היא להשתמש ב ==.
name1==name2
הדרך הנכונה:
if(name1.equals(name2))



c#:
string name1 ="almog";
string name2 = "almog";

דרך לא טובה: היא להשתמש ב ==.

הדרך הנכונה:
if(name1.Equals(name2))



השוואת תווים יכולה להתקיים עם ==!!


כלל מספר ארבע:
כאשר אתם מציינים סיבוכיות עם פרמטר או פרמטרים יש לציין ולהסביר מהו הפרטמר.
O(n)
חובה להסביר מהו הפרמטר n.



כלל מספר חמש:
גישה לאיבר בתור, אך ורק אם התור לא ריק!
Java:
Queue<Integer> q = new Queue<Integer>();
q.head(); // אולי התור ריק... ואז זה יקרוס

if( !q.isEmpty())
q.head(); // q.remove()



C#:
Queue<int> q = new Queue<int>();
q.Head(); // אולי התור ריק... ואז זה יקרוס

if( !q.IsEmpty())
q.Head(); // q.Remove()


כלל מספר שש:
כיצד ליצור רשימה ריקה?
java:
Node<Integer> n = new Node<Integer>();
Node<Integer> n = null; //correct

C#:
Node<int> n = new Node<int>();
Node<int> n = null; //correct



פעולות על חולייה:
java:
Node<Integer> n = new Node<Integer>(23,null);

n.getValue(); // מביא לי את הערך שבסוגריים המשולשות
n.setValue(34); //משנה את ערכו
n.getNext(); // מביא לי את החולייה הבאה
n.setNext(n2); // גורם לחולייה להצביע למישהו אחר
n.hasNext();// האם יש חולייה הבאה שהיא לא נאל


c#:
Node<int> n = new Node<int>(23,null);

n.GetValue(); // מביא לי את הערך שבסוגריים המשולשות
n.SetValue(34); //משנה את ערכו
n.GetNext(); // מביא לי את החולייה הבאה
n.SetNext(n2); // גורם לחולייה להצביע למישהו אחר
n.HasNext();// האם יש חולייה הבאה שהיא לא נאל

Full post

99 weeks ago

0👍

0👎



פעולות עזר לבגרות במדעי המחשב
פעולת עזר שמקבלת הפנייה לשרשרת חוליות (רשימה) ומעתיקה את כל השרשרת לרשימה חדשה.

פתרון מלא בשפת Java:
public static Node<Integer> copy(Node<Integer> lst)
{
Node<Integer> p = lst; // על מנת לא להרוס את הרשימה, הרגל טוב

Node<Integer> head = new Node<Integer> ( 0 ,null ); //זאת השרשרת המשוכפלת
Node<Integer> tail = head; // תמיד בסוף השרשרת

while(p!=null) //סריקת שרשרת חוליות
{
Node<Integer> n = new Node<Integer>( p.getValue(),null);
tail.setNext(n);
tail = tail.getNext();

p = p.getNext();
}

return head.getNext();
}




פתרון מלא שפת C# סי שארפ:

public static Node<Integer> Copy(Node<int> lst)
{
Node<int> p = lst; // על מנת לא להרוס את הרשימה, הרגל טוב

Node<int> head = new Node<int> ( 0 ,null ); //זאת השרשרת המשוכפלת
Node<int> tail = head; // תמיד בסוף השרשרת

while(p!=null) //סריקת שרשרת חוליות
{
Node<int> n = new Node<int>( p.GetValue(),null);
tail.SetNext(n);
tail = tail.GetNext();

p = p.GetNext();
}

return head.GetNext();
}

Full post

99 weeks ago

0👍

0👎



משרד החינוך מועד הבחינה: קיץ נבצרים, תשפ"א, 2021 פתרון מלא בגרות מדעי המחשב

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

אם גילינו כי האורך אי זוגי, נפסול ישר את המחרוזת ונחזיר False.

שאלה מספר 1 בשפת C#
public static bool IsDouble (string str)
{
int size = str.Length;

if(size%2==1) //האם האורך הוא אי זוגי
return false;
for(int i=0, j=size/2; j<size; i++,j++)
{
if( str[i]!=str[j] )
return false;
}
return true;
}

שאלה מספר 1 בשפת Java

public static boolean isDouble (String str)
{
int size = str.length();

if(size%2==1) //האם האורך הוא אי זוגי
return false;

for(int i=0, j=size/2; j<size; i++,j++)
{
if( str.charAt(i)!=str.charAt(j) )
return false;
}

return true;
}

Full post

99 weeks ago

0👍

0👎



כל מה שצריך לדעת על מחרוזות בשפת Java מדעי המחשב בגרות

String name = "almog";

כיצד מגלים את אורך המחרוזת?
int size = name.length();


כיצד ניגשים לתו הראשון במחרוזת?
char tav = name.charAt(0); // 'a'


כיצד ניגשים לתו האחרון במחרוזת?
char last = name.charAt(size-1); // name[name.length()-1]


מהו indexOf? באמצעות indexOf אנחנו מקבלים מספר שלם. אם המספר שונה ממינוס אחד, אזי אנחנו מקבלים את המיקום הראשון של מה ששלחנו.
int i = name.indexOf("mo"); //2
int p = name.indexOf("gg"); //-1

מהי הפעולה contains? מפעילים פעולה זו על מחרוזת על מנת לבדוק האם היא מחרוזת זו מכילה מחרוזת אחרת.
למשל אם נרצה לבדוק האם המחרוזת "almog" מכילה את המחרוזת "mo" נבצע:
name.contains("mo"); //true

Full post

99 weeks ago

0👍

0👎



כל מה שצריך לדעת על מחרוזות בשפת c# סי שארפ מדעי המחשב בגרות

string name = "almog";

כיצד מגלים את אורך המחרוזת?
int size = name.Length;


כיצד ניגשים לתו הראשון במחרוזת?
char tav = name[0]; // 'a'


כיצד ניגשים לתו האחרון במחרוזת?
char last = name[size-1]; // name[name.Length-1]


מהו indexOf? באמצעות indexOf אנחנו מקבלים מספר שלם. אם המספר שונה ממינוס אחד, אזי אנחנו מקבלים את המיקום הראשון של מה ששלחנו.
int i = name.IndexOf("mo"); //2
int p = name.IndexOf("gg"); //-1

מהי הפעולה Contains? מפעילים פעולה זו על מחרוזת על מנת לבדוק האם היא מחרוזת זו מכילה מחרוזת אחרת.
למשל אם נרצה לבדוק האם המחרוזת "almog" מכילה את המחרוזת "mo" נבצע:
name.Contains("mo"); //True


Full post

99 weeks ago

0👍

0👎



כאן יופיע פתרון בגרות 2024 מדעי המחשב תשפ"ד קיץ שאלון 399271




Full post

99 weeks ago

0👍

0👎



כאן יופיע פתרון בגרות 2024 מדעי המחשב תשפ"ד קיץ שאלון 899381

פתרון שאלה 1 בשפת java וגם בשפת C#

פתרון שאלה 2 בשפת Java וגם בשפת C#

פתרון שאלה 3 בשפת JAVA וגם בשפת C#

">

"

Full post

99 weeks ago

0👍

0👎



מבחן מתכונת במדעי המחשב - שאלון 899381 מבחן_מתכונת2_תשפד.גרסה1_סופי (1)

באדיבותו של המורה אלוג'דאן כסרא סמיע

משך הבחינה : שלוש שעות ו-30 דקות

מבנה השאלון ומפתח הערכה:

בשאלון זו שלושה פרקים:
פרק ראשון – בפרק זה שלוש שאלות, עליכם לענות על שתיים.
שאלה 1 שאלת חובה – 10 נק'
שאלה 2 או שאלה 3 – 15 נק'
פרק שני – בפרק זה ארבע שאלות
פרק שלישי – בפרק זה שתי שאלות
עליכם לענות על 3 שאלות מהפרק השני והשלישי
לכל שאלה 25 נקודות ( 3 * 25 ) – 75 נק'

חומר עזר מותר בשימוש : כל חומר עזר ,חוץ ממחשב שניתן לתכנות וטלפון נייד,
אין להעביר ספרים ודפים בין הנבחנים.
יש לענות על שאלות מפרק 1 + 3 במחברת נפרדת
ושאלות מפרק 2 במחברת אחרת –
יש לכתוב על כל מחברת מה הפרקים שעניתם עליהם

ב ה צ ל ח ה !!


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

דוגמה:
עבור הקלט:
arr[0] = 0
arr[1] = 2
arr[2] = -20
arr[3] = 1
arr[4] = 7
arr[5] = 4
arr[6] = 0
arr[7] = -3
arr[8] = -19
arr[9] = 2

הפולה תחזיר:
r[0] = -20
r[1] = -3
r[2] = -19

משום שסכום האיברים השליליים בערך מוחלט הוא 42, ואילו סכום האיברים החיוביים הוא: 14

פתרון מלא בשפת c#:



public static int[] MaxArr(int[] arr)
{
    int pos = 0, neg = 0;
    for (int i = 0; i < arr.Length; i++)
    {
        if (arr[i] < 0)
            neg++;
        else pos++;
    }
    int[] possitave = new int[pos];
    int[] negative = new int[neg];
    pos = 0;
    neg = 0;
    int countpos=0,countneg=0;
    for (int i = 0; i < arr.Length; i++)
    {
        if (arr[i] < 0)
        {
            negative[neg++] = arr[i];
            countneg += Math.Abs(arr[i]);
        }
        else
        {
            possitave[pos++] = arr[i];
            countpos += Math.Abs(arr[i]);
        }   
    }
    return countpos > countneg ? possitave : negative;
}


שאלה 2:
נתונה המחלקה SpecialString שיש לה 2 תכונות:
string quote
bool isSentence


הפעולה הבונה מקבלת מחרוזת ומאתחלת את התכונה quote בערך של הקלט, 
תבדוק אם המחרוזת המתקבלת מהווה משפט (לפחות 2 מילים מופרדות ע"י רווח), אם משפט תגדיר את הערך של התכונה isSentence באמת אחרת בשקר.

הנח שיש פעולת Get ו Set לכל אחת מתכונות המחלקה. 

1) כתוב את כותרת הפעולה הבונה של המחלקה וממש אותה.


נתונה המחלקה Article שיש לה 2 תכונות:
הראשונה: מערך מטיפוס SpecialString בשם strings
השנייה: מערך מטיפוס שלם בשם wordsCount מונה מילים בגודל 6. כלומר כל המשפטים חייבות להיות באורך מקסימלי של 5 מילים.

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

2) כתוב את כותרת הפעולה הבונה של המחלקה Article וממש אותה. 
יש להשתמש בפעולה המאחזרת של הערך isSentense

דוגמה:

עבור הערכים של quote במערך strings:

arr[0] = "This exam"; // size 2
arr[1] = "is"; //size 1
arr[2] = "champions of the world"; // size 4
arr[3] = "so" //size 1
arr[4]="easy, and we are" //size 4
arr[5] = "1 2 3 4 5"; //size 5
arr[6]="thanks you are the best"; //size 5

הפעולה הבונה תבנה את המערך wordsCount:

wordsCount[0] = 0
wordsCount[1]=0
wordsCount[2] = 1
wordsCount[3] = 0
wordsCount[4] =1
wordsCount[5] = 2




פתרון מלא שאלה 2 סעיף 1
public SpecialString(string st)
{
quote = st;
if( st.IndexOf(' ')>0 && !st[1].Equals(' ') && !st[st.Length-1].Equals(' '))
isSentence = true;
else
isSentence = false;
}


פתרון שאלה 2 סעיף 2:

public Article(SpecialString[] strings)
{
    int maxcount = CountSpace(strings[0].GetQute());
    for (int i = 0; i < strings.Length; i++)
    {
        int tmp = CountSpace(strings[i].GetQute());
        if (tmp > maxcount)
            maxcount = tmp;
    }
    wordsCount = new int[maxcount+2];
    for (int i = 0; i < strings.Length; i++)
    {
        if (strings[i].GetIsSentence()) // if true
        {
            int count = CountSpace(strings[i].GetQute());
            wordsCount[count+1]++;
        }
    }
}



שאלה 3
נתונות 2 המחלקות הבאות:
המחלקה TrafficLight רמזור מאופיין ע"י תכונה אחת מטיפוס מחרוזת שאורכה שווה ל-3:
RYG :
Red
Yellow
Green

המחרוזת יכולה להכיל בכל מקום או 0 או 1 , 0=כבוי, 1=דלוק
למשל אם ערך המחרוזת RYG="001" הרמזור דולק ירוק

המחלקה צומת Point מאופיינת ע"י מספר שלם number ומערך מטיפוס TrafficLight בשם lights באורך מספר הרמזורים שיש בצומת שזה המספר number (number מספר הרמזורים בצומת)

הפעולה הבונה של המחלקה Point מקבלת מספר שלם number ומאתחלת את המערך lights לערכים ריקים null
כותרת הפעולה הבונה public Point (int number)
דוגמא לצומת עם 3 רמזורים - הניחו שיש צמתים רק עם 3 רמזורים מהסוג הזה:

במערכת בדיקת תקינות הרמזורים בצמתים רוצים לבדוק בכל זמן נתון את תקינות הרמזורים בצומת, מצב תקלה הוא מצב שיכול לגרום התנגשות בין 2 רכבים. 

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


Full post

99 weeks ago

0👍

0👎



שאלון בגרות מדעי המחשב, קיץ תשע"ו, מועד ב, מס' 899381 פתרון מלא

שאלה מספר 4

פתרון בשפת C# סי שארפ
תחילה נבצע פעולת עזר אשר סופרת את כמות החוליות ברשימה:
public static int Size ( Node<int> lst)
{
int counter=0;
while(lst!=null)
{
counter++;
lst = lst.GetNext();
}
return counter;
}

public static bool IsTripple(Node<int> lst)
{
int size = Size(lst);
if(size%3!=0)
return false;
//first jump size/3
//second jump (size/3)*2
Node<int> p1 = lst;
Node<int> p2 = lst;
Node<int> p3 = lst;
for(int i=0; i<size/3;i++)
p2=p2.getNext();

for(int i=0; i<(size/3)*2;i++)
p3=p3.getNext();

while(p3!=null)
{
if(p1.GetValue()!=p2.GetValue() ||p1.GetValue()!=p3.GetValue() || p2.GetValue()!=p3.GetValue() )
return false;

p1 = p1.getNext();
p2 = p2.getNext();
p3 = p3.getNext();
}
return true;
}

Full post

100 weeks ago

0👍

0👎



שאלה:

שאלה לא מנוסחת היטב, ניתן להניח כי המספרים שונים זה מזה.
פתרון:

public static int sizeList( Node<int> lst)
{
int counter=0;
while(lst!=null)
{
counter++;
lst = lst.GetNext();
}
return counter;
}

סעיף א - פתרון ב java
public static int biggerNumbers(Node<Integer> lst, int n)
{
Node<Integer> p = lst;
int counter=0;
while(p!=null)
{
if(p.getValue()<n)
counter++;
p = p.GetNext();
}
return counter;
}

פונקציית עזר:
public static int smallerNumbers(Node<Integer> lst, int n)
{
return sizeList(lst)-biggerNumbers(n); //נקבל את מי שקטן ממני
}

פתרון סעיף ב
public static boolean checkList(Node<Integer> lst)
{
Node<Integer> p = lst;

while(p!=null)
{
int afterMe = sizeList(p.getNext()); //כמה איברים יש אחריי
int smaller=0; // כמה איברים קטנים אני מחפש
if(afterMe>=3)
smaller = 3;
else
smaller =afterMe;

int smallerThanMe = smallerNumbers(p.getNext(),p.getValue());

if (smallerThanMe < smaller )
return false;

p = p.getNext();
}
return true;
}

Full post

100 weeks ago

0👍

0👎



שאלון קיץ תשע"ט – 2019 מדעי המחשב – שאלון 899381

שאלה מספר 5
סעיף א
פתרון ב-java:
public static int toNumber(Queue<Integer> q)
{
int result = 0;
int mul=1;

while(!q.isEmpty())
{
result = result + q.remove()*mul;
mul = mul *10;
}
return result;
}


פתרון ב-C# סי שארפ:
public static int ToNumber(Queue<int> q)
{
int result = 0;
int mul=1;

while(!q.IsEmpty())
{
result = result + q.Remove()*mul;
mul = mul *10;
}
return result;
}


סעיף ב
פתרון בשפת java:
public static int bigNumber(Node<Queue<Integer>> lst)
{
int max=0;
if( lst!=null )
{
Queue<Integer> q = lst.getValue();
max = toNumber(q);
}

lst = lst.getNext(); //קידום של המציע אחד קדימה

//סריקת שרשרת חוליות
while(lst!=null)
{
Queue<Integer> q = lst.getValue();
int temp= toNumber(q);
if(max<temp)
max=temp;

lst = lst.getNext();
}
return max;
}


פתרון בשפת C# סי שארפ:
public static int BigNumber(Node<Queue<int>> lst)
{
int max=0;
if( lst!=null )
{
Queue<int> q = lst.GetValue();
max = ToNumber(q);
}

lst = lst.GetNext(); //קידום של המציע אחד קדימה

//סריקת שרשרת חוליות
while(lst!=null)
{
Queue<int> q = lst.GetValue();
int temp= ToNumber(q);
if(max<temp)
max=temp;

lst = lst.GetNext();
}
return max;
}

Full post

100 weeks ago

0👍

0👎



קיץ תשע"ח – 2018 פתרון מלא בגרות שאלון מדעי המחשב – שאלון 899381 שאלה מספר 1

public class AllNumbers{
private int [] arrayNum ;

// public int LastOddValue()
public int lastOddValue()
{
for(int i=arrayNum.length-1 ; i>=0 ; i-- )
if(arrayNum[i] % 2 ==1 ) //אי זוגי
return arrayNum[i];
}
return 1; //הבטיחו לנו כי קיים איבר אי זוגי אחד לפחות, לכן החזרנו אפס
}

האסטרטגיה שלנו היית לסרוק את המערך מהסוף להתחלה, כך שנחזיר את האיבר האי זוגי הראשון שניתקל בו.

Full post

100 weeks ago

0👍

0👎



כללים לניסוח נימוק של סיבוכיות לשאלות בגרות במדעי המחשב:

כאשר נשאלים על סיבוכיות האפשרויות הן בדרך כלל:
O(1) - כאשר יש מספר קבוע של פעולות
O(logn) - חיפוש בינארי
O(n) - חיפוש סידרתי: מעבר על מערך/מחסנית/תור/שרשרת חוליות
O(n^2) - לולאה מקוננת בד"כ

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



דוגמה ראשונה:
סריקת מערך בגודל n:
for(int i=0; i<arr.length;i++) //O(n)
{
// o(1)
}

במידה וסורקים מערך ובגוף הלולאה מבצעים מספר קבוע של פעולות הסיבוכיות היא O(n) כאשר n הוא מספר האיברים.


דוגמה שנייה:
לולאת for מקוננת:
for(int i=0; i<n; i++) //O(n)
}
for(int j=0; j<m ; j++) //O(m)
{
//o(1)
}
}

בלולאה מקוננת אם גופי הלולאה מבצעים מספר קבוע של פעמים אז הסיבוכיות היא o(n*m).

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


דוגמה שלישית:
סריקת תור / מחסנית / רשימה / מערך: אם במהלך הסריקה מבצעים מספר קבוע של פעולות אזי הסיבוכיות היא o(n) כאשר n הוא גודל מבנה הנתונים.

במידה ובגוף הסריקה קוראים לפעולת עזר / מבצעים לולאה נוספת, אזי מבצעים כפל בין הסיבוכיות.

דוגמה רביעית:
פונקציה שסוכמת / סופרת את כמות הספרות.
יש להבין שהסיבוכיות כאן תלויה במספר הספרות, לכן הסיבוכיות היא O(n) כאשר n הוא מספר הספרות.


Full post

100 weeks ago

0👍

0👎



פתרון מלא
סעיף ב' של תור שווה סכומים:

c#: Node<Queue<int>>
public static Node<Queue<Integer>> removeEqualSums ( Node<Queue<Integer>> lst ) //java
{
Node<Queue<Integer>> result= lst; // result - head of the list
Node<Queue<Integer>> p= lst;

//remove all the problematic firsts
boolean finish = false;
while(result!=null && !finish)
{
Queue<Integer> q = result .getValue();
if(!equalSums(q))
result= result.getNext();
else
finish=true;
}

p = result;

while(p.hasNext())
{
Queue<Integer> q = p.getNext().getValue();
if(!equalSums(q))
{
p.setNext(p.getNext().getNext());
}
else
{
p =p.getNext();
}
}

return result;
}

Full post

100 weeks ago

0👍

0👎



פתרון מלא
"תור שווה סכומים", הוא תור של מספרים שלמים, המכיל מספר אי זוגי של איברים, כך שכל שני 
איברים קיצוניים (ראשון+אחרון, שני+לפני האחרון וכו') שווים בסכומם לאיבר האמצעי של התור. 
לדוגמא: התור הבא הוא "תור שווה סכומים" -
האיבר האמצעי הוא 25 וכל זוג איברים קיצוניים שווה ל 25
18←3101342521121522 ←7

18+7 = 25
3+22 = 25
10+15 = 25
13+12 = 25
4+21 = 25
הניחו שקיימת פעולה getAndRemoveLast, המקבלת תור לא ריק של מספרים שלמים. הפעולה מוציאה את האיבר שבסוף התור, ומחזירה את ערכו כתוצאה לזימון שלה. הפעולה שומרת על התור המקורי, למעט האיבר שהוסר. סיבוכיות הפעולה היא (O(n. אין צורך לממש פעולה זו. 

 כתבו פעולה חיצונית equalSums, המקבלת q תור של מספרים שלמים ומחזירה true אם התור הוא "תור שווה סכומים", אחרת יוחזר false. 



פתרון בשפת java:

public static boolean equalSums(Queue<Integer> q)
{
int counter=0;
int realMid=0;
int mid = 0;

int f=0; //first
if(!q.istEmpty())
{
counter++;
f=q.remove();
}
int l=0; //last
if(!q.isEmpty())
{
counter++;
l = getAndRemoveLast(q);
}
mid = f+l;

while( !q.isEmpty() )
{
realMid = q.remove(); //נכון רק פעם אחת
counter++;
if(!q.isEmpty())
{
counter++;
f = realMid;
l = getAndRemoveLast(q);
if(f+l != mid)
return false;
}

}

return (realMid == mid && counter%2==1 );

}






Full post

100 weeks ago

0👍

0👎



שאלה מספר 4 בגרות מדעי המחשב, קיץ תשע"ז, מס' 899381 פתרון מלא

א. מבנה הנתונים שאנו מציעים מורכב משני דברים:
רשימה מקושרת חד כיווניות
מצביע לסוף הרשימה

כיצד נממש את הפעולה insert:
אם הרשימה ריקה, פשוט נכניס את האיבר לראש הרשימה. O(1).
אם ברשימה יש איברים, נחפש מיקום שבו ערכו של האיבר יהיה גדול מימינו וקטן משמאלו.
לדוגמה:
5 → 8→ 10 →null
אנו מעוניינים להכניס את האיבר 6. במקרה זה האיבר מימינו של 6 גדול ממנו, והאיבר משמאלו קטן ממנו.
5 →6→ 8→ 10 →null

נכניס את האיבר במיקום הראשון שבו אחד משני התנאים הללו יתקיימו:
האיבר גדול משמאלו או האיבר קטן מימינו. במקרה הגרוע ביותר נעבור על כל האיברים O(n).

בכל מקרה נדאג לכך שמצביע לסוף הרשימה תמיד יהיה בסוף. במקרה הגרוע O(1).


כיצד נממש את הפעולה getMax:
נחזיר את ערכו של המצביע לסוף הרשימה. O(1).

כיצד נממש את הפעולה showMin:
נחזיר את ערכו של המצביע של תחילת הרשימה. O(1).

כיצד נממש את הפעולה exist:
עוברים על כל האיברים ובודקים האם הערך קיים או לא. O(n).

Full post

100 weeks ago

0👍

0👎



תרגיל במדעי המחשב בנושא שרשרת חוליות שפת C#.
כתבו פונקציה חיצונית הנקראת IsEqual אשר מקבלת שתי רשימות (שרשרת חוליות) ובודקת האם הן זהות בגודל ובסדר.

publiuc static bool IsEqual (Node<int> lst1, Node<int> lst2)
{


while(true)
{
if( (lst1==null && lst2!=null) || (lst1!=null && lst2==null)
return false;

if(lst1==null && lst2==null)
return true;

if(! lst2.GetValue()!=ls1.GetValue())
retirn false;

lst1=lst1.GetNext();
lst2=lst.GetNext();
}
return false;
}

Full post

100 weeks ago

0👍

0👎



2020ב בגרות במדעי המחשב תרגיל מספר 2 פתרון מלא

סעיף א
public Doctor (String name , String specialization )
{
this.name = name;
this.specialization = specialization ;
rate = 0 ;
}

סעיף ב

public static void doctorRating (Doctor [] doctors)
{
for(int i=0; i<doctors.length; i++)
{
double sum=0;
int counter=0;

System.out.println("Please enter rate:");
double rate = input.nextDouble();
while( rate !=-1)
{
counter++;
sum+=rate;

System.out.println("Please enter rate:");
rate = input.nextDouble();
}

double avg = sum/counter;
doctors[i].setRate(avg);

}

}

Full post

101 weeks ago

0👍

0👎



2020ב שאלה מספר 4 מדעי המחשב, מועד מיוחד, אוגוסט ,2020 מס' 899381 פתרון מלא

השינוי משפת c# לשפת java הוא מינורי.
C# - Node<int>
java - Node<Integer>

java: שמות הפונקציות מתחילות באותיות קטנות


public static Node<int> BuildDigit(Node<int> lst)
{
Node<int> p1 = lst;
Node<int> r = new Node<int>( -1,null );
Node<int> p2 = r; // תמיד צריך להיות בסוף השרשרת כדי להוסיף איברים מהסוף

while( p1!=null)
{
int x = p1.GetValue();
while(x>0)
{
int digit = x%10;
x/=10; //x=x/10;

Node<int> n = new Node<int>(digit, null);
p2.SetNext(n);
p2=p2.GetNext(); //בשביל שיהיה תמיד בסוף השרשרת
}
Node<int> n1 = new Node<int>(-9, null);
p2.SetNext(n1);
p2=p2.GetNext(); //בשביל שיהיה תמיד בסוף השרשרת
p1=p1.GetNext();

}

return r.GetNext();
}

Full post

101 weeks ago

0👍

0👎



מבנה נתונים רשימה מקושרת שפת C# / java , מדריך הסבר פקודות

כל חוליה Node מכילה שני דברים: value, next.
value - ערך (יכול להיות מספר שלם, תו, מחרוזת וכו).
next - מצביע לחוליה אחרת או מצביע ל null.

יצירת חוליה:
c#: Node<int> n = new Node<int>(5,null); // 5 → null

סך הכל אפשר לבצע על חולייה 5 פעולות:
C# - n.GetValue(); //value equals 5

C# - n.SetValue(8); // value equals 8

C# - n.GetNext(); // next is null;

C# - Node<int> n1 = new Node<int>(2,null);
n.SetNext(n1); // 5 → 2 → null

c# - n1.HasNext(); // false
c# - n.HasNext(); // true

כיצד סורקים רשימה?
שלב ראשון עדיף ליצור מצביע חדש (על מנת לא לשכוח את הראש).

Node<int> p = n;
כעת ניתן לסרוק את הרשימה כך:
while(p!=null)
{
// כאן אפשר לעשות מה שרוצים

p=p.GetNext(); // מקדם את המצביע לחוליה הבאה
}

Full post

101 weeks ago

0👍

0👎



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

public static int sum(Queue<Integer> q)
{
Queue<Integer> temp = new Queue<Integer>(); //empty temp Queue
int sum = 0;
while( !q.isEmpty())
{
int x = q.remove();
sum+=x; //sum = sum + x;
temp.insert(x);
}

while( !temp.isEmpty()
q.insert( temp.remove() );

return sum;

}

Full post

101 weeks ago

0👍

0👎



מבנה נתונים מדעי המחשב Queue תור שפת java (דומה מאוד לשפת c#)

תור הוא מבנה נתונים המאפשר שמירת נתונים בצורה של: הראשון שנכנס הוא הראשון שיוצא. FIFO.
נניח ואנחנו בתור בקופה, הראשון שהגיע לתור הוא הראשון שיקבל שירות. האחרון שהגיע לתור הוא האחרון שיקבל שירות.

head ← 1 , 3, 5 , 0 ← tail
במידה ומישהו חדש מצטרף לתור הוא ייכנס מהסוף (tail).
במידה וישלפו מישהו מהתור, הוא ייצא מראש התור (head).

איך יוצרים תור?
Queue<Integer> q = new Queue<Integer>(); // יצירת תור ריק

כיצד בודקים האם התור ריק?
if(q.isEmpty()) // בדיקה האם התור ריק

כיצד בודקים האם התור הוא לא ריק?
if(!q.isEmpty()) // בדיקה האם התור לא ריק

איך מוסיפים איבר לתור?
q.insert(4); //הכנסת איבר לתור

איך מסירים איבר מתור?
if(!q.isEmpty()) //בדיקה אם התור לא ריק, רק אז ניתן להסיר איבר
int x = q.remove();
//במידה והתור ריק וננסה להסיר איבר התכנית תקרוס


כיצד סורקים תור? (יש לקחת בחשבון שהוא יתרוקן)
while( !q.isEmpty())


כיצד מקבלים את ערכו של ראש התור ?
if( !q.isEmpty())
int x = q.head();


אפשר לסכם שיש לתור 4 פעולות:
q.insert(4) , q.remove() , q.isEmpty()


Full post

101 weeks ago

0👍

0👎



מדעי המחשב, 2022 קיץ תשפ"ב, מס' 899381 בגרות מדעי המחשב תרגיל מספר 1 פתרון מלא

public static int [] multiply (int [] arr1, int [] arr2)
{
int [] max = arr2;
int [] min = arr1;
if (arr1.length > arr2.length)
{
max = arr1;
min = arr2;
}

int [] arr3 = new int[max.length];

for(int i=0; i<min.length ; i++)
arr3[i] = max[i]*min[i];
for(int i = min.length; i<max.length; i++)
arr3[i] = max[i];

return arr3;
}

Full post

101 weeks ago

0👍

0👎



מדעי המחשב, קיץ תשפ"ב, מס' 899381 בגרות במדעי המחשב פתרון מלא

public static boolean isIncluded(Node<Integer> lst1, Node<Range> lst2)
{
while(lst1 != null && lst2!=null)
{
if(lst1.getValue() >= lst2.getValue().getLow() && lst1.getValue()<=lst2.getValue().getHigh() )
{
lst1 = lst1.getNext();
}
else
{
lst2 = lst2.getNext();
}


}
if(lst1 == null)
return true;

return false;
}

Full post

101 weeks ago

0👍

0👎



שאלה במדעי המחשב בנושא מבנה נתונים שרשרת חוליות מטיפוס מורכב
שימו לב השאלה - השאלה מנוסחת בשפת c#!

השאלה:
מחלקת סטודנט Student בנויה בעזרת התכונות הבאות:
שם - name מטיפוס string
רשימת קורסים - courses מטיפוס חולייה מטיפוס Course.


המחלקה קורס Course בנויה בעזרת התכונות הבאות:
קוד הקורס - code מטיפוס string
ציון - grade n מטיפוס int.

מאגר ציונים Grades מוגדר כרשימה של תלמידים, כלומר כל חוליה היא מטיפוס Student.


א. בנו את כל המחלקות:
מחלקת מאגר ציונים - Grades: רשימה של תלמידים.
מחלקת תלמיד Student כמתואר לעיל.
מחלקת קורס - Course כמתואר לעיל.

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

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

ג. כתבו פעולה חיצונית המקבלת מאגר ציונים - כלומר עצם מטיפוס Grades ומדפיסה עבור כל תלמיד את ממוצע ציוניו.

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

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

צרו 4 תלמידים ו-8 קורסים: 2 קורסים לכל תלמיד.

צרו מופע מטיפוס Grade, הוסיפו את התלמידים.

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


פתרון מלא:
המחלקה Course אשר כתובה בקובץ Course.cs

public class Course
{
private string code;
private int grade;

public Course(string code, int grade)
{
this.code = code;
this.grade = grade;
}
public string GetCode()
{
return code;
}

public void SetCode(string code)
{
this.code = code;
}

public int GetGrade()
{
return grade;
}

public void SetGrade(int grade)
{
this.grade = grade;
}

public override string ToString()
{
return "Code: " + code + "-> Grade: " + grade;
}
}

המחלקה Student אשר כתובה בקובץ Student.cs

public class Student
{
private string name;
private string id;
private int year;
private Node<Course> courses;

public Student(string name, string id, int year)
{
this.name = name;
this.id = id;
this.year = year;
this.courses = null; // Initialize courses to null
}
public void AddCourse(Course c)
{
courses = new Node<Course>(c,courses);
}

public string GetName()
{
return name;
}

public void SetName(string name)
{
this.name = name;
}

public string GetId()
{
return id;
}

public void SetId(string id)
{
this.id = id;
}

public int GetYear()
{
return year;
}

public void SetYear(int year)
{
this.year = year;
}

public Node<Course> GetCourses()
{
return courses;
}

public void SetCourses(Node<Course> courses)
{
this.courses = courses;
}

public double Avg()
{
Node<Course> p = courses;
int sum=0,counter=0;
while(p!=null)
{
int grade = p.GetValue().GetGrade();
sum+=grade;
counter++;
p=p.GetNext();
}
return (sum/(double)counter);
}

public string GetAllCoursesAsString()
{
string coursesString ="";
Node<Course> p = courses;
while (p != null)
{
coursesString+=p.GetValue().ToString();
if (p.GetNext() != null)
{
coursesString+=", ";
}
p = p.GetNext();
}
return coursesString;
}
public override string ToString()
{
return "Name: " + name + ", ID: " + id + ", Year: " + year+", Courses: "+GetAllCoursesAsString()+"\n";
}
}


המחלקה Grades אשר כתובה בקובץ Grades.cs


public class Grades
{
private Node<Student> students;
public Grades()
{
students = null;
}
public void AddStudent(Student s) //הוספת תלמיד
{
students = new Node<Student>(s, students);
}

public Node<Student> GetStudents()
{
return students;
}

public void SetStudents(Node<Student> students)
{
this.students = students;
}

public override string ToString()
{
string studentsString = "";
Node<Student> currentStudent = students;
while (currentStudent != null)
{
studentsString += currentStudent.GetValue().ToString();
if (currentStudent.GetNext() != null)
{
studentsString += ", ";
}
currentStudent = currentStudent.GetNext();
}

return studentsString;
}
}

המחלקה Main אשר כתובה בקובץ Main.cs


using System;
class HelloWorld {
// סעיף א
public static void AvgEachStudent(Grades grades)
{
Node<Student> p = grades.GetStudents();

while(p!=null)
{
Student s = p.GetValue();
Console.WriteLine("The avg of "+s.GetName()+" is "+ s.Avg());
p=p.GetNext();
}

}
//סעיף ב
public static string MaxCourseAvg(Grades grades)
{
Node<Student> pS = grades.GetStudents(); //pointer student
Node<string> codes =null;
Node<int> sums =null;
Node<int> counters = null;
Node<string> pCode =null; //pointer code courses
Node<int> pSum =null; //pointer sum courses
Node<int> pCounter = null; //pointer counter courses

while(pS!=null)
{
Student s = pS.GetValue();
Node<Course> pC = s.GetCourses();
while(pC!=null)
{
Course c = pC.GetValue();
string code = c.GetCode();
//make the pointer at the beggning
pCode=codes;
pSum=sums;
pCounter=counters;
// find the code in list of codes, or add at the begning if not found
while(pCode!=null && !pCode.GetValue().Equals(code) )
{
pCode=pCode.GetNext();
pSum=pSum.GetNext();
pCounter=pCounter.GetNext();
}
//not found
if(pCode==null)
{
//add at the begning
codes = new Node<string>(code,codes);
sums = new Node<int>(c.GetGrade(),sums);
counters = new Node<int>(1,counters);
}
else //found
{
//add values for avg
pSum.SetValue(pSum.GetValue()+c.GetGrade());// add grade to sum
pCounter.SetValue(pCounter.GetValue()+1); //add one to counter
}
pC=pC.GetNext();
}
pS=pS.GetNext();
}
//now we have all the sums and counters of all the courses.
//let's calculate the avg
pCode=codes;
pSum=sums;
pCounter=counters;
string maxCode = pCode.GetValue();
double maxAvg = pSum.GetValue()/(double)pCounter.GetValue();
while(pCode!=null)
{
double avg = pSum.GetValue()/(double)pCounter.GetValue();
if(avg>maxAvg)
{
maxCode = pCode.GetValue();
maxAvg = avg;
}

pCode=pCode.GetNext();
pSum=pSum.GetNext();
pCounter=pCounter.GetNext();
}
return maxCode;
}
static void Main() {
Grades grades = new Grades();
// Create 4 students
Student student1 = new Student("John", "S001", 2022);
Student student2 = new Student("Alice", "S002", 2023);
Student student3 = new Student("Bob", "S003", 2022);
Student student4 = new Student("Emily", "S004", 2023);

// Create 8 courses
Course course1 = new Course("C101", 85);
Course course2 = new Course("C102", 78);
Course course3 = new Course("C101", 90);
Course course4 = new Course("C102", 92);
Course course5 = new Course("C101", 80);
Course course6 = new Course("C102", 87);
Course course7 = new Course("C101", 88);
Course course8 = new Course("C102", 95);
student1.AddCourse(course1);
student1.AddCourse(course2);
grades.AddStudent(student1);

student2.AddCourse(course3);
student2.AddCourse(course4);
grades.AddStudent(student2);
student3.AddCourse(course5);
student4.AddCourse(course6);
grades.AddStudent(student3);
student4.AddCourse(course7);
student4.AddCourse(course8);
grades.AddStudent(student4);
Console.WriteLine(grades);
AvgEachStudent(grades); // סעיף א
Console.WriteLine(MaxCourseAvg(grades));
}
}

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


פלט של הרצה:

Name: Emily, ID: S004, Year: 2023, Courses: Code: C102-> Grade: 95, Code: C101-> Grade: 88, Code: C102-> Grade: 87

, Name: Bob, ID: S003, Year: 2022, Courses: Code: C101-> Grade: 80

, Name: Alice, ID: S002, Year: 2023, Courses: Code: C102-> Grade: 92, Code: C101-> Grade: 90

, Name: John, ID: S001, Year: 2022, Courses: Code: C102-> Grade: 78, Code: C101-> Grade: 85



The avg of Emily is 90

The avg of Bob is 80

The avg of Alice is 91

The avg of John is 81.5

C102



Full post

107 weeks ago

0👍

0👎



פתרון מלא במדעי המחשב בגרות שאלה עם לולאה מקוננת, מציאת מקסימום, מציאת מינימום

השאלה:
בבניין משרדים 30 קומות. בכל קומה יש 7 משרדים ממוספרים 1-7.
א. כתבו תוכנית הקולטת את מספר העובדים בכל משרד ומחזירה את סך העובדים בכל קומה.
ב. הציגו כפלט את מספר הקומה שיש בה הכי פחות עובדים וכן את מספר העובדים בקומה זו.
ג. הציגו כפלט את מספר המשרד והקומה של המשרד שבו מספר העובדים הוא הגדול ביותר.


פתרון מלא בשפת c#:


using System;
class HelloWorld {
  static void Main() {
      
      Random rnd = new Random();
      
      int minEmployee=-1; //סעיף ב
      int minFloor=0;   //סעיף ב
      
      int maxEmployee =-1; //סעיף ג
      int maxFloor = 0; //סעיף ג
      int maxOffice =0; //סעיף ג
      
      for(int i=0; i<30;i++)
      {
    Console.WriteLine("Offices for "+(i+1)+" floor");
    int employeesInFloor=0; //סעיף א
        for(int j=0;j<7;j++)
        {
            Console.WriteLine("Enter number of employees floor "+(i+1)+" and office number "+(j+1));
            //int employees = int.Parse(Console.ReadLine());;
            int employees = rnd.Next(20,500);//for checking only
            employeesInFloor+=employees;
            
            if(minEmployee==-1 || minEmployee>employees)
            {
                minEmployee = employees;
                minFloor = (i+1);
                maxOffice = (j+1);
                
            }
            
            if(maxEmployee==-1 || maxEmployee<employees)
            {
                maxEmployee = employees;
                maxFloor = (i+1);
                
            }
        }
    Console.WriteLine("Total employees of "+(i+1)+" floor is "+employeesInFloor); // סעיף א

    
      }
      
     Console.WriteLine("The minimun employees belongs to "+ minFloor+" floor, and the quantity is "+minEmployee); // סעיף ב
     Console.WriteLine("The maximum employees belongs to "+ maxFloor+" floor, and the office numbers is "+maxOffice); // סעיף ג


  }
}

Full post

107 weeks ago

0👍

0👎