1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

procedure TForm1.Button1Click(Sender: TObject);
var a,b,c,d,g:integer;
    f:string;
begin

  a:=strtoint(edit1.text);
  d:=0;
  For c:=2 to a do 
  begin
    For b:=2 to (c-1) do  
    begin
      if (c mod b)=0 THEN
        d:=1
    end;
    if d = 0 THEN
      f:=f+ inttostr(c)+ chr(13);
    g:= g+1;
  end;
  d:=0;
  if (g=a) THEN
    Label1.caption:=f;
end;

end.                    

1:
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:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:

static void Main(string[] args)
        {
            Console.WriteLine("Geben sie eine Zahl ein die die höchste Primzahl sein kann");

            int a;
            int b;
            int c;
            double d;
            int Zähler;

            Zähler=0;
            d = 0;
            
            List<int> arr1 = new List<int>();
            arr1.Add(2);
            // in dieser Liste stehen alle Primzahlen ausßer 1


            //In diesem Stückchen wird einfach nur die höchstmögliche Zahl festgelegt und verhindert das das Programm durch eine falsche eingabe abstürzt
            try
            {
                 a = int.Parse(Console.ReadLine());
            }
            catch (FormatException)
            {
                Console.WriteLine("Bitte geben sie eine positive Zahl ein");
                a = int.Parse(Console.ReadLine());
            }

            //Ende der bestimmung von a


            // hier beginnt der Spannende Teil!
            
            for ( b=3;b<=a; b=b+2)
                //also die For-Schleife: b beginnt bei drei und soll bei a enden (b steht für alle potenziellen Primzahlen)
            {
                
                while ((arr1.Count!=Zähler))
                    //Die Schleife soll solange durchgeführt werden bis die Anzahl der Primzahlen in der Liste gleich der Anzahl an schon, für das durchdividiern, verwendeten Primzahlen
                {
                    c = arr1[Zähler];
                    // c wird die Zahl, die auf Position "Zähler" in der Liste arr1 steht!
                    //am Anfang ist Zähler noch null und c hat dadurch den Wert 2 weil an Position 0 von arr1 "2" steht.
                    d= (double)(b) / (c);
                    //Jezt wird dividiert.
                    Zähler = Zähler + 1;
                    //Zähler wächst damit beim nächsten mal Schleife durchlaufen die nächste Zahl aus der Liste ausgewählt wird!

                    if (d-Convert.ToInt32(d)==0)
                        // das ist eine Abfrage ob d eine integere Zahl ist, in dem man d weniger dem Integer-Anteil von d rechnet. kommt 0 heraus=>INTEGER!! kommt etwas anderes heraus=>kein Integer
                    {
                        Zähler = arr1.Count;
                        //wenn d eine integere Zahl ist steht fest das b keine Primzahl sein kann. Darum stellt man das Ergebnis der Bedingung der Schleife auf "False" damit her hinausspringt
                    }

                    else if(Zähler==arr1.Count)
                        //für den Fall das alle vorhergegangenen Primzahlen durchgelaufen sind ohne das eine integere Zahl erhalten wurde... d.h. Das Zähler gleich der Anzahl an Primzahlen in Liste arr1 ist springt das Programm hier herein
                    {
                        Console.WriteLine(b);
                        // b wird ausgegeben!
                        arr1.Add(b);
                        //b wird zur Liste arr1 hinzugefügt!
                    }


                }

                Zähler=0;
                //Zähler wird wieder auf Anfang gestellt um beim nächsten mal wieder alle Primzahlen aus arr1 auswählen zu können!
                
            }
            Console.ReadLine();
        }                    

1:
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:

procedure Eratosthenes(bis: Integer);
  var
  keinePrim: Array of Boolean;
  i, step, ende: Integer;
begin
  setlength(keinePrim, bis);
  ende := round(sqrt(high(keinePrim)));
  //"0" und "1" Streichen
  keinePrim[0] := True;
  keinePrim[1] := True;
  //Sämmtliche Vielfache streichen
  for i:=2 to ende do
  begin
    if (keinePrim[i]) then
      continue;
    step := i;
    while step+i <= high(keinePrim) do
    begin
      step := step+i;
      if (keinePrim[i]) then
        continue;
      keinePrim[step] := True;
    end;
  end;
end;
{wenn keinePrim[i] = False ist, dann ist i eine Primzahl}