逆FizzBuzz問題を考えてみました。

InverseFizzBuzz.java

package satomaru.quiz;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 逆FizzBuzz問題を考えてみました。
 */
public class InverseFizzBuzz {

	public enum Elements {
		FIZZ(3),
		BUZZ(5),
		FIZZBUZZ(15);

		public static final List<Elements> VALUES = Arrays.asList(values());

		public static final Comparator<Elements> FACTOR_COMPARATOR =
				(e1, e2) -> e1.getFactor().compareTo(e2.getFactor());

		public static Optional<Elements> match(int value) {
			return VALUES.stream().filter(e -> e.isTarget(value)).max(FACTOR_COMPARATOR);
		}

		private final Integer factor;

		private Elements(Integer factor) {
			this.factor = factor;
		}

		public Integer getFactor() {
			return factor;
		}

		public boolean isTarget(int value) {
			return (value % factor) == 0;
		}
	}

	private static final int LIMIT = 100;

	private static final Comparator<Object[]> LENGTH_COMPARATOR =
			(e1, e2) -> Integer.valueOf(e1.length).compareTo(e2.length);

	public Optional<Integer[]> resolve(Elements... elements) {
		switch (elements.length) {
		case 0: return Optional.empty();
		case 1: return Optional.of(new Integer[] { elements[0].getFactor() });
		}

		int firstFactor = elements[0].getFactor();
		Stream.Builder<Integer[]> results = Stream.builder();

		for (int i = firstFactor; i <= LIMIT; i += firstFactor) {
			int index = 1;

			for (int j = i + 1; j <= LIMIT; j++) {
				Optional<Elements> element = Elements.match(j);

				if (!element.isPresent()) {
					continue;
				}

				if (!element.get().equals(elements[index])) {
					break;
				}

				++index;

				if (index == elements.length) {
					Integer[] result = IntStream.rangeClosed(i, j).boxed().toArray(Integer[]::new);

					if (result.length == elements.length) {
						return Optional.of(result);
					}

					results.accept(result);
					break;
				}
			}
		}

		return results.build().min(LENGTH_COMPARATOR);
	}
}

InverseFizzBuzzTest.java

package satomaru.quiz;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

import satomaru.quiz.InverseFizzBuzz.Elements;

public class InverseFizzBuzzTest {

	private InverseFizzBuzz tested;

	@Before
	public void setUp() {
		tested = new InverseFizzBuzz();
	}

	@Test
	public void testA() {
		assertArrayEquals(
				new Integer[] { 3 },
				tested.resolve(Elements.FIZZ).get()
		);
	}

	@Test
	public void testB() {
		assertArrayEquals(
				new Integer[] { 5 },
				tested.resolve(Elements.BUZZ).get()
		);
	}

	@Test
	public void testC() {
		assertArrayEquals(
				new Integer[] { 9, 10 },
				tested.resolve(Elements.FIZZ, Elements.BUZZ).get()
		);
	}

	@Test
	public void testD() {
		assertArrayEquals(
				new Integer[] { 5, 6 },
				tested.resolve(Elements.BUZZ, Elements.FIZZ).get()
		);
	}

	@Test
	public void testE() {
		assertArrayEquals(
				new Integer[] { 3, 4, 5, 6 },
				tested.resolve(Elements.FIZZ, Elements.BUZZ, Elements.FIZZ).get()
		);
	}

	@Test
	public void testF() {
		assertArrayEquals(
				new Integer[] { 6, 7, 8, 9 },
				tested.resolve(Elements.FIZZ, Elements.FIZZ).get()
		);
	}

	@Test
	public void testG() {
		assertArrayEquals(
				new Integer[] { 6, 7, 8, 9, 10 },
				tested.resolve(Elements.FIZZ, Elements.FIZZ, Elements.BUZZ).get()
		);
	}
}