The way to Clear up a Pandigital Sequence in Java

The problem

In arithmetic, a pandigital quantity is a quantity that in a given base has amongst its vital digits every digit used within the base not less than as soon as. For instance, 1234567890 is a pandigital quantity in base 10.

For simplification, on this problem, we are going to contemplate pandigital numbers in base 10 and with all digits used precisely as soon as. The problem is to calculate a sorted sequence of pandigital numbers, beginning at a sure offset and with a specified measurement.

Instance:

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

Guidelines:

• We’re searching for optimistic pandigital numbers in base 10.
• Every digit ought to happen precisely as soon as.
• A pandigital quantity can’t begin with digit zero.
• The offset is an integer (unfavourable, zero or optimistic quantity) (lengthy in Java)
• The dimensions is a optimistic integer quantity (int in Java)
• Return the measurement pandigital numbers which aren’t smaller than the offset. If there may be not sufficient measurement pandigital numbers, simply return all of them.
• Return an empty array if nothing is discovered.

The answer in Java code

Possibility 1:

import java.util.Arrays;
import java.util.stream.LongStream;

public class Pandigital {
    public static lengthy[] getSequence(remaining lengthy offset, remaining int measurement) {
        lengthy from=Math.max(offset,1023456789L);
        return LongStream.rangeClosed(from,9876543210L)
                .filter(n->n>=offset)
                .filter(Pandigital::isPandigital)
                .restrict(measurement)
                .toArray();
    }
    personal static boolean isPandigital(lengthy n){
        return (""+n).chars().distinct().rely()==10;
    }
}

Possibility 2:

import java.util.operate.LongPredicate;
import java.util.stream.LongStream;

public class Pandigital {
    personal static remaining lengthy MIN_PANDIGITAL = 1023456789L;
    personal static remaining lengthy MAX_PANDIGITAL = 9876543210L;
    
    personal static remaining LongPredicate isPandigital = l ->
            !String.valueOf(l).matches(".*(.).*?1.*");

    public static lengthy[] getSequence(remaining lengthy offset, remaining int measurement) {
        return LongStream
                .iterate(Math.max(MIN_PANDIGITAL, offset),
                        l -> l <= MAX_PANDIGITAL,
                        l -> ++l)
                .filter(isPandigital)
                .restrict(measurement)
                .toArray();
    }
}

Option3:

import java.util.ArrayList;

public class Pandigital {

    public static lengthy[] getSequence(remaining lengthy offset, remaining int measurement) {
     boolean b = true;
        for (int i = 0; i < String.valueOf(offset).size(); i++) {
            if (String.valueOf(offset).charAt(i) != '9') {
                b = false;
                break;
            }
        }
        if (b) return new lengthy[] {};
        lengthy x = offset;
        ArrayList<Lengthy> checklist = new ArrayList<>();
        if (offset < 1023456789L) x = 1023456789L;
        for (lengthy i = x; checklist.measurement() != measurement; i++) {
            String s = String.valueOf(i);
            if (!s.startsWith("0") && s.incorporates("0")
                    && s.incorporates("1") && s.incorporates("2")
                    && s.incorporates("3") && s.incorporates("4")
                    && s.incorporates("5") && s.incorporates("6")
                    && s.incorporates("7") && s.incorporates("8")
                    && s.incorporates("9") ) checklist.add(i);
        }
        lengthy[] res = new lengthy[list.size()];
        for (int i = 0; i < checklist.measurement(); i++) {
            res[i] = checklist.get(i);
        }
        return res;
    }

}

Take a look at circumstances to validate our answer

import org.junit.Take a look at;
import static org.junit.Assert.assertArrayEquals;

public class ExampleTests {

    @Take a look at
    public void simpleTest() {
        lengthy[] topic = Pandigital.getSequence(0L, 5);
        lengthy[] anticipated = {1023456789L, 1023456798L, 1023456879L, 1023456897L, 1023456978L};
        assertArrayEquals(anticipated, topic);
    }

    @Take a look at
    public void withPandigitalOffset() {
        lengthy[] topic = Pandigital.getSequence(5432160879L, 3);
        lengthy[] anticipated = {5432160879L, 5432160897L, 5432160978L};
        assertArrayEquals(anticipated, topic);
    }

    @Take a look at
    public void withNonPandigitalOffset() {
        lengthy[] topic = Pandigital.getSequence(9876543000L, 5);
        lengthy[] anticipated = {9876543012L, 9876543021L, 9876543102L, 9876543120L, 9876543201L};
        assertArrayEquals(anticipated, topic);
    }

    @Take a look at
    public void withTooBigOffset() {
        lengthy[] topic = Pandigital.getSequence(9999999999L, 1);
        lengthy[] anticipated = {};
        assertArrayEquals(anticipated, topic);
    }

    @Take a look at
    public void withNegativeOffset() {
        lengthy[] topic = Pandigital.getSequence(-123456789L, 1);
        lengthy[] anticipated = {1023456789L};
        assertArrayEquals(anticipated, topic);
    }

}