Eratosfen algoritmiga asosan 120 gacha boʻlgan tub sonlarni topish animatsiyasi
**Eratosfen elagi** (Eratosfen gʻalviri) — butun son *{\displaystyle n}*gacha boʻlgan barcha tub sonlarni topish algoritmi boʻlib, qadimiy grek matematigi Eratosfen Kireniyga bagʻishlab nomlangan. Eratosfen elagi algoritmi kichik (odatda, 10 milliondan kichik boʻlgan) tub sonlar topishning eng tez uslub hisoblanadi.

Algoritm
--------

Butun son *n* gacha boʻlgan barcha tub sonlarni topish Eratosfen uslubiga asosan quyidagi bosqichlardan iborat.

1. Ikkidan boshlab *n* gacha boʻlgan barcha sonlarni yozib chiqamiz (2, 3, 4, …, *n*).
2. Oʻzgaruvchi *p* boshida 2 — birinchi butun songa teng deb qabul qilamiz.
3. Yozib chiqilgan sonlardan *p* dan boshlab *p* qadam bilan *n* gacha barcha sonlarni oʻchiramiz, (yaʼni  2*p*,  3*p*, 4*p*, … kabi sonlar).
4. *p*da katta birinchi oʻchilirilmagan sonni *p* deb yangidan qabul qilamiz.
5. 3- va 4-qadamni  *p*2 qiymati *n*dan katta yoki teng boʻlguncha takrorlaymiz.

Natijada roʻyxatdagi oʻchirilmagan sonlarning barchasi tub son boʻladi.

Amaliyotda, ushbu algoritmni quyidagicha yaxshilash (tezlashtirish) mumkin. Algoritmdagi 3-qadamda sonlarni  *p*2 dan boshlab oʻchirish yetarli, chunki bundan kichik sonlar avval oʻchirilgan boʻladi. Va, algoritm  *p*2 qiymati *n*ga teng yoki katta boʻlganda toʻxtatiladi.

Misol
-----

Quyidga *n*=30 uchun Eratosfen algoritmni qoʻllab tub sonlarni topamiz. Buning uchun, 2dan 30gacha boʻlgan barcha butun sonlarni tartib boʻyicha yozib chiqamiz:

```
 2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
```

Roʻyxatdagi birinchi son 2 — butun son.
Roʻyxatdan birma-bir 2ning koʻpaytmalarini oʻchirib chiqamiz, yaʼni 2 2 = 4 dan boshlab :

```
 2  3  ~~4~~  5  ~~6~~  7  ~~8~~  9  ~~10~~ 11 ~~12~~ 13 ~~14~~ 15 ~~16~~ 17 ~~18~~ 19 ~~20~~ 21 ~~22~~ 23 ~~24~~ 25 ~~26~~ 27 ~~28~~ 29 ~~30~~
```

Keyingi oʻchirilmagan son 3 — butun son.
Roʻyxatdan endi 3ning koʻpaytmalarini oʻchirib chiqamiz, yaʼni 3 2=9 dan boshlab :

```
 2  3  ~~4~~  5  ~~6~~  7  ~~8~~  ~~9~~  ~~10~~ 11 ~~12~~ 13 ~~14~~ ~~15~~ ~~16~~ 17 ~~18~~ 19 ~~20~~ ~~21~~ ~~22~~ 23 ~~24~~ 25 ~~26~~ ~~27~~ ~~28~~ 29 ~~30~~
```

Keyingi oʻchirilmagan son 5 — butun son.
Roʻyxatdan endi 5 ning koʻpaytmalarini oʻchirib chiqamiz, yaʼni 52=25 dan boshlab :

```
 2  3  ~~4~~  5  ~~6~~  7  ~~8~~  ~~9~~  ~~10~~ 11 ~~12~~ 13 ~~14~~ ~~15~~ ~~16~~ 17 ~~18~~ 19 ~~20~~ ~~21~~ ~~22~~ 23 ~~24~~ ~~25~~ ~~26~~ ~~27~~ ~~28~~ 29 ~~30~~
```

Algoritmga asosan *p*ning koʻpaytmalarini *p*2 >= *n* shart bajarilguncha oʻchirib chiqish zarur.
 misol uchun, 5ning koʻpaytmalari oʻchirilib chiqildi va 62 > 30 shart bajarildi. Demak, oʻchirilmagan sonlarning barchasi butun son:

```
 2  3     5     7           11    13          17    19          23                29   
```

C tilidagi dastur
-----------------

```
 /\*
 \* Eratosfen Elagi
 \* soe\_algo.c
 \*/
#include <stdio.h>
#include <stdbool.h>
#include <math.h>

int main (int argc,char \*argv[])
{

 if (argc<2) {
 printf("Ushbu dastur biror butun songacha bo'lgan tub sonlarni ko'rsatadi \n
 Foydalanish: %s <butun son> \n ", argv[0]);
 return -1;
 }

 int m, k, upper\_bound = atoi(argv[1]);

 int upper\_bound\_sqrt = (int) sqrt(upper\_bound);

 bool is\_composite[upper\_bound + 1];

 for (m = 2; m <= upper\_bound\_sqrt; m++) {
 if (!is\_composite[m]) {
 printf("%d ", m);
 for (k = m \* m; k <= upper\_bound; k += m)
 is\_composite[k] = true;
 } // if
 }//for

 for (m = upper\_bound\_sqrt + 1; m <= upper\_bound; m++)
 if (!is\_composite[m])
 printf("%d ", m);

 printf("\n");

 return 0;
} // end

```

Havolalar
---------

* *Eratosfen elagi* Encyclopaedia of Mathematics saytida (ingl.)