Deberá generar el primo más pequeño con ndígitos, y solo contendrá los dígitos especificados en la lista k.

Ejemplos:

Entrada:

4
1 2

Para esto, debe generar el primo más pequeño con 4dígitos, y ese primo solo debe contener los dígitos 1y 2.

Salida:

2111

Entrada:

10
0 4 7 

Salida:

4000000007

Entrada:

6
5 5 5 5 5 5 5 5 5 5 1 5 5 5 5 5 5 5 5 5 5

Salida:

115151

Puede garantizar que la entrada siempre estará en el formato que especifique, y puede hacer cualquier cosa si obtiene una entrada no válida (como que la entrada sea de un solo dígito n, sin k).

Si no existe tal solución para una entrada, su programa puede hacer lo siguiente:

• Impresión banana
• Lanzar un error
• Corre por siempre
• Algo más

Como se trata de código de golf , intente apuntar al código más corto.

La entrada puede estar en cualquier formato que especifique. Por ejemplo, si desea que su entrada sea como cualquiera de los siguientes, está bien.

4
[1, 2]

[1,2]4

1,2
4

4 12

Puede escribir un programa o una función, y debe devolver el valor correcto o imprimirlo.

El espacio en blanco está permitido en cualquier lugar.

^{Este desafío inspirado en A036229 .}

Brachylog (2), 8 bytes

j₍oᵐ∋ᵐcṗ

Pruébalo en línea!

Muy lento en problemas que tienen muchos dígitos posibles, o que contienen un 0 en el conjunto de dígitos posibles ( funciona en este caso; es solo que es mucho más lento que TIO agota el tiempo de espera a menos que el problema sea muy simple). Como es habitual en Brachylog, esta es una función, no un programa completo.

La entrada se toma en el formato [ndigits,[list of digits]], por ejemplo [10,[[0,4,7]]].

Explicación

j₍oᵐ∋ᵐcṗ
j₍        Make a number of copies of the second element equal to the first element
  oᵐ      Sort each (ᵐ) of those copies (evaluation order hint)
    ∋ᵐ    Take one element from each of those copies
      c   Concatenate those elements to form an integer (asserts no leading 0)
       ṗ  producing a prime number

Visto desde el punto de vista puramente declarativo, esto dice "encontrar un número primo, con el número dado de dígitos, donde todos los dígitos son uno de los dígitos dados". Para encontrar el número más pequeño , utilizamos sugerencias de orden de evaluación para asegurarnos de que el orden en el que probamos los números sea menor a mayor; en este caso, las ᵐdecisiones cerca del comienzo de la lista son menos propensas a cambiar que las decisiones cerca del final (este es su orden natural, que es el mismo que el orden lexicográfico y, por lo tanto, el número en los enteros), y por lo tanto {o∋}ᵐtiene dos órdenes de evaluación consejos "varían los últimos dígitos primeros" (del ᵐorden natural 's) como el indicio más importante, y 'los dígitos de verificación más pequeños antes de dígitos más grandes'(de la oantes de la∋, que actúa como una pista en este contexto) como el desempate. {o∋}ᵐse puede escribir como el equivalente oᵐ∋ᵐpara guardar un byte.

Paquete Bash + bsd-games, 28 bytes

• 18 bytes guardados gracias a @Dennis.

primes 1|egrep -wm1 [$2]{$1}

Entrada dada en la línea de comando como n seguido de k como una lista no delimitada de dígitos.

Pruébalo en línea.

Python 2 , 66 bytes

f=lambda n,s,k=1,p=1:10**~-n<p%k*k<s>=set(`k`)or-~f(n,s,k+1,p*k*k)

Pruébalo en línea!

Toma entrada como f(3,{'9','3','8'}).

Python no tiene funciones integradas para los números primos, por lo que la función los genera utilizando el Teorema de Wilson para verificar a su vez que cada valor potencial ksea ​​primo.

La desigualdad encadenada 10**~-n<p%k*k<s>=set(`k`)combina tres condiciones en k:

• 10**~-n<k: kcontiene al menos ndígitos. No necesitamos verificar exactamente ya que si alcanzamos más dígitos, no debe haber solución
• p%k>0: kes primo, a través de la condición del teorema de Wilson con p=(n-1)!^2. Como p%kes 0 o 1, esto se puede combinar con la condición anterior como10**~-n<p%k*k
• s>=set(`k`): Todos los dígitos kestán en el conjunto s. Esto se puede empalmar porque Python 2 considera los conjuntos como más grandes que los números.

Si la corriente kno satisface todo esto, la función se repite k+1y agrega 1 a la salida resultante. Como la salida termina con lo Trueque es igual 1, y kcomienza en 1, la salida es k. Este seguimiento paralelo de klatidos que salen kdirectamente en caso de éxito.

JavaScript (ES7), 100 bytes

Toma la entrada como número de dígitos ny cadena de dígitos permitidos sen la sintaxis de curry (n)(s). Devuelve undefinedsi no se encuentra una solución.

Funciona bastante rápido para hasta 6 dígitos, podría funcionar para 7 y definitivamente demasiado lento, y con mucha memoria, más allá de eso.

n=>s=>(a=[...Array(10**n).keys()]).find(i=>eval(`/[${s}]{${n}}/`).test(i)&&a.every(j=>j<2|j==i|i%j))

Prueba

let f =

n=>s=>(a=[...Array(10**n).keys()]).find(i=>eval(`/[${s}]{${n}}/`).test(i)&&a.every(j=>j<2|j==i|i%j))
                                        
console.log(f(5)("247")) // 22247

Jalea , 12 bytes

DL×ÆP
ṗḌÇÐṀṂ

Toma un conjunto y un entero como argumentos de línea de comandos. Imprime 0 si no existe una solución.

Pruébalo en línea!

Cómo funciona

ṗḌÇÐṀṂ  Main link. Left argument: A (digit set/array). Right argument: n (integer)

ṗ       Cartesian power; yield all arrays of length n that consist only of elements
        of the array A.
 Ḍ      Undecimal; convert all generated digit arrays to integers.
  ÇÐṀ   Keep only elements for which the helper link returns a maximal result.
     Ṃ  Take the minimum.


DL×ÆP   Helper link. Argument: k (integer)

D       Decimal; convert k into the array of its base 10 digits.
 L      Take the length.
   ÆP   Test if k is a prime number. Yields 1 or 0.
  ×     Multiply the length and the Boolean.

Pyke, 18 16 bytes

j;~p#`ljqi`Q-!)h

Pruébalo aquí!

Se ejecuta para siempre si no se encuentran valores

Mathematica, 64 bytes

FirstCase[Tuples@##,x:{f_,___}/;f>0&&PrimeQ[y=FromDigits@x]:>y]&

Función pura donde el primer argumento es la lista (ordenada) de dígitos permitidos y el segundo argumento es la longitud permitida. Tuples@##calcula todas las listas de los dígitos permitidos de la longitud permitida, luego encontramos los FirstCaseque coinciden de manera x:{f_,___}tal que el primer dígito fno lo es 0y el entero y=FromDigits@xes primo y lo reemplaza por y.

Brachylog , 15 bytes

tL∧?h~lṗ.dẹp⊆L∧

Pruébalo en línea!

Esto es bastante lento.

Explicación

tL                Input = [H, L]
  ∧
   ?h~l .         The Output is a variable of length H
       ṗ.         The Output is a prime number
          ẹ       The Output's digits...
        .d        ...when removing duplicate digits...
           p      ...is a permutation...
            ⊆L    ...of an ordered subset of L
              ∧

JavaScript (ES6), 86 bytes

Toma información a través de la sintaxis de curry, por ejemplo, (4)('12')

n=>(d,F=(i,P=j=>i%--j?P(j):1==j)=>P(i)&&`${i}`.match(`^[${d}]{${n}}$`)?i:F(i+1))=>F(2)

'use strict';

const G=n=>(d,F=(i,P=j=>i%--j?P(j):1==j)=>P(i)&&`${i}`.match(`^[${d}]{${n}}$`)?i:F(i+1))=>F(2)

const submit = () => {
  console.clear();
  console.log(G(+n.value)(d.value));
}

button.onclick = submit;
submit();

<input id="n" type="number" min="1" value="4" />
<input id="d" type="text" value="12" />
<button id="button">Submit</button>

Para ejecutarse en modo estricto (para la optimización de llamada de cola [TCO] ). Si su entorno no admite TCO, se producirá un error de desbordamiento de la pila para primos más grandes que la pila de entornos.

Para entradas no válidas se ejecutará para siempre.

Nota:

• Los usuarios de Chrome (> = 51) pueden acceder chrome://flags/#enable-javascript-harmonyy habilitar este indicador para ejecutar el fragmento anterior con soporte de TCO.
• Safari (> = 10) admite TCO

MATL, 17 bytes

wlwX"1GXNUStZp)l)

Esta función acepta dos entradas, un número entero que especifica el número de dígitos y una matriz de caracteres que indica los posibles valores. En el caso de no primos, se muestra un error.

Pruébalo en línea!

Explicación

        % Implicitly grab two inputs. First as an integer (N), second as a string (OPTS)
w       % Reverse the order of the inputs
l       % Push the literal 1 to the stack
w       % Pull N back to the top of the stack
X"      % Repeat OPTS N times 
1G      % Explicitly grab N again
XN      % Get all N-character combinations of the repeated version of OPTS
U       % Convert each row from a string to a number
S       % Sort them in ascending order
tZp)    % Grab only those that are primes
l)      % Retrieve the first prime
        % Implicitly print the result

Pyth - 13 12 bytes

f&P_T!-Tz^Tt

Test Suite .

Sabio, 62 bytes

lambda l,d:[p for p in primes(10^(l-1),10^l)if set(`p`)<=d][0]

Toma entrada del formulario: f( 4 , {'1','2'} )

Perl 6 , 43 bytes

->\n,@k {first *.is-prime&/^@k**{n}$/,^∞}

Se ejecuta para siempre si no existe una solución.

05AB1E , 17 bytes

[¾Øмg¹QiS²Kg0Qiq

Pruébalo en línea!

[¾Ø ¼             # Infinite loop over all primes
   Ð              # Push two extra copies on the stack
     g¹Qi         # If the length of this prime == the first input...
         S²K      # Push this prime without any of the digits in the second input
            g0Qi  # If the length of what remains is 0...
                q # quit
                  # implicitly print this prime

05AB1E , 22 19 18 bytes (-1 @Riley)

[NØ©S¹Kg0Q®g²Q&i®q

Pruébalo en línea!

[                   # infinite loop.
 NØ©                # push nth prime.
    S¹Kg0Q          # see if, without banned digits, it's 0 length.
          ®g²Q&     # see if, it is originally also the length specified.
               i®q  # if true, print result and exit.

Perl5, 77 bytes

($n,$d)=@ARGV;/^[$d]{$n}$/&&("x"x$_)!~/^(..+?)\1+$/&&print&&die for 2..10**$n

Corre así:

perl -le '($n,$d)=@ARGV;/^[$d]{$n}$/&&("x"x$_)!~/^(..+?)\1+$/&&print&&die for 2..10**$n' 4 12

Ruby, 77 76 bytes

->n,l{(10**~-n..10**n).find{|n|(2...n).none?{|x|n%x<1}&&!n.to_s[/[^#{l}]/]}}

Formato de entrada: un número y una cadena.

Ejemplo:

->n,l{...see above...} [6,"555555555515555555555"]
=> 115151

Perl 6 , 68 bytes

->\n,\k{first {.is-prime&&/.**{n}/},+«[X~] 0,|(k.unique.sort xx n)}

Intentalo

Devoluciones Nil si no se puede encontrar tal primo.

Expandido:

->
  \n, # number of digits
  \k  # list of digits
{

  first

    {
        .is-prime
      &&
        / . ** {n} / # exactly ｢n｣ digits ( in case ｢k｣ has a 0 )
    },

    +«\          # turn the following into a list of numbers

    [X[~]]       # cross the following with &infix:<~>

    0,           # append a 0 in case ｢n｣ was 1
    |(           # slip this list in (flatten)

        k        # the input list of possible digits
        .unique  # only one of each to reduce the search space (optional)
        .sort    # sort it so that the cross meta op returns them sorted

      xx         # list repeat

        n        # ｢n｣ times
    )
}

Python 2 + primefac , 91 85 bytes

import primefac as P
n,k=input()
p=10**~-n
while set(`p`)!=k:p=P.nextprime(p)
print p

Pruébalo en línea

La entrada es como 4,{'1','2'}.

PHP, 82 bytes

for($n=10**--$argv[1];$i-1||a&trim($n,$argv[2]);)for($i=++$n;--$i&&$n%$i;);echo$n;

Toma un número y una cadena de dígitos de los argumentos de la línea de comandos. Corre con -nr.

Descompostura

for($n=10**--$argv[1];  // $n = smallest number with (argument1) digits
    $i-1||                  // loop while $n is not prime or
    a&trim($n,$argv[2]);    // $n without all digits from (argument2) is not empty
)
    for($i=++$n;--$i&&$n%$i;);  // $i=largest divisor of $n smaller than $n (1 for primes)
echo$n;                 // print

Java 7, 139 141 bytes

long c(int a,String b){for(long n=2,i,x;;n++){for(x=n,i=2;i<x;x=x%i++<1?0:x);if(x>1&(n+"").length()==a&(n+"").matches("["+b+"]+"))return n;}}

+2 bytes al admitir números superiores a 32 bits (cambiado inta long)

Formato de entrada: un entero (es decir 4) y una cadena (es decir"12" )

Explicación:

long c(int a, String b){                  // Method with the two input parameters specified above
  for(long n = 2, i, x; ; n++){           // Loop from 2 going upwards
    for(x = n, i = 2; i < x; x = x % i++ < 1 ? 0 : x);  // Prime check for `n` 
    if (x > 1                             // if `n` is a prime (if `x` > 1 after the loop above it means `n` is a prime)
         & (n+"").length() == a           // AND if `n` has a length equal to the input integer
         & (n+"").matches("["+b+"]+")){   // AND if `n` only contains the specified digits of the input String (using a regex)
      return n;                           // Then we have our answer
    }
  }                                       // If no answer is available for the given input, it continues looping
}

Código de prueba:

Pruébalo aquí
NOTA: El segundo caso de prueba está deshabilitado porque se repite durante mucho tiempo.

class M{
  static long c(int a,String b){for(long n=2,i,x;;n++){for(x=n,i=2;i<x;x=x%i++<1?0:x);if(x>1&(n+"").length()==a&(n+"").matches("["+b+"]+"))return n;}}

  public static void main(String[] a){
    System.out.println(c(4, "12"));
    //System.out.println(c(10, "047"));
    System.out.println(c(6, "555555555515555555555"));
  }
}

Salida:

2111
115151