|
Alisher ismailov shakirovich algoritmlash va dasturlash asoslari (1-qism)
|
| bet | 24/33 | | Sana | 21.02.2024 | | Hajmi | 290,29 Kb. | | #160200 |
Bog'liq Algoritmlash va dasturlash asoslari-fayllar.orgOperator
|
Nomi
|
Tavsifi
| |
!
|
Emas
|
mantiqiy inkor
| |
&&
|
Va
|
mantiqiy birikma
| |
||
|
Yoki
|
mantiqiy ajratish
|
Quyidagi dastur raqamning 2 va 3ga bo‘linishini tekshiradigan dastur:
1 #include
2 using namespace std;
3
4 int main()
5 {
6 int raqam;
7 cout << "Butun sonni kiriting: ";
8 cin >> raqam;
9
10 if (raqam % 2 == 0 && raqam % 3 == 0)
11 cout << raqam << " 2 va 3 ga bo`linadi." << endl;
12
13 if (raqam % 2 == 0 || raqam % 3 == 0)
14 cout << raqam << " 2 yoki 3 ga bo`linadi." << endl;
15
16 if ((raqam % 2 == 0 || raqam % 3 == 0) &&
17 !( raqam % 2 == 0 && raqam % 3 == 0))
18 cout << raqam << " 2 yoki 3 ga bo`linadi, lekin ikkalasiga bo`linmaydi." << endl;
19
20 return 0;
21 }
Natija:
Butun sonni kiriting: 4
4 - 2 yoki 3 ga bo‘linadi.
4 - 2 yoki 3 ga bo‘linadi, lekin ikkalasiga bo‘linmaydi.
(% 2 == 0 && raqam % 3 == 0) (10-satr) raqamning 2 va 3 ga boʻlinishini tekshiradi.
(% 2 == 0 || raqam % 3 == 0) (13-satr) raqamning 2 yoki 3 ga boʻlinishini tekshiradi. Demak, 16–17-qatorlardagi mantiqiy ifoda.
Agar && operatorining operandlaridan biri noto‘g‘ri bo‘lsa, ifoda false(noto‘g‘ri) bo‘ladi; agar || operandlaridan biri operator to‘g‘ri bo‘lsa, ifoda true hisoblanadi. C++ dasturlash tili ushbu operatorlarning ish faoliyatini yaxshilash uchun ushbu xususiyatlardan foydalanadi.
Kabisa yilini aniqlash
Yil 4 ga bo`linsa, lekin 100 ga bo`linmasa yoki 400 ga bo`linsa, bu kabisa yil hisoblanadi.
1 #include
2 using namespace std;
3
4 int main()
5 {
6 cout << "Yilni kiriting: ";
7 int yil;
8 cin >> yil;
9
10 // Yil kabisa yili ekanligini tekshirish
11 bool kabasiYil = (yil % 4 == 0 && yil % 100 != 0) || (yil % 400 == 0);
13
14 // Natijani ko`rsatish
15 if(kabasiYil)
16 cout << yil << " kabisa yili" << endl;
17 else
18 cout << yil << " kabisa yil emas" << endl;
19
20 return 0;
21 }
Natija:
Yilni kiriting: 2008
2008 yil kabisa yili
switch bayonotlari
Switch operatori o‘zgaruvchi yoki ifoda qiymatiga asoslangan bayonotlarni bajaradi. C++ dasturlash tili bir nechta holatlar uchun kod yozishni soddalashtirish uchun switch bayonotini taqdim etadi.
Switch bayonoti quyidagi qoidalarga amal qiladi:
O‘zgartirish ifodasi integral qiymat berishi va har doim qavs ichiga olinishi kerak.
Qiymat 1, . . . , va qiymatN integral doimiy ifodalardir, ya’ni ular 1 + x kabi o‘zgaruvchilarni o‘z ichiga olmaydi. Bu qiymatlar kasrli son qiymatlari bo‘lishi mumkin emas.
Case operatoridagi qiymat switch ifoda qiymatiga to‘g‘ri kelganda, bu holatdan boshlangan operatorlar break operatorigacha yoki switch operatorining oxirigacha bajariladi.
Ixtiyoriy bo‘lgan standart holat, ko‘rsatilgan holatlarning hech biri switch ifodasiga mos kelmasa, amallarni bajarish uchun ishlatilishi mumkin.
break operatori darhol switch iborasini to‘xtadi.
switch (kun)
{
case 1: cout<<”Dushanba”; break;
case 2: cout<<”Seshanba”; break;
case 3: cout<<”Chorshanba”; break;
case 4: cout<<”Payshanba”; break;
case 5: cout << "Juma"; break;
case 6: cout << "Shanba" break;
case 7: cout<<”Yakshanba”; break;
}
Amaliy mashg‘ulotlar
x qiymatini 1 deb hisoblab, quyidagi mantiqiy ifodalar natijasini aniqlang:
(x > 0)
(x < 0)
(x != 0)
(x >= 0)
(x != 1)
Quyidagi kodning chop etilishini aniqlang:
bool b = true;
int i = b;
cout << b << endl;
cout << i << endl;
Agar y 0 dan katta bo‘lsa, x ga 1 ni belgilaydigan if ifodasini yozing
Agar ball 90 dan yuqori bo‘lsa, to‘lovni 3% ga oshiradigan if bayonotini yozing
Quyidagi kodda nima noto‘g‘ri?
if radius >= 0
{
yuzi = radius * radius * PI;
cout << "Doira yuzi - " <<
" radius " << radius << "- yuzi " << yuzi;
}
Agar son 90 dan yuqori bo‘lsa, to‘lovni 3% ga, boshqa hollarda to‘lovni 1% ga oshiradigan if bayonotini yozing
Agar raqam 30 bo‘lsa, (a) va (b) dagi kodning chop etilishi qanday natija beradi? Agar raqam 35 bo‘lsachi?
|
if(nomer % 2 == )
cout |
if(nomer % 2 == ){
cout<}else{
cout<}
| |
a
|
b
|
Quyidagi kodda xatoni toping va to‘g‘rilang:
if (natija >= 60.0)
cout << "Baho 2";
else if (natija >= 70.0)
cout << “Baho 3";
else if (natija >= 80.0)
cout << “Baho 4";
else if (natija >= 90.0)
cout << "Baho 5";
else
cout << "Baho 1";
Mantiqiy ifoda yordamida quyidagi bayonotni qayta yozing:
if (sanoq % 10 == 0)
yangiQator = true;
else
yangiQator = false;
34 dan 55 gacha bo‘lgan tasodifiy butun sonni (int) oladigan ifodani yozing.
0 dan 999 gacha tasodifiy butun sonni (int) oladigan ifodani yozing.
x qiymatini 10 dan 100 gacha ekanligini tekshirish uchun quyidagi ifodalardan qaysi biri to‘g‘ri?
a. 100 > x > 10
b. (100 > x) && (x > 10)
c. (100 > x) || (x > 10)
d. (100 > x) and (x > 10)
e. (100 > x) or (x > 10)
Quyidagi ikkita ifoda bir xilmi natija beradimi?
a. x % 2 == 0 && x % 3 == 0
b. x % 6 == 0
Agar x 45 va 67 bo‘lsa, x >= 50 && x <= 100 ifodaning qiymati qanday bo‘ladi, yoki 101 bo‘lsachi?
Agar yosh 13 dan katta va 18 dan kichik bo‘lsa, holat to‘g‘ri bo‘ladigan mantiqiy ifodani yozing.
Og‘irligi 50 kgdan va bo‘yi 60 smdan katta bo‘lsa, to‘g‘ri deb baholanadigan mantiqiy ifodani yozing
Sikl operatori. Oddiy va oʻrnatilgan sikllari.
12-mavzu
while sikli (loop)
Loop dizayn strategiyalari
Case-study: sonlarni ayirish bo‘yicha test
Foydalanuvchining tasdiqlashi bilan siklni boshqarish
Do-while sikli
For sikli
Qaysi sikldan foydalanish kerak
Sikl ichida sikl
Kalit so‘zlar break va continue
Amaliy mashg‘ulotlar
Sikl operatorlari. shart bilan sikl while, Do while sikl operatori va ularning farqi. formatlar va yozuv qoidalari. Sikllarni dasturlashda xatoliklar.
Dasturga buyruqlarni qayta-qayta bajarishni aytish uchun sikldan foydalanish mumkin. Aytaylik, siz (masalan, "C++ ga xush kelibsiz!") xabarini 100 marta ekranga chop etishingiz kerak. Quyidagi kodlarni 100 marta yozish zerikarli bo‘ladi:
|
100 marta
|
cout”C++ ga xush kelibsiz!\n”;
cout”C++ ga xush kelibsiz!\n”;
cout”C++ ga xush kelibsiz!\n”;
.......
cout”C++ ga xush kelibsiz!\n”;
|
C++ dsturlash tili operatsiya yoki amallar ketma-ketligi necha marta bajarilishini nazorat qiluvchi sikl(loop) deb ataladigan kuchli konstruksiyani taqdim etadi. Sikl (Loop) bayonotidan foydalanib, siz kompyuterga chop etish bayonotini 100 marta kod yozmasdan, qatorni 100 marta chop etishingiz mumkin:
int sanoq = 0;
while (sanoq < 100) {
cout << "C++ ga xush kelibsiz!\n";
sanoq++;
}
Yuqoridagi misolda o‘zgaruvchining soni dastlab 0 ga teng. Sikl (Loop) (sanoq < 100) to‘g‘ri(true) yoki noto‘g‘ri(false)ligini tekshiradi. Agar to‘g‘ri bo‘lsa, u ‘C++ ga xush kelibsiz!’ xabarini chop etish uchun sikl blokini bajaradi va increment (o‘sish)lar soni 1 ga teng bo‘ladi. Bu jarayon (sanoq < 100) holati noto‘g‘ri (false) bo‘lgunga qadar (ya’ni, sanoq 100 ga yetguncha) sikl (loop) bloki qayta-qayta bajariladi. Bu vaqtda sikl tugaydi va sikl operatoridan keyingi operator bajariladi.
Sikl (Loop)lar - bayonotlar blokining takroriy bajarilishini boshqaruvchi konstruksiyalar hisoblanadi. Sikl (Loop) tushunchasi dasturlash uchun juda muhim hisoblanadi. C++ dasturlash tilida 3 turdagi sikl operatorlari mavjud: while sikllari, do-while sikllari va for sikllari.
while sikli (loop)
while sikli shart to‘g‘ri (true) bo‘lganda, ko‘rsatmalarni qayta-qayta bajaradi.
while siklining sintaksisi:
while (davom qilish-sharti)
{
// sikl bloki
Bayonot(lar);
}
Dasturning takrorlanadigan kodlarini o‘z ichiga olgan qismi sikl bloki deb ataladi. Sikl (Loop) blokining bir martalik bajarilishi siklning takrorlanishi deb ataladi. Har bir siklda, sikl-davom -etish sharti, blokning bajarilishini boshqaruvchi mantiqiy ifoda mavjud. Sikl (Loop) bloki bajarilganligini aniqlash uchun har safar tekshiriladi. Agar ifoda to‘g‘ri (true) bo‘lsa, sikl bloki bajariladi; agar ifoda noto‘g‘ri (false) bo‘lsa, butun sikl tugaydi va dastur boshqaruvi while siklidan keyingi bayonotga o‘tadi.
100 marta ‘C++ ga xush kelibsiz!’ xabarini chop etuvchi while sikliga misol quyidagi blok-sxemada keltirilgan. Sikl (Loop)ning davom etish sharti sanoq < 100 va sikl bloki quyidagi ikkita bayonotni o‘z ichiga oladi:
Davom etish sharti to‘g‘ri (true) bo‘lganda while sikli blokdagi kodlarni qayta-qayta bajaradi.
Ushbu misolda siz sikl blokini necha marta bajarish kerakligini aniq bilasiz, chunki nazorat o‘zgaruvchisi sanoq bajarilishlar sonini hisoblash uchun ishlatiladi. Ushbu turdagi sikl qarama-qarshi boshqariladigan sikl deb ham ataladi.
Eslatma
sikl-davomi-sharti har doim qavs ichida bo‘lishi kerak.
Loop qanday ishlashini tushunishga yordam beradigan yana bir misol:
int jami = 0, i = 1;
while (i < 10) {
jami = jami + i;
i++;
}
cout << "Jami: " <
Agar i < 10 to‘g‘ri (true) bo‘lsa, dastur yig‘indiga i o‘zgaruvchisi qiymatini ni qo‘shadi. i o‘zgaruvchisi qiymati dastlab 1 ga teng, keyin 2, 3 va 10 gacha oshiriladi. i o‘zgaruvchisi qiymati 10 ga teng bo‘lganda, i < 10 holati noto‘g‘ri (false) bo‘ladi, shuning uchun sikl to‘xtaydi. Shuning uchun yig‘indi 1 + 2 + 3 + ... + 9 = 45 ga teng.
Agar sikl quyidagi tarzda noto‘g‘ri yozilsa:
int jami = 0, i = 1;
while (i < 10) {
jami = jami + i;
}
Bu sikl cheksiz hisoblanadi, chunki i har doim 1 ga teng va i < 10 holati doimiy to‘g‘ri (true) bo‘ladi.
Eslatma
sikl-davom-sharti oxir-oqibat noto‘g‘ri (false) bo‘lishiga ishonch hosil qiling, shunda sikl tugaydi. Keng tarqalgan dasturlash xatosi cheksiz sikllarni o‘z ichiga oladi (ya’ni, sikl abadiy ishlaydi). Agar sizning dasturingiz ishlash uchun juda uzoq vaqt talab qilsa va to‘xtamasa, unda cheksiz sikl bo‘lishi mumkin.
Yana bir keng tarqalgan xato bu dasturchilar ko‘pincha siklni bir marta ko‘proq yoki bir marta kamroq bajarishda xato qilishadi. Bu odatda bitta xato deb nomlanadi. Masalan, quyidagi sikl C++ ga xush kelibsiz! xabarini 100 marta emas, 101 marta chop etadi. Xato mantiqiy shartda yotadi, uni hisoblash <= 100 emas, balki < 100 bo‘lishi kerak.
int sanoq = 0;
while (sanoq <= 100)
{
cout << "C++ ga xush kelibsiz!\n";
count++;
}
Bir marta taxmin qiling dasturi
1 #include
2 #include
3 #include
4 using namespace std;
5
6 int main()
7 {
8 // Taxmin qilish uchun tasodifiy sonni yarating
9 srand (time(0));
10 int raqam = rand() % 101;
11
12 cout << "0 dan 100 gacha bo`lgan taxminiy raqamni toping";
13
14 // Foydalanuvchiga raqamni taxmin qilishni taklif qilish
15 cout << "\nTaxminingizni kiriting: ";
16 int taxmin;
17 cin >> taxmin;
18
19 if(taxmin == raqam)
20 cout << "Ha, raqam " << raqam << endl;
21 else if(taxmin > raqam)
22 cout << "Sizning taxminingiz juda baland" << endl;
23 else
24 cout << "Sizning taxminingiz juda past" << endl;
25
26 return 0;
27 }
Ushbu dasturni ishga tushirganingizda, u foydalanuvchidan bitta taxminni kiritishni taklif qiladi. Foydalanuvchiga qayta-qayta taxmin kiritishiga ruxsat berish uchun 15–24 qatorlarga quyidagi kodni qo‘shish mumkin:
while (to'g'ri) {
// Foydalanuvchiga raqamni taxmin qilishni taklif qilish
cout << "\nTaxminingizni kiriting: ";
cin >> taxmin; if(taxmin == raqam)
cout << "Ha, bu raqam " << raqam << endl;
else (taxmin > raqam)
cout << "Sizning taxminingiz juda baland" << endl;
else cout << "Sizning taxminingiz juda past" << endl; }
// blok oxiri
Ushbu sikl foydalanuvchidan taxmin kiritishni qayta-qayta taklif qiladi. Biroq, bu sikl noto‘g‘ri (false), chunki u hech qachon tugamaydi. Agar taxmin raqamga mos kelsa, sikl tugashi kerak. Shunday qilib, siklni quyidagicha qayta yozish mumkin:
while (taxmin != raqam)
{
// Foydalanuvchiga raqamni taxmin qilishni taklif qilish
cout << "\nTaxminingizni kiriting: ";
cin >> taxmin;
if(taxmin == raqam)
cout << "Ha, bu raqam " << raqam << endl;
else if(taxmin > raqam)
cout << "Sizning taxminingiz juda baland" << endl;
esle
cout << "Sizning taxminingiz juda past" << endl;
} // oxiri
To‘liq kod
1 #include
2 #include
3 #include
4 using namespace std;
5
6 int main()
7 {
8 // Taxmin qilish uchun tasodifiy sonni yarating
9 srand (time(0));
10 int raqam = rand() % 101;
11
12 cout << "0 dan 100 gacha bo`lgan sehrli raqamni toping";
13
14 int taxmin = -1;
15 while(taxmin != raqam)
16 {
17 // Foydalanuvchiga raqamni taxmin qilishni taklif qilish
18 cout << "\nTaxminingizni kiriting: ";
19 cin >> taxmin;
20
21 if(taxmin == raqam)
22 cout << "Ha, bu raqam " << raqam << endl;
23 else if(taxmin > raqam)
24 cout << "Sizning taxminingiz juda baland" << endl;
25 else
26 cout << "Sizning taxminingiz juda past" << endl;
27 } // oxiri
28
29 return 0;
30 }
Dastur 10-qatorda raqamni yaratadi va foydalanuvchini siklga qayta-qayta taxmin kiritishni taklif qiladi (15-27-qatorlar).
Har bir taxmin uchun dastur uning to‘g‘ri, juda baland yoki juda past ekanligini tekshiradi (21-26 qatorlar). Taxmin to‘g‘ri(true) bo‘lsa, dastur sikldan chiqadi (15-qator). E’tibor bering, taxmin -1 ga ishga tushirilgan. Uni 0 dan 100 gacha bo‘lgan qiymatga boshlash noto‘g‘ri (false) bo‘ladi, chunki bu taxmin qilingan raqam bo‘lishi mumkin.
Loop dizayn strategiyalari
To‘g‘ri siklni yozish yangi dasturchilar uchun oson ish emas. Sikl(Loop) yozishda uchta bosqichni ko‘rib chiqish kerak.
1-qadam: Qayta takrorlanishi kerak bo‘lgan bayonotlarni aniqlang.
2-qadam: Ushbu bayonotlarni quyidagi tarzda siklga joylang:
while (true)
{
bayonotlar;
}
3-qadam: sikl-davom-shartini kodlang va siklni boshqarish uchun tegishli iboralarni qo‘shing.
while (davom qilish-sharti)
{
Bayonotlar;
Loopni boshqarish uchun qo'shimcha bayonotlar;
}
Case-study: sonlarni ayirish bo‘yicha test
Quyidagi dasturda ayirish viktorina dasturi, har bir ishga tushirish uchun faqat bitta savol yaratadi. Qayta-qayta savollar yaratish uchun sikldan foydalanishingiz mumkin.
Sikl (Loop) dizayn strategiyasiga amal qiling. Birinchidan, takrorlanishi kerak bo‘lgan bayonotlarni aniqlang. Ular ikkita tasodifiy sonni olishi, foydalanuvchiga ayirish savolini berish va savolni baholash uchun bayonotlar hisoblanadi.
Ikkinchidan, iboralarni siklga joylashtiring. Uchinchidan, besh marta bajarish uchun boshqarish o‘zgaruvchisini va siklni davom ettirish shartini qo‘shing.
Quyidagi dasturda beshta savolni yaratadigan va talaba ularga javob bergandan so‘ng, to‘g‘ri javoblar sonini xabar qiladi. Dastur shuningdek, testni topshirishga sarflangan vaqtni ham ko‘rsatadi.
Ayirish bo‘yicha test sikli dasturi
#include
#include
#include
using namespace std;
int main()
{
int togrisanoq = 0; // To`g`ri javoblar sonini hisoblang
int sanoq = 0; // Savollar sonini hisoblang
long boshlashVaqti = time(0);
const int SAVOLLAR_SONI = 5;
srand (time(0)); // Tasodifiy
while (sanoq < SAVOLLAR_SONI)
{
// 1. Ikki tasodifiy bir xonali butun son hosil qiling
int raqam1 = rand() % 10;
int raqam2 = rand() % 10;
// 2. Agar raqam1 < raqam2 bo'lsa, 1 raqamini 2 raqami bilan almashtiring
if(raqam1 < raqam2)
{
int temp = raqam1;
raqam1 = raqam2;
raqam2 = temp;
}
// “raqam1 – raqam2 ?” deb javob berishga taklif qiling.
cout << "" << raqam1 << " - " << raqam2 << " ? ";
int javob;
cin >> javob;
// natijani ko'rsating
int natija = raqam1-raqam2;
if(natija == javob)
{
cout << "Siz haqsiz!\n";
togrisanoq ++;
}
else
cout << "Javobingiz noto`g`ri.\n" << raqam1 << " - " <<
raqam2 << " boʻlishi kerak " << natija << endl;
// Hisobni oshiring
sanoq++;
}
long tugashVaqti = time(0);
long testVaqti = tugashVaqti - boshlashVaqti;
cout << "To`g`ri hisob - " << togrisanoq << "\nTest vaqti "
<< testVaqti << " soniya\n";
return 0;
}
Dastur siklning bajarilishini nazorat qilish uchun nazorat o‘zgaruvchisi sanoq dan foydalanadi. sanoq dastlab 0 (8-satr) va har bir iteratsiyada 1 ga oshiriladi (39-qator). Har bir iteratsiyada ayirish savoli ko‘rsatiladi va qayta ishlanadi. Dastur 9-qatorda test boshlanishidan oldingi vaqtni, 41-satrda test tugagandan keyingi vaqtni oladi va 42-satrda test vaqtini hisoblab chiqadi.
Foydalanuvchining tasdiqlashi bilan siklni boshqarish
Oldingi misol siklni besh marta bajaradi. Agar foydalanuvchi davom etish yoki etmaslik to‘g‘risida qaror qabul qilishni istasa, foydalanuvchi tasdiqlashini taklif qilishingiz mumkin. Dasturning shablonini quyidagicha kodlash mumkin:
char siklniDavomettirish = 'Y';
while (siklniDavomettirish == 'Y')
{
// Loop blokini bir marta bajaring
...
// Foydalanuvchini tasdiqlashni so`rang
cout << "Davom etish uchun Y kiriting va tugatish uchun N: ";
cin >> siklniDavomettirish;
}
Quyidagi dasturda sonlarni o‘qiydigan va hisoblaydigan dasturni beradi. Har bir kirish qiymati uchun yangi o‘zgaruvchini e’lon qilishingiz shart emas. Kirish qiymatini saqlash uchun ma’lumotlar deb nomlangan o‘zgaruvchidan (8-qator) foydalaning va jamini saqlash uchun sum (12-satr) nomli o‘zgaruvchidan foydalaning.
Qiymat o‘qilganda, uni ma’lumotlarga tayinlang (9, 20-satrlar) va agar u nol bo‘lmasa, uni yig‘indiga (15-satr) qo‘shing.
1 #include
2 using namespace std;
3
4 int main()
5 {
6 cout << "Butun sonni kiriting (kirish tugaydi" <<" agar u 0 bo`lsa): ";
7
8 int malumotlar;
9 cin >> malumotlar;
10
11 // Kirish 0 bo`lguncha ma’lumotlarni o`qishni davom eting
12 int yigindi = 0;
13 while(malumotlar != 0)
14 {
15 yigindi += malumotlar;
16
17 // Keyingi ma’lumotlarni o`qing
18 cout << "Butun sonni kiriting (kirish tugaydi" <<"agar u 0 bo'lsa): ";
19
20 cin >> malumotlar;
21 }
22
23 cout << "Yig`indi - " << yigindi << endl;
24
25 return 0;
26 }
Agar ma’lumotlar 0 bo‘lmasa, u yig‘indiga qo‘shiladi (15-qator) va kirish ma’lumotlarining keyingi elementlari o‘qiladi (18-20-qatorlar). Agar ma’lumotlar 0 bo‘lsa, sikl tugaydi. Kirish qiymati 0 bu sikl uchun sentinel qiymati hisoblanadi. E’tibor bering, agar birinchi kirish 0 bo‘lsa, sikl bloki hech qachon bajarilmaydi va natijada yig‘indi 0 ga teng bo‘ladi.
Do-while sikli
Do-while sikli a while sikliga o‘xshash sikl asosiy farqi do while sikl blokini avval bajarib keyin holatni tekshiradi.
do-while siklining sintaksisi quyidagicha:
do
{
// Loop bloki;
Bayonot(lar);
} while (davom qilish-sharti)
Avval sikl bloki bajariladi. Keyin sikl-davom-sharti tekshiriladi. Agar shart to‘g‘ri (true) bo‘lsa, sikl bloki yana bajariladi; aks holda do-while sikli tugaydi. while va do-while sikli oʻrtasidagi asosiy farq sikl-davom-shartini tekshirish va sikl blokini bajarish tartibidir. while va do-while sikllari teng ifoda kuchiga ega. Ba’zan biri boshqasidan ko‘ra qulayroq hisoblanadi.
TestDoWhile.cpp
1 #include
2 using namespace std;
3
4 int main()
5 {
6 // Kirish 0 bo'lguncha ma'lumotlarni o'qishni davom eting
7 int yigindi = 0;
8 int malumotlar = 0;
9
10 do
11 {
12 yigindi += malumotlar;
13
14 // Keyingi ma'lumotlarni o'qing
15 cout << "Butun sonni kiriting (kirish tugaydi " <<"agar u 0 bo'lsa): ";
16
17 cin >> malumotlar;
18 }
19 while (malumotlar != 0);
20
21 cout << "Yig'indi:" << yigindi << endl;
22
23 return 0;
24 }
Eslatma
Agar oldingi TestDoWhile dasturidagi do-while siklida bo`lgani kabi, hech bo‘lmaganda bir marta bajarilishi kerak bo‘lgan sikl ichida buyruqlar mavjud bo‘lsa, do-while siklidan foydalaning. Agar while siklidan foydalansangiz, bu iboralar sikldan oldin ham, uning ichida ham paydo bo‘lishi kerak bo‘ladi.
For sikli
For sikli sikllarni yozish uchun qisqacha sintaksisga ega.
Ko‘pincha siz siklni quyidagi umumiy shaklda yozasiz:
i = boshlangichqiymat; // Loop-control o'zgaruvchisini ishga tushiring
while (i {
// Loop bloki
...
i++; // Loop-nazorat o`zgaruvchisini sozlang
}
Yuqoridagi siklni soddalashtirish uchun for siklidan foydalanish mumkin:
for (i = boshlangichqiymat; i < TugatishQiymati; i++)
{
// Loop bloki
...
}
for siklining sintaksisi quyida ko‘rsatilgan:
for (boshlangichqiymat; sikl-davom-shart; Har bir takrorlashdan keyin harakat)
{
// Loop bloki;
Bayonot(lar);
}
for sikli dastlabki amalni bir marta bajaradi, keyin sikl blokidagi bayonotlarni qayta-qayta bajaradi,va sikl-davom-sharti to‘g‘ri (true) deb baholanganda iteratsiyadan keyin amalni bajaradi. for sikli for kalit so‘zidan boshlanadi, undan keyin boshlangichQiymat belgilanadi, sikl-davom-shart va har bir takrorlashdan so‘ng increment (1ga o‘sish) va gullik qavslar ichiga olingan sikl bloki kiradi. boshlangichQiymat, sikl-davom-shart va har bir takrorlashdan keyingi harakat nuqta-vergul (;) bilan ajratiladi.
for sikli odatda sikl bloki necha marta bajarilishini va sikl qachon tugashini nazorat qilish uchun o‘zgaruvchidan foydalanadi. Bu nazorat o‘zgaruvchisi deb ataladi. Boshlang‘ich harakat ko‘pincha boshqaruv o‘zgaruvchisini ishga tushiradi, har bir takrorlashdan keyingi harakat odatda boshqaruv o‘zgaruvchisi qiymatini 1 ga oshiradi yoki kamaytiradi va sikl-davom-ettirish sharti boshqaruv o‘zgaruvchisi tugatish qiymatiga yetganligini tekshiradi. Masalan, quyidagi for sikl (loop) “C++ ga xush kelibsiz!” xabarini 100 marta ekranga chop etadi:
int i;
for (i = 0; i < 100; i++)
{
cout << "C++ ga xush kelibsiz!\n";
}
For sikli i o‘zgaruvchisini 0 ga teng qilib belgiladi, so‘ngra chiqish (cout) bayonoti qayta-qayta bajariladi va i 100 dan kichik bo‘lganda i++ amalini bajaradi.
Dastlabki harakat, i = 0, boshqaruv o‘zgaruvchisini ishga tushiradi, sikl-davom-sharti,
i < 100 tekshiriladi ushnu bayonot mantiqiy ifodadir. Agar bu shart to‘g‘ri (true) bo‘lsa, sikl bloki bajariladi. Agar u noto‘g‘ri bo‘lsa, sikl tugaydi va dastur boshqaruvi sikldan keyingi qatorga o‘tadi.
Har bir iteratsiyadan so‘ng harakat, i++, boshqaruv o‘zgaruvchisini qiymatini 1 ga oshiradi. Ushbu bayonot har bir iteratsiyadan keyin bajariladi. U nazorat o‘zgaruvchisini qiymatini 1 ga oshiradi. Oxir-oqibat, boshqaruv o‘zgaruvchisining qiymati sikl-davom-shartini noto‘g‘ri bo‘lishga majbur qilishi kerak. Aks holda, sikl cheksiz bo‘lib qoladi.
Sikl (Loop)ni boshqarish o‘zgaruvchisi for siklida e’lon qilinishi va ishga tushirilishi ham mumkin.
Misol:
for (int i = 0; i < 100; i++)
{
cout << "C++ ga xush kelibsiz!\n";
}
Agar siklda faqat bitta bayonot mavjud bo‘lsa, quyidagi misol kabi, gullik qavslarni qo‘ymaslik ham mumkin:
for (int i = 0; i < 100; i++)
cout << "C++ ga xush kelibsiz!\n";
Tavsiya
Boshqaruv o‘zgaruvchisi siklning boshqaruv tuzilmasi ichida yoki sikldan oldin e’lon qilinishi kerak. Agar siklni boshqarish o‘zgaruvchisi boshqa joyda emas, faqat siklda ishlatilsa, uni for siklining dastlabki harakatida e’lon qilish yaxshi dasturlash amaliyoti hisoblanadi. Agar o‘zgaruvchi siklni boshqarish tuzilmasi ichida e’lon qilingan bo‘lsa, uni sikldan tashqarida ishlatib bo‘lmaydi. Oldingi kodda, masalan, for siklidan tashqarida i o‘zgaruvchisiga murojaat qila olmaysiz, chunki u for sikli ichida e’lon qilingan.
For siklidagi har bir iteratsiyadan keyingi amal nol yoki undan koʻp vergul bilan ajratilgan gaplar roʻyxati boʻlishi mumkin. Masalan:
for (int i = 1; i < 100; cout << i << endl, i++);
Bu misol to‘g‘ri, lekin bu yomon dasturlash usuli hisoblanadi, chunki u kodni o‘qishni qiyinlashtiradi. Odatda, siz boshqaruv o‘zgaruvchisini boshlang‘ich harakat sifatida e’lon qilasiz va ishga tushirasiz va har bir iteratsiyadan keyin boshqaruv o‘zgaruvchisini harakat sifatida oshirasiz(increment) yoki kamaytirasiz(decrement).
Qaysi sikldan foydalanish kerak
For siklidan, while yoki do-while sikllaridan qaysi biri qulay boʻlsa, foydalanishingiz mumkin.
while va for sikllari sinovdan oldingi sikl deb ataladi, chunki sikl-davom-sharti sikl bloki bajarilishidan oldin tekshiriladi. Do-while sikli posttest sikli deb ataladi, chunki shart sikl bloki bajarilgandan keyin tekshiriladi. Sikllarning uchta shakli — while, do-while va for — ekspressiv jihatdan ekvivalentdir; ya’ni siz ushbu uchta shakldan istalganida sikl yozishingiz mumkin.
Sikl ichida sikl
Sikl boshqa sikl ichiga joylashtirilishi mumkin. Ichki sikllar tashqi sikl va bir yoki bir nechta ichki sikllardan iborat bo‘ladi. Har safar tashqi sikl takrorlanganda, ichki sikllar amallarni bajaraadi.
Ko`paytirish jadvali.cpp
1 #include
2 #include
3 using namespace std;
4
5 int main()
6 {
7 cout << " Ko'paytirish jadvali\n";
8 cout << "--------------------------------\n";
9
10 // Raqam sarlavhasini ko'rsatish
11 cout << " | ";
12 for(int j = 1; j <= 9; j++)
13 cout << setw(3) << j;
14
15 cout << "\n";
16
17 // Jadval tanasini ko`rsatish
18 for(int i = 1; i <= 9; i++)
19 {
20 cout << i << " | ";
21 for(int j = 1; j <= 9; j++)
22 {
23 // Mahsulotni ko`rsating va to`g`ri tekislang
24 cout << setw(3) << i * j;
25 }
26 cout << "\n";
27 }
28
29 return 0;
30 }
Dastur birinchi qatorda sarlavhani (7-qator), ikkinchi qatorda esa (-) (8-qator) tirelarni ko‘rsatadi. Birinchi for sikli (12-13-qatorlar) uchinchi qatorda 1 dan 9 gacha raqamlarni ko‘rsatadi. Keyingi sikl (18–27-qatorlar) tashqi tomonda boshqaruv oʻzgaruvchisi i boʻlgan tashqi for sikli hisoblanadi.
Sikl (loop) va j ichki sikl hisoblanadi. Har bir i uchun i * j natijasi ichki sikldagi chiziqda ko‘rsatiladi, j 1, 2, 3, … , 9. setw(3) manipulyatori (24-satr) har bir raqam uchun kenglikni belgilaydi.
Kalit so‘zlar break va continue
break va continue kalit so‘zlari siklda qo‘shimcha boshqaruvni ta’minlaydi. Siz switch iborasida break kalit so‘zidan foydalangansiz. Sikl (Loop)ni zudlik bilan to‘xtatish uchun siz sikldagi break dan ham foydalanishingiz mumkin. Quyidagi dasturda sikldagi break dan foydalanish samarasini ko‘rsatish uchun dastur taqdim etilgan.
TestBreak.cpp
1 #include
2 using namespace std;
3
4 int main()
5 {
6 int yigindi = 0;
7 int raqam = 0;
8
9 while(raqam < 20)
10 {
11 raqam++;
12 yigindi += raqam;
13 if (yigindi >= 100)
14 break;
15 }
16
17 cout << "Raqam bu: " << raqam << endl;
18 cout << "Yig'indi: " << yigindi << endl;
19
20 return 0;
21 }
Natija:
Raqam bu:14
Yig‘indi: 105
Dastur 1 dan 20 gacha bo‘lgan butun sonlarni yig‘indisi 100 dan katta yoki teng bo‘lguncha qo‘shadi.Ammo 13–14-qatorlarda, yig‘indi 100 dan katta yoki unga teng bo‘lganda, sikl tugaydi. 13–14-qatorlarsiz natija shunday bo‘ladi.
Natija:
Raqam 20
Jami 210
continue kalit so‘zidan siklda ham foydalanishingiz mumkin. Qachon duch kelsangiz, u joriy iteratsiyani tugatadi. Sikl joriy iteratsiyani tashlab keyingi iteratsiyadan davom etadi. Quyidagi dastur sikl-davom-shartidan foydalanish samarasini ko‘rsatadi.
TestContinue.cpp
1 #include
2 using namespace std;
3
4 int main()
5 {
6 int yigindi = 0;
7 int raqam = 0;
8
9 while (raqam < 20)
10 {
11 raqam++;
12 if (raqam == 10 || raqam == 11)
13 continue;
14 yigindi += raqam;
15 }
16
17 cout << "Yig'indi: " << yigindi << endl;
18
19 return 0;
20 }
Natija:
Yig'indi: 189
Dastur yig‘indiga 10 va 11 dan tashqari 1 dan 20 gacha butun sonlarni qo‘shadi. continue operatori raqam 10 yoki 11 ga aylanganda bajariladi ya’ni shu iteratsiyalar tashlab o‘tiladi. continue operatori joriy takrorlanishni tugatadi, shunda sikl blokidagi operatorning qolgan qismi bajarilmaydi; shuning uchun son 10 yoki 11 bo‘lganda yig‘indiga qo‘shilmaydi.
12-13 qatorlarsiz natija quyidagicha bo‘ladi:
Natija:
Yig'indi: 210
Bu holda, barcha raqamlar yig‘indiga qo‘shiladi, hatto raqam 10 yoki 11 bo‘lsa ham. Demak, natija 210 bo‘ladi.
Amaliy mashg‘ulotlar
Quyidagi kodni tahlil qiling. A, B va C nuqtada hisoblash har doim to‘g‘ri, har doim noto‘g‘ri yoki ba’zan to‘g‘ri yoki ba’zan noto‘g‘rimi ?
int sanoq = 0;
while (count < 100)
{
//A nuqta
cout << "C++ xush kelibsiz!\n";
sanoq++;
//B nuqta
}
//C nuqta
Quyidagi sikl necha marta takrorlanadi? Har bir siklning chop etishi qanday bo‘ladi?
|
int i = 1;
while(i < 10)
if(i % 2 == 0)
cout<< i << endl;
|
int i = 1;
while(i < 10)
if(i % 2 == 0)
cout<< i++ << endl;
|
int i = 1;
while(i < 10)
if(i++ % 2 == 0)
cout<< i << endl;
| |
a
|
b
|
c
|
Faraz qilaylik, kirish ma’lumoti 2, 3, 4, 5, 0. Quyidagi kodning natijasi nima?
#include
using namespace std;
int main()
{
int nomer, maks;
cin >> nomer;
maks = nomer;
while (nomer != 0)
{
cin >> nomer;
if (nomer > maks)
maks = nomer;
}
cout << "Maks " << maks << endl;
cout << "nomer " << nomer << endl;
return 0;
}
Quyidagi kodning natijasi nima? Tushuntiring.
int x = 80000000;
while (x > 0)
x++;
cout << "x: " << x << endl;
while sikli va do-while sikli o‘rtasidagi farq nima? Quyidagi while siklini do-while sikliga aylantiring.
int jami = 0;
int nomer;
cin >> nomer;
while (nomer!= 0)
{
jami += nomer;
cin >> nomer;
}
Quyidagi kodda xatolikni aniqlang va tuzating.
int jami = 0, nomer = 0;
do
{
// ma’lumot kiritish
cout << "Butun sonni kiriting, " << "\n agar 0 kiritilsa dastur to‘xtating: ";
int nomer;
cin >> nomer;
jami += nomer;
} while (nomer != 0);
cout << "Jami " << jami << endl;
for siklini boshqarishning uchta qismi nimalar? 1 dan 100 gacha bo‘lgan raqamlarni chop etadigan for siklini yozing:
Quyidagi kod bayonoti qanday amal bajaradi?
for ( ; ; )
{
// Do something
}
Quyidagi for loop iborasini while sikliga va do-while sikliga aylantiring:
long jami = 0;
for (int i = 0; i <= 1000; i++)
jami = jami + i;
For siklini while sikliga aylantirish mumkinmi? for siklidan foydalanishning afzalliklarini sanab o‘ting
Quyidagi while siklini for sikliga o‘zgartiring.
int i = 1;
int jami = 0;
while (jami < 10000)
{
jami = jami + i;
i++;
}
Quyidagi koddagi xatolarni aniqlang va tuzating:
1 int main()
2 {
3 for (int i = 0; i < 10; i++);
4 jami += i;
5
6 if (i < j);
7 cout << i << endl;
8 else
9 cout << j << endl;
10
11 while (j < 10);
12 {
13 j++;
14 }
15
16 do {
17 j++;
18 }
19 while (j < 10)
20 }
Quyidagi dasturda nima noto‘g‘ri?
1 int main()
2 {
3 for (int i = 0; i < 10; i++);
4 cout << i + 4 << endl;
5 }
Masalani yechishda oddiy va oʻrnatilgan sikllardan foydalanib, siklik blok-sxemalarni tuzish. Tashqi va ichki sikllar.
13-mavzu
Amaliy mashg‘ulotlar
Foydalanuvchi necha marta chop etish sonini kiritadigan dastur yozing.
j o‘zgaruvchi yarating va qiymatini 0 ga teng qilib belgilang, j o‘zgaruvchisi 6 ga teng bo‘lguncha j o‘zgaruvchisi qiymatini ekranga chop eting. Siklda j o‘zgaruvchisini 2 ga oshiring. (incerementdan foydalaning)
Dastur yozing son qiymati 7 bo‘lgunga qadar amal bajarilsin.
Dastur yozing, foydalanuvchi 1 dan 10 gacha bo‘lgan son kiritsin, dastur kiritilgan sonni 1 dan 10 gacha bo‘lgan sonlar bilan ko‘paytirib natija ekranga chop etsin. (karra jadval 1 ta son uchun)
Sikl ichida sikl usulidan foydalanib, karra jadvalini yarating.
Takrorlanuvchi hisoblash jarayonlarini dasturlash. Siklli hisoblash jarayonlarini dasturlash.
Amaliy mashg‘ulotlar
Foydalanuvchi necha marta chop etish sonini kiritadigan dastur yozing.
Blok-sxmasi
C++ dasturlash kodi
#include
using namespace std;
int main()
{
int n;
cout << "Necha marta ekranga chop etishni xoxlaysiz:" << endl;
cin >> n;
cout << endl;
for (int i = 1; i <= n; i++)
{
cout << i << endl;
} return 0;
}
j o‘zgaruvchi yarating va qiymatini 0 ga teng qilib belgilang, j o‘zgaruvchisi 6 ga teng bo‘lguncha j o‘zgaruvchisi qiymatini ekranga chop eting. Siklda j o‘zgaruvchisini 2 ga oshiring. (incerementdan foydalaning)
blok-sxemasi
C++ kodi
#include
using namespace std;
int main()
{
for(int j = 0; j <= 6; j = j + 2)
{
cout << j << endl;
} return 0;
}
Dastur yozing son qiymati 7 bo‘lgunga qadar amal bajarilsin.
Blok-sxemasi
C++ kodi
#include
using namespace std;
int main()
{
int sanoq = 0;
cout << endl;
for (sanoq; sanoq <= 7; sanoq++)
{
cout << “Dasturlash” << endl;
} return 0;
}
Dastur yozing, foydalanuvchi 1 dan 10 gacha bo‘lgan son kiritsin, dastur kiritilgan sonni 1 dan 10 gacha bo‘lgan sonlar bilan ko‘paytirib natija ekranga chop etsin. (karra jadval 1 ta son uchun)
Blok-sxemasi
C++ kodi
#include
using namespace std;
int main(){
int natija = 0;
int raqam = 0;
cout<<"1 dan 10 gacha son kiriting: ";
cin>>raqam;
for(int sanoq = 1; sanoq < 10; sanoq++){
natija = raqam * sanoq;
cout<}
return 0;
}
Sikl ichida sikl usulidan foydalanib, karra jadvalini yarating.
Blok-sxemasi
C++ kodi
#include
using namespace std;
int main(){
for(int sanoq1 = 1; sanoq1 < 10; sanoq1++){
for(int sanoq2 = 1; sanoq2 < 10; sanoq2++){
cout<
}
}
return 0;
}
Massivning tavsifi. Bir oʻlchovli va koʻp oʻlchovli massivlar
14-mavzu
Massiv asoslari
Massivlarni e’lon qilish
Massiv elementlariga kirish
Massivga qiymat berish
Ikki o‘lchovli massivlarni e’lon qilish
Koʻrsatkichlar massivlari
Dinamik massivlar
Dinamik massivlarning ishlashiga ta’sir qiluvchi omillar
Massivlarni qayta ishlash
Amaliy mashg‘ulotlar
Massivlar: tavsif va oʻlcham. Bir oʻlchovli massivlar, koʻrsatkichlar massivlari, dinamik massivlar. Massivlar, C++ massivlarini tavsiflash va qayta ishlash.
Bir o‘lchovli massiv ma’lumotlar to‘plamini saqlashi mumkin. Ko‘pincha, dasturni bajarish jarayonida dasturchi ko‘p sonli qiymatlarni saqlashi kerak bo‘ladi. Masalan, 100 ta raqamni o‘qib, ularning o‘rtachasini hisoblash va qancha raqam o‘rtachadan yuqori ekanligini aniqlash kerak, deylik. Birinchi, dastur raqamlarni o‘qiydi va ularning o‘rtachasini hisoblaydi, so‘ngra har bir raqamni o‘rtacha ko‘rsatkichdan yuqori yoki pastligini aniqlash uchun solishtiradi. Buni amalga oshirish uchun raqamlarning barchasi o‘zgaruvchilarda saqlanishi kerak. Dasturchi 100 ta o‘zgaruvchini e’lon qilishi va deyarli bir xil kodni 100 marta takrorlashi kerak bo‘ladi. Dasturni bu tarzda yozish amaliy jihatdan murakkab hisoblanadi. C++ dasturlash tili va boshqa yuqori darajali dasturlash tillari bir xil turdagi elementlarning qatʼiy oʻlchamdagi ketma-ket toʻplamini saqlaydigan maʼlumotlar strukturasini, massivni taqdim etadi. Ushbu holatda barcha 100 ta raqamni massivda saqlash va ularga bitta massiv o‘zgaruvchisi orqali kirish mumkin.
#include
using namespace std;
int main()
{
const int ELEMENTLAR_SONI = 100;
double raqamlar[ELEMENTLAR_SONI];
double jami = 0;
for (int i = 0; i < ELEMENTLAR_SONI; i++)
{
cout << "Yangi raqamni kiriting: ";
cin >> raqamlar[i];
jami += raqamlar[i];
}
double ortachasi = jami / ELEMENTLAR_SONI;
int count = 0; // nechta raqam ortachadan yuqori ekanligini saqlang
for (int i = 0; i < ELEMENTLAR_SONI; i++)
if (raqamlar[i] > ortachasi)
count++;
cout << "O`rtacha raqam: " << ortachasi << endl;
cout << "O`rtachadan yuqori raqamlar soni: " << count << endl;
return 0;
}
Dastur 7-qatorda 100 ta elementdan iborat massivni e’lon qiladi, 14-qatordagi massivga raqamlarni saqlaydi, har bir raqamni 15-qatordagi yig‘indiga qo‘shadi va 18-qatordagi o‘rtachani oladi. Keyin massivdagi har bir sonni o‘rtacha qiymat bilan taqqoslaydi. 20-23-qatorlarda o`rtacha qiymatdan yuqori qiymatlar sonini hisoblaydi. Yuqoridagi misol massiv nima ekanligini ko`rsatish uchun berildi. Keyingi bo‘limlarda massivlar bilan ishlashni o‘rganamiz.
Massiv asoslari
Massiv bir xil turdagi bir nechta qiymatlarni saqlash uchun ishlatiladi. Massivdagi elementga massivning indeks raqami yordamida kirish mumkin. Massiv ma’lumotlar to‘plamini saqlash uchun ishlatiladi, lekin ko‘pincha massivni bir xil turdagi o‘zgaruvchilar to‘plami deb hisoblash ham mumkin. Alohida o‘zgaruvchilarni e’lon qilish o‘rniga, masalan, nomer0, nomer1, . . . ,nomerN, dasturchi raqamlar nomli bitta massivni e’lon qiladi va raqamlar[0], raqamlar[1], . . . , raqamlar[N] alohida o‘zgaruvchilardan sifatida foydalanishi mumkin. Ushbu bo‘limda massivlarni e’lon qilish va indekslar yordamida massiv elementlariga kirish usullari ko‘rsatilgan.
Massivlarni e’lon qilish
Massivni e’lon qilish uchun quyidagi sintaksisdan foydalanib, uning ma’lumot turi va hajmini belgilash kerak:
ma’lumotTuri massivNomi[hajmi];
ma’lumotTuri har qanday ma’lumot turi bo‘lishi mumkin va massivdagi barcha elementlar bir xil ma’lumotlar turiga ega bo‘ladi. Massiv o‘lchami deklaratori sifatida tanilgan SIZE(o‘lchami) noldan katta doimiy butun songa baholanadigan ifoda bo‘lishi kerak. Misol uchun, quyidagi bayonot 10 ta double (kasrli son) ma’lumot turiga oid massivni e’lon qiladi:
double Birinchimassiv[10];
Kompilyator to‘plam massivi uchun 10 ta double ma’lumot turi uchun joy ajratadi. Massiv e’lon qilinganda uning elementlariga ixtiyoriy qiymatlar beriladi. Qiymatlarni belgilash uchun quyidagi sintaksisdan foydalanish mumkin:
massiv nomi[ indeks ] = qiymat;
Masalan, quyidagi kod massivni ishga tushiradi:
Birinchimassiv[0] = 5.6;
Birinchimassiv[1] = 4.5;
Birinchimassiv[2] = 3.3;
Birinchimassiv[3] = 13.2;
Birinchimassiv[4] = 4.0;
Birinchimassiv[5] = 34.33;
Birinchimassiv[6] = 34.0;
Birinchimassiv[7] = 45.45;
Birinchimassiv[8] = 99.993;
Birinchimassiv[9] = 111.23;
|
| |
