יום ראשון, 5 באפריל 2015

שאלות ופתרונות בשפת C, C++ תיכנות מחשבים הנדסאי אלקטרוניקה תרגול בתיכנות תרגילים עם פתרונות מלאים כל מה שצרךי לדעת הסברים טבלת מעקב

המדריך לשפת C מאפס הבסיס של שפת C איך לתכנת בשפת C חוקים
שאלות ופתרונות בשפת C,  C++ תיכנות מחשבים הנדסאי אלקטרוניקה כיתה יד'

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

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

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

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

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


חוקים בסיסיים:
כל סיום פקודה מסתיימת בנקודה פסיק (;) - כך המחשב יודע איך להבדיל בין הפקודה הנוכחית לפקודה הבאה.
סוגריים מסולסלות ({}) מעידות על בלוק נתונים, בלוק נתונים מסויים יהיה בין הסוגריים המסולסלות.
סלש סלש (//) מעיד על כך שמה שיהיה כתוב אחר כך יוצג כהערה, שם נוכל לרשום כל דבר כרצוננו.

משתנים:
משתנה הוא שם שאנו קובעים מטיפוס שאנחנו בוחרים ואנחנו שומרים נתון כלשהו בהתאם לטיפוס שלו.
במשתנה מטיפוס שלם - נשמור רק מספרים שלמים int
במשתנה מטיפוס תו נשמור רק תוווים בודדים char
במשתנה מטיפוס float - נשמור רק מספרים עם נקודה עשרונית. float

דוגמאות למשנים מטיפוס int:
100
-100
2
45
65

דוגמאות למשתנים מטיפוס char:
a
4
b
-
F
r

דוגמאות למשתנים מטיפוס float
0.2
-0.4
66.7
0.5
6.0



הגדרת משתנה
כדי להגדיר משתנה אנחנו חייבים לדעת שני פרטים עליו: טיפוס המשתנה, שם המשתנה (שאותו אנחנו נמציא).
קודם יבוא הטיפוס ואחר כך שמו.
דוגמאות להגדרת משתנה:
int i, x, z;
int w; int r;
float tt;
char a, b, c;
char dd; char ffg;


השמת ערך למשתנה:
באמצעות = אנחנו מבצעים פעולת השמה. צד ימין  שיועבר לצד שמאל.
דוגמאות להשמת ערך למשתנה:
int x;
x=0;

int e=4;

float fff=0.05;


אופרטורים פעולות בין מספרים (גם בין טיפוסים של int ו float) (טיפוסים שהם מספרים)
חשוב לציין כי בשפת C יש שמירה של סדר פעולות חשבון (קודם סוגריים, אחר כך כפל וחילוק, ואז חיבור וחיסור)
+ פעולת חיבור
- פעולת חיסור
* פעולת כפל
/ פעולת חילוק ללא שארית
% פעולת חילוק שהתוצאה שלה היא השארית בלבד

דוגמאות:
int a=5+6;   //a=11

int a=9;
int b=4;
int w;
w=a*b; //w=9*4=36

int jj= 12/7; //jj=1  שימו לב שבע נכנס פעם אחת בשתיים עשרה ללא שארית

int hh=12%7; //hh=5; השארית של החילוק הזה היא חמש

int dd=12%4; // dd=0 ארבע נכנס בשתיים עשרה ללא שארית




המבנה הבסיסי של כל תוכנה בשפת C:

  1. #include <stdio.h>
  2. void main()
  3. {
  4. // תוכן הפקודות שרצות בעת הרצת התכנית
  5. }



  1.  הנחייה לקומפיילר לכלול קובץ כותר בשם stdio.h אשר מכיל כל מיני פונקציות והכרזות. עצם כתיבה של שורה זו מאפשרת לנו להשתמש בשני פונקציות חשובות:
printf("");
הדפסה לפי פורמט, הפונקציה תדפיס את כל מה שבין הגרשיים למעט תווים מיוחדים \ %
נפרט:
\n  = יורד שורה
%d = מציג מספר שלם
%f = מציג מספר עם נקודה עשרונית
דוגמאות לשימוש:
int age=17;
float money= 30.5;
printf("my name is: David \nI am %d years old\nI have %f Shekels", age, money);

בעת ריצת התכנית זה מה שיוצג למשתמש:
my name is: David 
I am 17 years old
I have 30.5 Shekels


המשתנים age ו money יוצבו בהתאמה: age הראשון, ו money יהיה השני.

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


scanf("");

קליטה לפי פורמט, הפונקציה תקלוט משתנים מהמשתמש ותבצע פעולת השמה על אותו משתנה, על פי הדוגמה הבאה:
int age;  float money;
printf("What is your age?");
scanf("%d", &age);
printf("\nHow many  money do you have?");
scanf("%f", &money);

printf("\nmy name is: David \nI am %d years old\nI have %f Shekels", agemoney);

התו & הכרחי לפעולת ההשמה!

כך יוצג מסך המשתמש:
What is your age?
54 (המשתמש יקיש מספר שלם וילחץ אנטר) 
How many  money do you have?
100.50 (המשתמש יקיש מספר עם נקודה עשרונית שלם וילחץ אנטר) 
my name is: David 
I am 54 years old
I have 100.5 Shekels




נוכל גם לקלוט כמה משתנים במכה:
int a,b,c; float dd;
scan(" %d %d %d %f", &a, &b, &c, &dd);

המשתמש יקיש את המספר בצורה הנכונה (שלם או עם נקודה עשרוני בהתאמה) ויקיש אנטר אחרי כל סיפרה. אם הקיש כך:
6
8
22
36.3

אז הוא עשה פעולת השמה:
a=6
b=8
c=22
dd=36.3
2. פונקציה ראשית - מכאן התכנית תתחיל לרוץ בעת הרצת התוכנית, נרחיב על כך בהמשך.
3. פתיחת בלוק ההוראות של הפונקציה הראשית.
4. כאן יהיו כל הפקודות שהן הוראות הפונקציה הראשית.
5. סיום בלוק ההוראות של הפונקציה הראשית.

לסיכום מעתה והלאה, שנכתוב תכנית היא אמורה להתחיל כך:
#include <stdio.h>
void main()
{

}




התכנית הראשונה שלי בשפת C:
התכנית תכתוב על מסך המשתמש: hello nice user (שלום משתמש נחמד).

#include <stdio.h>
void main()
{
printf("hello nice user");
}

ידידותי למשתמש
אנו ככותבי התכנית יודעים מה בפועל התכנית צריכה לעשות, אבל המשתמש לא תמיד יודע זאת, לכן הוא צריך הוראות ברורות, וממשק קל להבנה.
אנו נקל עליו ונרשום לו הוראות מפורטות.
למשל:
אם נרצה לקלוט ממנו את כמות השקלים שיש לו בקופה, אז נבקש ממנו יפה לפני הקליטה:
printf("please enter your numbers of your Shekalim: ");
בתרגום בבקשה הכנס את מספר השקלים שלך

אם נרצה לקלוט לו תוצאה של חישוב עיבוד:
printf(" the result is: %d", num1);


קח דף ופתור את התרגילים הבאים, רק בתום פתירת התרגילים כולם בדוק את תשובתך.

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

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

3. כתוב תכנית שקולטת 3 מספרים במכה, ומדפיסה אותם.

פתרונות:

1.

#include <stdio.h>
void main()
{
int age,numbrosis;
printf("Please enter your age: ");
scanf(" %d", &age);

printf("\nPlease enter your number of brothers and sister: ");
scanf(" %d", &numbrosis);

printf("\nYour age is: %d and your number of brothers and sister is %d:", age,numbrosis );

}




2.

#include <stdio.h>
void main()
{
int eng ,math, safroot;
printf("Please enter your grade in English: ");
scanf(" %d", &eng );

printf("\nPlease enter your grade in math: ");
scanf(" %d", &math);

printf("\nPlease enter your grade in Safroot: ");
scanf(" %d", &safroot);

printf("\nYour grade in English is: %d and your grade in math is %d and you grade in safroot is %d ",eng , math, safroot);

}




3.
#include <stdio.h>
void main()
{
int a,b, c;
printf("Please enter 3 int number at once: ");


scanf(" %d %d %d", &a, &b, &c);
printf("\nYour 3 numbers is: %d %d %d", a, b, c);
}



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






תזכורת:

+ פעולת חיבור
- פעולת חיסור
* פעולת כפל
/ פעולת חילוק ללא שארית
% פעולת חילוק שהתוצאה שלה היא השארית בלבד


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

תרגיל: קלוט שני מספרים שלמים והדפס את הממוצע השלם שלהם.
פתור את התרגיל ולאחר מכן השווה עם הפתרון.
#include <stdio.h>
void main()
{
int a,b, memoza;
printf("Please enter 2 int number at once: ");


scanf(" %d %d", &a, &b);
memoza=(a+b)/2;
printf("\nThe memoza of %d and %d  is: %d", a, b, memoza);
}




תרגיל: קלוט שני מספרים והדפס את הסכום שלה.

פתור את התרגיל ולאחר מכן השווה עם הפתרון.

#include <stdio.h>
void main()
{
int a,b, sum;
printf("Please enter 2 int number at once: ");
scanf(" %d %d", &a, &b);
sum=a+b;
printf("\nThe sum of %d and %d  is: %d", a, b, sum);
}

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

#include <stdio.h>
void main()
{
int a,b;
printf("Please enter 2 int number at once: ");
scanf(" %d %d", &a, &b);

printf("\nThe sum of %d and %d  is: %d", a, b, a+b);
}


תכנית זו תעבוד בדיוק כמו התכנית למעלה, רק היא תהיה יעילה יותר.



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

פעולות בתוך תנאי:
== בודק האם שווה
=! בודק האם לא שווה
=< בודק האם גדול או שווה
=> בודק האם קטן או שווה

למשל:
int a=5;
a==4 אם נבצע את התנאי הזה אז נקבל את התשובה שקר

int d;
scanf(" %d",&d);
d==8  אם המשתמש יקיש את המספר שמונה אז התשובה בתנאי תהא אמת

ניתן לראות את נוכחות התנאי במקומות רבים:
if(____)
{

}
else (_____)
{

}


while(______)
{

}


for (   ;____;   )
{



}

נלמד על כל אחד מהם בהדרגה בקרוב.


תנאי If

כל מספר חיובי או שלילי חוץ מאפס הוא TRUE. רק אפס הוא FALSE.



if(תנאי)
{ // פתיחת בלוק ההוראות של התנאי

} // סגירת בלוק ההוראות של התנאי

אם התנאי התקיים ניכנס לבלוק ההוראות של התנאי.

int x=2;
if(x==3)
{
x=6;
}

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


תרגיל: כתוב תכנית אשר קולטת מספר. אם הוא גדול מחמש שנה אותו לאפס והדפס: hello.

חשוב להתמודד עם התרגיל באופן עצמאי, גם אם טועים.

הפתרון:

#include <stdio.h>
void main()
{
int a;
printf("Please enter int number: ");
scanf(" %d" , &a);
if(a>5)
  {
printf("hello");
   }
}


פעולות לוגיות
&& - וגם (חייב שכל התנאים יהיו נכונים כדי להוציא אמת בתנאי)
|| - או (חייב שתנאי אחד בלבד יהיה נכון על מנת להוציא אמת בתנאי)
int a=5;
for( (a==4) || (a==5) )  // במקרה הזה התנאי יחזיר אמת, כי רק אחד מהתנאים מתקיים

int b=3;
if ( (b==3)&& (b==6) ) // במקרה הזה התנאי יחזיר שקר, כי כל התאים ביחד לא מתקיים



תרגיל: כתוב תכנית שקולטת שני מספרים, אם אחד מהם הוא 6 אז התכנית תדפיס hello

נא לפתור לבד!



פתרון:

#include <stdio.h>
void main()
{
int a, b;
printf("Please enter 2 int number: ");
scanf(" %d %d" , &a, &b);
if( (a==6) || (b==6))
  {
printf("hello");
   }
}






המשך של if 
if(תנאי)
{ // בלוק ההוראות של התנאי - רק אם התנאי מתקיים

}

else // רק אם התנאי לא התקיים נריץ את בלוק ההוראות הזה
{

}


למשל: אם המספר יהיה גדול מאפס אז אני אכתוב גדול מאפס, ואם לא אז אני אכתוב המספר לא גדול מאפס
if(a>0)
{
printf("The number is big than zero"); // המספר גדול מאפס
}

else
{
printf("The number isn't big than zero"); // המספר לא גדול מאפס
}




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


פתרון:
#include <stdio.h>
void main()
{
int a, b;
printf("Please enter 2 int number: ");
scanf(" %d %d" , &a, &b);
if (a>b)
  {
printf("\nThe biggest number is: %d",a);
   }
else
{
printf("\nThe biggest number is: %d",b);
}
}

האם a גדול מ-b, אם כן זה יבצע את בלוק ההוראות בתאי הזה, אם לא זה ייבצע את מה שיש ב else.



שילוב של תנאי עם תנאי ועם תנאי...

ניתן ליצור שילובים מעניינים של תנאי, שימו לב:

if(1)
{
מתממש רק אם 1 התקיים
}

else if(2)
{
מתממש רק אם 1 לא התממש, ושתיים התממש
}
else
{
מתממש רק אם 1 לא התממש, וגם 2 לא התממש
}


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


#include <stdio.h>
void main()
{
int a;
printf("Please enter int number: ");
scanf(" %d", &a);
if ((a>=50)&&(a<=60))
  {
printf("\nYes");
   }
else if( (a>30) && (a<40) )
      {
printf("\nNo");
       }
else
          {
printf("\nYes no");
          }
}



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

#include <stdio.h>
void main()
{
int a;
printf("Please enter int number: ");
scanf(" %d", &a);

if ((a>=50)&&(a<=60))
printf("\nYes");


else if( (a>30) && (a<40) )
printf("\nNo");
   

else       
printf("\nYes no");
          
}

התכנית תפעל בדיוק אותו הדבר.


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


פתרון:

#include <stdio.h>
void main()
{
int a, b, c;
printf("Please enter 3 int number: ");
scanf(" %d %d %d" , &a, &b, &c);
if ( (a>b) && (a>c))
 printf("\nThe biggest number is: %d",a);

else if ( (b>a) && (b>c))
 printf("\nThe biggest number is: %d",b);

else
printf("\nThe biggest number is: %d",c);

}





מונים counter mone

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

דרכים להעלות את המונה באחד:
int mone=0;
mone++; // אחרי הפקודה הזאת המונה יהיה שווה אחד
mone++; // עכשיו המונה יהיה שווה שתיים


int counter=0;
counter=counter+1; // זה בידיוק אותו דבר כמו מונה פלוס פלוס


דקויות חשובות מאוד בדיקדוק:
נניח ויש לנו משתנה מטיפוס שלם x, ומונה.
mone=3;
x=1;

x=++mone // x=4; mone=4

אם נעשה

x=mone++ // x=3; mone 4;


אם נעשה
x=mone+1// x=4; mone 4;


צוברים zover
בשונה ממונה אנחנו רוצים להגדיל את הצובר במשהו אחר כל פעם (לא בהכרח באחד)
נעשה את זה כך:
int zover=0;
int bb=100;

zover=zover+bb; // zover=0+100=100
bb=50;
zover=zover+bb; // zover=100+50=150


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



פתרון מלא:


#include <stdio.h>
void main()
{
int a, b, c;
int counter=0;
printf("Please enter 3 int number: ");
scanf(" %d %d %d" , &a, &b, &c);
if  (a>3)
counter++;

if ( b>3)
counter++;


if  (c>3)
counter++;


printf("\nThe number of numbers who bigger than 3 is: %d",counter);

}


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

בשביל לפתור את התרגיל הזה אנחנו נלמד משהו חדש:

לולאת for

מבנה לולאת for ואיך היא מתבצעת:
for(1 ; 2; 4)
{
3
}
סדר הרצת הפקודות:
1 - משפט פתיחה, קורה בכניסה ל-for פעם אחת בלבד.
2.- תנאי. אם התנאי הוא אמת אז נכנס לגוף הלולאה.
3. גוף הלולאה מתבצע
4. -משפט סיום, פועל בסיום הרצת הפקודות בגוף לולאה.
2. התנאי נבדק שוב אם הוא מתקיים אז נכנסים אל גוף הלולאה
3. גוף הלולאה מתבצע
4. משפט סיום, פועל בסיום הרצת הפקודות בגוף הלולאה
2. התנאי נבדק שוב אם מתקיים אז נכנסים אל גוף הלולאה....

כל זה חוזר על עצמו עד שהתנאי לא מתקיים, ויוצאים מהלולאה!


שימוש קלאסי של for

ברצוננו לקלוט 100 מספרים מהמשתמש. נוכל לבצע את זה באמצעות for:
int i ,num;
for (i=0 ; i<100 ; i++)
{
printf("Please enter a int number: ");
scanf(" %d",&num);
}
הסבר:
1.כאשר הגענו ללואת for קודם כל מתבצע משפט הפתיחה: i=0
2.תנאי, אם התנאי הוא אמת נכנס לגוף הלולאה, האם i<100, האם אפס קטן ממאה? התשובה היא כן.
3. גוף הלולאה מתבצע: מבקשים מהמשתמש להכניס מספר, ואז קולטים ממנו מספר.
4. משפט הסיום מתבצע: i=1
2. האם התנאי מתקיים? אחד קטן ממאה? כן
3. מבצע את גוף הלולאה
4. מבצע את משפט הסיום, i=2

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


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

פתרון:
#include <stdio.h>
void main()
{
int i ,num;
for (i=0 ; i<30; i++)
{
printf("Please enter a int number: ");
scanf(" %d",&num);
}

}


תזכורת:
צובר:
zover=zover+num; // מוסיפים לצובר את הערך של המשתנה נאם

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


#include <stdio.h>
void main()
{
int i ,num, sum=0;
for (i=0 ; i<7; i++)
{
printf("Please enter a int number: ");
scanf(" %d",&num);
sum=sum+num;
}
printf("\nThe sum of the numbers is %d", sum);

}

בהתחלה נגדיר את הצובר שלנו (sum=סכום) ונאפס אותו. אנחנו רוצים שהוא יתחיל לספור מאפס.
אחרי כל פעם שנקלוט מספר, אנחנו נוסיף אותו לצובר שלנו (sum) כך:
sum=sum+num

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


מי שלא הצליח נא לפתור מחדש.



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

#include <stdio.h>
void main()
{
int i ,num, sum=0;
for (i=0 ; i<10; i++)
{
printf("Please enter a int number: ");
scanf(" %d",&num);
sum=sum+num;
}
printf("\nThe sum of the numbers is %d", sum/10);
}

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






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
















נתון מערך a מטיפוס שלם ובו עשרה איברים.
מערך "מדהים" הוא מערך שכל זוג איברים (a0 a1, s2 a3 וכך הלאה) הם או זוגיים או אי זוגיים ללא יומא מן הכלל.
למשל: a0 זוגי, a1 זוגי - זה מתאים...   a0 אי זוגי a1 אי זוגי - זה מתאים..   a0 אי זוגי a1 זוגי - לא מתאים.

הפתרון הארוך:
for(i=0, f=0; i<9 && f==0 ; i=i+2)
{

if(a[i]%2==0 && a[i+1]%2==0);

else if (a[i]%2!=0 && a[i+1]%2!=0);

else f=1;
}

if(!f) printf("amazing");
else printf("not amazing");



הפתרון הקצר:
for(i=0; (i<9) && ((a[i]%2==0 && a[i+1]%2==0) || (a[i]%2!=0 && a[i+1]%2!=0) ); i=i+2);
if(i!=10) printf("not amazing");
else printf("amazing");


הסבר א':
במקום לרוץ על כל המערך, ניתן לרוץ רק על האיברים הזוגיים במערך: 0 2 4 6 8.
כל עוד הכל בסדר (הזוג זוגי או הזוג אי זוגי) ה-for ימשיך.
אם יש זוג שהוא לא אי זוגי או זוגי אז ה-for ייעצר - ואז בטוח ה-i יהיה קטן מעשר, ונציג שהוא לא מדהים.
אם כולם כמו שצריך: אז שנגיע ל i=8 הוא יבדוק אותו ואת הסמוך שלו (והם בסדר), אז i=i+2 זאת אומרת i=10 ואז אנחנו נצא מהלולאה כי התנאי של i<9 לא יהיה נכון. אם i=10 אזי המערך מדהים.


הסבר ב'
שמנו לב כי כל זוג מתחיל במספר זוגי. (0 2 4 6 8)
במשפט הפתיחה: מתחילים באפס,
במשפט התנאי: אנחנו נמשיך כל עוד: i קטן מתשע, וגם אם הזוג כולו או זוגי או או אי זוגי.
במשפט הסיום: נקפוץ כל פעם בשתיים.

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

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








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

פתרון תשובה מלאה:
int a[15];
a[0]=0;
a[1]=1;
int i, num1=0, num2=1, num3=0;
for (i=2 ; i<15 ; i++)
{
a[i]=num1+num2;
num1=num2;
num2=a[i];
}

נריץ את התכנית לבדיקה

num1=0
num2=1

a[]={0,1}

נכנסים לfor
i=2
a[2]=0+1
num1=1
num2=1

נכנסים לfor
i=3
a[3]=1+1
num1=1
num2=2


נכנסים לfor
i=4
a[4]=1+2
num1=2
num2=3


נכנסים לfor
i=5
a[4]=3+2
num1=3
num2=5

a[]={0,1,1,2,3,5,,,,}






קלוט מספר והדפס את מספר ספרותיו

int num, counter=1, 
int i=1; // המכפלה
int x=11111; // נאגור שם תוצאת חילוק ללא שארית

sacnf("%d",&num);
while (x!=0)
{
i=i*10;
x=num/i;
if(x!=0)
if(i !=10)
counter++


}
if(counter !=1)
counter++;


נריץ את התכנה

נציב num=1
תנאי הלולאה מתקיים
i=1*10=10
x=1/10=0
התנאי לא מתקיים

תנאי הלולאה לא מתקיים
יש סיפרה אחת


נציב num=2314
תנאי הלולאה מתקיים
i=1*10=10
x=2314/10=231
התנאי הראשון מתקיים
התנאי השני לא מתקיים
counter=1

תנאי הלולאה מתקיים
i=10*10=100
x=2314/100=23
התנאי הראשון מתקיים
התנאי השני מתקיים
counter=2


תנאי הלולאה מתקיים
i=100*10=1000
x=2314/1000=2
התנאי הראשון מתקיים
התנאי השני מתקיים
counter=3


תנאי הלולאה מתקיים
i=1000*10=10000
x=2314/10000=0
התנאי הראשון לא מתקיים

תנאי הלולאה לא מתקיים
התנאי מתקיים
counter=4




נציב מספר אחר:

נציב num=132
תנאי הלולאה מתקיים
i=1*10=10
x=132/10=13
התנאי הראשון מתקיים
התנאי השני לא מתקיים
counter=1

תנאי הלולאה מתקיים
i=10*10=100
x=132/100=1
התנאי הראשון מתקיים
התנאי השני מתקיים
counter=2

תנאי הלולאה מתקיים
i=100*10=1000
x=132/1000=0
התנאי הראשון לא מתקיים

תנאי הלולאה לא מתקיים
התנאי מתקיים
counter=3



אפשר לשפר את התכנית ולעשות אותה יעילה יותר:

int num, counter=1, 

int x=11111; // נאגור שם תוצאת חילוק ללא שארית

sacnf("%d",&num);

if (num/10 ==0);
else
{
int i=10; // המכפלה
while (x!=0)  
{
i=i*10;
x=num/i;
if(x!=0)
counter++
}
counter++;
}




קלוט מספר ומצא את סכום ספרותיו

int num;
int sum=0;
scanf("%d",num);
while(x!=0)
{
sum=sum+(num%10)
temp=temp/10;
}

נציב את המספר 3513
תנאי הלולאה מתקיים
i=1*10=10
sum=0+3=3

תנאי הלולאה מתקיים
i=10*10=100
sum=0+3=3
temp=351

תנאי הלולאה מתקיים
sum=3+1
temp=35


תנאי הלולאה מתקיים
sum=4+5
temp=3
תנאי הלולאה מתקיים
sum=9+3
temp=0

תנאי הלולאה לא מתקיים





קלוט עשר מספרים ומצא את הגבוה ביותר

// קליטת עשר מספרים לתוך מערך
int i, num;
int arr[10];
for(i=0; i<10; i++)
{
scanf("%d", &num);
printf("\n)
arr[i]=num
}
// בדיקת המספר הגבוה ביותר
int max=arr[i];

for(i=0; i<10; i++)
if(max<arr[i])
max=arr[i];


קלוט עשר מספרים ותמיין אותך מהגדול לגבוה (במערך)

חשיבה

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

אנחנו נעשה לולאה בתוך לולאה בדרך הבאה:



// קליטת עשר מספרים לתוך מערך
int i, num;
int temp;
int arr[10];
for(i=0; i<10; i++)
{
scanf("%d", &num);
printf("\n)
arr[i]=num
}


// מיון המספרים הגבוהים ביותר
int max=arr[i];

for(i=0; i<10; i++)
max=a[i];
for(y=i; y<10; y++)
if(max<arr[y])  // אם מתקיים נבצע החלפה
{
temp=arr[i];  // נעביר את המקסימלי הישן למשתנה בשם זמני מטיפוס שלם
a[i]=a[y];   // נעביר את המקסימלי החדש למיקום שבו התחלנו לרוץ על המערך
a[y]=




תכנית שקולטת מספר ומדפיסה את המספר ההפוך שלו   פתרון תשובה מלאה
#include <stdio.h>

int main()
{
    int a, i, sum=0, counter=1,b,d,f;
    printf("please enter number");
    scanf("%d",&a);
    b=a;
    while((b/10)>0) {b=b/10; counter++;}     
    if (counter==1)   printf("\nThe number is: %d", a);
    else
    {
            b=a;
    for(i=0;i<counter;i++)
    {
        
    f=counter-(i+1);
    
    d=1;
    while(f>0) {d=d*10;f--;}

    sum=(b%10)*d+sum; printf("\n %d", sum);
    b=b/10;
    }
    
  printf("\nThe number is: %d", sum);
    }
    return 0;
}




easily rounding in c programming how to round a number
כתוב תכנית אשר מעגל מספר אשר נקלט על ידי המשתמש


#include <stdio.h>

int main()
{
  float a; int b, c;
  scanf("%f",&a);
b= (int) a;
a=a*10;
c= (int) a;
if((c%10) >=5)
printf("%d",b+1);

else
printf("%d",b);
    return 0;
}





ממוצע עם תוצאה של שני ספרות אחרי הנקודה
#include <stdio.h>

int main()
{
  float resu, temp; int a, b, c,d,temp2;
  scanf("%d %d %d %d",&a,&b,&c,&d);
temp = (float) (a+b+c+d)/3;
temp = temp*100;
temp2 = (int) temp;

resu= (float) temp2/100;

printf("%f",resu);


    return 0;
}



http://www.tutorialspoint.com/compile_c_online.php





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

type of array   name of array[amount of arrasy ;

type of array - טיפוס המערך
name of array - שם המערך
amount of array - כמות האיברים במערך

לדוגמה:
.
int arr[3];
הדרנו שלושה איברים מטיפוס שלם במערך בשם arr.
a[0]
a[1]
a[2]







פיתוח תכנית

אנו מבצעים את פיתוח התכנה בעזרת "מעבד תמלילים".
בעזרת "מעבד תמלילים" אנו יוצרים את קובץ המקור שלנו: name.C
אנו מבצעים תרגום (קומפליציה) - התכנה מתרגמת את מה התכנית שכתבנו לשפת מכונה.
אנחנו יוצרים קןבץ מורה: name_file.OBJ - קובץ אשר יכול לרוץ.
מתבצע ה"קישור" link   שמחבר את את כל חלקי התכנייות (כל מיני פונקציות כמו printf וכדומה) ואז נוצר קובץ exe אשר יכול לרוץ.



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


פתרון:
אנחנו נקלוט את המחרוזת בעזרת הפקודה gets.
בעזרת לולאת for אנחנו נספור כמה תווים יש במחרוזת שקלטנו. אומנם הגדרנו מחרוזת של 11 (התו האחרון הוא null אפס שמודיע כי זה סוף המחרוזת, לכן 10 תווים לרשות המשתמש ואחד בשביל ה-null) אבל המשתמש יכול לנצל עד עשרה תווים, אם הוא כותב שלוש תווים - זה בסדר, ואוטומטית הרביעי יהיה null.
לולאת ה-for שלנו תכלול:
משפט פתיחה: המונה שווה אפס, נקרא לו i.
משפט תנאי: האם המחרוזת במיקום המונה היא אמת, זאת אומרת היא לא null.
משפט סיום: נקדם את המונה באחד.
כך זה נראה:
for(i=0; i<a[i];i++);

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

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

החלפה שנייה:
x=1
i-x=6

החלפה שלישית
x=2
i-x=5

באמת זה מסתדר.

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

הפתרון המלא:

#include <stdio.h>

void main()
{
    int i, x;
    char temp;
   char a[11];
   gets(a);
   
   for(i=0; i<a[i];i++);
   i--;
for(x=0; x<i;x++)
{
    temp=a[x];
    a[x]=a[i-x];
    a[i-x]=temp;
}

puts(a);

}



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

הצעת פתרון:

נקלוט את שני המחרוזות.

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

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


#include <stdio.h>


int str_equal( char a[], char b[])
    int i, x, counter=0;
   for(i=0; i<a[i];i++);

   
     for(x=0; x<b[x];x++);
  
   printf("%d %d",i,x);
   if(x==i)
   {
       printf("hey i");
       for(x=0; x<i; x++)
       if(a[x]==b[x])
       counter++;
        printf("%d",counter);
   }
  
   else return 0;
   
   if (counter !=i) return 0;
   else return 1;
    
    
}

int main()
{
   
    char temp;
   char a[11];
    char b[11];
   gets(a);
     gets(b);
   
   if(str_equal(a,b)) printf("the two strings are equal");
   else printf("the two strings are not equal");
    return 0;
}




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


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

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

** אם וכאשר שתי המחרוזות הסתיימו באותו הזמן, הריי ששתיהן הסתיימו להן ב-null (מסמן את סוף המחרוזת) והריי שלאורך כל הדרך הן היו שוות. נשווה את המיקום שלהן שזהו ה-null שלהן - null אכן שווה ל-null לכן הן שוות זה לזו.



#include <stdio.h>

int cpr(char a[], char b[])
{
    int i;
for(i=0; a[i] && b[i]==a[i]&&b[i];i++);

if(a[i]==b[i]) return 1;
else return 0;

}

int main()
{
      char temp;
   char a[11];
    char b[11];
   gets(a);
     gets(b);
   
   if(cpr(a,b)) printf("the two strings are equal");
   else printf("the two strings are not equal");

    return 0;
}





יש כמה אפשרויות:
הם יצאו כאשר התו הנוכחי שלהם היה האחרון: null ולכן הם שווים.

הם יצאו כאשר התו האחרון של אחד מהם היה null והשני לא - לכן הם לא שווים


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

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

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

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

אנחנו נעבור על כך התווים האפשריים. כל פעם ניקח תו אחד מתוך כל ה-0 עד 255 אפשרויות ונרוץ על כל המחרוזת תוך כדי זה שנספור כמה פעמים התו הזה מופיע באמצעות מונה.
ככה אנחנו נעבור על כל התווים האפשריים ונדפיס את הכמות רק של התווים אשר מופיעים יותר מאפס פעמים.


#include <stdio.h>

void main()
{
    int i,x, mone=0;
    char a[11];
    printf("enter string: \n");
gets(a);

for(i=0; i<255; i++)
{
for(x=0; a[x]; x++)
if(a[x]==i) mone++;
if(mone)
printf("\nthe char %c appears %d times", i, mone);
mone=0;
}
}



דרך ב' לפתרון התרגיל: פתרון מתוחכם
אנחנו מראש נגדיר מערך של 256 איברים (0 עד 255) כמספר אפשרויות התווים. בעצם כל איבר כזה במערך הוא מונה ייחודי לאותו תו. לכן אנחנו נגדיר אותו במיקום גלובלי - שכל הערכים שלו יהיו אפס.
אנחנו נרוץ על כל המחרוזת שלנו פעם אחד: אנחנו נעבור איבר איבר, המספר של האיבר, למשל 34 ייספר במונה שנימצא במערך במיקום 34.
נעבור על כל המחרוזות ונמיין את כל התווים למונה המתאים.
לבסוף נרוץ על מערך המונים ונדפיס כמה פעמים כל איבר הופיע. (כמובן שאין צורך לציין את התווים אשר לא הופיעו כלל וכלל במחרוזות)

#include <stdio.h>
char mone[256];

void main()
{
int i;
char a[11];
printf("enter string: \n");
gets(a);

for(i=0; a[i]; i++)
mone[a[i]]++;

for(i=0; i<256;i++)
if(mone[i])
printf("\nthe char %c appears %d times", i, mone[i]);

}






מצביעים
מצביע מכיל בתוכו ערך הוא כתובת.
מצביע יכול להיות מכל טיפוס שהוא.
המצביע יכול להצביע רק על הטיפוס שלו.

למשל: מצביע מטיפוס שלם יכול להכיל בתוכו כתובות של משתנים מטיפוס שלם.
מצביע של תו יכול להכיל בתוכו כתובות של משתנים מטיפוס תו בלבד.

הגדרת מצביע:
type *name

int *pint;
char *sd;
float *sd;

השמה במצביע 
השמה של כתובת משתנה מסוים למבציע.

int x=45 // the adress of the variable is:5002
int *pt= &x 
ביצענו פעולת השמה, הכתובת של השמתנה x, שהיא: 5002 עברה לתוך המצביע מטיפוס שלם *pt ובתוכו יש 5002.


כעת אם נרצה לשנות את ערכו של x יש לנו שני דרכים:

או
X=5;

או

*pt=5;
הכנס את הערך חמש לתוך לערך של הכתובת של pt מצביע עליה




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

פתרון:

#include <stdio.h>

int check1 (char a[], char b[])
{
    char *ptr1, *ptr2;
    for(ptr1=a, ptr2=b; *ptr1 && *ptr2 && *ptr1==*ptr2; ptr1++, ptr2++);
    printf("\n %c %c",*ptr1, *ptr2);
    if(*ptr1==*ptr2) return 1;
    else return 0;
}




int main()
 char pass[] ={'s','h','a','b','y','\0'};
 char pass_user[20];
int i, flag=0;
for(i=0;i<3 && flag==0;i++) 
{
 printf("\n please enter password: (this is your %d try)",i+1);
 gets(pass_user);

 flag=check1(pass_user, pass);
 printf("\n %d", flag);
 puts(pass_user);
}

if(flag) printf("The password is corret"); 
else printf("The password is not corret");

  return 0;
}





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


פתרון מלא תשובה מלאה 

#include <stdio.h>

int max, time_max,min, time_min, avg=0,failss=0;

void c_max(int *ptr3)
{

if (*ptr3>max)
{
time_max=1;
max=*ptr3;
}

else if (*ptr3==max)time_max++;


}



void c_min(int *ptr3)
{

if (*ptr3<min)
{
time_min=1;
min=*ptr3;
}

else if (*ptr3==min)time_min++;


}



void c_avg (int *ptr3)
{

avg=avg+(*ptr3);

}



void c_fails(int *ptr3)
{
if(*ptr3<55) failss++;
}

int main()
{
int grades[10], *ptr1,*ptr2;
max=0;
min=100;
for(ptr1=ptr2=grades; ptr2-ptr1<10;ptr2++)
{

printf("\n Plese enter grade numnber %d \n",ptr2-ptr1+1);

scanf("%d",ptr2);

c_max(ptr2);

c_min(ptr2);

c_avg(ptr2);

c_fails(ptr2);



}
printf("\n The max grade is %d, and %d got it. \n The min grade is %d and %d got it. \n the avg is %d \n the number of failers is %d", max, time_max, min, time_min,avg/10, failss );



return 0;
}




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


#include <stdio.h>

int main()
{

int counter=0,i;
char a[20], *ptr1,*ptr2,temp;
printf("please enter string: \n");
gets(a);

for(ptr1=ptr2=a; *ptr2; ptr2++);
counter=ptr2-ptr1;
ptr2--;
for(i=0;i<(counter/2);ptr1++,ptr2--,i++)
{

temp=*ptr1;
*ptr1=*ptr2;
*ptr2=temp;

}

printf("\n");
puts(a);


return 0;


}











אורך חיים: life time
טווח הכרה: scope

טווח הכרה: הוא מושג המתאר באילו שורות של התוכנית המשתנה מוכר.
אורך חיים: מתי המשתנה מותר (מתי הוא "נולד") ועד מתי ערכו תקף (מתי הוא "מת).

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

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

משתנה גלובלי שאיננו מאותחל מקבל את הערך 0.
משתנה אוטומטי שאיננו מאותחל מהוא בעל ערך אקראי. (במונח המקצועי: ערך מזובל).



רשום תכנית שתקלוט מהמשתמש 2 מחרוזות. מחרוזת אחת של 5 תווים ומחרוזת שנייה של 3 תווים. התכנית תבדוק ותדפיס האם המחרוזת הקטנה מוכלת במחרוזת הגדולה וכמה פעמים היא מוכלת.



#include <stdio.h>

void main()
{
    int check=2, good=0;
    int i;
    char a[6], b[4];
    char *ptr1, *ptr2;
    char *ptr3, *ptr4;

    printf("please enter string 5 chars");
    gets(a);
printf("\n");
printf("please enter string b 3 chars");

gets(b);


printf("\n");



    for(ptr1=a,ptr2=b, check=2; *ptr1; ptr1++, ptr2=b, check=2)
    {

if(*ptr1==*ptr2)
{
   ptr3=ptr1; ptr4=ptr2;

while(*(ptr3+1) && *(ptr4+1) && check !=0)
{
   ptr3++;
 ptr4++;
   if(*ptr3==*ptr4)

    check--;

}

}
if(check==0) good++;


    }
    printf("\n");
    printf("\n");

printf("the number is: %d", good);

scanf("%d",&i);

}





מבנים - structures

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

למשל מבנה בשם תלמיד, יכלול את המשתנים הבאים:
תעודת זהות תלמיד ( long, האמת היא שמשתמשים במציאות ב-char במערכות)
שם תלמד (char בעל 30 תווים)
שם משפחה char בעל 30 תווים)
ציון במחשבים (int)
ציון באומנות (int)
גיל (מבנה בשם "תאריך1")


למשל מבנה בשם תאריך, יכלול את המשתנים הבאים:
יום (int)
חודש (int)
שנה (int)

הצהרות על מבנה
יש שתי שיטת על מנת להצהיר על מבנה:
א. שיטת הטיפוס (השיטה המומלצת)
ב. שיטת התג (תגית).

א.


typedef struct
{
int day;
int month;
int year;
} date ;


typedef sturct 
{
long id;
char name[30];
int computers;
int art;
struct date taric;
} ;



ב.

struct student {
long id;
char name[30];
int computers;
int art;
struct date taric;
};


הגדרת משתנים מטיפוס מבנה בשיטת טיפוס:
student arie;
date birthday;


הגדרת משתנים מטיפוס מבנה בשיטת תג

struct student arie;


אתחול בשלב ההגדרה:

date birthday={1,1,1996};
student daniel={207342342, "daniel", 78,30,birthday};


השמה לאיבר במבנה האופרטור נקודה
arie.id=203423234;
arie.art=97;


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

התכנית תקלוט את הפרטים מהמשתמש.

פתרון מלא תשובה מלאה דרך מלאה 

#include <stdio.h>
void main()
{
typedef struct{
char name[10];
char last_name[10];
int grade_com;
int grade_ele;
} student;
student user;
     printf("\n please enter name");
     gets(user.name);

     printf("\n please enter last name:");
     gets(user.last_name);

     printf("\n please enter grade of computer");
     scanf("%d", &user.grade_com);

     printf("\n please enter grade of electricity");
     scanf("%d", &user.grade_com);

}




מבנה time הנראה כך.
struct time{
int hour,minitue,seconds;
};
רשום תוכנית המגדירה 3 משתנים  t1  , t2  ,  t3 , קולטת לשני המבנים הראשונים נתונים מהמשתמש, מחשבת את הפרש הזמן    t1-t2   ומכניסה אותו ל t3.


פתרון מלא תשובה מלאה 


#include<stdio.h>

void main()
{

typedef struct
{
int hour;
int minutes;
int seconds;
} time;

time t1, t2, t3;

int i, sum1, sum2,sum3;


printf("please enter first hour");

scanf("%d",&t1.hour);

printf("\nplease enter first minute");

scanf("%d",&t1.minutes);

printf("\nplease enter first second");

scanf("%d",&t1.seconds);

printf("\nplease enter second hour");
scanf("%d",&t2.hour);

printf("\nplease enter second minute");
scanf("%d",&t2.minutes);


printf("\nplease enter second second");
scanf("%d",&t2.seconds);

sum1= (t1.hour*3600)+(t1.minutes*60)+(t1.seconds);

sum2= (t2.hour*3600)+(t2.minutes*60)+(t2.seconds);
sum3=sum1-sum2;

t3.hour=sum3/3600; sum3=sum3%3600;
t3.minutes=sum3/60;sum3=sum3%60;
t3.seconds=sum3;

printf("\n hour: %d \nminutes: %d\n seconds: %d", t3.hour, t3.minutes,t3.seconds);

}





רשום תוכנית בעזרת מערך של מבנים מטיפוס סטודנט. כל מבנה מורכב בצורה הבאה:
typedef  struct {
long id; //   תעודת זהות
char name[25]; //   שם סטודנט
int c,takbilit,sifratit;  //     מקצועות הלימוד
float average; //  ממוצע של 3 המקצועות שבשורה מעל
}student;
  1. הגדר את המערך. גודל המערך כמספר הסטודנטים בכיתה שלך.
  2. רשום תוכנית ראשית שבה יהיו קריאות (זימונים) לפונקציות הבאות :
    1. קריאה לפונקציה המכניסה נתונים למבנה מטיפוס סטודנט. הקריאה תתבצע בעזרת לולאה . כמות הפעמים שהלולאה מתבצעת הוא כמספר הסטודנטים בכיתה.
    2. קריאה לפונקציה הבודקת ומדפיסה מיהו התלמיד עם הציון הגבוה במקצוע שפת c שבתוך המערך ומהו הציון.
    3. קריאה לפונקציה הבודקת ומדפיסה מיהו התלמיד עם הציון הגבוה במקצוע takbilit שבתוך המערך ומהו הציון.
    4. קריאה לפונקציה הבודקת ומדפיסה מיהו התלמיד עם הציון הגבוה במקצוע sifratit שבתוך המערך ומהו הציון.
    5. קריאה לפונקציה הבודקת ומדפיסה מיהו התלמיד עם ממוצע הציונים הגבוה ביותר במערך ומהו הממוצע שלו.


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

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


#include<stdio.h>


typedef  struct {
long id; //  id of student
int name; //   name of student
int c,takbilit,sifratit;  //    subjects
float average; // avg of subjects
}student;





void fill_details(student yd1[])
{
int i;
for(i=0; i<2; i++)
{

printf("\n please enter number of student:");

scanf("%d",&yd1[i].name);




//gets(&yd1[i].name);

printf("\n please enter id of student:");
scanf("%ld",&yd1[i].id);




printf("\n please enter c grade of student:");
scanf("%d",&yd1[i].c);



printf("\n please enter takbilit of student:");
scanf("%d",&yd1[i].takbilit);


printf("\n please enter sifratit grade of student:");
scanf("%ld",&yd1[i].sifratit);

yd1[i].average=(yd1[i].c+yd1[i].takbilit+yd1[i].sifratit)/(float)3.0;
printf("\n %f", yd1[i].average);

}

}

void bestc(student yd1[])
{
int max=yd1[0].c;
int i;
int num;
for(i=0; i<2;i++)
{
if(yd1[i].c>max)
{
max=yd1[i].c;
num=i;
}
}
printf("\n the best student in c is:");
printf("\n %d",yd1[num].name);
}


void main()
{

int i;
student yd1[2];

fill_details(yd1);
bestc(yd1);

scanf("%d",&i);
}










במכללה שבה אתה לומד  יש 5000 ספרים שונים. יש להגדיר מערך של מבנים מהטיפוס book  הנראים כך:   
typedef struct {
int code; //   קוד הספר
char name[20]; // שם הספר
char author[20]; //  מחבר הספר
int amount; //  כמות הספרים בעלי קוד ושם שווים
}book;

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

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

------------- M E N U ---------
a ---  Add a new Book //     הוספה של ספר חדש
i  ---  Increase items quantity //  הגדלת כמות הספרים בעלי אותו הקוד  
d ---  Decrease items quantity /*     הקטנה של כמות הספרים מאותו קוד (ספר קרוע ולא ראוי לשימוש...)                                                                                          */
m --- find maximum books               /*  מציאה והדפסה של הספר שבו הכי הרבה עותקים  - ( הנח שיש רק אחד כזה )                                                                                */
x --- To delete Book // מחיקה של אחד הספרים מהמבנה
p --- Print all Books //  הדפסת כל הספרים שבספריה במסך
q --- To Quit //  יציאה וסיום התוכנית
המשתמש יקיש על המקש המתאים ויקבל את השרות הנכון.
יש לבנות את התוכנית בצורה מודולארית (מבנית) עם פונקציות.


פתרון מלא תשובה מלאה איך לפתור דרך מלאה תשובה נכונה מדריך חינם

#include<stdio.h>
#include<string.h>

typedef struct {
int code; //   code of book
char name[20]; // name of book
char author[20]; //  name of author
int amount; //  amount of books
}book;

int i=0;



void new_book(book yd1[])
{




printf("\n please enter code of book:");

scanf("%d",&yd1[i].code);

flushall();




printf("\n please enter name of book:");
gets(yd1[i].name);
flushall();

printf("\n please enter name of author:");
gets(yd1[i].author);
flushall();

printf("\n please enter the amount of books:");
scanf("%d",&yd1[i].amount);

i++;
}


void Increase (book yd1[])
{
int w, gg, num=-1,add_num;
char temp[20];
printf("\n what book do you want to add?");
flushall();
gets(temp);
for(w=0;w<i;w++)
{

gg= strcmp(temp, yd1[w].name);
if (gg==0) num=w;
}

if(num != -1) 
{
printf(" \n how many books do you want to add?");
flushall();
scanf("%d", &add_num);
flushall();
yd1[num].amount=yd1[num].amount+add_num;

}
}




void max_book (book yd1[])
{
int max, w, result=0;
if(i !=0)
{
max=yd1[0].amount;
for(w=0; w<i; w++)
{
if(yd1[w].amount> max)
{
max=yd1[w].amount;
result=w;
}

}
printf("\n the book with the max amount is:");
flushall();
puts(yd1[result].name);

}

}





void delete (book yd1[])
{
{
int w, gg, num=-1,add_num;
char temp[20];
printf("\n what book do you want to delete?");
flushall();
gets(temp);
for(w=0;w<i;w++)
{

gg= strcmp(temp, yd1[w].name);
if (gg==0) num=w;
}

if(num != -1) 
{


yd1[num].code=0;

flushall();


yd1[num].name[0]='d';
yd1[num].name[1]='e';
yd1[num].name[2]='l';
yd1[num].name[3]='e';
yd1[num].name[4]='t';
yd1[num].name[5]='e';
yd1[num].name[6]='\0';

flushall();

yd1[num].author[0]='d';
yd1[num].author[1]='e';
yd1[num].author[2]='l';
yd1[num].author[3]='e';
yd1[num].author[4]='t';
yd1[num].author[5]='e';
yd1[num].author[6]='\0';

flushall();

printf("\n please enter the amount of books:");
yd1[num].amount=0;

printf(" \n The book deleted successfuly ");
}
}

}

void menu()
{
printf(" \n \n \t \t ------------- M E N U --------- \n a ---  Add a new Book \n i  ---  Increase items quantity \n d ---  Decrease items quantity \n m --- find maximum books \n x --- To delete Book \n p --- Print all Books \n q --- To Quit ");

}

void print_all (book yd1[])
{

int w;
for (w=0; w<i; w++)
{

printf("\n code of book:");

printf("\n %d",yd1[w].code);

flushall();




printf("\n please enter name of book:");
puts(yd1[w].name);
flushall();

printf("\n name of author:");
puts(yd1[w].author);
flushall();

printf("\n amount of books:");
printf("\n %d",yd1[w].amount);
printf("\n \n \n");
}

}


void main()
{

int i;
book yd1[5];
char choose;
while(choose != 'q')
{
menu();
printf("\nPlease choose your action");
scanf("%c",&choose);

switch(choose)
{
case 'a':
new_book(yd1);
flushall();
break;


case 'i':
Increase(yd1);
flushall();
break;




case 'p':
print_all(yd1);
flushall();
break;

case 'm':
max_book(yd1);
flushall();
break;


case 'x':
delete(yd1);
flushall();
break;
}


}


}






קצבים files
קובץ הוא אוסף של אפסים או אחדים שמקובצים בשם אחד ונשמרים באמצעי שמירה כמו: דיסק קשיח, דיסק און קי, או בכל אמצעי שמירה אחר.

יש שני סוגי קבצים:
  1. קובץ מסוג (פורמט) טקסט. דוגמאות: cpp ,txt, vb,c, doc
  2. קובץ מסוג (פורמט) בינארי: dat, bin, hex, com, exe

בפורמט טקסט הופכים כל תו שהמשתמש רשם לערך אסקי (ASCII) שלו.
קבצי טקסט הם קבצים שניתן לקרוא ולהבין אותם בקלות.

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

קובץ טקסט גדול בהרבה מקובץ בינארי (בדרך כלל).

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

3 שלבים בטיפול בקובץ
1. פתיחת קובץ
2. קריאה / כתיבה לקובץ
3. סגירת הקובץ.

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

על מנת לטפל בקבצים, נצטרך תחילה להגדיר מצביע לאותו קובץ!
FILE *p;
הגדרת מצביע למבנה מטיפוס FILE

תהליך של פתיחת קובץ
כדי לפתוח את הקובץ אנחנו צריכים לזמן את הפונקציה: fopen אשר נימצאת בקובץ כותר stdlib.h.
אנחנו שולחים את הפרמטרים הפורמאליים הבאים: "שם הקובץ (או נתיב path של הקובץ)", ואת אופן הגישה של הקובץ בהתאמה.

אם פתיחת הקובץ הצליחה, מוחזר ל-P ערך כלשהו שונה מאפס
אם פתיחת הקובץ לא הצליחה, מוזר ל-P הערך (000000000) NULL.

FILE *p;
p=fopen("my_file.txt","w");


כאשר כתבנו: my_file.text, התוכנה שלנו תלך למקום בו שמורה התוכנית, תחפש שם את הקובץ my_file.txt.
אם היא לא תמצא אחד כזה, היא תיצור אחד כזה.
אם היא תמצא אחד כזה, היא תפתח אותו.

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

FILE *p;

p=fopen("C:\Program Files\my folder\my_file.txt","w");


לאחר פתיחת הקובץ יש לבדוק האם הוא נפתח (נוצר כראוי).

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

תקינות פתיחת קובץ

לאחר שפתחנו את הקובץ נבדוק האם הוא אכן הצליח לפתוח את הקובץ שלנו בעזרת הערך שלחזר לנו מהפונצקיה fopen אשר נכנס למצביע p בפעולת השמה:
if(p==NULL)
{
printf("\n Error in opening file");
exit(1);
}


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

fclose(p);
אם הפונקציה נסגרה בהצלחה יוחזר הערך אפס,
אם הפונקציה לא נסגרה בהצלחה, יוחזר הערך ֹEOF ׁׁ(אשר שווה ל 1-)



תקינות של סגירת קובץ

if (p==EOF)
{
printf("\n Error in closing file");
exit(1);
}




אופני גישה
r - קריאה
w - כתיבה


פעולות על קבצים:
פעולות קריאה (r):
fgetc(p);   קורא תו מקובץ, במקום המצביע הנוכחי, אחרי קריאת התו הוא מתקדם קדימה לבד
fgets(name of string. amount of chars, p)

name of stirng - למחרוזת הזאת ייכנסו הנתונים שייקראו מהוקבץ
amount of chars - מספר התווים שברצוננו לקלוט ביחד עם תו סיום, אם ברצוני לקרוא 5 תווים, ארשום 6
p - המצביע של אותו קובץ
הפונקציה יכולה לעצור את הקריאה מהקובץ בשלושה מצבים

היא פוגשת n\
קוראת את מספר התווים שאמרנו לה (אם כתבנו 6 היא תקרא 5 תווים).
מגיעה ל-EOF שזה סוף הקובץ


פעולות כתיבה (w)
fputc(c,p);  כתיבת תו לקובץ, במיקום המצביע העכשווי, אחרי כתיבת התו הוא זז לבד קדימה
c- התו שאותו אתם רוצים לכתוב

fputs(name of string,p);
name of string - המחרוזת שברצוננו לכתוב לקובץ

אם לא הצלחנו לכתוב לקובץ מוחזר הערך EOF.


תרגיל:

כתוב תכנית אשר תכתוב את שמך בקובץ טקסט (txt).

#include<stdio.h>
#include<stdlib.h>

void main()
{
char my_name[20];
FILE *p;
printf("\n Please enter your name");
gets(my_name);


p=fopen("my_name.txt","w");
if(p==NULL)
{
printf("Error opening file");
exit(1);
}

fputs(my_name,p);

p=fclose(p);
if(p==EOF)
{
printf("Error closing file");
exit(1);
}

}





כתוב תכנית אשר סופרת כמה תווים של A ו-a יש בקובץ ותשחיל לתוך הקובץ: מספר האותיות A ו-a בקובץ הוא:....

#include<stdio.h>
#include<stdlib.h>

void main()
{
char tav;
char my_name[20];
int counter=0;
FILE *p;

printf("\n Please enter your name");
gets(my_name);

p=fopen("my_name.txt","w+");
if(p==NULL)
{
printf("Error opening file");
scanf("%d",&counter);
exit(1);


}

fputs(my_name,p);

while((tav=fgetc(p)) != EOF)
if(tav=='A' || tav=='a') counter++;

printf("\n the number of the letter a or A in the file is: %d",counter);
scanf("%d",&counter);

fclose(p);
if (p==EOF)
{
printf("Error opening file");
scanf("%d",&counter);
exit(1);
}
}





פתרונות מלאים לתרגילים בשפת סי ב-FILES

פתרון תרגיל מספר אחד

#include <stdio.h>
#include <stdlib.h>

 void main()
{
FILE *p=fopen("tar1.txt","wt");

char mar [255];
printf("\n por favor entre story: \n");
flushall ();
gets(mar);
fputs (mar,p);
fclose(p);


}


פתרון תרגיל מספר שתיים
#include <stdio.h>
#include <stdlib.h>

void main()
{
FILE *p=fopen("tar1.txt","r");
if(p==NULL)
{ printf("Error LOading file");
exit(1);
}
int c,counter=0;
while(c=fgetc(p)!=EOF)
{
counter++;
}
printf("\n THE number of charecters is:%d",counter);
if(fclose(p)){
exit(1);}
}


פתרון תרגיל מספר שלוש

#include <stdio.h>
#include <stdlib.h>
int counter[200],i;

void main()
{
FILE *p=fopen("tar1.txt","r");
if(p==NULL)
{ printf("Error LOading file");
exit(1);
}
char c;
c=fgetc(p);
while(c!=EOF)
{
counter[c]++;
c=fgetc(p);
}for(i=0;i<200;i++)
if(counter[i])
printf("\n THE number of charecters %c is: %d",i,counter[i]);
if(fclose(p)){
exit(1);}
}

פתרון תרגיל מספר ארבע

#include <stdio.h>
#include <stdlib.h>

char str_arry[5][20],i;

void main()
{
FILE *p=fopen("tar1.txt","w");
if(p==NULL)
{ printf("Error Loading file");
exit(1);
}
for(i=0;i<5;i++){
 printf("enter arry #%d: ",i+1);
 flushall();
 gets(str_arry[i]);
 fputs(str_arry[i],p);
 fputs("\n",p);
}

if(fclose(p))
 exit(1);
}

פתרון תרגיל מספר חמש
#include <stdio.h>
#include <stdlib.h>

void main()
{
FILE *p = fopen("tar1.txt","r");
if(p==NULL) {
printf("not ok");
exit(1);}

int count=0,i=0;
char mar [255];
while(fgets(mar,255,p))
   count++;

fclose(p);
}



פתרון תרגיל מספר שש




#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
char str_arry[5][20];

void main()
{
FILE *p1=fopen("tar1.txt","r");
FILE *p2=fopen("tar3.txt","w");
if(p1==NULL||p2==NULL)
{ printf("Error Loading file");
Sleep(2000);
exit(1);
}
char line[200];
while(fgets(line,200,p1)){
 fputs(line,p2);}

if(fclose(p1)||fclose(p2))
 exit(1);
}



פתרון תרגיל מספר שבע



#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

void main()
{
FILE *p1=fopen("tar1.txt","r");
FILE *p2=fopen("tar3.txt","w");
if(p1==NULL||p2==NULL)
{ printf("Error Loading file");
exit(1);
}
char line[200],temp,*p,*pp;

fgets(line,200,p1);
for(p=line;*p;p++);
for(p--,pp=line;p>pp;p--,pp++){
 temp=*p;
 *p=*pp;
 *pp=temp;}
 fputs(line,p2);
if(fclose(p1)||fclose(p2))
 exit(1);
}



פתרון תרגיל מספר שמונה

#include<stdio.h>
#include<stdlib.h>
void main()
{
 int big=0,little=0,digits=0,white=0;
 FILE *p=fopen("tar2.dat","r");
 char tav;
        if(p==NULL)
  {
  printf("error opening file");
  exit(1);
 }
 while((tav=fgetc(p))!=EOF)
 {
  if(tav>='A'&&tav<='Z')
  big++;
  else if
   (tav>='a'&&tav<='z')
   little++;
  else if
   (tav>='1'&&tav<='9')
   digits++;
    else
     white++;
      }
   printf("%d,%d,%d,%d",big,little,digits,white);
            }



פתרון תרגיל מספר תשע
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

void main()
{
FILE *p1=fopen("tar1.txt","r");
if(p1==NULL)
{ printf("Error Loading file");
exit(1);
}
char c,tav=1,line[200];
int count=0,i;

fgets(line,200,p1);
while(tav){
 flushall();
 count=0;
printf("enter a character\n");
printf("(enter the same character twice in a row to quit)\n");
scanf("%c",&c);
if(tav==c)
 tav=0;
else
 tav=c;

for(i=0;i<200;i++){
 if(line[i]==c)
  count++;}
printf("shows %d times\n\n",count);
}

if(fclose(p1))
 exit(1);
}


פתרון תרגיל מספר עשר

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

void main()
{
FILE *p1=fopen("tar1.txt","w+");
if(p1==NULL)
{ printf("Error Loading file");
exit(1);
}
char line[50];
int big=0,bigc=0,smal=1000000,smallc=0,i,num;

for(i=0;i<10;i++){
 printf("enter a number\n");
 scanf("%d",&line[i]);
 fprintf(p1,"%d,",line[i]);}
rewind(p1);
for(i=0;i<10;i++){
 fscanf(p1,"%d,",&num);
 if(num>big){
  big=num;
  bigc=1;}
 else if(num==big)
  bigc++;
 if(num<smal){
  smal=num;
  smallc=1;}
 else if(num==smal)
  smallc++;
 
}
printf("biggest: %d , shows %d times\nsmallest: %d , shows %d times\n",big,bigc,smal,smallc);
Sleep(5000);

if(fclose(p1))
 exit(1);
}







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












#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define clas_size 3

typedef struct{
 long id;
 char name[25];
 int c,takbilit,sifratit;
 float avarage;
}student;

student clas[clas_size],*p;

void get_data(student *p){
 int i;
 for(i=0;i<clas_size;i++,p++){
 printf("enter studet name: ");
 scanf("%s",p->name);
 printf("enter student id: ");
 scanf("%d",&p->id);
 printf("enter grade in c: ");
 scanf("%d",&p->c);
 printf("enter grade in takbilit: ");
 scanf("%d",&p->takbilit);
 printf("enter grade in sifratit: ");
 scanf("%d",&p->sifratit);
 p->avarage=((p->c)+(p->sifratit)+(p->takbilit))/3.0000;
 printf("student saved!\n");}}

void menuscreen(){
 printf("\t MENU\n");
 printf("1. get data from user\n");
 printf("2. highest mark in c\n");
 printf("3. highest mark in sifratit\n");
 printf("4. highest mark in takbilit\n");
 printf("5. highest avarage\n");
 printf("6. save data to file\n");
 printf("7. load from file\n");
 printf("8. exit\n");}

void highc(student *p){
 student *p1;
 int max=0;
 for(p=clas;p->id!=0;p++){
  if(p->c>max){
   max=p->c;
   p1=p;}}
 printf("%s got the highest mark is c\n",p1->name);
}

void highsifratit(student *p){
 student *p1;
 int max=0;
 for(p=clas;p->id!=0;p++){
  if(p->sifratit>max){
   max=p->sifratit;
   p1=p;}}
 printf("%s got the highest mark in sifratit\n",p1->name);
}

void hightakbilit(student *p){
 student *p1;
 int max=0;
 for(p=clas;p->id!=0;p++){
  if(p->takbilit>max){
   max=p->takbilit;
   p1=p;}}
 printf("%s got the highest mark in takbilit\n",p1->name);
}

void highavarage(student *p){
 student *p1;
 int max=0;
 for(p=clas;p->id!=0;p++){
  if(p->avarage>max){
   max=p->avarage;
   p1=p;}}
 printf("%s got the highest avarage\n",p1->name);
}

void saved(FILE *p1,student *p2){
 rewind(p1);
 for(p=clas;p<clas+clas_size;p++)
 fprintf(p1,"%d\n%s\n%d\n%d\n%d\n%f\n",p->id,p->name,p->c,p->takbilit,p->sifratit,p->avarage);
}

void loadd (FILE *p1,student *p2){
 rewind(p1);
 for(p=clas;p<clas+clas_size;p++){
 fscanf(p1,"%d\n%s\n%d\n%d\n%d\n%f\n",&p->id,p->name,&p->c,&p->takbilit,&p->sifratit,&p->avarage);
 printf("%d\n%s\n%d\n%d\n%d\n%f\n",p->id,p->name,p->c,p->takbilit,p->sifratit,p->avarage);}
}

void main()
{
FILE *p1=fopen("tar1.txt","a+");
if(p1==NULL)
{ printf("Error Loading file");
exit(1);
}
int stop=1,ind;
p=clas;
menuscreen();

while(stop){
  printf("enter your choice:");
  scanf("%d",&ind);
  switch (ind){
  case 1:
   get_data(p);
   break;
  case 2:
   highc(p);
   break;
  case 3:
   hightakbilit(p);
   break;
  case 4:
   highsifratit(p);
   break;
  case 5:
   highavarage(p);
   break;
  case 6:
   saved(p1,p);
   break;
  case 7:
   loadd(p1,p);
   break;
  case 8:
   stop=0;
   break;}
 }



if(fclose(p1))
 exit(1);
}





















פתרון תרגיל מספר שלוש עשרה




#include "stdafx.h"
#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#define size 3
char name [20];
typedef struct{ long code; char supplier [20];
product clas[size],*p;
int price, inventory; } product; void get_data (product *p){ int i;
scanf("%s",p->name);
for(i=0;i<size;i++){ printf("enter product name: "); printf("enter product code: ");
printf("enter product supplier: ");
scanf("%d",&p->code); printf("enter product price: "); scanf("%d",&p->price); scanf("%s",p->supplier);
printf("\t MENU\n");
printf("enter inventory: "); scanf("%d",&p->inventory); printf("product saved!\n");}} void menuscreen(){
printf("4. save to file\n");
printf("1. enter new product\n"); printf("2. find expensive product\n"); printf("3. total inventory price\n");
printf("%s cost %d\n",p->name,p->price);}
printf("5. load from file\n"); printf("7. exit\n"); } void printer(product *p){ for(;p->code!=0;p++) void most_exp(product *p){
printf("%s is the most expensive\n",p1->name);
product *p1; int max=0; char nameof [20]={NULL}; for(;p->code!=0;p++){ if(p->price>max){ max=p->price; p1=p;}} }
fprintf(p1,"%d\n%s\n%s\n%d\n%d\n",p->code,p->name,p->supplier,p->price,p->inventory);
void saved(FILE *p1,product *p2){ rewind(p1); for(p=clas;p<clas+size;p++) } void loadd (FILE *p1,product *p2){ rewind(p1); for(p=clas;p<clas+size;p++){
printf(p1,"%d\n%s\n%s\n%d\n%d\n",p->code,p->name,p->supplier,p->price,p->inventory);
fscanf(p1,"%d\n%s\n%s\n%d\n%d\n",&p->code,p->name,p->supplier,&p->price,&p->inventory); } void main() { FILE *p1=fopen("tar1.txt","a+"); if(p1==NULL) { printf("Error Loading file"); exit(1); } int stop=1,ind; p=clas; menuscreen();
loadd(p1,p);
while(stop){ printf("enter your choice:"); scanf("%d",&ind); switch (ind){ case 1: get_data(p); break; case 2: most_exp(p); break; case 3: printer(p); break; case 4: saved(p1,p); break; case 5: break;
}
case 7: stop=0; break;} } if(fclose(p1))
exit(1);











פתרון תרגיל מספר 14


#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define size 3

typedef struct{
 int day,month,year;}dates;

typedef struct{
 char name[30];
 char place;
 dates date1;
 int our_score, thier_score, our_fauls, thier_fuls;
 int victory;
} game;

game league [size];
void update(game *p){
 for(;(*p).date1.day;p++);
 printf("enter opponent team name: ");
 scanf("%s",p->name);
 printf("enter location(home-0, away-1): ");
 scanf("%d",&p->place);
 printf("enter date(day,month,year): ");
 scanf("%d,%d,%d",&(*p).date1.day,&(*p).date1.month,&(*p).date1.year);
 printf("enter our score: ");
 scanf("%d",&p->our_score);
 printf("enter thier score: ");
 scanf("%d",&p->thier_score);
 printf("enter our fauls: ");
 scanf("%d",&p->our_fauls);
 printf("enter thier fauls: ");
 scanf("%d",&p->thier_fuls);
 printf("game data saved\n");
 if(p->our_score>p->thier_score) p->victory=1;
 else p->victory=0;}

void victories(game *p){
 int wins=0,lose=0;
 for(;(*p).date1.day;p++){
  if(p->victory==1)
   wins++;
  else
   lose++;}
 printf("wins: %d\nloses: %d\n", wins,lose);}

void points(game *p){
 int wins=0,lose=0;
 for(;(*p).date1.day;p++){
  if(p->victory==1)
   wins++;
  else
   lose++;}
 printf("your team has %d points\n",lose+wins*3);}

void most_points(game *p){
 int max=0;
 for(;(*p).date1.day;p++)
  if(p->our_score>max)
   max=p->our_score;
 printf("most points scored: %d\n",max);
}

void fauls(game *p){
 int low=100,high=0;
 game *pl,*ph;
 for(;(*p).date1.day;p++){
  if((p->thier_fuls+p->our_fauls)>high)
  {high=(p->thier_fuls+p->our_fauls);
  ph=p;}
  if((p->thier_fuls+p->our_fauls)<low)
  {low=(p->thier_fuls+p->our_fauls);
  pl=p;}}
 printf("most fauls: %d\nresolt: %d:%d\n",high,ph->our_score,ph->thier_score);
 printf("least fauls: %d\nresolt: %d:%d\n",low,pl->our_score,pl->thier_score);}

void menuscreen(){
 printf("\t MENU\n");
 printf("1. enter new game data\n");
 printf("2. find most points\n");
 printf("3. resolts by fauls\n");
 printf("4. points\n");
 printf("5. victories\n");
 printf("6. save data\n");
 printf("7. load data\n");
 printf("8. exit\n");
}

void saved(FILE *p1,game *p){
 rewind(p1);
 for(p=league;p<league+size;p++)
  fprintf(p1,"%s\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n",p->name,p->place,(*p).date1.day,(*p).date1.month,(*p).date1.year,p->our_score,p->thier_score,p->our_fauls,p->thier_fuls,p->victory);
}

void loadd (FILE *p1,game *p){
 rewind(p1);
 for(p=league;p<league+size;p++){
  fscanf(p1,"%s\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n",p->name,&p->place,&(*p).date1.day,&(*p).date1.month,&(*p).date1.year,&p->our_score,&p->thier_score,&p->our_fauls,&p->thier_fuls,&p->victory);
  printf("%s\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n",p->name,p->place,(*p).date1.day,(*p).date1.month,(*p).date1.year,p->our_score,p->thier_score,p->our_fauls,p->thier_fuls,p->victory);}
}

void main()
{
FILE *p1=fopen("tar1.txt","a+");
if(p1==NULL)
{ printf("Error Loading file");
exit(1);
}

int stop=1,ind;
game *p;
p=league;
menuscreen();

while(stop){
  printf("enter your choice:");
  scanf("%d",&ind);
  switch (ind){
  case 1:
   update(p);
   break;
  case 2:
   most_points(p);
   break;
  case 3:
   fauls(p);
   break;
  case 4:
   points(p);
   break;
  case 5:
   victories(p);
   break;
  case 6:
   saved(p1,p);
   break;
  case 7:
   loadd(p1,p);
   break;
  case 8:
   stop=0;
   break;}
 }



if(fclose(p1))
 exit(1);
}





פתרון תרגיל מספר חמש עשרה 15

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define size 50


typedef struct{
 char state[20];
 int num_of_athlets;
 int gold,silver,bronze,sum;
}olympic_state;

olympic_state sta [size], temp;

void get_data(olympic_state *p){
 for(;p->num_of_athlets;p++);
 printf("enter state name: ");
 scanf("%s",p->state);
 printf("enter number of athlets: ");
 scanf("%d",&p->num_of_athlets);
 printf("enter number of golds: ");
 scanf("%d",&p->gold);
 printf("enter number of silvers: ");
 scanf("%d",&p->silver);
 printf("enter number of bronzes: ");
 scanf("%d",&p->bronze);
 p->sum = p->bronze + p->gold + p->silver; 
 printf("data saved\n");}

void printer(olympic_state *p){
 for(;p->num_of_athlets;p++)
  printf("%s won %d medals in total\n",p->state,p->sum);}

void most_golds(olympic_state *p){
 olympic_state *p1;
 int max=0;
 for(;p->num_of_athlets;p++){
  if(p->gold>max){
   max=p->gold;
   p1=p;}}
 printf("%s won the most gold medals: %d\n",p1->state,max);
}

void most_silver(olympic_state *p){
 olympic_state *p1;
 int max=0;
 for(;p->num_of_athlets;p++){
  if(p->silver>max){
   max=p->silver;
   p1=p;}}
 printf("%s won the most silver medals: %d\n",p1->state,max);
}

void most_bronze(olympic_state *p){
 olympic_state *p1;
 int max=0;
 for(;p->num_of_athlets;p++){
  if(p->bronze>max){
   max=p->bronze;
   p1=p;}}
 printf("%s won the most bronze medals: %d\n",p1->state,max);
}

void most_medals(olympic_state *p){
 olympic_state *p1;
 int max=0;
 for(;p->num_of_athlets;p++){
  if(p->sum>max){
   max=p->sum;
   p1=p;}}
 printf("%s won the most medals: %d\n",p1->state,max);
}

void order (olympic_state *p){
 int i=1;
 while (i){
  i=0;
  for(p=sta;p->num_of_athlets;p++){
   if(p->sum<(*(p+1)).sum){
    temp=*p;
    *p=*(p+1);
    *(p+1)=temp;
    i=1;
   }}}
 printer(sta);}

void menu(){
 printf("\tMENU\n");
 printf("1.Get_Data\n");
 printf("2.Find A total medals for every state\n");
 printf("3.Find Max gold medals\n");
 printf("4.Find MAX silver medals\n");
 printf("5.Find MAX bronze medals\n");
 printf("6.Find MAX total medals\n");
 printf("7.Print by order\n");
 printf("8. save data\n");
 printf("9. load data\n");
 printf("10.exit\n");
 }

void saved(FILE *p1,olympic_state *p){
 rewind(p1);
 for(p=sta;p<sta+size;p++)
  fprintf(p1,"%s\n%d\n%d\n%d\n%d\n%d\n",p->state,p->num_of_athlets,p->gold,p->silver,p->bronze,p->sum);
}

void loadd (FILE *p1,olympic_state *p){
 rewind(p1);
 for(p=sta;p<sta+size;p++){
  fscanf(p1,"%s\n%d\n%d\n%d\n%d\n%d\n",p->state,&p->num_of_athlets,&p->gold,&p->silver,&p->bronze,&p->sum);
  printf("%s\n%d\n%d\n%d\n%d\n%d\n",p->state,p->num_of_athlets,p->gold,p->silver,p->bronze,p->sum);}
}

void main()
{
FILE *p1=fopen("tar1.txt","a+");
if(p1==NULL)
{ printf("Error Loading file");
exit(1);
}

int stop=1,ind;
olympic_state *point;
point=sta;
menu();

while(stop){
  printf("enter your choice:");
  scanf("%d",&ind);
  switch (ind){
  case 1:
   get_data(point);
   break;
  case 2:
   printer(point);
   break;
  case 3:
   most_golds(point);
   break;
  case 4:
   most_silver(point);
   break;
  case 5:
   most_bronze(point);
   break;
  case 6:
   most_medals(point);
   break;
  case 7:
   order(point);
   break;
  case 8:
   saved(p1,point);
   break;
  case 9:
   loadd(p1,point);
  case 10:
   stop=0;
   break;}
 }



if(fclose(p1))
 exit(1);
}





פתרון תרגיל 17
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define size 200

typedef struct{
 int day,month,year;
}date;

typedef struct{
 date t;
 int n[6],win,price;
}loto;

loto lot[size];

void get_data(loto *p){
 int i;
 for(;p->price;p++);
 printf("enter day: ");
 scanf("%d",&p->t.day);
 printf("enter month: ");
 scanf("%d",&p->t.month);
 printf("enter year: ");
 scanf("%d",&p->t.year);
 for(i=0;i<6;i++){
  printf("enter number #%d: ",i+1);
  scanf("%d",&p->n[i]);}
 printf("enter number of wins: ");
 scanf("%d",&p->win);
 printf("enter price: ");
 scanf("%d",&p->price);  
 printf("data saved\n");}

void most_wins(loto *p){
 loto *p1;
 int max=0;
 for(;p->price;p++){
  if(p->win>max){
   max=p->win;
   p1=p;}}
 printf("on the %d/%d/%d most people won: %d\n",p1->t.day,p1->t.month,p1->t.year,max);}

void big_price(loto *p){
 loto *p1;
 int max=0;
 for(;p->price;p++){
  if(p->price>max){
   max=p->price;
   p1=p;}}
 printf("on the %d/%d/%d was the biggest price: %d\n",p1->t.day,p1->t.month,p1->t.year,max);}

void big_price_pperson(loto *p){
 loto *p1;
 int max=0;
 for(;p->price;p++){
  if(p->win!=0)
   if(p->price/p->win>max){
    max=p->price/p->win;
    p1=p;}}
 printf("on the %d/%d/%d was the biggest price: %d\n",p1->t.day,p1->t.month,p1->t.year,max);}

void no_price(loto *p){
 for(;p->price;p++){
  if(p->win==0){
   printf("on the %d/%d/%d no one won. the numers were: %d,%d,%d,%d,%d,%d\n",p->t.day,p->t.month,p->t.year,p->n[0],p->n[1],p->n[2],p->n[3],p->n[4],p->n[5]);}}}

int nums[41];
void numbers(loto *p,int w){
 int i,m=0,mi=10000,is,ism;
 for(;p->price;p++){
  for(i=0;i<6;i++){
   nums[(*p).n[i]]++;}}
 for(i=1;i<41;i++){
  if(nums[i]>=m){
   m=nums[i];
   is=i;}
  if(nums[i]<=mi){
   mi=nums[i];
   ism=i;}
 }
 if(w==1)
  printf("%d showed the most times: %d\n",is,m);
 else
  printf("%d showed the least times: %d\n",ism,mi);

}

void menu(){
 printf("\tMENU\n");
 printf("1.Get_Data\n");
 printf("2.Maximum people Wins\n");
 printf("3.Maximum Price\n");
 printf("4.Maximum price to person\n");
 printf("5.No wins\n");
 printf("6.Maximum Number\n");
 printf("7.Minimum Number\n");
 printf("8. save data\n");
 printf("9. load data\n");
 printf("10.exit\n");
 }

void saved(FILE *p1,loto *p){
 rewind(p1);
 for(p=lot;p<lot+size;p++)
  fprintf(p1,"%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n",(*p).t.day,(*p).t.month,(*p).t.year,p->n[0],p->n[1],p->n[2],p->n[3],p->n[4],p->n[5],p->price,p->win);
}

void loadd (FILE *p1,loto *p){
 rewind(p1);
 for(p=lot;p<lot+size;p++){
  fscanf(p1,"%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n",&(*p).t.day,&(*p).t.month,&(*p).t.year,&p->n[0],&p->n[1],&p->n[2],&p->n[3],&p->n[4],&p->n[5],&p->price,&p->win);
  printf("%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n",(*p).t.day,(*p).t.month,(*p).t.year,p->n[0],p->n[1],p->n[2],p->n[3],p->n[4],p->n[5],p->price,p->win);}
}

void main()
{
FILE *p1=fopen("tar1.txt","a+");
if(p1==NULL)
{ printf("Error Loading file");
exit(1);
}

int stop=1,ind;
loto *point;
point=lot;
menu();

while(stop){
  printf("enter your choice:");
  scanf("%d",&ind);
  switch (ind){
  case 1:
   get_data(point);
   break;
  case 2:
   most_wins(point);
   break;
  case 3:
   big_price(point);
   break;
  case 4:
   big_price_pperson(point);
   break;
  case 5:
   no_price(point);
   break;
  case 6:
   numbers(point,1);
   break;
  case 7:
   numbers(point,0);
   break;
  case 8:
   saved(p1,point);
   break;
  case 9:
   loadd(p1,point);
  case 10:
   stop=0;
   break;}
 }



if(fclose(p1))
 exit(1);
}




אין תגובות:

הוסף רשומת תגובה