Eratosthenovo síto

 program ErSito;
 const
   MaxN = 20;
 var
   Pole: array [2 .. MaxN] of boolean;
   i, j: integer;
 begin
   {inicializace: nejprve předpokládáme, že vše jsou prvočísla}
   for i := 2 to MaxN do 
     Pole[i] := true;
   i := 1;
   repeat
     i := i + 1;
     {najdeme prvni cislo, u kterého je true}
     while (i<MaxN) and (not Pole[i]) do i := i + 1;
     {optimalizace: nemá smysl hledat násobky nižších čísel označené dříve}
     j := i;
     {najdeme všechny násobky daného prvočísla, které tudíž nejsou prvočísla}
     while j*i<=MaxN do
        begin
          Pole[j*i] := false;
          j := j + 1;
        end;
   until i>=sqrt(MaxN); {optimalizace: stačí hledat pouze po odmocninu z MaxN}
   {výpis prvočísel}
   for i := 2 to MaxN do
     if Pole[i] then
       Writeln(i);
 end.

  int MaxN = 1024;        
  boolean[] Pole = new boolean[MaxN+1];
  int i,j;
  for (i=2;i<(MaxN+1);i++) { /* Inicializace pole (vse jsou prvocisla a postupne budem vyrazovat) */
    Pole[i] = true; 
  }
  i=2;
  while (i*i <= MaxN) { /* dokud mocnina prvniho cisla na seznamu je mensi nez nejvetsi */
    if (Pole[i]){       /* pokud je i stale na seznamu (nezkoumej nasobky 4, kdyz jsme uz vyhodili nasobky 2 */
      j=2;              /* j bude novy nasobek */
      while (i*j <= MaxN) {
        Pole[j*i] = false; /* cislo slozene */
        j++;
      }         
    } 
    i++;
  }

#include <iostream>
#include <set>
using namespace std;
 
int main()
{
 
   int max;
   cout << "Zadejte cislo do ktereho chcete vypsat prvocisla" << endl;
   cin >> max;
 
   set<int> sito, prvocisla;
   set<int>::iterator p;
   int dalsi, nasobek;
 
   for (int i = 2; i <= max; i++)
      sito.insert(i);
 
   dalsi = 2;
   while (!sito.empty())
   {
      while (sito.count(dalsi) == 0) dalsi++;
      prvocisla.insert(dalsi);
      nasobek = dalsi;
      while (nasobek <= max)
      {
         sito.erase(nasobek);
         nasobek += dalsi;
      }
   }
 
   for (p = prvocisla.begin(); p != prvocisla.end(); p++)
      cout << *p << ' ';
   cout << endl;
}

MaxN = 1024                                              #horni hranice seznamu cisel
SeznamN = range(2,MaxN+1)                                #vytvoreni seznamu cisel v rozpeti <2,1024>
Prvocisla = []                                           #vytvoreni (prozatim) prazdneho seznam prvocisel
while SeznamN[0]**2 <= SeznamN[-1]:                      #Dokud bude ctverec prvniho prvku SeznamuN mensi nebo roven poslednimu
                                                         #prvku SeznamuN, vykonej:
    Prvocisla.append(SeznamN[0])                         #    1)K seznamu Prvocisla pripoj prvni cislo ze SeznamuN
    Nasobky = range(SeznamN[0],SeznamN[-1]+1,SeznamN[0]) #    2)Vytvor seznam nasobku naposledy pripojeneho Prvocisla
    for k in Nasobky:                                    #    3)Pro kazde cislo "k" v seznamu Nasobky:
        if k in SeznamN:                                 #        1)Pouze pokud se k naleza v SeznamuN:
            SeznamN.remove(k)                            #            1)Odstran cislo/nasobek k ze SeznamuN;kod se opakuje od 4 radku
                                                         #Prvni cislo v seznamu je vetsi jak odmocnina z cisla posledniho a tedy
Prvocisla.extend(SeznamN)                                #zbyla cisla jsou prvocisla. Extend je podobne k append.
print Prvocisla                                          #Zobraz vysledek!

function erPrimes($max)
{
	$numbers = range(2,$max,1); //inicializuji si pole cisel od 2 do $max po jedne
	$primes = array(); // inicializace vystupniho pole
	while (list($key,$value) = each($numbers)) { // nactu si dalsi cislo z pole
		if ($value) { // zjistim jestli cislo uz neni vynulovane
			for ($i=1;($exp = $value*$i) < $max;$i++) { // vynuluju vsechny nasobky aktualniho cisla
				$numbers[$exp-2] = null; /* ///Opraveno/// U $exp musí být -2,
                                                         / protože bychom při testování trojky
                                                         / odebrali pětku - pole $numbers totiž vypadá takto:
                                                         / Array ( [0] => 2 [1] => 3 [2] => 4 [3] => 5 ... [97] => 99 [98] => 100 )
                                                         / Jak jste si mohli všimnout číslo 5 má index 3 a číslo 3 má index 1,
                                                         / a zde nastává problém, kdybychom neodečetli od indexu dvojku, tak namísto
                                                         / to, abychom vynulovali všechny násobky daného čísla, tak nulujeme nasobky
                                                         / daného čísla zvětšeného o 2. Příklad:
                                                         / Testujeme č. 3: Vynásobíme jedničkou, dostaneme trojku,
                                                         / ale podle původního kódu bychom vymazali pětku,
                                                         / protože proměnná $numbers s indexem 3 odkazuje na 5,
                                                         / a proto musíme kód ošetřit tak,
                                                         / aby index odkazoval na správné číslo, tzn. chceme vymazat trojku,
                                                         / takže chceme aby proměnná $numbers s indexem 3 vymazala trojku.
                                                         / Takže když na trojku odkazuje $numbers s indexem 1, tak musíme zařídit,
                                                         / aby se index 1 opravdu rovnal, a proto je tam ta -2.
                                                         / Číslo 3 je pouhý příklad, toto by nastalo u všech dalších čísel.
                                                        */
			}
			$primes[] = $value; // pridam si zjistene prvocislo do vystupu
		}
	}
	return $primes;
}