2-spaltige Ausgabe als Tabelle ausgeben

SaggiTarrio

Mitglied
Hallo Java-Programmierer,

Bevor ich die Frage stelle möchte ich betonen: Ich habe Mr. Google und das Forum schon durchsucht, jedoch nichts verständliches gefunden. Also:

Ich schreibe zurzeit an einem Programm, dass mir Wurzeln berechnet. Funktioniert alles ganz gut, ich möchte aber, dass die Ausgabe des Rechenweges etwas schöner ist als:

Java:
Von welcher Zahl soll die Wurzel berechnet werden? (bitte nur positive Zahlen eingeben)
7 //(Input)
Auf wieviele Nachkommastellen soll das Ergebnis gerundet werden?
6 //(Input)
x0: 7.0    y0: 1.0
x1: 4.0    y1: 1.75
x2: 2.875    y2: 2.4347826086956523
x3: 2.654891304347826    y3: 2.636642784032753
x4: 2.64576704419029    y4: 2.6457355780324487






Die Wurzel von 7 ist ungefähr 2.645751

Also meine Frage: Kann ich irgendwie meinen Rechenweg als Tabelle ausgeben, damit Java die Einrückung automatisch macht oder kann ich das irgendwie manuell?

Methode zieheWurzel:
Java:
public static double zieheWurzel(double i, int nks){
        // Nötige Variablen werden initiiert.
        double a = i;
        double b = 1;
        int k = 0;
        String j = "";
        // Schleife, die so lange läuft bis a und b ungefähr gleich sind.
        while(runde(a, nks) != runde(b, nks)){
            j = Integer.toString(k);
            // Diese Zeile gibt mir den Rechenweg aus.
            System.out.println("x"+j+": " + a + "" + "\t" + "" + "y"+j+": " + b);
            // Berechnung der Wurzel über das Heron-Verfahren.
            a = (a+b)/2;
            b = i/a;
            k++;
        }
        // Eigentlich unnötig, da a und b jetzt gleich sein müssten, ich fand es aber schöner.
        double wurzel = (a+b)/2;
        // Rückgabe der Wurzel als double.
        return wurzel;
    }

Methode runde:
Java:
public static double runde(double zahl, int nks){
        
        BigDecimal zahlGerundet = new BigDecimal(zahl);
        String ausgabe = (zahlGerundet.setScale(nks, RoundingMode.HALF_UP)).toString();
        return Double.parseDouble(ausgabe);
    }

Hauptprogramm:
Java:
static InputStreamReader isr = new InputStreamReader(System.in);
    static BufferedReader br = new BufferedReader(isr);


    public static void main(String[] args) throws IOException {
        // Ein paar Anweisungen an den Anwender.
        System.out.println("Wurzelberechnen über das Heronverfahren mit Rechenweg.");
        System.out.println("Bitte nur positive Ziffern eingeben, sonst müssen das Programm neustarten. Zum Abschalten einfach eine 0 eintippen.");
        System.out.println("    von Linus K. Ehlers");
        // Methode, die Einfach nur Absätze einfügt.
        tippeEnter(2);
        // Variablen werden initiiert.
        double zahl = 1;
        String zahlenstring = "";
        double ausgabe = 0;
        
        // Schleife, damit das Programm nach dem Berechnen der Wurzel wieder von vorne anfangen kann.
        while(zahl != 0){
            // Entgegennahme der Zahl von der die Wurzel berechnet werden soll.
            System.out.println("Von welcher Zahl soll die Wurzel berechnet werden? (bitte nur positive Zahlen eingeben)");
            zahlenstring = br.readLine();
            zahl = Double.parseDouble(zahlenstring);
            // Entgegennahme der Anzahl der Nachkommastellen auf die gerundet werden soll.
            System.out.println("Auf wieviele Nachkommastellen soll das Ergebnis gerundet werden?");
            int nks = Integer.parseInt(br.readLine());
            ausgabe = runde(zieheWurzel(zahl, nks), nks);
            tippeEnter(3);
            // Ausgabe der Lösung
            System.out.println("Die Wurzel von " + zahlenstring + " ist ungefähr " + ausgabe);
            tippeEnter(1);
            
        }
        
        // Information an Benutzer, dass Programm sich abschaltet.
        tippeEnter(20);
        System.out.println("Programm wird abgeschaltet, weil Sie eine 0 eingetippt haben!");
        System.out.println("");
        System.out.println("von Linus K. Ehlers");
        tippeEnter(7);
    }

Und die Imports:
Java:
import java.io.*;
import java.util.*;
import java.math.*;
 
Zuletzt bearbeitet:
Ich verstehe jetzt nicht so genau, was du mit
was du suchst ist String.format();
String s =String.format( "Stringformatierung", Parameter);
meinst.

Ich meinte, dass die Ausgabe ungefähr so aussieht:
[TABLE="width: 500, align: left"]
[TR]
[TD]x0 = 76.0[/TD]
[TD]y0 = 1.0[/TD]
[/TR]
[TR]
[TD]x1 = 38.5[/TD]
[TD]y1 = 1.974025974025974[/TD]
[/TR]
[TR]
[TD]x2 = 20.23701298701299[/TD]
[TD]y2 = 3.75549494625381[/TD]
[/TR]
[TR]
[TD]x3 = 11.9962539666334[/TD]
[TD]y3 = 6.335311023873602[/TD]
[/TR]
[TR]
[TD]x4 = 9.1657824952535[/TD]
[TD]y4 = 8.291708868212462[/TD]
[/TR]
[TR]
[TD]x5 = 8.728745681732981[/TD]
[TD]y5 = 8.70686382340689[/TD]
[/TR]
[TR]
[TD]x6 = 8.717804752569936[/TD]
[TD]y6 = 8.717791021598165[/TD]
[/TR]
[TR]
[TD]x7 = 8.71779788708405[/TD]
[TD]y7 = 8.717797887078644[/TD]
[/TR]
[TR]
[TD]x8 = 8.717797887081346[/TD]
[TD]y8 = 8.717797887081348[/TD]
[/TR]
[/TABLE]
Zurzeit ist es so:
Java:
x0 = 76.0    y0 = 1.0   
   x1 = 38.5    y1 = 1.974025974025974
   x2 = 20.23701298701299    y2 = 3.75549494625381
   x3 = 11.9962539666334    y3 = 6.335311023873602
   x4 = 9.1657824952535    y4 = 8.291708868212462
   x5 = 8.728745681732981    y5 = 8.70686382340689
   x6 = 8.717804752569936    y6 = 8.717791021598165
   x7 = 8.71779788708405    y7 = 8.717797887078644
   x8 = 8.717797887081346    y8 = 8.717797887081348
 
in meinem link ( kapitel 4.26) ist es doch erklärt wie man das macht.
zählerv, wertX zählerv, werty zV Wx zV Wy
String formatierteAusgabe =String.format( "x%-3d: = % -21.16f "y%-3d: = % -21.16f", i, xi, i, yi);
 
Ah, ich habe es jetzt auch verstanden.
Es gibt immer noch mehrere Probleme:

1: Er rundet auf 6 Stellen hinter dem Komma.
2: Wenn die Zahl nicht mehr einstellig sondern zweistellig wird, verschiebt sich das alles um eine Stelle:
Java:
   Rechenweg:
   98,000000      1,000000
   49,500000      1,979798 
   25,739899      3,807319 
   14,773609      6,633450 
   10,703530      9,155858 
   9,929694      9,869388 
   9,899541      9,899449 
   9,899495      9,899495


Die auf 12 Nachkommastellen gerundete Wurzel von 98.0 ist 9.899494936612.
Ich meine, klar mit dem Runden, damit komme ich schon klar, aber die Einrückung sollte schon irgendwie funktionieren...
 
es soll jetzt nicht wie ein dummer spruch klingen, aber lesen hilft. Du kannst ja probieren, was passiert wenn du die "%"-Parameter anpasst
 
Ich habe das jetzt alles soweit verstanden, habe aber noch eine Frage:

Gibt es eine Möglichkeit, dass das Programm automatisch überprüft, wieviele Stellen die größte Zahl hat oder muss ich einen Faustwert wählen, der hoffentlich passt? (Wahrscheinlich habe ich sowas überlesen)
 
du kannst, wenn du deine werte vor der ausgabe in einem Array "speicherst" prüfen, welches der größte wert ist/welcher die meisten nachkommastellen hat. dann kannst du das auch in die ausgabe mit einfließen lassen.
 
Ein Problem habe ich jetzt noch (ich weiß ich sage das oft):

Ich bin zu blöd um zum Beispiel "%15.00002f" mit einer Variable zu sagen, wie viele Stellen Sie haben soll, also irgendwie: "%vorkommastellen.nachkommastellen"

Das habe ich schon probiert, funktioniert aber nicht...
 
Zuletzt bearbeitet:
du musst den formatedTeil bauen, und diesen, dann dann im String.format( formatedTeil, parameter); übergeben. etwas eigeninitiative ist gefragt
 
So weit war ich glaube ich schon:

Java:
System.out.printf( "   %15.00002f = %3s  %3s = %10.9f %n" , x, xzahl, yzahl, y );

Möchte aber anstatt 15.00002f eine Variable reinschreiben. Was muss ich tun?
Ich verstehe das leider nicht.
 
wenn du die zahlen in ein Array Packst kannst du die ausgabe auch über eine schleife machen
for( int i =0; i <...){
System.out.println( String.format( vorgabe, i+1, xzahl[ i], i+1, yzahl[ i]));
}
 

Neue Themen


Zurück
Oben