Você precisará gerar o menor primo com ndígitos, e ele conterá apenas os dígitos especificados na lista k.

Exemplos:

Entrada:

4
1 2

Para isso, você deve gerar o menor primo com 4dígitos, e esse primo deve conter apenas os dígitos 1e 2.

Saída:

2111

Entrada:

10
0 4 7 

Saída:

4000000007

Entrada:

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

Saída:

115151

Você pode garantir que a entrada sempre esteja no formato especificado e poderá fazer qualquer coisa se receber uma entrada inválida (como a entrada sendo um dígito único n, sem k).

Se não existir essa solução para uma entrada, seu programa poderá fazer o seguinte:

• Impressão banana
• Lançar um erro
• Corra para sempre
• Algo mais

Como esse é o código-golfe , tente apontar para o código mais curto.

A entrada pode estar em qualquer formato que você especificar. Por exemplo, se você deseja que sua entrada seja como qualquer uma das seguintes, tudo bem.

4
[1, 2]

[1,2]4

1,2
4

4 12

Você pode escrever um programa ou uma função e ele deve retornar o valor correto ou imprimi-lo.

Espaço em branco é permitido em qualquer lugar.

^{Este desafio inspirado na A036229 .}

Braquilog (2), 8 bytes

j₍oᵐ∋ᵐcṗ

Experimente online!

Problemas muito lentos com muitos dígitos possíveis ou que contêm um 0 no conjunto de dígitos possíveis ( funciona nesse caso; é só que é muito mais lento que o TIO expira, a menos que o problema seja muito simples). Como de costume no Brachylog, essa é uma função, não um programa completo.

A entrada é obtida no formato [ndigits,[list of digits]], por exemplo [10,[[0,4,7]]].

Explicação

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 do ponto de vista puramente declarativo, isso diz "encontre um número primo, com o número especificado de dígitos, onde todos os dígitos são um dos dígitos fornecidos". Para encontrar o menor número, usamos sugestões de ordem de avaliação para garantir que a ordem em que testamos os números seja do menor para o maior; nesse caso, ᵐtoma decisões perto do início da lista menos propensas a alterações do que decisões perto do fim (essa é sua ordem natural, que é a mesma que ordem lexicográfica e, portanto, numérica em números inteiros) e, portanto, {o∋}ᵐtem duas ordens de avaliação dicas, "varie primeiro os últimos dígitos" (da ᵐordem natural da) como a dica mais importante e "verifique os dígitos menores antes dos dígitos maiores" (da oanterior à∋, que funciona como uma dica nesse contexto) como o desempate. {o∋}ᵐpode ser escrito como o equivalente oᵐ∋ᵐpara salvar um byte.

Pacote Bash + bsd-games, 28 bytes

• 18 bytes salvos graças a @Dennis.

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

Entrada fornecida na linha de comando como n seguida por k como uma lista de dígitos não delimitada.

Experimente online.

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)

Experimente online!

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

O Python não possui built-ins para números primos; portanto, a função os gera usando o Teorema de Wilson para verificar cada valor potencial, por ksua vez, por ser primo.

A desigualdade encadeada 10**~-n<p%k*k<s>=set(`k`)combina três condições k:

• 10**~-n<k: kcontém pelo menos ndígitos. Não precisamos verificar exatamente, pois se alcançarmos mais dígitos, não deve ter havido solução
• p%k>0: ké primo, através da condição do teorema de Wilson com p=(n-1)!^2. Como p%ké 0 ou 1, isso pode ser combinado com a condição anterior como10**~-n<p%k*k
• s>=set(`k`): Todos os dígitos kestão no conjunto s. Isso pode ser resolvido porque o Python 2 considera os conjuntos como maiores que os números.

Se a corrente knão atender a tudo isso, a função retornará k+1, adicionando 1 à saída resultante. Como a saída termina com Trueque é igual 1e kcomeça em 1, a saída é k. Esse rastreamento paralelo de kbatidas produzindo kdiretamente com sucesso.

JavaScript (ES7), 100 bytes

Recebe a entrada como número de dígitos ne sequência de dígitos permitidos sna sintaxe de currying (n)(s). Retorna undefinedse nenhuma solução for encontrada.

Funciona rapidamente para até 6 dígitos, pode funcionar para 7 e definitivamente muito lento - e com muita memória - além disso.

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

Teste

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

Gelatina , 12 bytes

DL×ÆP
ṗḌÇÐṀṂ

Toma um conjunto e um número inteiro como argumentos da linha de comando. Imprime 0 se não houver solução.

Experimente online!

Como 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

Experimente aqui!

É executado para sempre se nenhum valor encontrado

Mathematica, 64 bytes

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

Função pura em que o primeiro argumento é a lista (classificada) de dígitos permitidos e o segundo argumento é o comprimento permitido. Tuples@##calcula todas as listas dos dígitos permitidos com o comprimento permitido, então encontramos o FirstCaseque corresponde a x:{f_,___}tal que o primeiro dígito fnão é 0e o número inteiro y=FromDigits@xé primo e o substitui por y.

Braquilog , 15 bytes

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

Experimente online!

Isso é bastante lento.

Explicação

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

Recebe entrada através da sintaxe de currying, por exemplo, (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 ser executado no modo estrito (para otimização da chamada de cauda [TCO] ). Se seu ambiente não suportar TCO, isso resultará em um erro de estouro de pilha para números primos maiores que a pilha de ambientes.

Para entradas inválidas, ele será executado para sempre.

Nota:

• Usuários do Chrome (> = 51) podem acessar chrome://flags/#enable-javascript-harmony e ativar esse sinalizador para executar o snippet acima com suporte ao TCO.
• O Safari (> = 10) suporta TCO

MATL, 17 bytes

wlwX"1GXNUStZp)l)

Esta função aceita duas entradas, um número inteiro especificando o número de dígitos e uma matriz de caracteres indicando os valores possíveis. No caso de sem primos, um erro é mostrado.

Experimente Online!

Explicação

        % 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

Pitão - 13 12 bytes

f&P_T!-Tz^Tt

Conjunto de Teste .

Sábio, 62 bytes

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

Recebe a entrada do formulário: f( 4 , {'1','2'} )

Perl 6 , 43 bytes

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

É executado para sempre, se não houver solução.

05AB1E , 17 bytes

[¾Øмg¹QiS²Kg0Qiq

Experimente online!

[¾Ø ¼             # 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

Experimente online!

[                   # 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

Execute assim:

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: um número e uma sequência.

Exemplo:

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

Perl 6 , 68 bytes

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

Tente

Retorna Nilse esse prime não puder ser encontrado.

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

Experimente online

Entrada é 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;

Pega um número e uma sequência de dígitos nos argumentos da linha de comando. Corra com -nr.

demolir

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 suportando números acima de 32 bits (alterado intparalong )

Formato de entrada: um número inteiro (ie 4) e uma String (ie"12" )

Explicação:

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 do teste:

Experimente aqui.
NOTA: O segundo caso de teste está desativado porque fica em loop por um período muito longo.

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

Saída:

2111
115151