#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

sub is_prime {
    my $i = shift;
    die if $i < 2;
    
    return 2 if $i == 2;    
    $i % $_ == 0 and return for 2..(($i/2)+1);
    return $i;
}

my $number  = shift @ARGV || 129;
print Dumper [grep is_prime($_), 2..$number];

        for my $teiler (2..(($i/2)+1)) {
                return 0 if $i % $teiler == 0;   # Abbrechen wenn kein Rest bleibt
        }

#!/usr/bin/perl
use strict;
use warnings;

my ($Zahl, $is_prime, $p);
my @prime = ("2");
print "Bis zu welcher Zahl sollen die Primzahlen gesucht werden?";
chomp(my $Ziel = <STDIN>);

foreach $Zahl (3..$Ziel) {

    ### $is_prime ist ein Anzeiger, ob $Zahl eine Primzahl ist;
    ### wir gehen erstmal davon aus, dass sie eine ist (1 bedeutet hier WAHR)
    $is_prime = 1;

    #Wofür ist $p was macht sie und brauche ich das for noch?
    ### $p ist die Laufvariable innerhalb der Schleife;
    ### das foreach macht klar, dass Du hier in einer Schleife jedes Element aus @prime
    ### durchforsten willst; dafuer wird jedes Element einmal in $p abgelegt, damit du
    ### damit arbeiten kannst;
    foreach $p (@prime) {

        ### also pruefen, ob die aktuelle $Zahl durch eine der zuvor gefundenen Primzahlen
        ### teilbar ist; d.h. wenn kein Rest bei der Division uebrig bleibt
        if ($Zahl % $p == 0){

            ### $Zahl ist durch $p teilbar und kann also keine Primzahl sein
            ### deswegen setzen wir $is_prime auf 0 (0 bedeutet UNWAHR)
            $is_prime = 0;

            ### Bevor du sicher bist, dass $Zahl eine Primzahl ist, gibst Du hier die $Zahl
            ### schon aus und packst sie zu den Primzahlen? 
            ### Das kann nicht richtig sein; denn wie eben gerade festgestellt, kommen
            ### wir nur hier hin, weil $Zahl durch $p teilbar ist; damit ist es *keine*
            ### Primzahl... als raus damit...
            #weg: print $Zahl, "\n";
            #weg: push @prime, $Zahl;
            
            #Was macht das last?
            ### Weil wir ein $p gefunden haben, durch das $Zahl teilbar ist, brauchen wir
            ### kein weiteres $p pruefen; $Zahl ist keine Primzahl;
            ### also brechen wir mit 'last' die (innere) Schleife ab
            last;
        }

    } ### Ende innerer Schleife

    ### $Zahl kann nur dann eine Primzahl sein, wenn sie durch keine in @prime enthaltene
    ### Zahl teilbar ist; damit Du sicher sein kannst, dass $Zahl eine Primzahl ist, musst
    ### Du nun $is_prime pruefen, um $Zahl zu den Primzahlen in @prime packen zu koennen.
    ### Welchen Wert musst $is_prime dafuer haben?
}

$Zahl = 3; @p = (2);
3 % 2 = Rest 1, also wird 3 an @p gepackt; ### das ist OK

$Zahl = 4; @p = ( 2, 3 );
4 % 2 = Rest 0; also nächste Zahl aus @p testen
4 % 3 = Rest 1, also wird 4 an @p gepackt ### das ist nicht mehr OK

Wir müssen dabei bedenken, dass $Zahl jetzt 4 enthaelt, und wir diese 4 an @p anhaengen ...

return scalar  grep { $i % $_ == 0 } (2 .. sqrt($i)); 
# 0 wenn es keinen restfreien Teiler gibt

 for ( 2 .. sqrt($i) )  { return $_  unless $i % $_ }  

 for ( 2 .. sqrt($i) )  { return $_  if $i % $_  == 0}