Schleifen

[Need_Help1993]

Hey. ich habe folgende Methode mit for-Schleife gegeben. w = die Wurzel einer positiven Zahl n

int intWurzel(int n){
int w;
for (w=0; w<=n; ++w)
if ((w+1)*(w+1)>n)
break;
terun w;
}

Jetzt soll ich diese Methode nehmen und so umscshreiben, dass es eine while-Schleife wird, und einmal so, dass es eine do-While Schelife wird.
weiß jemand, wie man das macht?

 

[Final_Striker]

Du nimmst das was in der for-Schleife steht, packts das in die while-Schleife und passt die Abbruchbedingung so an, das diese der for-Schleife entspricht.

 

[Marcinek]

Indem du zunächst erfasst, was die for. Schleife macht. Und das am besten mit eigenen worten.

Wenn du das machst ist es trivial eine while und do while zu machen.

Gruß,

Martin

 

[Need_Help1993]

int intWurzel(int n){
int w;
while (i<=n){
break;
return w;
}

wäre das korrekt als umwandlung in eine while schleife?

 

[hdi]

Hä? Nein, da fehlt doch jetzt die gesamte Logik. Glaubst du echt diese Schleife berechnet ne Wurzel? Die macht gar nix. Kann es sein dass du da die Hälfte des Codes auf dem Weg von Copy bis hin zum Paste verloren hast?

PS: Bitte pack deinen Code in Java-Code Tags (Kaffeetassen Symbol im Editor), und formatiere ihn vor dem Posten! (Zeilen einrücken)

 

[tuttle64]

int intWurzel(int n){
int w;
while (i<=n){
break;
return w;
}

wäre das korrekt als umwandlung in eine while schleife?

Nein, eine do-while-Schleife hat die Struktur:

do {
} while (true)

Abgesehen davon, geschieht innerhalb der Schleife gar nix und zudem wo wird i initialisiert?

 

[nillehammer]

Die For-Schleife übernimmt für Dich das Hochzählen und innerhalb prüfst Du die Bedingung. Bei der While-Schleife ist es mehr oder weniger genau andersrum. D.h. im while(...) musst Du die Bedingung prüfen und innerhalb das Hochzählen selbst übernehmen.

 

[Final_Striker]

wäre das korrekt als umwandlung in eine while schleife?

Wenn die Methode

intWurzel(int n)

für alle möglichen Parameter

int n

die identischen Rückgabewerte liefert wie die mit der for-Schleife, dann ist das die korrekte Umwandlung.

 

[hdi]

@Final_Striker Wenn du dich da mal nicht in Teufels Küche bringst Es geht offensichtlich darum, eine for-Schleife 1:1 in eine while-Schleife zu übersetzen. Nicht darum, ob die Methode noch das selbe liefert, wenn da (irgendwie, irgendwo, irgendwann) ne while-Schleife drin steht. Klar, dass du die Aufgabe intuitiv richtig lösen würdest. Aber wer weiß, was für ein Konstrukt der TO da aufzieht.. Von daher würd ich das jetzt nich so definieren wie du

 

[Need_Help1993]

ich komm nicht auf den Trichter....
ich bin jetzt so weit:

 int intWurzel(int n){
	int w;
	while (w=0; w<=n; ++w)
			if ((w+1)*(w+1)>n)
				break;
	return w;
}

ich habe jetzt genau dass, was in der for schleife stand in die while schleife geschrieben.
aber wie passe ich jetzt die abbruchbedingung an?

 

[Marcinek]

Und liefert es das korrekte ergebnis?

Wenn while und for die gleiche syntax hätten, wäre die Aufgabe sinnlos oder?

;D

Kannst du mal ein Buch aufschlagen und nachlesen, was die while schleife so macht?

 

[Firephoenix]

Der Code entspricht in etwa dem Ergebnis, als sollte man ein Bild mit Bohrmaschine und Schraube anstatt mit Hammer und Nagel aufhängen - und nimmt dann die Schraube und prügelt sie mit dem Griff der Bohrmaschine in den Putz.

Hier findest du Grundlagen zu Schleifen, versuche erstmal zu verstehen was eine Schleife eigentlich macht, bzw wie sie aufgebaut werden:
Tutorial / Java Grundlagen / Schleifen

Dannach formulierst du die Schleife in Worte und überträgst das auf die andere Schleife - was mit dem Grundwissen dann nicht mehr all zu schwer werden wird.

Ein Beispiel:

for(int i = 0; i < 10; i++){System.out.println(i);}

wäre eine Schleife die eine Variable i mit 0 initialisiert, dann prüft ob die Variable kleiner 10 ist, und wenn das der Fall ist diese Variable ausgibt. Nach jedem Schleifendurchlauf wird i um eins erhöht und die Abfrage neu geprüft - falls die Abfrage true ergibt wiederholt sich die Schleife.

Überträgt man den Text auf eine normale while würde man erhalten:

int i = 0;
while(i < 10){
system.out.println(i);
i++;
}

(Code einfach in den Editor getippt - ungetestet)
Gruß

 

[njans]

Die while-Schleife hat aber nicht dei for-Schleifen Syntax.
In der while-Schleife steht im Kopf nur die Bedingung. Den Rest musst du in die Schleife packen ^^

 

[Final_Striker]

aber wie passe ich jetzt die abbruchbedingung an?

Vielleicht in dem du einfach überlegst wie lange die Schleife laufen soll?!

Ich würde an deiner Stelle bei Schleifen und if-Bedingungen immer Klammern

{..}

nutzen, so passieren dir weniger (in der Regel schwer zu findenden) Fehler .

 

[Need_Help1993]

okay. also die while Schleife prüft etwas so lange bis es false ergibt, und führt dan den nachstehenden code aus.
d.h. Meine Methode berechnet den größten wert, der kleiner / gleich n ist, und das so lange bis der wer nichtmehr kleiner / gleich n ist, und dan bricht die while schleife ab.
soweit verstehe ich das auch ganz gut... aber wie implementiere ich das. bzw. wie müsste der code dazu aussehen?

 int intWurzel(int n){
	int w;
	while (w=0; w<=n; ++w)

so weit müsste die ganze sache ja dan auf jeden fall stimmen. er führt das ganze so lange aus, wie es 0, oder kleiner / gleich n ist. und dabei zählt er immer weiter hoch?

 

[hdi]

Schau dir die for-Schleife an. Was ist ihre Abbruchbedingung? Negiere das und du hast die Eintrittsbedingung für deine while-Schleife. zB

for(int i = 0; i<10; i++){...}

Die Abbruchbedingung ist: i >= 10. Negiert: i < 10. Also:

int i = 0;
while(i<10){...}

Eine while-Schleife sieht wie du siehst syntaktisch anders aus. Da gibts nix mit (x;y;z). Die Klammern erwarten nur einen einzigen booleschen Ausdruck. Bitte google doch mal wenigstens kurz nach while-Schleife.. Du weißt ja noch nicht mal was das ist, und wie die Syntax ist.

Was ist jetzt noch der Unterschied? Die for-Schleife führt nach jedem Schleifendurchlauf automatisch das aus, was am Ende in der Signatur steht. Hier ist das i++. Das tut die while-Schleife nicht, also musst du es in den Rumpf packen:

int i = 0;
while(i<10){ ...; i++; }

Und das, was jetzt noch im Rumpf der for-Schleife steht kopierst du in den Rumpf der while-Schleife, natürlich vor das Inkrement. Und dann hast du deine for-Schleife 1:1 auf eine while-Schleife übertragen.

 

[Firephoenix]

Kleine Vereinfachung hdi:
Bevor du die Abbruchbedingung der for-Schleife durch Negation ihrer Eintrittsbedingung erzeugst und diese wieder negierst um die Eintrittsbedingung der While-Schleife zu erhalten könntest du auch ...
Gruß

 

[hdi]

Ja ich hab dabei an Bedingungen innerhalb des Rumpfes gedacht, die man dann auch in die while-Bedingung ziehen will:

for(...){
     doSomeStuff();
     boolean abort = checkThings();
     if(abort){ 
        break;
     }
}

=>

do{...}
while(... && !checkThings() )

 

[Need_Help1993]

int intWurzel(int n) {
	int w;
	for (w = 0; w <= n; ++w)
		if ((w + 1) * (w + 1) > n)
			break;
	return w;
}


int intWurzel(int n){
	int w=0;
	while(w<=n)7
	++w;
		if((w+1)*(w+1)>n);
			break;}
	return w;
}



int intWurzel(int n){
	int w=0;
	do{
		if((w+1)*(w+1)>n);
			break;
			++w; }
		while(w<=n);
	return w;
}

stimmt das so?

 

[VfL_Freak]

Moin,

hast Du mal versucht das zu compilieren ???:L

Erstens kannst Du nicht dreimal die gleiche Funktion (gleicher Name, gleicher Parameter, gleicher Rückgabewert) deklarieren !

Zweitens stehen in den Zeilen 15 und 26 überflüssige schließende Klammern !

Gruß
Klaus

 

[Need_Help1993]

ne, habs noch nicht versucht, ich machs gerade auf nem blatt. die Klammern sind gleich weg, aber wie müsste es den richtig lauten? ich verstehe nicht so genau, was du meinst?
das soll ja nicht zusammen in eine klasse, die aufgabe ist ja die 1. schleife ganz oben in eine while und in eine do-while schleife umzuwandeln und das ganze 1:1

 

[VfL_Freak]

Moin,

ach so, also geht es Dir ausschließlich nur um das Umwandeln von FOR{...} in WHILE{...} resp. DO{...}WHILE ?

Ich habe auch den Sinn der zuerst geposteten Methode nicht verstanden! Was hat das denn mit Wurzeln zu tun ???:L

Übergibt man bspw. den Wert "3", würde eine "2" zurückbekommen ......
Was genau soll die Funktion denn nun eigentlich berechnen?

Gruß
Klaus

EDIT:
Scheint grundlegend so ok zu sein - hab's mal etwas schöner formatiert :

int intWurzel( int n ) 
{
    for( int w = 0; w <= n; w++ ) // warum eigentlich ++w ?
    {
        if( (w + 1) * (w + 1) > n )
        {
            break;
        }
    }
    return w;
}
 
 
int intWurzel_1( int n )
{
    int w = 0;
    while( w <= n )
    {
        if( (w+1)*(w+1) > n )
        {
            break;
        }
        w++;  // gehört HINTER die Berechnung
    }
    return w;
}
 
 
 
int intWurzel_2( int n )
{
    int w = 0;
    do
    {
        if( (w+1)*(w+1)>n )
        {
            break;
        }
        w++;
    } while( w <= n );
    return w;
}

 

[mumpf]

Hallo!

Bitte denke an die Menschen, die deine Kodausschnitte lesen. Es ist bedeutend einfacher und angenehmer, wenn dein Kod ordentlich formatiert/eingerückt ist und von Schusseligkeitsfehlern (wie z.B. "terun" im ersten Postin) bereinigt ist. Damit zeigst du, dass du dich bemüht hast und das wird man dir anerkennen und in einer hilfreichen Antwort zollen.
Du stehst auf der etwas sichereren Seite, wenn du deinen Kod vor dem Forum vom Kompiler prüfen lässt.
Und wie einige hier schon geschrieben haben: Erst lernen und denken, dann Kod schreiben. Wenn du die Syntax der while-Schleife hier derart falsch postest, weiß man, dass du nicht anständig gelernt hast

int intWurzel(int n) {
     int w;
     for (w = 0; w <= n; ++w){
          if ((w + 1) * (w + 1) > n)
          break;
     }
     return w;
}


int intWurzel(int n){                        // hier ist w das Problem, es wird um 1 erhöht bevor es das
     int w=0;                                  // erste Mal verwendet wird
     while(w<=n){
          ++w;                                 //diese Zeile gehört also unter die nächste mit if...
          if((w+1)*(w+1)>n)  break;
     }
     return w;
}



int intWurzel(int n){
     int w=0;
     do{
          if((w+1)*(w+1)>n);     //Das Symikolon ist falsch, ne? ^^
               break;
          ++w;
     }
     while(w<=n);
     return w;
}

stimmt das so?

 

[Need_Help1993]

okay, vielen Dank für eure Hilfe.
++W, weil die Aufgaben ein C-Programmierer gemacht hat, und da zählt man mit ++w

Aufgabentext dazu ist:
Die unten stehende Methode intWurzel(int n) berechnet die ganzzahlige Wurzel
w einer positiven int-Zahl n. Das heißt, sie berechnet den größten ganzzahligen Wert
w mit w * w <= n.

eine weitere Frage ist, welche der beiden (while oder do-while) schleifen besser geeignet wären.
Das müsste meiner Ansicht nach die while Schleife sein, da vor der Anweisung geprüft wird ob w>n (sie ist somit effizienter)

kann man das so sagen?

 

[Marcinek]

Alle Schleifen sind hier gleich effizient.

Ich würde eher eine do while schleife machen, weil man mind. einmal prüfen muss ob das quadrat schon das ergebnis ist und man damit die wurzel hat.

Gruß,

Martin

 

[VfL_Freak]

Moin,

++W, weil die Aufgaben ein C-Programmierer gemacht hat, und da zählt man mit ++w

Das stimmt so nicht !
Es gibt in vielen Sprachen Prä- und Postinkrement!
Hier mal schnell ein Link, in dem das ganz gut erklärt wird :
Prä-und Postinkrement - BuHa-Security Board

Sollte aber in Deinem konkreten Fall nicht so wichtig sein, obwohl ich dass in einer for-Schleife auch noch nie versucht habe und nicht wirklich weiß, wie es sich auswirkt!

Gruß
Klaus

 

[Need_Help1993]

ups, ich habe übersehen, dass man die for-schleife auch benutzen könnte:
Welche Art von Schleife (for-, while- oder do-while-Schleife) halten Sie in diesem Fall
für angebracht? Begründen Sie Ihre Antwort kurz.