Programm mit Endlosschleife für eine Reihe zu n

09.11.2010, 15:39

DergrößteMatheDepp2

Programm mit Endlosschleife für eine Reihe zu n

Meine Frage:
Hallo, ich soll ein Programm schreiben, dass eine Reihe für Zahlen >0 erstellt, welche bei n=1 abbricht, für n gerade (3n+1) addiert und für n ungerade und >1 (n/2) addiert, dies als Reihe, soll in ein Programm verpackt werden.

Meine Ideen:
import Prog1Tools.IOTools;

public class Collatz{

//Calculation for a sequence n>0, different cases
public static void main (String[] args)
{

//Read in n
int n = IOTools.readInteger("n:");

//Decleration of n
int nG = (n/2);
int nGe = 3 * n + 1;

int row;

do
{
//Calculation of n, for cases and misentry
int result;
n = IOTools.readInteger ("nächstes Glied der Reihe (Abbruch bei n=1:");

if (n==1) break;
if (n<=0) break;
if (n%2==1)
{ result = n + nG;
}
if (n>1 & n%2==1)
{ result = n + nGe;
}

row += result;
System.out.println ("Reihe = " + result);

} while (true);

System.out.println ("Programm beendet");
}
}

soweit war ich jetzt ,aber da stimmt was nicht mit dem row+=result und sicher paar anderen Sachen, aber ich komme leider nicht weiter - ich weiß nicht ob der Weg so prinzipiell richtig ist ,aber ich brauche ja eine Dauerschleife, bis n 1 wird, nur habe ich glaube ich ,auch das if N<=0 break; da falsch, da dies ja eher eine Grundvorraussetzung für den Durchlauf sein sollte ..

Könnt ihr mir helfen ?

mfg

09.11.2010, 19:53

Auf diesen Beitrag antworten »

cav

Programm mit Endlosschleife für eine Reihe zu n

Hi,
ich versuchs mal...

FRAGEN

F1)
verstehe ich das richtig dass immer genau ein Element der Reihe aus dem user-input berechnet wird und dann der Anwender wieder eine neue Zahl eingeben muss? solange biss er 1 eingibt?
Muss wohl, weil so wie Deine Berechnung der Reihen-Elemente aussschaut kann n ja durch die Berechnung nie mehr 1 werden wenn es einmal >1 ist, weil ja immer was draufaddiert wird.

F2)
was genau soll denn row sein? die Summe aller Reihen-Elemente? oder eine Liste davon (in dem Fall müsste row vom Typ String sein)?
ausgeben tust Du's ja nicht...

ANTWORTEN

1)
Was (Endlos-)Schleife bzw. Abbruchkriterium angeht:

So wie ich das versteh willst Du abbrechen bei:
- Zahlen kleiner 0
- bei 0
- und bei 1
Also zusammengefasst: bei Zahlen kleiner gleich 1.

warum nicht sowas in der Art:

code:
1: 2: 3: 4: 5: 6:	while( n > 1) { ... }

2)
Bedingung (n>1 & n%2==1):

das n>1 nochmal abzuprüfen nachdem du schon n==1 und n<=0 ausgeschlossen hast, bringt nix sonder verwirrt eher. mit while-schleifewie oben bei 1) beschrieben sowieso überflüssig.

3)
Du benutzt 2 mal die Bedingung (n%2==1). Ich denke nicht dass das gewollt ist.

P.S.: hier ist es zwar noch eher trivial, aber ich hoffe das klar ist dass bei ausdrücken wie n%2==1 die "operator precendence" (welcher operator vorrang hat, punkt vor strich und so) darüber entscheided ob es ( (n%2) == 1 ) oder ( n % (2==1) ) bedeutet.
Ich empfehle wirklich Klammerung.

4)
die Bedingungen ( (n%2) == 1 ) und ( (n%2) == 0 ) sind disjunkt (entweder die eine oder die andere, es gibt keinen fall bei dem beide ausgeführt werden), also würde ich das auch im code so abbilden
(das hilft in vielen Fällen, z.B. wenn man später was ändert, und sich dabei nicht mehr im Klaren ist dass sich die Bedingungen nicht überschneiden dürfen. Dann sieht man's halt gleich: entweder - oder).

code:
1: 2: 3: 4:	if(bedingung1) {...} else if(bedingung2) {...}

in dem fall sind die Bedningungen sogar total, decken also alle existierenden fälle ab, also gehts auch abgekürzt:

code:
1: 2: 3: 4:	if(bedingung1) {...} else {...}

(wenn die zahl nicht gerade ist, muss sie ja ungerade sein, bleibt ja sonst nix).

5)
result sollte aber wohl nicht vom typ int sein.
wenn n ungerade ist, dann addierst Du ja n/2, und das ist per Defninition dann keine ganze Zahl (Bsp.: n=19, n/2 = 9,5 etc.).

Oder wills Du abrunden (dh. Nachkommastellen wegschmeissen)? Dann würde ich nicht n/2 sondern (n-1)/2 draufaddieren.
Weiss nicht ob der cast von Kommazahl zu integer bei Java so problemlos funktioniert, müsst ich erst ausprobieren..

6)

code:
1: 2: 3: 4: 5:	//Decleration of n int nG = (n/2); int nGe = 3 * n + 1;

das kapseln der Element-Berechnung ist zwar eine gute Idee, aber in dem fall wird diese Berechnung nur EIN mal ausgeführt und dann immer die gleichen Zahlen für nG und nGe hergenommen.
(Es ist also keine Formel-Deklaration wie Du Dir das wahrschl. vorgestellt hast, sonder eine 'normale' Zuweisung, die exakt dann ausgeführt wird, wenn der besagte Code durchlaufen wird. Und das passiert eben nur ein mal.)
Deine Zuweisung muss jeden Schleifendurchlauf neu ausgewertet werden, also muss sie auch in die Schleife rein.

(Oder gibts bei Java sowas wie die C/C++ Präprozessor Direktive #define, a la "#define NG(n) ( n/2)"? glaube nicht...)

=>

das Ganze Konstrukt sähe dann grob so aus:

code:

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:

String row;

while( n > 1)
{
   //// calculate new element based on input
   // n is even
   if( (n%2) == 1 )
   {
      result = n + (n/2);
   }
   // n is odd
   else
   {
      result = n +  (3 * n + 1);
   }
 
   //// output new element
   System.out.println ("Reihe = " + result);

   //// Append new element to string
   row += result;
 
   //// prompt for next n
   n = IOTools.readInteger ("nächstes Glied der Reihe (Abbruch bei n=1:");
}

//// print the whole series
System.out.println ("Reihe = " + result);

Hoffe das hilt
Grüsse

btw. "row ist eher "Zeile", die mathematische Reihe wäre eher "series". habs mal so gelassen damit keine Verwirrung entsteht.

10.11.2010, 09:56

Auf diesen Beitrag antworten »

ed209

RE: Programm mit Endlosschleife für eine Reihe zu n

Zitat:

Original von DergrößteMatheDepp2
Meine Frage:
Hallo, ich soll ein Programm schreiben, dass eine Reihe für Zahlen >0 erstellt, welche bei n=1 abbricht, für n gerade (3n+1) addiert und für n ungerade und >1 (n/2) addiert, dies als Reihe, soll in ein Programm verpackt werden.

Also aus dieser Beschreibung geht noch nicht wirklich hervor was gemacht werden soll, ich hab zwar eine Vermutung was du machen sollst, aber ich bin mir nicht sicher ob dir das selber ganz klar ist smile

Du bist kommst also eine Eingabe n und wie sieht dann die Ausgabe dazu aus?

Gruß,
ED

10.11.2010, 20:48

Auf diesen Beitrag antworten »

cav

Programm mit Endlosschleife für eine Reihe zu n

Ähem sorry, ich war wohl etwas zu schlampig....
Korrektur zum besseren Verständnis:

code:

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:

String row;

while( n > 1)
{
   //// calculate new element based on input
   // n is even
   if( (n%2) == 1 )
   {
      result = n + ( (n-1) / 2 );
   }
   // n is odd
   else
   {
      result = n +  (3 * n + 1);
   }
 
   //// output new element
   System.out.println("Element = " + result);

   //// Append new element to string
   row += " "+result;
 
   //// prompt for next n
   n = IOTools.readInteger ("nächstes Glied der Reihe (Abbruch bei n=1:");
}

//// print the whole series
System.out.println("Reihe = " + row);

grüsse & viel erfolg

Neue Frage »

Antworten »

Programm mit Endlosschleife für eine Reihe zu n

Verwandte Themen