## The challenge

In mathematics, a pandigital number is a number that in a given base has among its significant digits each digit used in the base at least once. For example, 1234567890 is a pandigital number in base 10.

For simplification, in this challenge, we will consider pandigital numbers in base 10 and with all digits used exactly once. The challenge is to calculate a sorted sequence of pandigital numbers, starting at a certain offset and with a specified size.

Example:

 Pandigital.getSequence(0, 5) // [1023456789, 1023456798, 1023456879, 1023456897, 1023456978]

Rules:

• We are looking for positive pandigital numbers in base 10.
• Each digit should occur exactly once.
• The offset is an integer (negative, zero or positive number) (long in Java)
• The size is a positive integer number (int in Java)
• Return the size pandigital numbers which are not smaller than the offset. If there is not enough size pandigital numbers, just return all of them.
• Return an empty array if nothing is found.

## The solution in Java code

Option 1:

 import java.util.Arrays; import java.util.stream.LongStream; public class Pandigital { public static long[] getSequence(final long offset, final int size) { long from=Math.max(offset,1023456789L); return LongStream.rangeClosed(from,9876543210L) .filter(n->n>=offset) .filter(Pandigital::isPandigital) .limit(size) .toArray(); } private static boolean isPandigital(long n){ return (""+n).chars().distinct().count()==10; } }

Option 2:

 import java.util.function.LongPredicate; import java.util.stream.LongStream; public class Pandigital { private static final long MIN_PANDIGITAL = 1023456789L; private static final long MAX_PANDIGITAL = 9876543210L; private static final LongPredicate isPandigital = l -> !String.valueOf(l).matches(".*(.).*?\\1.*"); public static long[] getSequence(final long offset, final int size) { return LongStream .iterate(Math.max(MIN_PANDIGITAL, offset), l -> l <= MAX_PANDIGITAL, l -> ++l) .filter(isPandigital) .limit(size) .toArray(); } }

Option3:

 import java.util.ArrayList; public class Pandigital { public static long[] getSequence(final long offset, final int size) { boolean b = true; for (int i = 0; i < String.valueOf(offset).length(); i++) { if (String.valueOf(offset).charAt(i) != '9') { b = false; break; } } if (b) return new long[] {}; long x = offset; ArrayList list = new ArrayList<>(); if (offset < 1023456789L) x = 1023456789L; for (long i = x; list.size() != size; i++) { String s = String.valueOf(i); if (!s.startsWith("0") && s.contains("0") && s.contains("1") && s.contains("2") && s.contains("3") && s.contains("4") && s.contains("5") && s.contains("6") && s.contains("7") && s.contains("8") && s.contains("9") ) list.add(i); } long[] res = new long[list.size()]; for (int i = 0; i < list.size(); i++) { res[i] = list.get(i); } return res; } }

## Test cases to validate our solution

 import org.junit.Test; import static org.junit.Assert.assertArrayEquals; public class ExampleTests { @Test public void simpleTest() { long[] subject = Pandigital.getSequence(0L, 5); long[] expected = {1023456789L, 1023456798L, 1023456879L, 1023456897L, 1023456978L}; assertArrayEquals(expected, subject); } @Test public void withPandigitalOffset() { long[] subject = Pandigital.getSequence(5432160879L, 3); long[] expected = {5432160879L, 5432160897L, 5432160978L}; assertArrayEquals(expected, subject); } @Test public void withNonPandigitalOffset() { long[] subject = Pandigital.getSequence(9876543000L, 5); long[] expected = {9876543012L, 9876543021L, 9876543102L, 9876543120L, 9876543201L}; assertArrayEquals(expected, subject); } @Test public void withTooBigOffset() { long[] subject = Pandigital.getSequence(9999999999L, 1); long[] expected = {}; assertArrayEquals(expected, subject); } @Test public void withNegativeOffset() { long[] subject = Pandigital.getSequence(-123456789L, 1); long[] expected = {1023456789L}; assertArrayEquals(expected, subject); } }