Easy methods 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 at the least 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 dimension.

Instance:

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

Guidelines:

• We’re on the lookout 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 (unfavourable, zero or constructive quantity) (lengthy in Java)
• The dimensions is a constructive integer quantity (int in Java)
• Return the dimension pandigital numbers which aren’t smaller than the offset. If there’s not sufficient dimension 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(ultimate lengthy offset, ultimate int dimension) {
        lengthy from=Math.max(offset,1023456789L);
        return LongStream.rangeClosed(from,9876543210L)
                .filter(n->n>=offset)
                .filter(Pandigital::isPandigital)
                .restrict(dimension)
                .toArray();
    }
    non-public static boolean isPandigital(lengthy n){
        return (""+n).chars().distinct().depend()==10;
    }
}

Possibility 2:

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

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

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

Option3:

import java.util.ArrayList;

public class Pandigital {

    public static lengthy[] getSequence(ultimate lengthy offset, ultimate int dimension) {
     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.dimension() != dimension; 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.dimension(); 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);
    }

}