Variablen in formatierter Ausgabe

[erikafuchs]

Hallo Leute,
ich bin absoluter Anfänger und habe schon eine schwierige Frage:
Ich möchte die Dezimalstellen einer Kommazahl mit einer Zufallszahl festlegen. Ich kenne jetzt "printf("|%.2",zahl)" und möchte die "2" durch eine Variable z ersetzen, die als Zufallszahl erzeugt wird.
Geht das?
Pit

 

[VfL_Freak]

Moin,
IMHO nicht! Ich denke, dass das der Compiler zur Compilezeit wissen muss!
Aber erläuter mal, was Du da überhaupt vorhast. Klingt mit verlaub ein bisschen abstrus
VG Klaus

 

[mrBrown]

IMHO nicht! Ich denke, dass das der Compiler zur Compilezeit wissen muss!

Wie kommst du denn darauf?

 

[erikafuchs]

Also denn:
Ich habe für meine Schüler ein Programm geschrieben, mit dem man nahezu alle Gebiete der Mathematik bis Klasse 10 üben kann. (wen es interessiert). Die Aufgaben werden alle mit Zufallszahlen erzeugt. Das ganze ist ein wirklich riesiges Makro in OpenOffice Calc. Meine Schüler wollen das als App, jetzt bin ich in Pension und habe das entsprechende Projekt hiermit gestartet.
Was die Schüler, aus welchen Gründen auch immer, nicht können, ist Runden. Also brauche ich zufällig erzeugte Dezimalzahlen die auf Hunderter, Zehner, Ganze, Zehntel, Hunderstel ... gerundet werden müssen.
Falls das nicht wie gewünscht geht, muss ich halt mehrere Zeilen mit select (?) schreiben.

 

[fhoffmann]

So etwas vielleicht:

public class Test {
    public static void main(String[] args) {
        int anzahlStellen = 7; // Zufallszahl
        int zahl = 123;
        String format = "%0" + anzahlStellen + "d\n";
        System.out.printf(format, zahl);
    }
}

 

[erikafuchs]

Prima, danke!
So geht es auch mit Kommazahlen:

public class runden3 {
    
    public static void main(String[] args) {
        double zufall = Math.random()*5;
        int anzahlStellen = (int) zufall; // Zufallszahl
        System.out.println(anzahlStellen);
        double zahl = 123.456789;
        String format = "%." + anzahlStellen + "f";
        System.out.printf(format, zahl);
    }
}

 

[mihe7]

So geht es auch mit Kommazahlen:

Zwei Dinge:

1. double sind binäre Fließkommazahlen, da gelten eigene Regeln:

public class Test {
    public static void main(String[] args) {
        vergleiche(0.3, 0.3);
        double zahl = 0.1 * 3;
        vergleiche(zahl, 0.3);
     }

     static void vergleiche(double d1, double d2) {
        if (d1 == d2) {
            System.out.printf("%f ist gleich %f\n", d1, d2);
        } else {
            System.out.printf("%f ist nicht gleich %f\n", d1, d2);
        }
     }
}

2. Die Ausgabe mit %f rundet auf 6 Stellen, wenn keine Stellenzahl angegeben wird.

 

[erikafuchs]

Das Genauigkeitsproblem von Fließkommazahlen ist mir schon (wenigstens wage) bewußt - welche Möglichkeit gibt es denn sonst? Festkommazahlen gibt es ja eher nicht.

 

[mihe7]

Beim Runden besteht das Problem ja nur in der Ausgabe der nicht gerundeten Zahl (wenn diese bereits durch die Ausgabe gerundet wird, führt das Runden einer gerundeten Zahl ggf. zu einem anderen Ergebnis).

Mir ging es um die allgemeine Problematik der Genauigkeit, die in vielen Fällen zwar nicht gegeben ist, aber gerade bei Vergleichen eine Rolle spielt und ggf. Rechentrainern vermutlich nicht unberücksichtigt werden darf.

Für Bruchrechnungen eignen sich z. B. eigens hierfür geschriebene Klassen, die tatsächlich einen Bruch mit Zähler und Nenner darstellen.

Festkommazahlen gibt es ja eher nicht.

Festkomma: https://docs.oracle.com/javase/8/docs/api/java/math/BigDecimal.html

 

[Xyz1]

import java.math.BigDecimal;
import java.util.Random;

public class Runden {
	String runde() {
		return runde(new Random().nextDouble());
	}

	String runde(double d) {
		return runde(d, new Random().nextInt(10));
	}

	String runde(double d, int stellen) {
		BigDecimal d2 = BigDecimal.valueOf(d);
		d2 = d2.setScale(stellen, BigDecimal.ROUND_HALF_UP);
		return d2.toString();
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			System.out.println(new Runden().runde());
		}
	}
}

 

[erikafuchs]

Danke, da muss ich mich erstmal reinarbeiten.
... wie gesagt, ich bin blutiger Anfänger.

Für Bruchrechnungen eignen sich z. B. eigens hierfür geschriebene Klassen, die tatsächlich einen Bruch mit Zähler und Nenner darstellen.

auch ein guter Hinweis, die Brüche haben mir in meinem "Rechentrainer" viel Arbeit gemacht.

 

[Xyz1]

Mir war gerad langweilig:

import java.math.BigDecimal;

public class B {
	long z, n;

	/*
	 * ?
	 */
	B(double d) {
		BigDecimal d2 = BigDecimal.valueOf(d);
		int s = d2.scale();
		z = d2.movePointRight(s).longValue();
		n = BigDecimal.ONE.movePointRight(s).longValue();
	}

	/*
	 * (z/n) must be lower than one.
	 */
	B(long z, long n) {
		this.z = z;
		this.n = n;
	}

	B add(B b) {
		long c = Math.abs(n), d = Math.abs(b.n);
		while (c > 0 && d > 0) {
			if (c > d)
				c = c % d;
			else
				d = d % c;
		}
		long ggt = c + d;

		if (n < b.n) {
			return new B(z * ggt + b.z, b.n);
		} else {
			return new B(z + b.z * ggt, n);
		}
	}

	B su(B b) {
		long c = Math.abs(n), d = Math.abs(b.n);
		while (c > 0 && d > 0) {
			if (c > d)
				c = c % d;
			else
				d = d % c;
		}
		long ggt = c + d;

		if (n < b.n) {
			return new B(z * ggt - b.z, b.n);
		} else {
			return new B(z - b.z * ggt, n);
		}
	}

	B mul(B b) {
		return new B(z * b.z, n * b.n);
	}

	B div(B b) {
		long c = Math.abs(n), d = Math.abs(b.n);
		while (c > 0 && d > 0) {
			if (c > d)
				c = c % d;
			else
				d = d % c;
		}
		long ggt = c + d;

		if (n < b.n) {
			return new B(z * ggt * b.z, b.n);
		} else {
			return new B(z * b.z * ggt, n);
		}
	}

	@Override
	public String toString() {
		BigDecimal d2 = BigDecimal.valueOf(z);
		d2 = d2.divide(BigDecimal.valueOf(n));
		d2 = d2.setScale(5, BigDecimal.ROUND_HALF_UP);
		return d2.toString();
	}

	public static void main(String[] args) {
		System.out.println(new B(1, 2).add(new B(1, 4)).su(new B(1, 2)).mul(new B(1, 8)).div(new B(1, 16)));
	}
}

Allerdings müssen die Brüche alle kleiner 1 sein.
Und der "geklaute" Konstruktor (B(double d) {) stimmt noch nich.

 

[mihe7]

Auf Deutsch:

class Bruch {
    int zaehler;
    int nenner;

    public Bruch(int zaehler, int nenner) {
        if (nenner == 0) {
            throw new ArithmeticException("Nenner darf nicht 0 sein");
        }
        this.zaehler = nenner < 0 ? -zaehler : zaehler;
        this.nenner = nenner < 0 ? -nenner : nenner;
        kuerzen();
    }

    public Bruch negiert() {
        return new Bruch(-zaehler, nenner);
    }

    public Bruch kehrwert() {
        return new Bruch(nenner, zaehler);
    }

    public Bruch addiere(Bruch b) {
        return new Bruch(zaehler * b.nenner + nenner * b.zaehler,
                         nenner * b.nenner);
    }

    public Bruch subtrahiere(Bruch b) {
        return addiere(b.negiert());
    }

    public Bruch multipliziere(Bruch b) {
        return new Bruch(zaehler * b.zaehler, nenner * b.nenner);
    }

    public Bruch dividiere(Bruch b) {
        return multipliziere(b.kehrwert());
    }

    private void kuerzen() {
        int ggt = Bruch.ggT(zaehler, nenner);
        zaehler /= ggt;
        nenner /= ggt;
    }
        
    public static int ggT(int a, int b) {
        a = Math.abs(a);
        b = Math.abs(b);

        while (b != 0) {
            int h = a % b;
            a = b;
            b = h;
        }
        return a;
    } 

    @Override
    public boolean equals(Object o) {
        if (o == null || o == this || !(o instanceof Bruch)) {
            return o == this;
        }

        Bruch b = (Bruch) o;
        return zaehler == b.zaehler && nenner == b.nenner;
    }

    @Override
    public int hashCode() {
        return 5*zaehler + 13*nenner;
    }

    @Override
    public String toString() {
        return "(" + zaehler + "/" + nenner + ")";
    }

    public static void main(String[] args) {
        System.out.println(new Bruch(1, 2)
                .addiere(new Bruch(1, 4))
                .subtrahiere(new Bruch(1, 2))
                .multipliziere(new Bruch(1, 8))
                .dividiere(new Bruch(1, 16)));
    }
}

 

[Xyz1]

mihe7, Das funktioniert immer noch nich...

	/*
	 *
	 */
	B(long z, long n) {
		this.z = n < 0 ? -z : z;
		this.n = n < 0 ? -n : n;
	}

Sobald (z/n) größer-gleich 1 ist, zum Beispiel bei new B(2, 1), dann kommt da etwas ganz Merkwürdiges raus....

 

[mihe7]

return new B(z * ggt + b.z, b.n);

Hm... bei 1/4 + 5/6 dürfte ggt = 2 sein, d. h. bei Dir käme (1*2 + 5)/6 = 7/6 raus.

Richtig wäre aber 6/24 + 20/24 = 26/24 = 13/12...

 

[Xyz1]

Ich glaub das ist alles falsch