Tips on how to Remedy a Pandigital Sequence in Java

The problem

In arithmetic, a pandigital quantity is a quantity that in a given base has amongst its important 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 think about 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 constructive 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 (unfavorable, zero or constructive quantity) (lengthy in Java)
• The dimensions is a constructive 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

Choice 1:

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

public class Pandigital {
    public static lengthy[] getSequence(last lengthy offset, last 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;
    }
}

Choice 2:

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

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

    public static lengthy[] getSequence(last lengthy offset, last 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(last lengthy offset, last 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> record = new ArrayList<>();
        if (offset < 1023456789L) x = 1023456789L;
        for (lengthy i = x; record.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") ) record.add(i);
        }
        lengthy[] res = new lengthy[list.size()];
        for (int i = 0; i < record.measurement(); i++) {
            res[i] = record.get(i);
        }
        return res;
    }

}

Check instances to validate our answer

import org.junit.Check;
import static org.junit.Assert.assertArrayEquals;

public class ExampleTests {

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

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

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

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

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

}