OOP eine Zahl immer weiter durch 2 teilen

[Hilfesuchende0101]

Hallo zusammen,
ich bin neu hier und auch Anfänger in der Java Programmierung. Ich sitze seit längerem an einer Aufgabe und, obwohl sie wohl ziemlich einfach ist, komme ich einfach nicht auf die Lösung. Es geht um einen Frosch, der beim 1. Sprung eine Distanz von einem Meter zurücklegt und dann bei jedem weiteren Schritt nur noch halb so weit springt wie davor. Die Entfernung, die er dabei zurücklegt, soll sich also aus der Summe der Werte 1 + 0,5 + 0,25 + 0,125 usw berechnen, bis der Frosch insgesamt 2 Meter gesprungen ist.
Ich habe versucht, dass mit einer Schleife zu lösen, aber mir werden nur die Werte von 1 - 0,125 ausgegeben. Kann mir jemand helfen, wie ich alle Werte bis 2 Meter ausgegeben bekommen?
Freue mich über jeden Tipp!

public class Frosch {

    public static void main(String[] args) {
        double anzahlSpruenge=0;
        double sprung1 = 1;
        double sprung2=0;
       
         int i=0;
         System.out.println(sprung1);
        while(i<=3){
           
        sprung2=sprung1/2;
       
            i++;
           
             System.out.println(sprung2/i);
           
         }
   
        }
       
        }

 

[Lazyyy]

also ich würde hier mit einer for - Schleife Arbeiten:
und einer hilfsvariable die die immer kleinere Distanz speichert.
bei result += result/2 würde es immer größer werden weil result nach jedem Sprung auch größer wird.

double result = 0;
double temp = 1;
 for(int i = 0; i < anzahlSprünge; i++){
    temp = temp/2;
    result += temp;
 }
 return result;

 

[mrBrown]

Aktuell läuft deine Schleife nur so lange, bis i größer als 3 ist, damit werden nur maximal 4 Sprünge berechnet.

Du solltest stattdessen die weiter der Sprünge in einer Variablen speichern, und die Schliefe so lange laufen lassen, wie er noch nicht 2m weit gekommen ist.

 

[mihe7]

@Hilfesuchende0101, sag Bescheid, wenn der Frosch zwei Meter weit gesprungen ist SCNR.

 

[Hilfesuchende0101]

Danke schonmal für die schnellen Antworten! Bis jetzt hab ich die Lösung noch nicht aber ich denke nochmal drüber nach so schwer kann das ja nicht sein

 

[VfL_Freak]

Moin,

ist eigentlich ganz simpel mit einer while-Schleife und den richtigen Startvariablen:

int anzahlSpruenge = 1;  // erster Sprung
double result = 1.0;  // da im ersten Sprung schon 1 m !!
double temp = 1.0;  // Hilfsvariable zur Berechnung

System.out.println( "anzahlSpruenge<" + anzahlSpruenge + ">  # temp<" + temp + ">  #  result<" + result + ">" );  // für den ersten Sprung von 1 m!!
while( result < 2.00 )
{
    anzahlSpruenge++;
    temp = temp / 2;
    result += temp;
    System.out.println( "anzahlSpruenge<" + anzahlSpruenge + ">  # temp<" + temp + ">  #  result<" + result + ">" );
}

Spoiler: Ergebnis

anzahlSpruenge<1> # temp<1.0> # result<1.0>
anzahlSpruenge<2> # temp<0.5> # result<1.5>
anzahlSpruenge<3> # temp<0.25> # result<1.75>
anzahlSpruenge<4> # temp<0.125> # result<1.875>
anzahlSpruenge<5> # temp<0.0625> # result<1.9375>
anzahlSpruenge<6> # temp<0.03125> # result<1.96875>
anzahlSpruenge<7> # temp<0.015625> # result<1.984375>
anzahlSpruenge<8> # temp<0.0078125> # result<1.9921875>
anzahlSpruenge<9> # temp<0.00390625> # result<1.99609375>
anzahlSpruenge<10> # temp<0.001953125> # result<1.998046875>
anzahlSpruenge<11> # temp<9.765625E-4> # result<1.9990234375>
anzahlSpruenge<12> # temp<4.8828125E-4> # result<1.99951171875>
anzahlSpruenge<13> # temp<2.44140625E-4> # result<1.999755859375>
anzahlSpruenge<14> # temp<1.220703125E-4> # result<1.9998779296875>
anzahlSpruenge<15> # temp<6.103515625E-5> # result<1.99993896484375>
anzahlSpruenge<16> # temp<3.0517578125E-5> # result<1.999969482421875>
anzahlSpruenge<17> # temp<1.52587890625E-5> # result<1.9999847412109375>
anzahlSpruenge<18> # temp<7.62939453125E-6> # result<1.9999923706054688>
anzahlSpruenge<19> # temp<3.814697265625E-6> # result<1.9999961853027344>
anzahlSpruenge<20> # temp<1.9073486328125E-6> # result<1.9999980926513672>
anzahlSpruenge<21> # temp<9.5367431640625E-7> # result<1.9999990463256836>
anzahlSpruenge<22> # temp<4.76837158203125E-7> # result<1.9999995231628418>
anzahlSpruenge<23> # temp<2.384185791015625E-7> # result<1.999999761581421>
anzahlSpruenge<24> # temp<1.1920928955078125E-7> # result<1.9999998807907104>
anzahlSpruenge<25> # temp<5.9604644775390625E-8> # result<1.9999999403953552>
anzahlSpruenge<26> # temp<2.9802322387695312E-8> # result<1.9999999701976776>
anzahlSpruenge<27> # temp<1.4901161193847656E-8> # result<1.9999999850988388>
anzahlSpruenge<28> # temp<7.450580596923828E-9> # result<1.9999999925494194>
anzahlSpruenge<29> # temp<3.725290298461914E-9> # result<1.9999999962747097>
anzahlSpruenge<30> # temp<1.862645149230957E-9> # result<1.9999999981373549>
anzahlSpruenge<31> # temp<9.313225746154785E-10> # result<1.9999999990686774>
anzahlSpruenge<32> # temp<4.6566128730773926E-10> # result<1.9999999995343387>
anzahlSpruenge<33> # temp<2.3283064365386963E-10> # result<1.9999999997671694>
anzahlSpruenge<34> # temp<1.1641532182693481E-10> # result<1.9999999998835847>
anzahlSpruenge<35> # temp<5.820766091346741E-11> # result<1.9999999999417923>
anzahlSpruenge<36> # temp<2.9103830456733704E-11> # result<1.9999999999708962>
anzahlSpruenge<37> # temp<1.4551915228366852E-11> # result<1.999999999985448>
anzahlSpruenge<38> # temp<7.275957614183426E-12> # result<1.999999999992724>
anzahlSpruenge<39> # temp<3.637978807091713E-12> # result<1.999999999996362>
anzahlSpruenge<40> # temp<1.8189894035458565E-12> # result<1.999999999998181>
anzahlSpruenge<41> # temp<9.094947017729282E-13> # result<1.9999999999990905>
anzahlSpruenge<42> # temp<4.547473508864641E-13> # result<1.9999999999995453>
anzahlSpruenge<43> # temp<2.2737367544323206E-13> # result<1.9999999999997726>
anzahlSpruenge<44> # temp<1.1368683772161603E-13> # result<1.9999999999998863>
anzahlSpruenge<45> # temp<5.6843418860808015E-14> # result<1.9999999999999432>
anzahlSpruenge<46> # temp<2.8421709430404007E-14> # result<1.9999999999999716>
anzahlSpruenge<47> # temp<1.4210854715202004E-14> # result<1.9999999999999858>
anzahlSpruenge<48> # temp<7.105427357601002E-15> # result<1.999999999999993>
anzahlSpruenge<49> # temp<3.552713678800501E-15> # result<1.9999999999999964>
anzahlSpruenge<50> # temp<1.7763568394002505E-15> # result<1.9999999999999982>
anzahlSpruenge<51> # temp<8.881784197001252E-16> # result<1.9999999999999991>
anzahlSpruenge<52> # temp<4.440892098500626E-16> # result<1.9999999999999996>
anzahlSpruenge<53> # temp<2.220446049250313E-16> # result<1.9999999999999998>
anzahlSpruenge<54> # temp<1.1102230246251565E-16> # result<2.0>

EDIT: kleine Korrektur für den ersten Sprung eingebaut!


VG Klaus

 

[Hilfesuchende0101]

Vielen Dank Klaus! Das hilft mir sehr, es zu verstehen und auf ähnliche Aufgabenstellungen anzuwenden!

 

[VfL_Freak]

Hatte heute meinen größenzügigen Tag, weil gleich die WM anfängt
Überleg' Dir immer, welche Schleife (FOR, WHILE-DO, DO-WHILE) im konkreten Fall sinnvoll ist und wie die Werte vorher, während und nach der Ausführung aussehen !!

VG Klaus

 

[Javinner]

@VfL_Freak

Es geht um einen Frosch, der beim 1. Sprung eine Distanz von einem Meter zurücklegt und dann bei jedem weiteren Schritt nur noch halb so weit springt wie davor

Viel Spaß für die WM, möge die Mannschaft deiner Wahl den Titel mit nachhause nehmen


@Hilfesuchende0101
Was mir nicht klar ist: gibt es eine minimal mögliche Sprungweite? Wenn es diese nicht geben sollte und dein Frosch für seine Sprünge double als primitiven Typ nimmt, dann macht dieser, zumindest laut NetBeans genau 1084 Sprünge, bis er zwei Meter überwunden hat. Wenn minimal mögliche Schrittweite 0,001mm beträgt, sind es zwanzig Sprünge an der Zahl.

 

[FourOhFour]

Welche Schleife man verwendet habe ich mir immer gemerkt mit:
-> for - wenn du weißt, wie viele Schritte du brauchst
-> while - wenn du nicht weißt, wie viele Schritte du brauchst
-> do-while - wenn es zumindest 1x geschehen muss
Evtl. hat da ein mehr Erfahrener einen Einwand, aber bisher hat mir das immer geholfen, besonders bei so simplen Aufgaben.

 

[MoxxiManagarm]

Rein mathematisch gesehen würde ich meinen geht die Aufgabe eigentlich garnicht (zumindest nicht bei einem erstsprung<=zielwert/2)?! Theoretisch nähert sich der Frosch immer näher der 2m an, würde diese aber nie erreichen.

 

[Javinner]

Welche Schleife man verwendet habe ich mir immer gemerkt mit:
-> for - wenn du weißt, wie viele Schritte du brauchst
-> while - wenn du nicht weißt, wie viele Schritte du brauchst
-> do-while - wenn es zumindest 1x geschehen muss
Evtl. hat da ein mehr Erfahrener einen Einwand, aber bisher hat mir das immer geholfen, besonders bei so simplen Aufgaben.

rekursiv gibt es auch noch

 

[VfL_Freak]

Moin,

ketzerische Frage:
ist die Rekursion wirklich ein Schleifenkonstrukt im strengen Sinne??
Du kannst zwar jede Rekursion auch in eine iterative Lösung umwandeln und umgekehrt, aber das macht doch IMHO aus der Rekursion selbst noch keine Schleife ...

VG Klaus

 

[httpdigest]

Rein mathematisch gesehen würde ich meinen geht die Aufgabe eigentlich garnicht (zumindest nicht bei einem erstsprung<=zielwert/2)?! Theoretisch nähert sich der Frosch immer näher der 2m an, würde diese aber nie erreichen.

Das ist der Spaß, den man hat, wenn man mit diskreten IEEE-754 Werten und dementsprechenden Rundungsungenauigkeiten arbeitet. Theoretisch erreicht der Frosch die 2m Marke nicht, praktisch schon.
Interessanterweise wird die Grenze von 2.0 zwar erreicht, aber nicht 2.0 + Math.ulp(2.0), also die kleinste Zahl, die echt größer als 2.0 ist und in double repräsentiert werden kann.

 

[Xyz1]

Es geht um einen Frosch, der beim 1. Sprung eine Distanz von einem Meter zurücklegt und dann bei jedem weiteren Schritt nur noch halb so weit springt wie davor. Die Entfernung, die er dabei zurücklegt, soll sich also aus der Summe der Werte 1 + 0,5 + 0,25 + 0,125 usw berechnen, bis der Frosch insgesamt 2 Meter gesprungen ist.

    public static void main(String[] args) {
        froschSpring(0.002F);
    }

    static void froschSpring(final float epsilon) {
        float weite = 1;
        float weiteIgs = 0;
        while (weiteIgs < 2 - epsilon) {
            System.out.println("Der Frosch springt jetzt: " + weite);
            weiteIgs = weiteIgs + weite;
            System.out.println("Der Frosch sprang insges: " + weiteIgs);
            weite = weite / 2;
            System.out.println("Die Weite wird geringer : " + weite);
            System.out.println("");
        }
        System.out.println("Fertig");
    }

Der Frosch springt jetzt: 1.0
Der Frosch sprang insges: 1.0
Die Weite wird geringer : 0.5

Der Frosch springt jetzt: 0.5
Der Frosch sprang insges: 1.5
Die Weite wird geringer : 0.25

Der Frosch springt jetzt: 0.25
Der Frosch sprang insges: 1.75
Die Weite wird geringer : 0.125

Der Frosch springt jetzt: 0.125
Der Frosch sprang insges: 1.875
Die Weite wird geringer : 0.0625

Der Frosch springt jetzt: 0.0625
Der Frosch sprang insges: 1.9375
Die Weite wird geringer : 0.03125

Der Frosch springt jetzt: 0.03125
Der Frosch sprang insges: 1.96875
Die Weite wird geringer : 0.015625

Der Frosch springt jetzt: 0.015625
Der Frosch sprang insges: 1.984375
Die Weite wird geringer : 0.0078125

Der Frosch springt jetzt: 0.0078125
Der Frosch sprang insges: 1.9921875
Die Weite wird geringer : 0.00390625

Der Frosch springt jetzt: 0.00390625
Der Frosch sprang insges: 1.9960938
Die Weite wird geringer : 0.001953125

Der Frosch springt jetzt: 0.001953125
Der Frosch sprang insges: 1.9980469
Die Weite wird geringer : 9.765625E-4

Fertig

Versuch das mal zu verstehen.
Durch die Ausgaben ist das eigentlich selbsterklärend....

Besteht jetzt noch Erklärungsbedarf ?

Wenn ja beschäftige Dich mit float, der Epsilontik sowie der Kontrollstruktur while.

(Oder tu was Sinnvolles.... )

 

[Javinner]

ist die Rekursion wirklich ein Schleifenkonstrukt im strengen Sinne??

Natürlich nicht. Jedoch passt die Rekursion zu der Aufgabe und eventuell interessiert sich der Fragesteller für die Vielfalt der Lösungswege