Cómo resolver una secuencia pandigital en Java

El reto

En matemáticas, un número pandigital es un número que en una base dada tiene entre sus dígitos significativos cada dígito usado en la base al menos una vez. Por ejemplo, 1234567890 es un número pandigital en base 10.

Para simplificar, en este desafío, consideraremos números pandigitales en base 10 y con todos los dígitos utilizados Exactamente una vez. El desafío es calcular una secuencia ordenada de números pandigitales, comenzando en un cierto offset y con un determinado measurement.

Ejemplo:

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

Normas:

• Estamos buscando números pandigitales positivos en base 10.
• Cada dígito debe ocurrir precisely as soon as.
• Un número pandigital no puede comenzar con el dígito cero.
• El desplazamiento es un número entero (número negativo, cero o positivo) (largo en Java)
• El tamaño es un número entero positivo (int en Java)
• Devuelve el measurement números pandigitales que no son más pequeños que el offset. si no hay suficiente measurement números pandigitales, simplemente devuélvalos todos.
• Devuelve una matriz vacía si no se encuentra nada.

La solución en código Java

Opción 1:

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

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

Opcion 2:

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

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

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

Opción 3:

import java.util.ArrayList;

public class Pandigital {

    public static lengthy() getSequence(closing lengthy offset, closing 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.accommodates("0")
                    && s.accommodates("1") && s.accommodates("2")
                    && s.accommodates("3") && s.accommodates("4")
                    && s.accommodates("5") && s.accommodates("6")
                    && s.accommodates("7") && s.accommodates("8")
                    && s.accommodates("9") ) record.add(i);
        }
        lengthy() res = new lengthy(record.measurement());
        for (int i = 0; i < record.measurement(); i++) {
            res(i) = record.get(i);
        }
        return res;
    }

}

Casos de prueba para validar nuestra solución

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);
    }

}