Question

问题很容易理解，但对于我的生活，我无法弄清楚如何实施它：

如何从小数分数近似值得到实际分数（即两个整数）？例如给出0.666666666667，如何得到2/3 （使用一些定义的精度）？

我知道我可以将0.666666666667转换为666666666667/10000000 ...，我知道我可以使用GCD减少一小部分，但这些方法无法解决问题，因为6667/10000没有减少到2/3。

我想知道的是如何取一些小数，如0.6666667并说，“那可能是2/3”。

有什么想法吗？

我有一些代码可用于减少分数但是再次，不适用于上述任务：

public class Fraction implements Comparable<Fraction> {
    private static Map<Fraction, Long> gcdMemo = new HashMap<>();
    public final long n;
    public final long d;

    public Fraction(long n, long d) {
        this.n = n; this.d = d;
    }

    public Fraction multiply(Fraction f) {
        return new Fraction(f.n * this.n, f.d * this.d).reduced();
    }

    public Fraction subtract(Fraction f) {
        return this.add(new Fraction(-f.n, f.d));
    }

    public Fraction abs() {
        return new Fraction(Math.abs(n), Math.abs(d));
    }

    public Fraction add(Fraction f) {
        long newN0 = this.n * f.d;
        long newD0 = this.d * f.d;
        long newN1 = f.n * this.d;
        return new Fraction(newN0 + newN1, newD0).reduced();
    }

    public static long gcd(long a, long b) {
        if (gcdMemo.containsKey(new Fraction(a, b))) {
            return gcdMemo.get(new Fraction(a, b));
        }
        if(a == 0 || b == 0) return a + b; // base case
        long result = gcd(b, a % b);

        Fraction f = new Fraction(a, b);
        if (!gcdMemo.containsKey(f)) {
            gcdMemo.put(f, result);
        }
        return result;
    }

    public Fraction reduced() {
        long gcd = gcd(n, d);
        return new Fraction(n / gcd, d /gcd);
    }

    public int compareTo(Fraction f) { /*...*/ }
    public int hashCode() { /**/ }
    public boolean equals(Object obj) { /*...*/ }
    public String toString() { /*...*/ }

}

另外，我知道这是可能的，因为我的TI-84可以做到这一点：D

如何将.66667转换为2/3分数？

0 个答案: