hilfe!! kein plan was das heißt! bitte helft mir!

[namous]

also zu erst das ist mein code in c:
++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++

#include <stdio.h>
#include <stdlib.h>


main(){

int vergl, zahl, prim[999], a, b;


printf ("sgji");
vergl=0;
zahl=0;
a=0,
b=0;


printf ("sgji");
while (a<1000){
prim[a]=0;
a++;
}

prim[0]=2;
prim[1]=3;

begin:
a=-1;
zahl++;
middl:
a++;
vergl=zahl%prim[a];

if (vergl==0){
goto begin;
}

else {
b=a+1;
if (prim[b]=0){
prim[b]=zahl;
printf ("*%i+",prim[b]);
}
goto middl;
}

}

++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++

beim kompilieren kommt kein fehler! aber beim ausführen kommt der fehler:

++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++

donset@linux:~> ./shit
Gleitkomma-Ausnahme

++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++

bitte um hilfe was das heißt und was man ändern sollte. danke

PS: ich nenne meine kleinen "programme" immer so :))

[tuxipuxi]

hi,

kann dir nicht wirklich helfen aber:
if(primp[b]=0)
macht keinen sinn... == ueberprueft die werte, = weist zu.
von goto solltest du die finger lassen,macht zuviele fehler.
lieber mit funktionen arbeiten. beispielsweise
"
int incr(int &a)
{
a++;
};
"
(is natuerlich uebertrieben ne eigene funktion aber besser als goto).

ciao lane

[anda_skoa]

Außerdem hast du im ersten while einen "index off by one" Fehler.
Der höchste zulässige Index im prim Array ist 998, nicht 999.

Außerdem ist das eine for Schleife besser geeignet:



for (a = 0; a < 999; ++a)
{
prim[a] = 0;
}


Ciao,
_

[Pingu]

Original geschrieben von namous
if (prim[b]=0){
prim[b]=zahl;
printf ("*%i+",prim[b]);
}


Ich glaube hier liegt ein kleiner Fehler. Denn durch das
if (prim[b] = 0)machst Du ja eine Zuweisung von 0. Sollte bestimmt aber mal ein Vergleich werden, also
if (prim[b] == 0)Ist ein beliebter Flüchtigkeitsfehler. Passiert mir ständig, deswegen achte ich beim durchgehen immer darauf.
Jedenfalls durch diese Zuweisung passiert beim nächsten Durchgang von
vergl=zahl%prim[a];
eine Zuweisung von
vergl = zahl % 0; // prim[a] = 0. MOD 0 ist nunmal das Gleiche wie DIV 0. Nicht definiert im natürlichen Zahlenbereichen. Ich glaube nicht das Dein Rechner ohne weiteres im imaginären Zahlenbereich rechnen kann ;o)

Gruß

-= Pingu =-

[namous]

zuerst mal danke für die tipps.


code:vergl = zahl % 0; // prim[a] = 0

aber prim[0] und prim [1] haben ja natürliche ganzzahlen 2 und 3 und wenn es zu prim [2] kommen würde wäre prim[2]=0 und damit auch vergl 0 zahl % 0, aber dazu kommt es ja nicht weil wenn er vergl = zahl % prim[1] rechnet check er ja ob die nächte prim also prim[2] null ist, wenn ja dann setzt er a wieder zurück. ich hoff ich hab es jetzt net alzu kompliziert erklärt oder??? vielleicht red ich auch nen stuß aber so seh ich des grad.

[namous]

das ist jetzt der code mit euren vorschlägen, nur um die übersicht zu behalten. und der fehler kommt nicht mehr. beim kompilieren kommt auch kein fehler aber wenn ichs ausführe dann läufts ohne meldungen undendlich. ich hab ja auch ein par printf's eingebaut aber die werden auch nicht angezeigt.



++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++

#include <stdio.h>
#include <stdlib.h>


main(){

int vergl, zahl, prim[998], a, b;


printf ("sgji");
vergl=0;
zahl=0;
a=0,
b=0;


printf ("sgji");



for (a = 1; a < 999; ++a)
{
prim[a] = 0;
}



prim[0]=2;
prim[1]=3;

begin:
a=-1;
zahl++;
middl:
a++;
vergl=zahl%prim[a];

if (vergl==0){
goto begin;
}

else {
b=a+1;
if (prim[b]==0){
prim[b]=zahl;
printf ("*%i+",prim[b]);
goto begin;
}
goto middl;
}


}

[anda_skoa]

Du hast schon wieder einen off-by-one Fehler :)



int prim[998]; // 998 Elemente, d.h letzer Index 997

// das Element 0 wird nicht initialisiert, dafür wird das nicht vorhandene
// Element 998 angesprochen
for (a = 1; a < 999; ++a)


Wenn du mit a < X die Schleife kontrollierst, dann ist X die selbe Zahl wie bei
prim[X].

Weil, wie schon gesagt, der Array dann X Elemente hat und damit X-1 der letzte gültige Index im Array ist.

Ciao,
_

P.S.: wenn du längeren code postest, verwende bitte [code] tags. Das ist übersichtlicher

[The Ripper]

printf()-Ausgaben werden gepuffert, und erst angezeigt, wenn ein Newline (\n) gesendet wird, oder der Puffer "geflushed" wird.
Hier sind die zwei Möglichkeiten:


printf ("*%i+\n",prim[a]);
zeigt die Zahl an und setzt den Cursor an den Anfang der nächsten Zeile





printf ("*%i+",prim[a]);
fflush(stdout);
zeigt die Zahl an und setzt den Cursor direkt dahinter

(den Index b hab ich zu a gemacht, sonst gibts Probleme mit dem vB Code)

[The Ripper]

So jetzt hab ich auch entdeckt, wieso dein Programm nicht funktioniert:
Es erkennt 1 als Primzahl, und kann im folgenden alle Zahlen (ohne Rest :D) durch 1 teilen, worauf es annimmt, dass sie keine Primzahlen sind.

Umgehen kannst du das, indem du alle Zahlen ab 4 überprüfst:
zahl=4; // zeile 12

allerdings stürzt das Programm dann irgendwann ab, da du versuchst, "hinter" das Feld prim[] zu schreiben.

Ich persönlich finde einen Algorithmus mit for schöner, dieses kleine Programm zu schreiben ging schneller als deines zu debuggen :D



#include <stdio.h>
#include <stdlib.h>


int main()
{
int i, a, numprimes, primes[1000];

printf("Primzahlberechnung\n\n");

// Es sei bekannt, dass 1 eine Primzahl ist (sonst wird der Algorithmus umfangreicher)
printf("* 1\n");
primes[0]=1;
numprimes=1;

for (i=2; i < 100; i++)
{
int isprime=1; // Wir nehmen erstmal an, dass jede Zahl eine
// Primzahl ist

for (a = numprimes-1; a > 0; a--)
{
if (i % primes[a] == 0) // Wenn die Zahl durch eine bereits
// vorhandene Primzahl (ausser 1) teilbar
// ist, so ist sie keine Primzahl
{
isprime=0;
break;
}
}

if (isprime)
{
printf("* %i\n", i);

// VORSICHT: erst wird primes[numprimes] gesetzt, dann numprimes
// inkrementiert!!!
primes[numprimes++]=i;

if (numprimes == sizeof(primes) / sizeof(int))
{
puts("Achtung: primes[] kann keine weiteren Elemente aufnehmen!");
exit(1);
}
}
}

exit(0);
}

[anda_skoa]

In Wirklichkeit kann man antürlcih bei 3 starten und nur ungerade Zahlen prüfen.
Denn jede gerade Zahl ist definitiv durch 2 tielbar :)

Außerdem könnte die äußere Schleife über numprimes laufen und i wird extra um 2 inkrementiert.

in etwa so




int i = 3;
while (numprimes < 1000)
{
// body von Rippers äußeren for

i += 2;
}


Das if (numprimes == sizeof(primes) ... kann man dann weglassen.
(ist jetzt auch nciht nötig, denn i erreciht 1000 weit vor 1000 primzahlen)

Ciao,
_

[The Ripper]

ups sorry, das ding hat aus 10 ne primzahl gemacht, allerdings nur die version auf meiner platte
das hab ich dann natürlich korrigiert :D

€: for-Schleife, die nur jede 2te Zahl untersucht: for (i=3; i < 1000; i+=2)