1. תכנות בשפת סי
תרגול 5

2. מערכים חד-מימדיים - חזרה
מערך: קבוצה של משתנים אשר הגישה לכל אחד מהם מתבצע ע"י שם משותף (שם המערך) ואינדקס.
מוטיבציה: יכול לשמש כאשר יש פעולות חוזרות שמתבצעות על משתנים דומים.
דוגמאות להגדרת מערך:
int ids[7];
char name[12];
int arr[] = {1,2,45,6};

3. מערכים חד-מימדיים - חזרה
הכנסת ערך למערך (כתיבה):
name[3] = 'm';
קריאת ערך ממערך:
x = arr[3] + arr[5];
printf("%c %d",name[2],ids[0]);
בהינתן מערך X[20], ניתן להתייחס לכל איבר בתחום X[0],…,X[19] כאל משתנה רגיל מטיפוס המערך.

4. מערכים חד-מימדיים - חזרה
דוגמא לשימוש בלולאה כדי לגשת לאיברי מערך:
int i, x[10];
for (i=0; i<10; i++)
x[i] = i * i;
מה עושה הלולאה?

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

6. פתרון תרגיל 1 #include <stdio.h> #define NUMBER_OF_ELEMENTS 5
void main() {
int arr[NUMBER_OF_ELEMENTS];
int i,min,max,sum;
/* Read the input numbers */
printf("Insert %d numbers\n",NUMBER_OF_ELEMENTS);
for(i=0; i<NUMBER_OF_ELEMENTS; i++)
printf("%d : ", i+1);
scanf("%d",&arr[i]); }

7. פתרון תרגיל 1, המשך
/* Calculate the min, max and sum of the numbers: */
for(i=sum=0,min=max=arr[0];i<NUMBER_OF_ELEMENTS;i++) {
if(min > arr[i])
min=arr[i];
if(max < arr[i])
max=arr[i];
sum+=arr[i]; }
printf("Minimum= %d , Maximum= %d , Sum=
%d\n",min,max,sum);

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

9. פתרון תרגיל 2 void main() {
int arr1[]={12,15,5,567}, arr2[]={66,4,5,88,33,55};
int i,j,len1,len2;
len1 = sizeof(arr1)/sizeof(int);
len2 = sizeof(arr2)/sizeof(int);
for(i=0;i<len1;i++)
for(j=0;j<len2;j++)
if(arr1[i]==arr2[j])
printf("Common ID Found: %d\n",arr1[i]); }

10. תרגיל 3- מערכים דו-ממדיים
צריך לממש את התוכנית הבאה:
קלט: מערך דו-ממדי המכיל תווים (chars), ומילה המורכבת מתווים ואורכה קצר משני ממדי המערך.
הקלט נתון (Hardcoded), אין צורך לקלוט אותו ממשתמש.
פלט: הדפסת כל המופעים של המילה במערך הדו-ממדי, כאשר המילה יכולה להופיע בשורה (horizontally) או בעמודה (vertically)
חלוקת עבודה לשלבים:
נבין כיצד למצוא את כל המופעים בשורות.
נבין כיצד למצוא את כל המופעים בעמודות.
האם יש דמיון למציאה עבור שורות.

11. פתרון תרגיל 3 #include <stdio.h> #define ROW 5 #define COL 5
#define WORDSIZE 3
void main() {
char matr[ROW][COL]={{'r','v','o','q','w'},
{'a','h','s','x','l'}, {'n','k','s','d','m'},
{'r','a','n','j','r'},
{'d','k','u','c','a'}};
char word[WORDSIZE+1]="ran"; //Leave room for the ‘\0’ character.
int i,j,k,l;

12. פתרון תרגיל 3 - שורות // Search for horizontal words (along the rows):
for(i=0; i<ROW; i++) //Scan the rows.
for(j=0; j<=COL-WORDSIZE; j++) //Scan the columns. {
for(k=j, l=0; l<WORDSIZE && matr[i][k]==word[l]; k++, l++);//Scan the word if it is there.
if(l==WORDSIZE) //Check if the whole word was encountered.
printf("The word was found horizontally!!! Its coordinates are: x1=%d, y1=%d, x2=%d, y2=%d\n", i, k-WORDSIZE,i,k-1); }

13. פתרון תרגיל 3 - עמודות
//Search for vertical words (along the columns):
for(i=0; i<COL; i++) //Scan the columns:
for(j=0; j<=ROW-WORDSIZE; j++) //Scan the rows: {
for(k=j, l=0;l<WORDSIZE && matr[k][i]==word[l]; k++, l++);
if(l==WORDSIZE)
printf("The word was found vertically!!! Its coordinates are: x1=%d, y1=%d, x2=%d, y2=%d\n", k-WORDSIZE,i,k-1,i); }

14. פתרון תרגיל 3 - פלט R V O Q W A H S X L N K D M J U C a
The word was found horizontally!!! Its coordinates are: x1=0, y1=0, x2=0, y2=2“
The word was found vertically!!! Its coordinates are: x1=3, y1=0, x2=3, y2=2

15. מחרוזות מחרוזת היא מערך של char-ים המסתיימת בתו ‘\0’.
לא בהכרח ממלאת את כל המערך.
מטרת תו הסיום ‘\0’ היא מניעת הצורך בציון מפורש של אורך המחרוזת בכל שימוש.
char word[10];
Word[0] = ‘D’; Word[1] = ‘o’; Word[2] = ‘g’;
Word בינתיים הוא רק מערך של תווים
Word[3] = ‘\0’;
כעת Word מכיל בתוכו מחרוזת (כמובן שהוא עדיין מערך של תווים).
char Word[] = “dog”;
ניתן להגדיר את Word גם כך – המהדר מסיק שזוהי מחרוזת ומוסיף ‘\0’ בסיומה.

16. int strcmp(const char *s1, const char *s2);
The function compares successive elements from two strings, s1 and s2, until it finds elements that are not equal.
If all elements are equal, the function returns zero.
If the differing element from s1 is greater than the element from s2 (both taken as unsigned char), the function returns a positive number.
Otherwise, the function returns a negative number.

17. strlen() and strcpy() size_t strlen(const char *s);
The function returns the number of characters in the string s, not including its terminating null character.
char *strcpy(char *s1, const char *s2);
The function copies the string s2, including its terminating null character, to successive elements of the array of char whose first element has the address s1. It returns s1.

18. תרגיל 4 להלן אלג' פסודו-קוד עבור מחרוזת W: מה עושה האלג'?
עבור על כל אינדקס iמ-0 עד אורך מחרוזת נתונה W
עבור על כל אינדקס j מ-0 עד אורך מחרוזת נתונה W
אם W[i] = W[j] הדפס את W[i].
מה עושה האלג'?
מוצא אותיות שמופיעות במילה יותר מפעם אחת. (אמור להיות לכם כבר מוכר)
מה יודפס בהינתן המלה “abc” ?
תשובה “abc”
כיצד נתקן את האלג' ?
מה יודפס בהינתן המילה “koshka” ?
תשובה "kk”

19. ASCII codes הייצוג של תווים כ- char-ים הוא ע"י תווי ascii.
לדוגמא, ייצוג ascii של ‘a’ הוא 97, ועל כן (int) ‘a’ == 97.
כל האותיות באנגלית מופיעות באופן עוקב ב- ascii.
ערך ‘b’ הוא 98, ערך ‘c’ הוא 99 וכן הלאה.
נוכל לנצל תכונה זו על מנת לבצע השוואות ואריתמטיקה של תווים.
דוגמא:
if (c >= ‘a’ && c <= ‘z’)
printf(“%c is an alphabetic character\n”, c);
דוגמא שקולה:
If (c – ‘a’ >= 0 && c – ‘z’ <= 0)

20. תרגיל 4 – פתרון #include <stdio.h> #define MAX_WORD_LEN 256
void main() {
char inWord[MAX_WORD_LEN];
int alphabet[26]={0};
int i,found=0;
printf("Insert your word in lowercase letters(%d chars max):" ,MAX_WORD_LEN);
gets(inWord) ;
for(i=0;inWord[i]!='\0';i++) //Fill array with alphabet occurances
alphabet[inWord[i]-'a']++;

21. תרגיל 4 – פתרון, המשך
for(i=0;i<26;i++)//Run over all the elements in alphabet[]:
if (alphabet[i] > 1) {
printf("%c",i+'a');
found++; }
if(! found)
printf("Didn't find any double letters!\n");

22. תרגיל 5 - פלינדרום צריך לממש את התוכנית הבאה:
פלינדרום הוא מילה שנקראת באופן זהה כאשר קוראים אותה מן הסוף להתחלה.
דוגמאות לפלינדרומים:
“a”
“aba”
“a man, a plan, a canal – panama” (בהתעלם מסימני פיסוק ורווחים)
צריך לממש את התוכנית הבאה:
קלט: מחרוזת מן המשתמש.
פלט: הודעה האם המחרוזת היא פלינדרום או לא.

23. תרגיל 5 - פתרון #include <stdio.h> #include <string.h>
void main() {
int i,len;
char w1[256];
printf("Please enter a word no longer than 256 characters:\n");
gets(w1);
len=strlen(w1); //Get the length of the input string.
for (i=0 ; i < len/2 && w1[i] == w1[len-i-1] ; i ++);
if (i==len/2) printf("The word is a palindrome! \n");
else printf("The word isn't a palindrome! \n"); }

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

25. תרגיל 6 – פתרון #include <stdio.h> #define MAX_WORD_LEN 256
void main() {
int i;
char w1[MAX_WORD_LEN], w2[MAX_WORD_LEN];
printf("Please enter first word:");
gets(w1);
printf("Please enter second word:");
gets(w2);
for (i=0 ; w2[i] && w1[i] == w2[i] ; i++);
if (!w1[i] && !w2[i]) printf("equal\n");
else if (w1[i] > w2[i]) printf("first bigger\n");
else printf("last bigger\n"); }

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

27. תרגיל 7 - פתרון #include <stdio.h> void main() { int i,len;
תרגיל 7 - פתרון
#include <stdio.h>
void main() {
int i,len;
char w1[256];
printf("Please enter a sentence:\n");
gets(w1);
for (i=0; w1[i] ; i++)
if (! i || w1[i-1]==' ')
if (w1[i] >='a' && w1[i]<='z')
w1[i] += 'A' - 'a';//This is actually subtracting 32 from w1[i].
printf("%s\n",w1); }

28. תרגיל 8 צריך לממש את התוכנית הבאה:
קלט: מחרוזת שמייצגת משפט המכיל 5 מילים.
פלט: המילה הארוכה ביותר במשפט.
הגבלות: אסור להשתמש ב- strcmp(), strcpy(), strlen().
זכרו: גם מחרוזת היא מערך. כמו שיכולנו לעבוד על מערך באמצעות לולאות מקוננות, ניתן לבצע פעולה כזו גם על מחרוזות.

29. תרגיל 8 - פתרון #include <stdio.h> void main() {
תרגיל 8 - פתרון
#include <stdio.h>
void main() {
int i=0,len,maxWordLoc, maxWordLen=0, curWordLen=0;
char w1[256];
printf("Please enter a sentence consisting of 5 words:\n");
gets(w1);
do{
if (w1[i] == ' ' || w1[i] =='\0') {
if (curWordLen>maxWordLen) {
maxWordLen = curWordLen;
maxWordLoc = i; }
curWordLen = 0;
} else
curWordLen++;
} while(w1[i++]);

30. תרגיל 8 – פתרון, המשך
while (maxWordLoc && w1[maxWordLoc-1] !=' ')
maxWordLoc--;
while (w1[maxWordLoc] && w1[maxWordLoc]!=' ')
putchar(w1[maxWordLoc++]); }
איך היינו יכולים לפתור את הבעיה ללא ההגבלות שהצבנו?
תחת ההנחה שהמשפט עודנו לא יותר ארוך מ- 256 תווים.

31. תרגיל 8 – פתרון ללא הגבלות
תרגיל 8 – פתרון ללא הגבלות
#include <stdio.h>
void main() {
int i=0,len,maxWordLoc;
int maxWordLen=0;
int curWordLen=0;
char longest[256]="",w1[256];
printf("Please enter a sentence consisting of 5 words:\n");
for (i=0 ; i<5 ; i++) {
scanf("%s",w1);
if (strlen(w1) > strlen(longest))
strcpy(longest,w1); }
printf("%s\n",longest);