project euler 71

Problem 71

---

Ordered fractions

Consider the fraction, n/d, where n and d are positive integers. If n < d and HCF(n,d)=1, it is called a reduced proper fraction.

If we list the set of reduced proper fractions for d ≤ 8 in ascending order of size, we get:

1/8, 1/7, 1/6, 1/5, 1/4, 2/7, 1/3, 3/8,  2/5, 3/7, 1/2, 4/7, 3/5, 5/8, 2/3, 5/7, 3/4, 4/5, 5/6, 6/7, 7/8

It can be seen that 2/5 is the fraction immediately to the left of 3/7.

By listing the set of reduced proper fractions for d ≤ 1,000,000 in ascending order of size, find the numerator of the fraction immediately to the left of 3/7.

---

有序分数

考虑形如n/d的分数，其中n和d均为正整数。如果n < d且其最大公约数为1，则该分数称为最简真分数。

如果我们将d ≤ 8的最简真分数构成的集合按大小升序列出，我们得到：

1/8, 1/7, 1/6, 1/5, 1/4, 2/7, 1/3, 3/8,  2/5, 3/7, 1/2, 4/7, 3/5, 5/8, 2/3, 5/7, 3/4, 4/5, 5/6, 6/7, 7/8

可以看出2/5是3/7直接左邻的分数。

将所有d ≤ 1,000,000的最简真分数按大小升序排列，求此时3/7直接左邻的分数的分子。

package projecteuler;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

public class Prj71  extends TestCase{

	public static final int UP_LIMIT = 1000000;

	public Prj71(String name) {
		super(name);
	}

	public static Test suite() {
		TestSuite suite = new TestSuite(Prj71.class);
		suite.addTest(new Prj71("testOrderedFractionsUseFarey"));
		//suite.addTest(new Prj71("qtestOrderedFractions"));

		return suite;
	}

	/**
	 * http://mathworld.wolfram.com/FareySequence.html;
	 * http://www.docin.com/p-835313638.html
	 */
	public void testOrderedFractionsUseFarey() {
		List<ReducedProperFraction> start = new ArrayList<ReducedProperFraction>();
		start.add(new ReducedProperFraction(0, 1));
		start.add(new ReducedProperFraction(1, 1));

		ReducedProperFraction find = new ReducedProperFraction(3, 7);
		List<ReducedProperFraction> dataList = iter(start, find, 1);

		for (ReducedProperFraction rpf : dataList) {
			System.out.println(rpf);
		}
		int idx = dataList.indexOf(find);
		assert (idx > 1);
		ReducedProperFraction lf = dataList.get(idx - 1);

		while (true) {

			int nn = lf.n + find.n;
			int dd = lf.d + find.d;

			if (nn > UP_LIMIT || dd > UP_LIMIT) {
				break;
			} else {

				lf = new ReducedProperFraction(nn, dd);
			}

		}

		System.out.println(lf);

	}

	List<ReducedProperFraction> iter(List<ReducedProperFraction> dataList,
			ReducedProperFraction find, int level) {

		boolean flag = false;
		for (int i = 0; i < dataList.size(); i++) {
			ReducedProperFraction rpf = dataList.get(i);
			if (rpf.n == find.n && rpf.d == find.d) {
				flag = true;
				break;
			}
		}

		if (flag) {
			return dataList;
		} else {
			List<ReducedProperFraction> next = new ArrayList<ReducedProperFraction>();
			next.add(new ReducedProperFraction(0, 1));
			for (int i = 1; i < dataList.size(); i++) {
				ReducedProperFraction lf = dataList.get(i - 1);
				ReducedProperFraction rt = dataList.get(i);
				if (lf.d + rt.d > (level + 1) || lf.n + rt.n > (level + 1)) {

				} else {
					next.add(new ReducedProperFraction(lf.n + rt.n, lf.d + rt.d));
				}
				next.add(new ReducedProperFraction(rt.n, rt.d));
			}
			return iter(next, find, level + 1);
		}
	}

	/**
	 * out of memory
	 */
	public void qtestOrderedFractions() {

		int count = 0;

		List<ReducedProperFraction> dataList = new ArrayList<ReducedProperFraction>();
		for (int i = 2; i <= UP_LIMIT; i++) {
			for (int j = 1; j < i; j++) {
				if (gcd(i, j) == 1) {
					count++;
					if (count % 10000 == 0) {
						System.out.println("i=" + i + ",j=" + j + ",count="
								+ count);
					}
					dataList.add(new ReducedProperFraction(j, i));
				}
			}
		}

		Collections.sort(dataList);

		for (int i = 0; i < dataList.size(); i++) {
			System.out.println(i + dataList.get(i).toString());
		}

	}

	/**
	 * n/d
	 * 
	 * @author suc
	 *
	 */
	public static class ReducedProperFraction implements
			Comparable<ReducedProperFraction> {

		public int n;
		public int d;

		public ReducedProperFraction(int n, int d) {
			this.n = n;
			this.d = d;
		}

		@Override
		public int compareTo(ReducedProperFraction o) {

			if (n * o.d == d * o.n) {
				return 0;
			} else if (n * o.d < d * o.n) {
				return -1;
			}

			return 1;
		}

		@Override
		public String toString() {
			return "ReducedProperFraction [n=" + n + ", d=" + d + "]";
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + d;
			result = prime * result + n;
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			ReducedProperFraction other = (ReducedProperFraction) obj;
			if (d != other.d)
				return false;
			if (n != other.n)
				return false;
			return true;
		}
	}

	public int gcd(int m, int n) {

		int a = m;
		int b = n;
		if (m < n) {
			a = n;
			b = m;
		}

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

	}

}