[C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

[nay]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Es gibt keinen Fehler alles was du machen musst ist eine Taylorreihe mit 10 Summanden. Die Genauigkeit in den Beispielen stimmt nicht überein.

btw du hast 11 Summanden aber das Ergebnis ist ist nicht falsch sondern sogar genauer als das erwartete Ergebnis.

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Hast du das mal mit der "vereinfachten" TR versucht, die ich vorgeschlagen habe? Ich hatte mal ein Programm geschrieben, das auch 50% Abweichung bei den Berechnungen hatte, nur weil ich "falsch" addiert hatte (sehr kleine auf sehr große Werte gibt nur große Wert -> Müll). Eventuell kannst du mit der vereinfachten Berechnung schon dein Problem lösen

Sorry, aber deinen Lösungsweg kann ich leider gar nicht nachvollziehen. Fehlen dir nicht die ganzen Hochzahlberechnungen? Ich finde da meinen Weg (obgleich länger) verständlicher, aber ist sicher Ansichtssache.

Es gibt keinen Fehler alles was du machen musst ist eine Taylorreihe mit 10 Summanden. Die Genauigkeit in den Beispielen stimmt nicht überein.

btw du hast 11 Summanden aber das Ergebnis ist ist nicht falsch sondern sogar genauer als das erwartete Ergebnis.

Oha!

Auf das hätte ich echt selber kommen können, dass ich einfach nur über's Ziel hinausgeschossen bin ... und dabei suche ich schon seit 3 Tagen den "Fehler".

Ich habe jetzt die Funktion exp_genaehert mal entsprechend geändert (10 Summanden):

double exp_genaehert(int start, int end) {
    int j=0, hoch=0;
    double genaehert=1.0+start, i=0.0;

    for (hoch=2, j=2; hoch<end, j<end; hoch++, j++) {  
        i=fakultaet(j); 
        genaehert += ((1/i)*(hochzahl(start, hoch)));
    }

    return genaehert;
}

Ich weiß, dass es 100 %ig identisch geht und das will ich noch hinkriegen. Trotzdem schon mal danke für's Augenöffnen!

[Edit]
Mit 10 Summanden bin ich wieder weiter weg vom "Zielergebnis", dabei sollte es gerade mit 10 hinkommen?! 10 = end.

 

[bingo88]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Ein Beispiel:

e^x mit x = 4, n = 4

Klassisch: 1 + 4 + 4^2/2! + 4^3/3! + 4^4/4! = 103/3

Vereinfacht: 1 + 4 * (1 + 4/2 * (1 + 4/3 * (1 + 4/4))) = 103/3

Für den "richtigen" Wert von e^4 fehlen aber noch ein paar Iterationen

 

[nay]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Du musst für e^6, e^8 und e^10 die Anzahl der Summanden anpassen und gleichzeitig einige Datentypen ändern.
int kann so große Zahlen wie 10^30 z.B. nicht halten.

Eigentlich macht man die Taylorreihe so lang bis sich die an der gewünschten Genaugkeit nichts mehr geändert hat.

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Du musst für e^6, e^8 und e^10 die Anzahl der Summanden anpassen und gleichzeitig einige Datentypen ändern.
int kann so große Zahlen wie 10^30 z.B. nicht halten.

Das größte, was ich erreiche, wäre 10^10 (= 10000000000). Wenn ich allerdings den Funktionstyp jener Funktion, die die Hochzahlen berechnet, von int auf long ändere, ändert sich im Gesamtergebnis gar nichts. Ändere ich den Funktionstyp auf double, bekomme ich zwar andere Werte im Gesamtergebnis, die auch noch näher am gewünschten Ergebnis liegen, aber ich will nicht double verwenden, wenn es gar nicht um Kommazahlen geht ...

Wieso zeigt long hier keine Wirkung?

long:

long hochzahl(int a, int b) {
    long i=1, j=a;
    
    for (i; i<b; i++) {
        j*=a;
    }
    
    return j;
}

double:

double hochzahl(int a, int b) {
    double i=1.0, j=a;
    
    for (i; i<b; i++) {
        j*=a;
    }
    
    return j;
}

 

[bingo88]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

ein long ist hier ein int, das stammt noch aus alten Zeiten
Versuche es mal mit long long, der sollte 64 bit groß sein.

Hier mal mein Code zu der vereinfachten Variante. Bei e^x mit x=10 und 40 iterationen liefert der mir 22026.465795.

double my_exp(double x, int n)
{
    double res = 1.0;
    double sub = 1.0;
    int i;

    for (i = 1; i < n; ++i)
    {
        sub *= x/i;
        res += sub;
    }

    return res;
}

 

[nay]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Ja die Potenzfunktion sollte eigentlich double zurückgeben, ist bei mir auch performanter als die Funktion in Post #26 mit int Typen.

Die Fakultät Funktion sollte ein unsigned int64 (oder wenigstens ein unsigned int) zurückgeben. Eine Möglichkeit das zu machen ist

typedef unsigned long long uint64;
printf("sizeof(uint64) returns %d Byte\n\n", sizeof(uint64)); // zum Testen

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

long long als Funktionstyp bei der Potenzfunktion liefert das selbe, wie double. Scheint sich vom Wertebereich her also beides auszugehen. Wenn aber nay meint, dass double perfomanter sei, dann glaube ich das jetzt einfach mal und lasse es so.

BTW: Wieso unsigned int bei der Fakultätsfunktion? Das ändert genau gar nichts am Ergebnis?!

 

[JimSim]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Naja, bei der Fakultätsfunktion haste eh nur positive Werte. (Negative Fakultät ist nicht definiert) Dann kann man sich auch den negativen Wertebereich der Variablen auch sparen und den positiven effektiv verdoppeln in dem man sie als unsigned definiert...

 

[nay]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Naja ich hab es einfach ganz oft durchlaufen lassen und double war schneller als int. Außerdem gibt es auch Sachen wie e^1.5 oder so.

Fakultäten gibt es nur für positive Integers also würde ich einfach unsigned nehmen, weil du sonst den Fehler abfangen müsstest. (in dem Fall egal, aber warum nicht gleich robusten Code schreiben?)

Edit: Eine Sache habe ich nicht verstanden: Warum soll deine selbst geschriebene Funktion ungenauer sein als die exp Funktion? Wenn dann ist es anders herum. Kannst du vielleicht sagen was die Aufgabe war? Würde mich interessieren.

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Außerdem gibt es auch Sachen wie e^1.5 oder so.

Ja, aber nicht in meinem konkreten Beispiel. Sonst wäre ich eh selber auf float oder double gekommen.

Fakultäten gibt es nur für positive Integers also würde ich einfach unsigned nehmen, weil du sonst den Fehler abfangen müsstest. (in dem Fall egal, aber warum nicht gleich robusten Code schreiben?)

Ok, hast recht.

Edit: Eine Sache habe ich nicht verstanden: Warum soll deine selbst geschriebene Funktion ungenauer sein als die exp Funktion? Wenn dann ist es anders herum. Kannst du vielleicht sagen was die Aufgabe war? Würde mich interessieren.

Laut Angabe nähert die selbstgeschriebene Funktion auf Basis der Taylor-Reihe sich dem exakten Ergebnis nur an, während exp() der math.h angeblich den exakten Wert bestimmt?! Ich bin davon ausgegangen, dass das stimmt?! ...

Die Aufgabe habe ich schon im ersten Posting zu diesem Beispiel kurz beschrieben, aber hier noch einmal komplett:

Und hier meine derzeitige Lösung:

#include <stdio.h>
#include <math.h>

unsigned int fakultaet(int x) {
    if (x == 0)
        return 1;
    else
        return (x * fakultaet(x-1));
}

double hochzahl(int a, int b) {
    double i=1.0, j=a;
    
    for (i; i<b; i++) {
        j*=a;
    }
    
    return j;
}

double exp_exakt(int start) {
    double exakt=0.0;

    exakt=exp(start);

    return exakt;
}

double exp_genaehert(int start, int end) {
    int j=0, hoch=0;
    double genaehert=1.0+start, i=0.0;

    for (hoch=2, j=2; hoch<=end, j<=end; hoch++, j++) {  
        i=fakultaet(j); 
        genaehert += ((1/i)*(hochzahl(start, hoch)));
    }

    return genaehert;
}

int main(void) {
    int start=0, end=10, inc=2;
    double err_bound=0.0010000000;

    printf("Naeherungsweise Berechnung von exp(x)\n\n");
    printf("Startpunkt: %d\n", start);
    printf("Endpunkt: %d\n", end);
    printf("Schrittweite: %d\n", inc);
    printf("Fehlerschranke: %.10lf\n\n", err_bound);
    printf(" x : exp(x) genaehert : exp(x) exakt     : Fehler\n");
    printf("============================================================\n");
    for (start; start<=end; start+=inc) {
        printf("%2d : %16.10lf : %16.10lf : %.10e\n", start, exp_genaehert(start, end), exp_exakt(start), (exp_exakt(start)-exp_genaehert(start, end)));
    }
    putchar('\n');

    return 0;
}

Was ich eben nicht verstehe: Ich weiß, dass es bei der Taylor-Reihe, also exp(x) genaehert in der Ausgabe, mit maximal x^10 möglich ist, das exakt selbe Ergebnis zu erhalten, wie in der Angabe, aber ich komme einfach nicht hin.

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

^^ Wem die Taylor-Reihe schon zu langweilig geworden ist, der darf mir bitte gerne verraten, warum mein Sieb des Eratosthenes alle Zahlen als Primzahlen erkennt und nicht nur die, die es wirklich sind ... *ganz lieb schau*

#include <stdio.h>

/* Sieb des Eratosthenes */
int is_prime(unsigned int num) {
    int i=2, j=0, k=0;

    if (num==2) { /* 2 ist die kleinste Primzahl */
        return 1;
    } else if (num==1) { /* 1 soll nicht als Primzahl gewertet werden */
        return 0;
    }

    for (i; i<=10000; i++) { /* alle Zahlen von 2 bis 10000 werden überprüft */
        for (j=i; j<=10000; j+=i) { /* alle Vielfachen des Startwertes der jeweiligen Runde werden ermittelt ... */
            k=j; /* ... und in k gespeichert */
            if (num!=k) { /* Alle Werte, die noch nie in k gespeichert wurden, sind Primzahlen */
                return 1;
            }
        }
    }

    return 0;
}

int main(void) {
    unsigned int num, i=1, j=0;

    printf("Please enter any number to check whether it's a prime: ");
    scanf("%d", &num);
    if (is_prime(num)==1) {
        printf("%d is a prime!\n", num);
    } else {
        printf("Sorry, no prime.\n");
    }
    putchar('\n');

    while (i<=1000) { /* Ausgabe der ersten 1000 Primzahlen */
        if (is_prime(j)==1) {
            printf("%d", j);
            printf(", ", i < 1000 ? ", " : "");
            j++;
            i++;
        } else {
            j++;
        }
    }
    putchar('\n');
    
    return 0;
}

Danke im Voraus!

 

[nay]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Eigentlich ist long long oder int64 (oder wie man es auch immer nennen will) zu klein für dein Programm.
Um auf den Wert von e^10 zu kommen (22026.4652523840) braucht man 32 Summanden in der Taylorreihe also hat man Zahlen wie 32! und 10^32 (zu groß!).

Deswegen würde ich fakultaet so definieren (ist zwar unschön aber effektiv)

double fakultaet(double x)

Du machst immer eine Taylorreihe mit 10 Summanden, das ist zu ungenau für große Exponenten wie du siehst. Die Beispielausgabe wurde auf eine andere Art erstellt, etwa so:

double exp_genaehert(int n, double exact, double prec)
{
    if (prec <= 0 || exact <= 0) return -1;

    double x = 1 + n;
    unsigned int i = 2;

    /* invariant: i ist die Anzahl der Summanden der Taylorreihe */
    do
    {
        x += hochzahl(n, i) / fakultaet(i);
        i = i + 1;
    }
    while ((exact - x) >= prec);

    /* Info */
    /*printf("%2d Summanden ", i);*/

    return x;
}

Hier ist dein Code, den ich ein wenig abgewandelt habe:

#include <stdio.h>
#include <math.h>

#define exp_exakt(val) exp(val) /* Platzhalter */

double fakultaet(double x) { /* Fakultät rekursiv */
    if (x == 0)
        return 1;
    else
        return (x * fakultaet(x-1));
}

double hochzahl(double a, int b) { /* Berechnung der Hochzahl; eingesetzt werden die Werte 'start' und 'hoch' aus Funktion exp_genaehert; start steht für x in der Taylorreihe */
    double i=1, j=a;

    if (b == 0) {
        return 1;
    } else {
        for (i; i<b; i++) {
            j*=a;
        }
    }

    return j;
}

double exp_genaehert(int n, double exact, double prec)
{
    if (prec <= 0 || exact <= 0) return -1;

    double x = 1 + n;
    unsigned int i = 2;

    /* invariant: i ist die Anzahl der Summanden der Taylorreihe */
    do
    {
        x += hochzahl(n, i) / fakultaet(i);
        i = i + 1;
    }
    while ((exact - x) >= prec);

    /* Info */
    /*printf("%2d Summanden ", i);*/

    return x;
}

int main(void) {

    int i=0, end=10, inc=2;
    const double prec = 1.0e-3;
    double exact, approx, errmargin;

    printf("Naeherungsweise Berechnung von exp(x)\n\n");
    printf("Startpunkt: %d\n", i);
    printf("Endpunkt: %d\n", end);
    printf("Schrittweite: %d\n", inc);
    printf("Fehlerschranke: %.10lf\n\n", prec);
    printf(" x : exp(x) genaehert : exp(x) exakt     : Fehler\n");
    printf("============================================================\n");

    for (i; i <= 10; i=i+inc) {
        exact = exp_exakt(i);
        approx = exp_genaehert(i, exact, prec);
        errmargin = exact - approx;

        printf("%2d : %16.10lf : %16.10lf : %.10e\n", i, approx, exact, errmargin);
    }

    return 0;
}

Deine Siebfunktion ist sehr komisch, du machst nicht das was in den Kommentaren steht. Fang am besten mal von vorne an und verwende dabei eine Datenstruktur (ein array wäre schon mal gut) und programmiere nah am Beispiel.

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Um auf den Wert von e^10 zu kommen (22026.4652523840) braucht man 32 Summanden in der Taylorreihe also hat man Zahlen wie 32! und 10^32 (zu groß!).

Deswegen würde ich fakultaet so definieren (ist zwar unschön aber effektiv)

double fakultaet(double x)

Du machst immer eine Taylorreihe mit 10 Summanden, das ist zu ungenau für große Exponenten wie du siehst.

Ich merke gerade, dass ich bei dem Beispiel einen wesentlich Punkt übersehen haben! Ich habe zwar brav die Fehlerschranke (err_bound) definiert, aber nie verwendet! OMG!

Die Berechnung der Taylor-Reihe soll so lange laufen, bis der Wert von genaehert kleiner als die Fehlerschranke werden würde ...

Habe den Code jetzt noch einmal entsprechend umgeschrieben (siehe do-while Schleife in Funktion genaehert()):

#include <stdio.h>
#include <math.h>

unsigned int fakultaet(int x) {
    if (x == 0)
        return 1;
    else
        return (x * fakultaet(x-1));
}

double hochzahl(int a, int b) {
    double i=1.0, j=a;
    
    for (i; i<b; i++) {
        j*=a;
    }
    
    return j;
}

double exp_exakt(int start) {
    double exakt=0.0;

    exakt=exp(start);

    return exakt;
}

[COLOR=royalblue]double exp_genaehert(int start, int end, double err_bound, double res) {
    int j=2, hoch=2;
    double genaehert=1.0+start, i=0.0;

    [B]do {  
        i=fakultaet(j); 
        genaehert += ((1/i)*(hochzahl(start, hoch)));
        hoch++;
        j++;
    } while ((res-genaehert)>err_bound);[/B]

    return genaehert;
}
int main(void) {
    int start=0, end=10, inc=2;
    double err_bound=0.0010000000, [COLOR=royalblue]res=0.0;

    printf("Naeherungsweise Berechnung von exp(x)\n\n");
    printf("Startpunkt: %d\n", start);
    printf("Endpunkt: %d\n", end);
    printf("Schrittweite: %d\n", inc);
    printf("Fehlerschranke: %.10lf\n\n", err_bound);
    printf(" x : exp(x) genaehert : exp(x) exakt     : Fehler\n");
    printf("============================================================\n");
    for (start; start<=end; start+=inc) {
        [COLOR=royalblue]res=(exp_exakt(start));        printf("%2d : %16.10lf : %16.10lf : %.10e\n", start, exp_genaehert(start, end, err_bound, [COLOR=royalblue]res), exp_exakt(start), (exp_exakt(start)-exp_genaehert(start, end, err_bound, [COLOR=royalblue]res)));
    }
    putchar('\n');

    return 0;
}

Meinen großen Denkfehler hätten wir damit endlich gefunden. Nur leider bin ich jetzt minimal über dem erwarteten Ergebnis (Why?) ...
-------------

Deine Siebfunktion ist sehr komisch, du machst nicht das was in den Kommentaren steht. Fang am besten mal von vorne an und verwende dabei eine Datenstruktur (ein array wäre schon mal gut) und programmiere nah am Beispiel.

Öhm, glaub' mir, ich hätte das ganze sofort mit einem array gelöst, wenn ich denn dürfte!

Zu dem Zeitpunkt, als wir auf der FH dieses Bsp. mit den Primzahlen bekommen haben, "kannten" wir offiziell noch keine arrays und durften die daher auch nicht verwenden. Deswegen würde ich das auch jetzt gerne ohne lösen, so wie's eben von der Angabe verlangt wird.

BTW: Dass das Programm einfach alle Zahlen bis 1000 ausgibt, ist mir schon aufgefallen (ich teste immer!). Die Frage ist: Wie ändern?

PS: Wikipedia war meine Vorlage. Deswegen verstehe ich nicht, was ich so anders mache, als ich mir das mit den Kommentaren gedacht habe.

 

[JimSim]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Was dein Sieb betrifft...

int is_prime(unsigned int num) {
    int i=2, j=0, k=0;

    if (num==2) { /* 2 ist die kleinste Primzahl */
        return 1;
    } else if (num==1) { /* 1 soll nicht als Primzahl gewertet werden */
        return 0;
    }

    for (i; i<=10000; i++) { /* alle Zahlen von 2 bis 10000 werden überprüft */
        for (j=i; j<=10000; j+=i) { /* alle Vielfachen des Startwertes der jeweiligen Runde werden ermittelt ... */
            k=j; /* ... und in k gespeichert */
            if (num==k) { /* Ist der Wert gleich der Vielfachen eines anderen Wertes, ist sie keine Primzahl */
                return 0;
            }
        }
    }

    return 1;
}

So sollte es was werden... Wenn die gegebene Zahl = einem Vielfachen einer Zahl ist, ist sie keine Primzahl. Durchläuft dagegen die Primzahl die ganze Schleife, ohne das ein Vielfaches mit der gegebenen Zahl übereinstimmt, ist sie (wahrscheinlich) eine Primzahl

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

^^ Hast du das mal ausprobiert?! Da kommen nur unsinnige Werte raus, die fast alle noch dazu größer als 10000 sind ...

 

[JimSim]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

int is_prime(unsigned int num) {
    int i=2, j=0, k=0;

    if (num==2) { /* 2 ist die kleinste Primzahl */
        return 1;
    } else if (num==1) { /* 1 soll nicht als Primzahl gewertet werden */
        return 0;
    }

    for (i; i<=10000; i++) { /* alle Zahlen von 2 bis 10000 werden überprüft */
        for (j=i; j<=10000; j+=i) { /* alle Vielfachen des Startwertes der jeweiligen Runde werden ermittelt ... */
            if(j!=i) {
                     k=j; /* ... und in k gespeichert */
                     if (num==k) { /* Ist der Wert gleich der Vielfachen eines anderen Wertes, ist sie keine Primzahl */
                             return 0;
                     }
            }
        }
    }

    return 1;
}

Mist, wenn man natürlich jede Zahl mit jeder vergleicht kann das nichts werden... so ists was. Jetzt musst du natürlich noch ne Abfrage machen, damit er keine höheren Zahlen als 10000 prüft.

 

[boss3D]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

^^ Vielen Dank, jetzt funktioniert es wirklich!

Zwei Sachen wären bei dem Beispiel noch zu klären:
1. Kannst du bitte meine Kommentare checken, nur damit ich sicher sein kann, dass ich den Effekt von (if (j!=i)) richtig verstanden habe?!
2. Warum wird auch nach der 1000sten Primzahl noch ein Beistrich ausgegeben, obwohl doch nach der 999sten (i<1000) Schluss damit sein sollte?

#include <stdio.h>

/* Sieb des Eratosthenes */
int is_prime(unsigned int num) {
    int i=2, j=0, k=0;

    if (num==2) { /* 2 ist die kleinste Primzahl */
        return 1;
    } else if (num==1) { /* 1 soll nicht als Primzahl gewertet werden */
        return 0;
    }

    for (i; i<=10000; i++) { /* alle Zahlen von 2 bis 10000 werden überprüft */
        for (j=i; j<=10000; j+=i) { /* alle Vielfachen des Startwertes der jeweiligen Runde werden ermittelt */
            [COLOR=royalblue]if (j!=i) { /* Immer wenn j ungleich i ist, handelt es sich um ein Vielfaches von j */                 k=j; /* Die Vielfachen werden in k gespeichert */
                if (num==k) { /* Alle Werte, die in k gespeichert wurden, sind keine Primzahlen */
                    return 0;
                }
            }
        }
    }

    return 1;
}

int main(void) {
    unsigned int num, i=1, j=2;

    printf("Please enter any number to check whether it's a prime: ");
    scanf("%d", &num);
    if (is_prime(num)==1) {
        printf("%d is a prime!\n", num);
    } else {
        printf("Sorry, no prime.\n");
    }
    putchar('\n');

    while (i<=1000) { /* Ausgabe der ersten 1000 Primzahlen */
        if (is_prime(j)==1) {
            printf("%d", j);
            [COLOR=royalblue]printf(", ", i < 1000 ? ", " : "");            j++;
            i++;
        } else {
            j++;
        }
    }
    putchar('\n');
    
    return 0;
}

 

[nay]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Du kannst die äußere Schleife schon bei sqrt(num) beenden.

Beispiel:

num = 100

Wenn irgendeine Zahl kleiner num (z.B. 22) durch eine Primzahl größer der Quadratwurzel von num (z.B. 11) teilbar ist, dann ist die Zahl (22) auch ein Vielfaches einer Zahl kleiner der Quadratwurzel von num.
Also wurde die 22 schon vorher durch eine andere Primzahl abgedeckt. Deswegen ist die Betrachtung der Vielfachen von 11 überflüssig.

22 => 2
33 => 3
...
99 => 3

Hier wäre mein Code:

int is_prime_sieve(unsigned int num)
{
    if (num < 2) return 0;

    int tBorder = (int)(sqrt(num));

    int i=2, j;

    for (i; i <= tBorder; i=i+1)
    {
        for (j=i+i; j <= num; j=j+i) /* beginnend mit dem Vielfachen von i !! */
        {
            if (num == j) return 0;
        }
    }

    return 1;
}

 

[Freddycbv]

AW: [C] Hochzahlen ohne math.h und pow berechnen ...

Du kannst die äußere Schleife schon bei sqrt(num) beenden.

Hier wäre mein Code:

int is_prime_sieve(unsigned int num)
{
    if (num < 2) return 0;

    int tBorder = (int)(sqrt(num));

    int i=2, j;

    for (i; i <= tBorder; i=i+1)
    {
        for (j=i+i; j <= num; j=j+i) /* beginnend mit dem Vielfachen von i !! */
        {
            if (num == j) return 0;
        }
    }

    return 1;
}

Ist die innerste for-Schleife nicht genau das selbe wie if(!num%i) return 0; ?
Meine Lösung für Primzahlen sah bisher nämlich immer so aus:

bool isPrime(int Zahl)
{
    if(Zahl < 2) return false;
    for(int i=2; i< Zahl/2 +1; i++)
    {
        if(!Zahl % i)
            return false;
    }
    return true;
}

Aber das mit der Quadratwurzel ist interressant. Das wusste ich noch nicht...