0.6-bob: Algoritmik fikrlash va pseudokod

0-QISM — TAYYORGARLIK · 6-mavzu

1. Kirish va motivatsiya

Ko'pchilik dasturlashni "qaysidir tilning sintaksisini yodlash" deb tushunadi. Bu — eng katta xato. Sintaksisni bir oyda unutasiz va qaytadan o'rganasiz; lekin muammoni qadamlarga bo'lib yechish ko'nikmasi — butun umringiz davomida ishlaydigan, har bir til va frameworkdan muhimroq mahorat.

Haqiqat: dasturlash tili — bu shunchaki qurol. Algoritmik fikrlash — bu qurol bilan nima qilishni bilish. Eng zo'r palitra rassom qilmaganidek, eng zo'r til ham sizni dasturchi qilmaydi. Fikrlash qiladi.

Siz kelajakda yuzlab muammoga duch kelasiz: "foydalanuvchilarni saralash", "savatdagi summani hisoblash", "takrorlanuvchi yozuvlarni topish". Hech qaysi til kitobi sizga aynan bu muammolarning yechimini bermaydi. Lekin agar siz fikrlashni bilsangiz — har qanday muammoni qadamlarga ajratib, yechimni o'zingiz ixtiro qilasiz, keyin uni istalgan tilda yozasiz.

Bu bobda o'rganasiz:

• Algoritm nima va yaxshi algoritm qanday bo'ladi.
• Computational thinking (kompyutercha fikrlash): katta muammoni qanday qilib mayda, yechiladigan bo'laklarga bo'lish.
• Pseudokod — kod yozishdan oldin, sof o'zbek (yoki istalgan) tilda fikrni tartibga solish.
• Barcha dasturlarning uch g'ishti: ketma-ketlik, shart, takror.
• Muammoga professional yondashuv usuli (bu — intervyularda ham ishlatiladi).

Bu — 2-QISM (JavaScript), 3-QISM (Algoritmlar) va System Design intervyu 15.7-bob uchun eng muhim poydevor. Kod yozishdan oldin fikrlashni o'rganamiz.

2. Nazariya — chuqur tushuntirish

2.1. Algoritm nima?

Algoritm — biror muammoni yechish yoki maqsadga yetish uchun aniq, tartibli qadamlar ketma-ketligi. Algoritm — kompyuterga xos narsa emas; siz kuniga o'nlab algoritm bajarasiz.

Hayotiy misol — choy damlash algoritmi:

1. Choynakka suv quy
2. Suvni qaynat
3. Choynakka choy barglarini sol
4. Qaynagan suvni choynakka quy
5. 5 daqiqa kut
6. Piyolaga quy

Bu — algoritm. Aniq (har qadam tushunarli), tartibli (3-qadamni 1-dan oldin qilib bo'lmaydi), tugaydigan (cheksiz emas), va natija beradigan (choy tayyor).

Boshqa misollar: ovqat retsepti, manzilga borish yo'l-yo'rig'i, IKEA mebelini yig'ish qo'llanmasi — hammasi algoritm.

O'xshatish: algoritm — bu retsept. Tarkib (input) qadamlar (jarayon) taom (output). Yaxshi retsept har kim takrorlay oladigan darajada aniq bo'ladi. Yaxshi algoritm ham xuddi shunday — kompyuter (yoki boshqa odam) hech ikkilanmasdan bajara olishi kerak.

2.2. Yaxshi algoritmning xususiyatlari

Har qanday "qadamlar to'plami" yaxshi algoritm bo'lavermaydi. Yaxshisi quyidagilarga ega:

Masalan, "suvni qaynat" — odam uchun aniq, lekin kompyuter uchun juda noaniq (necha gradus? qanday? qancha vaqt?). Kompyuter uchun algoritm mayda-chuydagacha aniq bo'lishi kerak — chunki u "o'zidan o'ylab" qo'ymaydi, faqat aytilganni bajaradi.

2.3. Computational thinking — kompyutercha fikrlash

Bu — katta, qo'rqinchli muammoni yechib bo'ladigan holatga keltirish san'ati. To'rt ustundan iborat:

1) Decomposition (bo'laklash) — katta muammoni kichik, yechiladigan qismlarga bo'lish.

Misol: "Onlayn do'kon yasash" — qo'rqinchli. Bo'laklaymiz: (a) mahsulotlar ro'yxati, (b) savat, (c) to'lov, (d) ro'yxatdan o'tish. Har biri yana bo'linadi. Endi har bir mayda qism — yechiladigan.

2) Pattern recognition (naqsh ko'rish) — o'xshashliklarni payqash.

Misol: "mahsulotlarni narx bo'yicha saralash" va "foydalanuvchilarni yosh bo'yicha saralash" — bir xil naqsh (saralash). Bittasini yechsangiz, ikkinchisini ham yechasiz.

3) Abstraction (mavhumlashtirish) — keraksiz tafsilotlarni tashlab, faqat muhimini olish.

Misol: mashina haydashda dvigatel ichida nima bo'layotgani kerak emas — faqat rul, gaz, tormoz kerak. Dasturlashda ham: funksiyani ishlatish uchun uning ichini bilish shart emas, nima qilishini bilsangiz bas (2.3-bob funksiyalar, 0.2: OS abstraksiyasi).

4) Algorithm design (algoritm tuzish) — yuqoridagilarni birlashtirib, qadamlar yozish.

2.4. Pseudokod — kod yozishdan oldin fikrlash

Pseudokod ("soxta kod") — algoritmni odam tilida, lekin dastur tuzilishiga yaqin tarzda yozish. U hech bir real tilning sintaksisiga bog'lanmagan — vergul, nuqta-vergul, qavslar haqida o'ylamaysiz, faqat mantiq haqida.

Nega pseudokod kerak?

• Fikrni tildan ajratadi. Avval nima qilishni hal qiling, keyin qanday yozishni (JS? Python?).
• Xatoni arzon tutadi. Pseudokoddagi mantiqiy xatoni tuzatish — yozilgan kodni tuzatishdan ancha oson.
• Murakkablikni kamaytiradi. "Sintaksis + mantiq" ni bir vaqtda o'ylash — qiyin. Pseudokod ularni ajratadi.
• Muloqot tili. Boshqa dasturchilar bilan g'oyani sintaksissiz muhokama qilasiz.

Misol — eng katta sonni topish (pseudokod):

ALGORITM eng_katta(sonlar):
    AGAR sonlar bo'sh BO'LSA:
        XATO qaytar "ro'yxat bo'sh"

    eng_katta = sonlar dagi BIRINCHI son
    HAR BIR son UCHUN sonlar ichida:
        AGAR son > eng_katta BO'LSA:
            eng_katta = son
    QAYTAR eng_katta

Buni o'qib, har qanday tilda yozish mumkin (4-bo'limda JS'ga aylantiramiz). E'tibor bering: bu yerda mantiq bor, sintaksis yo'q.

2.5. Barcha algoritmlarning uch g'ishti

Dunyodagi har bir dastur — qanchalik murakkab bo'lmasin — atigi uchta asosiy tuzilmadan quriladi. Bu — strukturaviy dasturlash teoremasi:

1) Ketma-ketlik (sequence) — qadamlar birin-ketin bajariladi:

qadam_1
qadam_2
qadam_3

2) Tanlov / shart (selection) — shartga qarab har xil yo'l:

AGAR shart BO'LSA:
    A ni qil
AKS HOLDA:
    B ni qil

3) Takror / tsikl (iteration) — biror narsani qayta-qayta:

TO shart ROST EKAN:
    qadamni takrorla

Mana shu uchtasini turli kombinatsiyada ulab, dunyoning eng murakkab dasturlari yoziladi. (Bularning JS sintaksisini 2.2-bobda ko'ramiz; bu yerda g'oyasini o'zlashtiramiz.)

2.6. Flowchart (blok-sxema) — algoritmni chizish

Algoritmni rasm bilan ham ko'rsatish mumkin — bu flowchart. Asosiy belgilar:

   ( Boshlash/Tugash )    oval: start/end
   [   Amal/qadam   ]     to'rtburchak: ish (hisob, tayinlash)
   <   Shart?       >     romb: qaror (ha/yo'q)
   ─────▶                strelka: oqim yo'nalishi

"Eng katta son" flowchart ko'rinishida:

        ( Boshlash )
             │
             ▼
   [ eng_katta = birinchi son ]
             │
             ▼
   [ keyingi sonni ol ]◀───────────┐
             │                      │
             ▼                      │
      < son > eng_katta? >          │
        │ha          │yo'q          │
        ▼            │              │
 [eng_katta = son]   │              │
        │            │              │
        └─────▶ < yana son bormi? >─┘ (ha)
                     │ yo'q
                     ▼
              [ eng_katta'ni qaytar ]
                     │
                     ▼
                ( Tugash )

2.7. Muammoga professional yondashuv (eng muhim qism)

Tajribali dasturchi muammoni ko'rishi bilan kod yozishga tashlanmaydi. U tartib bilan ishlaydi (bu usul intervyularda ham qo'llanadi):

  1. TUSHUN     Muammo aniq nima? Kirish nima, chiqish nima?
       │          Hech narsa noaniq qolmasin.
       ▼
  2. MISOLLAR   2-3 ta aniq misol o'ylab top (kirish  chiqish).
       │          "Chegaraviy" (edge) holatlarni ham: bo'sh? bitta? manfiy?
       ▼
  3. BO'LAKLA   Muammoni mayda qadamlarga ajrat (decomposition — 2.3).
       │
       ▼
  4. PSEUDOKOD  Yechimni odam tilida yoz 2.4-bob. Mantiqni tekshir.
       │
       ▼
  5. KOD        Pseudokodni real tilga o'gir.
       │
       ▼
  6. TEST       2-qadamdagi misollarni sina. Edge holatlarni ham.
       │          Ishlamasa — qaytib, qaysi qadamda xato qilganingizni toping.
       ▼
  7. YAXSHILA   Toza, tezroq, o'qishli qilib qayta ko'r (refactor — 15.1, 3.1).

Eng katta sir: dasturchining vaqtining ~70% fikrlash va debugga, atigi ~30% kod yozishga ketadi. Yangi boshlovchilar buni teskari deb o'ylaydi va shoshib kod yozadi — keyin soatlab debug qiladi. To'g'ri yo'l: sekin fikrlang, tez yozing.

2.8. Edge case (chegaraviy holat) — fikrlashning sifati

Yaxshi algoritmni o'rtachasidan ajratadigan narsa — chegaraviy holatlarni o'ylash. "Eng katta son" misolida:

• Ro'yxat bo'sh bo'lsa-chi?
• Bitta son bo'lsa-chi?
• Hammasi manfiy bo'lsa-chi?
• Bir xil sonlar bo'lsa-chi?
• Son emas, matn kelsa-chi? (0.1: NaN)

Yangi dasturchi faqat "oddiy" holatni o'ylaydi. Professional — buziladigan holatlarni oldindan ko'radi. Bu — keyinroq validatsiya 5.9-bob, test 8.11-bob va xavfsizlik (14) ga aylanadi.

2.9. "Avval ishlatib ol, keyin tezlat" (brute force optimize)

Yangi boshlovchilarni ko'p qiynaydigan narsa — birinchi urinishdayoq eng tez yechimni topishga harakat qilish. Bu — qulflanishga olib keladi: "qanday qilib bu masalani eng oqilona yechaman?" degan savol ostida hech narsa yozilmaydi.

Professional yondashuv teskari:

  1. BRUTE FORCE   Eng oddiy, hatto "qo'pol" yechimni yoz — ishlasa bo'lgani.
       │             (masalan: hamma juftlikni birma-bir tekshirib chiqish)
       ▼
  2. ISHLASHIGA ISHON   Misollar va edge-holatlarda to'g'ri ishlashini tasdiqla.
       │
       ▼
  3. KEYIN TEZLAT   Endi sekin joylarni izla: takroriy ish bormi? Ortiqcha
                      tsikl bormi? Yaxshiroq naqsh bormi? (3.1: Big-O)

Nega shunday? Ishlaydigan "sekin" yechim — ishlamaydigan "tez" yechimdan har doim qimmatroq. Avval to'g'rilik, keyin tezlik. Ishlaydigan yechim qo'lda bo'lsa, uni o'lchab, faqat haqiqatan sekin joyini yaxshilaysiz — "bu yer sekin bo'lar" degan taxminga emas, o'lchovga tayanasiz.

Misol: "ro'yxatda takror son bormi?" degan masalada avval har juftlikni solishtirib chiqadigan oddiy yechim yoziladi (ishlaydi). Keyingina, agar sekin bo'lsa, undan tezroq usul (masalan, ko'rilgan sonlarni belgilab borish) o'ylanadi. Birinchi qadamsiz ikkinchisiga sakrash — adashishning eng tez yo'li.

2.10. Invariant — tsikl ichida "buzilmaydigan haqiqat"

Algoritm, ayniqsa tsikl, to'g'ri ishlashini tekshirishning kuchli usuli — invariant topish. Invariant — bu tsiklning har bir aylanishidan keyin doim rost bo'lib qoladigan bir jumla.

"Eng katta son" misolini eslang: tsikl davomida eng_katta o'zgaruvchisi nimani anglatadi? Invariant shunday:

"Hozirgacha ko'rilgan sonlar ichida eng_katta — chindan ham eng kattasi."

Bu jumla tsiklning boshida ham (birinchi son bilan), har aylanishdan keyin ham, oxirida ham rost qoladi. Oxirida "ko'rilgan sonlar" = butun ro'yxat bo'lgani uchun, javob to'g'ri bo'lishi kafolatlanadi.

Invariantni ataylab so'rash — algoritmni "isbotlash"ning kirish darajasidagi shakli:

• Tsikl boshlanishidan oldin invariant rostmi?
• Har aylanish uni saqlab qoladimi (buzmaydimi)?
• Tsikl tugagach, invariantdan kerakli natija kelib chiqadimi?

Agar bu uchovi ham "ha" bo'lsa, algoritm to'g'ri ishlaydi. Bu — keyinchalik murakkabroq algoritmlar (saralash, qidiruv — 3-QISM) to'g'riligini tushunishning poydevori.

3. Pseudokod konventsiyalari

Pseudokodning rasmiy "standarti" yo'q, lekin keng tarqalgan yozuvlar bor. Biz butun kitob davomida quyidagi uslubni ishlatamiz:

ALGORITM nom(parametrlar):      algoritm boshi
    o'zgaruvchi = qiymat          tayinlash
    AGAR shart BO'LSA: ...        shart (if)
    AKS HOLDA: ...                else
    HAR BIR x UCHUN ro'yxat ichida: ...    for-each tsikl
    TO shart ROST EKAN: ...       while tsikl
    QAYTAR qiymat                 natija (return)
    XATO qaytar "..."             xato holati

Flowchart belgilar 2.6-bob: oval (start/end), to'rtburchak (amal), romb (shart), strelka (oqim).

4. Batafsil kod namunalari (pseudokod JS)

Endi muammoni pseudokodda yechib, keyin JavaScriptga o'giramiz. Bu — 2.7-dagi 45 qadam. (JS sintaksisini hali to'liq o'rganmadik — bu yerda maqsad mantiqni ko'rish; sintaksis 2-QISMda.)

Misol 1 — Eng katta son

PSEUDOKOD:
ALGORITM eng_katta(sonlar):
    AGAR sonlar bo'sh BO'LSA: XATO "ro'yxat bo'sh"
    eng_katta = sonlar[0]
    HAR BIR son UCHUN sonlar ichida:
        AGAR son > eng_katta BO'LSA: eng_katta = son
    QAYTAR eng_katta

// JS'GA O'GIRILGAN:
function engKatta(sonlar) {
  // Chegaraviy holat 2.8-bob: bo'sh ro'yxat
  if (sonlar.length === 0) {
    throw new Error("ro'yxat bo'sh");
  }
  let eng = sonlar[0];              // birinchini "eng katta" deb olamiz
  for (const son of sonlar) {       // har bir sonni ko'rib chiqamiz (2.5: tsikl)
    if (son > eng) {                // agar kattaroq bo'lsa (2.5: shart)
      eng = son;                    // yangilaymiz
    }
  }
  return eng;                       // natija
}

console.log(engKatta([3, 9, 2, 7])); // 9

Misol 2 — FizzBuzz (klassik intervyu masalasi)

PSEUDOKOD:
ALGORITM fizzbuzz(n):
    HAR BIR i UCHUN 1 dan n gacha:
        AGAR i 15 ga bo'linsa: chiqar "FizzBuzz"
        AKS HOLDA AGAR i 3 ga bo'linsa: chiqar "Fizz"
        AKS HOLDA AGAR i 5 ga bo'linsa: chiqar "Buzz"
        AKS HOLDA: chiqar i

// JS:
function fizzbuzz(n) {
  for (let i = 1; i <= n; i++) {          // 1 dan n gacha (2.5: tsikl)
    if (i % 15 === 0) console.log("FizzBuzz"); // % — qoldiq; 15=3*5 (avval tekshir!)
    else if (i % 3 === 0) console.log("Fizz");
    else if (i % 5 === 0) console.log("Buzz");
    else console.log(i);
  }
}
fizzbuzz(15); // 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz

Diqqat — tartib muhim: 15 ni birinchi tekshirish kerak. Agar 3 ni oldin tekshirsangiz, 15 ham 3 ga bo'linadi va "Fizz" chiqib, "FizzBuzz"ga yetib bormaysiz. Bu — mantiqiy tartibni o'ylashning misoli 2.5-bob.

Misol 3 — Matndagi unlilarni sanash

PSEUDOKOD:
ALGORITM unli_sanash(matn):
    unlilar = "aeiou..."
    son = 0
    HAR BIR harf UCHUN matn ichida:
        AGAR harf unlilar ichida BO'LSA: son = son + 1
    QAYTAR son

// JS:
function unliSanash(matn) {
  const unlilar = "aeiouAEIOU";       // qaysi harflar unli
  let son = 0;                         // hisoblagich (2.5: ketma-ketlik)
  for (const harf of matn.toLowerCase()) { // har bir harf (registrni tenglab)
    if ("aeiou".includes(harf)) {      // unli ichidami? (2.5: shart)
      son++;                           // ha bo'lsa, +1
    }
  }
  return son;
}
console.log(unliSanash("Salom Dunyo")); // 4 (a, o, u, o)

Misol 4 — Sonni teskari aylantirish (fikrlash mashqi)

PSEUDOKOD:
ALGORITM teskari(son):
    natija = 0
    TO son > 0 EKAN:
        oxirgi_raqam = son ning 10 ga bo'lgan QOLDIG'I
        natija = natija * 10 + oxirgi_raqam
        son = son ning 10 ga bo'lgan BUTUN qismi
    QAYTAR natija

// JS:
function teskari(son) {
  let natija = 0;
  while (son > 0) {                 // son tugaguncha (2.5: while tsikl)
    const oxirgi = son % 10;        // oxirgi raqam (qoldiq — 0.1: arifmetika)
    natija = natija * 10 + oxirgi;  // natijaga "surib" qo'shamiz
    son = Math.floor(son / 10);     // oxirgi raqamni "tashlaymiz"
  }
  return natija;
}
console.log(teskari(1234)); // 4321

5. To'g'ri va noto'g'ri holatlar

1) Fikrlamasdan kodga tashlanish

 Muammoni o'qib, darrov kod yozishga kirishish  2 soat debug
 2.7-dagi tartib: tushun  misol  pseudokod  kod  test

2) Chegaraviy holatlarni unutish

 Faqat "oddiy" kirishni o'ylash (3 ta normal son)
 Bo'sh, bitta, manfiy, takror, noto'g'ri tur — hammasini o'yla (2.8)

3) Pseudokodni "tashlab ketish"

 "Pseudokod vaqt isrofi, to'g'ridan-to'g'ri yozaman"
 Murakkab masalada avval pseudokod — mantiqni arzon tekshirasiz (2.4)

4) Algoritmni "tugaydigan" qilmaslik

 Tsikl shartini noto'g'ri qo'yib, cheksiz takror (0.1: stack/muzlash)
 Har tsiklda: "bu qachon TO'XTAYDI?" deb so'ra (2.2: cheklilik)

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — Off-by-one (bir qadam adashish)

//  oxirgi elementni o'tkazib yuborish yoki chegaradan oshish
for (let i = 0; i <= arr.length; i++) // <= xato! oxirida undefined
//  to'g'ri chegara
for (let i = 0; i < arr.length; i++)

Sababi: chegarani noto'g'ri belgilash (< o'rniga <=). Yechimi: misol bilan qo'lda tekshiring — 3 elementli massivda indekslar 0,1,2 (length=3 emas!).

Xato 2 — Cheksiz tsikl (infinite loop)

//  son hech kamaymaydi — abadiy aylanadi (sahifa qotadi — 0.5)
let son = 10;
while (son > 0) { console.log(son); /* son-- unutilgan! */ }
//  tsikl o'zgaruvchisini har safar o'zgartir
while (son > 0) { console.log(son); son--; }

Sababi: tsikl shartini "yolg'on"ga olib keladigan o'zgarish yo'q. Yechimi: "bu tsikl qaysi qadamda tugaydi?" deb har doim tekshiring.

Xato 3 — Bo'sh/noto'g'ri kirishda qulash

//  bo'sh massivda [0]  undefined, keyin xato
function eng(a) { let m = a[0]; /* a bo'sh bo'lsa m = undefined */ }
//  avval tekshir (2.8)
function eng(a) { if (a.length === 0) throw new Error("bo'sh"); /* ... */ }

Xato 4 — Mantiqiy tartib xatosi

FizzBuzzda 15 ni 3dan keyin tekshirish (Misol 2). Yechimi: shartlar tartibini misol bilan tekshiring — eng "maxsus" holat birinchi bo'lsin.

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

• JavaScript (2-QISM): shart 2.2-bob, tsikl 2.2-bob, funksiya 2.3-bob — 2.5-dagi uch g'ishtning real sintaksisi.
• Algoritmlar va ma'lumotlar tuzilmasi (3-QISM): bu bob — butun 3-QISMning kirishi; Big-O 3.1-bob, saralash 3.9-bob, rekursiya 3.11-bob. "Avval ishlat, keyin tezlat" 2.9-bob va invariant 2.10-bob — aynan shu yerda kuchayadi.
• Validatsiya 5.9-bob: chegaraviy holatlar 2.8-bob kirishni tekshirish.
• Test 8.11-bob: 2.2-dagi misollar va edge holatlar unit testlar.
• Debugging 15.5-bob: 2.7-dagi "qaytib, xatoni top" — debug metodologiyasi.
• System Design intervyu 15.7-bob: decomposition 2.3-bob va muammoga yondashuv 2.7-bob — to'g'ridan-to'g'ri ishlatiladi.
• Toza kod 15.1-bob: 2.7-dagi 7-qadam (refactor).

8. Eng yaxshi amaliyotlar (best practices)

• Avval fikrlang, keyin yozing. 2.7-dagi 7 qadamni odat qiling. Sekin fikrlash — tez yozishni beradi.
• Pseudokodni mensimang. Murakkab masalada u soatlab debug'dan saqlaydi.
• Doim chegaraviy holatlarni o'ylang 2.8-bob: bo'sh, bitta, manfiy, juda katta, noto'g'ri tur.
• Misol bilan tekshiring. Kodni yozishdan oldin ham, keyin ham — aniq kirishchiqish misolida.
• Har tsiklga "qachon tugaydi?" deb so'rang — cheksiz tsikldan saqlaydi.
• Muammoni ovoz chiqarib tushuntiring ("rubber duck debugging" — o'rdakka tushuntirish). Tushuntira olmasangiz — tushunmagansiz.
• Katta muammoni bo'laklang 2.3-bob. Bir o'tirishda butun tizimni yechmoqchi bo'lmang.
• Yodlamang — naqshni o'rganing 2.3-bob. "Saralash", "qidirish", "hisoblash" naqshlarini bilsangiz, minglab masalani yechasiz.

9. Amaliy loyiha: "Algoritm Daftari — Fikrlash Mashqlari"

Bu loyihada kod kam, fikrlash ko'p. Har masala uchun avval pseudokod, keyin kod, keyin edge-holat testlari yozasiz 2.7-bob.

Maqsad

2.7-dagi 7 qadamli yondashuvni odatga aylantirish; pseudokoddan kodga o'tishni mashq qilish.

Talablar (requirements)

Quyidagi har bir masala uchun: (1) 2-3 misol (kirishchiqish), (2) chegaraviy holatlar ro'yxati 2.8-bob, (3) pseudokod, (4) JS kod, (5) misollar bilan test.

1. Palindrom tekshiruvchi: matn old-orqa bir xil o'qilsa true ("kanok", "aza"). Bo'sh va bitta harfni ham o'ylang.
2. So'zlarni sanash: matnda nechta so'z borligini qaytar. Ketma-ket bir nechta bo'sh joy bo'lsa-chi?
3. Eng ko'p takrorlangan element: massivda eng ko'p uchraganini toping. Bir xil son bo'lsa-chi?
4. Tub son (prime) tekshiruvchi: son tub ekanini aniqlang. 0, 1, 2, manfiy sonni o'ylang.
5. Anagram tekshiruvchi: ikki so'z bir xil harflardan tuzilganmi ("tsar" va "star"). Uzunligi har xil bo'lsa?
6. (Bonus) Eng katta ikkinchi son: massivdagi ikkinchi eng katta sonni toping (eng kattani emas). Takror sonlarni o'ylang.

Maslahatlar (hint)

• Har masalaga kod yozishdan oldin pseudokod yozing — bu shart, qoida emas.
• Palindrom: matnni teskari aylantirib (Misol 4 g'oyasi) asli bilan solishtiring, yoki ikki tomondan (chap/o'ng) yuring.
• So'z sanash: bo'sh joylar bo'yicha bo'ling (split), bo'sh bo'laklarni tashlang.
• Tub son: 2 dan son gacha bo'lib ko'ring — birortasiga bo'linsa, tub emas (3.1-da tezroq usulni ko'rasiz).
• Anagram: ikki so'z harflarini saralab (sort) solishtiring, yoki har harf sonini sanang.
• Har masalada: bo'sh, bitta, takror, manfiy, noto'g'ri tur holatlarini sinang.

"Tayyor" mezonlari (acceptance criteria)

• Har masala uchun pseudokod koddan oldin yozilgan.
• Har masalada kamida 3 ta chegaraviy holat aniqlangan va sinab ko'rilgan.
• Barcha 5 (yoki 6) masala to'g'ri ishlaydi.
• Hech bir yechimda cheksiz tsikl yo'q (har biri tugaydi — 2.2).
• Bo'sh/noto'g'ri kirishda dastur qulamaydi 2.8-bob.

Yechim kodi ataylab berilmagan — bu loyihani o'zingiz yozib ko'ring.

10. Xulosa va keyingi bobga ko'prik

Bu bobda dasturchining eng muhim mahoratini — fikrlashni o'rgandik:

• Algoritm — muammoni yechish uchun aniq, tartibli, tugaydigan qadamlar (retsept kabi).
• Computational thinking: decomposition (bo'laklash), pattern recognition (naqsh), abstraction (mavhumlashtirish), algorithm design.
• Pseudokod — kod yozishdan oldin, mantiqni tildan ajratib yozish. Xatoni arzon tutadi.
• Har bir dastur uch g'ishtdan: ketma-ketlik, shart, takror.
• Muammoga yondashuv: tushun misol bo'lakla pseudokod kod test yaxshila. ~70% vaqt fikrlash va debug'ga.
• Chegaraviy holatlar 2.8-bob — yaxshi dasturchini o'rtachasidan ajratadi.

Keyingi bob — 0.7-bob: Dasturchi asboblari (VS Code, kengaytmalar, Node.js, npm). Endi mashinani (0.1–0.2), terminalni 0.3-bob, tarmoqni (0.4–0.5) va fikrlashni 0.6-bob o'rgandik — ya'ni butun nazariy poydevor tayyor. So'nggi tayyorgarlik qadami: kod yozadigan muhitni (VS Code, Node.js, npm) o'rnatish va sozlash. Shundan so'ng — 0-QISM tugaydi va biz haqiqiy kod yozishga (1-QISM: HTML/CSS) o'tamiz!

Eslatma

Bu bob — universal kompyuter fani (computer science) tushunchalariga asoslangan (algoritm, computational thinking, strukturaviy dasturlash teoremasi). Bular biror til yoki framework hujjatiga emas, balki dasturlashning fundamental nazariyasiga tegishli.