project euler 37

Problem 37

---

Truncatable primes

The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.

Find the sum of the only eleven primes that are both truncatable from left to right and right to left.

NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.

---

可截素数

3797有着奇特的性质。不仅它本身是一个素数，而且如果从左往右逐一截去数字，剩下的仍然都是素数：3797、797、97和7；同样地，如果从右往左逐一截去数字，剩下的也依然都是素数：3797、379、37和3。

只有11个素数，无论从左往右还是从右往左逐一截去数字，剩下的仍然都是素数，求这些数的和。

注意：2、3、5和7不被视为可截素数。

@Test
	public void test() {

		CalTruncatablePrime truncateUtilLeft = new CalTruncatablePrime();
		truncateUtilLeft.iterSet(new HashSet<Long>( truncateUtilLeft.getTruncatePrimes()),
				TRUNCATE_DIR.LEFT);

		
		System.out.println(truncateUtilLeft.getTruncatePrimes());
		System.out.println(truncateUtilLeft.getTruncatePrimes().size());
		
		CalTruncatablePrime truncateUtilRt = new CalTruncatablePrime();
		truncateUtilRt.iterSet(new HashSet<Long>( truncateUtilRt.getTruncatePrimes()),
				TRUNCATE_DIR.RIGHT);

		
		System.out.println(truncateUtilRt.getTruncatePrimes());
		System.out.println(truncateUtilRt.getTruncatePrimes().size());
		
		long sum = 0;
		for(Long val : truncateUtilLeft.getTruncatePrimes()){
			if( truncateUtilRt.getTruncatePrimes().contains(val)){
				System.err.println(val);
				sum += val;
			}
		}
		
		System.out.println("sum=" + (sum - 2 - 3 - 5 - 7));
	}


	public static enum TRUNCATE_DIR {
		LEFT, RIGHT
	}

	public static class CalTruncatablePrime {

		private Set<Long> truncatablePrimes = new HashSet<Long>();

		public CalTruncatablePrime() {
			truncatablePrimes.add(2L);
			truncatablePrimes.add(3L);
			truncatablePrimes.add(5L);
			truncatablePrimes.add(7L);
		}

		public Set<Long> getTruncatePrimes() {
			return truncatablePrimes;
		}

		public void iterSet(Set<Long> candidates, TRUNCATE_DIR direction) {

			if (candidates == null || candidates.size() < 1) {
				return;
			}

			Set<Long> newCandidates = new HashSet<Long>();

			for (Long val : candidates) {

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

					int bit = val.toString().length();
					long newVal = val;

					if (direction.equals(TRUNCATE_DIR.LEFT)) {
						newVal += Math.pow(10, bit) * i;
					} else {
						newVal = newVal * 10 + i;
					}
					if (isPrime(newVal)) {
						newCandidates.add(newVal);
						System.out.println(newVal);
						truncatablePrimes.add(newVal);
					}
				}

			}

			if (newCandidates.size() < 1) {
				return;
			}

			iterSet(newCandidates, direction);

		}

		private boolean isPrime(long val) {
			long num = Math.abs(val);

			if (num <= 10) {
				if (num == 2 || num == 3 || num == 5 || num == 7) {
					return true;
				}
				return false;
			} else {

				for (int i = 2; i <= Math.sqrt(num); i++) {
					if (num % i == 0) {
						return false;
					}
				}

				return true;
			}

		}
	}