Eulersche Zahl e

Hallo und zwar hab ich folgende Aufgabe:

Die Eulersche Zahl e kann mit folgender Näherungsformel berechnet werden:

12684


Dabei bezeichnet „!“ die Fakultätsfunktion: n! = n ⋅ (n-1) ⋅ (n-2) ⋅... ⋅ 2 ⋅ 1 0! = 1

Schreiben Sie ein Programm, das eine gewünschte Genauigkeit einliest (z.B. 0.01) und dann mit dieser Formel die Zahl e näherungsweise bestimmt, indem nacheinander die Näherungswerte berechnet werden, bis sich zwei aufeinander folgende Wert um weniger als die vorgegebene Genauigkeit unterscheiden.

Hier mein Code ich verstehe nur nicht ganz was es mit der Genauigkeit auf sich hat bzw verstehe ich die Aufgabenstellung nicht ganz wie prüfe ich die Genauigkeit? stehe leider ziemlich auf dem schlauch :S



Code:
public static void fak() {



    System.out.println("Bitte geben Sie einen Wert für n ein : ");

    int n = new Scanner(System.in).nextInt();



    double f = 1;

    double erg = 1;



    for (int i = 1; i <= n; i++) {

        f = f * i;

        erg= erg + (1/f);



        System.out.println(erg);

    }
 
Zuletzt bearbeitet:
Berechne erg, so lange ergAlt - erg > genauigkeit.
In etwa so?

Code:
 public static void fak() {

        
  public static void fak() {

            double erg = 0;
            double f ;
            int n = 20;

            System.out.println("Bitte geben Sie eine Genaugikeit ein ein : ");
            double g = new Scanner(System.in).nextDouble();

            for(int j = 0; j<= n; j++){
                f = 1;

                for(int i = j; i > g; i--){
                    f =f * i;
                }
                erg =erg + 1/f;
            }

            System.out.println("Das Ergebnis lautet: \t\t" + erg);
            

        }

}
 
Zuletzt bearbeitet:
Nimm mal Deinen Code und erläutere ihn mit Worten. Also wirklich jede Zeile einmal genau beschreiben, was Du da genau meinst zu machen....

Oder wenn Du mal ganz von Anfang an starten willst: geh einfach einmal hin mit Taschenrechner, Stift und Papier und schreib auf wie Du Schritt für Schritt vorgehen würdest um e mit einer bestimmten Genauigkeit zu berechnen ...
 
Nein.

In der Bedingung hatte ich einen Fehler: weil erg wächst, hätte es natürlich erg - ergAlt > genauigkeit heißen müssen.

Bezogen auf Deinen Code beträgt die Differenz ja gerade 1/f, d. h. 1/f > g <=> 1 > f*g, und somit etwas in der Richtung:
Java:
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        System.out.println("Bitte geben Sie eine Genaugikeit ein ein : ");
        double g = new Scanner(System.in).nextDouble();
        double f = 1;
        double erg = 1;
        int i = 1;
        do {
            f = f * i;
            erg= erg + (1/f);
            i++;
        } while (g*f < 1);

        System.out.println("Das Ergebnis lautet: \t\t" + erg);
    }
}
@JustNobody sorry, hat sich überschnitten. @TheNox21 Aufgabe: trotzdem manuell nachvollziehen.
 
Wo hier schon eine Lösung da steht, dann evtl. auch eine Implementation mit aussagekräftigen Variablennamen, ohne die Umformung (da muss man halt überlegen, wie man die Genauigkeit bekommt, sprich: alten und neuen Wert speichern um dann vergleichen zu können) und wenn man da etwas nachvollziehen will: Einfach mehr Ausgaben einbauen:


Java:
    System.out.println("Bitte geben Sie die gewünschte Genauigkeit ein: ");
    double genauigkeit = new Scanner(System.in).nextDouble();

    double fakultaet = 1;
    double altesErgebnis = 1;
    double neuesErgebnis = 1;
    int counter = 0;
    do {
      counter++;
      fakultaet = fakultaet * counter;
      altesErgebnis = neuesErgebnis;
      neuesErgebnis = neuesErgebnis + (1/fakultaet);
      System.out.println("Zwischenergebnis bei counter: " + counter + " ist: " + neuesErgebnis + " (Differenz: " + (neuesErgebnis - altesErgebnis)+ ")");
    } while ((neuesErgebnis - altesErgebnis) > genauigkeit);

    System.out.println("e = " + neuesErgebnis);
Der Code sollte so 1:1 nachvollziehbar sein denke ich mal weil der eigentliche Algorithmus 1:1 erhalten geblieben ist.
Ich selbst neige noch dazu, noch längere Variablennamen zu wählen, denn die genauigkeit ist die gewuenschteGenauigkeit, die fakutaet ist die fakultaetVonCounter ... dann ist auch leicht ersichtlich, dass man fakultaetVomCounter mit dem neuen Counter multiplizieren muss, wenn man counter erhöht und so ... Aber da im Code ist nun ein gewisses Minimum an Aussagekraft bezüglich Variablennamen (aus meiner Sicht).
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben